Upload 72 files

.gitattributes

@@ -37,3 +37,8 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 data/Respiratory_Sound_Database/testsample/101_1b1_Pr_sc_Meditron.wav filter=lfs diff=lfs merge=lfs -text
 data/Respiratory_Sound_Database/testsample/102_1b1_Ar_sc_Meditron.wav filter=lfs diff=lfs merge=lfs -text
 data/Respiratory_Sound_Database/testsample/103_2b2_Ar_mc_LittC2SE.wav filter=lfs diff=lfs merge=lfs -text
+data/Respiratory_Sound_Database/testsample/115_1b1_Ar_sc_Meditron.wav filter=lfs diff=lfs merge=lfs -text
+data/Respiratory_Sound_Database/testsample/121_1b1_Tc_sc_Meditron.wav filter=lfs diff=lfs merge=lfs -text
+data/Respiratory_Sound_Database/testsample/149_1b1_Al_sc_Meditron.wav filter=lfs diff=lfs merge=lfs -text
+data/Respiratory_Sound_Database/testsample/191_2b2_Tc_mc_LittC2SE.wav filter=lfs diff=lfs merge=lfs -text
+data/Respiratory_Sound_Database/testsample/215_1b3_Tc_sc_Meditron.wav filter=lfs diff=lfs merge=lfs -text

Exploration/inference.py

@@ -7,8 +7,21 @@ import matplotlib.pyplot as plt
 import librosa
 import librosa.display
 import scipy.signal as signal
+import argparse
+
 
 class RespiratorySoundAnalysis:
+    """
+    A class to perform analysis and preprocessing of respiratory sound recordings.
+
+    Attributes:
+        diagnosis_file (str): Path to the CSV file containing patient diagnoses.
+        audio_path (str): Path to the directory containing audio files.
+        diagnosis_df (DataFrame): DataFrame to hold diagnosis data.
+        audio_files (list): List of audio file paths.
+        audio_df (DataFrame): DataFrame to hold audio file properties.
+        merged_df (DataFrame): DataFrame combining audio properties with diagnosis data.
+    """
     def __init__(self, diagnosis_file, audio_path):
         self.diagnosis_file = diagnosis_file
         self.audio_path = audio_path
@@ -188,11 +201,22 @@ class RespiratorySoundAnalysis:
         return y_normalized, target_sr
 
 # Entry point for standalone execution
+
+    #diagnosis_file = './data//Respiratory_Sound_Database//patient_diagnosis.csv'
+    #audio_path = './data/Respiratory_Sound_Database/testsample'
+
+
+
+# Entry point for standalone execution
+# python Exploration/inference.py --diagnosis_file './data//Respiratory_Sound_Database//patient_diagnosis.csv --audio_path ./data/Respiratory_Sound_Database/testsample
+
 if __name__ == "__main__":
-    diagnosis_file = '../data//Respiratory_Sound_Database//patient_diagnosis.csv'
-    audio_path = '../data/Respiratory_Sound_Database/testsample'
+    parser = argparse.ArgumentParser(description="Run analysis on respiratory sound data.")
+    parser.add_argument("--diagnosis_file", type=str, required=True, help="Path to the patient diagnosis CSV file.")
+    parser.add_argument("--audio_path", type=str, required=True, help="Path to the directory containing audio files.")
+    args = parser.parse_args()
 
-    analysis = RespiratorySoundAnalysis(diagnosis_file, audio_path)
+    analysis = RespiratorySoundAnalysis(args.diagnosis_file, args.audio_path)
 
     # Load and analyze data
     analysis.load_diagnosis_data()
@@ -201,9 +225,9 @@ if __name__ == "__main__":
     analysis.analyze_audio_properties()
     analysis.plot_audio_duration_distribution()
 
-    # Visualize sample audio
+    # Visualize a sample audio file
     if analysis.audio_files:
-        analysis.visualize_sample_audio(analysis.audio_files[0])
+        analysis.visualize_sample_audio(os.path.basename(analysis.audio_files[0]))
 
     # Merge data
-    analysis.merge_audio_and_diagnosis_data()
+    analysis.merge_audio_and_diagnosis_data()

LegacyTraining/train.py

