Applied lintrunner changes

Author: Akupadhye

openai-whisper-large-v3-turbo/olive/app.py

@@ -6,16 +6,17 @@
 from __future__ import annotations
 
 import os
+
 import numpy as np
 import onnxruntime as ort
 import torch
-from transformers import WhisperProcessor
-
 from qai_hub_models.models._shared.hf_whisper.app import HfWhisperApp, chunk_and_resample_audio
 from qai_hub_models.models._shared.hf_whisper.model import (
     CHUNK_LENGTH,
     SAMPLE_RATE,
 )
+from transformers import WhisperProcessor
+
 
 def infer_audio(app, model_id, audio_file, save_data):
     audio_dict = np.load(audio_file, allow_pickle=True).item()
@@ -25,7 +26,7 @@ def infer_audio(app, model_id, audio_file, save_data):
     audio_name = os.path.splitext(os.path.basename(audio_file))[0] if save_data else None
 
     processor = WhisperProcessor.from_pretrained(model_id)
-    reference = processor.tokenizer._normalize(audio_dict['text'])
+    reference = processor.tokenizer._normalize(audio_dict["text"])
     print("Reference: ", reference)
 
     # Perform transcription
@@ -47,17 +48,17 @@ def __init__(
     ):
         super().__init__(None, None, hf_model_id, sample_rate, max_audio_seconds)
         options = ort.SessionOptions()
-        
+
         self.encoder = ort.InferenceSession(encoder,
                                        sess_options=options,
                                        providers=[execution_provider],
                                        provider_options=[provider_options])
-        
+
         self.decoder = ort.InferenceSession(decoder,
                                        sess_options=options,
                                        providers=[execution_provider],
                                        provider_options=[provider_options])
-        
+
     def transcribe_tokens(
         self, audio, sample_rate, audio_name, save_data = False
     ) -> list[int]:
