update

app.py

@@ -1,130 +1,216 @@
-# Hugging Face Spaces – Phone Vibration Sound Classifier
-# -------------------------------------------------
-# Features:
-# - Record 2x 60-second audio samples (Class A and Class B)
-# - Sliding window segmentation (20 ms)
-# - MFCC feature extraction
-# - Train / fine‑tune a classifier
-# - Record a 3rd sample for testing and predict class
-#
-# Requirements (automatically handled by Spaces):
-#   gradio, numpy, librosa, scikit-learn, soundfile
-#
-# Space type: Gradio
-
 import gradio as gr
 import numpy as np
 import librosa
-from sklearn.linear_model import LogisticRegression
+import xgboost as xgb
+import random
 from sklearn.preprocessing import StandardScaler
 from sklearn.pipeline import Pipeline
-import tempfile
-import os
+import difflib
 
+# --- Constants ---
 SAMPLE_RATE = 16000
-WINDOW_MS = 20
+WINDOW_MS = 100 
 WINDOW_SAMPLES = int(SAMPLE_RATE * WINDOW_MS / 1000)
 N_MFCC = 13
-
-# Global model storage
-model_pipeline = None
-class_names = ["Class A", "Class B"]
-
-
-def audio_to_windows(y: np.ndarray, sr: int):
-    hop = WINDOW_SAMPLES
-    windows = []
-    for start in range(0, len(y) - WINDOW_SAMPLES, hop):
-        windows.append(y[start:start + WINDOW_SAMPLES])
-    return windows
-
-
-def extract_features(y: np.ndarray, sr: int):
-    windows = audio_to_windows(y, sr)
+SILENCE_EMOJI = "_"
+MIN_SEC = 3.0
+MAX_SEC = 5.0
+
+def generate_challenge():
+    length = random.randint(3, 5)
+    seq = []
+    for i in range(length):
+        seq.append(str(random.choice([0, 1])))
+        if i < length - 1:
+            seq.append(SILENCE_EMOJI)
+    # Return both the mission string and reset visibility to True
+    mission = " ".join(seq)
+    return mission, gr.update(visible=True, value=mission)
+
+def hide_mission(audio_data):
+    """Hides the mission textbox once the referee has recorded audio."""
+    if audio_data is not None:
+        return gr.update(visible=False)
+    return gr.update(visible=True)
+
+
+def post_process_to_emoji(preds, window_ms, min_silence_ms=200):
+    """Processes raw AI output, smooths it, enforces silence gaps, and merges duplicates."""
+    if len(preds) == 0: return ""
+    
+    ms_per_step = window_ms / 2
+    min_silence_steps = int(min_silence_ms / ms_per_step)
+
+    # 1. Majority Vote Smoothing (Temporal Filtering)
+    # Reduces "flicker" where a single window might jump to a wrong class
+    smoothed = []
+    for i in range(len(preds)):
+        start = max(0, i - 1)
+        end = min(len(preds), i + 2)
+        neighborhood = list(preds[start:end])
+        smoothed.append(max(set(neighborhood), key=neighborhood.count))
+
+    # 2. Silence Enforcement & Transition Logic
+    # We only allow a change of class if the silence buffer is respected
+    intermediate_sequence = []
+    last_val = -1
+    silence_count = 0
+    
+    for p in smoothed:
+        p = int(p)
+        if p == 2:  # Silence Class
+            silence_count += 1
+            if last_val != 2:
+                intermediate_sequence.append(2)
+                last_val = 2
+        else:  # Sound Class (0 or 1)
+            if last_val != p:
+                # If we were in silence, check if the gap was long enough
+                if last_val == -1 or (last_val == 2 and silence_count >= min_silence_steps):
+                    intermediate_sequence.append(p)
+                    last_val = p
+                    silence_count = 0
+                # If we are jumping directly from 0 to 1 without silence, 
+                # we ignore it or force silence (depending on game strictness)
+
+    # 3. Final Merge (The "100110" -> "1010" logic)
+    # This removes any accidental back-to-back duplicates
+    # print("Intermediate Sequence (post-silence enforcement):", intermediate_sequence)
+    final_output = []
+    for val in intermediate_sequence:
+        # print(f"Processing value: {val}")
+        if val != 2:
+            # Map back to emoji for silence or string for numbers
+            # symbol = SILENCE_EMOJI if val == 2 else str(val)
+            
+            if not final_output or val != final_output[-1]:
+                final_output.append(str(val))
+                # print(f"Added {val} to final output {final_output}")
+
+    final_output=[char+"_" for char in final_output]
+
+    return "".join(final_output[:-1])  # Remove trailing silence if exists
+
+def extract_features_sequence(audio_path,validate_duration=True):
+    if audio_path is None: return None
+    y, sr = librosa.load(audio_path, sr=SAMPLE_RATE, mono=True)
+    if len(y) < WINDOW_SAMPLES:
+        return None, f"Audio too short ({len(y)/SAMPLE_RATE:.1f}s), needs to be at least {WINDOW_MS/1000:.1f}s."
+    elif validate_duration and len(y) > SAMPLE_RATE * 5:  # Limit to 30 seconds for performance
+        print(f"Audio too long ({len(y)/SAMPLE_RATE:.1f}s), truncating to 5s for feature extraction.")
+        y = y[:SAMPLE_RATE * 5]
+    
+    hop = WINDOW_SAMPLES // 2  # 50% overlap for smoother sequence detection
     feats = []
