Update pipeline.py

pipeline.py

@@ -28,26 +28,48 @@ efficientnet_model = tf.keras.layers.TFSMLayer(
 )
 
 # ─────────────────────────────────────────────────────────────────────────────
-# Audio Model: mo-thecreator/Deepfake-audio-detection
-# Wav2Vec2 fine-tuned for real vs fake audio classification
-# Accuracy: 98.82% on evaluation set
+# Audio Ensemble: 3 models vote — majority wins
+#
+# Model 1: mo-thecreator/Deepfake-audio-detection
+#   Wav2Vec2-base, trained on real/fake speech, 98.82% accuracy
+#
+# Model 2: MelodyMachine/Deepfake-audio-detection-V2
+#   Fine-tuned from mo-thecreator, 99.73% accuracy on evaluation
+#
+# Model 3: Gustking/wav2vec2-large-xlsr-deepfake-audio-classification
+#   Wav2Vec2-large-xlsr, bigger multilingual model, more robust
+#
+# Voting logic:
+#   Each model casts a vote: "real", "ai_synth", or "fake"
+#   Final result = whichever label gets the most votes (majority)
+#   Tie on real vs fake → AI Synthesized (safest middle ground)
 # ─────────────────────────────────────────────────────────────────────────────
-AUDIO_MODEL_ID = "Gustking/wav2vec2-large-xlsr-deepfake-audio-classification"
+AUDIO_MODELS = [
+    "mo-thecreator/Deepfake-audio-detection",
+    "MelodyMachine/Deepfake-audio-detection-V2",
+    "Gustking/wav2vec2-large-xlsr-deepfake-audio-classification",
+]
 AUDIO_SAMPLE_RATE = 16000
 
-print(f"Loading audio model: {AUDIO_MODEL_ID} ...")
-audio_feature_extractor = AutoFeatureExtractor.from_pretrained(AUDIO_MODEL_ID)
-audio_model = AutoModelForAudioClassification.from_pretrained(AUDIO_MODEL_ID)
-audio_model.eval()
-print("Audio model loaded successfully!")
-print(f"[Audio] Label map: {audio_model.config.id2label}")
+# ─── Thresholds (applied per model before voting) ────────────────────────────
+REAL_THRESHOLD = 0.50   # real_prob >= 0.50 → vote "real"
+FAKE_THRESHOLD = 0.90   # fake_prob >= 0.90 → vote "fake"
+                        # anything between  → vote "ai_synth"
 
-# ─── Thresholds ───────────────────────────────────────────────────────────────
-# REAL_THRESHOLD = 0.50 → anything above 50% real probability = Real
-# FAKE_THRESHOLD = 0.90 → needs very high confidence to be called Fake
-# Between 50-90% fake  → AI Synthesized / Voice Cloned
-REAL_THRESHOLD = 0.50
-FAKE_THRESHOLD = 0.90
+print("Loading audio ensemble models ...")
+ensemble = []
+for model_id in AUDIO_MODELS:
+    print(f"  Loading {model_id} ...")
+    try:
+        fe = AutoFeatureExtractor.from_pretrained(model_id)
+        m = AutoModelForAudioClassification.from_pretrained(model_id)
+        m.eval()
+        ensemble.append({"id": model_id, "extractor": fe, "model": m})
+        print(f"  ✅ Loaded: {model_id} | labels: {m.config.id2label}")
+    except Exception as e:
+        print(f"  ⚠️ Skipped {model_id}: {e}")
+
+print(f"Ensemble ready with {len(ensemble)} models.")
 
 
 def convert_to_mp4(input_path):
@@ -177,13 +199,11 @@ def deepfakes_image_predict(input_image):
 
 def get_real_fake_probs(probs, id2label: dict):
     """
-    Robustly map model label indices → real/fake probabilities.
-    Always prints the raw label map to Logs for debugging.
+    Map model output probabilities → real/fake floats.
+    Handles all known label naming conventions.
     """
     real_prob, fake_prob = None, None
 
-    print(f"[Audio] id2label: {id2label}")
-
     for idx, prob in enumerate(probs):
         label = id2label[idx].lower().strip()
         if label in ("real", "label_1", "genuine", "bonafide", "1"):
@@ -191,35 +211,55 @@ def get_real_fake_probs(probs, id2label: dict):
         elif label in ("fake", "label_0", "spoof", "synthetic", "0"):
             fake_prob = float(prob)
 
-    # Fallback if label names are unrecognised
+    # Fallback: 0=fake, 1=real
     if real_prob is None or fake_prob is None:
