Update custom_interface_app.py

custom_interface_app.py

@@ -128,7 +128,6 @@ class ASR(Pretrained):
 
     def classify_file_w2v2(self, path, device):
         # Load the audio file
-        # path = "long_sample.wav"
         waveform, sr = librosa.load(path, sr=16000)
 
         # increase the volume if needed
@@ -138,42 +137,22 @@ class ASR(Pretrained):
         audio_length = len(waveform) / sr
         
         if audio_length >= 20:
-            print(f"Audio is too long ({audio_length:.2f} seconds), splitting into segments")
-            # Detect non-silent segments
-
-            non_silent_intervals = librosa.effects.split(waveform, top_db=20)  # Adjust top_db for sensitivity
-
+            # split audio every 20 seconds
             segments = []
-            current_segment = []
-            current_length = 0
             max_duration = 20 * sr  # Maximum segment duration in samples (20 seconds)
-
-
-            for interval in non_silent_intervals:
-                start, end = interval
+            num_segments = int(np.ceil(len(waveform) / max_duration))
+            start = 0
+            end = 0
+            for i in range(num_segments):
+                start = start + end
+                end = start + max_duration * sr
                 segment_part = waveform[start:end]
+                segment_len = len(segment_part) / sr
+                if segment_len < 1:
+                    continue
+                segments.append(segment_part)
 
-                # If adding the next part exceeds max duration, store the segment and start a new one
-                if current_length + len(segment_part) > max_duration:
-                    segments.append(np.concatenate(current_segment))
-                    current_segment = []
-                    current_length = 0
-
-                current_segment.append(segment_part)
-                current_length += len(segment_part)
-
-            # Append the last segment if it's not empty
-            if current_segment:
-                segments.append(np.concatenate(current_segment))
-
-            # Process each segment
-            outputs = []
-            for i, segment in enumerate(segments):
-                print(f"Processing segment {i + 1}/{len(segments)}, length: {len(segment) / sr:.2f} seconds")
-
-                # import soundfile as sf
-                # sf.write(f"outputs/segment_{i}.wav", segment, sr)
-
+            for segment in segments:
                 segment_tensor = torch.tensor(segment).to(device)
 
                 # Fake a batch for the segment
@@ -195,7 +174,6 @@ class ASR(Pretrained):
 
     def classify_file_whisper_mkd(self, path, device):
         # Load the audio file
-        # path = "long_sample.wav"
         waveform, sr = librosa.load(path, sr=16000)
 
         # increase the volume if needed
@@ -205,42 +183,22 @@ class ASR(Pretrained):
         audio_length = len(waveform) / sr
         
         if audio_length >= 20:
-            print(f"Audio is too long ({audio_length:.2f} seconds), splitting into segments")
-            # Detect non-silent segments
-
-            non_silent_intervals = librosa.effects.split(waveform, top_db=20)  # Adjust top_db for sensitivity
-
+            # split audio every 20 seconds
             segments = []
-            current_segment = []
-            current_length = 0
             max_duration = 20 * sr  # Maximum segment duration in samples (20 seconds)
-
-
-            for interval in non_silent_intervals:
-                start, end = interval
+            num_segments = int(np.ceil(len(waveform) / max_duration))
+            start = 0
+            end = 0
+            for i in range(num_segments):
+                start = start + end
+                end = start + max_duration * sr
                 segment_part = waveform[start:end]
+                segment_len = len(segment_part) / sr
+                if segment_len < 1:
+                    continue
+                segments.append(segment_part)
 
-                # If adding the next part exceeds max duration, store the segment and start a new one
-                if current_length + len(segment_part) > max_duration:
-                    segments.append(np.concatenate(current_segment))
-                    current_segment = []
-                    current_length = 0
-
-                current_segment.append(segment_part)
-                current_length += len(segment_part)
-
-            # Append the last segment if it's not empty
-            if current_segment:
-                segments.append(np.concatenate(current_segment))
-
-            # Process each segment
-            outputs = []
-            for i, segment in enumerate(segments):
-                print(f"Processing segment {i + 1}/{len(segments)}, length: {len(segment) / sr:.2f} seconds")
-
-                # import soundfile as sf
-                # sf.write(f"outputs/segment_{i}.wav", segment, sr)
-
+            for segment in segments:
                 segment_tensor = torch.tensor(segment).to(device)
 
                 # Fake a batch for the segment
@@ -270,42 +228,29 @@ class ASR(Pretrained):
         # Load the audio file
         waveform, sr = librosa.load(path, sr=16000)
 
+        # increase the volume if needed
+        # waveform = self.increase_volume(waveform)
+
         # Get audio length in seconds
         audio_length = len(waveform) / sr
         
         if audio_length >= 20:
-            print(f"MMS Audio is too long ({audio_length:.2f} seconds), splitting into segments")
-            # Detect non-silent segments
-            non_silent_intervals = librosa.effects.split(waveform, top_db=20)  # Adjust top_db for sensitivity
-
+            # split audio every 20 seconds
             segments = []
-            current_segment = []
-            current_length = 0
             max_duration = 20 * sr  # Maximum segment duration in samples (20 seconds)
-
-
-            for interval in non_silent_intervals:
-                start, end = interval
+            num_segments = int(np.ceil(len(waveform) / max_duration))
+            start = 0
+            end = 0
+            for i in range(num_segments):
+                start = start + end
+                end = start + max_duration * sr
                 segment_part = waveform[start:end]
+                segment_len = len(segment_part) / sr
+                if segment_len < 1:
+                    continue
+                segments.append(segment_part)
 
-                # If adding the next part exceeds max duration, store the segment and start a new one
-                if current_length + len(segment_part) > max_duration:
-                    segments.append(np.concatenate(current_segment))
-                    current_segment = []
-                    current_length = 0
-
-                current_segment.append(segment_part)
-                current_length += len(segment_part)
-
-            # Append the last segment if it's not empty
-            if current_segment:
-                segments.append(np.concatenate(current_segment))
-
-            # Process each segment
-            outputs = []
-            for i, segment in enumerate(segments):
-                print(f"MMS Processing segment {i + 1}/{len(segments)}, length: {len(segment) / sr:.2f} seconds")
-
+            for segment in segments:
                 segment_tensor = torch.tensor(segment).to(device)
 
                 # Pass the segment through the ASR model