updated backend

audio_preprocessing.py

@@ -1,6 +1,7 @@
 """
 Audio Preprocessing Module for Respiratory Symptom Analysis
-Version without external resampling dependencies (resampy-free)
+Updated for 39% F1-Macro Model (128x431 mel-spectrograms)
+Version: 3.0.0
 """
 
 import librosa
@@ -16,13 +17,13 @@ from scipy import signal
 os.environ['NUMBA_CACHE_DIR'] = '/tmp'
 os.environ['NUMBA_DISABLE_JIT'] = '0'
 
-# Disable warnings
 warnings.filterwarnings('ignore')
 
+
 class RespiratoryAudioPreprocessor:
     """
-    Audio preprocessor without external resampling dependencies
-    Uses scipy.signal for resampling instead of resampy
+    Audio preprocessor matching your 39% F1-Macro training pipeline
+    Mel-spectrogram shape: (128, 431) to match training data
     """
     
     def __init__(self, 
@@ -35,8 +36,8 @@ class RespiratoryAudioPreprocessor:
                  fmin: float = 0.0,
                  fmax: float = None,
                  power: float = 2.0,
-                 duration: float = 3.0):
-        """Initialize preprocessing parameters"""
+                 duration: float = 10.0):  # Changed from 3.0 to 10.0 to match training
+        """Initialize preprocessing parameters to match training"""
         self.target_sr = target_sr
         self.n_mels = n_mels
         self.n_fft = n_fft
@@ -49,8 +50,8 @@ class RespiratoryAudioPreprocessor:
         self.duration = duration
         self.target_length = int(target_sr * duration)
         
-        # Expected output shape
-        self.expected_shape = (1, 1, 128, 251)
+        # Expected output shape - UPDATED to match training (128, 431)
+        self.expected_shape = (1, 1, 128, 431)
         
         # Pre-warm librosa
         self._warmup_librosa()
@@ -190,14 +191,14 @@ class RespiratoryAudioPreprocessor:
             raise RuntimeError(f"Failed to load audio: {str(e)}")
     
     def extract_mel_spectrogram(self, audio_data: np.ndarray) -> np.ndarray:
-        """Extract mel spectrogram without resampling dependencies"""
+        """Extract mel spectrogram matching training configuration"""
         try:
             # Ensure proper format
             audio_data = np.asarray(audio_data, dtype=np.float32)
             if len(audio_data.shape) > 1:
                 audio_data = audio_data.flatten()
             