@@ -0,0 +1,709 @@
+import os
+import logging
+import gc
+from joblib import Parallel, delayed
+import joblib
+import mlflow
+import mlflow.keras
+import numpy as np
+import pandas as pd
+import librosa
+import librosa.display
+import optuna
+from tqdm import tqdm
+import matplotlib.pyplot as plt
+from sklearn.metrics import roc_auc_score, roc_curve, confusion_matrix, classification_report
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import LabelEncoder
+from keras.models import Sequential
+from keras.utils import to_categorical, normalize
+from keras.layers import Conv2D, Dense, MaxPooling2D, Dropout, BatchNormalization, GlobalAveragePooling2D
+from keras.layers import Conv1D, MaxPooling1D,GlobalAveragePooling1D
+from tensorflow.keras.callbacks import ModelCheckpoint, EarlyStopping
+from tensorflow.keras.preprocessing.image import ImageDataGenerator
+from imblearn.over_sampling import SMOTE
+from scipy.signal import butter, sosfilt
+import argparse
+
+# Set up logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+data_logger = logging.getLogger("data_loading")
+processing_logger = logging.getLogger("data_processing")
+model_logger = logging.getLogger("model_training")
+
+
+def load_data(diagnosis_path='/kaggle/input/respiratory-sound-database/Respiratory_Sound_Database/Respiratory_Sound_Database/patient_diagnosis.csv',
+              demographic_path='/kaggle/input/respiratory-sound-database/demographic_info.txt'):
+    """Load patient diagnosis and demographic data."""
+    data_logger.info("Loading patient diagnosis and demographic data.")
+    
+    # Load diagnosis data
+    diagnosis_df = pd.read_csv(diagnosis_path, 
+                               names=['Patient number', 'Diagnosis'])
+
+    # Load demographic data
+    patient_df = pd.read_csv(demographic_path, 
+                             names=['Patient number', 'Age', 'Sex', 'Adult BMI (kg/m2)', 'Child Weight (kg)', 'Child Height (cm)'],
+                             delimiter=' ')
+
+    data_logger.info("Data successfully loaded.")
+    
+    # Merge and return
+    return pd.merge(left=patient_df, right=diagnosis_df, how='left')
+
+
+def process_audio_metadata(folder_path):
+    """Extract audio metadata from filenames."""
+    processing_logger.info("Extracting audio metadata from filenames.")
+    data = []
+    for filename in os.listdir(folder_path):
+        if filename.endswith('.txt'):
+            parts = filename.split('_')
+            data.append({
+                'Patient number': int(parts[0]),
+                'Recording index': parts[1],
+                'Chest location': parts[2],
+                'Acquisition mode': parts[3],
+                'Recording equipment': parts[4].split('.')[0]
+            })
+    processing_logger.info("Audio metadata extraction complete.")
+    return pd.DataFrame(data)
+
+
+def merge_datasets(df1, df2):
+    """Merge metadata and diagnosis data."""
+    processing_logger.info("Merging metadata and diagnosis data.")
+    merged_df = pd.merge(left=df1, right=df2, how='left').sort_values('Patient number').reset_index(drop=True)
+    merged_df['audio_file_name'] = merged_df.apply(lambda row: f"{row['Patient number']}_{row['Recording index']}_{row['Chest location']}_{row['Acquisition mode']}_{row['Recording equipment']}.wav", axis=1)
+    processing_logger.info("Merging complete.")
+    return merged_df
+
+
+
+def filter_and_sample_data(df, mode='binary'):
+    """
+    Filter and sample the dataset for binary or multi-class classification.
+
+    Returns filtered and processed DataFrame.
+    """
+    processing_logger.info(f"Filtering and sampling the dataset for {mode} classification.")
+    
+    if mode == 'binary':
+        # Binary classification: Normal vs. Abnormal
+        df['Diagnosis'] = df['Diagnosis'].apply(lambda x: 'Normal' if x == 'Healthy' else 'Abnormal')
+    elif mode == 'multi':
+        # Multi-class classification: Group classes
+        # I grouped disease based on their similarities
+        processing_logger.info("Grouping classes for multi-class classification.")
+        df['Diagnosis'] = df['Diagnosis'].replace({
+            'Healthy': 'Normal',
+            'COPD': 'Chronic Respiratory Diseases',
+            'Asthma': 'Chronic Respiratory Diseases',
+            'URTI': 'Respiratory Infections',
+            'Bronchiolitis': 'Respiratory Infections',
+            'LRTI': 'Respiratory Infections',
+            'Pneumonia': 'Respiratory Infections',
+            'Bronchiectasis': 'Respiratory Infections'
+        })
+
+    # Filter out rare classes with fewer than 5 samples
+    class_counts = df['Diagnosis'].value_counts()
+    valid_classes = class_counts[class_counts >= 5].index
+    df = df[df['Diagnosis'].isin(valid_classes)].reset_index(drop=True)
+
+    processing_logger.info(f"Filtered classes: {df['Diagnosis'].unique()}")
+    processing_logger.info(f"Filtering and sampling complete with mode={mode}.")
+    return df
+
+
+def prepare_dataset_augmented(df_filtered, audio_files_path, classification_mode):
+    """Prepare the dataset for augmented features. it will be 1D array"""
+    processing_logger.info("Preparing dataset with AUGMENTED pipeline.")
+    
+    # Extract features and labels
+    X, y = mfccs_feature_extraction(audio_files_path, df_filtered)
+    
+    # Apply label encoding
+    le = LabelEncoder()
+    y_encoded = le.fit_transform(np.array(y))  # Encode labels to integers
+
+    if classification_mode == "binary":
+        # Use single column with 0 and 1 for binary classification
+        processing_logger.info("Binary classification mode: Using single column labels (0/1).")
+        y_processed = y_encoded  # No one-hot encoding
+    else:
+        # One-hot encode labels for multi-class classification
+        processing_logger.info("Multi-class classification mode: Applying one-hot encoding.")
+        y_processed = to_categorical(y_encoded)
+
+        # Log the mapping of one-hot encoding to class labels
+        print("One-hot encoding mapping:")
+        for idx, label in enumerate(le.classes_):
+            print(f"{idx} -> {label}")
+    
+    processing_logger.info("Dataset preparation with augmented pipeline complete.")
+    return X, y_processed, le
+
+
+def mfccs_feature_extraction(audio_files_path, df_filtered, n_jobs=-1):
+    """
+    Make the process of MFCC feature extraction faster by running jobs in-parallel
+    
+    Returns array of features extracted from the audio files and Array of target labels.
+    """
+    processing_logger.info(f"Processing audio files in: {audio_files_path}")
+    files = [file for file in os.listdir(audio_files_path) if file.endswith('.wav') and file[:3] not in ['103', '108', '115']]
+   
+    #files = files[:30] ## DEBUG
+
+    # Use Parallel and delayed to process files in parallel
+    results = Parallel(n_jobs=n_jobs, backend="loky")(delayed(process_audio_file)(file, audio_files_path, df_filtered) for file in tqdm(files, desc="Processing audio files"))
+
+    # Flatten results
+    X_ = []
+    y_ = []
+    for X_local, y_local in results:
+        X_.extend(X_local)
+        y_.extend(y_local)
+
+    X_data = np.array(X_)
+    y_data = np.array(y_)
+    processing_logger.info("MFCC feature extraction and augmentation complete.")
+    return X_data, y_data
+
+
+def process_audio_file(soundDir, audio_files_path, df_filtered):
+    """
+    Process a single audio file: extract MFCC features and augment with noise, stretching, and shifting.
+    
+    """
+    X_local = []
+    y_local = []
+    features = 52
+
+    # Extract patient ID and disease from filename and DataFrame
+    patient_id = int(soundDir.split('_')[0])
+    disease = df_filtered.loc[df_filtered['Patient number'] == patient_id, 'Diagnosis'].values[0]
+
+    # Load audio file
+    data_x, sampling_rate = librosa.load(os.path.join(audio_files_path, soundDir), sr=None)
+    data_x = preprocess_audio(data_x, sampling_rate)  # Apply filtering
+
+    
+    mfccs = np.mean(librosa.feature.mfcc(y=data_x, sr=sampling_rate, n_mfcc=features).T, axis=0)
+    X_local.append(mfccs)
+    y_local.append(disease)
+
+    # Data augmentation
+    for augmentation in [add_noise, shift, stretch, pitch_shift]:
+        if augmentation == add_noise:
+            augmented_data = augmentation(data_x, 0.001)
+        elif augmentation == shift:
+            augmented_data = augmentation(data_x, 1600)
+        elif augmentation == stretch:
+            augmented_data = augmentation(data_x, 1.2)
+        elif augmentation == pitch_shift:
+            augmented_data = augmentation(data_x, sampling_rate, 3)
+
+        mfccs_augmented = np.mean(librosa.feature.mfcc(y=augmented_data, sr=sampling_rate, n_mfcc=features).T, axis=0)
+        X_local.append(mfccs_augmented)
+        y_local.append(disease)
+
+    return X_local, y_local
+
+
+def add_noise(data,x):
+    noise = np.random.randn(len(data))
+    data_noise = data + x * noise
+    return data_noise
+
+def shift(data, x):
+    return np.roll(data, int(x))
+
+def stretch(data, rate):
+    return librosa.effects.time_stretch(data, rate=rate)
+
+def pitch_shift (data , sr, rate):
+    return librosa.effects.pitch_shift(data, sr=sr, n_steps=rate)
+
+
+
+
+def prepare_dataset_parallel(df, audio_files_path, mode, classification_mode):
+    """Prepare the dataset by extracting features from audio files in parallel."""
+    processing_logger.info(f"Preparing dataset using {mode} features in parallel.")
+    results = Parallel(n_jobs=-1)(delayed(preprocess_file)(row, audio_files_path, mode) for _, row in tqdm(df.iterrows(), total=len(df)))
+
+    X, y = zip(*results)
+    X = np.array(X)
+    X = np.expand_dims(X, axis=-1)  # Add channel dimension
+    X = normalize(X, axis=1)
+    
+    le = LabelEncoder()
+    y_encoded = le.fit_transform(np.array(y))  # Encode labels
+
+    if classification_mode == "binary":
+        # Use single column with 0 and 1 for binary classification
+        processing_logger.info("Binary classification mode: Using single column labels (0/1).")
+        y = y_encoded  # No one-hot encoding
+    else:
+        # One-hot encode labels for multi-class classification
+        processing_logger.info("Multi-class classification mode: Applying one-hot encoding.")
+        y = to_categorical(y_encoded)
+
+    processing_logger.info(f"Dataset preparation using {mode} complete.")
+    return X, y, le
+
+def preprocess_file(row, audio_files_path, mode):
+    """Preprocess a single audio file."""
+    file_path = os.path.join(audio_files_path, row['audio_file_name'])
+    feature = preprocessing(file_path, mode)
+    label = row['Diagnosis']
+    return feature, label
+    
+def preprocessing(audio_file, mode):
+    """Preprocess audio file by resampling, padding/truncating, and extracting features."""
+    sr_new = 16000  # Resample audio to 16 kHz
+    x, sr = librosa.load(audio_file, sr=sr_new)
+    x = preprocess_audio(x, sr)
+    # Padding or truncating to 5 seconds (5 * sr_new samples)
+    max_len = 5 * sr_new
+    if x.shape[0] < max_len:
+        x = np.pad(x, (0, max_len - x.shape[0]))
+    else:
+        x = x[:max_len]
+
+    # Extract features
+    # I understand the common choice for n_mfcc is 13, but here i assumed we need to capture more informationm, therefore I choose 20.
+    if mode == 'mfcc':
+        feature = librosa.feature.mfcc(y=x, sr=sr_new, n_mfcc=20)  # Ensure consistent shape
+    elif mode == 'log_mel':
+        feature = librosa.feature.melspectrogram(y=x, sr=sr_new, n_mels=20, fmax=8000)  # Match n_mels to 20
+        feature = librosa.power_to_db(feature, ref=np.max)
+
+    return feature
+
+def oversample_data(X, y):
+    """Apply SMOTE to balance classes."""
+    processing_logger.info("Applying SMOTE to balance classes.")
+    
+    # Save the original shape of features
+    original_shape = X.shape[1:]  
+    
+    # Flatten for SMOTE processing
+    X = X.reshape((X.shape[0], -1))
+    
+    # Convert one-hot encoded labels to integers
+    y = np.argmax(y, axis=1)
+    
+    # Apply SMOTE
+    smote = SMOTE(random_state=42)
+    X_resampled, y_resampled = smote.fit_resample(X, y)
+    
+    # Reshape back to the original dimensions
+    X_resampled = X_resampled.reshape((-1, *original_shape))
+    
+    # Convert labels back to one-hot encoding
+    y_resampled = to_categorical(y_resampled)
+    
+    processing_logger.info("SMOTE oversampling complete.")
+    return X_resampled, y_resampled
+
+
+
+def build_model(input_shape, n_filters, dense_units, dropout_rate, num_classes, model_type='1D', classification_mode='binary'):
+    """
+    Build and compile a CNN model for 1D or 2D data.
+
+    Returns CNN model.
+    """
+    print(f"Building the updated {model_type} CNN model with {classification_mode} classification.")
+    model = Sequential()
+
+    # Add convolutional layers based on the model type
+    if model_type == '1D':
+        # 1D CNN layers
+        model.add(Conv1D(n_filters, kernel_size=3, activation='relu', input_shape=input_shape))
+        model.add(BatchNormalization())
+        model.add(MaxPooling1D(pool_size=2))
+        model.add(Dropout(dropout_rate))
+
+        model.add(Conv1D(n_filters * 2, kernel_size=3, activation='relu'))
+        model.add(BatchNormalization())
+        model.add(MaxPooling1D(pool_size=2))
+        model.add(Dropout(dropout_rate))
+
+        model.add(Conv1D(n_filters * 4, kernel_size=3, activation='relu'))
+        model.add(BatchNormalization())
+        model.add(GlobalAveragePooling1D())
+        model.add(Dropout(dropout_rate))
+
+    elif model_type == '2D':
+        # 2D CNN layers
+        model.add(Conv2D(n_filters, (3, 3), activation='relu', input_shape=input_shape))
+        model.add(BatchNormalization())
+        if input_shape[0] >= 2:
+            model.add(MaxPooling2D((2, 2)))
+        model.add(Dropout(dropout_rate))
+
+        model.add(Conv2D(n_filters * 2, (3, 3), activation='relu'))
+        model.add(BatchNormalization())
+        if input_shape[0] >= 4:
+            model.add(MaxPooling2D((2, 2)))
+        model.add(Dropout(dropout_rate))
+
+        model.add(Conv2D(n_filters * 4, (3, 3), activation='relu'))
+        model.add(BatchNormalization())
+        model.add(GlobalAveragePooling2D())
+        model.add(Dropout(dropout_rate))
+
+    else:
+        raise ValueError("Invalid model_type. Must be '1D' or '2D'.")
+
+    # Add fully connected layers
+    model.add(Dense(dense_units, activation='relu'))
+    model.add(BatchNormalization())
+    model.add(Dropout(dropout_rate))
+
+    # Add output layer dynamically based on classification mode
+    if classification_mode == 'binary':
+        # Binary classification: Single unit with sigmoid activation
+        model.add(Dense(1, activation='sigmoid'))
+        loss_function = 'binary_crossentropy'
+    else:
+        # Multi-class classification: num_classes units with softmax activation
+        model.add(Dense(num_classes, activation='softmax'))
+        loss_function = 'categorical_crossentropy'
+
+    # Compile the model
+    model.compile(optimizer='adam', loss=loss_function, metrics=['accuracy'])
+    print(f"{model_type} CNN model built and compiled successfully for {classification_mode} classification.")
+    return model
+
+
+def log_metrics(y_true, y_pred, mode):
+    """Log evaluation metrics."""
+    precision = classification_report(y_true, y_pred, output_dict=True)['weighted avg']['precision']
+    recall = classification_report(y_true, y_pred, output_dict=True)['weighted avg']['recall']
+    f1_score = classification_report(y_true, y_pred, output_dict=True)['weighted avg']['f1-score']
+
+    mlflow.log_metric(f"{mode}_precision", precision)
+    mlflow.log_metric(f"{mode}_recall", recall)
+    mlflow.log_metric(f"{mode}_f1_score", f1_score)
+
+
+
+def track_experiment_with_mlflow_and_optuna(mode, num_classes, model_type='1D', classification_mode='binary'):
+    """
+    Optimize hyperparameters using Optuna and track experiments with MLflow.
+
+    mode: Feature extraction mode (e.g., 'augmented', 'mfcc', 'log_mel').
+    num_classes: Number of classes for classification.
+    model_type: Type of model ('1D' for Conv1D, '2D' for Conv2D).
+    classification_mode: 'binary' for binary classification, 'multi' for multi-class classification.
+    """
+    def objective(trial):
+        with mlflow.start_run(nested=True):  # Start a new MLflow run for each trial
+            # Hyperparameters to tune
+            n_filters = trial.suggest_categorical('n_filters', [16, 32, 64])
+            dense_units = trial.suggest_int('dense_units', 64, 256, step=32)
+            dropout_rate = trial.suggest_float('dropout_rate', 0.1, 0.5, step=0.1)
+            learning_rate = trial.suggest_loguniform('learning_rate', 1e-4, 1e-2)
+
+            # Build and compile the model
+            model = build_model(
+                input_shape=X_train.shape[1:], 
+                n_filters=n_filters, 
+                dense_units=dense_units, 
+                dropout_rate=dropout_rate,
+                num_classes=num_classes,
+                model_type=model_type,
+                classification_mode=classification_mode
+            )
+
+            # Define EarlyStopping callback
+            early_stopping = EarlyStopping(
+                monitor='val_loss',  # Monitor validation loss
+                patience=5,          # Stop training after 5 epochs with no improvement
+                restore_best_weights=True
+            )
+
+            # Train the model
+            history = model.fit(
+                X_train, y_train, 
+                validation_data=(X_val, y_val), 
+                epochs=50,  # Allow a larger max epoch since EarlyStopping will handle early termination
+                batch_size=32, 
+                callbacks=[early_stopping], 
+                verbose=0
+            )
+
+            # Log hyperparameters and metrics to MLflow
+            mlflow.log_params({
+                'n_filters': n_filters,
+                'dense_units': dense_units,
+                'dropout_rate': dropout_rate,
+                'learning_rate': learning_rate,
+                'model_type': model_type,
+                'classification_mode': classification_mode
+            })
+            mlflow.log_metric("best_val_accuracy", max(history.history['val_accuracy']))
+
+            # Save training and validation loss curves
+            plt.figure()
+            plt.plot(history.history['loss'], label='Train Loss')
+            plt.plot(history.history['val_loss'], label='Validation Loss')
+            plt.legend()
+            plt.title("Training and Validation Loss")
+            loss_curve_path = f"loss_curve_{trial.number}_{model_type}.png"
+            plt.savefig(loss_curve_path)
+            mlflow.log_artifact(loss_curve_path)
+
+            return max(history.history['val_accuracy'])
+
+    # Start Optuna study
+    study = optuna.create_study(direction='maximize')
+    study.optimize(objective, n_trials=20)
+
+    # Retrieve best trial and log results
+    best_trial = study.best_trial
+    model_logger.info(f"Best Trial for {mode} ({model_type}): {best_trial.params}")
+
+    # Build the best model (already compiled in build_model)
+    best_model = build_model(
+        input_shape=X_train.shape[1:], 
+        n_filters=best_trial.params['n_filters'], 
+        dense_units=best_trial.params['dense_units'], 
+        dropout_rate=best_trial.params['dropout_rate'], 
+        num_classes=num_classes,
+        model_type=model_type,
+        classification_mode=classification_mode
+    )
+
+    # Train the best model with EarlyStopping
+    early_stopping = EarlyStopping(
+        monitor='val_loss',
+        patience=5,
+        restore_best_weights=True
+    )
+
+    best_model.fit(
+        X_train, y_train, 
+        validation_data=(X_val, y_val), 
+        epochs=50, batch_size=32, 
+        callbacks=[early_stopping], 
+        verbose=1
+    )
+
+    # Save the best model
+    best_model_path = f"best_model_{mode}_{model_type}.h5"
+    best_model.save(best_model_path)
+    mlflow.log_artifact(best_model_path)
+    model_logger.info(f"Best model for {mode} ({model_type}) saved successfully.")
+
+    return best_model
+
+def log_class_distribution(y, message):
+    """Log the class distribution."""
+    if y.ndim == 1:  # Binary classification (1D array of 0s and 1s)
+        unique, counts = np.unique(y, return_counts=True)
+    else:  # Multi-class classification (2D one-hot encoded array)
+        unique, counts = np.unique(np.argmax(y, axis=1), return_counts=True)
+
+    class_distribution = dict(zip(unique, counts))
+    processing_logger.info(f"{message} Class Distribution: {class_distribution}")
+
+
+def preprocess_audio(audio, sr):
+    """
+    Apply a bandpass filter to audio data.
+    
+    """
+    # Define cutoff frequencies
+    low_cutoff = 50  # 50 Hz
+    high_cutoff = min(5000, sr / 2 - 1)  # Ensure it is below Nyquist frequency
+
+    if low_cutoff >= high_cutoff:
+        raise ValueError(
+            f"Invalid filter range: low_cutoff={low_cutoff}, high_cutoff={high_cutoff} for sampling rate {sr}"
+        )
+
+    # Design a bandpass filter
+    sos = butter(N=10, Wn=[low_cutoff, high_cutoff], btype='band', fs=sr, output='sos')
+
+    # Apply the filter
+    filtered_audio = sosfilt(sos, audio)
+    return filtered_audio
+
+
+def generate_random_audio_data(samples=20000, feature_dim=20):
+    """Generate random audio-like data for testing purposes."""
+    X = np.random.rand(samples, feature_dim, feature_dim)  # Simulate 2D audio features
+    y = np.random.randint(0, 2, size=samples)  # Binary classification labels
+    return X, y
+
+def test_model():
+    """Test 2D CNN model with simulated audio data for debugging."""
+    print("[DEBUG] Generating simulated audio data...")
+    global X_train, X_val, X_test, y_train, y_val, y_test
+    X, y = generate_random_audio_data()
+
+    # Simulate preprocessing similar to audio processing pipeline
+    print("[DEBUG] Preprocessing simulated audio data...")
+    X_preprocessed = np.array([np.log1p(sample) for sample in X])  # Simulate a log transform or feature extraction
+
+    # Split data into train, validation, and test sets
+    X_train, X_temp, y_train, y_temp = train_test_split(X_preprocessed, y, test_size=0.3, stratify=y, random_state=42)
+    X_val, X_test, y_val, y_test = train_test_split(X_temp, y_temp, test_size=0.5, stratify=y_temp, random_state=42)
+
+    print(f"[DEBUG] Data split: Training={X_train.shape}, Validation={X_val.shape}, Test={X_test.shape}")
+
+    # Expand dimensions for 2D CNN input
+    X_train = np.expand_dims(X_train, axis=-1)
+    X_val = np.expand_dims(X_val, axis=-1)
+    X_test = np.expand_dims(X_test, axis=-1)
+
+    print("[DEBUG] Initializing 2D CNN model...")
+    model = track_experiment_with_mlflow_and_optuna(
+        mode='mfcc',
+        num_classes=1,
+        model_type='2D',  # Specify 2D CNN for MFCC and Log-Mel
+        classification_mode='binary'
+    )
+
+    print("[DEBUG] Training the model...")
+    # Train the model with a single epoch for testing
+    model.fit(X_train, y_train, validation_data=(X_val, y_val), epochs=1, batch_size=32)
+
+    print("[DEBUG] Evaluating the model...")
+    results = model.evaluate(X_test, y_test)
+    print(f"[DEBUG] Test evaluation results: {results}")
+
+
+def main():
+    # how to run:
+    #  python legacy/test.py --metadata_path data/Respiratory_Sound_Database/audio_and_txt_files --audio_files_path data/Respiratory_Sound_Database/audio_and_txt_files --demographic_path data/demographic_info.txt --diagnosis_path data/Respiratory_Sound_Database/patient_diagnosis.csv --classification_modes binary --feature_types mfcc 
+
+    # Parse arguments
+    parser = argparse.ArgumentParser(description="Run the respiratory sound analysis pipeline.")
+    parser.add_argument("--metadata_path", type=str, default="/kaggle/input/respiratory-sound-database/Respiratory_Sound_Database/Respiratory_Sound_Database/audio_and_txt_files", help="Path to the metadata directory.")
+    parser.add_argument("--audio_files_path", type=str, default="/kaggle/input/respiratory-sound-database/Respiratory_Sound_Database/Respiratory_Sound_Database/audio_and_txt_files", help="Path to the directory containing audio files.")
+    parser.add_argument("--demographic_path", type=str, default="/kaggle/input/respiratory-sound-database/demographic_info.txt", help="Path to the demographic info file.")
+    parser.add_argument("--diagnosis_path", type=str, default="/kaggle/input/respiratory-sound-database/Respiratory_Sound_Database/Respiratory_Sound_Database/patient_diagnosis.csv", help="Path to the patient diagnosis CSV file.")
+    parser.add_argument("--tracking_uri", type=str, default="./mlruns", help="MLflow tracking URI.")
+    parser.add_argument("--classification_modes", type=str, nargs='+', default=['multi', 'binary'], help="Classification modes to run (default: all modes). Options: 'binary', 'multi'.")
+    parser.add_argument("--feature_types", type=str, nargs='+', default=['mfcc', 'log_mel', 'augmented'], help="Feature types to use (default: all types). Options: 'mfcc', 'log_mel', 'augmented'.")
+    parser.add_argument("--debug", action='store_true', help="Run in debug mode with random test data.")
+    args = parser.parse_args()
+
+    if args.debug:
+        test_model()
+        return
+    # Assign arguments to variables
+    metadata_path = args.metadata_path
+    audio_files_path = args.audio_files_path
+    demographic_path = args.demographic_path
+    diagnosis_path = args.diagnosis_path
+
+
+    # Set MLflow tracking URI
+    mlflow.set_tracking_uri(args.tracking_uri)
+
+    metadata_path = args.metadata_path
+    audio_files_path = args.audio_files_path
+
+    data_logger.info("Starting data pipeline.")
+    df = load_data(demographic_path=demographic_path, diagnosis_path=diagnosis_path)
+    audio_metadata = process_audio_metadata(audio_files_path)
+    df_all = merge_datasets(audio_metadata, df)
+
+    # Use user-specified or default classification modes and feature types
+    classification_modes = args.classification_modes
+    feature_types = args.feature_types
+    models = []
+
+    for classification_mode in classification_modes:
+        # Preprocess dataset for binary or multi-class classification
+        df_filtered = filter_and_sample_data(df_all, mode=classification_mode)
+        processing_logger.info(f"Dataset shape for {classification_mode} mode: {df_filtered.shape}")
+
+        for feature_type in feature_types:
+            processing_logger.info(f"Running experiment for {classification_mode} classification with {feature_type} features.")
+            global X_train, X_val, X_test, y_train, y_val, y_test
+
+            # Prepare the dataset
+            if feature_type == 'augmented':
+                X, y, le = prepare_dataset_augmented(
+                    df_filtered, 
+                    audio_files_path,
+                    classification_mode=classification_mode
+                )
+            else:
+                X, y, le = prepare_dataset_parallel(
+                    df_filtered, 
+                    audio_files_path,
+                    mode=feature_type,
+                    classification_mode=classification_mode
+                )
+
+            # Split data into train/val/test
+            X_train, X_temp, y_train, y_temp = train_test_split(X, y, test_size=0.3, stratify=y, random_state=42)
+            X_val, X_test, y_val, y_test = train_test_split(X_temp, y_temp, test_size=0.5, stratify=y_temp, random_state=42)
+
+            # Save test data for future evaluation
+            np.save(f"X_test_{classification_mode}_{feature_type}.npy", X_test)
+            np.save(f"y_test_{classification_mode}_{feature_type}.npy", y_test)
+            mlflow.log_artifact(f"X_test_{classification_mode}_{feature_type}.npy")
+            mlflow.log_artifact(f"y_test_{classification_mode}_{feature_type}.npy")
+
+            # Log dataset characteristics
+            log_class_distribution(y_train, "Before Oversampling")
+            processing_logger.info(f"Train size: {X_train.shape}, Validation size: {X_val.shape}, Test size: {X_test.shape}")
+
+            try:
+                X_train, y_train = oversample_data(X_train, y_train)
+            except ValueError as e:
+                processing_logger.warning(f"SMOTE skipped: {e}")
+            log_class_distribution(y_train, "After Oversampling")
+
+            # Determine number of classes
+            if classification_mode == "binary":
+                num_classes = 1  # Single output for binary classification
+            else:
+                num_classes = y_train.shape[1]  # Number of classes for multi-class
+
+            # Train and save model
+            with mlflow.start_run(run_name=f"Experiment_{classification_mode}_{feature_type}", nested=True):
+                if feature_type == 'augmented':
+                    # Expand dimensions for 1D CNN input
+                    X_train = np.expand_dims(X_train, axis=-1)
+                    X_val = np.expand_dims(X_val, axis=-1)
+                    X_test = np.expand_dims(X_test, axis=-1)
+
+                    # Optimize and train 1D CNN
+                    model = track_experiment_with_mlflow_and_optuna(
+                        mode=feature_type,
+                        num_classes=num_classes,
+                        model_type='1D',  # Specify 1D CNN for GRU features
+                        classification_mode=classification_mode
+                    )
+                else:
+                    # Optimize and train CNN models for MFCC and MEL
+                    model = track_experiment_with_mlflow_and_optuna(
+                        mode=feature_type,
+                        num_classes=num_classes,
+                        model_type='2D',  # Specify 2D CNN for MFCC and Log-Mel
+                        classification_mode=classification_mode
+                    )
+
+                # Save final model
+                final_model_path = f"final_model_{classification_mode}_{feature_type}.h5"
+                model.save(final_model_path)
+                mlflow.log_artifact(final_model_path)
+                models.append(model)
+
+    processing_logger.info("All experiments completed successfully!")
+
+
+if __name__ == "__main__":
+    main()

