Implement changes in review request

README.md

@@ -188,9 +188,9 @@ from faster_whisper import WhisperModel, BatchedInferencePipeline
 
 model = WhisperModel("medium", device="cuda", compute_type="float16")
 batched_model = BatchedInferencePipeline(model=model)
-result = batched_model.transcribe("audio.mp3", batch_size=16)
+segments, info = batched_model.transcribe("audio.mp3", batch_size=16)
 
-for segment, info in result:
+for segment in segments:
     print("[%.2fs -> %.2fs] %s" % (segment.start, segment.end, segment.text))
 ```
 

faster_whisper/feature_extractor.py

@@ -26,16 +26,14 @@ def __init__(
         self.mel_filters = self.get_mel_filters(
             sampling_rate, n_fft, n_mels=feature_size
         )
-        self.n_mels = feature_size
 
     @staticmethod
-    def get_mel_filters(sr, n_fft, n_mels=128, dtype=torch.float32):
+    def get_mel_filters(sr, n_fft, n_mels=128):
         """
         Implementation of librosa.filters.mel in Pytorch
         """
         # Initialize the weights
         n_mels = int(n_mels)
-        weights = torch.zeros((n_mels, int(1 + n_fft // 2)), dtype=dtype)
 
         # Center freqs of each FFT bin
         fftfreqs = torch.fft.rfftfreq(n=n_fft, d=1.0 / sr)

faster_whisper/transcribe.py

@@ -342,7 +342,7 @@ def get_language_and_tokenizer(
                     language,
                     language_probability,
                     all_language_probs,
-                ) = self.model.detect_language_function(audio)
+                ) = self.model.detect_language(audio)
             task = task or "transcribe"
             self.tokenizer = Tokenizer(
                 self.model.hf_tokenizer,
@@ -1919,21 +1919,6 @@ def generate_segment_batched(
 
         return encoder_output, output
 
-    def detect_language_function(self, audio: torch.Tensor):
-        to_cpu = self.model.device == "cuda" and len(self.model.device_index) > 1
-        segment = self.feature_extractor(audio, padding=True, to_cpu=to_cpu)[
-            :, : self.feature_extractor.nb_max_frames
-        ]
-        encoder_output = self.encode(segment)
-        results = self.model.detect_language(encoder_output)
-        language_token, language_probability = results[0][0]
-        language = language_token[2:-2]
-        self.logger.info(
-            f"Detected language: {language} ({language_probability:.2f}) in first 30s of audio..."
-        )
-        all_language_probs = [(token[2:-2], prob) for (token, prob) in results[0]]
-        return language, language_probability, all_language_probs
-
     def detect_language(self, audio: torch.Tensor):
         to_cpu = self.model.device == "cuda" and len(self.model.device_index) > 1
         segment = self.feature_extractor(audio, padding=True, to_cpu=to_cpu)[
@@ -2124,7 +2109,7 @@ def key_func(language):
                 all_language_probabilities[language]
             )
 
-            return (frequency, prob_avg)
+            return frequency, prob_avg
 
         max_language = None
 

faster_whisper/vad.py

@@ -537,10 +537,10 @@ def merge_chunks(
         # reset the edge padding. Similarly for end timing.
         if idx > 0:
             if seg.start < segments_list[idx - 1].end:
-                seg.start = seg.start + edge_padding
+                seg.start += edge_padding
         if idx < len(segments_list) - 1:
             if seg.end > segments_list[idx + 1].start:
-                seg.end = seg.end - edge_padding
+                seg.end -= edge_padding
 
         if seg.end - curr_start > chunk_size and curr_end - curr_start > 0:
             merged_segments.append(