Update app.py

app.py

@@ -2,264 +2,151 @@ import gradio as gr
 import os
 import tempfile
 import requests
-from moviepy.editor import VideoFileClip
+import subprocess
 import random
-import json
-
-# --- Lightweight AccentAnalyzer class ---
-
+import matplotlib.pyplot as plt
+import torchaudio
+import torch
+
+# --- Load SpeechBrain ---
+try:
+    from speechbrain.inference import EncoderClassifier
+    speechbrain_classifier = EncoderClassifier.from_hparams(
+        source="speechbrain/lang-id-commonlanguage_ecapa",
+        savedir="pretrained_models/lang-id-commonlanguage_ecapa"
+    )
+    SPEECHBRAIN_LOADED = True
+except Exception as e:
+    print(f"Error loading SpeechBrain model: {e}. Simulated mode ON.")
+    SPEECHBRAIN_LOADED = False
+
+# --- Accent Analyzer Class ---
 class AccentAnalyzer:
     def __init__(self):
         self.accent_profiles = {
-            "American": {
-                "features": ["rhotic", "flapped_t", "cot_caught_merger"],
-                "description": "American English accent with rhotic pronunciation and typical North American features."
-            },
-            "British": {
-                "features": ["non_rhotic", "t_glottalization", "trap_bath_split"],
-                "description": "British English accent with non-rhotic pronunciation and typical UK features."
-            },
-            "Australian": {
-                "features": ["non_rhotic", "flat_a", "high_rising_terminal"],
-                "description": "Australian English accent with distinctive vowel sounds and intonation patterns."
-            },
-            "Canadian": {
-                "features": ["rhotic", "canadian_raising", "eh_tag"],
-                "description": "Canadian English accent with features of both American and British English."
-            },
-            "Indian": {
-                "features": ["retroflex_consonants", "monophthongization", "syllable_timing"],
-                "description": "Indian English accent influenced by native Indian languages."
-            },
-            "Irish": {
-                "features": ["dental_fricatives", "alveolar_l", "soft_consonants"],
-                "description": "Irish English accent with distinctive rhythm and consonant patterns."
-            },
-            "Scottish": {
-                "features": ["rolled_r", "monophthongs", "glottal_stops"],
-                "description": "Scottish English accent with strong consonants and distinctive vowel patterns."
-            },
-            "South African": {
-                "features": ["non_rhotic", "kit_split", "kw_hw_distinction"],
-                "description": "South African English accent with influences from Afrikaans and other local languages."
-            }
+            "American": {"features": ["rhotic", "flapped_t", "cot_caught_merger"]},
+            "British": {"features": ["non_rhotic", "t_glottalization", "trap_bath_split"]},
+            "Australian": {"features": ["non_rhotic", "flat_a", "high_rising_terminal"]},
+            "Canadian": {"features": ["rhotic", "canadian_raising", "eh_tag"]},
+            "Indian": {"features": ["retroflex_consonants", "monophthongization", "syllable_timing"]},
+            "Irish": {"features": ["dental_fricatives", "alveolar_l", "soft_consonants"]},
+            "Scottish": {"features": ["rolled_r", "monophthongs", "glottal_stops"]},
+            "South African": {"features": ["non_rhotic", "kit_split", "kw_hw_distinction"]}
         }
-        self._load_or_create_accent_data()
-
-    def _load_or_create_accent_data(self):
-        # For demo: just create simulated data in-memory
-        self.accent_data = self._create_simulated_accent_data()
+        self.accent_data = self._simulate_profiles()
 
