Update app.py

app.py

@@ -32,14 +32,16 @@ N_FFT = 2048
 HOP_LENGTH = 512
 N_MELS = 128
 FMAX = 8000
-DURATION = 10
+DURATION = 10  # 10 seconds per segment
 
 # --- LOAD YOUR FINE-TUNED MODEL ---
 FINETUNED_MODEL_PATH = "snoring_detection_model fine tuned.h5"
 finetuned_snore_model = None
 
 def build_finetuned_model_architecture():
-    """Reconstruct the EXACT fine-tuned model architecture from training"""
+    """
+    Reconstruct the EXACT fine-tuned model architecture from training.
+    """
     inputs = layers.Input(shape=(128, 431, 1))
     
     # Block 1
@@ -123,38 +125,57 @@ except Exception as e:
     finetuned_snore_model = None
 
 # ========================================
-# KAGGLE METHOD - SNORING DETECTION
+# SNORING DETECTION - EXACT FROM KAGGLE CLEANING PIPELINE
 # ========================================
 
 def create_mel_spectrogram(y, sr):
-    """Create mel-spectrogram EXACTLY as in Kaggle cleaning pipeline"""
+    """
+    Create mel-spectrogram EXACTLY as in Kaggle cleaning pipeline
+    This is the EXACT function from your working code
+    """
     mel_spec = librosa.feature.melspectrogram(
         y=y, sr=sr, n_fft=N_FFT, hop_length=HOP_LENGTH,
         n_mels=N_MELS, fmax=FMAX, power=1.0
     )
     mel_spec_db = librosa.power_to_db(mel_spec, ref=np.max)
+    # Normalize to 0-1 range
     mel_spec_db = (mel_spec_db - mel_spec_db.min()) / (mel_spec_db.max() - mel_spec_db.min() + 1e-10)
     return mel_spec_db
 
 def predict_snoring_segment(y_segment, sr, model):
-    """Predict snoring for a segment - EXACT from Kaggle cleaning pipeline"""
-    target_length = SAMPLE_RATE * DURATION
+    """
+    Predict snoring for a segment - EXACT from Kaggle cleaning pipeline
+    This is the EXACT function from your working code
+    """
+    # Ensure segment is exactly 10 seconds
+    target_length = SAMPLE_RATE * DURATION  # 22050 * 10 = 220500 samples
     
     if len(y_segment) < target_length:
+        # Pad with zeros
         padding = target_length - len(y_segment)
         y_segment = np.pad(y_segment, (0, padding), mode='constant')
     elif len(y_segment) > target_length:
+        # Truncate
         y_segment = y_segment[:target_length]
     
+    # Normalize
     y_segment = y_segment / (np.max(np.abs(y_segment)) + 1e-10)
+    
+    # Create mel-spectrogram
     mel_spec = create_mel_spectrogram(y_segment, sr)
+    
+    # Add batch and channel dimensions
     mel_spec_input = mel_spec[np.newaxis, ..., np.newaxis]
+    
+    # Predict
     probability = model.predict(mel_spec_input, verbose=0)[0][0]
     
     return float(probability)
 
 def analyze_audio_segments(y, sr, model, segment_duration=10):
-    """Analyze audio in segments - EXACT from Kaggle cleaning pipeline"""
+    """
+    Analyze audio in segments - EXACT from Kaggle cleaning pipeline
+    """
     segment_length = int(segment_duration * sr)
     total_duration = len(y) / sr
     num_segments = int(np.ceil(total_duration / segment_duration))
@@ -167,15 +188,19 @@ def analyze_audio_segments(y, sr, model, segment_duration=10):
         start_sample = i * segment_length
         end_sample = min(start_sample + segment_length, len(y))
         
+        # Extract segment
         segment = y[start_sample:end_sample]
         
+        # Pad if too short
         if len(segment) < segment_length:
             padding = segment_length - len(segment)
             segment = np.pad(segment, (0, padding), mode='constant')
         
+        # Resample to 22050 Hz (training sample rate)
         if sr != SAMPLE_RATE:
             segment = librosa.resample(segment, orig_sr=sr, target_sr=SAMPLE_RATE)
         
+        # Predict using EXACT Kaggle method
         probability = predict_snoring_segment(segment, SAMPLE_RATE, model)
         is_snoring = probability > 0.5
         
@@ -190,82 +215,121 @@ def analyze_audio_segments(y, sr, model, segment_duration=10):
         
         segment_results.append(segment_result)
         
+        # Progress and logging
         if is_snoring:
             print(f"   ✅ Segment {i+1}/{num_segments}: SNORE (prob: {probability:.4f})")
