Upload 3 files

README.md

@@ -1,26 +1,24 @@
 ---
-title: ADMC – AI Music Detection
+title: ADMC AI Music Detection
 emoji: 🎵
 colorFrom: red
 colorTo: indigo
 sdk: gradio
-sdk_version: 6.9.0
+sdk_version: "4.0"
 app_file: app.py
 pinned: true
 license: apache-2.0
 ---
 
-# 🎵 ADMC – Rilevamento Autorialità AI nella Musica
+# ADMC - Rilevamento Autorialita AI nella Musica
 
 Parte del sistema di certificazione **ADMC (Artigiani della Musica Code)**.
 
-Analizza brani musicali per rilevare la presenza di generazione AI, supportando
-il rilascio del **Certificato di Paternità Umana dell'Opera Musicale**.
+Modello usato: `AI-Music-Detection/ai_music_detection_large_60s`
 
 ## API REST
 
 ### POST /analyze
-Invia audio grezzo e riceve lo score AI:
 
 ```bash
 curl -X POST https://YOUR-SPACE.hf.space/analyze \
@@ -37,16 +35,11 @@ Risposta:
 ```
 
 ### GET /health
+
 Verifica stato del servizio.
 
 ## Configurazione nel Plugin WordPress
 
 1. Copia l'URL del tuo Space (es. `https://artigianidellamusica-admc.hf.space`)
-2. Incollalo nel campo **Endpoint personalizzato** nelle impostazioni del plugin ADMC
-3. Aggiungi il tuo **Hugging Face API Token** per autenticarti
-
-## Modello
-
-Il modello predefinito è `motheecreator/ai-music-detection`.
-È consigliato addestrare un modello custom su dataset di musica umana vs AI
-per massimizzare la precisione nel contesto specifico di ADMC.
+2. Incollalo in **ADMC -> Impostazioni -> Endpoint personalizzato**: `https://YOUR-SPACE.hf.space/analyze`
+3. Aggiungi il tuo **Hugging Face API Token**

app.py

@@ -1,130 +1,121 @@
 """
-ADMC – AI Music Detection API
+ADMC - AI Music Detection API
 Hugging Face Space (Gradio + FastAPI)
+v2 - Fix: modello corretto + compatibilita Gradio 5+
 
-Questo Space espone un endpoint REST che il plugin WordPress ADMC può chiamare
-per analizzare se un brano musicale è stato generato da AI o creato da un umano.
-
-Deploy su Hugging Face Spaces:
-1. Crea un nuovo Space (tipo: Gradio, SDK: Python)
-2. Carica questo file come app.py
-3. Aggiungi requirements.txt (vedi sotto)
-4. Configura l'URL del Space nelle impostazioni del plugin WordPress
-
-Il plugin WP invia il file audio grezzo in POST e riceve una risposta JSON
-nel formato standard HF audio-classification:
-  [{"label": "AI", "score": 0.87}, {"label": "Human", "score": 0.13}]
+Correzioni rispetto a v1:
+1. Modello corretto: AI-Music-Detection/ai_music_detection_large_60s
+   (il precedente motheecreator/ai-music-detection non esiste)
+2. allow_flagging rimosso (deprecato in Gradio 4+, rimpiazzato da flagging_mode)
 """
 
 import gradio as gr
 import numpy as np
-import librosa
 import torch
 from fastapi import FastAPI, Request, HTTPException
 from fastapi.responses import JSONResponse
 from transformers import pipeline
-import tempfile, os, io
+import tempfile
+import os
 
-# ── Model loading ──────────────────────────────────────────────────────────
+# Modello specifico per rilevamento musica AI vs umana
+# Addestrato su SleepyJesse/ai_music_large
+# LABEL_0 = Human, LABEL_1 = AI generated
+MODEL_ID = "AI-Music-Detection/ai_music_detection_large_60s"
 
-MODEL_ID = "motheecreator/ai-music-detection"  # Change to your fine-tuned model
-
-print(f"Loading model: {MODEL_ID}")
+print("Loading model: " + MODEL_ID)
+classifier = None
 try:
     classifier = pipeline(
         "audio-classification",
         model=MODEL_ID,
         device=0 if torch.cuda.is_available() else -1,
     )