-    def _create_simulated_accent_data(self):
-        accent_data = {}
-        for accent, profile in self.accent_profiles.items():
-            accent_data[accent] = {
+    def _simulate_profiles(self):
+        all_features = set(f for p in self.accent_profiles.values() for f in p["features"])
+        data = {}
+        for name, profile in self.accent_profiles.items():
+            data[name] = {
                 "primary_features": profile["features"],
-                "feature_probabilities": {}
+                "feature_probabilities": {
+                    f: random.uniform(0.7, 0.9) if f in profile["features"] else random.uniform(0.1, 0.4)
+                    for f in all_features
+                }
             }
-            for feature in profile["features"]:
-                accent_data[accent]["feature_probabilities"][feature] = random.uniform(0.7, 0.9)
-            all_features = set()
-            for a, p in self.accent_profiles.items():
-                all_features.update(p["features"])
-            for feature in all_features:
-                if feature not in profile["features"]:
-                    accent_data[accent]["feature_probabilities"][feature] = random.uniform(0.1, 0.4)
-        return accent_data
+        return data
 
-    def _extract_features(self, audio_path):
-        # This is a simulated feature extraction for the demo.
-        # In a real application, this would use SpeechBrain or similar ML models
-        # to extract actual phonetic features from the audio.
-        all_features = set()
-        for accent, profile in self.accent_profiles.items():
-            all_features.update(profile["features"])
-        detected_features = {}
-        for feature in all_features:
-            # Simulate detection of features with varying probabilities
-            detected_features[feature] = random.uniform(0.1, 0.9)
-        return detected_features
-
-    def _calculate_accent_scores(self, detected_features):
-        accent_scores = {}
+    def _simulate_accent_classification(self, audio_path):
+        all_features = {f for p in self.accent_profiles.values() for f in p["features"]}
+        detected = {f: random.uniform(0.1, 0.9) for f in all_features}
+        scores = {}
         for accent, data in self.accent_data.items():
-            score = 0
-            total_weight = 0
-            for feature, probability in detected_features.items():
-                expected_prob = data["feature_probabilities"].get(feature, 0.1)
-                weight = 3.0 if feature in data["primary_features"] else 1.0 # Give more weight to primary features
-                feature_score = probability * expected_prob * weight
-                score += feature_score
-                total_weight += weight
-            if total_weight > 0:
-                accent_scores[accent] = (score / total_weight) * 100
-            else:
-                accent_scores[accent] = 0
-        return accent_scores
-
-    def _generate_explanation(self, accent_type, confidence):
-        if confidence >= 70:
-            confidence_level = "high confidence"
-            certainty = "is very clear"
-        elif confidence >= 50:
-            confidence_level = "moderate confidence"
-            certainty = "is present"
-        else:
-            confidence_level = "low confidence"
-            certainty = "may be present"
-        description = self.accent_profiles[accent_type]["description"]
-        second_accent = self._get_second_most_likely_accent(accent_type)
-        explanation = f"The speaker has a {confidence_level} {accent_type} English accent. The {accent_type} accent {certainty}, with features of both {accent_type} and {second_accent} English present."
-        return explanation
-
-    def _get_second_most_likely_accent(self, primary_accent):
-        # Simple rule-based selection for demo purposes
-        accent_similarities = {
-            "American": ["Canadian", "British"],
-            "British": ["Australian", "Irish"],
-            "Australian": ["British", "South African"],
-            "Canadian": ["American", "British"],
-            "Indian": ["British", "South African"],
-            "Irish": ["Scottish", "British"],
-            "Scottish": ["Irish", "British"],
-            "South African": ["Australian", "British"]
-        }
-        # Pick a random similar accent from the predefined list
-        return random.choice(accent_similarities[primary_accent])
-
-    def analyze_accent(self, audio_path):
-        """
-        Analyzes the accent from an audio file.
-        In this demo, it simulates feature extraction and accent scoring.
-        """
-        detected_features = self._extract_features(audio_path)
-        accent_scores = self._calculate_accent_scores(detected_features)
-        
-        # Find the accent with the highest score
-        accent_type = max(accent_scores, key=accent_scores.get)
-        confidence = accent_scores[accent_type]
-        
-        explanation = self._generate_explanation(accent_type, confidence)
-        
+            score = sum(
+                detected[f] * data["feature_probabilities"][f] * (3.0 if f in data["primary_features"] else 1.0)
+                for f in all_features
+            )
+            scores[accent] = score
+        top = max(scores, key=scores.get)
+        conf = (scores[top] / max(scores.values())) * 100
         return {
-            "accent_type": accent_type,
-            "confidence": confidence,
-            "explanation": explanation,
-            "all_scores": accent_scores # Useful for debugging or more detailed display
+            "accent_type": top,
+            "confidence": conf,
+            "explanation": f"Detected **{top}** accent with {conf:.1f}% confidence.",
+            "all_scores": scores
         }
 
-# --- Utility: Download video and extract audio ---
+    def analyze_accent(self, audio_path):
+        if not SPEECHBRAIN_LOADED:
+            return self._simulate_accent_classification(audio_path)
+        try:
+            signal, sr = torchaudio.load(audio_path)
+            if sr != 16000:
+                signal = torchaudio.transforms.Resample(sr, 16000)(signal)
+            if signal.shape[0] > 1:
+                signal = signal.mean(dim=0, keepdim=True)
+            pred = speechbrain_classifier.classify_batch(signal.unsqueeze(0))
+            probs = pred[0].squeeze(0).tolist()
+            labels = pred[1][0]
+            scores = {speechbrain_classifier.hparams.label_encoder.ind2lab[i]: p * 100 for i, p in enumerate(probs)}
+            if labels[0] == 'en':
+                result = self._simulate_accent_classification(audio_path)
+                result["all_scores"] = scores
+                return result
+            return {
+                "accent_type": labels[0],
+                "confidence": max(probs) * 100,
+                "explanation": f"Detected language: **{labels[0]}** ({max(probs)*100:.1f}%)",
+                "all_scores": scores
+            }
+        except Exception as e:
+            print(f"Fallback to simulation: {e}")
+            return self._simulate_accent_classification(audio_path)
 
+# --- Download & Extract Audio ---
 def download_and_extract_audio(url):
-    """
-    Downloads a video from a URL and extracts its audio to a WAV file.
-    Handles both direct MP4 links and YouTube URLs (using pytubefix).
-    """
     temp_dir = tempfile.mkdtemp()
     video_path = os.path.join(temp_dir, "video.mp4")
     audio_path = os.path.join(temp_dir, "audio.wav")
 
-    try:
-        # Download video
-        # Check for YouTube URL patterns (simplified for demo)
-        if "youtube.com/" in url or "youtu.be/" in url:
-            try:
-                from pytubefix import YouTube
-                yt = YouTube(url)
-                # Try to get a progressive stream (video + audio)
-                stream = yt.streams.filter(progressive=True, file_extension='mp4').order_by('resolution').desc().first()
-                if not stream:
-                    # Fallback to separate audio stream if progressive not found
-                    stream = yt.streams.filter(only_audio=True).first()
-                    if not stream:
-                        raise RuntimeError("No suitable video or audio stream found for YouTube URL.")
-                
-                # Download the stream
-                stream.download(output_path=temp_dir, filename="video.mp4")
-            except ImportError:
-                raise ImportError("pytubefix is not installed. Please install it with 'pip install pytubefix'.")
-            except Exception as e:
-                # Catch specific YouTube errors, e.g., age restriction, unavailable
-                raise RuntimeError(f"Error downloading YouTube video: {e}. Try running locally or use a direct MP4 link.")
-        else:
-            # Direct MP4 download
-            response = requests.get(url, stream=True)
-            response.raise_for_status() # Raise an exception for bad status codes (4xx or 5xx)
-            with open(video_path, "wb") as f:
-                for chunk in response.iter_content(chunk_size=8192):
+    if "youtube.com" in url or "youtu.be" in url:
+        from pytubefix import YouTube
+        yt = YouTube(url)
+        stream = yt.streams.filter(progressive=True, file_extension='mp4').first()
+        stream.download(output_path=temp_dir, filename="video.mp4")
+    else:
+        with requests.get(url, stream=True) as r:
+            r.raise_for_status()
+            with open(video_path, 'wb') as f:
+                for chunk in r.iter_content(chunk_size=8192):
                     f.write(chunk)
-        
-        # Extract audio using moviepy
-        clip = VideoFileClip(video_path)
-        clip.audio.write_audiofile(audio_path, logger=None) # logger=None suppresses moviepy output
-        clip.close()
-        
-        return audio_path
-    finally:
-        # Clean up the video file immediately after audio extraction
-        if os.path.exists(video_path):
-            os.remove(video_path)
-        # The temp_dir itself will be handled by Gradio's internal tempfile management,
-        # or you can add os.rmdir(temp_dir) if you manage temp_dir manually.
 
-# --- Gradio interface ---
+    # Extract audio using ffmpeg
+    subprocess.run([
+        "ffmpeg", "-i", video_path, "-ar", "16000", "-ac", "1", "-f", "wav", audio_path, "-y"
+    ], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
 
-def analyze_from_url(url):
-    """
-    Gradio interface function to analyze accent from a given video URL.
-    """
-    if not url:
-        return "Please enter a video URL.", "N/A", "No URL provided."
+    return audio_path
 
+# --- Gradio Function ---
+def analyze_from_url_gradio(url):
+    if not url:
+        return "Please enter a URL.", plt.figure()
     try:
         audio_path = download_and_extract_audio(url)
         analyzer = AccentAnalyzer()
         results = analyzer.analyze_accent(audio_path)
-        
-        # Clean up the temporary audio file after analysis
-        if os.path.exists(audio_path):
-            os.remove(audio_path)
 
-        return (
-            results["accent_type"],
-            f"{results['confidence']:.1f}%",
-            results["explanation"]
-        )
+        labels, values = zip(*results["all_scores"].items())
+        fig, ax = plt.subplots()
+        ax.bar(labels, values)
+        ax.set_ylabel('Confidence (%)')
+        ax.set_title('Accent/Language Confidence')
+        plt.xticks(rotation=45)
+        plt.tight_layout()
+
+        return results["explanation"], fig
     except Exception as e:
-        # Catch and display any errors during the process
-        return (
-            "Error",
-            "0%",
-            f"Error processing video/audio: {e}. Please ensure the URL is valid and publicly accessible."
-        )
+        return f"Error: {e}", plt.figure()
 
-# Create the Gradio interface
+# --- Gradio Interface ---
 iface = gr.Interface(
-    fn=analyze_from_url,
-    inputs=gr.Textbox(
-        label="Enter Public Video URL (YouTube or direct MP4)",
-        placeholder="e.g., https://www.youtube.com/watch?v=dQw4w9WgXcQ or https://samplelib.com/lib/preview/mp4/sample-5s.mp4"
-    ),
-    outputs=[
-        gr.Textbox(label="Detected Accent"),
-        gr.Textbox(label="Confidence Score"),
-        gr.Textbox(label="Explanation")
-    ],
-    title="English Accent Analyzer (Rule-Based Demo)",
-    description="""
-    Paste a public video URL (YouTube or direct MP4) to detect the English accent and confidence score.
-    
-    **Important Notes:**
-    * This is a **DEMO** using a simulated accent analysis model, not a real machine learning model.
-    * It uses `pytubefix` for YouTube links and `requests`/`moviepy` for direct MP4s.
-    * YouTube video extraction can sometimes be temperamental due to YouTube's changing policies or region restrictions. Direct MP4 links are generally more reliable.
-    * **Sample MP4 URL for testing:** `https://samplelib.com/lib/preview/mp4/sample-5s.mp4`
-    """
+    fn=analyze_from_url_gradio,
+    inputs=gr.Textbox(label="Enter Public Video URL (YouTube or MP4)"),
+    outputs=[gr.Textbox(label="Result"), gr.Plot(label="Confidence Plot")],
+    title="English Accent or Language Analyzer",
+    description="Paste a public video URL. The system will detect the accent or language spoken using SpeechBrain or simulation."
 )
 
-# Launch the Gradio interface
-# `share=False` for local deployment (no public link generated)
-# For Hugging Face Spaces, you typically don't need `iface.launch()` as the platform handles it.
-# However, if you're running it locally to test before deployment, keep this block.
-if __name__ == "__main__":
-    iface.launch(debug=True, share=False)
+iface.launch()