-    for w in windows:
-        mfcc = librosa.feature.mfcc(y=w, sr=sr, n_mfcc=N_MFCC)
-        mfcc_mean = mfcc.mean(axis=1)
-        feats.append(mfcc_mean)
-    return np.array(feats)
-
-
-def load_audio(file):
-    y, sr = librosa.load(file, sr=SAMPLE_RATE, mono=True)
-    return y, sr
-
-
-def train_model(audio_a, audio_b):
-    global model_pipeline
-
-    if audio_a is None or audio_b is None:
-        return "Please record both Class A and Class B samples."
-
-    y_a, sr_a = load_audio(audio_a)
-    y_b, sr_b = load_audio(audio_b)
-
-    X_a = extract_features(y_a, sr_a)
-    X_b = extract_features(y_b, sr_b)
-
-    y_labels = np.concatenate([
-        np.zeros(len(X_a)),
-        np.ones(len(X_b))
-    ])
-
-    X = np.vstack([X_a, X_b])
-
-    model_pipeline = Pipeline([
+    for start in range(0, len(y) - WINDOW_SAMPLES, hop):
+        w = y[start:start + WINDOW_SAMPLES]
+        mfcc = librosa.feature.mfcc(y=w, sr=sr, n_mfcc=N_MFCC, n_fft=512)
+        feats.append(mfcc.mean(axis=1))
+    return np.array(feats), "OK"
+
+def train_player_model(a0, a1, a_silence, player_name):
+    X0, msg0 = extract_features_sequence(a0, validate_duration=True)
+    X1, msg1 = extract_features_sequence(a1, validate_duration=True)
+    X_sil, msg_sil = extract_features_sequence(a_silence, validate_duration=True)
+    
+    if X0 is None: return None, f"{player_name} Source 0: {msg0}"
+    if X1 is None: return None, f"{player_name} Source 1: {msg1}"
+    if X_sil is None: return None, f"{player_name} Silence: {msg_sil}"
+    
+    X = np.vstack([X0, X1, X_sil])
+    y = np.concatenate([np.zeros(len(X0)), np.ones(len(X1)), np.full(len(X_sil), 2)])
+
+    print(f"{player_name} - Training model with {len(X)} samples: {len(X0)} Source 0, {len(X1)} Source 1, {len(X_sil)} Silence")
+    
+    model = Pipeline([
         ("scaler", StandardScaler()),
-        ("clf", LogisticRegression(max_iter=200))
+        ("clf", xgb.XGBClassifier(n_estimators=50, max_depth=3, objective='multi:softprob', num_class=3))
     ])
-
-    model_pipeline.fit(X, y_labels)
-
-    return f"Model trained successfully. Windows used: {len(X)}"
-
-
-def predict(audio_test):
-    global model_pipeline
-
-    if model_pipeline is None:
-        return "Model not trained yet."
-
-    if audio_test is None:
-        return "Please record a test sample."
-
-    y, sr = load_audio(audio_test)
-    X_test = extract_features(y, sr)
-
-    probs = model_pipeline.predict_proba(X_test)
-    avg_prob = probs.mean(axis=0)
-
-    predicted_class = int(np.argmax(avg_prob))
-
-    return (
-        f"Prediction: {class_names[predicted_class]} (Confidence: {avg_prob[predicted_class]*100:.1f}%)"
-    )
-
-
-with gr.Blocks(title="Phone Vibration Sound Classifier") as demo:
-    gr.Markdown("# Phone Vibration Sound Classifier")
-    gr.Markdown("Record two 1‑minute samples for two vibration sources, train the model, then test a third recording.")
+    model.fit(X, y)
+    print(f"{player_name} model trained successfully with {len(X)} samples!")
+    return model, "OK"
+
+def play_game(target_display, ref_audio, p1_0, p1_1, p1_s, p2_0, p2_1, p2_s):
+    # Validation and Training logic...
+    m1, err1 = train_player_model(p1_0, p1_1, p1_s, "Player 1")
+    if m1 is None: return f"### ❌ {err1}"
+    
+    m2, err2 = train_player_model(p2_0, p2_1, p2_s, "Player 2")
+    if m2 is None: return f"### ❌ {err2}"
+    
+    if not ref_audio: return "### ⚠️ Referee recording missing!"
+    
+    X_ref, _ = extract_features_sequence(ref_audio, validate_duration=False)
+    target_numeric = target_display.replace(" ", "").replace(SILENCE_EMOJI, "2")
+    
+    res1_emoji = post_process_to_emoji(m1.predict(X_ref), WINDOW_MS)
+    res2_emoji = post_process_to_emoji(m2.predict(X_ref), WINDOW_MS)
+    
+    res1_num = res1_emoji.replace(SILENCE_EMOJI, "2")
+    res2_num = res2_emoji.replace(SILENCE_EMOJI, "2")
+
+    score1 = round(difflib.SequenceMatcher(None, target_numeric, res1_num).ratio() * 100, 1)
+    score2 = round(difflib.SequenceMatcher(None, target_numeric, res2_num).ratio() * 100, 1)
+
+    winner = "Player 1" if score1 > score2 else "Player 2"
+    if score1 == score2: winner = "It's a Tie!"
+
+    # Formatting results with Large Markdown
+    return f"""
+    # 🏁 BATTLE RESULTS
+    
+    ## 🎯 Mission Target: {target_display}
+    
+    ---
+    ## 👤 Player 1 `{res1_emoji}` | **Accuracy:** `{score1}%`
+    
+    ## 👤 Player 2 `{res2_emoji}` | **Accuracy:** `{score2}%`
+    
+    ---
+    # 🏆 WINNER: <span style="color: #ff4b4b; font-size: 40px;">{winner}</span>
+    """
+
+# --- Gradio UI ---
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 🎙️ The AI Sequence Battle")
+    
+    # Store the mission in a hidden state so we can still use it for scoring even when invisible
+    hidden_target = gr.State("")
 
     with gr.Row():
-        audio_a = gr.Audio(sources=["microphone"], type="filepath", label="Record Class A (60 seconds)")
-        audio_b = gr.Audio(sources=["microphone"], type="filepath", label="Record Class B (60 seconds)")
-
-    train_btn = gr.Button("Train / Fine‑tune Model")
-    train_status = gr.Textbox(label="Training Status")
-
-    train_btn.click(train_model, inputs=[audio_a, audio_b], outputs=train_status)
-
-    gr.Markdown("---")
-
-    audio_test = gr.Audio(sources=["microphone"], type="filepath", label="Record Test Sample (up to 60 seconds)")
-    predict_btn = gr.Button("Predict Class")
-    prediction_output = gr.Textbox(label="Prediction Result")
-
-    predict_btn.click(predict, inputs=audio_test, outputs=prediction_output)
+        target_seq_ui = gr.Textbox(label="📢 Referee's Mission (Memorize this!)", interactive=False)
+        refresh_btn = gr.Button("🔄 New Mission")
+    
+    # On load and on refresh, update both the UI and the State
+    demo.load(generate_challenge, outputs=[hidden_target, target_seq_ui])
+    refresh_btn.click(generate_challenge, outputs=[hidden_target, target_seq_ui])
+
+    with gr.Accordion("⚖️ Step 1: The Referee", open=True):
+        ref_audio = gr.Audio(sources=["microphone"], type="filepath", label="Record the Mission")
+        # Trigger hiding when audio is recorded
+        ref_audio.change(hide_mission, inputs=ref_audio, outputs=target_seq_ui)
 
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("### 👤 Player 1 (3-5s samples)")
+            p1_0 = gr.Audio(sources=["microphone"], type="filepath", label="Source 0")
+            p1_1 = gr.Audio(sources=["microphone"], type="filepath", label="Source 1")
+            p1_s = gr.Audio(sources=["microphone"], type="filepath", label="Silence 🤫")
+        with gr.Column():
+            gr.Markdown("### 👤 Player 2 (3-5s samples)")
+            p2_0 = gr.Audio(sources=["microphone"], type="filepath", label="Source 0")
+            p2_1 = gr.Audio(sources=["microphone"], type="filepath", label="Source 1")
+            p2_s = gr.Audio(sources=["microphone"], type="filepath", label="Silence 🤫")
+
+    btn_fight = gr.Button("🔥 REVEAL WINNER", variant="primary", size="lg")
+    
+    # Using Markdown for large, styled text results
+    result_display = gr.Markdown("### Results will appear here after the battle!")
+
+    btn_fight.click(
+        play_game,
+        inputs=[hidden_target, ref_audio, p1_0, p1_1, p1_s, p2_0, p2_1, p2_s],
+        outputs=result_display
+    )
 
-demo.launch()
+demo.launch()

requirements.txt

@@ -2,4 +2,5 @@ gradio
 numpy
 librosa
 scikit-learn
-soundfile
+soundfile
+xgboost