Upload 19 files

.dockerignore

@@ -0,0 +1,16 @@
+.git
+.gitignore
+README.md
+USAGE_GUIDE.md
+test_api.py
+*.md
+.DS_Store
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+.env
+.venv
+venv/
+.pytest_cache
+.coverage 

.gitattributes

@@ -1,35 +1,35 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,169 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+Pipfile.lock
+
+# poetry
+poetry.lock
+
+# pdm
+.pdm.toml
+
+# PEP 582
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+.idea/
+
+# VS Code
+.vscode/
+
+# OS generated files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Audio files (test files)
+*.wav
+*.mp3
+*.flac
+*.m4a
+*.ogg
+
+# Temporary files
+*.tmp
+*.temp
+temp/
+tmp/
+
+# Logs
+*.log
+logs/
+
+# API keys and secrets
+.env
+secrets.json
+config.local.json 

Dockerfile

@@ -1,21 +1,33 @@
-FROM python:3.9-slim
-
-WORKDIR /app
-
-RUN apt-get update && apt-get install -y \
-    build-essential \
-    curl \
-    software-properties-common \
-    git \
-    && rm -rf /var/lib/apt/lists/*
-
-COPY requirements.txt ./
-COPY src/ ./src/
-
-RUN pip3 install -r requirements.txt
-
-EXPOSE 8501
-
-HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
-
-ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]
+FROM python:3.11-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    ffmpeg \
+    libsndfile1 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application files
+COPY . .
+
+# Create non-root user for security
+RUN useradd -m -u 1000 appuser && chown -R appuser:appuser /app
+USER appuser
+
+# Expose port
+EXPOSE 8000
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=30s --start-period=60s --retries=3 \
+    CMD curl -f http://localhost:8000/health || exit 1
+
+# Start the application
+CMD ["python", "api.py"] 

README.md

@@ -1,20 +1,105 @@
----
-title: Ai Music Detection
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: docker
-app_port: 8501
-tags:
-- streamlit
-pinned: false
-short_description: Streamlit template space
-license: mit
----
-
-# Welcome to Streamlit!
-
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
-
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+# Madverse Music: AI Music Detection
+
+Detect AI-generated music vs human-created music using advanced AI technology.
+
+## What is Madverse Music?
+
+Madverse Music is an AI-powered tool that can detect whether music is created by AI or human artists. With the growth of AI music generation platforms like Suno and Udio, it's important to distinguish between human creativity and artificial intelligence.
+
+## Key Features
+
+- Upload and analyze audio files instantly
+- Web interface for easy testing
+- REST API for integration
+- High accuracy: 97% F1 score with 96% sensitivity and 99% specificity
+- Supports WAV, MP3, FLAC, M4A, and OGG files
+- Uses SpecTTTra transformer technology
+- Trained on 97,000+ songs
+
+## Quick Start
+
+### Hugging Face Space (Recommended)
+1. Go to our Hugging Face Space
+2. Upload your audio file
+3. Get instant results
+
+### Local Setup
+```bash
+# Install dependencies
+pip install -r requirements.txt
+
+# Start web interface
+streamlit run app.py
+
+# Or start API server
+python api.py
+```  
+
+## Web Interface
+
+Use the web interface for easy testing:
+
+```bash
+streamlit run app.py
+```
+
+Then open your browser to `http://localhost:8501` and:
+1. Upload your audio file
+2. Click "Analyze Audio"  
+3. Get instant results
+
+The web interface provides:
+- Audio player to preview your file
+- Detailed analysis with confidence scores
+- Clean visualization of results
+
+## Model Performance
+
+Our model (SpecTTTra-α 120s) achieves:
+- F1 Score: 0.97
+- Sensitivity: 0.96  
+- Specificity: 0.99
+
+## Technical Details
+
+- Model: SpecTTTra (Spectro-Temporal Tokens Transformer)
+- Sample Rate: 16kHz
+- Max Duration: 120 seconds
+- Trained on 97,000+ songs  
+
+## API Usage
+
+### Hugging Face Space
+```bash
+# Health check
+curl https://your-space-name.hf.space/health
+
+# Analyze audio file
+curl -X POST "https://your-space-name.hf.space/analyze" \
+     -F "[email protected]"
+```
+
+### Local Setup
+```bash
+# Install dependencies
+pip install -r requirements.txt
+
+# Start the API server
+python api.py
+```
+
+### Command Line Usage
+
+```bash
+# Analyze a single file
+python classify_audio.py "your_song.mp3"
+
+# Analyze all files in directory
+python classify_audio.py
+```
+
+## Acknowledgments
+
+This tool is designed for research, education, and transparency in AI music detection. Results may vary depending on audio quality and content type.
+
+Visit [madverse.co](https://madverse.co) for more information.

USAGE_GUIDE.md

@@ -0,0 +1,152 @@
+# Madverse Music: AI Audio Classifier - Usage Guide
+
+## Quick Start
+
+### Option 1: Hugging Face Space (Recommended)
+Use our deployed model on Hugging Face Spaces:
+
+**Web Interface:**
+1. Go to the Hugging Face Space URL
+2. Upload your audio file
+3. Click "Analyze Audio"
+4. Get instant results
+
+**API Access:**
+```bash
+# Health check
+curl https://your-space-name.hf.space/health
+
+# Analyze audio file
+curl -X POST "https://your-space-name.hf.space/analyze" \
+     -F "[email protected]"
+```
+
+### Option 2: Local Setup
+```bash
+# Install dependencies
+pip install -r requirements.txt
+
+# Start the API server
+python api.py
+
+# Or start web interface
+streamlit run app.py
+```
+
+## Supported Audio Formats
+- WAV (.wav)
+- MP3 (.mp3) 
+- FLAC (.flac)
+- M4A (.m4a)
+- OGG (.ogg)
+
+## API Usage
+
+### Hugging Face Space API
+
+#### Health Check
+```bash
+GET /health
+```
+
+#### Analyze Audio
+```bash
+POST /analyze
+```
+Upload audio file using multipart/form-data
+
+**Request:**
+Upload file using form data with field name "file"
+
+**Response Format:**
+```json
+{
+  "classification": "Real",
+  "confidence": 0.85,
+  "probability": 0.15,
+  "raw_score": -1.73,
+  "duration": 30.5,
+  "message": "Detected as real music"
+}
+```
+
+
+
+### Usage Examples
+
+#### Python
+```python
+import requests
+
+# Upload file to HF Space
+with open('your_song.mp3', 'rb') as f:
+    response = requests.post('https://your-space-name.hf.space/analyze', 
+                           files={'file': f})
+result = response.json()
+print(result)
+```
+
+#### JavaScript
+```javascript
+const formData = new FormData();
+formData.append('file', fileInput.files[0]);
+
+const response = await fetch('https://your-space-name.hf.space/analyze', {
+    method: 'POST',
+    body: formData
+});
+const result = await response.json();
+```
+
+## Understanding Results
+
+The classifier will output:
+- **"Real"** = Human-created music
+- **"Fake"** = AI-generated music (from Suno, Udio, etc.)
+
+### API Response Format:
+```json
+{
+  "classification": "Real",
+  "confidence": 0.85,
+  "probability": 0.15,
+  "raw_score": -1.73,
+  "duration": 30.5,
+  "message": "Detected as real music"
+}
+```
+
+### Command Line Output:
+```
+Analyzing: my_song.wav
+Result: Fake (AI-generated music)
+Confidence: 0.96 | Raw output: 3.786
+```
+
+## Model Specifications
+- Model: SpecTTTra-α (120 seconds)
+- Sample Rate: 16kHz
+- Performance: 97% F1 score, 96% sensitivity, 99% specificity
+- Max Duration: 120 seconds (2 minutes)
+
+## Technical Details
+
+### How It Works:
+1. Audio is loaded and resampled to 16kHz
+2. Converted to mel-spectrograms
+3. Processed by the SpecTTTra transformer model
+4. Output logit is converted to probability using sigmoid
+5. Classification: `prob < 0.5` = Real, `prob ≥ 0.5` = Fake
+
+### Testing Your Music
+
+1. Get AI-generated samples: Download from Suno, Udio, or other AI music platforms
+2. Get real music samples: Use traditional human-created songs
+3. Run the classifier: Compare results to see how well it detects AI vs human music
+
+## Expected Performance
+- High accuracy on detecting modern AI-generated music
+- Works best with full songs (up to 120 seconds)
+- Optimized for music from platforms like Suno and Udio
+
+Note: This model was trained specifically for detecting AI-generated songs, not just AI vocals over real instrumentals. It analyzes the entire musical composition. 

api.py

@@ -0,0 +1,385 @@
+#!/usr/bin/env python3
+"""
+Madverse Music API
+AI Music Detection Service
+"""
+
+from fastapi import FastAPI, HTTPException, BackgroundTasks, Header, Depends
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from pydantic import BaseModel, HttpUrl
+import torch
+import librosa
+import tempfile
+import os
+import requests
+from pathlib import Path
+import time
+from typing import Optional, Annotated, List
+import uvicorn
+import asyncio
+
+# Initialize FastAPI app
+app = FastAPI(
+    title="Madverse Music API",
+    description="AI-powered music detection API to identify AI-generated vs human-created music",
+    version="1.0.0",
+    docs_url="/",
+    redoc_url="/docs"
+)
+
+# API Key Configuration
+API_KEY = os.getenv("MADVERSE_API_KEY", "madverse-music-api-key-2024")  # Default key for demo
+
+# Global model variable
+model = None
+
+async def verify_api_key(x_api_key: Annotated[str | None, Header()] = None):
+    """Verify API key from header"""
+    if x_api_key is None:
+        raise HTTPException(
+            status_code=401,
+            detail="Missing API key. Please provide a valid X-API-Key header."
+        )
+    if x_api_key != API_KEY:
+        raise HTTPException(
+            status_code=401,
+            detail="Invalid API key. Please provide a valid X-API-Key header."
+        )
+    return x_api_key
+
+class MusicAnalysisRequest(BaseModel):
+    urls: List[HttpUrl]
+
+def check_api_key_first(request: MusicAnalysisRequest, x_api_key: Annotated[str | None, Header()] = None):
+    """Check API key before processing request"""
+    if x_api_key is None:
+        raise HTTPException(
+            status_code=401,
+            detail="Missing API key. Please provide a valid X-API-Key header."
+        )
+    if x_api_key != API_KEY:
+        raise HTTPException(
+            status_code=401,
+            detail="Invalid API key. Please provide a valid X-API-Key header."
+        )
+    return request
+    
+class FileAnalysisResult(BaseModel):
+    url: str
+    success: bool
+    classification: Optional[str] = None  # "Real" or "Fake"
+    confidence: Optional[float] = None    # 0.0 to 1.0
+    probability: Optional[float] = None   # Raw sigmoid probability
+    raw_score: Optional[float] = None     # Raw model output
+    duration: Optional[float] = None      # Audio duration in seconds
+    message: str
+    processing_time: Optional[float] = None
+    error: Optional[str] = None
+
+class MusicAnalysisResponse(BaseModel):
+    success: bool
+    total_files: int
+    successful_analyses: int
+    failed_analyses: int
+    results: List[FileAnalysisResult]
+    total_processing_time: float
+    message: str
+
+class ErrorResponse(BaseModel):
+    success: bool
+    error: str
+    message: str
+
+@app.on_event("startup")
+async def load_model():
+    """Load the AI model on startup"""
+    global model
+    try:
+        from sonics import HFAudioClassifier
+        print("🔄 Loading Madverse Music AI model...")
+        model = HFAudioClassifier.from_pretrained("awsaf49/sonics-spectttra-alpha-120s")
+        model.eval()
+        print("✅ Model loaded successfully!")
+    except Exception as e:
+        print(f"❌ Failed to load model: {e}")
+        raise
+
+def cleanup_file(file_path: str):
+    """Background task to cleanup temporary files"""
+    try:
+        if os.path.exists(file_path):
+            os.unlink(file_path)
+    except:
+        pass
+
+def download_audio(url: str, max_size_mb: int = 100) -> str:
+    """Download audio file from URL with size validation"""
+    try:
+        # Check if URL is accessible
+        response = requests.head(str(url), timeout=10)
+        
+        # Check content size
+        content_length = response.headers.get('Content-Length')
+        if content_length and int(content_length) > max_size_mb * 1024 * 1024:
+            raise HTTPException(
+                status_code=413, 
+                detail=f"File too large. Maximum size: {max_size_mb}MB"
+            )
+        
+        # Download file
+        response = requests.get(str(url), timeout=30, stream=True)
+        response.raise_for_status()
+        
+        # Create temporary file
+        with tempfile.NamedTemporaryFile(delete=False, suffix='.tmp') as tmp_file:
+            downloaded_size = 0
+            for chunk in response.iter_content(chunk_size=8192):
+                downloaded_size += len(chunk)
+                if downloaded_size > max_size_mb * 1024 * 1024:
+                    os.unlink(tmp_file.name)
+                    raise HTTPException(
+                        status_code=413,
+                        detail=f"File too large. Maximum size: {max_size_mb}MB"
+                    )
+                tmp_file.write(chunk)
+            
+            return tmp_file.name
+            
+    except requests.exceptions.RequestException as e:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Failed to download audio: {str(e)}"
+        )
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Error downloading file: {str(e)}"
+        )
+
+def classify_audio(file_path: str) -> dict:
+    """Classify audio file using the AI model"""
+    try:
+        # Load audio (model uses 16kHz sample rate)
+        audio, sr = librosa.load(file_path, sr=16000)
+        
+        # Convert to tensor and add batch dimension
+        audio_tensor = torch.FloatTensor(audio).unsqueeze(0)
+        
+        # Get prediction
+        with torch.no_grad():
+            output = model(audio_tensor)
+            
+            # Convert logit to probability using sigmoid
+            prob = torch.sigmoid(output).item()
+            
+            # Classify: prob < 0.5 = Real, prob >= 0.5 = Fake
+            if prob < 0.5:
+                classification = "Real"
+                confidence = (1 - prob) * 2  # Convert to 0-1 scale
+            else:
+                classification = "Fake"
+                confidence = (prob - 0.5) * 2  # Convert to 0-1 scale
+        
+        return {
+            "classification": classification,
+            "confidence": min(confidence, 1.0),  # Cap at 1.0
+            "probability": prob,
+            "raw_score": output.item(),
+            "duration": len(audio) / sr
+        }
+        
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Error analyzing audio: {str(e)}"
+        )
+
+async def process_single_url(url: str) -> FileAnalysisResult:
+    """Process a single URL and return result"""
+    start_time = time.time()
+    
+    try:
+        # Download audio file
+        temp_file = download_audio(url)
+        
+        # Classify audio
+        result = classify_audio(temp_file)
+        
+        # Calculate processing time
+        processing_time = time.time() - start_time
+        
+        # Cleanup file in background
+        try:
+            os.unlink(temp_file)
+        except:
+            pass
+        
+        # Prepare response
+        emoji = "🎤" if result["classification"] == "Real" else "🤖"
+        message = f'{emoji} Detected as {result["classification"].lower()} music'
+        
+        return FileAnalysisResult(
+            url=str(url),
+            success=True,
+            classification=result["classification"],
+            confidence=result["confidence"],
+            probability=result["probability"],
+            raw_score=result["raw_score"],
+            duration=result["duration"],
+            message=message,
+            processing_time=processing_time
+        )
+        
+    except Exception as e:
+        processing_time = time.time() - start_time
+        error_msg = str(e)
+        
+        return FileAnalysisResult(
+            url=str(url),
+            success=False,
+            message=f"❌ Failed to process: {error_msg}",
+            processing_time=processing_time,
+            error=error_msg
+        )
+
+@app.post("/analyze", response_model=MusicAnalysisResponse)
+async def analyze_music(
+    request: MusicAnalysisRequest = Depends(check_api_key_first)
+):
+    """
+    Analyze music from URL(s) to detect if it's AI-generated or human-created
+    
+    - **urls**: Array of direct URLs to audio files (MP3, WAV, FLAC, M4A, OGG)
+    - Returns classification results for each file
+    - Processes files concurrently for better performance when multiple URLs provided
+    """
+    start_time = time.time()
+    
+    if not model:
+        raise HTTPException(
+            status_code=503,
+            detail="Model not loaded. Please try again later."
+        )
+    
+    if len(request.urls) > 50:  # Limit processing
+        raise HTTPException(
+            status_code=400,
+            detail="Too many URLs. Maximum 50 files per request."
+        )
+    
+    if len(request.urls) == 0:
+        raise HTTPException(
+            status_code=400,
+            detail="At least one URL is required."
+        )
+    
+    try:
+        # Process all URLs concurrently with limited concurrency
+        semaphore = asyncio.Semaphore(5)  # Limit to 5 concurrent downloads
+        
+        async def process_with_semaphore(url):
+            async with semaphore:
+                return await process_single_url(str(url))
+        
+        # Create tasks for all URLs
+        tasks = [process_with_semaphore(url) for url in request.urls]
+        
+        # Wait for all tasks to complete
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+        
+        # Process results and handle any exceptions
+        processed_results = []
+        successful_count = 0
+        failed_count = 0
+        
+        for i, result in enumerate(results):
+            if isinstance(result, Exception):
+                # Handle exception case
+                processed_results.append(FileAnalysisResult(
+                    url=str(request.urls[i]),
+                    success=False,
+                    message=f"❌ Processing failed: {str(result)}",
+                    error=str(result)
+                ))
+                failed_count += 1
+            else:
+                processed_results.append(result)
+                if result.success:
+                    successful_count += 1
+                else:
+                    failed_count += 1
+        
+        # Calculate total processing time
+        total_processing_time = time.time() - start_time
+        
+        # Prepare summary message
+        total_files = len(request.urls)
+        if total_files == 1:
+            # Single file message
+            if successful_count == 1:
+                message = processed_results[0].message
+            else:
+                message = processed_results[0].message
+        else:
+            # Multiple files message
+            if successful_count == total_files:
+                message = f"✅ Successfully analyzed all {total_files} files"
+            elif successful_count > 0:
+                message = f"⚠️ Analyzed {successful_count}/{total_files} files successfully"
+            else:
+                message = f"❌ Failed to analyze any files"
+        
+        return MusicAnalysisResponse(
+            success=successful_count > 0,
+            total_files=total_files,
+            successful_analyses=successful_count,
+            failed_analyses=failed_count,
+            results=processed_results,
+            total_processing_time=total_processing_time,
+            message=message
+        )
+        
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Internal server error during processing: {str(e)}"
+        )
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    return {
+        "status": "healthy",
+        "model_loaded": model is not None,
+        "service": "Madverse Music API"
+    }
+
+@app.get("/info")
+async def get_info():
+    """Get API information"""
+    return {
+        "name": "Madverse Music API",
+        "version": "1.0.0",
+        "description": "AI-powered music detection to identify AI-generated vs human-created music",
+        "model": "SpecTTTra-α (120s)",
+        "accuracy": {
+            "f1_score": 0.97,
+            "sensitivity": 0.96,
+            "specificity": 0.99
+        },
+        "supported_formats": ["MP3", "WAV", "FLAC", "M4A", "OGG"],
+        "max_file_size": "100MB",
+        "max_duration": "120 seconds",
+        "authentication": {
+            "required": True,
+            "type": "API Key",
+            "header": "X-API-Key",
+            "example": "X-API-Key: your-api-key-here"
+        },
+        "usage": {
+            "curl_example": "curl -X POST 'http://localhost:8000/analyze' -H 'X-API-Key: your-api-key' -H 'Content-Type: application/json' -d '{\"url\":\"https://example.com/song.mp3\"}'"
+        }
+    }
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=8000) 

app.py

@@ -0,0 +1,451 @@
+#!/usr/bin/env python3
+"""
+Madverse Music: AI Music Detection Web App
+A Streamlit interface for testing AI-generated music detection
+"""
+
+import streamlit as st
+import torch
+import librosa
+import numpy as np
+import tempfile
+import os
+from pathlib import Path
+import time
+
+# Configure the page
+st.set_page_config(
+    page_title="Madverse Music: AI Music Detector",
+    page_icon="🎵",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Custom CSS for styling
+st.markdown("""
+<style>
+    .main-header {
+        font-size: 3rem;
+        color: #1f77b4;
+        text-align: center;
+        margin-bottom: 2rem;
+        background: linear-gradient(90deg, #667eea 0%, #764ba2 100%);
+        -webkit-background-clip: text;
+        -webkit-text-fill-color: transparent;
+        font-weight: bold;
+    }
+    
+    .sub-header {
+        font-size: 1.2rem;
+        color: #666;
+        text-align: center;
+        margin-bottom: 3rem;
+    }
+    
+    .result-box {
+        padding: 1.5rem;
+        border-radius: 10px;
+        margin: 1rem 0;
+        border-left: 5px solid;
+    }
+    
+    .real-music {
+        background-color: #d4edda;
+        border-left-color: #28a745;
+        color: #155724;
+    }
+    
+    .fake-music {
+        background-color: #f8d7da;
+        border-left-color: #dc3545;
+        color: #721c24;
+    }
+    
+    .info-box {
+        background-color: #e3f2fd;
+        padding: 1rem;
+        border-radius: 8px;
+        border-left: 4px solid #2196f3;
+        margin: 1rem 0;
+    }
+    
+    .metric-card {
+        background: white;
+        padding: 1rem;
+        border-radius: 8px;
+        box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+        text-align: center;
+        margin: 0.5rem;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# Initialize session state
+if 'model' not in st.session_state:
+    st.session_state.model = None
+if 'model_loaded' not in st.session_state:
+    st.session_state.model_loaded = False
+
+@st.cache_resource
+def load_model():
+    """Load the AI model (cached for performance)"""
+    try:
+        from sonics import HFAudioClassifier
+        model = HFAudioClassifier.from_pretrained("awsaf49/sonics-spectttra-alpha-120s")
+        model.eval()
+        return model
+    except Exception as e:
+        st.error(f"Failed to load model: {e}")
+        return None
+
+def classify_audio_file(audio_file, model):
+    """Classify uploaded audio file"""
+    try:
+        # Create temporary file
+        with tempfile.NamedTemporaryFile(delete=False, suffix='.wav') as tmp_file:
+            tmp_file.write(audio_file.getvalue())
+            tmp_file_path = tmp_file.name
+        
+        # Load audio (model uses 16kHz sample rate)
+        audio, sr = librosa.load(tmp_file_path, sr=16000)
+        
+        # Convert to tensor and add batch dimension
+        audio_tensor = torch.FloatTensor(audio).unsqueeze(0)
+        
+        # Get prediction
+        with torch.no_grad():
+            output = model(audio_tensor)
+            
+            # Convert logit to probability using sigmoid
+            prob = torch.sigmoid(output).item()
+            
+            # Classify: prob < 0.5 = Real, prob >= 0.5 = Fake
+            if prob < 0.5:
+                classification = "Real"
+                confidence = (1 - prob) * 2  # Convert to 0-1 scale
+            else:
+                classification = "Fake"
+                confidence = (prob - 0.5) * 2  # Convert to 0-1 scale
+        
+        # Cleanup
+        os.unlink(tmp_file_path)
+        
+        return {
+            "classification": classification,
+            "confidence": min(confidence, 1.0),  # Cap at 1.0
+            "probability": prob,
+            "raw_score": output.item(),
+            "duration": len(audio) / sr
+        }
+        
+    except Exception as e:
+        # Cleanup on error
+        if 'tmp_file_path' in locals() and os.path.exists(tmp_file_path):
+            os.unlink(tmp_file_path)
+        raise e
+
+# Main UI
+def main():
+    # Header
+    st.markdown('<h1 class="main-header">🎵 Madverse Music AI Detector</h1>', unsafe_allow_html=True)
+    st.markdown('<p class="sub-header">Upload audio files to detect if they\'re AI-generated or human-created</p>', unsafe_allow_html=True)
+    
+    # Sidebar
+    with st.sidebar:
+        st.header("🔬 Model Information")
+        
+        # Model loading status
+        if not st.session_state.model_loaded:
+            if st.button("🚀 Load AI Model", type="primary"):
+                with st.spinner("Loading Madverse Music AI model..."):
+                    st.session_state.model = load_model()
+                    if st.session_state.model:
+                        st.session_state.model_loaded = True
+                        st.success("✅ Model loaded successfully!")
+                        st.rerun()
+                    else:
+                        st.error("❌ Failed to load model")
+        else:
+            st.success("✅ Model Ready")
+            
+            # Model specs
+            st.markdown("""
+            **Model Details:**
+            - **Architecture**: SpecTTTra-α
+            - **Duration**: 120 seconds
+            - **Sample Rate**: 16kHz
+            - **F1 Score**: 97%
+            - **Sensitivity**: 96%
+            - **Specificity**: 99%
+            """)
+            
+            if st.button("🔄 Reload Model"):
+                st.session_state.model_loaded = False
+                st.session_state.model = None
+                st.cache_resource.clear()
+                st.rerun()
+    
+    # Main content
+    if st.session_state.model_loaded:
+        st.markdown("### 📁 Upload Audio File")
+        
+        # File uploader with bulk support
+        uploaded_files = st.file_uploader(
+            "Choose audio file(s)",
+            type=['wav', 'mp3', 'flac', 'm4a', 'ogg'],
+            accept_multiple_files=True,
+            help="Supported formats: WAV, MP3, FLAC, M4A, OGG (Max 200MB each). You can upload multiple files for bulk analysis."
+        )
+        
+        if uploaded_files:
+            # Display summary info for multiple files
+            if len(uploaded_files) == 1:
+                # Single file - show detailed info
+                uploaded_file = uploaded_files[0]
+                col1, col2, col3 = st.columns(3)
+                with col1:
+                    st.metric("📝 Filename", uploaded_file.name)
+                with col2:
+                    file_size_mb = uploaded_file.size / (1024 * 1024)
+                    st.metric("📊 File Size", f"{file_size_mb:.2f} MB")
+                with col3:
+                    st.metric("🎵 Format", uploaded_file.type)
+                
+                # Audio player
+                st.audio(uploaded_file, format='audio/wav')
+            else:
+                # Multiple files - show summary
+                total_size = sum(f.size for f in uploaded_files) / (1024 * 1024)
+                col1, col2, col3 = st.columns(3)
+                with col1:
+                    st.metric("📝 Files Selected", len(uploaded_files))
+                with col2:
+                    st.metric("📊 Total Size", f"{total_size:.2f} MB")
+                with col3:
+                    formats = list(set(f.type.split('/')[-1].upper() for f in uploaded_files))
+                    st.metric("🎵 Formats", ", ".join(formats))
+                
+                # Show file list
+                with st.expander(f"📋 File List ({len(uploaded_files)} files)"):
+                    for i, file in enumerate(uploaded_files, 1):
+                        size_mb = file.size / (1024 * 1024)
+                        st.write(f"{i}. **{file.name}** ({size_mb:.2f} MB)")
+            
+            # Analyze button
+            if len(uploaded_files) == 1:
+                button_text = "🔍 Analyze Audio"
+            else:
+                button_text = f"🔍 Analyze {len(uploaded_files)} Files"
+            
+            if st.button(button_text, type="primary", use_container_width=True):
+                try:
+                    if len(uploaded_files) == 1:
+                        # Single file analysis
+                        with st.spinner("🧠 Analyzing audio with AI..."):
+                            start_time = time.time()
+                            result = classify_audio_file(uploaded_files[0], st.session_state.model)
+                            processing_time = time.time() - start_time
+                        
+                        # Display results for single file
+                        st.markdown("### 🎯 Analysis Results")
+                        
+                        # Main result
+                        if result["classification"] == "Real":
+                            st.markdown(f"""
+                            <div class="result-box real-music">
+                                <h3>🎤 Human-Created Music</h3>
+                                <p>This audio appears to be created by human artists.</p>
+                            </div>
+                            """, unsafe_allow_html=True)
+                        else:
+                            st.markdown(f"""
+                            <div class="result-box fake-music">
+                                <h3>🤖 AI-Generated Music</h3>
+                                <p>This audio appears to be generated by AI (like Suno, Udio, etc.)</p>
+                            </div>
+                            """, unsafe_allow_html=True)
+                        
+                        # Detailed metrics for single file
+                        col1, col2, col3, col4 = st.columns(4)
+                        
+                        with col1:
+                            st.metric(
+                                "🎯 Classification",
+                                result["classification"],
+                                help="AI model's prediction"
+                            )
+                        
+                        with col2:
+                            confidence_pct = result["confidence"] * 100
+                            st.metric(
+                                "📊 Confidence",
+                                f"{confidence_pct:.1f}%",
+                                help="How confident the model is in its prediction"
+                            )
+                        
+                        with col3:
+                            st.metric(
+                                "⏱️ Duration",
+                                f"{result['duration']:.1f}s",
+                                help="Audio file duration"
+                            )
+                        
+                        with col4:
+                            st.metric(
+                                "⚡ Processing Time",
+                                f"{processing_time:.2f}s",
+                                help="Time taken to analyze"
+                            )
+                        
+                        # Technical details (expandable)
+                        with st.expander("🔬 Technical Details"):
+                            col1, col2 = st.columns(2)
+                            with col1:
+                                st.metric("Raw Sigmoid Probability", f"{result['probability']:.4f}")
+                                st.metric("Raw Model Output", f"{result['raw_score']:.4f}")
+                            with col2:
+                                st.info("""
+                                **How it works:**
+                                - Audio is resampled to 16kHz
+                                - Processed by SpecTTTra transformer
+                                - Output < 0.5 = Real, ≥ 0.5 = Fake
+                                """)
+                        
+                        # Progress bars for visualization
+                        st.markdown("### 📈 Confidence Visualization")
+                        if result["classification"] == "Real":
+                            st.progress(result["confidence"], text=f"Human Confidence: {result['confidence']:.1%}")
+                        else:
+                            st.progress(result["confidence"], text=f"AI Confidence: {result['confidence']:.1%}")
+                    
+                    else:
+                        # Multiple files analysis
+                        progress_bar = st.progress(0, text="🧠 Analyzing files...")
+                        results = []
+                        start_time = time.time()
+                        
+                        for i, file in enumerate(uploaded_files):
+                            progress = (i + 1) / len(uploaded_files)
+                            progress_bar.progress(progress, text=f"🧠 Analyzing file {i+1}/{len(uploaded_files)}: {file.name}")
+                            
+                            try:
+                                file_result = classify_audio_file(file, st.session_state.model)
+                                file_result["filename"] = file.name
+                                file_result["success"] = True
+                                results.append(file_result)
+                            except Exception as e:
+                                results.append({
+                                    "filename": file.name,
+                                    "success": False,
+                                    "error": str(e)
+                                })
+                        
+                        total_time = time.time() - start_time
+                        progress_bar.progress(1.0, text="✅ Analysis complete!")
+                        
+                        # Display bulk results
+                        st.markdown("### 🎯 Bulk Analysis Results")
+                        
+                        # Summary metrics
+                        successful = sum(1 for r in results if r["success"])
+                        failed = len(results) - successful
+                        
+                        col1, col2, col3, col4 = st.columns(4)
+                        with col1:
+                            st.metric("📁 Total Files", len(results))
+                        with col2:
+                            st.metric("✅ Successful", successful)
+                        with col3:
+                            st.metric("❌ Failed", failed)
+                        with col4:
+                            st.metric("⏱️ Total Time", f"{total_time:.1f}s")
+                        
+                        # Results breakdown
+                        if successful > 0:
+                            real_count = sum(1 for r in results if r.get("success") and r.get("classification") == "Real")
+                            fake_count = sum(1 for r in results if r.get("success") and r.get("classification") == "Fake")
+                            
+                            col1, col2 = st.columns(2)
+                            with col1:
+                                st.markdown(f"""
+                                <div class="result-box real-music">
+                                    <h4>🎤 Human Music: {real_count} files</h4>
+                                </div>
+                                """, unsafe_allow_html=True)
+                            with col2:
+                                st.markdown(f"""
+                                <div class="result-box fake-music">
+                                    <h4>🤖 AI Music: {fake_count} files</h4>
+                                </div>
+                                """, unsafe_allow_html=True)
+                        
+                        # Detailed results table
+                        st.markdown("### 📋 Detailed Results")
+                        
+                        for i, result in enumerate(results, 1):
+                            with st.expander(f"📄 {i}. {result['filename']}" + 
+                                           (" ✅" if result["success"] else " ❌")):
+                                if result["success"]:
+                                    col1, col2, col3 = st.columns(3)
+                                    with col1:
+                                        st.metric("Classification", result["classification"])
+                                    with col2:
+                                        st.metric("Confidence", f"{result['confidence']:.1%}")
+                                    with col3:
+                                        st.metric("Duration", f"{result['duration']:.1f}s")
+                                    
+                                    # Confidence bar
+                                    if result["classification"] == "Real":
+                                        st.progress(result["confidence"], 
+                                                  text=f"Human Confidence: {result['confidence']:.1%}")
+                                    else:
+                                        st.progress(result["confidence"], 
+                                                  text=f"AI Confidence: {result['confidence']:.1%}")
+                                else:
+                                    st.error(f"❌ Analysis failed: {result['error']}")
+                    
+                except Exception as e:
+                    st.error(f"❌ Error analyzing audio: {str(e)}")
+    
+    else:
+        # Model not loaded
+        st.markdown("""
+        <div class="info-box">
+            <h3>🚀 Getting Started</h3>
+            <p>Click "Load AI Model" in the sidebar to begin analyzing audio files.</p>
+            <p><strong>Note:</strong> The first load may take a moment as the model downloads.</p>
+        </div>
+        """, unsafe_allow_html=True)
+        
+        # Show supported formats
+        st.markdown("### 📁 Supported Audio Formats")
+        col1, col2, col3, col4, col5 = st.columns(5)
+        formats = [
+            ("🎵 WAV", ".wav"),
+            ("🎧 MP3", ".mp3"),
+            ("💿 FLAC", ".flac"),
+            ("📱 M4A", ".m4a"),
+            ("🎼 OGG", ".ogg")
+        ]
+        
+        for i, (icon_name, ext) in enumerate(formats):
+            with [col1, col2, col3, col4, col5][i]:
+                st.markdown(f"""
+                <div class="metric-card">
+                    <h4>{icon_name}</h4>
+                    <p>{ext}</p>
+                </div>
+                """, unsafe_allow_html=True)
+
+    # Footer
+    st.markdown("---")
+    st.markdown("""
+    <div style="text-align: center; color: #666; padding: 1rem;">
+        <p>🎵 <strong>Madverse Music</strong> - AI Music Detection Technology</p>
+        <p>Visit <a href="https://madverse.co" target="_blank">madverse.co</a> for more AI music tools</p>
+        <p><em>This tool is designed for research and testing purposes.</em></p>
+    </div>
+    """, unsafe_allow_html=True)
+
+if __name__ == "__main__":
+    main() 

app_hf.py

@@ -0,0 +1,272 @@
+#!/usr/bin/env python3
+"""
+Madverse Music - Hugging Face Spaces Version
+Streamlit app for HF Spaces deployment
+"""
+
+import streamlit as st
+import torch
+import librosa
+import tempfile
+import os
+import time
+import numpy as np
+
+# Import the sonics library for model loading
+try:
+    from sonics import HFAudioClassifier
+except ImportError:
+    st.error("Sonics library not found. Please install it first.")
+    st.stop()
+
+# Global model variable
+model = None
+
+# Page configuration
+st.set_page_config(
+    page_title="Madverse Music: AI Music Detector",
+    page_icon="🎵",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Custom CSS
+st.markdown("""
+<style>
+    .main-header {
+        background: linear-gradient(90deg, #667eea 0%, #764ba2 100%);
+        padding: 1rem;
+        border-radius: 10px;
+        color: white;
+        text-align: center;
+        margin-bottom: 2rem;
+    }
+    .result-box {
+        padding: 1rem;
+        border-radius: 10px;
+        margin: 1rem 0;
+        border-left: 5px solid;
+    }
+    .real-music {
+        background-color: #d4edda;
+        border-left-color: #28a745;
+    }
+    .fake-music {
+        background-color: #f8d7da;
+        border-left-color: #dc3545;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+@st.cache_resource
+def load_model():
+    """Load the model with caching for HF Spaces"""
+    try:
+        with st.spinner("Loading AI model... This may take a moment..."):
+            # Use the same loading method as the working API
+            model = HFAudioClassifier.from_pretrained("awsaf49/sonics-spectttra-alpha-120s")
+            model.eval()
+            return model
+    except Exception as e:
+        st.error(f"Failed to load model: {str(e)}")
+        return None
+
+def process_audio(audio_file, model):
+    """Process audio file and return classification"""
+    try:
+        # Save uploaded file temporarily
+        with tempfile.NamedTemporaryFile(delete=False, suffix='.wav') as tmp_file:
+            tmp_file.write(audio_file.read())
+            tmp_path = tmp_file.name
+        
+        # Load audio (model uses 16kHz sample rate)
+        audio, sr = librosa.load(tmp_path, sr=16000)
+        
+        # Convert to tensor and add batch dimension
+        audio_tensor = torch.FloatTensor(audio).unsqueeze(0)
+        
+        # Get prediction using the same pattern as working API
+        with torch.no_grad():
+            output = model(audio_tensor)
+            
+            # Convert logit to probability using sigmoid
+            probability = torch.sigmoid(output).item()
+            
+            # Classify: prob < 0.5 = Real, prob >= 0.5 = Fake
+            if probability < 0.5:
+                classification = "Real"
+                confidence = (1 - probability) * 2  # Convert to 0-1 scale
+            else:
+                classification = "Fake"
+                confidence = (probability - 0.5) * 2  # Convert to 0-1 scale
+        
+        # Calculate duration
+        duration = len(audio) / sr
+        
+        # Clean up
+        os.unlink(tmp_path)
+        
+        return {
+            'classification': classification,
+            'confidence': min(confidence, 1.0),  # Cap at 1.0
+            'probability': probability,
+            'raw_score': output.item(),
+            'duration': duration,
+            'success': True
+        }
+        
+    except Exception as e:
+        # Clean up on error
+        if 'tmp_path' in locals():
+            try:
+                os.unlink(tmp_path)
+            except:
+                pass
+        return {
+            'success': False,
+            'error': str(e)
+        }
+
+def main():
+    # Header
+    st.markdown("""
+    <div class="main-header">
+        <h1>Madverse Music: AI Music Detector</h1>
+        <p>Detect AI-generated music vs human-created music using advanced AI technology</p>
+    </div>
+    """, unsafe_allow_html=True)
+    
+    # Sidebar
+    with st.sidebar:
+        st.markdown("### About")
+        st.markdown("""
+        This AI model can detect whether music is:
+        - **Real**: Human-created music
+        - **Fake**: AI-generated music (Suno, Udio, etc.)
+        
+        **Model**: SpecTTTra-α (120s)  
+        **Accuracy**: 97% F1 score  
+        **Max Duration**: 120 seconds
+        """)
+        
+        st.markdown("### Supported Formats")
+        st.markdown("- WAV (.wav)")
+        st.markdown("- MP3 (.mp3)")
+        st.markdown("- FLAC (.flac)")
+        st.markdown("- M4A (.m4a)")
+        st.markdown("- OGG (.ogg)")
+        
+        st.markdown("### Links")
+        st.markdown("- [Madverse Website](https://madverse.co)")
+        st.markdown("- [GitHub Repository](#)")
+    
+    # Load model
+    model = load_model()
+    
+    if model is None:
+        st.error("Model failed to load. Please refresh the page.")
+        return
+    
+    st.success("AI model loaded successfully!")
+    
+    # File upload
+    st.markdown("### Upload Audio File")
+    uploaded_file = st.file_uploader(
+        "Choose an audio file",
+        type=['wav', 'mp3', 'flac', 'm4a', 'ogg'],
+        help="Upload an audio file to analyze (max 120 seconds)"
+    )
+    
+    if uploaded_file is not None:
+        # Display file info
+        st.markdown("### File Information")
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            st.metric("Filename", uploaded_file.name)
+        with col2:
+            st.metric("File Size", f"{uploaded_file.size / 1024:.1f} KB")
+        with col3:
+            st.metric("Format", uploaded_file.type)
+        
+        # Audio player
+        st.markdown("### Preview")
+        st.audio(uploaded_file)
+        
+        # Analysis button
+        if st.button("Analyze Audio", type="primary", use_container_width=True):
+            try:
+                with st.spinner("Analyzing audio... This may take a few seconds..."):
+                    # Reset file pointer
+                    uploaded_file.seek(0)
+                    
+                    # Process audio
+                    start_time = time.time()
+                    result = process_audio(uploaded_file, model)
+                    processing_time = time.time() - start_time
+                
+                if not result['success']:
+                    st.error(f"Error processing audio: {result['error']}")
+                    return
+                
+                # Display results
+                st.markdown("### Analysis Results")
+                
+                classification = result['classification']
+                confidence = result['confidence']
+                
+                # Result box
+                if classification == "Real":
+                    st.markdown(f"""
+                    <div class="result-box real-music">
+                        <h3>Result: Human-Created Music</h3>
+                        <p><strong>Classification:</strong> {classification}</p>
+                        <p><strong>Confidence:</strong> {confidence:.1%}</p>
+                        <p><strong>Message:</strong> This appears to be human-created music!</p>
+                    </div>
+                    """, unsafe_allow_html=True)
+                else:
+                    st.markdown(f"""
+                    <div class="result-box fake-music">
+                        <h3>Result: AI-Generated Music</h3>
+                        <p><strong>Classification:</strong> {classification}</p>
+                        <p><strong>Confidence:</strong> {confidence:.1%}</p>
+                        <p><strong>Message:</strong> This appears to be AI-generated music!</p>
+                    </div>
+                    """, unsafe_allow_html=True)
+                
+                # Detailed metrics
+                with st.expander("Detailed Metrics"):
+                    col1, col2, col3 = st.columns(3)
+                    
+                    with col1:
+                        st.metric("Confidence", f"{confidence:.1%}")
+                    with col2:
+                        st.metric("Probability", f"{result['probability']:.3f}")
+                    with col3:
+                        st.metric("Processing Time", f"{processing_time:.2f}s")
+                    
+                    if result['duration'] > 0:
+                        st.metric("Duration", f"{result['duration']:.1f}s")
+                    
+                    st.markdown("**Interpretation:**")
+                    st.markdown("""
+                    - **Probability < 0.5**: Classified as Real (human-created)
+                    - **Probability ≥ 0.5**: Classified as Fake (AI-generated)
+                    - **Confidence**: How certain the model is about its prediction
+                    """)
+                
+            except Exception as e:
+                st.error(f"Error processing audio: {str(e)}")
+    
+    # Footer
+    st.markdown("---")
+    st.markdown("""
+    <div style="text-align: center; color: #666;">
+        <p>Powered by <strong>Madverse Music</strong> | Built with Streamlit & PyTorch</p>
+        <p>This tool is for research and educational purposes. Results may vary depending on audio quality.</p>
+    </div>
+    """, unsafe_allow_html=True)
+
+if __name__ == "__main__":
+    main() 

classify_audio.py

@@ -0,0 +1,122 @@
+#!/usr/bin/env python3
+"""
+Simple Audio Classifier using Madverse Music AI Model
+Usage: python classify_audio.py <audio_file_path>
+"""
+
+import sys
+import os
+from pathlib import Path
+
+def load_model():
+    """Load the Madverse Music AI model"""
+    try:
+        from sonics import HFAudioClassifier
+        print("🔄 Loading Madverse Music AI model...")
+        model = HFAudioClassifier.from_pretrained("awsaf49/sonics-spectttra-alpha-120s")
+        print("✅ Model loaded successfully!")
+        return model
+    except Exception as e:
+        print(f"❌ Error loading model: {e}")
+        return None
+
+def classify_audio(model, audio_path):
+    """Classify a single audio file"""
+    try:
+        import librosa
+        import torch
+        
+        print(f"🎵 Analyzing: {audio_path}")
+        
+        # Load audio file (model uses 16kHz sample rate)
+        audio, sr = librosa.load(audio_path, sr=16000)
+        
+        # Convert to tensor and add batch dimension
+        audio_tensor = torch.FloatTensor(audio).unsqueeze(0)
+        
+        # Set model to evaluation mode
+        model.eval()
+        
+        # Get prediction
+        with torch.no_grad():
+            output = model(audio_tensor)
+            
+            # Convert logit to probability using sigmoid
+            prob = torch.sigmoid(output).item()
+            
+            # Classify: prob < 0.5 = Real, prob >= 0.5 = Fake
+            if prob < 0.5:
+                result = "Real"
+                emoji = "🎤"
+                description = "Human-created music"
+                confidence = (1 - prob) * 2  # Convert to 0-1 scale
+            else:
+                result = "Fake"
+                emoji = "🤖"
+                description = "AI-generated music"
+                confidence = (prob - 0.5) * 2  # Convert to 0-1 scale
+            
+        print(f"{emoji} Result: {result} ({description})")
+        print(f"   Confidence: {confidence:.2f} | Raw output: {output.item():.3f}")
+        return result
+        
+    except Exception as e:
+        print(f"❌ Error classifying {audio_path}: {e}")
+        return None
+
+def classify_multiple_files(model, directory_path="."):
+    """Classify all audio files in a directory"""
+    audio_extensions = ['.wav', '.mp3', '.flac', '.m4a', '.ogg']
+    directory = Path(directory_path)
+    
+    audio_files = []
+    for ext in audio_extensions:
+        audio_files.extend(list(directory.glob(f'*{ext}')))
+    
+    if not audio_files:
+        print(f"No audio files found in {directory}")
+        return
+    
+    print(f"Found {len(audio_files)} audio file(s) to classify:")
+    print("=" * 50)
+    
+    results = {}
+    for audio_file in audio_files:
+        result = classify_audio(model, str(audio_file))
+        if result:
+            results[str(audio_file)] = result
+        print()
+    
+    # Summary
+    if results:
+        print("📊 Summary:")
+        print("=" * 30)
+        real_count = sum(1 for r in results.values() if r.lower() == 'real')
+        fake_count = len(results) - real_count
+        print(f"🎤 Real music: {real_count}")
+        print(f"🤖 AI-generated: {fake_count}")
+
+def main():
+    """Main function"""
+    print("🎵 Madverse Music: AI Audio Classifier")
+    print("=" * 40)
+    
+    # Load model
+    model = load_model()
+    if not model:
+        return
+    
+    if len(sys.argv) > 1:
+        # Classify specific file
+        audio_path = sys.argv[1]
+        if os.path.exists(audio_path):
+            classify_audio(model, audio_path)
+        else:
+            print(f"❌ File not found: {audio_path}")
+    else:
+        # Classify all files in current directory
+        print("\nNo specific file provided. Scanning current directory...")
+        classify_multiple_files(model)
+
+if __name__ == "__main__":
+    main() 

config.json

@@ -0,0 +1,100 @@
+{
+  "audio": {
+    "max_len": 1920000,
+    "max_time": 120,
+    "normalize": true,
+    "random_sampling": true,
+    "sample_rate": 16000,
+    "skip_time": false
+  },
+  "augment": {
+    "freq_mask_param": 8,
+    "mixup_alpha": 2.5,
+    "mixup_p": 0.5,
+    "n_freq_masks": 1,
+    "n_time_masks": 2,
+    "time_freq_mask_p": 0.5,
+    "time_mask_param": 8
+  },
+  "dataset": {
+    "test_dataframe": "test.csv",
+    "train_dataframe": "train.csv",
+    "valid_dataframe": "valid.csv"
+  },
+  "environment": {
+    "mixed_precision": true,
+    "num_workers": 2,
+    "seed": 42
+  },
+  "experiment_name": "spectttra_alpha-t=120",
+  "logger": {
+    "primary_metric": "f1",
+    "project": "sonics"
+  },
+  "loss": {
+    "label_smoothing": 0.02,
+    "name": "BCEWithLogitsLoss"
+  },
+  "melspec": {
+    "f_max": 8000,
+    "f_min": 20,
+    "hop_length": 512,
+    "n_fft": 2048,
+    "n_mels": 128,
+    "norm": "mean_std",
+    "power": 2,
+    "top_db": 80,
+    "win_length": 2048
+  },
+  "model": {
+    "attn_drop_rate": 0.1,
+    "embed_dim": 384,
+    "f_clip": 1,
+    "input_shape": [
+      128,
+      3744
+    ],
+    "mlp_ratio": 2.67,
+    "name": "SpecTTTra",
+    "num_heads": 6,
+    "num_layers": 12,
+    "pe_learnable": true,
+    "pos_drop_rate": 0.1,
+    "pre_norm": true,
+    "proj_drop_rate": 0.0,
+    "resume": null,
+    "t_clip": 3,
+    "use_init_weights": false
+  },
+  "num_classes": 1,
+  "optimizer": {
+    "clip_grad_norm": 5.0,
+    "grad_accum_steps": 1,
+    "momentum": 0.9,
+    "opt": "adamw",
+    "opt_betas": [
+      0.9,
+      0.999
+    ],
+    "opt_eps": 1e-08,
+    "weight_decay": 0.05
+  },
+  "scheduler": {
+    "decay_rate": 0.1,
+    "lr": 0.0005,
+    "lr_base": 0.001,
+    "lr_base_scale": "linear",
+    "lr_base_size": 256,
+    "min_lr": 0.0,
+    "sched": "cosine",
+    "warmup_epochs": 5,
+    "warmup_lr": 1e-06
+  },
+  "training": {
+    "batch_size": 96,
+    "epochs": 50
+  },
+  "validation": {
+    "batch_size": 96
+  }
+}

deploy.ps1

@@ -0,0 +1,68 @@
+# Madverse Music Deployment Script for Windows
+# Run with: .\deploy.ps1
+
+Write-Host "🎵 Deploying Madverse Music API..." -ForegroundColor Cyan
+
+# Check if Docker is installed
+try {
+    docker --version | Out-Null
+    Write-Host "✅ Docker found" -ForegroundColor Green
+} catch {
+    Write-Host "❌ Docker is not installed. Please install Docker Desktop first." -ForegroundColor Red
+    exit 1
+}
+
+# Check if docker-compose is installed
+try {
+    docker-compose --version | Out-Null
+    Write-Host "✅ Docker Compose found" -ForegroundColor Green
+} catch {
+    Write-Host "❌ Docker Compose is not installed. Please install Docker Desktop with Compose." -ForegroundColor Red
+    exit 1
+}
+
+# Set environment variables
+if (-not $env:MADVERSE_API_KEY) {
+    $env:MADVERSE_API_KEY = "madverse-music-api-key-2024"
+}
+
+Write-Host "🔧 Building Docker image..." -ForegroundColor Yellow
+docker-compose build
+
+if ($LASTEXITCODE -ne 0) {
+    Write-Host "❌ Failed to build Docker image" -ForegroundColor Red
+    exit 1
+}
+
+Write-Host "🚀 Starting services..." -ForegroundColor Yellow
+docker-compose up -d
+
+if ($LASTEXITCODE -ne 0) {
+    Write-Host "❌ Failed to start services" -ForegroundColor Red
+    exit 1
+}
+
+Write-Host "⏳ Waiting for services to be healthy..." -ForegroundColor Yellow
+Start-Sleep -Seconds 30
+
+# Test the API
+Write-Host "🧪 Testing API health..." -ForegroundColor Yellow
+try {
+    $response = Invoke-WebRequest -Uri "http://localhost:8000/health" -Method GET -TimeoutSec 10
+    if ($response.StatusCode -eq 200) {
+        Write-Host "✅ API is healthy and running!" -ForegroundColor Green
+        Write-Host "📍 API URL: http://localhost:8000" -ForegroundColor Cyan
+        Write-Host "📖 API Docs: http://localhost:8000/" -ForegroundColor Cyan
+        Write-Host "🔑 API Key: $env:MADVERSE_API_KEY" -ForegroundColor Cyan
+    } else {
+        throw "Health check failed"
+    }
+} catch {
+    Write-Host "❌ API health check failed. Check logs:" -ForegroundColor Red
+    docker-compose logs madverse-api
+    exit 1
+}
+
+Write-Host ""
+Write-Host "🎯 Quick Test Command:" -ForegroundColor Yellow
+Write-Host "Invoke-RestMethod -Uri 'http://localhost:8000/analyze' -Method POST -Headers @{'X-API-Key'='$env:MADVERSE_API_KEY'; 'Content-Type'='application/json'} -Body '{`"urls`": [`"https://example.com/song.mp3`"]}'" -ForegroundColor Gray 

deploy.sh

@@ -0,0 +1,51 @@
+#!/bin/bash
+
+# Madverse Music Deployment Script
+
+set -e
+
+echo "🎵 Deploying Madverse Music API..."
+
+# Check if Docker is installed
+if ! command -v docker &> /dev/null; then
+    echo "❌ Docker is not installed. Please install Docker first."
+    exit 1
+fi
+
+# Check if docker-compose is installed
+if ! command -v docker-compose &> /dev/null; then
+    echo "❌ Docker Compose is not installed. Please install Docker Compose first."
+    exit 1
+fi
+
+# Set environment variables
+export MADVERSE_API_KEY=${MADVERSE_API_KEY:-madverse-music-api-key-2024}
+
+echo "🔧 Building Docker image..."
+docker-compose build
+
+echo "🚀 Starting services..."
+docker-compose up -d
+
+echo "⏳ Waiting for services to be healthy..."
+sleep 30
+
+# Test the API
+echo "🧪 Testing API health..."
+if curl -f http://localhost:8000/health > /dev/null 2>&1; then
+    echo "✅ API is healthy and running!"
+    echo "📍 API URL: http://localhost:8000"
+    echo "📖 API Docs: http://localhost:8000/"
+    echo "🔑 API Key: $MADVERSE_API_KEY"
+else
+    echo "❌ API health check failed. Check logs:"
+    docker-compose logs madverse-api
+    exit 1
+fi
+
+echo ""
+echo "🎯 Quick Test:"
+echo "curl -X POST 'http://localhost:8000/analyze' \\"
+echo "  -H 'X-API-Key: $MADVERSE_API_KEY' \\"
+echo "  -H 'Content-Type: application/json' \\"
+echo "  -d '{\"urls\": [\"https://example.com/song.mp3\"]}'" 

docker-compose.yml

@@ -0,0 +1,34 @@
+version: '3.8'
+
+services:
+  madverse-api:
+    build: .
+    ports:
+      - "8000:8000"
+    environment:
+      - MADVERSE_API_KEY=${MADVERSE_API_KEY:-madverse-music-api-key-2024}
+    volumes:
+      # Optional: Mount model files if you want to update them without rebuilding
+      - ./pytorch_model.bin:/app/pytorch_model.bin:ro
+      - ./config.json:/app/config.json:ro
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 60s
+
+  # Optional: Add nginx proxy for production
+  nginx:
+    image: nginx:alpine
+    ports:
+      - "80:80"
+      - "443:443"
+    volumes:
+      - ./nginx.conf:/etc/nginx/nginx.conf:ro
+    depends_on:
+      - madverse-api
+    restart: unless-stopped
+    profiles:
+      - production 

env.example

@@ -0,0 +1,19 @@
+# Madverse Music API Configuration
+
+# API Authentication
+MADVERSE_API_KEY=your-secure-api-key-here
+
+# Optional: Model Configuration (if using custom model paths)
+MODEL_PATH=./pytorch_model.bin
+CONFIG_PATH=./config.json
+
+# Optional: Server Configuration
+HOST=0.0.0.0
+PORT=8000
+
+# Optional: Logging
+LOG_LEVEL=INFO
+
+# Optional: Performance Tuning
+MAX_WORKERS=4
+TIMEOUT_SECONDS=300 

pytorch_model.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:082df7e387041b654315656efb891c07f831dcb01f9c047b74d33b2777a8373b
+size 75315274

requirements.txt

@@ -1,3 +1,8 @@
-altair
-pandas
-streamlit
+fastapi==0.104.1
+uvicorn==0.24.0
+streamlit>=1.28.0
+torch>=2.0.0
+librosa>=0.9.0
+requests>=2.25.0
+pydantic>=2.0.0
+git+https://github.com/awsaf49/sonics.git 

requirements_hf.txt

@@ -0,0 +1,9 @@
+streamlit>=1.28.0
+torch>=2.0.0
+librosa>=0.9.0
+numpy>=1.24.0
+soundfile>=0.12.0
+fastapi>=0.100.0
+uvicorn>=0.20.0
+python-multipart>=0.0.6
+git+https://github.com/awsaf49/sonics.git 

test_api.py

@@ -0,0 +1,183 @@
+#!/usr/bin/env python3
+"""
+Test script for Madverse Music API
+"""
+
+import requests
+import json
+import time
+import os
+
+# API endpoint
+API_URL = "http://localhost:8000"
+
+# API Key (same as in api.py)
+API_KEY = os.getenv("MADVERSE_API_KEY", "madverse-music-api-key-2024")
+
+# Headers for authenticated requests
+HEADERS = {
+    "X-API-Key": API_KEY,
+    "Content-Type": "application/json"
+}
+
+def test_health():
+    """Test health check endpoint"""
+    print("🔍 Testing health check...")
+    response = requests.get(f"{API_URL}/health")
+    print(f"Status: {response.status_code}")
+    print(f"Response: {response.json()}")
+    print()
+
+def test_info():
+    """Test info endpoint"""
+    print("📊 Testing info endpoint...")
+    response = requests.get(f"{API_URL}/info")
+    print(f"Status: {response.status_code}")
+    print(f"Response: {json.dumps(response.json(), indent=2)}")
+    print()
+
+def test_analyze_single(audio_url):
+    """Test music analysis endpoint with single URL"""
+    print(f"🎵 Testing single file analysis with URL: {audio_url}")
+    
+    payload = {
+        "urls": [audio_url]
+    }
+    
+    start_time = time.time()
+    response = requests.post(f"{API_URL}/analyze", json=payload, headers=HEADERS)
+    end_time = time.time()
+    
+    print(f"Status: {response.status_code}")
+    print(f"Request time: {end_time - start_time:.2f} seconds")
+    
+    if response.status_code == 200:
+        result = response.json()
+        print("✅ Analysis successful!")
+        print(f"Total files: {result['total_files']}")
+        print(f"Successful: {result['successful_analyses']}")
+        print(f"Message: {result['message']}")
+        
+        if result['results']:
+            file_result = result['results'][0]
+            if file_result['success']:
+                print(f"Classification: {file_result['classification']}")
+                print(f"Confidence: {file_result['confidence']:.2%}")
+                print(f"Duration: {file_result['duration']:.1f} seconds")
+                print(f"Processing time: {file_result['processing_time']:.2f} seconds")
+    else:
+        print("❌ Analysis failed!")
+        print(f"Error: {response.json()}")
+    print()
+
+def test_analyze_multiple(audio_urls):
+    """Test music analysis endpoint with multiple URLs"""
+    print(f"🎵 Testing multiple files analysis with {len(audio_urls)} URLs...")
+    
+    payload = {
+        "urls": audio_urls
+    }
+    
+    start_time = time.time()
+    response = requests.post(f"{API_URL}/analyze", json=payload, headers=HEADERS)
+    end_time = time.time()
+    
+    print(f"Status: {response.status_code}")
+    print(f"Request time: {end_time - start_time:.2f} seconds")
+    
+    if response.status_code == 200:
+        result = response.json()
+        print("✅ Multiple files analysis successful!")
+        print(f"Total files: {result['total_files']}")
+        print(f"Successful: {result['successful_analyses']}")
+        print(f"Failed: {result['failed_analyses']}")
+        print(f"Message: {result['message']}")
+        print(f"Total processing time: {result['total_processing_time']:.2f} seconds")
+        
+        print("\n📋 Individual Results:")
+        for i, file_result in enumerate(result['results'][:3]):  # Show first 3 results
+            status = "✅" if file_result['success'] else "❌"
+            print(f"  {i+1}. {status} {file_result['url'][:50]}...")
+            if file_result['success']:
+                print(f"     Classification: {file_result['classification']}")
+                print(f"     Confidence: {file_result['confidence']:.2%}")
+            else:
+                print(f"     Error: {file_result['message']}")
+        
+        if len(result['results']) > 3:
+            print(f"  ... and {len(result['results']) - 3} more results")
+            
+    else:
+        print("❌ Multiple files analysis failed!")
+        print(f"Error: {response.json()}")
+    print()
+
+def test_unauthorized_access():
+    """Test unauthorized access (without API key)"""
+    print("🔒 Testing unauthorized access...")
+    
+    payload = {
+        "urls": ["https://example.com/test.mp3"]
+    }
+    
+    # Make request without API key
+    response = requests.post(f"{API_URL}/analyze", json=payload)
+    
+    print(f"Status: {response.status_code}")
+    if response.status_code == 401:
+        print("✅ Unauthorized access properly blocked!")
+        print(f"Error: {response.json()}")
+    else:
+        print("❌ Unauthorized access not blocked!")
+        print(f"Response: {response.json()}")
+    print()
+
+def main():
+    """Main test function"""
+    print("🚀 Madverse Music API Test")
+    print("=" * 40)
+    
+    # Test basic endpoints
+    test_health()
+    test_info()
+    
+    # Test authentication
+    test_unauthorized_access()
+    
+    # Test with a sample audio URL (you can replace with your own)
+    # This is just an example - replace with actual audio URLs
+    sample_urls = [
+        "https://example.com/sample.mp3",  # Replace with real URLs
+        "https://example.com/sample2.wav"
+    ]
+    
+    print("📝 To test with real audio:")
+    print("1. Replace sample URLs in this script with real audio URLs")
+    print("2. Or use curl for single file:")
+    print(f'   curl -X POST "{API_URL}/analyze" \\')
+    print(f'        -H "X-API-Key: {API_KEY}" \\')
+    print(f'        -H "Content-Type: application/json" \\')
+    print(f'        -d \'{{"urls": ["YOUR_AUDIO_URL"]}}\'')
+    print()
+    print("3. Or use curl for multiple files:")
+    print(f'   curl -X POST "{API_URL}/analyze" \\')
+    print(f'        -H "X-API-Key: {API_KEY}" \\')
+    print(f'        -H "Content-Type: application/json" \\')
+    print(f'        -d \'{{"urls": ["URL1", "URL2", "URL3"]}}\'')
+    print()
+    
+    # Uncomment below to test with real URLs
+    # for url in sample_urls:
+    #     try:
+    #         test_analyze_single(url)
+    #     except Exception as e:
+    #         print(f"Error testing {url}: {e}")
+    
+    # Uncomment below to test multiple files analysis
+    # try:
+    #     test_analyze_multiple(sample_urls)
+    # except Exception as e:
+    #     print(f"Error testing multiple files: {e}")
+
+if __name__ == "__main__":
+    main()