+        else:
+            print(f"   ⬜ Segment {i+1}/{num_segments}: No snore (prob: {probability:.4f})")
     
     return segment_results
 
 # ========================================
-# SMART SOFT VALIDATION (LENIENT)
+# BREATHING & SLEEP RECORDING VALIDATION
 # ========================================
 
-def smart_audio_validation(y, sr):
-    """
-    SMART SOFT VALIDATION - Only reject obvious non-sleep audio
-    
-    REJECTS (HARD STOP):
-    - Completely silent audio (blank recordings)
-    - Music with strong beat patterns
-    - Clear speech/conversation (high speech frequencies)
-    - Very loud audio (concerts, parties)
-    
-    ALLOWS (PROCESS ANYWAY):
-    - Short audio (even < 20s)
-    - Low breathing confidence (snoring doesn't always have regular breathing)
-    - Moderate energy audio
-    - Any audio with potential sleep sounds
-    """
+def has_speech_in_segment(y_segment, sr):
+    """Check if segment contains human speech"""
+    if len(y_segment) < sr * 0.2:
+        return False
+    
+    zcr = np.mean(librosa.feature.zero_crossing_rate(y_segment)[0])
+    if zcr > 0.30:
+        return True
+    
+    centroid = np.mean(librosa.feature.spectral_centroid(y=y_segment, sr=sr)[0])
+    if centroid > 3000:
+        return True
+    
+    stft = np.abs(librosa.stft(y_segment))
+    freq_bins = librosa.fft_frequencies(sr=sr)
+    speech_range = (freq_bins >= 2000) & (freq_bins <= 8000)
+    speech_energy = np.sum(stft[speech_range, :])
+    total_energy = np.sum(stft) + 1e-10
+    speech_ratio = speech_energy / total_energy
+    
+    if speech_ratio > 0.4:
+        return True
+    
+    return False
+
+def is_human_breathing_sound(y_segment, sr):
+    """Detect if segment contains breathing sounds"""
+    if len(y_segment) < sr * 0.05:
+        return False
+    
+    rms_energy = np.sqrt(np.mean(y_segment**2))
+    
+    if rms_energy < 0.002 or rms_energy > 0.8:
+        return False
+    
+    stft = np.abs(librosa.stft(y_segment))
+    freq_bins = librosa.fft_frequencies(sr=sr)
+    
+    breathing_range = (freq_bins >= 200) & (freq_bins <= 2000)
+    breathing_energy = np.sum(stft[breathing_range, :])
+    total_energy = np.sum(stft) + 1e-10
+    breathing_ratio = breathing_energy / total_energy
+    
+    if breathing_ratio < 0.2:
+        return False
+    
+    zcr = librosa.feature.zero_crossing_rate(y_segment)[0]
+    mean_zcr = np.mean(zcr)
+    
+    if mean_zcr > 0.25:
+        return False
+    
+    return True
+
+def validate_sleep_recording(y, sr):
+    """Validate that this is a sleep recording"""
     duration = len(y) / sr
+    
+    if duration < 20:
+        return False, 0.0, "Audio too short (< 20 seconds)"
+    
     rms_energy = np.sqrt(np.mean(y**2))
+    if rms_energy < 0.001:
+        return False, 0.0, "Audio is blank/silent"
+    
+    if rms_energy > 0.6:
+        return False, 0.0, "Audio too loud (not a sleep recording)"
     
-    # HARD REJECT 1: Completely silent (blank recording)
-    if rms_energy < 0.0005:
-        return False, "REJECT: Audio is completely blank/silent (no sound detected)"
+    num_samples = min(10, int(duration / 5))
+    breathing_segments = 0
+    
+    for i in range(num_samples):
+        start = int((duration / num_samples) * i * sr)
+        end = int(start + 3 * sr)
+        if end > len(y):
+            end = len(y)
+        segment = y[start:end]
+        
+        if is_human_breathing_sound(segment, sr):
+            breathing_segments += 1
     
-    # HARD REJECT 2: Extremely loud (not a bedroom recording)
-    if rms_energy > 0.7:
-        return False, "REJECT: Audio too loud (likely music/TV/party, not sleep recording)"
+    breathing_confidence = breathing_segments / num_samples
     
-    # Spectral analysis
     stft = np.abs(librosa.stft(y))
     freq_bins = librosa.fft_frequencies(sr=sr)
     
-    # Frequency distribution
     low_freq_energy = np.sum(stft[freq_bins < 2000, :])
     high_freq_energy = np.sum(stft[freq_bins > 4000, :])
