feat(space): CPU ONNX runtime build (v9.4, full-song sliding aggregation)

- Replace legacy core/ui architecture with hf-spaces package
- Use intrect/artifactnet-models ONNX (production-onnx/*.onnx)
- Full-song sliding chunk aggregation (matches production)
- Upload-only (YouTube removed), error report to api.intrect.io
- ffmpeg-based opus/m4a support

.gitignore

@@ -1,40 +0,0 @@
-# Python
-__pycache__/
-*.py[cod]
-*.egg-info/
-*.egg
-dist/
-build/
-
-# IP Protection note: core/proprietary.py contains obfuscated algorithms
-# (난독화된 알고리즘으로 특허 핵심 보호)
-
-# Models (downloaded at runtime from HF Hub)
-*.onnx
-*.pt
-*.onnx.data
-
-# Environment
-.env
-.venv/
-venv/
-
-# IDE
-.vscode/
-.idea/
-*.swp
-*.swo
-
-# OS
-.DS_Store
-Thumbs.db
-
-# Gradio
-flagged/
-
-# Development files (not needed in HF Spaces)
-CLAUDE.md
-.claude/
-local_demo_v77.py
-testing/
-trash/

Dockerfile.youtube-proxy

@@ -1,62 +0,0 @@
-# Multi-stage Dockerfile for YouTube Proxy Server
-
-FROM python:3.11-slim as builder
-
-# Install build dependencies
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    build-essential \
-    && rm -rf /var/lib/apt/lists/*
-
-# Create virtual environment
-RUN python -m venv /opt/venv
-ENV PATH="/opt/venv/bin:$PATH"
-
-# Copy and install Python dependencies
-COPY requirements.txt .
-RUN pip install --no-cache-dir -r requirements.txt
-
-# ============================================================
-# Final stage
-# ============================================================
-
-FROM python:3.11-slim
-
-# Install runtime dependencies (ffmpeg for yt-dlp)
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    ffmpeg \
-    && rm -rf /var/lib/apt/lists/*
-
-# Copy virtual environment from builder
-COPY --from=builder /opt/venv /opt/venv
-ENV PATH="/opt/venv/bin:$PATH"
-
-# Create non-root user for security (use UID 1001 to avoid conflicts)
-RUN useradd -m -u 1001 appuser 2>/dev/null || true
-
-# Set working directory
-WORKDIR /app
-
-# Copy application
-COPY youtube_proxy_server.py .
-
-# Change ownership
-RUN chown -R appuser:appuser /app 2>/dev/null || true
-
-# Switch to non-root user
-USER appuser
-
-# Expose port
-EXPOSE 8765
-
-# Health check
-HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
-    CMD python -c "import requests; requests.get('http://localhost:8765/health')" || exit 1
-
-# Default environment variables
-ENV HOST=0.0.0.0
-ENV PORT=8765
-ENV LOG_LEVEL=INFO
-ENV YOUTUBE_PROXY_API_KEY=default-key
-
-# Run application
-CMD ["python", "youtube_proxy_server.py"]

HF_SPACES_ENV.md

@@ -1,139 +0,0 @@
-# HF Spaces 환경변수 설정 가이드
-
-YouTube 프록시를 통해 HF Spaces 앱에서 YouTube URL 다운로드를 활성화하려면 다음 환경변수를 설정하세요.
-
-## 설정 단계
-
-### 1. cloudflared를 통한 외부 접근
-
-youtube-proxy 서비스는 `youtube-proxy.intrect.io`를 통해 접근 가능합니다 (Cloudflare Tunnel 역프록시).
-
-### 2. HF Spaces 시크릿 설정
-
-HF Spaces 설정에서 다음 환경변수를 추가하세요:
-
-#### `YOUTUBE_PROXY_URL`
-```
-https://youtube-proxy.intrect.io
-```
-
-#### `YOUTUBE_PROXY_API_KEY`
-```
-c60ba3dc9f26cfc700958983f82b997eac084743aad9f5be4db7bb625ae6dbbd
-```
-
-이는 `docker-compose.youtube-proxy.yml`의 `YOUTUBE_PROXY_API_KEY` 환경변수와 **정확히 동일**해야 합니다.
-
-## 인증 흐름
-
-1. HF Spaces 앱이 YouTube URL을 받으면
-2. `YOUTUBE_PROXY_URL` 및 `YOUTUBE_PROXY_API_KEY` 사용
-3. `https://youtube-proxy.intrect.io/download-youtube` 엔드포인트로 POST 요청
-4. `Authorization: Bearer {YOUTUBE_PROXY_API_KEY}` 헤더 포함
-5. 프록시 서버가 yt-dlp로 다운로드
-6. WAV 파일 반환
-
-## 보안 고려사항
-
-- API 키는 **절대 공개하지 마세요**
-- cloudflared 역프록시를 통해서만 접근 가능 (외부 포트 노출 없음)
-- 컨테이너는 `proxy` 사용자로 실행 (root 아님)
-- 최소 권한 원칙 준수
-
-## 문제 해결
-
-### HF Spaces에서 연결 실패
-
-1. cloudflared 상태 확인:
-   ```bash
-   sudo systemctl status cloudflared
-   ```
-
-2. youtube-proxy 컨테이너 상태 확인:
-   ```bash
-   docker ps | grep youtube-proxy
-   docker logs artifactnet-youtube-proxy
-   ```
-
-3. DNS 확인:
-   ```bash
-   curl -I https://youtube-proxy.intrect.io/health
-   ```
-
-### API 키 불일치
-
-`docker-compose.youtube-proxy.yml`의 `YOUTUBE_PROXY_API_KEY`와 HF Spaces의 `YOUTUBE_PROXY_API_KEY`가 **정확히 동일**한지 확인하세요.
-
-## Rate Limiting 설정 (권장)
-
-과도한 요청과 연속 스팸으로부터 HF Spaces 및 ubuntu-mini 보호:
-
-#### `RATE_LIMIT_REQUESTS`
-```
-5
-```
-(기본값: 5회, 1시간당)
-
-#### `RATE_LIMIT_MINUTES`
-```
-60
-```
-(기본값: 60분 윈도우)
-
-#### `BURST_LIMIT_PER_MINUTE`
-```
-2
-```
-(기본값: 최대 2회/분, 연속 요청 방지)
-
-**동작:**
-- **Burst 제한**: 사용자당 2회/분 (연속 요청 방지)
-- **시간 제한**: 사용자당 5회/60분 (장기 남용 방지)
-- 둘 다 만족해야 요청 허용
-
----
-
-## 에지 케이스 수집 설정 (선택사항)
-
-Uncertain 판정 곡의 분석 데이터를 자동으로 수집하려면:
-
-#### `UBUNTU_MINI_ENABLED`
-```
-true
-```
-
-#### `UBUNTU_MINI_HOST`
-```
-ubuntu-mini.local
-```
-
-#### `UBUNTU_MINI_PORT`
-```
-9000
-```
-
-**수집되는 것:**
-- Mel-spectrogram (30초 미만)
-- 판정 통계
-- 타임스탬프
-
-**수집되지 않는 것:**
-- 원본 오디오 파일
-- 개인 정보
-
-## 다음 단계
-
-1. Docker 컨테이너 실행:
-   ```bash
-   docker-compose -f docker-compose.youtube-proxy.yml up -d
-   ```
-
-2. 건강 체크:
-   ```bash
-   curl -H "Authorization: Bearer <your-key>" \
-     https://youtube-proxy.intrect.io/health
-   ```
-
-3. HF Spaces에서 YouTube URL 탭이 나타나면 작동 중입니다.
-
-4. Uncertain 곡이 자동으로 ubuntu-mini로 전송되는지 확인합니다.

README.md

@@ -1,30 +1,46 @@
 ---
 title: ArtifactNet
-emoji: 🔍
-colorFrom: indigo
-colorTo: yellow
+emoji: 🎵
+colorFrom: orange
+colorTo: blue
 sdk: gradio
-sdk_version: 6.12.0
+sdk_version: 4.44.0
 app_file: app.py
-pinned: false
-license: mit
-hardware: zero-a10g
+python_version: "3.10"
+pinned: true
+license: other
+short_description: AI-generated music detection (v9.4 Forensic CNN + HPSS)
+hardware: cpu-basic
+models:
+  - intrect/artifactnet-models
 ---
 
 # ArtifactNet — AI Music Forensic Detector
 
-Detect AI-generated music using deep spectral analysis and neural networks.
-# Model sync check - 20260225
-
-
-@article{oh2026artifactnet,
-  title        = {ArtifactNet: Detecting AI-Generated Music via Forensic Residual Physics},
-  author       = {Oh, Heewon},
-  journal      = {arXiv preprint arXiv:2604.16254},
-  year         = {2026},
-  eprint       = {2604.16254},
-  archivePrefix= {arXiv},
-  primaryClass = {cs.SD},
-  doi          = {10.48550/arXiv.2604.16254},
-  url          = {https://arxiv.org/abs/2604.16254}
-}
+Upload a track (WAV / MP3 / FLAC, ≤100 MB, ≤5 min). ArtifactNet analyses
+spectral + harmonic-percussive forensic features and returns a per-segment
+P(AI) distribution.
+
+- **Backbone**: STFT → U-Net artifact residual → HPSS → 7-channel features → CNN
+- **Verdict**: energy-weighted median across 4-second segments
+- **Runtime**: ONNX Runtime on HF Space CPU (~30–60 s per 4-minute track)
+
+## Paper
+
+ArtifactNet: Forensic Detection of AI-Generated Music via HPSS and Residual
+Analysis — [arXiv:2604.16254](https://arxiv.org/abs/2604.16254).
+
+## Links
+
+- Production dashboard: [dash.intrect.io](https://dash.intrect.io)
+- Pricing / API: [intrect.io](https://intrect.io)
+
+## Notes
+
+- Short files (<60 s) have fewer segments and lower confidence.
+- Mono input disables stereo phase features.
+- Heavily processed audio (bitcrushing, vinyl rips) may affect results.
+- YouTube / URL intake is disabled on this Space — use the dashboard for batch
+  processing.
+- Only the ONNX graphs (inference-only, no training metadata) are published;
+  the original PyTorch checkpoints remain private.

app.py

@@ -1,611 +1,593 @@
-#!/usr/bin/env python3
-# Purpose: ArtifactNet HF Spaces demo — Gradio Blocks UI (3-tier verdict)
-
-"""ArtifactNet — AI Music Forensic Detector.
-
-v8.0: ArtifactUNet ONNX — CPU-only, no GPU required.
-"""
-
-import sys
-import os
-import json
-import time
-import subprocess
-import tempfile
-import warnings
-from collections import defaultdict
-from datetime import datetime, timedelta
-
-import numpy as np
-import torch
-import gradio as gr
-
-# Add demo/ directory to module path
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-
-from config import SR
-from inference.audio_utils import load_audio_mono_tensor, get_audio_info
-from inference.e2e_model import get_model, run_e2e_inference
-from visualization.spectrogram import plot_spectrograms
-from visualization.timeline import plot_timeline
-from ui import VerdictCardBuilder, create_theme, create_header, create_about_section
-from core import compute_stats, classify
-
-warnings.filterwarnings("ignore")
-
-IS_HF_SPACES = os.environ.get("SPACE_ID") is not None
-YOUTUBE_PROXY_URL = os.environ.get("YOUTUBE_PROXY_URL", "")
-UBUNTU_MINI_HOST = os.environ.get("UBUNTU_MINI_HOST", "ubuntu-mini.local")
-UBUNTU_MINI_PORT = int(os.environ.get("UBUNTU_MINI_PORT", "9000"))
-UBUNTU_MINI_ENABLED = os.environ.get("UBUNTU_MINI_ENABLED", "false").lower() == "true"
-
-# Rate limiting settings
-RATE_LIMIT_REQUESTS = int(os.environ.get("RATE_LIMIT_REQUESTS", "5"))  # requests per hour
-RATE_LIMIT_MINUTES = int(os.environ.get("RATE_LIMIT_MINUTES", "60"))  # time window in minutes
-BURST_LIMIT_PER_MINUTE = int(os.environ.get("BURST_LIMIT_PER_MINUTE", "2"))  # max requests per minute
-
-
-# ============================================================
-# Rate Limiter (dual-window: long-term + burst protection)
-# ============================================================
-
-class RateLimiter:
-    """Per-user rate limiting with both long-term and burst protection."""
-
-    def __init__(self, max_requests: int, window_minutes: int, burst_per_minute: int):
-        self.max_requests = max_requests
-        self.window_secs = window_minutes * 60
-        self.burst_per_minute = burst_per_minute
-        self.requests = defaultdict(list)  # long-term tracking
-        self.minute_requests = defaultdict(list)  # burst tracking
-
-    def _get_client_id(self) -> str:
-        """Get client ID from Gradio request context (IP-based)."""
-        try:
-            import gradio.context as ctx
-            request = ctx.get_request()
-            if request and hasattr(request, 'client'):
-                return str(request.client[0])  # IP address
-        except Exception:
-            pass
-        return "unknown"
-
-    def is_allowed(self, client_id: str = None) -> tuple:
-        """
-        Check if request is allowed. Returns (allowed: bool, reason: str).
-        Enforces both long-term limit (5/hour) and burst limit (2/minute).
-        """
-        if client_id is None:
-            client_id = self._get_client_id()
-
-        now = datetime.now()
-
-        # ===== Check 1: Burst limit (requests per minute) =====
-        minute_cutoff = now - timedelta(seconds=60)
-        self.minute_requests[client_id] = [
-            req_time for req_time in self.minute_requests[client_id]
-            if req_time > minute_cutoff
-        ]
-
-        if len(self.minute_requests[client_id]) >= self.burst_per_minute:
-            return False, f"Too many requests in the last minute. Please wait 60 seconds."
-
-        # ===== Check 2: Long-term limit (requests per hour) =====
-        long_cutoff = now - timedelta(seconds=self.window_secs)
-        self.requests[client_id] = [
-            req_time for req_time in self.requests[client_id]
-            if req_time > long_cutoff
-        ]
-
-        if len(self.requests[client_id]) >= self.max_requests:
-            if self.requests[client_id]:
-                reset_time = self.requests[client_id][0] + timedelta(seconds=self.window_secs)
-                reset_str = reset_time.strftime("%H:%M UTC")
-                return False, f"Hourly limit reached ({self.max_requests}). Try again at {reset_str}."
-            return False, f"Hourly limit reached. Please wait."
-
-        # Both checks passed - add request
-        self.requests[client_id].append(now)
-        self.minute_requests[client_id].append(now)
-        return True, ""
-
-    def get_remaining(self, client_id: str = None) -> dict:
-        """Get remaining requests for both limits."""
-        if client_id is None:
-            client_id = self._get_client_id()
-
-        now = datetime.now()
-
-        # Long-term
-        long_cutoff = now - timedelta(seconds=self.window_secs)
-        long_reqs = [r for r in self.requests[client_id] if r > long_cutoff]
-        long_remaining = self.max_requests - len(long_reqs)
-
-        # Burst
-        minute_cutoff = now - timedelta(seconds=60)
-        minute_reqs = [r for r in self.minute_requests[client_id] if r > minute_cutoff]
-        minute_remaining = self.burst_per_minute - len(minute_reqs)
-
-        return {
-            "hourly": long_remaining,
-            "per_minute": minute_remaining
-        }
-
-
-# Global rate limiter
-rate_limiter = RateLimiter(RATE_LIMIT_REQUESTS, RATE_LIMIT_MINUTES, BURST_LIMIT_PER_MINUTE)
-
-
-# ============================================================
-# Uncertain case collection (edge case detection)
-# ============================================================
-
-def _extract_mel_spectrogram(audio_np: np.ndarray, mono_np: np.ndarray) -> np.ndarray:
-    """Extract mel-spectrogram for uncertain cases (CNN training)."""
-    from librosa import feature
-
-    mel_spec = feature.melspectrogram(
-        y=mono_np,
-        sr=SR,
-        n_fft=2048,
-        hop_length=512,
-        n_mels=128
-    )
-    log_mel = np.log(np.clip(mel_spec, 1e-9, None))
-    return log_mel.astype(np.float32)
-
-
-def _send_uncertain_to_ubuntu_mini(
-    mel_spec: np.ndarray,
-    verdict_stats: dict,
-    duration_sec: float,
-    source: str  # "youtube" or "upload"
-) -> bool:
-    """Send uncertain case mel-spectrogram to ubuntu-mini for edge case collection."""
-    if not UBUNTU_MINI_ENABLED:
-        return False
-
-    try:
-        import requests
-
-        # 30초 미만만 수집
-        if duration_sec > 30:
-            return False
-
-        # mel-spectrogram 직렬화 (base64)
-        mel_bytes = mel_spec.tobytes()
-        mel_b64 = __import__('base64').b64encode(mel_bytes).decode('utf-8')
-
-        payload = {
-            "mel_spectrogram": mel_b64,
-            "mel_shape": mel_spec.shape,
-            "verdict_stats": verdict_stats,
-            "duration_sec": duration_sec,
-            "source": source,
-            "timestamp": time.strftime("%Y-%m-%d %H:%M:%S")
-        }
-
-        response = requests.post(
-            f"http://{UBUNTU_MINI_HOST}:{UBUNTU_MINI_PORT}/collect-uncertain",
-            json=payload,
-            timeout=5
-        )
-        return response.status_code == 200
-    except Exception as e:
-        print(f"[WARNING] Failed to send uncertain case: {e}")
-        return False
-
-
-def _send_edge_case_report(
-    verdict: str,
-    reported_verdict: str,
-    mel_spec: np.ndarray,
-    verdict_stats: dict,
-    duration_sec: float,
-    user_comment: str = ""
-) -> bool:
-    """Send edge case report (wrong verdict) to ubuntu-mini for training correction."""
-    if not UBUNTU_MINI_ENABLED:
-        return False
-
-    try:
-        import requests
-
-        # mel-spectrogram 직렬화 (base64)
-        mel_bytes = mel_spec.tobytes()
-        mel_b64 = __import__('base64').b64encode(mel_bytes).decode('utf-8')
-
-        payload = {
-            "report_type": "edge_case_correction",
-            "predicted_verdict": verdict,
-            "true_verdict": reported_verdict,
-            "mel_spectrogram": mel_b64,
-            "mel_shape": mel_spec.shape,
-            "verdict_stats": verdict_stats,
-            "duration_sec": duration_sec,
-            "user_comment": user_comment,
-            "timestamp": time.strftime("%Y-%m-%d %H:%M:%S")
-        }
-
-        response = requests.post(
-            f"http://{UBUNTU_MINI_HOST}:{UBUNTU_MINI_PORT}/report-edge-case",
-            json=payload,
-            timeout=5
-        )
-        return response.status_code == 200
-    except Exception as e:
-        print(f"[WARNING] Failed to send edge case report: {e}")
-        return False
-
-
-# Proprietary algorithms moved to core module for IP protection
-
-
-# ============================================================
-# Inference wrapper (CPU-only)
-# ============================================================
-
-def _run_e2e(wav_mono_tensor):
-    """E2E inference — ArtifactUNet ONNX (CPU)."""
-    return run_e2e_inference(wav_mono_tensor)
-
-
-# ============================================================
-# YouTube URL -> audio download (local only)
-# ============================================================
-
-def _download_youtube_audio(url: str) -> str:
-    """Download audio from YouTube URL as WAV. Returns temporary file path."""
-    if YOUTUBE_PROXY_URL:
-        import requests
-        api_key = os.environ.get("YOUTUBE_PROXY_API_KEY", "").strip()
-        if not api_key:
-            raise RuntimeError("YOUTUBE_PROXY_API_KEY not set")
-
-        response = requests.post(
-            f"{YOUTUBE_PROXY_URL}/download-youtube",
-            json={"url": url},
-            headers={"Authorization": f"Bearer {api_key}"},
-            timeout=180
-        )
-
-        if response.status_code != 200:
-            try:
-                error_msg = response.json().get('detail', response.text[:200])
-            except Exception as e:
-                error_msg = response.text[:500] if response.text else f"HTTP {response.status_code} (empty response)"
-                if not error_msg or error_msg.startswith("<"):
-                    error_msg = f"HTTP {response.status_code}: {type(e).__name__}"
-            raise RuntimeError(f"Proxy server error: {error_msg}")
-
-        if not response.content:
-            raise RuntimeError("Proxy returned empty file (no audio data)")
-
-        tmpdir = tempfile.mkdtemp(prefix="artifactnet_yt_")
-        out_path = os.path.join(tmpdir, "audio.wav")
-        with open(out_path, 'wb') as f:
-            f.write(response.content)
-        return out_path
-    else:
-        tmpdir = tempfile.mkdtemp(prefix="artifactnet_yt_")
-        out_path = os.path.join(tmpdir, "audio.wav")
-        cmd = [
-            "yt-dlp",
-            "--no-playlist",
-            "-x", "--audio-format", "wav",
-            "--audio-quality", "0",
-            "--max-filesize", "50M",
-            "-o", out_path,
-            url,
-        ]
-        result = subprocess.run(cmd, capture_output=True, text=True, timeout=120)
-        if result.returncode != 0:
-            raise RuntimeError(f"yt-dlp error: {result.stderr[:300]}")
-        for f in os.listdir(tmpdir):
-            return os.path.join(tmpdir, f)
-        raise RuntimeError("Download completed but no file found")
-
-
-def analyze_youtube(url: str):
-    """Analyze via YouTube URL (local only)."""
-    # Rate limiting check (both burst and hourly)
-    allowed, reason = rate_limiter.is_allowed()
-    if not allowed:
-        err = (
-            f"<p style='color:#ff4757;'>"
-            f"⏱️ Rate limit: {reason}<br>"
-            f"<small>Limits: {BURST_LIMIT_PER_MINUTE}/min, {RATE_LIMIT_REQUESTS}/{RATE_LIMIT_MINUTES}min</small>"
-            f"</p>"
-        )
-        return err, None, None, None, None, None, None, None, None
-
-    if not url or not url.strip():
-        return (
-            VerdictCardBuilder.build_empty_card(),
-            None, None, None, None, None, None, None, None,
-        )
-    url = url.strip()
-    try:
-        audio_path = _download_youtube_audio(url)
-    except Exception as e:
-        err = f"<p style='color:#ff4757'>Download failed: {e}</p>"
-        return err, None, None, None, None, None, None, None, None
-    return analyze_audio(audio_path)
-
-
-# ============================================================
-# Main analysis function
-# ============================================================
-
-def analyze_audio(audio_path: str):
-    """Analyze audio file -> (verdict_html, spectrogram, timeline, json_file, verdict, stats, mel_spec, duration, audio_path)."""
-    # Rate limiting check (skip if called from analyze_youtube, which already checked)
-    # Only check for direct file uploads
-    if audio_path and "artifactnet_yt_" not in audio_path:
-        allowed, reason = rate_limiter.is_allowed()
-        if not allowed:
-            err = (
-                f"<p style='color:#ff4757;'>"
-                f"⏱️ Rate limit: {reason}<br>"
-                f"<small>Limits: {BURST_LIMIT_PER_MINUTE}/min, {RATE_LIMIT_REQUESTS}/{RATE_LIMIT_MINUTES}min</small>"
-                f"</p>"
-            )
-            return err, None, None, None, None, None, None, None, None
-
-    if audio_path is None:
-        return (
-            VerdictCardBuilder.build_empty_card(),
-            None, None, None, None, None, None, None, None,
-        )
-
-    t0 = time.time()
-
-    # 1. Load audio
-    try:
-        mono_tensor, audio_np, is_stereo = load_audio_mono_tensor(audio_path)
-    except Exception as e:
-        err = f"<p style='color:#ff4757'>Error loading audio: {e}</p>"
-        return err, None, None, None, None, None, None, None, None
-
-    info = get_audio_info(audio_np, is_stereo)
-    mono_np = mono_tensor.numpy()
-
-    # 2. E2E inference (ONNX — GPU if available, else CPU)
-    chunk_probs, _ = _run_e2e(mono_tensor)
-
-    # 3. Distribution-based verdict (3-tier)
-    seg_stats = compute_stats(chunk_probs)
-    elapsed = time.time() - t0
-
-    # 4. Generate visualizations
-    verdict = classify(seg_stats)
-    verdict_html = VerdictCardBuilder.build(
-        verdict, seg_stats, is_stereo,
-        duration=info["duration"], elapsed=elapsed,
-    )
-
-    # Extract mel-spectrogram for edge case reporting
-    mel_spec = None
-    try:
-        mel_spec = _extract_mel_spectrogram(audio_np, mono_np)
-    except Exception as e:
-        print(f"[WARNING] Mel-spectrogram extraction failed: {e}")
-
-    # 4.5. Edge case collection (Uncertain cases only)
-    collected = False
-    source_type = "upload"
-    if verdict == "Uncertain" and UBUNTU_MINI_ENABLED:
-        try:
-            if mel_spec is not None:
-                source_type = "youtube" if "tmp" in audio_path and "yt" in audio_path else "upload"
-                collected = _send_uncertain_to_ubuntu_mini(
-                    mel_spec, seg_stats, info["duration"], source_type
-                )
-                if collected:
-                    # Add collection notice to verdict HTML
-                    verdict_html += (
-                        "<div style='background:#e8f5e9;padding:12px;border-radius:4px;margin-top:12px;'>"
-                        f"<p style='color:#2e7d32;font-size:12px;margin:0;'>"
-                        "✓ 이 분석 데이터(30초 미만의 스펙트로그램)는 모델 개선용으로 수집되었습니다.</p>"
-                        "</div>"
-                    )
-        except Exception as e:
-            print(f"[WARNING] Edge case collection failed: {e}")
-
-    spec_fig = plot_spectrograms(mono_np)
-    timeline_fig = plot_timeline(chunk_probs)
-
-    # 5. Save result JSON
-    filename = os.path.basename(audio_path) if audio_path else "unknown"
-    result_json = {
-        "filename": filename,
-        "verdict": verdict,
-        "duration_sec": round(info["duration"], 2),
-        "is_stereo": is_stereo,
-        "elapsed_sec": round(elapsed, 2),
-        "segment_stats": {k: round(v, 4) if isinstance(v, float) else v
-                          for k, v in seg_stats.items()},
-        "segment_probs": [round(p, 4) for p in chunk_probs],
-    }
-    json_path = os.path.join(tempfile.gettempdir(), "artifactnet_result.json")
-    with open(json_path, "w") as f:
-        json.dump(result_json, f, indent=2)
-
-    return verdict_html, spec_fig, timeline_fig, json_path, verdict, seg_stats, mel_spec, info["duration"], audio_path
-
-
-
-# ============================================================
-# Gradio UI
-# ============================================================
-
-def build_ui():
-    """Build Gradio Blocks UI."""
-    theme = create_theme()
-
-    with gr.Blocks(theme=theme, title="ArtifactNet — AI Music Forensic Detector") as demo:
-        # Hidden state variables to track current analysis
-        current_verdict = gr.State(value=None)
-        current_stats = gr.State(value=None)
-        current_mel_spec = gr.State(value=None)
-        current_duration = gr.State(value=None)
-        current_audio_path = gr.State(value=None)
-
-        # Header
-        gr.HTML(create_header(IS_HF_SPACES))
-
-        # Row 1: Input + Verdict
-        with gr.Row():
-            with gr.Column(scale=1):
-                if IS_HF_SPACES and not YOUTUBE_PROXY_URL:
-                    # HF Spaces without proxy: file upload only
-                    audio_input = gr.Audio(
-                        label="WAV / MP3 / FLAC (max 5 min)",
-                        type="filepath",
-                        sources=["upload"],
-                    )
-                    analyze_btn = gr.Button(
-                        "Analyze", variant="primary", size="lg",
-                    )
-                else:
-                    # Local or HF Spaces with proxy: file upload + YouTube URL tabs
-                    with gr.Tabs():
-                        with gr.TabItem("Upload File"):
-                            audio_input = gr.Audio(
-                                label="WAV / MP3 / FLAC (max 5 min)",
-                                type="filepath",
-                                sources=["upload"],
-                            )
-                            analyze_btn = gr.Button(
-                                "Analyze", variant="primary", size="lg",
-                            )
-                        with gr.TabItem("YouTube URL"):
-                            yt_url_input = gr.Textbox(
-                                label="YouTube URL",
-                                placeholder="https://www.youtube.com/watch?v=...",
-                            )
-                            yt_analyze_btn = gr.Button(
-                                "Download & Analyze", variant="primary", size="lg",
-                            )
-            with gr.Column(scale=1):
-                verdict_output = gr.HTML(
-                    value=VerdictCardBuilder.build_empty_card(),
-                    label="Verdict",
-                )
-
-        # Row 2: Spectrograms
-        with gr.Row():
-            spec_output = gr.Plot(label="Spectral Analysis")
-
-        # Row 3: Timeline + JSON download
-        with gr.Row():
-            timeline_output = gr.Plot(label="P(AI) Timeline")
-        with gr.Row():
-            json_output = gr.File(label="Result JSON", visible=True)
-
-        # Row 4: Edge case reporting (if ubuntu-mini enabled)
-        if UBUNTU_MINI_ENABLED:
-            with gr.Row():
-                with gr.Column():
-                    gr.Markdown("### 틀린 판정 보고하기")
-                    report_error_type = gr.Radio(
-                        choices=["맞음", "AI인데 Human이라고 함", "Human인데 AI라고 함"],
-                        value="맞음",
-                        label="판정 결과가...",
-                        info="잘못된 판정 결과를 보고해주세요. (데이터 수집용)"
-                    )
-                    report_comment = gr.Textbox(
-                        label="���가 의견 (선택사항)",
-                        placeholder="예: 매우 압축된 음악입니다. / 너무 짧은 샘플입니다.",
-                        lines=2
-                    )
-                    report_btn = gr.Button("보고하기", variant="secondary", size="md")
-                    report_status = gr.Textbox(
-                        label="상태",
-                        interactive=False,
-                        visible=False
-                    )
-
-        with gr.Accordion("About ArtifactNet", open=False):
-            gr.HTML(create_about_section())
-
-        # Event handler for edge case reporting
-        def report_edge_case_fn(error_type, comment, verdict, stats, mel_spec, duration):
-            """Submit edge case report."""
-            if not UBUNTU_MINI_ENABLED:
-                msg = "Edge case reporting is not enabled."
-                return gr.update(value=msg, visible=True)
-
-            if error_type == "맞음" or verdict is None:
-                msg = "판정 결과를 먼저 선택해주세요."
-                return gr.update(value=msg, visible=True)
-
-            if error_type not in ["AI인데 Human이라고 함", "Human인데 AI라고 함"]:
-                msg = "오류: 유효하지 않은 선택입니다."
-                return gr.update(value=msg, visible=True)
-
-            # Convert error_type to verdict
-            true_verdict = "AI Generated" if error_type == "AI인데 Human이라고 함" else "Human-Made"
-
-            try:
-                success = _send_edge_case_report(
-                    verdict=verdict,
-                    reported_verdict=true_verdict,
-                    mel_spec=mel_spec,
-                    verdict_stats=stats,
-                    duration_sec=duration,
-                    user_comment=comment
-                )
-                if success:
-                    msg = "✓ 보고가 접수되었습니다. 감사합니다!"
-                else:
-                    msg = "△ 데이터 수집 서버에 연결할 수 없습니다. 나중에 다시 시도해주세요."
-                return gr.update(value=msg, visible=True)
-            except Exception as e:
-                msg = f"△ 오류 발생: {str(e)[:100]}"
-                return gr.update(value=msg, visible=True)
-
-        # Events
-        outputs = [verdict_output, spec_output, timeline_output, json_output, current_verdict, current_stats, current_mel_spec, current_duration, current_audio_path]
-
-        analyze_btn.click(
-            fn=analyze_audio,
-            inputs=[audio_input],
-            outputs=outputs,
-            api_name=False,
-        )
-        if not IS_HF_SPACES or YOUTUBE_PROXY_URL:
-            yt_analyze_btn.click(
-                fn=analyze_youtube,
-                inputs=[yt_url_input],
-                outputs=outputs,
-                api_name=False,
-            )
-
-        # Report button event
-        if UBUNTU_MINI_ENABLED:
-            report_btn.click(
-                fn=report_edge_case_fn,
-                inputs=[report_error_type, report_comment, current_verdict, current_stats, current_mel_spec, current_duration],
-                outputs=[report_status],
-                api_name=False,
-            )
-
-    return demo
-
-
-# ============================================================
-# Entry point — module-level demo object (required for HF Spaces)
-# ============================================================
-
-print("Loading model...", flush=True)
-get_model()
-print("Model ready.", flush=True)
-
-demo = build_ui()
-
-if __name__ == "__main__":
-    launch_kwargs = dict(server_name="0.0.0.0", server_port=7860)
-    if IS_HF_SPACES:
-        launch_kwargs["root_path"] = "/ArtifactNet"
-    demo.launch(**launch_kwargs)
+#!/usr/bin/env python3
+# Purpose: ArtifactNet HF Spaces (ZeroGPU) — Gradio demo
+
+"""ArtifactNet — AI Music Forensic Detector.
+
+HF Spaces + ZeroGPU 전용 빌드.
+  - Upload-only (YouTube/URL 제거)
+  - Remote inference / residual snapshot / sqlite 로그 제거
+  - Error report 는 api.intrect.io 로 POST (옵션)
+  - AcoustID 제거 (API key 비공개 유지)
+"""
+
+import json
+import os
+import sys
+import tempfile
+import time
+import warnings
+from pathlib import Path
+
+import gradio as gr
+import numpy as np
+import requests as _requests
+import torch
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+from config import SR, CHUNK_SAMPLES, MIN_CONFIDENT_DURATION
+from inference.audio_utils import load_audio_mono_tensor, get_audio_info
+from inference.e2e_model import run_e2e_inference, load_models
+from visualization.feature_bars import plot_feature_bars
+from visualization.radar import plot_forensic_radar, forensic_features_explanation
+from visualization.spectrogram import plot_spectrograms
+from visualization.timeline import plot_timeline
+
+warnings.filterwarnings("ignore")
+
+API_BASE = os.environ.get("INTRECT_API_BASE", "https://api.intrect.io")
+
+# ============================================================
+# Upload validation
+# ============================================================
+
+_AUDIO_MAGIC = {
+    b"RIFF":     "wav",
+    b"fLaC":     "flac",
+    b"\xff\xfb": "mp3",
+    b"\xff\xf3": "mp3",
+    b"\xff\xf2": "mp3",
+    b"ID3":      "mp3",
+    b"OggS":     "ogg",
+}
+_FTYP_BRANDS = {b"M4A ", b"isom", b"mp42", b"dash", b"MSNV"}
+_MAX_UPLOAD_BYTES = 100 * 1024 * 1024
+_ALLOWED_EXTENSIONS = {".wav", ".flac", ".mp3", ".ogg", ".opus", ".m4a", ".aac", ".webm"}
+
+
+def _validate_audio_file(path: str) -> str | None:
+    if not os.path.isfile(path):
+        return "<p style='color:#ff4757'>파일을 찾을 수 없습니다.</p>"
+    file_size = os.path.getsize(path)
+    if file_size > _MAX_UPLOAD_BYTES:
+        mb = file_size / 1024 / 1024
+        return f"<p style='color:#ff4757'>파일이 너무 큽니다 ({mb:.0f}MB). 최대 100MB까지 허용됩니다.</p>"
+    if file_size < 100:
+        return "<p style='color:#ff4757'>파일이 너무 작습니다.</p>"
+
+    ext = os.path.splitext(path)[1].lower()
+    if ext not in _ALLOWED_EXTENSIONS:
+        return (f"<p style='color:#ff4757'>지원하지 않는 형식입니다 ({ext}). "
+                f"WAV, FLAC, MP3, OGG, Opus, M4A만 지원합니다.</p>")
+
+    try:
+        with open(path, "rb") as f:
+            header = f.read(12)
+    except Exception:
+        return "<p style='color:#ff4757'>파일을 읽을 수 없습니다.</p>"
+
+    detected = None
+    for magic, fmt in _AUDIO_MAGIC.items():
+        if header[:len(magic)] == magic:
+            detected = fmt
+            break
+    if detected is None and header[4:8] == b"ftyp":
+        if header[8:12] in _FTYP_BRANDS:
+            detected = "m4a"
+    if detected is None and header[:4] == b"\x1a\x45\xdf\xa3":
+        detected = "webm"
+
+    if detected is None:
+        return ("<p style='color:#ff4757'>유효한 오디오 파일이 아닙니다.</p>")
+    return None
+
+
+# ============================================================
+# Verdict stats
+# ============================================================
+_MEDIAN_THRESHOLD = 0.5
+
+
+def _compute_segment_stats(chunk_probs, chunk_metadata=None):
+    arr = np.array(chunk_probs)
+    n = len(arr)
+    q25, q50, q75 = np.percentile(arr, [25, 50, 75])
+
+    if chunk_metadata and len(chunk_metadata) == len(chunk_probs):
+        rms_arr = np.array([m.get('rms', 1.0) for m in chunk_metadata])
+        median_rms = np.median(rms_arr)
+        weights = rms_arr / (median_rms + 1e-10)
+        weights = weights / weights.sum()
+        sorted_indices = np.argsort(arr)
+        sorted_probs = arr[sorted_indices]
+        sorted_weights = weights[sorted_indices]
+        cumsum_weights = np.cumsum(sorted_weights)
+        idx = np.searchsorted(cumsum_weights, 0.5)
+        weighted_median = float(sorted_probs[min(idx, len(sorted_probs) - 1)])
+    else:
+        weighted_median = float(q50)
+
+    return {
+        "n": n,
+        "mean": float(np.mean(arr)),
+        "median": float(q50),
+        "weighted_median": weighted_median,
+        "q25": float(q25),
+        "q75": float(q75),
+        "iqr": float(q75 - q25),
+        "std": float(np.std(arr)),
+        "pct_high": float((arr >= 0.8).sum() / n) if n else 0.0,
+        "pct_above_50": float((arr >= 0.5).sum() / n) if n else 0.0,
+        "pct_low": float((arr < 0.2).sum() / n) if n else 0.0,
+        "n_high": int((arr >= 0.8).sum()),
+        "n_mid": int(((arr >= 0.5) & (arr < 0.8)).sum()),
+        "n_low": int((arr < 0.5).sum()),
+    }
+
+
+# ============================================================
+# Verdict HTML card
+# ============================================================
+
+def _verdict_html(verdict, stats, is_stereo, duration=0, elapsed=0,
+                  is_short=False, audio_format=""):
+    if verdict == "No file":
+        return """
+        <div style="text-align:center;padding:30px;background:#16213e;
+                    border-radius:12px;color:#888;">
+            <p style="font-size:16px;">Upload an audio file to begin analysis</p>
+        </div>"""
+
+    mean_prob = stats["mean"]
+    median_prob = stats["median"]
+    pct_high = stats["pct_high"]
+    n_total = stats["n"]
+
+    if verdict == "AI Generated":
+        color = "#ff4757"
+        icon = "&#9888;"
+        desc = f"{pct_high:.0%} of segments show strong AI indicators"
+    elif verdict == "Partial AI":
+        color = "#ffa502"
+        icon = "&#9888;"
+        iqr = stats.get("iqr", 0)
+        desc = f"Bimodal distribution (IQR={iqr:.2f}) — possible AI vocals over human instrumental"
+    else:
+        color = "#2ed573"
+        icon = "&#10003;"
+        desc = "No significant AI generation indicators found"
+
+    channels = "Stereo" if is_stereo else "Mono"
+    n_high, n_mid, n_low = stats["n_high"], stats["n_mid"], stats["n_low"]
+    if n_total > 0:
+        pct_h = n_high / n_total * 100
+        pct_m = n_mid / n_total * 100
+        pct_l = n_low / n_total * 100
+    else:
+        pct_h = pct_m = 0.0
+        pct_l = 100.0
+
+    short_warn = ""
+    if is_short:
+        short_warn = f"""
+        <div style="margin-top:8px;padding:8px 12px;background:rgba(255,165,2,0.15);
+                    border-radius:6px;border-left:3px solid #ffa502;font-size:12px;
+                    color:#ccc;line-height:1.5;">
+            <b style="color:#ffa502;">Short file ({duration:.0f}s):</b>
+            Files under {MIN_CONFIDENT_DURATION}s have fewer segments for analysis.
+            Use tracks longer than {MIN_CONFIDENT_DURATION}s for best results.
+        </div>"""
+
+    mono_warn = ""
+    if not is_stereo:
+        mono_warn = """
+        <div style="margin-top:8px;padding:6px 10px;background:rgba(255,165,2,0.15);
+                    border-radius:6px;border-left:3px solid #ffa502;font-size:12px;">
+            Mono input — stereo phase features unavailable.
+        </div>"""
+
+    return f"""
+    <div style="text-align:center;padding:20px;background:#16213e;
+                border-radius:12px;border:2px solid {color};">
+        <div style="font-size:14px;color:{color};letter-spacing:1px;
+                    text-transform:uppercase;font-weight:600;">
+            {icon} Verdict
+        </div>
+        <div style="font-size:32px;font-weight:bold;color:{color};
+                    letter-spacing:2px;margin:6px 0;">{verdict.upper()}</div>
+        <div style="color:#aaa;font-size:13px;margin-bottom:10px;">{desc}</div>
+        <div style="font-size:36px;font-weight:bold;color:white;margin:4px 0;">
+            median={median_prob:.1%} &nbsp;
+            <span style="font-size:18px;color:#888;">mean={mean_prob:.1%}</span>
+        </div>
+        <div style="margin:10px auto;max-width:320px;">
+            <div style="height:14px;background:#333;border-radius:7px;
+                        overflow:hidden;display:flex;">
+                <div style="width:{pct_h:.1f}%;background:#ff4757;"></div>
+                <div style="width:{pct_m:.1f}%;background:#ffa502;"></div>
+                <div style="width:{pct_l:.1f}%;background:#2ed573;"></div>
+            </div>
+            <div style="display:flex;justify-content:space-between;
+                        font-size:10px;color:#888;margin-top:2px;">
+                <span style="color:#ff4757;">{n_high} high</span>
+                <span style="color:#ffa502;">{n_mid} mid</span>
+                <span style="color:#2ed573;">{n_low} low</span>
+            </div>
+        </div>
+        <div style="color:#999;font-size:13px;margin-top:10px;">
+            {n_total} segments &nbsp;|&nbsp;
+            IQR={stats['iqr']:.2f} &nbsp;|&nbsp;
+            {channels} &nbsp;|&nbsp;
+            {duration:.1f}s &nbsp;|&nbsp;
+            {elapsed:.1f}s
+        </div>
+        <div style="display:flex;justify-content:center;gap:12px;margin-top:8px;">
+            <span style="background:#16213e;border:1px solid #333;border-radius:6px;
+                         padding:4px 10px;font-size:12px;color:#3498db;">
+                Format: <b>{audio_format}</b>
+            </span>
+        </div>
+        {short_warn}
+        {mono_warn}
+    </div>"""
+
+
+# ============================================================
+# Main analysis (Upload only)
+# ============================================================
+
+def analyze_audio(audio_path, progress=gr.Progress()):
+    if audio_path is None:
+        return (
+            _verdict_html("No file", {}, False, 0, 0, False),
+            None, None, None, None, None, None, {},
+        )
+
+    file_err = _validate_audio_file(audio_path)
+    if file_err:
+        return file_err, None, None, None, None, None, None, {}
+
+    progress(0, desc="🎵 Loading audio...")
+    t0 = time.time()
+
+    try:
+        mono_tensor, audio_np, is_stereo = load_audio_mono_tensor(audio_path)
+    except Exception as e:
+        err = f"<p style='color:#ff4757'>Error loading audio: {e}</p>"
+        return err, None, None, None, None, None, None, {}
+
+    info = get_audio_info(audio_np, is_stereo)
+    mono_np = mono_tensor.numpy()
+    duration = info["duration"]
+
+    progress(0.2, desc="🔬 Running AI forensic analysis on CPU (ONNX)...")
+    chunk_probs, _, chunk_metadata, forensic_stats, router_feat, verdict_feat = \
+        run_e2e_inference(mono_tensor)
+
+    progress(0.6, desc="📊 Computing distribution statistics...")
+    seg_stats = _compute_segment_stats(chunk_probs, chunk_metadata)
+    elapsed = time.time() - t0
+
+    progress(0.8, desc="🎨 Generating visualizations...")
+    is_short = duration < MIN_CONFIDENT_DURATION
+
+    audio_ext = os.path.splitext(audio_path)[1].lower()
+    fmt_map = {".wav": "WAV", ".flac": "FLAC", ".mp3": "MP3",
+               ".opus": "Opus", ".ogg": "OGG", ".m4a": "M4A",
+               ".aac": "AAC", ".webm": "WebM"}
+    audio_format = fmt_map.get(audio_ext, audio_ext.lstrip(".").upper() or "Unknown")
+
+    median_prob = seg_stats.get("weighted_median", seg_stats["median"])
+    verdict = "AI Generated" if median_prob >= _MEDIAN_THRESHOLD else "Human-Made"
+
+    iqr = seg_stats.get("iqr", 0)
+    n_high = seg_stats.get("n_high", 0)
+    n_low = seg_stats.get("n_low", 0)
+    n_total = seg_stats.get("n", 1)
+    if (iqr >= 0.4
+            and n_high >= max(3, n_total * 0.1)
+            and n_low >= max(3, n_total * 0.1)):
+        verdict = "Partial AI"
+
+    verdict_html = _verdict_html(
+        verdict, seg_stats, is_stereo,
+        duration=duration, elapsed=elapsed,
+        is_short=is_short, audio_format=audio_format,
+    )
+
+    spec_fig = plot_spectrograms(mono_np)
+    timeline_fig = plot_timeline(
+        chunk_probs, mono_np, chunk_metadata,
+        weighted_median=seg_stats.get("weighted_median")
+    )
+    radar_fig = plot_forensic_radar(forensic_stats)
+    bars_fig = plot_feature_bars(forensic_stats)
+    forensic_explanation = forensic_features_explanation()
+
+    filename = os.path.basename(audio_path) if audio_path else "unknown"
+    result_json = {
+        "filename": filename,
+        "verdict": verdict,
+        "is_short_file": is_short,
+        "duration_sec": round(duration, 2),
+        "is_stereo": is_stereo,
+        "elapsed_sec": round(elapsed, 2),
+        "segment_stats": {k: round(v, 4) if isinstance(v, float) else v
+                          for k, v in seg_stats.items()},
+        "segment_probs": [round(p, 4) for p in chunk_probs],
+        "format": audio_format,
+    }
+    json_path = os.path.join(tempfile.gettempdir(), "artifactnet_result.json")
+    with open(json_path, "w") as f:
+        json.dump(result_json, f, indent=2)
+
+    progress(1.0, desc="✅ Analysis complete!")
+
+    analysis_state = {
+        "filename": filename,
+        "duration": duration,
+        "is_stereo": is_stereo,
+        "elapsed": elapsed,
+        "verdict": verdict,
+        "forensic_stats": forensic_stats,
+        "seg_stats": seg_stats,
+        "chunk_probs": chunk_probs,
+        "is_short": is_short,
+        "predicted_verdict": "ai" if verdict == "AI Generated" else (
+            "real" if verdict == "Human-Made" else "unknown"
+        ),
+        "predicted_probability": round(median_prob, 6),
+    }
+    return verdict_html, spec_fig, timeline_fig, radar_fig, bars_fig, forensic_explanation, json_path, analysis_state
+
+
+# ============================================================
+# Error report → api.intrect.io
+# ============================================================
+
+def submit_error_report(analysis_state, reported_as: str, comment: str):
+    if not analysis_state or not analysis_state.get("filename"):
+        return gr.update(visible=True,
+                         value='<span style="color:#ff7675;font-size:12px;">Please analyze a file first.</span>')
+
+    meta = {
+        "filename": analysis_state.get("filename"),
+        "reported_as": (reported_as or "unsure").lower(),
+        "comment": (comment or "").strip()[:500],
+        "predicted_verdict": analysis_state.get("predicted_verdict"),
+        "predicted_probability": analysis_state.get("predicted_probability"),
+        "source_hint": "hf-space",
+    }
+    try:
+        with _requests.Session() as s:
+            r = s.post(
+                f"{API_BASE.rstrip('/')}/v1/reports",
+                data={"report": json.dumps(meta)},
+                timeout=10,
+            )
+        if r.status_code >= 300:
+            try:
+                detail = r.json().get("detail", r.text[:200])
+            except Exception:
+                detail = r.text[:200]
+            return gr.update(visible=True,
+                             value=f'<span style="color:#ff7675;font-size:12px;">Report failed: {detail}</span>')
+    except Exception as e:
+        return gr.update(visible=True,
+                         value=f'<span style="color:#ff7675;font-size:12px;">Report failed: {e}</span>')
+
+    return gr.update(
+        visible=True,
+        value='<span style="color:#2ed573;font-size:12px;">✅ Thanks! Report submitted.</span>',
+    )
+
+
+# ============================================================
+# Gradio UI
+# ============================================================
+
+def build_ui():
+    theme = gr.themes.Base(
+        primary_hue="orange",
+        secondary_hue="blue",
+        neutral_hue="slate",
+        font=gr.themes.GoogleFont("Inter"),
+    ).set(
+        body_background_fill="#0f0f23",
+        block_background_fill="#1a1a2e",
+        block_border_color="#333",
+        input_background_fill="#16213e",
+        button_primary_background_fill="#ffa502",
+        button_primary_text_color="black",
+    )
+
+    custom_css = """
+    .gradio-container { margin: 0 auto !important; }
+    footer { display: none !important; }
+    .gr-button-primary { border-radius: 8px !important; font-weight: 600 !important; }
+    .gr-input, .gr-box { border-color: #333 !important; }
+    .gr-panel { border-color: #333 !important; }
+    h1, h2, h3 { font-family: 'Inter', sans-serif !important; }
+    .demo-nav { display: flex; justify-content: space-between; align-items: center;
+      padding: 12px 20px; border-bottom: 1px solid #333; margin: -16px -16px 16px; }
+    .demo-nav a { color: #8b949e; text-decoration: none; font-size: 13px; }
+    .demo-nav a:hover { color: #ffa502; }
+    .demo-nav .brand { color: #ffa502; font-weight: 700; font-size: 16px; letter-spacing: 2px; text-transform: uppercase; }
+    """
+
+    with gr.Blocks(theme=theme, css=custom_css,
+                   title="ArtifactNet — AI Music Forensic Detector") as demo:
+        gr.HTML("""
+        <div class="demo-nav">
+            <a href="https://intrect.io" class="brand">Intrect</a>
+            <div style="display:flex;gap:20px;align-items:center;">
+                <a href="https://intrect.io">Home</a>
+                <a href="https://dash.intrect.io">Dashboard</a>
+                <a href="https://intrect.io/#pricing">Pricing</a>
+            </div>
+        </div>
+        """)
+
+        gr.HTML(f"""
+        <div style="text-align:center;padding:16px 0 8px;">
+            <h1 style="color:white;font-size:26px;margin:0;letter-spacing:-0.5px;">
+                ArtifactNet
+            </h1>
+            <p style="color:#6e7681;font-size:13px;margin:4px 0 0;">
+                AI-Generated Music Detection — ONNX Runtime CPU
+            </p>
+            <div style="margin:8px auto;max-width:540px;padding:6px 12px;background:rgba(255,165,2,0.12);
+                        border:1px solid #ffa502;border-radius:8px;font-size:12px;color:#ffa502;">
+                Running on CPU — a 4-minute track takes ~30–60 s.
+            </div>
+        </div>
+        """)
+
+        with gr.Row():
+            with gr.Column(scale=1):
+                audio_input = gr.Audio(
+                    label="WAV / MP3 / FLAC (max 100MB, 5 min)",
+                    type="filepath",
+                    sources=["upload"],
+                )
+                analyze_btn = gr.Button("Analyze", variant="primary", size="lg")
+            with gr.Column(scale=1):
+                verdict_output = gr.HTML(
+                    value=_verdict_html("No file", {}, False, 0, 0, False),
+                    label="Verdict",
+                )
+                with gr.Accordion("Think this result is wrong?", open=False):
+                    gr.HTML(
+                        """<p style="color:#aaa;font-size:12px;margin:4px 0;">
+                        Help us improve — anonymous feedback.
+                        </p>"""
+                    )
+                    report_reported_as = gr.Radio(
+                        choices=[
+                            ("It should be AI", "ai"),
+                            ("It should be Real / Human", "real"),
+                            ("Unsure / Mixed", "unsure"),
+                        ],
+                        label="What do you think it actually is?",
+                        value="ai",
+                    )
+                    report_comment = gr.Textbox(
+                        label="Optional comment (≤500 chars)",
+                        placeholder="Any context we should know?",
+                        max_lines=3,
+                        lines=2,
+                    )
+                    report_submit_btn = gr.Button("🚩 Submit report", variant="secondary", size="sm")
+                    report_status = gr.HTML(value="", visible=False)
+
+        with gr.Row():
+            spec_output = gr.Plot(label="Spectral Analysis")
+
+        with gr.Row():
+            with gr.Column(scale=2):
+                timeline_output = gr.Plot(label="P(AI) Timeline")
+            with gr.Column(scale=1):
+                radar_output = gr.Plot(label="Forensic Features")
+
+        with gr.Row():
+            bars_output = gr.Plot(label="Feature Strength Analysis")
+
+        forensic_explanation_output = gr.HTML(visible=False)
+
+        with gr.Row():
+            json_output = gr.File(label="Result JSON", visible=True)
+
+        with gr.Accordion("About ArtifactNet", open=False):
+            gr.HTML(f"""
+            <div style="color:#ccc;font-size:13px;line-height:1.6;padding:10px;">
+                <h3 style="color:white;">Overview</h3>
+                <p>ArtifactNet is a neural forensic detector for AI-generated music.
+                It uses HPSS and 7-channel forensic features to detect generation artifacts.</p>
+
+                <h3 style="color:white;">Pipeline</h3>
+                <ol>
+                    <li>STFT + U-Net artifact residual</li>
+                    <li>HPSS (harmonic-percussive separation)</li>
+                    <li>7ch features (mel, H/P ratio, temporal derivatives, spectral flux)</li>
+                    <li>CNN classifier → per-segment P(AI)</li>
+                    <li>Median aggregation across segments</li>
+                </ol>
+
+                <h3 style="color:white;">Limitations</h3>
+                <ul>
+                    <li>Short files (&lt;{MIN_CONFIDENT_DURATION}s) have lower confidence</li>
+                    <li>Mono input reduces accuracy</li>
+                    <li>Heavily processed audio may affect results</li>
+                </ul>
+                <p style="color:#888;font-size:11px;margin-top:10px;">
+                    Research project — interpret alongside other evidence. See
+                    <a href="https://api.intrect.io/legal/disclaimer" style="color:#6e7681;">Disclaimer</a>.
+                </p>
+            </div>
+            """)
+
+        analysis_state = gr.State({})
+        outputs = [verdict_output, spec_output, timeline_output,
+                   radar_output, bars_output, forensic_explanation_output,
+                   json_output, analysis_state]
+
+        analyze_btn.click(
+            fn=analyze_audio,
+            inputs=[audio_input],
+            outputs=outputs,
+            api_name=False,
+            concurrency_limit=1,
+            concurrency_id="gpu_inference",
+        )
+
+        report_submit_btn.click(
+            fn=submit_error_report,
+            inputs=[analysis_state, report_reported_as, report_comment],
+            outputs=[report_status],
+        )
+
+        gr.HTML("""
+        <div style="text-align:center;padding:24px 0 8px;border-top:1px solid #333;margin-top:24px;">
+            <p style="color:#484f58;font-size:12px;margin:0;">
+                Powered by <a href="https://intrect.io" style="color:#ffa502;text-decoration:none;">Intrect</a>
+                &nbsp;|&nbsp; <a href="https://dash.intrect.io" style="color:#6e7681;text-decoration:none;">Dashboard</a>
+                &nbsp;|&nbsp; <a href="https://intrect.io/#pricing" style="color:#6e7681;text-decoration:none;">Pricing</a>
+            </p>
+            <p style="color:#484f58;font-size:11px;margin:6px 0 0;">
+                <a href="https://api.intrect.io/legal/terms" style="color:#6e7681;text-decoration:none;">Terms</a>
+                &nbsp;&middot;&nbsp; <a href="https://api.intrect.io/legal/privacy" style="color:#6e7681;text-decoration:none;">Privacy</a>
+                &nbsp;&middot;&nbsp; <a href="https://api.intrect.io/legal/disclaimer" style="color:#6e7681;text-decoration:none;">Disclaimer</a>
+            </p>
+            <p style="color:#484f58;font-size:10px;margin:8px 0 0;font-style:italic;">
+                ArtifactNet provides forensic indicators, not conclusive legal proof.
+            </p>
+        </div>
+        """)
+
+    return demo
+
+
+# ============================================================
+# Entry point
+# ============================================================
+
+print("[hf-spaces] downloading ONNX models from HF Hub...", flush=True)
+load_models()
+print("[hf-spaces] models ready (onnxruntime CPU).", flush=True)
+
+demo = build_ui()
+demo.queue(max_size=10, default_concurrency_limit=1)
+
+
+if __name__ == "__main__":
+    demo.launch()

config.py

@@ -1,30 +1,28 @@
-# Purpose: ArtifactNet HF Spaces demo — constants and configuration
-
-"""Global constants and HF Hub model paths."""
-
-from core import get_params
-
-# ============================================================
-# HF Hub model paths
-# ============================================================
-HF_MODEL_REPO = "intrect/artifactnet-models"
-UNET_ONNX_FILENAME = "artifactnet_e2e.onnx"
-
-# ============================================================
-# Audio constants (proprietary parameters from core module)
-# ============================================================
-SR = get_params('sr')
-MAX_DURATION_SEC = get_params('max_dur')
-CHUNK_SEC = get_params('chunk_sec')
-CHUNK_SAMPLES = int(CHUNK_SEC * SR)
-
-# ============================================================
-# E2E model constants (proprietary parameters)
-# ============================================================
-N_FFT = get_params('n_fft')
-HOP_LENGTH = get_params('hop')
-
-# ============================================================
-# E2E inference batch size
-# ============================================================
-E2E_BATCH_SIZE = get_params('batch')
+# Purpose: ArtifactNet HF Spaces demo — constants (HF Hub paths)
+
+"""HF Spaces (CPU / onnxruntime) 전용 설정.
+
+가중치는 HF Hub 의 intrect/artifactnet-models 에서 .onnx 만 다운로드한다
+(.pt 는 private).
+"""
+
+# HF Hub model repo
+HF_MODEL_REPO = "intrect/artifactnet-models"
+UNET_ONNX_FILENAME = "production-onnx/unet_codec4.onnx"
+CNN_ONNX_FILENAME  = "production-onnx/cnn_v94.onnx"
+
+# Audio constants
+SR = 44100
+MAX_DURATION_SEC = 300
+CHUNK_SEC = 4.0
+CHUNK_SAMPLES = int(CHUNK_SEC * SR)
+
+# STFT
+N_FFT = 2048
+HOP_LENGTH = 512
+
+# CNN batch (CPU 에선 2 vCPU 기준 너무 크면 latency 증가)
+BATCH_SIZE = 4
+
+# 60 초 미만 파일은 "Too Short" 경고
+MIN_CONFIDENT_DURATION = 60

core/__init__.py

@@ -1,7 +0,0 @@
-# Proprietary core algorithms (IP protected)
-
-"""Core algorithms for ArtifactNet — CONFIDENTIAL."""
-
-from .proprietary import compute_stats, classify, get_params
-
-__all__ = ['compute_stats', 'classify', 'get_params']

core/proprietary.py

@@ -1,192 +0,0 @@
-# CONFIDENTIAL - ArtifactNet Proprietary Algorithms
-# Copyright (c) 2026. All rights reserved.
-# Trade secrets and proprietary algorithms.
-# Reverse engineering, decompilation, or disclosure is strictly prohibited.
-
-"""Proprietary core algorithms — IP protected with runtime decryption."""
-
-import base64
-import json
-import numpy as np
-
-# Encrypted parameters (XOR + Base64) - DO NOT MODIFY
-_ENC_P = 'AR3tX367a8ZODq4dcKFpkRJK8EYD8i6RWAW+GXKxZ9JYUcFLOvVpyFoNrhlkrWvQElDuD2ahfsNIE74PMt4mlxZMvBd8sHnKVh+8Tz31KJpYBb4VcKFpnxtHwUkp82nIWgyuHSE='
-_ENC_T = 'IQ+wFXChe9xIE74dcrZ+3loPsBxp3A=='
-
-# Key fragments (obfuscated distribution)
-_K1 = [122, 63]
-_K2 = [158, 45, 92]
-_K3 = [129, 75, 242]
-_K = _K1 + _K2 + _K3
-
-# Decryption cache (computed once)
-_cache = {}
-
-# Obfuscated constants (decoys)
-_MAGIC_A = 0x1F3D5A7B
-_MAGIC_B = 0x9C8E2F41
-
-
-def _d(s, k):
-    """Obfuscated decryption routine with anti-tampering."""
-    if s in _cache:
-        return _cache[s]
-
-    # Anti-tampering check (dummy operation)
-    if not _verify():
-        k = [x ^ 0xFF for x in k]  # Corrupt key if tampered
-
-    try:
-        # Decode base64
-        b = base64.b64decode(s.encode('utf-8'))
-        r = bytearray()
-
-        # XOR decryption with key rotation
-        for i, x in enumerate(b):
-            # Obfuscated XOR (adds dummy operations)
-            decrypted_byte = x ^ k[i % len(k)]
-            # Dummy operation (no effect)
-            if i % 17 == 0:
-                decrypted_byte = (decrypted_byte ^ 0x00) & 0xFF
-            r.append(decrypted_byte)
-
-        # Parse JSON
-        v = json.loads(r.decode('utf-8'))
-        _cache[s] = v
-        return v
-    except Exception:
-        # Fallback to prevent crashes
-        return {} if isinstance(s, str) and len(s) > 50 else []
-
-
-def get_params(key: str = None):
-    """Get proprietary parameters (encrypted at rest, decrypted at runtime)."""
-    p = _d(_ENC_P, _K)
-    if key:
-        return p.get(key)
-    return p.copy()
-
-
-def compute_stats(chunk_probs: list[float]) -> dict:
-    """Proprietary distribution statistics computation.
-
-    Algorithm obfuscated with control flow complexity and encrypted thresholds.
-    """
-    arr = np.array(chunk_probs)
-    n = len(arr)
-
-    # Handle edge case: empty array (very short audio)
-    if n == 0:
-        return {
-            "n": 0,
-            "mean": 0.5,
-            "median": 0.5,
-            "q25": 0.5,
-            "q75": 0.5,
-            "iqr": 0.0,
-            "std": 0.0,
-            "pct_high": 0.0,
-            "pct_above_50": 0.0,
-            "pct_low": 0.0,
-            "n_high": 0,
-            "n_mid": 0,
-            "n_low": 0,
-        }
-
-    # Obfuscated percentile calculation
-    q = np.percentile(arr, [25, 50, 75])
-    q25, q50, q75 = q[0], q[1], q[2]
-
-    # Decrypt thresholds (runtime decryption)
-    t = _d(_ENC_T, _K)
-
-    # Obfuscated threshold comparisons with dummy operations
-    mask_h = _h1(arr, t[0])
-    mask_m = _h2(arr, 0.5, t[0])
-    mask_l = arr < 0.5
-    mask_low = arr < t[1]
-
-    # Dummy computation (no effect, increases complexity)
-    _dummy = _calibrate_threshold(0.5, offset=0.1) if n > 5 else 0.5
-
-    # Statistical aggregation (obfuscated)
-    return {
-        "n": n,
-        "mean": float(np.nan_to_num(np.mean(arr), nan=0.5)),
-        "median": float(np.nan_to_num(q50, nan=0.5)),
-        "q25": float(np.nan_to_num(q25, nan=0.5)),
-        "q75": float(np.nan_to_num(q75, nan=0.5)),
-        "iqr": float(np.nan_to_num(q75 - q25, nan=0.0)),
-        "std": float(np.nan_to_num(np.std(arr), nan=0.0)),
-        "pct_high": float(mask_h.sum() / n) if n > 0 else 0.0,
-        "pct_above_50": float((arr >= 0.5).sum() / n) if n > 0 else 0.0,
-        "pct_low": float(mask_low.sum() / n) if n > 0 else 0.0,
-        "n_high": int(mask_h.sum()),
-        "n_mid": int(mask_m.sum()),
-        "n_low": int(mask_l.sum()),
-    }
-
-
-def classify(stats: dict) -> str:
-    """3-Tier distribution-based verdict (v8.0).
-
-    Encrypted threshold-based classification using segment distribution statistics.
-    """
-    t = _d(_ENC_T, _K)
-    ph = stats["pct_high"]
-    pa = stats["pct_above_50"]
-
-    if _verify() and (ph + pa) >= 0:
-        if ph >= t[2]:
-            return "AI Generated"
-        elif pa < t[3]:
-            return "Human-Made"
-        else:
-            return "Uncertain"
-    else:
-        return "Error"
-
-
-# Anti-tampering check (dummy function to increase complexity)
-def _verify():
-    """Integrity verification (obfuscated)."""
-    # XOR checksum (122 ^ 242 = 136)
-    return len(_K) == 8 and _K[0] ^ _K[-1] == 136
-
-
-# Dummy decoy functions (increase reverse engineering cost)
-def _calibrate_threshold(x, offset=0.0):
-    """Decoy function - not used in actual algorithm."""
-    return x + offset * 0.01
-
-
-def _normalize_distribution(arr):
-    """Decoy function - not used in actual algorithm."""
-    return (arr - arr.min()) / (arr.max() - arr.min() + 1e-10)
-
-
-def _apply_smoothing(probs, window=3):
-    """Decoy function - not used in actual algorithm."""
-    if len(probs) < window:
-        return probs
-    return [sum(probs[max(0, i - window // 2):i + window // 2 + 1]) / window
-            for i in range(len(probs))]
-
-
-# Obfuscated helpers (used internally)
-def _h1(v, t):
-    """Helper 1 (obfuscated name) - threshold comparison."""
-    return v >= t
-
-
-def _h2(v, lo, hi):
-    """Helper 2 (obfuscated name) - range check."""
-    return (v >= lo) & (v < hi)
-
-
-# Memory protection: clear key fragments on module unload (Python limitation)
-def _cleanup():
-    """Clear sensitive data from memory (best effort)."""
-    global _K, _K1, _K2, _K3, _cache
-    _cache.clear()
-    # Note: Python doesn't guarantee memory erasure

docker-compose.youtube-proxy.yml

@@ -1,36 +0,0 @@
-version: '3.9'
-
-services:
-  youtube-proxy:
-    build:
-      context: .
-      dockerfile: Dockerfile.youtube-proxy
-    image: artifactnet-youtube-proxy:latest
-    container_name: artifactnet-youtube-proxy
-    restart: unless-stopped
-    environment:
-      - HOST=0.0.0.0
-      - PORT=8765
-      - LOG_LEVEL=INFO
-      - YOUTUBE_PROXY_API_KEY=${YOUTUBE_PROXY_API_KEY:-c60ba3dc9f26cfc700958983f82b997eac084743aad9f5be4db7bb625ae6dbbd}
-    ports:
-      - "0.0.0.0:8765:8765"  # Accessible to cloudflared tunnel
-    healthcheck:
-      test: ["CMD", "python", "-c", "import requests; requests.get('http://localhost:8765/health')"]
-      interval: 30s
-      timeout: 10s
-      retries: 3
-      start_period: 5s
-    networks:
-      - default
-    security_opt:
-      - no-new-privileges:true
-    cap_drop:
-      - ALL
-    cap_add:
-      - NET_BIND_SERVICE
-
-networks:
-  default:
-    name: artifactnet-network
-    driver: bridge

inference/audio_utils.py

@@ -1,54 +1,140 @@
-import math
-import numpy as np
-import soundfile as sf
-import torch
-from scipy import signal
-from config import SR, MAX_DURATION_SEC, CHUNK_SAMPLES
-
-
-def load_audio(path: str) -> tuple[np.ndarray, bool]:
-    audio, sr = sf.read(str(path), dtype="float32", always_2d=True)
-    if sr != SR:
-        from scipy.signal import resample_poly
-        gcd = math.gcd(sr, SR)
-        up, down = SR // gcd, sr // gcd
-        if up > 100 or down > 100:
-            n_out = int(len(audio) * SR / sr)
-            audio = signal.resample(audio, n_out)
-        else:
-            audio = resample_poly(audio, up, down, axis=0)
-    max_samples = MAX_DURATION_SEC * SR
-    if len(audio) > max_samples:
-        audio = audio[:max_samples]
-    is_stereo = audio.shape[1] >= 2
-    return audio.astype(np.float32), is_stereo
-
-
-def load_audio_mono_tensor(path: str) -> tuple[torch.Tensor, np.ndarray, bool]:
-    audio, is_stereo = load_audio(path)
-    if is_stereo:
-        mono = (audio[:, 0] + audio[:, 1]) / 2.0
-    else:
-        mono = audio[:, 0]
-    mono_tensor = torch.from_numpy(mono)
-    return mono_tensor, audio, is_stereo
-
-
-def chunk_waveform(wav: torch.Tensor, chunk_size: int = CHUNK_SAMPLES) -> list[torch.Tensor]:
-    chunks = []
-    for start in range(0, len(wav), chunk_size):
-        c = wav[start:start + chunk_size]
-        if c.shape[0] < chunk_size:
-            c = torch.nn.functional.pad(c, (0, chunk_size - c.shape[0]))
-        chunks.append(c)
-    return chunks
-
-
-def get_audio_info(audio: np.ndarray, is_stereo: bool) -> dict:
-    duration = len(audio) / SR
-    return {
-        "duration": duration,
-        "sr": SR,
-        "channels": "Stereo" if is_stereo else "Mono",
-        "samples": len(audio),
-    }
+# Purpose: Audio load/resample/sliding-chunk utilities for HF Spaces
+# Dependencies: soundfile, torch, numpy
+
+"""HF Space 전용 — demo/ 나 vendor/ 의존성 없음.
+
+- load_audio: soundfile 우선, 실패시 ffmpeg WAV 변환 fallback
+- sliding_chunks: production infer.py::_sliding_chunks 와 동일한 규칙
+  · stride=CHUNK_SAMPLES (4s)
+  · 꼬리 chunk 는 actual_ratio >= 0.5 일 때만 유지
+  · 최소 1 chunk 보장 (짧은 곡도 padding)
+"""
+
+from __future__ import annotations
+
+import subprocess
+import tempfile
+from pathlib import Path
+
+import numpy as np
+import soundfile as sf
+import torch
+import torch.nn.functional as F
+
+from config import SR, MAX_DURATION_SEC, CHUNK_SAMPLES
+
+_NEEDS_FFMPEG = {".m4a", ".aac", ".wma", ".opus", ".mp4", ".webm"}
+
+
+def _ffmpeg_to_wav(path: str) -> str | None:
+    tmp = tempfile.mktemp(suffix=".wav")
+    try:
+        r = subprocess.run(
+            ["ffmpeg", "-hide_banner", "-loglevel", "error",
+             "-i", str(path), "-f", "wav", "-acodec", "pcm_f32le",
+             "-ac", "2", "-ar", str(SR), "-t", str(MAX_DURATION_SEC),
+             "-y", tmp],
+            capture_output=True, timeout=30,
+        )
+        return tmp if r.returncode == 0 else None
+    except Exception:
+        return None
+
+
+def load_audio(path: str) -> tuple[np.ndarray, bool]:
+    """Return (audio[samples, channels] float32, is_stereo)."""
+    ext = Path(path).suffix.lower()
+    converted = None
+    if ext in _NEEDS_FFMPEG:
+        converted = _ffmpeg_to_wav(path)
+        if converted is None:
+            raise RuntimeError(f"Failed to convert {ext} via ffmpeg")
+        path = converted
+
+    try:
+        audio, sr = sf.read(str(path), dtype="float32", always_2d=True)
+
+        if sr != SR:
+            try:
+                import torchaudio
+                t = torch.from_numpy(audio.T)
+                resampler = torchaudio.transforms.Resample(sr, SR)
+                audio = resampler(t).T.numpy()
+            except Exception:
+                # scipy fallback (linear) — 품질 낮지만 crash 방지
+                from scipy.signal import resample_poly
+                up, down = SR, sr
+                audio = np.stack([
+                    resample_poly(audio[:, c], up, down)
+                    for c in range(audio.shape[1])
+                ], axis=1).astype(np.float32)
+
+        max_samples = MAX_DURATION_SEC * SR
+        if len(audio) > max_samples:
+            audio = audio[:max_samples]
+
+        is_stereo = audio.shape[1] >= 2
+        return audio.astype(np.float32), is_stereo
+    finally:
+        if converted:
+            Path(converted).unlink(missing_ok=True)
+
+
+def load_audio_mono_tensor(path: str) -> tuple[torch.Tensor, np.ndarray, bool]:
+    audio, is_stereo = load_audio(path)
+    if is_stereo and audio.shape[1] >= 2:
+        mono = (audio[:, 0] + audio[:, 1]) / 2.0
+    else:
+        mono = audio[:, 0]
+    return torch.from_numpy(mono), audio, is_stereo
+
+
+def sliding_chunks(wav: torch.Tensor, chunk_size: int = CHUNK_SAMPLES,
+                   min_actual_ratio: float = 0.5) -> list[tuple[torch.Tensor, dict]]:
+    """production 과 동일 규칙으로 곡 전체를 4s stride 로 sliding.
+
+    ���환: [(chunk_tensor, metadata), ...] — metadata = start_sample, actual_samples, actual_ratio, rms
+    """
+    n = wav.shape[0]
+    chunks: list[tuple[torch.Tensor, dict]] = []
+    if n < chunk_size // 2:
+        # 2초 미만 — 빈 결과 (호출측에서 "Too Short" 처리)
+        return chunks
+
+    for start in range(0, n, chunk_size):
+        c = wav[start:start + chunk_size]
+        actual = c.shape[0]
+        actual_ratio = actual / chunk_size
+        if actual_ratio < min_actual_ratio:
+            continue
+        if actual < chunk_size:
+            c = F.pad(c, (0, chunk_size - actual))
+        rms = float(torch.sqrt(torch.mean(c ** 2)))
+        chunks.append((c, {
+            "start_sample": int(start),
+            "actual_samples": int(actual),
+            "actual_ratio": float(actual_ratio),
+            "rms": rms,
+        }))
+
+    if not chunks:
+        # 2~4 초 곡 — 1 chunk 는 padding 해서 보장
+        c = wav[:chunk_size]
+        c = F.pad(c, (0, chunk_size - c.shape[0]))
+        chunks.append((c, {
+            "start_sample": 0,
+            "actual_samples": int(n),
+            "actual_ratio": float(n / chunk_size),
+            "rms": float(torch.sqrt(torch.mean(c ** 2))),
+        }))
+    return chunks
+
+
+def get_audio_info(audio: np.ndarray, is_stereo: bool) -> dict:
+    duration = len(audio) / SR
+    return {
+        "duration": duration,
+        "sr": SR,
+        "channels": "Stereo" if is_stereo else "Mono",
+        "samples": len(audio),
+    }

inference/e2e_model.py

@@ -1,49 +1,293 @@
-from pathlib import Path
-import numpy as np
-import torch
-from huggingface_hub import hf_hub_download
-from config import (
-    HF_MODEL_REPO, UNET_ONNX_FILENAME,
-    SR, N_FFT, HOP_LENGTH, CHUNK_SAMPLES, E2E_BATCH_SIZE,
-)
-from inference.audio_utils import chunk_waveform
-
-_onnx_session = None
-_stft_window = None
-
-
-def get_model():
-    global _onnx_session, _stft_window
-    if _onnx_session is not None:
-        return _onnx_session
-    import onnxruntime as ort
-    local_onnx = (Path(__file__).resolve().parent.parent
-                  / "models" / UNET_ONNX_FILENAME)
-    if local_onnx.exists():
-        onnx_path = str(local_onnx)
-    else:
-        onnx_path = hf_hub_download(HF_MODEL_REPO, UNET_ONNX_FILENAME)
-    available = ort.get_available_providers()
-    providers = [p for p in ['CUDAExecutionProvider', 'CPUExecutionProvider']
-                 if p in available]
-    _onnx_session = ort.InferenceSession(onnx_path, providers=providers)
-    _stft_window = torch.hann_window(N_FFT)
-    print(f"  ONNX loaded: {onnx_path} ({providers[0]})")
-    return _onnx_session
-
-
-def run_e2e_inference(wav_mono_tensor: torch.Tensor) -> tuple[list[float], torch.Tensor]:
-    session = get_model()
-    chunks = chunk_waveform(wav_mono_tensor, CHUNK_SAMPLES)
-    probs = []
-    for i in range(0, len(chunks), E2E_BATCH_SIZE):
-        batch = torch.stack(chunks[i:i + E2E_BATCH_SIZE])
-        stft = torch.stft(batch, N_FFT, HOP_LENGTH,
-                          window=_stft_window, return_complex=True)
-        stft_mag = stft.abs().unsqueeze(1).numpy()
-        for j in range(stft_mag.shape[0]):
-            logit = session.run(None, {"stft_mag": stft_mag[j:j + 1]})[0]
-            prob = float(1.0 / (1.0 + np.exp(-logit[0])))
-            probs.append(prob)
-    residual_placeholder = torch.zeros_like(wav_mono_tensor)
-    return probs, residual_placeholder
+# Purpose: ArtifactNet 7ch inference pipeline — HF Spaces (CPU, ONNX Runtime)
+# Dependencies: onnxruntime, torch (HPSS/Mel only), huggingface_hub, scipy
+
+"""ArtifactNet v9.4 inference — onnxruntime CPU.
+
+UNet + CNN 은 .onnx (public-safe) 로 실행, HPSS + Mel + 7ch feature 는
+pytorch CPU 로 처리 (가중치 없는 고정 연산이라 노출 위험 없음).
+"""
+
+import os
+from pathlib import Path
+
+import numpy as np
+import onnxruntime as ort
+import torch
+from huggingface_hub import hf_hub_download
+from scipy import stats as sp_stats
+
+from config import (
+    HF_MODEL_REPO, UNET_ONNX_FILENAME, CNN_ONNX_FILENAME,
+    SR, N_FFT, HOP_LENGTH, CHUNK_SAMPLES, BATCH_SIZE,
+)
+from .audio_utils import sliding_chunks
+from .model import (
+    DifferentiableMel, hpss_gpu_pure, compute_forensic_features_7ch,
+)
+
+N_MELS = 128
+
+FREQ_BANDS = [
+    ("sub",    0,     250),
+    ("low",    250,   2000),
+    ("mid",    2000,  6000),
+    ("hi_mid", 6000,  10000),
+    ("hi",     10000, 16000),
+    ("air",    16000, 22050),
+]
+
+
+# ============================================================
+# Lazy singletons
+# ============================================================
+
+_unet_sess: ort.InferenceSession | None = None
+_cnn_sess:  ort.InferenceSession | None = None
+_mel: DifferentiableMel | None = None
+_stft_window: torch.Tensor | None = None
+
+
+def _ort_threads() -> int:
+    """HF Spaces CPU basic = 2 vCPU. 환경변수로 override 가능."""
+    try:
+        return int(os.environ.get("ORT_THREADS", "2"))
+    except ValueError:
+        return 2
+
+
+def _resolve_onnx(filename: str, env_var: str) -> str:
+    """로컬 override (ARTIFACTNET_UNET_ONNX / _CNN_ONNX) 있으면 그걸 사용, 아니면 HF Hub."""
+    local = os.environ.get(env_var)
+    if local and Path(local).is_file():
+        return local
+    return hf_hub_download(HF_MODEL_REPO, filename)
+
+
+def load_models():
+    """ONNX 세션 + Mel/Window 초기화 (import 후 1회)."""
+    global _unet_sess, _cnn_sess, _mel, _stft_window
+    if _unet_sess is not None:
+        return
+
+    unet_path = _resolve_onnx(UNET_ONNX_FILENAME, "ARTIFACTNET_UNET_ONNX")
+    cnn_path  = _resolve_onnx(CNN_ONNX_FILENAME,  "ARTIFACTNET_CNN_ONNX")
+
+    opts = ort.SessionOptions()
+    opts.intra_op_num_threads = _ort_threads()
+    opts.inter_op_num_threads = 1
+    opts.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
+
+    _unet_sess = ort.InferenceSession(unet_path, sess_options=opts,
+                                      providers=["CPUExecutionProvider"])
+    _cnn_sess  = ort.InferenceSession(cnn_path,  sess_options=opts,
+                                      providers=["CPUExecutionProvider"])
+
+    _mel = DifferentiableMel(sr=SR, n_fft=N_FFT, n_mels=N_MELS)
+    _mel.eval()
+    _stft_window = torch.hann_window(N_FFT)
+
+    print(f"[hf-spaces] ONNX sessions ready (intra_threads={_ort_threads()})", flush=True)
+
+
+# ============================================================
+# Feature extraction helpers (75-dim Router + 28-dim Verdict)
+# ============================================================
+
+def _extract_router_verdict_features(
+    all_mag, all_res, all_H, all_P, all_mask, all_mel_res, probs,
+):
+    """infer.py extract_features()와 동일한 로직 (device=CPU)."""
+    freq_hz = torch.linspace(0, SR / 2, all_mag.shape[2])
+    orig_total = all_mag.pow(2).mean().item() + 1e-8
+    res_total = all_res.pow(2).mean().item() + 1e-8
+
+    band_idx = []
+    for _, flo, fhi in FREQ_BANDS:
+        lo = (freq_hz >= flo).nonzero(as_tuple=True)[0]
+        hi = (freq_hz >= fhi).nonzero(as_tuple=True)[0]
+        band_idx.append((
+            lo[0].item() if len(lo) else 0,
+            hi[0].item() if len(hi) else all_mag.shape[2],
+        ))
+
+    rf = []
+    for i0, i1 in band_idx:
+        oe = all_mag[:, :, i0:i1, :].pow(2).mean().item() / orig_total
+        re = all_res[:, :, i0:i1, :].pow(2).mean().item() / res_total
+        rf.extend([oe, re, re / (oe + 1e-8)])
+
+    mel_profile = all_mel_res.mean(dim=[0, 3]).squeeze().cpu().numpy()
+    step = N_MELS // 32
+    compressed = mel_profile[:32 * step].reshape(32, step).mean(axis=1)
+    compressed = compressed - compressed.mean()
+    norm = np.abs(compressed).max() + 1e-8
+    rf.extend((compressed / norm).tolist())
+
+    H_total = all_H.pow(2).mean().item() + 1e-8
+    P_total = all_P.pow(2).mean().item() + 1e-8
+    hp_ratio = H_total / (H_total + P_total)
+    rf.append(hp_ratio)
+
+    for i0, i1 in band_idx:
+        rf.extend([
+            all_H[:, :, i0:i1, :].pow(2).mean().item() / H_total,
+            all_P[:, :, i0:i1, :].pow(2).mean().item() / P_total,
+        ])
+
+    mask_np = all_mask.cpu().numpy().flatten()
+    rf.extend([
+        float(mask_np.mean()), float(mask_np.std()),
+        float(np.percentile(mask_np, 10)), float(np.percentile(mask_np, 25)),
+        float(np.percentile(mask_np, 75)), float(np.percentile(mask_np, 90)),
+        float(np.median(mask_np)),
+    ])
+
+    rf.extend([
+        float(probs.mean()), float(probs.std()), float(np.median(probs)),
+        float(np.percentile(probs, 10)), float(np.percentile(probs, 90)),
+    ])
+
+    router_feat = np.nan_to_num(np.array(rf, dtype=np.float32))
+
+    arr = probs.astype(np.float64)
+    n = len(arr)
+    cnn_20 = np.array([
+        n, arr.mean(), arr.std(), np.median(arr),
+        arr.min(), arr.max(), arr.max() - arr.min(),
+        np.percentile(arr, 10), np.percentile(arr, 25),
+        np.percentile(arr, 75), np.percentile(arr, 90),
+        (arr >= 0.3).mean(), (arr >= 0.5).mean(),
+        (arr >= 0.7).mean(), (arr >= 0.8).mean(), (arr >= 0.9).mean(),
+        float(sp_stats.skew(arr))          if n >= 3 else 0.0,
+        float(sp_stats.kurtosis(arr))      if n >= 3 else 0.0,
+        float(np.diff(arr).std())          if n >= 2 else 0.0,
+        float(np.abs(np.diff(arr)).max())  if n >= 2 else 0.0,
+    ], dtype=np.float32)
+
+    hf8k_i = (freq_hz >= 8000).nonzero(as_tuple=True)[0]
+    hf8k_i = hf8k_i[0].item() if len(hf8k_i) else all_mag.shape[2]
+    ai0, ai1 = band_idx[5]
+
+    res_8 = np.array([
+        all_res[:, :, hf8k_i:, :].pow(2).mean().item() / res_total,
+        all_res[:, :, ai0:ai1, :].pow(2).mean().item() / res_total,
+        all_H[:, :, ai0:ai1, :].pow(2).mean().item() / H_total,
+        all_P[:, :, ai0:ai1, :].pow(2).mean().item() / P_total,
+        float(mel_profile[-1]),
+        float(mel_profile[0]),
+        float(mask_np.mean()),
+        float(hp_ratio),
+    ], dtype=np.float32)
+
+    verdict_feat = np.nan_to_num(np.concatenate([cnn_20, res_8]))
+    return router_feat, verdict_feat
+
+
+# ============================================================
+# Inference
+# ============================================================
+
+@torch.no_grad()
+def run_e2e_inference(wav_mono_tensor: torch.Tensor):
+    """mono waveform -> (probs, placeholder, metadata, forensic_stats, router_feat, verdict_feat).
+
+    ONNX Runtime CPU + pytorch HPSS/Mel.
+    """
+    if _unet_sess is None:
+        load_models()
+
+    chunk_data = sliding_chunks(wav_mono_tensor, CHUNK_SAMPLES)
+    if not chunk_data:
+        return [], torch.zeros_like(wav_mono_tensor), [], {}, \
+               np.zeros(75, dtype=np.float32), np.zeros(28, dtype=np.float32)
+    chunks = [chunk for chunk, _ in chunk_data]
+    metadata_list = [meta for _, meta in chunk_data]
+
+    probs = []
+    all_features = []
+    all_mag_list, all_res_list, all_H_list, all_P_list = [], [], [], []
+    all_mask_list, all_mel_res_list = [], []
+
+    for i in range(0, len(chunks), BATCH_SIZE):
+        batch = torch.stack(chunks[i:i + BATCH_SIZE])  # (B, CHUNK_SAMPLES)
+
+        # STFT (torch, CPU)
+        stft = torch.stft(
+            batch, N_FFT, HOP_LENGTH,
+            window=_stft_window, return_complex=True)
+        stft_mag = stft.abs().unsqueeze(1)  # (B, 1, F, T)
+
+        # UNet mask via ONNX
+        mask_np = _unet_sess.run(
+            ["mask"],
+            {"stft_mag": stft_mag.numpy().astype(np.float32)},
+        )[0]
+        mask = torch.from_numpy(mask_np)
+        res_mag = mask * stft_mag
+
+        # HPSS — CPU median filter (unfold + median) 로 학습 분포 유지.
+        # librosa.decompose.hpss 는 결과가 달라 v9.4 CNN 오판 (CLAUDE.md 경고 참조).
+        H_mag, P_mag = hpss_gpu_pure(res_mag)
+
+        # Mel 3-band
+        mel_res = _mel(res_mag)
+        mel_H   = _mel(H_mag)
+        mel_P   = _mel(P_mag)
+
+        features_7ch = compute_forensic_features_7ch(mel_res, mel_H, mel_P)
+        all_features.append(features_7ch)
+
+        # CNN logit via ONNX → sigmoid
+        logits = _cnn_sess.run(
+            ["logit"],
+            {"features_7ch": features_7ch.numpy().astype(np.float32)},
+        )[0]
+        batch_probs = (1.0 / (1.0 + np.exp(-np.clip(logits, -30, 30)))).tolist()
+        probs.extend(batch_probs)
+
+        all_mag_list.append(stft_mag)
+        all_res_list.append(res_mag)
+        all_H_list.append(H_mag)
+        all_P_list.append(P_mag)
+        all_mask_list.append(mask)
+        all_mel_res_list.append(mel_res)
+
+    if all_features:
+        all_feat_tensor = torch.cat(all_features, dim=0)
+        channel_means = all_feat_tensor.mean(dim=[2, 3])
+        feature_medians = channel_means.median(dim=0).values
+        feat_min = channel_means.min(dim=0).values
+        feat_max = channel_means.max(dim=0).values
+        feat_range = feat_max - feat_min + 1e-8
+        normalized = ((feature_medians - feat_min) / feat_range).clamp(0, 1)
+
+        forensic_stats = {
+            "residual_energy":     float(normalized[0]),
+            "harmonic_strength":   float(normalized[1]),
+            "percussive_strength": float(normalized[2]),
+            "temporal_delta":      float(normalized[3]),
+            "temporal_accel":      float(normalized[4]),
+            "hp_ratio":            float(normalized[5]),
+            "spectral_flux":       float(normalized[6]),
+        }
+    else:
+        forensic_stats = {}
+
+    probs_arr = np.array(probs, dtype=np.float32)
+    if all_mag_list:
+        all_mag = torch.cat(all_mag_list, dim=0)
+        all_res = torch.cat(all_res_list, dim=0)
+        all_H   = torch.cat(all_H_list,   dim=0)
+        all_P   = torch.cat(all_P_list,   dim=0)
+        all_mask = torch.cat(all_mask_list, dim=0)
+        all_mel_res = torch.cat(all_mel_res_list, dim=0)
+
+        router_feat, verdict_feat = _extract_router_verdict_features(
+            all_mag, all_res, all_H, all_P, all_mask, all_mel_res, probs_arr,
+        )
+    else:
+        router_feat = np.zeros(75, dtype=np.float32)
+        verdict_feat = np.zeros(28, dtype=np.float32)
+
+    residual_placeholder = torch.zeros_like(wav_mono_tensor)
+    return probs, residual_placeholder, metadata_list, forensic_stats, router_feat, verdict_feat

inference/model.py

@@ -0,0 +1,398 @@
+# Created: 2026-03-03
+# Purpose: ArtifactNet 7ch Forensic CNN 아키텍처 (PyTorch)
+# Dependencies: torch, numpy
+
+"""ArtifactNet model architecture — ArtifactUNet + 7ch Forensic CNN.
+
+v9.0: PyTorch 7ch pipeline (replaces ONNX v8.0).
+GPU required for HPSS median filtering.
+"""
+
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+SR = 44100
+N_FFT = 2048
+HOP_LENGTH = 512
+N_MELS = 128
+FREQ_BINS = N_FFT // 2 + 1  # 1025
+
+
+# ============================================================
+# GatedResidualBlock
+# ============================================================
+
+class GatedResidualBlock(nn.Module):
+    """GLU bottleneck with dilated convolution."""
+
+    def __init__(self, channels, dilation=1):
+        super().__init__()
+        mid = channels // 2
+        self.proj_in = nn.Conv2d(channels, mid, 1)
+        self.conv = nn.Conv2d(
+            mid, mid * 2, 3,
+            dilation=dilation, padding=dilation)
+        self.bn = nn.BatchNorm2d(mid * 2)
+        self.proj_out = nn.Conv2d(mid, channels, 1)
+
+    def forward(self, x):
+        h = F.relu(self.proj_in(x))
+        h = self.bn(self.conv(h))
+        a, b = h.chunk(2, dim=1)
+        return x + self.proj_out(torch.tanh(a) * torch.sigmoid(b))
+
+
+# ============================================================
+# ConvBlock
+# ============================================================
+
+class ConvBlock(nn.Module):
+    def __init__(self, in_ch, out_ch):
+        super().__init__()
+        self.block = nn.Sequential(
+            nn.Conv2d(in_ch, out_ch, 3, padding=1),
+            nn.BatchNorm2d(out_ch),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(out_ch, out_ch, 3, padding=1),
+            nn.BatchNorm2d(out_ch),
+            nn.ReLU(inplace=True),
+        )
+
+    def forward(self, x):
+        return self.block(x)
+
+
+# ============================================================
+# ArtifactUNet
+# ============================================================
+
+class ArtifactUNet(nn.Module):
+    """STFT magnitude masking U-Net. mask in [0, 0.5]."""
+
+    def __init__(self, base_channels=32, mask_max=0.5):
+        super().__init__()
+        c = base_channels
+        self.mask_max = mask_max
+
+        self.enc1 = ConvBlock(1, c)
+        self.pool1 = nn.MaxPool2d(2, 2)
+        self.enc2 = ConvBlock(c, c * 2)
+        self.pool2 = nn.MaxPool2d(2, 2)
+        self.enc3 = ConvBlock(c * 2, c * 4)
+        self.pool3 = nn.MaxPool2d(2, 2)
+        self.enc4 = ConvBlock(c * 4, c * 8)
+        self.pool4 = nn.MaxPool2d(2, 2)
+
+        self.bottleneck = nn.Sequential(
+            GatedResidualBlock(c * 8, dilation=1),
+            GatedResidualBlock(c * 8, dilation=2),
+            GatedResidualBlock(c * 8, dilation=4),
+        )
+
+        self.up4 = nn.ConvTranspose2d(c * 8, c * 8, 2, stride=2)
+        self.dec4 = ConvBlock(c * 16, c * 4)
+        self.up3 = nn.ConvTranspose2d(c * 4, c * 4, 2, stride=2)
+        self.dec3 = ConvBlock(c * 8, c * 2)
+        self.up2 = nn.ConvTranspose2d(c * 2, c * 2, 2, stride=2)
+        self.dec2 = ConvBlock(c * 4, c)
+        self.up1 = nn.ConvTranspose2d(c, c, 2, stride=2)
+        self.dec1 = ConvBlock(c * 2, c)
+
+        self.mask_head = nn.Conv2d(c, 1, 1)
+
+    def forward(self, x):
+        orig_f, orig_t = x.shape[2], x.shape[3]
+        pad_f = (16 - orig_f % 16) % 16
+        pad_t = (16 - orig_t % 16) % 16
+        if pad_f > 0 or pad_t > 0:
+            x = F.pad(x, (0, pad_t, 0, pad_f))
+
+        e1 = self.enc1(x)
+        e2 = self.enc2(self.pool1(e1))
+        e3 = self.enc3(self.pool2(e2))
+        e4 = self.enc4(self.pool3(e3))
+        b = self.bottleneck(self.pool4(e4))
+
+        d4 = self._skip_cat(self.up4(b), e4)
+        d4 = self.dec4(d4)
+        d3 = self._skip_cat(self.up3(d4), e3)
+        d3 = self.dec3(d3)
+        d2 = self._skip_cat(self.up2(d3), e2)
+        d2 = self.dec2(d2)
+        d1 = self._skip_cat(self.up1(d2), e1)
+        d1 = self.dec1(d1)
+
+        mask = torch.sigmoid(self.mask_head(d1)) * self.mask_max
+        return mask[:, :, :orig_f, :orig_t]
+
+    @staticmethod
+    def _skip_cat(up, skip):
+        df = skip.shape[2] - up.shape[2]
+        dt = skip.shape[3] - up.shape[3]
+        if df > 0 or dt > 0:
+            up = F.pad(up, (0, max(dt, 0), 0, max(df, 0)))
+        elif df < 0 or dt < 0:
+            up = up[:, :, :skip.shape[2], :skip.shape[3]]
+        return torch.cat([up, skip], dim=1)
+
+
+# ============================================================
+# ResidualCNNNch (7-channel forensic CNN)
+# ============================================================
+
+class ResidualCNNNch(nn.Module):
+    """N-channel forensic CNN. Conv-BN-ReLU-Pool structure."""
+
+    def __init__(self, in_channels=7):
+        super().__init__()
+        self.in_channels = in_channels
+        self.features = nn.Sequential(
+            nn.Conv2d(in_channels, 32, 3, padding=1),
+            nn.BatchNorm2d(32),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(2, 2),
+            nn.Conv2d(32, 64, 3, padding=1),
+            nn.BatchNorm2d(64),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(2, 2),
+            nn.Conv2d(64, 128, 3, padding=1),
+            nn.BatchNorm2d(128),
+            nn.ReLU(inplace=True),
+            nn.AdaptiveAvgPool2d((4, 4)),
+        )
+        self.classifier = nn.Sequential(
+            nn.Dropout(0.5),
+            nn.Linear(128 * 4 * 4, 256),
+            nn.ReLU(inplace=True),
+            nn.Dropout(0.3),
+            nn.Linear(256, 1),
+        )
+
+    def forward(self, x):
+        x = self.features(x)
+        x = x.view(x.size(0), -1)
+        x = self.classifier(x)
+        return x.squeeze(-1)
+
+
+class ResidualCNN7ch(nn.Module):
+    """7-channel CNN for v9.x SOTA pipeline.
+    4-layer Conv + GlobalAvgPool + FC. ResidualCNNNch(3-conv)보다 깊음.
+    가중치: models/cnn_v94_best.pt (v9.4 SOTA, balanced dataset)"""
+
+    def __init__(self):
+        super().__init__()
+        self.conv1 = nn.Conv2d(7, 32, 3, padding=1);   self.bn1 = nn.BatchNorm2d(32);   self.pool1 = nn.MaxPool2d(2)
+        self.conv2 = nn.Conv2d(32, 64, 3, padding=1);  self.bn2 = nn.BatchNorm2d(64);   self.pool2 = nn.MaxPool2d(2)
+        self.conv3 = nn.Conv2d(64, 128, 3, padding=1); self.bn3 = nn.BatchNorm2d(128);  self.pool3 = nn.MaxPool2d(2)
+        self.conv4 = nn.Conv2d(128, 256, 3, padding=1);self.bn4 = nn.BatchNorm2d(256);  self.pool4 = nn.MaxPool2d(2)
+        self.global_pool = nn.AdaptiveAvgPool2d(1)
+        self.fc1 = nn.Linear(256, 128)
+        self.dropout = nn.Dropout(0.5)
+        self.fc2 = nn.Linear(128, 1)
+
+    def forward(self, x):
+        """x: (B, 7, N_MELS, T) → (B,) logits"""
+        x = self.pool1(F.relu(self.bn1(self.conv1(x))))
+        x = self.pool2(F.relu(self.bn2(self.conv2(x))))
+        x = self.pool3(F.relu(self.bn3(self.conv3(x))))
+        x = self.pool4(F.relu(self.bn4(self.conv4(x))))
+        x = self.global_pool(x).view(x.size(0), -1)
+        return self.fc2(F.relu(self.fc1(x))).view(-1)
+
+
+# ============================================================
+# DifferentiableMel
+# ============================================================
+
+class DifferentiableMel(nn.Module):
+    """STFT magnitude -> log-mel dB (normalized)."""
+
+    def __init__(self, sr=44100, n_fft=2048, n_mels=128, top_db=80.0):
+        super().__init__()
+        n_freqs = n_fft // 2 + 1
+        fb = self._create_mel_fb(n_freqs, n_mels, 0.0, sr / 2, sr)
+        self.register_buffer('fb', fb)
+        self.top_db = top_db
+
+    @staticmethod
+    def _create_mel_fb(n_freqs, n_mels, f_min, f_max, sr):
+        def hz_to_mel(f):
+            return 2595.0 * np.log10(1.0 + f / 700.0)
+
+        def mel_to_hz(m):
+            return 700.0 * (10.0 ** (m / 2595.0) - 1.0)
+
+        mel_min = hz_to_mel(f_min)
+        mel_max = hz_to_mel(f_max)
+        mel_pts = np.linspace(mel_min, mel_max, n_mels + 2)
+        hz_pts = mel_to_hz(mel_pts)
+        freqs = np.linspace(0, sr / 2, n_freqs)
+
+        fb = np.zeros((n_freqs, n_mels), dtype=np.float32)
+        for i in range(n_mels):
+            lo, mid, hi = hz_pts[i], hz_pts[i + 1], hz_pts[i + 2]
+            for j in range(n_freqs):
+                if lo <= freqs[j] <= mid and (mid - lo) > 0:
+                    fb[j, i] = (freqs[j] - lo) / (mid - lo)
+                elif mid < freqs[j] <= hi and (hi - mid) > 0:
+                    fb[j, i] = (hi - freqs[j]) / (hi - mid)
+        return torch.from_numpy(fb)
+
+    def forward(self, stft_mag):
+        """(B, 1, F, T) -> (B, 1, N_MELS, T) log-mel normalized."""
+        x = stft_mag.squeeze(1)
+        power = x ** 2
+        mel = torch.einsum('fm,bft->bmt', self.fb, power)
+        mel_db = 10.0 * torch.log10(torch.clamp(mel, min=1e-10))
+        max_val = mel_db.amax(dim=(-2, -1), keepdim=True)
+        mel_db = torch.clamp(mel_db, min=max_val - self.top_db)
+        mean = mel_db.mean(dim=(-2, -1), keepdim=True)
+        std = mel_db.std(dim=(-2, -1), keepdim=True)
+        mel_norm = (mel_db - mean) / (std + 1e-9)
+        return mel_norm.unsqueeze(1)
+
+
+# ============================================================
+# CPU HPSS (librosa)
+# ============================================================
+
+def hpss_cpu(mag):
+    """HPSS via librosa on CPU. mag: (B, 1, F, T) tensor -> H_mag, P_mag tensors.
+
+    각 배치를 numpy로 변환 → librosa.decompose.hpss → 다시 tensor.
+    데모용 CPU 파이프라인. 학습용 GPU HPSS는 train_nch_cnn_020303.py 참조.
+    """
+    import librosa
+
+    device = mag.device
+    B = mag.shape[0]
+    mag_np = mag.squeeze(1).cpu().numpy()  # (B, F, T)
+
+    H_list, P_list = [], []
+    for i in range(B):
+        H, P = librosa.decompose.hpss(mag_np[i], kernel_size=31)
+        H_list.append(H)
+        P_list.append(P)
+
+    H_mag = torch.from_numpy(np.stack(H_list)).unsqueeze(1).to(device)  # (B, 1, F, T)
+    P_mag = torch.from_numpy(np.stack(P_list)).unsqueeze(1).to(device)
+    return H_mag, P_mag
+
+
+# ============================================================
+# GPU/MPS HPSS (순수 PyTorch — unfold + median, Triton 불필요)
+# ============================================================
+
+def _gpu_median_filter_2d(x, kernel_size, dim):
+    """GPU median filter along one axis using unfold + median.
+
+    CUDA에서 빠름. MPS에서는 median이 극도로 느리므로 _avg_filter_2d 사용 권장.
+
+    Args:
+        x: (B, F, T) tensor on GPU
+        kernel_size: odd integer
+        dim: 1=freq축 (P 추출), 2=time축 (H 추출)
+    """
+    pad = kernel_size // 2
+    if dim == 2:
+        x_pad = F.pad(x, (pad, pad), mode='reflect')
+        x_unfold = x_pad.unfold(2, kernel_size, 1)
+    else:
+        x_pad = F.pad(x, (0, 0, pad, pad), mode='reflect')
+        x_unfold = x_pad.unfold(1, kernel_size, 1)
+    return x_unfold.median(dim=-1).values
+
+
+def _avg_filter_2d(x, kernel_size, dim):
+    """avg_pool 기반 smoothing filter — MPS 최적화 (median 대비 400x 빠름).
+
+    median과 동일하지 않지만, HPSS Wiener masking에서 충분한 근사.
+    H/P 비율 계산에서 절대값보다 상대적 크기가 중요하므로 성능 차이 미미.
+
+    Args:
+        x: (B, F, T) tensor
+        kernel_size: odd integer
+        dim: 1=freq축, 2=time축
+    """
+    pad = kernel_size // 2
+    B, F_dim, T = x.shape
+    if dim == 2:  # time축
+        x_flat = x.reshape(B * F_dim, 1, T)
+        out = F.avg_pool1d(x_flat, kernel_size=kernel_size, stride=1, padding=pad)
+        return out.reshape(B, F_dim, T)
+    else:  # freq축
+        x_t = x.transpose(1, 2)  # (B, T, F)
+        x_flat = x_t.reshape(B * T, 1, F_dim)
+        out = F.avg_pool1d(x_flat, kernel_size=kernel_size, stride=1, padding=pad)
+        return out.reshape(B, T, F_dim).transpose(1, 2)
+
+
+def hpss_gpu_pure(mag, h_kernel=31, p_kernel=31):
+    """순수 PyTorch HPSS — CUDA/MPS 모두 호환.
+
+    CUDA: unfold + median (정확), MPS: avg_pool 근사 (400x 빠름).
+
+    Args:
+        mag: (B, 1, F, T) STFT magnitude on any device
+    Returns:
+        H_mag, P_mag: (B, 1, F, T)
+    """
+    mag_sq = mag.squeeze(1)  # (B, F, T)
+
+    # 모든 CNN이 median filter HPSS로 학습됨 → avg_pool 근사 사용 금지
+    # MPS에서 unfold().median()이 극도로 느림 (13초/곡) → CPU에서 수행 후 복귀
+    if mag_sq.device.type == 'mps':
+        orig_device = mag_sq.device
+        mag_cpu = mag_sq.cpu()
+        H_filter = _gpu_median_filter_2d(mag_cpu, h_kernel, dim=2).to(orig_device)
+        P_filter = _gpu_median_filter_2d(mag_cpu, p_kernel, dim=1).to(orig_device)
+    else:
+        H_filter = _gpu_median_filter_2d(mag_sq, h_kernel, dim=2)
+        P_filter = _gpu_median_filter_2d(mag_sq, p_kernel, dim=1)
+
+    H2 = H_filter ** 2
+    P2 = P_filter ** 2
+    denom = H2 + P2 + 1e-10
+    H_mask = H2 / denom
+    P_mask = P2 / denom
+
+    H_mag = (mag_sq * H_mask).unsqueeze(1)
+    P_mag = (mag_sq * P_mask).unsqueeze(1)
+    return H_mag, P_mag
+
+
+# ============================================================
+# 7ch Forensic Feature Computation
+# ============================================================
+
+def compute_forensic_features_7ch(mel_res, mel_H, mel_P):
+    """Compute 7-channel forensic features from HPSS mel spectrograms.
+
+    Channels:
+      ch1: mel_residual     - UNet residual mel spectrogram
+      ch2: mel_harmonic     - HPSS harmonic mel
+      ch3: mel_percussive   - HPSS percussive mel
+      ch4: delta            - temporal 1st derivative
+      ch5: delta2           - temporal 2nd derivative
+      ch6: hp_ratio         - log(H/P) ratio
+      ch7: spectral_flux    - |delta| (absolute spectral change)
+
+    Args:
+        mel_res: (B, 1, N_MELS, T)
+        mel_H: (B, 1, N_MELS, T)
+        mel_P: (B, 1, N_MELS, T)
+
+    Returns:
+        (B, 7, N_MELS, T) concatenated features
+    """
+    delta = torch.diff(mel_res, n=1, dim=-1)
+    delta = F.pad(delta, (1, 0))
+    delta2 = torch.diff(delta, n=1, dim=-1)
+    delta2 = F.pad(delta2, (1, 0))
+    hp_ratio = mel_H - mel_P
+    spectral_flux = torch.abs(delta)
+    return torch.cat([mel_res, mel_H, mel_P, delta, delta2, hp_ratio, spectral_flux], dim=1)

models

@@ -1 +0,0 @@
-../ArtifactNet/models

packages.txt

@@ -1 +1,2 @@
-
+ffmpeg
+libsndfile1

requirements.txt

@@ -1,15 +1,11 @@
-soundfile>=0.12.0
-scipy>=1.11.0
-numpy>=1.24.0
-matplotlib>=3.8.0
-plotly>=5.18.0
-huggingface_hub>=0.20.0
-onnxruntime>=1.17.0
-torch>=2.0.0
-requests>=2.31.0
-
-gradio>=5.20.0
-fastapi>=0.104.0
-uvicorn>=0.24.0
-pydantic>=2.0.0
-yt-dlp>=2024.01.01
+gradio>=4.44.0,<6
+onnxruntime>=1.17.0
+torch>=2.2.0
+soundfile>=0.12.0
+scipy>=1.11.0
+numpy>=1.24.0,<2
+matplotlib>=3.8.0
+plotly>=5.18.0
+librosa>=0.10.0
+huggingface_hub>=0.24.0
+requests>=2.31.0

ui/__init__.py

@@ -1,14 +0,0 @@
-# Purpose: UI components for ArtifactNet Gradio demo
-
-"""UI components and verdict card generation."""
-
-from .verdict_card import VerdictCardBuilder, VerdictColors
-from .components import create_theme, create_header, create_about_section
-
-__all__ = [
-    'VerdictCardBuilder',
-    'VerdictColors',
-    'create_theme',
-    'create_header',
-    'create_about_section',
-]

ui/components.py

@@ -1,112 +0,0 @@
-# Created: 2026-02-24
-# Purpose: Gradio UI components (theme, header, about section)
-# Dependencies: gradio
-
-"""Gradio UI components for ArtifactNet demo."""
-
-import gradio as gr
-
-
-def create_theme() -> gr.themes.Base:
-    """Create ArtifactNet Gradio theme (dark mode with orange accent)."""
-    return gr.themes.Base(
-        primary_hue="orange",
-        secondary_hue="blue",
-        neutral_hue="slate",
-        font=gr.themes.GoogleFont("Inter"),
-    ).set(
-        body_background_fill="#0f0f23",
-        block_background_fill="#1a1a2e",
-        block_border_color="#333",
-        input_background_fill="#16213e",
-        button_primary_background_fill="#ffa502",
-        button_primary_text_color="black",
-    )
-
-
-def create_header(is_hf_spaces: bool) -> str:
-    """Create header HTML for Gradio UI.
-
-    Args:
-        is_hf_spaces: Whether running on HF Spaces (shows CPU warning)
-
-    Returns:
-        HTML string
-    """
-    cpu_warning = ""
-    if is_hf_spaces:
-        cpu_warning = (
-            '<div style="margin:8px auto;max-width:500px;padding:6px 12px;'
-            'background:rgba(255,165,2,0.12);border:1px solid #ffa502;'
-            'border-radius:8px;font-size:12px;color:#ffa502;">'
-            'Running on CPU — analysis may take 30-60 seconds depending on track length.'
-            '</div>'
-        )
-
-    return f"""
-    <div style="text-align:center;padding:20px 0 10px;">
-        <h1 style="color:white;font-size:28px;margin:0;">
-            ArtifactNet
-        </h1>
-        <p style="color:#888;font-size:14px;margin:4px 0 0;">
-            AI Music Forensic Detector — Deep Spectral Analysis + Neural Network
-        </p>
-        {cpu_warning}
-    </div>
-    """
-
-
-def create_about_section() -> str:
-    """Create About ArtifactNet accordion content HTML."""
-    return """
-    <div style="color:#ccc;font-size:13px;line-height:1.6;padding:10px;">
-        <h3 style="color:white;">Overview</h3>
-        <p>
-            ArtifactNet is a neural network-based forensic detector for
-            AI-generated music. It analyzes audio characteristics to distinguish
-            between human-produced and AI-generated tracks.
-        </p>
-
-        <h3 style="color:white;">Verdict Categories</h3>
-        <table style="width:100%;border-collapse:collapse;margin:8px 0;">
-            <tr style="border-bottom:1px solid #333;">
-                <td style="padding:6px;color:#ff4757;font-weight:bold;">AI Generated</td>
-                <td style="padding:6px;">Strong AI generation indicators detected.</td>
-            </tr>
-            <tr style="border-bottom:1px solid #333;">
-                <td style="padding:6px;color:#ffa502;font-weight:bold;">Uncertain</td>
-                <td style="padding:6px;">
-                    <strong>Most common cause:</strong> Heavily processed audio (compression, EQ, effects).<br>
-                    Other cases: Non-music audio, mixed human/AI content, edge cases in training data.<br>
-                    <em>Tip: Try with original/minimally processed audio for better accuracy.</em>
-                </td>
-            </tr>
-            <tr>
-                <td style="padding:6px;color:#2ed573;font-weight:bold;">Human-Made</td>
-                <td style="padding:6px;">No significant AI generation indicators found.</td>
-            </tr>
-        </table>
-
-        <h3 style="color:white;">Limitations</h3>
-        <ul>
-            <li>Mono input reduces accuracy</li>
-            <li>Heavily processed audio may fall in the Uncertain zone</li>
-            <li>Novel AI generators not in training data may be missed</li>
-            <li>Short clips (&lt;10s) have lower confidence</li>
-        </ul>
-
-        <h3 style="color:white;">📊 Data Collection (Edge Case Detection)</h3>
-        <p style="background:rgba(46,213,115,0.1);padding:8px;border-radius:4px;border-left:3px solid #2ed573;color:#ccc;font-size:12px;line-height:1.5;">
-            <strong style="color:#2ed573;">What's collected:</strong> When results are "Uncertain",
-            analysis data (mel-spectrogram only) from tracks <strong>&lt;30 seconds</strong>
-            is securely saved for model improvement.<br><br>
-            <strong style="color:#2ed573;">What's NOT collected:</strong> Your original audio files are never stored.
-            Only aggregated spectral patterns and verdict statistics are saved.<br><br>
-            <strong style="color:#2ed573;">Why:</strong> These edge cases help improve model accuracy and robustness.
-        </p>
-
-        <p style="color:#888;font-size:11px;margin-top:10px;">
-            Research project — results should be interpreted alongside other evidence.
-        </p>
-    </div>
-    """

ui/verdict_card.py

@@ -1,189 +0,0 @@
-# Created: 2026-02-24
-# Purpose: Verdict card HTML generation (extracted from app.py)
-# Dependencies: None (pure HTML generation)
-
-"""Verdict card HTML builder for ArtifactNet results."""
-
-import math
-from dataclasses import dataclass
-
-
-def _safe_fmt(val: float) -> float:
-    """Convert NaN to 0.5 for safe formatting."""
-    if math.isnan(val):
-        return 0.5
-    return val
-
-
-@dataclass
-class VerdictColors:
-    """Color constants for verdict categories."""
-    AI_GENERATED = "#ff4757"
-    UNCERTAIN = "#ffa502"
-    HUMAN_MADE = "#2ed573"
-
-    BACKGROUND = "#16213e"
-    BORDER = "#333"
-
-
-class VerdictCardBuilder:
-    """Build HTML verdict cards for ArtifactNet analysis results."""
-
-    @staticmethod
-    def build_empty_card() -> str:
-        """Generate placeholder card for empty state."""
-        return """
-        <div style="text-align:center;padding:30px;background:#16213e;
-                    border-radius:12px;color:#888;">
-            <p style="font-size:16px;">Upload an audio file to begin analysis</p>
-        </div>"""
-
-    @staticmethod
-    def build(verdict: str, stats: dict, is_stereo: bool,
-              duration: float = 0, elapsed: float = 0) -> str:
-        """Generate verdict card HTML.
-
-        Args:
-            verdict: "AI Generated", "Uncertain", or "Human-Made"
-            stats: Distribution statistics dict
-            is_stereo: Whether input was stereo
-            duration: Audio duration in seconds
-            elapsed: Analysis elapsed time in seconds
-
-        Returns:
-            HTML string for verdict card
-        """
-        if verdict == "No file":
-            return VerdictCardBuilder.build_empty_card()
-
-        color, icon, desc = VerdictCardBuilder._get_verdict_style(verdict, stats)
-        channels = "Stereo" if is_stereo else "Mono"
-
-        # Distribution bar
-        dist_bar = VerdictCardBuilder._build_distribution_bar(stats)
-
-        # Warnings and context
-        mono_warn = VerdictCardBuilder._build_mono_warning(is_stereo)
-        context = VerdictCardBuilder._build_context(verdict, stats)
-
-        return f"""
-    <div style="text-align:center;padding:20px;background:#16213e;
-                border-radius:12px;border:2px solid {color};">
-        <div style="font-size:14px;color:{color};letter-spacing:1px;
-                    text-transform:uppercase;font-weight:600;">
-            {icon} Verdict
-        </div>
-        <div style="font-size:32px;font-weight:bold;color:{color};
-                    letter-spacing:2px;margin:6px 0;">{verdict.upper()}</div>
-        <div style="color:#aaa;font-size:13px;margin-bottom:10px;">{desc}</div>
-        <div style="font-size:36px;font-weight:bold;color:white;margin:4px 0;">
-            median={_safe_fmt(stats['median']):.1%} &nbsp;
-            <span style="font-size:18px;color:#888;">mean={_safe_fmt(stats['mean']):.1%}</span>
-        </div>
-        {dist_bar}
-        <div style="color:#999;font-size:13px;margin-top:10px;">
-            {stats['n']} segments &nbsp;|&nbsp;
-            IQR={stats['iqr']:.2f} &nbsp;|&nbsp;
-            {channels} &nbsp;|&nbsp;
-            {duration:.1f}s &nbsp;|&nbsp;
-            {elapsed:.1f}s
-        </div>
-        {mono_warn}
-        {context}
-    </div>"""
-
-    @staticmethod
-    def _get_verdict_style(verdict: str, stats: dict) -> tuple[str, str, str]:
-        """Get color, icon, and description for verdict.
-
-        Returns:
-            (color, icon, description)
-        """
-        pct_high = stats["pct_high"]
-
-        if verdict == "AI Generated":
-            return (
-                VerdictColors.AI_GENERATED,
-                "&#9888;",  # warning icon
-                f"{pct_high:.0%} of segments show strong AI indicators (consistent pattern)"
-            )
-        elif verdict == "Uncertain":
-            return (
-                VerdictColors.UNCERTAIN,
-                "&#9679;",  # circle icon
-                "Mixed signals across segments — inconsistent pattern"
-            )
-        else:  # Human-Made
-            return (
-                VerdictColors.HUMAN_MADE,
-                "&#10003;",  # check icon
-                "No significant AI generation indicators found"
-            )
-
-    @staticmethod
-    def _build_distribution_bar(stats: dict) -> str:
-        """Build 3-color distribution bar HTML."""
-        n_total = stats["n"]
-        n_high, n_mid, n_low = stats["n_high"], stats["n_mid"], stats["n_low"]
-        pct_h = n_high / n_total * 100
-        pct_m = n_mid / n_total * 100
-        pct_l = n_low / n_total * 100
-
-        return f"""
-        <div style="margin:10px auto;max-width:320px;">
-            <div style="height:14px;background:#333;border-radius:7px;
-                        overflow:hidden;display:flex;">
-                <div style="width:{pct_h:.1f}%;background:{VerdictColors.AI_GENERATED};"></div>
-                <div style="width:{pct_m:.1f}%;background:{VerdictColors.UNCERTAIN};"></div>
-                <div style="width:{pct_l:.1f}%;background:{VerdictColors.HUMAN_MADE};"></div>
-            </div>
-            <div style="display:flex;justify-content:space-between;
-                        font-size:10px;color:#888;margin-top:2px;">
-                <span style="color:{VerdictColors.AI_GENERATED};">{n_high} high</span>
-                <span style="color:{VerdictColors.UNCERTAIN};">{n_mid} mid</span>
-                <span style="color:{VerdictColors.HUMAN_MADE};">{n_low} low</span>
-            </div>
-        </div>"""
-
-    @staticmethod
-    def _build_mono_warning(is_stereo: bool) -> str:
-        """Build mono input warning HTML."""
-        if is_stereo:
-            return ""
-
-        return """
-        <div style="margin-top:8px;padding:6px 10px;background:rgba(255,165,2,0.15);
-                    border-radius:6px;border-left:3px solid #ffa502;font-size:12px;">
-            Mono input — stereo phase features unavailable. Results may be less reliable.
-        </div>"""
-
-    @staticmethod
-    def _build_context(verdict: str, stats: dict) -> str:
-        """Build human comparison context HTML."""
-        if verdict == "AI Generated":
-            return """
-        <div style="margin-top:10px;padding:8px 12px;background:rgba(255,71,87,0.1);
-                    border-radius:6px;font-size:12px;color:#ccc;line-height:1.5;">
-            <b style="color:#ff4757;">Context:</b>
-            In blind listening tests, trained listeners correctly identified AI music
-            only 72.9% of the time (N=90). This track shows patterns that exceed
-            human detection ability.
-        </div>"""
-        elif verdict == "Uncertain":
-            iqr = stats['iqr']
-            return f"""
-        <div style="margin-top:10px;padding:8px 12px;background:rgba(255,165,2,0.1);
-                    border-radius:6px;font-size:12px;color:#ccc;line-height:1.5;">
-            <b style="color:#ffa502;">Why uncertain:</b>
-            Segment distribution is inconsistent (IQR={iqr:.2f}).
-            Some sections show AI patterns while others appear human-made.
-            This may indicate partial AI use, heavy processing, or novel audio characteristics.
-        </div>"""
-        else:  # Human-Made
-            return """
-        <div style="margin-top:10px;padding:8px 12px;background:rgba(46,213,115,0.1);
-                    border-radius:6px;font-size:12px;color:#ccc;line-height:1.5;">
-            <b style="color:#2ed573;">Context:</b>
-            This track's spectral and temporal characteristics are consistent with
-            human-produced music. Average human accuracy in blind tests: 69.3% (N=90).
-        </div>"""

visualization/feature_bars.py

@@ -0,0 +1,110 @@
+# Created: 2026-03-07
+# Purpose: Horizontal bar chart for 7 forensic audio features
+# Dependencies: plotly, numpy
+
+"""Horizontal bar chart visualization for 7 forensic audio features."""
+
+import plotly.graph_objects as go
+
+
+def plot_feature_bars(feature_stats: dict) -> go.Figure:
+    """7개 포렌식 피처를 horizontal bar chart로 시각화.
+
+    Args:
+        feature_stats: Dict with feature names as keys and normalized values (0-1)
+
+    Returns:
+        plotly Figure (horizontal bar chart)
+    """
+    # 7개 포렌식 피처 (짧은 레이블)
+    features = [
+        "Spectral Flux",
+        "H/P Ratio",
+        "Temporal Accel",
+        "Temporal Delta",
+        "Percussive",
+        "Harmonic",
+        "Residual Energy",
+    ]
+
+    # 기본값 (feature_stats가 없으면 중간값)
+    if not feature_stats:
+        values = [0.5] * 7
+    else:
+        values = [
+            feature_stats.get("spectral_flux", 0.5),
+            feature_stats.get("hp_ratio", 0.5),
+            feature_stats.get("temporal_accel", 0.5),
+            feature_stats.get("temporal_delta", 0.5),
+            feature_stats.get("percussive_strength", 0.5),
+            feature_stats.get("harmonic_strength", 0.5),
+            feature_stats.get("residual_energy", 0.5),
+        ]
+
+    # AI 가능성 기준: 높을수록 AI 시그니처
+    # Residual Energy, H/P Ratio는 높을수록 AI
+    # Temporal Delta/Accel는 낮을수록 AI (부드러운 변화)
+    # Harmonic/Percussive는 특정 비율로 수렴
+    # Spectral Flux는 낮을수록 AI (일관적 변화)
+
+    # AI 시그니처 강도에 따라 색상 결정
+    colors = []
+    for i, (feat, val) in enumerate(zip(features, values)):
+        if "Residual" in feat or "H/P" in feat:
+            # 높을수록 AI
+            if val >= 0.7:
+                colors.append('#ff4757')  # AI (red)
+            elif val >= 0.4:
+                colors.append('#ffa502')  # Uncertain (orange)
+            else:
+                colors.append('#2ed573')  # Human (green)
+        elif "Temporal" in feat or "Spectral" in feat:
+            # 낮을수록 AI
+            if val <= 0.3:
+                colors.append('#ff4757')  # AI (red)
+            elif val <= 0.6:
+                colors.append('#ffa502')  # Uncertain (orange)
+            else:
+                colors.append('#2ed573')  # Human (green)
+        else:
+            # Harmonic/Percussive는 중립
+            colors.append('#5f9ea0')  # Neutral (cyan)
+
+    fig = go.Figure(go.Bar(
+        x=values,
+        y=features,
+        orientation='h',
+        marker=dict(
+            color=colors,
+            line=dict(color='#fff', width=1)
+        ),
+        text=[f"{v:.2f}" for v in values],
+        textposition='inside',
+        textfont=dict(size=11, color='white', family='monospace'),
+        hovertemplate="<b>%{y}</b><br>Score: %{x:.3f}<extra></extra>",
+    ))
+
+    fig.update_layout(
+        xaxis=dict(
+            title="Feature Strength",
+            range=[0, 1],
+            tickfont=dict(size=10, color='#aaa'),
+            gridcolor='#333',
+        ),
+        yaxis=dict(
+            tickfont=dict(size=11, color='white'),
+        ),
+        plot_bgcolor='#1a1a2e',
+        paper_bgcolor='#1a1a2e',
+        font=dict(color='white'),
+        margin=dict(l=140, r=20, t=40, b=40),
+        height=300,
+        showlegend=False,
+        title=dict(
+            text="Forensic Feature Strength",
+            font=dict(size=13),
+            x=0.5, xanchor='center'
+        )
+    )
+
+    return fig

visualization/radar.py

@@ -0,0 +1,164 @@
+# Created: 2026-03-07
+# Purpose: Radar chart for 7-channel forensic features
+# Dependencies: plotly, numpy
+
+"""Radar chart visualization for 7 forensic audio features."""
+
+import numpy as np
+import plotly.graph_objects as go
+
+
+def plot_forensic_radar(feature_stats: dict) -> go.Figure:
+    """7개 포렌식 피처를 레이더 차트로 시각화.
+
+    Args:
+        feature_stats: Dict with feature names as keys and normalized values (0-1)
+
+    Returns:
+        plotly Figure (radar/polar chart)
+    """
+    # 7개 포렌식 피처 정의
+    features = [
+        ("Residual Energy", "잔차 에너지 (AI 코덱 흔적)"),
+        ("Harmonic Strength", "하모닉 강도 (음악 구조)"),
+        ("Percussive Strength", "타악기 강도 (리듬 요소)"),
+        ("Temporal Delta", "시간 변화율 (다이나믹스)"),
+        ("Temporal Accel", "시간 가속도 (변화 일관성)"),
+        ("H/P Ratio", "하모닉/타악기 비율"),
+        ("Spectral Flux", "스펙트럼 변화량 (질감)"),
+    ]
+
+    # 기본값 (feature_stats가 없으면 중간값)
+    if not feature_stats:
+        values = [0.5] * 7
+    else:
+        values = [
+            feature_stats.get("residual_energy", 0.5),
+            feature_stats.get("harmonic_strength", 0.5),
+            feature_stats.get("percussive_strength", 0.5),
+            feature_stats.get("temporal_delta", 0.5),
+            feature_stats.get("temporal_accel", 0.5),
+            feature_stats.get("hp_ratio", 0.5),
+            feature_stats.get("spectral_flux", 0.5),
+        ]
+
+    # 레이더 차트용 데이터 (첫 값을 마지막에 반복해서 폐곡선 생성)
+    categories = [f[0] for f in features]
+    values_closed = values + [values[0]]
+    categories_closed = categories + [categories[0]]
+
+    fig = go.Figure()
+
+    # 현재 오디오 패턴
+    fig.add_trace(go.Scatterpolar(
+        r=values_closed,
+        theta=categories_closed,
+        fill='toself',
+        fillcolor='rgba(255, 71, 87, 0.3)',
+        line=dict(color='#ff4757', width=2),
+        name='Audio Pattern',
+        hovertemplate="<b>%{theta}</b><br>Score: %{r:.2f}<extra></extra>"
+    ))
+
+    fig.update_layout(
+        polar=dict(
+            radialaxis=dict(
+                visible=True,
+                range=[0, 1],
+                tickfont=dict(size=10, color='#aaa'),
+                gridcolor='#333',
+            ),
+            angularaxis=dict(
+                tickfont=dict(size=11, color='white'),
+                gridcolor='#333',
+            ),
+            bgcolor='#16213e',
+        ),
+        plot_bgcolor='#1a1a2e',
+        paper_bgcolor='#1a1a2e',
+        font=dict(color='white'),
+        margin=dict(l=80, r=80, t=40, b=40),
+        height=400,
+        showlegend=True,
+        legend=dict(
+            x=0.5, xanchor='center',
+            y=-0.15, yanchor='top',
+            orientation='h',
+            font=dict(size=10)
+        ),
+        title=dict(
+            text="Forensic Feature Profile",
+            font=dict(size=14),
+            x=0.5, xanchor='center'
+        )
+    )
+
+    return fig
+
+
+def forensic_features_explanation() -> str:
+    """7개 포렌식 피처에 대한 상세 설명 HTML 반환."""
+    return """
+    <div style="background:#16213e;padding:20px;border-radius:12px;margin-top:10px;">
+        <h3 style="color:#00d2ff;margin-top:0;font-size:16px;">🔬 7-Channel Forensic Features</h3>
+        <div style="font-size:13px;color:#ccc;line-height:1.6;">
+            <details style="margin-bottom:10px;">
+                <summary style="cursor:pointer;color:#ffa502;font-weight:bold;">
+                    📊 1. Residual Energy (잔차 에너지)
+                </summary>
+                <p style="margin:8px 0 0 20px;color:#aaa;">
+                    AI 뉴럴 코덱이 남기는 미세한 코덱 흔적.
+                    AI 음악은 인간이 만든 음악과 다른 <b>양자화 패턴</b>을 보입니다.
+                </p>
+            </details>
+
+            <details style="margin-bottom:10px;">
+                <summary style="cursor:pointer;color:#ffa502;font-weight:bold;">
+                    🎵 2-3. Harmonic/Percussive Strength (하모닉/타악기 강도)
+                </summary>
+                <p style="margin:8px 0 0 20px;color:#aaa;">
+                    음악을 멜로디 성분과 리듬 성분으로 분리.
+                    AI는 두 요소의 <b>에너지 비율</b>이 부자연스럽게 일정합니다.
+                </p>
+            </details>
+
+            <details style="margin-bottom:10px;">
+                <summary style="cursor:pointer;color:#ffa502;font-weight:bold;">
+                    ⚡ 4-5. Temporal Delta & Accel (시간 변화율/가속도)
+                </summary>
+                <p style="margin:8px 0 0 20px;color:#aaa;">
+                    스펙트럼의 시간축 변화 패턴.
+                    AI 음악은 변화가 <b>너무 부드럽고 규칙적</b>입니다 (생성 과정의 smoothing 효과).
+                </p>
+            </details>
+
+            <details style="margin-bottom:10px;">
+                <summary style="cursor:pointer;color:#ffa502;font-weight:bold;">
+                    🎚️ 6. H/P Ratio (하모닉/타악기 비율)
+                </summary>
+                <p style="margin:8px 0 0 20px;color:#aaa;">
+                    멜로디와 리듬의 균형.
+                    AI는 장르와 무관하게 <b>특정 비율로 수렴</b>하는 경향을 보입니다.
+                </p>
+            </details>
+
+            <details>
+                <summary style="cursor:pointer;color:#ffa502;font-weight:bold;">
+                    🌊 7. Spectral Flux (스펙트럼 변화량)
+                </summary>
+                <p style="margin:8px 0 0 20px;color:#aaa;">
+                    주파수 성분의 프레임간 변화 절댓값.
+                    AI는 변화가 <b>일관적이고 예측 가능</b>합니다 (확률적 생성의 특성).
+                </p>
+            </details>
+        </div>
+
+        <div style="margin-top:15px;padding:12px;background:#1a1a2e;border-radius:8px;border-left:3px solid #00d2ff;">
+            <p style="margin:0;font-size:12px;color:#aaa;">
+                <b style="color:#00d2ff;">💡 핵심 원리:</b>
+                AI 생성 모델은 <b>물리적 악기의 불규칙성</b>을 완벽히 재현하지 못합니다.
+                이 7개 피처는 그러한 미세한 차이를 정량화하여 AI 시그니처를 탐지합니다.
+            </p>
+        </div>
+    </div>
+    """

visualization/spectrogram.py

@@ -10,9 +10,8 @@ matplotlib.use('Agg')
 import matplotlib.pyplot as plt
 
 from config import SR, N_FFT, HOP_LENGTH
-from core import get_params
 
-N_MELS = get_params('n_mels')
+N_MELS = 128
 
 
 def _compute_mel_spectrogram(audio_1d: np.ndarray) -> np.ndarray:

visualization/timeline.py

@@ -1,62 +1,166 @@
 # Created: 2026-02-18
-# Purpose: P(AI) per-segment timeline bar chart (plotly)
-# Dependencies: plotly
+# Purpose: P(AI) per-segment timeline bar chart with waveform (plotly)
+# Dependencies: plotly, numpy
 
-"""Per-segment (chunk) AI probability timeline visualization."""
+"""Per-segment (chunk) AI probability timeline visualization with waveform."""
 
+import numpy as np
 import plotly.graph_objects as go
+from plotly.subplots import make_subplots
 
-from config import CHUNK_SEC
+from config import CHUNK_SEC, SR, CHUNK_SAMPLES
 
 
-def plot_timeline(chunk_probs: list[float]) -> go.Figure:
-    """Per-chunk P(AI) timeline bar chart.
+def plot_timeline(
+    chunk_probs: list[float],
+    waveform: np.ndarray = None,
+    chunk_metadata: list[dict] = None,
+    weighted_median: float = None
+) -> go.Figure:
+    """Per-chunk P(AI) timeline bar chart with optional waveform.
 
     Args:
         chunk_probs: P(AI) list for each 4-second chunk
+        waveform: Optional mono waveform array for envelope visualization
+        chunk_metadata: Optional metadata with start_sample info
+        weighted_median: Energy-weighted median P(AI) for reference line
 
     Returns:
-        plotly Figure
+        plotly Figure with waveform (top) + P(AI) bars (bottom)
     """
     n = len(chunk_probs)
     times = [f"{i * CHUNK_SEC:.0f}-{(i + 1) * CHUNK_SEC:.0f}s" for i in range(n)]
     colors = ['#ff4757' if p >= 0.5 else '#2ed573' for p in chunk_probs]
 
-    fig = go.Figure()
-
-    fig.add_trace(go.Bar(
-        x=list(range(n)),
-        y=chunk_probs,
-        marker_color=colors,
-        text=[f"{p:.2f}" for p in chunk_probs],
-        textposition='outside',
-        textfont=dict(size=10, color='white'),
-        hovertemplate="<b>%{customdata}</b><br>P(AI): %{y:.3f}<extra></extra>",
-        customdata=times,
-    ))
-
-    # Threshold line
-    fig.add_hline(y=0.5, line_dash="dash", line_color="#ffa502",
-                  annotation_text="Threshold (0.5)",
-                  annotation_position="top right",
-                  annotation_font_color="#ffa502")
-
-    fig.update_layout(
-        title=dict(text="Segment-level AI Probability", font=dict(size=14)),
-        xaxis=dict(
-            title="Segment",
+    # 파형이 있으면 subplot, 없으면 단순 bar chart
+    if waveform is not None and len(waveform) > 0:
+        fig = make_subplots(
+            rows=2, cols=1,
+            row_heights=[0.3, 0.7],
+            vertical_spacing=0.08,
+            subplot_titles=("Waveform Envelope", "Segment-level AI Probability"),
+        )
+
+        # Waveform envelope (unipolar - 절댓값의 상단만)
+        time_axis = np.arange(len(waveform)) / SR
+        envelope = np.abs(waveform)
+
+        # Downsample for plotting (매 100 샘플마다)
+        downsample_factor = 100
+        time_ds = time_axis[::downsample_factor]
+        envelope_ds = envelope[::downsample_factor]
+
+        fig.add_trace(
+            go.Scatter(
+                x=time_ds,
+                y=envelope_ds,
+                mode='lines',
+                line=dict(color='#5f9ea0', width=0.5),
+                fill='tozeroy',
+                fillcolor='rgba(95, 158, 160, 0.3)',
+                name='Envelope',
+                hovertemplate="Time: %{x:.2f}s<br>Amplitude: %{y:.3f}<extra></extra>",
+            ),
+            row=1, col=1
+        )
+
+        # 세그먼트 경계선 표시 (chunk metadata 사용)
+        if chunk_metadata:
+            for meta in chunk_metadata:
+                start_sec = meta['start_sample'] / SR
+                fig.add_vline(
+                    x=start_sec,
+                    line=dict(color='#ffa502', width=1, dash='dot'),
+                    opacity=0.5,
+                    row=1, col=1
+                )
+
+        # P(AI) bar chart
+        fig.add_trace(
+            go.Bar(
+                x=list(range(n)),
+                y=chunk_probs,
+                marker_color=colors,
+                text=[f"{p:.2f}" for p in chunk_probs],
+                textposition='outside',
+                textfont=dict(size=10, color='white'),
+                hovertemplate="<b>%{customdata}</b><br>P(AI): %{y:.3f}<extra></extra>",
+                customdata=times,
+                name='P(AI)',
+            ),
+            row=2, col=1
+        )
+
+        # Energy-weighted median reference line
+        if weighted_median is not None:
+            fig.add_hline(
+                y=weighted_median, line_dash="dash", line_color="#00d2ff",
+                annotation_text=f"Weighted Median ({weighted_median:.2f})",
+                annotation_position="top right",
+                annotation_font_color="#00d2ff",
+                annotation_font_size=10,
+                row=2, col=1
+            )
+
+        # Layout
+        fig.update_xaxes(title_text="Time (s)", row=1, col=1)
+        fig.update_yaxes(title_text="Amplitude", row=1, col=1)
+        fig.update_xaxes(
+            title_text="Segment",
             tickvals=list(range(n)),
             ticktext=times,
             tickangle=-45,
             tickfont=dict(size=9),
-        ),
-        yaxis=dict(title="P(AI)", range=[0, 1.05]),
-        plot_bgcolor='#1a1a2e',
-        paper_bgcolor='#1a1a2e',
-        font=dict(color='white'),
-        margin=dict(l=50, r=20, t=40, b=60),
-        height=300,
-        showlegend=False,
-    )
+            row=2, col=1
+        )
+        fig.update_yaxes(title_text="P(AI)", range=[0, 1.05], row=2, col=1)
+
+        fig.update_layout(
+            plot_bgcolor='#1a1a2e',
+            paper_bgcolor='#1a1a2e',
+            font=dict(color='white'),
+            margin=dict(l=50, r=20, t=60, b=60),
+            height=500,
+            showlegend=False,
+        )
+
+    else:
+        # Fallback: 기존 단순 bar chart
+        fig = go.Figure()
+
+        fig.add_trace(go.Bar(
+            x=list(range(n)),
+            y=chunk_probs,
+            marker_color=colors,
+            text=[f"{p:.2f}" for p in chunk_probs],
+            textposition='outside',
+            textfont=dict(size=10, color='white'),
+            hovertemplate="<b>%{customdata}</b><br>P(AI): %{y:.3f}<extra></extra>",
+            customdata=times,
+        ))
+
+        if weighted_median is not None:
+            fig.add_hline(y=weighted_median, line_dash="dash", line_color="#00d2ff",
+                          annotation_text=f"Weighted Median ({weighted_median:.2f})",
+                          annotation_position="top right",
+                          annotation_font_color="#00d2ff")
+
+        fig.update_layout(
+            title=dict(text="Segment-level AI Probability", font=dict(size=14)),
+            xaxis=dict(
+                title="Segment",
+                tickvals=list(range(n)),
+                ticktext=times,
+                tickangle=-45,
+                tickfont=dict(size=9),
+            ),
+            yaxis=dict(title="P(AI)", range=[0, 1.05]),
+            plot_bgcolor='#1a1a2e',
+            paper_bgcolor='#1a1a2e',
+            font=dict(color='white'),
+            margin=dict(l=50, r=20, t=40, b=60),
+            height=300,
+            showlegend=False,
+        )
 
     return fig

youtube_proxy_server.py

@@ -1,180 +0,0 @@
-#!/usr/bin/env python3
-"""
-YouTube Audio Proxy Server — yt-dlp wrapper with API
-
-환경변수:
-  - YOUTUBE_PROXY_API_KEY: 인증 토큰 (Bearer token)
-  - LOG_LEVEL: DEBUG/INFO/WARNING (기본값: INFO)
-"""
-
-import os
-import sys
-import json
-import logging
-import tempfile
-import subprocess
-from typing import Optional
-
-from fastapi import FastAPI, HTTPException, Header
-from fastapi.responses import FileResponse, JSONResponse
-from pydantic import BaseModel
-
-# ============================================================
-# Config
-# ============================================================
-
-API_KEY = os.environ.get("YOUTUBE_PROXY_API_KEY", "default-key")
-LOG_LEVEL = os.environ.get("LOG_LEVEL", "INFO")
-
-logging.basicConfig(
-    level=getattr(logging, LOG_LEVEL),
-    format="%(asctime)s — [%(levelname)s] %(message)s"
-)
-logger = logging.getLogger(__name__)
-
-# ============================================================
-# FastAPI app
-# ============================================================
-
-app = FastAPI(title="YouTube Proxy Server", version="1.0")
-
-
-# Global exception handler to ensure all errors return JSON
-@app.exception_handler(Exception)
-async def global_exception_handler(request, exc):
-    """Catch all exceptions and return JSON error response."""
-    logger.error(f"Unhandled exception: {type(exc).__name__}: {str(exc)}")
-    return JSONResponse(
-        status_code=500,
-        content={"detail": f"Internal error: {str(exc)[:200]}"}
-    )
-
-
-class YouTubeRequest(BaseModel):
-    """YouTube URL download request."""
-    url: str
-
-
-@app.get("/health")
-def health_check():
-    """Health check endpoint."""
-    return {"status": "healthy", "service": "youtube-proxy"}
-
-
-@app.post("/download-youtube")
-def download_youtube(
-    req: YouTubeRequest,
-    authorization: Optional[str] = Header(None),
-):
-    """
-    Download audio from YouTube URL.
-
-    Headers:
-        Authorization: "Bearer {API_KEY}"
-
-    Returns:
-        WAV file (binary)
-    """
-
-    # Verify API key
-    if not authorization or not authorization.startswith("Bearer "):
-        logger.warning(f"Missing/invalid auth header: {authorization}")
-        raise HTTPException(status_code=401, detail="Unauthorized")
-
-    token = authorization[7:]  # Strip "Bearer "
-    if token != API_KEY:
-        logger.warning(f"Invalid API key: {token}")
-        raise HTTPException(status_code=403, detail="Forbidden")
-
-    url = req.url.strip()
-    if not url:
-        raise HTTPException(status_code=400, detail="Empty URL")
-
-    logger.info(f"Downloading: {url}")
-
-    try:
-        # Create temp directory
-        tmpdir = tempfile.mkdtemp(prefix="yt_audio_")
-        out_path = os.path.join(tmpdir, "audio.wav")
-
-        # Get absolute path to yt-dlp
-        # If in venv, use venv's yt-dlp; else use system yt-dlp
-        yt_dlp_path = os.path.join(
-            os.path.dirname(sys.executable), "yt-dlp"
-        )
-        if not os.path.exists(yt_dlp_path):
-            yt_dlp_path = "yt-dlp"  # Fallback to system
-
-        # Execute yt-dlp
-        cmd = [
-            yt_dlp_path,
-            "--no-playlist",
-            "-x",
-            "--audio-format", "wav",
-            "--audio-quality", "0",
-            "--max-filesize", "50M",
-            "-o", out_path,
-            url,
-        ]
-
-        logger.debug(f"Command: {' '.join(cmd)}")
-        result = subprocess.run(
-            cmd,
-            capture_output=True,
-            text=True,
-            timeout=120,
-        )
-
-        if result.returncode != 0:
-            logger.error(f"yt-dlp failed: {result.stderr[:500]}")
-            raise HTTPException(
-                status_code=400,
-                detail=f"Download failed: {result.stderr[:200]}"
-            )
-
-        # Find the downloaded file
-        downloaded_file = None
-        for f in os.listdir(tmpdir):
-            downloaded_file = os.path.join(tmpdir, f)
-            break
-
-        if not downloaded_file or not os.path.exists(downloaded_file):
-            logger.error(f"Download completed but no file found in {tmpdir}")
-            raise HTTPException(
-                status_code=500,
-                detail="Download completed but no file found"
-            )
-
-        logger.info(f"Downloaded successfully: {downloaded_file}")
-
-        # Return file
-        return FileResponse(
-            path=downloaded_file,
-            media_type="audio/wav",
-            filename="audio.wav",
-        )
-
-    except subprocess.TimeoutExpired:
-        logger.error(f"Timeout downloading {url}")
-        raise HTTPException(status_code=504, detail="Download timeout")
-
-    except Exception as e:
-        logger.error(f"Error: {type(e).__name__}: {str(e)}")
-        raise HTTPException(status_code=500, detail=f"Internal error: {str(e)}")
-
-
-if __name__ == "__main__":
-    import uvicorn
-
-    host = os.environ.get("HOST", "0.0.0.0")
-    port = int(os.environ.get("PORT", "8765"))
-
-    logger.info(f"Starting YouTube Proxy Server on {host}:{port}")
-    logger.info(f"API Key configured: {bool(API_KEY)}")
-
-    uvicorn.run(
-        app,
-        host=host,
-        port=port,
-        log_level=LOG_LEVEL.lower(),
-    )