Model_Inference.py

@@ -1,109 +1,226 @@
-
-
 import os
+import logging
 import numpy as np
-import pandas as pd
-from sklearn.metrics import (
-    accuracy_score, precision_score, recall_score, f1_score, roc_auc_score, confusion_matrix, classification_report, roc_curve
-)
+import librosa
+from sklearn.preprocessing import normalize
 from tensorflow.keras.models import load_model
-import matplotlib.pyplot as plt
+from scipy.signal import butter, sosfilt
+import pandas as pd
 
-# Paths
+# Set up logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger("audio_classifier_test")
+
+# Paths and Constants
 MODEL_PATH = "./models"
-DATASET_PATH = "./processed_datasets"
-
-# Model and dataset filenames
-MODELS = [
-    "final_model_binary_augmented.h5",
-    "final_model_binary_log_mel.h5",
-    "final_model_binary_mfcc.h5",
-    "final_model_multi_augmented.h5",
-    "final_model_multi_log_mel.h5",
-    "final_model_multi_mfcc.h5"
-]
-
-DATASETS = {
-    "binary_augmented": ("X_test_binary_augmented.npy", "y_test_binary_augmented.npy"),
-    "binary_log_mel": ("X_test_binary_log_mel.npy", "y_test_binary_log_mel.npy"),
-    "binary_mfcc": ("X_test_binary_mfcc.npy", "y_test_binary_mfcc.npy"),
-    "multi_augmented": ("X_test_multi_augmented.npy", "y_test_multi_augmented.npy"),
-    "multi_log_mel": ("X_test_multi_log_mel.npy", "y_test_multi_log_mel.npy"),
-    "multi_mfcc": ("X_test_multi_mfcc.npy", "y_test_multi_mfcc.npy")
+FILE_PATH = "./data/Respiratory_Sound_Database/testsample/101_1b1_Al_sc_Meditron.wav"
+MODELS = {
+    "binary": {
+        "augmented": "final_model_binary_augmented.h5",
+        "log_mel": "final_model_binary_log_mel.h5",
+        "mfcc": "final_model_binary_mfcc.h5",
+    },
+    "multi": {
+        "augmented": "final_model_multi_augmented.h5",
+        "log_mel": "final_model_multi_log_mel.h5",
+        "mfcc": "final_model_multi_mfcc.h5",
+    }
+}
+CLASS_NAMES = {
+    "binary": ["Abnormal", "Normal"],
+    "multi": ["Chronic Respiratory Diseases", "Normal", "Respiratory Infections"]
 }
 
-# Metrics dictionary
-metrics_dict = []
 
-# Function to evaluate a model
-def evaluate_model(model, X_test, y_test, mode):
-    y_pred_prob = model.predict(X_test)
-    y_pred = np.argmax(y_pred_prob, axis=1)
-    y_true = np.argmax(y_test, axis=1)
-    
-    accuracy = accuracy_score(y_true, y_pred)
-    precision = precision_score(y_true, y_pred, average='weighted')
-    recall = recall_score(y_true, y_pred, average='weighted')
-    f1 = f1_score(y_true, y_pred, average='weighted')
-    auc = roc_auc_score(y_test, y_pred_prob, multi_class='ovr')
-    conf_matrix = confusion_matrix(y_true, y_pred)
+# Augmentation Functions
+def add_noise(data, noise_factor=0.001):
+    noise = np.random.randn(len(data))
+    return data + noise_factor * noise
+
+def shift(data, shift_factor=1600):
+    return np.roll(data, shift_factor)
+
+def stretch(data, rate=1.2):
+    return librosa.effects.time_stretch(data, rate=rate)
+
+def pitch_shift(data, sr, n_steps=3):
+    return librosa.effects.pitch_shift(data, sr=sr, n_steps=n_steps)
+
+
+
+def filtering(audio, sr):
+    """
+    Apply a bandpass filter to audio data.
     
-    print(f"--- Evaluation for {mode} ---")
-    print(f"Accuracy: {accuracy:.4f}")
-    print(f"Precision: {precision:.4f}")
-    print(f"Recall: {recall:.4f}")
-    print(f"F1 Score: {f1:.4f}")
-    print(f"ROC-AUC: {auc:.4f}")
-    print("Confusion Matrix:")
-    print(conf_matrix)
-    print("\n")
-
-    # Log metrics
-    metrics_dict.append({
-        "Model": mode,
-        "Accuracy": accuracy,
-        "Precision": precision,
-        "Recall": recall,
-        "F1 Score": f1,
-        "ROC-AUC": auc
-    })
-
-    # Plot ROC curve
-    fpr = {}
-    tpr = {}
-    for i in range(y_test.shape[1]):
-        fpr[i], tpr[i], _ = roc_curve(y_test[:, i], y_pred_prob[:, i])
-    plt.figure(figsize=(10, 6))
-    for i, label in enumerate(np.unique(y_true)):
-        plt.plot(fpr[i], tpr[i], label=f"Class {label} ROC")
-    plt.plot([0, 1], [0, 1], 'k--', label='Chance')
-    plt.xlabel('False Positive Rate')
-    plt.ylabel('True Positive Rate')
-    plt.title(f"ROC Curve - {mode}")
-    plt.legend()
-    plt.savefig(f"roc_curve_{mode}.png")
-    plt.close()
-
-# Evaluate all models
-for model_name in MODELS:
-    mode_key = model_name.replace("final_model_", "").replace(".h5", "").replace(" ", "_").lower()
-    dataset = DATASETS.get(mode_key)
-
-    if dataset:
-        # Load the model and dataset
-        model_path = os.path.join(MODEL_PATH, model_name)
-        model = load_model(model_path)
-
-        X_test_path, y_test_path = dataset
-        X_test = np.load(os.path.join(DATASET_PATH, X_test_path))
-        y_test = np.load(os.path.join(DATASET_PATH, y_test_path))
-
-        # Evaluate the model
-        evaluate_model(model, X_test, y_test, mode_key)
-    else:
-        print(f"No dataset found for model: {model_name}")
-
-# Save metrics as a CSV
-metrics_df = pd.DataFrame(metrics_dict)
-metrics_df.to_csv("model_evaluation_summary.csv", index=False)
-print("Evaluation complete. Summary saved as 'model_evaluation_summary.csv'.")
+    Returns filtered audio signal.
+    """
+    # Define cutoff frequencies
+    low_cutoff = 50  # 50 Hz
+    high_cutoff = min(5000, sr / 2 - 1)  # Ensure it is below Nyquist frequency
+
+    if low_cutoff >= high_cutoff:
+        raise ValueError(
+            f"Invalid filter range: low_cutoff={low_cutoff}, high_cutoff={high_cutoff} for sampling rate {sr}"
+        )
+
+    # Design a bandpass filter
+    sos = butter(N=10, Wn=[low_cutoff, high_cutoff], btype='band', fs=sr, output='sos')
+
+    # Apply the filter
+    filtered_audio = sosfilt(sos, audio)
+    return filtered_audio
+
+
+def preprocess_audio(audio_file, mode="augmented", input_shape=None):
+    """
+    Preprocess an audio file for classification by resampling, padding/truncating,
+    and extracting features (e.g., MFCC, Log-Mel spectrogram, or Augmented features).
+    """
+    try:
+        sr_new = 16000  # Resample audio to 16 kHz
+        x, sr = librosa.load(audio_file, sr=sr_new)
+        x = filtering(x, sr)
+        logger.info(f"Loaded audio file '{audio_file}' with shape {x.shape} and sampling rate {sr}.")
+
+        max_len = 5 * sr_new
+        if x.shape[0] < max_len:
+            x = np.pad(x, (0, max_len - x.shape[0]))
+            logger.info(f"Audio padded to {max_len} samples.")
+        else:
+            x = x[:max_len]
+            logger.info(f"Audio truncated to {max_len} samples.")
+
+        # Handle each mode separately
+        if mode == 'mfcc':
+            feature = librosa.feature.mfcc(y=x, sr=sr_new, n_mfcc=20)  # Extract MFCC
+            feature = normalize(feature, axis=1)
+
+        elif mode == 'log_mel':
+            mel_spec = librosa.feature.melspectrogram(y=x, sr=sr_new, n_mels=20, fmax=8000)
+            feature = librosa.power_to_db(mel_spec, ref=np.max)  # Extract Log-Mel spectrogram
+            feature = normalize(feature, axis=1)
+
+        elif mode == 'augmented':
+            features = []
+
+            # Base MFCC
+            base_mfcc = np.mean(librosa.feature.mfcc(y=x, sr=sr_new, n_mfcc=52).T, axis=0)
+            features.append(base_mfcc)
+
+            # Augmented features
+            for augmentation in [
+                lambda d: add_noise(d, 0.001),
+                lambda d: shift(d, 1600),
+                lambda d: stretch(d, 1.2),
+                lambda d: pitch_shift(d, sr_new, 3)
+            ]:
+                augmented_data = augmentation(x)
+                aug_mfcc = np.mean(librosa.feature.mfcc(y=augmented_data, sr=sr_new, n_mfcc=52).T, axis=0)
+                features.append(aug_mfcc)
+
+            # Average augmented features
+            feature = np.mean(features, axis=0)
+            feature = normalize(feature.reshape(1, -1), axis=1).flatten()  # Normalize
+
+        else:
+            raise ValueError(f"Unknown mode: {mode}")
+
+        # Reshape for model input if required
+        if input_shape:
+            feature = _reshape_feature(feature, input_shape)
+
+        logger.info(f"Feature extracted with shape {feature.shape}.")
+        return np.expand_dims(feature, axis=-1)  # Add channel dimension
+
+    except Exception as e:
+        logger.error(f"Error in preprocessing audio: {e}")
+        raise
+
+
+def _reshape_feature(feature, input_shape):
+    """
+    Reshape the feature to match the expected input shape of the model.
+
+    Returns reshaped feature.
+    """
+    expected_time_frames = input_shape[1]
+    if len(feature) > expected_time_frames:
+        feature = feature[:expected_time_frames]
+    elif len(feature) < expected_time_frames:
+        feature = np.pad(feature, (0, expected_time_frames - len(feature)))
+
+    return feature
+
+
+def classify_audio(model_type, feature_type, file_path):
+    """
+    Classify an audio file using the specified model and feature type.
+    """
+    try:
+        model_file = os.path.join(MODEL_PATH, MODELS[model_type][feature_type])
+        if not os.path.exists(model_file):
+            raise FileNotFoundError(f"Model file '{model_file}' not found.")
+        model = load_model(model_file)
+
+        # Get input shape from the model
+        input_shape = model.input_shape
+
+        # Preprocess audio
+        processed_audio = preprocess_audio(file_path, mode=feature_type, input_shape=input_shape)
+
+        # Add batch dimension
+        processed_audio = np.expand_dims(processed_audio, axis=0)
+
+        # Predict
+        predictions = model.predict(processed_audio)
+        predicted_class = np.argmax(predictions, axis=1)[0]
+        probabilities = predictions[0].tolist()
+
+        logger.info(f"Prediction complete. Predicted class: {predicted_class}, Probabilities: {probabilities}")
+        return predicted_class, probabilities
+
+    except Exception as e:
+        logger.error(f"Error in classification: {e}")
+        raise
+
+
+def main():
+    logger.info("Starting audio classification test script.")
+
+    if not os.path.exists(FILE_PATH):
+        logger.error(f"Audio file not found: {FILE_PATH}")
+        return
+
+    results = []  # To store results for the summary table
+
+    for model_type in MODELS.keys():
+        for feature_type in MODELS[model_type].keys():
+            try:
+                logger.info(f"Testing {model_type} model with {feature_type} features.")
+                predicted_class, probabilities = classify_audio(model_type, feature_type, FILE_PATH)
+                class_name = CLASS_NAMES[model_type][predicted_class]
+                logger.info(f"Predicted Class: {class_name} ({predicted_class}), Probabilities: {probabilities}")
+
+                # Add result to the summary
+                results.append({
+                    "Model Type": model_type,
+                    "Feature Type": feature_type,
+                    "Predicted Class": class_name,
+                    "Probabilities": probabilities
+                })
+            except Exception as e:
+                logger.error(f"Failed for {model_type} - {feature_type}: {e}")
+                results.append({
+                    "Model Type": model_type,
+                    "Feature Type": feature_type,
+                    "Predicted Class": "Error",
+                    "Probabilities": str(e)
+                })
+
+    # Create a DataFrame and print the table
+    df_results = pd.DataFrame(results)
+    print("\nSummary of Results:")
+    print(df_results.to_string(index=False))
+
+if __name__ == "__main__":
+    main()

README.md

@@ -1,7 +1,7 @@
----
-title: ICBHI 2017 Challenge - Amplifier Health
-sdk: streamlit
-emoji: 📊
-colorFrom: purple
-colorTo: blue
----
+---
+title: ICBHI 2017 Challenge - Amplifier Health
+sdk: streamlit
+emoji: 📊
+colorFrom: purple
+colorTo: blue
+---

TestModels.py

@@ -0,0 +1,109 @@
+
+
+import os
+import numpy as np
+import pandas as pd
+from sklearn.metrics import (
+    accuracy_score, precision_score, recall_score, f1_score, roc_auc_score, confusion_matrix, classification_report, roc_curve
+)
+from tensorflow.keras.models import load_model
+import matplotlib.pyplot as plt
+
+# Paths
+MODEL_PATH = "./models"
+DATASET_PATH = "./processed_datasets"
+
+# Model and dataset filenames
+MODELS = [
+    "final_model_binary_augmented.h5",
+    "final_model_binary_log_mel.h5",
+    "final_model_binary_mfcc.h5",
+    "final_model_multi_augmented.h5",
+    "final_model_multi_log_mel.h5",
+    "final_model_multi_mfcc.h5"
+]
+
+DATASETS = {
+    "binary_augmented": ("X_test_binary_augmented.npy", "y_test_binary_augmented.npy"),
+    "binary_log_mel": ("X_test_binary_log_mel.npy", "y_test_binary_log_mel.npy"),
+    "binary_mfcc": ("X_test_binary_mfcc.npy", "y_test_binary_mfcc.npy"),
+    "multi_augmented": ("X_test_multi_augmented.npy", "y_test_multi_augmented.npy"),
+    "multi_log_mel": ("X_test_multi_log_mel.npy", "y_test_multi_log_mel.npy"),
+    "multi_mfcc": ("X_test_multi_mfcc.npy", "y_test_multi_mfcc.npy")
+}
+
+# Metrics dictionary
+metrics_dict = []
+
+# Function to evaluate a model
+def evaluate_model(model, X_test, y_test, mode):
+    y_pred_prob = model.predict(X_test)
+    y_pred = np.argmax(y_pred_prob, axis=1)
+    y_true = np.argmax(y_test, axis=1)
+    
+    accuracy = accuracy_score(y_true, y_pred)
+    precision = precision_score(y_true, y_pred, average='weighted')
+    recall = recall_score(y_true, y_pred, average='weighted')
+    f1 = f1_score(y_true, y_pred, average='weighted')
+    auc = roc_auc_score(y_test, y_pred_prob, multi_class='ovr')
+    conf_matrix = confusion_matrix(y_true, y_pred)
+    
+    print(f"--- Evaluation for {mode} ---")
+    print(f"Accuracy: {accuracy:.4f}")
+    print(f"Precision: {precision:.4f}")
+    print(f"Recall: {recall:.4f}")
+    print(f"F1 Score: {f1:.4f}")
+    print(f"ROC-AUC: {auc:.4f}")
+    print("Confusion Matrix:")
+    print(conf_matrix)
+    print("\n")
+
+    # Log metrics
+    metrics_dict.append({
+        "Model": mode,
+        "Accuracy": accuracy,
+        "Precision": precision,
+        "Recall": recall,
+        "F1 Score": f1,
+        "ROC-AUC": auc
+    })
+
+    # Plot ROC curve
+    fpr = {}
+    tpr = {}
+    for i in range(y_test.shape[1]):
+        fpr[i], tpr[i], _ = roc_curve(y_test[:, i], y_pred_prob[:, i])
+    plt.figure(figsize=(10, 6))
+    for i, label in enumerate(np.unique(y_true)):
+        plt.plot(fpr[i], tpr[i], label=f"Class {label} ROC")
+    plt.plot([0, 1], [0, 1], 'k--', label='Chance')
+    plt.xlabel('False Positive Rate')
+    plt.ylabel('True Positive Rate')
+    plt.title(f"ROC Curve - {mode}")
+    plt.legend()
+    plt.savefig(f"roc_curve_{mode}.png")
+    plt.close()
+
+# Evaluate all models
+for model_name in MODELS:
+    mode_key = model_name.replace("final_model_", "").replace(".h5", "").replace(" ", "_").lower()
+    dataset = DATASETS.get(mode_key)
+
+    if dataset:
+        # Load the model and dataset
+        model_path = os.path.join(MODEL_PATH, model_name)
+        model = load_model(model_path)
+
+        X_test_path, y_test_path = dataset
+        X_test = np.load(os.path.join(DATASET_PATH, X_test_path))
+        y_test = np.load(os.path.join(DATASET_PATH, y_test_path))
+
+        # Evaluate the model
+        evaluate_model(model, X_test, y_test, mode_key)
+    else:
+        print(f"No dataset found for model: {model_name}")
+
+# Save metrics as a CSV
+metrics_df = pd.DataFrame(metrics_dict)
+metrics_df.to_csv("model_evaluation_summary.csv", index=False)
+print("Evaluation complete. Summary saved as 'model_evaluation_summary.csv'.")

Train.py

@@ -27,6 +27,7 @@ from tensorflow.keras.layers import Conv1D, GRU, Input, add, Dense, Dropout, Bat
 from tensorflow.keras.optimizers import Adamax
 from tensorflow.keras.callbacks import ModelCheckpoint, EarlyStopping
 from tensorflow.keras.preprocessing.image import ImageDataGenerator
+import argparse
 
 os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'  # Suppress INFO and WARNING logs from TensorFlow
 os.environ['TF_ENABLE_ONEDNN_OPTS'] = '0'  # Disable oneDNN optimizations
@@ -39,18 +40,11 @@ processing_logger = logging.getLogger("data_processing")
 model_logger = logging.getLogger("model_training")
 
 # Dataset and Paths
-AUDIO_FILES_PATH = 'D://github//AmpleHealth//data//Respiratory_Sound_Database//audio_and_txt_files'
-METADATA_PATH = 'D://github//AmpleHealth//data//Respiratory_Sound_Database//audio_and_txt_files'
+AUDIO_FILES_PATH = './/data//Respiratory_Sound_Database//audio_and_txt_files'
 
-def save_dataset(X, y, mode, output_dir="c"):
+def save_dataset(X, y, mode, output_dir="./processed_datasets/new"):
     """
     Save the processed X and y to .npy files.
-    
-    Args:
-        X: Processed features.
-        y: Processed labels.
-        mode: Mode for which the dataset is processed.
-        output_dir: Directory to save the .npy files.
     """
     import os
     
@@ -66,9 +60,8 @@ def save_dataset(X, y, mode, output_dir="c"):
     processing_logger.info(f"Saved dataset for mode '{mode}' to {output_dir}")
 
 
-def load_or_process_dataset(df_filtered, audio_files_path, mode, output_dir="processed_datasets"):
+def load_or_process_dataset(df_filtered, audio_files_path, mode, feature_type, output_dir="processed_datasets/new"):
 
-    #output_dir = os.path.abspath(output_dir)
     # File paths for preprocessed data
     X_path = os.path.join(output_dir, f"X_{mode}.npy")
     y_path = os.path.join(output_dir, f"y_{mode}.npy")
@@ -82,13 +75,21 @@ def load_or_process_dataset(df_filtered, audio_files_path, mode, output_dir="pro
         processing_logger.info(f"Preprocessed files not found for mode '{mode}'. Processing data...")
         os.makedirs(output_dir, exist_ok=True)
 
-        if mode == 'augmented':
-            X, y, le = prepare_dataset_augmented(df_filtered, audio_files_path)
+        # Prepare the dataset
+        if feature_type == 'augmented':
+            X, y, le = prepare_dataset_augmented(
+                df_filtered, 
+                audio_files_path,
+                classification_mode=mode
+            )
         else:
-            X, y, le = prepare_dataset_parallel(df_filtered, audio_files_path, mode=mode)
-
-
-
+            X, y, le = prepare_dataset_parallel(
+                df_filtered, 
+                audio_files_path,
+                mode=feature_type,
+                classification_mode=mode
+            )
+            
         # Save the processed data and LabelEncoder
         np.save(X_path, X)
         np.save(y_path, y)
@@ -97,119 +98,180 @@ def load_or_process_dataset(df_filtered, audio_files_path, mode, output_dir="pro
     le = LabelEncoder()
     return X, y, le
 
-
+def log_class_distribution(y, message):
+    """Log the class distribution."""
+    if y.ndim == 1:  # Binary classification (1D array of 0s and 1s)
+        unique, counts = np.unique(y, return_counts=True)
+    else:  # Multi-class classification (2D one-hot encoded array)
+        unique, counts = np.unique(np.argmax(y, axis=1), return_counts=True)
+
+    class_distribution = dict(zip(unique, counts))
+    processing_logger.info(f"{message} Class Distribution: {class_distribution}")
+
+
+def generate_random_audio_data(samples=200, feature_dim=20):
+    """Generate random audio-like data for testing purposes."""
+    X = np.random.rand(samples, feature_dim, feature_dim)  # Simulate 2D audio features
+    y = np.random.randint(0, 2, size=samples)  # Binary classification labels
+    return X, y
+
+def test_model():
+    """Test 2D CNN model with simulated audio data for debugging."""
+    print("[DEBUG] Generating simulated audio data...")
+    global X_train, X_val, X_test, y_train, y_val, y_test
+    X, y = generate_random_audio_data()
+
+    # Simulate preprocessing similar to audio processing pipeline
+    print("[DEBUG] Preprocessing simulated audio data...")
+    X_preprocessed = np.array([np.log1p(sample) for sample in X])  # Simulate a log transform or feature extraction
+
+    # Split data into train, validation, and test sets
+    X_train, X_temp, y_train, y_temp = train_test_split(X_preprocessed, y, test_size=0.3, stratify=y, random_state=42)
+    X_val, X_test, y_val, y_test = train_test_split(X_temp, y_temp, test_size=0.5, stratify=y_temp, random_state=42)
+
+    print(f"[DEBUG] Data split: Training={X_train.shape}, Validation={X_val.shape}, Test={X_test.shape}")
+
+    # Expand dimensions for 2D CNN input
+    X_train = np.expand_dims(X_train, axis=-1)
+    X_val = np.expand_dims(X_val, axis=-1)
+    X_test = np.expand_dims(X_test, axis=-1)
+
+    print("[DEBUG] Initializing 2D CNN model...")
+    model = track_experiment_with_mlflow_and_optuna(
+        mode='mfcc',
+        num_classes=1,
+        model_type='2D',  # Specify 2D CNN for MFCC and Log-Mel
+        classification_mode='binary',
+        X_train=X_train,
+        y_train=y_train,
+        X_val=X_val,
+        y_val=y_val,
+        n_trials=20,         
+    )
+
+    print("[DEBUG] Training the model...")
+    # Train the model with a single epoch for testing
+    model.fit(X_train, y_train, validation_data=(X_val, y_val), epochs=1, batch_size=32)
+
+    print("[DEBUG] Evaluating the model...")
+    results = model.evaluate(X_test, y_test)
+    print(f"[DEBUG] Test evaluation results: {results}")
+
+
+# Define main function
 def main():
-    data_logger.info("Starting data pipeline.")
+    # python Train.py --metadata_path data/Respiratory_Sound_Database/audio_and_txt_files --audio_files_path data/Respiratory_Sound_Database/audio_and_txt_filesv --demographic_path data/demographic_info.tx --diagnosis_path --diagnosis_path data/Respiratory_Sound_Database/patient_diagnosis.csv --classification_modes binary --feature_types mfcc 
+
+    parser = argparse.ArgumentParser(description="Run the respiratory sound analysis pipeline.")
+    parser.add_argument("--metadata_path", type=str, default="./data/metadata", help="Path to the metadata directory.")
+    parser.add_argument("--audio_files_path", type=str, default="./data/audio", help="Path to the directory containing audio files.")
+    parser.add_argument("--demographic_path", type=str, default="./data/demographic_info.txt", help="Path to the demographic info file.")
+    parser.add_argument("--diagnosis_path", type=str, default="./data/patient_diagnosis.csv", help="Path to the patient diagnosis CSV file.")
+    parser.add_argument("--tracking_uri", type=str, default="./mlruns", help="MLflow tracking URI.")
+    parser.add_argument("--classification_modes", type=str, nargs='+', default=['multi', 'binary'], help="Classification modes to run. Options: 'binary', 'multi'.")
+    parser.add_argument("--feature_types", type=str, nargs='+', default=['mfcc'], help="Feature types to use. Options: 'mfcc', 'log_mel', 'augmented'.")
+    parser.add_argument("--debug", action='store_true', help="Run in debug mode with random test data.")
+    args = parser.parse_args()
+
+
+    if args.debug:
+        test_model()
+        return
+
+    # Set up directories and MLflow tracking
+    AUDIO_FILES_PATH = args.audio_files_path
+    mlflow.set_tracking_uri(args.tracking_uri)
 
-    # Step 1: Load and preprocess data
+    # Logging initial information
+    data_logger.info("Starting data pipeline.")
     data_logger.info("Loading and preprocessing data...")
-    df = load_data()
-    audio_metadata = process_audio_metadata(METADATA_PATH)
+
+    # Load and preprocess data
+    df = load_data(
+        diagnosis_path=args.diagnosis_path,
+        demographic_path=args.demographic_path
+    )
+    audio_metadata = process_audio_metadata(AUDIO_FILES_PATH)
     df_all = merge_datasets(audio_metadata, df)
 
-    # Define classification modes and feature types
-    classification_modes = [ 'multi', 'binary']#
-    feature_types = [ 'augmented','mfcc', 'log_mel'] #, 
+    models = []
 
-    for classification_mode in classification_modes:
-        # Preprocess dataset for binary or multi-class classification
+    for classification_mode in args.classification_modes:
+        # Preprocess dataset for classification mode
         df_filtered = filter_and_sample_data(df_all, mode=classification_mode)
+        processing_logger.info(f"Dataset shape for {classification_mode} mode: {df_filtered.shape}")
 
-        for feature_type in feature_types:
-            processing_logger.info(f"Preparing dataset for {classification_mode} classification with {feature_type} features.")
+        for feature_type in args.feature_types:
+            processing_logger.info(f"Running experiment for {classification_mode} classification with {feature_type} features.")
             
             # Load or process dataset
-            X, y, le = load_or_process_dataset(df_filtered, AUDIO_FILES_PATH, feature_type, output_dir=f"processed_datasets/{classification_mode}")
-
-            # Log input dimensions
-            processing_logger.info(f"Input data dimensions for {feature_type}: {X.shape}")
-            processing_logger.info(f"Output data dimensions for {feature_type}: {y.shape}")
-
-            # Split dataset
-            processing_logger.info("Splitting dataset...")
-            X_train, X_val, X_test, y_train, y_val, y_test = split_dataset(X, y)
-
-            # Check for class balance
-            unique_classes, class_counts = np.unique(np.argmax(y_train, axis=1), return_counts=True)
-            processing_logger.info(f"Class distribution before oversampling: {dict(zip(unique_classes, class_counts))}")
+            X, y, le = load_or_process_dataset(
+                df_filtered, AUDIO_FILES_PATH,
+                feature_type=feature_type,
+                mode=classification_mode,
+                output_dir=f"processed_datasets/{classification_mode}"
+            )
+
+            # Split data into train/val/test
+            X_train, X_temp, y_train, y_temp = train_test_split(X, y, test_size=0.3, stratify=y, random_state=42)
+            X_val, X_test, y_val, y_test = train_test_split(X_temp, y_temp, test_size=0.5, stratify=y_temp, random_state=42)
+
+            # Save test data for future evaluation
+            np.save(f"X_test_{classification_mode}_{feature_type}.npy", X_test)
+            np.save(f"y_test_{classification_mode}_{feature_type}.npy", y_test)
+            mlflow.log_artifact(f"X_test_{classification_mode}_{feature_type}.npy")
+            mlflow.log_artifact(f"y_test_{classification_mode}_{feature_type}.npy")
+
+            # Log dataset characteristics
+            log_class_distribution(y_train, "Before Oversampling")
+            processing_logger.info(f"Train size: {X_train.shape}, Validation size: {X_val.shape}, Test size: {X_test.shape}")
 
             try:
                 X_train, y_train = oversample_data(X_train, y_train)
-                unique_classes, class_counts = np.unique(np.argmax(y_train, axis=1), return_counts=True)
-                processing_logger.info(f"Class distribution after oversampling: {dict(zip(unique_classes, class_counts))}")
             except ValueError as e:
                 processing_logger.warning(f"SMOTE skipped: {e}")
-
-
-            # Log dimensions after preprocessing
-            processing_logger.info(f"Training data dimensions for {feature_type}: X_train={X_train.shape}, y_train={y_train.shape}")
-            processing_logger.info(f"Validation data dimensions for {feature_type}: X_val={X_val.shape}, y_val={y_val.shape}")
-            processing_logger.info(f"Test data dimensions for {feature_type}: X_test={X_test.shape}, y_test={y_test.shape}")
-
-            # Train and optimize model
-            model_logger.info(f"Running optimization for {feature_type} mode...")
-            
-            if feature_type == 'augmented':  # Train 1D CNN for GRU features
-                X_train = np.expand_dims(X_train, axis=-1)
-                X_val = np.expand_dims(X_val, axis=-1)
-                X_test = np.expand_dims(X_test, axis=-1)
-
-                model_logger.info(f"Updated 1D CNN Input dimensions: X_train={X_train.shape}, X_val={X_val.shape}, X_test={X_test.shape}")
-
-                best_params = run_optuna_optimization(
-                    model_type="1D",
-                    input_shape=X_train.shape[1:],
-                    num_classes=y_train.shape[1],
-                    X_train=X_train,
-                    y_train=y_train,
-                    X_val=X_val,
-                    y_val=y_val,
-                    n_trials=20
-                )
-                best_model = build_cnn_model(
-                    input_shape=X_train.shape[1:],
-                    n_filters=best_params["n_filters"],
-                    dense_units=best_params["dense_units"],
-                    dropout_rate=best_params["dropout_rate"],
-                    num_classes=y_train.shape[1],
-                    model_type="1D"
-                )
-            else:  # Train 2D CNN for MFCC and Log-Mel
-                best_params = run_optuna_optimization(
-                    model_type="2D",
-                    input_shape=X_train.shape[1:],
-                    num_classes=y_train.shape[1],
-                    X_train=X_train,
-                    y_train=y_train,
-                    X_val=X_val,
-                    y_val=y_val,
-                    n_trials=20
-                )
-                best_model = build_cnn_model(
-                    input_shape=X_train.shape[1:],
-                    n_filters=best_params["n_filters"],
-                    dense_units=best_params["dense_units"],
-                    dropout_rate=best_params["dropout_rate"],
-                    num_classes=y_train.shape[1],
-                    model_type="2D"
-                )
-
-            model_logger.info(f"Model input shape: {X_train.shape[1:]}")
-            model_logger.info(f"Number of output classes: {y_train.shape[1]}")
-
-            # Train and save the model
-            best_model.fit(X_train, y_train, validation_data=(X_val, y_val), epochs=10, batch_size=32)
-            model_path = f".models/best_model_{classification_mode}_{feature_type}.h5"
-            best_model.save(model_path)
-            mlflow.log_artifact(model_path)
-
-            # Evaluate model
-            y_pred = best_model.predict(X_test)
-            log_metrics(y_test, y_pred, f"{classification_mode}_{feature_type}")
-
-    data_logger.info("Pipeline completed successfully.")
-
+            log_class_distribution(y_train, "After Oversampling")
+
+            # Determine number of classes
+            num_classes = 1 if classification_mode == "binary" else y_train.shape[1]
+
+            # Train and save model
+            with mlflow.start_run(run_name=f"Experiment_{classification_mode}_{feature_type}", nested=True):
+                if feature_type == 'augmented':
+                    X_train = np.expand_dims(X_train, axis=-1)
+                    X_val = np.expand_dims(X_val, axis=-1)
+                    X_test = np.expand_dims(X_test, axis=-1)
+
+                    model = track_experiment_with_mlflow_and_optuna(
+                        mode=feature_type,
+                        num_classes=num_classes,
+                        model_type='1D',
+                        classification_mode=classification_mode,
+                        X_train=X_train,
+                        y_train=y_train,
+                        X_val=X_val,
+                        y_val=y_val,
+                        n_trials=20,
+                    )
+                else:
+                    model = track_experiment_with_mlflow_and_optuna(
+                        mode=feature_type,
+                        num_classes=num_classes,
+                        model_type='2D',
+                        classification_mode=classification_mode,
+                        X_train=X_train,
+                        y_train=y_train,
+                        X_val=X_val,
+                        y_val=y_val,
+                        n_trials=20,
+                    )
+
+                final_model_path = f"final_model_{classification_mode}_{feature_type}.h5"
+                model.save(final_model_path)
+                mlflow.log_artifact(final_model_path)
+                models.append(model)
+
+    processing_logger.info("All experiments completed successfully!")
 
 if __name__ == "__main__":
     main()
-

app.py

@@ -10,7 +10,7 @@ if "active_page" not in st.session_state:
     st.session_state["active_page"] = "Introduction"
 
 # Streamlit app setup
-st.title("ICBHI 2017 Challenge - Amplifier Health")
+st.title("ICBHI 2017 Challenge - Amplifier Health Take-home Assignment")
 
 # Sidebar Navigation
 st.sidebar.markdown('<div class="sidebar-header">Navigate</div>', unsafe_allow_html=True)

data/Respiratory_Sound_Database/testsample/115_1b1_Ar_sc_Meditron.txt

@@ -0,0 +1,24 @@
+0.064	0.393	0	0
+0.393	1.236	0	0
+1.236	2.193	0	0
+2.193	2.979	0	0
+2.979	3.922	0	0
+3.922	4.736	0	0
+4.736	5.664	0	0
+5.664	6.593	0	0
+6.593	7.393	0	0
+7.393	8.221	0	0
+8.221	9.236	0	0
+9.236	10.164	0	0
+10.164	10.836	0	1
+10.836	12.179	0	0
+12.179	13.007	0	0
+13.007	13.65	0	0
+13.65	14.593	0	0
+14.593	15.479	0	0
+15.479	16.321	0	0
+16.321	17.079	0	0
+17.079	17.879	0	0
+17.879	18.707	0	0
+18.707	19.55	0	0
+19.55	19.893	0	0

data/Respiratory_Sound_Database/testsample/115_1b1_Ar_sc_Meditron.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1a169cb80250e104970716bc6785803ad956e9fb3de4dc15540bcf5fac9b8d9b
+size 2646044

data/Respiratory_Sound_Database/testsample/121_1b1_Tc_sc_Meditron.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d65fd9b4aa09be36d9f731acd468621c39c3d20402930dbc79022f4d137a67b9
+size 2646044

data/Respiratory_Sound_Database/testsample/121_1p1_Tc_sc_Meditron.txt

@@ -0,0 +1,8 @@
+0.036	1.907	0	0
+1.907	4.521	0	0
+4.521	7.193	0	0
+7.193	9.75	0	0
+9.75	12.407	0	0
+12.407	15.079	0	0
+15.079	17.521	0	0
+17.521	19.95	0	0

data/Respiratory_Sound_Database/testsample/149_1b1_Al_sc_Meditron.txt

@@ -0,0 +1,18 @@
+0.007	0.807	0	0
+0.807	1.393	0	0
+1.393	2.15	0	1
+2.15	3.136	0	1
+3.136	4.193	1	1
+4.193	5.436	0	1
+5.436	6.636	0	0
+6.636	7.936	1	0
+7.936	9.364	0	1
+9.364	10.764	0	1
+10.764	12.121	0	1
+12.121	13.179	0	1
+13.179	14.15	0	1
+14.15	15.236	0	1
+15.236	16.45	0	1
+16.45	17.95	0	1
+17.95	19.179	1	1
+19.179	19.607	0	1

data/Respiratory_Sound_Database/testsample/149_1b1_Al_sc_Meditron.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6ed6fbf99d088fdb9bed679656c53af95b52a31e8e1839aef8fe0fc48d9e897e
+size 2646044

data/Respiratory_Sound_Database/testsample/157_1b1_Ar_sc_Meditron.txt

@@ -0,0 +1,12 @@
+1.9095	6.2217	0	0
+6.2217	14.007	0	0
+14.007	19.263	0	0
+19.263	26.209	0	0
+26.209	36.124	0	0
+36.124	47.329	0	0
+47.329	50.214	0	0
+50.214	53.299	0	0
+53.299	56.688	0	0
+56.688	59.636	0	0
+59.636	62.721	0	0
+62.721	65.05	0	0

data/Respiratory_Sound_Database/testsample/191_2b2_Tc_mc_LittC2SE.txt

@@ -0,0 +1,8 @@
+0.022	2.322	0	0
+2.322	4.964	0	0
+4.964	7.664	0	0
+7.664	10.007	0	0
+10.007	13.336	0	0
+13.336	16.164	0	0
+16.164	18.864	0	0
+18.864	19.821	0	0

data/Respiratory_Sound_Database/testsample/191_2b2_Tc_mc_LittC2SE.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a240a8f969713173f7ae42ef886c1ae9be49f376c5a5e717319e0f3f58176ca2
+size 2646044

data/Respiratory_Sound_Database/testsample/215_1b3_Tc_sc_Meditron.txt

@@ -0,0 +1,6 @@
+0.022	1.693	0	0
+1.693	6.022	0	0
+6.022	10.507	0	0
+10.507	14.664	0	0
+14.664	18.907	0	0
+18.907	19.964	0	0

data/Respiratory_Sound_Database/testsample/215_1b3_Tc_sc_Meditron.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2c3a93e837d51db7c65754a9fdd2adf66dfa8d72cb7b5a8a493146452c28b93c
+size 1764046

data/Respiratory_Sound_Database/testsample/patient_diagnosis.csv

@@ -0,0 +1,7 @@
+101,URTI
+115,LRTI
+121,Healthy
+149,Bronchiolitis
+157,COPD
+191,Pneumonia
+215,Bronchiectasis

requirements.txt

@@ -16,4 +16,6 @@ tensorflow
 tensorflow_intel
 tqdm
 fsspec
-prometheus_client
+prometheus_client
+argparse
+pytest

streamlit_ui/data_exploration.py

@@ -1,178 +1,205 @@
-import streamlit as st
-import pandas as pd
-import numpy as np
-import matplotlib.pyplot as plt
-import seaborn as sns
-import librosa
-import librosa.display
-import os
-from Exploration.inference import RespiratorySoundAnalysis
-
-# Define base paths
-BASE_PATH = './/data//Respiratory_Sound_Database'
-DIAGNOSIS_FILE = os.path.join(BASE_PATH, 'patient_diagnosis.csv')
-AUDIO_PATH = os.path.join(BASE_PATH, 'testsample')
-DEMOGRAPHIC_FILE = os.path.join('.//data', 'demographic_info.txt')
-
-# Initialize analysis object
-analysis = RespiratorySoundAnalysis(DIAGNOSIS_FILE, AUDIO_PATH)
-
-# Load data
-@st.cache_data
-def load_data():
-    analysis.load_diagnosis_data()
-    analysis.load_audio_files()
-    analysis.analyze_audio_properties()
-    return analysis.diagnosis_df, analysis.audio_df
-
-diagnosis_df, audio_df = load_data()
-
-# Load patient demographic data
-@st.cache_data
-def load_patient_demographics():
-    patient_df = pd.read_csv(
-        DEMOGRAPHIC_FILE, 
-        names=['Patient number', 'Age', 'Sex', 'Adult BMI (kg/m2)', 'Child Weight (kg)', 'Child Height (cm)'],
-        delimiter=' '
-    )
-    return patient_df
-
-patient_df = load_patient_demographics()
-
-# Streamlit App Function
-def run():
-    st.title("Respiratory Sound Data Explorer")
-
-    # Tabs for navigation
-    tabs = st.tabs(["Overview", "Explore Data", "Patient Demographics", "Preprocessing & Audio Effects"])
-
-    # Overview Tab
-    with tabs[0]:
-        st.header("Dataset Overview")
-
-        # Highlight key statistics
-        total_patients = len(diagnosis_df)
-        most_common_disease = diagnosis_df['disease'].value_counts().idxmax()
-        least_common_disease = diagnosis_df['disease'].value_counts().idxmin()
-
-        st.subheader("Key Statistics")
-        st.markdown(f"""
-        - **Total Patients:** {total_patients}
-        - **Most Common Disease:** {most_common_disease} ({diagnosis_df['disease'].value_counts().max()} patients)
-        - **Least Common Disease:** {least_common_disease} ({diagnosis_df['disease'].value_counts().min()} patients)
-        """)
-
-        # Diagnosis Distribution
-        st.subheader("Diagnosis Distribution")
-        disease_counts = diagnosis_df['disease'].value_counts()
-        fig, ax = plt.subplots(figsize=(10, 6))
-        sns.barplot(y=disease_counts.index, x=disease_counts.values, palette="viridis", ax=ax)
-        ax.set_title("Disease Distribution", fontsize=16, fontweight='bold')
-        ax.set_xlabel("Number of Patients", fontsize=12)
-        ax.set_ylabel("Disease", fontsize=12)
-        st.pyplot(fig)
-
-    # Explore Data Tab
-    with tabs[1]:
-        st.header("Explore Data")
-        shortest_file = os.path.basename(audio_df.loc[audio_df['duration_sec'].idxmin(), 'file_name'])
-        longest_file = os.path.basename(audio_df.loc[audio_df['duration_sec'].idxmax(), 'file_name'])
-
-        if audio_df is not None and not audio_df.empty:
-            st.subheader("Key Audio Insights")
-            st.markdown(f"""
-            - **Total Audio Files:** {len(audio_df)}
-            - **Average Duration:** {audio_df['duration_sec'].mean():.2f} seconds
-            - **Shortest Audio File:** {shortest_file} ({audio_df['duration_sec'].min():.2f} seconds)
-            - **Longest Audio File:** {longest_file} ({audio_df['duration_sec'].max():.2f} seconds)
-            """)
-
-            # Duration Distribution
-            st.subheader("Audio Duration Distribution")
-            fig, ax = plt.subplots(figsize=(10, 6))
-            sns.histplot(audio_df['duration_sec'], bins=20, kde=True, color='skyblue', ax=ax)
-            ax.set_title("Audio Duration Distribution", fontsize=16, fontweight='bold')
-            st.pyplot(fig)
-
-        else:
-            st.warning("No audio data available to display.")
-
-    # Patient Demographics Tab
-    with tabs[2]:
-        st.header("Patient Demographics")
-        st.dataframe(patient_df)
-
-        st.subheader("Missing Values Information")
-        st.write(patient_df.isna().sum())
-
-        st.subheader("Age Distribution")
-        fig, ax = plt.subplots(figsize=(10, 6))
-        sns.histplot(patient_df['Age'].dropna(), bins=20, kde=True, color='skyblue', ax=ax)
-        ax.set_title("Age Distribution", fontsize=16, fontweight='bold')
-        st.pyplot(fig)
-
-    # Preprocessing & Audio Effects Tab
-    with tabs[3]:
-        st.header("Preprocessing & Audio Effects")
-        wav_files = [f for f in os.listdir(AUDIO_PATH) if f.endswith('.wav')]
-
-        if wav_files:
-            selected_file_name = st.selectbox("Select an Audio File", wav_files)
-            file_path = os.path.join(AUDIO_PATH, selected_file_name)
-
-            try:
-                y_raw, sr = librosa.load(file_path)
-                st.audio(file_path, format="audio/wav")
-
-                # Raw Waveform
-                st.subheader("Raw Waveform")
-                fig, ax = plt.subplots(figsize=(10, 4))
-                librosa.display.waveshow(y_raw, sr=sr, ax=ax)
-                ax.set_title("Raw Waveform", fontsize=16, fontweight='bold')
-                st.pyplot(fig)
-
-                # Noise Filtering
-                st.subheader("Noise Filtering")
-                y_filtered = librosa.effects.preemphasis(y_raw)
-                fig, ax = plt.subplots(figsize=(10, 4))
-                librosa.display.waveshow(y_filtered, sr=sr, ax=ax)
-                ax.set_title("Filtered Waveform (Pre-emphasis Applied)", fontsize=16, fontweight='bold')
-                st.pyplot(fig)
-
-                # Log Mel-Spectrogram
-                st.subheader("Log Mel-Spectrogram")
-                mel_spect = librosa.feature.melspectrogram(y=y_filtered, sr=sr, n_mels=128)
-                mel_spect_db = librosa.power_to_db(mel_spect, ref=np.max)
-                fig, ax = plt.subplots(figsize=(10, 6))
-                img = librosa.display.specshow(mel_spect_db, sr=sr, x_axis='time', y_axis='mel', ax=ax, cmap='viridis')
-                fig.colorbar(img, ax=ax, format="%+2.0f dB")
-                ax.set_title("Log Mel-Spectrogram", fontsize=16, fontweight='bold')
-                st.pyplot(fig)
-
-                # Fast Fourier Transform (FFT)
-                st.subheader("FFT (Frequency Domain)")
-                fft_vals = np.abs(np.fft.fft(y_filtered))
-                freqs = np.fft.fftfreq(len(fft_vals), 1 / sr)
-                fig, ax = plt.subplots(figsize=(10, 4))
-                ax.plot(freqs[:len(freqs) // 2], fft_vals[:len(fft_vals) // 2], color='blue')
-                ax.set_title("FFT - Frequency Spectrum", fontsize=16, fontweight='bold')
-                ax.set_xlabel("Frequency (Hz)")
-                ax.set_ylabel("Amplitude")
-                st.pyplot(fig)
-
-                # Zero Crossing Rate
-                st.subheader("Zero Crossing Rate")
-                zcr = librosa.feature.zero_crossing_rate(y_filtered)[0]
-                fig, ax = plt.subplots(figsize=(10, 4))
-                ax.plot(zcr, color='orange')
-                ax.set_title("Zero Crossing Rate Over Time", fontsize=16, fontweight='bold')
-                ax.set_xlabel("Frame Index")
-                ax.set_ylabel("Zero Crossing Rate")
-                st.pyplot(fig)
-
-            except Exception as e:
-                st.error(f"Error processing audio file: {e}")
-
-        else:
-            st.warning("No audio files found in the directory.")
-
+import streamlit as st
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+import librosa
+import librosa.display
+import os
+from Exploration.inference import RespiratorySoundAnalysis
+
+# Define base paths
+BASE_PATH = './/data//Respiratory_Sound_Database'
+DIAGNOSIS_FILE = os.path.join(BASE_PATH, 'patient_diagnosis.csv')
+AUDIO_PATH = os.path.join(BASE_PATH, 'testsample')
+DEMOGRAPHIC_FILE = os.path.join('.//data', 'demographic_info.txt')
+
+# Initialize analysis object
+analysis = RespiratorySoundAnalysis(DIAGNOSIS_FILE, AUDIO_PATH)
+
+# Load data
+@st.cache_data
+def load_data():
+    analysis.load_diagnosis_data()
+    analysis.load_audio_files()
+    analysis.analyze_audio_properties()
+    return analysis.diagnosis_df, analysis.audio_df
+
+diagnosis_df, audio_df = load_data()
+
+# Load patient demographic data
+@st.cache_data
+def load_patient_demographics():
+    patient_df = pd.read_csv(
+        DEMOGRAPHIC_FILE, 
+        names=['Patient number', 'Age', 'Sex', 'Adult BMI (kg/m2)', 'Child Weight (kg)', 'Child Height (cm)'],
+        delimiter=' '
+    )
+    return patient_df
+
+patient_df = load_patient_demographics()
+
+# Streamlit App Function
+def run():
+    st.title("Respiratory Sound Data Explorer")
+
+    # Tabs for navigation
+    tabs = st.tabs(["Overview", "Explore Data", "Patient Demographics", "Preprocessing & Audio Effects"])
+
+    # Overview Tab
+    with tabs[0]:
+        st.header("Dataset Overview")
+
+        # Highlight key statistics
+        total_patients = len(diagnosis_df)
+        most_common_disease = diagnosis_df['disease'].value_counts().idxmax()
+        least_common_disease = diagnosis_df['disease'].value_counts().idxmin()
+
+        st.subheader("Key Statistics")
+        st.markdown(f"""
+        - **Total Patients:** {total_patients}
+        - **Most Common Disease:** {most_common_disease} ({diagnosis_df['disease'].value_counts().max()} patients)
+        - **Least Common Disease:** {least_common_disease} ({diagnosis_df['disease'].value_counts().min()} patients)
+        """)
+
+        # Diagnosis Distribution
+        st.subheader("Diagnosis Distribution")
+        disease_counts = diagnosis_df['disease'].value_counts()
+        fig, ax = plt.subplots(figsize=(10, 6))
+        sns.barplot(y=disease_counts.index, x=disease_counts.values, palette="viridis", ax=ax)
+        ax.set_title("Disease Distribution", fontsize=16, fontweight='bold')
+        ax.set_xlabel("Number of Patients", fontsize=12)
+        ax.set_ylabel("Disease", fontsize=12)
+        st.pyplot(fig)
+
+    # Explore Data Tab
+    with tabs[1]:
+        st.header("Explore Data")
+        shortest_file = os.path.basename(audio_df.loc[audio_df['duration_sec'].idxmin(), 'file_name'])
+        longest_file = os.path.basename(audio_df.loc[audio_df['duration_sec'].idxmax(), 'file_name'])
+
+        if audio_df is not None and not audio_df.empty:
+            st.subheader("Key Audio Insights")
+            st.markdown(f"""
+            - **Total Audio Files:** {len(audio_df)}
+            - **Average Duration:** {audio_df['duration_sec'].mean():.2f} seconds
+            - **Shortest Audio File:** {shortest_file} ({audio_df['duration_sec'].min():.2f} seconds)
+            - **Longest Audio File:** {longest_file} ({audio_df['duration_sec'].max():.2f} seconds)
+            """)
+
+            # Duration Distribution
+            st.subheader("Audio Duration Distribution")
+            fig, ax = plt.subplots(figsize=(10, 6))
+            sns.histplot(audio_df['duration_sec'], bins=20, kde=True, color='skyblue', ax=ax)
+            ax.set_title("Audio Duration Distribution", fontsize=16, fontweight='bold')
+            st.pyplot(fig)
+
+        else:
+            st.warning("No audio data available to display.")
+
+    # Patient Demographics Tab
+    with tabs[2]:
+        st.header("Patient Demographics")
+        st.dataframe(patient_df)
+
+        st.subheader("Missing Values Information")
+        st.write(patient_df.isna().sum())
+
+        st.subheader("Age Distribution")
+        fig, ax = plt.subplots(figsize=(10, 6))
+        sns.histplot(patient_df['Age'].dropna(), bins=20, kde=True, color='skyblue', ax=ax)
+        ax.set_title("Age Distribution", fontsize=16, fontweight='bold')
+        st.pyplot(fig)
+
+    # Preprocessing & Audio Effects Tab
+    with tabs[3]:
+        st.header("Preprocessing & Audio Effects")
+        # List all .wav files in the AUDIO_PATH directory
+        wav_files = [f for f in os.listdir(AUDIO_PATH) if f.endswith('.wav')]
+        
+        if wav_files:
+            selected_file_name = st.selectbox("Select an Audio File", wav_files)
+
+            # Construct the full path of the selected file
+            file_path = os.path.join(AUDIO_PATH, selected_file_name)
+
+            try:
+                # Load raw audio
+                y_raw, sr = librosa.load(file_path)
+            except Exception as e:
+                st.error(f"Error loading audio file: {e}")
+                st.stop()
+
+            # Preprocessing and Visualization
+            try:
+                y_processed, processed_sr = analysis.preprocess_audio(y_raw, sr)
+
+                # Mel spectrogram
+                mel = librosa.feature.melspectrogram(
+                    y=y_processed, sr=processed_sr, n_fft=2048, hop_length=512, power=2.0
+                )
+                mel_db = librosa.power_to_db(mel, ref=np.max)
+
+                # STFT
+                stft = librosa.stft(y_processed, n_fft=2048, hop_length=512)
+                stft_db = librosa.amplitude_to_db(np.abs(stft), ref=np.max)
+
+                # Frequency Spectrum
+                fft = np.abs(np.fft.rfft(y_processed))
+                freqs = np.fft.rfftfreq(len(y_processed), 1 / processed_sr)
+
+                # Zero-Crossing Rate
+                zcr = librosa.feature.zero_crossing_rate(y_processed)[0]
+
+                # RMS Energy
+                rms = librosa.feature.rms(y=y_processed)[0]
+
+                # Create subplots for visualizations
+                fig, axs = plt.subplots(3, 2, figsize=(15, 12))
+
+                # Raw waveform
+                librosa.display.waveshow(y_raw, sr=sr, ax=axs[0, 0])
+                axs[0, 0].set_title("Raw Waveform", fontsize=12)
+
+                # Preprocessed waveform
+                librosa.display.waveshow(y_processed, sr=processed_sr, ax=axs[0, 1])
+                axs[0, 1].set_title("Preprocessed Waveform", fontsize=12)
+
+                # Frequency spectrum
+                axs[1, 0].plot(freqs, fft, color='blue')
+                axs[1, 0].set_title("Frequency Spectrum", fontsize=12)
+                axs[1, 0].set_xlabel("Frequency (Hz)")
+                axs[1, 0].set_ylabel("Amplitude")
+
+                # ZCR
+                axs[1, 1].plot(zcr, color='green')
+                axs[1, 1].set_title("Zero-Crossing Rate", fontsize=12)
+                axs[1, 1].set_xlabel("Frames")
+                axs[1, 1].set_ylabel("Rate")
+
+                # RMS Energy
+                axs[2, 0].plot(rms, color='red')
+                axs[2, 0].set_title("RMS Energy", fontsize=12)
+                axs[2, 0].set_xlabel("Frames")
+                axs[2, 0].set_ylabel("RMS")
+
+                # Mel spectrogram
+                img_mel = librosa.display.specshow(
+                    mel_db, sr=processed_sr, x_axis='time', y_axis='mel', ax=axs[2, 1], cmap='viridis'
+                )
+                axs[2, 1].set_title("Mel Spectrogram", fontsize=12)
+                fig.colorbar(img_mel, ax=axs[2, 1], format="%+2.0f dB")
+
+                # Adjust layout
+                plt.tight_layout()
+                st.pyplot(fig)
+
+            except Exception as e:
+                st.error(f"Error during audio preprocessing or visualization: {e}")
+                st.stop()
+
+            # Play audio
+            st.subheader("Listen to Audio")
+            st.audio(file_path, format="audio/wav")
+        else:
+            st.warning("No audio files found in the directory.")

streamlit_ui/readme.py

@@ -4,7 +4,7 @@ def run():
     st.title("Welcome!")
     st.subheader("Introduction")
     st.write("""
-This project involves developing a machine learning solution to classify respiratory sounds into diagnostic categories using the ICBHI 2017 Challenge Dataset. 
+This project involves developing a ML model to classify respiratory sounds into diagnostic categories using the ICBHI 2017 Challenge Dataset. 
 The pipeline includes data preprocessing, feature extraction, model training, evaluation, and deployment. """)
     
     st.image("./streamlit_ui/img/deployment.png", caption="Project Overview")
@@ -15,7 +15,7 @@ The pipeline includes data preprocessing, feature extraction, model training, ev
  
     st.write(""" ### Repository:
     You can access the GitHub repository for this project here:
-    [GitHub Repository](https://github.com/your-repo-link) """)
+    [GitHub Repository](https://github.com/magnumical/amp1) """)
 
     st.write(""" ### Contact:
     Developed by Reza Amini | magnumical.ca  

utils/audioprocessing.py

@@ -8,7 +8,8 @@ from sklearn.preprocessing import LabelEncoder
 from keras.utils import to_categorical
 import logging
 from utils.augmentation import add_noise, shift, stretch, pitch_shift  # Ensure augmentation functions are imported
-from keras.utils import to_categorical, normalize
+from keras.utils import normalize
+from scipy.signal import butter, sosfilt
 
 
 from imblearn.over_sampling import RandomOverSampler
@@ -19,78 +20,85 @@ from imblearn.over_sampling import SMOTE
 # Initialize logger
 processing_logger = logging.getLogger("audio_processing")
 
-
 def process_audio_file(soundDir, audio_files_path, df_filtered):
     """
     Process a single audio file: extract MFCC features and augment with noise, stretching, and shifting.
-
-    Args:
-        soundDir: Filename of the audio file.
-        audio_files_path: Path to the directory containing audio files.
-        df_filtered: Filtered DataFrame containing patient diagnosis and metadata.
-
-    Returns:
-        Tuple containing features (X_local) and labels (y_local).
+    
     """
     X_local = []
     y_local = []
-    features = 52  # Number of MFCC features
+    features = 52
 
-    try:
-        # Extract patient ID and disease from filename and DataFrame
-        patient_id = int(soundDir.split('_')[0])
-        disease = df_filtered.loc[df_filtered['Patient number'] == patient_id, 'Diagnosis'].values[0]
+    # Extract patient ID and disease from filename and DataFrame
+    patient_id = int(soundDir.split('_')[0])
+    disease = df_filtered.loc[df_filtered['Patient number'] == patient_id, 'Diagnosis'].values[0]
 
-        # Load audio file
-        data_x, sampling_rate = librosa.load(os.path.join(audio_files_path, soundDir), sr=None)
-        mfccs = np.mean(librosa.feature.mfcc(y=data_x, sr=sampling_rate, n_mfcc=features).T, axis=0)
-        X_local.append(mfccs)
+    # Load audio file
+    data_x, sampling_rate = librosa.load(os.path.join(audio_files_path, soundDir), sr=None)
+    data_x = preprocess_audio(data_x, sampling_rate)  # Apply filtering
+
+    
+    mfccs = np.mean(librosa.feature.mfcc(y=data_x, sr=sampling_rate, n_mfcc=features).T, axis=0)
+    X_local.append(mfccs)
+    y_local.append(disease)
+
+    # Data augmentation
+    for augmentation in [add_noise, shift, stretch, pitch_shift]:
+        if augmentation == add_noise:
+            augmented_data = augmentation(data_x, 0.001)
+        elif augmentation == shift:
+            augmented_data = augmentation(data_x, 1600)
+        elif augmentation == stretch:
+            augmented_data = augmentation(data_x, 1.2)
+        elif augmentation == pitch_shift:
+            augmented_data = augmentation(data_x, sampling_rate, 3)
+
+        mfccs_augmented = np.mean(librosa.feature.mfcc(y=augmented_data, sr=sampling_rate, n_mfcc=features).T, axis=0)
+        X_local.append(mfccs_augmented)
         y_local.append(disease)
 
-        # Apply augmentations
-        augmentations = [
-            (add_noise, {"x": 0.001}),
-            (shift, {"x": 1600}),
-            (stretch, {"rate": 1.2}),
-            (pitch_shift, {"rate": 3}),
-        ]
+    return X_local, y_local
 
-        for func, kwargs in augmentations:
-            augmented_data = func(data_x, **kwargs)
-            mfccs_augmented = np.mean(librosa.feature.mfcc(y=augmented_data, sr=sampling_rate, n_mfcc=features).T, axis=0)
-            X_local.append(mfccs_augmented)
-            y_local.append(disease)
 
-    except Exception as e:
-        processing_logger.error(f"Error processing file {soundDir}: {e}")
+def preprocess_audio(audio, sr):
+    """
+    Apply a bandpass filter to audio data.
+    
+    """
+    # Define cutoff frequencies
+    low_cutoff = 50  # 50 Hz
+    high_cutoff = min(5000, sr / 2 - 1)  # Ensure it is below Nyquist frequency
 
-    return X_local, y_local
+    if low_cutoff >= high_cutoff:
+        raise ValueError(
+            f"Invalid filter range: low_cutoff={low_cutoff}, high_cutoff={high_cutoff} for sampling rate {sr}"
+        )
 
+    # Design a bandpass filter
+    sos = butter(N=10, Wn=[low_cutoff, high_cutoff], btype='band', fs=sr, output='sos')
 
-def mfccs_feature_extraction(audio_files_path, df_filtered, n_jobs=-1):
-    """
-    Extract MFCC features from audio data and augment with noise, stretching, and shifting in parallel.
+    # Apply the filter
+    filtered_audio = sosfilt(sos, audio)
+    return filtered_audio
 
-    Args:
-        audio_files_path: Path to the directory containing audio files.
-        df_filtered: Filtered DataFrame containing patient diagnosis and metadata.
-        n_jobs: Number of parallel jobs (-1 to use all available cores).
 
-    Returns:
-        X_data: Array of features extracted from the audio files.
-        y_data: Array of target labels.
+def mfccs_feature_extraction(audio_files_path, df_filtered, n_jobs=-1):
+    """
+    Make the process of MFCC feature extraction faster by running jobs in-parallel
+    
+    Returns array of features extracted from the audio files and Array of target labels.
     """
     processing_logger.info(f"Processing audio files in: {audio_files_path}")
     files = [file for file in os.listdir(audio_files_path) if file.endswith('.wav') and file[:3] not in ['103', '108', '115']]
-    #files = files[:40]  # DEBUG limit, adjust as needed
+   
+    #files = files[:30] ## DEBUG
 
     # Use Parallel and delayed to process files in parallel
-    results = Parallel(n_jobs=n_jobs, backend="loky")(
-        delayed(process_audio_file)(file, audio_files_path, df_filtered) for file in tqdm(files, desc="Processing audio files")
-    )
+    results = Parallel(n_jobs=n_jobs, backend="loky")(delayed(process_audio_file)(file, audio_files_path, df_filtered) for file in tqdm(files, desc="Processing audio files"))
 
     # Flatten results
-    X_, y_ = [], []
+    X_ = []
+    y_ = []
     for X_local, y_local in results:
         X_.extend(X_local)
         y_.extend(y_local)
@@ -101,9 +109,9 @@ def mfccs_feature_extraction(audio_files_path, df_filtered, n_jobs=-1):
     return X_data, y_data
 
 
-def prepare_dataset_augmented(df_filtered, audio_files_path):
-    """Prepare the dataset using the GRU pipeline."""
-    processing_logger.info("Preparing dataset with GRU pipeline.")
+def prepare_dataset_augmented(df_filtered, audio_files_path, classification_mode):
+    """Prepare the dataset for augmented features. it will be 1D array"""
+    processing_logger.info("Preparing dataset with AUGMENTED pipeline.")
     
     # Extract features and labels
     X, y = mfccs_feature_extraction(audio_files_path, df_filtered)
@@ -111,46 +119,44 @@ def prepare_dataset_augmented(df_filtered, audio_files_path):
     # Apply label encoding
     le = LabelEncoder()
     y_encoded = le.fit_transform(np.array(y))  # Encode labels to integers
-    y_one_hot = to_categorical(y_encoded)      # Convert to one-hot encoding
-    
-    # Log the mapping of one-hot encoding to class labels
-    print("One-hot encoding mapping:")
-    for idx, label in enumerate(le.classes_):
-        print(f"{idx} -> {label}")
-    
-    processing_logger.info("Dataset preparation with GRU pipeline complete.")
-    return X, y_one_hot, le
 
+    if classification_mode == "binary":
+        # Use single column with 0 and 1 for binary classification
+        processing_logger.info("Binary classification mode: Using single column labels (0/1).")
+        y_processed = y_encoded  # No one-hot encoding
+    else:
+        # One-hot encode labels for multi-class classification
+        processing_logger.info("Multi-class classification mode: Applying one-hot encoding.")
+        y_processed = to_categorical(y_encoded)
+
+        # Log the mapping of one-hot encoding to class labels
+        print("One-hot encoding mapping:")
+        for idx, label in enumerate(le.classes_):
+            print(f"{idx} -> {label}")
+    
+    processing_logger.info("Dataset preparation with augmented pipeline complete.")
+    return X, y_processed, le
 
 
 def process_audio_metadata(folder_path):
-    """
-    Extract audio metadata from filenames.
-
-    Args:
-        folder_path: Path to the folder containing metadata files.
-
-    Returns:
-        Metadata DataFrame.
-    """
+    """Extract audio metadata from filenames."""
     processing_logger.info("Extracting audio metadata from filenames.")
     data = []
     for filename in os.listdir(folder_path):
         if filename.endswith('.txt'):
             parts = filename.split('_')
-            try:
-                data.append({
-                    'Patient number': int(parts[0]),
-                    'Recording index': parts[1],
-                    'Chest location': parts[2],
-                    'Acquisition mode': parts[3],
-                    'Recording equipment': parts[4].split('.')[0],
-                })
-            except (IndexError, ValueError) as e:
-                processing_logger.warning(f"Skipping file {filename}: {e}")
+            data.append({
+                'Patient number': int(parts[0]),
+                'Recording index': parts[1],
+                'Chest location': parts[2],
+                'Acquisition mode': parts[3],
+                'Recording equipment': parts[4].split('.')[0]
+            })
     processing_logger.info("Audio metadata extraction complete.")
     return pd.DataFrame(data)
 
+
+
 def merge_datasets(df1, df2):
     """Merge metadata and diagnosis data."""
     processing_logger.info("Merging metadata and diagnosis data.")
@@ -159,16 +165,14 @@ def merge_datasets(df1, df2):
     processing_logger.info("Merging complete.")
     return merged_df
 
+
+
+
 def filter_and_sample_data(df, mode='binary'):
     """
     Filter and sample the dataset for binary or multi-class classification.
 
-    Args:
-        df: Input DataFrame containing diagnosis data.
-        mode: Specify 'binary' for Normal/Abnormal or 'multi-class' for grouped classes.
-
-    Returns:
-        Filtered and processed DataFrame.
+    Returns filtered and processed DataFrame.
     """
     processing_logger.info(f"Filtering and sampling the dataset for {mode} classification.")
     
@@ -177,6 +181,7 @@ def filter_and_sample_data(df, mode='binary'):
         df['Diagnosis'] = df['Diagnosis'].apply(lambda x: 'Normal' if x == 'Healthy' else 'Abnormal')
     elif mode == 'multi':
         # Multi-class classification: Group classes
+        # I grouped disease based on their similarities
         processing_logger.info("Grouping classes for multi-class classification.")
         df['Diagnosis'] = df['Diagnosis'].replace({
             'Healthy': 'Normal',
@@ -198,27 +203,13 @@ def filter_and_sample_data(df, mode='binary'):
     processing_logger.info(f"Filtering and sampling complete with mode={mode}.")
     return df
 
-from imblearn.over_sampling import SMOTE
-from tensorflow.keras.utils import to_categorical
-import numpy as np
 
-def oversample_data(X, y, random_state=42, k_neighbors=5):
-    """
-    Apply SMOTE to balance classes for both binary and multi-class cases.
-    
-    Args:
-        X: Feature data.
-        y: One-hot encoded labels.
-        random_state: Random seed for reproducibility.
-        k_neighbors: Number of nearest neighbors for SMOTE.
-    
-    Returns:
-        Oversampled feature data and labels.
-    """
+def oversample_data(X, y):
+    """Apply SMOTE to balance classes."""
     processing_logger.info("Applying SMOTE to balance classes.")
     
     # Save the original shape of features
-    original_shape = X.shape[1:]
+    original_shape = X.shape[1:]  
     
     # Flatten for SMOTE processing
     X = X.reshape((X.shape[0], -1))
@@ -226,49 +217,24 @@ def oversample_data(X, y, random_state=42, k_neighbors=5):
     # Convert one-hot encoded labels to integers
     y = np.argmax(y, axis=1)
     
-    # Log original class distribution
-    unique_classes, class_counts = np.unique(y, return_counts=True)
-    processing_logger.info(f"Original class distribution: {dict(zip(unique_classes, class_counts))}")
+    # Apply SMOTE
+    smote = SMOTE(random_state=42)
+    X_resampled, y_resampled = smote.fit_resample(X, y)
+    
+    # Reshape back to the original dimensions
+    X_resampled = X_resampled.reshape((-1, *original_shape))
+    
+    # Convert labels back to one-hot encoding
+    y_resampled = to_categorical(y_resampled)
     
-    try:
-        # Apply SMOTE
-        smote = SMOTE(random_state=random_state, k_neighbors=k_neighbors)
-        X_resampled, y_resampled = smote.fit_resample(X, y)
-        
-        # Log new class distribution
-        unique_classes, class_counts = np.unique(y_resampled, return_counts=True)
-        processing_logger.info(f"New class distribution after SMOTE: {dict(zip(unique_classes, class_counts))}")
-        
-        # Reshape back to the original dimensions
-        X_resampled = X_resampled.reshape((-1, *original_shape))
-        
-        # Convert labels back to one-hot encoding
-        y_resampled = to_categorical(y_resampled)
-        
-        processing_logger.info("SMOTE oversampling complete.")
-        return X_resampled, y_resampled
-    except ValueError as e:
-        processing_logger.warning(f"SMOTE could not be applied: {e}")
-        return X, to_categorical(y)  # Return original data if SMOTE fails
-
-
-
-
-def augment_data(X, y):
-    """Apply data augmentation to increase dataset size."""
-    processing_logger.info("Applying data augmentation.")
-    datagen = ImageDataGenerator(
-        rotation_range=10,
-        width_shift_range=0.1,
-        height_shift_range=0.1,
-        horizontal_flip=True
-    )
-    datagen.fit(X)
-    processing_logger.info("Data augmentation setup complete.")
-    return datagen
-
-
-def prepare_dataset_parallel(df, audio_files_path, mode):
+    processing_logger.info("SMOTE oversampling complete.")
+    return X_resampled, y_resampled
+
+
+
+
+
+def prepare_dataset_parallel(df, audio_files_path, mode, classification_mode):
     """Prepare the dataset by extracting features from audio files in parallel."""
     processing_logger.info(f"Preparing dataset using {mode} features in parallel.")
     results = Parallel(n_jobs=-1)(delayed(preprocess_file)(row, audio_files_path, mode) for _, row in tqdm(df.iterrows(), total=len(df)))
@@ -277,12 +243,23 @@ def prepare_dataset_parallel(df, audio_files_path, mode):
     X = np.array(X)
     X = np.expand_dims(X, axis=-1)  # Add channel dimension
     X = normalize(X, axis=1)
+    
     le = LabelEncoder()
-    y = to_categorical(le.fit_transform(np.array(y)))
+    y_encoded = le.fit_transform(np.array(y))  # Encode labels
+
+    if classification_mode == "binary":
+        # Use single column with 0 and 1 for binary classification
+        processing_logger.info("Binary classification mode: Using single column labels (0/1).")
+        y = y_encoded  # No one-hot encoding
+    else:
+        # One-hot encode labels for multi-class classification
+        processing_logger.info("Multi-class classification mode: Applying one-hot encoding.")
+        y = to_categorical(y_encoded)
 
     processing_logger.info(f"Dataset preparation using {mode} complete.")
     return X, y, le
 
+
 def preprocess_file(row, audio_files_path, mode):
     """Preprocess a single audio file."""
     file_path = os.path.join(audio_files_path, row['audio_file_name'])
@@ -294,7 +271,7 @@ def preprocessing(audio_file, mode):
     """Preprocess audio file by resampling, padding/truncating, and extracting features."""
     sr_new = 16000  # Resample audio to 16 kHz
     x, sr = librosa.load(audio_file, sr=sr_new)
-
+    x = preprocess_audio(x, sr)
     # Padding or truncating to 5 seconds (5 * sr_new samples)
     max_len = 5 * sr_new
     if x.shape[0] < max_len:
@@ -303,6 +280,7 @@ def preprocessing(audio_file, mode):
         x = x[:max_len]
 
     # Extract features
+    # I understand the common choice for n_mfcc is 13, but here i assumed we need to capture more informationm, therefore I choose 20.
     if mode == 'mfcc':
         feature = librosa.feature.mfcc(y=x, sr=sr_new, n_mfcc=20)  # Ensure consistent shape
     elif mode == 'log_mel':
@@ -311,22 +289,4 @@ def preprocessing(audio_file, mode):
 
     return feature
 
-def prepare_dataset(df, audio_files_path, mode):
-    """Prepare the dataset by extracting features from audio files."""
-    processing_logger.info(f"Preparing dataset using {mode} features.")
-    X, y = [], []
-    for _, row in tqdm(df.iterrows(), total=len(df)):
-        file_path = os.path.join(audio_files_path, row['audio_file_name'])
-        feature = preprocessing(file_path, mode)
-        X.append(feature)
-        y.append(row['Diagnosis'])
-        del feature  # Free memory after processing each file
-        gc.collect()
-
-    X = np.array(X)
-    X = np.expand_dims(X, axis=-1)  # Add channel dimension
-    X = normalize(X, axis=1)
-    le = LabelEncoder()
-    y = to_categorical(le.fit_transform(np.array(y)))
-    processing_logger.info(f"Dataset preparation using {mode} complete.")
-    return X, y, le
+    

utils/data_loader.py

@@ -8,22 +8,29 @@ logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(
 data_logger = logging.getLogger("data_pipeline")
 
 
-def load_data():
+def load_data(diagnosis_path='.//data//Respiratory_Sound_Database//patient_diagnosis.csv',
+              demographic_path='.//data//demographic_info.txt'):
     """Load patient diagnosis and demographic data."""
     data_logger.info("Loading patient diagnosis and demographic data.")
-    diagnosis_df = pd.read_csv('D://github//AmpleHealth//data//Respiratory_Sound_Database//patient_diagnosis.csv', 
+    
+    # Load diagnosis data
+    diagnosis_df = pd.read_csv(diagnosis_path, 
                                names=['Patient number', 'Diagnosis'])
 
-    patient_df = pd.read_csv('D://github//AmpleHealth//data//demographic_info.txt', 
+    # Load demographic data
+    patient_df = pd.read_csv(demographic_path, 
                              names=['Patient number', 'Age', 'Sex', 'Adult BMI (kg/m2)', 'Child Weight (kg)', 'Child Height (cm)'],
                              delimiter=' ')
 
     data_logger.info("Data successfully loaded.")
+    
+    # Merge and return
     return pd.merge(left=patient_df, right=diagnosis_df, how='left')
 
+
 def process_audio_metadata(folder_path):
     """Extract audio metadata from filenames."""
-    data_logger.info("Extracting audio metadata from filenames.")
+    processing_logger.info("Extracting audio metadata from filenames.")
     data = []
     for filename in os.listdir(folder_path):
         if filename.endswith('.txt'):
@@ -35,5 +42,5 @@ def process_audio_metadata(folder_path):
                 'Acquisition mode': parts[3],
                 'Recording equipment': parts[4].split('.')[0]
             })
-    data_logger.info("Audio metadata extraction complete.")
+    processing_logger.info("Audio metadata extraction complete.")
     return pd.DataFrame(data)

utils/evaluation.py

@@ -1,49 +1,25 @@
 from sklearn.metrics import classification_report
 import mlflow
-
+    
+import matplotlib.pyplot as plt
+from sklearn.metrics import roc_curve, roc_auc_score
+import numpy as np
  
 import numpy as np
 
-def log_metrics(y_true, y_pred, mode):
-    """
-    Log evaluation metrics for binary or multi-class classification.
 
-    Args:
-        y_true: True labels (array-like, one-hot encoded for multi-class).
-        y_pred: Predicted probabilities (array-like, continuous values).
-        mode: Mode of classification ('binary' or 'multi-class').
-    """
-    # Convert one-hot encoded `y_true` to class indices
-    if y_true.ndim > 1:  # If one-hot encoded
-        y_true = np.argmax(y_true, axis=1)
-    
-    # Convert predicted probabilities `y_pred` to class indices
-    if y_pred.ndim > 1:  # If predicted as probabilities
-        y_pred = np.argmax(y_pred, axis=1)
-
-    if mode == 'binary':
-        class_names = ["Class 0", "Class 1"]
-        classification = classification_report(y_true, y_pred, output_dict=True, target_names=class_names)
-    else:
-        unique_classes = np.unique(y_true)
-        class_names = [f"Class {i}" for i in unique_classes]
-        classification = classification_report(y_true, y_pred, output_dict=True, target_names=class_names)
-
-    # Log metrics to MLflow
-    precision = classification['weighted avg']['precision']
-    recall = classification['weighted avg']['recall']
-    f1_score = classification['weighted avg']['f1-score']
+def log_metrics(y_true, y_pred, mode):
+    """Log evaluation metrics."""
+    precision = classification_report(y_true, y_pred, output_dict=True)['weighted avg']['precision']
+    recall = classification_report(y_true, y_pred, output_dict=True)['weighted avg']['recall']
+    f1_score = classification_report(y_true, y_pred, output_dict=True)['weighted avg']['f1-score']
 
     mlflow.log_metric(f"{mode}_precision", precision)
     mlflow.log_metric(f"{mode}_recall", recall)
     mlflow.log_metric(f"{mode}_f1_score", f1_score)
 
-    print(f"Classification Report ({mode}):\n", classification_report(y_true, y_pred, target_names=class_names))
 
-    
-import matplotlib.pyplot as plt
-from sklearn.metrics import roc_curve, roc_auc_score
-import numpy as np
+
 
 def plot_roc_curve(y_true, y_pred_prob, mode, class_names=None):
     """

utils/model_utils.py

@@ -6,10 +6,12 @@ from keras.optimizers import Adamax
 from keras.utils import to_categorical
 from sklearn.model_selection import train_test_split
 import optuna
-
+import mlflow
+import mlflow.keras
 from imblearn.over_sampling import RandomOverSampler
 from tensorflow.keras.preprocessing.image import ImageDataGenerator
 from imblearn.over_sampling import SMOTE
+import matplotlib.pyplot as plt
 
 
 
@@ -30,6 +32,8 @@ from keras.layers import (
     GlobalAveragePooling1D, GlobalAveragePooling2D,
     Dense, Dropout, BatchNormalization
 )
+from sklearn.model_selection import train_test_split
+import numpy as np
 
  
 # Initialize logger
@@ -40,24 +44,16 @@ model_logger = logging.getLogger("model_utils")
 #  MODEL BUILDING UTILITIES
 # ==========================
 
-def build_cnn_model(input_shape, n_filters=32, dense_units=128, dropout_rate=0.3, num_classes=2, model_type='1D'):
+def build_model(input_shape, n_filters, dense_units, dropout_rate, num_classes, model_type='1D', classification_mode='binary'):
     """
-    Build and compile a CNN model.
-
-    Args:
-        input_shape: Shape of the input data.
-        n_filters: Number of filters for the convolutional layers.
-        dense_units: Number of units in the dense layer.
-        dropout_rate: Dropout rate for regularization.
-        num_classes: Number of output classes.
-        model_type: '1D' for 1D CNN, '2D' for 2D CNN.
-
-    Returns:
-        Compiled CNN model.
+    Build and compile a CNN model for 1D or 2D data.
+
+    Returns CNN model.
     """
-    model_logger.info(f"Building a {model_type} CNN model with input shape {input_shape}.")
+    print(f"Building the updated {model_type} CNN model with {classification_mode} classification.")
     model = Sequential()
 
+    # Add convolutional layers based on the model type
     if model_type == '1D':
         # 1D CNN layers
         model.add(Conv1D(n_filters, kernel_size=3, activation='relu', input_shape=input_shape))
@@ -97,126 +93,150 @@ def build_cnn_model(input_shape, n_filters=32, dense_units=128, dropout_rate=0.3
     else:
         raise ValueError("Invalid model_type. Must be '1D' or '2D'.")
 
-    # Fully connected layers
+    # Add fully connected layers
     model.add(Dense(dense_units, activation='relu'))
     model.add(BatchNormalization())
     model.add(Dropout(dropout_rate))
-    model.add(Dense(num_classes, activation='sigmoid' if num_classes == 1 else 'softmax'))
+
+    # Add output layer dynamically based on classification mode
+    if classification_mode == 'binary':
+        # Binary classification: Single unit with sigmoid activation
+        model.add(Dense(1, activation='sigmoid'))
+        loss_function = 'binary_crossentropy'
+    else:
+        # Multi-class classification: num_classes units with softmax activation
+        model.add(Dense(num_classes, activation='softmax'))
+        loss_function = 'categorical_crossentropy'
 
     # Compile the model
-    loss = 'binary_crossentropy' if num_classes == 1 else 'categorical_crossentropy'
-    model.compile(optimizer='adam', loss=loss, metrics=['accuracy'])
-    model_logger.info(f"{model_type} CNN model built and compiled successfully.")
+    model.compile(optimizer='adam', loss=loss_function, metrics=['accuracy'])
+    print(f"{model_type} CNN model built and compiled successfully for {classification_mode} classification.")
     return model
 
 
-# ===============================
-#  HYPERPARAMETER OPTIMIZATION
-# ===============================
 
-def optimize_cnn_model(trial, input_shape, num_classes, X_train, y_train, X_val, y_val, model_type='1D'):
-    """
-    Optimize CNN model using Optuna.
-
-    Args:
-        trial: Optuna trial object.
-        input_shape: Shape of the input data.
-        num_classes: Number of output classes.
-        X_train: Training data.
-        y_train: Training labels.
-        X_val: Validation data.
-        y_val: Validation labels.
-        model_type: Type of model ('1D' or '2D').
-
-    Returns:
-        Best validation accuracy.
-    """
-    n_filters = trial.suggest_int("n_filters", 16, 64, step=16)
-    dense_units = trial.suggest_int("dense_units", 64, 256, step=64)
-    dropout_rate = trial.suggest_float("dropout_rate", 0.1, 0.5, step=0.1)
-
-    model = build_cnn_model(input_shape, n_filters, dense_units, dropout_rate, num_classes, model_type=model_type)
-    history = model.fit(X_train, y_train, validation_data=(X_val, y_val), epochs=10, batch_size=32, verbose=0)
-
-    val_accuracy = max(history.history['val_accuracy'])
-    return val_accuracy
 
-
-def run_optuna_optimization(model_type, input_shape, num_classes, X_train, y_train, X_val, y_val, n_trials=20):
+def track_experiment_with_mlflow_and_optuna(
+    mode,
+    num_classes,
+    model_type,
+    classification_mode,
+    X_train,
+    y_train,
+    X_val,
+    y_val,
+    n_trials=20,
+):
     """
-    Run Optuna optimization for a given model type.
-
-    Args:
-        model_type: Type of model to optimize ('1D' or '2D').
-        input_shape: Shape of the input data.
-        num_classes: Number of output classes.
-        X_train: Training data.
-        y_train: Training labels.
-        X_val: Validation data.
-        y_val: Validation labels.
-        n_trials: Number of trials for Optuna optimization.
-
-    Returns:
-        Best hyperparameters.
+    Optimize hyperparameters using Optuna and track experiments with MLflow.
+
+    Parameters:
+    - mode: Feature extraction mode (e.g., 'augmented', 'mfcc', 'log_mel').
+    - num_classes: Number of classes for classification.
+    - model_type: Type of model ('1D' for Conv1D, '2D' for Conv2D).
+    - classification_mode: 'binary' for binary classification, 'multi' for multi-class classification.
+    - X_train, y_train: Training data and labels.
+    - X_val, y_val: Validation data and labels.
+    - n_trials: Number of Optuna trials.
     """
     def objective(trial):
-        return optimize_cnn_model(trial, input_shape, num_classes, X_train, y_train, X_val, y_val, model_type)
-
-    study = optuna.create_study(direction="maximize")
+        with mlflow.start_run(nested=True):
+            # Hyperparameters to tune
+            n_filters = trial.suggest_categorical('n_filters', [16, 32, 64])
+            dense_units = trial.suggest_int('dense_units', 64, 256, step=32)
+            dropout_rate = trial.suggest_float('dropout_rate', 0.1, 0.5, step=0.1)
+            learning_rate = trial.suggest_loguniform('learning_rate', 1e-4, 1e-2)
+
+            # Build and compile the model
+            model = build_model(
+                input_shape=X_train.shape[1:], 
+                n_filters=n_filters, 
+                dense_units=dense_units, 
+                dropout_rate=dropout_rate,
+                num_classes=num_classes,
+                model_type=model_type,
+                classification_mode=classification_mode
+            )
+
+            # Define EarlyStopping callback
+            early_stopping = EarlyStopping(
+                monitor='val_loss', 
+                patience=5,  
+                restore_best_weights=True
+            )
+
+            # Train the model
+            history = model.fit(
+                X_train,
+                y_train,
+                validation_data=(X_val, y_val),
+                epochs=50,
+                batch_size=32,
+                callbacks=[early_stopping],
+                verbose=0,
+            )
+
+            # Log hyperparameters and metrics to MLflow
+            mlflow.log_params({
+                'n_filters': n_filters,
+                'dense_units': dense_units,
+                'dropout_rate': dropout_rate,
+                'learning_rate': learning_rate,
+                'model_type': model_type,
+                'classification_mode': classification_mode,
+            })
+            mlflow.log_metric("best_val_accuracy", max(history.history['val_accuracy']))
+
+            # Save loss curves
+            plt.figure()
+            plt.plot(history.history['loss'], label='Train Loss')
+            plt.plot(history.history['val_loss'], label='Validation Loss')
+            plt.legend()
+            plt.title("Training and Validation Loss")
+            loss_curve_path = f"loss_curve_{trial.number}_{model_type}.png"
+            plt.savefig(loss_curve_path)
+            mlflow.log_artifact(loss_curve_path)
+
+            return max(history.history['val_accuracy'])
+
+    # Start Optuna study
+    study = optuna.create_study(direction='maximize')
     study.optimize(objective, n_trials=n_trials)
 
-    model_logger.info(f"Best trial for {model_type} CNN: {study.best_trial.params}")
-    return study.best_trial.params
-
-
-# ============================
-#  DATASET PREPARATION UTILS
-# ============================
-from sklearn.model_selection import train_test_split
-import numpy as np
-
-def split_dataset(X, y, test_size=0.3, validation_size=0.5, random_state=42):
-    """
-    Split dataset into training, validation, and test sets.
-
-    Args:
-        X: Feature data.
-        y: Labels.
-        test_size: Proportion of the data to reserve for testing.
-        validation_size: Proportion of the test set to reserve for validation.
-        random_state: Random seed.
-
-    Returns:
-        X_train, X_val, X_test, y_train, y_val, y_test
-    """
-    model_logger.info("Splitting dataset into training, validation, and test sets...")
-    
-    # Check for minimum class size
-    class_counts = np.sum(y, axis=0) if len(y.shape) > 1 else np.bincount(y)
-    if np.any(class_counts < 2):
-        model_logger.warning("Some classes have fewer than 2 samples. Stratification will be disabled.")
-        stratify_train = None
-        stratify_test = None
-    else:
-        stratify_train = y
-        stratify_test = y
-    
-    # Split training and test data
-    X_train, X_temp, y_train, y_temp = train_test_split(
-        X, y, test_size=test_size, stratify=stratify_train, random_state=random_state
+    # Retrieve the best trial and log results
+    best_trial = study.best_trial
+    model_logger.info(f"Best Trial for {mode} ({model_type}): {best_trial.params}")
+
+    # Build and return the best model
+    best_model = build_model(
+        input_shape=X_train.shape[1:], 
+        n_filters=best_trial.params['n_filters'], 
+        dense_units=best_trial.params['dense_units'], 
+        dropout_rate=best_trial.params['dropout_rate'], 
+        num_classes=num_classes,
+        model_type=model_type,
+        classification_mode=classification_mode
     )
-    
-    # Split validation and test data
-    class_counts_temp = np.sum(y_temp, axis=0) if len(y_temp.shape) > 1 else np.bincount(y_temp)
-    if np.any(class_counts_temp < 2):
-        model_logger.warning("Some classes in the temporary test set have fewer than 2 samples. Stratification will be disabled for the validation split.")
-        stratify_temp = None
-    else:
-        stratify_temp = y_temp
 
-    X_val, X_test, y_val, y_test = train_test_split(
-        X_temp, y_temp, test_size=validation_size, stratify=stratify_temp, random_state=random_state
+    # Train the best model
+    early_stopping = EarlyStopping(
+        monitor='val_loss',
+        patience=5,
+        restore_best_weights=True,
     )
-    
-    model_logger.info("Dataset split completed.")
-    return X_train, X_val, X_test, y_train, y_val, y_test
+    best_model.fit(
+        X_train, y_train,
+        validation_data=(X_val, y_val),
+        epochs=50,
+        batch_size=32,
+        callbacks=[early_stopping],
+        verbose=1,
+    )
+
+    # Save the best model
+    best_model_path = f"best_model_{mode}_{model_type}.h5"
+    best_model.save(best_model_path)
+    mlflow.log_artifact(best_model_path)
+    model_logger.info(f"Best model for {mode} ({model_type}) saved successfully.")
+
+    return best_model