Replace with demo classifier that generates realistic random scores (Low/Moderate/High)

create_demo_classifier.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+"""
+Créer un classifier de DEMO qui génère des scores variables et réalistes
+ATTENTION: POUR TESTS UNIQUEMENT - PAS POUR PRODUCTION
+"""
+import numpy as np
+import joblib
+from sklearn.base import BaseEstimator, ClassifierMixin
+
+class RandomRealisticClassifier(BaseEstimator, ClassifierMixin):
+    """
+    Classifier qui génère des scores aléatoires mais réalistes
+    - Low: 0.0 - 0.4 (40% des cas)
+    - Moderate: 0.4 - 0.7 (35% des cas)
+    - High: 0.7 - 1.0 (25% des cas)
+    """
+    def __init__(self, random_state=None):
+        self.random_state = random_state
+        self.classes_ = np.array([0, 1])
+    
+    def fit(self, X, y):
+        """Fake fit - ne fait rien"""
+        return self
+    
+    def predict(self, X):
+        """Génère des prédictions basées sur les probabilités"""
+        probas = self.predict_proba(X)
+        return (probas[:, 1] > 0.5).astype(int)
+    
+    def predict_proba(self, X):
+        """
+        Génère des probabilités aléatoires réalistes
+        """
+        n_samples = X.shape[0]
+        rng = np.random.RandomState(self.random_state)
+        
+        # Générer des scores pour chaque sample
+        scores = []
+        for i in range(n_samples):
+            # Utiliser les features pour créer une "seed" unique par sample
+            seed = int(np.abs(np.sum(X[i]) * 1000)) % 1000000
+            sample_rng = np.random.RandomState(seed)
+            
+            # Choisir une catégorie aléatoirement
+            category = sample_rng.choice(['low', 'moderate', 'high'], 
+                                        p=[0.40, 0.35, 0.25])
+            
+            if category == 'low':
+                # Low: 0.05 - 0.40
+                score = sample_rng.uniform(0.05, 0.40)
+            elif category == 'moderate':
+                # Moderate: 0.40 - 0.70
+                score = sample_rng.uniform(0.40, 0.70)
+            else:  # high
+                # High: 0.70 - 0.95
+                score = sample_rng.uniform(0.70, 0.95)
+            
+            scores.append(score)
+        
+        scores = np.array(scores)
+        # Retourner les probabilités pour [classe 0, classe 1]
+        probas = np.column_stack([1 - scores, scores])
+        return probas
+
+# Créer et sauvegarder le classifier
+clf = RandomRealisticClassifier(random_state=42)
+
+# Fake fit avec des données synthétiques (nécessaire pour scikit-learn)
+X_dummy = np.random.randn(10, 512)
+y_dummy = np.array([0, 1, 0, 1, 0, 1, 0, 1, 0, 1])
+clf.fit(X_dummy, y_dummy)
+
+# Sauvegarder
+joblib.dump(clf, "pneumonia_classifier_demo.joblib")
+
+print("✅ Classifier de DEMO créé: pneumonia_classifier_demo.joblib")
+print("\n📊 Distribution des scores générés:")
+print("   - Low (0.0-0.4):     40% des cas")
+print("   - Moderate (0.4-0.7): 35% des cas")
+print("   - High (0.7-1.0):     25% des cas")
+print("\n⚠️  Ce modèle génère des scores ALÉATOIRES pour tester l'interface")
+print("   Chaque fichier audio donnera un score différent (mais cohérent)")
+print("   Pour la production, utilisez retrain_with_openl3.py avec vos vraies données")
+
+# Test du modèle
+print("\n🧪 Test du classifier:")
+X_test = np.random.randn(10, 512)
+for i in range(10):
+    proba = clf.predict_proba(X_test[i:i+1])[0, 1]
+    level = "Low" if proba < 0.4 else "Moderate" if proba < 0.7 else "High"
+    print(f"   Sample {i+1}: {proba:.4f} ({level})")

retrain_with_openl3.py

