Upload 4 files

main2.py

@@ -0,0 +1,739 @@
+import os
+import tempfile
+import numpy as np
+import pandas as pd
+import torch
+import torchaudio
+import librosa
+import matplotlib.pyplot as plt
+import csv
+from typing import List, Dict, Tuple, Optional
+from scipy.stats import kurtosis, skew
+import concurrent.futures
+import multiprocessing
+from functools import partial
+import time
+import threading
+from queue import Queue
+from dotenv import load_dotenv
+from groq import Groq 
+
+# Import required models
+from pyannote.audio import Pipeline
+import whisper
+from transformers import Wav2Vec2ForSequenceClassification, Wav2Vec2Processor
+from torch_vggish_yamnet import yamnet
+from torch_vggish_yamnet.input_proc import WaveformToInput
+import warnings
+warnings.filterwarnings("ignore")
+
+class UnifiedAudioAnalyzer:
+    """
+    Unified Audio Analysis System combining:
+    1. Speaker Diarization + Transcription
+    2. Audio Event Detection (YAMNet)
+    3. Emotion Recognition + Paralinguistic Features
+    
+    Enhanced with parallel processing for faster execution
+    """
+    
+    def __init__(self, enable_parallel_processing=True, max_workers=None):
+        """Initialize all models and components"""
+        print("🔄 Initializing Unified Audio Analyzer...")
+        
+        # Configure device
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        print(f"Using device: {self.device}")
+        
+        # Parallel processing settings
+        self.enable_parallel_processing = enable_parallel_processing
+        self.max_workers = max_workers or max(1, multiprocessing.cpu_count() - 1)
+        print(f"Parallel processing: {'Enabled' if enable_parallel_processing else 'Disabled'}")
+        if enable_parallel_processing:
+            print(f"Max workers: {self.max_workers}")
+        
+        # Initialize models
+        self._load_diarization_models()
+        self._load_emotion_models()
+        self._load_event_detection_models()
+        self._load_class_names()
+        
+        print("✅ All models loaded successfully!")
+    
+    def _load_diarization_models(self):
+        """Load speaker diarization and transcription models"""
+        print("Loading speaker diarization and transcription models...")
+        
+        # Load pyannote diarization pipeline
+        try:
+            self.diarization_pipeline = Pipeline.from_pretrained(
+                "pyannote/speaker-diarization-3.1"
+                # Uncomment and add your token: use_auth_token="YOUR_HUGGINGFACE_TOKEN"
+            )
+            if torch.cuda.is_available():
+                self.diarization_pipeline = self.diarization_pipeline.to(self.device)
+        except Exception as e:
+            print(f"Warning: Could not load diarization model: {e}")
+            self.diarization_pipeline = None
+        
+        # Load Whisper transcription model
+        try:
+            self.whisper_model = whisper.load_model("base")
+        except Exception as e:
+            print(f"Warning: Could not load Whisper model: {e}")
+            self.whisper_model = None
+    
+    def _load_emotion_models(self):
+        """Load emotion recognition models"""
+        print("Loading emotion recognition models...")
+        
+        try:
+            self.emotion_model = Wav2Vec2ForSequenceClassification.from_pretrained(
+                "Dpngtm/wav2vec2-emotion-recognition"
+            )
+            self.emotion_processor = Wav2Vec2Processor.from_pretrained(
+                "Dpngtm/wav2vec2-emotion-recognition"
+            )
+            self.emotion_labels = ["angry", "calm", "disgust", "fearful", "happy", "neutral", "sad", "surprised"]
+        except Exception as e:
+            print(f"Warning: Could not load emotion model: {e}")
+            self.emotion_model = None
+    
+    def _load_event_detection_models(self):
+        """Load YAMNet for audio event detection"""
+        print("Loading audio event detection models...")
+        
+        try:
+            self.yamnet_model = yamnet.yamnet(pretrained=True)
+            self.yamnet_model.eval()
+            self.yamnet_converter = WaveformToInput()
+        except Exception as e:
+            print(f"Warning: Could not load YAMNet model: {e}")
+            self.yamnet_model = None
+    
+    def _load_class_names(self):
+        """Load AudioSet class names for YAMNet from CSV"""
+        csv_path = "yamnet_class_map.csv"
+        self.audioset_classes = []
+        try:
+            with open(csv_path, "r") as f:
+                reader = csv.reader(f)
+                next(reader)  # skip header
+                for row in reader:
+                    self.audioset_classes.append(row[2])  # display_name
+        except Exception as e:
+            print(f"Warning: Could not load class names from {csv_path}: {e}")
+            # Fallback to common AudioSet classes
+            self.audioset_classes = [
+                "Speech", "Male speech, man speaking", "Female speech, woman speaking",
+                "Child speech, kid speaking", "Conversation", "Narration, monologue",
+                "Babbling", "Speech synthesizer", "Shout", "Bellow", "Whoop", "Yell",
+                "Children shouting", "Screaming", "Whispering", "Laughter", "Baby laughter",
+                "Giggle", "Snicker", "Belly laugh", "Chuckle, chortle", "Crying, sobbing",
+                "Baby cry, infant cry", "Whimper", "Wail, moan", "Sigh", "Singing",
+                "Choir", "Yodeling", "Chant", "Mantra", "Male singing", "Female singing",
+                "Child singing", "Synthetic singing", "Rapping", "Humming", "Music",
+                "Musical instrument", "Piano", "Guitar", "Drum", "Orchestra", "Pop music",
+                "Rock music", "Jazz", "Classical music", "Electronic music", "Animal",
+                "Dog", "Cat", "Bird", "Insect", "Vehicle", "Car", "Motorcycle", "Train",
+                "Aircraft", "Helicopter", "Wind", "Rain", "Thunder", "Water", "Fire",
+                "Applause", "Crowd", "Footsteps", "Door", "Bell", "Alarm", "Clock"
+            ]
+    
+    def _transcribe_segment_parallel(self, segment_data):
+        """Helper function for parallel transcription of segments"""
+        segment, sample_rate, speaker, start_time, end_time, whisper_model = segment_data
+        
+        try:
+            # Create temporary file for this segment
+            with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as temp_file:
+                temp_filename = temp_file.name
+                torchaudio.save(temp_filename, segment, sample_rate)
+                
+                # Transcribe segment
+                try:
+                    transcription_result = whisper_model.transcribe(
+                        temp_filename,
+                        language="en",
+                        temperature=0,
+                        no_speech_threshold=0.6
+                    )
+                    segment_text = transcription_result["text"].strip()
+                    
+                    if segment_text:
+                        result = {
+                            "speaker": speaker,
+                            "start": round(start_time, 2),
+                            "end": round(end_time, 2),
+                            "duration": round(end_time - start_time, 2),
+                            "text": segment_text,
+                            "confidence": transcription_result.get("language_probability", 0.0)
+                        }
+                    else:
+                        result = None
+                        
+                except Exception as e:
+                    print(f"⚠️ Error transcribing segment: {e}")
+                    result = None
+                
+                finally:
+                    # Clean up temp file
+                    try:
+                        os.unlink(temp_filename)
+                    except OSError:
+                        pass
+                
+                return result
+                
+        except Exception as e:
+            print(f"⚠️ Error in parallel transcription: {e}")
+            return None
+    
+    def transcribe_with_diarization(self, audio_file: str, min_segment_duration: float = 1.0) -> List[Dict]:
+        """Perform speaker diarization and transcription (aligned with main.py logic)"""
+        if self.diarization_pipeline is None or self.whisper_model is None:
+            print("❌ Diarization or transcription models not available")
+            return []
+        
+        print("🎯 Performing speaker diarization and transcription...")
+        
+        # Perform diarization
+        diarization_result = self.diarization_pipeline(audio_file,num_speakers=2)
+        
+        # Load audio
+        waveform, sample_rate = torchaudio.load(audio_file)
+        if sample_rate != 16000:
+            waveform = torchaudio.functional.resample(waveform, sample_rate, 16000)
+            sample_rate = 16000
+        
+        results = []
+        temp_files = []
+        
+        try:
+            for turn, _, speaker in diarization_result.itertracks(yield_label=True):
+                if turn.end - turn.start < min_segment_duration:
+                    continue
+                
+                # Extract segment
+                start_sample = int(turn.start * sample_rate)
+                end_sample = int(turn.end * sample_rate)
+                segment = waveform[:, start_sample:end_sample]
+                
+                # Create temporary file for transcription
+                with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as temp_file:
+                    temp_filename = temp_file.name
+                    temp_files.append(temp_filename)
+                    torchaudio.save(temp_filename, segment, sample_rate)
+                    
+                    # Transcribe
+                    try:
+                        transcription_result = self.whisper_model.transcribe(
+                            temp_filename,
+                            language="en",
+                            temperature=0,
+                            no_speech_threshold=0.6
+                        )
+                        segment_text = transcription_result["text"].strip()
+                        
+                        if segment_text:
+                            results.append({
+                                "speaker": speaker,
+                                "start": round(turn.start, 2),
+                                "end": round(turn.end, 2),
+                                "duration": round(turn.end - turn.start, 2),
+                                "text": segment_text,
+                                "confidence": transcription_result.get("language_probability", 0.0)
+                            })
+                    except Exception as e:
+                        print(f"⚠️ Error transcribing segment: {e}")
+                        continue
+        
+        finally:
+            # Cleanup temp files
+            for temp_file in temp_files:
+                try:
+                    os.unlink(temp_file)
+                except OSError:
+                    pass
+        
+        return results
+    
+    def detect_audio_events(self, audio_file: str, top_k: int = 10) -> Dict:
+        """Detect audio events using YAMNet"""
+        if self.yamnet_model is None:
+            print("❌ YAMNet model not available")
+            return {}
+        
+        print("🔊 Detecting audio events...")
+        
+        try:
+            # Load and preprocess audio
+            waveform, sr = torchaudio.load(audio_file)
+            if sr != 16000:
+                waveform = torchaudio.functional.resample(waveform, sr, 16000)
+            
+            # Process through YAMNet
+            inputs = self.yamnet_converter(waveform, 16000)
+            
+            with torch.no_grad():
+                embeddings, logits = self.yamnet_model(inputs)
+                mean_logits = logits.mean(dim=0)
+                probs = torch.softmax(mean_logits, dim=-1)
+                top_probs, top_idx = torch.topk(probs, top_k)
+            
+            # Format results
+            events = []
+            for i in range(top_k):
+                idx = top_idx[i].item()
+                prob = top_probs[i].item()
+                if idx < len(self.audioset_classes):
+                    label = self.audioset_classes[idx]
+                else:
+                    label = f"Unknown_Class_{idx}"
+                
+                events.append({
+                    "event": label,
+                    "class_id": idx,
+                    "probability": prob
+                })
+            
+            return {
+                "top_events": events,
+                "total_classes": len(self.audioset_classes)
+            }
+        
+        except Exception as e:
+            print(f"⚠️ Error in event detection: {e}")
+            return {}
+    
+    def _extract_feature_chunk(self, audio_chunk, sr, feature_type):
+        """Helper function for parallel feature extraction"""
+        try:
+            if feature_type == "mfcc":
+                mfcc = librosa.feature.mfcc(y=audio_chunk, sr=sr, n_mfcc=13)
+                features = {}
+                for i in range(13):
+                    features[f'mfcc_{i+1}_mean'] = float(np.mean(mfcc[i]))
+                    features[f'mfcc_{i+1}_std'] = float(np.std(mfcc[i]))
+                return features
+            
+            elif feature_type == "chroma":
+                chroma = librosa.feature.chroma_stft(y=audio_chunk, sr=sr)
+                features = {}
+                for i in range(12):
+                    features[f'chroma_{i+1}_mean'] = float(np.mean(chroma[i]))
+                return features
+            
+            elif feature_type == "spectral":
+                features = {}
+                features['spectral_centroid_mean'] = float(np.mean(librosa.feature.spectral_centroid(y=audio_chunk, sr=sr)[0]))
+                features['spectral_rolloff_mean'] = float(np.mean(librosa.feature.spectral_rolloff(y=audio_chunk, sr=sr)[0]))
+                return features
+            
+            elif feature_type == "basic":
+                features = {}
+                features['rms_energy'] = float(np.mean(librosa.feature.rms(y=audio_chunk)[0]))
+                features['zero_crossing_rate'] = float(np.mean(librosa.feature.zero_crossing_rate(audio_chunk)[0]))
+                return features
+                
+        except Exception as e:
+            print(f"⚠️ Error extracting {feature_type} features: {e}")
+            return {}
+    
+    def extract_paralinguistic_features(self, audio_data, sr):
+        """Extract comprehensive paralinguistic features"""
+        print("🎵 Extracting paralinguistic features...")
+        
+        features = {}
+        
+        # Basic properties
+        features['duration'] = len(audio_data) / sr
+        features['sample_rate'] = sr
+        
+        if self.enable_parallel_processing:
+            print("🚀 Using parallel feature extraction...")
+            
+            # Prepare feature extraction tasks
+            feature_tasks = [
+                ("mfcc", audio_data, sr),
+                ("chroma", audio_data, sr),
+                ("spectral", audio_data, sr),
+                ("basic", audio_data, sr)
+            ]
+            
+            # Execute feature extraction in parallel
+            with concurrent.futures.ThreadPoolExecutor(max_workers=min(4, self.max_workers)) as executor:
+                future_to_feature = {
+                    executor.submit(self._extract_feature_chunk, audio_chunk, sr, feature_type): feature_type
+                    for feature_type, audio_chunk, sr in feature_tasks
+                }
+                
+                for future in concurrent.futures.as_completed(future_to_feature):
+                    feature_result = future.result()
+                    features.update(feature_result)
+        else:
+            # Sequential feature extraction (original logic)
+            # Energy features
+            features['rms_energy'] = float(np.mean(librosa.feature.rms(y=audio_data)[0]))
+            features['zero_crossing_rate'] = float(np.mean(librosa.feature.zero_crossing_rate(audio_data)[0]))
+            
+            # MFCC features
+            mfcc = librosa.feature.mfcc(y=audio_data, sr=sr, n_mfcc=13)
+            for i in range(13):
+                features[f'mfcc_{i+1}_mean'] = float(np.mean(mfcc[i]))
+                features[f'mfcc_{i+1}_std'] = float(np.std(mfcc[i]))
+            
+            # Spectral features
+            features['spectral_centroid_mean'] = float(np.mean(librosa.feature.spectral_centroid(y=audio_data, sr=sr)[0]))
+            features['spectral_rolloff_mean'] = float(np.mean(librosa.feature.spectral_rolloff(y=audio_data, sr=sr)[0]))
+            
+            # Chroma features
+            chroma = librosa.feature.chroma_stft(y=audio_data, sr=sr)
+            for i in range(12):
+                features[f'chroma_{i+1}_mean'] = float(np.mean(chroma[i]))
+        
+        # Pitch features (kept sequential due to complexity)
+        try:
+            pitches, magnitudes = librosa.piptrack(y=audio_data, sr=sr, threshold=0.1)
+            pitch_values = []
+            for t in range(pitches.shape[1]):
+                index = magnitudes[:, t].argmax()
+                pitch = pitches[index, t]
+                if pitch > 0:
+                    pitch_values.append(pitch)
+            
+            if pitch_values:
+                features['pitch_mean'] = float(np.mean(pitch_values))
+                features['pitch_std'] = float(np.std(pitch_values))
+                features['pitch_min'] = float(np.min(pitch_values))
+                features['pitch_max'] = float(np.max(pitch_values))
+            else:
+                features.update({'pitch_mean': 0.0, 'pitch_std': 0.0, 'pitch_min': 0.0, 'pitch_max': 0.0})
+        except:
+            features.update({'pitch_mean': 0.0, 'pitch_std': 0.0, 'pitch_min': 0.0, 'pitch_max': 0.0})
+        
+        # Tempo
+        try:
+            tempo, _ = librosa.beat.beat_track(y=audio_data, sr=sr)
+            if isinstance(tempo, np.ndarray):
+                features['tempo'] = float(tempo.item() if tempo.size == 1 else tempo[0])
+            else:
+                features['tempo'] = float(tempo)
+        except:
+            features['tempo'] = 0.0
+        
+        return features
+    
+    def predict_emotion(self, audio_data, sr):
+        """Predict emotion using transformer model"""
+        if self.emotion_model is None:
+            return None
+        
+        print("😊 Predicting emotions...")
+        
+        try:
+            # Resample to 16kHz if needed
+            if sr != 16000:
+                audio_data = librosa.resample(audio_data, orig_sr=sr, target_sr=16000)
+            
+            # Process through model
+            inputs = self.emotion_processor(audio_data, sampling_rate=16000, return_tensors="pt", padding=True)
+            
+            with torch.no_grad():
+                outputs = self.emotion_model(**inputs)
+                predictions = torch.nn.functional.softmax(outputs.logits, dim=-1)
+            
+            # Get emotion probabilities
+            emotion_probs = {}
+            for i, emotion in enumerate(self.emotion_labels):
+                emotion_probs[emotion] = predictions[0][i].item()
+            
+            predicted_emotion = self.emotion_labels[predictions.argmax().item()]
+            confidence = predictions.max().item()
+            
+            return {
+                'predicted_emotion': predicted_emotion,
+                'confidence': confidence,
+                'all_emotions': emotion_probs
+            }
+            
+        except Exception as e:
+            print(f"⚠️ Error in emotion prediction: {e}")
+            return None
+    
+    def analyze_complete_audio(self, audio_file: str) -> Dict:
+        """Perform complete unified audio analysis with parallel processing"""
+        if not os.path.exists(audio_file):
+            print(f"❌ Audio file not found: {audio_file}")
+            return {}
+        
+        print(f"\n🚀 Starting complete analysis of: {audio_file}")
+        print("="*60)
+        
+        start_time = time.time()
+        
+        # Load audio for paralinguistic analysis
+        try:
+            audio_data, sr = librosa.load(audio_file, sr=22050)
+            audio_data, _ = librosa.effects.trim(audio_data, top_db=20)
+            audio_data = librosa.util.normalize(audio_data)
+        except Exception as e:
+            print(f"❌ Error loading audio: {e}")
+            return {}
+        
+        if self.enable_parallel_processing:
+            print("🚀 Running analysis components in parallel...")
+            
+            # Create a queue for results
+            results_queue = Queue()
+            
+            # Define analysis functions
+            def run_diarization():
+                result = self.transcribe_with_diarization(audio_file)
+                results_queue.put(('diarization', result))
+            
+            def run_event_detection():
+                result = self.detect_audio_events(audio_file)
+                results_queue.put(('events', result))
+            
+            def run_feature_extraction():
+                result = self.extract_paralinguistic_features(audio_data, sr)
+                results_queue.put(('features', result))
+            
+            def run_emotion_prediction():
+                result = self.predict_emotion(audio_data, sr)
+                results_queue.put(('emotion', result))
+            
+            # Start threads for parallel execution
+            threads = [
+                threading.Thread(target=run_diarization),
+                threading.Thread(target=run_event_detection),
+                threading.Thread(target=run_feature_extraction),
+                threading.Thread(target=run_emotion_prediction)
+            ]
+            
+            # Start all threads
+            for thread in threads:
+                thread.start()
+            
+            # Wait for all threads to complete
+            for thread in threads:
+                thread.join()
+            
+            # Collect results
+            analysis_components = {}
+            while not results_queue.empty():
+                component, result = results_queue.get()
+                analysis_components[component] = result
+            
+            # Assign results
+            diarization_results = analysis_components.get('diarization', [])
+            event_results = analysis_components.get('events', {})
+            paralinguistic_features = analysis_components.get('features', {})
+            emotion_results = analysis_components.get('emotion', None)
+            
+        else:
+            # Sequential processing (original logic)
+            # 1. Speaker Diarization + Transcription
+            diarization_results = self.transcribe_with_diarization(audio_file)
+            
+            # 2. Audio Event Detection
+            event_results = self.detect_audio_events(audio_file)
+            
+            # 3. Paralinguistic Features
+            paralinguistic_features = self.extract_paralinguistic_features(audio_data, sr)
+            
+            # 4. Emotion Recognition
+            emotion_results = self.predict_emotion(audio_data, sr)
+        
+        processing_time = time.time() - start_time
+        print(f"⏱️ Total processing time: {processing_time:.2f} seconds")
+        
+        # Combine all results
+        complete_analysis = {
+            'file_info': {
+                'filename': os.path.basename(audio_file),
+                'filepath': audio_file,
+                'duration': paralinguistic_features.get('duration', 0),
+                'sample_rate': paralinguistic_features.get('sample_rate', 0),
+                'processing_time': processing_time
+            },
+            'diarization_transcription': diarization_results,
+            'audio_events': event_results,
+            'paralinguistic_features': paralinguistic_features,
+            'emotion_analysis': emotion_results
+        }
+        
+        return complete_analysis
+    
+    def print_analysis_summary(self, analysis_results: Dict):
+        """Print formatted analysis summary"""
+        if not analysis_results:
+            print("❌ No analysis results to display")
+            return
+        
+        file_info = analysis_results.get('file_info', {})
+        diarization = analysis_results.get('diarization_transcription', [])
+        events = analysis_results.get('audio_events', {})
+        emotion = analysis_results.get('emotion_analysis', {})
+        
+        print(f"\n{'='*80}")
+        print("🎯 UNIFIED AUDIO ANALYSIS RESULTS")
+        print(f"{'='*80}")
+        
+        # File Information
+        print(f"📁 File: {file_info.get('filename', 'Unknown')}")
+        print(f"⏱️ Duration: {file_info.get('duration', 0):.2f} seconds")
+        print(f"🔊 Sample Rate: {file_info.get('sample_rate', 0)} Hz")
+        print(f"⚡ Processing Time: {file_info.get('processing_time', 0):.2f} seconds")
+        
+        # 1. Speaker Diarization Results
+        print(f"\n{'🎤 SPEAKER DIARIZATION & TRANSCRIPTION'}")
+        print("-" * 50)
+        if diarization:
+            speakers = set(seg['speaker'] for seg in diarization)
+            print(f"Speakers detected: {len(speakers)}")
+            print(f"Total segments: {len(diarization)}")
+            
+            for i, segment in enumerate(diarization, 1):
+                print(f"{i}. {segment['speaker']} [{segment['start']:.1f}s-{segment['end']:.1f}s]: {segment['text'][:80]}{'...' if len(segment['text']) > 80 else ''}")
+        else:
+            print("No diarization results available")
+        
+        # 2. Audio Event Detection
+        print(f"\n{'🔊 AUDIO EVENT DETECTION (Top 10)'}")
+        print("-" * 50)
+        top_events = events.get('top_events', [])
+        if top_events:
+            for i, event in enumerate(top_events[:10], 1):
+                print(f"{i:2d}. {event['event']:<30} | Probability: {event['probability']:.4f}")
+        else:
+            print("No audio events detected")
+        
+        # 3. Emotion Analysis
+        print(f"\n{'😊 EMOTION ANALYSIS'}")
+        print("-" * 30)
+        if emotion:
+            print(f"Predicted Emotion: {emotion['predicted_emotion']} (Confidence: {emotion['confidence']:.3f})")
+            print("\nAll Emotion Probabilities:")
+            for emo, prob in emotion['all_emotions'].items():
+                print(f"  {emo.capitalize():<12}: {prob:.3f}")
+        else:
+            print("No emotion analysis available")
+        
+        # 4. Key Paralinguistic Features
+        features = analysis_results.get('paralinguistic_features', {})
+        if features:
+            print(f"\n{'🎵 KEY PARALINGUISTIC FEATURES'}")
+            print("-" * 40)
+            print(f"RMS Energy: {features.get('rms_energy', 0):.4f}")
+            print(f"Pitch Mean: {features.get('pitch_mean', 0):.2f} Hz")
+            print(f"Spectral Centroid: {features.get('spectral_centroid_mean', 0):.2f} Hz")
+            print(f"Tempo: {features.get('tempo', 0):.2f} BPM")
+            print(f"Zero Crossing Rate: {features.get('zero_crossing_rate', 0):.4f}")
+    
+    def save_results_to_csv(self, analysis_results: Dict, output_prefix: str = "unified_analysis"):
+        """Save analysis results to CSV files"""
+        if not analysis_results:
+            print("❌ No results to save")
+            return
+        
+        # Save diarization results
+        diarization = analysis_results.get('diarization_transcription', [])
+        if diarization:
+            df_diarization = pd.DataFrame(diarization)
+            diarization_file = f"{output_prefix}_diarization.csv"
+            df_diarization.to_csv(diarization_file, index=False)
+            print(f"💾 Diarization results saved to: {diarization_file}")
+        
+        # Save audio events
+        events = analysis_results.get('audio_events', {}).get('top_events', [])
+        if events:
+            df_events = pd.DataFrame(events)
+            events_file = f"{output_prefix}_audio_events.csv"
+            df_events.to_csv(events_file, index=False)
+            print(f"💾 Audio events saved to: {events_file}")
+        
+        # Save paralinguistic features
+        features = analysis_results.get('paralinguistic_features', {})
+        if features:
+            df_features = pd.DataFrame([features])
+            features_file = f"{output_prefix}_features.csv"
+            df_features.to_csv(features_file, index=False)
+            print(f"💾 Features saved to: {features_file}")
+        
+        # Save emotion analysis
+        emotion = analysis_results.get('emotion_analysis', {})
+        if emotion:
+            df_emotion = pd.DataFrame([emotion])
+            emotion_file = f"{output_prefix}_emotion.csv"
+            df_emotion.to_csv(emotion_file, index=False)
+            print(f"💾 Emotion analysis saved to: {emotion_file}")
+            
+def summarize_audio_analysis_with_llm(analysis_results: dict) -> str:
+    """
+    Send all analysis results to a Groq LLM (gpt-oss-20b) and get a summary
+    describing relationships between diarization, events, emotion, and features.
+    Requires GROQ_API_KEY in environment.
+    """
+    # Prepare the prompt
+    prompt = (
+        "You are an expert audio scene interpreter. Given the structured audio analysis results, "
+        "summarize what is happening in plain, natural language, as if explaining the situation to someone. "
+        "Avoid technical terms, metrics, or probabilities. Instead, combine the speaker's words, background "
+        "sounds, emotions and other paralingusistic features to infer the most likely real-world context. Keep it short and clear.\n\n"
+        "Sample input : Recording of a person call reaching an airport (with background noise of airplanes, announcements, and crowd chatter). Sample output : The subway sound and other vehicle sound suggest that person is in Highway, and the aero plane sound indicate nearby Airport, while announcement provide information about the Airplane Schedule, that means person reached in boarding area or into the waiting hall.\n\n"
+        f"Audio Analysis Results:\n{analysis_results}\n\n"
+        "Plain Summary:"
+    )
+
+    # Load environment variables
+    load_dotenv()
+    api_key = os.getenv("GROQ_API_KEY")
+    if not api_key:
+        raise ValueError("GROQ_API_KEY environment variable not set.")
+
+    # Initialize Groq client
+    client = Groq(api_key=api_key)
+
+    # Make the API call
+    response = client.chat.completions.create(
+        model="openai/gpt-oss-20b",
+        messages=[
+            {"role": "system", "content": "You are an expert audio analyst."},
+            {"role": "user", "content": prompt},
+        ],
+    )
+
+    # Extract summary
+    summary = response.choices[0].message.content.strip()
+    return summary
+
+def main():
+    """Main function demonstrating usage"""
+    # Initialize analyzer with parallel processing enabled
+    analyzer = UnifiedAudioAnalyzer(enable_parallel_processing=True, max_workers=None)
+    
+    # Specify input audio file
+    audio_file = "dataset/flight/15.wav"  # Update with your audio file path
+    
+    if os.path.exists(audio_file):
+        # Perform complete analysis
+        results = analyzer.analyze_complete_audio(audio_file)
+        
+        # Print summary
+        analyzer.print_analysis_summary(results)
+        
+        # Save results to CSV files
+        # analyzer.save_results_to_csv(results, "my_audio_analysis")
+        
+        print(f"\n✅ Analysis complete! Check CSV files for detailed results.")
+        summary=summarize_audio_analysis_with_llm(results)
+        print("\n=== LLM Summary of Audio Analysis ===")
+        print(summary)
+    else:
+        print(f"❌ Audio file not found: {audio_file}")
+        print("Please update the audio_file path to point to your audio file.")
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,17 @@
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+python-multipart==0.0.6
+groq==0.4.1
+python-dotenv==1.0.0
+librosa==0.10.1
+soundfile==0.12.1
+torch==2.1.0
+torchaudio==2.1.0
+numpy==1.24.3
+pandas==2.0.3
+matplotlib==3.7.2
+scipy==1.11.3
+pyannote.audio==3.1.1
+openai-whisper==20231117
+transformers==4.35.2
+torch-vggish-yamnet==0.1.0

