Upload 11 files

Dockerfile

@@ -0,0 +1,27 @@
+FROM continuumio/miniconda3
+
+# Update apt-get and install basic utilities
+RUN apt-get update -y && apt-get install -y nano unzip curl
+
+# THIS IS SPECIFIC TO HUGGINGFACE: Create a non-root user
+RUN useradd -m -u 1000 user
+
+USER user
+ENV HOME=/home/user
+ENV PATH=/home/user/.local/bin:$PATH
+
+# Set working directory
+WORKDIR $HOME/app
+
+# Copy only requirements file first to leverage Docker caching
+COPY --chown=user requirements.txt /dependencies/requirements.txt
+
+# Install Python dependencies from requirements.txt
+RUN pip install --no-cache-dir -r /dependencies/requirements.txt
+
+# Copy the rest of the application code
+COPY --chown=user . $HOME/app
+
+EXPOSE 7860
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -0,0 +1,58 @@
+import os
+import tempfile
+import uvicorn
+from fastapi import FastAPI, UploadFile, File, HTTPException
+from fastapi.responses import JSONResponse
+import tensorflow as tf
+
+# Import your prediction function from your prediction module.
+from prediction import predict_eeg_recording
+
+app = FastAPI(title="EEG Epilepsy Prediction API")
+
+# Load the trained model once at startup.
+model = tf.keras.models.load_model('model1_2dcnn.h5')
+
+@app.get("/", tags=["Introduction Endpoints"])
+async def index():
+    """
+    Simply returns a welcome message!
+    """
+    message = (
+        "Hello world! Welcome to the EEG Epilepsy Prediction API. "
+        "Submit an EEG recording EDF file to the `/predict` endpoint to receive a prediction."
+    )
+    return message
+
+@app.post("/predict", tags=["Machine Learning"])
+async def predict_endpoint(file: UploadFile = File(...)):
+    """
+    Accepts an EEG EDF file, processes it using the preprocessing and spectrogram conversion functions,
+    and returns an aggregated prediction (epilepsy or no epilepsy) along with the mean probability.
+    """
+    # Save the uploaded file temporarily.
+    try:
+        suffix = os.path.splitext(file.filename)[1]
+        with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as tmp:
+            tmp.write(await file.read())
+            tmp_path = tmp.name
+    except Exception as e:
+        raise HTTPException(status_code=500, detail="Error saving temporary file")
+    
+    # Use your prediction function to process the file and obtain an aggregated prediction.
+    try:
+        pred_label, mean_prob = predict_eeg_recording(tmp_path, model, threshold=0.5)
+    except Exception as e:
+        os.remove(tmp_path)
+        raise HTTPException(status_code=400, detail=f"Prediction failed: {e}")
+    
+    os.remove(tmp_path)
+    
+    response = {
+        "prediction": "epilepsy" if pred_label == 1 else "no epilepsy",
+        "mean_probability": float(mean_prob)
+    }
+    return JSONResponse(content=response)
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=7860)

model1_2dcnn.h5

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

prediction.py

@@ -0,0 +1,34 @@
+import numpy as np
+import tensorflow as tf
+import pandas as pd
+from sklearn.metrics import confusion_matrix, f1_score, accuracy_score
+from preprocessing import preprocess_eeg_file
+from preprocessing_2dcnn import convert_epoch_to_spectrogram
+import random
+random.seed(42)
+
+def aggregate_predictions(spectrogram_list, model, threshold=0.5):
+
+    # Convert each spectrogram to channels-last format.
+    X = np.array([np.transpose(s, (1, 2, 0)) for s in spectrogram_list])
+    print(f'---Aggregating predictions from {len(spectrogram_list)} segments---')
+    preds = model.predict(X)
+    mean_prob = np.mean(preds[:, 1])
+    final_label = 1 if mean_prob >= threshold else 0
+    return final_label, mean_prob
+
+def predict_eeg_recording(edf_path, model, threshold=0.5):
+    #Process the edf file
+    preprocessed_df = preprocess_eeg_file(edf_path, fmin=1.0, fmax=45.0, segment_lenght=5, overlap=2)
+    
+    if preprocessed_df is None or preprocessed_df.empty:
+        raise ValueError("EEG file could not be preprocessed or no valid segments found.")
+    
+    channels = ["EEG FP1-REF", "EEG FP2-REF", "EEG F3-REF", "EEG F4-REF", "EEG C3-REF"]
+    # Convert each 5-second segment (each row) into a spectrogram.
+    spectrogram_list = preprocessed_df.apply(
+        lambda row: convert_epoch_to_spectrogram(row, channels, fs=250, nperseg=128, noverlap=64), axis=1
+    ).tolist()
+    
+    return aggregate_predictions(spectrogram_list, model, threshold)
+

preprocessing.py

