app.py

# Tone Classification System
# This implementation combines text and acoustic features to detect emotions,
# including sarcasm and figures of speech
# Part 1: Install required packages with improved error handling
import sys
import os

# Function to install packages with error handling
def install_packages():
    packages = [
        "hf_xet","transformers", "pytorch-lightning", "datasets",
        "numpy", "pandas", "matplotlib", "seaborn",
        "librosa", "opensmile", "torch", "torchaudio",
        "accelerate", "nltk", "scikit-learn"
    ]

    for package in packages:
        try:
            print(f"Installing {package}...")
            import subprocess
            # Install a package quietly
            subprocess.run([sys.executable, '-m', 'pip', 'install', package, '-q'])
            print(f"Successfully installed {package}")
        except Exception as e:
            print(f"Error installing {package}: {e}")

    print("Package installation completed!")

install_packages()

# Part 2: Import libraries with error handling
import numpy as np
import pandas as pd
import torch
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.metrics import confusion_matrix, classification_report
from torch.utils.data import Dataset, DataLoader
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim

# Check for CUDA availability
DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print(f"Using device: {DEVICE}")

# Try to import libraries that might cause issues with specific error handling
try:
    import torchaudio
    print("Successfully imported torchaudio")
except Exception as e:
    print(f"Error importing torchaudio: {e}")
    print("Some audio functionality may be limited")

try:
    import librosa
    print("Successfully imported librosa")
except Exception as e:
    print(f"Error importing librosa: {e}")
    print("Audio processing capabilities will be limited")

try:
    import opensmile
    print("Successfully imported opensmile")
except Exception as e:
    print(f"Error importing opensmile: {e}")
    print("Will use fallback feature extraction methods")

# Part 3: Define constants
EMOTIONS = ["neutral", "happy", "sad", "angry", "fearful", "disgust", "surprised", "sarcastic"]
MODEL_CACHE_DIR = "./model_cache"

# Create cache directory if it doesn't exist
os.makedirs(MODEL_CACHE_DIR, exist_ok=True)
print(f"Using model cache directory: {MODEL_CACHE_DIR}")

# Part 4: Model Loading with Error Handling and Cache
def load_model_with_cache(model_class, model_name, cache_subdir=""):
    """Load a model with proper error handling and caching"""
    cache_path = os.path.join(MODEL_CACHE_DIR, cache_subdir)
    os.makedirs(cache_path, exist_ok=True)

    print(f"Loading model: {model_name}")
    try:
        model = model_class.from_pretrained(
            model_name,
            cache_dir=cache_path,
            local_files_only=os.path.exists(os.path.join(cache_path, model_name.replace('/', '-')))
        )
        print(f"Successfully loaded model: {model_name}")
        return model
    except KeyboardInterrupt:
        print("\nModel download interrupted. Try again or download manually.")
        return None
    except Exception as e:
        print(f"Error loading model {model_name}: {e}")
        print("Will try to continue with limited functionality.")
        return None

# Part 5: Modified Whisper Transcriber with Error Handling
class WhisperTranscriber:
    def __init__(self, model_size="tiny"):  # Changed from base to tiny for faster loading
        from transformers import WhisperProcessor, WhisperForConditionalGeneration
        print("Initializing Whisper transcriber...")

        try:
            self.processor = load_model_with_cache(
                WhisperProcessor,
                f"openai/whisper-{model_size}",
                "whisper"
            )
            self.model = load_model_with_cache(
                WhisperForConditionalGeneration,
                f"openai/whisper-{model_size}",
                "whisper"
            )

            if self.model is not None:
                self.model = self.model.to(DEVICE)
                print("Whisper model loaded successfully and moved to device")
            else:
                print("Failed to load Whisper model")

        except Exception as e:
            print(f"Error initializing Whisper: {e}")
            self.processor = None
            self.model = None

    def transcribe(self, audio_path):
        if self.processor is None or self.model is None:
            print("Whisper not properly initialized. Cannot transcribe.")
            return "Error: Transcription failed."

        try:
            # Load audio
            waveform, sample_rate = librosa.load(audio_path, sr=16000)

            # Process audio
            input_features = self.processor(waveform, sampling_rate=16000, return_tensors="pt").input_features.to(DEVICE)

            # Generate transcription
            with torch.no_grad():
                predicted_ids = self.model.generate(input_features, max_length=100)

            # Decode the transcription
            transcription = self.processor.batch_decode(predicted_ids, skip_special_tokens=True)[0]
            return transcription

        except Exception as e:
            print(f"Error in transcription: {e}")
            return "Error: Transcription failed."

