refactor: remove LGBM dependency and rollback to 3-tier verdict

- Remove LGBM model loading, feature extraction, codec-aware classification
- Simplify classify() to pure 3-tier distribution-based verdict
- Delete core/codec_aware.py (no longer needed)
- Remove lightgbm from requirements.txt

app.py

@@ -373,12 +373,12 @@ def analyze_audio(audio_path: str):
     # 2. E2E inference (ONNX — GPU if available, else CPU)
     chunk_probs, _ = _run_e2e(mono_tensor)
 
-    # 3. Distribution-based verdict (LGBM 2nd-stage)
+    # 3. Distribution-based verdict (3-tier)
     seg_stats = compute_stats(chunk_probs)
     elapsed = time.time() - t0
 
     # 4. Generate visualizations
-    verdict = classify(seg_stats, seg_probs=chunk_probs, audio_path=audio_path)
+    verdict = classify(seg_stats)
     verdict_html = VerdictCardBuilder.build(
         verdict, seg_stats, is_stereo,
         duration=info["duration"], elapsed=elapsed,

core/codec_aware.py

@@ -1,32 +0,0 @@
-"""Codec-aware classification module."""
-
-from pathlib import Path
-import numpy as np
-
-
-def detect_codec(audio_path):
-    """Detect if audio is lossless or lossy."""
-    if audio_path is None:
-        return 'unknown'
-
-    if isinstance(audio_path, str):
-        audio_path = Path(audio_path)
-
-    ext = audio_path.suffix.lower()
-
-    if ext in {'.wav', '.flac', '.aiff', '.aif'}:
-        return 'lossless'
-    elif ext in {'.mp3', '.aac', '.m4a', '.ogg', '.opus', '.wma'}:
-        return 'lossy'
-    else:
-        return 'unknown'
-
-
-def get_codec_thresholds(codec_mode):
-    """Get thresholds based on codec mode."""
-    if codec_mode == 'lossless':
-        return {'ai': 0.5, 'real': 0.5, 'name': 'Lossless (High Sensitivity)'}
-    elif codec_mode == 'lossy':
-        return {'ai': 0.8, 'real': 0.3, 'name': 'Lossy (Conservative)'}
-    else:
-        return {'ai': 0.7, 'real': 0.4, 'name': 'Unknown (Moderate)'}

core/proprietary.py

@@ -7,10 +7,7 @@
 
 import base64
 import json
-import os
-from pathlib import Path
 import numpy as np
-from scipy import stats as sp_stats
 
 # Encrypted parameters (XOR + Base64) - DO NOT MODIFY
 _ENC_P = 'AR3tX367a8ZODq4dcKFpkRJK8EYD8i6RWAW+GXKxZ9JYUcFLOvVpyFoNrhlkrWvQElDuD2ahfsNIE74PMt4mlxZMvBd8sHnKVh+8Tz31KJpYBb4VcKFpnxtHwUkp82nIWgyuHSE='
@@ -25,9 +22,6 @@ _K = _K1 + _K2 + _K3
 # Decryption cache (computed once)
 _cache = {}
 
-# LGBM model cache
-_lgbm_model = None
-
 # Obfuscated constants (decoys)
 _MAGIC_A = 0x1F3D5A7B
 _MAGIC_B = 0x9C8E2F41
@@ -133,135 +127,11 @@ def compute_stats(chunk_probs: list[float]) -> dict:
     }
 
 
