Add files using upload-large-folder tool

external/CBraMod/.gitignore

@@ -0,0 +1 @@
+.idea

external/CBraMod/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Jiquan Wang
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

external/CBraMod/README.md

@@ -0,0 +1,118 @@
+<div align="center">
+
+# CBraMod
+
+
+_A Criss-Cross Brain Foundation Model for EEG Decoding_
+
+
+[![Paper](https://img.shields.io/badge/arXiv-2412.07236-red)](https://arxiv.org/abs/2412.07236)
+[![Paper](https://img.shields.io/badge/Paper-ICLR-008B8B)](https://openreview.net/forum?id=NPNUHgHF2w)
+[![huggingface](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Models-FFD21E)](https://huggingface.co/weighting666/CBraMod)
+![GitHub Repo stars](https://img.shields.io/github/stars/wjq-learning/CBraMod)
+
+</div>
+
+
+<div align="center">
+<img src="figure/CBraMod_logo.png" style="width: 15%;" />
+</div>
+
+
+<p align="center">
+    🔍&nbsp;<a href="#-about">About</a>
+    | 🔨&nbsp;<a href="#-setup">Setup</a>
+    | 🚢&nbsp;<a href="#-pretrain">Pretrain</a>
+    | ⛵&nbsp;<a href="#-finetune">Finetune</a>
+    | 🚀&nbsp;<a href="#-quick-start">Quick Start</a>
+    | 🔗&nbsp;<a href="#-citation">Citation</a>
+</p>
+🔥 NEWS: Thanks to over 100 stars! We've further refined the code for improved stability. Appreciate your patience as we refine the implementation — ongoing EEG research continues to shape the development of a standardized pipeline.
+
+🔥 NEWS: The paper "_CBraMod: A Criss-Cross Brain Foundation Model for EEG Decoding_" has been accepted by ICLR 2025!
+
+## 🔍 About
+We propose **CBraMod**, a novel EEG foundation model, for EEG decoding on various clinical and BCI application.
+The preprint version of our paper is available at [arXiv](https://arxiv.org/abs/2412.07236). 
+The camera-ready version of the paper will be available at [OpenReview](https://openreview.net/forum?id=NPNUHgHF2w).
+<div align="center">
+<img src="figure/model.png" style="width:100%;" />
+</div>
+
+
+
+## 🔨 Setup
+Install [Python](https://www.python.org/downloads/).
+
+Install [PyTorch](https://pytorch.org/get-started/locally/).
+
+Install other requirements:
+```commandline
+pip install -r requirements.txt
+``` 
+
+
+## 🚢 Pretrain
+You can pretrain CBraMod on our pretraining dataset or your custom pretraining dataset using the following code:
+```commandline
+python pretrain_main.py
+```
+We have released a pretrained checkpoint on [Hugginface🤗](https://huggingface.co/weighting666/CBraMod).
+
+## ⛵ Finetune
+You can finetune CBraMod on our selected downstream datasets using the following code:
+```commandline
+python finetune_main.py
+```
+
+
+## 🚀 Quick Start
+You can fine-tune the pretrained CBraMod on your custom downstream dataset using the following example code:
+```python
+import torch
+import torch.nn as nn
+from models.cbramod import CBraMod
+from einops.layers.torch import Rearrange
+
+device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+model = CBraMod().to(device)
+model.load_state_dict(torch.load('pretrained_weights/pretrained_weights.pth', map_location=device))
+model.proj_out = nn.Identity()
+classifier = nn.Sequential(
+  Rearrange('b c s p -> b (c s p)'),
+  nn.Linear(22*4*200, 4*200),
+  nn.ELU(),
+  nn.Dropout(0.1),
+  nn.Linear(4 * 200, 200),
+  nn.ELU(),
+  nn.Dropout(0.1),
+  nn.Linear(200, 4),
+).to(device)
+
+# mock_eeg.shape = (batch_size, num_of_channels, time_segments, points_per_patch)
+mock_eeg = torch.randn((8, 22, 4, 200)).to(device)
+
+# logits.shape = (batch_size, num_of_classes)
+logits = classifier(model(mock_eeg))
+```
+
+
+
+## 🔗 Citation
+If you're using this repository in your research or applications, please cite using the following BibTeX:
+```bibtex
+@inproceedings{wang2025cbramod,
+    title={{CB}raMod: A Criss-Cross Brain Foundation Model for {EEG} Decoding},
+    author={Jiquan Wang and Sha Zhao and Zhiling Luo and Yangxuan Zhou and Haiteng Jiang and Shijian Li and Tao Li and Gang Pan},
+    booktitle={The Thirteenth International Conference on Learning Representations},
+    year={2025},
+    url={https://openreview.net/forum?id=NPNUHgHF2w}
+}
+```
+
+## ⭐ Star History
+<div align="center">
+    <a href="https://star-history.com/#wjq-learning/CBraMod&Date">
+        <img src="https://api.star-history.com/svg?repos=wjq-learning/CBraMod&type=Date" style="width: 80%;" />
+    </a>
+</div>

external/CBraMod/datasets/bciciv2a_dataset.py

@@ -0,0 +1,68 @@
+import torch
+from torch.utils.data import Dataset, DataLoader
+import numpy as np
+from utils.util import to_tensor
+import os
+import random
+import lmdb
+import pickle
+
+class CustomDataset(Dataset):
+    def __init__(
+            self,
+            data_dir,
+            mode='train',
+    ):
+        super(CustomDataset, self).__init__()
+        self.db = lmdb.open(data_dir, readonly=True, lock=False, readahead=True, meminit=False)
+        with self.db.begin(write=False) as txn:
+            self.keys = pickle.loads(txn.get('__keys__'.encode()))[mode]
+
+    def __len__(self):
+        return len((self.keys))
+
+    def __getitem__(self, idx):
+        key = self.keys[idx]
+        with self.db.begin(write=False) as txn:
+            pair = pickle.loads(txn.get(key.encode()))
+        data = pair['sample']
+        label = pair['label']
+        return data/100, label
+
+    def collate(self, batch):
+        x_data = np.array([x[0] for x in batch])
+        y_label = np.array([x[1] for x in batch])
+        return to_tensor(x_data), to_tensor(y_label).long()
+
+class LoadDataset(object):
+    def __init__(self, params):
+        self.params = params
+        self.datasets_dir = params.datasets_dir
+
+    def get_data_loader(self):
+        train_set = CustomDataset(self.datasets_dir, mode='train')
+        val_set = CustomDataset(self.datasets_dir, mode='val')
+        test_set = CustomDataset(self.datasets_dir, mode='test')
+        print(len(train_set), len(val_set), len(test_set))
+        print(len(train_set)+len(val_set)+len(test_set))
+        data_loader = {
+            'train': DataLoader(
+                train_set,
+                batch_size=self.params.batch_size,
+                collate_fn=train_set.collate,
+                shuffle=True,
+            ),
+            'val': DataLoader(
+                val_set,
+                batch_size=self.params.batch_size,
+                collate_fn=val_set.collate,
+                shuffle=False,
+            ),
+            'test': DataLoader(
+                test_set,
+                batch_size=self.params.batch_size,
+                collate_fn=test_set.collate,
+                shuffle=False,
+            ),
+        }
+        return data_loader

external/CBraMod/datasets/chb_dataset.py

@@ -0,0 +1,70 @@
+import torch
+from torch.utils.data import Dataset, DataLoader
+import numpy as np
+from utils.util import to_tensor
+import os
+import random
+import lmdb
+import pickle
+from scipy import signal
+
+class CustomDataset(Dataset):
+    def __init__(
+            self,
+            data_dir,
+            mode='train',
+    ):
+        super(CustomDataset, self).__init__()
+        self.files = [os.path.join(data_dir, mode, file) for file in os.listdir(os.path.join(data_dir, mode))]
+
+
+    def __len__(self):
+        return len((self.files))
+
+    def __getitem__(self, idx):
+        file = self.files[idx]
+        data_dict = pickle.load(open(file, 'rb'))
+        data = data_dict['X']
+        label = data_dict['y']
+        data = signal.resample(data, 2000, axis=1)
+        data = data.reshape(16, 10, 200)
+        return data/100, label
+
+    def collate(self, batch):
+        x_data = np.array([x[0] for x in batch])
+        y_label = np.array([x[1] for x in batch])
+        return to_tensor(x_data), to_tensor(y_label)
+
+
+class LoadDataset(object):
+    def __init__(self, params):
+        self.params = params
+        self.datasets_dir = params.datasets_dir
+
+    def get_data_loader(self):
+        train_set = CustomDataset(self.datasets_dir, mode='train')
+        val_set = CustomDataset(self.datasets_dir, mode='val')
+        test_set = CustomDataset(self.datasets_dir, mode='test')
+        print(len(train_set), len(val_set), len(test_set))
+        print(len(train_set) + len(val_set) + len(test_set))
+        data_loader = {
+            'train': DataLoader(
+                train_set,
+                batch_size=self.params.batch_size,
+                collate_fn=train_set.collate,
+                shuffle=True,
+            ),
+            'val': DataLoader(
+                val_set,
+                batch_size=self.params.batch_size,
+                collate_fn=val_set.collate,
+                shuffle=False,
+            ),
+            'test': DataLoader(
+                test_set,
+                batch_size=self.params.batch_size,
+                collate_fn=test_set.collate,
+                shuffle=False,
+            ),
+        }
+        return data_loader

external/CBraMod/datasets/faced_dataset.py

@@ -0,0 +1,69 @@
+import torch
+from torch.utils.data import Dataset, DataLoader
+import numpy as np
+from utils.util import to_tensor
+import os
+import random
+import lmdb
+import pickle
+
+class CustomDataset(Dataset):
+    def __init__(
+            self,
+            data_dir,
+            mode='train',
+    ):
+        super(CustomDataset, self).__init__()
+        self.db = lmdb.open(data_dir, readonly=True, lock=False, readahead=True, meminit=False)
+        with self.db.begin(write=False) as txn:
+            self.keys = pickle.loads(txn.get('__keys__'.encode()))[mode]
+
+    def __len__(self):
+        return len((self.keys))
+
+    def __getitem__(self, idx):
+        key = self.keys[idx]
+        with self.db.begin(write=False) as txn:
+            pair = pickle.loads(txn.get(key.encode()))
+        data = pair['sample']
+        label = pair['label']
+        return data/100, label
+
+    def collate(self, batch):
+        x_data = np.array([x[0] for x in batch])
+        y_label = np.array([x[1] for x in batch])
+        return to_tensor(x_data), to_tensor(y_label).long()
+
+
+class LoadDataset(object):
+    def __init__(self, params):
+        self.params = params
+        self.datasets_dir = params.datasets_dir
+
+    def get_data_loader(self):
+        train_set = CustomDataset(self.datasets_dir, mode='train')
+        val_set = CustomDataset(self.datasets_dir, mode='val')
+        test_set = CustomDataset(self.datasets_dir, mode='test')
+        print(len(train_set), len(val_set), len(test_set))
+        print(len(train_set)+len(val_set)+len(test_set))
+        data_loader = {
+            'train': DataLoader(
+                train_set,
+                batch_size=self.params.batch_size,
+                collate_fn=train_set.collate,
+                shuffle=True,
+            ),
+            'val': DataLoader(
+                val_set,
+                batch_size=self.params.batch_size,
+                collate_fn=val_set.collate,
+                shuffle=False,
+            ),
+            'test': DataLoader(
+                test_set,
+                batch_size=self.params.batch_size,
+                collate_fn=test_set.collate,
+                shuffle=False,
+            ),
+        }
+        return data_loader

external/CBraMod/datasets/isruc_dataset.py

@@ -0,0 +1,107 @@
+import torch
+from torch.utils.data import Dataset, DataLoader
+import numpy as np
+from utils.util import to_tensor
+import os
+import random
+
+
+
+class CustomDataset(Dataset):
+    def __init__(
+            self,
+            seqs_labels_path_pair
+    ):
+        super(CustomDataset, self).__init__()
+        self.seqs_labels_path_pair = seqs_labels_path_pair
+
+    def __len__(self):
+        return len((self.seqs_labels_path_pair))
+
+    def __getitem__(self, idx):
+        seq_path = self.seqs_labels_path_pair[idx][0]
+        label_path = self.seqs_labels_path_pair[idx][1]
+        # print(seq_path)
+        # print(label_path)
+        seq = np.load(seq_path)
+        label = np.load(label_path)
+        return seq/100, label
+
+    def collate(self, batch):
+        x_seq = np.array([x[0] for x in batch])
+        y_label = np.array([x[1] for x in batch])
+        return to_tensor(x_seq), to_tensor(y_label).long()
+
+
+class LoadDataset(object):
+    def __init__(self, params):
+        self.params = params
+        self.seqs_dir = os.path.join(params.datasets_dir, 'seq')
+        self.labels_dir = os.path.join(params.datasets_dir, 'labels')
+        self.seqs_labels_path_pair = self.load_path()
+
+    def get_data_loader(self):
+        train_pairs, val_pairs, test_pairs = self.split_dataset(self.seqs_labels_path_pair)
+        train_set = CustomDataset(train_pairs)
+        val_set = CustomDataset(val_pairs)
+        test_set = CustomDataset(test_pairs)
+        print(len(train_set), len(val_set), len(test_set))
+        print(len(train_set) + len(val_set) + len(test_set))
+        data_loader = {
+            'train': DataLoader(
+                train_set,
+                batch_size=self.params.batch_size,
+                collate_fn=train_set.collate,
+                shuffle=True,
+            ),
+            'val': DataLoader(
+                val_set,
+                batch_size=1,
+                collate_fn=val_set.collate,
+                shuffle=False,
+            ),
+            'test': DataLoader(
+                test_set,
+                batch_size=1,
+                collate_fn=test_set.collate,
+                shuffle=False,
+            ),
+        }
+        return data_loader
+
+    def load_path(self):
+        seqs_labels_path_pair = []
+        # subject_nums = os.listdir(self.seqs_dir)
+        # print(subject_nums)
+        subject_dirs_seq = []
+        subject_dirs_labels = []
+        for subject_num in range(1, 101):
+            subject_dirs_seq.append(os.path.join(self.seqs_dir, f'ISRUC-group1-{subject_num}'))
+            subject_dirs_labels.append(os.path.join(self.labels_dir, f'ISRUC-group1-{subject_num}'))
+
+        for subject_seq, subject_label in zip(subject_dirs_seq, subject_dirs_labels):
+            # print(subject_seq, subject_label)
+            subject_pairs = []
+            seq_fnames = os.listdir(subject_seq)
+            label_fnames = os.listdir(subject_label)
+            # print(seq_fnames)
+            for seq_fname, label_fname in zip(seq_fnames, label_fnames):
+                subject_pairs.append((os.path.join(subject_seq, seq_fname), os.path.join(subject_label, label_fname)))
+            seqs_labels_path_pair.append(subject_pairs)
+        # print(seqs_labels_path_pair)
+        return seqs_labels_path_pair
+
+    def split_dataset(self, seqs_labels_path_pair):
+        train_pairs = []
+        val_pairs = []
+        test_pairs = []
+
+        for i in range(100):
+            if i < 80:
+                train_pairs.extend(seqs_labels_path_pair[i])
+            elif i < 90:
+                val_pairs.extend(seqs_labels_path_pair[i])
+            else:
+                test_pairs.extend(seqs_labels_path_pair[i])
+        # print(train_pairs, val_pairs, test_pairs)
+        return train_pairs, val_pairs, test_pairs

external/CBraMod/datasets/mumtaz_dataset.py

@@ -0,0 +1,70 @@
+import torch
+from torch.utils.data import Dataset, DataLoader
+import numpy as np
+from utils.util import to_tensor
+import os
+import random
+import lmdb
+import pickle
+
+class CustomDataset(Dataset):
+    def __init__(
+            self,
+            data_dir,
+            mode='train',
+    ):
+        super(CustomDataset, self).__init__()
+        self.db = lmdb.open(data_dir, readonly=True, lock=False, readahead=True, meminit=False)
+        with self.db.begin(write=False) as txn:
+            self.keys = pickle.loads(txn.get('__keys__'.encode()))[mode]
+
+    def __len__(self):
+        return len((self.keys))
+
+    def __getitem__(self, idx):
+        key = self.keys[idx]
+        with self.db.begin(write=False) as txn:
+            pair = pickle.loads(txn.get(key.encode()))
+        data = pair['sample']
+        label = pair['label']
+        # print(label)
+        return data/100, label
+
+    def collate(self, batch):
+        x_data = np.array([x[0] for x in batch])
+        y_label = np.array([x[1] for x in batch])
+        return to_tensor(x_data), to_tensor(y_label)
+
+
+class LoadDataset(object):
+    def __init__(self, params):
+        self.params = params
+        self.datasets_dir = params.datasets_dir
+
+    def get_data_loader(self):
+        train_set = CustomDataset(self.datasets_dir, mode='train')
+        val_set = CustomDataset(self.datasets_dir, mode='val')
+        test_set = CustomDataset(self.datasets_dir, mode='test')
+        print(len(train_set), len(val_set), len(test_set))
+        print(len(train_set) + len(val_set) + len(test_set))
+        data_loader = {
+            'train': DataLoader(
+                train_set,
+                batch_size=self.params.batch_size,
+                collate_fn=train_set.collate,
+                shuffle=True,
+            ),
+            'val': DataLoader(
+                val_set,
+                batch_size=self.params.batch_size,
+                collate_fn=val_set.collate,
+                shuffle=True,
+            ),
+            'test': DataLoader(
+                test_set,
+                batch_size=self.params.batch_size,
+                collate_fn=test_set.collate,
+                shuffle=True,
+            ),
+        }
+        return data_loader

external/CBraMod/datasets/physio_dataset.py

@@ -0,0 +1,72 @@
+import torch
+from torch.utils.data import Dataset, DataLoader
+import numpy as np
+from utils.util import to_tensor
+import os
+import random
+import lmdb
+import pickle
+
+class CustomDataset(Dataset):
+    def __init__(
+            self,
+            data_dir,
+            mode='train',
+    ):
+        super(CustomDataset, self).__init__()
+        self.db = lmdb.open(data_dir, readonly=True, lock=False, readahead=True, meminit=False)
+        with self.db.begin(write=False) as txn:
+            self.keys = pickle.loads(txn.get('__keys__'.encode()))[mode]
+
+    def __len__(self):
+        return len((self.keys))
+
+    def __getitem__(self, idx):
+        key = self.keys[idx]
+        with self.db.begin(write=False) as txn:
+            pair = pickle.loads(txn.get(key.encode()))
+        data = pair['sample']
+        label = pair['label']
+        # print(key)
+        # print(data)
+        # print(label)
+        return data/100, label
+
+    def collate(self, batch):
+        x_data = np.array([x[0] for x in batch])
+        y_label = np.array([x[1] for x in batch])
+        return to_tensor(x_data), to_tensor(y_label).long()
+
+
+class LoadDataset(object):
+    def __init__(self, params):
+        self.params = params
+        self.datasets_dir = params.datasets_dir
+
+    def get_data_loader(self):
+        train_set = CustomDataset(self.datasets_dir, mode='train')
+        val_set = CustomDataset(self.datasets_dir, mode='val')
+        test_set = CustomDataset(self.datasets_dir, mode='test')
+        print(len(train_set), len(val_set), len(test_set))
+        print(len(train_set)+len(val_set)+len(test_set))
+        data_loader = {
+            'train': DataLoader(
+                train_set,
+                batch_size=self.params.batch_size,
+                collate_fn=train_set.collate,
+                shuffle=True,
+            ),
+            'val': DataLoader(
+                val_set,
+                batch_size=self.params.batch_size,
+                collate_fn=val_set.collate,
+                shuffle=False,
+            ),
+            'test': DataLoader(
+                test_set,
+                batch_size=self.params.batch_size,
+                collate_fn=test_set.collate,
+                shuffle=False,
+            ),
+        }
+        return data_loader

external/CBraMod/datasets/pretraining_dataset.py

@@ -0,0 +1,34 @@
+import pickle
+
+import lmdb
+from torch.utils.data import Dataset
+
+from utils.util import to_tensor
+
+
+class PretrainingDataset(Dataset):
+    def __init__(
+            self,
+            dataset_dir
+    ):
+        super(PretrainingDataset, self).__init__()
+        self.db = lmdb.open(dataset_dir, readonly=True, lock=False, readahead=True, meminit=False)
+        with self.db.begin(write=False) as txn:
+            self.keys = pickle.loads(txn.get('__keys__'.encode()))
+        # self.keys = self.keys[:100000]
+
+    def __len__(self):
+        return len(self.keys)
+
+    def __getitem__(self, idx):
+        key = self.keys[idx]
+
+        with self.db.begin(write=False) as txn:
+            patch = pickle.loads(txn.get(key.encode()))
+
+        patch = to_tensor(patch)
+        # print(patch.shape)
+        return patch
+
+
+

external/CBraMod/datasets/seedv_dataset.py

@@ -0,0 +1,73 @@
+import torch
+from torch.utils.data import Dataset, DataLoader
+import numpy as np
+from utils.util import to_tensor
+import os
+import random
+import lmdb
+import pickle
+
+
+class CustomDataset(Dataset):
+    def __init__(
+            self,
+            data_dir,
+            mode='train',
+    ):
+        super(CustomDataset, self).__init__()
+        self.db = lmdb.open(data_dir, readonly=True, lock=False, readahead=True, meminit=False)
+        with self.db.begin(write=False) as txn:
+            self.keys = pickle.loads(txn.get('__keys__'.encode()))[mode]
+
+    def __len__(self):
+        return len((self.keys))
+
+    def __getitem__(self, idx):
+        key = self.keys[idx]
+        with self.db.begin(write=False) as txn:
+            pair = pickle.loads(txn.get(key.encode()))
+        data = pair['sample']
+        label = pair['label']
+        # print(key)
+        # print(data)
+        # print(label)
+        return data / 100, label
+
+    def collate(self, batch):
+        x_data = np.array([x[0] for x in batch])
+        y_label = np.array([x[1] for x in batch])
+        return to_tensor(x_data), to_tensor(y_label).long()
+
+
+class LoadDataset(object):
+    def __init__(self, params):
+        self.params = params
+        self.datasets_dir = params.datasets_dir
+
+    def get_data_loader(self):
+        train_set = CustomDataset(self.datasets_dir, mode='train')
+        val_set = CustomDataset(self.datasets_dir, mode='val')
+        test_set = CustomDataset(self.datasets_dir, mode='test')
+        print(len(train_set), len(val_set), len(test_set))
+        print(len(train_set) + len(val_set) + len(test_set))
+        data_loader = {
+            'train': DataLoader(
+                train_set,
+                batch_size=self.params.batch_size,
+                collate_fn=train_set.collate,
+                shuffle=True,
+            ),
+            'val': DataLoader(
+                val_set,
+                batch_size=self.params.batch_size,
+                collate_fn=val_set.collate,
+                shuffle=False,
+            ),
+            'test': DataLoader(
+                test_set,
+                batch_size=self.params.batch_size,
+                collate_fn=test_set.collate,
+                shuffle=False,
+            ),
+        }
+        return data_loader

external/CBraMod/datasets/seedvig_dataset.py

@@ -0,0 +1,70 @@
+import torch
+from torch.utils.data import Dataset, DataLoader
+import numpy as np
+from utils.util import to_tensor
+import os
+import random
+import lmdb
+import pickle
+
+class CustomDataset(Dataset):
+    def __init__(
+            self,
+            data_dir,
+            mode='train',
+    ):
+        super(CustomDataset, self).__init__()
+        self.db = lmdb.open(data_dir, readonly=True, lock=False, readahead=True, meminit=False)
+        with self.db.begin(write=False) as txn:
+            self.keys = pickle.loads(txn.get('__keys__'.encode()))[mode]
+
+    def __len__(self):
+        return len((self.keys))
+
+    def __getitem__(self, idx):
+        key = self.keys[idx]
+        with self.db.begin(write=False) as txn:
+            pair = pickle.loads(txn.get(key.encode()))
+        data = pair['sample']
+        label = pair['label']
+        # print(key)
+        # print(data.shape)
+        return data/100, label
+
+    def collate(self, batch):
+        x_data = np.array([x[0] for x in batch])
+        y_label = np.array([x[1] for x in batch])
+        return to_tensor(x_data), to_tensor(y_label)
+
+
+class LoadDataset(object):
+    def __init__(self, params):
+        self.params = params
+        self.datasets_dir = params.datasets_dir
+
+    def get_data_loader(self):
+        train_set = CustomDataset(self.datasets_dir, mode='train')
+        val_set = CustomDataset(self.datasets_dir, mode='val')
+        test_set = CustomDataset(self.datasets_dir, mode='test')
+        print(len(train_set), len(val_set), len(test_set))
+        data_loader = {
+            'train': DataLoader(
+                train_set,
+                batch_size=self.params.batch_size,
+                collate_fn=train_set.collate,
+                shuffle=True,
+            ),
+            'val': DataLoader(
+                val_set,
+                batch_size=self.params.batch_size,
+                collate_fn=val_set.collate,
+                shuffle=False,
+            ),
+            'test': DataLoader(
+                test_set,
+                batch_size=self.params.batch_size,
+                collate_fn=test_set.collate,
+                shuffle=False,
+            ),
+        }
+        return data_loader

external/CBraMod/datasets/shu_dataset.py

@@ -0,0 +1,70 @@
+import torch
+from torch.utils.data import Dataset, DataLoader
+import numpy as np
+from utils.util import to_tensor
+import os
+import random
+import lmdb
+import pickle
+
+class CustomDataset(Dataset):
+    def __init__(
+            self,
+            data_dir,
+            mode='train',
+    ):
+        super(CustomDataset, self).__init__()
+        self.db = lmdb.open(data_dir, readonly=True, lock=False, readahead=True, meminit=False)
+        with self.db.begin(write=False) as txn:
+            self.keys = pickle.loads(txn.get('__keys__'.encode()))[mode]
+
+    def __len__(self):
+        return len((self.keys))
+
+    def __getitem__(self, idx):
+        key = self.keys[idx]
+        with self.db.begin(write=False) as txn:
+            pair = pickle.loads(txn.get(key.encode()))
+        data = pair['sample']
+        label = pair['label']
+        # print(label)
+        return data/100, label
+
+    def collate(self, batch):
+        x_data = np.array([x[0] for x in batch])
+        y_label = np.array([x[1] for x in batch])
+        return to_tensor(x_data), to_tensor(y_label)
+
+
+class LoadDataset(object):
+    def __init__(self, params):
+        self.params = params
+        self.datasets_dir = params.datasets_dir
+
+    def get_data_loader(self):
+        train_set = CustomDataset(self.datasets_dir, mode='train')
+        val_set = CustomDataset(self.datasets_dir, mode='val')
+        test_set = CustomDataset(self.datasets_dir, mode='test')
+        print(len(train_set), len(val_set), len(test_set))
+        print(len(train_set)+len(val_set)+len(test_set))
+        data_loader = {
+            'train': DataLoader(
+                train_set,
+                batch_size=self.params.batch_size,
+                collate_fn=train_set.collate,
+                shuffle=True,
+            ),
+            'val': DataLoader(
+                val_set,
+                batch_size=self.params.batch_size,
+                collate_fn=val_set.collate,
+                shuffle=True,
+            ),
+            'test': DataLoader(
+                test_set,
+                batch_size=self.params.batch_size,
+                collate_fn=test_set.collate,
+                shuffle=True,
+            ),
+        }
+        return data_loader

external/CBraMod/datasets/speech_dataset.py

@@ -0,0 +1,71 @@
+import torch
+from torch.utils.data import Dataset, DataLoader
+import numpy as np
+from utils.util import to_tensor
+import os
+import random
+import lmdb
+import pickle
+
+class CustomDataset(Dataset):
+    def __init__(
+            self,
+            data_dir,
+            mode='train',
+    ):
+        super(CustomDataset, self).__init__()
+        self.db = lmdb.open(data_dir, readonly=True, lock=False, readahead=True, meminit=False)
+        with self.db.begin(write=False) as txn:
+            self.keys = pickle.loads(txn.get('__keys__'.encode()))[mode]
+
+    def __len__(self):
+        return len((self.keys))
+
+    def __getitem__(self, idx):
+        key = self.keys[idx]
+        with self.db.begin(write=False) as txn:
+            pair = pickle.loads(txn.get(key.encode()))
+        data = pair['sample']
+        label = pair['label']
+        # print(key)
+        # print(data.shape)
+        # print(label)
+        return data/100, label
+
+    def collate(self, batch):
+        x_data = np.array([x[0] for x in batch])
+        y_label = np.array([x[1] for x in batch])
+        return to_tensor(x_data), to_tensor(y_label).long()
+
+
+class LoadDataset(object):
+    def __init__(self, params):
+        self.params = params
+        self.datasets_dir = params.datasets_dir
+
+    def get_data_loader(self):
+        train_set = CustomDataset(self.datasets_dir, mode='train')
+        val_set = CustomDataset(self.datasets_dir, mode='val')
+        test_set = CustomDataset(self.datasets_dir, mode='test')
+        print(len(train_set), len(val_set), len(test_set))
+        data_loader = {
+            'train': DataLoader(
+                train_set,
+                batch_size=self.params.batch_size,
+                collate_fn=train_set.collate,
+                shuffle=True,
+            ),
+            'val': DataLoader(
+                val_set,
+                batch_size=self.params.batch_size,
+                collate_fn=val_set.collate,
+                shuffle=False,
+            ),
+            'test': DataLoader(
+                test_set,
+                batch_size=self.params.batch_size,
+                collate_fn=test_set.collate,
+                shuffle=False,
+            ),
+        }
+        return data_loader

external/CBraMod/datasets/stress_dataset.py

@@ -0,0 +1,70 @@
+import torch
+from torch.utils.data import Dataset, DataLoader
+import numpy as np
+from utils.util import to_tensor
+import os
+import random
+import lmdb
+import pickle
+
+class CustomDataset(Dataset):
+    def __init__(
+            self,
+            data_dir,
+            mode='train',
+    ):
+        super(CustomDataset, self).__init__()
+        self.db = lmdb.open(data_dir, readonly=True, lock=False, readahead=True, meminit=False)
+        with self.db.begin(write=False) as txn:
+            self.keys = pickle.loads(txn.get('__keys__'.encode()))[mode]
+
+    def __len__(self):
+        return len((self.keys))
+
+    def __getitem__(self, idx):
+        key = self.keys[idx]
+        with self.db.begin(write=False) as txn:
+            pair = pickle.loads(txn.get(key.encode()))
+        data = pair['sample']
+        label = pair['label']
+        # print(label)
+        return data/100, label
+
+    def collate(self, batch):
+        x_data = np.array([x[0] for x in batch])
+        y_label = np.array([x[1] for x in batch])
+        return to_tensor(x_data), to_tensor(y_label)
+
+
+class LoadDataset(object):
+    def __init__(self, params):
+        self.params = params
+        self.datasets_dir = params.datasets_dir
+
+    def get_data_loader(self):
+        train_set = CustomDataset(self.datasets_dir, mode='train')
+        val_set = CustomDataset(self.datasets_dir, mode='val')
+        test_set = CustomDataset(self.datasets_dir, mode='test')
+        print(len(train_set), len(val_set), len(test_set))
+        print(len(train_set)+len(val_set)+len(test_set))
+        data_loader = {
+            'train': DataLoader(
+                train_set,
+                batch_size=self.params.batch_size,
+                collate_fn=train_set.collate,
+                shuffle=True,
+            ),
+            'val': DataLoader(
+                val_set,
+                batch_size=self.params.batch_size,
+                collate_fn=val_set.collate,
+                shuffle=True,
+            ),
+            'test': DataLoader(
+                test_set,
+                batch_size=self.params.batch_size,
+                collate_fn=test_set.collate,
+                shuffle=True,
+            ),
+        }
+        return data_loader

external/CBraMod/datasets/tuab_dataset.py

@@ -0,0 +1,70 @@
+import torch
+from torch.utils.data import Dataset, DataLoader
+import numpy as np
+from utils.util import to_tensor
+import os
+import random
+import lmdb
+import pickle
+from scipy import signal
+
+class CustomDataset(Dataset):
+    def __init__(
+            self,
+            data_dir,
+            mode='train',
+    ):
+        super(CustomDataset, self).__init__()
+        self.files = [os.path.join(data_dir, mode, file) for file in os.listdir(os.path.join(data_dir, mode))]
+
+
+    def __len__(self):
+        return len((self.files))
+
+    def __getitem__(self, idx):
+        file = self.files[idx]
+        data_dict = pickle.load(open(file, 'rb'))
+        data = data_dict['X']
+        label = data_dict['y']
+        # data = signal.resample(data, 2000, axis=-1)
+        data = data.reshape(16, 10, 200)
+        return data/100, label
+
+    def collate(self, batch):
+        x_data = np.array([x[0] for x in batch])
+        y_label = np.array([x[1] for x in batch])
+        return to_tensor(x_data), to_tensor(y_label)
+
+
+class LoadDataset(object):
+    def __init__(self, params):
+        self.params = params
+        self.datasets_dir = params.datasets_dir
+
+    def get_data_loader(self):
+        train_set = CustomDataset(self.datasets_dir, mode='train')
+        val_set = CustomDataset(self.datasets_dir, mode='val')
+        test_set = CustomDataset(self.datasets_dir, mode='test')
+        print(len(train_set), len(val_set), len(test_set))
+        print(len(train_set) + len(val_set) + len(test_set))
+        data_loader = {
+            'train': DataLoader(
+                train_set,
+                batch_size=self.params.batch_size,
+                collate_fn=train_set.collate,
+                shuffle=True,
+            ),
+            'val': DataLoader(
+                val_set,
+                batch_size=self.params.batch_size,
+                collate_fn=val_set.collate,
+                shuffle=False,
+            ),
+            'test': DataLoader(
+                test_set,
+                batch_size=self.params.batch_size,
+                collate_fn=test_set.collate,
+                shuffle=False,
+            ),
+        }
+        return data_loader

external/CBraMod/datasets/tuev_dataset.py

@@ -0,0 +1,77 @@
+import torch
+from torch.utils.data import Dataset, DataLoader
+import numpy as np
+from utils.util import to_tensor
+import os
+import random
+import lmdb
+import pickle
+from scipy import signal
+
+
+class CustomDataset(Dataset):
+    def __init__(
+            self,
+            data_dir,
+            files,
+    ):
+        super(CustomDataset, self).__init__()
+        self.data_dir = data_dir
+        self.files = files
+
+    def __len__(self):
+        return len((self.files))
+
+    def __getitem__(self, idx):
+        file = self.files[idx]
+        data_dict = pickle.load(open(os.path.join(self.data_dir, file), "rb"))
+        data = data_dict['signal']
+        label = int(data_dict['label'][0]-1)
+        # data = signal.resample(data, 1000, axis=-1)
+        data = data.reshape(16, 5, 200)
+        return data/100, label
+
+    def collate(self, batch):
+        x_data = np.array([x[0] for x in batch])
+        y_label = np.array([x[1] for x in batch])
+        return to_tensor(x_data), to_tensor(y_label).long()
+
+
+class LoadDataset(object):
+    def __init__(self, params):
+        self.params = params
+        self.datasets_dir = params.datasets_dir
+
+    def get_data_loader(self):
+        train_files = os.listdir(os.path.join(self.datasets_dir, "processed_train"))
+        val_files = os.listdir(os.path.join(self.datasets_dir, "processed_eval"))
+        test_files = os.listdir(os.path.join(self.datasets_dir, "processed_test"))
+
+        train_set = CustomDataset(os.path.join(self.datasets_dir, "processed_train"), train_files)
+        val_set = CustomDataset(os.path.join(self.datasets_dir, "processed_eval"), val_files)
+        test_set = CustomDataset(os.path.join(self.datasets_dir, "processed_test"), test_files)
+
+        print(len(train_set), len(val_set), len(test_set))
+        print(len(train_set)+len(val_set)+len(test_set))
+
+        data_loader = {
+            'train': DataLoader(
+                train_set,
+                batch_size=self.params.batch_size,
+                collate_fn=train_set.collate,
+                shuffle=True,
+            ),
+            'val': DataLoader(
+                val_set,
+                batch_size=self.params.batch_size,
+                collate_fn=val_set.collate,
+                shuffle=False,
+            ),
+            'test': DataLoader(
+                test_set,
+                batch_size=self.params.batch_size,
+                collate_fn=test_set.collate,
+                shuffle=False,
+            ),
+        }
+        return data_loader

external/CBraMod/finetune_evaluator.py

@@ -0,0 +1,79 @@
+import numpy as np
+import torch
+from sklearn.metrics import balanced_accuracy_score, f1_score, confusion_matrix, cohen_kappa_score, roc_auc_score, \
+    precision_recall_curve, auc, r2_score, mean_squared_error
+from tqdm import tqdm
+
+
+class Evaluator:
+    def __init__(self, params, data_loader):
+        self.params = params
+        self.data_loader = data_loader
+
+    def get_metrics_for_multiclass(self, model):
+        model.eval()
+
+        truths = []
+        preds = []
+        for x, y in tqdm(self.data_loader, mininterval=1):
+            x = x.cuda()
+            y = y.cuda()
+
+            pred = model(x)
+            pred_y = torch.max(pred, dim=-1)[1]
+
+            truths += y.cpu().squeeze().numpy().tolist()
+            preds += pred_y.cpu().squeeze().numpy().tolist()
+
+        truths = np.array(truths)
+        preds = np.array(preds)
+        acc = balanced_accuracy_score(truths, preds)
+        f1 = f1_score(truths, preds, average='weighted')
+        kappa = cohen_kappa_score(truths, preds)
+        cm = confusion_matrix(truths, preds)
+        return acc, kappa, f1, cm
+
+    def get_metrics_for_binaryclass(self, model):
+        model.eval()
+
+        truths = []
+        preds = []
+        scores = []
+        for x, y in tqdm(self.data_loader, mininterval=1):
+            x = x.cuda()
+            y = y.cuda()
+            pred = model(x)
+            score_y = torch.sigmoid(pred)
+            pred_y = torch.gt(score_y, 0.5).long()
+            truths += y.long().cpu().squeeze().numpy().tolist()
+            preds += pred_y.cpu().squeeze().numpy().tolist()
+            scores += score_y.cpu().numpy().tolist()
+
+        truths = np.array(truths)
+        preds = np.array(preds)
+        scores = np.array(scores)
+        acc = balanced_accuracy_score(truths, preds)
+        roc_auc = roc_auc_score(truths, scores)
+        precision, recall, thresholds = precision_recall_curve(truths, scores, pos_label=1)
+        pr_auc = auc(recall, precision)
+        cm = confusion_matrix(truths, preds)
+        return acc, pr_auc, roc_auc, cm
+
+    def get_metrics_for_regression(self, model):
+        model.eval()
+
+        truths = []
+        preds = []
+        for x, y in tqdm(self.data_loader, mininterval=1):
+            x = x.cuda()
+            y = y.cuda()
+            pred = model(x)
+            truths += y.cpu().squeeze().numpy().tolist()
+            preds += pred.cpu().squeeze().numpy().tolist()
+
+        truths = np.array(truths)
+        preds = np.array(preds)
+        corrcoef = np.corrcoef(truths, preds)[0, 1]
+        r2 = r2_score(truths, preds)
+        rmse = mean_squared_error(truths, preds) ** 0.5
+        return corrcoef, r2, rmse

external/CBraMod/finetune_main.py

@@ -0,0 +1,153 @@
+import argparse
+import random
+
+import numpy as np
+import torch
+
+from datasets import faced_dataset, seedv_dataset, physio_dataset, shu_dataset, isruc_dataset, chb_dataset, \
+    speech_dataset, mumtaz_dataset, seedvig_dataset, stress_dataset, tuev_dataset, tuab_dataset, bciciv2a_dataset
+from finetune_trainer import Trainer
+from models import model_for_faced, model_for_seedv, model_for_physio, model_for_shu, model_for_isruc, model_for_chb, \
+    model_for_speech, model_for_mumtaz, model_for_seedvig, model_for_stress, model_for_tuev, model_for_tuab, \
+    model_for_bciciv2a
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Big model downstream')
+    parser.add_argument('--seed', type=int, default=3407, help='random seed (default: 0)')
+    parser.add_argument('--cuda', type=int, default=1, help='cuda number (default: 1)')
+    parser.add_argument('--epochs', type=int, default=50, help='number of epochs (default: 5)')
+    parser.add_argument('--batch_size', type=int, default=64, help='batch size for training (default: 32)')
+    parser.add_argument('--lr', type=float, default=1e-4, help='learning rate (default: 1e-3)')
+    parser.add_argument('--weight_decay', type=float, default=5e-2, help='weight decay (default: 1e-2)')
+    parser.add_argument('--optimizer', type=str, default='AdamW', help='optimizer (AdamW, SGD)')
+    parser.add_argument('--clip_value', type=float, default=1, help='clip_value')
+    parser.add_argument('--dropout', type=float, default=0.1, help='dropout')
+    parser.add_argument('--classifier', type=str, default='all_patch_reps',
+                        help='[all_patch_reps, all_patch_reps_twolayer, '
+                             'all_patch_reps_onelayer, avgpooling_patch_reps]')
+    # all_patch_reps: use all patch features with a three-layer classifier;
+    # all_patch_reps_twolayer: use all patch features with a two-layer classifier;
+    # all_patch_reps_onelayer: use all patch features with a one-layer classifier;
+    # avgpooling_patch_reps: use average pooling for patch features;
+
+    """############ Downstream dataset settings ############"""
+    parser.add_argument('--downstream_dataset', type=str, default='MentalArithmetic',
+                        help='[FACED, SEED-V, PhysioNet-MI, SHU-MI, ISRUC, CHB-MIT, BCIC2020-3, Mumtaz2016, '
+                             'SEED-VIG, MentalArithmetic, TUEV, TUAB, BCIC-IV-2a]')
+    parser.add_argument('--datasets_dir', type=str,
+                        default='/data/datasets/BigDownstream/mental-arithmetic/processed',
+                        help='datasets_dir')
+    parser.add_argument('--num_of_classes', type=int, default=2, help='number of classes')
+    parser.add_argument('--model_dir', type=str, default='/data/wjq/models_weights/Big/BigFaced', help='model_dir')
+    """############ Downstream dataset settings ############"""
+
+    parser.add_argument('--num_workers', type=int, default=16, help='num_workers')
+    parser.add_argument('--label_smoothing', type=float, default=0.1, help='label_smoothing')
+    parser.add_argument('--multi_lr', type=bool, default=True,
+                        help='multi_lr')  # set different learning rates for different modules
+    parser.add_argument('--frozen', type=bool,
+                        default=False, help='frozen')
+    parser.add_argument('--use_pretrained_weights', type=bool,
+                        default=True, help='use_pretrained_weights')
+    parser.add_argument('--foundation_dir', type=str,
+                        default='pretrained_weights/pretrained_weights.pth',
+                        help='foundation_dir')
+
+    params = parser.parse_args()
+    print(params)
+
+    setup_seed(params.seed)
+    torch.cuda.set_device(params.cuda)
+    print('The downstream dataset is {}'.format(params.downstream_dataset))
+    if params.downstream_dataset == 'FACED':
+        load_dataset = faced_dataset.LoadDataset(params)
+        data_loader = load_dataset.get_data_loader()
+        model = model_for_faced.Model(params)
+        t = Trainer(params, data_loader, model)
+        t.train_for_multiclass()
+    elif params.downstream_dataset == 'SEED-V':
+        load_dataset = seedv_dataset.LoadDataset(params)
+        data_loader = load_dataset.get_data_loader()
+        model = model_for_seedv.Model(params)
+        t = Trainer(params, data_loader, model)
+        t.train_for_multiclass()
+    elif params.downstream_dataset == 'PhysioNet-MI':
+        load_dataset = physio_dataset.LoadDataset(params)
+        data_loader = load_dataset.get_data_loader()
+        model = model_for_physio.Model(params)
+        t = Trainer(params, data_loader, model)
+        t.train_for_multiclass()
+    elif params.downstream_dataset == 'SHU-MI':
+        load_dataset = shu_dataset.LoadDataset(params)
+        data_loader = load_dataset.get_data_loader()
+        model = model_for_shu.Model(params)
+        t = Trainer(params, data_loader, model)
+        t.train_for_binaryclass()
+    elif params.downstream_dataset == 'ISRUC':
+        load_dataset = isruc_dataset.LoadDataset(params)
+        data_loader = load_dataset.get_data_loader()
+        model = model_for_isruc.Model(params)
+        t = Trainer(params, data_loader, model)
+        t.train_for_multiclass()
+    elif params.downstream_dataset == 'CHB-MIT':
+        load_dataset = chb_dataset.LoadDataset(params)
+        data_loader = load_dataset.get_data_loader()
+        model = model_for_chb.Model(params)
+        t = Trainer(params, data_loader, model)
+        t.train_for_binaryclass()
+    elif params.downstream_dataset == 'BCIC2020-3':
+        load_dataset = speech_dataset.LoadDataset(params)
+        data_loader = load_dataset.get_data_loader()
+        model = model_for_speech.Model(params)
+        t = Trainer(params, data_loader, model)
+        t.train_for_multiclass()
+    elif params.downstream_dataset == 'Mumtaz2016':
+        load_dataset = mumtaz_dataset.LoadDataset(params)
+        data_loader = load_dataset.get_data_loader()
+        model = model_for_mumtaz.Model(params)
+        t = Trainer(params, data_loader, model)
+        t.train_for_binaryclass()
+    elif params.downstream_dataset == 'SEED-VIG':
+        load_dataset = seedvig_dataset.LoadDataset(params)
+        data_loader = load_dataset.get_data_loader()
+        model = model_for_seedvig.Model(params)
+        t = Trainer(params, data_loader, model)
+        t.train_for_regression()
+    elif params.downstream_dataset == 'MentalArithmetic':
+        load_dataset = stress_dataset.LoadDataset(params)
+        data_loader = load_dataset.get_data_loader()
+        model = model_for_stress.Model(params)
+        t = Trainer(params, data_loader, model)
+        t.train_for_binaryclass()
+    elif params.downstream_dataset == 'TUEV':
+        load_dataset = tuev_dataset.LoadDataset(params)
+        data_loader = load_dataset.get_data_loader()
+        model = model_for_tuev.Model(params)
+        t = Trainer(params, data_loader, model)
+        t.train_for_multiclass()
+    elif params.downstream_dataset == 'TUAB':
+        load_dataset = tuab_dataset.LoadDataset(params)
+        data_loader = load_dataset.get_data_loader()
+        model = model_for_tuab.Model(params)
+        t = Trainer(params, data_loader, model)
+        t.train_for_binaryclass()
+    elif params.downstream_dataset == 'BCIC-IV-2a':
+        load_dataset = bciciv2a_dataset.LoadDataset(params)
+        data_loader = load_dataset.get_data_loader()
+        model = model_for_bciciv2a.Model(params)
+        t = Trainer(params, data_loader, model)
+        t.train_for_multiclass()
+    print('Done!!!!!')
+
+
+def setup_seed(seed):
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+    np.random.seed(seed)
+    random.seed(seed)
+    torch.backends.cudnn.deterministic = True
+
+
+if __name__ == '__main__':
+    main()

external/CBraMod/finetune_trainer.py

@@ -0,0 +1,285 @@
+import copy
+import os
+from timeit import default_timer as timer
+
+import numpy as np
+import torch
+from torch.nn import CrossEntropyLoss, BCEWithLogitsLoss, MSELoss
+from tqdm import tqdm
+
+from finetune_evaluator import Evaluator
+
+
+class Trainer(object):
+    def __init__(self, params, data_loader, model):
+        self.params = params
+        self.data_loader = data_loader
+
+        self.val_eval = Evaluator(params, self.data_loader['val'])
+        self.test_eval = Evaluator(params, self.data_loader['test'])
+
+        self.model = model.cuda()
+        if self.params.downstream_dataset in ['FACED', 'SEED-V', 'PhysioNet-MI', 'ISRUC', 'BCIC2020-3', 'TUEV', 'BCIC-IV-2a']:
+            self.criterion = CrossEntropyLoss(label_smoothing=self.params.label_smoothing).cuda()
+        elif self.params.downstream_dataset in ['SHU-MI', 'CHB-MIT', 'Mumtaz2016', 'MentalArithmetic', 'TUAB']:
+            self.criterion = BCEWithLogitsLoss().cuda()
+        elif self.params.downstream_dataset == 'SEED-VIG':
+            self.criterion = MSELoss().cuda()
+
+        self.best_model_states = None
+
+        backbone_params = []
+        other_params = []
+        for name, param in self.model.named_parameters():
+            if "backbone" in name:
+                backbone_params.append(param)
+
+                if params.frozen:
+                    param.requires_grad = False
+                else:
+                    param.requires_grad = True
+            else:
+                other_params.append(param)
+
+        if self.params.optimizer == 'AdamW':
+            if self.params.multi_lr: # set different learning rates for different modules
+                self.optimizer = torch.optim.AdamW([
+                    {'params': backbone_params, 'lr': self.params.lr},
+                    {'params': other_params, 'lr': 0.001*(self.params.batch_size/256)**0.5}
+                ], weight_decay=self.params.weight_decay)
+            else:
+                self.optimizer = torch.optim.AdamW(self.model.parameters(), lr=self.params.lr,
+                                                   weight_decay=self.params.weight_decay)
+        else:
+            if self.params.multi_lr:
+                self.optimizer = torch.optim.SGD([
+                    {'params': backbone_params, 'lr': self.params.lr},
+                    {'params': other_params, 'lr': self.params.lr * 5}
+                ],  momentum=0.9, weight_decay=self.params.weight_decay)
+            else:
+                self.optimizer = torch.optim.SGD(self.model.parameters(), lr=self.params.lr, momentum=0.9,
+                                                 weight_decay=self.params.weight_decay)
+
+        self.data_length = len(self.data_loader['train'])
+        self.optimizer_scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
+            self.optimizer, T_max=self.params.epochs * self.data_length, eta_min=1e-6
+        )
+        print(self.model)
+
+    def train_for_multiclass(self):
+        f1_best = 0
+        kappa_best = 0
+        acc_best = 0
+        cm_best = None
+        for epoch in range(self.params.epochs):
+            self.model.train()
+            start_time = timer()
+            losses = []
+            for x, y in tqdm(self.data_loader['train'], mininterval=10):
+                self.optimizer.zero_grad()
+                x = x.cuda()
+                y = y.cuda()
+                pred = self.model(x)
+                if self.params.downstream_dataset == 'ISRUC':
+                    loss = self.criterion(pred.transpose(1, 2), y)
+                else:
+                    loss = self.criterion(pred, y)
+
+                loss.backward()
+                losses.append(loss.data.cpu().numpy())
+                if self.params.clip_value > 0:
+                    torch.nn.utils.clip_grad_norm_(self.model.parameters(), self.params.clip_value)
+                    # torch.nn.utils.clip_grad_value_(self.model.parameters(), self.params.clip_value)
+                self.optimizer.step()
+                self.optimizer_scheduler.step()
+
+            optim_state = self.optimizer.state_dict()
+
+            with torch.no_grad():
+                acc, kappa, f1, cm = self.val_eval.get_metrics_for_multiclass(self.model)
+                print(
+                    "Epoch {} : Training Loss: {:.5f}, acc: {:.5f}, kappa: {:.5f}, f1: {:.5f}, LR: {:.5f}, Time elapsed {:.2f} mins".format(
+                        epoch + 1,
+                        np.mean(losses),
+                        acc,
+                        kappa,
+                        f1,
+                        optim_state['param_groups'][0]['lr'],
+                        (timer() - start_time) / 60
+                    )
+                )
+                print(cm)
+                if kappa > kappa_best:
+                    print("kappa increasing....saving weights !! ")
+                    print("Val Evaluation: acc: {:.5f}, kappa: {:.5f}, f1: {:.5f}".format(
+                        acc,
+                        kappa,
+                        f1,
+                    ))
+                    best_f1_epoch = epoch + 1
+                    acc_best = acc
+                    kappa_best = kappa
+                    f1_best = f1
+                    cm_best = cm
+                    self.best_model_states = copy.deepcopy(self.model.state_dict())
+        self.model.load_state_dict(self.best_model_states)
+        with torch.no_grad():
+            print("***************************Test************************")
+            acc, kappa, f1, cm = self.test_eval.get_metrics_for_multiclass(self.model)
+            print("***************************Test results************************")
+            print(
+                "Test Evaluation: acc: {:.5f}, kappa: {:.5f}, f1: {:.5f}".format(
+                    acc,
+                    kappa,
+                    f1,
+                )
+            )
+            print(cm)
+            if not os.path.isdir(self.params.model_dir):
+                os.makedirs(self.params.model_dir)
+            model_path = self.params.model_dir + "/epoch{}_acc_{:.5f}_kappa_{:.5f}_f1_{:.5f}.pth".format(best_f1_epoch, acc, kappa, f1)
+            torch.save(self.model.state_dict(), model_path)
+            print("model save in " + model_path)
+
+    def train_for_binaryclass(self):
+        acc_best = 0
+        roc_auc_best = 0
+        pr_auc_best = 0
+        cm_best = None
+        for epoch in range(self.params.epochs):
+            self.model.train()
+            start_time = timer()
+            losses = []
+            for x, y in tqdm(self.data_loader['train'], mininterval=10):
+                self.optimizer.zero_grad()
+                x = x.cuda()
+                y = y.cuda()
+                pred = self.model(x)
+
+                loss = self.criterion(pred, y)
+
+                loss.backward()
+                losses.append(loss.data.cpu().numpy())
+                if self.params.clip_value > 0:
+                    torch.nn.utils.clip_grad_norm_(self.model.parameters(), self.params.clip_value)
+                    # torch.nn.utils.clip_grad_value_(self.model.parameters(), self.params.clip_value)
+                self.optimizer.step()
+                self.optimizer_scheduler.step()
+
+            optim_state = self.optimizer.state_dict()
+
+            with torch.no_grad():
+                acc, pr_auc, roc_auc, cm = self.val_eval.get_metrics_for_binaryclass(self.model)
+                print(
+                    "Epoch {} : Training Loss: {:.5f}, acc: {:.5f}, pr_auc: {:.5f}, roc_auc: {:.5f}, LR: {:.5f}, Time elapsed {:.2f} mins".format(
+                        epoch + 1,
+                        np.mean(losses),
+                        acc,
+                        pr_auc,
+                        roc_auc,
+                        optim_state['param_groups'][0]['lr'],
+                        (timer() - start_time) / 60
+                    )
+                )
+                print(cm)
+                if roc_auc > roc_auc_best:
+                    print("roc_auc increasing....saving weights !! ")
+                    print("Val Evaluation: acc: {:.5f}, pr_auc: {:.5f}, roc_auc: {:.5f}".format(
+                        acc,
+                        pr_auc,
+                        roc_auc,
+                    ))
+                    best_f1_epoch = epoch + 1
+                    acc_best = acc
+                    pr_auc_best = pr_auc
+                    roc_auc_best = roc_auc
+                    cm_best = cm
+                    self.best_model_states = copy.deepcopy(self.model.state_dict())
+        self.model.load_state_dict(self.best_model_states)
+        with torch.no_grad():
+            print("***************************Test************************")
+            acc, pr_auc, roc_auc, cm = self.test_eval.get_metrics_for_binaryclass(self.model)
+            print("***************************Test results************************")
+            print(
+                "Test Evaluation: acc: {:.5f}, pr_auc: {:.5f}, roc_auc: {:.5f}".format(
+                    acc,
+                    pr_auc,
+                    roc_auc,
+                )
+            )
+            print(cm)
+            if not os.path.isdir(self.params.model_dir):
+                os.makedirs(self.params.model_dir)
+            model_path = self.params.model_dir + "/epoch{}_acc_{:.5f}_pr_{:.5f}_roc_{:.5f}.pth".format(best_f1_epoch, acc, pr_auc, roc_auc)
+            torch.save(self.model.state_dict(), model_path)
+            print("model save in " + model_path)
+
+    def train_for_regression(self):
+        corrcoef_best = 0
+        r2_best = 0
+        rmse_best = 0
+        for epoch in range(self.params.epochs):
+            self.model.train()
+            start_time = timer()
+            losses = []
+            for x, y in tqdm(self.data_loader['train'], mininterval=10):
+                self.optimizer.zero_grad()
+                x = x.cuda()
+                y = y.cuda()
+                pred = self.model(x)
+                loss = self.criterion(pred, y)
+
+                loss.backward()
+                losses.append(loss.data.cpu().numpy())
+                if self.params.clip_value > 0:
+                    torch.nn.utils.clip_grad_norm_(self.model.parameters(), self.params.clip_value)
+                    # torch.nn.utils.clip_grad_value_(self.model.parameters(), self.params.clip_value)
+                self.optimizer.step()
+                self.optimizer_scheduler.step()
+
+            optim_state = self.optimizer.state_dict()
+
+            with torch.no_grad():
+                corrcoef, r2, rmse = self.val_eval.get_metrics_for_regression(self.model)
+                print(
+                    "Epoch {} : Training Loss: {:.5f}, corrcoef: {:.5f}, r2: {:.5f}, rmse: {:.5f}, LR: {:.5f}, Time elapsed {:.2f} mins".format(
+                        epoch + 1,
+                        np.mean(losses),
+                        corrcoef,
+                        r2,
+                        rmse,
+                        optim_state['param_groups'][0]['lr'],
+                        (timer() - start_time) / 60
+                    )
+                )
+                if r2 > r2_best:
+                    print("r2 increasing....saving weights !! ")
+                    print("Val Evaluation: corrcoef: {:.5f}, r2: {:.5f}, rmse: {:.5f}".format(
+                        corrcoef,
+                        r2,
+                        rmse,
+                    ))
+                    best_r2_epoch = epoch + 1
+                    corrcoef_best = corrcoef
+                    r2_best = r2
+                    rmse_best = rmse
+                    self.best_model_states = copy.deepcopy(self.model.state_dict())
+
+        self.model.load_state_dict(self.best_model_states)
+        with torch.no_grad():
+            print("***************************Test************************")
+            corrcoef, r2, rmse = self.test_eval.get_metrics_for_regression(self.model)
+            print("***************************Test results************************")
+            print(
+                "Test Evaluation: corrcoef: {:.5f}, r2: {:.5f}, rmse: {:.5f}".format(
+                    corrcoef,
+                    r2,
+                    rmse,
+                )
+            )
+
+            if not os.path.isdir(self.params.model_dir):
+                os.makedirs(self.params.model_dir)
+            model_path = self.params.model_dir + "/epoch{}_corrcoef_{:.5f}_r2_{:.5f}_rmse_{:.5f}.pth".format(best_r2_epoch, corrcoef, r2, rmse)
+            torch.save(self.model.state_dict(), model_path)
+            print("model save in " + model_path)

external/CBraMod/models/cbramod.py

@@ -0,0 +1,119 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from models.criss_cross_transformer import TransformerEncoderLayer, TransformerEncoder
+
+
+class CBraMod(nn.Module):
+    def __init__(self, in_dim=200, out_dim=200, d_model=200, dim_feedforward=800, seq_len=30, n_layer=12,
+                    nhead=8):
+        super().__init__()
+        self.patch_embedding = PatchEmbedding(in_dim, out_dim, d_model, seq_len)
+        encoder_layer = TransformerEncoderLayer(
+            d_model=d_model, nhead=nhead, dim_feedforward=dim_feedforward, batch_first=True, norm_first=True,
+            activation=F.gelu
+        )
+        self.encoder = TransformerEncoder(encoder_layer, num_layers=n_layer, enable_nested_tensor=False)
+        self.proj_out = nn.Sequential(
+            # nn.Linear(d_model, d_model*2),
+            # nn.GELU(),
+            # nn.Linear(d_model*2, d_model),
+            # nn.GELU(),
+            nn.Linear(d_model, out_dim),
+        )
+        self.apply(_weights_init)
+
+    def forward(self, x, mask=None):
+        patch_emb = self.patch_embedding(x, mask)
+        feats = self.encoder(patch_emb)
+
+        out = self.proj_out(feats)
+
+        return out
+
+class PatchEmbedding(nn.Module):
+    def __init__(self, in_dim, out_dim, d_model, seq_len):
+        super().__init__()
+        self.d_model = d_model
+        self.positional_encoding = nn.Sequential(
+            nn.Conv2d(in_channels=d_model, out_channels=d_model, kernel_size=(19, 7), stride=(1, 1), padding=(9, 3),
+                      groups=d_model),
+        )
+        self.mask_encoding = nn.Parameter(torch.zeros(in_dim), requires_grad=False)
+        # self.mask_encoding = nn.Parameter(torch.randn(in_dim), requires_grad=True)
+
+        self.proj_in = nn.Sequential(
+            nn.Conv2d(in_channels=1, out_channels=25, kernel_size=(1, 49), stride=(1, 25), padding=(0, 24)),
+            nn.GroupNorm(5, 25),
+            nn.GELU(),
+
+            nn.Conv2d(in_channels=25, out_channels=25, kernel_size=(1, 3), stride=(1, 1), padding=(0, 1)),
+            nn.GroupNorm(5, 25),
+            nn.GELU(),
+
+            nn.Conv2d(in_channels=25, out_channels=25, kernel_size=(1, 3), stride=(1, 1), padding=(0, 1)),
+            nn.GroupNorm(5, 25),
+            nn.GELU(),
+        )
+        self.spectral_proj = nn.Sequential(
+            nn.Linear(101, d_model),
+            nn.Dropout(0.1),
+            # nn.LayerNorm(d_model, eps=1e-5),
+        )
+        # self.norm1 = nn.LayerNorm(d_model, eps=1e-5)
+        # self.norm2 = nn.LayerNorm(d_model, eps=1e-5)
+        # self.proj_in = nn.Sequential(
+        #     nn.Linear(in_dim, d_model, bias=False),
+        # )
+
+
+    def forward(self, x, mask=None):
+        bz, ch_num, patch_num, patch_size = x.shape
+        if mask == None:
+            mask_x = x
+        else:
+            mask_x = x.clone()
+            mask_x[mask == 1] = self.mask_encoding
+
+        mask_x = mask_x.contiguous().view(bz, 1, ch_num * patch_num, patch_size)
+        patch_emb = self.proj_in(mask_x)
+        patch_emb = patch_emb.permute(0, 2, 1, 3).contiguous().view(bz, ch_num, patch_num, self.d_model)
+
+        mask_x = mask_x.contiguous().view(bz*ch_num*patch_num, patch_size)
+        spectral = torch.fft.rfft(mask_x, dim=-1, norm='forward')
+        spectral = torch.abs(spectral).contiguous().view(bz, ch_num, patch_num, 101)
+        spectral_emb = self.spectral_proj(spectral)
+        # print(patch_emb[5, 5, 5, :])
+        # print(spectral_emb[5, 5, 5, :])
+        patch_emb = patch_emb + spectral_emb
+
+        positional_embedding = self.positional_encoding(patch_emb.permute(0, 3, 1, 2))
+        positional_embedding = positional_embedding.permute(0, 2, 3, 1)
+
+        patch_emb = patch_emb + positional_embedding
+
+        return patch_emb
+
+
+def _weights_init(m):
+    if isinstance(m, nn.Linear):
+        nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+    if isinstance(m, nn.Conv1d):
+        nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+    elif isinstance(m, nn.BatchNorm1d):
+        nn.init.constant_(m.weight, 1)
+        nn.init.constant_(m.bias, 0)
+
+
+
+if __name__ == '__main__':
+
+    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+    model = CBraMod(in_dim=200, out_dim=200, d_model=200, dim_feedforward=800, seq_len=30, n_layer=12,
+                    nhead=8).to(device)
+    model.load_state_dict(torch.load('pretrained_weights/pretrained_weights.pth',
+                                     map_location=device))
+    a = torch.randn((8, 16, 10, 200)).cuda()
+    b = model(a)
+    print(a.shape, b.shape)

external/CBraMod/models/criss_cross_transformer.py

@@ -0,0 +1,219 @@
+import copy
+from typing import Optional, Any, Union, Callable
+
+import torch
+import torch.nn as nn
+# import torch.nn.functional as F
+import warnings
+from torch import Tensor
+from torch.nn import functional as F
+
+
+class TransformerEncoder(nn.Module):
+    def __init__(self, encoder_layer, num_layers, norm=None, enable_nested_tensor=True, mask_check=True):
+        super().__init__()
+        torch._C._log_api_usage_once(f"torch.nn.modules.{self.__class__.__name__}")
+        self.layers = _get_clones(encoder_layer, num_layers)
+        self.num_layers = num_layers
+        self.norm = norm
+
+    def forward(
+            self,
+            src: Tensor,
+            mask: Optional[Tensor] = None,
+            src_key_padding_mask: Optional[Tensor] = None,
+            is_causal: Optional[bool] = None) -> Tensor:
+
+        output = src
+        for mod in self.layers:
+            output = mod(output, src_mask=mask)
+        if self.norm is not None:
+            output = self.norm(output)
+        return output
+
+
+class TransformerEncoderLayer(nn.Module):
+    __constants__ = ['norm_first']
+
+    def __init__(self, d_model: int, nhead: int, dim_feedforward: int = 2048, dropout: float = 0.1,
+                 activation: Union[str, Callable[[Tensor], Tensor]] = F.relu,
+                 layer_norm_eps: float = 1e-5, batch_first: bool = False, norm_first: bool = False,
+                 bias: bool = True, device=None, dtype=None) -> None:
+        factory_kwargs = {'device': device, 'dtype': dtype}
+        super().__init__()
+        self.self_attn_s = nn.MultiheadAttention(d_model//2, nhead // 2, dropout=dropout,
+                                                 bias=bias, batch_first=batch_first,
+                                                 **factory_kwargs)
+        self.self_attn_t = nn.MultiheadAttention(d_model//2, nhead // 2, dropout=dropout,
+                                                 bias=bias, batch_first=batch_first,
+                                                 **factory_kwargs)
+
+        # Implementation of Feedforward model
+        self.linear1 = nn.Linear(d_model, dim_feedforward, bias=bias, **factory_kwargs)
+        self.dropout = nn.Dropout(dropout)
+        self.linear2 = nn.Linear(dim_feedforward, d_model, bias=bias, **factory_kwargs)
+
+        self.norm_first = norm_first
+        self.norm1 = nn.LayerNorm(d_model, eps=layer_norm_eps, **factory_kwargs)
+        self.norm2 = nn.LayerNorm(d_model, eps=layer_norm_eps, **factory_kwargs)
+        self.dropout1 = nn.Dropout(dropout)
+        self.dropout2 = nn.Dropout(dropout)
+
+        # Legacy string support for activation function.
+        if isinstance(activation, str):
+            activation = _get_activation_fn(activation)
+
+        # We can't test self.activation in forward() in TorchScript,
+        # so stash some information about it instead.
+        if activation is F.relu or isinstance(activation, torch.nn.ReLU):
+            self.activation_relu_or_gelu = 1
+        elif activation is F.gelu or isinstance(activation, torch.nn.GELU):
+            self.activation_relu_or_gelu = 2
+        else:
+            self.activation_relu_or_gelu = 0
+        self.activation = activation
+
+    def __setstate__(self, state):
+        super().__setstate__(state)
+        if not hasattr(self, 'activation'):
+            self.activation = F.relu
+
+
+    def forward(
+            self,
+            src: Tensor,
+            src_mask: Optional[Tensor] = None,
+            src_key_padding_mask: Optional[Tensor] = None,
+            is_causal: bool = False) -> Tensor:
+
+        x = src
+        x = x + self._sa_block(self.norm1(x), src_mask, src_key_padding_mask, is_causal=is_causal)
+        x = x + self._ff_block(self.norm2(x))
+        return x
+
+    # self-attention block
+    def _sa_block(self, x: Tensor,
+                  attn_mask: Optional[Tensor], key_padding_mask: Optional[Tensor], is_causal: bool = False) -> Tensor:
+        bz, ch_num, patch_num, patch_size = x.shape
+        xs = x[:, :, :, :patch_size // 2]
+        xt = x[:, :, :, patch_size // 2:]
+        xs = xs.transpose(1, 2).contiguous().view(bz*patch_num, ch_num, patch_size // 2)
+        xt = xt.contiguous().view(bz*ch_num, patch_num, patch_size // 2)
+        xs = self.self_attn_s(xs, xs, xs,
+                             attn_mask=attn_mask,
+                             key_padding_mask=key_padding_mask,
+                             need_weights=False)[0]
+        xs = xs.contiguous().view(bz, patch_num, ch_num, patch_size//2).transpose(1, 2)
+        xt = self.self_attn_t(xt, xt, xt,
+                              attn_mask=attn_mask,
+                              key_padding_mask=key_padding_mask,
+                              need_weights=False)[0]
+        xt = xt.contiguous().view(bz, ch_num, patch_num, patch_size//2)
+        x = torch.concat((xs, xt), dim=3)
+        return self.dropout1(x)
+
+    # feed forward block
+    def _ff_block(self, x: Tensor) -> Tensor:
+        x = self.linear2(self.dropout(self.activation(self.linear1(x))))
+        return self.dropout2(x)
+
+
+
+def _get_activation_fn(activation: str) -> Callable[[Tensor], Tensor]:
+    if activation == "relu":
+        return F.relu
+    elif activation == "gelu":
+        return F.gelu
+
+    raise RuntimeError(f"activation should be relu/gelu, not {activation}")
+
+def _get_clones(module, N):
+    # FIXME: copy.deepcopy() is not defined on nn.module
+    return nn.ModuleList([copy.deepcopy(module) for i in range(N)])
+
+
+def _get_seq_len(
+        src: Tensor,
+        batch_first: bool
+) -> Optional[int]:
+
+    if src.is_nested:
+        return None
+    else:
+        src_size = src.size()
+        if len(src_size) == 2:
+            # unbatched: S, E
+            return src_size[0]
+        else:
+            # batched: B, S, E if batch_first else S, B, E
+            seq_len_pos = 1 if batch_first else 0
+            return src_size[seq_len_pos]
+
+
+def _detect_is_causal_mask(
+        mask: Optional[Tensor],
+        is_causal: Optional[bool] = None,
+        size: Optional[int] = None,
+) -> bool:
+    """Return whether the given attention mask is causal.
+
+    Warning:
+    If ``is_causal`` is not ``None``, its value will be returned as is.  If a
+    user supplies an incorrect ``is_causal`` hint,
+
+    ``is_causal=False`` when the mask is in fact a causal attention.mask
+       may lead to reduced performance relative to what would be achievable
+       with ``is_causal=True``;
+    ``is_causal=True`` when the mask is in fact not a causal attention.mask
+       may lead to incorrect and unpredictable execution - in some scenarios,
+       a causal mask may be applied based on the hint, in other execution
+       scenarios the specified mask may be used.  The choice may not appear
+       to be deterministic, in that a number of factors like alignment,
+       hardware SKU, etc influence the decision whether to use a mask or
+       rely on the hint.
+    ``size`` if not None, check whether the mask is a causal mask of the provided size
+       Otherwise, checks for any causal mask.
+    """
+    # Prevent type refinement
+    make_causal = (is_causal is True)
+
+    if is_causal is None and mask is not None:
+        sz = size if size is not None else mask.size(-2)
+        causal_comparison = _generate_square_subsequent_mask(
+            sz, device=mask.device, dtype=mask.dtype)
+
+        # Do not use `torch.equal` so we handle batched masks by
+        # broadcasting the comparison.
+        if mask.size() == causal_comparison.size():
+            make_causal = bool((mask == causal_comparison).all())
+        else:
+            make_causal = False
+
+    return make_causal
+
+
+def _generate_square_subsequent_mask(
+        sz: int,
+        device: torch.device = torch.device(torch._C._get_default_device()),  # torch.device('cpu'),
+        dtype: torch.dtype = torch.get_default_dtype(),
+) -> Tensor:
+    r"""Generate a square causal mask for the sequence. The masked positions are filled with float('-inf').
+        Unmasked positions are filled with float(0.0).
+    """
+    return torch.triu(
+        torch.full((sz, sz), float('-inf'), dtype=dtype, device=device),
+        diagonal=1,
+    )
+
+
+if __name__ == '__main__':
+    encoder_layer = TransformerEncoderLayer(
+        d_model=256, nhead=4, dim_feedforward=1024, batch_first=True, norm_first=True,
+        activation=F.gelu
+    )
+    encoder = TransformerEncoder(encoder_layer, num_layers=2, enable_nested_tensor=False)
+    encoder = encoder.cuda()
+
+    a = torch.randn((4, 19, 30, 256)).cuda()
+    b = encoder(a)
+    print(a.shape, b.shape)

external/CBraMod/models/model_for_bciciv2a.py

@@ -0,0 +1,56 @@
+import torch
+import torch.nn as nn
+from einops.layers.torch import Rearrange
+from .cbramod import CBraMod
+
+
+class Model(nn.Module):
+    def __init__(self, param):
+        super(Model, self).__init__()
+        self.backbone = CBraMod(
+            in_dim=200, out_dim=200, d_model=200,
+            dim_feedforward=800, seq_len=30,
+            n_layer=12, nhead=8
+        )
+        if param.use_pretrained_weights:
+            map_location = torch.device(f'cuda:{param.cuda}')
+            self.backbone.load_state_dict(torch.load(param.foundation_dir, map_location=map_location))
+        self.backbone.proj_out = nn.Identity()
+        if param.classifier == 'avgpooling_patch_reps':
+            self.classifier = nn.Sequential(
+                Rearrange('b c s d -> b d c s'),
+                nn.AdaptiveAvgPool2d((1, 1)),
+                nn.Flatten(),
+                nn.Linear(200, param.num_of_classes),
+            )
+        elif param.classifier == 'all_patch_reps_onelayer':
+            self.classifier = nn.Sequential(
+                Rearrange('b c s d -> b (c s d)'),
+                nn.Linear(22 * 4 * 200, param.num_of_classes),
+            )
+        elif param.classifier == 'all_patch_reps_twolayer':
+            self.classifier = nn.Sequential(
+                Rearrange('b c s d -> b (c s d)'),
+                nn.Linear(22 * 4 * 200, 200),
+                nn.ELU(),
+                nn.Dropout(param.dropout),
+                nn.Linear(200, param.num_of_classes),
+            )
+        elif param.classifier == 'all_patch_reps':
+            self.classifier = nn.Sequential(
+                Rearrange('b c s d -> b (c s d)'),
+                nn.Linear(22 * 4 * 200, 4 * 200),
+                nn.ELU(),
+                nn.Dropout(param.dropout),
+                nn.Linear(4 * 200, 200),
+                nn.ELU(),
+                nn.Dropout(param.dropout),
+                nn.Linear(200, param.num_of_classes),
+            )
+
+    def forward(self, x):
+        # x = x / 100
+        bz, ch_num, seq_len, patch_size = x.shape
+        feats = self.backbone(x)
+        out = self.classifier(feats)
+        return out

external/CBraMod/models/model_for_chb.py

@@ -0,0 +1,60 @@
+import torch
+import torch.nn as nn
+from einops.layers.torch import Rearrange
+from .cbramod import CBraMod
+
+
+class Model(nn.Module):
+    def __init__(self, param):
+        super(Model, self).__init__()
+        self.backbone = CBraMod(
+            in_dim=200, out_dim=200, d_model=200,
+            dim_feedforward=800, seq_len=30,
+            n_layer=12, nhead=8
+        )
+        if param.use_pretrained_weights:
+            map_location = torch.device(f'cuda:{param.cuda}')
+            self.backbone.load_state_dict(torch.load(param.foundation_dir, map_location=map_location))
+        self.backbone.proj_out = nn.Identity()
+
+        if param.classifier == 'avgpooling_patch_reps':
+            self.classifier = nn.Sequential(
+                Rearrange('b c s d -> b d c s'),
+                nn.AdaptiveAvgPool2d((1, 1)),
+                nn.Flatten(),
+                nn.Linear(200, 1),
+                Rearrange('b 1 -> (b 1)'),
+            )
+        elif param.classifier == 'all_patch_reps_onelayer':
+            self.classifier = nn.Sequential(
+                Rearrange('b c s d -> b (c s d)'),
+                nn.Linear(16*10*200, 1),
+                Rearrange('b 1 -> (b 1)'),
+            )
+        elif param.classifier == 'all_patch_reps_twolayer':
+            self.classifier = nn.Sequential(
+                Rearrange('b c s d -> b (c s d)'),
+                nn.Linear(16*10*200, 200),
+                nn.ELU(),
+                nn.Dropout(param.dropout),
+                nn.Linear(200, 1),
+                Rearrange('b 1 -> (b 1)'),
+            )
+        elif param.classifier == 'all_patch_reps':
+            self.classifier = nn.Sequential(
+                Rearrange('b c s d -> b (c s d)'),
+                nn.Linear(16*10*200, 10*200),
+                nn.ELU(),
+                nn.Dropout(param.dropout),
+                nn.Linear(10*200, 200),
+                nn.ELU(),
+                nn.Dropout(param.dropout),
+                nn.Linear(200, 1),
+                Rearrange('b 1 -> (b 1)'),
+            )
+
+    def forward(self, x):
+        bz, ch_num, seq_len, patch_size = x.shape
+        feats = self.backbone(x)
+        out = self.classifier(feats)
+        return out

external/CBraMod/models/model_for_faced.py

@@ -0,0 +1,61 @@
+import torch
+import torch.nn as nn
+from einops.layers.torch import Rearrange
+
+from .cbramod import CBraMod
+
+
+class Model(nn.Module):
+    def __init__(self, param):
+        super(Model, self).__init__()
+        self.backbone = CBraMod(
+            in_dim=200, out_dim=200, d_model=200,
+            dim_feedforward=800, seq_len=30,
+            n_layer=12, nhead=8
+        )
+
+        if param.use_pretrained_weights:
+            map_location = torch.device(f'cuda:{param.cuda}')
+            self.backbone.load_state_dict(torch.load(param.foundation_dir, map_location=map_location))
+        self.backbone.proj_out = nn.Identity()
+
+        if param.classifier == 'avgpooling_patch_reps':
+            self.classifier = nn.Sequential(
+                Rearrange('b c s d -> b d c s'),
+                nn.AdaptiveAvgPool2d((1, 1)),
+                nn.Flatten(),
+                nn.Linear(200, param.num_of_classes),
+            )
+        elif param.classifier == 'all_patch_reps_onelayer':
+            self.classifier = nn.Sequential(
+                Rearrange('b c s d -> b (c s d)'),
+                nn.Linear(32 * 10 * 200, param.num_of_classes),
+            )
+        elif param.classifier == 'all_patch_reps_twolayer':
+            self.classifier = nn.Sequential(
+                Rearrange('b c s d -> b (c s d)'),
+                nn.Linear(32 * 10 * 200, 200),
+                nn.ELU(),
+                nn.Dropout(param.dropout),
+                nn.Linear(200, param.num_of_classes),
+            )
+        elif param.classifier == 'all_patch_reps':
+            self.classifier = nn.Sequential(
+                Rearrange('b c s d -> b (c s d)'),
+                nn.Linear(32 * 10 * 200, 10 * 200),
+                nn.ELU(),
+                nn.Dropout(param.dropout),
+                nn.Linear(10 * 200, 200),
+                nn.ELU(),
+                nn.Dropout(param.dropout),
+                nn.Linear(200, param.num_of_classes),
+            )
+
+    def forward(self, x):
+        bz, ch_num, seq_len, patch_size = x.shape
+        feats = self.backbone(x)
+        out = self.classifier(feats)
+        return out
+
+
+

external/CBraMod/models/model_for_isruc.py

@@ -0,0 +1,43 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from .cbramod import CBraMod
+
+
+class Model(nn.Module):
+    def __init__(self, param):
+        super().__init__()
+        self.backbone = CBraMod(
+            in_dim=200, out_dim=200, d_model=200,
+            dim_feedforward=800, seq_len=30,
+            n_layer=12, nhead=8
+        )
+        if param.use_pretrained_weights:
+            map_location = torch.device(f'cuda:{param.cuda}')
+            self.backbone.load_state_dict(torch.load(param.foundation_dir, map_location=map_location))
+        self.backbone.proj_out = nn.Identity()
+
+        self.head = nn.Sequential(
+            nn.Linear(6*30*200, 512),
+            nn.GELU(),
+        )
+
+        encoder_layer = nn.TransformerEncoderLayer(
+            d_model=512, nhead=4, dim_feedforward=2048, batch_first=True, activation=F.gelu, norm_first=True
+        )
+        self.sequence_encoder = nn.TransformerEncoder(encoder_layer, num_layers=1, enable_nested_tensor=False)
+        self.classifier = nn.Linear(512, param.num_of_classes)
+
+        # self.apply(_weights_init)
+
+    def forward(self, x):
+        bz, seq_len, ch_num, epoch_size = x.shape
+
+        x = x.contiguous().view(bz * seq_len, ch_num, 30, 200)
+        epoch_features = self.backbone(x)
+        epoch_features = epoch_features.contiguous().view(bz, seq_len, ch_num*30*200)
+        epoch_features = self.head(epoch_features)
+        seq_features = self.sequence_encoder(epoch_features)
+        out = self.classifier(seq_features)
+        return out

external/CBraMod/models/model_for_mumtaz.py

@@ -0,0 +1,60 @@
+import torch
+import torch.nn as nn
+from einops.layers.torch import Rearrange
+
+from .cbramod import CBraMod
+
+
+class Model(nn.Module):
+    def __init__(self, param):
+        super(Model, self).__init__()
+        self.backbone = CBraMod(
+            in_dim=200, out_dim=200, d_model=200,
+            dim_feedforward=800, seq_len=30,
+            n_layer=12, nhead=8
+        )
+        if param.use_pretrained_weights:
+            map_location = torch.device(f'cuda:{param.cuda}')
+            self.backbone.load_state_dict(torch.load(param.foundation_dir, map_location=map_location))
+        self.backbone.proj_out = nn.Identity()
+        if param.classifier == 'avgpooling_patch_reps':
+            self.classifier = nn.Sequential(
+                Rearrange('b c s d -> b d c s'),
+                nn.AdaptiveAvgPool2d((1, 1)),
+                nn.Flatten(),
+                nn.Linear(200, 1),
+                Rearrange('b 1 -> (b 1)'),
+            )
+        elif param.classifier == 'all_patch_reps_onelayer':
+            self.classifier = nn.Sequential(
+                Rearrange('b c s d -> b (c s d)'),
+                nn.Linear(19 * 5 * 200, 1),
+                Rearrange('b 1 -> (b 1)'),
+            )
+        elif param.classifier == 'all_patch_reps_twolayer':
+            self.classifier = nn.Sequential(
+                Rearrange('b c s d -> b (c s d)'),
+                nn.Linear(19 * 5 * 200, 200),
+                nn.ELU(),
+                nn.Dropout(param.dropout),
+                nn.Linear(200, 1),
+                Rearrange('b 1 -> (b 1)'),
+            )
+        elif param.classifier == 'all_patch_reps':
+            self.classifier = nn.Sequential(
+                Rearrange('b c s d -> b (c s d)'),
+                nn.Linear(19 * 5 * 200, 5 * 200),
+                nn.ELU(),
+                nn.Dropout(param.dropout),
+                nn.Linear(5 * 200, 200),
+                nn.ELU(),
+                nn.Dropout(param.dropout),
+                nn.Linear(200, 1),
+                Rearrange('b 1 -> (b 1)'),
+            )
+
+    def forward(self, x):
+        bz, ch_num, seq_len, patch_size = x.shape
+        feats = self.backbone(x)
+        out = self.classifier(feats)
+        return out

external/CBraMod/models/model_for_physio.py

@@ -0,0 +1,57 @@
+import torch
+import torch.nn as nn
+from einops.layers.torch import Rearrange
+
+from .cbramod import CBraMod
+
+
+class Model(nn.Module):
+    def __init__(self, param):
+        super(Model, self).__init__()
+        self.backbone = CBraMod(
+            in_dim=200, out_dim=200, d_model=200,
+            dim_feedforward=800, seq_len=30,
+            n_layer=12, nhead=8
+        )
+        if param.use_pretrained_weights:
+            map_location = torch.device(f'cuda:{param.cuda}')
+            self.backbone.load_state_dict(torch.load(param.foundation_dir, map_location=map_location))
+        self.backbone.proj_out = nn.Identity()
+        if param.classifier == 'avgpooling_patch_reps':
+            self.classifier = nn.Sequential(
+                Rearrange('b c s d -> b d c s'),
+                nn.AdaptiveAvgPool2d((1, 1)),
+                nn.Flatten(),
+                nn.Linear(200, param.num_of_classes),
+            )
+        elif param.classifier == 'all_patch_reps_onelayer':
+            self.classifier = nn.Sequential(
+                Rearrange('b c s d -> b (c s d)'),
+                nn.Linear(64 * 4 * 200, param.num_of_classes),
+            )
+        elif param.classifier == 'all_patch_reps_twolayer':
+            self.classifier = nn.Sequential(
+                Rearrange('b c s d -> b (c s d)'),
+                nn.Linear(64 * 4 * 200, 200),
+                nn.ELU(),
+                nn.Dropout(param.dropout),
+                nn.Linear(200, param.num_of_classes),
+            )
+        elif param.classifier == 'all_patch_reps':
+            self.classifier = nn.Sequential(
+                Rearrange('b c s d -> b (c s d)'),
+                nn.Linear(64 * 4 * 200, 4 * 200),
+                nn.ELU(),
+                nn.Dropout(param.dropout),
+                nn.Linear(4 * 200, 200),
+                nn.ELU(),
+                nn.Dropout(param.dropout),
+                nn.Linear(200, param.num_of_classes),
+            )
+
+
+    def forward(self, x):
+        bz, ch_num, seq_len, patch_size = x.shape
+        feats = self.backbone(x)
+        out = self.classifier(feats)
+        return out

external/CBraMod/models/model_for_seedv.py

@@ -0,0 +1,58 @@
+import torch
+import torch.nn as nn
+from einops.layers.torch import Rearrange
+
+from .cbramod import CBraMod
+
+
+class Model(nn.Module):
+    def __init__(self, param):
+        super(Model, self).__init__()
+        self.backbone = CBraMod(
+            in_dim=200, out_dim=200, d_model=200,
+            dim_feedforward=800, seq_len=30,
+            n_layer=12, nhead=8
+        )
+        if param.use_pretrained_weights:
+            map_location = torch.device(f'cuda:{param.cuda}')
+            self.backbone.load_state_dict(torch.load(param.foundation_dir, map_location=map_location))
+        self.backbone.proj_out = nn.Identity()
+        if param.classifier == 'avgpooling_patch_reps':
+            self.classifier = nn.Sequential(
+                Rearrange('b c s d -> b d c s'),
+                nn.AdaptiveAvgPool2d((1, 1)),
+                nn.Flatten(),
+                nn.Linear(200, param.num_of_classes),
+            )
+        elif param.classifier == 'all_patch_reps_onelayer':
+            self.classifier = nn.Sequential(
+                Rearrange('b c s d -> b (c s d)'),
+                nn.Linear(62 * 1 * 200, param.num_of_classes),
+            )
+        elif param.classifier == 'all_patch_reps_twolayer':
+            self.classifier = nn.Sequential(
+                Rearrange('b c s d -> b (c s d)'),
+                nn.Linear(62 * 1 * 200, 200),
+                nn.ELU(),
+                nn.Dropout(param.dropout),
+                nn.Linear(200, param.num_of_classes),
+            )
+        elif param.classifier == 'all_patch_reps':
+            self.classifier = nn.Sequential(
+                Rearrange('b c s d -> b (c s d)'),
+                nn.Linear(62 * 1 * 200, 4 * 200),
+                nn.ELU(),
+                nn.Dropout(param.dropout),
+                nn.Linear(4 * 200, 200),
+                nn.ELU(),
+                nn.Dropout(param.dropout),
+                nn.Linear(200, param.num_of_classes),
+            )
+
+    def forward(self, x):
+        # x = x / 100
+        bz, ch_num, seq_len, patch_size = x.shape
+        feats = self.backbone(x)
+        feats = feats.contiguous().view(bz, ch_num*seq_len*200)
+        out = self.classifier(feats)
+        return out

external/CBraMod/models/model_for_seedvig.py

@@ -0,0 +1,61 @@
+import torch
+import torch.nn as nn
+from einops.layers.torch import Rearrange
+
+from .cbramod import CBraMod
+
+
+class Model(nn.Module):
+    def __init__(self, param):
+        super(Model, self).__init__()
+        self.backbone = CBraMod(
+            in_dim=200, out_dim=200, d_model=200,
+            dim_feedforward=800, seq_len=30,
+            n_layer=12, nhead=8
+        )
+        if param.use_pretrained_weights:
+            map_location = torch.device(f'cuda:{param.cuda}')
+            self.backbone.load_state_dict(torch.load(param.foundation_dir, map_location=map_location))
+        self.backbone.proj_out = nn.Identity()
+        if param.classifier == 'avgpooling_patch_reps':
+            self.classifier = nn.Sequential(
+                Rearrange('b c s d -> b d c s'),
+                nn.AdaptiveAvgPool2d((1, 1)),
+                nn.Flatten(),
+                nn.Linear(200, 1),
+                Rearrange('b 1 -> (b 1)'),
+            )
+        elif param.classifier == 'all_patch_reps_onelayer':
+            self.classifier = nn.Sequential(
+                Rearrange('b c s d -> b (c s d)'),
+                nn.Linear(17 * 8 * 200, 1),
+                Rearrange('b 1 -> (b 1)'),
+            )
+        elif param.classifier == 'all_patch_reps_twolayer':
+            self.classifier = nn.Sequential(
+                Rearrange('b c s d -> b (c s d)'),
+                nn.Linear(17 * 8 * 200, 200),
+                nn.ELU(),
+                nn.Dropout(param.dropout),
+                nn.Linear(200, 1),
+                Rearrange('b 1 -> (b 1)'),
+            )
+        elif param.classifier == 'all_patch_reps':
+            self.classifier = nn.Sequential(
+                Rearrange('b c s d -> b (c s d)'),
+                nn.Linear(17 * 8 * 200, 8 * 200),
+                nn.ELU(),
+                nn.Dropout(param.dropout),
+                nn.Linear(8 * 200, 200),
+                nn.ELU(),
+                nn.Dropout(param.dropout),
+                nn.Linear(200, 1),
+                Rearrange('b 1 -> (b 1)'),
+            )
+
+    def forward(self, x):
+        bz, ch_num, seq_len, patch_size = x.shape
+        feats = self.backbone(x)
+        out = self.classifier(feats)
+        return out
+

external/CBraMod/models/model_for_shu.py

@@ -0,0 +1,61 @@
+import torch
+import torch.nn as nn
+from einops.layers.torch import Rearrange
+
+from .cbramod import CBraMod
+
+
+class Model(nn.Module):
+    def __init__(self, param):
+        super(Model, self).__init__()
+        self.backbone = CBraMod(
+            in_dim=200, out_dim=200, d_model=200,
+            dim_feedforward=800, seq_len=30,
+            n_layer=12, nhead=8
+        )
+        if param.use_pretrained_weights:
+            map_location = torch.device(f'cuda:{param.cuda}')
+            self.backbone.load_state_dict(torch.load(param.foundation_dir, map_location=map_location))
+        self.backbone.proj_out = nn.Identity()
+        if param.classifier == 'avgpooling_patch_reps':
+            self.classifier = nn.Sequential(
+                Rearrange('b c s d -> b d c s'),
+                nn.AdaptiveAvgPool2d((1, 1)),
+                nn.Flatten(),
+                nn.Linear(200, 1),
+                Rearrange('b 1 -> (b 1)'),
+            )
+        elif param.classifier == 'all_patch_reps_onelayer':
+            self.classifier = nn.Sequential(
+                Rearrange('b c s d -> b (c s d)'),
+                nn.Linear(32 * 4 * 200, 1),
+                Rearrange('b 1 -> (b 1)'),
+            )
+        elif param.classifier == 'all_patch_reps_twolayer':
+            self.classifier = nn.Sequential(
+                Rearrange('b c s d -> b (c s d)'),
+                nn.Linear(32 * 4 * 200, 200),
+                nn.ELU(),
+                nn.Dropout(param.dropout),
+                nn.Linear(200, 1),
+                Rearrange('b 1 -> (b 1)'),
+            )
+        elif param.classifier == 'all_patch_reps':
+            self.classifier = nn.Sequential(
+                Rearrange('b c s d -> b (c s d)'),
+                nn.Linear(32 * 4 * 200, 4 * 200),
+                nn.ELU(),
+                nn.Dropout(param.dropout),
+                nn.Linear(4 * 200, 200),
+                nn.ELU(),
+                nn.Dropout(param.dropout),
+                nn.Linear(200, 1),
+                Rearrange('b 1 -> (b 1)'),
+            )
+    def forward(self, x):
+        bz, ch_num, seq_len, patch_size = x.shape
+        feats = self.backbone(x)
+        out = self.classifier(feats)
+        return out
+
+

external/CBraMod/models/model_for_speech.py

@@ -0,0 +1,57 @@
+import torch
+import torch.nn as nn
+from einops.layers.torch import Rearrange
+
+from .cbramod import CBraMod
+
+
+class Model(nn.Module):
+    def __init__(self, param):
+        super(Model, self).__init__()
+        self.backbone = CBraMod(
+            in_dim=200, out_dim=200, d_model=200,
+            dim_feedforward=800, seq_len=30,
+            n_layer=12, nhead=8
+        )
+        if param.use_pretrained_weights:
+            map_location = torch.device(f'cuda:{param.cuda}')
+            self.backbone.load_state_dict(torch.load(param.foundation_dir, map_location=map_location))
+        self.backbone.proj_out = nn.Identity()
+        if param.classifier == 'avgpooling_patch_reps':
+            self.classifier = nn.Sequential(
+                Rearrange('b c s d -> b d c s'),
+                nn.AdaptiveAvgPool2d((1, 1)),
+                nn.Flatten(),
+                nn.Linear(200, param.num_of_classes)
+            )
+        elif param.classifier == 'all_patch_reps_onelayer':
+            self.classifier = nn.Sequential(
+                Rearrange('b c s d -> b (c s d)'),
+                nn.Linear(64*3*200, param.num_of_classes),
+            )
+        elif param.classifier == 'all_patch_reps_twolayer':
+            self.classifier = nn.Sequential(
+                Rearrange('b c s d -> b (c s d)'),
+                nn.Linear(64*3*200, 200),
+                nn.ELU(),
+                nn.Dropout(param.dropout),
+                nn.Linear(200, param.num_of_classes),
+            )
+        elif param.classifier == 'all_patch_reps':
+            self.classifier = nn.Sequential(
+                Rearrange('b c s d -> b (c s d)'),
+                nn.Linear(64*3*200, 3*200),
+                nn.ELU(),
+                nn.Dropout(param.dropout),
+                nn.Linear(3*200, 200),
+                nn.ELU(),
+                nn.Dropout(param.dropout),
+                nn.Linear(200, param.num_of_classes),
+            )
+
+    def forward(self, x):
+        bz, ch_num, seq_len, patch_size = x.shape
+        feats = self.backbone(x)
+        out = self.classifier(feats)
+        return out
+

external/CBraMod/models/model_for_stress.py

@@ -0,0 +1,60 @@
+import torch
+import torch.nn as nn
+from einops.layers.torch import Rearrange
+
+from .cbramod import CBraMod
+
+class Model(nn.Module):
+    def __init__(self, param):
+        super(Model, self).__init__()
+        self.backbone = CBraMod(
+            in_dim=200, out_dim=200, d_model=200,
+            dim_feedforward=800, seq_len=30,
+            n_layer=12, nhead=8
+        )
+        if param.use_pretrained_weights:
+            map_location = torch.device(f'cuda:{param.cuda}')
+            self.backbone.load_state_dict(torch.load(param.foundation_dir, map_location=map_location))
+        self.backbone.proj_out = nn.Identity()
+        if param.classifier == 'avgpooling_patch_reps':
+            self.classifier = nn.Sequential(
+                Rearrange('b c s d -> b d c s'),
+                nn.AdaptiveAvgPool2d((1, 1)),
+                nn.Flatten(),
+                nn.Linear(200, 1),
+                Rearrange('b 1 -> (b 1)'),
+            )
+        elif param.classifier == 'all_patch_reps_onelayer':
+            self.classifier = nn.Sequential(
+                Rearrange('b c s d -> b (c s d)'),
+                nn.Linear(20 * 5 * 200, 1),
+                Rearrange('b 1 -> (b 1)'),
+            )
+        elif param.classifier == 'all_patch_reps_twolayer':
+            self.classifier = nn.Sequential(
+                Rearrange('b c s d -> b (c s d)'),
+                nn.Linear(20 * 5 * 200, 200),
+                nn.ELU(),
+                nn.Dropout(param.dropout),
+                nn.Linear(200, 1),
+                Rearrange('b 1 -> (b 1)'),
+            )
+        elif param.classifier == 'all_patch_reps':
+            self.classifier = nn.Sequential(
+                Rearrange('b c s d -> b (c s d)'),
+                nn.Linear(20 * 5 * 200, 5 * 200),
+                nn.ELU(),
+                nn.Dropout(param.dropout),
+                nn.Linear(5 * 200, 200),
+                nn.ELU(),
+                nn.Dropout(param.dropout),
+                nn.Linear(200, 1),
+                Rearrange('b 1 -> (b 1)'),
+            )
+
+    def forward(self, x):
+        bz, ch_num, seq_len, patch_size = x.shape
+        feats = self.backbone(x)
+        out = self.classifier(feats)
+        return out
+

external/CBraMod/models/model_for_tuab.py

@@ -0,0 +1,60 @@
+import torch
+import torch.nn as nn
+from einops.layers.torch import Rearrange
+
+from .cbramod import CBraMod
+
+
+class Model(nn.Module):
+    def __init__(self, param):
+        super(Model, self).__init__()
+        self.backbone = CBraMod(
+            in_dim=200, out_dim=200, d_model=200,
+            dim_feedforward=800, seq_len=30,
+            n_layer=12, nhead=8
+        )
+        if param.use_pretrained_weights:
+            map_location = torch.device(f'cuda:{param.cuda}')
+            self.backbone.load_state_dict(torch.load(param.foundation_dir, map_location=map_location))
+        self.backbone.proj_out = nn.Identity()
+        if param.classifier == 'avgpooling_patch_reps':
+            self.classifier = nn.Sequential(
+                Rearrange('b c s d -> b d c s'),
+                nn.AdaptiveAvgPool2d((1, 1)),
+                nn.Flatten(),
+                nn.Linear(200, 1),
+                Rearrange('b 1 -> (b 1)'),
+            )
+        elif param.classifier == 'all_patch_reps_onelayer':
+            self.classifier = nn.Sequential(
+                Rearrange('b c s d -> b (c s d)'),
+                nn.Linear(16 * 10 * 200, 1),
+                Rearrange('b 1 -> (b 1)'),
+            )
+        elif param.classifier == 'all_patch_reps_twolayer':
+            self.classifier = nn.Sequential(
+                Rearrange('b c s d -> b (c s d)'),
+                nn.Linear(16 * 10 * 200, 200),
+                nn.ELU(),
+                nn.Dropout(param.dropout),
+                nn.Linear(200, 1),
+                Rearrange('b 1 -> (b 1)'),
+            )
+        elif param.classifier == 'all_patch_reps':
+            self.classifier = nn.Sequential(
+                Rearrange('b c s d -> b (c s d)'),
+                nn.Linear(16 * 10 * 200, 10 * 200),
+                nn.ELU(),
+                nn.Dropout(param.dropout),
+                nn.Linear(10 * 200, 200),
+                nn.ELU(),
+                nn.Dropout(param.dropout),
+                nn.Linear(200, 1),
+                Rearrange('b 1 -> (b 1)'),
+            )
+
+    def forward(self, x):
+        bz, ch_num, seq_len, patch_size = x.shape
+        feats = self.backbone(x)
+        out = self.classifier(feats)
+        return out

external/CBraMod/models/model_for_tuev.py

@@ -0,0 +1,58 @@
+import torch
+import torch.nn as nn
+from einops.layers.torch import Rearrange
+
+from .cbramod import CBraMod
+
+
+class Model(nn.Module):
+    def __init__(self, param):
+        super(Model, self).__init__()
+        self.backbone = CBraMod(
+            in_dim=200, out_dim=200, d_model=200,
+            dim_feedforward=800, seq_len=30,
+            n_layer=12, nhead=8
+        )
+        if param.use_pretrained_weights:
+            map_location = torch.device(f'cuda:{param.cuda}')
+            self.backbone.load_state_dict(torch.load(param.foundation_dir, map_location=map_location))
+        self.backbone.proj_out = nn.Identity()
+
+        if param.classifier == 'avgpooling_patch_reps':
+            self.classifier = nn.Sequential(
+                Rearrange('b c s d -> b d c s'),
+                nn.AdaptiveAvgPool2d((1, 1)),
+                nn.Flatten(),
+                nn.Linear(200, param.num_of_classes),
+            )
+        elif param.classifier == 'all_patch_reps_onelayer':
+            self.classifier = nn.Sequential(
+                Rearrange('b c s d -> b (c s d)'),
+                nn.Linear(16 * 5 * 200, param.num_of_classes),
+            )
+        elif param.classifier == 'all_patch_reps_twolayer':
+            self.classifier = nn.Sequential(
+                Rearrange('b c s d -> b (c s d)'),
+                nn.Linear(16 * 5 * 200, 200),
+                nn.ELU(),
+                nn.Dropout(param.dropout),
+                nn.Linear(200, param.num_of_classes),
+            )
+        elif param.classifier == 'all_patch_reps':
+            self.classifier = nn.Sequential(
+                Rearrange('b c s d -> b (c s d)'),
+                nn.Linear(16 * 5 * 200, 5 * 200),
+                nn.ELU(),
+                nn.Dropout(param.dropout),
+                nn.Linear(5 * 200, 200),
+                nn.ELU(),
+                nn.Dropout(param.dropout),
+                nn.Linear(200, param.num_of_classes),
+            )
+
+    def forward(self, x):
+        bz, ch_num, seq_len, patch_size = x.shape
+        feats = self.backbone(x)
+        out = self.classifier(feats)
+        return out
+

external/CBraMod/preprocessing/README.md

@@ -0,0 +1,42 @@
+# Dataset Preprocessing README
+
+
+## 🔥 June 2, 2025 Update for TUAB and TUEV
+
+The previous preprocessing code for the **TUAB** and **TUEV** datasets was inherited from the [BIOT](https://github.com/ycq091044/BIOT) and [LaBraM](https://github.com/935963004/LaBraM) repositories. These original implementations included **random elements** in the data splitting process. Even with fixed random seeds, different hardware environments could lead to **inconsistent Train/Val/Test splits**. This issue has been carried forward into **CBraMod**.
+
+In the performance comparison presented in the **CBraMod paper**, I directly cited the results reported in the **BIOT** and **LaBraM** papers without having access to their exact dataset splits. Therefore, I cannot guarantee that the comparisons were made using the **same dataset partitions**. As a result, the evaluation may **not be entirely fair**.
+
+Moreover, others may also be unable to reproduce a **fair comparison** with **CBraMod** on **TUAB** and **TUEV** under the same conditions.
+
+To fully address this issue, I have updated the preprocessing code for **TUAB** and **TUEV** to ensure **fixed, deterministic dataset splits**. If you are conducting experiments on these two datasets, please use the **latest version of the preprocessing code** to generate the splits.
+
+For accurate and fair comparisons, it is **strongly recommended** to re-implement existing methods such as **BIOT**, **LaBraM**, and **CBraMod** **on the same fixed splits**.
+
+> ⚠️ **Please note**: The **TUAB version** used in our experiments is **3.0.1**, and the **TUEV version** is **2.0.0**. Updates to the datasets may result in changes to the total number of samples.  
+>  
+> 📌 If you are using **different versions** of these datasets, **do not refer to our sample counts**. Instead, **reproduce the results directly on your own data splits**.
+>
+> ✅ We also provide **dataset splits** for **TUEV v2.0.1**. Please refer to the sample counts below for details. 
+
+### 📊 Current Sample Counts (Updated Preprocessing)
+
+#### **TUAB (v3.0.1):**
+- **Train:** 297,103  
+- **Validation:** 75,407  
+- **Test:** 36,945  
+- **Total:** 409,455
+
+
+#### **TUEV (v2.0.0):**
+- **Train:** 67,436  
+- **Validation:** 15,634  
+- **Test:** 29,421  
+- **Total:** 112,491  
+
+
+#### **TUEV (v2.0.1):**
+- **Train:** 68,445  
+- **Validation:** 15,487  
+- **Test:** 29,421  
+- **Total:** 113,353  

external/CBraMod/pretrain_main.py

@@ -0,0 +1,69 @@
+import argparse
+import random
+import numpy as np
+import torch
+from torch.utils.data import DataLoader
+
+from datasets.pretraining_dataset import PretrainingDataset
+from models.cbramod import CBraMod
+from pretrain_trainer import Trainer
+
+
+def setup_seed(seed):
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+    np.random.seed(seed)
+    random.seed(seed)
+    torch.backends.cudnn.deterministic = True
+
+
+def main():
+    parser = argparse.ArgumentParser(description='EEG Foundation Model')
+    parser.add_argument('--seed', type=int, default=42, help='random seed (default: 0)')
+    parser.add_argument('--cuda', type=int, default=3, help='cuda number (default: 1)')
+    parser.add_argument('--parallel', type=bool, default=False, help='parallel')
+    parser.add_argument('--epochs', type=int, default=40, help='number of epochs (default: 5)')
+    parser.add_argument('--batch_size', type=int, default=128, help='batch size for training (default: 32)')
+    parser.add_argument('--lr', type=float, default=5e-4, help='learning rate (default: 1e-3)')
+    parser.add_argument('--weight_decay', type=float, default=5e-2, help='weight_decay')
+    parser.add_argument('--clip_value', type=float, default=1, help='clip_value')
+    parser.add_argument('--lr_scheduler', type=str, default='CosineAnnealingLR',
+                        help='lr_scheduler: CosineAnnealingLR, ExponentialLR, StepLR, MultiStepLR, CyclicLR')
+
+    # parser.add_argument('--project_mode', type=str, default='cnn', help='project_mode')
+    parser.add_argument('--dropout', type=float, default=0.1, help='dropout')
+    parser.add_argument('--in_dim', type=int, default=200, help='in_dim')
+    parser.add_argument('--out_dim', type=int, default=200, help='out_dim')
+    parser.add_argument('--d_model', type=int, default=200, help='d_model')
+    parser.add_argument('--dim_feedforward', type=int, default=800, help='dim_feedforward')
+    parser.add_argument('--seq_len', type=int, default=30, help='seq_len')
+    parser.add_argument('--n_layer', type=int, default=12, help='n_layer')
+    parser.add_argument('--nhead', type=int, default=8, help='nhead')
+    parser.add_argument('--need_mask', type=bool, default=True, help='need_mask')
+    parser.add_argument('--mask_ratio', type=float, default=0.5, help='mask_ratio')
+
+    parser.add_argument('--dataset_dir', type=str, default='dataset_dir',
+                        help='dataset_dir')
+    parser.add_argument('--model_dir',   type=str,   default='model_dir', help='model_dir')
+    params = parser.parse_args()
+    print(params)
+    setup_seed(params.seed)
+    pretrained_dataset = PretrainingDataset(dataset_dir=params.dataset_dir)
+    print(len(pretrained_dataset))
+    data_loader = DataLoader(
+        pretrained_dataset,
+        batch_size=params.batch_size,
+        num_workers=8,
+        shuffle=True,
+    )
+    model = CBraMod(
+        params.in_dim, params.out_dim, params.d_model, params.dim_feedforward, params.seq_len, params.n_layer,
+        params.nhead
+    )
+    trainer = Trainer(params, data_loader, model)
+    trainer.train()
+    pretrained_dataset.db.close()
+
+
+if __name__ == '__main__':
+    main()

external/CBraMod/pretrain_trainer.py

@@ -0,0 +1,95 @@
+import numpy as np
+import torch
+from ptflops import get_model_complexity_info
+from torch.nn import MSELoss
+from torchinfo import summary
+from tqdm import tqdm
+
+from utils.util import generate_mask
+
+
+class Trainer(object):
+    def __init__(self, params, data_loader, model):
+        self.params = params
+        self.device = torch.device(f"cuda:{self.params.cuda}" if torch.cuda.is_available() else "cpu")
+        self.data_loader = data_loader
+        self.model = model.to(self.device)
+        self.criterion = MSELoss(reduction='mean').to(self.device)
+
+        if self.params.parallel:
+            device_ids = [0, 1, 2, 3, 4, 5, 6, 7]
+            self.model = torch.nn.DataParallel(self.model, device_ids=device_ids)
+
+        self.data_length = len(self.data_loader)
+
+        summary(self.model, input_size=(1, 19, 30, 200))
+
+        macs, params = get_model_complexity_info(self.model, (19, 30, 200), as_strings=True,
+                                                 print_per_layer_stat=True, verbose=True)
+        print('{:<30}  {:<8}'.format('Computational complexity: ', macs))
+        print('{:<30}  {:<8}'.format('Number of parameters: ', params))
+
+        self.optimizer = torch.optim.AdamW(self.model.parameters(), lr=self.params.lr,
+                                           weight_decay=self.params.weight_decay)
+
+        if self.params.lr_scheduler=='CosineAnnealingLR':
+            self.optimizer_scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
+                self.optimizer, T_max=40*self.data_length, eta_min=1e-5
+            )
+        elif self.params.lr_scheduler=='ExponentialLR':
+            self.optimizer_scheduler = torch.optim.lr_scheduler.ExponentialLR(
+                self.optimizer, gamma=0.999999999
+            )
+        elif self.params.lr_scheduler=='StepLR':
+            self.optimizer_scheduler = torch.optim.lr_scheduler.StepLR(
+                self.optimizer, step_size=5*self.data_length, gamma=0.5
+            )
+        elif self.params.lr_scheduler=='MultiStepLR':
+            self.optimizer_scheduler = torch.optim.lr_scheduler.MultiStepLR(
+                self.optimizer, milestones=[10*self.data_length, 20*self.data_length, 30*self.data_length], gamma=0.1
+            )
+        elif self.params.lr_scheduler=='CyclicLR':
+            self.optimizer_scheduler = torch.optim.lr_scheduler.CyclicLR(
+                self.optimizer, base_lr=1e-6, max_lr=0.001, step_size_up=self.data_length*5,
+                step_size_down=self.data_length*2, mode='exp_range', gamma=0.9, cycle_momentum=False
+            )
+
+
+    def train(self):
+        best_loss = 10000
+        for epoch in range(self.params.epochs):
+            losses = []
+            for x in tqdm(self.data_loader, mininterval=10):
+                self.optimizer.zero_grad()
+                x = x.to(self.device)/100
+                if self.params.need_mask:
+                    bz, ch_num, patch_num, patch_size = x.shape
+                    mask = generate_mask(
+                        bz, ch_num, patch_num, mask_ratio=self.params.mask_ratio, device=self.device,
+                    )
+                    y = self.model(x, mask=mask)
+                    masked_x = x[mask == 1]
+                    masked_y = y[mask == 1]
+                    loss = self.criterion(masked_y, masked_x)
+
+                    # non_masked_x = x[mask == 0]
+                    # non_masked_y = y[mask == 0]
+                    # non_masked_loss = self.criterion(non_masked_y, non_masked_x)
+                    # loss = 0.8 * masked_loss + 0.2 * non_masked_loss
+                else:
+                    y = self.model(x)
+                    loss = self.criterion(y, x)
+                loss.backward()
+                if self.params.clip_value > 0:
+                    torch.nn.utils.clip_grad_norm_(self.model.parameters(), self.params.clip_value)
+                self.optimizer.step()
+                self.optimizer_scheduler.step()
+                losses.append(loss.data.cpu().numpy())
+            mean_loss = np.mean(losses)
+            learning_rate = self.optimizer.state_dict()['param_groups'][0]['lr']
+            print(f'Epoch {epoch+1}: Training Loss: {mean_loss:.6f}, Learning Rate: {learning_rate:.6f}')
+            if  mean_loss < best_loss:
+                model_path = rf'{self.params.model_dir}/epoch{epoch+1}_loss{mean_loss}.pth'
+                torch.save(self.model.state_dict(), model_path)
+                print("model save in " + model_path)
+                best_loss = mean_loss

external/CBraMod/quick_example.py

@@ -0,0 +1,27 @@
+import torch
+import torch.nn as nn
+from models.cbramod import CBraMod
+from einops.layers.torch import Rearrange
+
+device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+model = CBraMod().to(device)
+model.load_state_dict(torch.load('pretrained_weights/pretrained_weights.pth', map_location=device))
+model.proj_out = nn.Identity()
+classifier = nn.Sequential(
+  Rearrange('b c s p -> b (c s p)'),
+  nn.Linear(22*4*200, 4*200),
+  nn.ELU(),
+  nn.Dropout(0.1),
+  nn.Linear(4 * 200, 200),
+  nn.ELU(),
+  nn.Dropout(0.1),
+  nn.Linear(200, 4),
+).to(device)
+
+# mock_eeg.shape = (batch_size, num_of_channels, time_segments, points_per_patch)
+mock_eeg = torch.randn((8, 22, 4, 200)).to(device)
+
+# logits.shape = (batch_size, num_of_classes)
+logits = classifier(model(mock_eeg))
+
+print(logits.shape)

external/CBraMod/requirements.txt

@@ -0,0 +1,14 @@
+einops
+h5py
+lmdb
+matplotlib
+mne
+numpy
+pandas
+ptflops
+pyEDFlib
+scikit_learn
+scipy
+torchinfo
+tqdm
+umap_learn

external/T3A/CODE_OF_CONDUCT.md

@@ -0,0 +1,5 @@
+# Code of Conduct
+
+Facebook has adopted a Code of Conduct that we expect project participants to adhere to.
+Please read the [full text](https://code.fb.com/codeofconduct/)
+so that you can understand what actions will and will not be tolerated.

external/T3A/CONTRIBUTING.md

@@ -0,0 +1,32 @@
+# Contributing to `DomainBed`
+We want to make contributing to this project as easy and transparent as
+possible.
+
+## Pull Requests
+We actively welcome your pull requests.
+
+1. Fork the repo and create your branch from `master`.
+2. If you've added code that should be tested, add tests.
+3. If you've changed APIs, update the documentation.
+4. Ensure the test suite passes.
+5. Make sure your code lints.
+6. If you haven't already, complete the Contributor License Agreement ("CLA").
+
+## Contributor License Agreement ("CLA")
+In order to accept your pull request, we need you to submit a CLA. You only need
+to do this once to work on any of Facebook's open source projects.
+
+Complete your CLA here: <https://code.facebook.com/cla>
+
+## Issues
+We use GitHub issues to track public bugs. Please ensure your description is
+clear and has sufficient instructions to be able to reproduce the issue.
+
+Facebook has a [bounty program](https://www.facebook.com/whitehat/) for the safe
+disclosure of security bugs. In those cases, please go through the process
+outlined on that page and do not file a public issue.
+
+## License
+By contributing to `DomainBed`, you agree that your contributions
+will be licensed under the LICENSE file in the root directory of this source
+tree.

external/T3A/LICENSE

@@ -0,0 +1,9 @@
+The MIT License
+
+Copyright (c) Facebook, Inc. and its affiliates.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

external/T3A/Pipfile

@@ -0,0 +1,29 @@
+[[source]]
+url = "https://pypi.org/simple"
+verify_ssl = true
+name = "pypi"
+
+[packages]
+torch = "*"
+torchvision = "*"
+torchaudio = "*"
+tqdm = "*"
+einops = "*"
+python-dotenv = "*"
+rarfile = "*"
+scipy = "*"
+jupyterlab = "*"
+wilds = "*"
+gdown = "*"
+wget = "*"
+timm = "*"
+
+[dev-packages]
+pipenv = "*"
+flake8 = "*"
+autopep8 = "*"
+wandb = "*"
+jupyter = "*"
+
+[requires]
+python_version = "3.7"

external/T3A/README.md

@@ -0,0 +1,116 @@
+# Test-Time Classifier Adjustment Module for Model-Agnostic Domain Generalization
+
+This codebase is the official implementation of `Test-Time Classifier Adjustment Module for Model-Agnostic Domain Generalization` (NeurIPS2021, Spotlight, [url](<https://openreview.net/forum?id=e_yvNqkJKAW&referrer=%5BAuthor%20Console%5D(%2Fgroup%3Fid%3DNeurIPS.cc%2F2021%2FConference%2FAuthors%23your-submissions)>). 
+This codebase is mainly based on [DomainBed](https://github.com/facebookresearch/DomainBed), with following modifications:
+
+* enable to use various backbone networks including Big Transfer (BiT), Vision Transformers (ViT, DeiT, HViT), and MLP-Mixer. 
+* enable to test test-time adaptation method (T3A and [Tent](https://github.com/DequanWang/tent)). 
+
+## Installation
+
+#### CUDA/Python
+```
+git clone git@github.com:matsuolab/Domainbed_contrib.git
+cd Domainbed_contrib/docker
+docker build -t {image_name} .
+docker run -it -h `hostname` --runtime=nvidia -v /path/to/Domainbed_contrib /path/to/anyware --shm-size=40gb --name {container_name} {image_name}
+```
+
+#### Python libralies
+We use `pipenv` for package management. 
+```
+cd /path/to/Domainbed_contrib
+pip install pipenv
+pipenv install
+pipenv shell
+pip install torch-scatter -f https://pytorch-geometric.com/whl/torch-1.8.0+cu102.html
+```
+
+## Quick start
+#### (1) Downlload the datasets
+
+```sh
+python -m domainbed.scripts.download --data_dir=/my/datasets/path --dataset pacs
+```
+Note: change `--dataset pacs` for downloading other datasets (e.g., `vlcs`, `office_home`, `terra_incognita`). 
+
+
+#### (2) Train a model on source domains
+```sh
+python -m domainbed.scripts.train\
+       --data_dir /my/datasets/path\
+       --output_dir /my/pretrain/path\
+       --algorithm ERM\
+       --dataset PACS\
+       --hparams "{\"backbone\": \"resnet50\"}" 
+```
+This scripts will produce new directory `/my/pretrain/path`, which include the full training log. 
+
+Note: change `--dataset PACS` for training on other datasets (e.g., `VLCS`, `OfficeHome`, `TerraIncognita`). 
+
+Note: change `--hparams "{\"backbone\": \"resnet50\"}"` for using other backbones (e.g., `resnet18`, `ViT-B16`, `HViT`). 
+
+
+#### (3) Evaluate model with test time adaptation (Table 1, Table 2, Figure 2)
+```sh
+python -m domainbed.scripts.unsupervised_adaptation\
+       --input_dir=/my/pretrain/path\
+       --adapt_algorithm=T3A
+```
+This scripts will produce a new file in `/my/pretrain/path`, whose name is `results_{adapt_algorithm}.jsonl`. 
+
+Note: change `--adapt_algorithm=T3A` for using other test time adaptation methods (`T3A`, `Tent`, or `TentClf`). 
+
+
+
+#### (4) Evaluate model with fine-tuning classifier(Figure 1)
+```sh
+python -m domainbed.scripts.supervised_adaptation\
+       --input_dir=/my/pretrain/path\
+       --ft_mode=clf
+```
+This scripts will produce a new file in `/my/pretrain/path`, whose name is `results_{ft_mode}.jsonl`. 
+
+
+## Available backbones
+
+* resnet18
+* resnet50
+* BiT-M-R50x3
+* BiT-M-R101x3
+* BiT-M-R152x2
+* ViT-B16
+* ViT-L16
+* DeiT
+* Hybrid ViT (HViT)
+* MLP-Mixer (Mixer-L16)
+
+## Reproducing results
+#### Table 1 and Figure 2 (Tuned ERM and CORAL)
+
+You can use `scripts/hparam_search.sh`. Specifically, for each dataset and base algorithm, you can just type a following command.
+```
+sh scripts/hparam_search.sh resnet50 PACS ERM
+```
+Note that, it automatically starts 240 jobs, and take many times to finish. 
+
+
+#### Table 2 and Figure 1 (ERM with various backbone)
+
+You can use `scripts/launch.sh`. Specifically, for each backbone, you can just type following three commands. 
+```
+sh scripts/launch.sh pretrain resnet50 10 3 local
+sh scripts/launch.sh sup resnet50 10 3 local
+sh scripts/launch.sh unsup resnet50 10 3 local
+```
+
+
+#### Other results
+For table 1, we used scores reported by [In Search of Lost Domain Generalization](https://arxiv.org/abs/2007.01434). 
+Full results for the reported scores in LaTeX format available [here](domainbed/results/2020_10_06_7df6f06/results.tex).
+Note: We only used scores for VLCS, PACS, OfficeHome, and TerraIncognita. We used the resutls with `IIDAccuracySelectionMethod`. 
+
+
+## License
+
+This source code is released under the MIT license, included [here](LICENSE).

repo/outputs/budgeted_risk/risk_decisions/stage0_random_eval_batch/eegmmidb/fold_4/seed_0/b10_eegmmidb_029.json

@@ -0,0 +1,326 @@
+{
+  "batch_hash": "b984cc53016c7232032ac8f4026c8e2c02eb993fa85bd504266ce7b458c68b43",
+  "decisions": [
+    {
+      "alpha": 0.1,
+      "budget": 10,
+      "certified_index": 20,
+      "dataset": "eegmmidb",
+      "decision_hash": "6e5164374b0a8883c238cb677413de0e10b2b053372e3bf56c4818e9c11a06e8",
+      "delta": 0.1,
+      "episode_hash": "cc728c588c3fe108a7529effa80262ed1ed989041eb9917f7c3f894626019053",
+      "query_hash": "2071d3c4bff25b84331c4ee43af9045d384f5b238619c70b50da100225d7b182",
+      "repeat": 0,
+      "role": "evaluation",
+      "seed": 0,
+      "source_model_hash": "e3ff1372a811e8eb9532e4030c3d343fd0e496860900ac7742718fe94fe0446d",
+      "strategy": "random",
+      "subject_id": "eegmmidb:029"
+    },
+    {
+      "alpha": 0.1,
+      "budget": 10,
+      "certified_index": 18,
+      "dataset": "eegmmidb",
+      "decision_hash": "b3af3756ac33832e8efdf06e496458d9e9337440d8d1d9300068e4c4e5d7f857",
+      "delta": 0.1,
+      "episode_hash": "cc728c588c3fe108a7529effa80262ed1ed989041eb9917f7c3f894626019053",
+      "query_hash": "c4388b996ee81a7fc54156bfe3a113a0ddbb41a22fcbffba31e20dc9e69ecf9d",
+      "repeat": 1,
+      "role": "evaluation",
+      "seed": 0,
+      "source_model_hash": "e3ff1372a811e8eb9532e4030c3d343fd0e496860900ac7742718fe94fe0446d",
+      "strategy": "random",
+      "subject_id": "eegmmidb:029"
+    },
+    {
+      "alpha": 0.1,
+      "budget": 10,
+      "certified_index": 17,
+      "dataset": "eegmmidb",
+      "decision_hash": "87a63c6f35e0aad0466d53ed6789158caaa0db666d73a6fe195c0699e554f354",
+      "delta": 0.1,
+      "episode_hash": "cc728c588c3fe108a7529effa80262ed1ed989041eb9917f7c3f894626019053",
+      "query_hash": "b84266c2c265ca593a1c4fb3295f6e2acfe0f31cd3fa1dcc40a2105a9e6b3424",
+      "repeat": 2,
+      "role": "evaluation",
+      "seed": 0,
+      "source_model_hash": "e3ff1372a811e8eb9532e4030c3d343fd0e496860900ac7742718fe94fe0446d",
+      "strategy": "random",
+      "subject_id": "eegmmidb:029"
+    },
+    {
+      "alpha": 0.1,
+      "budget": 10,
+      "certified_index": 15,
+      "dataset": "eegmmidb",
+      "decision_hash": "c91d48da8a1ea672edf4b4a1605919dcccd06f0d66e6da6cf67a33560a35b362",
+      "delta": 0.1,
+      "episode_hash": "cc728c588c3fe108a7529effa80262ed1ed989041eb9917f7c3f894626019053",
+      "query_hash": "3734a29e5d2d56dcfc7c94d63d5959bf527308af895047df8e729b909943d59b",
+      "repeat": 3,
+      "role": "evaluation",
+      "seed": 0,
+      "source_model_hash": "e3ff1372a811e8eb9532e4030c3d343fd0e496860900ac7742718fe94fe0446d",
+      "strategy": "random",
+      "subject_id": "eegmmidb:029"
+    },
+    {
+      "alpha": 0.1,
+      "budget": 10,
+      "certified_index": 20,
+      "dataset": "eegmmidb",
+      "decision_hash": "17f8b78b5823de89921244ffc9acf31d222b5c9cd6b0a1b8eff49e04636ab644",
+      "delta": 0.1,
+      "episode_hash": "cc728c588c3fe108a7529effa80262ed1ed989041eb9917f7c3f894626019053",
+      "query_hash": "12312319c188d6a5002d31cb1783760c70ff6349ded1b7fa07ff51fddba14927",
+      "repeat": 4,
+      "role": "evaluation",
+      "seed": 0,
+      "source_model_hash": "e3ff1372a811e8eb9532e4030c3d343fd0e496860900ac7742718fe94fe0446d",
+      "strategy": "random",
+      "subject_id": "eegmmidb:029"
+    },
+    {
+      "alpha": 0.1,
+      "budget": 10,
+      "certified_index": 20,
+      "dataset": "eegmmidb",
+      "decision_hash": "1706b5cf86d4b924f98403b7139974ec40b7fa85648082c16f48cf91e206e908",
+      "delta": 0.1,
+      "episode_hash": "cc728c588c3fe108a7529effa80262ed1ed989041eb9917f7c3f894626019053",
+      "query_hash": "efe4098d881f8c51fa9b5d3a7a10ad8028e8cd611ab41f16846c51ffa979985e",
+      "repeat": 5,
+      "role": "evaluation",
+      "seed": 0,
+      "source_model_hash": "e3ff1372a811e8eb9532e4030c3d343fd0e496860900ac7742718fe94fe0446d",
+      "strategy": "random",
+      "subject_id": "eegmmidb:029"
+    },
+    {
+      "alpha": 0.1,
+      "budget": 10,
+      "certified_index": 19,
+      "dataset": "eegmmidb",
+      "decision_hash": "63fc4da4d7ac1a17b2008bd2f33a2a948add5d11d572b912a59f215e2e8ec81b",
+      "delta": 0.1,
+      "episode_hash": "cc728c588c3fe108a7529effa80262ed1ed989041eb9917f7c3f894626019053",
+      "query_hash": "e3a9f3e904ac592828fac34bc7ae2e9dd349e03d980df45ee014c3778e625144",
+      "repeat": 6,
+      "role": "evaluation",
+      "seed": 0,
+      "source_model_hash": "e3ff1372a811e8eb9532e4030c3d343fd0e496860900ac7742718fe94fe0446d",
+      "strategy": "random",
+      "subject_id": "eegmmidb:029"
+    },
+    {
+      "alpha": 0.1,
+      "budget": 10,
+      "certified_index": 15,
+      "dataset": "eegmmidb",
+      "decision_hash": "37c73754029f242d8cd446a9674c426da704d892b5d721dc613f170fbc832fcf",
+      "delta": 0.1,
+      "episode_hash": "cc728c588c3fe108a7529effa80262ed1ed989041eb9917f7c3f894626019053",
+      "query_hash": "e824932cc8698ffb0f55cc0a5385b6fe5b31d0922f840b7e56811833d091c6ee",
+      "repeat": 7,
+      "role": "evaluation",
+      "seed": 0,
+      "source_model_hash": "e3ff1372a811e8eb9532e4030c3d343fd0e496860900ac7742718fe94fe0446d",
+      "strategy": "random",
+      "subject_id": "eegmmidb:029"
+    },
+    {
+      "alpha": 0.1,
+      "budget": 10,
+      "certified_index": 17,
+      "dataset": "eegmmidb",
+      "decision_hash": "96a4ee94c9773e31357f665201bfc1bc3b1d64ddb81cb7582cf4fa0fcbcf1335",
+      "delta": 0.1,
+      "episode_hash": "cc728c588c3fe108a7529effa80262ed1ed989041eb9917f7c3f894626019053",
+      "query_hash": "b926b40d79cd477c730efca2db4595dc67ad8ce97d7ccf2907fb1e14a262d28a",
+      "repeat": 8,
+      "role": "evaluation",
+      "seed": 0,
+      "source_model_hash": "e3ff1372a811e8eb9532e4030c3d343fd0e496860900ac7742718fe94fe0446d",
+      "strategy": "random",
+      "subject_id": "eegmmidb:029"
+    },
+    {
+      "alpha": 0.1,
+      "budget": 10,
+      "certified_index": 20,
+      "dataset": "eegmmidb",
+      "decision_hash": "53a6d2ef080d9f4d279ea1c9597292c347ea87832bb2528dfb82b10224ac30c2",
+      "delta": 0.1,
+      "episode_hash": "cc728c588c3fe108a7529effa80262ed1ed989041eb9917f7c3f894626019053",
+      "query_hash": "9394f9363bbcf4b312171ac4f2871c8ef64cda1b53a5cfa687f457efe3565ecc",
+      "repeat": 9,
+      "role": "evaluation",
+      "seed": 0,
+      "source_model_hash": "e3ff1372a811e8eb9532e4030c3d343fd0e496860900ac7742718fe94fe0446d",
+      "strategy": "random",
+      "subject_id": "eegmmidb:029"
+    },
+    {
+      "alpha": 0.1,
+      "budget": 10,
+      "certified_index": 18,
+      "dataset": "eegmmidb",
+      "decision_hash": "fe5db362a72223d7fac9534e827faf93a1dd6b393965826f328e92ca15b9448e",
+      "delta": 0.1,
+      "episode_hash": "cc728c588c3fe108a7529effa80262ed1ed989041eb9917f7c3f894626019053",
+      "query_hash": "395bc405d43442ccef51969069b9a6340209650e4f4ee5765bab51a9fac664a0",
+      "repeat": 10,
+      "role": "evaluation",
+      "seed": 0,
+      "source_model_hash": "e3ff1372a811e8eb9532e4030c3d343fd0e496860900ac7742718fe94fe0446d",
+      "strategy": "random",
+      "subject_id": "eegmmidb:029"
+    },
+    {
+      "alpha": 0.1,
+      "budget": 10,
+      "certified_index": 15,
+      "dataset": "eegmmidb",
+      "decision_hash": "0c14b99cf8bde029e3326c34ff865c0030a49ecc8c364a2bf3548ef2c392562d",
+      "delta": 0.1,
+      "episode_hash": "cc728c588c3fe108a7529effa80262ed1ed989041eb9917f7c3f894626019053",
+      "query_hash": "3497f71549578546958f0fb68a9ab4b249bbe5003101a4c89fd02e1bf056d3a9",
+      "repeat": 11,
+      "role": "evaluation",
+      "seed": 0,
+      "source_model_hash": "e3ff1372a811e8eb9532e4030c3d343fd0e496860900ac7742718fe94fe0446d",
+      "strategy": "random",
+      "subject_id": "eegmmidb:029"
+    },
+    {
+      "alpha": 0.1,
+      "budget": 10,
+      "certified_index": 18,
+      "dataset": "eegmmidb",
+      "decision_hash": "b5001867eb717109111e7d24726d9a354bac9aafca5820bbe8da4b5e28666558",
+      "delta": 0.1,
+      "episode_hash": "cc728c588c3fe108a7529effa80262ed1ed989041eb9917f7c3f894626019053",
+      "query_hash": "bdfb5aed68f89462c32bb81e17dc3c2f6e156390e130111badc8550b6b8ec4c7",
+      "repeat": 12,
+      "role": "evaluation",
+      "seed": 0,
+      "source_model_hash": "e3ff1372a811e8eb9532e4030c3d343fd0e496860900ac7742718fe94fe0446d",
+      "strategy": "random",
+      "subject_id": "eegmmidb:029"
+    },
+    {
+      "alpha": 0.1,
+      "budget": 10,
+      "certified_index": 20,
+      "dataset": "eegmmidb",
+      "decision_hash": "e5e716d0f1b95422b90aef497d1a739d428251851167fc060cb430372a350607",
+      "delta": 0.1,
+      "episode_hash": "cc728c588c3fe108a7529effa80262ed1ed989041eb9917f7c3f894626019053",
+      "query_hash": "656c344c22ee3b7879b743b3fc1337c8c3372b5877a1b555207651212d0322b2",
+      "repeat": 13,
+      "role": "evaluation",
+      "seed": 0,
+      "source_model_hash": "e3ff1372a811e8eb9532e4030c3d343fd0e496860900ac7742718fe94fe0446d",
+      "strategy": "random",
+      "subject_id": "eegmmidb:029"
+    },
+    {
+      "alpha": 0.1,
+      "budget": 10,
+      "certified_index": 15,
+      "dataset": "eegmmidb",
+      "decision_hash": "8c0d8ab97ef2044b8c8091e0b384085af7a6927ba8717d40ef1dde675aa30bf0",
+      "delta": 0.1,
+      "episode_hash": "cc728c588c3fe108a7529effa80262ed1ed989041eb9917f7c3f894626019053",
+      "query_hash": "90143bbb710dd398989f4a10c3fd036422ed1898d8107ec3dd9e89043e144d72",
+      "repeat": 14,
+      "role": "evaluation",
+      "seed": 0,
+      "source_model_hash": "e3ff1372a811e8eb9532e4030c3d343fd0e496860900ac7742718fe94fe0446d",
+      "strategy": "random",
+      "subject_id": "eegmmidb:029"
+    },
+    {
+      "alpha": 0.1,
+      "budget": 10,
+      "certified_index": 15,
+      "dataset": "eegmmidb",
+      "decision_hash": "c338821bf97455b200f1228bcebc67ce8c1e4babf0913f537bec0f2987263eb5",
+      "delta": 0.1,
+      "episode_hash": "cc728c588c3fe108a7529effa80262ed1ed989041eb9917f7c3f894626019053",
+      "query_hash": "fea5c7a4a20071b5114c42d334f677b308a00bbdf34e7095dd6995435b3f3bda",
+      "repeat": 15,
+      "role": "evaluation",
+      "seed": 0,
+      "source_model_hash": "e3ff1372a811e8eb9532e4030c3d343fd0e496860900ac7742718fe94fe0446d",
+      "strategy": "random",
+      "subject_id": "eegmmidb:029"
+    },
+    {
+      "alpha": 0.1,
+      "budget": 10,
+      "certified_index": 19,
+      "dataset": "eegmmidb",
+      "decision_hash": "680449eee1572031e5bf8ef941fa5db0bde860a168de93b68f76f41ef5033770",
+      "delta": 0.1,
+      "episode_hash": "cc728c588c3fe108a7529effa80262ed1ed989041eb9917f7c3f894626019053",
+      "query_hash": "37b804f8231dc6382bed75a59cd3a2c6b8931709a8bfe172b042a5c8c8e6004b",
+      "repeat": 16,
+      "role": "evaluation",
+      "seed": 0,
+      "source_model_hash": "e3ff1372a811e8eb9532e4030c3d343fd0e496860900ac7742718fe94fe0446d",
+      "strategy": "random",
+      "subject_id": "eegmmidb:029"
+    },
+    {
+      "alpha": 0.1,
+      "budget": 10,
+      "certified_index": 15,
+      "dataset": "eegmmidb",
+      "decision_hash": "1ed7ff5b08778dceb294ffc1e7a33ef248ba246d4cd8741cbd483dd37d59110b",
+      "delta": 0.1,
+      "episode_hash": "cc728c588c3fe108a7529effa80262ed1ed989041eb9917f7c3f894626019053",
+      "query_hash": "f5364b63c289182d5c8056f8c07bacd1a9ec97dfba96a3e0ba62ff1251dc82a9",
+      "repeat": 17,
+      "role": "evaluation",
+      "seed": 0,
+      "source_model_hash": "e3ff1372a811e8eb9532e4030c3d343fd0e496860900ac7742718fe94fe0446d",
+      "strategy": "random",
+      "subject_id": "eegmmidb:029"
+    },
+    {
+      "alpha": 0.1,
+      "budget": 10,
+      "certified_index": 17,
+      "dataset": "eegmmidb",
+      "decision_hash": "8fcd561487cf7eff3a773c679506dcbc601fac1b75bc27766adc1ae6a9107c26",
+      "delta": 0.1,
+      "episode_hash": "cc728c588c3fe108a7529effa80262ed1ed989041eb9917f7c3f894626019053",
+      "query_hash": "faec179143d2fa98848429afa982074e2cb13133047e1943a23121b9ae6a4b76",
+      "repeat": 18,
+      "role": "evaluation",
+      "seed": 0,
+      "source_model_hash": "e3ff1372a811e8eb9532e4030c3d343fd0e496860900ac7742718fe94fe0446d",
+      "strategy": "random",
+      "subject_id": "eegmmidb:029"
+    },
+    {
+      "alpha": 0.1,
+      "budget": 10,
+      "certified_index": 20,
+      "dataset": "eegmmidb",
+      "decision_hash": "3389d41155ad02bec82e375e34ad8d65d5406c5cd205283305e4dc78c73dcdcb",
+      "delta": 0.1,
+      "episode_hash": "cc728c588c3fe108a7529effa80262ed1ed989041eb9917f7c3f894626019053",
+      "query_hash": "f8e3380911c3cdd9ec98c2b0b447581c9b365eefb70e270cf3966e2b559cfb31",
+      "repeat": 19,
+      "role": "evaluation",
+      "seed": 0,
+      "source_model_hash": "e3ff1372a811e8eb9532e4030c3d343fd0e496860900ac7742718fe94fe0446d",
+      "strategy": "random",
+      "subject_id": "eegmmidb:029"
+    }
+  ],
+  "schema_version": "budgeted-risk-decision-batch-v1"
+}