@@ -71,13 +72,13 @@ def transcribe_tokens(
         for chunk_tokens in out_chunked_tokens:
             out_tokens.extend(chunk_tokens)
         return out_tokens
-    
+
     def transcribe(
         self, audio, sample_rate, audio_name, save_data = False
     ) -> str:
         tokens = self.transcribe_tokens(audio, sample_rate, audio_name, save_data)
         return self.tokenizer.decode(tokens, skip_special_tokens=True).strip()
-    
+
     def _transcribe_single_chunk(self, audio: np.ndarray, audio_name = None, chunk_number = None, save_data = False) -> list[int]:
         # feature
         input_features = self.feature_extractor(
@@ -87,7 +88,7 @@ def _transcribe_single_chunk(self, audio: np.ndarray, audio_name = None, chunk_n
         # encoder
         output_names_encoder = [output.name for output in self.encoder.get_outputs()]
         # kv_cache_cross = self.encoder(input_features)
-        input_features_feed = {'input_features': input_features}
+        input_features_feed = {"input_features": input_features}
 
         if(save_data):
             input_features_save_path = os.path.join(save_data, audio_name, f"{chunk_number}_input_features.npy")
@@ -170,7 +171,7 @@ def _transcribe_single_chunk(self, audio: np.ndarray, audio_name = None, chunk_n
             # print("decoder_input: ", decoder_input)
             input_names_decoder = [input.name for input in self.decoder.get_inputs()]
             output_names_decoder = [output.name for output in self.decoder.get_outputs()]
-            
+
             # decoder_input_feed = dict(zip(input_names_decoder, decoder_input))
             decoder_input_feed = {name: tensor.numpy() if isinstance(tensor, torch.Tensor) else tensor for name, tensor in zip(input_names_decoder, decoder_input)}
 
@@ -179,7 +180,7 @@ def _transcribe_single_chunk(self, audio: np.ndarray, audio_name = None, chunk_n
                 os.makedirs(os.path.dirname(decoder_input_save_path), exist_ok=True)
                 np.save(decoder_input_save_path, decoder_input_feed)
 
-            decoder_output_numpy = self.decoder.run(output_names_decoder, decoder_input_feed) 
+            decoder_output_numpy = self.decoder.run(output_names_decoder, decoder_input_feed)
             decoder_output = [torch.from_numpy(arr) for arr in decoder_output_numpy]
             # decoder_output = self.decoder(*decoder_input)
             if isinstance(decoder_output, tuple) and len(decoder_output) == 2:
@@ -206,4 +207,3 @@ def _transcribe_single_chunk(self, audio: np.ndarray, audio_name = None, chunk_n
             position_ids += 1
 
         return output_ids[0].tolist()
-    

openai-whisper-large-v3-turbo/olive/demo.py

@@ -3,10 +3,12 @@
 # SPDX-License-Identifier: BSD-3-Clause
 # ---------------------------------------------------------------------
 
-import os
 import argparse
+import os
+
 from app import HfWhisperAppWithSave, infer_audio
 
+
 def main():
     parser = argparse.ArgumentParser(description="Demo")
     parser.add_argument(
@@ -55,25 +57,27 @@ def main():
     decoder_path = args.decoder
 
     provider_options = {}
-    if(args.execution_provider == "QNNExectionProvider"):
-        provider_options = {"backend_path": "QnnHtp.dll",
-                            "htp_performance_mode": "sustained_high_performance",
-                            "htp_graph_finalization_optimization_mode": "3",
-                            "offload_graph_io_quantization": "0",
-                            }
-        
+    if args.execution_provider == "QNNExectionProvider":
+        provider_options = {
+            "backend_path": "QnnHtp.dll",
+            "htp_performance_mode": "sustained_high_performance",
+            "htp_graph_finalization_optimization_mode": "3",
+            "offload_graph_io_quantization": "0",
+        }
+
     app = HfWhisperAppWithSave(encoder_path, decoder_path, args.model_id, args.execution_provider, provider_options)
 
-    if os.path.isdir(args.audio_path):  
+    if os.path.isdir(args.audio_path):
         for i, item in enumerate(os.listdir(args.audio_path)):
-            if(args.save_data and i == args.num_data):
+            if args.save_data and i == args.num_data:
                 break
-            
+
             full_path = os.path.join(args.audio_path, item)
             infer_audio(app, args.model_id, full_path, args.save_data)
-            
+
     else:
         infer_audio(app, args.model_id, args.audio_path, args.save_data)
 
+
 if __name__ == "__main__":
-    main()
+    main()

openai-whisper-large-v3-turbo/olive/download_librispeech_asr.py

@@ -1,9 +1,10 @@
-import os
 import argparse
+import os
+
 import numpy as np
-from itertools import islice
 from datasets import load_dataset
 
+
 def download_librispeech_asr(save_dir):
     # Create save_dir if it doesn't exist
     save_dir = os.path.join(save_dir, "librispeech_asr_clean_test")

openai-whisper-large-v3-turbo/olive/evaluate_whisper.py

@@ -3,16 +3,16 @@
 # SPDX-License-Identifier: BSD-3-Clause
 # ---------------------------------------------------------------------
 
-# from qai_hub_models.models._shared.hf_whisper.demo import hf_whisper_demo  # noqa
-# from qai_hub_models.models.whisper_small.model import WhisperSmall  # noqa
+# from qai_hub_models.models._shared.hf_whisper.demo import hf_whisper_demo
+# from qai_hub_models.models.whisper_small.model import WhisperSmall
 
 import argparse
 
-from evaluate import load
+from app import HfWhisperAppWithSave
 from datasets import load_dataset
+from evaluate import load
 from transformers import WhisperProcessor
 
-from app import HfWhisperAppWithSave
 
 def main():
     parser = argparse.ArgumentParser(description="Evaluate Whisper")
@@ -50,7 +50,7 @@ def main():
                             "htp_graph_finalization_optimization_mode": "3",
                             "offload_graph_io_quantization": "0",
                             }
-        
+
     processor = WhisperProcessor.from_pretrained(args.model_id)
     app = HfWhisperAppWithSave(encoder_path, decoder_path, args.model_id, args.execution_provider, provider_options)
 
@@ -68,7 +68,7 @@ def main():
         transcription = app.transcribe(audio, audio_sample_rate, None, None)
         prediction = processor.tokenizer._normalize(transcription)
 
-        reference = processor.tokenizer._normalize(item['text'])
+        reference = processor.tokenizer._normalize(item["text"])
         references.append(reference)
         predictions.append(prediction)
         print("Reference: ", reference)
@@ -78,4 +78,4 @@ def main():
     print("WER:", 100 * wer.compute(references=references, predictions=predictions))
 
 if __name__ == "__main__":
-    main()
+    main()

openai-whisper-large-v3-turbo/olive/whisper_decoder_load.py

@@ -1,15 +1,15 @@
+import glob
 import os
+
 import numpy as np
-import os
-import glob
+from qai_hub_models.utils.input_spec import make_torch_inputs
 
 from olive.data.registry import Registry
-from qai_hub_models.utils.input_spec import make_torch_inputs
 
 
 def model_loader(model_name):
     if(model_name == "openai/whisper-large-v3-turbo"):
-        from qai_hub_models.models.whisper_large_v3_turbo import  Model
+        from qai_hub_models.models.whisper_large_v3_turbo import Model
         model = Model.from_pretrained()
         component = model.components["HfWhisperDecoder"]
         return component
@@ -26,11 +26,11 @@ def generate_dummy_inputs(model=None):
 
 class DecoderBaseDataLoader:
     def __init__(self, data_path):
-        self.data_files = glob.glob(os.path.join(data_path, '**', '*_decoder_input.npy'), recursive=True)
+        self.data_files = glob.glob(os.path.join(data_path, "**", "*_decoder_input.npy"), recursive=True)
 
     def __len__(self):
         return len(self.data_files)
-    
+
     def __getitem__(self, idx):
         return np.load(self.data_files[idx], allow_pickle=True).item()
 

openai-whisper-large-v3-turbo/olive/whisper_encoder_load.py

@@ -1,10 +1,10 @@
+import glob
 import os
+
 import numpy as np
-import os
-import glob
+from qai_hub_models.utils.input_spec import make_torch_inputs
 
 from olive.data.registry import Registry
-from qai_hub_models.utils.input_spec import make_torch_inputs
 
 
 def model_loader(model_name):
@@ -25,14 +25,14 @@ def generate_dummy_inputs(model=None):
 
 class EncoderBaseDataLoader:
     def __init__(self, data_path):
-        self.data_files = glob.glob(os.path.join(data_path, '**', '*_input_features.npy'), recursive=True)
+        self.data_files = glob.glob(os.path.join(data_path, "**", "*_input_features.npy"), recursive=True)
 
     def __len__(self):
         return len(self.data_files)
-    
+
     def __getitem__(self, idx):
         return np.load(self.data_files[idx], allow_pickle=True).item()
-    
+
 @Registry.register_dataloader()
 def encoder_data_loader(dataset, data_path):
     return EncoderBaseDataLoader(data_path)