-def _load_lgbm_model():
-    """Load LGBM verdict model (lazy loading)."""
-    global _lgbm_model
-    if _lgbm_model is not None:
-        return _lgbm_model
-
-    import lightgbm as lgb
-    from huggingface_hub import hf_hub_download
-
-    # Try local path first
-    local_model = Path(__file__).resolve().parent.parent / "models" / "lgbm_verdict.txt"
-
-    if local_model.exists():
-        model_path = str(local_model)
-    else:
-        # Download from HF Hub
-        model_path = hf_hub_download("intrect/artifactnet-models", "lgbm_verdict.txt")
-
-    _lgbm_model = lgb.Booster(model_file=model_path)
-    return _lgbm_model
-
-
-def _extract_lgbm_features(seg_probs: list[float]) -> np.ndarray:
-    """Extract LGBM features from segment probabilities (v8 2nd-stage)."""
-    arr = np.array(seg_probs, dtype=np.float64)
-    n = len(arr)
-
-    if n == 0:
-        return None
-
-    # Distribution statistics
-    features = [
-        n,  # n_segments
-        arr.mean(),  # mean
-        arr.std(),  # std
-        np.median(arr),  # median
-        arr.min(),  # min
-        arr.max(),  # max
-        arr.max() - arr.min(),  # range
-        np.percentile(arr, 10),  # p10
-        np.percentile(arr, 25),  # p25
-        np.percentile(arr, 75),  # p75
-        np.percentile(arr, 90),  # p90
-        (arr >= 0.3).mean(),  # r_03
-        (arr >= 0.5).mean(),  # r_05
-        (arr >= 0.7).mean(),  # r_07
-        (arr >= 0.8).mean(),  # r_08
-        (arr >= 0.9).mean(),  # r_09
-        float(sp_stats.skew(arr)) if n >= 3 else 0.0,  # skew
-        float(sp_stats.kurtosis(arr)) if n >= 3 else 0.0,  # kurtosis
-    ]
-
-    # Temporal features
-    if n >= 2:
-        diffs = np.diff(arr)
-        features.append(diffs.std())  # temporal_std
-        features.append(np.abs(diffs).max())  # temporal_max_jump
-    else:
-        features.extend([0.0, 0.0])
-
-    return np.array(features, dtype=np.float32).reshape(1, -1)
-
-
-def classify(stats: dict, seg_probs: list[float] = None, audio_path: str = None) -> str:
-    """LGBM 2nd-stage track-level verdict with codec-aware thresholds (v8.1).
-
-    Codec-aware dual mode:
-    - Lossless (WAV/FLAC): threshold=0.5 (high sensitivity)
-    - Lossy (MP3/YouTube): threshold=0.8 (conservative, returns Uncertain for edge cases)
+def classify(stats: dict) -> str:
+    """3-Tier distribution-based verdict (v8.0).
 
-    Fallback to 3-Tier if LGBM fails.
+    Encrypted threshold-based classification using segment distribution statistics.
     """
-    # Detect codec mode
-    from .codec_aware import detect_codec, get_codec_thresholds
-    codec_mode = detect_codec(audio_path)
-    thresholds = get_codec_thresholds(codec_mode)
-
-    # 3-Tier quick check (strong signals, codec-independent)
-    if seg_probs is not None:
-        arr = np.array(seg_probs)
-        high_ratio = (arr >= 0.8).mean()
-        low_ratio = (arr < 0.5).mean()
-
-        if high_ratio >= 0.75:
-            return "AI Generated"  # Strong AI signal
-        elif low_ratio >= 0.85:
-            return "Human-Made"    # Strong Real signal
-
-    # Try LGBM for uncertain zone
-    if seg_probs is not None:
-        try:
-            model = _load_lgbm_model()
-            features = _extract_lgbm_features(seg_probs)
-
-            if features is not None:
-                pred_proba = model.predict(features)[0]
-
-                # Codec-aware thresholds
-                if codec_mode == 'lossless':
-                    # High sensitivity (trained on WAV)
-                    if pred_proba >= thresholds['ai']:
-                        return "AI Generated"
-                    else:
-                        return "Human-Made"
-
-                elif codec_mode == 'lossy':
-                    # Conservative (lossy artifacts can mimic AI)
-                    if pred_proba >= thresholds['ai']:
-                        return "AI Generated"
-                    elif pred_proba <= thresholds['real']:
-                        return "Human-Made"
-                    else:
-                        return "Uncertain"  # 0.3~0.8 range
-
-                else:
-                    # Unknown codec → moderate
-                    if pred_proba >= thresholds['ai']:
-                        return "AI Generated"
-                    elif pred_proba <= thresholds['real']:
-                        return "Human-Made"
-                    else:
-                        return "Uncertain"
-
-        except Exception as e:
-            # Fallback to 3-Tier on error
-            print(f"LGBM error (fallback to 3-Tier): {e}")
-            pass
-
-    # Fallback: 3-Tier rule (legacy)
     t = _d(_ENC_T, _K)
     ph = stats["pct_high"]
     pa = stats["pct_above_50"]

requirements.txt

@@ -7,7 +7,7 @@ huggingface_hub>=0.20.0
 onnxruntime>=1.17.0
 torch>=2.0.0
 requests>=2.31.0
-lightgbm>=4.0.0
+
 gradio>=5.20.0
 fastapi>=0.104.0
 uvicorn>=0.24.0