-    very_high_freq = np.sum(stft[freq_bins > 6000, :])
     total_energy = np.sum(stft) + 1e-10
     
     low_freq_ratio = low_freq_energy / total_energy
     high_freq_ratio = high_freq_energy / total_energy
-    very_high_ratio = very_high_freq / total_energy
     
-    # HARD REJECT 3: Too much very high frequency = music/speech
-    if very_high_ratio > 0.25:
-        return False, "REJECT: Too much very high-frequency content (likely music or TV)"
+    if low_freq_ratio < 0.4:
+        return False, breathing_confidence, "Frequency distribution doesn't match sleep audio"
     
-    # HARD REJECT 4: Almost no low frequency AND lots of high frequency = speech
-    if low_freq_ratio < 0.2 and high_freq_ratio > 0.5:
-        return False, "REJECT: Frequency pattern matches speech/conversation, not sleep audio"
+    if high_freq_ratio > 0.3:
+        return False, breathing_confidence, "Too much high-frequency content (speech/TV detected)"
     
-    # SOFT WARNINGS (but still process)
-    warnings = []
-    
-    if duration < 10:
-        warnings.append("⚠️ Very short audio (< 10s) - limited analysis")
-    
-    if rms_energy < 0.003:
-        warnings.append("⚠️ Very quiet audio - may be mostly silence")
-    
-    if high_freq_ratio > 0.35:
-        warnings.append("⚠️ Moderate high-frequency content detected")
-    
-    # ACCEPT: Let the model decide
-    if warnings:
-        warning_msg = " | ".join(warnings)
-        return True, f"SOFT WARNING: {warning_msg}"
+    if breathing_confidence >= 0.3:
+        return True, breathing_confidence, "Valid sleep recording detected"
     else:
-        return True, "PASS: Audio appears suitable for sleep analysis"
+        return False, breathing_confidence, "Insufficient breathing patterns detected"
 
 # --- API ENDPOINTS ---
 
@@ -277,13 +341,15 @@ async def root():
         "model_loaded": finetuned_snore_model is not None,
         "model_type": "Fine-tuned CNN with Kaggle preprocessing",
         "model_accuracy": "95.33%",
-        "validation": "Smart soft validation (lenient)"
+        "model_auc": "99.43%",
+        "preprocessing": "Exact match to Kaggle cleaning pipeline"
     }
 
 @app.post("/analyze")
 async def analyze_audio(file: UploadFile = File(...)):
-    """Analyze audio using smart soft validation + Kaggle method"""
+    """Analyze audio using Kaggle preprocessing method"""
     
