Update app.py

app.py

@@ -154,31 +154,33 @@ try:
     
     except Exception as e1:
         print(f"   Method 1 failed: {str(e1)[:150]}")
-        print("   Trying Method 2: Load weights only...")
+        print("   Trying Method 2: Rebuild EXACT architecture from training code...")
         
         try:
-            # Build a compatible architecture based on your latest model code
+            # Build EXACT architecture from your training code
             new_counting_model = models.Sequential([
-                layers.Input(shape=(128, None, 1)),  # Variable time dimension
-                layers.Conv2D(32, (3, 3), activation='relu', padding='same'),
-                layers.BatchNormalization(),
+                # First Block: Detects basic edges in sound
+                layers.Conv2D(32, (3, 3), activation='relu', input_shape=(128, 431, 1)),
                 layers.MaxPooling2D((2, 2)),
-                
-                layers.Conv2D(64, (3, 3), activation='relu', padding='same'),
                 layers.BatchNormalization(),
+
+                # Second Block: Detects complex patterns (snore textures)
+                layers.Conv2D(64, (3, 3), activation='relu'),
                 layers.MaxPooling2D((2, 2)),
-                
-                layers.Conv2D(128, (3, 3), activation='relu', padding='same'),
                 layers.BatchNormalization(),
-                layers.GlobalAveragePooling2D(),
+
+                # Third Block
+                layers.Conv2D(128, (3, 3), activation='relu'),
+                layers.MaxPooling2D((2, 2)),
                 
+                layers.Flatten(),
                 layers.Dense(128, activation='relu'),
-                layers.Dropout(0.4),
+                layers.Dropout(0.5),
                 layers.Dense(1, activation='sigmoid')
             ])
             
             new_counting_model.load_weights(NEW_MODEL_PATH)
-            print("✅ New Counting Model Loaded Successfully (Method 2 - Weight Reconstruction)!")
+            print("✅ New Counting Model Loaded Successfully (Method 2 - EXACT Architecture Rebuild)!")
             print(f"   Model input shape: {new_counting_model.input_shape}")
             print(f"   Model output shape: {new_counting_model.output_shape}")
         
@@ -269,36 +271,39 @@ def predict_snoring_segment(y_segment, sr, model):
 # ========================================
 
 def extract_spectrogram_for_new_model(y_segment, sr):
-    """Extract spectrogram for new model (from latest model code)"""
-    # Resample to 16kHz if needed
+    """Extract spectrogram for new model - EXACT from training code"""
+    # Resample to 16kHz as in training
     if sr != NEW_MODEL_SAMPLE_RATE:
         y_segment = librosa.resample(y_segment, orig_sr=sr, target_sr=NEW_MODEL_SAMPLE_RATE)
         sr = NEW_MODEL_SAMPLE_RATE
     
-    # Ensure exact length
-    target_len = NEW_MODEL_SAMPLE_RATE * NEW_MODEL_DURATION
+    # Ensure exact length: 160,000 samples for 10s @ 16kHz
+    target_len = NEW_MODEL_SAMPLE_RATE * NEW_MODEL_DURATION  # 160,000
     if len(y_segment) < target_len:
         y_segment = np.pad(y_segment, (0, target_len - len(y_segment)))
     else:
         y_segment = y_segment[:target_len]
     
-    # Generate Mel Spectrogram
-    spec = librosa.feature.melspectrogram(y=y_segment, sr=sr, n_mels=128, n_fft=2048, hop_length=512)
-    log_spec = librosa.power_to_db(spec, ref=np.max)
-    # Normalize
-    log_spec = (log_spec - log_spec.min()) / (log_spec.max() - log_spec.min() + 1e-6)
+    # Convert to Mel Spectrogram - EXACT same as training
+    spectrogram = librosa.feature.melspectrogram(y=y_segment, sr=sr, n_mels=128)
+    log_spec = librosa.power_to_db(spectrogram, ref=np.max)
+    
+    # Normalize between 0 and 1 - EXACT same as training
+    log_spec = (log_spec - log_spec.min()) / (log_spec.max() - log_spec.min())
+    
     return log_spec[..., np.newaxis]
 
 def count_snores_in_segment(y_segment, sr, model, threshold=0.7):
     """
     Count individual snores within a detected snoring segment
     Uses sliding 2-second window to detect multiple snore events
+    USES EXACT PREPROCESSING FROM TRAINING CODE
     """
     if model is None:
         return 0
     
     try:
-        # Resample to 16kHz for new model
+        # Resample to 16kHz for new model (as in training)
         if sr != NEW_MODEL_SAMPLE_RATE:
             y_segment = librosa.resample(y_segment, orig_sr=sr, target_sr=NEW_MODEL_SAMPLE_RATE)
             sr = NEW_MODEL_SAMPLE_RATE
@@ -307,16 +312,18 @@ def count_snores_in_segment(y_segment, sr, model, threshold=0.7):
         is_snoring = False
         
         # Slide a 2-second window across the segment