-        print("[Audio] Warning: unrecognised labels — falling back to probs[0]=fake, probs[1]=real")
+        print("[Audio] Warning: unknown labels — falling back to probs[0]=fake, probs[1]=real")
         fake_prob = float(probs[0])
         real_prob = float(probs[1])
 
     return real_prob, fake_prob
 
 
-def classify_audio_3class(real_prob: float, fake_prob: float) -> str:
+def single_model_vote(x, entry):
     """
-    3-class decision:
-      real_prob >= 0.50  →  Real Human Voice
-      fake_prob >= 0.90  →  Fake / Manipulated Audio
-      in between         →  AI Synthesized / Voice Cloned
+    Run one model and return its vote: 'real', 'ai_synth', or 'fake'
+    along with the real/fake probabilities.
     """
-    print(f"[Audio] real_prob={real_prob:.4f}  fake_prob={fake_prob:.4f}")
+    model_id = entry["id"]
+    fe = entry["extractor"]
+    m = entry["model"]
+
+    inputs = fe(
+        x,
+        sampling_rate=AUDIO_SAMPLE_RATE,
+        return_tensors="pt",
+        padding=True
+    )
+
+    with torch.no_grad():
+        logits = m(**inputs).logits
+
+    probs = torch.softmax(logits, dim=-1)[0]
+    real_prob, fake_prob = get_real_fake_probs(probs, m.config.id2label)
+
+    print(f"[Audio] {model_id} → real={real_prob:.4f}  fake={fake_prob:.4f}")
 
     if real_prob >= REAL_THRESHOLD:
-        return "✅ Real Human Voice"
+        vote = "real"
     elif fake_prob >= FAKE_THRESHOLD:
-        return "🚨 Fake / Manipulated Audio"
+        vote = "fake"
     else:
-        return "🤖 AI Synthesized / Voice Cloned"
+        vote = "ai_synth"
+
+    print(f"[Audio] {model_id} → vote: {vote}")
+    return vote, real_prob, fake_prob
 
 
 def deepfakes_audio_predict(input_audio):
     """
-    Detect whether audio is: Real Human Voice / AI Synthesized / Fake.
+    Ensemble audio deepfake detection.
+    All loaded models vote — majority wins.
+
     Gradio gr.Audio() returns (sample_rate, numpy_array).
     """
     sr, x = input_audio
@@ -240,19 +280,42 @@ def deepfakes_audio_predict(input_audio):
         x = librosa.resample(x, orig_sr=sr, target_sr=AUDIO_SAMPLE_RATE)
         print(f"[Audio] After resample: {len(x)} samples ({len(x) / AUDIO_SAMPLE_RATE:.2f}s)")
 
-    # Step 4 — inference
-    inputs = audio_feature_extractor(
-        x,
-        sampling_rate=AUDIO_SAMPLE_RATE,
-        return_tensors="pt",
-        padding=True
-    )
-
-    with torch.no_grad():
-        logits = audio_model(**inputs).logits
+    # Step 4 — each model votes
+    votes = {"real": 0, "ai_synth": 0, "fake": 0}
+    all_real_probs = []
+    all_fake_probs = []
+
+    for entry in ensemble:
+        try:
+            vote, real_prob, fake_prob = single_model_vote(x, entry)
+            votes[vote] += 1
+            all_real_probs.append(real_prob)
+            all_fake_probs.append(fake_prob)
+        except Exception as e:
+            print(f"[Audio] Model {entry['id']} failed during inference: {e}")
+
+    print(f"[Audio] Vote tally: {votes}")
+
+    if len(all_real_probs) == 0:
+        return "⚠️ All models failed. Please try again."
+
+    # Step 5 — majority vote decision
+    max_votes = max(votes.values())
+    winners = [label for label, count in votes.items() if count == max_votes]
+
+    # Tie-break: real > ai_synth > fake (bias toward safety)
+    if "real" in winners:
+        final = "real"
+    elif "ai_synth" in winners:
+        final = "ai_synth"
+    else:
+        final = "fake"
 
-    probs = torch.softmax(logits, dim=-1)[0]
-    real_prob, fake_prob = get_real_fake_probs(probs, audio_model.config.id2label)
+    print(f"[Audio] Final decision: {final}")
 
-    # Step 5 — 3-class decision
-    return classify_audio_3class(real_prob, fake_prob)
+    if final == "real":
+        return "✅ Real Human Voice"
+    elif final == "ai_synth":
+        return "🤖 AI Synthesized / Voice Cloned"
+    else:
+        return "🚨 Fake / Manipulated Audio"