+    # Check if model is loaded
     if finetuned_snore_model is None:
         raise HTTPException(
             status_code=503,
@@ -292,43 +358,40 @@ async def analyze_audio(file: UploadFile = File(...)):
     
     temp_path = f"temp_{os.getpid()}_{file.filename}"
     
+    # Save uploaded file
     with open(temp_path, "wb") as buffer:
         shutil.copyfileobj(file.file, buffer)
             
     try:
-        # 1. LOAD AUDIO
+        # 1. LOAD: Use original sample rate, will resample per segment
         print(f"\n🔊 Loading audio: {file.filename}")
         y, sr = librosa.load(temp_path, sr=None, dtype=np.float32)
-        print(f"   Duration: {len(y)/sr:.1f}s, Sample rate: {sr} Hz")
+        print(f"   Original sample rate: {sr} Hz")
+        print(f"   Duration: {len(y)/sr:.1f}s")
         
-        # 2. SMART SOFT VALIDATION
-        print("\n🔍 Smart audio validation...")
-        is_valid, validation_message = smart_audio_validation(y, sr)
+        # 2. VALIDATE: Check if valid sleep recording
+        print("\n🔍 Validating sleep recording...")
+        is_valid_recording, breathing_confidence, validation_reason = validate_sleep_recording(y, sr)
         
-        if not is_valid:
-            # HARD REJECT - Don't process
-            print(f"   ❌ {validation_message}")
-            raise HTTPException(
-                status_code=400,
-                detail=validation_message
-            )
+        print(f"   Validation: {'✅ PASS' if is_valid_recording else '⚠️ WARNING'}")
+        print(f"   Breathing confidence: {breathing_confidence*100:.1f}%")
+        print(f"   Reason: {validation_reason}")
         
-        # SOFT WARNING or PASS - Continue processing
-        print(f"   ✅ {validation_message}")
+        validation_warning = None if is_valid_recording else validation_reason
         
-        # 3. NOISE REDUCTION
-        print("🧹 Applying noise reduction...")
+        # 3. CLEAN: Apply noise reduction
+        print("\n🧹 Applying noise reduction...")
         y_clean = nr.reduce_noise(y=y, sr=sr, stationary=True)
         
-        # 4. KAGGLE METHOD - ANALYZE
-        print(f"🎯 Analyzing with fine-tuned model (Kaggle method)...")
+        # 4. ANALYZE: Use EXACT Kaggle method
+        print(f"\n🎯 Analyzing with fine-tuned model (Kaggle method)...")
         segment_results = analyze_audio_segments(y_clean, sr, finetuned_snore_model, segment_duration=10)
         
-        # 5. COUNT RESULTS
+        # 5. COUNT SNORING
         snore_count = sum(1 for seg in segment_results if seg['is_snoring'])
         total_segments = len(segment_results)
         
-        print(f"\n📊 Analysis Results:")
+        print(f"\n📊 Results:")
         print(f"   Total segments: {total_segments}")
         print(f"   Snoring segments: {snore_count}")
         print(f"   Snoring percentage: {(snore_count/total_segments)*100:.1f}%")
@@ -337,7 +400,7 @@ async def analyze_audio(file: UploadFile = File(...)):
         annotations = []
         apnea_count = 0
         
-        # Snoring annotations
+        # Add snoring annotations
         for seg in segment_results:
             if seg['is_snoring']:
                 annotations.append({
@@ -349,45 +412,48 @@ async def analyze_audio(file: UploadFile = File(...)):
                     "confidence": round(seg['confidence'], 4)
                 })
         
-        # Apnea detection (gaps between snoring)
+        # Detect apnea (gaps between snoring)
         for i in range(len(segment_results) - 1):
             current = segment_results[i]
             next_seg = segment_results[i + 1]
             
+            # If current is snoring and next is not, check gap
             if current['is_snoring'] and not next_seg['is_snoring']:
+                gap_start = current['end_time']
+                # Find next snoring segment
                 for j in range(i + 1, len(segment_results)):
                     if segment_results[j]['is_snoring']:
-                        gap_duration = segment_results[j]['start_time'] - current['end_time']
+                        gap_end = segment_results[j]['start_time']
+                        gap_duration = gap_end - gap_start
                         
+                        # Apnea = 10-120 second gaps
                         if 10.0 <= gap_duration <= 120.0:
                             apnea_count += 1
                             risk = "LOW" if gap_duration < 15.0 else ("MEDIUM" if gap_duration < 20.0 else "HIGH")
                             annotations.append({
                                 "label": "APNEA",
-                                "start_sec": round(current['end_time'], 2),
-                                "end_sec": round(segment_results[j]['start_time'], 2),
+                                "start_sec": round(gap_start, 2),
+                                "end_sec": round(gap_end, 2),
                                 "duration": round(gap_duration, 2),
                                 "risk_level": risk
                             })
-                            print(f"   ⚠️  Apnea: {gap_duration:.1f}s gap")
+                            print(f"   ⚠️  Apnea detected: {gap_duration:.1f}s gap")
                         break
         
-        # 7. STATISTICS
+        # 7. Calculate statistics
         total_duration = segment_results[-1]['end_time']
         duration_hours = total_duration / 3600
         ahi = apnea_count / duration_hours if duration_hours > 0 else 0
         
         snoring_percentage = (snore_count / total_segments) * 100
         
-        # Risk based on snoring percentage
-        if snoring_percentage > 60:
+        risk_summary = "NORMAL"
+        if snoring_percentage > 50:
             risk_summary = "HIGH"
-        elif snoring_percentage > 40:
+        elif snoring_percentage > 30:
             risk_summary = "MEDIUM"
-        elif snoring_percentage > 20:
+        elif snoring_percentage > 15:
             risk_summary = "LOW"
-        else:
-            risk_summary = "NORMAL"
         
         # Cleanup
         del y, y_clean
@@ -395,7 +461,8 @@ async def analyze_audio(file: UploadFile = File(...)):
 
         return {
             "valid_recording": True,
-            "validation_message": validation_message,
+            "validation_warning": validation_warning,
+            "breathing_confidence": round(breathing_confidence, 4),
             "snore_count": snore_count,
             "total_segments": total_segments,
             "snoring_percentage": round(snoring_percentage, 2),
@@ -403,11 +470,10 @@ async def analyze_audio(file: UploadFile = File(...)):
             "overall_risk": risk_summary,
             "ahi_score": round(ahi, 1),
             "model_used": "Fine-tuned CNN (Kaggle method)",
+            "model_accuracy": "95.33%",
             "events": annotations
         }
 
-    except HTTPException:
-        raise
     except Exception as e:
         print(f"🔥 ERROR: {str(e)}")
         import traceback