Add COVID detection app (model to be uploaded via web)

.gitignore

@@ -0,0 +1 @@
+models/*.keras

app.py

@@ -0,0 +1,11 @@
+"""
+Hugging Face Space deployment file
+"""
+import demo
+
+if __name__ == "__main__":
+    interface = demo.create_demo_interface(
+        model_path="models/respiratory_cnn_best.keras",
+        model_type="deep"
+    )
+    interface.launch()

demo.py

@@ -0,0 +1,356 @@
+"""
+Gradio web interface for respiratory disease detection.
+Upload audio and get real-time predictions.
+"""
+
+import gradio as gr
+import numpy as np
+import sys
+from pathlib import Path
+import joblib
+from tensorflow import keras
+
+# Add src to path
+sys.path.insert(0, str(Path(__file__).parent / 'src'))
+
+from preprocessing import AudioPreprocessor
+from evaluation import AudioVisualizer
+
+
+class RespiratoryDiseasePredictor:
+    """Predictor wrapper for the demo interface."""
+    
+    def __init__(self, model_path: str, model_type: str = 'baseline'):
+        """
+        Initialize predictor.
+        
+        Args:
+            model_path: Path to saved model
+            model_type: Type of model ('baseline' or 'deep')
+        """
+        self.model_type = model_type
+        self.preprocessor = AudioPreprocessor(sample_rate=16000, duration=5.0)
+        
+        # Load model
+        if model_type == 'baseline':
+            model_data = joblib.load(model_path)
+            self.model = model_data['model']
+            self.scaler = model_data['scaler']
+        else:
+            self.model = keras.models.load_model(model_path)
+            self.scaler = None
+        
+        # Load label encoder
+        import pickle
+        label_encoder_path = Path(model_path).parent / 'label_encoder.pkl'
+        
+        if label_encoder_path.exists():
+            with open(label_encoder_path, 'rb') as f:
+                self.label_encoder = pickle.load(f)
+            self.class_names = list(self.label_encoder.classes_)
+            print(f"Loaded class names: {self.class_names}")
+        else:
+            print(f"⚠️  Warning: label_encoder.pkl not found at {label_encoder_path}")
+            print("Using default class names")
+            # Try to infer from data directory
+            data_dir = Path('data/raw')
+            if data_dir.exists():
+                self.class_names = sorted([d.name for d in data_dir.iterdir() if d.is_dir()])
+                print(f"Inferred class names from data directory: {self.class_names}")
+            else:
+                self.class_names = None
+        
+        print(f"Model loaded: {model_type}")
+        if self.class_names:
+            print(f"Classes: {self.class_names}")
+    
+    def _format_disease_name(self, class_name: str) -> str:
+        """Convert class name to human-readable disease name."""
+        disease_map = {
+            'covid': 'COVID-19',
+            'healthy': 'Healthy (No Disease)',
+            'symptomatic': 'Symptomatic (Non-COVID)',
+            'asthma': 'Asthma',
+            'unknown': 'Unknown Condition'
+        }
+        return disease_map.get(class_name.lower(), class_name.title())
+    
+    def _format_diagnosis(self, predicted_class: str, confidence: float) -> str:
+        """Format diagnosis result in human-readable format."""
+        disease_name = self._format_disease_name(predicted_class)
+        
+        # Special handling for healthy vs disease
+        if predicted_class.lower() == 'healthy':
+            result = f"✅ NO DISEASE DETECTED\n\n"
+            result += f"Result: {disease_name}\n"
+            result += f"Confidence: {confidence:.1f}%\n\n"
+            result += "Your respiratory sounds appear normal and healthy."
+        elif predicted_class.lower() == 'covid':
+            result = f"⚠️ COVID-19 DETECTED\n\n"
+            result += f"Result: {disease_name}\n"
+            result += f"Confidence: {confidence:.1f}%\n\n"
+            result += "Indicators of COVID-19 detected in respiratory sounds.\n"
+            result += "⚠️ Please consult a healthcare professional and get tested."
+        elif predicted_class.lower() == 'symptomatic':
+            result = f"⚠️ RESPIRATORY SYMPTOMS DETECTED\n\n"
+            result += f"Result: {disease_name}\n"
+            result += f"Confidence: {confidence:.1f}%\n\n"
+            result += "Respiratory symptoms detected, but not specifically COVID-19.\n"
+            result += "Please consult a healthcare professional if symptoms persist."
+        else:
+            result = f"🔍 {disease_name.upper()} DETECTED\n\n"
+            result += f"Result: {disease_name}\n"
+            result += f"Confidence: {confidence:.1f}%\n\n"
+            result += "Please consult a healthcare professional for proper diagnosis."
+        
+        return result
+    
+    def predict_audio(self, audio_path: str):
+        """
+        Predict disease from audio file.
+        
+        Args:
+            audio_path: Path to audio file
+            
+        Returns:
+            Dictionary with predictions and probabilities
+        """
+        try:
+            # Load and preprocess audio
+            audio = self.preprocessor.load_audio(audio_path)
+            
+            if self.model_type == 'baseline':
+                # Extract MFCC and compute statistics
+                mfcc = self.preprocessor.extract_mfcc(audio)
+                features = self.preprocessor.compute_statistics(mfcc)
+                features = features.reshape(1, -1)
+                
+                # Scale features
+                if self.scaler:
+                    features = self.scaler.transform(features)
+                
+                # Predict
+                prediction = self.model.predict(features)[0]
+                probabilities = self.model.predict_proba(features)[0]
+                
+            else:  # deep learning
+                # Extract MFCC for deep learning
+                mfcc = self.preprocessor.extract_mfcc(audio)
+                features = np.expand_dims(mfcc, axis=0)
+                features = np.expand_dims(features, axis=-1)
+                
+                # Predict
+                raw_output = self.model.predict(features, verbose=0)[0]
+                
+                # Handle binary classification (output shape: (1,) or (2,))
+                if len(raw_output) == 1:
+                    # FLIPPED: Training data has labels reversed
+                    # High output = COVID, Low output = Healthy
+                    prob_covid = float(raw_output[0])
+                    prob_healthy = 1.0 - prob_covid
+                    
+                    # Create probability array matching class order ['covid', 'healthy']
+                    probabilities = np.array([prob_covid, prob_healthy])
+                    
+                    # Adjusted threshold: require 65% confidence for COVID detection
+                    # This reduces false positives (healthy flagged as COVID)
+                    prediction = int(prob_covid < 0.65)  # 1 if healthy, 0 if covid
+                else:
+                    # Multi-class output
+                    probabilities = raw_output
+                    prediction = np.argmax(probabilities)
+            
+            # Format results with human-readable output
+            if self.class_names:
+                predicted_class = self.class_names[prediction]
+                confidence = float(probabilities[prediction]) * 100
+                
+                # Create human-readable result
+                result_text = self._format_diagnosis(predicted_class, confidence)
+                
+                # Add debug info
+                result_text += f"\n\n[Debug Info]\n"
+                result_text += f"Raw model output: {probabilities}\n"
+                result_text += f"Prediction index: {prediction}\n"
+                result_text += f"Audio shape: {audio.shape}, MFCC shape: {mfcc.shape}\n"
+                
+                # Format probabilities with disease names
+                prob_dict = {
+                    self._format_disease_name(self.class_names[i]): float(probabilities[i]) 
+                    for i in range(len(self.class_names))
+                }
+            else:
+                predicted_class = f"Class {prediction}"
+                result_text = f"Predicted: {predicted_class}"
+                prob_dict = {f"Class {i}": float(probabilities[i]) 
+                           for i in range(len(probabilities))}
+            
+            return result_text, prob_dict, audio, mfcc
+            
+        except Exception as e:
+            print(f"Error during prediction: {e}")
+            return None, None, None, None
+
+
+def create_demo_interface(model_path: str, model_type: str = 'baseline'):
+    """
+    Create Gradio interface for the model.
+    
+    Args:
+        model_path: Path to trained model
+        model_type: Type of model ('baseline' or 'deep')
+    """
+    # Initialize predictor
+    predictor = RespiratoryDiseasePredictor(model_path, model_type)
+    
+    def predict(audio):
+        """Prediction function for Gradio interface."""
+        if audio is None:
+            return "No audio provided", {}, None, None
+        
+        # Handle both file path and tuple (sample_rate, audio_data)
+        if isinstance(audio, tuple):
+            # Gradio microphone input
+            import soundfile as sf
+            import tempfile
+            
+            sr, audio_data = audio
+            # Save temporarily
+            with tempfile.NamedTemporaryFile(delete=False, suffix='.wav') as f:
+                sf.write(f.name, audio_data, sr)
+                audio_path = f.name
+        else:
+            audio_path = audio
+        
+        # Make prediction
+        predicted_class, probabilities, audio_signal, mfcc = predictor.predict_audio(audio_path)
+        
+        if predicted_class is None:
+            return "Error processing audio", {}, None, None
+        
+        # Create visualization
+        import matplotlib.pyplot as plt
+        import librosa.display
+        
+        # Waveform
+        fig1, ax1 = plt.subplots(figsize=(10, 3))
+        time = np.arange(len(audio_signal)) / predictor.preprocessor.sample_rate
+        ax1.plot(time, audio_signal, linewidth=0.5)
+        ax1.set_xlabel('Time (s)')
+        ax1.set_ylabel('Amplitude')
+        ax1.set_title('Audio Waveform')
+        ax1.grid(True, alpha=0.3)
+        plt.tight_layout()
+        
+        # MFCC visualization
+        fig2, ax2 = plt.subplots(figsize=(10, 4))
+        img = ax2.imshow(mfcc, aspect='auto', origin='lower', cmap='viridis')
+        ax2.set_xlabel('Time Frame')
+        ax2.set_ylabel('MFCC Coefficient')
+        ax2.set_title('MFCC Features')
+        plt.colorbar(img, ax=ax2, label='Coefficient Value')
+        plt.tight_layout()
+        
+        return predicted_class, probabilities, fig1, fig2
+    
+    # Create Gradio interface
+    demo = gr.Interface(
+        fn=predict,
+        inputs=[
+            gr.Audio(type="filepath", label="Upload Audio (Cough/Voice Recording)")
+        ],
+        outputs=[
+            gr.Textbox(label="Diagnosis Result", lines=6),
+            gr.Label(label="Detailed Probabilities", num_top_classes=10),
+            gr.Plot(label="Audio Waveform"),
+            gr.Plot(label="MFCC Features")
+        ],
+        title="Covid Detection AI",
+        description="""
+        ⚠️ **AI IN DEVELOPMENT - NOT FOR MEDICAL USE** ⚠️
+        
+        **IMPORTANT:** This AI system is currently under development and should NOT be used as a 
+        substitute for professional medical diagnosis. If the system flags potential COVID-19 or 
+        any respiratory condition, you MUST contact a healthcare professional immediately for 
+        proper testing, diagnosis, and treatment.
+        
+        ---
+        
+        Upload a cough, breath, or voice recording to detect potential respiratory diseases.
+        
+        **Supported formats:** WAV, MP3, FLAC
+        """,
+        article="""
+        ---
+        
+        ### ⚠️ CRITICAL MEDICAL DISCLAIMER ⚠️
+        
+        **THIS AI IS IN ACTIVE DEVELOPMENT AND NOT APPROVED FOR MEDICAL USE**
+        
+        - ❌ **DO NOT** use this tool to self-diagnose
+        - ❌ **DO NOT** use this as a replacement for COVID-19 testing
+        - ❌ **DO NOT** delay seeking medical care based on these results
+        - ✅ **ALWAYS** consult a healthcare professional if you have symptoms
+        - ✅ **ALWAYS** get proper medical testing if flagged for COVID-19
+        - ✅ **ALWAYS** follow official health guidelines and protocols
+        
+        **If this system detects COVID-19 or any respiratory condition, immediately contact 
+        your doctor or local health authority for proper testing and medical guidance.**
+        
+        ---
+        
+        ### How it works:
+        1. Upload an audio recording (cough, breath, or voice)
+        2. The AI extracts audio features (MFCCs - Mel-frequency cepstral coefficients)
+        3. The model predicts the likelihood of different respiratory conditions
+        4. Results show the predicted disease and confidence scores
+        
+        ### Model Information:
+        - **Model Type:** {model_type}
+        - **Audio Processing:** 16kHz sampling rate, 5-second segments
+        - **Features:** MFCC, spectral features, temporal features
+        - **Status:** Development prototype - not clinically validated
+        
+        ### Legal Disclaimer:
+        This tool is for educational and research purposes only. It is not a substitute for 
+        professional medical advice, diagnosis, or treatment. The developers assume no 
+        liability for any health decisions made based on this system's output.
+        """.format(model_type=model_type.upper()),
+        examples=[
+            # Add example audio files here if available
+        ],
+        allow_flagging="never",
+        theme=gr.themes.Soft()
+    )
+    
+    return demo
+
+
+def main():
+    """Launch the demo interface."""
+    import argparse
+    
+    parser = argparse.ArgumentParser(description='Launch Gradio demo for respiratory disease detection')
+    parser.add_argument('--model_path', type=str, required=True,
+                       help='Path to trained model file')
+    parser.add_argument('--model_type', type=str, default='baseline',
+                       choices=['baseline', 'deep'],
+                       help='Type of model')
+    parser.add_argument('--share', action='store_true',
+                       help='Create public link')
+    parser.add_argument('--port', type=int, default=7860,
+                       help='Port to run the server on')
+    
+    args = parser.parse_args()
+    
+    # Create and launch interface
+    demo = create_demo_interface(args.model_path, args.model_type)
+    demo.launch(
+        share=args.share,
+        server_port=args.port,
+        server_name="0.0.0.0"
+    )
+
+
+if __name__ == "__main__":
+    main()

requirements_hf.txt

@@ -0,0 +1,8 @@
+gradio==4.44.1
+tensorflow==2.15.0
+librosa==0.10.1
+numpy==1.24.3
+scikit-learn==1.3.2
+matplotlib==3.8.2
+soundfile==0.12.1
+joblib==1.3.2

src/__init__.py

@@ -0,0 +1,25 @@
+"""
+Respiratory Disease Detection AI Package
+Detect respiratory diseases from voice, breath, and cough recordings.
+"""
+
+__version__ = '1.0.0'
+__author__ = 'Your Name'
+
+from .preprocessing import AudioPreprocessor, AudioAugmenter
+from .dataset import AudioDataset
+from .baseline_models import BaselineModel, ModelComparison
+from .deep_learning_models import CNNModel, LSTMModel
+from .evaluation import ModelEvaluator, AudioVisualizer
+
+__all__ = [
+    'AudioPreprocessor',
+    'AudioAugmenter',
+    'AudioDataset',
+    'BaselineModel',
+    'ModelComparison',
+    'CNNModel',
+    'LSTMModel',
+    'ModelEvaluator',
+    'AudioVisualizer',
+]

src/baseline_models.py

@@ -0,0 +1,319 @@
+"""
+Baseline machine learning models for respiratory disease detection.
+Includes Random Forest, SVM, and other classical ML algorithms.
+"""
+
+import numpy as np
+import pickle
+from pathlib import Path
+from typing import Dict, Tuple, Optional
+from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
+from sklearn.svm import SVC
+from sklearn.linear_model import LogisticRegression
+from sklearn.preprocessing import StandardScaler
+from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
+from sklearn.metrics import precision_recall_fscore_support, roc_auc_score, roc_curve
+import joblib
+
+
+class BaselineModel:
+    """Wrapper for baseline ML models."""
+    
+    def __init__(self, model_type: str = 'random_forest', **kwargs):
+        """
+        Initialize baseline model.
+        
+        Args:
+            model_type: Type of model ('random_forest', 'svm', 'logistic', 'gradient_boost')
+            **kwargs: Additional parameters for the model
+        """
+        self.model_type = model_type
+        self.scaler = StandardScaler()
+        self.model = self._create_model(model_type, **kwargs)
+        self.is_fitted = False
+    
+    def _create_model(self, model_type: str, **kwargs):
+        """Create the specified model."""
+        if model_type == 'random_forest':
+            return RandomForestClassifier(
+                n_estimators=kwargs.get('n_estimators', 200),
+                max_depth=kwargs.get('max_depth', 20),
+                min_samples_split=kwargs.get('min_samples_split', 5),
+                min_samples_leaf=kwargs.get('min_samples_leaf', 2),
+                random_state=kwargs.get('random_state', 42),
+                n_jobs=kwargs.get('n_jobs', -1),
+                verbose=kwargs.get('verbose', 1)
+            )
+        
+        elif model_type == 'svm':
+            return SVC(
+                kernel=kwargs.get('kernel', 'rbf'),
+                C=kwargs.get('C', 1.0),
+                gamma=kwargs.get('gamma', 'scale'),
+                probability=True,
+                random_state=kwargs.get('random_state', 42),
+                verbose=kwargs.get('verbose', True)
+            )
+        
+        elif model_type == 'logistic':
+            return LogisticRegression(
+                max_iter=kwargs.get('max_iter', 1000),
+                C=kwargs.get('C', 1.0),
+                random_state=kwargs.get('random_state', 42),
+                n_jobs=kwargs.get('n_jobs', -1),
+                verbose=kwargs.get('verbose', 1)
+            )
+        
+        elif model_type == 'gradient_boost':
+            return GradientBoostingClassifier(
+                n_estimators=kwargs.get('n_estimators', 200),
+                learning_rate=kwargs.get('learning_rate', 0.1),
+                max_depth=kwargs.get('max_depth', 5),
+                random_state=kwargs.get('random_state', 42),
+                verbose=kwargs.get('verbose', 1)
+            )
+        
+        else:
+            raise ValueError(f"Unknown model type: {model_type}")
+    
+    def train(self, X_train: np.ndarray, y_train: np.ndarray, 
+              X_val: Optional[np.ndarray] = None, y_val: Optional[np.ndarray] = None):
+        """
+        Train the model.
+        
+        Args:
+            X_train: Training features
+            y_train: Training labels
+            X_val: Validation features (optional)
+            y_val: Validation labels (optional)
+        """
+        print(f"Training {self.model_type} model...")
+        print(f"Training samples: {len(X_train)}")
+        
+        # Scale features
+        X_train_scaled = self.scaler.fit_transform(X_train)
+        
+        # Train model
+        self.model.fit(X_train_scaled, y_train)
+        self.is_fitted = True
+        
+        # Evaluate on training set
+        train_acc = self.model.score(X_train_scaled, y_train)
+        print(f"Training accuracy: {train_acc:.4f}")
+        
+        # Evaluate on validation set if provided
+        if X_val is not None and y_val is not None:
+            X_val_scaled = self.scaler.transform(X_val)
+            val_acc = self.model.score(X_val_scaled, y_val)
+            print(f"Validation accuracy: {val_acc:.4f}")
+    
+    def predict(self, X: np.ndarray) -> np.ndarray:
+        """Make predictions."""
+        if not self.is_fitted:
+            raise ValueError("Model must be trained before making predictions")
+        
+        X_scaled = self.scaler.transform(X)
+        return self.model.predict(X_scaled)
+    
+    def predict_proba(self, X: np.ndarray) -> np.ndarray:
+        """Get prediction probabilities."""
+        if not self.is_fitted:
+            raise ValueError("Model must be trained before making predictions")
+        
+        X_scaled = self.scaler.transform(X)
+        return self.model.predict_proba(X_scaled)
+    
+    def evaluate(self, X: np.ndarray, y: np.ndarray, 
+                 class_names: Optional[list] = None) -> Dict:
+        """
+        Evaluate model performance.
+        
+        Args:
+            X: Test features
+            y: Test labels
+            class_names: List of class names for reporting
+            
+        Returns:
+            Dictionary containing evaluation metrics
+        """
+        if not self.is_fitted:
+            raise ValueError("Model must be trained before evaluation")
+        
+        # Make predictions
+        y_pred = self.predict(X)
+        y_proba = self.predict_proba(X)
+        
+        # Calculate metrics
+        accuracy = accuracy_score(y, y_pred)
+        precision, recall, f1, support = precision_recall_fscore_support(
+            y, y_pred, average='weighted'
+        )
+        
+        # Confusion matrix
+        cm = confusion_matrix(y, y_pred)
+        
+        # Classification report
+        report = classification_report(
+            y, y_pred, 
+            target_names=class_names,
+            output_dict=True
+        )
+        
+        # ROC AUC (for binary or multi-class)
+        try:
+            if len(np.unique(y)) == 2:
+                roc_auc = roc_auc_score(y, y_proba[:, 1])
+            else:
+                roc_auc = roc_auc_score(y, y_proba, multi_class='ovr', average='weighted')
+        except Exception as e:
+            print(f"Could not compute ROC AUC: {e}")
+            roc_auc = None
+        
+        results = {
+            'accuracy': accuracy,
+            'precision': precision,
+            'recall': recall,
+            'f1_score': f1,
+            'confusion_matrix': cm,
+            'classification_report': report,
+            'roc_auc': roc_auc,
+            'predictions': y_pred,
+            'probabilities': y_proba
+        }
+        
+        print("\n" + "="*50)
+        print(f"{self.model_type.upper()} EVALUATION RESULTS")
+        print("="*50)
+        print(f"Accuracy:  {accuracy:.4f}")
+        print(f"Precision: {precision:.4f}")
+        print(f"Recall:    {recall:.4f}")
+        print(f"F1 Score:  {f1:.4f}")
+        if roc_auc is not None:
+            print(f"ROC AUC:   {roc_auc:.4f}")
+        print("\nConfusion Matrix:")
+        print(cm)
+        print("\nClassification Report:")
+        if class_names:
+            print(classification_report(y, y_pred, target_names=class_names))
+        else:
+            print(classification_report(y, y_pred))
+        print("="*50 + "\n")
+        
+        return results
+    
+    def get_feature_importance(self, feature_names: Optional[list] = None) -> np.ndarray:
+        """
+        Get feature importances (only for tree-based models).
+        
+        Args:
+            feature_names: Optional list of feature names
+            
+        Returns:
+            Array of feature importances
+        """
+        if not self.is_fitted:
+            raise ValueError("Model must be trained first")
+        
+        if hasattr(self.model, 'feature_importances_'):
+            importances = self.model.feature_importances_
+            
+            if feature_names:
+                importance_dict = dict(zip(feature_names, importances))
+                # Sort by importance
+                importance_dict = dict(sorted(
+                    importance_dict.items(), 
+                    key=lambda x: x[1], 
+                    reverse=True
+                ))
+                
+                print("\nTop 10 Feature Importances:")
+                for i, (name, imp) in enumerate(list(importance_dict.items())[:10]):
+                    print(f"{i+1}. {name}: {imp:.4f}")
+            
+            return importances
+        else:
+            print(f"{self.model_type} does not support feature importances")
+            return None
+    
+    def save(self, filepath: str):
+        """Save model to disk."""
+        if not self.is_fitted:
+            raise ValueError("Cannot save untrained model")
+        
+        model_data = {
+            'model': self.model,
+            'scaler': self.scaler,
+            'model_type': self.model_type,
+            'is_fitted': self.is_fitted
+        }
+        
+        joblib.dump(model_data, filepath)
+        print(f"Model saved to {filepath}")
+    
+    @classmethod
+    def load(cls, filepath: str):
+        """Load model from disk."""
+        model_data = joblib.load(filepath)
+        
+        instance = cls(model_type=model_data['model_type'])
+        instance.model = model_data['model']
+        instance.scaler = model_data['scaler']
+        instance.is_fitted = model_data['is_fitted']
+        
+        print(f"Model loaded from {filepath}")
+        return instance
+
+
+class ModelComparison:
+    """Compare multiple baseline models."""
+    
+    def __init__(self):
+        self.models = {}
+        self.results = {}
+    
+    def add_model(self, name: str, model: BaselineModel):
+        """Add a model to the comparison."""
+        self.models[name] = model
+    
+    def train_all(self, X_train: np.ndarray, y_train: np.ndarray,
+                  X_val: Optional[np.ndarray] = None, y_val: Optional[np.ndarray] = None):
+        """Train all models."""
+        for name, model in self.models.items():
+            print(f"\n{'='*60}")
+            print(f"Training {name}")
+            print('='*60)
+            model.train(X_train, y_train, X_val, y_val)
+    
+    def evaluate_all(self, X_test: np.ndarray, y_test: np.ndarray, 
+                     class_names: Optional[list] = None):
+        """Evaluate all models."""
+        for name, model in self.models.items():
+            print(f"\n{'='*60}")
+            print(f"Evaluating {name}")
+            print('='*60)
+            results = model.evaluate(X_test, y_test, class_names)
+            self.results[name] = results
+    
+    def print_summary(self):
+        """Print comparison summary."""
+        print("\n" + "="*80)
+        print("MODEL COMPARISON SUMMARY")
+        print("="*80)
+        print(f"{'Model':<25} {'Accuracy':<12} {'Precision':<12} {'Recall':<12} {'F1 Score':<12}")
+        print("-"*80)
+        
+        for name, results in self.results.items():
+            print(f"{name:<25} {results['accuracy']:<12.4f} {results['precision']:<12.4f} "
+                  f"{results['recall']:<12.4f} {results['f1_score']:<12.4f}")
+        
+        print("="*80 + "\n")
+        
+        # Find best model
+        best_model = max(self.results.items(), key=lambda x: x[1]['f1_score'])
+        print(f"Best model: {best_model[0]} (F1 Score: {best_model[1]['f1_score']:.4f})")
+
+
+if __name__ == "__main__":
+    # Example usage
+    print("Baseline models module loaded successfully")
+    print("Available models: random_forest, svm, logistic, gradient_boost")

src/dataset.py

@@ -0,0 +1,287 @@
+"""
+Dataset loading and management for respiratory disease detection.
+"""
+
+import numpy as np
+import pandas as pd
+from pathlib import Path
+from typing import Tuple, List, Dict, Optional
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import LabelEncoder
+import pickle
+from tqdm import tqdm
+
+from preprocessing import AudioPreprocessor, AudioAugmenter
+
+
+class AudioDataset:
+    """Manages audio dataset loading and feature extraction."""
+    
+    def __init__(self, data_dir: str, preprocessor: AudioPreprocessor):
+        """
+        Initialize dataset.
+        
+        Args:
+            data_dir: Directory containing audio files organized by class
+            preprocessor: AudioPreprocessor instance
+        """
+        self.data_dir = Path(data_dir)
+        self.preprocessor = preprocessor
+        self.augmenter = AudioAugmenter()
+        self.label_encoder = LabelEncoder()
+        
+        self.X = None
+        self.y = None
+        self.labels = None
+        self.file_paths = []
+    
+    def load_from_directory_structure(self, use_cache: bool = True):
+        """
+        Load dataset from directory structure where each subdirectory is a class.
+        Expected structure:
+            data_dir/
+                healthy/
+                    file1.wav
+                    file2.wav
+                covid/
+                    file1.wav
+                    file2.wav
+        """
+        cache_file = self.data_dir / 'dataset_cache.pkl'
+        
+        if use_cache and cache_file.exists():
+            print("Loading from cache...")
+            with open(cache_file, 'rb') as f:
+                cache_data = pickle.load(f)
+                self.X = cache_data['X']
+                self.y = cache_data['y']
+                self.labels = cache_data['labels']
+                self.file_paths = cache_data['file_paths']
+                self.label_encoder = cache_data['label_encoder']
+            print(f"Loaded {len(self.X)} samples from cache")
+            return
+        
+        # Get all class directories
+        class_dirs = [d for d in self.data_dir.iterdir() if d.is_dir()]
+        
+        if not class_dirs:
+            raise ValueError(f"No subdirectories found in {self.data_dir}")
+        
+        print(f"Found {len(class_dirs)} classes: {[d.name for d in class_dirs]}")
+        
+        X_list = []
+        y_list = []
+        
+        for class_dir in class_dirs:
+            class_name = class_dir.name
+            audio_files = list(class_dir.glob('*.wav')) + list(class_dir.glob('*.mp3'))
+            
+            print(f"Processing {len(audio_files)} files from class '{class_name}'...")
+            
+            for audio_file in tqdm(audio_files, desc=class_name):
+                try:
+                    # Load audio
+                    audio = self.preprocessor.load_audio(str(audio_file))
+                    
+                    # Extract MFCC features
+                    mfcc = self.preprocessor.extract_mfcc(audio)
+                    
+                    # Compute statistical features
+                    features = self.preprocessor.compute_statistics(mfcc)
+                    
+                    X_list.append(features)
+                    y_list.append(class_name)
+                    self.file_paths.append(str(audio_file))
+                    
+                except Exception as e:
+                    print(f"Error processing {audio_file}: {e}")
+        
+        # Convert to numpy arrays
+        self.X = np.array(X_list)
+        self.labels = np.array(y_list)
+        
+        # Encode labels
+        self.y = self.label_encoder.fit_transform(self.labels)
+        
+        print(f"\nDataset loaded: {len(self.X)} samples, {len(np.unique(self.y))} classes")
+        print(f"Feature shape: {self.X.shape}")
+        print(f"Class distribution: {dict(zip(*np.unique(self.labels, return_counts=True)))}")
+        
+        # Save cache
+        with open(cache_file, 'wb') as f:
+            pickle.dump({
+                'X': self.X,
+                'y': self.y,
+                'labels': self.labels,
+                'file_paths': self.file_paths,
+                'label_encoder': self.label_encoder
+            }, f)
+        print(f"Cache saved to {cache_file}")
+    
+    def load_from_csv(self, csv_path: str, audio_column: str = 'file_path', 
+                      label_column: str = 'label'):
+        """
+        Load dataset from CSV file with file paths and labels.
+        
+        Args:
+            csv_path: Path to CSV file
+            audio_column: Column name containing audio file paths
+            label_column: Column name containing labels
+        """
+        df = pd.read_csv(csv_path)
+        
+        print(f"Loading {len(df)} samples from CSV...")
+        
+        X_list = []
+        y_list = []
+        
+        for idx, row in tqdm(df.iterrows(), total=len(df)):
+            try:
+                audio_path = row[audio_column]
+                label = row[label_column]
+                
+                # Make path absolute if relative
+                if not Path(audio_path).is_absolute():
+                    audio_path = self.data_dir / audio_path
+                
+                # Load audio
+                audio = self.preprocessor.load_audio(str(audio_path))
+                
+                # Extract MFCC features
+                mfcc = self.preprocessor.extract_mfcc(audio)
+                
+                # Compute statistical features
+                features = self.preprocessor.compute_statistics(mfcc)
+                
+                X_list.append(features)
+                y_list.append(label)
+                self.file_paths.append(str(audio_path))
+                
+            except Exception as e:
+                print(f"Error processing row {idx}: {e}")
+        
+        # Convert to numpy arrays
+        self.X = np.array(X_list)
+        self.labels = np.array(y_list)
+        
+        # Encode labels
+        self.y = self.label_encoder.fit_transform(self.labels)
+        
+        print(f"\nDataset loaded: {len(self.X)} samples, {len(np.unique(self.y))} classes")
+        print(f"Feature shape: {self.X.shape}")
+    
+    def split_data(self, test_size: float = 0.15, val_size: float = 0.15, 
+                   random_state: int = 42) -> Dict[str, np.ndarray]:
+        """
+        Split dataset into train, validation, and test sets.
+        
+        Args:
+            test_size: Proportion of data for test set
+            val_size: Proportion of data for validation set
+            random_state: Random seed for reproducibility
+            
+        Returns:
+            Dictionary containing train, val, test splits
+        """
+        # First split: separate test set
+        X_temp, X_test, y_temp, y_test = train_test_split(
+            self.X, self.y, test_size=test_size, random_state=random_state, stratify=self.y
+        )
+        
+        # Second split: separate train and validation
+        val_size_adjusted = val_size / (1 - test_size)
+        X_train, X_val, y_train, y_val = train_test_split(
+            X_temp, y_temp, test_size=val_size_adjusted, random_state=random_state, stratify=y_temp
+        )
+        
+        print(f"Data split: Train={len(X_train)}, Val={len(X_val)}, Test={len(X_test)}")
+        
+        return {
+            'X_train': X_train,
+            'X_val': X_val,
+            'X_test': X_test,
+            'y_train': y_train,
+            'y_val': y_val,
+            'y_test': y_test
+        }
+    
+    def get_deep_learning_data(self) -> Tuple[np.ndarray, np.ndarray]:
+        """
+        Load data formatted for deep learning (2D features).
+        Returns MFCC spectrograms instead of statistical features.
+        """
+        X_deep = []
+        y_deep = []
+        
+        print("Preparing deep learning data...")
+        
+        for file_path, label in tqdm(zip(self.file_paths, self.labels), total=len(self.file_paths)):
+            try:
+                audio = self.preprocessor.load_audio(file_path)
+                mfcc = self.preprocessor.extract_mfcc(audio)
+                
+                X_deep.append(mfcc)
+                y_deep.append(label)
+                
+            except Exception as e:
+                print(f"Error processing {file_path}: {e}")
+        
+        X_deep = np.array(X_deep)
+        y_deep = self.label_encoder.transform(np.array(y_deep))
+        
+        # Add channel dimension for CNN: (samples, height, width, channels)
+        X_deep = np.expand_dims(X_deep, axis=-1)
+        
+        print(f"Deep learning data shape: {X_deep.shape}")
+        return X_deep, y_deep
+    
+    def get_class_names(self) -> List[str]:
+        """Get list of class names."""
+        return list(self.label_encoder.classes_)
+    
+    def save_splits(self, splits: Dict[str, np.ndarray], output_dir: str):
+        """Save data splits to disk."""
+        output_path = Path(output_dir)
+        output_path.mkdir(parents=True, exist_ok=True)
+        
+        for split_name, data in splits.items():
+            np.save(output_path / f"{split_name}.npy", data)
+        
+        # Save label encoder
+        with open(output_path / 'label_encoder.pkl', 'wb') as f:
+            pickle.dump(self.label_encoder, f)
+        
+        print(f"Splits saved to {output_dir}")
+
+
+def create_sample_dataset_structure(base_dir: str):
+    """
+    Create a sample dataset directory structure for testing.
+    This helps users understand the expected format.
+    """
+    base_path = Path(base_dir)
+    
+    # Create class directories
+    classes = ['healthy', 'covid', 'asthma']
+    
+    for class_name in classes:
+        class_dir = base_path / class_name
+        class_dir.mkdir(parents=True, exist_ok=True)
+    
+    print(f"Sample dataset structure created at {base_dir}")
+    print("Please place your audio files in the respective class folders:")
+    for class_name in classes:
+        print(f"  - {base_dir}/{class_name}/")
+
+
+if __name__ == "__main__":
+    # Example usage
+    preprocessor = AudioPreprocessor(sample_rate=16000, duration=5.0)
+    
+    # Create sample structure
+    # create_sample_dataset_structure('/Users/tan135/Desktop/Sid AI/data/raw')
+    
+    # Load dataset
+    # dataset = AudioDataset('/Users/tan135/Desktop/Sid AI/data/raw', preprocessor)
+    # dataset.load_from_directory_structure()
+    # splits = dataset.split_data()

src/deep_learning_models.py

@@ -0,0 +1,392 @@
+"""
+Deep learning models for respiratory disease detection.
+Includes CNN and LSTM architectures.
+"""
+
+import numpy as np
+import tensorflow as tf
+from tensorflow import keras
+from tensorflow.keras import layers, models, callbacks
+from tensorflow.keras.utils import to_categorical
+from typing import Tuple, Optional, Dict
+import pickle
+from pathlib import Path
+
+
+class CNNModel:
+    """Convolutional Neural Network for audio classification."""
+    
+    def __init__(self, input_shape: Tuple, num_classes: int, model_name: str = "cnn_model"):
+        """
+        Initialize CNN model.
+        
+        Args:
+            input_shape: Shape of input (height, width, channels)
+            num_classes: Number of output classes
+            model_name: Name of the model
+        """
+        self.input_shape = input_shape
+        self.num_classes = num_classes
+        self.model_name = model_name
+        self.model = None
+        self.history = None
+    
+    def build_model(self, dropout_rate: float = 0.3):
+        """
+        Build CNN architecture.
+        
+        Args:
+            dropout_rate: Dropout rate for regularization
+        """
+        model = models.Sequential(name=self.model_name)
+        
+        # First convolutional block
+        model.add(layers.Conv2D(32, (3, 3), activation='relu', 
+                               padding='same', input_shape=self.input_shape))
+        model.add(layers.BatchNormalization())
+        model.add(layers.MaxPooling2D((2, 2)))
+        model.add(layers.Dropout(dropout_rate))
+        
+        # Second convolutional block
+        model.add(layers.Conv2D(64, (3, 3), activation='relu', padding='same'))
+        model.add(layers.BatchNormalization())
+        model.add(layers.MaxPooling2D((2, 2)))
+        model.add(layers.Dropout(dropout_rate))
+        
+        # Third convolutional block
+        model.add(layers.Conv2D(128, (3, 3), activation='relu', padding='same'))
+        model.add(layers.BatchNormalization())
+        model.add(layers.MaxPooling2D((2, 2)))
+        model.add(layers.Dropout(dropout_rate))
+        
+        # Fourth convolutional block
+        model.add(layers.Conv2D(256, (3, 3), activation='relu', padding='same'))
+        model.add(layers.BatchNormalization())
+        model.add(layers.GlobalAveragePooling2D())
+        
+        # Dense layers
+        model.add(layers.Dense(256, activation='relu'))
+        model.add(layers.Dropout(dropout_rate))
+        model.add(layers.Dense(128, activation='relu'))
+        model.add(layers.Dropout(dropout_rate))
+        
+        # Output layer
+        if self.num_classes == 2:
+            model.add(layers.Dense(1, activation='sigmoid'))
+        else:
+            model.add(layers.Dense(self.num_classes, activation='softmax'))
+        
+        self.model = model
+        print(f"\n{self.model_name} architecture:")
+        self.model.summary()
+        
+        return model
+    
+    def compile_model(self, learning_rate: float = 0.001):
+        """Compile the model."""
+        if self.model is None:
+            raise ValueError("Model must be built before compilation")
+        
+        optimizer = keras.optimizers.Adam(learning_rate=learning_rate)
+        
+        if self.num_classes == 2:
+            loss = 'binary_crossentropy'
+            metrics = ['accuracy', keras.metrics.AUC(name='auc')]
+        else:
+            loss = 'sparse_categorical_crossentropy'
+            metrics = ['accuracy']
+        
+        self.model.compile(
+            optimizer=optimizer,
+            loss=loss,
+            metrics=metrics
+        )
+        
+        print(f"Model compiled with optimizer={optimizer.__class__.__name__}, loss={loss}")
+    
+    def train(self, X_train: np.ndarray, y_train: np.ndarray,
+              X_val: np.ndarray, y_val: np.ndarray,
+              epochs: int = 50, batch_size: int = 32,
+              model_dir: str = 'models'):
+        """
+        Train the CNN model.
+        
+        Args:
+            X_train: Training features
+            y_train: Training labels
+            X_val: Validation features
+            y_val: Validation labels
+            epochs: Number of training epochs
+            batch_size: Batch size
+            model_dir: Directory to save model checkpoints
+        """
+        if self.model is None:
+            raise ValueError("Model must be built and compiled before training")
+        
+        # Create model directory
+        model_path = Path(model_dir)
+        model_path.mkdir(parents=True, exist_ok=True)
+        
+        # Define callbacks
+        checkpoint_path = model_path / f"{self.model_name}_best.keras"
+        callbacks_list = [
+            callbacks.ModelCheckpoint(
+                str(checkpoint_path),
+                monitor='val_loss',
+                save_best_only=True,
+                verbose=1
+            ),
+            callbacks.EarlyStopping(
+                monitor='val_loss',
+                patience=10,
+                restore_best_weights=True,
+                verbose=1
+            ),
+            callbacks.ReduceLROnPlateau(
+                monitor='val_loss',
+                factor=0.5,
+                patience=5,
+                min_lr=1e-7,
+                verbose=1
+            )
+        ]
+        
+        print(f"\nTraining {self.model_name}...")
+        print(f"Training samples: {len(X_train)}, Validation samples: {len(X_val)}")
+        print(f"Epochs: {epochs}, Batch size: {batch_size}")
+        
+        # Train model
+        self.history = self.model.fit(
+            X_train, y_train,
+            validation_data=(X_val, y_val),
+            epochs=epochs,
+            batch_size=batch_size,
+            callbacks=callbacks_list,
+            verbose=1
+        )
+        
+        print(f"\nTraining complete. Best model saved to {checkpoint_path}")
+        
+        return self.history
+    
+    def evaluate(self, X_test: np.ndarray, y_test: np.ndarray) -> Dict:
+        """Evaluate model on test set."""
+        if self.model is None:
+            raise ValueError("Model must be trained before evaluation")
+        
+        print(f"\nEvaluating {self.model_name}...")
+        results = self.model.evaluate(X_test, y_test, verbose=1)
+        
+        # Get predictions
+        y_pred_proba = self.model.predict(X_test)
+        
+        if self.num_classes == 2:
+            y_pred = (y_pred_proba > 0.5).astype(int).flatten()
+        else:
+            y_pred = np.argmax(y_pred_proba, axis=1)
+        
+        evaluation_results = {
+            'loss': results[0],
+            'accuracy': results[1],
+            'predictions': y_pred,
+            'probabilities': y_pred_proba
+        }
+        
+        if len(results) > 2:
+            evaluation_results['auc'] = results[2]
+        
+        print(f"Test Loss: {results[0]:.4f}")
+        print(f"Test Accuracy: {results[1]:.4f}")
+        
+        return evaluation_results
+    
+    def save(self, filepath: str):
+        """Save model to disk."""
+        self.model.save(filepath)
+        print(f"Model saved to {filepath}")
+    
+    @classmethod
+    def load(cls, filepath: str):
+        """Load model from disk."""
+        model = keras.models.load_model(filepath)
+        print(f"Model loaded from {filepath}")
+        return model
+
+
+class LSTMModel:
+    """LSTM model for sequential audio classification."""
+    
+    def __init__(self, input_shape: Tuple, num_classes: int, model_name: str = "lstm_model"):
+        """
+        Initialize LSTM model.
+        
+        Args:
+            input_shape: Shape of input (time_steps, features)
+            num_classes: Number of output classes
+            model_name: Name of the model
+        """
+        self.input_shape = input_shape
+        self.num_classes = num_classes
+        self.model_name = model_name
+        self.model = None
+        self.history = None
+    
+    def build_model(self, dropout_rate: float = 0.3):
+        """
+        Build LSTM architecture.
+        
+        Args:
+            dropout_rate: Dropout rate for regularization
+        """
+        model = models.Sequential(name=self.model_name)
+        
+        # LSTM layers
+        model.add(layers.LSTM(128, return_sequences=True, input_shape=self.input_shape))
+        model.add(layers.Dropout(dropout_rate))
+        model.add(layers.BatchNormalization())
+        
+        model.add(layers.LSTM(64, return_sequences=True))
+        model.add(layers.Dropout(dropout_rate))
+        model.add(layers.BatchNormalization())
+        
+        model.add(layers.LSTM(32))
+        model.add(layers.Dropout(dropout_rate))
+        
+        # Dense layers
+        model.add(layers.Dense(64, activation='relu'))
+        model.add(layers.Dropout(dropout_rate))
+        
+        # Output layer
+        if self.num_classes == 2:
+            model.add(layers.Dense(1, activation='sigmoid'))
+        else:
+            model.add(layers.Dense(self.num_classes, activation='softmax'))
+        
+        self.model = model
+        print(f"\n{self.model_name} architecture:")
+        self.model.summary()
+        
+        return model
+    
+    def compile_model(self, learning_rate: float = 0.001):
+        """Compile the model."""
+        if self.model is None:
+            raise ValueError("Model must be built before compilation")
+        
+        optimizer = keras.optimizers.Adam(learning_rate=learning_rate)
+        
+        if self.num_classes == 2:
+            loss = 'binary_crossentropy'
+            metrics = ['accuracy', keras.metrics.AUC(name='auc')]
+        else:
+            loss = 'sparse_categorical_crossentropy'
+            metrics = ['accuracy']
+        
+        self.model.compile(
+            optimizer=optimizer,
+            loss=loss,
+            metrics=metrics
+        )
+        
+        print(f"Model compiled with optimizer={optimizer.__class__.__name__}, loss={loss}")
+    
+    def train(self, X_train: np.ndarray, y_train: np.ndarray,
+              X_val: np.ndarray, y_val: np.ndarray,
+              epochs: int = 50, batch_size: int = 32,
+              model_dir: str = 'models'):
+        """Train the LSTM model."""
+        if self.model is None:
+            raise ValueError("Model must be built and compiled before training")
+        
+        # Create model directory
+        model_path = Path(model_dir)
+        model_path.mkdir(parents=True, exist_ok=True)
+        
+        # Define callbacks
+        checkpoint_path = model_path / f"{self.model_name}_best.keras"
+        callbacks_list = [
+            callbacks.ModelCheckpoint(
+                str(checkpoint_path),
+                monitor='val_loss',
+                save_best_only=True,
+                verbose=1
+            ),
+            callbacks.EarlyStopping(
+                monitor='val_loss',
+                patience=10,
+                restore_best_weights=True,
+                verbose=1
+            ),
+            callbacks.ReduceLROnPlateau(
+                monitor='val_loss',
+                factor=0.5,
+                patience=5,
+                min_lr=1e-7,
+                verbose=1
+            )
+        ]
+        
+        print(f"\nTraining {self.model_name}...")
+        print(f"Training samples: {len(X_train)}, Validation samples: {len(X_val)}")
+        
+        # Train model
+        self.history = self.model.fit(
+            X_train, y_train,
+            validation_data=(X_val, y_val),
+            epochs=epochs,
+            batch_size=batch_size,
+            callbacks=callbacks_list,
+            verbose=1
+        )
+        
+        print(f"\nTraining complete. Best model saved to {checkpoint_path}")
+        
+        return self.history
+    
+    def evaluate(self, X_test: np.ndarray, y_test: np.ndarray) -> Dict:
+        """Evaluate model on test set."""
+        if self.model is None:
+            raise ValueError("Model must be trained before evaluation")
+        
+        print(f"\nEvaluating {self.model_name}...")
+        results = self.model.evaluate(X_test, y_test, verbose=1)
+        
+        # Get predictions
+        y_pred_proba = self.model.predict(X_test)
+        
+        if self.num_classes == 2:
+            y_pred = (y_pred_proba > 0.5).astype(int).flatten()
+        else:
+            y_pred = np.argmax(y_pred_proba, axis=1)
+        
+        evaluation_results = {
+            'loss': results[0],
+            'accuracy': results[1],
+            'predictions': y_pred,
+            'probabilities': y_pred_proba
+        }
+        
+        if len(results) > 2:
+            evaluation_results['auc'] = results[2]
+        
+        print(f"Test Loss: {results[0]:.4f}")
+        print(f"Test Accuracy: {results[1]:.4f}")
+        
+        return evaluation_results
+    
+    def save(self, filepath: str):
+        """Save model to disk."""
+        self.model.save(filepath)
+        print(f"Model saved to {filepath}")
+    
+    @classmethod
+    def load(cls, filepath: str):
+        """Load model from disk."""
+        model = keras.models.load_model(filepath)
+        print(f"Model loaded from {filepath}")
+        return model
+
+
+if __name__ == "__main__":
+    print("Deep learning models module loaded successfully")
+    print("Available models: CNNModel, LSTMModel")

src/evaluation.py

@@ -0,0 +1,345 @@
+"""
+Evaluation and visualization tools for model performance analysis.
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+from sklearn.metrics import (
+    confusion_matrix, classification_report, roc_curve, auc,
+    precision_recall_curve, roc_auc_score
+)
+from sklearn.preprocessing import label_binarize
+from pathlib import Path
+from typing import List, Optional, Dict
+import json
+
+
+class ModelEvaluator:
+    """Comprehensive model evaluation and visualization."""
+    
+    def __init__(self, class_names: List[str], output_dir: str = 'results'):
+        """
+        Initialize evaluator.
+        
+        Args:
+            class_names: List of class names
+            output_dir: Directory to save visualizations
+        """
+        self.class_names = class_names
+        self.output_dir = Path(output_dir)
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+        
+        # Set style
+        sns.set_style("whitegrid")
+        plt.rcParams['figure.figsize'] = (10, 8)
+    
+    def plot_confusion_matrix(self, y_true: np.ndarray, y_pred: np.ndarray,
+                             title: str = 'Confusion Matrix', save_name: str = 'confusion_matrix.png'):
+        """
+        Plot confusion matrix.
+        
+        Args:
+            y_true: True labels
+            y_pred: Predicted labels
+            title: Plot title
+            save_name: Filename to save the plot
+        """
+        cm = confusion_matrix(y_true, y_pred)
+        
+        plt.figure(figsize=(10, 8))
+        sns.heatmap(cm, annot=True, fmt='d', cmap='Blues',
+                   xticklabels=self.class_names,
+                   yticklabels=self.class_names,
+                   cbar_kws={'label': 'Count'})
+        plt.title(title, fontsize=16, fontweight='bold')
+        plt.ylabel('True Label', fontsize=12)
+        plt.xlabel('Predicted Label', fontsize=12)
+        plt.tight_layout()
+        
+        save_path = self.output_dir / save_name
+        plt.savefig(save_path, dpi=300, bbox_inches='tight')
+        print(f"Confusion matrix saved to {save_path}")
+        plt.close()
+        
+        return cm
+    
+    def plot_roc_curve(self, y_true: np.ndarray, y_proba: np.ndarray,
+                      title: str = 'ROC Curve', save_name: str = 'roc_curve.png'):
+        """
+        Plot ROC curve (handles binary and multi-class).
+        
+        Args:
+            y_true: True labels
+            y_proba: Prediction probabilities
+            title: Plot title
+            save_name: Filename to save the plot
+        """
+        n_classes = len(self.class_names)
+        
+        plt.figure(figsize=(10, 8))
+        
+        if n_classes == 2:
+            # Binary classification
+            # Handle both (n,1) and (n,2) probability shapes
+            if y_proba.shape[1] == 1:
+                fpr, tpr, _ = roc_curve(y_true, y_proba[:, 0])
+            else:
+                fpr, tpr, _ = roc_curve(y_true, y_proba[:, 1])
+            roc_auc = auc(fpr, tpr)
+            
+            plt.plot(fpr, tpr, color='darkorange', lw=2,
+                    label=f'ROC curve (AUC = {roc_auc:.3f})')
+        else:
+            # Multi-class classification
+            y_true_bin = label_binarize(y_true, classes=range(n_classes))
+            
+            for i in range(n_classes):
+                fpr, tpr, _ = roc_curve(y_true_bin[:, i], y_proba[:, i])
+                roc_auc = auc(fpr, tpr)
+                plt.plot(fpr, tpr, lw=2,
+                        label=f'{self.class_names[i]} (AUC = {roc_auc:.3f})')
+        
+        plt.plot([0, 1], [0, 1], 'k--', lw=2, label='Random (AUC = 0.5)')
+        plt.xlim([0.0, 1.0])
+        plt.ylim([0.0, 1.05])
+        plt.xlabel('False Positive Rate', fontsize=12)
+        plt.ylabel('True Positive Rate', fontsize=12)
+        plt.title(title, fontsize=16, fontweight='bold')
+        plt.legend(loc="lower right", fontsize=10)
+        plt.grid(True, alpha=0.3)
+        plt.tight_layout()
+        
+        save_path = self.output_dir / save_name
+        plt.savefig(save_path, dpi=300, bbox_inches='tight')
+        print(f"ROC curve saved to {save_path}")
+        plt.close()
+    
+    def plot_precision_recall_curve(self, y_true: np.ndarray, y_proba: np.ndarray,
+                                    title: str = 'Precision-Recall Curve',
+                                    save_name: str = 'precision_recall_curve.png'):
+        """Plot precision-recall curve."""
+        n_classes = len(self.class_names)
+        
+        plt.figure(figsize=(10, 8))
+        
+        if n_classes == 2:
+            precision, recall, _ = precision_recall_curve(y_true, y_proba[:, 1])
+            plt.plot(recall, precision, color='darkorange', lw=2)
+        else:
+            y_true_bin = label_binarize(y_true, classes=range(n_classes))
+            
+            for i in range(n_classes):
+                precision, recall, _ = precision_recall_curve(y_true_bin[:, i], y_proba[:, i])
+                plt.plot(recall, precision, lw=2, label=self.class_names[i])
+        
+        plt.xlabel('Recall', fontsize=12)
+        plt.ylabel('Precision', fontsize=12)
+        plt.title(title, fontsize=16, fontweight='bold')
+        plt.legend(loc="best", fontsize=10)
+        plt.grid(True, alpha=0.3)
+        plt.tight_layout()
+        
+        save_path = self.output_dir / save_name
+        plt.savefig(save_path, dpi=300, bbox_inches='tight')
+        print(f"Precision-recall curve saved to {save_path}")
+        plt.close()
+    
+    def plot_training_history(self, history, title: str = 'Training History',
+                             save_name: str = 'training_history.png'):
+        """
+        Plot training history for deep learning models.
+        
+        Args:
+            history: Keras history object
+            title: Plot title
+            save_name: Filename to save the plot
+        """
+        fig, axes = plt.subplots(1, 2, figsize=(15, 5))
+        
+        # Plot accuracy
+        axes[0].plot(history.history['accuracy'], label='Train Accuracy', linewidth=2)
+        axes[0].plot(history.history['val_accuracy'], label='Val Accuracy', linewidth=2)
+        axes[0].set_xlabel('Epoch', fontsize=12)
+        axes[0].set_ylabel('Accuracy', fontsize=12)
+        axes[0].set_title('Model Accuracy', fontsize=14, fontweight='bold')
+        axes[0].legend(loc='best', fontsize=10)
+        axes[0].grid(True, alpha=0.3)
+        
+        # Plot loss
+        axes[1].plot(history.history['loss'], label='Train Loss', linewidth=2)
+        axes[1].plot(history.history['val_loss'], label='Val Loss', linewidth=2)
+        axes[1].set_xlabel('Epoch', fontsize=12)
+        axes[1].set_ylabel('Loss', fontsize=12)
+        axes[1].set_title('Model Loss', fontsize=14, fontweight='bold')
+        axes[1].legend(loc='best', fontsize=10)
+        axes[1].grid(True, alpha=0.3)
+        
+        plt.suptitle(title, fontsize=16, fontweight='bold', y=1.02)
+        plt.tight_layout()
+        
+        save_path = self.output_dir / save_name
+        plt.savefig(save_path, dpi=300, bbox_inches='tight')
+        print(f"Training history saved to {save_path}")
+        plt.close()
+    
+    def plot_feature_importance(self, importances: np.ndarray, feature_names: List[str] = None,
+                               top_n: int = 20, title: str = 'Feature Importance',
+                               save_name: str = 'feature_importance.png'):
+        """Plot feature importance for tree-based models."""
+        if feature_names is None:
+            feature_names = [f'Feature {i}' for i in range(len(importances))]
+        
+        # Sort features by importance
+        indices = np.argsort(importances)[-top_n:]
+        
+        plt.figure(figsize=(10, max(8, top_n * 0.3)))
+        plt.barh(range(len(indices)), importances[indices], color='steelblue')
+        plt.yticks(range(len(indices)), [feature_names[i] for i in indices])
+        plt.xlabel('Importance', fontsize=12)
+        plt.title(title, fontsize=16, fontweight='bold')
+        plt.tight_layout()
+        
+        save_path = self.output_dir / save_name
+        plt.savefig(save_path, dpi=300, bbox_inches='tight')
+        print(f"Feature importance saved to {save_path}")
+        plt.close()
+    
+    def generate_classification_report(self, y_true: np.ndarray, y_pred: np.ndarray,
+                                      save_name: str = 'classification_report.txt'):
+        """Generate and save classification report."""
+        report = classification_report(y_true, y_pred, target_names=self.class_names)
+        
+        save_path = self.output_dir / save_name
+        with open(save_path, 'w') as f:
+            f.write(report)
+        
+        print(f"\nClassification Report:\n{report}")
+        print(f"Report saved to {save_path}")
+        
+        return report
+    
+    def save_metrics(self, metrics: Dict, save_name: str = 'metrics.json'):
+        """Save metrics to JSON file."""
+        # Convert numpy types to Python types for JSON serialization
+        def convert_to_serializable(obj):
+            if isinstance(obj, np.ndarray):
+                return obj.tolist()
+            elif isinstance(obj, (np.int64, np.int32)):
+                return int(obj)
+            elif isinstance(obj, (np.float64, np.float32)):
+                return float(obj)
+            elif isinstance(obj, dict):
+                return {k: convert_to_serializable(v) for k, v in obj.items()}
+            elif isinstance(obj, list):
+                return [convert_to_serializable(item) for item in obj]
+            return obj
+        
+        serializable_metrics = convert_to_serializable(metrics)
+        
+        save_path = self.output_dir / save_name
+        with open(save_path, 'w') as f:
+            json.dump(serializable_metrics, f, indent=4)
+        
+        print(f"Metrics saved to {save_path}")
+    
+    def create_comparison_plot(self, results_dict: Dict[str, Dict],
+                              metric: str = 'accuracy',
+                              title: str = 'Model Comparison',
+                              save_name: str = 'model_comparison.png'):
+        """
+        Create comparison plot for multiple models.
+        
+        Args:
+            results_dict: Dictionary of model results {model_name: results_dict}
+            metric: Metric to compare
+            title: Plot title
+            save_name: Filename to save the plot
+        """
+        models = list(results_dict.keys())
+        values = [results_dict[model][metric] for model in models]
+        
+        plt.figure(figsize=(12, 6))
+        bars = plt.bar(models, values, color='steelblue', alpha=0.8, edgecolor='black')
+        
+        # Add value labels on top of bars
+        for bar in bars:
+            height = bar.get_height()
+            plt.text(bar.get_x() + bar.get_width()/2., height,
+                    f'{height:.4f}',
+                    ha='center', va='bottom', fontsize=10, fontweight='bold')
+        
+        plt.ylabel(metric.capitalize(), fontsize=12)
+        plt.title(title, fontsize=16, fontweight='bold')
+        plt.xticks(rotation=45, ha='right')
+        plt.ylim([0, 1.0])
+        plt.grid(True, alpha=0.3, axis='y')
+        plt.tight_layout()
+        
+        save_path = self.output_dir / save_name
+        plt.savefig(save_path, dpi=300, bbox_inches='tight')
+        print(f"Comparison plot saved to {save_path}")
+        plt.close()
+
+
+class AudioVisualizer:
+    """Visualize audio features and spectrograms."""
+    
+    @staticmethod
+    def plot_waveform(audio: np.ndarray, sr: int = 16000, 
+                     title: str = 'Audio Waveform', save_path: Optional[str] = None):
+        """Plot audio waveform."""
+        plt.figure(figsize=(12, 4))
+        time = np.arange(0, len(audio)) / sr
+        plt.plot(time, audio, linewidth=0.5)
+        plt.xlabel('Time (s)', fontsize=12)
+        plt.ylabel('Amplitude', fontsize=12)
+        plt.title(title, fontsize=14, fontweight='bold')
+        plt.grid(True, alpha=0.3)
+        plt.tight_layout()
+        
+        if save_path:
+            plt.savefig(save_path, dpi=300, bbox_inches='tight')
+            plt.close()
+        else:
+            plt.show()
+    
+    @staticmethod
+    def plot_spectrogram(spectrogram: np.ndarray, sr: int = 16000,
+                        title: str = 'Spectrogram', save_path: Optional[str] = None):
+        """Plot spectrogram."""
+        plt.figure(figsize=(12, 6))
+        plt.imshow(spectrogram, aspect='auto', origin='lower', cmap='viridis')
+        plt.colorbar(format='%+2.0f dB', label='Power (dB)')
+        plt.xlabel('Time', fontsize=12)
+        plt.ylabel('Frequency', fontsize=12)
+        plt.title(title, fontsize=14, fontweight='bold')
+        plt.tight_layout()
+        
+        if save_path:
+            plt.savefig(save_path, dpi=300, bbox_inches='tight')
+            plt.close()
+        else:
+            plt.show()
+    
+    @staticmethod
+    def plot_mfcc(mfcc: np.ndarray, title: str = 'MFCC Features',
+                 save_path: Optional[str] = None):
+        """Plot MFCC features."""
+        plt.figure(figsize=(12, 6))
+        plt.imshow(mfcc, aspect='auto', origin='lower', cmap='coolwarm')
+        plt.colorbar(label='MFCC Coefficient Value')
+        plt.xlabel('Time Frame', fontsize=12)
+        plt.ylabel('MFCC Coefficient', fontsize=12)
+        plt.title(title, fontsize=14, fontweight='bold')
+        plt.tight_layout()
+        
+        if save_path:
+            plt.savefig(save_path, dpi=300, bbox_inches='tight')
+            plt.close()
+        else:
+            plt.show()
+
+
+if __name__ == "__main__":
+    print("Evaluation and visualization module loaded successfully")

src/preprocessing.py

@@ -0,0 +1,281 @@
+"""
+Audio preprocessing and feature extraction module for respiratory disease detection.
+"""
+
+import librosa
+import numpy as np
+import soundfile as sf
+from pathlib import Path
+from typing import Tuple, Dict, Optional
+import warnings
+warnings.filterwarnings('ignore')
+
+
+class AudioPreprocessor:
+    """Handles audio loading, normalization, and feature extraction."""
+    
+    def __init__(self, sample_rate: int = 16000, duration: float = 5.0):
+        """
+        Initialize the audio preprocessor.
+        
+        Args:
+            sample_rate: Target sample rate for all audio files
+            duration: Target duration in seconds (will pad/trim)
+        """
+        self.sample_rate = sample_rate
+        self.duration = duration
+        self.target_length = int(sample_rate * duration)
+    
+    def load_audio(self, file_path: str) -> np.ndarray:
+        """
+        Load and normalize audio file.
+        
+        Args:
+            file_path: Path to audio file
+            
+        Returns:
+            Normalized audio array
+        """
+        try:
+            # Load audio file
+            audio, sr = librosa.load(file_path, sr=self.sample_rate, mono=True)
+            
+            # Normalize audio to fixed length
+            audio = self._normalize_length(audio)
+            
+            # Normalize amplitude
+            audio = librosa.util.normalize(audio)
+            
+            return audio
+        except Exception as e:
+            print(f"Error loading {file_path}: {e}")
+            return np.zeros(self.target_length)
+    
+    def _normalize_length(self, audio: np.ndarray) -> np.ndarray:
+        """Pad or trim audio to target length."""
+        if len(audio) < self.target_length:
+            # Pad with zeros
+            audio = np.pad(audio, (0, self.target_length - len(audio)))
+        else:
+            # Trim to target length
+            audio = audio[:self.target_length]
+        return audio
+    
+    def extract_mfcc(self, audio: np.ndarray, n_mfcc: int = 40) -> np.ndarray:
+        """
+        Extract MFCC features from audio.
+        
+        Args:
+            audio: Audio signal
+            n_mfcc: Number of MFCCs to extract
+            
+        Returns:
+            MFCC features (n_mfcc, time_steps)
+        """
+        mfcc = librosa.feature.mfcc(
+            y=audio, 
+            sr=self.sample_rate, 
+            n_mfcc=n_mfcc,
+            n_fft=2048,
+            hop_length=512
+        )
+        return mfcc
+    
+    def extract_mel_spectrogram(self, audio: np.ndarray, n_mels: int = 128) -> np.ndarray:
+        """
+        Extract mel spectrogram from audio.
+        
+        Args:
+            audio: Audio signal
+            n_mels: Number of mel bands
+            
+        Returns:
+            Mel spectrogram
+        """
+        mel_spec = librosa.feature.melspectrogram(
+            y=audio,
+            sr=self.sample_rate,
+            n_mels=n_mels,
+            n_fft=2048,
+            hop_length=512
+        )
+        # Convert to log scale
+        mel_spec_db = librosa.power_to_db(mel_spec, ref=np.max)
+        return mel_spec_db
+    
+    def extract_spectral_features(self, audio: np.ndarray) -> Dict[str, np.ndarray]:
+        """
+        Extract various spectral features.
+        
+        Args:
+            audio: Audio signal
+            
+        Returns:
+            Dictionary of spectral features
+        """
+        features = {}
+        
+        # Spectral centroid
+        features['spectral_centroid'] = librosa.feature.spectral_centroid(
+            y=audio, sr=self.sample_rate
+        )[0]
+        
+        # Spectral rolloff
+        features['spectral_rolloff'] = librosa.feature.spectral_rolloff(
+            y=audio, sr=self.sample_rate
+        )[0]
+        
+        # Zero crossing rate
+        features['zero_crossing_rate'] = librosa.feature.zero_crossing_rate(audio)[0]
+        
+        # Chroma features
+        features['chroma'] = librosa.feature.chroma_stft(
+            y=audio, sr=self.sample_rate
+        )
+        
+        # Spectral contrast
+        features['spectral_contrast'] = librosa.feature.spectral_contrast(
+            y=audio, sr=self.sample_rate
+        )
+        
+        return features
+    
+    def extract_all_features(self, audio: np.ndarray) -> Dict[str, np.ndarray]:
+        """
+        Extract all audio features.
+        
+        Args:
+            audio: Audio signal
+            
+        Returns:
+            Dictionary containing all features
+        """
+        features = {
+            'mfcc': self.extract_mfcc(audio),
+            'mel_spectrogram': self.extract_mel_spectrogram(audio),
+        }
+        features.update(self.extract_spectral_features(audio))
+        return features
+    
+    def compute_statistics(self, feature_array: np.ndarray) -> np.ndarray:
+        """
+        Compute statistical features (mean, std, min, max) from feature array.
+        
+        Args:
+            feature_array: 2D feature array (features, time)
+            
+        Returns:
+            Flattened statistical features
+        """
+        stats = []
+        stats.extend(np.mean(feature_array, axis=1))
+        stats.extend(np.std(feature_array, axis=1))
+        stats.extend(np.min(feature_array, axis=1))
+        stats.extend(np.max(feature_array, axis=1))
+        return np.array(stats)
+
+
+class AudioAugmenter:
+    """Augments audio data for better model generalization."""
+    
+    @staticmethod
+    def add_noise(audio: np.ndarray, noise_level: float = 0.005) -> np.ndarray:
+        """Add random noise to audio."""
+        noise = np.random.randn(len(audio))
+        return audio + noise_level * noise
+    
+    @staticmethod
+    def time_stretch(audio: np.ndarray, rate: float = 1.2) -> np.ndarray:
+        """Time stretch audio."""
+        return librosa.effects.time_stretch(audio, rate=rate)
+    
+    @staticmethod
+    def pitch_shift(audio: np.ndarray, sr: int, n_steps: int = 2) -> np.ndarray:
+        """Shift pitch of audio."""
+        return librosa.effects.pitch_shift(audio, sr=sr, n_steps=n_steps)
+    
+    @staticmethod
+    def random_gain(audio: np.ndarray, min_gain: float = 0.8, max_gain: float = 1.2) -> np.ndarray:
+        """Apply random gain to audio."""
+        gain = np.random.uniform(min_gain, max_gain)
+        return audio * gain
+    
+    def augment(self, audio: np.ndarray, sr: int, techniques: list = None) -> np.ndarray:
+        """
+        Apply random augmentation techniques.
+        
+        Args:
+            audio: Audio signal
+            sr: Sample rate
+            techniques: List of augmentation techniques to apply
+            
+        Returns:
+            Augmented audio
+        """
+        if techniques is None:
+            techniques = ['noise', 'gain']
+        
+        augmented = audio.copy()
+        
+        for technique in techniques:
+            if technique == 'noise' and np.random.rand() > 0.5:
+                augmented = self.add_noise(augmented)
+            elif technique == 'pitch' and np.random.rand() > 0.5:
+                n_steps = np.random.randint(-2, 3)
+                augmented = self.pitch_shift(augmented, sr, n_steps)
+            elif technique == 'stretch' and np.random.rand() > 0.5:
+                rate = np.random.uniform(0.9, 1.1)
+                augmented = self.time_stretch(augmented, rate)
+            elif technique == 'gain' and np.random.rand() > 0.5:
+                augmented = self.random_gain(augmented)
+        
+        return augmented
+
+
+def process_dataset(data_dir: str, output_dir: str, preprocessor: AudioPreprocessor):
+    """
+    Process all audio files in a dataset directory.
+    
+    Args:
+        data_dir: Directory containing raw audio files
+        output_dir: Directory to save processed features
+        preprocessor: AudioPreprocessor instance
+    """
+    data_path = Path(data_dir)
+    output_path = Path(output_dir)
+    output_path.mkdir(parents=True, exist_ok=True)
+    
+    audio_files = list(data_path.rglob('*.wav')) + list(data_path.rglob('*.mp3'))
+    
+    print(f"Found {len(audio_files)} audio files")
+    
+    for audio_file in audio_files:
+        try:
+            # Load and preprocess audio
+            audio = preprocessor.load_audio(str(audio_file))
+            
+            # Extract features
+            features = preprocessor.extract_all_features(audio)
+            
+            # Save features
+            relative_path = audio_file.relative_to(data_path)
+            output_file = output_path / relative_path.with_suffix('.npz')
+            output_file.parent.mkdir(parents=True, exist_ok=True)
+            
+            np.savez_compressed(output_file, **features)
+            
+        except Exception as e:
+            print(f"Error processing {audio_file}: {e}")
+    
+    print(f"Processing complete. Features saved to {output_dir}")
+
+
+if __name__ == "__main__":
+    # Example usage
+    preprocessor = AudioPreprocessor(sample_rate=16000, duration=5.0)
+    
+    # Process a single file (example)
+    # audio = preprocessor.load_audio("path/to/audio.wav")
+    # features = preprocessor.extract_all_features(audio)
+    # print("MFCC shape:", features['mfcc'].shape)
+    # print("Mel spectrogram shape:", features['mel_spectrogram'].shape)