# Part 6: Text-based Emotion Analysis with Fallback Options
# Improved Text-based Emotion Analysis
class TextEmotionClassifier:
    def __init__(self):
        from transformers import AutoTokenizer, AutoModelForSequenceClassification
        print("Initializing text emotion classifier...")

        # Primary emotion model
        self.emotion_model_name = "j-hartmann/emotion-english-distilroberta-base"
        self.tokenizer = load_model_with_cache(
            AutoTokenizer,
            self.emotion_model_name,
            "text_emotion"
        )
        self.model = load_model_with_cache(
            AutoModelForSequenceClassification,
            self.emotion_model_name,
            "text_emotion"
        )

        if self.model is not None:
            self.model = self.model.to(DEVICE)

        # Sentiment model for sarcasm detection
        self.sentiment_model_name = "cardiffnlp/twitter-roberta-base-sentiment"
        self.sarcasm_tokenizer = load_model_with_cache(
            AutoTokenizer,
            self.sentiment_model_name,
            "sentiment"
        )
        self.sarcasm_model = load_model_with_cache(
            AutoModelForSequenceClassification,
            self.sentiment_model_name,
            "sentiment"
        )

        if self.sarcasm_model is not None:
            self.sarcasm_model = self.sarcasm_model.to(DEVICE)

        # Enhanced keyword-based analyzer as fallback and enhancement
        self.keyword_analyzer = EnhancedKeywordEmotionAnalyzer()

    def predict_emotion(self, text):
        if self.tokenizer is None or self.model is None:
            print("Text emotion model not properly initialized.")
            # Use keyword-based analysis as primary method in this case
            return self.keyword_analyzer.analyze(text)

        try:
            # Get model predictions
            inputs = self.tokenizer(text, return_tensors="pt", truncation=True, padding=True).to(DEVICE)
            with torch.no_grad():
                outputs = self.model(**inputs)

            # Get probabilities from model
            model_probs = F.softmax(outputs.logits, dim=1).cpu().numpy()[0]

            # Get keyword-based analysis
            keyword_probs = self.keyword_analyzer.analyze(text)

            # Combine both methods with weighting
            # If text contains strong emotional keywords, give more weight to keyword analysis
            keyword_strength = self.keyword_analyzer.get_keyword_strength(text)

            # Adaptive weighting based on keyword strength
            keyword_weight = min(0.6, keyword_strength * 0.1)  # Cap at 0.6
            model_weight = 1.0 - keyword_weight

            # Combine predictions
            combined_probs = (model_weight * model_probs) + (keyword_weight * keyword_probs)

            # Normalize to ensure sum is 1
            combined_probs = combined_probs / np.sum(combined_probs)

            return combined_probs

        except Exception as e:
            print(f"Error in text emotion prediction: {e}")
            # Fallback to keyword analysis
            return self.keyword_analyzer.analyze(text)

    def detect_sarcasm(self, text):
        if self.sarcasm_tokenizer is None or self.sarcasm_model is None:
            print("Sarcasm model not properly initialized.")
            # Use keyword-based sarcasm detection as fallback
            return self.keyword_analyzer.detect_sarcasm(text)

        try:
            inputs = self.sarcasm_tokenizer(text, return_tensors="pt", truncation=True, padding=True).to(DEVICE)
            with torch.no_grad():
                outputs = self.sarcasm_model(**inputs)

            sentiment_probs = F.softmax(outputs.logits, dim=1).cpu().numpy()[0]

            # Enhance with keyword-based sarcasm detection
            keyword_sarcasm = self.keyword_analyzer.detect_sarcasm(text)

            # If keyword analysis strongly suggests sarcasm, blend with model prediction
            if keyword_sarcasm[2] > 0.5:  # If sarcasm probability is high from keywords
                # Give 40% weight to keyword analysis
                combined_probs = 0.6 * sentiment_probs + 0.4 * keyword_sarcasm
                return combined_probs

            return sentiment_probs

        except Exception as e:
            print(f"Error in sarcasm detection: {e}")
            # Fallback to keyword analysis
            return self.keyword_analyzer.detect_sarcasm(text)

