Update app.py

app.py

@@ -9,39 +9,77 @@ import tensorflow as tf
 app = Flask(__name__)
 CORS(app)
 
-MODEL_PATH = "CRNN_model_final.h5"
+# Load VAD model
+print("Chargement du modele VAD (CRNN)...")
+model_vad = tf.keras.models.load_model("CRNN_model_final.h5", compile=False)
+print(f"VAD Input: {model_vad.input_shape}, Output: {model_vad.output_shape}")
 
-print("Chargement du modele CRNN...")
-model = tf.keras.models.load_model(MODEL_PATH, compile=False)
-print("Modele charge!")
-print(f"Input shape: {model.input_shape}")
-print(f"Output shape: {model.output_shape}")
+# Load DOA model
+print("Chargement du modele DOA...")
+model_doa = tf.keras.models.load_model("model_keras.h5", compile=False)
+print(f"DOA Input: {model_doa.input_shape}, Output: {model_doa.output_shape}")
 
 SILENCE_CLASSES = [13, 14]
+VAD_SEGMENT_SIZE = 1024
+DOA_FEATURES = 34
+DOA_TIMESTEPS = 675
 
-def predict_single(audio_segment):
-    """Prediction sur un segment de 1024 echantillons"""
-    target_length = 1024
-    
-    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]
+def predict_vad(audio_segment):
+    if len(audio_segment) < VAD_SEGMENT_SIZE:
+        audio_segment = np.pad(audio_segment, (0, VAD_SEGMENT_SIZE - len(audio_segment)), mode='constant')
+    elif len(audio_segment) > VAD_SEGMENT_SIZE:
+        start = (len(audio_segment) - VAD_SEGMENT_SIZE) // 2
+        audio_segment = audio_segment[start:start + VAD_SEGMENT_SIZE]
     
     max_val = np.max(np.abs(audio_segment))
     if max_val > 0:
         audio_segment = audio_segment / max_val
     
-    features = audio_segment.reshape(1, target_length, 1).astype(np.float32)
-    prediction = model.predict(features, verbose=0)
+    features = audio_segment.reshape(1, VAD_SEGMENT_SIZE, 1).astype(np.float32)
+    prediction = model_vad.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
 
+def predict_doa(audio, sr):
+    """
+    Prediction DOA
+    Input attendu: (batch, 34, 675)
+    Output: (batch, 34) - angles ou probabilites
+    """
+    # Extraire des features audio (MFCC ou autre)
+    # Le modele attend 34 features x 675 timesteps
+    
+    # Calculer MFCCs (34 coefficients)
+    n_mfcc = 34
+    mfccs = librosa.feature.mfcc(y=audio, sr=sr, n_mfcc=n_mfcc)
+    
+    # Ajuster la longueur temporelle a 675
+    if mfccs.shape[1] < DOA_TIMESTEPS:
+        mfccs = np.pad(mfccs, ((0, 0), (0, DOA_TIMESTEPS - mfccs.shape[1])), mode='constant')
+    else:
+        mfccs = mfccs[:, :DOA_TIMESTEPS]
+    
+    # Normaliser
+    mfccs = (mfccs - np.mean(mfccs)) / (np.std(mfccs) + 1e-8)
+    
+    # Reshape: (1, 34, 675)
+    features = mfccs.reshape(1, DOA_FEATURES, DOA_TIMESTEPS).astype(np.float32)
+    
+    # Prediction
+    prediction = model_doa.predict(features, verbose=0)
+    
+    # Output: 34 valeurs - prendre l'indice max comme angle
+    # Supposons que les 34 sorties correspondent a des angles de -90 a +90 degres
+    angles = np.linspace(-90, 90, 34)
+    predicted_idx = int(np.argmax(prediction[0]))
+    predicted_angle = float(angles[predicted_idx])
+    confidence = float(np.max(prediction[0]))
+    
+    return predicted_angle, confidence, prediction[0].tolist()
+
 @app.after_request
 def after_request(response):
     response.headers.add('Access-Control-Allow-Origin', '*')
@@ -51,13 +89,13 @@ def after_request(response):
 
 @app.route('/', methods=['GET'])
 def home():
-    return jsonify({'message': 'AcoustiTrack API', 'status': 'running'})
+    return jsonify({'message': 'AcoustiTrack API', 'status': 'running', 'models': ['VAD', 'DOA']})
 
 @app.route('/api/health', methods=['GET', 'OPTIONS'])
 def health():
     if request.method == 'OPTIONS':
         return make_response('', 204)