-        window_size = 2 * sr
+        window_size = 2 * sr  # 2 seconds
         step_size = int(0.5 * sr)  # 0.5s steps for high resolution
         
         for start in range(0, len(y_segment) - window_size, step_size):
             chunk = y_segment[start : start + window_size]
             
-            # Process chunk to spectrogram
-            spec = librosa.feature.melspectrogram(y=chunk, sr=sr, n_mels=128, n_fft=2048, hop_length=512)
-            log_spec = librosa.power_to_db(spec, ref=np.max)
-            log_spec = (log_spec - log_spec.min()) / (log_spec.max() - log_spec.min() + 1e-6)
+            # Process chunk to spectrogram - EXACT same as training code
+            spectrogram = librosa.feature.melspectrogram(y=chunk, sr=sr, n_mels=128)
+            log_spec = librosa.power_to_db(spectrogram, ref=np.max)
+            
+            # Normalize between 0 and 1 - EXACT same as training
+            log_spec = (log_spec - log_spec.min()) / (log_spec.max() - log_spec.min())
             
             # Predict
             prediction = model.predict(log_spec[np.newaxis, ..., np.newaxis], verbose=0)
@@ -766,7 +773,7 @@ async def analyze_audio(file: UploadFile = File(...)):
                 
                 annotations.append(annotation)
         
-        # Apnea detection - only with HIGH and MEDIUM confidence snoring
+        # Apnea detection - FOCUS: Silence gaps of 10-120 seconds between snoring events
         for i in range(len(segment_results) - 1):
             current = segment_results[i]
             if current['is_snoring'] and current['confidence_level'] in ['HIGH', 'MEDIUM']:
@@ -774,35 +781,27 @@ async def analyze_audio(file: UploadFile = File(...)):
                     if segment_results[j]['is_snoring'] and segment_results[j]['confidence_level'] in ['HIGH', 'MEDIUM']:
                         gap_duration = segment_results[j]['start_time'] - current['end_time']
                         
-                        # Apnea detection with confidence requirement
-                        if 10.0 <= gap_duration <= 90.0:
-                            # Require higher confidence for longer gaps
-                            if gap_duration > 30.0:
-                                # For long gaps, require at least one HIGH confidence
-                                if current['confidence_level'] == 'HIGH' or segment_results[j]['confidence_level'] == 'HIGH':
-                                    apnea_count += 1
-                                    risk = "MEDIUM" if gap_duration < 40.0 else "HIGH"
-                                    annotations.append({
-                                        "label": "APNEA",
-                                        "start_sec": round(current['end_time'], 2),
-                                        "end_sec": round(segment_results[j]['start_time'], 2),
-                                        "duration": round(gap_duration, 2),
-                                        "risk_level": risk,
-                                        "note": "Detected between high/medium confidence snoring segments"
-                                    })
-                                    print(f"   ⚠️  Apnea: {gap_duration:.1f}s gap (between confident snoring segments)")
+                        # APNEA: Silence gap between 10-120 seconds
+                        if 10.0 <= gap_duration <= 120.0:
+                            apnea_count += 1
+                            
+                            # Risk classification based on gap duration
+                            if gap_duration < 20.0:
+                                risk = "LOW"
+                            elif gap_duration < 40.0:
+                                risk = "MEDIUM"
                             else:
-                                # Shorter gaps - any confidence level (but already filtered for HIGH/MEDIUM)
-                                apnea_count += 1
-                                risk = "LOW" if gap_duration < 20.0 else "MEDIUM"
-                                annotations.append({
-                                    "label": "APNEA",
-                                    "start_sec": round(current['end_time'], 2),
-                                    "end_sec": round(segment_results[j]['start_time'], 2),
-                                    "duration": round(gap_duration, 2),
-                                    "risk_level": risk
-                                })
-                                print(f"   ⚠️  Apnea: {gap_duration:.1f}s gap")
+                                risk = "HIGH"
+                            
+                            annotations.append({
+                                "label": "APNEA",
+                                "start_sec": round(current['end_time'], 2),
+                                "end_sec": round(segment_results[j]['start_time'], 2),
+                                "duration": round(gap_duration, 2),
+                                "risk_level": risk,
+                                "note": f"Silence gap of {gap_duration:.1f}s between snoring events"
+                            })
+                            print(f"   ⚠️  Apnea: {gap_duration:.1f}s silence gap (Risk: {risk})")
                         break
         
         # 7. STATISTICS
@@ -837,13 +836,14 @@ async def analyze_audio(file: UploadFile = File(...)):
             "valid_recording": True,
             "validation_warning": validation_warning,
             "snore_count": snore_count,
+            "total_snore_counts": total_individual_snores,  # NEW: Total individual snores counted by new model
             "high_confidence_snores": high_conf_count,
             "medium_confidence_snores": medium_conf_count,
             "rejected_potential_snores": rejected_count,
             "total_segments": total_segments,
             "snoring_percentage": round(snoring_percentage, 2),
             "apnea_count": apnea_count,
-            "apnea_risk": risk_summary,
+            "overall_risk": risk_summary,
             "ahi_score": round(ahi, 1),
             "detection_mode": "STRICT: Only HIGH and MEDIUM confidence snoring detection",
             "detection_note": detection_note,