Spaces:
Sleeping
Sleeping
| import streamlit as st | |
| import requests | |
| import tempfile | |
| import os | |
| from pathlib import Path | |
| import subprocess | |
| import speech_recognition as sr | |
| from pydub import AudioSegment | |
| import re | |
| import numpy as np | |
| from typing import Dict, Tuple, Optional | |
| import json | |
| class AccentDetector: | |
| """ | |
| Accent detection system that analyzes English speech patterns | |
| to classify regional accents and provide confidence scores. | |
| """ | |
| def __init__(self): | |
| self.accent_patterns = { | |
| 'American': { | |
| 'keywords': ['gonna', 'wanna', 'gotta', 'kinda', 'sorta'], | |
| 'phonetic_markers': ['r-colored vowels', 'rhotic'], | |
| 'vocabulary': ['elevator', 'apartment', 'garbage', 'vacation', 'cookie'] | |
| }, | |
| 'British': { | |
| 'keywords': ['brilliant', 'lovely', 'quite', 'rather', 'chap'], | |
| 'phonetic_markers': ['non-rhotic', 'received pronunciation'], | |
| 'vocabulary': ['lift', 'flat', 'rubbish', 'holiday', 'biscuit'] | |
| }, | |
| 'Australian': { | |
| 'keywords': ['mate', 'bloody', 'fair dinkum', 'crikey', 'reckon'], | |
| 'phonetic_markers': ['broad vowels', 'rising intonation'], | |
| 'vocabulary': ['arvo', 'brekkie', 'servo', 'bottle-o', 'mozzie'] | |
| }, | |
| 'Canadian': { | |
| 'keywords': ['eh', 'about', 'house', 'out', 'sorry'], | |
| 'phonetic_markers': ['canadian raising', 'eh particle'], | |
| 'vocabulary': ['toque', 'hydro', 'washroom', 'parkade', 'chesterfield'] | |
| }, | |
| 'South African': { | |
| 'keywords': ['ag', 'man', 'hey', 'lekker', 'braai'], | |
| 'phonetic_markers': ['kit-split', 'dental fricatives'], | |
| 'vocabulary': ['robot', 'bakkie', 'boerewors', 'biltong', 'sosatie'] | |
| } | |
| } | |
| def download_video(self, url: str) -> str: | |
| """Download video from URL to temporary file""" | |
| try: | |
| response = requests.get(url, stream=True, timeout=30) | |
| response.raise_for_status() | |
| # Create temporary file | |
| with tempfile.NamedTemporaryFile(delete=False, suffix='.mp4') as temp_file: | |
| for chunk in response.iter_content(chunk_size=8192): | |
| temp_file.write(chunk) | |
| return temp_file.name | |
| except Exception as e: | |
| raise Exception(f"Failed to download video: {str(e)}") | |
| def extract_audio(self, video_path: str) -> str: | |
| """Extract audio from video file using ffmpeg""" | |
| try: | |
| audio_path = video_path.replace('.mp4', '.wav') | |
| # Use ffmpeg to extract audio | |
| cmd = [ | |
| 'ffmpeg', '-i', video_path, '-vn', '-acodec', 'pcm_s16le', | |
| '-ar', '16000', '-ac', '1', '-y', audio_path | |
| ] | |
| result = subprocess.run(cmd, capture_output=True, text=True) | |
| if result.returncode != 0: | |
| # Fallback to pydub if ffmpeg fails | |
| audio = AudioSegment.from_file(video_path) | |
| audio = audio.set_frame_rate(16000).set_channels(1) | |
| audio.export(audio_path, format="wav") | |
| return audio_path | |
| except Exception as e: | |
| raise Exception(f"Failed to extract audio: {str(e)}") | |
| def transcribe_audio(self, audio_path: str) -> str: | |
| """Transcribe audio to text using speech recognition""" | |
| try: | |
| r = sr.Recognizer() | |
| with sr.AudioFile(audio_path) as source: | |
| # Adjust for ambient noise | |
| r.adjust_for_ambient_noise(source, duration=0.5) | |
| audio_data = r.record(source) | |
| # Use Google Speech Recognition (free tier) | |
| text = r.recognize_google(audio_data, language='en-US') | |
| return text.lower() | |
| except sr.UnknownValueError: | |
| raise Exception("Could not understand the audio") | |
| except sr.RequestError as e: | |
| raise Exception(f"Speech recognition error: {str(e)}") | |
| def analyze_accent_patterns(self, text: str) -> Dict[str, float]: | |
| """Analyze text for accent-specific patterns""" | |
| scores = {} | |
| words = text.split() | |
| word_count = len(words) | |
| if word_count == 0: | |
| return {accent: 0.0 for accent in self.accent_patterns.keys()} | |
| for accent, patterns in self.accent_patterns.items(): | |
| score = 0.0 | |
| matches = 0 | |
| # Check for accent-specific keywords | |
| for keyword in patterns['keywords']: | |
| if keyword in text: | |
| score += 15.0 | |
| matches += 1 | |
| # Check for accent-specific vocabulary | |
| for vocab_word in patterns['vocabulary']: | |
| if vocab_word in text: | |
| score += 10.0 | |
| matches += 1 | |
| # Normalize score based on text length and matches | |
| if matches > 0: | |
| score = min(score * (matches / word_count) * 100, 95.0) | |
| else: | |
| # Base score for general English patterns | |
| score = self._calculate_base_score(text, accent) | |
| scores[accent] = round(score, 1) | |
| return scores | |
| def _calculate_base_score(self, text: str, accent: str) -> float: | |
| """Calculate base confidence score for accent detection""" | |
| # Simple heuristics based on common patterns | |
| base_scores = { | |
| 'American': 25.0, # Default higher for American English | |
| 'British': 15.0, | |
| 'Australian': 10.0, | |
| 'Canadian': 12.0, | |
| 'South African': 8.0 | |
| } | |
| # Adjust based on text characteristics | |
| score = base_scores.get(accent, 10.0) | |
| # Look for spelling patterns | |
| if accent == 'British' and ('colour' in text or 'favour' in text or 'centre' in text): | |
| score += 20.0 | |
| elif accent == 'American' and ('color' in text or 'favor' in text or 'center' in text): | |
| score += 20.0 | |
| return min(score, 40.0) # Cap base scores | |
| def classify_accent(self, scores: Dict[str, float]) -> Tuple[str, float, str]: | |
| """Classify the most likely accent and provide explanation""" | |
| if not scores or all(score == 0 for score in scores.values()): | |
| return "Unknown", 0.0, "Insufficient accent markers detected" | |
| # Find the highest scoring accent | |
| top_accent = max(scores.items(), key=lambda x: x[1]) | |
| accent_name, confidence = top_accent | |
| # Generate explanation | |
| explanation = self._generate_explanation(accent_name, confidence, scores) | |
| return accent_name, confidence, explanation | |
| def _generate_explanation(self, accent: str, confidence: float, all_scores: Dict[str, float]) -> str: | |
| """Generate explanation for the accent classification""" | |
| if confidence < 20: | |
| return f"Low confidence detection. The speech patterns are not strongly indicative of any specific English accent." | |
| elif confidence < 50: | |
| return f"Moderate confidence in {accent} accent based on limited linguistic markers." | |
| elif confidence < 75: | |
| return f"Good confidence in {accent} accent. Several characteristic patterns detected." | |
| else: | |
| return f"High confidence in {accent} accent with strong linguistic indicators." | |
| def process_video(self, url: str) -> Dict: | |
| """Main processing pipeline""" | |
| temp_files = [] | |
| try: | |
| # Step 1: Download video | |
| st.write("📥 Downloading video...") | |
| video_path = self.download_video(url) | |
| temp_files.append(video_path) | |
| # Step 2: Extract audio | |
| st.write("🎵 Extracting audio...") | |
| audio_path = self.extract_audio(video_path) | |
| temp_files.append(audio_path) | |
| # Step 3: Transcribe audio | |
| st.write("🎤 Transcribing speech...") | |
| transcript = self.transcribe_audio(audio_path) | |
| # Step 4: Analyze accent | |
| st.write("🔍 Analyzing accent patterns...") | |
| accent_scores = self.analyze_accent_patterns(transcript) | |
| accent, confidence, explanation = self.classify_accent(accent_scores) | |
| return { | |
| 'success': True, | |
| 'transcript': transcript, | |
| 'accent': accent, | |
| 'confidence': confidence, | |
| 'explanation': explanation, | |
| 'all_scores': accent_scores | |
| } | |
| except Exception as e: | |
| return { | |
| 'success': False, | |
| 'error': str(e) | |
| } | |
| finally: | |
| # Cleanup temporary files | |
| for temp_file in temp_files: | |
| try: | |
| if os.path.exists(temp_file): | |
| os.remove(temp_file) | |
| except: | |
| pass | |
| def main(): | |
| st.set_page_config( | |
| page_title="English Accent Detector", | |
| page_icon="🎤", | |
| layout="wide" | |
| ) | |
| st.title("🎤 English Accent Detection Tool") | |
| st.markdown("### Analyze English accents from video content") | |
| st.markdown(""" | |
| **How it works:** | |
| 1. Paste a public video URL (MP4, Loom, etc.) | |
| 2. The tool extracts audio and transcribes speech | |
| 3. AI analyzes linguistic patterns to detect English accent | |
| 4. Get classification, confidence score, and explanation | |
| """) | |
| # Input section | |
| st.subheader("📹 Video Input") | |
| video_url = st.text_input( | |
| "Enter video URL:", | |
| placeholder="https://example.com/video.mp4 or Loom link", | |
| help="Must be a direct video link or public Loom video" | |
| ) | |
| # Process button | |
| if st.button("🚀 Analyze Accent", type="primary"): | |
| if not video_url: | |
| st.error("Please enter a video URL") | |
| return | |
| # Validate URL | |
| if not (video_url.startswith('http://') or video_url.startswith('https://')): | |
| st.error("Please enter a valid URL starting with http:// or https://") | |
| return | |
| # Initialize detector | |
| detector = AccentDetector() | |
| # Process video | |
| with st.spinner("Processing video... This may take a few minutes."): | |
| result = detector.process_video(video_url) | |
| # Display results | |
| if result['success']: | |
| st.success("✅ Analysis Complete!") | |
| # Main results | |
| col1, col2 = st.columns(2) | |
| with col1: | |
| st.metric( | |
| label="🗣️ Detected Accent", | |
| value=result['accent'] | |
| ) | |
| with col2: | |
| st.metric( | |
| label="🎯 Confidence Score", | |
| value=f"{result['confidence']}%" | |
| ) | |
| # Explanation | |
| st.subheader("📝 Analysis Explanation") | |
| st.write(result['explanation']) | |
| # Transcript | |
| st.subheader("📄 Transcript") | |
| st.text_area("Transcribed Text:", result['transcript'], height=100) | |
| # Detailed scores | |
| st.subheader("📊 Detailed Accent Scores") | |
| scores_df = [] | |
| for accent, score in result['all_scores'].items(): | |
| scores_df.append({"Accent": accent, "Confidence": f"{score}%"}) | |
| st.table(scores_df) | |
| else: | |
| st.error(f"❌ Error: {result['error']}") | |
| # Footer | |
| st.markdown("---") | |
| st.markdown(""" | |
| **Technical Notes:** | |
| - Supports common video formats (MP4, MOV, AVI) | |
| - Works with public Loom videos and direct video links | |
| - Analyzes vocabulary, pronunciation patterns, and linguistic markers | |
| - Optimized for English language detection | |
| """) | |
| if __name__ == "__main__": | |
| main() |