Upload 29 files

.gitattributes

@@ -33,3 +33,4 @@ 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
+example/example.wav filter=lfs diff=lfs merge=lfs -text

app.py

@@ -0,0 +1,224 @@
+# app.py
+import gradio as gr
+import os
+import warnings
+from pathlib import Path
+import tempfile
+import librosa
+import soundfile as sf  # Add this import
+import numpy as np
+
+# Suppress warnings for a cleaner interface
+warnings.filterwarnings('ignore')
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
+os.environ['TRANSFORMERS_VERBOSITY'] = 'error'
+
+# Import your framework's components
+from emotion_analysis_framework import EmotionAnalysisFramework, PatientData
+
+# --- Initialization ---
+# Initialize the framework. It will look for the 'model_weights' directory.
+# Make sure this directory is in your Hugging Face Space repository.
+try:
+    print("Initializing Emotion Analysis Framework...")
+    # The model_dir should point to the directory where your models are stored.
+    # In a Hugging Face Space, this will be relative to the app.py file.
+    framework = EmotionAnalysisFramework(model_dir="./model_weights", verbose=False)
+    print("Framework initialized successfully!")
+    FRAMEWORK_INITIALIZED = True
+except Exception as e:
+    print(f"FATAL: Error initializing framework: {e}")
+    print("Please ensure the 'model_weights' directory is present and contains the model files.")
+    FRAMEWORK_INITIALIZED = False
+    # Define a placeholder framework to avoid crashing the app
+    framework = None
+
+
+# --- Prediction Function ---
+def analyze_emotion(audio_file, sex, race, education, age):
+    """
+    This function is the core of the Gradio app. It takes user inputs,
+    runs the prediction, and returns the formatted results.
+    """
+    if not FRAMEWORK_INITIALIZED or framework is None:
+        return "Error: Framework not initialized. Check logs.", "", "", "", "", ""
+
+    if audio_file is None:
+        return "Please upload an audio file.", "", "", "", "", ""
+
+    try:
+        # Gradio provides the audio file as a temporary file path
+        audio_path = audio_file
+
+        # Take that audio file and make sure that the sr is 16000 Hz
+        if isinstance(audio_path, str):
+            # Ensure the audio file is a valid path
+            if not Path(audio_path).is_file():
+                return "Invalid audio file path.", "", "", "", "", ""
+        else:
+            # If the audio file is not a string, it might be a temporary file object
+            with tempfile.NamedTemporaryFile(delete=False, suffix='.wav') as temp_file:
+                temp_file.write(audio_file.read())
+                audio_path = temp_file.name
+
+        # Ensure the audio file is in the correct format (e.g., .wav)
+        if not audio_path.endswith('.wav'):
+            return "Please upload a valid .wav audio file.", "", "", "", "", ""
+
+        # Validate demographic inputs
+        if not isinstance(education, int) or not (0 <= education <= 30):
+            return "Education must be an integer between 0 and 30.", "", "", "", "", ""
+
+        # Check the audio sr and if its not 16000 Hz, resample it
+        try:
+            audio_data, sr = librosa.load(audio_path, sr=None)
+            if sr != 16000:
+                # print(f"Resampling audio from {sr}Hz to 16000Hz")
+                audio_data = librosa.resample(audio_data, orig_sr=sr, target_sr=16000)
+
+                # Create a temporary file for the resampled audio
+                with tempfile.NamedTemporaryFile(delete=False, suffix='.wav') as temp_file:
+                    temp_path = temp_file.name
+                    # Use soundfile to save the resampled audio
+                    sf.write(temp_path, audio_data, 16000)
+                    audio_path = temp_path
+        except Exception as e:
+            return f"Error processing audio file: {e}", "", "", "", "", ""
+
+        # Create a PatientData object with the inputs
+        patient_demographics = {
+            'sex': 0 if sex == "Female" else 1,
+            'race': 1 if race == "White" else 0,  # Assuming 1 for White, 0 for others as an example
+            'educ': int(education),
+            'entryage': int(age)
+        }
+
+        patient = PatientData(
+            patient_id="gradio_user",
+            audio_path=audio_path,
+            demographics=patient_demographics
+        )
+
+        # Run prediction for all tasks
+        results = framework.predict(patient)
+
+        # --- Format the results for display ---
+        # Binary Classification Results
+        binary_res = results.get('binary')
+        if binary_res and 'error' not in binary_res.predictions:
+            binary_label = f"Prediction: {binary_res.predictions.get('label', 'N/A')}"
+            binary_confidence = f"Confidence: {binary_res.confidence:.2%}"
+        else:
+            binary_label = "Binary analysis failed."
+            binary_confidence = str(binary_res.predictions.get('error', '')) if binary_res else "Unknown error."
+
+        # Multiclass Classification Results
+        multiclass_res = results.get('multiclass')
+        if multiclass_res and 'error' not in multiclass_res.predictions:
+            multiclass_label = f"Prediction: {multiclass_res.predictions.get('label', 'N/A')}"
+            multiclass_confidence = f"Confidence: {multiclass_res.confidence:.2%}"
+        else:
+            multiclass_label = "Multiclass analysis failed."
+            multiclass_confidence = str(
+                multiclass_res.predictions.get('error', '')) if multiclass_res else "Unknown error."
+
+        # Regression Results
+        regression_res = results.get('regression')
+        if regression_res and 'error' not in regression_res.predictions:
+            mmse_score = f"Predicted MMSE Score: {regression_res.predictions.get('mmse_score', 0):.2f}"
+            mmse_std = f"Standard Deviation: ±{regression_res.predictions.get('std', 0):.2f}"
+        else:
+            mmse_score = "MMSE prediction failed."
+            mmse_std = str(regression_res.predictions.get('error', '')) if regression_res else "Unknown error."
+
+        return binary_label, binary_confidence, multiclass_label, multiclass_confidence, mmse_score, mmse_std
+
+    except Exception as e:
+        print(f"An error occurred during prediction: {e}")
+        return f"An error occurred: {e}", "", "", "", "", ""
+
+
+# --- Gradio Interface Definition ---
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 🧠 Emotion and Cognitive Health Analysis from Speech")
+    gr.Markdown(
+        "Upload a patient's audio recording and provide their demographic information to get an analysis. "
+        "This tool provides predictions for Alzheimer's Disease (AD) vs. Healthy Control (HC), a multiclass "
+        "prediction (HC/MCI/AD), and an estimated MMSE score."
+    )
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### Inputs")
+            # Audio Input
+            audio_input = gr.Audio(type="filepath", label="Upload Patient Audio (.wav)")
+
+            # Demographics Inputs
+            sex_input = gr.Radio(["Female", "Male"], label="Sex")
+            race_input = gr.Radio(["White", "Other"], label="Race")  # Adjust as needed
+            education_input = gr.Slider(minimum=0, maximum=30, step=1, value=16, label="Years of Education")
+            age_input = gr.Slider(minimum=40, maximum=100, step=1, value=65, label="Age at Entry")
+
+            analyze_btn = gr.Button("Analyze", variant="primary")
+
+        with gr.Column(scale=2):
+            gr.Markdown("### Analysis Results")
+            # Binary Classification Output
+            with gr.Group():
+                gr.Label("Binary Classification (AD vs. HC)")
+                binary_output_label = gr.Textbox(label="Result")
+                binary_output_confidence = gr.Textbox(label="Confidence")
+
+            # Multiclass Classification Output
+            with gr.Group():
+                gr.Label("Multiclass Classification (HC vs. MCI vs. AD)")
+                multiclass_output_label = gr.Textbox(label="Result")
+                multiclass_output_confidence = gr.Textbox(label="Confidence")
+
+            # Regression Output
+            with gr.Group():
+                gr.Label("MMSE Score Regression")
+                regression_output_score = gr.Textbox(label="MMSE Score")
+                regression_output_std = gr.Textbox(label="Standard Deviation")
+
+    # Connect the button to the prediction function
+    analyze_btn.click(
+        fn=analyze_emotion,
+        inputs=[audio_input, sex_input, race_input, education_input, age_input],
+        outputs=[
+            binary_output_label,
+            binary_output_confidence,
+            multiclass_output_label,
+            multiclass_output_confidence,
+            regression_output_score,
+            regression_output_std
+        ]
+    )
+
+    gr.Markdown("---")
+    gr.Markdown(
+        "**Disclaimer:** This tool is for research purposes only and is not a substitute for professional medical advice, diagnosis, or treatment."
+    )
+    gr.Examples(
+        examples=[
+            ["./example/example.wav", "Female", "White", 16, 58],
+        ],
+        inputs=[audio_input, sex_input, race_input, education_input, age_input],
+        fn=analyze_emotion,
+        outputs=[
+            binary_output_label,
+            binary_output_confidence,
+            multiclass_output_label,
+            multiclass_output_confidence,
+            regression_output_score,
+            regression_output_std
+        ],
+        cache_examples=True
+    )
+
+if __name__ == "__main__":
+    # To run locally:
+    # 1. Make sure you have all dependencies from requirements.txt installed.
+    # 2. Place your 'model_weights' and 'example' folders in the same directory as this script.
+    # 3. Run 'python app.py' in your terminal.
+    demo.launch()

emotion_analysis_framework.py

@@ -0,0 +1,546 @@
+"""
+Emotion Analysis Framework
+A framework for analyzing emotions from patient audio recordings using wav2vec2 models.
+
+Author: Marek Sviderski
+
+This framework supports three main tasks:
+- Binary classification: Distinguishing between Alzheimer's Disease (AD) and Healthy Control (HC)
+- Multiclass classification: Classifying into HC, Mild Cognitive Impairment (MCI), and AD
+- Regression: Predicting the Mini-Mental State Examination (MMSE) score
+
+This code is designed to be modular and extensible, allowing for easy integration of new models and strategies.
+
+It uses dataclasses for structured data representation and provides methods for feature extraction, model loading, and predictions.
+"""
+
+import os
+from pathlib import Path
+from typing import Dict, List, Optional, Union, Any
+from dataclasses import dataclass, field
+import numpy as np
+import pandas as pd
+import torch
+import joblib
+import warnings
+
+from utils.config import ProjectConfig
+from utils.config_types import ChunkLength
+from models.inference_wav2vec import Wav2VecInference
+from preprocessing.flattening_statistical import StatisticalFlattening
+from preprocessing.flattening_categorical import CategoricalFlattening
+from preprocessing.flattening_minirocket import MiniRocketFlattening
+
+warnings.filterwarnings('ignore', category=UserWarning, module='xgboost')
+warnings.filterwarnings('ignore', message='Some weights of the model checkpoint')
+warnings.filterwarnings('ignore', message='Some weights of Wav2Vec2ForSequenceClassification')
+
+
+
+@dataclass
+class PatientData:
+    """Data class for patient information"""
+    patient_id: str
+    audio_path: str
+    demographics: Dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class PredictionResult:
+    """Data class for prediction results"""
+    patient_id: str
+    task: str
+    predictions: Dict[str, Any]
+    probabilities: Optional[Dict[str, Any]] = None
+    confidence: Optional[float] = None
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+    def summary(self) -> str:
+        """Return a clean summary of the prediction"""
+        if self.task == 'binary':
+            return f"Binary: {self.predictions['label']} (confidence: {self.confidence:.2f})"
+        elif self.task == 'multiclass':
+            return f"Multiclass: {self.predictions['label']} (confidence: {self.confidence:.2f})"
+        elif self.task == 'regression':
+            return f"MMSE Score: {self.predictions['mmse_score']:.1f} ± {self.predictions['std']:.1f}"
+        else:
+            return str(self.predictions)
+
+
+class EmotionAnalysisFramework:
+    """
+    End-to-end framework for emotion analysis from patient recordings.
+
+    This framework provides three prediction tasks:
+    - Binary classification: AD vs Healthy Control (HC)
+    - Multiclass classification: HC vs MCI vs AD
+    - Regression: MMSE score prediction
+
+    Args:
+        config_path: Optional path to custom configuration
+        model_dir: Path to directory containing model weights
+        verbose: Whether to print detailed progress information
+    """
+
+    def __init__(self, config_path: Optional[str] = None,
+                 model_dir: Optional[str] = None,
+                 verbose: bool = False):
+        self.config = ProjectConfig(config_path) if config_path else ProjectConfig()
+        self.model_dir = model_dir
+        self.verbose = verbose
+        self.wav2vec_model = None
+        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+        self.models = {
+            'binary': {},
+            'multiclass': {},
+            'regression': {}
+        }
+        self.strategies = {}
+        self._initialize_strategies()
+        self._load_models()
+
+    def _log(self, message: str):
+        """Print message only if verbose mode is enabled"""
+        if self.verbose:
+            print(message)
+
+    def _initialize_strategies(self):
+        """Initialize all flattening strategies"""
+        self.strategies = {
+            'statistical': StatisticalFlattening(),
+            'categorical': CategoricalFlattening(),
+            'minirocket': MiniRocketFlattening()
+        }
+
+    def _load_models(self):
+        """Load all trained models"""
+        if not self.model_dir:
+            # Try to find models in package directory
+            package_dir = os.path.dirname(os.path.abspath(__file__))
+            self.model_dir = os.path.join(package_dir, "model_weights")
+
+        if not os.path.exists(self.model_dir):
+            raise ValueError(f"Model directory not found: {self.model_dir}")
+
+        # Load models for each task
+        self._load_task_models('binary', os.path.join(self.model_dir, "binary"))
+        self._load_task_models('multiclass', os.path.join(self.model_dir, "multiclass"))
+        self._load_task_models('regression', os.path.join(self.model_dir, "regression"))
+
+        # Verify models were loaded
+        for task in ['binary', 'multiclass', 'regression']:
+            if not self.models[task]:
+                raise ValueError(f"No {task} models found in {self.model_dir}")
+
+    def _load_task_models(self, task: str, path: str):
+        """Load models for a specific task"""
+        if not os.path.exists(path):
+            self._log(f"Warning: {task} model path not found: {path}")
+            return
+
+        model_type = 'simple' if task in ['binary', 'regression'] else 'fusion'
+        self.models[task][model_type] = {}
+
+        model_files = [f for f in os.listdir(path)
+                       if f.startswith('model_fold_') and f.endswith('.joblib')]
+
+        for file in model_files:
+            fold_num = file.split('_')[-1].replace('.joblib', '')
+            model_path = os.path.join(path, file)
+            try:
+                self.models[task][model_type][fold_num] = joblib.load(model_path)
+                self._log(f"Loaded {task} {model_type} model fold {fold_num}")
+            except Exception as e:
+                self._log(f"Error loading model {model_path}: {e}")
+
+    def _extract_wav2vec_features(self, audio_path: str, chunk_length: ChunkLength) -> pd.DataFrame:
+        """Extract wav2vec features from audio file"""
+        if self.wav2vec_model is None:
+            self.wav2vec_model = Wav2VecInference(self.config, verbose=self.verbose)
+            self.wav2vec_model.load_model()
+
+        chunk_config = self.config.get_chunk_params(chunk_length)
+
+        emotions_over_time = self.wav2vec_model.analyze_emotions_over_time(
+            audio_path,
+            segment_duration=chunk_config.segment_duration,
+            overlap_duration=chunk_config.overlap_duration
+        )
+
+        rows = []
+        for start, end, emotions in emotions_over_time:
+            rows.append({
+                'filename': str(Path(audio_path).stem),
+                'start': start,
+                'end': end,
+                **emotions
+            })
+
+        return pd.DataFrame(rows)
+
+    def _prepare_features(self, patient_data: PatientData, task: str) -> Dict[str, pd.DataFrame]:
+        """Prepare features for a specific task - FIXED VERSION"""
+        prepared_data = {}
+
+        if task == 'binary':
+            # Binary uses statistical flattening with 3.5s chunks
+            df_3_5 = self._extract_wav2vec_features(patient_data.audio_path, ChunkLength.LENGTH_3_5)
+            flattened = self.strategies['statistical'].flatten_dataframe(df_3_5)
+
+            # Add demographics more efficiently
+            if patient_data.demographics:
+                # Create a copy and add all demographics at once
+                demo_df = pd.DataFrame([patient_data.demographics] * len(flattened))
+                flattened = pd.concat([flattened, demo_df], axis=1)
+
+            prepared_data['simple'] = flattened
+
+        elif task == 'multiclass':
+            # Multiclass uses categorical flattening with different chunk lengths
+            df_1_5 = self._extract_wav2vec_features(patient_data.audio_path, ChunkLength.LENGTH_1_5)
+            df_4_5 = self._extract_wav2vec_features(patient_data.audio_path, ChunkLength.LENGTH_4_5)
+
+            flattened_1_5 = self.strategies['categorical'].flatten_dataframe(df_1_5)
+            flattened_4_5 = self.strategies['categorical'].flatten_dataframe(df_4_5)
+
+            if patient_data.demographics:
+                # Add demographics efficiently
+                demo_df = pd.DataFrame([patient_data.demographics])
+                flattened_1_5 = pd.concat([flattened_1_5, demo_df], axis=1)
+                flattened_4_5 = pd.concat([flattened_4_5, demo_df], axis=1)
+
+            prepared_data['chunk1'] = flattened_1_5
+            prepared_data['chunk2'] = flattened_4_5
+
+        elif task == 'regression':
+            # Regression uses minirocket for 1.5s and 3.5s, categorical for 4.5s
+            df_1_5 = self._extract_wav2vec_features(patient_data.audio_path, ChunkLength.LENGTH_1_5)
+            df_3_5 = self._extract_wav2vec_features(patient_data.audio_path, ChunkLength.LENGTH_3_5)
+            df_4_5 = self._extract_wav2vec_features(patient_data.audio_path, ChunkLength.LENGTH_4_5)
+
+            flattened_1_5 = self.strategies['minirocket'].flatten_dataframe(df_1_5)
+            flattened_3_5 = self.strategies['minirocket'].flatten_dataframe(df_3_5)
+            flattened_4_5 = self.strategies['categorical'].flatten_dataframe(df_4_5)
+
+            if patient_data.demographics:
+                # Add demographics efficiently to 4_5 only
+                demo_df = pd.DataFrame([patient_data.demographics])
+                flattened_4_5 = pd.concat([flattened_4_5, demo_df], axis=1)
+
+            prepared_data['chunk_1_5'] = flattened_1_5
+            prepared_data['chunk_3_5'] = flattened_3_5
+            prepared_data['chunk_4_5_demo'] = flattened_4_5
+
+        return prepared_data
+
+    def _predict_binary(self, features: Dict[str, pd.DataFrame]) -> PredictionResult:
+        """Make binary classification predictions - FIXED"""
+        model_type = 'simple'
+
+        if model_type not in self.models['binary'] or not self.models['binary'][model_type]:
+            raise ValueError(f"No binary models loaded")
+
+        fold_predictions = []
+        fold_probabilities = []
+
+        # Get the patient ID from features
+        patient_id = 'unknown'
+        if 'filename' in features[model_type].columns:
+            patient_id = features[model_type]['filename'].iloc[0]
+
+        # Get predictions from all folds
+        for fold_num, model in self.models['binary'][model_type].items():
+            try:
+                X = features[model_type]
+
+                # Ensure correct feature order
+                if hasattr(model, 'feature_names_in_'):
+                    # Only use features that the model was trained on
+                    model_features = [f for f in model.feature_names_in_ if f in X.columns]
+                    X = X[model_features]
+
+                pred = model.predict(X)
+                pred_proba = model.predict_proba(X)
+
+                fold_predictions.append(pred[0])
+                fold_probabilities.append(pred_proba[0])
+            except Exception as e:
+                self._log(f"Error in fold {fold_num}: {e}")
+                continue
+
+        if not fold_predictions:
+            raise ValueError("No successful predictions from any fold")
+
+        # Aggregate predictions (majority vote)
+        final_prediction = int(np.round(np.mean(fold_predictions)))
+        mean_probabilities = np.mean(fold_probabilities, axis=0)
+
+        return PredictionResult(
+            patient_id=patient_id,
+            task='binary',
+            predictions={'class': final_prediction, 'label': 'AD' if final_prediction else 'HC'},
+            probabilities={'HC': float(mean_probabilities[0]), 'AD': float(mean_probabilities[1])},
+            confidence=float(np.max(mean_probabilities)),
+            metadata={'model_type': model_type, 'num_folds': len(fold_predictions)}
+        )
+
+    def _predict_multiclass(self, features: Dict[str, pd.DataFrame]) -> PredictionResult:
+        """Make multiclass classification predictions - FIXED"""
+        if 'fusion' not in self.models['multiclass'] or not self.models['multiclass']['fusion']:
+            raise ValueError("No multiclass fusion model loaded")
+
+        fold_predictions = []
+        fold_probabilities = []
+        class_labels = ['HC', 'MCI', 'AD']
+
+        # Get patient ID
+        patient_id = 'unknown'
+        if 'filename' in features['chunk1'].columns:
+            patient_id = features['chunk1']['filename'].iloc[0]
+
+        for fold_num, model_pack in self.models['multiclass']['fusion'].items():
+            try:
+                # Prepare features for each model
+                model1 = model_pack['chunk1']
+                model2 = model_pack['chunk2']
+
+                # Get features that the models were trained on
+                X_chunk1 = features['chunk1']
+                X_chunk2 = features['chunk2']
+
+                # Ensure we have the right features
+                if hasattr(model1, 'feature_names_in_'):
+                    model1_features = [f for f in model1.feature_names_in_ if f in X_chunk1.columns]
+                    X_chunk1 = X_chunk1[model1_features]
+
+                if hasattr(model2, 'feature_names_in_'):
+                    model2_features = [f for f in model2.feature_names_in_ if f in X_chunk2.columns]
+                    X_chunk2 = X_chunk2[model2_features]
+
+                pred_proba_1 = model1.predict_proba(X_chunk1)
+                pred_proba_2 = model2.predict_proba(X_chunk2)
+
+                # Apply fusion weights
+                weights = model_pack.get('weights', [0.5, 0.5])
+                fusion_proba = weights[0] * pred_proba_1 + weights[1] * pred_proba_2
+
+                pred = np.argmax(fusion_proba, axis=1)
+
+                fold_predictions.append(pred[0])
+                fold_probabilities.append(fusion_proba[0])
+            except Exception as e:
+                self._log(f"Error in multiclass fold {fold_num}: {e}")
+                continue
+
+        if not fold_predictions:
+            raise ValueError("No successful multiclass predictions from any fold")
+
+        # Aggregate predictions
+        final_prediction = int(np.round(np.mean(fold_predictions)))
+        mean_probabilities = np.mean(fold_probabilities, axis=0)
+
+        prob_dict = {label: float(prob) for label, prob in zip(class_labels, mean_probabilities)}
+
+        return PredictionResult(
+            patient_id=patient_id,
+            task='multiclass',
+            predictions={'class': final_prediction, 'label': class_labels[final_prediction]},
+            probabilities=prob_dict,
+            confidence=float(np.max(mean_probabilities)),
+            metadata={'num_folds': len(fold_predictions)}
+        )
+
+    def _predict_regression(self, features: Dict[str, pd.DataFrame]) -> PredictionResult:
+        """Make regression predictions - FIXED"""
+        model_type = 'simple'
+
+        if model_type not in self.models['regression'] or not self.models['regression'][model_type]:
+            raise ValueError("No regression models loaded")
+
+        fold_predictions = []
+
+        # Get patient ID
+        patient_id = 'unknown'
+        if 'filename' in features['chunk_1_5'].columns:
+            patient_id = features['chunk_1_5']['filename'].iloc[0]
+
+        for fold_num, model_pack in self.models['regression'][model_type].items():
+            try:
+                # Simple fusion prediction
+                models = model_pack['models']
+                weights = model_pack['weights']
+
+                # Get predictions from each model with proper feature selection
+                model1 = models["ridge_1_5_minirocket"]
+                X1 = features['chunk_1_5']
+                if hasattr(model1, 'feature_names_in_'):
+                    model1_features = [f for f in model1.feature_names_in_ if f in X1.columns]
+                    X1 = X1[model1_features]
+                pred1 = model1.predict(X1)
+
+                model2 = models["ridge_3_5_minirocket"]
+                X2 = features['chunk_3_5']
+                if hasattr(model2, 'feature_names_in_'):
+                    model2_features = [f for f in model2.feature_names_in_ if f in X2.columns]
+                    X2 = X2[model2_features]
+                pred2 = model2.predict(X2)
+
+                model3 = models["ridge_4_5_categorical"]
+                X3 = features['chunk_4_5_demo']
+                if hasattr(model3, 'feature_names_in_'):
+                    model3_features = [f for f in model3.feature_names_in_ if f in X3.columns]
+                    X3 = X3[model3_features]
+                pred3 = model3.predict(X3)
+
+                final_pred = weights[0] * pred1 + weights[1] * pred2 + weights[2] * pred3
+                fold_predictions.append(final_pred[0])
+
+            except Exception as e:
+                self._log(f"Error in regression fold {fold_num}: {e}")
+                continue
+
+        if not fold_predictions:
+            raise ValueError("No successful regression predictions from any fold")
+
+        # Aggregate predictions
+        final_prediction = float(np.mean(fold_predictions))
+        std_prediction = float(np.std(fold_predictions))
+
+        return PredictionResult(
+            patient_id=patient_id,
+            task='regression',
+            predictions={'mmse_score': final_prediction, 'std': std_prediction},
+            confidence=1.0 / (1.0 + std_prediction),
+            metadata={'model_type': model_type, 'num_folds': len(fold_predictions)}
+        )
+
+    def _predict_regression(self, features: Dict[str, pd.DataFrame]) -> PredictionResult:
+        """Make regression predictions - FIXED"""
+        model_type = 'simple'
+
+        if model_type not in self.models['regression'] or not self.models['regression'][model_type]:
+            raise ValueError("No regression models loaded")
+
+        fold_predictions = []
+
+        # Get patient ID
+        patient_id = 'unknown'
+        if 'filename' in features['chunk_1_5'].columns:
+            patient_id = features['chunk_1_5']['filename'].iloc[0]
+
+        for fold_num, model_pack in self.models['regression'][model_type].items():
+            try:
+                # Simple fusion prediction
+                models = model_pack['models']
+                weights = model_pack['weights']
+
+                # Get predictions from each model with proper feature selection
+                model1 = models["ridge_1_5_minirocket"]
+                X1 = features['chunk_1_5']
+                if hasattr(model1, 'feature_names_in_'):
+                    model1_features = [f for f in model1.feature_names_in_ if f in X1.columns]
+                    X1 = X1[model1_features]
+                pred1 = model1.predict(X1)
+
+                model2 = models["ridge_3_5_minirocket"]
+                X2 = features['chunk_3_5']
+                if hasattr(model2, 'feature_names_in_'):
+                    model2_features = [f for f in model2.feature_names_in_ if f in X2.columns]
+                    X2 = X2[model2_features]
+                pred2 = model2.predict(X2)
+
+                model3 = models["ridge_4_5_categorical"]
+                X3 = features['chunk_4_5_demo']
+                if hasattr(model3, 'feature_names_in_'):
+                    model3_features = [f for f in model3.feature_names_in_ if f in X3.columns]
+                    X3 = X3[model3_features]
+                pred3 = model3.predict(X3)
+
+                final_pred = weights[0] * pred1 + weights[1] * pred2 + weights[2] * pred3
+                fold_predictions.append(final_pred[0])
+
+            except Exception as e:
+                self._log(f"Error in regression fold {fold_num}: {e}")
+                continue
+
+        if not fold_predictions:
+            raise ValueError("No successful regression predictions from any fold")
+
+        # Aggregate predictions
+        final_prediction = float(np.mean(fold_predictions))
+        std_prediction = float(np.std(fold_predictions))
+
+        return PredictionResult(
+            patient_id=patient_id,
+            task='regression',
+            predictions={'mmse_score': final_prediction, 'std': std_prediction},
+            confidence=1.0 / (1.0 + std_prediction),
+            metadata={'model_type': model_type, 'num_folds': len(fold_predictions)}
+        )
+
+    def predict(self, patient_data: Union[PatientData, List[PatientData]],
+                task: Optional[str] = None) -> Union[
+        PredictionResult, List[PredictionResult], Dict[str, PredictionResult]]:
+        """
+        Make predictions for one or more patients.
+
+        Args:
+            patient_data: Single PatientData or list of PatientData objects
+            task: Specific task ('binary', 'multiclass', 'regression') or None for all
+
+        Returns:
+            Single PredictionResult, list of results, or dict of results by task
+        """
+        # Handle single patient
+        if isinstance(patient_data, PatientData):
+            patient_data = [patient_data]
+            single_patient = True
+        else:
+            single_patient = False
+
+        results = []
+
+        for patient in patient_data:
+            patient_results = {}
+
+            tasks_to_run = [task] if task else ['binary', 'multiclass', 'regression']
+
+            for current_task in tasks_to_run:
+                try:
+                    # Prepare features for the task
+                    features = self._prepare_features(patient, current_task)
+
+                    # Make predictions based on task
+                    if current_task == 'binary':
+                        result = self._predict_binary(features)
+                    elif current_task == 'multiclass':
+                        result = self._predict_multiclass(features)
+                    elif current_task == 'regression':
+                        result = self._predict_regression(features)
+                    else:
+                        raise ValueError(f"Unknown task: {current_task}")
+
+                    # Fix: use patient from the loop, not patient_data
+                    result.patient_id = patient.patient_id
+                    patient_results[current_task] = result
+
+                except Exception as e:
+                    self._log(f"Error predicting {current_task} for patient {patient.patient_id}: {e}")
+                    patient_results[current_task] = PredictionResult(
+                        patient_id=patient.patient_id,
+                        task=current_task,
+                        predictions={'error': str(e)},
+                        metadata={'status': 'failed'}
+                    )
+
+            # Return appropriate format
+            if task:  # Single task
+                results.append(patient_results[task])
+            else:  # All tasks
+                results.append(patient_results)
+
+        # Format return based on input
+        if single_patient:
+            return results[0]
+        else:
+            return results

example/example.wav

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

model_weights/binary/model_fold_0.joblib

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

model_weights/binary/model_fold_1.joblib

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

model_weights/binary/model_fold_2.joblib

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

model_weights/binary/model_fold_3.joblib

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

model_weights/binary/model_fold_4.joblib

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

model_weights/multiclass/model_fold_0.joblib

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

model_weights/multiclass/model_fold_1.joblib

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

model_weights/multiclass/model_fold_2.joblib

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

model_weights/multiclass/model_fold_3.joblib

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

model_weights/multiclass/model_fold_4.joblib

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

model_weights/regression/model_fold_0.joblib

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

model_weights/regression/model_fold_1.joblib

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

model_weights/regression/model_fold_2.joblib

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

model_weights/regression/model_fold_3.joblib

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

model_weights/regression/model_fold_4.joblib

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

models/__init__.py

@@ -0,0 +1,17 @@
+# models/__init__.py
+from .inference_wav2vec import Wav2VecInference
+
+__all__ = ["Wav2VecInference"]
+
+# preprocessing/__init__.py
+from preprocessing.flattening_base import BaseFlattening
+from preprocessing.flattening_categorical import CategoricalFlattening
+from preprocessing.flattening_minirocket import MiniRocketFlattening
+from preprocessing.flattening_statistical import StatisticalFlattening
+
+__all__ = [
+    "BaseFlattening",
+    "CategoricalFlattening",
+    "MiniRocketFlattening",
+    "StatisticalFlattening"
+]

models/inference_wav2vec.py

@@ -0,0 +1,127 @@
+import os
+import warnings
+from typing import List
+import numpy as np
+import pandas as pd
+import torch
+from pydub import AudioSegment
+from transformers import AutoModelForAudioClassification, Wav2Vec2FeatureExtractor
+
+from utils.config_types import ChunkLength
+
+# Suppress specific warnings
+warnings.filterwarnings('ignore', message='Passing `gradient_checkpointing` to a config initialization')
+warnings.filterwarnings('ignore', message='Some weights of the model checkpoint')
+warnings.filterwarnings('ignore', message='Some weights of Wav2Vec2ForSequenceClassification')
+
+
+class Wav2VecInference:
+    """Implementation for wav2vec emotion recognition model."""
+    name = "wav2vec"
+
+    def __init__(self, config, verbose=False):
+        self.config = config
+        self.verbose = verbose
+        self.input_directory = self.config.get_full_path(self.config.paths['data'].raw)
+        self.output_path = self.config.get_full_path(self.config.paths['data'].processed)
+        self.id2label = {
+            "0": "angry", "1": "calm", "2": "disgust", "3": "fearful",
+            "4": "happy", "5": "neutral", "6": "sad", "7": "surprised"
+        }
+        self.model = None
+        self.feature_extractor = None
+
+    def get_emotion_labels(self) -> List[str]:
+        """Return a list of emotion labels used by this model."""
+        return list(self.id2label.values())
+
+    def load_model(self):
+        """Load the wav2vec model and feature extractor."""
+        if self.model is None or self.feature_extractor is None:
+            if self.verbose:
+                print("Loading wav2vec2 emotion recognition model...")
+
+            # Suppress warnings during model loading
+            with warnings.catch_warnings():
+                warnings.filterwarnings("ignore")
+
+                # Load the model without the gradient_checkpointing parameter
+                self.model = AutoModelForAudioClassification.from_pretrained(
+                    "ehcalabres/wav2vec2-lg-xlsr-en-speech-emotion-recognition",
+                    ignore_mismatched_sizes=True  # This helps with the weights warning
+                ).to(self.config.settings.device)
+
+                self.feature_extractor = Wav2Vec2FeatureExtractor.from_pretrained(
+                    "facebook/wav2vec2-large-xlsr-53"
+                )
+
+            if self.verbose:
+                print("Model loaded successfully.")
+
+    def _predict_emotion_from_segment(self, segment):
+        """Predict emotions for a single audio segment."""
+        # Convert to mono numpy array
+        waveform = np.array(segment.get_array_of_samples()).astype(np.float32)
+        if segment.channels == 2:
+            waveform = waveform.reshape((-1, 2)).mean(axis=1)
+        waveform = waveform.reshape(-1)
+
+        # Extract features
+        inputs = self.feature_extractor(
+            waveform,
+            sampling_rate=segment.frame_rate,
+            return_tensors="pt",
+            padding=True
+        )
+        inputs = {k: v.to(self.config.settings.device) for k, v in inputs.items()}
+
+        # Get predictions
+        with torch.no_grad():
+            logits = self.model(**inputs).logits
+            probabilities = torch.softmax(logits, dim=1).cpu().squeeze().tolist()
+
+        return {self.id2label[str(i)]: float(prob) for i, prob in enumerate(probabilities)}
+
+    def analyze_emotions_over_time(self, audio_file: str, segment_duration: int,
+                                   overlap_duration: int) -> list:
+        """
+        Analyze emotions in chunks over the duration of an audio file.
+
+        Args:
+            audio_file: Path to the audio file
+            segment_duration: Duration of each segment in milliseconds
+            overlap_duration: Overlap between segments in milliseconds
+
+        Returns:
+            List of tuples (start_time, end_time, emotion_probabilities)
+        """
+        sound = AudioSegment.from_file(audio_file)
+        duration = len(sound)
+        emotions_over_time = []
+
+        start = 0
+        total_segments = 0
+
+        # Calculate total number of segments for progress tracking
+        if self.verbose:
+            temp_start = 0
+            while temp_start + segment_duration <= duration:
+                total_segments += 1
+                temp_start += segment_duration - overlap_duration
+            print(f"Processing {total_segments} segments from audio file...")
+
+        segment_count = 0
+        while start + segment_duration <= duration:
+            segment = sound[start:start + segment_duration]
+            emotion_probabilities = self._predict_emotion_from_segment(segment)
+            emotions_over_time.append((start, start + segment_duration, emotion_probabilities))
+            start += segment_duration - overlap_duration
+
+            segment_count += 1
+            if self.verbose and segment_count % 10 == 0:
+                print(f"  Processed {segment_count}/{total_segments} segments...")
+
+        if self.verbose:
+            print(f"  Completed processing {segment_count} segments.")
+
+        return emotions_over_time

preprocessing/flattening_base.py

@@ -0,0 +1,16 @@
+from abc import ABC, abstractmethod
+import pandas as pd
+
+
+class BaseFlattening(ABC):
+    name = "base"
+
+    @abstractmethod
+    def flatten_dataframe(self, df: pd.DataFrame) -> pd.DataFrame:
+        pass
+
+    def get_name(self) -> str:
+        return self.name
+
+    def __str__(self):
+        return self.name

preprocessing/flattening_categorical.py

@@ -0,0 +1,108 @@
+import pandas as pd
+from sklearn.preprocessing import LabelEncoder
+
+from preprocessing.flattening_base import BaseFlattening
+
+
+class CategoricalFlattening(BaseFlattening):
+    def __init__(self):
+        """Initialize the categorical flattening strategy."""
+        self.name = "categorical"
+        self.label_encoder = LabelEncoder()
+        # Maximum number of positions to encode individually
+        self.max_positions = 1000
+
+    def flatten_dataframe(self, df: pd.DataFrame) -> pd.DataFrame:
+        """
+        Implement categorical flattening for the combined DataFrame.
+        For each row, identifies the most dominant emotion and creates
+        a fixed-length sequence of these dominant emotions for each patient.
+        Additionally, adds summary features to capture information from longer sequences.
+
+        Args:
+            df: DataFrame containing all inference results
+
+        Returns:
+            DataFrame containing categorical features with encoded emotions
+        """
+        # Group by filename (patient ID)
+        grouped = df.groupby('filename')
+        results = []
+
+        emotion_columns = [col for col in df.columns
+                           if col not in ['start', 'end', 'filename']]
+
+        # Calculate global sequence statistics to determine max positions
+        sequence_lengths = []
+        for _, group in grouped:
+            sequence_lengths.append(len(group))
+
+        # Get the 95th percentile of sequence lengths to determine max_positions
+        if sequence_lengths:
+            # Only adjust max_positions if we have enough data
+            if len(sequence_lengths) > 10:
+                p95_length = int(pd.Series(sequence_lengths).quantile(0.95))
+                # Limit to a reasonable maximum (30) to prevent too many columns
+                self.max_positions = min(p95_length, self.max_positions)
+
+        for filename, group in grouped:
+            # Get the dominant emotion for each time point
+            dominant_emotions = group[emotion_columns].idxmax(axis=1)
+
+            # Create features dictionary for this patient
+            features = {'filename': filename}
+
+            # Add sequence length as a feature
+            features['sequence_length'] = len(dominant_emotions)
+
+            # Add fixed-length position features (up to max_positions)
+            for i in range(1, self.max_positions + 1):
+                if i <= len(dominant_emotions):
+                    features[f'emotion_pos_{i}'] = dominant_emotions.iloc[i - 1]
+                else:
+                    # For shorter sequences, use a consistent padding value
+                    features[f'emotion_pos_{i}'] = "padding"
+
+            # Add summary features for the entire sequence
+            for emotion in emotion_columns:
+                # Count occurrences of each emotion
+                features[f'count_{emotion}'] = (dominant_emotions == emotion).sum()
+                # Calculate proportion of each emotion
+                features[f'prop_{emotion}'] = features[f'count_{emotion}'] / len(dominant_emotions) if len(
+                    dominant_emotions) > 0 else 0
+
+            # Add summary of emotion transitions
+            if len(dominant_emotions) > 1:
+                transitions = 0
+                for i in range(len(dominant_emotions) - 1):
+                    if dominant_emotions.iloc[i] != dominant_emotions.iloc[i + 1]:
+                        transitions += 1
+                features['emotion_transitions'] = transitions
+                features['emotion_transitions_ratio'] = transitions / (len(dominant_emotions) - 1)
+            else:
+                features['emotion_transitions'] = 0
+                features['emotion_transitions_ratio'] = 0
+
+            results.append(features)
+
+        # Create DataFrame from results
+        result_df = pd.DataFrame(results)
+
+        # Encode all emotion position columns
+        emotion_cols = [col for col in result_df.columns if col.startswith('emotion_pos_')]
+        for col in emotion_cols:
+            result_df[col] = self.label_encoder.fit_transform(result_df[col].astype(str))
+
+        return result_df
+
+    def get_emotion_mapping(self) -> dict:
+        """
+        Get the mapping between encoded values and emotion categories.
+
+        Returns:
+            Dictionary mapping encoded values to emotion categories
+        """
+        return dict(zip(
+            self.label_encoder.transform(self.label_encoder.classes_),
+            self.label_encoder.classes_
+        ))

preprocessing/flattening_minirocket.py

@@ -0,0 +1,155 @@
+import numpy as np
+import pandas as pd
+from sklearn.preprocessing import StandardScaler
+from sktime.transformations.panel.rocket import MiniRocket
+
+from preprocessing.flattening_base import BaseFlattening
+
+class MiniRocketFlattening(BaseFlattening):
+    def __init__(self):
+        """Initialize the MiniRocket flattening strategy."""
+        self.name = "minirocket"
+        self.minirocket = None
+        self.emotion_columns = None
+        self.scaler = StandardScaler()
+        self.min_sequence_length = 9  # MiniRocket requires at least 9 timepoints
+        self.features_per_emotion = None  # Will store number of features per emotion
+
+    def _initialize_minirocket(self, data_3d):
+        """
+        Initialize and fit the MiniRocket transformer.
+
+        Args:
+            data_3d: 3D array with shape (n_instances, n_columns, n_timepoints)
+        """
+        try:
+            self.minirocket = MiniRocket(
+                random_state=42,
+                n_jobs=1,
+                num_kernels=84,
+                max_dilations_per_kernel=32
+            )
+            # print(f"Initializing MiniRocket with data shape: {data_3d.shape}")
+            self.minirocket.fit(data_3d)
+            # Calculate features per emotion after first transform
+            sample_transform = self.minirocket.transform(data_3d)
+            total_features = sample_transform.shape[1]
+            self.features_per_emotion = total_features // len(self.emotion_columns)
+
+        except Exception as e:
+            print(f"Error initializing MiniRocket: {str(e)}")
+            raise
+
+    def _prepare_3d_array(self, group_data: pd.DataFrame) -> np.ndarray:
+        """
+        Convert patient group data to 3D array format required by MiniRocket with improved error handling.
+
+        Args:
+            group_data: DataFrame containing one patient's data
+
+        Returns:
+            3D numpy array with shape (n_instances, n_columns, n_timepoints)
+        """
+        try:
+            if self.emotion_columns is None:
+                self.emotion_columns = [col for col in group_data.columns
+                                        if col not in ['start', 'end', 'filename']]
+
+            # Make sure we have data
+            if group_data.empty:
+                raise ValueError("Empty data array")
+
+            data = group_data[self.emotion_columns].values
+            if data.size == 0:
+                raise ValueError("Empty data array after selecting columns")
+
+            # Handle sequence length, ensuring minimum of 9 timepoints
+            current_length = data.shape[0]
+            if current_length < self.min_sequence_length:
+                # Padding for sequences shorter than minimum
+                pad_length = self.min_sequence_length - current_length
+                data = np.pad(data, ((0, pad_length), (0, 0)), mode='constant')
+            elif current_length > self.min_sequence_length:
+                # Truncate longer sequences
+                data = data[:self.min_sequence_length]
+
+            # Normalize the data with safeguards against division by zero
+            data_mean = data.mean(axis=0)
+            data_std = data.std(axis=0)
+            # Add small epsilon to avoid division by zero
+            data_std = np.where(data_std < 1e-8, 1e-8, data_std)
+            data = (data - data_mean) / data_std
+            data = data.astype(np.float32)
+
+            # Create 3D array
+            data_3d = np.zeros((1, len(self.emotion_columns), data.shape[0]), dtype=np.float32)
+            for i in range(len(self.emotion_columns)):
+                data_3d[0, i, :] = data[:, i]
+
+            return data_3d
+
+        except Exception as e:
+            logger.error(f"Error in _prepare_3d_array: {str(e)}")
+            # Return a safe default array if processing fails
+            empty_array = np.zeros((1, len(self.emotion_columns) if self.emotion_columns else 1,
+                                    self.min_sequence_length), dtype=np.float32)
+            return empty_array
+
+    def flatten_dataframe(self, df: pd.DataFrame) -> pd.DataFrame:
+        """Implement MiniRocket flattening with emotion-prefixed features."""
+        grouped = df.groupby('filename')
+        all_features = []
+        first_batch = True
+
+        # Process each patient
+        for filename, group in grouped:
+            try:
+                # Prepare 3D array for this patient
+                data_3d = self._prepare_3d_array(group)
+
+                # Initialize MiniRocket with first batch
+                if first_batch:
+                    self._initialize_minirocket(data_3d)
+                    first_batch = False
+
+                # Transform the data
+                features = self.minirocket.transform(data_3d)
+                features_array = features.to_numpy()
+                if len(features_array.shape) > 1:
+                    features_array = features_array[0]
+
+                # Create features dictionary with emotion prefixes
+                features_dict = {'filename': filename}
+
+                # Distribute features among emotions
+                for emotion_idx, emotion in enumerate(self.emotion_columns):
+                    start_idx = emotion_idx * self.features_per_emotion
+                    end_idx = start_idx + self.features_per_emotion
+
+                    # Add features for this emotion
+                    emotion_features = {
+                        f'{emotion}_feature_{i}': value
+                        for i, value in enumerate(features_array[start_idx:end_idx])
+                    }
+                    features_dict.update(emotion_features)
+
+                all_features.append(features_dict)
+
+            except Exception as e:
+                print(f"Error processing patient {filename}: {str(e)}")
+                continue
+
+        # Create DataFrame from all features
+        result_df = pd.DataFrame(all_features)
+
+        # Scale the features if we have any
+        feature_cols = [col for col in result_df.columns if 'feature_' in col]
+        if feature_cols:
+            features_array = result_df[feature_cols].values
+            scaled_features = self.scaler.fit_transform(features_array)
+
+            # Update the DataFrame with scaled features
+            for i, col in enumerate(feature_cols):
+                result_df[col] = scaled_features[:, i]
+
+        return result_df

preprocessing/flattening_statistical.py

@@ -0,0 +1,50 @@
+import pandas as pd
+from preprocessing.flattening_base import BaseFlattening
+
+
+class StatisticalFlattening(BaseFlattening):
+    def __init__(self):
+        super().__init__()
+        self.name = "statistical"
+
+    def flatten_dataframe(self, df: pd.DataFrame) -> pd.DataFrame:
+        """
+        Implement statistical flattening for the combined DataFrame.
+
+        Args:
+            df: DataFrame containing all inference results
+
+        Returns:
+            DataFrame containing statistical features for each unique filename
+        """
+        grouped = df.groupby('filename')
+
+        results = []
+        for filename, group in grouped:
+            stats = {'filename': filename}
+
+            # Calculate statistics for each feature column
+            for column in group.columns:
+                if column in ['start', 'end', 'filename']:
+                    continue
+
+                # Calculate statistical features
+                stats[f'{column}_mean'] = group[column].mean()
+                stats[f'{column}_std'] = group[column].std()
+                stats[f'{column}_max'] = group[column].max()
+                stats[f'{column}_min'] = group[column].min()
+                stats[f'{column}_mode'] = group[column].mode().iloc[0]
+                stats[f'{column}_skewness'] = group[column].skew()
+                stats[f'{column}_kurtosis'] = group[column].kurtosis()
+                stats[f'{column}_median'] = group[column].median()
+                stats[f'{column}_q1'] = group[column].quantile(0.25)
+                stats[f'{column}_q3'] = group[column].quantile(0.75)
+                stats[f'{column}_iqr'] = group[column].quantile(0.75) - group[column].quantile(0.25)
+                stats[f'{column}_range'] = group[column].max() - group[column].min()
+                stats[f'{column}_variance'] = group[column].var()
+                stats[f'{column}_sem'] = group[column].sem()
+                stats[f'{column}_cv'] = group[column].std() / group[column].mean()
+
+            results.append(stats)
+
+        return pd.DataFrame(results)

utils/__init__.py

@@ -0,0 +1,5 @@
+# utils/__init__.py
+from utils.config import ProjectConfig
+from utils.config_types import ChunkLength
+
+__all__ = ["ProjectConfig", "ChunkLength"]

utils/config.py

@@ -0,0 +1,43 @@
+import os
+from typing import List
+from .config_types import (
+    MachinePaths, Labels, ModelPaths, Settings,
+    Data, ChunkLength, ChunkConfig
+)
+
+
+class ProjectConfig:
+    """Project configuration class."""
+
+    def __init__(self):
+        self.machine_paths = MachinePaths()
+        self.paths = {
+            'labels': Labels(),
+            'models': ModelPaths(),
+            'data': Data()
+        }
+        self.settings = Settings()
+
+    def get_full_path(self, relative_path: str) -> str:
+        """Combine machine base path with relative path"""
+        base_path = self.machine_paths.get_current_machine_path()
+        return os.path.join(base_path, relative_path)
+
+    def get_model_length_path(self, model_name: str, length: ChunkLength) -> str:
+        """Get the folder location for a specific model and length"""
+        base_path = self.machine_paths.get_current_machine_path()
+        folder_name = f"{model_name}-{str(length)}"
+        return os.path.join(base_path, 'processed', folder_name)
+
+    def get_chunk_params(self, length: ChunkLength) -> ChunkConfig:
+        """Get chunk configuration for a specific length."""
+        if length not in self.paths['data'].chunks:
+            raise ValueError(f"Invalid length {length}. Must be one of {list(self.paths['data'].chunks.keys())}")
+        return self.paths['data'].chunks[length]
+
+    def get_available_lengths(self) -> List[ChunkLength]:
+        """Get list of available chunk lengths."""
+        return list(self.paths['data'].chunks.keys())
+
+    def get_model_path(self, name, length, task):
+        pass

utils/config_types.py

@@ -0,0 +1,98 @@
+import os
+from dataclasses import dataclass
+from enum import Enum
+from pathlib import Path
+from typing import Dict
+import torch
+
+
+class ChunkLength(str, Enum):
+    """Enumeration of available chunk lengths."""
+    LENGTH_1_5 = "1_5"
+    LENGTH_3_5 = "3_5"
+    LENGTH_4_5 = "4_5"
+
+    def __str__(self) -> str:
+        return self.value
+
+
+@dataclass
+class ChunkConfig:
+    """Configuration for audio chunk processing."""
+    length: ChunkLength
+    segment_duration: int  # in milliseconds
+    overlap_duration: int  # in milliseconds
+
+
+@dataclass
+class MachinePaths:
+    """Base paths for different machines/environments."""
+    default: Path = Path('./data')
+
+    def get_current_machine_path(self) -> Path:
+        """Get base path for current machine based on environment variable."""
+        # Use EMOTION_DATA_PATH environment variable if set, otherwise use default
+        env_path = os.getenv('EMOTION_DATA_PATH')
+        if env_path:
+            return Path(env_path)
+        return self.default
+
+
+@dataclass
+class Labels:
+    """Paths to label files."""
+    demographic: str = 'processed/labels/demographic.csv'
+    multi: str = 'processed/labels/multiclass.csv'
+    regression: str = 'processed/labels/regression.csv'
+
+
+@dataclass
+class ModelPaths:
+    """Paths for model storage."""
+    base_dir: str = 'models/'
+    checkpoints: str = 'models/checkpoints/'
+    configs: str = 'models/configs/'
+
+
+@dataclass
+class Settings:
+    """General framework settings."""
+    seed: int = 42
+    batch_size: int = 16
+    num_workers: int = -1
+    device: str = None
+
+    def __post_init__(self):
+        if self.device is None:
+            self.device = 'cuda' if torch.cuda.is_available() else 'cpu'
+
+
+@dataclass
+class Data:
+    """Data paths and chunk configurations."""
+    raw: str = 'raw/'
+    processed: str = 'processed/inference/'
+    table: str = 'processed/tables/'
+    splits: str = 'processed/splits/'
+    results: str = 'results/'
+    chunks: Dict[ChunkLength, ChunkConfig] = None
+
+    def __post_init__(self):
+        if self.chunks is None:
+            self.chunks = {
+                ChunkLength.LENGTH_1_5: ChunkConfig(
+                    length=ChunkLength.LENGTH_1_5,
+                    segment_duration=1500,
+                    overlap_duration=500
+                ),
+                ChunkLength.LENGTH_3_5: ChunkConfig(
+                    length=ChunkLength.LENGTH_3_5,
+                    segment_duration=3500,
+                    overlap_duration=500
+                ),
+                ChunkLength.LENGTH_4_5: ChunkConfig(
+                    length=ChunkLength.LENGTH_4_5,
+                    segment_duration=4500,
+                    overlap_duration=500
+                )
+            }

utils/logger.py

@@ -0,0 +1,6 @@
+import logging
+
+# Configure logging
+# logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logging.basicConfig(level=logging.INFO, format='%(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)

utils/tabular_transformation.py

@@ -0,0 +1,165 @@
+from typing import Optional
+import pandas as pd
+from sklearn.model_selection import StratifiedKFold, KFold
+
+from utils.config_types import LearningTask
+from utils.logger import logger
+from preprocessing.flattening_base import BaseFlattening
+
+
+class TabularTransformer:
+    """Static class for transforming tabular data in various ways."""
+
+    @staticmethod
+    def get_id(filename: str) -> int:
+        id_value = filename.split('_')[-1].split('-')[0]
+        return int(id_value)
+
+    @staticmethod
+    def attach_demographic(df_data: pd.DataFrame, demographic_path: str) -> pd.DataFrame:
+        """
+        Attaches demographic information to the data DataFrame.
+
+        Args:
+            df_data: DataFrame containing the processed data
+            demographic_path: Path to the demographic CSV file
+
+        Returns:
+            DataFrame with demographic information attached
+        """
+        df_demographic = pd.read_csv(demographic_path)
+
+        df_data['id'] = df_data['filename'].apply(TabularTransformer.get_id)
+        merged_df = pd.merge(df_data, df_demographic, on='id')
+        merged_df.drop(columns=['id'], inplace=True)
+        return merged_df
+
+    @staticmethod
+    def transform_to_binary(df: pd.DataFrame) -> pd.DataFrame:
+        """
+        Transforms the DataFrame into a binary classification problem.
+
+        Args:
+            df: DataFrame with demographic information
+
+        Returns:
+            DataFrame with binary target labels (0 or 1)
+        """
+        df['target'] = df['filename'].apply(lambda x: 1 if x.split('_')[0] == 'dementia' else 0)
+        return df
+
+    @staticmethod
+    def transform_to_multiclass(df: pd.DataFrame, path_to_label: str) -> pd.DataFrame:
+        """
+        Transforms the DataFrame into a multiclass classification problem.
+
+        Args:
+            df: DataFrame with demographic information
+            path_to_label: Path to the multiclass labels CSV file
+
+        Returns:
+            DataFrame with multiclass target labels
+        """
+        df_labels = pd.read_csv(path_to_label)
+        df_labels = df_labels[['ID', 'target_multi']]
+        df_labels.rename(columns={'target_multi': 'target'}, inplace=True)
+        df['ID'] = df['filename']
+        df = pd.merge(df, df_labels, on='ID')
+        df.drop(columns=['ID'], inplace=True)
+        return df
+
+    @staticmethod
+    def transform_to_regression(df: pd.DataFrame, path_to_label: str) -> pd.DataFrame:
+        """
+        Transforms the DataFrame into a regression problem.
+
+        Args:
+            df: DataFrame with demographic information
+            path_to_label: Path to the regression labels CSV file
+
+        Returns:
+            DataFrame with regression target labels
+        """
+        df_labels = pd.read_csv(path_to_label)
+        df_labels.rename(columns={'mms': 'target'}, inplace=True)
+
+        df['id'] = df['filename'].apply(TabularTransformer.get_id)
+        df = pd.merge(df, df_labels, on='id')
+        df.drop(columns=['id'], inplace=True)
+        return df
+
+    @staticmethod
+    def process_and_transform(df: pd.DataFrame,
+                              transform_func: callable,
+                              label_path_func: Optional[callable]) -> pd.DataFrame:
+        """Process and transform data based on the task requirements."""
+        if label_path_func:
+            return transform_func(df.copy(), label_path_func())
+        return transform_func(df.copy())
+
+    @staticmethod
+    def get_flattened_data(strategy: BaseFlattening, file_path: str, demographic_path: Optional[str] = None) -> pd.DataFrame:
+        """Get flattened data with optional demographic information."""
+        logger.info(f"Flattening data with strategy: {strategy.get_name()}")
+        # Flatten the data
+        df_inference = pd.read_csv(file_path) # Read the inference data
+        df_flatten = strategy.flatten_dataframe(df_inference) # Invoke the flattening strategy method
+
+        # Check if I want to attach demographic information
+        if demographic_path:
+            return TabularTransformer.attach_demographic(df_flatten, demographic_path)
+
+        # Return the flattened data
+        return df_flatten
+
+    @staticmethod
+    def get_memory_usage(df: pd.DataFrame) -> str:
+        """Get memory usage of dataframe in a human-readable format."""
+        memory_usage = df.memory_usage(deep=True).sum()
+        if memory_usage < 1024:
+            return f"{memory_usage} bytes"
+        elif memory_usage < 1024 ** 2:
+            return f"{memory_usage / 1024:.2f} KB"
+        elif memory_usage < 1024 ** 3:
+            return f"{memory_usage / 1024 ** 2:.2f} MB"
+        else:
+            return f"{memory_usage / 1024 ** 3:.2f} GB"
+
+    @staticmethod
+    def generate_folds(inference_data, folds, task, tasks):
+        df_folds = inference_data.groupby('filename').agg(list).reset_index()
+
+        # Check if the task is binary, multiclass, or regression
+        df_folds = df_folds[['filename']]
+
+        # Attach labels
+        df_task = TabularTransformer.process_and_transform(
+            df_folds,
+            tasks[task][0],
+            tasks[task][2]
+        )
+
+        # Split into features and target
+        target_column = df_task['target']
+        file_column = df_task['filename']
+
+        # Create the folds
+        fold_object = None
+        if task == LearningTask.BINARY or task == LearningTask.MULTICLASS:
+            fold_object = StratifiedKFold(n_splits=folds, shuffle=True, random_state=42)
+        elif task == LearningTask.REGRESSION:
+            fold_object = KFold(n_splits=folds, shuffle=True, random_state=42)
+
+        folds_data = []
+        for fold, (train_index, test_index) in enumerate(fold_object.split(file_column, target_column)):
+            current_fold = {
+                'fold': fold,
+                'train': file_column.iloc[train_index].tolist(),
+                'test': file_column.iloc[test_index].tolist(),
+            }
+
+            folds_data.append(current_fold)
+
+        # Turn the folds into a DataFrame
+        fold_df = pd.DataFrame(folds_data, columns=['fold', 'train', 'test'])
+        return fold_df