@@ -0,0 +1,96 @@
+import os
+import mne
+import numpy as np
+import pandas as pd
+
+
+def standardize_dataframe(df):
+    # Make a copy to avoid modifying the original dataframe
+    df_standardized = df.copy()
+    
+    # Only standardize numeric columns
+    numeric_columns = df.select_dtypes(include=np.number).columns
+    
+    for column in numeric_columns:
+        mean = df[column].mean()
+        std = df[column].std()
+        
+        df_standardized[column] = (df[column] - mean) / std
+    
+    return df_standardized
+
+def select_relevant_channels(raw):
+    # For relevant channel criteria check documentation
+    '''“EEG FP1-REF” for the left frontal pole
+
+        “EEG FP2-REF” for the right frontal pole
+
+        “EEG F3-REF” for the left frontal region
+
+        “EEG F4-REF” for the right frontal region
+
+        “EEG C3-REF” for the left central region'''
+        
+    desired = ["EEG FP1-REF", "EEG FP2-REF", "EEG F3-REF", "EEG F4-REF", "EEG C3-REF"]
+    #check if all desired channels are present; if not, skip this file
+    if not all(ch in raw.ch_names for ch in desired):
+        print("Skipping file because it doesn't have the full set of desired channels.")
+        return None
+    raw.pick_channels(desired, verbose=False)
+    return raw
+
+
+def collapse_epoch_df_by_channel(epoch_df):
+    # Identify channel columns (exclude time, epoch, condition)
+    channel_cols = [col for col in epoch_df.columns if col not in ['time', 'epoch']]
+    # Group by epoch
+    grouped = epoch_df.groupby('epoch')
+    rows = []
+    for epoch_num, group in grouped:
+        group_sorted = group.sort_values('time')
+        # For each channel, extract the 1D array for this epoch
+        row = {'epoch': epoch_num}
+        for ch in channel_cols:
+            row[ch] = group_sorted[ch].values  # 1D array of length = number of time samples in the epoch
+        rows.append(row)
+    return pd.DataFrame(rows)
+
+def preprocess_eeg_file(edf_path, fmin=1.0, fmax=45.0, segment_lenght=5, overlap=2):
+
+    # 1. Charger le fichier EDF avec MNE
+    raw = mne.io.read_raw_edf(edf_path, preload=True, verbose=False)
+    
+    # Resample (to 250 because it's the lowest sampling rate )
+    raw.resample(250, verbose=False)
+    
+    # Filtrage passe-bande (1-45 Hz)
+    raw.filter(fmin, fmax, fir_design='firwin', verbose=False)
+    
+    # Skip EEGs less than 5s
+    if raw.times[-1] < 5:
+        print(f"Skipping {edf_path}: duration ({raw.times[-1]:.2f} s) is less than required 5s.")
+        return None
+    
+    # Suppression des canaux non EEG
+    eeg_channels = mne.pick_types(raw.info, eeg=True, exclude=[])
+    raw.pick(eeg_channels, verbose=False)
+    
+    # Selectionner les channels pertinents (channel selection from EDA ?)
+    print(raw.ch_names)
+    raw = select_relevant_channels(raw)
+    if raw is None:
+        return None
+    
+    # Segmentation
+    epochs = mne.make_fixed_length_epochs(raw, duration=segment_lenght, preload=False, overlap=overlap, verbose=False)
+
+    # Transform to dataframe and standadize
+
+    df = epochs.to_data_frame() # epochs is returned by preprocess_eeg_file()
+    df_std = standardize_dataframe(df.drop(['time','epoch', 'condition'], axis=1))
+    result = pd.concat([df[['time','epoch']], df_std], axis=1)
+    
+    return collapse_epoch_df_by_channel(result)
+
+
+

preprocessing_2dcnn.py

@@ -0,0 +1,52 @@
+import numpy as np
+import pandas as pd
+from scipy.signal import spectrogram
+
+#METHOD 1: STFT spectrogram
+def convert_epoch_to_spectrogram(epoch_row, channels, fs=250, nperseg=128, noverlap=64):
+    """
+    Given a pandas Series representing one epoch, where each channel column contains
+    a 1D numpy array of time series data, compute a spectrogram for each channel and
+    stack them into a 3D array of shape (n_channels, freq_bins, time_bins).
+    
+    Parameters:
+      epoch_row: pandas Series
+          One row of your preprocessed dataframe (one epoch).
+      channels: list of str
+          The list of channel names to process.
+      fs: int
+          Sampling frequency (default 250 Hz).
+      nperseg: int
+          Length of each segment for spectrogram calculation.
+      noverlap: int
+          Number of overlapping samples between segments.
+    
+    Returns:
+      spec_stack: numpy array
+          A 3D array with shape (n_channels, freq_bins, time_bins) containing the
+          spectrogram (in dB) for each channel.
+    """
+    spec_list = []
+    for ch in channels:
+        ts = epoch_row[ch]  # this is the 1D time series for the channel
+        # Compute the spectrogram
+        f, t, Sxx = spectrogram(ts, fs=fs, nperseg=nperseg, noverlap=noverlap)
+        # Convert the power spectrogram to dB scale
+        Sxx_db = 10 * np.log10(Sxx + 1e-10)
+        spec_list.append(Sxx_db)
+    spec_stack = np.stack(spec_list, axis=0)
+    return spec_stack
+
+
+def convert_preprocessed_df_to_2d(preprocessed_df, channels=["EEG FP1-REF", "EEG FP2-REF", "EEG F3-REF", "EEG F4-REF", "EEG C3-REF"], 
+                                  fs=250, nperseg=128, noverlap=64):
+
+    # Make a copy to avoid modifying the original dataframe
+    df = preprocessed_df.copy()
+    
+    # Compute the spectrogram for each row (epoch)
+    df["spectrogram"] = df.apply(lambda row: convert_epoch_to_spectrogram(row, channels, fs, nperseg, noverlap), axis=1)
+    
+    #drop channel columns and other useless ones
+    df_final = df[["spectrogram", "epilepsy", "age", "gender",'subject_id', 'edf_path']]
+    return df_final

requirements.txt

@@ -0,0 +1,10 @@
+numpy==1.26.4
+pandas==2.2.3
+uvicorn==0.34.0
+scipy==1.15.0
+tensorflow==2.16.2
+scikit-learn==1.6.1
+fastapi==0.115.12
+mne==1.9.0
+python-multipart==0.0.20
+