# Enhanced keyword-based emotion analyzer
class EnhancedKeywordEmotionAnalyzer:
    def __init__(self):
        # Enhanced emotion keywords with weights
        self.emotion_keywords = {
            "happy": [
                ("happy", 1.0), ("joy", 1.0), ("delight", 0.9), ("excited", 0.9),
                ("glad", 0.8), ("pleased", 0.8), ("cheerful", 0.9), ("smile", 0.7),
                ("enjoy", 0.8), ("wonderful", 0.8), ("great", 0.7), ("excellent", 0.8),
                ("thrilled", 1.0), ("ecstatic", 1.0), ("content", 0.7), ("satisfied", 0.7),
                ("pleasure", 0.8), ("fantastic", 0.9), ("awesome", 0.9), ("love", 0.9),
                ("amazing", 0.9), ("perfect", 0.8), ("fun", 0.8), ("delighted", 1.0)
            ],
            "sad": [
                ("sad", 1.0), ("unhappy", 0.9), ("depressed", 1.0), ("sorrow", 1.0),
                ("grief", 1.0), ("tearful", 0.9), ("miserable", 1.0), ("disappointed", 0.8),
                ("upset", 0.8), ("down", 0.7), ("heartbroken", 1.0), ("gloomy", 0.9),
                ("devastated", 1.0), ("hurt", 0.8), ("blue", 0.7), ("regret", 0.8),
                ("dejected", 0.9), ("dismal", 0.9), ("lonely", 0.8), ("terrible", 0.8),
                ("hopeless", 0.9), ("lost", 0.7), ("crying", 0.9), ("tragic", 0.9)
            ],
            "angry": [
                ("angry", 1.0), ("mad", 0.9), ("furious", 1.0), ("annoyed", 0.8),
                ("irritated", 0.8), ("enraged", 1.0), ("livid", 1.0), ("outraged", 1.0),
                ("frustrated", 0.8), ("infuriated", 1.0), ("pissed", 0.9), ("hate", 0.9),
                ("hostile", 0.9), ("bitter", 0.8), ("resentful", 0.8), ("fuming", 0.9),
                ("irate", 1.0), ("outraged", 1.0), ("seething", 1.0), ("cross", 0.7),
                ("exasperated", 0.8), ("disgusted", 0.8), ("indignant", 0.9), ("rage", 1.0)
            ],
            "fearful": [
                ("afraid", 1.0), ("scared", 1.0), ("frightened", 1.0), ("fear", 0.9),
                ("terror", 1.0), ("panic", 1.0), ("horrified", 1.0), ("worried", 0.8),
                ("anxious", 0.9), ("nervous", 0.8), ("terrified", 1.0), ("dread", 0.9),
                ("alarmed", 0.8), ("petrified", 1.0), ("threatened", 0.8), ("intimidated", 0.8),
                ("apprehensive", 0.8), ("uneasy", 0.7), ("tense", 0.7), ("stressed", 0.7),
                ("spooked", 0.9), ("paranoid", 0.9), ("freaked", 0.9), ("jumpy", 0.8)
            ],
            "disgust": [
                ("disgust", 1.0), ("gross", 0.9), ("repulsed", 1.0), ("revolted", 1.0),
                ("sick", 0.8), ("nauseous", 0.8), ("yuck", 0.9), ("ew", 0.8),
                ("nasty", 0.9), ("repugnant", 1.0), ("foul", 0.9), ("appalled", 0.9),
                ("sickened", 0.9), ("offended", 0.8), ("distaste", 0.9), ("aversion", 0.9),
                ("abhorrent", 1.0), ("odious", 1.0), ("repellent", 1.0), ("objectionable", 0.8),
                ("detestable", 1.0), ("loathsome", 1.0), ("vile", 1.0), ("horrid", 0.9)
            ],
            "surprised": [
                ("surprised", 1.0), ("shocked", 0.9), ("astonished", 1.0), ("amazed", 0.9),
                ("startled", 0.9), ("stunned", 0.9), ("speechless", 0.8), ("unexpected", 0.8),
                ("wow", 0.8), ("whoa", 0.8), ("unbelievable", 0.8), ("incredible", 0.8),
                ("dumbfounded", 1.0), ("flabbergasted", 1.0), ("staggered", 0.9), ("aghast", 0.9),
                ("astounded", 1.0), ("taken aback", 0.9), ("disbelief", 0.8), ("bewildered", 0.8),
                ("thunderstruck", 1.0), ("wonder", 0.7), ("sudden", 0.6), ("jaw-dropping", 0.9)
            ],
            "neutral": [
                ("okay", 0.7), ("fine", 0.7), ("alright", 0.7), ("normal", 0.8),
                ("calm", 0.8), ("steady", 0.8), ("balanced", 0.8), ("ordinary", 0.8),
                ("routine", 0.8), ("regular", 0.8), ("standard", 0.8), ("moderate", 0.8),
                ("usual", 0.8), ("typical", 0.8), ("average", 0.8), ("common", 0.8),
                ("so-so", 0.7), ("fair", 0.7), ("acceptable", 0.7), ("stable", 0.8),
                ("unchanged", 0.8), ("plain", 0.7), ("mild", 0.7), ("middle-of-the-road", 0.8)
            ],
            "sarcastic": [
                ("yeah right", 1.0), ("sure thing", 0.9), ("oh great", 0.9), ("how wonderful", 0.9),
                ("wow", 0.7), ("really", 0.7), ("obviously", 0.8), ("definitely", 0.7),
                ("of course", 0.7), ("totally", 0.7), ("exactly", 0.7), ("perfect", 0.7),
                ("brilliant", 0.8), ("genius", 0.8), ("whatever", 0.8), ("right", 0.7),
                ("nice job", 0.8), ("good one", 0.8), ("bravo", 0.8), ("slow clap", 1.0),
                ("im shocked", 0.9), ("never would have guessed", 0.9), ("shocking", 0.7), ("unbelievable", 0.7)
            ]
        }

        # Sarcasm indicators
        self.sarcasm_indicators = [
            "yeah right", "sure thing", "oh great", "riiiight", "suuure",
            "*slow clap*", "/s", "wow just wow", "you don't say", "no kidding",
            "what a surprise", "shocker", "congratulations", "well done", "genius",
            "oh wow", "oh really", "totally", "absolutely", "clearly", "obviously",
            "genius idea", "brilliant plan", "fantastic job", "amazing work"
        ]

        # Negation words
        self.negations = [
            "not", "no", "never", "none", "nothing", "neither", "nor", "nowhere",
            "hardly", "scarcely", "barely", "doesn't", "isn't", "wasn't", "shouldn't",
            "wouldn't", "couldn't", "won't", "can't", "don't", "didn't", "haven't"
        ]

        # Intensifiers
        self.intensifiers = [
            "very", "really", "extremely", "absolutely", "completely", "totally",
            "utterly", "quite", "particularly", "especially", "remarkably", "truly",
            "so", "too", "such", "incredibly", "exceedingly", "extraordinarily"
        ]

        # Compile patterns for more efficient matching
        import re
        self.emotion_patterns = {}
        for emotion, keywords in self.emotion_keywords.items():
            self.emotion_patterns[emotion] = [
                (re.compile(r'\b' + re.escape(word) + r'\b', re.IGNORECASE), weight)
                for word, weight in keywords
            ]

        self.negation_pattern = re.compile(r'\b(' + '|'.join(re.escape(n) for n in self.negations) + r')\s+(\w+)', re.IGNORECASE)
        self.intensifier_pattern = re.compile(r'\b(' + '|'.join(re.escape(i) for i in self.intensifiers) + r')\s+(\w+)', re.IGNORECASE)

    def analyze(self, text):
        """
        Analyze text for emotions using enhanced keyword matching
        Returns numpy array of emotion probabilities
        """
        # Initialize scores
        emotion_scores = {emotion: 0.0 for emotion in EMOTIONS}

        # Set base score for neutral
        emotion_scores["neutral"] = 1.0

        # Convert to lowercase for case-insensitive matching
        text_lower = text.lower()

        # Process each emotion
        for emotion, patterns in self.emotion_patterns.items():
            for pattern, weight in patterns:
                matches = pattern.findall(text_lower)
                if matches:
                    # Add score based on number of matches and their weights
                    emotion_scores[emotion] += len(matches) * weight

        # Process negations - look for "not happy" patterns
        negation_matches = self.negation_pattern.finditer(text_lower)
        for match in negation_matches:
            negation, word = match.groups()
            # Check if the negated word is in any emotion keywords
            for emotion, keywords in self.emotion_keywords.items():
                if any(word == kw[0] for kw in keywords):
                    # Reduce score for this emotion and slightly increase opposite emotions
                    emotion_scores[emotion] -= 0.7

                    # Increase opposite emotions (e.g., if "not happy", increase "sad")
                    if emotion == "happy":
                        emotion_scores["sad"] += 0.3
                    elif emotion == "sad":
                        emotion_scores["happy"] += 0.3

        # Process intensifiers - "very happy" should increase score
        intensifier_matches = self.intensifier_pattern.finditer(text_lower)
        for match in intensifier_matches:
            intensifier, word = match.groups()
            # Check if the intensified word is in any emotion keywords
            for emotion, keywords in self.emotion_keywords.items():
                if any(word == kw[0] for kw in keywords):
                    # Increase score for this emotion
                    emotion_scores[emotion] += 0.5

        # Ensure no negative scores
        for emotion in emotion_scores:
            emotion_scores[emotion] = max(0, emotion_scores[emotion])

        # Normalize to probabilities
        total = sum(emotion_scores.values())
        if total > 0:
            probs = {emotion: score/total for emotion, score in emotion_scores.items()}
        else:
            # If no emotions detected, default to neutral
            probs = {emotion: 0.0 for emotion in EMOTIONS}
            probs["neutral"] = 1.0

        # Convert to numpy array in the same order as EMOTIONS
        return np.array([probs[emotion] for emotion in EMOTIONS])

    def detect_sarcasm(self, text):
        """
        Detect sarcasm in text
        Returns [negative, neutral, positive] probability array where high "positive"
        with negative context indicates sarcasm
        """
        text_lower = text.lower()
        sarcasm_score = 0.0

        # Check for direct sarcasm indicators
        for indicator in self.sarcasm_indicators:
            if indicator in text_lower:
                sarcasm_score += 0.3

        # Check for common sarcasm patterns
        positive_words = [kw[0] for kw in self.emotion_keywords["happy"]]
        has_positive = any(word in text_lower for word in positive_words)

        negative_context = any(neg in text_lower for neg in ["terrible", "awful", "horrible", "fail", "disaster", "mess"])

        # Positive words in negative context suggests sarcasm
        if has_positive and negative_context:
            sarcasm_score += 0.4

        # Check for excessive punctuation which might indicate sarcasm
        if "!!!" in text or "?!" in text:
            sarcasm_score += 0.2

        # Cap the score
        sarcasm_score = min(1.0, sarcasm_score)

        # If sarcasm detected, return sentiment array biased toward sarcasm
        # [negative, neutral, positive] - high positive with negative context indicates sarcasm
        if sarcasm_score > 0.3:
            return np.array([0.1, 0.1, 0.8])  # High positive signal for sarcasm detection
        else:
            # Return balanced array (no strong indication of sarcasm)
            return np.array([0.33, 0.34, 0.33])

    def get_keyword_strength(self, text):
        """
        Measure the strength of emotional keywords in the text
        Returns a value between 0 and 10
        """
        text_lower = text.lower()
        total_matches = 0
        weighted_matches = 0

        # Count all matches across all emotions with their weights
        for emotion, patterns in self.emotion_patterns.items():
            for pattern, weight in patterns:
                matches = pattern.findall(text_lower)
                total_matches += len(matches)
                weighted_matches += len(matches) * weight

        # Calculate strength score on a scale of 0-10
        if total_matches > 0:
            avg_weight = weighted_matches / total_matches
            # Scale based on number of matches and their average weight
            strength = min(10, (total_matches * avg_weight) / 2)
            return strength
        else:
            return 0.0