-            # Extract mel spectrogram
+            # Extract mel spectrogram with exact training parameters
             try:
                 mel_spec = librosa.feature.melspectrogram(
                     y=audio_data,
@@ -232,7 +233,7 @@ class RespiratoryAudioPreprocessor:
             raise RuntimeError(f"Failed to extract mel spectrogram: {str(e)}")
     
     def normalize_spectrogram(self, mel_spec: np.ndarray) -> np.ndarray:
-        """Normalize spectrogram"""
+        """Normalize spectrogram to match training"""
         try:
             mean = np.mean(mel_spec)
             std = np.std(mel_spec)
@@ -242,21 +243,30 @@ class RespiratoryAudioPreprocessor:
             else:
                 normalized = (mel_spec - mean) / (std + 1e-8)
             
+            # Clip to prevent extreme values
             normalized = np.clip(normalized, -5.0, 5.0)
             return normalized
             
         except Exception as e:
             raise RuntimeError(f"Failed to normalize spectrogram: {str(e)}")
     
-    def resize_spectrogram(self, mel_spec: np.ndarray, target_width: int = 251) -> np.ndarray:
-        """Resize spectrogram to target dimensions"""
+    def resize_spectrogram(self, mel_spec: np.ndarray, target_width: int = 431) -> np.ndarray:
+        """
+        Resize spectrogram to target dimensions (128, 431) to match training
+        """
         try:
             current_height, current_width = mel_spec.shape
             
+            # Handle height (should be 128 already)
+            if current_height != 128:
+                print(f"⚠️ Unexpected height: {current_height}, expected 128")
+            
+            # Handle width
             if current_width == target_width:
                 return mel_spec
             
             if current_width < target_width:
+                # Pad to target width
                 pad_width = target_width - current_width
                 mel_spec = np.pad(
                     mel_spec, 
@@ -265,6 +275,7 @@ class RespiratoryAudioPreprocessor:
                     constant_values=0
                 )
             else:
+                # Crop to target width
                 mel_spec = mel_spec[:, :target_width]
             
             return mel_spec
@@ -273,26 +284,31 @@ class RespiratoryAudioPreprocessor:
             raise RuntimeError(f"Failed to resize spectrogram: {str(e)}")
     
     def preprocess_audio(self, audio_input: Union[str, np.ndarray, tuple]) -> torch.Tensor:
-        """Complete preprocessing pipeline"""
+        """
+        Complete preprocessing pipeline matching your training
+        Output: (1, 1, 128, 431) tensor
+        """
         try:
             # Load audio
             audio_data = self.load_and_normalize_audio(audio_input)
             
-            # Extract features
+            # Extract mel-spectrogram
             mel_spec = self.extract_mel_spectrogram(audio_data)
             
             # Normalize
             mel_spec_norm = self.normalize_spectrogram(mel_spec)
             
-            # Resize
-            mel_spec_resized = self.resize_spectrogram(mel_spec_norm)
+            # Resize to (128, 431)
+            mel_spec_resized = self.resize_spectrogram(mel_spec_norm, target_width=431)
             
-            # Convert to tensor
+            # Convert to tensor (1, 1, 128, 431)
             tensor_input = torch.FloatTensor(mel_spec_resized)
             tensor_input = tensor_input.unsqueeze(0).unsqueeze(0)
             
-            # Fix shape if needed
+            # Verify shape
             if tensor_input.shape != self.expected_shape:
+                print(f"⚠️ Shape mismatch: got {tensor_input.shape}, expected {self.expected_shape}")
+                # Force resize using interpolation as last resort
                 tensor_input = torch.nn.functional.interpolate(
                     tensor_input, 
                     size=self.expected_shape[2:], 
@@ -306,7 +322,7 @@ class RespiratoryAudioPreprocessor:
             raise RuntimeError(f"Preprocessing failed: {str(e)}")
     
     def get_preprocessing_info(self) -> Dict:
-        """Get preprocessing info"""
+        """Get preprocessing configuration info"""
         return {
             'target_sr': self.target_sr,
             'n_mels': self.n_mels,
@@ -314,11 +330,13 @@ class RespiratoryAudioPreprocessor:
             'hop_length': self.hop_length,
             'duration': self.duration,
             'output_shape': self.expected_shape,
-            'resampling_method': 'scipy.signal'
+            'resampling_method': 'scipy.signal',
+            'normalization': 'z-score (mean=0, std=1)',
+            'db_scale': True
         }
     
     def validate_audio_file(self, audio_path: str) -> Tuple[bool, str]:
-        """Validate audio file"""
+        """Validate audio file before processing"""
         try:
             if not audio_path:
                 return False, "No audio file provided"
@@ -328,9 +346,9 @@ class RespiratoryAudioPreprocessor:
                 duration = info.duration
                 
                 if duration < 0.5:
-                    return False, f"Audio too short ({duration:.1f}s)"
+                    return False, f"Audio too short ({duration:.1f}s). Minimum: 0.5s"
                 if duration > 30.0:
-                    return False, f"Audio too long ({duration:.1f}s)"
+                    return False, f"Audio too long ({duration:.1f}s). Maximum: 30s"
                     
                 return True, "Audio file is valid"
                 

main.py

@@ -1,7 +1,8 @@
 """
 FastAPI Backend for Respiratory Symptom Analysis
-Updated with proper model weight loading and health classification system
+Updated for 39% F1-Macro Model (4 symptoms, no CBAM)
 Deployed on HuggingFace Spaces for use with Netlify frontend
+Version: 3.0.0
 """
 
 from fastapi import FastAPI, File, UploadFile, HTTPException
@@ -17,142 +18,132 @@ from pathlib import Path
 from typing import Dict, List, Any
 import time
 import warnings
-import copy
 
 # Import your preprocessing module
 from audio_preprocessing import RespiratoryAudioPreprocessor
 
 warnings.filterwarnings('ignore')
 
-def convert_numpy_types(obj):
-    """Convert numpy types to native Python types for JSON serialization"""
-    if isinstance(obj, np.integer):
-        return int(obj)
-    elif isinstance(obj, np.floating):
-        return float(obj)
-    elif isinstance(obj, np.ndarray):
-        return obj.tolist()
-    elif isinstance(obj, dict):
-        return {key: convert_numpy_types(value) for key, value in obj.items()}
-    elif isinstance(obj, list):
-        return [convert_numpy_types(item) for item in obj]
-    return obj
-
-# =================== MODEL ARCHITECTURE (Recreated for Loading) ===================
-class PurePyTorchInferenceModel(nn.Module):
+# =================== YOUR EXACT MODEL ARCHITECTURE ===================
+class LightweightMultiSymptomClassifier(nn.Module):
     """
-    Pure PyTorch model for inference - recreated to fix loading issues
+    Exact model architecture from your 39% F1-Macro training
+    4 symptoms: fever, cold, fatigue, cough
+    No CBAM, simplified CNN architecture
     """
-    def __init__(self, target_symptoms, confidence_thresholds):
+    def __init__(self, num_classes=4, dropout=0.5):
         super().__init__()
+        self.num_classes = num_classes
         
-        self.target_symptoms = target_symptoms
-        self.num_symptoms = len(target_symptoms)
-        
-        # Enhanced feature extractor (matching your training)
-        self.feature_extractor = nn.Sequential(
-            # Block 1: Fine-grained frequency analysis
-            nn.Conv2d(1, 32, kernel_size=(7, 3), stride=(2, 1), padding=(3, 1)),
+        # Convolutional backbone
+        self.conv1 = nn.Sequential(
+            nn.Conv2d(1, 32, kernel_size=3, padding=1),
             nn.BatchNorm2d(32),
-            nn.ReLU(inplace=True),
-            nn.MaxPool2d((2, 2)),
-            nn.Dropout2d(0.1),
-            
-            # Block 2: Temporal pattern capture
-            nn.Conv2d(32, 64, kernel_size=(3, 7), stride=(1, 2), padding=(1, 3)),
+            nn.ReLU(),
+            nn.Conv2d(32, 32, kernel_size=3, padding=1),
+            nn.BatchNorm2d(32),
+            nn.ReLU(),
+            nn.MaxPool2d(2)
+        )
+        
+        self.conv2 = nn.Sequential(
+            nn.Conv2d(32, 64, kernel_size=3, padding=1),
             nn.BatchNorm2d(64),
-            nn.ReLU(inplace=True),
-            nn.MaxPool2d((2, 2)),
-            nn.Dropout2d(0.15),
-            
-            # Block 3: Mixed spatio-temporal patterns
-            nn.Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
+            nn.ReLU(),
+            nn.Conv2d(64, 64, kernel_size=3, padding=1),
+            nn.BatchNorm2d(64),
+            nn.ReLU(),
+            nn.MaxPool2d(2)
+        )
+        
+        self.conv3 = nn.Sequential(
+            nn.Conv2d(64, 128, kernel_size=3, padding=1),
             nn.BatchNorm2d(128),
-            nn.ReLU(inplace=True),
-            nn.MaxPool2d((2, 2)),
-            nn.Dropout2d(0.2),
-            
-            # Block 4: High-level feature extraction
-            nn.Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
-            nn.BatchNorm2d(256),
-            nn.ReLU(inplace=True),
-            
-            # Block 5: Deep feature refinement
-            nn.Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
-            nn.BatchNorm2d(512),
-            nn.ReLU(inplace=True),
-            nn.AdaptiveAvgPool2d((1, 1))
+            nn.ReLU(),
+            nn.Conv2d(128, 128, kernel_size=3, padding=1),
+            nn.BatchNorm2d(128),
+            nn.ReLU(),
+            nn.MaxPool2d(2)
         )
         
-        # Shared feature processing
-        self.shared_features = nn.Sequential(
-            nn.Flatten(),
-            nn.Dropout(0.4),
-            nn.Linear(512, 512),
-            nn.BatchNorm1d(512),
-            nn.ReLU(inplace=True),
-            nn.Dropout(0.3)
+        self.conv4 = nn.Sequential(
+            nn.Conv2d(128, 256, kernel_size=3, padding=1),
+            nn.BatchNorm2d(256),
+            nn.ReLU(),
+            nn.Conv2d(256, 256, kernel_size=3, padding=1),
+            nn.BatchNorm2d(256),
+            nn.ReLU(),
+            nn.AdaptiveAvgPool2d((1, 1))
         )
         
-        # Simple attention mechanism (no MultiheadAttention to avoid TorchScript issues)
-        self.attention = nn.Sequential(
-            nn.Linear(512, 256),
-            nn.ReLU(inplace=True),
-            nn.Linear(256, 512),
-            nn.Sigmoid()
+        # Shared feature layer
+        self.shared_fc = nn.Sequential(
+            nn.Linear(256, 256),
+            nn.ReLU(),
+            nn.Dropout(dropout),
+            nn.Linear(256, 128),
+            nn.ReLU(),
+            nn.Dropout(dropout)
         )
         
-        # Individual symptom-specific heads
+        # Individual symptom heads
         self.symptom_heads = nn.ModuleList([
-            nn.Sequential(
-                nn.Linear(512, 128),
-                nn.ReLU(inplace=True),
-                nn.Dropout(0.2),
-                nn.Linear(128, 64),
-                nn.ReLU(inplace=True),
-                nn.Linear(64, 1)
-            ) for _ in range(self.num_symptoms)
+            nn.Linear(128, 1) for _ in range(num_classes)
         ])
-        
-        # Convert thresholds to tensor
-        self.register_buffer('threshold_tensor', 
-                           torch.tensor([confidence_thresholds[symptom] 
-                                       for symptom in target_symptoms], dtype=torch.float32))
     
     def forward(self, x):
-        """Forward pass for inference"""
-        # Extract features
-        features = self.feature_extractor(x)
-        shared_features = self.shared_features(features)
+        x = self.conv1(x)
+        x = self.conv2(x)
+        x = self.conv3(x)
+        x = self.conv4(x)
         
-        # Apply simple attention
-        attention_weights = self.attention(shared_features)
-        attended_features = shared_features * attention_weights
+        x = x.view(x.size(0), -1)
+        shared_features = self.shared_fc(x)
         
-        # Individual symptom predictions
-        symptom_logits = []
+        outputs = []
         for head in self.symptom_heads:
-            logit = head(attended_features)
-            symptom_logits.append(logit)
-        symptom_logits = torch.cat(symptom_logits, dim=1)
+            outputs.append(head(shared_features))
+        
+        logits = torch.cat(outputs, dim=1)
+        return logits
+
+
+class OptimizedInferenceModel(nn.Module):
+    """
+    Inference wrapper with custom thresholds
+    """
+    def __init__(self, base_model, target_symptoms, confidence_thresholds):
+        super().__init__()
+        self.base_model = base_model
+        self.target_symptoms = target_symptoms
+        
+        # Convert thresholds to tensor
+        self.register_buffer('threshold_tensor', 
+            torch.tensor([confidence_thresholds[symptom] 
+                         for symptom in target_symptoms], dtype=torch.float32))
+    
+    def forward(self, x):
+        # Get logits from base model
+        logits = self.base_model(x)
         
         # Convert to probabilities
-        symptom_probs = torch.sigmoid(symptom_logits)
+        probs = torch.sigmoid(logits)
         
-        # Apply thresholds
-        symptom_preds = (symptom_probs >= self.threshold_tensor).float()
+        # Apply custom thresholds
+        preds = (probs >= self.threshold_tensor).float()
         
         return {
-            'probabilities': symptom_probs,
-            'predictions': symptom_preds,
-            'logits': symptom_logits
+            'probabilities': probs,
+            'predictions': preds,
+            'logits': logits
         }
 
+
 # Initialize FastAPI app
 app = FastAPI(
-    title="🫁 Respiratory Symptom Analysis API",
-    description="AI-powered respiratory symptom detection from cough audio",
-    version="2.1.0",
+    title="🫁 Respiratory Symptom Analysis API v3.0",
+    description="AI-powered respiratory symptom detection (39% F1-Macro model)",
+    version="3.0.0",
     docs_url="/docs",
     redoc_url="/redoc"
 )
@@ -166,231 +157,159 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
+
 class RespiratoryAnalysisService:
     """
-    Enhanced service class for respiratory symptom analysis with proper model loading
+    Service class for respiratory symptom analysis with 39% F1-Macro model
     """
     
-    def __init__(self, config_path: str = "optimized_model_cpu/model_config.json"):
+    def __init__(self, model_dir: str = "deployment_model"):
         """Initialize the service with model and configuration"""
-        self.config_path = config_path
+        self.model_dir = Path(model_dir)
         self.model = None
         self.config = None
         self.preprocessor = None
-        self.weights_loaded = False  # Track if real weights are loaded
-        self.neutral_threshold = 0.35  # Below this = neutral/healthy
+        self.weights_loaded = False
+        self.neutral_threshold = 0.35
         
         # Load configuration and model
         self.load_config()
         self.create_and_load_model()
         self.setup_preprocessor()
-        
+    
     def load_config(self):
         """Load configuration"""
+        config_path = self.model_dir / "model_config.json"
+        
         try:
-            if Path(self.config_path).exists():
-                with open(self.config_path, 'r') as f:
+            if config_path.exists():
+                with open(config_path, 'r') as f:
                     self.config = json.load(f)
-                print(f"✅ Configuration loaded from {self.config_path}")
+                print(f"✅ Configuration loaded from {config_path}")
             else:
-                # Default configuration if file not found
+                # Default configuration for 4-symptom model
                 self.config = {
-                    'target_symptoms': ['fever', 'cold', 'sorethroat', 'lossofsmell', 'fatigue', 'cough'],
+                    'target_symptoms': ['fever', 'cold', 'fatigue', 'cough'],
                     'symptom_display_names': {
                         'fever': 'Fever',
-                        'cold': 'Cold/Runny Nose', 
-                        'sorethroat': 'Sore Throat',
-                        'lossofsmell': 'Loss of Smell',
+                        'cold': 'Cold/Runny Nose',
                         'fatigue': 'Fatigue',
                         'cough': 'Persistent Cough'
                     },
                     'confidence_thresholds': {
-                        'fever': 0.42, 'cold': 0.39, 'sorethroat': 0.45,
-                        'lossofsmell': 0.52, 'fatigue': 0.43, 'cough': 0.35
+                        'fever': 0.5,
+                        'cold': 0.5,
+                        'fatigue': 0.5,
+                        'cough': 0.5
                     },
                     'symptom_colors': {
-                        'fever': '#FF6B6B', 'cold': '#4ECDC4', 'sorethroat': '#45B7D1',
-                        'lossofsmell': '#96CEB4', 'fatigue': '#FFEAA7', 'cough': '#DDA0DD'
+                        'fever': '#FF6B6B',
+                        'cold': '#4ECDC4',
+                        'fatigue': '#FFEAA7',
+                        'cough': '#DDA0DD'
                     },
-                    'model_version': '2.1',
-                    'optimization_settings': {'torch_threads': 4}
+                    'model_version': '3.0_39percent_f1',
+                    'num_classes': 4,
+                    'dropout': 0.5
                 }
-                print("⚠️ Using default configuration")
+                print("⚠️  Using default configuration")
                 
         except Exception as e:
             raise RuntimeError(f"Failed to load config: {str(e)}")
     
     def create_and_load_model(self):
-        """Create model and try to load weights from available files with priority order"""
+        """Create model and load weights"""
         try:
-            # Create model with correct architecture
-            self.model = PurePyTorchInferenceModel(
-                target_symptoms=self.config['target_symptoms'],
-                confidence_thresholds=self.config['confidence_thresholds']
+            # Create base model
+            base_model = LightweightMultiSymptomClassifier(
+                num_classes=self.config['num_classes'],
+                dropout=self.config['dropout']
             )
             
             print("🔍 Searching for model weight files...")
             
-            # ✅ PRIORITY ORDER: Try different model files with detailed logging
+            # Priority order for loading weights
             weight_files_to_try = [
-                # Highest priority - state dicts (most compatible)
-                ("optimized_model_cpu/model_pytorch_state_dict.pt", "PyTorch State Dict", "state_dict"),
-                ("optimized_model_cpu/model_quantized_state_dict.pt", "Quantized State Dict", "state_dict"),
-                
-                # Medium priority - full models
-                ("optimized_model_cpu/model_pytorch.pt", "Full PyTorch Model", "full_model"),
-                ("optimized_model_cpu/model_quantized.pt", "Quantized PyTorch Model", "full_model"),
-                
-                # Lower priority - TorchScript (compatibility issues)
-                ("optimized_model_cpu/model_torchscript.pt", "TorchScript Model", "torchscript"),
+                (self.model_dir / "model_base.pt", "Base Model"),
+                (self.model_dir / "model_inference.pt", "Inference Model"),
+                (self.model_dir / "model_quantized.pt", "Quantized Model"),
+                (self.model_dir / "model_torchscript.pt", "TorchScript Model"),
+                (self.model_dir / "best_model.pt", "Best Checkpoint"),
             ]
             
-            for weight_file, model_type, load_type in weight_files_to_try:
-                if Path(weight_file).exists():
-                    file_size = Path(weight_file).stat().st_size / (1024*1024)  # Size in MB
+            for weight_file, model_type in weight_files_to_try:
+                if weight_file.exists():
+                    file_size = weight_file.stat().st_size / (1024*1024)
                     print(f"📁 Found {model_type}: {weight_file} ({file_size:.1f}MB)")
                     
                     try:
-                        if load_type == "state_dict":
-                            success = self._load_state_dict(weight_file, model_type)
-                        elif load_type == "full_model":
-                            success = self._load_full_model(weight_file, model_type)
-                        elif load_type == "torchscript":
-                            success = self._load_torchscript_model(weight_file, model_type)
+                        checkpoint = torch.load(weight_file, map_location='cpu', weights_only=False)
+                        
+                        # Handle different checkpoint formats
+                        if isinstance(checkpoint, dict):
+                            if 'model_state_dict' in checkpoint:
+                                state_dict = checkpoint['model_state_dict']
+                            elif 'state_dict' in checkpoint:
+                                state_dict = checkpoint['state_dict']
+                            else:
+                                state_dict = checkpoint
                         else:
-                            success = False
-                            
-                        if success:
+                            # TorchScript or full model
+                            if hasattr(checkpoint, 'state_dict'):
+                                state_dict = checkpoint.state_dict()
+                            else:
+                                # Use as TorchScript model directly
+                                self.model = checkpoint
+                                self.model.eval()
+                                self.weights_loaded = True
+                                print(f"✅ Loaded {model_type} (TorchScript)")
+                                return
+                        
+                        # Load state dict
+                        missing, unexpected = base_model.load_state_dict(state_dict, strict=False)
+                        
+                        loaded_keys = len(state_dict) - len(missing)
+                        total_keys = len(base_model.state_dict())
+                        load_percentage = (loaded_keys / total_keys) * 100
+                        
+                        print(f"   📊 Loaded {loaded_keys}/{total_keys} parameters ({load_percentage:.1f}%)")
+                        
+                        if load_percentage > 50:
                             self.weights_loaded = True
-                            print(f"✅ Successfully loaded {model_type}")
                             break
                             
                     except Exception as e:
-                        print(f"⚠️ Failed to load {model_type}: {str(e)}")
+                        print(f"⚠️  Failed to load {model_type}: {str(e)}")
                         continue
-                else:
-                    print(f"❌ Not found: {weight_file}")
             
             if not self.weights_loaded:
                 print("\n❌ WARNING: Using random model weights!")
-                print("❌ All predictions will be random (~50% confidence)")
-                print("❌ Please check your model files in optimized_model_cpu/")
-                print("❌ Expected files:")
-                for file_path, _, _ in weight_files_to_try:
-                    print(f"   - {file_path}")
+                print("❌ All predictions will be random")
+                print(f"❌ Expected model files in: {self.model_dir}/")
             else:
                 print(f"✅ Model ready with trained weights")
             
-            # Set model to evaluation mode
+            # Wrap in inference model with thresholds
+            self.model = OptimizedInferenceModel(
+                base_model,
+                self.config['target_symptoms'],
+                self.config['confidence_thresholds']
+            )
             self.model.eval()
             
-            # Set CPU optimization
-            torch.set_num_threads(self.config['optimization_settings'].get('torch_threads', 4))
+            # CPU optimization
+            torch.set_num_threads(4)
             
         except Exception as e:
             raise RuntimeError(f"Failed to create/load model: {str(e)}")
     
-    def _load_state_dict(self, weight_file: str, model_type: str) -> bool:
-        """Load model from state dict file"""
-        try:
-            checkpoint = torch.load(weight_file, map_location='cpu')
-            
-            # Handle different checkpoint formats
-            if isinstance(checkpoint, dict):
-                if 'state_dict' in checkpoint:
-                    state_dict = checkpoint['state_dict']
-                elif 'model_state_dict' in checkpoint:
-                    state_dict = checkpoint['model_state_dict']
-                else:
-                    state_dict = checkpoint
-            else:
-                state_dict = checkpoint
-            
-            # Remove any incompatible keys
-            filtered_state_dict = {}
-            for key, value in state_dict.items():
-                # Skip keys that might cause issues
-                if any(skip in key for skip in ['symptom_attention', 'covid_classifier', 'aux_']):
-                    print(f"   Skipping incompatible key: {key}")
-                    continue
-                filtered_state_dict[key] = value
-            
-            # Load weights
-            missing_keys, unexpected_keys = self.model.load_state_dict(filtered_state_dict, strict=False)
-            
-            # Check if enough weights were loaded
-            loaded_keys = len(filtered_state_dict) - len(missing_keys)
-            total_keys = len(self.model.state_dict())
-            load_percentage = (loaded_keys / total_keys) * 100
-            
-            print(f"   📊 Loaded {loaded_keys}/{total_keys} parameters ({load_percentage:.1f}%)")
-            
-            if missing_keys:
-                print(f"   ⚠️ Missing keys: {len(missing_keys)} (using random initialization)")
-            if unexpected_keys:
-                print(f"   ⚠️ Unexpected keys: {len(unexpected_keys)} (ignored)")
-            
-            # Consider successful if we loaded most parameters
-            return load_percentage > 50
-            
-        except Exception as e:
-            print(f"   ❌ State dict loading failed: {str(e)}")
-            return False
-    
-    def _load_full_model(self, weight_file: str, model_type: str) -> bool:
-        """Load full model file"""
-        try:
-            loaded_model = torch.load(weight_file, map_location='cpu')
-            
-            if hasattr(loaded_model, 'state_dict'):
-                # Extract state dict from full model
-                state_dict = loaded_model.state_dict()
-                return self._load_state_dict_direct(state_dict)
-            else:
-                # Try to use as state dict directly
-                return self._load_state_dict_direct(loaded_model)
-                
-        except Exception as e:
-            print(f"   ❌ Full model loading failed: {str(e)}")
-            return False
-    
-    def _load_torchscript_model(self, weight_file: str, model_type: str) -> bool:
-        """Load TorchScript model (with known compatibility issues)"""
-        try:
-            scripted_model = torch.jit.load(weight_file, map_location='cpu')
-            scripted_model.eval()
-            
-            # Replace the model entirely with TorchScript version
-            self.model = scripted_model
-            print(f"   ✅ Using TorchScript model directly")
-            return True
-            
-        except Exception as e:
-            print(f"   ❌ TorchScript loading failed: {str(e)}")
-            return False
-    
-    def _load_state_dict_direct(self, state_dict: Dict) -> bool:
-        """Helper to load state dict directly"""
-        try:
-            missing_keys, unexpected_keys = self.model.load_state_dict(state_dict, strict=False)
-            loaded_keys = len(state_dict) - len(missing_keys)
-            total_keys = len(self.model.state_dict())
-            load_percentage = (loaded_keys / total_keys) * 100
-            
-            print(f"   📊 Loaded {loaded_keys}/{total_keys} parameters ({load_percentage:.1f}%)")
-            return load_percentage > 50
-            
-        except Exception as e:
-            print(f"   ❌ Direct state dict loading failed: {str(e)}")
-            return False
-    
     def setup_preprocessor(self):
         """Initialize audio preprocessor"""
         self.preprocessor = RespiratoryAudioPreprocessor()
         print("✅ Audio preprocessor initialized")
     
     def predict_symptoms(self, audio_file_path: str) -> Dict[str, Any]:
-        """Predict respiratory symptoms with enhanced threshold logic and health classification"""
+        """Predict respiratory symptoms"""
         try:
             start_time = time.time()
             
@@ -405,215 +324,172 @@ class RespiratoryAnalysisService:
             inference_time = time.time() - inference_start
             
             # Parse outputs
-            probabilities = outputs['probabilities'].squeeze().detach().cpu().numpy().astype(float)
+            probabilities = outputs['probabilities'].squeeze().detach().cpu().numpy()
             
-            # ✅ ENHANCED THRESHOLD LOGIC with neutral detection
-            detected_symptoms = []
+            # Convert numpy types to Python types
+            probabilities = probabilities.astype(float).tolist()
             
+            # Detect symptoms
+            detected_symptoms = []
             for i, symptom in enumerate(self.config['target_symptoms']):
                 prob = float(probabilities[i])
-                symptom_threshold = self.config['confidence_thresholds'][symptom]
+                threshold = float(self.config['confidence_thresholds'][symptom])
+                effective_threshold = max(threshold, self.neutral_threshold)
                 
-                # Apply dual threshold system:
-                # 1. Must be above symptom-specific threshold
-                # 2. Must be above neutral threshold to avoid false positives
-                effective_threshold = max(symptom_threshold, self.neutral_threshold)
-                is_detected = prob >= effective_threshold
-                
-                if is_detected:
+                if prob >= effective_threshold:
                     detected_symptoms.append({
                         'symptom': symptom,
                         'display_name': self.config['symptom_display_names'][symptom],
-                        'confidence': float(prob),
+                        'confidence': prob,
                         'color': self.config['symptom_colors'][symptom],
-                        'threshold_used': float(effective_threshold)
+                        'threshold_used': effective_threshold
                     })
             
-            # ✅ DETERMINE OVERALL HEALTH STATUS
-            max_confidence = np.max(probabilities)
+            # Determine health status
+            max_confidence = max(probabilities)
             
             if not detected_symptoms:
                 if max_confidence < self.neutral_threshold:
                     health_status = "healthy"
                     status_message = "No symptoms detected - appears healthy"
                 else:
-                    health_status = "inconclusive" 
+                    health_status = "inconclusive"
                     status_message = "Some patterns detected but below confidence threshold"
             else:
                 health_status = "symptoms_detected"
                 status_message = f"{len(detected_symptoms)} symptom(s) detected"
             
-            # Format results with enhanced health classification
-            results = self.format_results_enhanced(
-                probabilities, detected_symptoms, health_status, status_message, max_confidence
-            )
-            
-            # Add comprehensive processing info
-            results['processing_info'] = {
-                'preprocessing_time_ms': round(preprocessing_time * 1000, 1),
-                'inference_time_ms': round(inference_time * 1000, 1),
-                'total_time_ms': round((preprocessing_time + inference_time) * 1000, 1),
-                'model_weights_loaded': self.weights_loaded,
-                'neutral_threshold': self.neutral_threshold,
-                'max_confidence': round(max_confidence, 3)
+            # Format results
+            results = {
+                'detected_symptoms': detected_symptoms,
+                'all_symptoms': {},
+                'summary': {
+                    'total_detected': len(detected_symptoms),
+                    'highest_confidence': max([s['confidence'] for s in detected_symptoms], default=0.0),
+                    'max_overall_confidence': float(max_confidence),
+                    'status': health_status,
+                    'status_message': status_message,
+                    'neutral_threshold': float(self.neutral_threshold),
+                    'weights_status': 'trained' if self.weights_loaded else 'random'
+                },
+                'recommendations': self._get_recommendations(health_status, detected_symptoms),
+                'health_classification': health_status,
+                'processing_info': {
+                    'preprocessing_time_ms': round(preprocessing_time * 1000, 1),
+                    'inference_time_ms': round(inference_time * 1000, 1),
+                    'total_time_ms': round((preprocessing_time + inference_time) * 1000, 1),
+                    'model_weights_loaded': self.weights_loaded,
+                    'model_version': '3.0_39percent_f1'
+                }
             }
             
+            # Add all symptoms details
+            for i, symptom in enumerate(self.config['target_symptoms']):
+                prob = float(probabilities[i])
+                threshold = float(self.config['confidence_thresholds'][symptom])
+                effective_threshold = max(threshold, self.neutral_threshold)
+                
+                results['all_symptoms'][symptom] = {
+                    'display_name': self.config['symptom_display_names'][symptom],
+                    'confidence': prob,
+                    'detected': prob >= effective_threshold,
+                    'original_threshold': threshold,
+                    'effective_threshold': effective_threshold,
+                    'color': self.config['symptom_colors'][symptom]
+                }
+            
             return results
             
         except Exception as e:
             raise HTTPException(status_code=500, detail=f"Prediction failed: {str(e)}")
     
-    def format_results_enhanced(self, probabilities, detected_symptoms, health_status, status_message, max_confidence):
-        """Enhanced results formatting with health classification"""
-        
-        results = {
-            'detected_symptoms': detected_symptoms,
-            'all_symptoms': {},
-            'summary': {},
-            'recommendations': [],
-            'health_classification': health_status
-        }
-        
-        # Process all symptoms with enhanced threshold information
-        for i, symptom in enumerate(self.config['target_symptoms']):
-            prob = float(probabilities[i])  # ✅ Convert to Python float
-            original_threshold = float(self.config['confidence_thresholds'][symptom])  # ✅ Convert
-            effective_threshold = float(max(original_threshold, self.neutral_threshold))
-            detected = prob >= effective_threshold
-            
-            results['all_symptoms'][symptom] = {
-                'display_name': self.config['symptom_display_names'][symptom],
-                'confidence': prob,
-                'detected': bool(detected),
-                'original_threshold': original_threshold,
-                'effective_threshold': effective_threshold,
-                'neutral_threshold': float(self.neutral_threshold),
-                'color': self.config['symptom_colors'][symptom]
-            }
+    def _get_recommendations(self, health_status, detected_symptoms):
+        """Generate recommendations based on health status"""
+        recommendations = []
         
-        # Enhanced summary with health classification
-        results['summary'] = {
-            'total_detected': int(len(detected_symptoms)),
-            'highest_confidence':float(max([s['confidence'] for s in detected_symptoms], default=0.0)),
-            'max_overall_confidence': float(max_confidence),
-            'status': str(health_status),
-            'status_message': str(status_message),
-            'neutral_threshold': float(self.neutral_threshold),
-            'weights_status': 'trained' if self.weights_loaded else 'random'
-        }
+        if not self.weights_loaded:
+            recommendations.append("⚠️ DEVELOPMENT MODE: Model using random weights - results not valid")
         
-        # ✅ ENHANCED RECOMMENDATIONS based on health status
         if health_status == "healthy":
-            results['recommendations'] = [
+            recommendations.extend([
                 "✅ No significant respiratory symptoms detected",
                 "Your cough patterns appear normal and healthy",
                 "Continue maintaining good respiratory health practices",
                 "This screening is for informational purposes only"
-            ]
+            ])
         elif health_status == "inconclusive":
-            results['recommendations'] = [
+            recommendations.extend([
                 "⚠️ Some respiratory patterns detected but below confidence threshold",
-                "Consider monitoring your symptoms over the next few days", 
+                "Consider monitoring your symptoms over the next few days",
                 "If symptoms persist or worsen, consult a healthcare provider",
                 "This AI screening should not replace professional medical advice"
-            ]
+            ])
         elif len(detected_symptoms) == 1:
             symptom_name = detected_symptoms[0]['display_name']
             confidence = detected_symptoms[0]['confidence']
-            results['recommendations'] = [
+            recommendations.extend([
                 f"🔍 Detected: {symptom_name} (confidence: {confidence:.1%})",
-                "Monitor this symptom and note any changes or progression",
-                "Consider consulting a healthcare provider if symptoms persist or worsen",
+                "Monitor this symptom and note any changes",
+                "Consider consulting a healthcare provider if symptoms persist",
                 "This AI screening should not replace professional medical advice"
-            ]
+            ])
         else:
             symptom_names = [s['display_name'] for s in detected_symptoms]
-            results['recommendations'] = [
+            recommendations.extend([
                 f"🚨 Multiple symptoms detected: {', '.join(symptom_names)}",
                 "Multiple symptoms may indicate a need for medical attention",
-                "Please consult a healthcare provider for proper evaluation and diagnosis",
+                "Please consult a healthcare provider for proper evaluation",
                 "This AI screening should not replace professional medical advice"
-            ]
+            ])
         
-        # Add model status warning if using random weights
-        if not self.weights_loaded:
-            results['recommendations'].insert(0, 
-                "⚠️ DEVELOPMENT MODE: Model using random weights - results are not medically valid"
-            )
+        return recommendations
 
-        def convert_numpy_types(obj):
-            """Convert any remaining numpy types to Python types"""
-            if hasattr(obj, 'item'):  # numpy scalars
-                return obj.item()
-            elif isinstance(obj, np.integer):
-                return int(obj)
-            elif isinstance(obj, np.floating):
-                return float(obj)
-            elif isinstance(obj, np.ndarray):
-                return obj.tolist()
-            elif isinstance(obj, dict):
-                return {key: convert_numpy_types(value) for key, value in obj.items()}
-            elif isinstance(obj, list):
-                return [convert_numpy_types(item) for item in obj]
-            elif isinstance(obj, bool):
-                return bool(obj)
-            return obj
-            
-        return convert_numpy_types(results)
 
-# Initialize service with enhanced error handling
-print("🚀 Initializing Enhanced Respiratory Analysis Service...")
+# Initialize service
+print("🚀 Initializing Respiratory Analysis Service v3.0...")
 try:
     service = RespiratoryAnalysisService()
     print("✅ Service initialized successfully!")
-    print(f"   Model weights loaded: {'Yes' if service.weights_loaded else 'No (using random weights)'}")
-    print(f"   Neutral threshold: {service.neutral_threshold}")
+    print(f"   Model: 39% F1-Macro (4 symptoms)")
+    print(f"   Weights loaded: {'Yes' if service.weights_loaded else 'No'}")
 except Exception as e:
     print(f"❌ Service initialization failed: {str(e)}")
     service = None
 
+
 # =================== API ROUTES ===================
 
 @app.get("/")
 async def root():
-    """Root endpoint with enhanced API information"""
+    """Root endpoint"""
     if service is None:
-        return {
-            "service": "Respiratory Symptom Analysis API",
-            "version": "2.1.0",
-            "status": "error - service not initialized"
-        }
+        return {"service": "Respiratory Symptom Analysis API", "version": "3.0.0", "status": "error"}
     
     return {
-        "service": "Respiratory Symptom Analysis API", 
-        "version": "2.1.0",
+        "service": "Respiratory Symptom Analysis API",
+        "version": "3.0.0",
+        "model_version": "39% F1-Macro (4 symptoms)",
         "status": "active",
         "model_status": "trained_weights" if service.weights_loaded else "random_weights",
-        "health_classification": ["healthy", "symptoms_detected", "inconclusive"],
-        "neutral_threshold": service.neutral_threshold,
+        "supported_symptoms": service.config['target_symptoms'],
         "endpoints": {
             "analyze": "/analyze",
-            "health": "/health", 
+            "health": "/health",
             "info": "/info",
             "docs": "/docs"
-        },
-        "supported_symptoms": service.config['target_symptoms'],
-        "model_info": {
-            "version": service.config['model_version'],
-            "optimization": "CPU-optimized with health classification"
         }
     }
 
+
 @app.get("/health")
 async def health_check():
-    """Enhanced health check with detailed model status"""
+    """Health check endpoint"""
     model_files_status = {
-        "pytorch_state_dict": Path("optimized_model_cpu/model_pytorch_state_dict.pt").exists(),
-        "quantized_state_dict": Path("optimized_model_cpu/model_quantized_state_dict.pt").exists(),
-        "pytorch_full": Path("optimized_model_cpu/model_pytorch.pt").exists(),
-        "quantized_full": Path("optimized_model_cpu/model_quantized.pt").exists(),
-        "torchscript": Path("optimized_model_cpu/model_torchscript.pt").exists(),
-        "config": Path("optimized_model_cpu/model_config.json").exists()
+        "model_base": (Path("deployment_model") / "model_base.pt").exists(),
+        "model_inference": (Path("deployment_model") / "model_inference.pt").exists(),
+        "model_quantized": (Path("deployment_model") / "model_quantized.pt").exists(),
+        "model_torchscript": (Path("deployment_model") / "model_torchscript.pt").exists(),
+        "config": (Path("deployment_model") / "model_config.json").exists()
     }
     
     return {
@@ -621,93 +497,72 @@ async def health_check():
         "timestamp": time.time(),
         "service_ready": service is not None,
         "model_loaded": service.model is not None if service else False,
-        "config_loaded": service.config is not None if service else False,
         "model_weights_status": "trained" if (service and service.weights_loaded) else "random",
-        "neutral_threshold": service.neutral_threshold if service else None,
-        "health_classification_enabled": True,
         "model_files_available": model_files_status,
-        "files_found": sum(model_files_status.values()),
-        "critical_files_missing": not (model_files_status["config"] and 
-                                     any([model_files_status["pytorch_state_dict"],
-                                          model_files_status["quantized_state_dict"], 
-                                          model_files_status["pytorch_full"]]))
+        "api_version": "3.0.0"
     }
 
+
 @app.get("/info")
 async def get_info():
-    """Get comprehensive model and service information"""
+    """Get model information"""
     if service is None:
         return {"error": "Service not initialized"}
     
     return {
         "model_info": {
-            "version": service.config.get('model_version', '2.1'),
+            "version": "3.0_39percent_f1",
+            "architecture": "LightweightMultiSymptomClassifier (no CBAM)",
             "target_symptoms": service.config['target_symptoms'],
             "symptom_display_names": service.config['symptom_display_names'],
             "confidence_thresholds": service.config['confidence_thresholds'],
             "weights_loaded": service.weights_loaded,
-            "neutral_threshold": service.neutral_threshold,
-            "health_classifications": ["healthy", "symptoms_detected", "inconclusive"]
+            "neutral_threshold": service.neutral_threshold
         },
         "preprocessing_info": service.preprocessor.get_preprocessing_info(),
         "supported_formats": ["wav", "mp3", "flac", "ogg", "m4a", "webm"],
         "max_duration": "30 seconds",
         "max_file_size": "10MB",
-        "api_version": "2.1.0",
-        "features": {
-            "health_classification": True,
-            "neutral_detection": True,
-            "dual_threshold_system": True,
-            "trained_weights": service.weights_loaded
-        }
+        "api_version": "3.0.0"
     }
 
+
 @app.post("/analyze")
 async def analyze_audio(audio_file: UploadFile = File(...)):
     """
-    Enhanced audio analysis with health classification
+    Analyze audio file for respiratory symptoms
     
-    Returns:
-    - Detected symptoms with confidence scores
-    - Health classification (healthy/symptoms_detected/inconclusive)  
-    - Enhanced recommendations based on health status
-    - Model weight status for debugging
+    Returns detected symptoms with confidence scores and health classification
     """
     if service is None:
         raise HTTPException(status_code=503, detail="Service not available")
     
-    # Validate file type (including WebM for browser recordings)
-    allowed_types = [
-        'audio/wav', 'audio/mpeg', 'audio/mp3', 'audio/flac', 
-        'audio/ogg', 'audio/x-m4a', 'audio/mp4', 'audio/webm'
-    ]
+    # Validate file type
+    allowed_types = ['audio/wav', 'audio/mpeg', 'audio/mp3', 'audio/flac', 
+                    'audio/ogg', 'audio/x-m4a', 'audio/mp4', 'audio/webm']
     
     if audio_file.content_type not in allowed_types:
-        raise HTTPException(
-            status_code=400,
-            detail=f"Unsupported format: {audio_file.content_type}. Supported: {', '.join(allowed_types)}"
-        )
+        raise HTTPException(status_code=400, 
+            detail=f"Unsupported format: {audio_file.content_type}")
     
     # Validate file size
     content = await audio_file.read()
-    max_size = 10 * 1024 * 1024  # 10MB
-    if len(content) > max_size:
-        raise HTTPException(status_code=400, detail="File too large. Maximum size: 10MB")
+    if len(content) > 10 * 1024 * 1024:  # 10MB
+        raise HTTPException(status_code=400, detail="File too large. Maximum: 10MB")
     
     try:
-        # Save uploaded file temporarily  
+        # Save uploaded file temporarily
         file_extension = audio_file.filename.split('.')[-1] if audio_file.filename else 'wav'
         with tempfile.NamedTemporaryFile(delete=False, suffix=f".{file_extension}") as temp_file:
             temp_file.write(content)
             temp_file_path = temp_file.name
         
-        # Analyze audio with enhanced health classification
+        # Analyze audio
         results = service.predict_symptoms(temp_file_path)
         
-        # Clean up temporary file
+        # Clean up
         os.unlink(temp_file_path)
         
-        # Return enhanced results
         return JSONResponse(
             status_code=200,
             content={
@@ -718,45 +573,20 @@ async def analyze_audio(audio_file: UploadFile = File(...)):
                     "file_size_bytes": len(content),
                     "content_type": audio_file.content_type,
                     "timestamp": time.time(),
-                    "api_version": "2.1.0"
+                    "api_version": "3.0.0"
                 }
             }
         )
         
-    except HTTPException:
-        raise
     except Exception as e:
-        # Clean up temporary file if exists
         if 'temp_file_path' in locals():
             try:
                 os.unlink(temp_file_path)
             except:
                 pass
-        
         raise HTTPException(status_code=500, detail=f"Analysis failed: {str(e)}")
 
-# Global exception handler
-@app.exception_handler(Exception)
-async def global_exception_handler(request, exc):
-    """Global exception handler with detailed error information"""
-    return JSONResponse(
-        status_code=500,
-        content={
-            "success": False,
-            "error": "Internal server error",
-            "detail": str(exc),
-            "model_status": "trained_weights" if (service and service.weights_loaded) else "random_weights",
-            "timestamp": time.time()
-        }
-    )
 
 if __name__ == "__main__":
     import uvicorn
-    
-    # Run the API server
-    uvicorn.run(
-        "main:app",
-        host="0.0.0.0",
-        port=7860,
-        reload=False
-    )
+    uvicorn.run("main:app", host="0.0.0.0", port=7860, reload=False)

requirements.txt

@@ -1,30 +1,36 @@
 # FastAPI and web server dependencies
-fastapi>=0.104.0
-uvicorn[standard]>=0.24.0
-python-multipart>=0.0.6
+fastapi==0.109.0
+uvicorn[standard]==0.27.0
+python-multipart==0.0.6
 
-# PyTorch ecosystem (matching your training environment)
-torch>=1.13.0,<2.0.0
-torchvision>=0.14.0
-torchaudio>=0.13.0
+# PyTorch ecosystem - CPU-only for HuggingFace Spaces
+--extra-index-url https://download.pytorch.org/whl/cpu
+torch==2.1.0+cpu
+torchvision==0.16.0+cpu
+torchaudio==2.1.0+cpu
 
-# Audio processing (with all dependencies)
-librosa>=0.9.2
-soundfile>=0.12.1
-resampy>=0.4.2
-audioread>=3.0.0
+# Audio processing core libraries
+librosa==0.10.1
+soundfile==0.12.1
+audioread==3.0.1
 
 # Core scientific computing
-numpy>=1.21.0,<2.0.0
-scipy>=1.7.0
-numba>=0.56.0
+numpy==1.24.3
+scipy==1.11.4
+numba==0.58.1
 
-# Additional audio processing dependencies
-llvmlite>=0.39.0
-pooch>=1.6.0
+# Audio processing dependencies
+llvmlite==0.41.1
+pooch==1.8.0
+joblib==1.3.2
+decorator==5.1.1
+lazy-loader==0.3
+msgpack==1.0.7
+cffi==1.16.0
+pycparser==2.21
 
 # Data handling
-pandas>=1.3.0
+typing-extensions==4.9.0
 
 # System utilities
-packaging>=21.0
+packaging==23.2