Upload 3 files

README.md

@@ -1,12 +1,52 @@
 ---
-title: Admc
-emoji: 🌍
-colorFrom: green
-colorTo: yellow
+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: false
+pinned: true
+license: apache-2.0
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🎵 ADMC – Rilevamento Autorialità 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**.
+
+## API REST
+
+### POST /analyze
+Invia audio grezzo e riceve lo score AI:
+
+```bash
+curl -X POST https://YOUR-SPACE.hf.space/analyze \
+  -H "Content-Type: audio/mpeg" \
+  --data-binary @brano.mp3
+```
+
+Risposta:
+```json
+[
+  {"label": "AI",    "score": 0.12},
+  {"label": "Human", "score": 0.88}
+]
+```
+
+### 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.

app.py

@@ -0,0 +1,164 @@
+"""
+ADMC – AI Music Detection API
+Hugging Face Space (Gradio + FastAPI)
+
+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}]
+"""
+
+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
+
+# ── Model loading ──────────────────────────────────────────────────────────
+
+MODEL_ID = "motheecreator/ai-music-detection"  # Change to your fine-tuned model
+
+print(f"Loading model: {MODEL_ID}")
+try:
+    classifier = pipeline(
+        "audio-classification",
+        model=MODEL_ID,
+        device=0 if torch.cuda.is_available() else -1,
+    )
+    print("Model loaded successfully ✅")
+except Exception as e:
+    print(f"Warning: Could not load primary model ({e}). Using fallback feature extractor.")
+    classifier = None
+
+
+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: 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)))
+    
+    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"
+    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)"
+    )
+
+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",
+    description=(
+        "Analizza un brano musicale per rilevare se è stato generato da sistemi AI generativi. "
+        "Parte del sistema di certificazione ADMC – Artigiani della Musica."
+    ),
+    examples=[],
+    allow_flagging="never",
+)
+
+# ── FastAPI endpoint (called by WordPress plugin) ─────────────────────────
+
+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 ...)
+    Returns: [{"label": "AI", "score": 0.87}, {"label": "Human", "score": 0.13}]
+    """
+    content_type = request.headers.get("content-type", "")
+    ext_map = {
+        "audio/mpeg":  ".mp3",
+        "audio/wav":   ".wav",
+        "audio/x-wav": ".wav",
+        "audio/flac":  ".flac",
+        "audio/ogg":   ".ogg",
+        "audio/aiff":  ".aiff",
+    }
+    ext = ext_map.get(content_type.split(";")[0].strip(), ".mp3")
+
+    audio_bytes = await request.body()
+    if len(audio_bytes) == 0:
+        raise HTTPException(status_code=400, detail="Nessun file audio ricevuto.")
+    if len(audio_bytes) > 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_path = tmp.name
+
+    try:
+        result = analyze_audio(tmp_path)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Errore analisi: {str(e)}")
+    finally:
+        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()}

requirements.txt

@@ -0,0 +1,9 @@
+gradio>=4.0.0
+fastapi>=0.104.0
+uvicorn>=0.24.0
+transformers>=4.35.0
+torch>=2.0.0
+torchaudio>=2.0.0
+librosa>=0.10.0
+numpy>=1.24.0
+soundfile>=0.12.0