Update app.py

app.py

@@ -1,7 +1,4 @@
 # app.py - Voice Analysis System with Clinical Interpretation
-# This application provides comprehensive voice analysis with mental health insights
-# using voice biomarkers, emotion detection, and clinical interpretation.
-
 import gradio as gr
 import torch
 from transformers import WhisperProcessor, WhisperForConditionalGeneration
@@ -15,13 +12,13 @@ from scipy.stats import kurtosis, skew
 from anthropic import Anthropic
 from dotenv import load_dotenv
 
-# Load environment variables for API keys
+# Load environment variables
 load_dotenv()
 
-# Suppress warnings for cleaner output
+# Suppress warnings
 warnings.filterwarnings('ignore')
 
-# Initialize global model variables
+# Initialize global variables
 processor = None
 whisper_model = None
 emotion_tokenizer = None
@@ -29,28 +26,21 @@ emotion_model = None
 clinical_analyzer = None
 
 def load_models():
-    """Load and initialize speech recognition and emotion analysis models.
-    
-    This function handles the initialization of both Whisper (for speech recognition)
-    and the emotion detection model, setting them up for CPU-based inference.
-    
-    Returns:
-        bool: True if all models loaded successfully, False otherwise
-    """
+    """Initialize and load required ML models."""
     global processor, whisper_model, emotion_tokenizer, emotion_model
     
     try:
-        # Initialize speech recognition (Whisper) model
+        # Load Whisper model
         print("Loading Whisper model...")
         processor = WhisperProcessor.from_pretrained("openai/whisper-tiny")
         whisper_model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny")
         
-        # Initialize emotion detection model
+        # Load emotion model
         print("Loading emotion model...")
         emotion_tokenizer = AutoTokenizer.from_pretrained("j-hartmann/emotion-english-distilroberta-base")
         emotion_model = AutoModelForSequenceClassification.from_pretrained("j-hartmann/emotion-english-distilroberta-base")
         
-        # Set models to CPU for consistent performance
+        # Set device
         device = "cpu"
         whisper_model.to(device)
         emotion_model.to(device)
@@ -62,48 +52,37 @@ def load_models():
         return False
 
 def extract_prosodic_features(waveform, sr):
-    """Extract voice features including pitch, energy, and rhythm patterns.
-    
-    Args:
-        waveform (numpy.ndarray): Audio signal data
-        sr (int): Sampling rate of the audio
-        
-    Returns:
-        dict: Dictionary containing extracted features or None if extraction fails
-    """
+    """Extract voice features from audio data."""
     try:
-        # Input validation
         if waveform is None or len(waveform) == 0:
             return None
             
         features = {}
         
-        # Pitch analysis with enhanced accuracy
+        # Pitch analysis
         try:
             pitches, magnitudes = librosa.piptrack(
                 y=waveform, 
                 sr=sr,
-                fmin=50,      # Minimum human voice frequency
-                fmax=2000,    # Maximum human voice frequency
-                n_mels=128,   # Frequency resolution
+                fmin=50,
+                fmax=2000,
+                n_mels=128,
                 hop_length=512,
                 win_length=2048
             )
             
-            # Extract valid pitch contour
             f0_contour = [
                 pitches[magnitudes[:, t].argmax(), t]
                 for t in range(pitches.shape[1])
                 if 50 <= pitches[magnitudes[:, t].argmax(), t] <= 2000
             ]
             
-            # Calculate pitch statistics
             if f0_contour:
                 features['pitch_mean'] = float(np.mean(f0_contour))
                 features['pitch_std'] = float(np.std(f0_contour))
                 features['pitch_range'] = float(np.ptp(f0_contour))
             else:
-                features['pitch_mean'] = 160.0  # Default adult pitch
+                features['pitch_mean'] = 160.0
                 features['pitch_std'] = 0.0
                 features['pitch_range'] = 0.0
                 
@@ -111,7 +90,7 @@ def extract_prosodic_features(waveform, sr):
             print(f"Pitch extraction error: {e}")
             features.update({'pitch_mean': 160.0, 'pitch_std': 0.0, 'pitch_range': 0.0})
         