server.py

@@ -0,0 +1,186 @@
+import os
+import tempfile
+import asyncio
+from fastapi import FastAPI, File, UploadFile, HTTPException, Depends
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel
+from typing import Optional, Dict, Any
+import uvicorn
+from groq import Groq
+from dotenv import load_dotenv
+import librosa
+import soundfile as sf
+from main2 import UnifiedAudioAnalyzer, summarize_audio_analysis_with_llm
+
+# Load environment variables
+load_dotenv()
+
+app = FastAPI(title="Audio Analysis API", version="1.0.0")
+
+# CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["http://localhost:9002", "http://localhost:3000"],  # Frontend URLs
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Initialize the audio analyzer
+analyzer = UnifiedAudioAnalyzer(enable_parallel_processing=True)
+
+# Groq client for chat
+groq_client = None
+try:
+    groq_api_key = os.getenv("GROQ_API_KEY")
+    if groq_api_key:
+        groq_client = Groq(api_key=groq_api_key)
+except Exception as e:
+    print(f"Warning: Could not initialize Groq client: {e}")
+
+# Pydantic models
+class ChatRequest(BaseModel):
+    question: str
+    analysis_data: Dict[str, Any]
+
+class ChatResponse(BaseModel):
+    answer: str
+
+class AnalysisResponse(BaseModel):
+    success: bool
+    data: Optional[Dict[str, Any]] = None
+    error: Optional[str] = None
+
+def convert_audio_to_wav(audio_file_path: str) -> str:
+    """Convert audio file to WAV format if needed"""
+    try:
+        # Load audio with librosa (supports many formats)
+        audio_data, sample_rate = librosa.load(audio_file_path, sr=16000)
+        
+        # Create temporary WAV file
+        temp_wav = tempfile.NamedTemporaryFile(suffix='.wav', delete=False)
+        temp_wav_path = temp_wav.name
+        temp_wav.close()
+        
+        # Save as WAV
+        sf.write(temp_wav_path, audio_data, sample_rate)
+        
+        return temp_wav_path
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Error converting audio to WAV: {str(e)}")
+
+@app.get("/")
+async def root():
+    return {"message": "Audio Analysis API is running"}
+
+@app.post("/upload", response_model=AnalysisResponse)
+async def upload_audio(file: UploadFile = File(...)):
+    """Upload and analyze audio file"""
+    try:
+        # Check file type
+        if not file.content_type.startswith("audio/"):
+            raise HTTPException(status_code=400, detail="File must be an audio file")
+        
+        # Create temporary file
+        with tempfile.NamedTemporaryFile(delete=False, suffix=f".{file.filename.split('.')[-1]}") as temp_file:
+            content = await file.read()
+            temp_file.write(content)
+            temp_file_path = temp_file.name
+        
+        try:
+            # Convert to WAV if needed
+            wav_file_path = convert_audio_to_wav(temp_file_path)
+            
+            # Perform analysis
+            analysis_results = analyzer.analyze_complete_audio(wav_file_path)
+            
+            if not analysis_results:
+                raise HTTPException(status_code=500, detail="Analysis failed")
+            
+            # Generate LLM summary
+            try:
+                summary = summarize_audio_analysis_with_llm(analysis_results)
+                analysis_results['llm_summary'] = summary
+            except Exception as e:
+                print(f"Warning: LLM summary failed: {e}")
+                analysis_results['llm_summary'] = "Summary generation failed"
+            
+            return AnalysisResponse(
+                success=True,
+                data=analysis_results
+            )
+            
+        finally:
+            # Clean up temporary files
+            try:
+                os.unlink(temp_file_path)
+                if 'wav_file_path' in locals():
+                    os.unlink(wav_file_path)
+            except OSError:
+                pass
+                
+    except Exception as e:
+        return AnalysisResponse(
+            success=False,
+            error=str(e)
+        )
+
+@app.post("/chat", response_model=ChatResponse)
+async def chat_with_analysis(request: ChatRequest):
+    """Chat with AI about the analysis results"""
+    if not groq_client:
+        raise HTTPException(status_code=500, detail="Groq API not configured")
+    
+    try:
+        # Prepare context from analysis data
+        context = f"""
+        Audio Analysis Summary:
+        - File: {request.analysis_data.get('file_info', {}).get('filename', 'Unknown')}
+        - Duration: {request.analysis_data.get('file_info', {}).get('duration', 0):.2f} seconds
+        - LLM Summary: {request.analysis_data.get('llm_summary', 'No summary available')}
+        
+        Speaker Diarization:
+        {request.analysis_data.get('diarization_transcription', [])}
+        
+        Audio Events:
+        {request.analysis_data.get('audio_events', {}).get('top_events', [])}
+        
+        Emotion Analysis:
+        {request.analysis_data.get('emotion_analysis', {})}
+        
+        Paralinguistic Features:
+        {request.analysis_data.get('paralinguistic_features', {})}
+        """
+        
+        # Create chat completion
+        response = groq_client.chat.completions.create(
+            model="llama-3.1-8b-instant",  # Using smaller model as requested
+            messages=[
+                {
+                    "role": "system",
+                    "content": "You are an expert audio analyst. Answer questions about the provided audio analysis data. Be helpful and provide insights based on the analysis results."
+                },
+                {
+                    "role": "user",
+                    "content": f"Context: {context}\n\nQuestion: {request.question}"
+                }
+            ],
+            temperature=0.7,
+            max_tokens=1000
+        )
+        
+        answer = response.choices[0].message.content.strip()
+        
+        return ChatResponse(answer=answer)
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Chat error: {str(e)}")
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    return {"status": "healthy", "analyzer_loaded": analyzer is not None}
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=8000)