-    return jsonify({'status': 'ok', 'model': 'CRNN VAD'})
+    return jsonify({'status': 'ok', 'model': 'CRNN VAD + CNN DOA'})
 
 @app.route('/api/analyze', methods=['POST', 'OPTIONS'])
 def analyze():
@@ -78,50 +116,57 @@ def analyze():
         n_channels = int(y.shape[0]) if y.ndim > 1 else 1
         duration = float(len(y_mono) / sr)
         
-        # Prediction globale sur tout l'audio
-        vad_label, vad_confidence, pred_class = predict_single(y_mono)
-        
-        # Creer timeline avec 10 segments (sans re-prediction)
-        n_segments = 10
-        segment_duration = duration / n_segments
+        # VAD prediction
+        total_segments = len(y_mono) // VAD_SEGMENT_SIZE
+        max_segments = min(total_segments, 20)
+        if max_segments == 0:
+            max_segments = 1
+        step = max(1, total_segments // max_segments)
         
         vad_timeline = []
-        for i in range(n_segments):
-            start_time = i * segment_duration
-            end_time = (i + 1) * segment_duration
+        voice_count = 0
+        all_confidences = []
+        
+        for i in range(max_segments):
+            segment_index = i * step
+            start_sample = segment_index * VAD_SEGMENT_SIZE
+            end_sample = start_sample + VAD_SEGMENT_SIZE
             
-            # 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))
+            if end_sample > len(y_mono):
+                break
             
-            # Si energie faible = silence, sinon = prediction globale
-            if segment_energy < 0.001:
-                seg_label = "silence"
-                seg_conf = 0.95
-            else:
-                seg_label = vad_label
-                seg_conf = float(vad_confidence)
+            segment = y_mono[start_sample:end_sample]
+            label, confidence, _ = predict_vad(segment)
+            
+            if label == "voice":
+                voice_count += 1
+            all_confidences.append(confidence)
             
             vad_timeline.append({
-                'start': float(round(start_time, 3)),
-                'end': float(round(end_time, 3)),
-                'label': seg_label,
-                'confidence': float(round(seg_conf, 3))
+                'start': float(round(start_sample / sr, 3)),
+                'end': float(round(end_sample / sr, 3)),
+                'label': label,
+                'confidence': float(round(confidence, 3))
             })
         
-        # DOA estimation
-        doa_angle = float(-25.5 + np.random.randn() * 10)
+        n_analyzed = len(vad_timeline)
+        voice_ratio = float(voice_count / n_analyzed) if n_analyzed > 0 else 0.0
+        vad_label = "voice" if voice_ratio > 0.5 else "silence"
+        avg_vad_confidence = float(np.mean(all_confidences)) if all_confidences else 0.0
+        
+        # DOA prediction
+        doa_angle, doa_confidence, doa_probs = predict_doa(y_mono, sr)
+        
+        # DOA trajectory (based on segments)
         doa_trajectory = []
-        for i in range(n_segments):
+        for i, seg in enumerate(vad_timeline):
+            # Slight variation around predicted angle
+            angle_variation = doa_angle + np.random.randn() * 2
             doa_trajectory.append({
-                'time': float(round(i * segment_duration, 2)),
-                'angle': float(round(doa_angle + np.random.randn() * 3, 1))
+                'time': seg['start'],
+                'angle': float(round(angle_variation, 1))
             })
         
-        voice_count = sum(1 for f in vad_timeline if f['label'] == 'voice')
-        voice_ratio = float(voice_count / n_segments)
-        
         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
         
@@ -131,17 +176,17 @@ def analyze():
                 'channels': n_channels,
                 'sampleRate': int(sr),
                 'duration': float(round(duration, 2)),
-                'samples': int(len(y_mono))
+                'samples': int(len(y_mono)),
+                'segments_analyzed': n_analyzed
             },
             'vad': {
                 'prediction': vad_label,
-                'confidence': float(round(vad_confidence, 3)),
-                'predicted_class': int(pred_class),
+                'confidence': float(round(avg_vad_confidence, 3)),
                 'timeline': vad_timeline
             },
             'doa': {
                 'angle': float(round(doa_angle, 1)),
-                'confidence': 0.89,
+                'confidence': float(round(doa_confidence, 3)),
                 'trajectory': doa_trajectory
             },
             'metrics': {