Add application file

README.md

@@ -1,13 +1,34 @@
 ---
-title: AccentDetect
-emoji: 🐠
-colorFrom: gray
-colorTo: red
+title: English Accent Detector
+emoji: 🎙️
+colorFrom: blue
+colorTo: green
 sdk: gradio
 sdk_version: 5.31.0
 app_file: app.py
 pinned: false
-short_description: 'tool for detecting and classifying English accents '
+short_description: Analyze speaker's accent from video URLs with English detection
 ---
+# English Accent Detector
+
+A Gradio-based tool for detecting and classifying English accents from public video URLs (e.g., YouTube, Loom). It first determines if the speaker is speaking English, then analyzes accent patterns with confidence scores for American, British, Australian, and other English variants.
+
+---
+
+## 🚀 Features
+
+* **Public URL support**: Download audio from YouTube, Loom, or direct MP4 links via `yt_dlp`.
+* **English language detection**: Uses SpeechBrain's language-ID model to filter for English speakers.
+* **Random-slice sampling**: Analyzes multiple random 8-second windows for robust classification.
+* **Accent classification**: Classifies each slice using a pretrained ECAPA model and aggregates results.
+* **Comprehensive confidence scoring**: Returns English detection confidence and accent classification scores.
+* **Interactive UI**: Simple Gradio interface—paste URL, choose sample count, click *Analyze Accent*.
+
+---
+
+## 🛠️ Requirements
+
+* Python 3.8+ (tested on 3.10)
+* Dependencies listed in `requirements.txt`
+
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,253 @@
+#!/usr/bin/env python3
+"""
+English Accent Detector - Analyzes speaker's accent from video URLs
+"""
+from __future__ import annotations
+import argparse, random, tempfile
+from collections import Counter
+from pathlib import Path
+
+import torch
+import torchaudio
+import gradio as gr
+from speechbrain.inference.classifiers import EncoderClassifier
+from yt_dlp import YoutubeDL
+
+# ─────────────── Model setup ───────────────
+ACCENT_MODEL_ID = "Jzuluaga/accent-id-commonaccent_ecapa"
+LANG_MODEL_ID   = "speechbrain/lang-id-voxlingua107-ecapa"
+
+# Force CPU
+DEVICE = "cpu"
+
+accent_clf = EncoderClassifier.from_hparams(
+    source=ACCENT_MODEL_ID,
+    run_opts={"device": DEVICE}
+)
+lang_clf = EncoderClassifier.from_hparams(
+    source=LANG_MODEL_ID,
+    run_opts={"device": DEVICE}
+)
+
+# ─────────────── Helpers ───────────────
+def sec_to_hms(sec: int) -> str:
+    h = sec // 3600
+    m = (sec % 3600) // 60
+    s = sec % 60
+    return f"{h:02d}:{m:02d}:{s:02d}"
+
+def download_audio(url: str, out_path: Path) -> Path:
+    """
+    Download best audio only via yt_dlp Python API.
+    Returns the actual file saved (could be .m4a, .webm, etc.).
+    """
+    opts = {
+        "format": "bestaudio/best",
+        "outtmpl": str(out_path.with_suffix(".%(ext)s")),
+        "postprocessors": [],  
+        "quiet": True,
+    }
+    with YoutubeDL(opts) as ydl:
+        info = ydl.extract_info(url, download=True)
+        filename = ydl.prepare_filename(info)
+    return Path(filename)
+
+def extract_wav(src: Path, dst: Path, start: int, dur: int = 8) -> None:
+    target_sr = 16000
+    offset = start * target_sr
+    frames = dur   * target_sr
+
+    wav, orig_sr = torchaudio.load(str(src),
+                                   frame_offset=offset,
+                                   num_frames=frames)
+    if orig_sr != target_sr:
+        wav = torchaudio.transforms.Resample(orig_sr, target_sr)(wav)
+
+    torchaudio.save(str(dst), wav, target_sr,
+                    encoding="PCM_S", bits_per_sample=16)
+
+def pick_random_offsets(total_s: int, n: int) -> list[int]:
+    max_start = total_s - 8
+    pool = list(range(max_start + 1))
+    if n > len(pool):
+        n = len(pool)
+    return random.sample(pool, n)
+
+# ─────────────── Classification ───────────────
+def classify_language(wav: Path) -> tuple[str, float]:
+    sig = lang_clf.load_audio(str(wav))
+    _, log_p, _, label = lang_clf.classify_batch(sig)
+    return label[0], float(log_p.exp().item()) * 100
+
+def classify_accent(wav: Path) -> tuple[str, float]:
+    sig = accent_clf.load_audio(str(wav))
+    _, log_p, _, label = accent_clf.classify_batch(sig)
+    return label[0], float(log_p.item()) * 100
+
+def calculate_english_confidence(lang: str, lang_conf: float, accent_conf: float) -> float:
+    """
+    Calculate overall English accent confidence score (0-100%)
+    """
+    if not lang.lower().startswith("en"):
+        return 0.0
+    
+    # Combine language confidence and accent confidence
+    # Weight language detection more heavily as it's the primary filter
+    english_score = (lang_conf * 0.7) + (accent_conf * 0.3)
+    return min(100.0, max(0.0, english_score))
+
+# ─────────────── Core pipeline ───────────────
+def analyse_accent(url: str, n_samples: int = 4) -> dict:
+    """
+    Main function to analyze accent from video URL
+    """
+    if not url:
+        return {"error": "Please provide a video URL."}
+    if n_samples < 1:
+        return {"error": "Number of samples must be at least 1."}
+
+    with tempfile.TemporaryDirectory() as td:
+        td = Path(td)
+        
+        try:
+            # 1) Download audio from video
+            audio_file = td / "audio"
+            audio_file = download_audio(url, audio_file)
+
+            # 2) Read metadata for total seconds
+            info = torchaudio.info(str(audio_file))
+            total_s = int(info.num_frames / info.sample_rate)
+            if total_s < 8:
+                return {"error": "Audio shorter than 8 seconds."}
+
+            # 3) Language detection on middle slice
+            mid_start = max(0, total_s // 2 - 4)
+            lang_wav = td / "lang_check.wav"
+            extract_wav(audio_file, lang_wav, start=mid_start)
+            lang, lang_conf = classify_language(lang_wav)
+            
+            # 4) Check if English is detected
+            is_english = lang.lower().startswith("en")
+            
+            if not is_english:
+                return {
+                    "is_english_speaker": False,
+                    "detected_language": lang,
+                    "language_confidence": round(lang_conf, 1),
+                    "accent_classification": "N/A",
+                    "english_confidence_score": 0.0,
+                    "summary": f"Non-English language detected: {lang} ({lang_conf:.1f}%)"
+                }
+
+            # 5) Accent analysis on multiple random slices
+            offsets = pick_random_offsets(total_s, n_samples)
+            accent_results = []
+            
+            for i, start in enumerate(sorted(offsets)):
+                clip_wav = td / f"clip_{i}.wav"
+                extract_wav(audio_file, clip_wav, start=start)
+                acc, conf = classify_accent(clip_wav)
+                accent_results.append({
+                    "clip": i + 1,
+                    "time_range": f"{sec_to_hms(start)} - {sec_to_hms(start + 8)}",
+                    "accent": acc,
+                    "confidence": round(conf, 1),
+                })
+
+            # 6) Determine overall accent classification
+            accent_labels = [r["accent"] for r in accent_results]
+            accent_counter = Counter(accent_labels)
+            most_common_accent, accent_count = accent_counter.most_common(1)[0]
+            
+            # Calculate average confidence for the most common accent
+            matching_confidences = [r["confidence"] for r in accent_results 
+                                  if r["accent"] == most_common_accent]
+            avg_accent_conf = sum(matching_confidences) / len(matching_confidences)
+            
+            # Calculate overall English confidence score
+            english_confidence = calculate_english_confidence(lang, lang_conf, avg_accent_conf)
+
+            return {
+                "is_english_speaker": True,
+                "detected_language": "English",
+                "language_confidence": round(lang_conf, 1),
+                "accent_classification": most_common_accent,
+                "accent_confidence": round(avg_accent_conf, 1),
+                "english_confidence_score": round(english_confidence, 1),
+                "samples_analyzed": len(accent_results),
+                "consensus": f"{accent_count}/{n_samples} samples",
+                "detailed_results": accent_results,
+                "summary": (
+                    f"English speaker detected with {most_common_accent} accent "
+                    f"(confidence: {english_confidence:.1f}%)"
+                )
+            }
+            
+        except Exception as e:
+            return {"error": f"Processing failed: {str(e)}"}
+
+# ─────────────── Gradio UI ───────────────
+def app():
+    with gr.Blocks(title="English Accent Detector") as demo:
+        gr.Markdown(
+            "# 🎙️ English Accent Detector\n"
+            "**Analyze speaker's accent from video URLs**\n\n"
+            "This tool:\n"
+            "1. Accepts public video URLs (YouTube, Loom, direct MP4 links)\n"
+            "2. Extracts audio from the video\n"
+            "3. Analyzes if the speaker is an English language candidate\n"
+            "4. Classifies the accent type and provides confidence scores\n"
+        )
+        
+        with gr.Row():
+            with gr.Column():
+                url_input = gr.Text(
+                    label="Video URL", 
+                    placeholder="Enter public video URL (YouTube, Loom, etc.)",
+                    lines=1
+                )
+                samples_input = gr.Slider(
+                    minimum=1, 
+                    maximum=10, 
+                    value=4, 
+                    step=1,
+                    label="Number of audio samples to analyze",
+                    info="More samples = more accurate but slower"
+                )
+                analyze_btn = gr.Button("🔍 Analyze Accent", variant="primary")
+            
+            with gr.Column():
+                result_output = gr.JSON(
+                    label="Analysis Results",
+                    show_label=True
+                )
+
+        # Examples
+        gr.Markdown("### Example URLs to try:")
+        gr.Examples(
+            examples=[
+                ["https://www.youtube.com/watch?v=dQw4w9WgXcQ", 4],
+                ["https://www.youtube.com/shorts/VO6n9GTzSqU", 4],
+            ],
+            inputs=[url_input, samples_input],
+            label="Click to load example"
+        )
+
+        analyze_btn.click(
+            fn=analyse_accent,
+            inputs=[url_input, samples_input],
+            outputs=result_output
+        )
+        
+    return demo
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="English Accent Detector")
+    parser.add_argument("--share", action="store_true",
+                        help="Enable public share link")
+    parser.add_argument("--port", type=int, default=7860,
+                        help="Port to run the server on")
+    args = parser.parse_args()
+    
+    demo = app()
+    demo.launch(share=args.share, server_port=args.port)

requirements.txt

@@ -0,0 +1,5 @@
+gradio>=3.0
+torch
+torchaudio
+speechbrain
+yt-dlp