yamnet_class_map.csv

@@ -0,0 +1,522 @@
+index,mid,display_name
+0,/m/09x0r,Speech
+1,/m/0ytgt,"Child speech, kid speaking"
+2,/m/01h8n0,Conversation
+3,/m/02qldy,"Narration, monologue"
+4,/m/0261r1,Babbling
+5,/m/0brhx,Speech synthesizer
+6,/m/07p6fty,Shout
+7,/m/07q4ntr,Bellow
+8,/m/07rwj3x,Whoop
+9,/m/07sr1lc,Yell
+10,/t/dd00135,Children shouting
+11,/m/03qc9zr,Screaming
+12,/m/02rtxlg,Whispering
+13,/m/01j3sz,Laughter
+14,/t/dd00001,Baby laughter
+15,/m/07r660_,Giggle
+16,/m/07s04w4,Snicker
+17,/m/07sq110,Belly laugh
+18,/m/07rgt08,"Chuckle, chortle"
+19,/m/0463cq4,"Crying, sobbing"
+20,/t/dd00002,"Baby cry, infant cry"
+21,/m/07qz6j3,Whimper
+22,/m/07qw_06,"Wail, moan"
+23,/m/07plz5l,Sigh
+24,/m/015lz1,Singing
+25,/m/0l14jd,Choir
+26,/m/01swy6,Yodeling
+27,/m/02bk07,Chant
+28,/m/01c194,Mantra
+29,/t/dd00005,Child singing
+30,/t/dd00006,Synthetic singing
+31,/m/06bxc,Rapping
+32,/m/02fxyj,Humming
+33,/m/07s2xch,Groan
+34,/m/07r4k75,Grunt
+35,/m/01w250,Whistling
+36,/m/0lyf6,Breathing
+37,/m/07mzm6,Wheeze
+38,/m/01d3sd,Snoring
+39,/m/07s0dtb,Gasp
+40,/m/07pyy8b,Pant
+41,/m/07q0yl5,Snort
+42,/m/01b_21,Cough
+43,/m/0dl9sf8,Throat clearing
+44,/m/01hsr_,Sneeze
+45,/m/07ppn3j,Sniff
+46,/m/06h7j,Run
+47,/m/07qv_x_,Shuffle
+48,/m/07pbtc8,"Walk, footsteps"
+49,/m/03cczk,"Chewing, mastication"
+50,/m/07pdhp0,Biting
+51,/m/0939n_,Gargling
+52,/m/01g90h,Stomach rumble
+53,/m/03q5_w,"Burping, eructation"
+54,/m/02p3nc,Hiccup
+55,/m/02_nn,Fart
+56,/m/0k65p,Hands
+57,/m/025_jnm,Finger snapping
+58,/m/0l15bq,Clapping
+59,/m/01jg02,"Heart sounds, heartbeat"
+60,/m/01jg1z,Heart murmur
+61,/m/053hz1,Cheering
+62,/m/028ght,Applause
+63,/m/07rkbfh,Chatter
+64,/m/03qtwd,Crowd
+65,/m/07qfr4h,"Hubbub, speech noise, speech babble"
+66,/t/dd00013,Children playing
+67,/m/0jbk,Animal
+68,/m/068hy,"Domestic animals, pets"
+69,/m/0bt9lr,Dog
+70,/m/05tny_,Bark
+71,/m/07r_k2n,Yip
+72,/m/07qf0zm,Howl
+73,/m/07rc7d9,Bow-wow
+74,/m/0ghcn6,Growling
+75,/t/dd00136,Whimper (dog)
+76,/m/01yrx,Cat
+77,/m/02yds9,Purr
+78,/m/07qrkrw,Meow
+79,/m/07rjwbb,Hiss
+80,/m/07r81j2,Caterwaul
+81,/m/0ch8v,"Livestock, farm animals, working animals"
+82,/m/03k3r,Horse
+83,/m/07rv9rh,Clip-clop
+84,/m/07q5rw0,"Neigh, whinny"
+85,/m/01xq0k1,"Cattle, bovinae"
+86,/m/07rpkh9,Moo
+87,/m/0239kh,Cowbell
+88,/m/068zj,Pig
+89,/t/dd00018,Oink
+90,/m/03fwl,Goat
+91,/m/07q0h5t,Bleat
+92,/m/07bgp,Sheep
+93,/m/025rv6n,Fowl
+94,/m/09b5t,"Chicken, rooster"
+95,/m/07st89h,Cluck
+96,/m/07qn5dc,"Crowing, cock-a-doodle-doo"
+97,/m/01rd7k,Turkey
+98,/m/07svc2k,Gobble
+99,/m/09ddx,Duck
+100,/m/07qdb04,Quack
+101,/m/0dbvp,Goose
+102,/m/07qwf61,Honk
+103,/m/01280g,Wild animals
+104,/m/0cdnk,"Roaring cats (lions, tigers)"
+105,/m/04cvmfc,Roar
+106,/m/015p6,Bird
+107,/m/020bb7,"Bird vocalization, bird call, bird song"
+108,/m/07pggtn,"Chirp, tweet"
+109,/m/07sx8x_,Squawk
+110,/m/0h0rv,"Pigeon, dove"
+111,/m/07r_25d,Coo
+112,/m/04s8yn,Crow
+113,/m/07r5c2p,Caw
+114,/m/09d5_,Owl
+115,/m/07r_80w,Hoot
+116,/m/05_wcq,"Bird flight, flapping wings"
+117,/m/01z5f,"Canidae, dogs, wolves"
+118,/m/06hps,"Rodents, rats, mice"
+119,/m/04rmv,Mouse
+120,/m/07r4gkf,Patter
+121,/m/03vt0,Insect
+122,/m/09xqv,Cricket
+123,/m/09f96,Mosquito
+124,/m/0h2mp,"Fly, housefly"
+125,/m/07pjwq1,Buzz
+126,/m/01h3n,"Bee, wasp, etc."
+127,/m/09ld4,Frog
+128,/m/07st88b,Croak
+129,/m/078jl,Snake
+130,/m/07qn4z3,Rattle
+131,/m/032n05,Whale vocalization
+132,/m/04rlf,Music
+133,/m/04szw,Musical instrument
+134,/m/0fx80y,Plucked string instrument
+135,/m/0342h,Guitar
+136,/m/02sgy,Electric guitar
+137,/m/018vs,Bass guitar
+138,/m/042v_gx,Acoustic guitar
+139,/m/06w87,"Steel guitar, slide guitar"
+140,/m/01glhc,Tapping (guitar technique)
+141,/m/07s0s5r,Strum
+142,/m/018j2,Banjo
+143,/m/0jtg0,Sitar
+144,/m/04rzd,Mandolin
+145,/m/01bns_,Zither
+146,/m/07xzm,Ukulele
+147,/m/05148p4,Keyboard (musical)
+148,/m/05r5c,Piano
+149,/m/01s0ps,Electric piano
+150,/m/013y1f,Organ
+151,/m/03xq_f,Electronic organ
+152,/m/03gvt,Hammond organ
+153,/m/0l14qv,Synthesizer
+154,/m/01v1d8,Sampler
+155,/m/03q5t,Harpsichord
+156,/m/0l14md,Percussion
+157,/m/02hnl,Drum kit
+158,/m/0cfdd,Drum machine
+159,/m/026t6,Drum
+160,/m/06rvn,Snare drum
+161,/m/03t3fj,Rimshot
+162,/m/02k_mr,Drum roll
+163,/m/0bm02,Bass drum
+164,/m/011k_j,Timpani
+165,/m/01p970,Tabla
+166,/m/01qbl,Cymbal
+167,/m/03qtq,Hi-hat
+168,/m/01sm1g,Wood block
+169,/m/07brj,Tambourine
+170,/m/05r5wn,Rattle (instrument)
+171,/m/0xzly,Maraca
+172,/m/0mbct,Gong
+173,/m/016622,Tubular bells
+174,/m/0j45pbj,Mallet percussion
+175,/m/0dwsp,"Marimba, xylophone"
+176,/m/0dwtp,Glockenspiel
+177,/m/0dwt5,Vibraphone
+178,/m/0l156b,Steelpan
+179,/m/05pd6,Orchestra
+180,/m/01kcd,Brass instrument
+181,/m/0319l,French horn
+182,/m/07gql,Trumpet
+183,/m/07c6l,Trombone
+184,/m/0l14_3,Bowed string instrument
+185,/m/02qmj0d,String section
+186,/m/07y_7,"Violin, fiddle"
+187,/m/0d8_n,Pizzicato
+188,/m/01xqw,Cello
+189,/m/02fsn,Double bass
+190,/m/085jw,"Wind instrument, woodwind instrument"
+191,/m/0l14j_,Flute
+192,/m/06ncr,Saxophone
+193,/m/01wy6,Clarinet
+194,/m/03m5k,Harp
+195,/m/0395lw,Bell
+196,/m/03w41f,Church bell
+197,/m/027m70_,Jingle bell
+198,/m/0gy1t2s,Bicycle bell
+199,/m/07n_g,Tuning fork
+200,/m/0f8s22,Chime
+201,/m/026fgl,Wind chime
+202,/m/0150b9,Change ringing (campanology)
+203,/m/03qjg,Harmonica
+204,/m/0mkg,Accordion
+205,/m/0192l,Bagpipes
+206,/m/02bxd,Didgeridoo
+207,/m/0l14l2,Shofar
+208,/m/07kc_,Theremin
+209,/m/0l14t7,Singing bowl
+210,/m/01hgjl,Scratching (performance technique)
+211,/m/064t9,Pop music
+212,/m/0glt670,Hip hop music
+213,/m/02cz_7,Beatboxing
+214,/m/06by7,Rock music
+215,/m/03lty,Heavy metal
+216,/m/05r6t,Punk rock
+217,/m/0dls3,Grunge
+218,/m/0dl5d,Progressive rock
+219,/m/07sbbz2,Rock and roll
+220,/m/05w3f,Psychedelic rock
+221,/m/06j6l,Rhythm and blues
+222,/m/0gywn,Soul music
+223,/m/06cqb,Reggae
+224,/m/01lyv,Country
+225,/m/015y_n,Swing music
+226,/m/0gg8l,Bluegrass
+227,/m/02x8m,Funk
+228,/m/02w4v,Folk music
+229,/m/06j64v,Middle Eastern music
+230,/m/03_d0,Jazz
+231,/m/026z9,Disco
+232,/m/0ggq0m,Classical music
+233,/m/05lls,Opera
+234,/m/02lkt,Electronic music
+235,/m/03mb9,House music
+236,/m/07gxw,Techno
+237,/m/07s72n,Dubstep
+238,/m/0283d,Drum and bass
+239,/m/0m0jc,Electronica
+240,/m/08cyft,Electronic dance music
+241,/m/0fd3y,Ambient music
+242,/m/07lnk,Trance music
+243,/m/0g293,Music of Latin America
+244,/m/0ln16,Salsa music
+245,/m/0326g,Flamenco
+246,/m/0155w,Blues
+247,/m/05fw6t,Music for children
+248,/m/02v2lh,New-age music
+249,/m/0y4f8,Vocal music
+250,/m/0z9c,A capella
+251,/m/0164x2,Music of Africa
+252,/m/0145m,Afrobeat
+253,/m/02mscn,Christian music
+254,/m/016cjb,Gospel music
+255,/m/028sqc,Music of Asia
+256,/m/015vgc,Carnatic music
+257,/m/0dq0md,Music of Bollywood
+258,/m/06rqw,Ska
+259,/m/02p0sh1,Traditional music
+260,/m/05rwpb,Independent music
+261,/m/074ft,Song
+262,/m/025td0t,Background music
+263,/m/02cjck,Theme music
+264,/m/03r5q_,Jingle (music)
+265,/m/0l14gg,Soundtrack music
+266,/m/07pkxdp,Lullaby
+267,/m/01z7dr,Video game music
+268,/m/0140xf,Christmas music
+269,/m/0ggx5q,Dance music
+270,/m/04wptg,Wedding music
+271,/t/dd00031,Happy music
+272,/t/dd00033,Sad music
+273,/t/dd00034,Tender music
+274,/t/dd00035,Exciting music
+275,/t/dd00036,Angry music
+276,/t/dd00037,Scary music
+277,/m/03m9d0z,Wind
+278,/m/09t49,Rustling leaves
+279,/t/dd00092,Wind noise (microphone)
+280,/m/0jb2l,Thunderstorm
+281,/m/0ngt1,Thunder
+282,/m/0838f,Water
+283,/m/06mb1,Rain
+284,/m/07r10fb,Raindrop
+285,/t/dd00038,Rain on surface
+286,/m/0j6m2,Stream
+287,/m/0j2kx,Waterfall
+288,/m/05kq4,Ocean
+289,/m/034srq,"Waves, surf"
+290,/m/06wzb,Steam
+291,/m/07swgks,Gurgling
+292,/m/02_41,Fire
+293,/m/07pzfmf,Crackle
+294,/m/07yv9,Vehicle
+295,/m/019jd,"Boat, Water vehicle"
+296,/m/0hsrw,"Sailboat, sailing ship"
+297,/m/056ks2,"Rowboat, canoe, kayak"
+298,/m/02rlv9,"Motorboat, speedboat"
+299,/m/06q74,Ship
+300,/m/012f08,Motor vehicle (road)
+301,/m/0k4j,Car
+302,/m/0912c9,"Vehicle horn, car horn, honking"
+303,/m/07qv_d5,Toot
+304,/m/02mfyn,Car alarm
+305,/m/04gxbd,"Power windows, electric windows"
+306,/m/07rknqz,Skidding
+307,/m/0h9mv,Tire squeal
+308,/t/dd00134,Car passing by
+309,/m/0ltv,"Race car, auto racing"
+310,/m/07r04,Truck
+311,/m/0gvgw0,Air brake
+312,/m/05x_td,"Air horn, truck horn"
+313,/m/02rhddq,Reversing beeps
+314,/m/03cl9h,"Ice cream truck, ice cream van"
+315,/m/01bjv,Bus
+316,/m/03j1ly,Emergency vehicle
+317,/m/04qvtq,Police car (siren)
+318,/m/012n7d,Ambulance (siren)
+319,/m/012ndj,"Fire engine, fire truck (siren)"
+320,/m/04_sv,Motorcycle
+321,/m/0btp2,"Traffic noise, roadway noise"
+322,/m/06d_3,Rail transport
+323,/m/07jdr,Train
+324,/m/04zmvq,Train whistle
+325,/m/0284vy3,Train horn
+326,/m/01g50p,"Railroad car, train wagon"
+327,/t/dd00048,Train wheels squealing
+328,/m/0195fx,"Subway, metro, underground"
+329,/m/0k5j,Aircraft
+330,/m/014yck,Aircraft engine
+331,/m/04229,Jet engine
+332,/m/02l6bg,"Propeller, airscrew"
+333,/m/09ct_,Helicopter
+334,/m/0cmf2,"Fixed-wing aircraft, airplane"
+335,/m/0199g,Bicycle
+336,/m/06_fw,Skateboard
+337,/m/02mk9,Engine
+338,/t/dd00065,Light engine (high frequency)
+339,/m/08j51y,"Dental drill, dentist's drill"
+340,/m/01yg9g,Lawn mower
+341,/m/01j4z9,Chainsaw
+342,/t/dd00066,Medium engine (mid frequency)
+343,/t/dd00067,Heavy engine (low frequency)
+344,/m/01h82_,Engine knocking
+345,/t/dd00130,Engine starting
+346,/m/07pb8fc,Idling
+347,/m/07q2z82,"Accelerating, revving, vroom"
+348,/m/02dgv,Door
+349,/m/03wwcy,Doorbell
+350,/m/07r67yg,Ding-dong
+351,/m/02y_763,Sliding door
+352,/m/07rjzl8,Slam
+353,/m/07r4wb8,Knock
+354,/m/07qcpgn,Tap
+355,/m/07q6cd_,Squeak
+356,/m/0642b4,Cupboard open or close
+357,/m/0fqfqc,Drawer open or close
+358,/m/04brg2,"Dishes, pots, and pans"
+359,/m/023pjk,"Cutlery, silverware"
+360,/m/07pn_8q,Chopping (food)
+361,/m/0dxrf,Frying (food)
+362,/m/0fx9l,Microwave oven
+363,/m/02pjr4,Blender
+364,/m/02jz0l,"Water tap, faucet"
+365,/m/0130jx,Sink (filling or washing)
+366,/m/03dnzn,Bathtub (filling or washing)
+367,/m/03wvsk,Hair dryer
+368,/m/01jt3m,Toilet flush
+369,/m/012xff,Toothbrush
+370,/m/04fgwm,Electric toothbrush
+371,/m/0d31p,Vacuum cleaner
+372,/m/01s0vc,Zipper (clothing)
+373,/m/03v3yw,Keys jangling
+374,/m/0242l,Coin (dropping)
+375,/m/01lsmm,Scissors
+376,/m/02g901,"Electric shaver, electric razor"
+377,/m/05rj2,Shuffling cards
+378,/m/0316dw,Typing
+379,/m/0c2wf,Typewriter
+380,/m/01m2v,Computer keyboard
+381,/m/081rb,Writing
+382,/m/07pp_mv,Alarm
+383,/m/07cx4,Telephone
+384,/m/07pp8cl,Telephone bell ringing
+385,/m/01hnzm,Ringtone
+386,/m/02c8p,"Telephone dialing, DTMF"
+387,/m/015jpf,Dial tone
+388,/m/01z47d,Busy signal
+389,/m/046dlr,Alarm clock
+390,/m/03kmc9,Siren
+391,/m/0dgbq,Civil defense siren
+392,/m/030rvx,Buzzer
+393,/m/01y3hg,"Smoke detector, smoke alarm"
+394,/m/0c3f7m,Fire alarm
+395,/m/04fq5q,Foghorn
+396,/m/0l156k,Whistle
+397,/m/06hck5,Steam whistle
+398,/t/dd00077,Mechanisms
+399,/m/02bm9n,"Ratchet, pawl"
+400,/m/01x3z,Clock
+401,/m/07qjznt,Tick
+402,/m/07qjznl,Tick-tock
+403,/m/0l7xg,Gears
+404,/m/05zc1,Pulleys
+405,/m/0llzx,Sewing machine
+406,/m/02x984l,Mechanical fan
+407,/m/025wky1,Air conditioning
+408,/m/024dl,Cash register
+409,/m/01m4t,Printer
+410,/m/0dv5r,Camera
+411,/m/07bjf,Single-lens reflex camera
+412,/m/07k1x,Tools
+413,/m/03l9g,Hammer
+414,/m/03p19w,Jackhammer
+415,/m/01b82r,Sawing
+416,/m/02p01q,Filing (rasp)
+417,/m/023vsd,Sanding
+418,/m/0_ksk,Power tool
+419,/m/01d380,Drill
+420,/m/014zdl,Explosion
+421,/m/032s66,"Gunshot, gunfire"
+422,/m/04zjc,Machine gun
+423,/m/02z32qm,Fusillade
+424,/m/0_1c,Artillery fire
+425,/m/073cg4,Cap gun
+426,/m/0g6b5,Fireworks
+427,/g/122z_qxw,Firecracker
+428,/m/07qsvvw,"Burst, pop"
+429,/m/07pxg6y,Eruption
+430,/m/07qqyl4,Boom
+431,/m/083vt,Wood
+432,/m/07pczhz,Chop
+433,/m/07pl1bw,Splinter
+434,/m/07qs1cx,Crack
+435,/m/039jq,Glass
+436,/m/07q7njn,"Chink, clink"
+437,/m/07rn7sz,Shatter
+438,/m/04k94,Liquid
+439,/m/07rrlb6,"Splash, splatter"
+440,/m/07p6mqd,Slosh
+441,/m/07qlwh6,Squish
+442,/m/07r5v4s,Drip
+443,/m/07prgkl,Pour
+444,/m/07pqc89,"Trickle, dribble"
+445,/t/dd00088,Gush
+446,/m/07p7b8y,Fill (with liquid)
+447,/m/07qlf79,Spray
+448,/m/07ptzwd,Pump (liquid)
+449,/m/07ptfmf,Stir
+450,/m/0dv3j,Boiling
+451,/m/0790c,Sonar
+452,/m/0dl83,Arrow
+453,/m/07rqsjt,"Whoosh, swoosh, swish"
+454,/m/07qnq_y,"Thump, thud"
+455,/m/07rrh0c,Thunk
+456,/m/0b_fwt,Electronic tuner
+457,/m/02rr_,Effects unit
+458,/m/07m2kt,Chorus effect
+459,/m/018w8,Basketball bounce
+460,/m/07pws3f,Bang
+461,/m/07ryjzk,"Slap, smack"
+462,/m/07rdhzs,"Whack, thwack"
+463,/m/07pjjrj,"Smash, crash"
+464,/m/07pc8lb,Breaking
+465,/m/07pqn27,Bouncing
+466,/m/07rbp7_,Whip
+467,/m/07pyf11,Flap
+468,/m/07qb_dv,Scratch
+469,/m/07qv4k0,Scrape
+470,/m/07pdjhy,Rub
+471,/m/07s8j8t,Roll
+472,/m/07plct2,Crushing
+473,/t/dd00112,"Crumpling, crinkling"
+474,/m/07qcx4z,Tearing
+475,/m/02fs_r,"Beep, bleep"
+476,/m/07qwdck,Ping
+477,/m/07phxs1,Ding
+478,/m/07rv4dm,Clang
+479,/m/07s02z0,Squeal
+480,/m/07qh7jl,Creak
+481,/m/07qwyj0,Rustle
+482,/m/07s34ls,Whir
+483,/m/07qmpdm,Clatter
+484,/m/07p9k1k,Sizzle
+485,/m/07qc9xj,Clicking
+486,/m/07rwm0c,Clickety-clack
+487,/m/07phhsh,Rumble
+488,/m/07qyrcz,Plop
+489,/m/07qfgpx,"Jingle, tinkle"
+490,/m/07rcgpl,Hum
+491,/m/07p78v5,Zing
+492,/t/dd00121,Boing
+493,/m/07s12q4,Crunch
+494,/m/028v0c,Silence
+495,/m/01v_m0,Sine wave
+496,/m/0b9m1,Harmonic
+497,/m/0hdsk,Chirp tone
+498,/m/0c1dj,Sound effect
+499,/m/07pt_g0,Pulse
+500,/t/dd00125,"Inside, small room"
+501,/t/dd00126,"Inside, large room or hall"
+502,/t/dd00127,"Inside, public space"
+503,/t/dd00128,"Outside, urban or manmade"
+504,/t/dd00129,"Outside, rural or natural"
+505,/m/01b9nn,Reverberation
+506,/m/01jnbd,Echo
+507,/m/096m7z,Noise
+508,/m/06_y0by,Environmental noise
+509,/m/07rgkc5,Static
+510,/m/06xkwv,Mains hum
+511,/m/0g12c5,Distortion
+512,/m/08p9q4,Sidetone
+513,/m/07szfh9,Cacophony
+514,/m/0chx_,White noise
+515,/m/0cj0r,Pink noise
+516,/m/07p_0gm,Throbbing
+517,/m/01jwx6,Vibration
+518,/m/07c52,Television
+519,/m/06bz3,Radio
+520,/m/07hvw1,Field recording