Update app.py

app.py

@@ -19,28 +19,25 @@ print(f"Output shape: {model.output_shape}")
 
 SILENCE_CLASSES = [13, 14]
 
-def predict_vad(audio, sr):
-    if sr != 16000:
-        audio = librosa.resample(audio, orig_sr=sr, target_sr=16000)
-    
+def predict_single(audio_segment):
+    """Prediction sur un segment de 1024 echantillons"""
     target_length = 1024
     
-    if len(audio) < target_length:
-        audio = np.pad(audio, (0, target_length - len(audio)), mode='constant')
-    elif len(audio) > target_length:
-        start = (len(audio) - target_length) // 2
-        audio = audio[start:start + target_length]
+    if len(audio_segment) < target_length:
+        audio_segment = np.pad(audio_segment, (0, target_length - len(audio_segment)), mode='constant')
+    elif len(audio_segment) > target_length:
+        # Prendre le milieu
+        start = (len(audio_segment) - target_length) // 2
+        audio_segment = audio_segment[start:start + target_length]
     
-    max_val = np.max(np.abs(audio))
+    max_val = np.max(np.abs(audio_segment))
     if max_val > 0:
-        audio = audio / max_val
-    
-    features = audio.reshape(1, target_length, 1)
+        audio_segment = audio_segment / max_val
     
+    features = audio_segment.reshape(1, target_length, 1).astype(np.float32)
     prediction = model.predict(features, verbose=0)
     predicted_class = int(np.argmax(prediction[0]))
     confidence = float(np.max(prediction[0]))
-    
     label = "silence" if predicted_class in SILENCE_CLASSES else "voice"
     
     return label, confidence, predicted_class
@@ -75,45 +72,58 @@ def analyze():
         
         if y.ndim == 1:
             y_mono = y
-            y = np.tile(y, (4, 1))
         else:
             y_mono = np.mean(y, axis=0)
         
         n_channels = int(y.shape[0]) if y.ndim > 1 else 1
-        duration = float(y.shape[-1] / sr)
+        duration = float(len(y_mono) / sr)
         
-        vad_label, vad_confidence, pred_class = predict_vad(y_mono, sr)
+        # Prediction globale sur tout l'audio
+        vad_label, vad_confidence, pred_class = predict_single(y_mono)
         
-        frame_size = 1024
-        n_frames = max(1, len(y_mono) // frame_size)
+        # Creer timeline avec 10 segments (sans re-prediction)
+        n_segments = 10
+        segment_duration = duration / n_segments
         
         vad_timeline = []
-        for i in range(n_frames):
-            start_sample = i * frame_size
-            end_sample = min(start_sample + frame_size, len(y_mono))
-            frame_audio = y_mono[start_sample:end_sample]
+        for i in range(n_segments):
+            start_time = i * segment_duration
+            end_time = (i + 1) * segment_duration
             
-            if len(frame_audio) >= 256:
-                frame_label, frame_conf, _ = predict_vad(frame_audio, sr)
+            # Simuler variation basee sur l'energie du segment
+            start_sample = int(i * len(y_mono) / n_segments)
+            end_sample = int((i + 1) * len(y_mono) / n_segments)
+            segment_energy = float(np.mean(y_mono[start_sample:end_sample] ** 2))
+            
+            # Si energie faible = silence, sinon = prediction globale
+            if segment_energy < 0.001:
+                seg_label = "silence"
+                seg_conf = 0.95
             else:
-                frame_label, frame_conf = vad_label, vad_confidence
+                seg_label = vad_label
+                seg_conf = float(vad_confidence)
             
             vad_timeline.append({
-                'start': float(round(start_sample / sr, 3)),
-                'end': float(round(end_sample / sr, 3)),
-                'label': frame_label,
-                'confidence': float(round(frame_conf, 3))
+                'start': float(round(start_time, 3)),
+                'end': float(round(end_time, 3)),
+                'label': seg_label,
+                'confidence': float(round(seg_conf, 3))
             })
         
+        # DOA estimation
         doa_angle = float(-25.5 + np.random.randn() * 10)
-        doa_trajectory = [{'time': float(round(i * (duration/n_frames), 2)), 'angle': float(round(doa_angle + np.random.randn()*3, 1))} for i in range(n_frames)]
+        doa_trajectory = []
+        for i in range(n_segments):
+            doa_trajectory.append({
+                'time': float(round(i * segment_duration, 2)),
+                'angle': float(round(doa_angle + np.random.randn() * 3, 1))
+            })
         
         voice_count = sum(1 for f in vad_timeline if f['label'] == 'voice')
-        voice_ratio = float(voice_count / len(vad_timeline))
+        voice_ratio = float(voice_count / n_segments)
         
-        mean_y = float(np.mean(y_mono**2))
+        mean_y = float(np.mean(y_mono ** 2))
         snr = float(round(10 * np.log10(mean_y / 1e-10), 1)) if mean_y > 0 else 0.0
-        mean_doa = float(round(np.mean([d['angle'] for d in doa_trajectory]), 1))
         
         return jsonify({
             'success': True,
@@ -121,7 +131,7 @@ def analyze():
                 'channels': n_channels,
                 'sampleRate': int(sr),
                 'duration': float(round(duration, 2)),
-                'samples': int(y.shape[-1])
+                'samples': int(len(y_mono))
             },
             'vad': {
                 'prediction': vad_label,
@@ -137,7 +147,7 @@ def analyze():
             'metrics': {
                 'snr': snr,
                 'voiceRatio': float(round(voice_ratio, 2)),
-                'meanDoa': mean_doa
+                'meanDoa': float(round(np.mean([d['angle'] for d in doa_trajectory]), 1))
             }
         })
     except Exception as e: