Upload 103 files

.gitattributes

@@ -33,3 +33,7 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+101_1b1_Al_sc_Meditron.wav 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

.gitignore

@@ -0,0 +1,7 @@
+/data/Respiratory_Sound_Database/audio_and_txt_files
+/mlruns
+/KaggleRuns
+/data
+/models/archive
+/huggingface
+/processed_datasets/old

101_1b1_Al_sc_Meditron.wav

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

Exploration/inference.py

@@ -0,0 +1,209 @@
+import os
+import wave
+import numpy as np
+import pandas as pd
+import seaborn as sns
+import matplotlib.pyplot as plt
+import librosa
+import librosa.display
+import scipy.signal as signal
+
+class RespiratorySoundAnalysis:
+    def __init__(self, diagnosis_file, audio_path):
+        self.diagnosis_file = diagnosis_file
+        self.audio_path = audio_path
+        self.diagnosis_df = None
+        self.audio_files = None
+        self.audio_df = None
+        self.merged_df = None
+
+    def load_diagnosis_data(self):
+        """Load patient diagnosis data."""
+        self.diagnosis_df = pd.read_csv(self.diagnosis_file, names=['patient_id', 'disease'])
+        print("Diagnosis Data Preview:")
+        print(self.diagnosis_df.head())
+        
+        print("\nDisease Distribution:")
+        print(self.diagnosis_df['disease'].value_counts())
+        
+        print("\nDisease Proportion:")
+        print(self.diagnosis_df['disease'].value_counts(normalize=True) * 100)
+
+    def plot_disease_distribution(self):
+        """Plot disease distribution."""
+        plt.figure(figsize=(10, 6))
+        sns.countplot(
+            y=self.diagnosis_df['disease'],
+            order=self.diagnosis_df['disease'].value_counts().index,
+            hue=self.diagnosis_df['disease'],
+            palette='viridis',
+            dodge=False,
+            legend=False
+        )
+        plt.title("Disease Distribution")
+        plt.xlabel("Count")
+        plt.ylabel("Disease")
+        plt.show()
+
+
+    def load_audio_files(self):
+        """Load audio file paths."""
+        print(f"Searching for .wav files in: {self.audio_path}")
+        try:
+            # Recursively look for .wav files
+            self.audio_files = [
+                os.path.join(root, file)
+                for root, _, files in os.walk(self.audio_path)  # Walk through subdirectories
+                for file in files
+                if file.lower().endswith('.wav')  # Case-insensitive filtering
+            ]
+            print(f"Total audio files found: {len(self.audio_files)}")
+            if not self.audio_files:
+                print("No .wav files found. Check the directory or file extensions.")
+        except Exception as e:
+            print(f"Error while loading audio files: {e}")
+            self.audio_files = []
+
+    def extract_audio_properties(self, file_path):
+        """Extract properties of an audio file."""
+        with wave.open(file_path, 'r') as audio_file:
+            params = audio_file.getparams()
+            return {
+                "n_channels": params.nchannels,
+                "sample_width": params.sampwidth,
+                "frame_rate": params.framerate,
+                "n_frames": params.nframes,
+                "duration_sec": params.nframes / params.framerate
+            }
+
+    def analyze_audio_properties(self):
+        """Analyze properties of audio files."""
+        if not self.audio_files:
+            print("No audio files found to analyze.")
+            self.audio_df = None
+            return
+
+        audio_properties = []
+
+        for file_path in self.audio_files:
+            if not os.path.exists(file_path):
+                print(f"File not found: {file_path}")
+                continue
+            try:
+                props = self.extract_audio_properties(file_path)
+                props['file_name'] = file_path
+                audio_properties.append(props)
+            except Exception as e:
+                print(f"Error analyzing {file_path}: {e}")
+
+        if audio_properties:
+            self.audio_df = pd.DataFrame(audio_properties)
+            print("\nAudio File Properties:")
+            print(self.audio_df.describe())
+        else:
+            print("No audio properties could be extracted.")
+            self.audio_df = None
+
+
+
+    def plot_audio_duration_distribution(self):
+        """Plot distribution of audio durations."""
+        if self.audio_df is None or 'duration_sec' not in self.audio_df:
+            print("Audio data is not available for plotting. Please ensure audio files are analyzed first.")
+            return
+
+        plt.figure(figsize=(10, 6))
+        sns.histplot(self.audio_df['duration_sec'], kde=True, bins=20, color='skyblue')
+        plt.title("Audio Duration Distribution")
+        plt.xlabel("Duration (seconds)")
+        plt.ylabel("Frequency")
+        plt.show()
+
+
+    def visualize_sample_audio(self, file_name):
+        """Visualize a sample audio file."""
+        file_path = os.path.join(self.audio_path, file_name)
+        if not os.path.exists(file_path):
+            print(f"File not found: {file_path}")
+            return
+
+        try:
+            y, sr = librosa.load(file_path)
+
+            # Plot waveform
+            plt.figure(figsize=(12, 6))
+            librosa.display.waveshow(y, sr=sr)
+            plt.title(f"Waveform for {file_name}")
+            plt.xlabel("Time (s)")
+            plt.ylabel("Amplitude")
+            plt.show()
+
+            # Plot spectrogram
+            D = librosa.amplitude_to_db(np.abs(librosa.stft(y)), ref=np.max)
+            plt.figure(figsize=(12, 6))
+            librosa.display.specshow(D, sr=sr, x_axis='time', y_axis='log', cmap='viridis')
+            plt.colorbar(format='%+2.0f dB')
+            plt.title("Spectrogram")
+            plt.show()
+        except Exception as e:
+            print(f"Error visualizing {file_name}: {e}")
+
+
+    def merge_audio_and_diagnosis_data(self):
+        """Combine audio stats with diagnosis data."""
+        if self.audio_df is None:
+            print("Audio data is not available. Please analyze audio properties before merging.")
+            return
+
+        # Extract file name without the full path
+        self.audio_df['file_name_only'] = self.audio_df['file_name'].apply(os.path.basename)
+
+        # Split the file name to extract patient ID (assuming it is the first part of the file name)
+        try:
+            self.audio_df['patient_id'] = self.audio_df['file_name_only'].str.split('_').str[0].astype(int)
+        except ValueError as e:
+            print(f"Error extracting patient_id: {e}")
+            print(self.audio_df['file_name_only'].head())  # Debugging information
+            return
+
+        # Merge with diagnosis data
+        self.merged_df = pd.merge(
+            self.audio_df, 
+            self.diagnosis_df, 
+            left_on='patient_id', 
+            right_on='patient_id', 
+            how='left'
+        )
+        print("\nMerged Audio and Diagnosis Data:")
+        print(self.merged_df.head())
+
+
+    def preprocess_audio(self, y, sr, target_sr=7000, low_cutoff=80, high_cutoff=3000, gamma=30):
+        """Preprocess audio by resampling, bandpass filtering, log compression, and normalization."""
+        y_resampled = librosa.resample(y, orig_sr=sr, target_sr=target_sr)
+        sos = signal.butter(10, [low_cutoff, high_cutoff], btype='bandpass', fs=target_sr, output='sos')
+        y_filtered = signal.sosfilt(sos, y_resampled)
+        y_compressed = np.sign(y_filtered) * np.log1p(gamma * np.abs(y_filtered)) / np.log1p(gamma)
+        y_normalized = y_compressed / np.max(np.abs(y_compressed))
+        return y_normalized, target_sr
+
+# Entry point for standalone execution
+if __name__ == "__main__":
+    diagnosis_file = '../data//Respiratory_Sound_Database//patient_diagnosis.csv'
+    audio_path = '../data/Respiratory_Sound_Database/testsample'
+
+    analysis = RespiratorySoundAnalysis(diagnosis_file, audio_path)
+
+    # Load and analyze data
+    analysis.load_diagnosis_data()
+    analysis.plot_disease_distribution()
+    analysis.load_audio_files()
+    analysis.analyze_audio_properties()
+    analysis.plot_audio_duration_distribution()
+
+    # Visualize sample audio
+    if analysis.audio_files:
+        analysis.visualize_sample_audio(analysis.audio_files[0])
+
+    # Merge data
+    analysis.merge_audio_and_diagnosis_data()

ExplorationApp.py

@@ -0,0 +1,247 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import librosa
+import librosa.display
+from Exploration.inference import RespiratorySoundAnalysis
+import seaborn as sns
+import os
+
+# Define base paths
+BASE_PATH = 'D://github//AmpleHealth//data//Respiratory_Sound_Database//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('D://github//AmpleHealth//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
+st.title("Respiratory Sound Data Explorer")
+
+# Tabs for navigation
+tabs = st.tabs(["Overview", "Explore Data", "Patient Demographics", "Preprocessing & Audio Effects"])
+
+# Overview Tab
+
+
+# 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, legend=False, hue=disease_counts.index, dodge=False)
+    ax.set_title("Disease Distribution", fontsize=16, fontweight='bold')
+    ax.set_xlabel("Number of Patients", fontsize=12)
+    ax.set_ylabel("Disease", fontsize=12)
+    for i, v in enumerate(disease_counts.values):
+        ax.text(v + 1, i, str(v), color='black', fontsize=10, va='center')
+    st.pyplot(fig)
+
+    # Proportion of Diseases
+    st.subheader("Disease Proportion")
+    disease_proportions = diagnosis_df['disease'].value_counts(normalize=True) * 100
+    fig, ax = plt.subplots(figsize=(10, 6))
+    sns.barplot(y=disease_proportions.index, x=disease_proportions.values, hue=disease_proportions.index, dodge=False, palette="coolwarm", ax=ax, legend=False)
+    ax.set_title("Disease Proportion (%)", fontsize=16, fontweight='bold')
+    ax.set_xlabel("Proportion (%)", fontsize=12)
+    ax.set_ylabel("Disease", fontsize=12)
+    for i, v in enumerate(disease_proportions.values):
+        ax.text(v + 0.5, i, f"{v:.1f}%", color='black', fontsize=10, va='center')
+    st.pyplot(fig)
+
+# Explore Data Tab
+with tabs[1]:
+    st.header("Explore Data")
+
+    if audio_df is not None and not audio_df.empty:
+        # Key Audio Insights
+        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:** {audio_df.loc[audio_df['duration_sec'].idxmin(), 'file_name']} ({audio_df['duration_sec'].min():.2f} seconds)
+        - **Longest Audio File:** {audio_df.loc[audio_df['duration_sec'].idxmax(), 'file_name']} ({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')
+        ax.set_xlabel("Duration (seconds)", fontsize=12)
+        ax.set_ylabel("Frequency", fontsize=12)
+        st.pyplot(fig)
+
+        # Highlight Outliers
+        st.subheader("Audio Duration Outliers")
+        outlier_threshold = st.slider("Set Outlier Threshold (seconds):", 1.0, float(audio_df['duration_sec'].max()), 25.0, step=0.5)
+        outliers = audio_df[audio_df['duration_sec'] > outlier_threshold]
+        st.write(outliers if not outliers.empty else "No outliers found above the threshold.")
+
+        # Optional Filtering
+        st.subheader("Filter Audio Files by Duration")
+        min_range, max_range = st.slider("Select Duration Range (seconds):", 0.0, float(audio_df['duration_sec'].max()), (0.0, float(audio_df['duration_sec'].max())), step=0.5)
+        filtered_files = audio_df[(audio_df['duration_sec'] >= min_range) & (audio_df['duration_sec'] <= max_range)]
+        st.write(f"**Number of Files in Range:** {len(filtered_files)}")
+        st.dataframe(filtered_files[['file_name', 'duration_sec']])
+    else:
+        st.warning("No audio data available to display.")
+
+# Patient Demographics Tab
+with tabs[2]:
+    st.header("Patient Demographics")
+    st.subheader("Demographics Data")
+    st.dataframe(patient_df)
+
+    st.subheader("Missing Values Information")
+    st.write(patient_df.isna().sum())
+
+    st.subheader("Key Statistics")
+    avg_age, min_age, max_age = patient_df['Age'].mean(), patient_df['Age'].min(), patient_df['Age'].max()
+    st.markdown(f"- **Average Age:** {avg_age:.1f} years\n- **Youngest Patient:** {min_age} years\n- **Oldest Patient:** {max_age} years")
+
+    # Visualizations
+    st.markdown("### 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)
+
+    st.markdown("### Gender Distribution")
+    fig, ax = plt.subplots(figsize=(10, 6))
+    sns.barplot(x=patient_df['Sex'].value_counts().index, y=patient_df['Sex'].value_counts().values, palette="coolwarm", ax=ax, hue=patient_df['Sex'].value_counts().index, dodge=False)
+    ax.set_title("Gender Distribution", fontsize=16, fontweight='bold')
+    st.pyplot(fig)
+
+
+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.")

Model_Inference.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'.")

README.md

@@ -1,12 +1 @@
----
-title: Amp
-emoji: 🔥
-colorFrom: purple
-colorTo: green
-sdk: streamlit
-sdk_version: 1.41.1
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+"# amp1" 

Train.py

@@ -0,0 +1,215 @@
+import logging
+import numpy as np
+from utils.data_loader import load_data, process_audio_metadata
+from utils.audioprocessing import *
+from utils.model_utils import * 
+import joblib
+from utils.evaluation import log_metrics, plot_roc_curve, plot_confusion_matrix
+import os
+import gc
+from joblib import Parallel, delayed
+import mlflow
+import mlflow.keras
+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.utils import to_categorical, normalize
+from keras.layers import Conv2D, Dense, MaxPooling2D, Flatten, Dropout, BatchNormalization, GlobalAveragePooling2D
+from imblearn.over_sampling import SMOTE
+from tensorflow.keras.models import Sequential, Model
+from tensorflow.keras.layers import Conv1D, GRU, Input, add, Dense, Dropout, BatchNormalization, LeakyReLU
+from tensorflow.keras.optimizers import Adamax
+from tensorflow.keras.callbacks import ModelCheckpoint, EarlyStopping
+from tensorflow.keras.preprocessing.image import ImageDataGenerator
+
+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
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+data_logger = logging.getLogger("data_pipeline")
+train_logger = logging.getLogger("train")
+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'
+
+def save_dataset(X, y, mode, output_dir="c"):
+    """
+    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
+    
+    # Ensure the output directory exists
+    os.makedirs(output_dir, exist_ok=True)
+    
+    # Save files with mode-specific names
+    X_path = os.path.join(output_dir, f"X_{mode}.npy")
+    y_path = os.path.join(output_dir, f"y_{mode}.npy")
+    
+    np.save(X_path, X)
+    np.save(y_path, y)
+    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"):
+
+    #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")
+
+    # Check if the files exist
+    if os.path.exists(X_path) and os.path.exists(y_path):
+        processing_logger.info(f"Preprocessed files found for mode '{mode}'. Loading from disk...")
+        X = np.load(X_path)
+        y = np.load(y_path)
+    else:
+        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)
+        else:
+            X, y, le = prepare_dataset_parallel(df_filtered, audio_files_path, mode=mode)
+
+
+
+        # Save the processed data and LabelEncoder
+        np.save(X_path, X)
+        np.save(y_path, y)
+        processing_logger.info(f"Saved processed dataset and LabelEncoder for mode '{mode}' to {output_dir}")
+
+    le = LabelEncoder()
+    return X, y, le
+
+
+def main():
+    data_logger.info("Starting data pipeline.")
+
+    # Step 1: Load and preprocess data
+    data_logger.info("Loading and preprocessing data...")
+    df = load_data()
+    audio_metadata = process_audio_metadata(METADATA_PATH)
+    df_all = merge_datasets(audio_metadata, df)
+
+    # Define classification modes and feature types
+    classification_modes = [ 'multi', 'binary']#
+    feature_types = [ 'augmented','mfcc', 'log_mel'] #, 
+
+    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)
+
+        for feature_type in feature_types:
+            processing_logger.info(f"Preparing dataset 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))}")
+
+            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.")
+
+
+if __name__ == "__main__":
+    main()
+

data/Respiratory_Sound_Database/filename_differences.txt

@@ -0,0 +1,91 @@
+'101_1b1_Al_sc_AKGC417L'
+'101_1b1_Pr_sc_AKGC417L'
+'102_1b1_Ar_sc_AKGC417L'
+'105_1b1_Tc_sc_LittC2SE'
+'108_1b1_Al_sc_LittC2SE'
+'111_1b2_Tc_sc_LittC2SE'
+'111_1b3_Tc_sc_LittC2SE'
+'115_1b1_Ar_sc_LittC2SE'
+'116_1b2_Pl_sc_LittC2SE'
+'116_1b2_Tc_sc_LittC2SE'
+'119_1b1_Ar_sc_AKGC417L'
+'121_1b1_Tc_sc_LittC2SE'
+'121_1p1_Tc_sc_LittC2SE'
+'123_1b1_Al_sc_AKGC417L'
+'125_1b1_Tc_sc_LittC2SE'
+'126_1b1_Al_sc_AKGC417L'
+'127_1b1_Ar_sc_LittC2SE'
+'129_1b1_Ar_sc_LittC2SE'
+'131_1b1_Al_sc_LittC2SE'
+'136_1b1_Ar_sc_AKGC417L'
+'137_1b1_Ar_sc_LittC2SE'
+'137_1b1_Ll_sc_LittC2SE'
+'143_1b1_Al_sc_AKGC417L'
+'144_1b1_Al_sc_AKGC417L'
+'144_1b1_Tc_sc_AKGC417L'
+'148_1b1_Al_sc_LittC2SE'
+'149_1b1_Al_sc_LittC2SE'
+'149_1b1_Lr_sc_LittC2SE'
+'149_1b1_Pl_sc_LittC2SE'
+'150_1b2_Al_sc_AKGC417L'
+'152_1b1_Al_sc_LittC2SE'
+'153_1b1_Al_sc_LittC2SE'
+'159_1b1_Al_sc_AKGC417L'
+'159_1b1_Ar_sc_AKGC417L'
+'159_1b1_Ll_sc_AKGC417L'
+'159_1b1_Pr_sc_AKGC417L'
+'161_1b1_Al_sc_LittC2SE'
+'161_1b1_Pl_sc_LittC2SE'
+'164_1b1_Ll_sc_LittC2SE'
+'165_1b1_Ar_sc_AKGC417L'
+'165_1b1_Pl_sc_AKGC417L'
+'165_1b1_Pr_sc_AKGC417L'
+'167_1b1_Al_sc_LittC2SE'
+'167_1b1_Pr_sc_LittC2SE'
+'168_1b1_Al_sc_LittC2SE'
+'169_1b1_Lr_sc_AKGC417L'
+'169_1b2_Ll_sc_AKGC417L'
+'171_1b1_Al_sc_AKGC417L'
+'173_1b1_Al_sc_AKGC417L'
+'179_1b1_Al_sc_LittC2SE'
+'179_1b1_Tc_sc_LittC2SE'
+'182_1b1_Tc_sc_LittC2SE'
+'183_1b1_Pl_sc_AKGC417L'
+'183_1b1_Tc_sc_AKGC417L'
+'184_1b1_Ar_sc_LittC2SE'
+'187_1b1_Ll_sc_AKGC417L'
+'188_1b1_Al_sc_LittC2SE'
+'188_1b1_Ar_sc_LittC2SE'
+'188_1b1_Pl_sc_LittC2SE'
+'188_1b1_Tc_sc_LittC2SE'
+'190_1b1_Tc_sc_AKGC417L'
+'194_1b1_Lr_sc_AKGC417L'
+'194_1b1_Pr_sc_AKGC417L'
+'196_1b1_Pr_sc_LittC2SE'
+'197_1b1_Al_sc_AKGC417L'
+'197_1b1_Tc_sc_AKGC417L'
+'201_1b1_Al_sc_LittC2SE'
+'201_1b1_Ar_sc_LittC2SE'
+'201_1b2_Al_sc_LittC2SE'
+'201_1b2_Ar_sc_LittC2SE'
+'201_1b3_Al_sc_LittC2SE'
+'201_1b3_Ar_sc_LittC2SE'
+'202_1b1_Ar_sc_AKGC417L'
+'206_1b1_Ar_sc_LittC2SE'
+'206_1b1_Lr_sc_LittC2SE'
+'206_1b1_Pl_sc_LittC2SE'
+'208_1b1_Ll_sc_LittC2SE'
+'209_1b1_Tc_sc_LittC2SE'
+'210_1b1_Al_sc_LittC2SE'
+'210_1b1_Ar_sc_LittC2SE'
+'214_1b1_Ar_sc_AKGC417L'
+'215_1b2_Ar_sc_LittC2SE'
+'215_1b3_Tc_sc_LittC2SE'
+'216_1b1_Al_sc_AKGC417L'
+'216_1b1_Pl_sc_AKGC417L'
+'217_1b1_Tc_sc_LittC2SE'
+'224_1b1_Tc_sc_AKGC417L'
+'224_1b2_Al_sc_AKGC417L'
+'225_1b1_Pl_sc_AKGC417L'
+'226_1b1_Al_sc_LittC2SE'
+'226_1b1_Ll_sc_LittC2SE'

data/Respiratory_Sound_Database/filename_format.txt

@@ -0,0 +1,7 @@
+Elements contained in the filenames:
+
+Patient number (101,102,...,226)
+Recording index
+Chest location (Trachea (Tc), {Anterior (A), Posterior (P), Lateral (L)}{left (l), right (r)})
+Acquisition mode (sequential/single channel (sc), simultaneous/multichannel (mc))
+Recording equipment (AKG C417L Microphone, 3M Littmann Classic II SE Stethoscope, 3M Litmmann 3200 Electronic Stethoscope, WelchAllyn Meditron Master Elite Electronic Stethoscope)

data/Respiratory_Sound_Database/patient_diagnosis.csv

@@ -0,0 +1,126 @@
+101,URTI
+102,Healthy
+103,Asthma
+104,COPD
+105,URTI
+106,COPD
+107,COPD
+108,LRTI
+109,COPD
+110,COPD
+111,Bronchiectasis
+112,COPD
+113,COPD
+114,COPD
+115,LRTI
+116,Bronchiectasis
+117,COPD
+118,COPD
+119,URTI
+120,COPD
+121,Healthy
+122,Pneumonia
+123,Healthy
+124,COPD
+125,Healthy
+126,Healthy
+127,Healthy
+128,COPD
+129,URTI
+130,COPD
+131,URTI
+132,COPD
+133,COPD
+134,COPD
+135,Pneumonia
+136,Healthy
+137,URTI
+138,COPD
+139,COPD
+140,Pneumonia
+141,COPD
+142,COPD
+143,Healthy
+144,Healthy
+145,COPD
+146,COPD
+147,COPD
+148,URTI
+149,Bronchiolitis
+150,URTI
+151,COPD
+152,Healthy
+153,Healthy
+154,COPD
+155,COPD
+156,COPD
+157,COPD
+158,COPD
+159,Healthy
+160,COPD
+161,Bronchiolitis
+162,COPD
+163,COPD
+164,URTI
+165,URTI
+166,COPD
+167,Bronchiolitis
+168,Bronchiectasis
+169,Bronchiectasis
+170,COPD
+171,Healthy
+172,COPD
+173,Bronchiolitis
+174,COPD
+175,COPD
+176,COPD
+177,COPD
+178,COPD
+179,Healthy
+180,COPD
+181,COPD
+182,Healthy
+183,Healthy
+184,Healthy
+185,COPD
+186,COPD
+187,Healthy
+188,URTI
+189,COPD
+190,URTI
+191,Pneumonia
+192,COPD
+193,COPD
+194,Healthy
+195,COPD
+196,Bronchiectasis
+197,URTI
+198,COPD
+199,COPD
+200,COPD
+201,Bronchiectasis
+202,Healthy
+203,COPD
+204,COPD
+205,COPD
+206,Bronchiolitis
+207,COPD
+208,Healthy
+209,Healthy
+210,URTI
+211,COPD
+212,COPD
+213,COPD
+214,Healthy
+215,Bronchiectasis
+216,Bronchiolitis
+217,Healthy
+218,COPD
+219,Pneumonia
+220,COPD
+221,COPD
+222,COPD
+223,COPD
+224,Healthy
+225,Healthy
+226,Pneumonia

data/Respiratory_Sound_Database/testsample/101_1b1_Al_sc_Meditron.txt

@@ -0,0 +1,12 @@
+0.036	0.579	0	0
+0.579	2.45	0	0
+2.45	3.893	0	0
+3.893	5.793	0	0
+5.793	7.521	0	0
+7.521	9.279	0	0
+9.279	11.15	0	0
+11.15	13.036	0	0
+13.036	14.721	0	0
+14.721	16.707	0	0
+16.707	18.507	0	0
+18.507	19.964	0	0

data/Respiratory_Sound_Database/testsample/101_1b1_Al_sc_Meditron.wav

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

data/Respiratory_Sound_Database/testsample/101_1b1_Pr_sc_Meditron.txt

@@ -0,0 +1,11 @@
+0.036	1.264	0	0
+1.264	3.422	0	0
+3.422	5.55	0	0
+5.55	7.436	0	0
+7.436	9.221	0	0
+9.221	11.264	0	0
+11.264	13.264	0	0
+13.264	15.179	0	0
+15.179	17.207	0	0
+17.207	19.179	0	0
+19.179	19.936	0	0

data/Respiratory_Sound_Database/testsample/101_1b1_Pr_sc_Meditron.wav

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

data/Respiratory_Sound_Database/testsample/102_1b1_Ar_sc_Meditron.txt

@@ -0,0 +1,13 @@
+0.264	1.736	0	0
+1.736	3.293	0	0
+3.293	5.307	0	0
+5.307	6.636	0	0
+6.636	8.036	0	0
+8.036	9.607	0	0
+9.607	11.036	0	0
+11.036	13.036	0	0
+13.036	14.664	0	0
+14.664	16.393	0	0
+16.393	17.893	0	0
+17.893	19.593	0	0
+19.593	19.964	0	0

data/Respiratory_Sound_Database/testsample/102_1b1_Ar_sc_Meditron.wav

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

data/Respiratory_Sound_Database/testsample/103_2b2_Ar_mc_LittC2SE.txt

@@ -0,0 +1,6 @@
+0.364	3.25	0	1
+3.25	6.636	0	0
+6.636	11.179	0	1
+11.179	14.25	0	1
+14.25	16.993	0	1
+16.993	19.979	0	0

data/Respiratory_Sound_Database/testsample/103_2b2_Ar_mc_LittC2SE.wav

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

data/Respiratory_Sound_Database/testsample/104_1b1_Al_sc_Litt3200.txt

@@ -0,0 +1,6 @@
+0	1.8771	0	0
+1.8771	3.7543	0	0
+3.7543	6.1071	0	0
+6.1071	8.2502	0	0
+8.2502	12.618	0	0
+12.618	15.856	0	0

data/Respiratory_Sound_Database/testsample/104_1b1_Ar_sc_Litt3200.txt

@@ -0,0 +1,14 @@
+0	0.54469	0	1
+0.54469	2.9628	0	1
+2.9628	5.1085	0	1
+5.1085	7.2172	0	1
+7.2172	9.1442	0	1
+9.1442	10.675	0	1
+10.675	12.371	0	1
+12.371	14.381	0	1
+14.381	16.535	0	1
+16.535	19.048	0	1
+19.048	22.176	0	0
+22.176	22.951	0	0
+22.951	24.664	0	0
+24.664	25.584	0	0

data/demographic_info.txt

@@ -0,0 +1,127 @@
+
+101 3 F NA 19 99
+102 0.75 F NA 9.8 73
+103 70 F 33 NA NA
+104 70 F 28.47 NA NA
+105 7 F NA 32 135
+106 73 F 21 NA NA
+107 75 F 33.7 NA NA
+108 3 M NA NA NA
+109 84 F 33.53 NA NA
+110 75 M 25.21 NA NA
+111 63 M 28.4 NA NA
+112 60 M 22.86 NA NA
+113 58 M 28.41 NA NA
+114 77 M 23.12 NA NA
+115 0.58 M NA 7.14 64
+116 56 M 28.58 NA NA
+117 68 M 24.4 NA NA
+118 81 M 36.76 NA NA
+119 2 F NA 15.2 94
+120 78 M 35.14 NA NA
+121 13 F NA 65 170
+122 66 M 33 NA NA
+123 5 M NA 25 125
+124 65 M 29.07 NA NA
+125 14 M NA 62 170
+126 1 F NA 10.18 80
+127 2 M NA 12.6 98
+128 65 F 24.3 NA NA
+129 6 M NA 23 119
+130 85 F 17.1 NA NA
+131 3 M NA 14 97
+132 71 M 34 NA NA
+133 68 M 27.4 NA NA
+134 61 M 32 NA NA
+135 70 M 21 NA NA
+136 5 M NA 16.2 110
+137 4 M NA 18 104
+138 56 F 21.6 NA NA
+139 61 M 28.68 NA NA
+140 79 F 23 NA NA
+141 66 M 22.4 NA NA
+142 78 M 26.1 NA NA
+143 0.25 F NA 8.24 68
+144 3 M NA 16.7 100
+145 69 M 23.4 NA NA
+146 67 M 28 NA NA
+147 77 M 25.7 NA NA
+148 4 M NA 33 110
+149 0.67 M NA 9.5 70
+150 0.67 F NA 8.12 74
+151 75 M 28.4 NA NA
+152 16 M NA 70 183
+153 3 M NA 16.7 103
+154 65 M 28.1 NA NA
+155 69 M 26 NA NA
+156 80 M 22.9 NA NA
+157 62 M 53.5 NA NA
+158 63 M 16.5 NA NA
+159 0.83 F NA 11 80
+160 74 M 27.4 NA NA
+161 2 F NA 12 85
+162 67 F 24.9 NA NA
+163 62 M 28.3 NA NA
+164 1 M NA 13 NA
+165 2 F NA 12.7 97
+166 71 M 25.06 NA NA
+167 1 F NA 11.5 86.4
+168 19 F 17.35 NA NA
+169 50 F 28.81 NA NA
+170 79 M 22.6 NA NA
+171 9 M NA 32 133
+172 73 M 29.3 NA NA
+173 3 M NA 17.3 NA
+174 68 M 26.4 NA NA
+175 63 M 28.34 NA NA
+176 65 M 30.1 NA NA
+177 56 M 22.1 NA NA
+178 58 M 30.1 NA NA
+179 10 F NA 15 104
+180 93 M 29.03 NA NA
+181 65 M 26.4 NA NA
+182 11 M NA 33 136
+183 14 F NA NA NA
+184 2 F NA 15 100
+185 75 M 27.7 NA NA
+186 71 M 30 NA NA
+187 0.5 F NA 8.26 71
+188 3 M NA 16 100
+189 75 F 26.2 NA NA
+190 3 F NA NA NA
+191 74 F 36 NA NA
+192 69 M 28 NA NA
+193 77 M 26.3 NA NA
+194 2 M NA 12.8 86
+195 67 M 29.41 NA NA
+196 21 F 25.5 NA NA
+197 16 F NA NA NA
+198 71 M 18.6 NA NA
+199 71 M 20 NA NA
+200 72 F 27.8 NA NA
+201 73 F 28.52 NA NA
+202 2 M NA 11.84 87
+203 57 F 24 NA NA
+204 66 M 29.76 NA NA
+205 45 M 20.1 NA NA
+206 3 M NA 13 92
+207 63 F 29.6 NA NA
+208 5 F NA 24.1 117
+209 14 F NA 80 183
+210 1 F NA 12.96 76
+211 70 F 31.1 NA NA
+212 83 M 23 NA NA
+213 58 F 24.7 NA NA
+214 5 M NA 30 118
+215 56 F 25.35 NA NA
+216 1 M NA 10.25 78
+217 12 F NA NA NA
+218 75 M 26.29 NA NA
+219 81 M 26 NA NA
+220 66 M 35.4 NA NA
+221 74 F 29 NA NA
+222 60 M NA NA NA
+223 NA NA NA NA NA
+224 10 F NA 32.3 143
+225 0.83 M NA 7.8 74
+226 4 M NA 16.7 103

deployTest.py

@@ -0,0 +1,231 @@
+import os
+import logging
+import numpy as np
+import librosa
+from sklearn.preprocessing import normalize
+from tensorflow.keras.models import load_model
+from scipy.signal import butter, sosfilt
+
+# 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"
+FILE_PATH = "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"]
+}
+
+
+# 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.
+    
+    Args:
+        audio: The input audio signal.
+        sr: The sampling rate of the audio.
+        
+    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).
+
+    Args:
+        audio_file: Path to the audio file.
+        mode: Feature extraction mode ('mfcc', 'log_mel', or 'augmented').
+        input_shape: Expected input shape of the model for feature alignment.
+
+    Returns:
+        Extracted features as per the mode.
+    """
+    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.
+
+    Args:
+        feature: The extracted feature.
+        input_shape: 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.
+
+    Args:
+        model_type: Type of model ('binary' or 'multi').
+        feature_type: Feature extraction type ('mfcc', 'log_mel', or 'augmented').
+        file_path: Path to the audio file.
+
+    Returns:
+        Predicted class and prediction probabilities.
+    """
+    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
+
+    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}")
+            except Exception as e:
+                logger.error(f"Failed for {model_type} - {feature_type}: {e}")
+
+
+if __name__ == "__main__":
+    main()

legacy/train,py

@@ -0,0 +1,767 @@
+import os
+import logging
+import gc
+from joblib import Parallel, delayed
+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, Flatten, Dropout, BatchNormalization, GlobalAveragePooling2D
+
+from imblearn.over_sampling import RandomOverSampler
+from keras.preprocessing.image import ImageDataGenerator
+from imblearn.over_sampling import SMOTE
+from scipy.signal import butter, sosfilt
+
+
+from keras.models import Sequential
+from keras.layers import (
+    Conv1D, Conv2D, MaxPooling1D, MaxPooling2D,
+    GlobalAveragePooling1D, GlobalAveragePooling2D,
+    Dense, Dropout, BatchNormalization
+)
+
+
+from tensorflow.keras.models import Sequential, Model, load_model
+
+from tensorflow.keras.layers import Conv1D, Conv2D, SeparableConv1D, MaxPooling1D, MaxPooling2D
+from tensorflow.keras.layers import Input, add, Flatten, Dense, BatchNormalization, Dropout, LSTM, GRU
+from tensorflow.keras.layers import GlobalMaxPooling1D, GlobalMaxPooling2D, Activation, LeakyReLU, ReLU
+
+from tensorflow.keras import regularizers
+from tensorflow.keras import backend as K
+from tensorflow.keras.optimizers import Adamax
+from tensorflow.keras.callbacks import ModelCheckpoint, EarlyStopping
+
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import accuracy_score,precision_score,recall_score,f1_score,matthews_corrcoef
+from sklearn.metrics import cohen_kappa_score,roc_auc_score,confusion_matrix,classification_report
+
+
+# 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")
+
+# Utility Functions
+def load_data():
+    """Load patient diagnosis and demographic data."""
+    data_logger.info("Loading patient diagnosis and demographic data.")
+    diagnosis_df = pd.read_csv('/kaggle/input/respiratory-sound-database/Respiratory_Sound_Database/Respiratory_Sound_Database/patient_diagnosis.csv', 
+                               names=['Patient number', 'Diagnosis'])
+
+    patient_df = pd.read_csv('/kaggle/input/respiratory-sound-database/demographic_info.txt', 
+                             names=['Patient number', 'Age', 'Sex', 'Adult BMI (kg/m2)', 'Child Weight (kg)', 'Child Height (cm)'],
+                             delimiter=' ')
+
+    data_logger.info("Data successfully loaded.")
+    return pd.merge(left=patient_df, right=diagnosis_df, how='left')
+
+
+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
+
+    # 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, 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 mfccs_feature_exteraction(audio_files_path, df_filtered, n_jobs=-1):
+    """
+    Extract MFCC features from audio data and augment with noise, stretching, and shifting in parallel.
+    
+    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.
+    """
+    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 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):
+    """Apply time-stretching to the audio signal."""
+    return librosa.effects.time_stretch(data, rate=rate)
+
+
+
+def pitch_shift (data , rate):
+    data = librosa.effects.pitch_shift(data, sr=220250, n_steps=rate)
+    return data
+
+
+
+
+def prepare_dataset_augmented(df_filtered, audio_files_path, classification_mode):
+    """Prepare the dataset using the GRU pipeline."""
+    processing_logger.info("Preparing dataset with GRU pipeline.")
+    
+    # Extract features and labels
+    X, y = mfccs_feature_exteraction(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 GRU pipeline complete.")
+    return X, y_processed, le
+
+
+
+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.
+
+    Args:
+        df: Input DataFrame containing diagnosis data.
+        mode: Specify 'binary' for Normal/Abnormal or 'multi-class' for grouped classes.
+
+    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
+        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 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 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, 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
+    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 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
+
+
+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.
+
+    Args:
+        input_shape: Tuple specifying the input shape.
+        n_filters: Number of filters in the first convolutional layer.
+        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 or '2D' for 2D CNN.
+        classification_mode: 'binary' for binary classification, 'multi' for multi-class classification.
+
+    Returns:
+        Compiled 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 evaluate_model(model, X_test, y_test, le, mode):
+    """Evaluate the model and display results."""
+    model_logger.info(f"Evaluating the model using {mode} features.")
+    predictions = model.predict(X_test)
+    predicted_classes = np.argmax(predictions, axis=1)
+    y_true = np.argmax(y_test, axis=1)
+
+    # Confusion Matrix
+    conf_matrix = confusion_matrix(y_true, predicted_classes)
+    plt.figure(figsize=(8, 6))
+    plt.imshow(conf_matrix, interpolation='nearest', cmap=plt.cm.Blues)
+    plt.title(f"Confusion Matrix ({mode})")
+    plt.colorbar()
+    plt.tight_layout()
+    plt.ylabel('True label')
+    plt.xlabel('Predicted label')
+    cm_path = f"confusion_matrix_{mode}.png"
+    plt.savefig(cm_path)
+    mlflow.log_artifact(cm_path)
+
+    # ROC Curve
+    fpr, tpr, _ = roc_curve(y_true, predictions[:, 1])
+    auc_score = roc_auc_score(y_true, predictions[:, 1])
+    plt.figure(figsize=(8, 6))
+    plt.plot(fpr, tpr, color='darkorange', lw=2, label=f"ROC curve (area = {auc_score:.2f})")
+    plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')
+    plt.xlabel('False Positive Rate')
+    plt.ylabel('True Positive Rate')
+    plt.title(f"Receiver Operating Characteristic ({mode})")
+    plt.legend(loc="lower right")
+    roc_path = f"roc_curve_{mode}.png"
+    plt.savefig(roc_path)
+    mlflow.log_artifact(roc_path)
+
+    # Log metrics
+    mlflow.log_metric(f"{mode}_auc", auc_score)
+    log_metrics(y_true, predicted_classes, mode)
+
+    model_logger.info(f"Model evaluation using {mode} features complete.")
+
+
+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.
+
+    Args:
+        mode: Feature extraction mode (e.g., 'gru', '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.
+    
+    Args:
+        audio: The input audio signal.
+        sr: The sampling rate of the audio.
+        
+    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 main():
+    mlflow.end_run()
+    
+    data_logger.info("Starting data pipeline.")
+    df = load_data()
+    audio_metadata = process_audio_metadata('/kaggle/input/respiratory-sound-database/Respiratory_Sound_Database/Respiratory_Sound_Database/audio_and_txt_files')
+    df_all = merge_datasets(audio_metadata, df)
+
+    # Define classification modes and feature types
+    classification_modes = [ 'multi', 'binary']  # Options: 'binary', 'multi'
+    feature_types = ['mfcc', 'log_mel', 'augmented']  # Options
+    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, 
+                    '/kaggle/input/respiratory-sound-database/Respiratory_Sound_Database/Respiratory_Sound_Database/audio_and_txt_files',
+                    classification_mode=classification_mode
+                )
+            else:
+                X, y, le = prepare_dataset_parallel(
+                    df_filtered, 
+                    '/kaggle/input/respiratory-sound-database/Respiratory_Sound_Database/Respiratory_Sound_Database/audio_and_txt_files',
+                    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()

main_ui.py

@@ -0,0 +1,35 @@
+import streamlit as st
+from streamlit_ui import readme, data_exploration, model_performance, model_deployment
+
+# Load custom CSS
+with open("streamlit_ui/style.css") as css_file:
+    st.markdown(f'<style>{css_file.read()}</style>', unsafe_allow_html=True)
+
+# Initialize session state for the selected page
+if "active_page" not in st.session_state:
+    st.session_state["active_page"] = "Introduction"
+
+# Streamlit app setup
+st.title("ICBHI 2017 Challenge - Amplifier Health")
+
+# Sidebar Navigation
+st.sidebar.markdown('<div class="sidebar-header">Navigate</div>', unsafe_allow_html=True)
+
+if st.sidebar.button("Introduction"):
+    st.session_state["active_page"] = "Introduction"
+if st.sidebar.button("Data Exploration"):
+    st.session_state["active_page"] = "Data Exploration"
+if st.sidebar.button("Model Performance"):
+    st.session_state["active_page"] = "Model Performance"
+if st.sidebar.button("Model Deployment"):
+    st.session_state["active_page"] = "Model Deployment"
+
+# Page Content
+if st.session_state["active_page"] == "Introduction":
+    readme.run()
+elif st.session_state["active_page"] == "Data Exploration":
+    data_exploration.run()
+elif st.session_state["active_page"] == "Model Performance":
+    model_performance.run()
+elif st.session_state["active_page"] == "Model Deployment":
+    model_deployment.run()

models/archive/latest/final_model_binary_augmented.h5

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

models/archive/latest/final_model_binary_log_mel.h5

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

models/archive/latest/final_model_binary_mfcc.h5

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

models/archive/latest/final_model_multi_augmented.h5

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

models/archive/latest/final_model_multi_log_mel.h5

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

models/archive/latest/final_model_multi_mfcc.h5

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

models/archive/old/final_model_binary_augmented.h5

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

models/archive/old/final_model_binary_log_mel.h5

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

models/archive/old/final_model_binary_mfcc.h5

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

models/archive/old/final_model_multi_augmented.h5

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

models/archive/old/final_model_multi_log_mel.h5

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

models/archive/old/final_model_multi_mfcc.h5

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

models/archive/workingmodels/final_model_binary_augmented.h5

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

models/archive/workingmodels/final_model_binary_log_mel.h5

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

models/archive/workingmodels/final_model_binary_mfcc.h5

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

models/archive/workingmodels/final_model_multi_augmented.h5

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

models/archive/workingmodels/final_model_multi_log_mel.h5

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

models/archive/workingmodels/final_model_multi_mfcc.h5

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

models/final_model_binary_augmented.h5

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

models/final_model_binary_log_mel.h5

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

models/final_model_binary_mfcc.h5

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

models/final_model_multi_augmented.h5

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