# Part 7: Acoustic Feature Extraction with Fallback
class AcousticFeatureExtractor:
    def __init__(self):
        self.use_opensmile = True
        try:
            import opensmile
            # Initialize OpenSMILE with the eGeMAPS feature set instead of ComParE_2016
            # eGeMAPS is specifically designed for voice analysis and emotion recognition
            self.smile = opensmile.Smile(
                feature_set=opensmile.FeatureSet.eGeMAPSv02,
                feature_level=opensmile.FeatureLevel.Functionals,
            )
            print("OpenSMILE feature extractor initialized successfully with eGeMAPS")
        except Exception as e:
            print(f"Failed to initialize OpenSMILE: {e}")
            print("Using librosa for feature extraction instead.")
            self.use_opensmile = False

    def extract_features(self, audio_path):
        try:
            if self.use_opensmile:
                # Use OpenSMILE for feature extraction
                features = self.smile.process_file(audio_path)
                return features.values
            else:
                # Fallback to improved librosa feature extraction
                return self._extract_librosa_features(audio_path)
        except Exception as e:
            print(f"Error in acoustic feature extraction: {e}")
            print("Using dummy features as fallback")
            # Return dummy features in case of error
            return np.zeros(88)  # eGeMAPS dimension

    def _extract_librosa_features(self, audio_path):
        """Improved librosa feature extraction focusing on emotion-relevant features"""
        try:
            # Load audio
            y, sr = librosa.load(audio_path, sr=22050)
            
            # Extract features specifically relevant to emotion detection
            
            # 1. Pitch features (fundamental frequency)
            pitches, magnitudes = librosa.piptrack(y=y, sr=sr)
            pitch_mean = np.mean(pitches[magnitudes > np.median(magnitudes)])
            pitch_std = np.std(pitches[magnitudes > np.median(magnitudes)])
            
            # 2. Energy/intensity features
            rms = librosa.feature.rms(y=y)[0]
            energy_mean = np.mean(rms)
            energy_std = np.std(rms)
            
            # 3. Tempo and rhythm features
            tempo, _ = librosa.beat.beat_track(y=y, sr=sr)
            
            # 4. Spectral features
            spectral_centroid = librosa.feature.spectral_centroid(y=y, sr=sr)[0]
            spectral_bandwidth = librosa.feature.spectral_bandwidth(y=y, sr=sr)[0]
            spectral_rolloff = librosa.feature.spectral_rolloff(y=y, sr=sr)[0]
            
            # 5. Voice quality features
            zero_crossing_rate = librosa.feature.zero_crossing_rate(y)[0]
            
            # Compute statistics for each feature
            features = []
            for feature in [spectral_centroid, spectral_bandwidth, spectral_rolloff, zero_crossing_rate]:
                features.extend([np.mean(feature), np.std(feature), np.min(feature), np.max(feature)])
            
            # Add pitch and energy features
            features.extend([pitch_mean, pitch_std, energy_mean, energy_std, tempo])
            
            # Add MFCCs (critical for speech emotion)
            mfccs = librosa.feature.mfcc(y=y, sr=sr, n_mfcc=13)
            for mfcc in mfccs:
                features.extend([np.mean(mfcc), np.std(mfcc)])
            
            # Convert to numpy array
            features = np.array(features)
            
            # Handle NaN values
            features = np.nan_to_num(features)
            
            # Pad or truncate to match eGeMAPS dimension (88)
            if len(features) < 88:
                features = np.pad(features, (0, 88 - len(features)))
            else:
                features = features[:88]
                
            return features

        except Exception as e:
            print(f"Error in librosa feature extraction: {e}")
            return np.zeros(88)  # Same dimension as eGeMAPS


