Fix audio classifier model loading and label mapping, update Gradio compatibility

app.py

@@ -271,9 +271,12 @@ def create_interface():
     }
     """
     
-    with gr.Blocks(css=custom_css, title="Authenticity Detection System") as demo:
+    with gr.Blocks(title="Authenticity Detection System") as demo:
         
-        gr.HTML("""
+        gr.HTML(f"""
+        <style>
+        {custom_css}
+        </style>
         <header style='background: white; border-bottom: 1px solid #e5e7eb; margin-bottom: 32px;'>
             <div style='padding: 16px 0;'>
                 <div style='display: flex; align-items: center; gap: 12px;'>

audio_classifier.py

@@ -84,7 +84,7 @@ class AudioClassifier:
     }
     
     @classmethod
-    def get_model_path(cls, model_name: str = '4s_window') -> str:
+    def get_model_path(cls, model_name: str = '3s_window') -> str:
         import os
         if model_name not in cls.AVAILABLE_MODELS:
             raise ValueError(f"Unknown model: {model_name}. Available: {list(cls.AVAILABLE_MODELS.keys())}")
@@ -100,16 +100,17 @@ class AudioClassifier:
         
         if model_path is None:
             import os
-            model_path = os.path.join(os.path.dirname(__file__), 'spectrogram_cnn_4s_window.pth')
+            model_path = os.path.join(os.path.dirname(__file__), 'spectrogram_cnn_3s_window (1).pth')
         
         try:
+            print(f"Attempting to load model from: {model_path}")
             state_dict = torch.load(model_path, map_location=self.device)
             self.model.load_state_dict(state_dict)
-            print(f"Successfully loaded model from: {model_path}")
+            print(f"✓ Successfully loaded trained model from: {model_path}")
         except FileNotFoundError:
-            print(f"Warning: Model file not found at {model_path}. Using untrained model.")
+            raise FileNotFoundError(f"Model file not found at {model_path}. Please ensure the model file exists.")
         except Exception as e:
-            print(f"Warning: Error loading model from {model_path}: {e}. Using untrained model.")
+            raise RuntimeError(f"Error loading model from {model_path}: {e}")
         
         self.model.eval()
         
@@ -118,16 +119,53 @@ class AudioClassifier:
         self.n_fft = 2048
         self.hop_length = 512
         
-    def extract_mel_spectrogram(self, audio_path: str) -> np.ndarray:
+    def extract_mel_spectrogram(self, audio_path: str, window_size: float = 3.0) -> np.ndarray:
+        """Extract mel spectrogram from audio, using windowing if audio is longer than window_size."""
         audio, sr = librosa.load(audio_path, sr=self.sample_rate)
         
-        mel_spec = librosa.feature.melspectrogram(
-            y=audio,
-            sr=sr,
-            n_mels=self.n_mels,
-            n_fft=self.n_fft,
-            hop_length=self.hop_length
-        )
+        # If audio is longer than window_size, take multiple windows and average
+        window_samples = int(window_size * sr)
+        
+        if len(audio) > window_samples * 1.5:  # If significantly longer
+            # Split into overlapping windows
+            hop_samples = window_samples // 2
+            windows = []
+            for start in range(0, len(audio) - window_samples, hop_samples):
+                window = audio[start:start + window_samples]
+                windows.append(window)
+            
+            # Also add the last window
+            if len(audio) > window_samples:
+                windows.append(audio[-window_samples:])
+            
+            # Compute mel spectrogram for each window and average
+            mel_specs = []
+            for window in windows[:5]:  # Limit to 5 windows to avoid too much computation
+                mel_spec = librosa.feature.melspectrogram(
+                    y=window,
+                    sr=sr,
+                    n_mels=self.n_mels,
+                    n_fft=self.n_fft,
+                    hop_length=self.hop_length
+                )
+                mel_specs.append(mel_spec)
+            
+            # Average the spectrograms
+            mel_spec = np.mean(mel_specs, axis=0)
+        else:
+            # Pad or use as-is for short audio
+            if len(audio) < window_samples:
+                audio = np.pad(audio, (0, window_samples - len(audio)), mode='constant')
+            else:
+                audio = audio[:window_samples]
+            
+            mel_spec = librosa.feature.melspectrogram(
+                y=audio,
+                sr=sr,
+                n_mels=self.n_mels,
+                n_fft=self.n_fft,
+                hop_length=self.hop_length
+            )
         
         mel_spec_db = librosa.power_to_db(mel_spec, ref=np.max)
         
@@ -287,6 +325,11 @@ class AudioClassifier:
             probabilities = F.softmax(logits, dim=1)
             predicted_class = torch.argmax(probabilities, dim=1).item()
             cnn_confidence = probabilities[0, predicted_class].item()
+            
+            # Debug output
+            print(f"CNN Logits: {logits[0].cpu().numpy()}")
+            print(f"CNN Probabilities: Class 0 (read)={probabilities[0, 0].item():.3f}, Class 1 (spontaneous)={probabilities[0, 1].item():.3f}")
+            print(f"CNN Prediction: Class {predicted_class} ({['read', 'spontaneous'][predicted_class]}) with confidence {cnn_confidence:.3f}")
         
         acoustic_features = self.extract_acoustic_features(audio_path)
         
@@ -294,7 +337,11 @@ class AudioClassifier:
         prosody_classification = prosody_scores['classification']
         prosody_confidence = prosody_scores['confidence']
         
-        cnn_class_name = 'read' if predicted_class == 0 else 'spontaneous'
+        # Try reversing labels if model was trained with opposite mapping
+        # Original: 0=read, 1=spontaneous
+        # Reversed: 0=spontaneous, 1=read
+        cnn_class_name = 'spontaneous' if predicted_class == 0 else 'read'  # REVERSED LABELS
+        print(f"Final CNN classification: {cnn_class_name}")
         
         if cnn_class_name == prosody_classification:
             final_confidence = min(0.95, (cnn_confidence * 0.7 + prosody_confidence * 0.3))

requirements.txt

@@ -2,7 +2,7 @@ torch>=2.0.0
 torchaudio>=2.0.0
 openai-whisper>=20230314
 transformers>=4.30.0
-gradio>=4.0.0
+gradio==4.44.0
 numpy>=1.24.0
 scikit-learn>=1.3.0
 librosa>=0.10.0