""" AURIS Local Demo - AI Music Detection Calistir: python local_demo.py """ from __future__ import annotations import asyncio import argparse import csv import json import pickle import socket import sys import time import warnings from collections import Counter from dataclasses import dataclass from pathlib import Path from typing import Any WINDOWS_SELECTOR_POLICY = None if sys.platform == "win32": with warnings.catch_warnings(): warnings.simplefilter("ignore", category=DeprecationWarning) WINDOWS_SELECTOR_POLICY = getattr(asyncio, "WindowsSelectorEventLoopPolicy", None) if WINDOWS_SELECTOR_POLICY is not None: # Gradio/Uvicorn is more stable with the selector loop on Windows. with warnings.catch_warnings(): warnings.simplefilter("ignore", category=DeprecationWarning) asyncio.set_event_loop_policy(WINDOWS_SELECTOR_POLICY()) try: import gradio as gr except ModuleNotFoundError as exc: if exc.name == "gradio": raise SystemExit( "Gradio bu Python kurulumunda yok.\n" f"Kullandigin yorumlayici: {sys.executable}\n" "Kurulum komutu:\n" f' "{sys.executable}" -m pip install -r requirements.txt' ) from exc raise import numpy as np from app.training.extract_features_batch import extract_sample_features from app.training.train_deep_classifiers import TorchSklearnWrapper from app.training.wav2vec2_classifier import Wav2Vec2Config, Wav2Vec2MusicClassifier class _AurisUnpickler(pickle.Unpickler): """Resolves TorchSklearnWrapper pickled under __main__ to the real module.""" _REMAP = {("__main__", "TorchSklearnWrapper"): TorchSklearnWrapper} def find_class(self, module: str, name: str) -> Any: cls = self._REMAP.get((module, name)) if cls is not None: return cls return super().find_class(module, name) BASE_DIR = Path(__file__).resolve().parent PROJECT_ROOT = BASE_DIR.parent MODELS_DIR = BASE_DIR / "models" FIGURES_DIR = PROJECT_ROOT / "docs" / "academic" / "figures" DATASET_DIR = PROJECT_ROOT / "DataSet" TEST_AUDIO_DIR = BASE_DIR / "test_audio" @dataclass(frozen=True) class DemoArtifacts: feature_cols: list[str] training_results: dict[str, Any] scaler: Any loaded_models: dict[str, Any] best_model_name: str best_model_label: str model_labels: list[str] label_to_name: dict[str, str] feature_importance: dict[str, float] feature_stats: dict[str, Any] dataset_summary: dict[str, Any] wav2vec2_model: Any # Wav2Vec2MusicClassifier | None def _safe_model_name(name: str) -> str: return ( name.lower() .replace(" ", "_") .replace("(", "") .replace(")", "") .replace("/", "_") .replace("-", "_") ) def _load_pickle(path: Path) -> Any: with open(path, "rb") as f: return _AurisUnpickler(f).load() def _load_json(path: Path) -> dict[str, Any]: with open(path, "r", encoding="utf-8") as f: return json.load(f) def _require_file(path: Path) -> None: if not path.exists(): raise FileNotFoundError(f"Missing required artifact: {path}") def _load_feature_stats() -> dict[str, Any]: stats_path = MODELS_DIR / "feature_stats_v1.json" if not stats_path.exists(): return {} return _load_json(stats_path) def _load_dataset_summary() -> dict[str, Any]: manifest_path = DATASET_DIR / "manifest.csv" if not manifest_path.exists(): return {} label_counts: Counter[str] = Counter() generator_counts: Counter[str] = Counter() total = 0 with open(manifest_path, "r", encoding="utf-8") as f: reader = csv.DictReader(f) for row in reader: total += 1 label = row.get("label", "").strip() or str(row.get("label_int", "")) generator = row.get("generator", "").strip() or "unknown" label_counts[label] += 1 generator_counts[generator] += 1 return { "manifest_path": str(manifest_path), "total": total, "ai": label_counts.get("ai", 0) + label_counts.get("1", 0), "human": label_counts.get("human", 0) + label_counts.get("0", 0), "generators": generator_counts.most_common(8), } def _find_matching_name(raw_name: str, training_results: dict[str, Any]) -> str: # DL model files are stored as "model_dl_" — strip the "dl_" infix too candidates = [raw_name] if raw_name.startswith("dl_"): candidates.append(raw_name[3:]) # "dl_deep_mlp_..." -> "deep_mlp_..." for name in training_results: if name.startswith("_"): continue safe = _safe_model_name(name) if safe in candidates: return name return raw_name.replace("_", " ").title() def _is_model_compatible(model: Any, n_features: int) -> bool: expected = getattr(model, "n_features_in_", None) return expected in (None, n_features) def _load_wav2vec2() -> Any: """Load trained wav2vec2 model from .pt checkpoint. Returns None if unavailable.""" import torch pt_path = MODELS_DIR / "wav2vec2_auris_v1.pt" if not pt_path.exists(): return None try: config = Wav2Vec2Config() model = Wav2Vec2MusicClassifier(config) state = torch.load(str(pt_path), map_location="cpu", weights_only=True) model.load_state_dict(state) model.eval() print(f"wav2vec2 loaded: {pt_path.name}") return model except Exception as exc: # noqa: BLE001 print(f"wav2vec2 skipped ({exc})") return None def _wav2vec2_predict(model: Any, audio_path: str) -> float | None: """Run wav2vec2 inference on a raw audio file. Returns AI probability or None.""" import torch try: import librosa config: Wav2Vec2Config = model.config y, _ = librosa.load(audio_path, sr=config.sample_rate, mono=True) max_samples = int(config.max_audio_sec * config.sample_rate) if len(y) > max_samples: y = y[:max_samples] elif len(y) < max_samples: import numpy as _np y = _np.pad(y, (0, max_samples - len(y))) tensor = torch.tensor(y, dtype=torch.float32).unsqueeze(0) # (1, samples) with torch.no_grad(): probs = model.predict_proba(tensor) return float(probs[0]) except Exception as exc: # noqa: BLE001 print(f"wav2vec2 inference failed: {exc}") return None def _load_artifacts() -> DemoArtifacts: scaler_path = MODELS_DIR / "feature_scaler_v1.pkl" columns_path = MODELS_DIR / "feature_columns_v1.json" results_path = MODELS_DIR / "training_results.json" best_model_path = MODELS_DIR / "auris_classifier_v1.pkl" for required in (scaler_path, columns_path, results_path, best_model_path): _require_file(required) scaler = _load_pickle(scaler_path) feature_cols = _load_json(columns_path) training_results = _load_json(results_path) # Merge DL metrics into the unified training_results dict dl_results_path = MODELS_DIR / "deep_learning_results.json" if dl_results_path.exists(): dl_results = _load_json(dl_results_path) for name, metrics in dl_results.items(): if name not in training_results: training_results[name] = metrics feature_importance = training_results.get("_feature_importance", {}) best_model_name = training_results.get("_best_model", "Gradient Boosting") loaded_models: dict[str, Any] = {} for model_path in sorted(MODELS_DIR.glob("model_*.pkl")): try: model = _load_pickle(model_path) except Exception as exc: # noqa: BLE001 print(f"Skipping model file {model_path.name}: {exc}") continue raw_name = model_path.stem.replace("model_", "") model_name = _find_matching_name(raw_name, training_results) if not _is_model_compatible(model, len(feature_cols)): print( f"Skipping incompatible model {model_path.name}: " f"expected {len(feature_cols)} features" ) continue loaded_models[model_name] = model if best_model_name not in loaded_models: best_model = _load_pickle(best_model_path) if _is_model_compatible(best_model, len(feature_cols)): loaded_models[best_model_name] = best_model if not loaded_models: raise RuntimeError("No compatible models were found in the models directory.") sorted_names = sorted( loaded_models, key=lambda name: training_results.get(name, {}).get("roc_auc", 0.0), reverse=True, ) label_to_name: dict[str, str] = {} model_labels: list[str] = [] for name in sorted_names: result = training_results.get(name, {}) auc = result.get("roc_auc", 0.0) acc = result.get("accuracy", 0.0) badge = " [EN IYI]" if name == best_model_name else "" label = f"{name}{badge} | AUC {auc:.3f} | Acc {acc:.1%}" label_to_name[label] = name model_labels.append(label) best_model_label = next( label for label, name in label_to_name.items() if name == best_model_name ) return DemoArtifacts( feature_cols=feature_cols, training_results=training_results, scaler=scaler, loaded_models=loaded_models, best_model_name=best_model_name, best_model_label=best_model_label, model_labels=model_labels, label_to_name=label_to_name, feature_importance=feature_importance, feature_stats=_load_feature_stats(), dataset_summary=_load_dataset_summary(), wav2vec2_model=_load_wav2vec2(), ) ARTIFACTS = _load_artifacts() def _example_audio_paths(limit: int = 6) -> list[list[str]]: if not TEST_AUDIO_DIR.exists(): return [] candidates = sorted( path for path in TEST_AUDIO_DIR.iterdir() if path.is_file() and path.suffix.lower() in {".wav", ".mp3", ".flac"} ) return [[str(path)] for path in candidates[:limit]] def _normalize_score(value: float, cap: float = 1.0) -> float: return max(0.0, min(float(value), cap)) def _extract_demo_features(audio_path: str) -> tuple[dict[str, float], float]: row = extract_sample_features(audio_path) if row is None: raise RuntimeError("Ozellik cikarimi basarisiz oldu.") features = { column: float(row.get(column, 0.0)) for column in ARTIFACTS.feature_cols } duration_sec = float(row.get("duration_sec", 0.0)) return features, duration_sec def _build_feature_vector(features: dict[str, float]) -> np.ndarray: vector = np.array( [[features.get(column, 0.0) for column in ARTIFACTS.feature_cols]], dtype=np.float32, ) return np.nan_to_num(vector, nan=0.0, posinf=1.0, neginf=-1.0) def _format_verdict(ai_prob: float) -> tuple[str, str, str]: if ai_prob >= 0.75: return "ai-high", "Yuksek AI ihtimali", "AI kaynakli izler baskin" if ai_prob >= 0.55: return "ai-mid", "AI olasiligi yuksek", "Model sentetik duzene yakin buldu" if ai_prob >= 0.40: return "human-mid", "Sinirda sonuc", "Insan ve AI sinyalleri birbirine yakin" return "human-high", "Insan yapimiya yakin", "Dogal varyasyon daha guclu" def _build_result_html( ai_prob: float, duration: float, elapsed: float, selected_model_name: str, ) -> str: verdict_class, verdict_title, verdict_subtitle = _format_verdict(ai_prob) confidence_pct = ai_prob * 100 human_pct = (1.0 - ai_prob) * 100 return f"""
Canli analiz sonucu
%{confidence_pct:.1f}
{verdict_title}
{verdict_subtitle}
Model: {selected_model_name} Sure: {duration:.1f}s Islem: {elapsed:.2f}s Insan olasiligi: %{human_pct:.1f}
""" def _build_signal_html(features: dict[str, float]) -> str: rows = [ ("Spektral duzen", _normalize_score(features.get("spectral_regularity", 0.0))), ("Zamansal kalip", _normalize_score(features.get("temporal_patterns", 0.0))), ("Harmonik yapi", _normalize_score(features.get("harmonic_structure", 0.0))), ("Vokal AI izi", _normalize_score(features.get("vocal_ai_score", 0.0))), ("Vokal guveni", _normalize_score(features.get("vocal_confidence", 0.0))), ("Pitch stabilitesi", _normalize_score(features.get("pitch_stability_score", 0.0))), ] parts = ['
Sinyal panosu
'] for label, raw_value in rows: pct = raw_value * 100 bar_class = "bar-warm" if pct >= 60 else "bar-cool" if pct <= 35 else "bar-mid" parts.append( f"""
{label}
%{pct:.0f}
""" ) parts.append("
") return "".join(parts) def _is_dl_wrapper(model: Any) -> bool: """True for TorchSklearnWrapper — it has its own internal scaler.""" return type(model).__name__ == "TorchSklearnWrapper" def _build_model_table_html( selected_model_name: str, feature_vector: np.ndarray, audio_path: str | None = None, ) -> str: scaled = ARTIFACTS.scaler.transform(feature_vector) scored_rows: list[tuple[str, float]] = [] for name, model in ARTIFACTS.loaded_models.items(): try: with warnings.catch_warnings(): warnings.simplefilter("ignore", category=UserWarning) # DL wrappers scale internally — pass raw vector to avoid double-scaling input_vector = feature_vector if _is_dl_wrapper(model) else scaled probability = float(model.predict_proba(input_vector)[0][1]) except Exception: # noqa: BLE001 continue scored_rows.append((name, probability)) # wav2vec2 row if ARTIFACTS.wav2vec2_model is not None and audio_path is not None: w2v_prob = _wav2vec2_predict(ARTIFACTS.wav2vec2_model, audio_path) if w2v_prob is not None: scored_rows.append(("wav2vec2", w2v_prob)) scored_rows.sort(key=lambda item: item[1], reverse=True) parts = [ '
Model karsilastirmasi
', "", ] for name, probability in scored_rows: metrics = ARTIFACTS.training_results.get(name, {}) row_class = "is-selected" if name == selected_model_name else "" best_badge = " en iyi" if name == ARTIFACTS.best_model_name else "" w2v_badge = " wav2vec2" if name == "wav2vec2" else "" auc_str = f"{metrics['roc_auc']:.4f}" if metrics.get("roc_auc") else "—" acc_str = f"{metrics['accuracy']:.4f}" if metrics.get("accuracy") else "—" parts.append( f""" """ ) parts.append("
ModelCanli AI %CV AUCAcc
{name}{best_badge}{w2v_badge} %{probability * 100:.1f} {auc_str} {acc_str}
") return "".join(parts) def _build_feature_details_md(features: dict[str, float], duration: float) -> str: importance = ARTIFACTS.feature_importance lines = [ "## Ses ozet", "", "| Metrik | Deger |", "|--------|-------|", f"| Sure | {duration:.1f}s |", f"| Tempo | {features.get('tempo_bpm', 0.0):.1f} BPM |", f"| RMS energy | {features.get('rms_energy', 0.0):.6f} |", f"| Harmonic ratio | {features.get('harmonic_ratio', 0.0):.4f} |", f"| Spectral centroid | {features.get('spectral_centroid_mean', 0.0):.1f} Hz |", f"| Vocal confidence | {features.get('vocal_confidence', 0.0):.3f} |", "", ] insight_block = _build_feature_insights_md(features) if insight_block: lines.extend([insight_block, ""]) lines.extend( [ "## Tum ozellikler", "", "| Ozellik | Deger | Global onem |", "|---------|-------|-------------|", ] ) for column in ARTIFACTS.feature_cols: value = features.get(column, 0.0) weight = importance.get(column, 0.0) lines.append(f"| {column} | {value:.6f} | {weight:.4f} |") return "\n".join(lines) def _build_feature_insights_md(features: dict[str, float]) -> str: stats = ARTIFACTS.feature_stats if not stats: return "" by_class = stats.get("_by_class", {}) rows: list[tuple[float, str, float, float, float, float]] = [] for column in ARTIFACTS.feature_cols: feature_stats = stats.get(column) if not feature_stats: continue std = float(feature_stats.get("std", 1.0)) or 1.0 value = float(features.get(column, 0.0)) z_score = (value - float(feature_stats.get("mean", 0.0))) / std ai_mean = float(by_class.get("ai", {}).get(column, {}).get("mean", 0.0)) human_mean = float(by_class.get("human", {}).get(column, {}).get("mean", 0.0)) rows.append((abs(z_score), column, value, z_score, ai_mean, human_mean)) if not rows: return "" rows.sort(reverse=True) lines = [ "## Dikkat ceken sapmalar", "", "| Ozellik | Deger | Z-score | AI ort. | Human ort. |", "|---------|-------|---------|---------|------------|", ] for _, column, value, z_score, ai_mean, human_mean in rows[:10]: lines.append( f"| {column} | {value:.6f} | {z_score:+.2f} | {ai_mean:.6f} | {human_mean:.6f} |" ) return "\n".join(lines) def analyze_audio(audio_file: Any, selected_model_label: str) -> tuple[str, str, str, str]: if not audio_file: empty = '
Ses dosyasi bekleniyor
Analiz icin bir .wav, .mp3 veya .flac yukleyin.
' return empty, "", "", "" audio_path = audio_file[0] if isinstance(audio_file, tuple) else audio_file selected_model_name = ARTIFACTS.label_to_name.get( selected_model_label, ARTIFACTS.best_model_name, ) start_time = time.time() try: features, duration = _extract_demo_features(str(audio_path)) except Exception as exc: # noqa: BLE001 error_html = f'
Analiz basarisiz
{exc}
' return error_html, "", "", "" feature_vector = _build_feature_vector(features) model = ARTIFACTS.loaded_models[selected_model_name] # DL wrappers scale internally; ML models expect pre-scaled input if _is_dl_wrapper(model): input_vector = feature_vector else: input_vector = ARTIFACTS.scaler.transform(feature_vector) with warnings.catch_warnings(): warnings.simplefilter("ignore", category=UserWarning) ai_prob = float(model.predict_proba(input_vector)[0][1]) elapsed = time.time() - start_time result_html = _build_result_html(ai_prob, duration, elapsed, selected_model_name) signal_html = _build_signal_html(features) model_table_html = _build_model_table_html(selected_model_name, feature_vector, str(audio_path)) details_md = _build_feature_details_md(features, duration) return result_html, signal_html, model_table_html, details_md def build_models_md() -> str: training_results = ARTIFACTS.training_results lines = [ "## Egitilmis modeller", "", f"- En iyi model: **{ARTIFACTS.best_model_name}**", f"- Ornek sayisi: **{training_results.get('_n_samples', '?')}**", f"- Ozellik sayisi: **{training_results.get('_n_features', len(ARTIFACTS.feature_cols))}**", f"- CV kat sayisi: **{training_results.get('_n_folds', '?')}**", "", "| Model | Tip | CV AUC | Holdout AUC | Acc | F1 |", "|------|-----|--------|-------------|-----|----|", ] model_names = [ name for name in training_results if not name.startswith("_") and isinstance(training_results[name], dict) ] model_names.sort(key=lambda name: training_results[name].get("roc_auc", 0.0), reverse=True) for name in model_names: result = training_results[name] display = f"**{name}**" if name == ARTIFACTS.best_model_name else name model_type = "DL" if result.get("type") == "deep_learning" else "ML" lines.append( f"| {display} | {model_type} | {result.get('roc_auc', 0.0):.4f} | " f"{result.get('validation_auc', 0.0):.4f} | " f"{result.get('accuracy', 0.0):.4f} | {result.get('f1', 0.0):.4f} |" ) if ARTIFACTS.wav2vec2_model is not None: lines.append("| wav2vec2 (fine-tuned) | DL | — | — | — | — |") lines.extend(["", "## Secilen parametreler", ""]) for name in model_names: params = training_results[name].get("selected_params", {}) lines.append(f"- **{name}**: `{json.dumps(params, ensure_ascii=True)}`") importance_items = sorted( ARTIFACTS.feature_importance.items(), key=lambda item: item[1], reverse=True, )[:15] if importance_items: lines.extend(["", "## Ilk 15 ozellik onemi", "", "| Ozellik | Onem |", "|---------|------|"]) for feature_name, score in importance_items: lines.append(f"| {feature_name} | {score:.4f} |") return "\n".join(lines) def build_dataset_md() -> str: summary = ARTIFACTS.dataset_summary if not summary: return "Veri seti ozeti bulunamadi." lines = [ "## Egitim veri seti", "", "| Metrik | Deger |", "|--------|-------|", f"| Manifest | `{summary.get('manifest_path', '-')}` |", f"| Toplam ornek | {summary.get('total', 0)} |", f"| AI | {summary.get('ai', 0)} |", f"| Human | {summary.get('human', 0)} |", f"| Ozellik | {len(ARTIFACTS.feature_cols)} |", "", "## Kaynak dagilimi", "", "| Kaynak | Adet |", "|--------|------|", ] for generator, count in summary.get("generators", []): lines.append(f"| {generator} | {count} |") return "\n".join(lines) AURIS_CSS = """ :root { --bg: #120f0b; --panel: rgba(31, 24, 17, 0.92); --panel-strong: rgba(42, 31, 22, 0.98); --line: rgba(215, 182, 122, 0.18); --text: #f5ead8; --muted: #c8af8a; --gold: #dfb56f; --gold-soft: #f1d4a2; --danger: #d66a55; --danger-soft: #5d2218; --safe: #7fbb7c; --safe-soft: #1f3b2d; } body { background: radial-gradient(circle at top left, rgba(223, 181, 111, 0.12), transparent 28%), radial-gradient(circle at bottom right, rgba(88, 43, 23, 0.24), transparent 26%), linear-gradient(135deg, #0d0a07 0%, #18120d 45%, #120f0b 100%); } .gradio-container { max-width: 1360px !important; margin: 0 auto !important; background: transparent !important; color: var(--text) !important; font-family: "Segoe UI", sans-serif !important; } .app-shell { padding: 24px 0 10px; } .app-hero { display: grid; grid-template-columns: 1.4fr 1fr; gap: 18px; align-items: stretch; margin-bottom: 18px; } .app-brand, .app-meta { background: linear-gradient(160deg, rgba(35, 26, 18, 0.95), rgba(19, 14, 10, 0.96)); border: 1px solid var(--line); border-radius: 22px; padding: 22px 24px; box-shadow: 0 24px 70px rgba(0, 0, 0, 0.28); } .app-brand__eyebrow { text-transform: uppercase; letter-spacing: 0.24em; font-size: 0.78rem; color: var(--gold); margin-bottom: 12px; } .app-brand__title { font-size: 3rem; font-weight: 800; line-height: 0.98; margin: 0; color: #fff6e6; } .app-brand__subtitle { margin: 14px 0 0; color: var(--muted); line-height: 1.6; max-width: 46rem; } .app-meta__grid { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 12px; } .meta-chip { background: rgba(255, 255, 255, 0.03); border: 1px solid rgba(255, 255, 255, 0.06); border-radius: 16px; padding: 14px 16px; } .meta-chip__label { display: block; color: var(--muted); font-size: 0.78rem; margin-bottom: 6px; } .meta-chip__value { display: block; color: #fff2db; font-size: 1.1rem; font-weight: 700; } .hero-card, .panel-card { background: linear-gradient(180deg, rgba(34, 26, 19, 0.96), rgba(19, 14, 10, 0.96)); border: 1px solid var(--line); border-radius: 20px; padding: 20px; box-shadow: 0 22px 60px rgba(0, 0, 0, 0.24); } .hero-card__eyebrow, .panel-card__title { font-size: 0.82rem; letter-spacing: 0.12em; text-transform: uppercase; color: var(--gold); margin-bottom: 10px; } .hero-card__score { font-size: clamp(2.8rem, 7vw, 4.8rem); line-height: 0.95; font-weight: 900; color: #fff6e7; } .hero-card__title { margin-top: 8px; font-size: 1.4rem; font-weight: 800; color: #fff6e7; } .hero-card__subtitle { margin-top: 8px; color: var(--muted); line-height: 1.6; } .hero-card__meta { display: flex; flex-wrap: wrap; gap: 10px; margin-top: 16px; } .hero-card__meta span { padding: 7px 12px; border-radius: 999px; background: rgba(255, 255, 255, 0.04); border: 1px solid rgba(255, 255, 255, 0.08); color: #f8ead4; font-size: 0.88rem; } .hero-card.ai-high, .hero-card.ai-mid { background: linear-gradient(150deg, rgba(84, 28, 20, 0.96), rgba(33, 15, 12, 0.97)); } .hero-card.human-high, .hero-card.human-mid { background: linear-gradient(150deg, rgba(23, 49, 34, 0.96), rgba(12, 23, 18, 0.97)); } .hero-card.neutral { background: linear-gradient(150deg, rgba(36, 29, 22, 0.96), rgba(17, 14, 11, 0.97)); } .meter-row { display: grid; grid-template-columns: 170px minmax(0, 1fr) 54px; gap: 12px; align-items: center; margin-top: 12px; } .meter-row__label { color: #f7ecd8; font-size: 0.92rem; } .meter-row__track { position: relative; height: 14px; background: rgba(255, 255, 255, 0.06); border-radius: 999px; overflow: hidden; border: 1px solid rgba(255, 255, 255, 0.08); } .meter-row__fill { height: 100%; border-radius: 999px; } .bar-warm { background: linear-gradient(90deg, var(--gold), var(--danger)); } .bar-mid { background: linear-gradient(90deg, var(--gold), var(--gold-soft)); } .bar-cool { background: linear-gradient(90deg, #76c490, #5ca39b); } .meter-row__value { color: var(--gold-soft); font-weight: 700; text-align: right; } .model-table { width: 100%; border-collapse: collapse; } .model-table th, .model-table td { padding: 10px 12px; text-align: left; border-bottom: 1px solid rgba(255, 255, 255, 0.08); } .model-table th { color: var(--gold); font-size: 0.82rem; text-transform: uppercase; letter-spacing: 0.06em; } .model-table td { color: #f6ead6; } .model-table tr.is-selected td { background: rgba(223, 181, 111, 0.08); } .badge { display: inline-block; margin-left: 8px; padding: 3px 8px; border-radius: 999px; font-size: 0.72rem; color: #fff2db; background: rgba(223, 181, 111, 0.18); border: 1px solid rgba(223, 181, 111, 0.25); } .block { border: 1px solid var(--line) !important; border-radius: 18px !important; background: var(--panel) !important; } .gr-button-primary { background: linear-gradient(135deg, #d4a85c, #b46d3f) !important; border: 0 !important; color: #20150d !important; font-weight: 800 !important; } .prose, .prose * { color: var(--text) !important; } .prose table { border-collapse: collapse; width: 100%; } .prose th, .prose td { padding: 8px 10px; border: 1px solid rgba(255, 255, 255, 0.08); } .prose th { background: rgba(255, 255, 255, 0.04); color: var(--gold) !important; } footer { display: none !important; } @media (max-width: 920px) { .app-hero { grid-template-columns: 1fr; } .app-meta__grid { grid-template-columns: 1fr; } .meter-row { grid-template-columns: 1fr; } } """ def _build_header_html() -> str: dataset_summary = ARTIFACTS.dataset_summary training_results = ARTIFACTS.training_results top_generator = dataset_summary.get("generators", [["-", 0]])[0][0] if dataset_summary else "-" return f"""
AURIS local demo

AI Muzik Tespiti
Canli Analiz

Demo arayuzu artik egitim artefact'lari ile ayni ozellik semasini kullaniyor. Yani yukledigin ses, `DataSet/features.csv` ile egitilen modellerle birebir uyumlu sekilde analiz ediliyor.

En iyi model {ARTIFACTS.best_model_name}
Model sayisi {len(ARTIFACTS.loaded_models)}
Veri seti {training_results.get('_n_samples', '?')} ornek
Baskin kaynak {top_generator}
""" with gr.Blocks(title="AURIS Local Demo") as demo: gr.HTML(_build_header_html()) with gr.Tabs(): with gr.Tab("Analiz"): with gr.Row(equal_height=False): with gr.Column(scale=1, min_width=320): audio_input = gr.Audio( label="Ses dosyasi yukle", type="filepath", ) model_dropdown = gr.Dropdown( choices=ARTIFACTS.model_labels, value=ARTIFACTS.best_model_label, label="Calistirilacak model", interactive=True, ) analyze_button = gr.Button("Analizi baslat", variant="primary", size="lg") if _example_audio_paths(): gr.Examples( examples=_example_audio_paths(), inputs=[audio_input], label="Hazir ornekler", ) with gr.Column(scale=2, min_width=520): result_html = gr.HTML() with gr.Row(equal_height=False): signal_html = gr.HTML() model_table_html = gr.HTML() details_md = gr.Markdown() analyze_button.click( fn=analyze_audio, inputs=[audio_input, model_dropdown], outputs=[result_html, signal_html, model_table_html, details_md], ) with gr.Tab("Modeller"): gr.Markdown(build_models_md()) with gr.Tab("Veri Seti"): gr.Markdown(build_dataset_md()) with gr.Tab("Gorseller"): figure_paths = sorted(str(path) for path in FIGURES_DIR.glob("*.png")) if FIGURES_DIR.exists() else [] if figure_paths: gr.Gallery( value=figure_paths, label="Akademik ciktılar", columns=3, height="auto", object_fit="contain", ) else: gr.Markdown("Gorsel bulunamadi.") def _pick_available_port(preferred_port: int) -> int: for port in range(preferred_port, preferred_port + 25): with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock: sock.settimeout(0.2) if sock.connect_ex(("127.0.0.1", port)) != 0: return port raise RuntimeError("Bos bir port bulunamadi.") def _parse_args() -> argparse.Namespace: parser = argparse.ArgumentParser(description="Run the AURIS local Gradio demo") parser.add_argument("--host", default="127.0.0.1", help="Bind address") parser.add_argument("--port", type=int, default=7864, help="Preferred port") parser.add_argument( "--no-browser", action="store_true", help="Do not open the browser automatically", ) return parser.parse_args() if __name__ == "__main__": args = _parse_args() port = _pick_available_port(args.port) local_host = "127.0.0.1" if args.host == "0.0.0.0" else args.host print("AURIS local demo") print(f"Host: {args.host}") print(f"Port: {port}") print(f"Open: http://{local_host}:{port}") demo.launch( server_name=args.host, server_port=port, share=False, inbrowser=not args.no_browser, show_error=True, css=AURIS_CSS, )