# Part 8: Acoustic Emotion Classifier
class AcousticEmotionClassifier(nn.Module):
    def __init__(self, input_dim, hidden_dim=128, num_classes=len(EMOTIONS)):
        super().__init__()
        
        # Normalize input features
        self.batch_norm = nn.BatchNorm1d(input_dim)
        
        # Feature extraction layers
        self.feature_extractor = nn.Sequential(
            nn.Linear(input_dim, hidden_dim * 2),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(hidden_dim * 2, hidden_dim),
            nn.ReLU(),
            nn.Dropout(0.3)
        )
        
        # Emotion classification head
        self.classifier = nn.Sequential(
            nn.Linear(hidden_dim, hidden_dim // 2),
            nn.ReLU(),
            nn.Dropout(0.2),
            nn.Linear(hidden_dim // 2, num_classes)
        )
        
        # Initialize weights properly
        self._init_weights()
    
    def _init_weights(self):
        """Initialize weights with Xavier initialization"""
        for m in self.modules():
            if isinstance(m, nn.Linear):
                nn.init.xavier_uniform_(m.weight)
                if m.bias is not None:
                    nn.init.zeros_(m.bias)
    
    def forward(self, x):
        # Handle different input shapes
        if len(x.shape) == 1:
            x = x.unsqueeze(0)  # Add batch dimension
        
        # Normalize features
        x = self.batch_norm(x)
        
        # Extract features
        features = self.feature_extractor(x)
        
        # Classify emotions
        output = self.classifier(features)
        
        return output


class PretrainedAudioClassifier:
    """A rule-based classifier for audio emotion detection until proper training"""
    
    def __init__(self):
        # Define acoustic feature thresholds for emotions based on research
        # These are simplified heuristics based on acoustic phonetics research
        self.feature_thresholds = {
            "happy": {
                "pitch_mean": (220, 400),  # Higher pitch for happiness
                "energy_mean": (0.6, 1.0),  # Higher energy
                "speech_rate": (0.8, 1.0)   # Faster speech rate
            },
            "sad": {
                "pitch_mean": (100, 220),   # Lower pitch for sadness
                "energy_mean": (0.1, 0.5),  # Lower energy
                "speech_rate": (0.3, 0.7)   # Slower speech rate
            },
            "angry": {
                "pitch_mean": (250, 400),   # Higher pitch for anger
                "energy_mean": (0.7, 1.0),  # Higher energy
                "speech_rate": (0.7, 1.0)   # Faster speech rate
            },
            "fearful": {
                "pitch_mean": (200, 350),   # Higher pitch
                "energy_mean": (0.4, 0.8),  # Medium energy
                "speech_rate": (0.6, 0.9)   # Medium-fast speech rate
            },
            "neutral": {
                "pitch_mean": (180, 240),   # Medium pitch
                "energy_mean": (0.3, 0.6),  # Medium energy
                "speech_rate": (0.4, 0.7)   # Medium speech rate
            }
        }
    
    def extract_key_features(self, audio_path):
        """Extract key acoustic features for rule-based classification"""
        try:
            y, sr = librosa.load(audio_path, sr=22050)
            
            # Extract pitch
            pitches, magnitudes = librosa.piptrack(y=y, sr=sr)
            pitch_mean = np.mean(pitches[magnitudes > 0.1]) if np.any(magnitudes > 0.1) else 200
            
            # Normalize pitch to 0-1 range (assuming human pitch range 80-400 Hz)
            pitch_mean_norm = (pitch_mean - 80) / (400 - 80)
            pitch_mean_norm = max(0, min(1, pitch_mean_norm))
            
            # Extract energy
            rms = librosa.feature.rms(y=y)[0]
            energy_mean = np.mean(rms)
            
            # Normalize energy
            energy_mean_norm = energy_mean / 0.1  # Assuming 0.1 is a reasonable max RMS
            energy_mean_norm = max(0, min(1, energy_mean_norm))
            
            # Estimate speech rate from onsets
            onset_env = librosa.onset.onset_strength(y=y, sr=sr)
            onsets = librosa.onset.onset_detect(onset_envelope=onset_env, sr=sr)
            if len(onsets) > 1:
                speech_rate = len(onsets) / (len(y) / sr)  # Onsets per second
                speech_rate_norm = min(1.0, speech_rate / 5.0)  # Normalize, assuming 5 onsets/sec is fast
            else:
                speech_rate_norm = 0.5  # Default to medium if can't detect
            
            return {
                "pitch_mean": pitch_mean_norm,
                "energy_mean": energy_mean_norm,
                "speech_rate": speech_rate_norm
            }
            
        except Exception as e:
            print(f"Error extracting key features: {e}")
            return {
                "pitch_mean": 0.5,  # Default to medium values
                "energy_mean": 0.5,
                "speech_rate": 0.5
            }
    
    def predict(self, audio_path):
        """Predict emotion based on acoustic features"""
        # Extract key features
        features = self.extract_key_features(audio_path)
        
        # Calculate match scores for each emotion
        emotion_scores = {}
        for emotion, thresholds in self.feature_thresholds.items():
            score = 0
            for feature, (min_val, max_val) in thresholds.items():
                # Normalize threshold to 0-1 range
                min_norm = (min_val - 80) / (400 - 80) if feature == "pitch_mean" else min_val
                max_norm = (max_val - 80) / (400 - 80) if feature == "pitch_mean" else max_val
                
                # Check if feature is in the emotion's range
                if min_norm <= features[feature] <= max_norm:
                    # Higher score if closer to the middle of the range
                    middle = (min_norm + max_norm) / 2
                    distance = abs(features[feature] - middle) / ((max_norm - min_norm) / 2)
                    feature_score = 1 - distance
                    score += feature_score
                else:
                    # Penalty for being outside the range
                    score -= 0.5
            
            emotion_scores[emotion] = max(0, score)
        
        # Add small values for other emotions not in our basic set
        for emotion in EMOTIONS:
            if emotion not in emotion_scores:
                emotion_scores[emotion] = 0.1
        
        # Normalize scores to probabilities
        total = sum(emotion_scores.values())
        if total > 0:
            probs = {emotion: score/total for emotion, score in emotion_scores.items()}
        else:
            # Default to neutral if all scores are 0
            probs = {emotion: 0.1 for emotion in EMOTIONS}
            probs["neutral"] = 0.5
        
        # Convert to array in the same order as EMOTIONS
        return np.array([probs[emotion] for emotion in EMOTIONS])




# Part 9: Improved Fusion Model for combining text and acoustic predictions
class AdaptiveModalityFusionModel(nn.Module):
    def __init__(self, text_dim, acoustic_dim, hidden_dim=128, num_classes=len(EMOTIONS)):
        super().__init__()
        
        # Confidence estimators for each modality
        self.text_confidence = nn.Sequential(
            nn.Linear(text_dim, hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, 1),
            nn.Sigmoid()
        )
        
        self.acoustic_confidence = nn.Sequential(
            nn.Linear(acoustic_dim, hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, 1),
            nn.Sigmoid()
        )
        
        # Feature transformation
        self.text_transform = nn.Linear(text_dim, hidden_dim)
        self.acoustic_transform = nn.Linear(acoustic_dim, hidden_dim)
        
        # Final classifier
        self.classifier = nn.Sequential(
            nn.Linear(hidden_dim, num_classes),
            nn.Softmax(dim=1)
        )
        
        # Initialize weights
        self._init_weights()
    
    def _init_weights(self):
        for m in self.modules():
            if isinstance(m, nn.Linear):
                nn.init.xavier_uniform_(m.weight)
                if m.bias is not None:
                    nn.init.zeros_(m.bias)
    
    def forward(self, text_features, acoustic_features):
        # Estimate confidence for each modality
        text_conf = self.text_confidence(text_features)
        acoustic_conf = self.acoustic_confidence(acoustic_features)
        
        # Normalize confidences to sum to 1
        total_conf = text_conf + acoustic_conf
        text_weight = text_conf / total_conf
        acoustic_weight = acoustic_conf / total_conf
        
        # Transform features
        text_transformed = self.text_transform(text_features)
        acoustic_transformed = self.acoustic_transform(acoustic_features)
        
        # Weighted combination
        combined = text_weight * text_transformed + acoustic_weight * acoustic_transformed
        
        # Classification
        output = self.classifier(combined)
        
        return output


# Part 10: Simple Rule-based Fallback Classifier
class RuleBasedClassifier:
    """A simple rule-based classifier for fallback when models fail"""

    def predict(self, text):
        """Predict emotion based on simple word matching"""
        text = text.lower()

        # Simple emotion keywords
        emotion_keywords = {
            "happy": ["happy", "joy", "delight", "excited", "glad", "pleased", "cheerful", "smile"],
            "sad": ["sad", "unhappy", "depressed", "sorrow", "grief", "tearful", "miserable"],
            "angry": ["angry", "mad", "furious", "annoyed", "irritated", "enraged", "livid"],
            "fearful": ["afraid", "scared", "frightened", "fear", "terror", "panic", "horrified"],
            "disgust": ["disgust", "gross", "repulsed", "revolted", "sick", "nauseous"],
            "surprised": ["surprised", "shocked", "astonished", "amazed", "startled"],
            "sarcastic": ["yeah right", "sure thing", "oh great", "wow", "really", "obviously"]
        }

        # Count matches for each emotion
        emotion_scores = {emotion: 0 for emotion in EMOTIONS}
        emotion_scores["neutral"] = 1  # Default to neutral

        for emotion, keywords in emotion_keywords.items():
            for keyword in keywords:
                if keyword in text:
                    emotion_scores[emotion] += 1

        # Return the emotion with highest score
        max_emotion = max(emotion_scores, key=emotion_scores.get)

        # Convert to probabilities
        total = sum(emotion_scores.values())
        probs = {emotion: score/total for emotion, score in emotion_scores.items()}

        return max_emotion, probs

# Part 11: Complete Emotion Recognition Pipeline with Comprehensive Error Handling
class EmotionRecognitionPipeline:
    def __init__(self, acoustic_model_path=None, fusion_model_path=None):
        try:
            print("Initializing Improved Emotion Recognition Pipeline...")
            
            # Initialize transcriber
            self.transcriber = WhisperTranscriber()
            
            # Initialize text classifier
            self.text_classifier = TextEmotionClassifier()
            
            # Initialize feature extractor with improved features
            self.feature_extractor = AcousticFeatureExtractor()
            
            # Initialize rule-based audio classifier as fallback
            self.rule_based_audio = PretrainedAudioClassifier()
            
            # Initialize simple rule-based fallback
            self.rule_based = RuleBasedClassifier()
            
            # Define simple fusion strategy
            self.use_adaptive_fusion = False
            
            print("Improved Emotion Recognition Pipeline initialized successfully")
        except Exception as e:
            print(f"Error initializing pipeline: {e}")
            print("Some functionality may be limited")
    
    def predict(self, audio_path):
        results = {
            "transcription": "",
            "text_emotions": {emotion: 0.0 for emotion in EMOTIONS},
            "acoustic_emotions": {emotion: 0.0 for emotion in EMOTIONS},
            "final_emotions": {emotion: 0.0 for emotion in EMOTIONS},
            "predicted_emotion": "neutral",
            "is_sarcastic": False,
            "errors": []
        }
        
        # Step 1: Transcribe audio
        try:
            transcription = self.transcriber.transcribe(audio_path)
            results["transcription"] = transcription
            print(f"Transcription: {transcription}")
        except Exception as e:
            error_msg = f"Failed to transcribe audio: {e}"
            print(error_msg)
            results["errors"].append(error_msg)
            results["transcription"] = "Error: Could not transcribe audio"
        
        # Step 2: Analyze text emotions
        try:
            if results["transcription"].startswith("Error:"):
                # Skip text analysis if transcription failed
                text_emotions = np.ones(len(EMOTIONS)) / len(EMOTIONS)  # Equal probabilities
                sarcasm_indicators = np.array([0.33, 0.33, 0.33])
                
                # Try rule-based as fallback
                rule_emotion, rule_probs = self.rule_based.predict(results["transcription"])
                results["text_emotions"] = rule_probs
            else:
                text_emotions = self.text_classifier.predict_emotion(results["transcription"])
                sarcasm_indicators = self.text_classifier.detect_sarcasm(results["transcription"])
                
                # Format text emotions result
                results["text_emotions"] = {EMOTIONS[i]: float(text_emotions[i])
                                         for i in range(min(len(text_emotions), len(EMOTIONS)))}
            
            print(f"Text-based emotions: {results['text_emotions']}")
        except Exception as e:
            error_msg = f"Failed to analyze text emotions: {e}"
            print(error_msg)
            results["errors"].append(error_msg)
            
            # Use equal probabilities as fallback
            results["text_emotions"] = {emotion: 1.0/len(EMOTIONS) for emotion in EMOTIONS}
        
        # Step 3: Use rule-based audio classifier instead of the untrained model
        try:
            # Get predictions from rule-based classifier
            audio_probs = self.rule_based_audio.predict(audio_path)
            
            # Format acoustic emotions result
            results["acoustic_emotions"] = {EMOTIONS[i]: float(audio_probs[i])
                                          for i in range(min(len(audio_probs), len(EMOTIONS)))}
            
            print(f"Acoustic-based emotions: {results['acoustic_emotions']}")
        except Exception as e:
            error_msg = f"Failed to predict acoustic emotions: {e}"
            print(error_msg)
            results["errors"].append(error_msg)
            
            # Use equal probabilities as fallback
            results["acoustic_emotions"] = {emotion: 1.0/len(EMOTIONS) for emotion in EMOTIONS}
            audio_probs = np.ones(len(EMOTIONS)) / len(EMOTIONS)
        
        # Step 4: Improved fusion strategy - text-biased weighted average
        try:
            # Convert dictionaries to arrays
            text_array = np.array(list(results["text_emotions"].values()))
            audio_array = np.array(list(results["acoustic_emotions"].values()))
            
            # Calculate confidence scores
            text_confidence = 1.0 - np.std(text_array)  # Higher confidence if distribution is more certain
            audio_confidence = 1.0 - np.std(audio_array)
            
            # Bias toward text model since it's working better
            text_confidence *= 1.5  # Increase text confidence
            
            # Normalize confidences
            total_confidence = text_confidence + audio_confidence
            text_weight = text_confidence / total_confidence
            audio_weight = audio_confidence / total_confidence
            
            # Weighted average
            final_probs = (text_weight * text_array) + (audio_weight * audio_array)
            
            # Format final emotions
            results["final_emotions"] = {EMOTIONS[i]: float(final_probs[i])
                                       for i in range(len(EMOTIONS))}
            
            print(f"Fusion weights: Text={text_weight:.2f}, Audio={audio_weight:.2f}")
        except Exception as e:
            error_msg = f"Failed to fuse predictions: {e}"
            print(error_msg)
            results["errors"].append(error_msg)
            
            # Fallback to text-only predictions since they're more reliable
            results["final_emotions"] = results["text_emotions"]
        
        # Get predicted emotion
        try:
            emotion_values = list(results["final_emotions"].values())
            emotion_idx = np.argmax(emotion_values)
            predicted_emotion = EMOTIONS[emotion_idx]
            results["predicted_emotion"] = predicted_emotion
            
            # Check for sarcasm
            is_sarcastic = False
            if hasattr(sarcasm_indicators, "__len__") and len(sarcasm_indicators) > 0:
                if predicted_emotion in ["happy", "neutral"] and np.argmax(sarcasm_indicators) == 0:
                    is_sarcastic = True
                    results["predicted_emotion"] = "sarcastic"
            
            results["is_sarcastic"] = is_sarcastic
        except Exception as e:
            error_msg = f"Failed to determine final emotion: {e}"
            print(error_msg)
            results["errors"].append(error_msg)
            results["predicted_emotion"] = "neutral"  # Default fallback
        
        return results


# Part 12: Example on sample audio (with better error handling)
def demo_on_sample_audio(pipeline, audio_path):
    if not os.path.exists(audio_path):
        print(f"Error: Audio file not found at {audio_path}")
        return

    print(f"Analyzing audio file: {audio_path}")

    try:
        # Predict emotion from audio
        result = pipeline.predict(audio_path)

        # Print results
        print("\n===== EMOTION ANALYSIS RESULTS =====")
        print(f"Transcription: {result['transcription']}")
        print(f"\nPredicted Emotion: {result['predicted_emotion'].upper()}")
        print(f"Is Sarcastic: {'Yes' if result['is_sarcastic'] else 'No'}")

        print("\nText-based Emotions:")
        for emotion, score in result['text_emotions'].items():
            print(f"  {emotion}: {score:.4f}")

        print("\nAcoustic-based Emotions:")
        for emotion, score in result['acoustic_emotions'].items():
            print(f"  {emotion}: {score:.4f}")

        print("\nFinal Fusion Emotions:")
        for emotion, score in result['final_emotions'].items():
            print(f"  {emotion}: {score:.4f}")

        if 'errors' in result and result['errors']:
            print("\nErrors encountered:")
            for error in result['errors']:
                print(f"  - {error}")

        # Plot results for visualization
        try:
            emotions = list(result['text_emotions'].keys())
            text_scores = list(result['text_emotions'].values())
            acoustic_scores = list(result['acoustic_emotions'].values())
            final_scores = list(result['final_emotions'].values())

            plt.figure(figsize=(12, 6))

            x = np.arange(len(emotions))
            width = 0.25

            plt.bar(x - width, text_scores, width, label='Text')
            plt.bar(x, acoustic_scores, width, label='Acoustic')
            plt.bar(x + width, final_scores, width, label='Final')

            plt.xlabel('Emotions')
            plt.ylabel('Probability')
            plt.title('Emotion Prediction Results')
            plt.xticks(x, emotions, rotation=45)
            plt.legend()

            plt.tight_layout()
            plt.show()
        except Exception as e:
            print(f"Error creating visualization: {e}")

    except Exception as e:
        print(f"Error in demo: {e}")

# Part 13: Simplified dataset loading for RAVDESS dataset
def load_ravdess_sample():
    """
    Download a small sample from RAVDESS dataset for testing
    """
    # Create directory for sample data
    sample_dir = "./sample_data"
    os.makedirs(sample_dir, exist_ok=True)

    # Try to download a sample file
    try:
        import urllib.request

        # Example file from RAVDESS dataset (happy emotion)
        url = "https://zenodo.org/record/1188976/files/Audio_Speech_Actors_01-24/Actor_01/03-01-01-01-01-01-01.wav"
        sample_path = os.path.join(sample_dir, "sample_happy.wav")

        if not os.path.exists(sample_path):
            print(f"Downloading sample audio file from RAVDESS dataset...")
            urllib.request.urlretrieve(url, sample_path)
            print(f"Downloaded sample to {sample_path}")
        else:
            print(f"Sample file already exists at {sample_path}")

        return sample_path
    except Exception as e:
        print(f"Error downloading RAVDESS sample: {e}")
        return None

# Part 14: Simplified main function with proper error handling
def main():
    print("Starting Tone Classification System...")

    try:
        # Create the pipeline
        pipeline = EmotionRecognitionPipeline()

        # Try to load a sample file
        sample_audio_path = load_ravdess_sample()

        if sample_audio_path and os.path.exists(sample_audio_path):
            demo_on_sample_audio(pipeline, sample_audio_path)
        else:
            print("\nNo sample audio file available.")
            print("To use the system, provide an audio file path when calling the demo_on_sample_audio function:")
            print("\ndemo_on_sample_audio(pipeline, '/path/to/your/audio.wav')")

    except Exception as e:
        print(f"Error in main execution: {e}")
        print("\nTroubleshooting tips:")
        print("1. Check if your audio file exists and is in a supported format (WAV recommended)")
        print("2. Ensure you have sufficient memory for model loading")
        print("3. Try with a smaller model size in WhisperTranscriber (tiny instead of base)")
        print("4. Make sure you have stable internet connection for model downloading")

if __name__ == "__main__":
    main()


# Add this after the main() function definition but before the if __name__ == "__main__": line
def upload_and_analyze():
    from IPython.display import display
    import ipywidgets as widgets

    # Create upload widget
    upload_widget = widgets.FileUpload(
        accept='.wav, .mp3',
        multiple=False,
        description='Upload Audio File',
        button_style='primary'
    )
    display(upload_widget)

    # Create button to trigger analysis
    analyze_button = widgets.Button(description='Analyze Audio')
    display(analyze_button)

    # Create output area for results
    output = widgets.Output()
    display(output)

    def on_analyze_click(b):
        with output:
            output.clear_output()
            if not upload_widget.value:
                print("Please upload an audio file first.")
                return

            # Get the uploaded file
            file_data = next(iter(upload_widget.value.values()))
            file_name = next(iter(upload_widget.value.keys()))

            # Save to temp file
            temp_file = f"./temp_{file_name}"
            with open(temp_file, 'wb') as f:
                f.write(file_data['content'])

            print(f"Analyzing uploaded file: {file_name}")

            # Create pipeline and analyze
            pipeline = EmotionRecognitionPipeline()
            demo_on_sample_audio(pipeline, temp_file)

    analyze_button.on_click(on_analyze_click)

# Then modify the if __name__ == "__main__": section
if __name__ == "__main__":
    try:
        import ipywidgets
        # If ipywidgets is available, we're in a notebook
        print("Running in notebook mode - use the upload widget below:")
        upload_and_analyze()
    except ImportError:
        # Otherwise, run the standard main function
        main()


import os
import numpy as np
import torch
import matplotlib.pyplot as plt
import gradio as gr
from io import BytesIO

# Use the existing EmotionRecognitionPipeline class from your code

def analyze_audio(audio_path):
    """
    Analyze an audio file and return the emotion recognition results
    """
    if audio_path is None:
        return "Please provide an audio file.", None, None
    
    try:
        # Create the pipeline
        pipeline = EmotionRecognitionPipeline()
        
        # Predict emotion from audio
        result = pipeline.predict(audio_path)
        
        # Format the results for display
        transcription = result['transcription']
        predicted_emotion = result['predicted_emotion'].upper()
        is_sarcastic = 'Yes' if result['is_sarcastic'] else 'No'
        
        # Create text summary
        summary = f"Transcription: {transcription}\n\n"
        summary += f"Predicted Emotion: {predicted_emotion}\n"
        summary += f"Is Sarcastic: {is_sarcastic}\n\n"
        
        summary += "Text-based Emotions:\n"
        for emotion, score in result['text_emotions'].items():
            summary += f"  {emotion}: {score:.4f}\n"
        
        summary += "\nAcoustic-based Emotions:\n"
        for emotion, score in result['acoustic_emotions'].items():
            summary += f"  {emotion}: {score:.4f}\n"
        
        summary += "\nFinal Fusion Emotions:\n"
        for emotion, score in result['final_emotions'].items():
            summary += f"  {emotion}: {score:.4f}\n"
        
        if 'errors' in result and result['errors']:
            summary += "\nErrors encountered:\n"
            for error in result['errors']:
                summary += f"  - {error}\n"
        
        # Create visualization
        fig = create_emotion_plot(result)
        
        return summary, fig, result['predicted_emotion']
    except Exception as e:
        return f"Error analyzing audio: {str(e)}", None, "error"

def create_emotion_plot(result):
    """
    Create a visualization of the emotion recognition results
    """
    emotions = list(result['text_emotions'].keys())
    text_scores = list(result['text_emotions'].values())
    acoustic_scores = list(result['acoustic_emotions'].values())
    final_scores = list(result['final_emotions'].values())

    fig = plt.figure(figsize=(10, 6))

    x = np.arange(len(emotions))
    width = 0.25

    plt.bar(x - width, text_scores, width, label='Text')
    plt.bar(x, acoustic_scores, width, label='Acoustic')
    plt.bar(x + width, final_scores, width, label='Final')

    plt.xlabel('Emotions')
    plt.ylabel('Probability')
    plt.title('Emotion Recognition Results')
    plt.xticks(x, emotions, rotation=45)
    plt.legend()
    plt.tight_layout()
    
    return fig

# Create the Gradio interface with tabs for microphone and file upload
def create_gradio_interface():
    with gr.Blocks(title="Tone Classification System") as demo:
        gr.Markdown("# Tone Classification System")
        gr.Markdown("This system analyzes audio to detect emotions, including sarcasm and figures of speech.")
        
        with gr.Tabs():
            with gr.TabItem("Microphone Input"):
                with gr.Row():
                    with gr.Column():
                        audio_input = gr.Audio(
                            sources=["microphone"], 
                            type="filepath",
                            label="Record your voice"
                        )
                        analyze_btn = gr.Button("Analyze Recording", variant="primary")
                    
                    with gr.Column():
                        result_text = gr.Textbox(label="Analysis Results", lines=15)
                        emotion_plot = gr.Plot(label="Emotion Probabilities")
                        emotion_label = gr.Label(label="Detected Emotion")
                
                analyze_btn.click(
                    fn=analyze_audio,
                    inputs=audio_input,
                    outputs=[result_text, emotion_plot, emotion_label]
                )
            
            with gr.TabItem("File Upload"):
                with gr.Row():
                    with gr.Column():
                        file_input = gr.Audio(
                            sources=["upload"], 
                            type="filepath",
                            label="Upload audio file (.wav, .mp3)"
                        )
                        file_analyze_btn = gr.Button("Analyze File", variant="primary")
                    
                    with gr.Column():
                        file_result_text = gr.Textbox(label="Analysis Results", lines=15)
                        file_emotion_plot = gr.Plot(label="Emotion Probabilities")
                        file_emotion_label = gr.Label(label="Detected Emotion")
                
                file_analyze_btn.click(
                    fn=analyze_audio,
                    inputs=file_input,
                    outputs=[file_result_text, file_emotion_plot, file_emotion_label]
                )
        
        gr.Markdown("## How to Use")
        gr.Markdown("""
        1. **Microphone Input**: Record your voice and click 'Analyze Recording'
        2. **File Upload**: Upload an audio file (.wav or .mp3) and click 'Analyze File'
        
        The system will transcribe the speech, analyze emotions from both text and acoustic features,
        and display the results with a visualization of emotion probabilities.
        """)
        
        gr.Markdown("## About")
        gr.Markdown("""
        This tone classification system combines text and acoustic features to detect emotions in speech.
        It uses a multi-modal approach with:
        
        - Speech-to-text transcription
        - Text-based emotion analysis
        - Acoustic feature extraction
        - Fusion of both modalities for final prediction
        
        The system can detect: neutral, happy, sad, angry, fearful, disgust, surprised, and sarcastic tones.
        """)
    
    return demo

# Main function to launch the Gradio interface
def main():
    demo = create_gradio_interface()
    demo.launch()

if __name__ == "__main__":
    main()