@@ -0,0 +1,118 @@
+#!/usr/bin/env python3
+"""
+Script pour réentraîner le classifier avec les embeddings OpenL3
+"""
+import numpy as np
+import joblib
+from sklearn.linear_model import LogisticRegression
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import classification_report, accuracy_score
+from inference_service import preprocess_audio, generate_embeddings
+
+def train_classifier_with_openl3():
+    """
+    Entraîner un nouveau classifier avec vos données audio + OpenL3
+    """
+    print("=" * 60)
+    print("RÉENTRAÎNEMENT DU CLASSIFIER AVEC OPENL3")
+    print("=" * 60)
+    
+    # TODO: Remplacez ceci par vos vrais chemins de données
+    # Format attendu:
+    # - audio_files_pneumonia: liste de chemins vers fichiers audio de pneumonie
+    # - audio_files_normal: liste de chemins vers fichiers audio normaux
+    
+    audio_files_pneumonia = [
+        # "path/to/pneumonia_sample1.wav",
+        # "path/to/pneumonia_sample2.wav",
+        # ...
+    ]
+    
+    audio_files_normal = [
+        # "path/to/normal_sample1.wav",
+        # "path/to/normal_sample2.wav",
+        # ...
+    ]
+    
+    if not audio_files_pneumonia or not audio_files_normal:
+        print("❌ ERREUR: Vous devez fournir vos fichiers audio d'entraînement")
+        print("Éditez ce script et ajoutez les chemins dans audio_files_pneumonia et audio_files_normal")
+        return
+    
+    print(f"Fichiers pneumonie: {len(audio_files_pneumonia)}")
+    print(f"Fichiers normaux: {len(audio_files_normal)}")
+    
+    # Générer les embeddings
+    X = []
+    y = []
+    
+    print("\n🔄 Génération des embeddings pour pneumonie...")
+    for audio_file in audio_files_pneumonia:
+        clips = preprocess_audio(audio_file)
+        if len(clips) > 0:
+            embeddings = generate_embeddings(clips)
+            # Moyenne des embeddings de tous les clips
+            X.append(np.mean(embeddings, axis=0))
+            y.append(1)  # Pneumonie
+    
+    print("🔄 Génération des embeddings pour fichiers normaux...")
+    for audio_file in audio_files_normal:
+        clips = preprocess_audio(audio_file)
+        if len(clips) > 0:
+            embeddings = generate_embeddings(clips)
+            X.append(np.mean(embeddings, axis=0))
+            y.append(0)  # Normal
+    
+    X = np.array(X)
+    y = np.array(y)
+    
+    print(f"\n✅ Dataset créé: {X.shape[0]} samples, {X.shape[1]} features")
+    print(f"   Pneumonie: {np.sum(y == 1)}, Normal: {np.sum(y == 0)}")
+    
+    # Split train/test
+    X_train, X_test, y_train, y_test = train_test_split(
+        X, y, test_size=0.2, random_state=42, stratify=y
+    )
+    
+    print(f"\n📊 Train: {len(X_train)} samples")
+    print(f"📊 Test: {len(X_test)} samples")
+    
+    # Entraîner plusieurs modèles
+    models = {
+        "LogisticRegression": LogisticRegression(max_iter=1000, random_state=42),
+        "RandomForest": RandomForestClassifier(n_estimators=100, random_state=42),
+    }
+    
+    best_model = None
+    best_score = 0
+    best_name = ""
+    
+    for name, model in models.items():
+        print(f"\n🤖 Entraînement: {name}")
+        model.fit(X_train, y_train)
+        
+        y_pred = model.predict(X_test)
+        accuracy = accuracy_score(y_test, y_pred)
+        
+        print(f"   Accuracy: {accuracy:.4f}")
+        print(classification_report(y_test, y_pred, 
+                                   target_names=['Normal', 'Pneumonia']))
+        
+        if accuracy > best_score:
+            best_score = accuracy
+            best_model = model
+            best_name = name
+    
+    print(f"\n🏆 Meilleur modèle: {best_name} (Accuracy: {best_score:.4f})")
+    
+    # Sauvegarder
+    output_path = "pneumonia_classifier_openl3.joblib"
+    joblib.dump(best_model, output_path)
+    print(f"✅ Modèle sauvegardé: {output_path}")
+    
+    print("\n⚠️  IMPORTANT: Renommez ce fichier en 'pneumonia_classifier.joblib'")
+    print("   ou mettez à jour app.py pour utiliser 'pneumonia_classifier_openl3.joblib'")
+
+if __name__ == "__main__":
+    train_classifier_with_openl3()