-    print("Model loaded successfully ✅")
+    print("Model loaded successfully")
 except Exception as e:
-    print(f"Warning: Could not load primary model ({e}). Using fallback feature extractor.")
-    classifier = None
-
+    print("Warning: Could not load model (" + str(e) + "). Using fallback heuristic.")
 
-def extract_features(audio_path: str) -> np.ndarray:
-    """Extract mel-spectrogram features from audio file (30s excerpt)."""
-    y, sr = librosa.load(audio_path, sr=22050, duration=30.0, mono=True)
-    mel = librosa.feature.melspectrogram(y=y, sr=sr, n_mels=128, fmax=8000)
-    mel_db = librosa.power_to_db(mel, ref=np.max)
-    return mel_db
 
+def analyze_audio(audio_path):
+    """Analizza file audio, restituisce lista [{label, score}]."""
 
-def analyze_audio(audio_path: str) -> list[dict]:
-    """
-    Run AI detection on an audio file.
-    Returns list of {label, score} dicts.
-    """
     if classifier is not None:
-        # Use HF pipeline directly
-        result = classifier(audio_path, top_k=2)
-        # Normalise labels to 'AI' / 'Human'
-        normalised = []
-        for item in result:
-            lbl = item["label"].upper()
-            if any(k in lbl for k in ["AI", "GENERATED", "FAKE", "SYNTH"]):
-                normalised.append({"label": "AI",    "score": float(item["score"])})
-            else:
-                normalised.append({"label": "Human", "score": float(item["score"])})
-        return normalised
-
-    # ── Fallback: simple spectral analysis heuristic ──────────────────────
-    # This is a placeholder. Replace with a trained model for production use.
-    features = extract_features(audio_path)
-    
-    # Heuristic: AI music often has very uniform spectral distribution
-    spectral_std  = float(np.std(features))
-    spectral_mean = float(np.mean(np.abs(features)))
-    
-    # Lower std relative to mean → more "uniform" → higher AI probability
-    # This is a very rough heuristic – fine-tune a real model for production!
-    ratio     = spectral_std / (spectral_mean + 1e-6)
-    ai_score  = max(0.0, min(1.0, 1.0 - (ratio / 3.0)))
-    
+        try:
+            result = classifier(audio_path, top_k=2)
+            ai_score = 0.5
+            for item in result:
+                lbl = item["label"].upper()
+                # AI-Music-Detection usa LABEL_0/LABEL_1
+                # LABEL_1 = AI, LABEL_0 = Human (verificato dal model card)
+                if "LABEL_1" in lbl or "AI" in lbl or "FAKE" in lbl:
+                    ai_score = float(item["score"])
+                    break
+                if "LABEL_0" in lbl or "HUMAN" in lbl or "REAL" in lbl:
+                    ai_score = 1.0 - float(item["score"])
+                    break
+            return [
+                {"label": "AI",    "score": round(ai_score, 4)},
+                {"label": "Human", "score": round(1.0 - ai_score, 4)},
+            ]
+        except Exception as e:
+            print("Inference error: " + str(e))
+
+    # Fallback euristico con librosa se disponibile
+    try:
+        import librosa
+        y, sr  = librosa.load(audio_path, sr=22050, duration=30.0, mono=True)
+        mel    = librosa.feature.melspectrogram(y=y, sr=sr, n_mels=128, fmax=8000)
+        mel_db = librosa.power_to_db(mel, ref=np.max)
+        std    = float(np.std(mel_db))
+        mean   = float(np.mean(np.abs(mel_db)))
+        ratio  = std / (mean + 1e-6)
+        ai_score = max(0.0, min(1.0, 1.0 - (ratio / 3.0)))
+    except Exception:
+        ai_score = 0.5
+
     return [
         {"label": "AI",    "score": round(ai_score, 4)},
         {"label": "Human", "score": round(1.0 - ai_score, 4)},
     ]
 
 
-# ── Gradio UI (for human testing) ─────────────────────────────────────────
-
 def gradio_analyze(audio_file):
     if audio_file is None:
         return "Nessun file caricato."
-    result = analyze_audio(audio_file)
-    ai_score    = next((r["score"] for r in result if r["label"] == "AI"),    0.0)
-    human_score = next((r["score"] for r in result if r["label"] == "Human"), 1.0)
-    verdict     = "🤖 Probabile AI" if ai_score > 0.5 else "✅ Probabile umano"
+    result   = analyze_audio(audio_file)
+    ai_score = next((r["score"] for r in result if r["label"] == "AI"), 0.5)
+    verdict  = "Probabile AI" if ai_score > 0.5 else "Probabile umano (autorialita' umana)"
     return (
-        f"{verdict}\n\n"
-        f"AI Score:    {ai_score*100:.1f}%\n"
-        f"Human Score: {human_score*100:.1f}%\n\n"
-        f"Soglia ADMC: 50% (configurabile nel plugin WP)"
+        verdict + "\n\n"
+        "AI Score:    " + str(round(ai_score * 100, 1)) + "%\n"
+        "Human Score: " + str(round((1 - ai_score) * 100, 1)) + "%\n\n"
+        "Soglia ADMC: 50% (configurabile nel plugin WordPress)"
     )
 
+
+# Gradio 4+ usa flagging_mode="never" invece di allow_flagging="never"
 demo = gr.Interface(
     fn=gradio_analyze,
     inputs=gr.Audio(type="filepath", label="Carica brano musicale (MP3/WAV/FLAC)"),
     outputs=gr.Textbox(label="Risultato analisi ADMC"),
-    title="🎵 ADMC – Rilevamento Autorialità AI",
+    title="ADMC - Rilevamento Autorialita AI nella Musica",
     description=(
-        "Analizza un brano musicale per rilevare se è stato generato da sistemi AI generativi. "
-        "Parte del sistema di certificazione ADMC – Artigiani della Musica."
+        "Analizza un brano musicale per rilevare se e stato generato da AI o creato da un umano. "
+        "Parte del sistema di certificazione ADMC - Artigiani della Musica."
     ),
-    examples=[],
-    allow_flagging="never",
+    flagging_mode="never",
 )
 
-# ── FastAPI endpoint (called by WordPress plugin) ─────────────────────────
-
+# Monta Gradio su FastAPI
 app = gr.mount_gradio_app(FastAPI(), demo, path="/")
 
+
 @app.post("/analyze")
 async def api_analyze(request: Request):
     """
     POST /analyze
-    Body: raw audio bytes (Content-Type: audio/mpeg | audio/wav | audio/flac ...)
+    Body: raw audio bytes
+    Content-Type: audio/mpeg | audio/wav | audio/flac | audio/ogg
     Returns: [{"label": "AI", "score": 0.87}, {"label": "Human", "score": 0.13}]
     """
     content_type = request.headers.get("content-type", "")
@@ -136,29 +127,34 @@ async def api_analyze(request: Request):
         "audio/ogg":   ".ogg",
         "audio/aiff":  ".aiff",
     }
-    ext = ext_map.get(content_type.split(";")[0].strip(), ".mp3")
+    ext        = ext_map.get(content_type.split(";")[0].strip(), ".mp3")
+    audio_data = await request.body()
 
-    audio_bytes = await request.body()
-    if len(audio_bytes) == 0:
+    if len(audio_data) == 0:
         raise HTTPException(status_code=400, detail="Nessun file audio ricevuto.")
-    if len(audio_bytes) > 100 * 1024 * 1024:
+    if len(audio_data) > 100 * 1024 * 1024:
         raise HTTPException(status_code=413, detail="File troppo grande (max 100 MB).")
 
-    # Save to temp file
     with tempfile.NamedTemporaryFile(suffix=ext, delete=False) as tmp:
-        tmp.write(audio_bytes)
+        tmp.write(audio_data)
         tmp_path = tmp.name
 
     try:
         result = analyze_audio(tmp_path)
     except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Errore analisi: {str(e)}")
+        raise HTTPException(status_code=500, detail="Errore analisi: " + str(e))
     finally:
-        os.unlink(tmp_path)
+        if os.path.exists(tmp_path):
+            os.unlink(tmp_path)
 
     return JSONResponse(content=result)
 
 
 @app.get("/health")
 async def health():
-    return {"status": "ok", "model": MODEL_ID, "gpu": torch.cuda.is_available()}
+    return {
+        "status":  "ok",
+        "model":   MODEL_ID,
+        "loaded":  classifier is not None,
+        "gpu":     torch.cuda.is_available(),
+    }