Create Space

README.md

@@ -0,0 +1,67 @@
+---
+title: BCGunet
+emoji: 🧠
+colorFrom: yellow
+colorTo: orange
+sdk: gradio
+app_file: bcgrun_web.py
+python_version: "3.10"
+sdk_version: "3.27.0"
+pinned: false
+---
+
+# BCGunet: Suppressing BCG artifacts on EEG collected inside an MRI scanner
+
+Ballistocardiogram (BCG) is the induced electric potentials caused by heartbeats when the EEG data are collected with a strong ambient magnetic field. This scenario is common in concurrent EEG-MRI acquisitions. One particular application of concurrent EEG-MRI is to delineate the irritative zones responsible for generating inter-ictal spikes (IIS) in medically refractory epilepsy patients. Specifically, EEG is used to detect onsets of spikes and these timing are used to inform functional MRI time series analysis. However, with strong BCG artifacts, the EEG data can be seriously corrupted and thus make spike annotation difficult.
+
+This project aims at using machine learning approaches to suppress BCG artifacts. We will use Unet as the artificual neural network structure to tackle this challenge.
+
+![](https://github.com/fahsuanlin/BCGunet/blob/main/images/alpha_annot.png)
+
+## Data
+
+Data were EEG time series collected inside a 3T MRI scanner (Skyra, Siemens). EEG were sampled by a 32-channel systemm (Brain Products) with electrodes arranged by the international 10-20 standard. EEG were sampled at 5,000 Hz.
+
+### Eyes open/closed in healthy control subjects
+A tar ball is [here](https://drive.google.com/file/d/1Te94WlQ4nGCT3rnij_w0pbPFhRcaphGJ/view?usp=share_link). Each subject had two sessions of data. One was "eyes-open" and the other was "eyes-closed", where subjects were instructed laying in the MRI without falling sleep but keeping their eyes open and closed, respectively. This is a resting-state recording. 
+During the recording, the MRI scanner did not collect any images. No so-called "gradient artifacts" caused by the swithcing of the imaging gradient coils of MRI was present.
+
+[This tar ball](https://drive.google.com/file/d/1Hfu5w0-CT6p3g82yXIp-7wIi6921DW4m/view?usp=share_link) includes the EEG data taken *outside* MRI, including "eyes-open" and "eyes-closed" conditions. In other words, these data can be taken as the gold standard to see how much alpha oscillation power increased when eyes were closed.
+
+The more complicated case is that when MRI was collecting the data. This imposed a strong "gradient artifacts" over EEG. Thus it takes extra efforts to deal with both gradient artifacts and BCG artifacts at the same time. [Here](https://drive.google.com/file/d/1oZAjCnec73ErwkuMxulUv_v3XipMZ7N_/view?usp=sharing) is the file with concurrent MRI-EEG when echo-planar imaging was used. Note that the gradient artifacts in these data have been suppressed already.
+
+### Steady-state visual evoked potential (SSVEP)
+Check [this page](https://github.com/fahsuanlin/labmanual/wiki/21.-Sample-data:-Steady-state-visual-potential) for some details.
+
+## Code
+- [Data input (Matlab)](https://github.com/fahsuanlin/BCGunet/blob/main/matlab/read_eeg.m): An example of reading EEG data. Each EEG recording has three files with .eeg, .vmrk, and .vhdr file suffix. Supply the .vmrk and .vmrk file names to read data into Matlab. Need functions at [bvaloader](https://github.com/stefanSchinkel/bvaloader).
+
+**NOTE**: Do not change the file names because data are associated with the file name.
+
+- [Unet basic structure and BCG suppression (Python)](https://github.com/fahsuanlin/BCGunet/blob/main/bcg_unet/unet1d-simple.ipynb): perform BCG suppression by Unet, including training and testing of data from the same subject.
+
+- Assessment (Matlab): 
+
+-- Alpha oscillations in eyes-closed vs. eyes-opened conditions: Calculate the alpha-band (10-Hz) power at all EEG electrodes. We expect that stronger alpha-band neural oscillations are found at the parietal lobe of the subject when he/she closed eyes than opened eyes after successful BCG artifact suppression. Download [our toolbox](https://github.com/fahsuanlin/fhlin_toolbox) to use the function in the following codes to calculate the average of 10-Hz oscillatory power across all EEG channels (in columns; with data stored in `EEG`) using the Morlet wavelet transform with 5-cycle. EEG data were sampled at 5,000 Hz denoted by `sfreq` variable.
+
+```
+sfreq=5000;
+mean(abs(inverse_waveletcoef(10,double(EEG),sfreq,5)),2);
+```
+[A sample script](https://github.com/fahsuanlin/BCGunet/blob/main/matlab/calc_alpha_unet.m) of calculating alpha-band oscillations across subjects and between conditions.
+
+
+- Rendering (Matlab): tools to render EEG data over a scalp.
+
+Use the [EEG topolgoy definition fiile](https://github.com/fahsuanlin/BCGunet/blob/main/matlab/bem.mat) to draw 10-Hz power distribution. Download [our toolbox](https://github.com/fahsuanlin/fhlin_toolbox) to use the  function in the following codes.
+```
+load bem.mat;
+verts_osc_electrode_idx(end-2:end,:)=[]; %last three channels are not needed.
+etc_render_topo('vol_vertex',verts_osc,'vol_face',faces_osc-1,'topo_vertex',verts_osc_electrode_idx-1,'topo_stc',mean(EEG_unet_close,2)./mean(EEG_unet_open,2),'topo_smooth',10,'topo_threshold',[1.25 1.5],'topo_stc_timevec_unit','Hz','view_angle',[0 50]);
+```
+
+## Resources
+- [Our lab routine](https://github.com/fahsuanlin/labmanual/wiki/18.-Suppression-of-ballistocardiography-artifacts-in-EEG-collected-inside-MRI) in BCG suppression.
+- A conventional PCA-based BCG suppression method using [Optimal Basis Sets (OBS)](https://www.sciencedirect.com/science/article/abs/pii/S1053811905004726?via%3Dihub).
+- An RNN-type BCG artifact suppression method (BCGnet) can be found [here](https://github.com/jiaangyao/BCGNet)
+- [Our BCG suppression protocol](https://github.com/fahsuanlin/labmanual/wiki/18.-Suppression-of-ballistocardiography-artifacts-in-EEG-collected-inside-MRI)

bcgrun_web.py

@@ -0,0 +1,127 @@
+import numpy as np
+from scipy.io import savemat
+import h5py
+from bcgunet import bcgunet
+import platform
+import os
+import time
+import os
+import gradio as gr
+import matplotlib
+import matplotlib.pyplot as plt
+
+matplotlib.use("agg")
+
+dir = os.path.dirname(os.path.realpath(__file__)) + "/tmp"
+os.makedirs(dir, exist_ok=True)
+
+
+def run(
+    files: list[bytes],
+    lr: float,
+    winsec: int,
+    iters: int,
+    onecycle: bool,
+    ecg: str,
+    bce: str,
+    eeg: str,
+) -> tuple[list[str], str]:
+    task = os.path.join(dir, str(int(time.time())))
+    os.makedirs(task)
+
+    outputs = []
+
+    for i, file in enumerate(files):
+        input = os.path.join(task, str(i) + ".mat")
+        with open(input, "wb") as o:
+            o.write(file)
+
+        output = os.path.join(task, str(i) + "_clean.mat")
+
+        mat = h5py.File(input, "r")
+        ECG = np.array(mat[ecg]).flatten()
+        EEG = np.array(mat[bce]).T
+
+        EEG_unet = bcgunet.run(
+            EEG,
+            ECG,
+            iter_num=iters,
+            winsize_sec=winsec,
+            lr=lr,
+            onecycle=onecycle,
+        )
+        result = dict()
+        result[eeg] = EEG_unet
+
+        savemat(output, result, do_compression=True)
+        outputs.append(output)
+
+        if i == 0:
+            plt.figure(figsize=(12, 6), dpi=300)
+            plt.plot(EEG[19, :10000], "b.-", label="Orig EEG")
+            plt.plot(EEG_unet[19, :10000], "g.-", label="U-Net")
+            plt.legend()
+            plt.title("BCG Unet")
+            plt.xlabel("Time (samples)")
+            plot = os.path.join(task, str(i) + ".png")
+            plt.savefig(plot)
+
+    return outputs, plot
+
+
+def main():
+    app = gr.Interface(
+        title="BCG Unet",
+        description="BCGunet: Suppressing BCG artifacts on EEG collected inside an MRI scanner",
+        fn=run,
+        inputs=[
+            gr.File(
+                label="Input Files (.mat)",
+                type="binary",
+                file_types=["mat"],
+                file_count=["multiple", "directory"],
+            ),
+            gr.Slider(
+                label="Learning Rate", minimum=1e-5, maximum=1e-1, step=1e-5, value=1e-3
+            ),
+            gr.Slider(
+                label="Window Size (seconds)", minimum=1, maximum=10, step=1, value=2
+            ),
+            gr.Slider(
+                label="Number of Iterations",
+                minimum=1000,
+                maximum=10000,
+                step=1000,
+                value=5000,
+            ),
+            gr.Checkbox(
+                label="One Cycle Scheduler",
+                value=True,
+            ),
+            gr.Textbox(
+                label="Variable name for ECG (input)",
+                value="ECG",
+            ),
+            gr.Textbox(
+                label="Variable name for BCG corropted EEG (input)",
+                value="EEG_before_bcg",
+            ),
+            gr.Textbox(
+                label="Variable name for clean EEG (output)",
+                value="EEG_clean",
+            ),
+        ],
+        outputs=[
+            gr.File(label="Output File", file_count="multiple"),
+            gr.Image(label="Output Image", type="filepath"),
+        ],
+        allow_flagging="never",
+    )
+
+    app.launch()
+
+
+if __name__ == "__main__":
+    main()
+    if platform.system() == "Windows":
+        os.system("pause")

bcgunet/bcgunet.py

@@ -0,0 +1,148 @@
+from os.path import *
+import numpy as np
+import random
+import torch
+import torch.nn as nn
+import time
+import tqdm
+from scipy.signal import butter, sosfilt
+from .unet import UNet1d
+
+
+def butter_bandpass_filter(data, lowcut, highcut, fs, order=5):
+    nyq = 0.5 * fs
+    low = lowcut / nyq
+    high = highcut / nyq
+    sos = butter(order, [low, high], analog=False, btype="band", output="sos")
+    y = sosfilt(sos, data)
+    return y
+
+
+def norm(ecg):
+    min1, max1 = np.percentile(ecg, [1, 99])
+    ecg[ecg > max1] = max1
+    ecg[ecg < min1] = min1
+    ecg = (ecg - min1) / (max1 - min1)
+    return ecg
+
+
+def run(
+    input_eeg,
+    input_ecg=None,
+    sfreq=5000,
+    iter_num=5000,
+    winsize_sec=2,
+    lr=1e-3,
+    onecycle=True,
+):
+    window = winsize_sec * sfreq
+    eeg_raw = input_eeg
+    eeg_channel = eeg_raw.shape[0]
+
+    eeg_filtered = eeg_raw * 0
+    t = time.time()
+    for ii in range(eeg_channel):
+        eeg_filtered[ii, ...] = butter_bandpass_filter(
+            eeg_raw[ii, :], 0.5, sfreq * 0.4, sfreq
+        )
+
+    baseline = eeg_raw - eeg_filtered
+
+    if input_ecg is None:
+        from sklearn.decomposition import PCA
+
+        pca = PCA(n_components=1)
+        ecg = norm(pca.fit_transform(eeg_filtered.T)[:, 0].flatten())
+    else:
+        ecg = norm(input_ecg.flatten())
+
+    torch.cuda.empty_cache()
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    NET = UNet1d(n_channels=1, n_classes=eeg_channel, nfilter=8).to(device)
+    optimizer = torch.optim.Adam(NET.parameters(), lr=lr)
+    optimizer.zero_grad()
+    maxlen = ecg.size
+    if onecycle:
+        scheduler = torch.optim.lr_scheduler.OneCycleLR(
+            optimizer, lr, total_steps=iter_num
+        )
+    else:
+        # constant learning rate
+        scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=1, gamma=1)
+
+    loss_list = []
+
+    # randomly get  windows in ECG signal
+
+    index_all = (np.random.random_sample(iter_num) * (maxlen - window)).astype(int)
+
+    pbar = tqdm.tqdm(index_all)
+    count = 0
+    for index in pbar:
+        count += 1
+        ECG = ecg[index : (index + window)]
+        EEG = eeg_filtered[:, index : (index + window)]
+        ECG_d = torch.from_numpy(ECG[None, ...][None, ...]).to(device).float()
+        EEG_d = torch.from_numpy(EEG[None, ...]).to(device).float()
+
+        # step 3: forward path of UNET
+        logits = NET(ECG_d)
+        loss = nn.MSELoss()(logits, EEG_d)
+        loss_list.append(loss.item())
+
+        # Step 5: Perform back-propagation
+        loss.backward()  # accumulate the gradients
+        optimizer.step()  # Update network weights according to the optimizer
+        optimizer.zero_grad()  # empty the gradients
+        scheduler.step()
+
+        if count % 50 == 0:
+            pbar.set_description(
+                f"Loss {np.mean(loss_list):.3f}, lr: {optimizer.param_groups[0]['lr']:.5f}"
+            )
+            loss_list = []
+
+    EEG = eeg_filtered
+    # ECG = norm(butter_bandpass_filter(data['ECG'], 0.5, 20, sfreq))
+    ECG = ecg
+    ECG_d = torch.from_numpy(ECG[None, ...][None, ...]).to(device).float()
+    EEG_d = torch.from_numpy(EEG[None, ...]).to(device).float()
+    with torch.no_grad():
+        logits = NET(ECG_d)
+    BCG_pred = logits.cpu().detach().numpy()[0, ...]
+
+    neweeg = EEG - BCG_pred + baseline
+
+    return neweeg
+
+
+def morlet_psd(signal, sample_rate=5000, freq=10, wavelet="morl"):
+    import pywt
+
+    # Define the wavelet and scales to be used
+
+    scales = np.arange(sample_rate)
+    freqs = pywt.scale2frequency("morl", scales) * sample_rate
+    indx = np.argmin(abs(freqs - freq))
+
+    scale = scales[indx]
+
+    # scale = pywt.frequency2scale('morl', freq/sample_rate)
+
+    # Calculate the wavelet coefficients
+    coeffs, freq = pywt.cwt(signal, scale, wavelet, 1 / sample_rate)
+    # Calculate the power (magnitude squared) of the coefficients
+    power = np.abs(coeffs) ** 2
+
+    # Average the power across time to get the power spectral density
+    psd = np.mean(power, axis=1)
+
+    return psd
+
+
+def get_psd(eeg, sfreq=5000, freq=10):
+    psd = []
+    for ii in tqdm.tqdm(range(eeg.shape[0])):
+        psd.append(morlet_psd(eeg[ii], sample_rate=sfreq, freq=freq))
+
+    return np.array(psd)

bcgunet/unet.py

@@ -0,0 +1,123 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class DoubleConv(nn.Module):
+    """(convolution => [BN] => ReLU) * 2"""
+
+    def __init__(self, in_channels, out_channels, mid_channels=None):
+        super().__init__()
+        if not mid_channels:
+            mid_channels = out_channels
+        self.double_conv = nn.Sequential(
+            nn.Conv1d(in_channels, mid_channels, kernel_size=3, padding=1),
+            nn.GroupNorm(num_groups=4, num_channels=mid_channels),
+            nn.ReLU(inplace=True),
+            nn.Conv1d(mid_channels, out_channels, kernel_size=3, padding=1),
+            nn.GroupNorm(num_groups=4, num_channels=out_channels),
+            nn.ReLU(inplace=True),
+        )
+
+    def forward(self, x):
+        return self.double_conv(x)
+
+
+class DoubleConvX(nn.Module):
+    """(convolution => [BN] => ReLU) * 2"""
+
+    def __init__(self, in_channels, out_channels, mid_channels=None):
+        super().__init__()
+        if not mid_channels:
+            mid_channels = out_channels
+        self.double_conv = nn.Sequential(
+            nn.Conv1d(in_channels, mid_channels, kernel_size=15, padding=7),
+            nn.GroupNorm(num_groups=8, num_channels=mid_channels),
+            nn.ReLU(inplace=True),
+            nn.Conv1d(mid_channels, out_channels, kernel_size=15, padding=7),
+            nn.GroupNorm(num_groups=8, num_channels=out_channels),
+            nn.ReLU(inplace=True),
+        )
+
+    def forward(self, x):
+        return self.double_conv(x)
+
+
+class Down(nn.Module):
+    """Downscaling with maxpool then double conv"""
+
+    def __init__(self, in_channels, out_channels):
+        super().__init__()
+        self.maxpool_conv = nn.Sequential(
+            nn.MaxPool1d(2), DoubleConv(in_channels, out_channels)
+        )
+
+    def forward(self, x):
+        return self.maxpool_conv(x)
+
+
+class Up(nn.Module):
+    """Upscaling then double conv"""
+
+    def __init__(self, in_channels, out_channels):
+        super().__init__()
+
+        self.up = nn.Upsample(scale_factor=2, mode="linear", align_corners=True)
+        self.conv = DoubleConv(in_channels, out_channels, in_channels // 2)
+
+    def forward(self, x1, x2):
+        x1 = self.up(x1)
+        # input is CHW
+        diffX = x2.size()[2] - x1.size()[2]
+
+        x1 = F.pad(x1, [diffX // 2, diffX - diffX // 2])
+        # if you have padding issues, see
+        # https://github.com/HaiyongJiang/U-Net-Pytorch-Unstructured-Buggy/commit/0e854509c2cea854e247a9c615f175f76fbb2e3a
+        # https://github.com/xiaopeng-liao/Pytorch-UNet/commit/8ebac70e633bac59fc22bb5195e513d5832fb3bd
+        x = torch.cat([x2, x1], dim=1)
+        return self.conv(x)
+
+
+class OutConv(nn.Module):
+    def __init__(self, in_channels, out_channels):
+        super(OutConv, self).__init__()
+        self.conv = nn.Conv1d(in_channels, out_channels, kernel_size=1)
+
+    def forward(self, x):
+        return self.conv(x)
+
+
+class UNet1d(nn.Module):
+    def __init__(self, n_channels, n_classes, nfilter=24):
+        super(UNet1d, self).__init__()
+        self.n_channels = n_channels
+        self.n_classes = n_classes
+
+        self.inc = DoubleConv(n_channels, nfilter)
+        self.down1 = Down(nfilter, nfilter * 2)
+        self.down2 = Down(nfilter * 2, nfilter * 4)
+        self.down3 = Down(nfilter * 4, nfilter * 8)
+        self.down4 = Down(nfilter * 8, nfilter * 8)
+        self.up1 = Up(nfilter * 16, nfilter * 4)
+        self.up2 = Up(nfilter * 8, nfilter * 2)
+        self.up3 = Up(nfilter * 4, nfilter * 1)
+        self.up4 = Up(nfilter * 2, nfilter)
+        self.outc = OutConv(nfilter, n_classes)
+
+    def forward(self, x):
+        x1 = self.inc(x)
+        x2 = self.down1(x1)
+        x3 = self.down2(x2)
+        x4 = self.down3(x3)
+        x5 = self.down4(x4)
+        x = self.up1(x5, x4)
+        x = self.up2(x, x3)
+        x = self.up3(x, x2)
+        x = self.up4(x, x1)
+        logits = self.outc(x)
+        return logits
+
+
+if __name__ == "__main__":
+    model = UNet1d(1, 1)
+    print(model)

bcgunet/unet1d-simple.ipynb

@@ -0,0 +1,282 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "62e7e36e",
+   "metadata": {},
+   "source": [
+    "Requirements: Pytorch, mat73, numpy\n",
+    "\n",
+    "```pip install mat73```\n",
+    "\n",
+    "相關論文： https://ieeexplore.ieee.org/document/9124646"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2962af4f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import glob\n",
+    "from os.path import *\n",
+    "import numpy as np\n",
+    "import random\n",
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "import torch.nn.functional as F\n",
+    "import time\n",
+    "import sys\n",
+    "import mat73\n",
+    "import matplotlib.pyplot as plt\n",
+    "from scipy.io import savemat\n",
+    "import os\n",
+    "import tqdm"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6151e083",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "class DoubleConv(nn.Module):\n",
+    "    \"\"\"(convolution => [BN] => ReLU) * 2\"\"\"\n",
+    "\n",
+    "    def __init__(self, in_channels, out_channels, mid_channels=None):\n",
+    "        super().__init__()\n",
+    "        if not mid_channels:\n",
+    "            mid_channels = out_channels\n",
+    "        self.double_conv = nn.Sequential(\n",
+    "            nn.Conv1d(in_channels, mid_channels, kernel_size=3, padding=1),\n",
+    "            nn.GroupNorm(num_groups=8, num_channels=mid_channels),\n",
+    "            nn.ReLU(inplace=True),\n",
+    "            nn.Conv1d(mid_channels, out_channels, kernel_size=3, padding=1),\n",
+    "            nn.GroupNorm(num_groups=8, num_channels=out_channels),\n",
+    "            nn.ReLU(inplace=True)\n",
+    "        )\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        return self.double_conv(x)\n",
+    "\n",
+    "\n",
+    "class Down(nn.Module):\n",
+    "    \"\"\"Downscaling with maxpool then double conv\"\"\"\n",
+    "\n",
+    "    def __init__(self, in_channels, out_channels):\n",
+    "        super().__init__()\n",
+    "        self.maxpool_conv = nn.Sequential(\n",
+    "            nn.MaxPool1d(2),\n",
+    "            DoubleConv(in_channels, out_channels)\n",
+    "        )\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        return self.maxpool_conv(x)\n",
+    "\n",
+    "\n",
+    "class Up(nn.Module):\n",
+    "    \"\"\"Upscaling then double conv\"\"\"\n",
+    "\n",
+    "    def __init__(self, in_channels, out_channels):\n",
+    "        super().__init__()\n",
+    "\n",
+    "        self.up = nn.Upsample(\n",
+    "            scale_factor=2, mode='linear', align_corners=True)\n",
+    "        self.conv = DoubleConv(in_channels, out_channels, in_channels // 2)\n",
+    "\n",
+    "    \n",
+    "    def forward(self, x1, x2):\n",
+    "        x1 = self.up(x1)\n",
+    "        # input is CHW\n",
+    "        diffX = x2.size()[2] - x1.size()[2]\n",
+    "\n",
+    "        x1 = F.pad(x1, [diffX // 2, diffX - diffX // 2])\n",
+    "        # if you have padding issues, see\n",
+    "        # https://github.com/HaiyongJiang/U-Net-Pytorch-Unstructured-Buggy/commit/0e854509c2cea854e247a9c615f175f76fbb2e3a\n",
+    "        # https://github.com/xiaopeng-liao/Pytorch-UNet/commit/8ebac70e633bac59fc22bb5195e513d5832fb3bd\n",
+    "        x = torch.cat([x2, x1], dim=1)\n",
+    "        return self.conv(x)\n",
+    "\n",
+    "\n",
+    "class OutConv(nn.Module):\n",
+    "    def __init__(self, in_channels, out_channels):\n",
+    "        super(OutConv, self).__init__()\n",
+    "        self.conv = nn.Conv1d(in_channels, out_channels, kernel_size=1)\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        return self.conv(x)\n",
+    "\n",
+    "\n",
+    "class UNet1d(nn.Module):\n",
+    "    def __init__(self, n_channels, n_classes, nfilter=24):\n",
+    "        super(UNet1d, self).__init__()\n",
+    "        self.n_channels = n_channels\n",
+    "        self.n_classes = n_classes\n",
+    "\n",
+    "        self.inc = DoubleConv(n_channels, nfilter)\n",
+    "        self.down1 = Down(nfilter, nfilter * 2)\n",
+    "        self.down2 = Down(nfilter * 2, nfilter * 4)\n",
+    "        self.down3 = Down(nfilter * 4, nfilter * 8)\n",
+    "        self.down4 = Down(nfilter * 8, nfilter * 8)\n",
+    "        self.up1 = Up(nfilter * 16, nfilter * 4)\n",
+    "        self.up2 = Up(nfilter * 8, nfilter * 2)\n",
+    "        self.up3 = Up(nfilter * 4, nfilter * 1)\n",
+    "        self.up4 = Up(nfilter * 2, nfilter)\n",
+    "        self.outc = OutConv(nfilter, n_classes)\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x1 = self.inc(x)\n",
+    "        x2 = self.down1(x1)\n",
+    "        x3 = self.down2(x2)\n",
+    "        x4 = self.down3(x3)\n",
+    "        x5 = self.down4(x4)\n",
+    "        x = self.up1(x5, x4)\n",
+    "        x = self.up2(x, x3)\n",
+    "        x = self.up3(x, x2)\n",
+    "        x = self.up4(x, x1)\n",
+    "        logits = self.outc(x)\n",
+    "        return logits\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1f21a6a9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from scipy.signal import butter, sosfilt, sosfreqz\n",
+    "\n",
+    "def butter_bandpass(lowcut, highcut, fs, order=5):\n",
+    "        nyq = 0.5 * fs\n",
+    "        low = lowcut / nyq\n",
+    "        high = highcut / nyq\n",
+    "        sos = butter(order, [low, high], analog=False, btype='band', output='sos')\n",
+    "        return sos\n",
+    "\n",
+    "def butter_bandpass_filter(data, lowcut, highcut, fs, order=5):\n",
+    "        sos = butter_bandpass(lowcut, highcut, fs, order=order)\n",
+    "        y = sosfilt(sos, data)\n",
+    "        return y"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "71b4e84a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "f = r'/NFS/tyhuang/fhlinXBCG/noscan/170320_CLY/analysis/EyeClose1_noscan.mat'\n",
+    "\n",
+    "def norm_ecg(ecg):\n",
+    "    min1, max1 = np.percentile(ecg, [1, 99])\n",
+    "    ecg[ecg>max1] = max1\n",
+    "    ecg[ecg<min1] = min1\n",
+    "    ecg = (ecg - min1)/(max1-min1)\n",
+    "    return ecg\n",
+    "\n",
+    "\n",
+    "data = mat73.loadmat(f)\n",
+    "eeg_filtered = data['EEG_before_bcg'] * 0\n",
+    "t = time.time()\n",
+    "for ii in range(31):\n",
+    "    eeg_filtered[ii, ...] = butter_bandpass_filter(data['EEG_before_bcg'][ii,:], 1, 40, 5000)\n",
+    "\n",
+    "torch.cuda.empty_cache()\n",
+    "device = ('cuda' if torch.cuda.is_available() else 'cpu')\n",
+    "NET = UNet1d(n_channels=1, n_classes=31, nfilter=8).to(device)\n",
+    "#NET = torch.load('pretrainbcg_f8.pt')\n",
+    "#NET.outc = OutConv(8, 31)\n",
+    "NET = NET.to(device)\n",
+    "optimizer = torch.optim.Adam(NET.parameters(), lr=5e-4)\n",
+    "optimizer.zero_grad()\n",
+    "maxlen = data['ECG'].size\n",
+    "\n",
+    "loss_list = []\n",
+    "count = 0\n",
+    "ecg = norm_ecg(data['ECG'])\n",
+    "for ii in range(5000):\n",
+    "    if ii % 10 == 0:\n",
+    "        sys.stdout.write('.')\n",
+    "    index = random.randrange(maxlen-20000)\n",
+    "    ECG = ecg[index:(index+20000)]\n",
+    "    EEG = eeg_filtered[:, index:(index+20000)]\n",
+    "    ECG_d = torch.from_numpy(ECG[None, ...][None, ...]).to(device).float()\n",
+    "    EEG_d = torch.from_numpy(EEG[None, ...]).to(device).float()\n",
+    "\n",
+    "    # step 3: forward path of UNET\n",
+    "    logits = NET(ECG_d)\n",
+    "    loss = nn.MSELoss()(logits, EEG_d)\n",
+    "    loss_list.append(loss.item())\n",
+    "\n",
+    "\n",
+    "    # Step 5: Perform back-propagation\n",
+    "    loss.backward() #accumulate the gradients\n",
+    "    optimizer.step() #Update network weights according to the optimizer\n",
+    "    optimizer.zero_grad() #empty the gradients\n",
+    "\n",
+    "\n",
+    "    if (ii + 1) % 500 == 0: #plot results per 500 iterations\n",
+    "        print('mse loss: ', np.mean(loss_list))\n",
+    "        loss_list = []\n",
+    "        EEG = eeg_filtered[:, :50000]\n",
+    "        ECG = data['ECG'][:50000]\n",
+    "        ECG_d = torch.from_numpy(ECG[None, ...][None, ...]).to(device).float()\n",
+    "        EEG_d = torch.from_numpy(EEG[None, ...]).to(device).float()\n",
+    "        logits = NET(ECG_d)        \n",
+    "        EEG_pred = logits.cpu().detach().numpy()\n",
+    "        plt.figure(figsize=(12, 6), dpi=300)\n",
+    "\n",
+    "        plt.plot(EEG[0, ...], 'g')\n",
+    "        plt.plot(EEG[0, ...] - EEG_pred[0, 0, ...], 'r')\n",
+    "        time1 = round(time.time() - t, 1)\n",
+    "        plt.title(f' {time1} seconds')\n",
+    "        plt.show()\n",
+    "\n",
+    "\n",
+    "# remove BCG from the whole dataset\n",
+    "EEG = eeg_filtered\n",
+    "ECG = data['ECG']\n",
+    "ECG_d = torch.from_numpy(ECG[None, ...][None, ...]).to(device).float()\n",
+    "EEG_d = torch.from_numpy(EEG[None, ...]).to(device).float()\n",
+    "logits = NET(ECG_d)\n",
+    "BCG_pred = logits.cpu().detach().numpy()[0, ...]\n",
+    "EEG_removeBCG_unet = eeg_filtered - BCG_pred\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4dc44936",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

requirements.txt

@@ -0,0 +1,91 @@
+aiofiles==22.1.0 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+aiohttp==3.8.4 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+aiosignal==1.3.1 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+altair==4.2.2 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+anyio==3.6.2 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+async-timeout==4.0.2 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+attrs==23.1.0 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+certifi==2022.12.7 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+charset-normalizer==3.1.0 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+click==8.1.3 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+cmake==3.26.3 ; platform_system == "Linux" and platform_machine == "x86_64" and python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+colorama==0.4.6 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0" and platform_system == "Windows"
+contourpy==1.0.7 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+cycler==0.11.0 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+entrypoints==0.4 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+fastapi==0.95.1 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+ffmpy==0.3.0 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+filelock==3.12.0 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+fonttools==4.39.3 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+frozenlist==1.3.3 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+fsspec==2023.4.0 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+gradio-client==0.1.3 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+gradio==3.27.0 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+h11==0.14.0 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+h5py==3.8.0 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+httpcore==0.17.0 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+httpx==0.24.0 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+huggingface-hub==0.14.1 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+idna==3.4 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+jinja2==3.1.2 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+joblib==1.2.0 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+jsonschema==4.17.3 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+kiwisolver==1.4.4 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+linkify-it-py==2.0.0 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+lit==16.0.2 ; platform_system == "Linux" and platform_machine == "x86_64" and python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+markdown-it-py==2.2.0 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+markdown-it-py[linkify]==2.2.0 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+markupsafe==2.1.2 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+matplotlib==3.7.1 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+mdit-py-plugins==0.3.3 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+mdurl==0.1.2 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+mpmath==1.3.0 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+multidict==6.0.4 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+networkx==3.1 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+numpy==1.24.3 ; python_version >= "3.10" and python_full_version < "3.11.0"
+nvidia-cublas-cu11==11.10.3.66 ; platform_system == "Linux" and platform_machine == "x86_64" and python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+nvidia-cuda-cupti-cu11==11.7.101 ; platform_system == "Linux" and platform_machine == "x86_64" and python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+nvidia-cuda-nvrtc-cu11==11.7.99 ; platform_system == "Linux" and platform_machine == "x86_64" and python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+nvidia-cuda-runtime-cu11==11.7.99 ; platform_system == "Linux" and platform_machine == "x86_64" and python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+nvidia-cudnn-cu11==8.5.0.96 ; platform_system == "Linux" and platform_machine == "x86_64" and python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+nvidia-cufft-cu11==10.9.0.58 ; platform_system == "Linux" and platform_machine == "x86_64" and python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+nvidia-curand-cu11==10.2.10.91 ; platform_system == "Linux" and platform_machine == "x86_64" and python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+nvidia-cusolver-cu11==11.4.0.1 ; platform_system == "Linux" and platform_machine == "x86_64" and python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+nvidia-cusparse-cu11==11.7.4.91 ; platform_system == "Linux" and platform_machine == "x86_64" and python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+nvidia-nccl-cu11==2.14.3 ; platform_system == "Linux" and platform_machine == "x86_64" and python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+nvidia-nvtx-cu11==11.7.91 ; platform_system == "Linux" and platform_machine == "x86_64" and python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+orjson==3.8.10 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+packaging==23.1 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+pandas==2.0.1 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+pillow==9.5.0 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+pydantic==1.10.7 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+pydub==0.25.1 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+pyparsing==3.0.9 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+pyrsistent==0.19.3 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+python-dateutil==2.8.2 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+python-multipart==0.0.6 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+pytz==2023.3 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+pywavelets==1.4.1 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+pyyaml==6.0 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+requests==2.28.2 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+scikit-learn==1.2.2 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+scipy==1.10.1 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+semantic-version==2.10.0 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+setuptools==67.7.2 ; platform_system == "Linux" and platform_machine == "x86_64" and python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+six==1.16.0 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+sniffio==1.3.0 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+starlette==0.26.1 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+sympy==1.11.1 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+threadpoolctl==3.1.0 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+toolz==0.12.0 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+torch==2.0.0 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+tqdm==4.65.0 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+triton==2.0.0 ; platform_system == "Linux" and platform_machine == "x86_64" and python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+typing-extensions==4.5.0 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+tzdata==2023.3 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+uc-micro-py==1.0.1 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+urllib3==1.26.15 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+uvicorn==0.21.1 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+websockets==11.0.2 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+wheel==0.40.0 ; platform_system == "Linux" and platform_machine == "x86_64" and python_full_version >= "3.10.0" and python_full_version < "3.11.0"
+yarl==1.9.2 ; python_full_version >= "3.10.0" and python_full_version < "3.11.0"