-        # Energy analysis with noise handling
+        # Energy analysis
         try:
             rms = librosa.feature.rms(
                 y=waveform,
@@ -129,7 +108,7 @@ def extract_prosodic_features(waveform, sr):
             print(f"Energy extraction error: {e}")
             features.update({'energy_mean': 0.02, 'energy_std': 0.0, 'energy_range': 0.0})
         
-        # Rhythm analysis with tempo validation
+        # Rhythm analysis
         try:
             onset_env = librosa.onset.onset_strength(
                 y=waveform,
@@ -145,7 +124,6 @@ def extract_prosodic_features(waveform, sr):
                 aggregate=None
             )[0]
             
-            # Validate tempo within normal speech range (40-240 BPM)
             features['tempo'] = float(tempo) if 40 <= tempo <= 240 else 120.0
             
         except Exception as e:
@@ -158,31 +136,21 @@ def extract_prosodic_features(waveform, sr):
         return None
 
 class ClinicalVoiceAnalyzer:
-    """Analyze voice characteristics for psychological indicators."""
+    """Clinical voice analysis and interpretation."""
     
     def __init__(self):
-        """Initialize the clinical analyzer with API and reference ranges."""
+        """Initialize analyzer with API and reference ranges."""
         self.anthropic = Anthropic(api_key=os.getenv('ANTHROPIC_API_KEY'))
         self.model = "claude-3-opus-20240229"
-        # Define normal ranges for voice metrics based on clinical research
         self.reference_ranges = {
-            'pitch': {'min': 150, 'max': 400},  # Hz
-            'tempo': {'min': 90, 'max': 130},   # BPM
+            'pitch': {'min': 150, 'max': 400},
+            'tempo': {'min': 90, 'max': 130},
             'energy': {'min': 0.01, 'max': 0.05}
         }
         print("Clinical analyzer ready")
 
     def analyze_voice_metrics(self, features, emotions, transcription):
-        """Generate clinical insights from voice and emotion data.
-        
-        Args:
-            features (dict): Extracted voice features
-            emotions (dict): Detected emotion scores
-            transcription (str): Speech content
-            
-        Returns:
-            str: Formatted clinical analysis or backup analysis if API fails
-        """
+        """Analyze voice metrics and generate clinical insights."""
         try:
             prompt = self._create_clinical_prompt(features, emotions, transcription)
             response = self.anthropic.messages.create(
@@ -196,7 +164,7 @@ class ClinicalVoiceAnalyzer:
             return self._generate_backup_analysis(features, emotions)
 
     def _create_clinical_prompt(self, features, emotions, transcription):
-        """Create detailed prompt for clinical analysis."""
+        """Create clinical analysis prompt."""
         return f"""As a clinical voice analysis expert, provide a psychological assessment of:
 
 Voice Metrics:
@@ -219,11 +187,11 @@ Provide:
 5. Clinical recommendations"""
 
     def _format_analysis(self, analysis):
-        """Format the clinical analysis output."""
+        """Format clinical analysis output."""
         return f"\nClinical Assessment:\n{analysis}"
 
     def _generate_backup_analysis(self, features, emotions):
-        """Generate basic analysis when API is unavailable."""
+        """Generate backup analysis when API fails."""
         dominant_emotion = max(emotions.items(), key=lambda x: x[1])
         pitch_status = (
             "elevated" if features['pitch_mean'] > self.reference_ranges['pitch']['max']
@@ -239,14 +207,7 @@ Basic Voice Analysis (API Unavailable):
 - Primary Emotion: {dominant_emotion[0]} ({dominant_emotion[1]:.1%} confidence)"""
 
 def create_feature_plots(features):
-    """Create interactive visualizations of voice features.
-    
-    Args:
-        features (dict): Dictionary of extracted voice features
-        
-    Returns:
-        str: HTML representation of the interactive plots
-    """
+    """Create visualizations for voice features."""
     try:
         fig = go.Figure()
         
@@ -285,7 +246,6 @@ def create_feature_plots(features):
             marker=dict(size=15, color='green')
         ))
         
-        # Layout configuration
         fig.update_layout(
             title='Voice Feature Analysis',
             showlegend=True,
@@ -302,14 +262,7 @@ def create_feature_plots(features):
         return None
 
 def create_emotion_plot(emotions):
-    """Create visualization of emotional analysis.
-    
-    Args:
-        emotions (dict): Dictionary of emotion scores
-        
-    Returns:
-        str: HTML representation of the emotion plot
-    """
+    """Create visualization for emotion analysis."""
     try:
         fig = go.Figure(data=[
             go.Bar(
@@ -335,46 +288,29 @@ def create_emotion_plot(emotions):
         return None
 
 def analyze_audio(audio_input):
-    """Process audio input and generate comprehensive analysis.
-    
-    This is the main function that coordinates the entire analysis pipeline,
-    including feature extraction, emotion detection, and clinical interpretation.
-    
-    Args:
-        audio_input: Audio file path or tuple containing audio data
-        
-    Returns:
-        tuple: (analysis_summary, emotion_visualization, feature_visualization)
-    """
+    """Main function for audio analysis."""
     try:
-        # Validate input
         if audio_input is None:
             return "Please provide an audio input", None, None
         
-        # Load audio
         audio_path = audio_input[0] if isinstance(audio_input, tuple) else audio_input
         waveform, sr = librosa.load(audio_path, sr=16000, duration=30)
         
-        # Validate duration
         duration = len(waveform) / sr
         if duration < 0.5:
             return "Audio too short (minimum 0.5 seconds needed)", None, None
         
-        # Extract features
         features = extract_prosodic_features(waveform, sr)
         if features is None:
             return "Feature extraction failed", None, None
         
-        # Generate visualizations
         feature_viz = create_feature_plots(features)
         
-        # Perform speech recognition
         inputs = processor(waveform, sampling_rate=sr, return_tensors="pt").input_features
         with torch.no_grad():
             predicted_ids = whisper_model.generate(inputs)
         transcription = processor.batch_decode(predicted_ids, skip_special_tokens=True)[0]
         
-        # Analyze emotions
         emotion_inputs = emotion_tokenizer(
             transcription,
             return_tensors="pt",
@@ -387,7 +323,6 @@ def analyze_audio(audio_input):
             emotion_outputs = emotion_model(**emotion_inputs)
         emotions = torch.nn.functional.softmax(emotion_outputs.logits, dim=-1)
         
-        # Process emotion scores
         emotion_labels = ['anger', 'fear', 'joy', 'neutral', 'sadness', 'surprise']
         emotion_scores = {
             label: float(score) 
@@ -396,7 +331,6 @@ def analyze_audio(audio_input):
         
         emotion_viz = create_emotion_plot(emotion_scores)
         
-        # Generate clinical analysis
         global clinical_analyzer
         if clinical_analyzer is None:
             clinical_analyzer = ClinicalVoiceAnalyzer()
@@ -405,20 +339,7 @@ def analyze_audio(audio_input):
             features, emotion_scores, transcription
         )
         
-        # Create comprehensive summary
-        summary = f"""Voice Analysis Summary:
-
-Speech Content:
-{transcription}
-
-Voice Characteristics:
-- Average Pitch: {features['pitch_mean']:.2f} Hz
-- Pitch Variation: {features['pitch_std']:.2f} Hz
-- Speech Rate (Tempo): {features['tempo']:.2f} BPM
-- Voice Energy: {features['energy_mean']:.4f}
-
-Dominant Emotion: {max(emotion_scores.items(), key=lambda x: x[1])[0]}
-Emotion# Continue from previous summary string
+        # Create summary with fixed string formatting
         summary = f"""Voice Analysis Summary:
 
 Speech Content:
@@ -435,8 +356,8 @@ Emotion Confidence: {max(emotion_scores.values()):.2%}
 
 Recording Duration: {duration:.2f} seconds
 
-{clinical_analysis}"""
-        
+{clinical_analysis}
+"""
         return summary, emotion_viz, feature_viz
         
     except Exception as e:
@@ -444,19 +365,16 @@ Recording Duration: {duration:.2f} seconds
         print(error_msg)
         return error_msg, None, None
 
-# Application initialization and Gradio interface setup
+# Application initialization
 try:
     print("===== Application Startup =====")
     
-    # Load required models
     if not load_models():
         raise RuntimeError("Model loading failed")
     
-    # Initialize clinical analyzer
     clinical_analyzer = ClinicalVoiceAnalyzer()
     print("Clinical analyzer initialized")
     
-    # Define the interface description
     description = """This application provides comprehensive voice analysis with clinical insights:
 
 1. Voice Features:
@@ -483,7 +401,6 @@ For optimal results:
 
 Upload an audio file or record directly through your microphone."""
 
-    # Create Gradio interface
     demo = gr.Interface(
         fn=analyze_audio,
         inputs=gr.Audio(
@@ -509,13 +426,12 @@ Upload an audio file or record directly through your microphone."""
         theme="default"
     )
     
-    # Launch the interface with additional configuration
     if __name__ == "__main__":
         demo.launch(
-            server_name="0.0.0.0",  # Allow external access
-            server_port=7860,        # Default Gradio port
-            share=False,             # Disable public URL generation
-            debug=False              # Disable debug mode in production
+            server_name="0.0.0.0",
+            server_port=7860,
+            share=False,
+            debug=False
         )
         
 except Exception as e: