Update app.py

app.py

@@ -4,9 +4,56 @@ import numpy as np
 import librosa
 import io
 import os
+import gdown
+import tensorflow as tf
 
 app = Flask(__name__)
-CORS(app, resources={r"/api/*": {"origins": "*"}})
+CORS(app)
+
+# Telecharger et charger le modele au demarrage
+MODEL_URL = "https://drive.google.com/uc?id=1_eUJwfSSab9bQFW5Ow4kL54OMr6cGaO0"
+MODEL_PATH = "/app/model.h5"
+
+print("Telechargement du modele CNN-1D...")
+gdown.download(MODEL_URL, MODEL_PATH, quiet=False)
+print("Chargement du modele...")
+model = tf.keras.models.load_model(MODEL_PATH)
+print("Modele charge avec succes!")
+print(f"Input shape: {model.input_shape}")
+print(f"Output shape: {model.output_shape}")
+
+def extract_mfcc(audio, sr, n_mfcc=13):
+    """Extrait les MFCC du signal audio"""
+    mfccs = librosa.feature.mfcc(y=audio, sr=sr, n_mfcc=n_mfcc)
+    # Normaliser
+    mfccs = (mfccs - np.mean(mfccs)) / (np.std(mfccs) + 1e-8)
+    return mfccs
+
+def predict_vad(audio, sr):
+    """Prediction VAD avec le modele CNN-1D"""
+    # Extraire MFCC
+    mfccs = extract_mfcc(audio, sr, n_mfcc=13)
+    
+    # Adapter la forme pour le modele (ajuster selon votre modele)
+    # Shape typique: (batch, time_steps, n_mfcc) ou (batch, n_mfcc, time_steps)
+    features = mfccs.T  # (time_steps, n_mfcc)
+    features = np.expand_dims(features, axis=0)  # (1, time_steps, n_mfcc)
+    
+    # Prediction
+    prediction = model.predict(features, verbose=0)
+    
+    # Interpreter la sortie (ajuster selon votre modele)
+    if prediction.shape[-1] == 2:
+        # Classification binaire avec softmax
+        confidence = float(np.max(prediction))
+        label = "voice" if np.argmax(prediction) == 1 else "silence"
+    else:
+        # Classification binaire avec sigmoid
+        confidence = float(prediction[0][0])
+        label = "voice" if confidence > 0.5 else "silence"
+        confidence = confidence if label == "voice" else 1 - confidence
+    
+    return label, confidence
 
 @app.after_request
 def after_request(response):
@@ -17,7 +64,7 @@ def after_request(response):
 
 @app.route('/', methods=['GET'])
 def home():
-    return jsonify({'message': 'AcoustiTrack API - CNN-1D VAD + GCC-PHAT DOA', 'status': 'running'})
+    return jsonify({'message': 'AcoustiTrack API', 'status': 'running', 'model': 'CNN-1D VAD'})
 
 @app.route('/api/health', methods=['GET', 'OPTIONS'])
 def health():
@@ -34,42 +81,48 @@ def analyze():
             return jsonify({'error': 'Aucun fichier audio'}), 400
         
         audio_file = request.files['audio']
-        audio_bytes = audio_file.read()
-        
-        y, sr = librosa.load(io.BytesIO(audio_bytes), sr=16000, mono=False)
+        y, sr = librosa.load(io.BytesIO(audio_file.read()), sr=16000, mono=False)
         
+        # Gerer mono/multi-canal
         if y.ndim == 1:
+            y_mono = y
             y = np.tile(y, (4, 1))
+        else:
+            y_mono = np.mean(y, axis=0)
         
         n_channels = y.shape[0] if y.ndim > 1 else 1
         duration = y.shape[-1] / sr
+        n_frames = max(1, int(duration * 10))
         
-        # ============================================
-        # VOTRE MODELE CNN-1D ICI
-        # Chargez votre modele et faites l'inference
-        # ============================================
-        vad_prediction = "voice"
-        vad_confidence = 0.962
-        doa_angle = -25.5
+        # Prediction VAD avec le modele CNN-1D
+        vad_label, vad_confidence = predict_vad(y_mono, sr)
         
-        n_frames = max(1, int(duration * 10))
+        # Generer timeline VAD frame par frame
+        frame_length = len(y_mono) // n_frames
         vad_timeline = []
         for i in range(n_frames):
+            start_sample = i * frame_length
+            end_sample = min((i + 1) * frame_length, len(y_mono))
+            frame_audio = y_mono[start_sample:end_sample]
+            
+            if len(frame_audio) > sr * 0.05:  # Au moins 50ms
+                frame_label, frame_conf = predict_vad(frame_audio, sr)
+            else:
+                frame_label = vad_label
+                frame_conf = vad_confidence
+            
             vad_timeline.append({
                 'start': round(i * 0.1, 2),
                 'end': round((i + 1) * 0.1, 2),
-                'label': 'voice' if np.random.random() > 0.3 else 'silence',
-                'confidence': round(0.85 + np.random.random() * 0.15, 3)
+                'label': frame_label,
+                'confidence': round(frame_conf, 3)
             })
         
-        doa_trajectory = []
-        for i in range(n_frames):
-            doa_trajectory.append({
-                'time': round(i * 0.1, 2),
-                'angle': round(doa_angle + np.random.randn() * 5, 1)
-            })
+        # DOA estimation (simulation - remplacer par GCC-PHAT reel si disponible)
+        doa_angle = -25.5 + np.random.randn() * 10
+        doa_trajectory = [{'time': round(i*0.1,2), 'angle': round(doa_angle + np.random.randn()*3, 1)} for i in range(n_frames)]
         
-        voice_frames = sum(1 for f in vad_timeline if f['label'] == 'voice')
+        voice_ratio = sum(1 for f in vad_timeline if f['label'] == 'voice') / len(vad_timeline)
         
         return jsonify({
             'success': True,
@@ -80,24 +133,25 @@ def analyze():
                 'samples': int(y.shape[-1])
             },
             'vad': {
-                'prediction': vad_prediction,
-                'confidence': vad_confidence,
+                'prediction': vad_label,
+                'confidence': round(vad_confidence, 3),
                 'timeline': vad_timeline
             },
             'doa': {
-                'angle': doa_angle,
+                'angle': round(doa_angle, 1),
                 'confidence': 0.89,
                 'trajectory': doa_trajectory
             },
             'metrics': {
-                'snr': 18.5,
-                'voiceRatio': round(voice_frames / len(vad_timeline), 2),
-                'meanDoa': round(float(np.mean([d['angle'] for d in doa_trajectory])), 1)
+                'snr': round(10 * np.log10(np.mean(y_mono**2) / 1e-10), 1),
+                'voiceRatio': round(voice_ratio, 2),
+                'meanDoa': round(np.mean([d['angle'] for d in doa_trajectory]), 1)
             }
         })
     except Exception as e:
+        import traceback
+        traceback.print_exc()
         return jsonify({'error': str(e)}), 500
 
 if __name__ == '__main__':
-    port = int(os.environ.get('PORT', 7860))
-    app.run(host='0.0.0.0', port=port)
+    app.run(host='0.0.0.0', port=int(os.environ.get('PORT', 7860)))