Repository: torcheeg/torcheeg (language: python)

Issue:
Bug  in seed_dataset docs



Discussion / hints:

Fix patch:
diff --git a/.gitignore b/.gitignore
index 0fc5c4e..d91d75a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -56,4 +56,5 @@ docs/source/auto_examples/
 tmp_in/
 tmp_out/
 dev/
+.torcheeg/
 lightning_logs/
\ No newline at end of file
diff --git a/README.md b/README.md
index de4acec..48740fb 100644
--- a/README.md
+++ b/README.md
@@ -146,7 +146,7 @@ The `torcheeg.datasets` module contains dataset classes for many real-world EEG
 from torcheeg.datasets import DEAPDataset
 from torcheeg import transforms
 
-from torcheeg.datasets.constants.emotion_recognition.deap import \
+from torcheeg.datasets.constants import \
     DEAP_CHANNEL_LOCATION_DICT
 
 dataset = DEAPDataset(
diff --git a/README.rst b/README.rst
index 488a830..cf46d2d 100644
--- a/README.rst
+++ b/README.rst
@@ -256,7 +256,7 @@ e.g. ``./tmp_in/data_preprocessed_python``.
    from torcheeg.datasets import DEAPDataset
    from torcheeg import transforms
 
-   from torcheeg.datasets.constants.emotion_recognition.deap import \
+   from torcheeg.datasets.constants import \
        DEAP_CHANNEL_LOCATION_DICT
 
    dataset = DEAPDataset(
diff --git a/docs/source/torcheeg.datasets.rst b/docs/source/torcheeg.datasets.rst
index 5c5ad09..1481504 100644
--- a/docs/source/torcheeg.datasets.rst
+++ b/docs/source/torcheeg.datasets.rst
@@ -22,6 +22,8 @@ Emotion Recognition Datasets
     SEEDFeatureDataset
     SEEDIVDataset
     SEEDIVFeatureDataset
+    SEEDVDataset
+    SEEDVFeatureDataset
     AMIGOSDataset
     MAHNOBDataset
     BCI2022Dataset
@@ -87,10 +89,3 @@ Customized Datasets
 
     FolderDataset
     CSVFolderDataset
-
-Hooks
----------------------------------------------------------
-
-.. autofunction:: before_trial_normalize
-.. autofunction:: after_trial_normalize
-.. autofunction:: after_trial_moving_avg
\ No newline at end of file
diff --git a/docs/source/torcheeg.transforms.rst b/docs/source/torcheeg.transforms.rst
index 7247001..5543a12 100644
--- a/docs/source/torcheeg.transforms.rst
+++ b/docs/source/torcheeg.transforms.rst
@@ -111,4 +111,23 @@ Label Transforms
     BinaryOneVSRest
     BinariesToCategory
     StringToInt
-    Mapping
\ No newline at end of file
+    Mapping
+
+.. contents:: We also provide hooks for preprocessing signals, which can leverage global information from trials, sessions, and subjects, and thus can improve the performance of prediction models, especially generalization. Please refer to the paper you are comparing to determine whether you should use it to conduct a fair comparison.
+    :depth: 2
+    :local:
+    :backlinks: top
+
+.. currentmodule:: torcheeg.transforms
+    
+Hooks
+----------------------------------
+.. autosummary::
+    :toctree: generated
+    :nosignatures:
+    :template: transformtemplate.rst
+
+    before_hook_normalize :noindex:
+    after_hook_normalize :noindex:
+    after_hook_running_norm :noindex:
+    after_hook_linear_dynamical_system :noindex:
\ No newline at end of file
diff --git a/examples/examples_datasets.py b/examples/examples_datasets.py
index 9ffe8cd..e00d67a 100644
--- a/examples/examples_datasets.py
+++ b/examples/examples_datasets.py
@@ -18,7 +18,7 @@
 from torcheeg.datasets import DEAPDataset
 from torcheeg import transforms
 
-from torcheeg.datasets.constants.emotion_recognition.deap import \
+from torcheeg.datasets.constants import \
     DEAP_CHANNEL_LOCATION_DICT
 
 dataset = DEAPDataset(
diff --git a/examples/examples_deap_cwgangp.py b/examples/examples_deap_cwgangp.py
index 6c06e92..962629b 100644
--- a/examples/examples_deap_cwgangp.py
+++ b/examples/examples_deap_cwgangp.py
@@ -27,7 +27,7 @@
 from torcheeg.datasets import DEAPDataset
 from torcheeg import transforms
 
-from torcheeg.datasets.constants.emotion_recognition.deap import \
+from torcheeg.datasets.constants import \
     DEAP_CHANNEL_LOCATION_DICT
 
 dataset = DEAPDataset(
diff --git a/examples/examples_pipeline.py b/examples/examples_pipeline.py
index b07f84b..5232424 100644
--- a/examples/examples_pipeline.py
+++ b/examples/examples_pipeline.py
@@ -31,7 +31,7 @@
 from torcheeg.datasets import DEAPDataset
 from torcheeg import transforms
 
-from torcheeg.datasets.constants.emotion_recognition.deap import \
+from torcheeg.datasets.constants import \
     DEAP_CHANNEL_LOCATION_DICT
 
 dataset = DEAPDataset(
diff --git a/examples/examples_seed_domain_adaption.py b/examples/examples_seed_domain_adaption.py
index 0fb7214..cbdd753 100644
--- a/examples/examples_seed_domain_adaption.py
+++ b/examples/examples_seed_domain_adaption.py
@@ -14,20 +14,20 @@
 #
 # In offline preprocessing, each electrode's EEG signal is segmented into 4 sub-bands. We then calculate the differential entropy for each sub-band as a feature. The signals are debaselined, mapped onto a grid, and finally saved locally. 
 #
-# For online processing, we convert all EEG signals into Tensors for neural network input. Additionally, we apply before_trial_normalize to reduce trial variance effects on cross-subject emotion recognition.
+# For online processing, we convert all EEG signals into Tensors for neural network input. Additionally, we apply after_hook_normalize to reduce trial variance effects on cross-subject emotion recognition.
 #
 
 from torcheeg.datasets import SEEDFeatureDataset
 from torcheeg import transforms
 from torcheeg.datasets.constants.emotion_recognition.seed import SEED_CHANNEL_LOCATION_DICT
-from torcheeg.datasets.functional import before_trial_normalize
+from torcheeg.transforms import after_hook_normalize
 from pytorch_lightning.callbacks import ModelCheckpoint
 import numpy as np
 
 dataset = SEEDFeatureDataset(
     io_path=f'./examples_seed_domain_adaption/seed',
     root_path='./ExtractedFeatures',
-    after_session=before_trial_normalize,
+    after_session=after_hook_normalize,
     offline_transform=transforms.Compose(
         [transforms.ToGrid(SEED_CHANNEL_LOCATION_DICT)]),
     online_transform=transforms.ToTensor(),  # seed do not have baseline signals
diff --git a/examples/examples_trainers.py b/examples/examples_trainers.py
index da39c75..7768441 100644
--- a/examples/examples_trainers.py
+++ b/examples/examples_trainers.py
@@ -28,7 +28,7 @@
 from torcheeg import transforms
 
 from torcheeg.model_selection import KFoldGroupbyTrial
-from torcheeg.datasets.constants.emotion_recognition.deap import \
+from torcheeg.datasets.constants import \
     DEAP_CHANNEL_LOCATION_DICT
 from torch.utils.data import DataLoader
 from torcheeg.models import CCNN
@@ -157,7 +157,7 @@ def training_step(self, batch, batch_idx):
 from torcheeg import transforms
 
 from torcheeg.model_selection import LeaveOneSubjectOut
-from torcheeg.datasets.constants.emotion_recognition.deap import \
+from torcheeg.datasets.constants import \
     DEAP_CHANNEL_LOCATION_DICT
 from torch.utils.data import DataLoader
 from torcheeg.models import CCNN
diff --git a/examples/examples_transfer_mahnob_2_deap.py b/examples/examples_transfer_mahnob_2_deap.py
index 2ba13d3..be46be3 100644
--- a/examples/examples_transfer_mahnob_2_deap.py
+++ b/examples/examples_transfer_mahnob_2_deap.py
@@ -22,14 +22,14 @@
 # convert all EEG signals into Tensors, making them suitable for neural
 # network input.
 #
-# We use the `before_trial_normalize` function to normalize each EEG trial. This helps in reducing the variance between trials, thereby aiding the transfer generalizable knowledge from MAHNOB to DEAP.
+# We use the `after_hook_normalize` function to normalize each EEG trial. This helps in reducing the variance between trials, thereby aiding the transfer generalizable knowledge from MAHNOB to DEAP.
 #
 
 from torcheeg.datasets import MAHNOBDataset
 from torcheeg import transforms
 from torcheeg.datasets.constants.emotion_recognition.mahnob import MAHNOB_CHANNEL_LOCATION_DICT
 
-from torcheeg.datasets.functional import before_trial_normalize
+from torcheeg.transforms import after_hook_normalize
 
 dataset = MAHNOBDataset(
     io_path='./examples_transfer_mahnob_2_deap/mahnob',
@@ -41,7 +41,7 @@
         transforms.ToGrid(MAHNOB_CHANNEL_LOCATION_DICT)
     ]),
     online_transform=transforms.ToTensor(),
-    after_subject=before_trial_normalize,
+    after_subject=after_hook_normalize,
     label_transform=transforms.Compose(
         [transforms.Select('feltVlnc'),
          transforms.Binary(5.0)]),
@@ -133,7 +133,7 @@
 
 from torcheeg.datasets import DEAPDataset
 
-from torcheeg.datasets.constants.emotion_recognition.deap import \
+from torcheeg.datasets.constants import \
     DEAP_CHANNEL_LOCATION_DICT
 
 dataset = DEAPDataset(
diff --git a/examples/examples_transforms.py b/examples/examples_transforms.py
index c45d5a5..b6faeba 100644
--- a/examples/examples_transforms.py
+++ b/examples/examples_transforms.py
@@ -17,7 +17,7 @@
 import numpy as np
 from torcheeg import transforms
 
-from torcheeg.datasets.constants.emotion_recognition.deap import \
+from torcheeg.datasets.constants import \
     DEAP_CHANNEL_LOCATION_DICT
 
 t = transforms.ToGrid(DEAP_CHANNEL_LOCATION_DICT)
diff --git a/examples/examples_vanilla_torch.py b/examples/examples_vanilla_torch.py
index 6e92540..af5e087 100644
--- a/examples/examples_vanilla_torch.py
+++ b/examples/examples_vanilla_torch.py
@@ -73,7 +73,7 @@ def seed_everything(seed):
 from torcheeg.datasets import DEAPDataset
 from torcheeg import transforms
 
-from torcheeg.datasets.constants.emotion_recognition.deap import \
+from torcheeg.datasets.constants import \
     DEAP_CHANNEL_LOCATION_DICT
 
 dataset = DEAPDataset(
diff --git a/meta.yaml b/meta.yaml
index 0afb885..59b7fda 100644
--- a/meta.yaml
+++ b/meta.yaml
@@ -21,6 +21,7 @@ requirements:
     - tqdm>=4.64.0
     - numpy>=1.21.5
     - pandas>=1.3.5
+    - xlrd>=2.0.1
     - scipy>=1.7.3
     - scikit-learn>=1.0.2
     - python-lmdb>=1.3.0
diff --git a/setup.py b/setup.py
index 0ea4865..6b47cc0 100644
--- a/setup.py
+++ b/setup.py
@@ -4,9 +4,9 @@
 URL = 'https://github.com/tczhangzhi/torcheeg'
 
 install_requires = [
-    'tqdm>=4.64.0', 'numpy>=1.21.5', 'pandas>=1.3.5', 'scipy>=1.7.3',
-    'scikit-learn>=1.0.2', 'lmdb>=1.3.0', 'einops>=0.4.1', 'mne>=1.0.3',
-    'xmltodict>=0.13.0', 'networkx>=2.6.3', 'PyWavelets>=1.3.0',
+    'tqdm>=4.64.0', 'numpy>=1.21.5', 'pandas>=1.3.5', 'xlrd>=2.0.1',
+    'scipy>=1.7.3', 'scikit-learn>=1.0.2', 'lmdb>=1.3.0', 'einops>=0.4.1',
+    'mne>=1.0.3', 'xmltodict>=0.13.0', 'networkx>=2.6.3', 'PyWavelets>=1.3.0',
     'spectrum>=0.8.1', 'torchmetrics>=0.10.0', 'mne_connectivity>=0.4.0',
     'pytorch-lightning>=1.9.5'
 ]
diff --git a/torcheeg/datasets/__init__.py b/torcheeg/datasets/__init__.py
index a074432..cbdbf08 100644
--- a/torcheeg/datasets/__init__.py
+++ b/torcheeg/datasets/__init__.py
@@ -1,2 +1,1 @@
-from .module import *
-from .functional import *
\ No newline at end of file
+from .module import *
\ No newline at end of file
diff --git a/torcheeg/datasets/constants/emotion_recognition/__init__.py b/torcheeg/datasets/constants/emotion_recognition/__init__.py
index 84d50d5..4e92d68 100644
--- a/torcheeg/datasets/constants/emotion_recognition/__init__.py
+++ b/torcheeg/datasets/constants/emotion_recognition/__init__.py
@@ -4,4 +4,5 @@
 from .mahnob import *
 from .seed import *
 from .seed_iv import *
-from .mped import *
\ No newline at end of file
+from .mped import *
+from .seed_v import *
\ No newline at end of file
diff --git a/torcheeg/datasets/constants/emotion_recognition/seed_v.py b/torcheeg/datasets/constants/emotion_recognition/seed_v.py
new file mode 100644
index 0000000..f799ef5
--- /dev/null
+++ b/torcheeg/datasets/constants/emotion_recognition/seed_v.py
@@ -0,0 +1,108 @@
+from ..region_1020 import (FRONTAL_REGION_LIST, GENERAL_REGION_LIST,
+                           HEMISPHERE_REGION_LIST)
+from ..standard_1005 import STANDARD_1005_CHANNEL_LOCATION_DICT
+from ..utils import (format_adj_matrix_from_adj_list,
+                     format_adj_matrix_from_standard,
+                     format_channel_location_dict, format_region_channel_list)
+
+SEED_V_CHANNEL_LIST = [
+    'FP1', 'FPZ', 'FP2', 'AF3', 'AF4', 'F7', 'F5', 'F3', 'F1', 'FZ', 'F2', 'F4',
+    'F6', 'F8', 'FT7', 'FC5', 'FC3', 'FC1', 'FCZ', 'FC2', 'FC4', 'FC6', 'FT8',
+    'T7', 'C5', 'C3', 'C1', 'CZ', 'C2', 'C4', 'C6', 'T8', 'TP7', 'CP5', 'CP3',
+    'CP1', 'CPZ', 'CP2', 'CP4', 'CP6', 'TP8', 'P7', 'P5', 'P3', 'P1', 'PZ',
+    'P2', 'P4', 'P6', 'P8', 'PO7', 'PO5', 'PO3', 'POZ', 'PO4', 'PO6', 'PO8',
+    'CB1', 'O1', 'OZ', 'O2', 'CB2'
+]
+
+SEED_V_LOCATION_LIST = [
+    ['-', '-', '-', 'FP1', 'FPZ', 'FP2', '-', '-', '-'],
+    ['-', '-', '-', 'AF3', '-', 'AF4', '-', '-', '-'],
+    ['F7', 'F5', 'F3', 'F1', 'FZ', 'F2', 'F4', 'F6', 'F8'],
+    ['FT7', 'FC5', 'FC3', 'FC1', 'FCZ', 'FC2', 'FC4', 'FC6', 'FT8'],
+    ['T7', 'C5', 'C3', 'C1', 'CZ', 'C2', 'C4', 'C6', 'T8'],
+    ['TP7', 'CP5', 'CP3', 'CP1', 'CPZ', 'CP2', 'CP4', 'CP6', 'TP8'],
+    ['P7', 'P5', 'P3', 'P1', 'PZ', 'P2', 'P4', 'P6', 'P8'],
+    ['-', 'PO7', 'PO5', 'PO3', 'POZ', 'PO4', 'PO6', 'PO8', '-'],
+    ['-', '-', 'CB1', 'O1', 'OZ', 'O2', 'CB2', '-', '-']
+]
+
+SEED_V_CHANNEL_LOCATION_DICT = format_channel_location_dict(
+    SEED_V_CHANNEL_LIST, SEED_V_LOCATION_LIST)
+
+SEED_V_ADJACENCY_LIST = {
+    'FP1': ['FPZ', 'AF3'],
+    'FPZ': ['FP1', 'FP2'],
+    'FP2': ['FPZ', 'AF4'],
+    'AF3': ['FP1', 'F5', 'F3', 'F1'],
+    'AF4': ['F2', 'F4', 'F6', 'FP2'],
+    'F7': ['F5', 'FT7'],
+    'F5': ['F7', 'AF3', 'F3', 'FC5'],
+    'F3': ['AF3', 'F5', 'FC3', 'F1'],
+    'F1': ['AF3', 'F3', 'FC1', 'FZ'],
+    'FZ': ['F1', 'FCZ', 'F2'],
+    'F2': ['FZ', 'FC2', 'F4', 'AF4'],
+    'F4': ['F2', 'FC4', 'F6', 'AF4'],
+    'F6': ['AF4', 'F4', 'FC6', 'F8'],
+    'F8': ['F6', 'FT8'],
+    'FT7': ['F7', 'FC5', 'T7'],
+    'FC5': ['F5', 'FT7', 'C5', 'FC3'],
+    'FC3': ['F3', 'FC5', 'C3', 'FC1'],
+    'FC1': ['F1', 'FC3', 'C1', 'FCZ'],
+    'FCZ': ['FZ', 'FC1', 'CZ', 'FC2'],
+    'FC2': ['F2', 'FCZ', 'C2', 'FC4'],
+    'FC4': ['F4', 'FC2', 'C4', 'FC6'],
+    'FC6': ['F6', 'FC4', 'C6', 'FT8'],
+    'FT8': ['F8', 'FC6', 'T8'],
+    'T7': ['FT7', 'C5', 'TP7'],
+    'C5': ['FC5', 'T7', 'C3', 'CP5'],
+    'C3': ['FC3', 'C5', 'C1', 'CP3'],
+    'C1': ['FC1', 'C3', 'CP1', 'CZ'],
+    'CZ': ['FCZ', 'C1', 'CPZ', 'C2'],
+    'C2': ['FC2', 'CZ', 'CP2', 'C4'],
+    'C4': ['FC4', 'C2', 'CP4', 'C6'],
+    'C6': ['FC6', 'C4', 'CP6', 'T8'],
+    'T8': ['FT8', 'C6', 'TP8'],
+    'TP7': ['T7', 'CP5', 'P7'],
+    'CP5': ['C5', 'TP7', 'P5', 'CP3'],
+    'CP3': ['C3', 'CP5', 'P3', 'CP1'],
+    'CP1': ['C1', 'CP3', 'P1', 'CPZ'],
+    'CPZ': ['CZ', 'CP1', 'PZ', 'CP2'],
+    'CP2': ['C2', 'CPZ', 'P2', 'CP4'],
+    'CP4': ['C4', 'CP2', 'P4', 'CP6'],
+    'CP6': ['C6', 'CP4', 'P6', 'TP8'],
+    'TP8': ['T8', 'CP6', 'P8'],
+    'P7': ['TP7', 'P5', 'PO7'],
+    'P5': ['CP5', 'P7', 'PO5', 'P3'],
+    'P3': ['CP3', 'P5', 'P1'],
+    'P1': ['CP1', 'P3', 'PO3', 'PZ'],
+    'PZ': ['CPZ', 'P1', 'POZ', 'P2'],
+    'P2': ['CP2', 'PZ', 'PO4', 'P4'],
+    'P4': ['CP4', 'P2', 'P6'],
+    'P6': ['CP6', 'P4', 'P8'],
+    'P8': ['TP8', 'P6', 'PO8'],
+    'PO7': ['P7', 'PO5', 'CB1'],
+    'PO5': ['P5', 'PO7', 'CB1', 'PO3'],
+    'PO3': ['P1', 'PO5', 'O1', 'POZ'],
+    'POZ': ['PZ', 'PO3', 'OZ', 'PO4'],
+    'PO4': ['P2', 'POZ', 'O2', 'PO6'],
+    'PO6': ['P6', 'PO4', 'CB2', 'PO8'],
+    'PO8': ['P8', 'PO6', 'CB2'],
+    'CB1': ['PO7', 'PO5', 'O1'],
+    'O1': ['CB1', 'PO3', 'OZ'],
+    'OZ': ['POZ', 'O1', 'O2'],
+    'O2': ['PO4', 'OZ', 'CB2'],
+    'CB2': ['PO6', 'O2', 'PO8']
+}
+
+SEED_V_ADJACENCY_MATRIX = format_adj_matrix_from_adj_list(SEED_V_CHANNEL_LIST,
+                                                        SEED_V_ADJACENCY_LIST)
+
+SEED_V_STANDARD_ADJACENCY_MATRIX = format_adj_matrix_from_standard(
+    SEED_V_CHANNEL_LIST, STANDARD_1005_CHANNEL_LOCATION_DICT)
+
+SEED_V_GENERAL_REGION_LIST = format_region_channel_list(SEED_V_CHANNEL_LIST,
+                                                      GENERAL_REGION_LIST)
+SEED_V_FRONTAL_REGION_LIST = format_region_channel_list(SEED_V_CHANNEL_LIST,
+                                                      FRONTAL_REGION_LIST)
+SEED_V_HEMISPHERE_REGION_LIST = format_region_channel_list(
+    SEED_V_CHANNEL_LIST, HEMISPHERE_REGION_LIST)
diff --git a/torcheeg/datasets/functional/__init__.py b/torcheeg/datasets/functional/__init__.py
deleted file mode 100644
index c3c024c..0000000
--- a/torcheeg/datasets/functional/__init__.py
+++ /dev/null
@@ -1,1 +0,0 @@
-from .hooks import *
\ No newline at end of file
diff --git a/torcheeg/datasets/functional/hooks.py b/torcheeg/datasets/functional/hooks.py
deleted file mode 100644
index d271398..0000000
--- a/torcheeg/datasets/functional/hooks.py
+++ /dev/null
@@ -1,163 +0,0 @@
-import numpy as np
-
-
-def before_trial_normalize(data: np.ndarray, eps: float = 1e-6, axis=0):
-    r'''
-    A common hook function used to normalize the signal of the whole trial before dividing it into chunks.
-
-    It is used as follows:
-
-    .. code-block:: python
-
-        from functools import partial
-        dataset = DEAPDataset(
-                ...
-                before_trial=before_trial_normalize,
-                num_worker=4)
-
-    If you want to pass in parameters, use partial to generate a new function:
-
-    .. code-block:: python
-
-        from functools import partial
-        dataset = DEAPDataset(
-                ...
-                before_trial=partial(before_trial_normalize, eps=1e-5),
-                num_worker=4)
-
-    Args:
-        data (np.ndarray): The input EEG signals or features of a trial.
-        eps (float): The term added to the denominator to improve numerical stability (default: :obj:`1e-6`)
-        
-    Returns:
-        np.ndarray: The normalized results of a trial.
-    '''
-    min_v = data.min(axis=axis, keepdims=True)
-    max_v = data.max(axis=axis, keepdims=True)
-    return (data - min_v) / (max_v - min_v + eps)
-
-
-def after_trial_normalize(data: np.ndarray, eps: float = 1e-6):
-    r'''
-    A common hook function used to normalize the signal of the whole trial after dividing it into chunks and transforming the divided chunks.
-
-    It is used as follows:
-
-    .. code-block:: python
-
-        from functools import partial
-        dataset = DEAPDataset(
-                ...
-                after_trial=after_trial_normalize,
-                num_worker=4)
-
-    If you want to pass in parameters, use partial to generate a new function:
-
-    .. code-block:: python
-
-        from functools import partial
-        dataset = DEAPDataset(
-                ...
-                after_trial=partial(after_trial_normalize, eps=1e-5),
-                num_worker=4)
-    
-    Args:
-        data (np.ndarray): The input EEG signals or features of a trial.
-        eps (float): The term added to the denominator to improve numerical stability (default: :obj:`1e-6`)
-        
-    Returns:
-        np.ndarray: The normalized results of a trial.
-    '''
-    trial_samples = []
-    trial_keys = []
-    trial_infos = []
-    for sample in data:
-        # electrodes, bands
-        trial_samples.append(sample['eeg'])
-        trial_keys.append(sample['key'])
-        trial_infos.append(sample['info'])
-
-    # windows, electrodes, bands
-    trial_samples = np.stack(trial_samples, axis=0)
-
-    min_v = trial_samples.min(axis=0, keepdims=True)
-    max_v = trial_samples.max(axis=0, keepdims=True)
-    trial_samples = (trial_samples - min_v) / (max_v - min_v + eps)
-
-    output_data = []
-    for i, sample in enumerate(trial_samples):
-        output_data.append({
-            'eeg': sample,
-            'key': trial_keys[i],
-            'info': trial_infos[i]
-        })
-    return output_data
-
-
-def after_trial_moving_avg(data: list, window_size: int = 4):
-    '''
-    A common hook function for smoothing the signal of each chunk in a trial after pre-processing.
-
-    It is used as follows:
-
-    .. code-block:: python
-
-        from functools import partial
-        dataset = DEAPDataset(
-                ...
-                after_trial=after_trial_moving_avg,
-                num_worker=4)
-    
-    If you want to pass in parameters, use partial to generate a new function:
-
-    .. code-block:: python
-
-        from functools import partial
-        dataset = DEAPDataset(
-                ...
-                after_trial=partial(after_trial_moving_avg, eps=1e-5),
-                num_worker=4)
-
-    Args:
-        data (np.ndarray): A list of dictionaries, one of which corresponds to an EEG signal in trial. Each dictionary consists of two key-value paris, eeg and key. The value of eeg is the representation of the EEG signal and the value of key is its ID in the IO.
-        window_size (int): The window size of moving average. (default: :obj:`4`)
-        
-    Returns:
-        list: The smoothing results of a trial. It is a list of dictionaries, one of which corresponds to an EEG signal in trial. Each dictionary consists of two key-value paris, eeg and key. The value of eeg is the representation of the EEG signal and the value of key is its ID in the IO.
-    '''
-    trial_samples = []
-    trial_keys = []
-    trial_infos = []
-    for sample in data:
-        # electrodes, bands
-        trial_samples.append(sample['eeg'])
-        trial_keys.append(sample['key'])
-        trial_infos.append(sample['info'])
-
-    trial_samples = np.stack(trial_samples, axis=0)
-    trial_samples_shape = trial_samples.shape
-    trial_samples = trial_samples.reshape(trial_samples.shape[0], -1)
-    # windows, electrodes * bands
-    trial_samples_T = trial_samples.T
-
-    # electrodes * bands, n
-    channel_list = []
-    for channel in trial_samples_T:
-        moving_avg_channel = np.convolve(channel, np.ones(window_size),
-                                         'same') / window_size
-        channel_list.append(moving_avg_channel)
-    trial_samples_T = np.array(channel_list)
-
-    # windows, electrodes * bands
-    trial_samples = trial_samples_T.T
-    # windows, electrodes, bands
-    trial_samples = trial_samples.reshape(*trial_samples_shape)
-
-    output_data = []
-    for i, sample in enumerate(trial_samples):
-        output_data.append({
-            'eeg': sample,
-            'key': trial_keys[i],
-            'info': trial_infos[i]
-        })
-    return output_data
diff --git a/torcheeg/datasets/moabb/moabb_dataset.py b/torcheeg/datasets/moabb/moabb_dataset.py
index 0084cbf..d8aa343 100644
--- a/torcheeg/datasets/moabb/moabb_dataset.py
+++ b/torcheeg/datasets/moabb/moabb_dataset.py
@@ -21,6 +21,10 @@ class MOABBDataset(BaseDataset):
 
     .. code-block:: python
         
+        from moabb.datasets import BNCI2014001
+        from moabb.paradigms import LeftRightImagery
+        
+        from torcheeg import transforms
         import torcheeg.datasets.moabb as moabb_dataset
 
         dataset = BNCI2014001()
diff --git a/torcheeg/datasets/module/base_dataset.py b/torcheeg/datasets/module/base_dataset.py
index c87149b..1c07b0f 100644
--- a/torcheeg/datasets/module/base_dataset.py
+++ b/torcheeg/datasets/module/base_dataset.py
@@ -296,10 +296,10 @@ def post_process_record(self,
             subject_df = self.info.groupby('subject_id')
         else:
             subject_df = [(None, self.info)]
-            if not after_subject is None:
-                log.info(
-                    "No subject_id column found in info, after_subject hook is ignored."
-                )
+            # if not after_subject is None:
+            #     log.info(
+            #         "No subject_id column found in info, after_subject hook is ignored."
+            #     )
         if after_subject is None:
             after_subject = lambda x: x
 
@@ -314,10 +314,10 @@ def post_process_record(self,
                 session_df = subject_info.groupby('session_id')
             else:
                 session_df = [(None, subject_info)]
-                if not after_session is None:
-                    log.info(
-                        "No session_id column found in info, after_session hook is ignored."
-                    )
+                # if not after_session is None:
+                #     log.info(
+                #         "No session_id column found in info, after_session hook is ignored."
+                #     )
             if after_session is None:
                 after_session = lambda x: x
 
diff --git a/torcheeg/datasets/module/csv_folder_dataset.py b/torcheeg/datasets/module/csv_folder_dataset.py
index 4cca864..871e4db 100644
--- a/torcheeg/datasets/module/csv_folder_dataset.py
+++ b/torcheeg/datasets/module/csv_folder_dataset.py
@@ -36,6 +36,9 @@ class CSVFolderDataset(BaseDataset):
         # | sub2       | 1        | 1     | './data/label2/sub2.fif' |
         # | sub2       | 2        | 2     | './data/label3/sub2.fif' |
 
+        from torcheeg.datasets import CSVFolderDataset
+        from torcheeg import transforms
+
         def default_read_fn(file_path, **kwargs):
             # Load EEG file
             raw = mne.io.read_raw(file_path)
diff --git a/torcheeg/datasets/module/emotion_recognition/__init__.py b/torcheeg/datasets/module/emotion_recognition/__init__.py
index 7961bb2..4952a18 100644
--- a/torcheeg/datasets/module/emotion_recognition/__init__.py
+++ b/torcheeg/datasets/module/emotion_recognition/__init__.py
@@ -3,8 +3,10 @@
 from .deap import DEAPDataset
 from .dreamer import DREAMERDataset
 from .mahnob import MAHNOBDataset
+from .mped_feature import MPEDFeatureDataset
 from .seed import SEEDDataset
 from .seed_feature import SEEDFeatureDataset
 from .seed_iv import SEEDIVDataset
 from .seed_iv_feature import SEEDIVFeatureDataset
-from .mped_feature import MPEDFeatureDataset
\ No newline at end of file
+from .seed_v import SEEDVDataset
+from .seed_v_feature import SEEDVFeatureDataset
diff --git a/torcheeg/datasets/module/emotion_recognition/amigos.py b/torcheeg/datasets/module/emotion_recognition/amigos.py
index 1a6fe34..84dc471 100644
--- a/torcheeg/datasets/module/emotion_recognition/amigos.py
+++ b/torcheeg/datasets/module/emotion_recognition/amigos.py
@@ -35,6 +35,11 @@ class AMIGOSDataset(BaseDataset):
 
     .. code-block:: python
 
+        from torcheeg.datasets import AMIGOSDataset
+        from torcheeg import transforms
+
+        from torcheeg.datasets.constants.emotion_recognition.amigos import AMIGOS_CHANNEL_LOCATION_DICT
+
         dataset = AMIGOSDataset(root_path='./data_preprocessed',
                                 offline_transform=transforms.Compose([
                                     transforms.BandDifferentialEntropy(),
@@ -54,6 +59,9 @@ class AMIGOSDataset(BaseDataset):
 
     .. code-block:: python
 
+        from torcheeg.datasets import AMIGOSDataset
+        from torcheeg import transforms
+
         dataset = AMIGOSDataset(root_path='./data_preprocessed',
                                 online_transform=transforms.Compose(
                                     [transforms.To2d(),
@@ -71,6 +79,12 @@ class AMIGOSDataset(BaseDataset):
 
     .. code-block:: python
     
+        from torcheeg.datasets import AMIGOSDataset
+        from torcheeg import transforms
+        from torcheeg.transforms.pyg import ToG
+
+        from torcheeg.datasets.constants.emotion_recognition.amigos import AMIGOS_ADJACENCY_MATRIX
+
         dataset = AMIGOSDataset(root_path='./data_preprocessed',
                                 online_transform=transforms.Compose(
                                     [ToG(AMIGOS_ADJACENCY_MATRIX)]),
diff --git a/torcheeg/datasets/module/emotion_recognition/bci2022.py b/torcheeg/datasets/module/emotion_recognition/bci2022.py
index 4b6fc59..1e173b0 100644
--- a/torcheeg/datasets/module/emotion_recognition/bci2022.py
+++ b/torcheeg/datasets/module/emotion_recognition/bci2022.py
@@ -117,6 +117,10 @@ class BCI2022Dataset(BaseDataset):
 
     .. code-block:: python
 
+        from torcheeg.datasets import BCI2022Dataset
+        from torcheeg import transforms
+        from torcheeg.datasets.constants.emotion_recognition.bci2022 import BCI2022_CHANNEL_LOCATION_DICT
+
         dataset = BCI2022Dataset(root_path='./TrainSet',
                                  offline_transform=transforms.Compose([
                                      transforms.BandDifferentialEntropy(),
@@ -133,6 +137,9 @@ class BCI2022Dataset(BaseDataset):
 
     .. code-block:: python
 
+        from torcheeg.datasets import BCI2022Dataset
+        from torcheeg import transforms
+
         dataset = BCI2022Dataset(root_path='./TrainSet',
                                  online_transform=transforms.Compose(
                                      [transforms.ToTensor(),
@@ -146,7 +153,11 @@ class BCI2022Dataset(BaseDataset):
     An example dataset for GNN-based methods:
 
     .. code-block:: python
-    
+
+        from torcheeg.datasets import BCI2022Dataset
+        from torcheeg import transforms
+        from torcheeg.datasets.constants.emotion_recognition.bci2022 import BCI2022_ADJACENCY_MATRIX
+        
         dataset = BCI2022Dataset(root_path='./TrainSet',
                                  online_transform=transforms.Compose(
                                      [transforms.ToG(BCI2022_ADJACENCY_MATRIX)]),
diff --git a/torcheeg/datasets/module/emotion_recognition/deap.py b/torcheeg/datasets/module/emotion_recognition/deap.py
index 9a404e8..2eb38e1 100644
--- a/torcheeg/datasets/module/emotion_recognition/deap.py
+++ b/torcheeg/datasets/module/emotion_recognition/deap.py
@@ -30,7 +30,11 @@ class DEAPDataset(BaseDataset):
     An example dataset for CNN-based methods:
 
     .. code-block:: python
-    
+
+        from torcheeg.datasets import DEAPDataset
+        from torcheeg import transforms
+        from torcheeg.datasets.constants import DEAP_CHANNEL_LOCATION_DICT
+
         dataset = DEAPDataset(root_path='./data_preprocessed_python',
                               offline_transform=transforms.Compose([
                                   transforms.BandDifferentialEntropy(),
@@ -50,6 +54,9 @@ class DEAPDataset(BaseDataset):
 
     .. code-block:: python
 
+        from torcheeg.datasets import DEAPDataset
+        from torcheeg import transforms
+
         dataset = DEAPDataset(root_path='./data_preprocessed_python',
                               online_transform=transforms.Compose([
                                   transforms.To2d(),
@@ -68,7 +75,12 @@ class DEAPDataset(BaseDataset):
     An example dataset for GNN-based methods:
 
     .. code-block:: python
-    
+
+        from torcheeg.datasets import DEAPDataset
+        from torcheeg import transforms
+        from torcheeg.datasets.constants import DEAP_ADJACENCY_MATRIX
+        from torcheeg.transforms.pyg import ToG
+
         dataset = DEAPDataset(root_path='./data_preprocessed_python',
                               online_transform=transforms.Compose([
                                   ToG(DEAP_ADJACENCY_MATRIX)
diff --git a/torcheeg/datasets/module/emotion_recognition/dreamer.py b/torcheeg/datasets/module/emotion_recognition/dreamer.py
index bcc0775..9369fb2 100644
--- a/torcheeg/datasets/module/emotion_recognition/dreamer.py
+++ b/torcheeg/datasets/module/emotion_recognition/dreamer.py
@@ -24,6 +24,10 @@ class DREAMERDataset(BaseDataset):
 
     .. code-block:: python
 
+        from torcheeg.datasets import DREAMERDataset
+        from torcheeg import transforms
+        from torcheeg.datasets.constants.emotion_recognition.dreamer import DREAMER_CHANNEL_LOCATION_DICT
+
         dataset = DREAMERDataset(mat_path='./DREAMER.mat',
                                  offline_transform=transforms.Compose([
                                      transforms.BandDifferentialEntropy(),
@@ -43,6 +47,9 @@ class DREAMERDataset(BaseDataset):
 
     .. code-block:: python
 
+        from torcheeg.datasets import DREAMERDataset
+        from torcheeg import transforms
+
         dataset = DREAMERDataset(mat_path='./DREAMER.mat',
                                  online_transform=transforms.Compose([
                                      transforms.To2d(),
@@ -61,7 +68,12 @@ class DREAMERDataset(BaseDataset):
     An example dataset for GNN-based methods:
 
     .. code-block:: python
-    
+        
+        from torcheeg.datasets import DREAMERDataset
+        from torcheeg import transforms
+        from torcheeg.datasets.constants.emotion_recognition.dreamer import DREAMER_ADJACENCY_MATRIX
+        from torcheeg.transforms.pyg import ToG
+        
         dataset = DREAMERDataset(mat_path='./DREAMER.mat',
                                  online_transform=transforms.Compose([
                                      ToG(DREAMER_ADJACENCY_MATRIX)
diff --git a/torcheeg/datasets/module/emotion_recognition/mahnob.py b/torcheeg/datasets/module/emotion_recognition/mahnob.py
index 2daac50..59059c2 100644
--- a/torcheeg/datasets/module/emotion_recognition/mahnob.py
+++ b/torcheeg/datasets/module/emotion_recognition/mahnob.py
@@ -56,6 +56,9 @@ class MAHNOBDataset(BaseDataset):
     Another example dataset for CNN-based methods:
 
     .. code-block:: python
+    
+        from torcheeg.datasets import MAHNOBDataset
+        from torcheeg import transforms
 
         dataset = MAHNOBDataset(root_path='./Sessions',
                                 online_transform=transforms.Compose([
@@ -75,7 +78,12 @@ class MAHNOBDataset(BaseDataset):
     An example dataset for GNN-based methods:
 
     .. code-block:: python
-    
+
+        from torcheeg.datasets import MAHNOBDataset
+        from torcheeg import transforms
+        from torcheeg.datasets.constants.emotion_recognition.mahnob import MAHNOB_ADJACENCY_MATRIX
+        from torcheeg.transforms.pyg import ToG
+
         dataset = MAHNOBDataset(root_path='./Sessions',
                                 online_transform=transforms.Compose([
                                     ToG(MAHNOB_ADJACENCY_MATRIX)
diff --git a/torcheeg/datasets/module/emotion_recognition/mped_feature.py b/torcheeg/datasets/module/emotion_recognition/mped_feature.py
index 879bbfd..5ae9dfb 100644
--- a/torcheeg/datasets/module/emotion_recognition/mped_feature.py
+++ b/torcheeg/datasets/module/emotion_recognition/mped_feature.py
@@ -32,6 +32,10 @@ class MPEDFeatureDataset(BaseDataset):
 
     .. code-block:: python
 
+        from torcheeg.datasets import MPEDFeatureDataset
+        from torcheeg import transforms
+        from torcheeg.datasets.constants.emotion_recognition.mped import MPED_CHANNEL_LOCATION_DICT
+
         dataset = MPEDFeatureDataset(root_path='./EEG_feature',
                                      features=['PSD'],
                                      offline_transform=transforms.ToGrid       (MPED_CHANNEL_LOCATION_DICT),
@@ -47,7 +51,12 @@ class MPEDFeatureDataset(BaseDataset):
     An example dataset for GNN-based methods:
 
     .. code-block:: python
-    
+
+        from torcheeg.datasets import MPEDFeatureDataset
+        from torcheeg import transforms
+        from torcheeg.datasets.constants.emotion_recognition.mped import MPED_ADJACENCY_MATRIX
+        from torcheeg.transforms.pyg import ToG
+
         dataset = MPEDFeatureDataset(root_path='./Preprocessed_EEG',
                                      features=['PSD'],
                                      online_transform=ToG(MPED_ADJACENCY_MATRIX),
diff --git a/torcheeg/datasets/module/emotion_recognition/seed.py b/torcheeg/datasets/module/emotion_recognition/seed.py
index 92d1610..39f83bc 100644
--- a/torcheeg/datasets/module/emotion_recognition/seed.py
+++ b/torcheeg/datasets/module/emotion_recognition/seed.py
@@ -30,6 +30,10 @@ class SEEDDataset(BaseDataset):
 
     .. code-block:: python
 
+        from torcheeg.datasets import SEEDDataset
+        from torcheeg import transforms
+        from torcheeg.datasets.constants.emotion_recognition.seed import SEED_CHANNEL_LOCATION_DICT
+
         dataset = SEEDDataset(root_path='./Preprocessed_EEG',
                               offline_transform=transforms.Compose([
                                   transforms.BandDifferentialEntropy(),
@@ -49,6 +53,9 @@ class SEEDDataset(BaseDataset):
 
     .. code-block:: python
 
+        from torcheeg.datasets import SEEDDataset
+        from torcheeg import transforms
+
         dataset = SEEDDataset(root_path='./Preprocessed_EEG',
                               online_transform=transforms.Compose([
                                   transforms.ToTensor(),
@@ -56,7 +63,7 @@ class SEEDDataset(BaseDataset):
                               ]),
                               label_transform=transforms.Compose([
                                   transforms.Select('emotion'),
-                                  transforms.Lambda(x: x + 1)
+                                  transforms.Lambda(lambda x: x + 1)
                               ]))
         print(dataset[0])
         # EEG signal (torch.Tensor[62, 200]),
@@ -66,14 +73,19 @@ class SEEDDataset(BaseDataset):
     An example dataset for GNN-based methods:
 
     .. code-block:: python
-    
+
+        from torcheeg.datasets import SEEDDataset
+        from torcheeg import transforms
+        from torcheeg.datasets.constants.emotion_recognition.seed import SEED_ADJACENCY_MATRIX
+        from torcheeg.transforms.pyg import ToG
+        
         dataset = SEEDDataset(root_path='./Preprocessed_EEG',
                               online_transform=transforms.Compose([
                                   ToG(SEED_ADJACENCY_MATRIX)
                               ]),
                               label_transform=transforms.Compose([
                                   transforms.Select('emotion'),
-                                  transforms.Lambda(x: x + 1)
+                                  transforms.Lambda(lambda x: x + 1)
                               ]))
         print(dataset[0])
         # EEG signal (torch_geometric.data.Data),
@@ -170,7 +182,6 @@ def process_record(file: Any = None,
         # loop for each trial
         for trial_id in trial_ids:
 
-            # extract baseline signals
             trial_samples = samples[trial_id]  # channel(62), timestep(n*200)
             if before_trial:
                 trial_samples = before_trial(trial_samples)
diff --git a/torcheeg/datasets/module/emotion_recognition/seed_feature.py b/torcheeg/datasets/module/emotion_recognition/seed_feature.py
index ed6e9d5..76c2f5f 100644
--- a/torcheeg/datasets/module/emotion_recognition/seed_feature.py
+++ b/torcheeg/datasets/module/emotion_recognition/seed_feature.py
@@ -33,6 +33,10 @@ class SEEDFeatureDataset(BaseDataset):
 
     .. code-block:: python
 
+        from torcheeg.datasets import SEEDFeatureDataset
+        from torcheeg import transforms
+        from torcheeg.datasets.constants.emotion_recognition.seed import SEED_CHANNEL_LOCATION_DICT
+
         dataset = SEEDFeatureDataset(root_path='./ExtractedFeatures',
                                      feature=['de_movingAve'],
                                      offline_transform=transforms.ToGrid       (SEED_CHANNEL_LOCATION_DICT),
@@ -49,7 +53,12 @@ class SEEDFeatureDataset(BaseDataset):
     An example dataset for GNN-based methods:
 
     .. code-block:: python
-    
+
+        from torcheeg.datasets import SEEDFeatureDataset
+        from torcheeg import transforms
+        from torcheeg.datasets.constants.emotion_recognition.seed import SEED_ADJACENCY_MATRIX
+        from torcheeg.transforms.pyg import ToG
+        
         dataset = SEEDFeatureDataset(root_path='./Preprocessed_EEG',
                                      features=['de_movingAve'],
                                      online_transform=ToG(SEED_ADJACENCY_MATRIX),
diff --git a/torcheeg/datasets/module/emotion_recognition/seed_iv.py b/torcheeg/datasets/module/emotion_recognition/seed_iv.py
index 1ffc86f..371e6f3 100644
--- a/torcheeg/datasets/module/emotion_recognition/seed_iv.py
+++ b/torcheeg/datasets/module/emotion_recognition/seed_iv.py
@@ -13,7 +13,7 @@ class SEEDIVDataset(BaseDataset):
 
     - Author: Zheng et al.
     - Year: 2018
-    - Download URL: https://ieeexplore.ieee.org/abstract/document/8283814
+    - Download URL: https://bcmi.sjtu.edu.cn/home/seed/seed-iv.html
     - Reference: Zheng W L, Liu W, Lu Y, et al. Emotionmeter: A multimodal framework for recognizing human emotions[J]. IEEE transactions on cybernetics, 2018, 49(3): 1110-1122.
     - Stimulus: 168 film clips.
     - Signals: Electroencephalogram (62 channels at 200Hz) and eye movement data of 15 subjects (8 females). Each subject conducts the experiments in three sessions, and each session contains 24 trials (6 per emotional category) totally 15 people x 3 sessions x 24 trials.
@@ -31,10 +31,14 @@ class SEEDIVDataset(BaseDataset):
 
     .. code-block:: python
 
+        from torcheeg.datasets import SEEDIVDataset
+        from torcheeg import transforms
+        from torcheeg.datasets.constants.emotion_recognition.seed import SEED_IV_CHANNEL_LOCATION_DICT
+        
         dataset = SEEDIVDataset(root_path='./eeg_raw_data',
                                 offline_transform=transforms.Compose([
                                     transforms.BandDifferentialEntropy(),
-                                    transforms.ToGrid(SEEDIV_CHANNEL_LOCATION_DICT)
+                                    transforms.ToGrid(SEED_IV_CHANNEL_LOCATION_DICT)
                                 ]),
                                 online_transform=transforms.ToTensor(),
                                 label_transform=transforms.Compose([
@@ -50,6 +54,9 @@ class SEEDIVDataset(BaseDataset):
 
     .. code-block:: python
 
+        from torcheeg.datasets import SEEDIVDataset
+        from torcheeg import transforms
+
         dataset = SEEDIVDataset(root_path='./eeg_raw_data',
                                 online_transform=transforms.Compose([
                                     transforms.ToTensor(),
@@ -64,7 +71,12 @@ class SEEDIVDataset(BaseDataset):
     An example dataset for GNN-based methods:
 
     .. code-block:: python
-    
+
+        from torcheeg.datasets import SEEDIVDataset
+        from torcheeg import transforms
+        from torcheeg.datasets.constants.emotion_recognition.seed import SEEDIV_ADJACENCY_MATRIX
+        from torcheeg.transforms.pyg import ToG
+        
         dataset = SEEDIVDataset(root_path='./eeg_raw_data',
                                 online_transform=transforms.Compose([
                                     ToG(SEED_IV_ADJACENCY_MATRIX)
diff --git a/torcheeg/datasets/module/emotion_recognition/seed_iv_feature.py b/torcheeg/datasets/module/emotion_recognition/seed_iv_feature.py
index d663901..ae738e2 100644
--- a/torcheeg/datasets/module/emotion_recognition/seed_iv_feature.py
+++ b/torcheeg/datasets/module/emotion_recognition/seed_iv_feature.py
@@ -14,7 +14,7 @@ class SEEDIVFeatureDataset(BaseDataset):
 
     - Author: Zheng et al.
     - Year: 2018
-    - Download URL: https://ieeexplore.ieee.org/abstract/document/8283814
+    - Download URL: https://bcmi.sjtu.edu.cn/home/seed/seed-iv.html
     - Reference: Zheng W L, Liu W, Lu Y, et al. Emotionmeter: A multimodal framework for recognizing human emotions[J]. IEEE transactions on cybernetics, 2018, 49(3): 1110-1122.
     - Stimulus: 168 film clips.
     - Signals: Electroencephalogram (62 channels at 200Hz) and eye movement data of 15 subjects (8 females). Each subject conducts the experiments in three sessions, and each session contains 24 trials (6 per emotional category) totally 15 people x 3 sessions x 24 trials.
@@ -31,9 +31,13 @@ class SEEDIVFeatureDataset(BaseDataset):
 
     .. code-block:: python
 
+        from torcheeg.datasets import SEEDIVFeatureDataset
+        from torcheeg import transforms
+        from torcheeg.datasets.constants.emotion_recognition.seed import SEED_IV_CHANNEL_LOCATION_DICT
+        
         dataset = SEEDIVFeatureDataset(root_path='./eeg_feature_smooth',
                                        features=['de_movingAve'],
-                                       offline_transform=transforms.ToGrid         (SEED_CHANNEL_LOCATION_DICT),
+                                       offline_transform=transforms.ToGrid         (SEED_IV_CHANNEL_LOCATION_DICT),
                                        online_transform=transforms.ToTensor(),
                                        label_transform=transforms.Select('emotion'))
         print(dataset[0])
@@ -44,7 +48,12 @@ class SEEDIVFeatureDataset(BaseDataset):
     An example dataset for GNN-based methods:
 
     .. code-block:: python
-    
+
+        from torcheeg.datasets import SEEDIVFeatureDataset
+        from torcheeg import transforms
+        from torcheeg.datasets.constants.emotion_recognition.seed import SEED_ADJACENCY_MATRIX
+        from torcheeg.transforms.pyg import ToG
+        
         dataset = SEEDIVFeatureDataset(root_path='./eeg_feature_smooth',
                                        features=['de_movingAve'],
                                        online_transform=ToG(SEED_ADJACENCY_MATRIX),
@@ -201,9 +210,9 @@ def process_record(feature: list = ['de_movingAve'],
 
                 # record meta info for each signal
                 record_info = {
-                    'start_at': i * 400,
+                    'start_at': i * 800,
                     'end_at': (i + 1) *
-                    400,  # The size of the sliding time windows for feature extraction is 4 seconds.
+                    800,  # The size of the sliding time windows for feature extraction is 4 seconds.
                     'clip_id': clip_id
                 }
                 record_info.update(trial_meta_info)
diff --git a/torcheeg/datasets/module/emotion_recognition/seed_v.py b/torcheeg/datasets/module/emotion_recognition/seed_v.py
new file mode 100644
index 0000000..c72b0d4
--- /dev/null
+++ b/torcheeg/datasets/module/emotion_recognition/seed_v.py
@@ -0,0 +1,321 @@
+import os
+from typing import Any, Callable, Dict, Tuple, Union
+
+import mne
+
+from ....utils import get_random_dir_path
+from ..base_dataset import BaseDataset
+
+mne.set_log_level('CRITICAL')
+
+
+class SEEDVDataset(BaseDataset):
+    r'''
+    The SEED-V dataset provided by the BCMI laboratory, which is led by Prof. Bao-Liang Lu. This class generates training samples and test samples according to the given parameters, and caches the generated results in a unified input and output format (IO). The relevant information of the dataset is as follows:
+
+    - Author: Liu et al.
+    - Year: 2021
+    - Download URL: https://bcmi.sjtu.edu.cn/home/seed/seed-v.html
+    - Reference: Liu W, Qiu J L, Zheng W L, et al. Comparing recognition performance and robustness of multimodal deep learning models for multimodal emotion recognition[J]. IEEE Transactions on Cognitive and Developmental Systems, 2021, 14(2): 715-729.
+    - Stimulus: 15 pieces of stimulating material.
+    - Signals: Electroencephalogram (62 channels at 200Hz) and eye movement data of 20 subjects (20 females). Each subject conducts the experiments in three sessions, and each session contains 15 trials (3 per emotional category) totally 20 people x 3 sessions x 15 trials.
+    - Rating: disgust (0), fear (1), sad (2), neutral (3), happy (4).
+
+    In order to use this dataset, the download folder :obj:`EEG_raw` is required, containing the following files:
+    
+    - 10_1_20180507.cnt
+    - 10_2_20180524.cnt
+    - 10_3_20180626.cnt
+    - ...
+    - 9_3_20180728.cnt
+
+    An example dataset for CNN-based methods:
+
+    .. code-block:: python
+
+        from torcheeg.datasets import SEEDVDataset
+        from torcheeg import transforms
+        from torcheeg.datasets.constants.emotion_recognition.seed import SEED_V_CHANNEL_LOCATION_DICT
+        
+        dataset = SEEDVDataset(root_path='./EEG_raw',
+                                offline_transform=transforms.Compose([
+                                    transforms.BandDifferentialEntropy(),
+                                    transforms.ToGrid(SEED_V_CHANNEL_LOCATION_DICT)
+                                ]),
+                                online_transform=transforms.ToTensor(),
+                                label_transform=transforms.Compose([
+                                    transforms.Select('emotion'),
+                                    transforms.Lambda(lambda x: x + 1)
+                                ]))
+        print(dataset[0])
+        # EEG signal (torch.Tensor[4, 9, 9]),
+        # coresponding baseline signal (torch.Tensor[4, 9, 9]),
+        # label (int)
+
+    Another example dataset for CNN-based methods:
+
+    .. code-block:: python
+
+        from torcheeg.datasets import SEEDVDataset
+        from torcheeg import transforms
+
+        dataset = SEEDVDataset(root_path='./EEG_raw',
+                                online_transform=transforms.Compose([
+                                    transforms.ToTensor(),
+                                    transforms.To2d()
+                                ]),
+                                label_transform=transforms.Select('emotion'))
+        print(dataset[0])
+        # EEG signal (torch.Tensor[62, 200]),
+        # coresponding baseline signal (torch.Tensor[62, 200]),
+        # label (int)
+
+    An example dataset for GNN-based methods:
+
+    .. code-block:: python
+
+        from torcheeg.datasets import SEEDVDataset
+        from torcheeg import transforms
+        from torcheeg.datasets.constants.emotion_recognition.seed import SEED_V_ADJACENCY_MATRIX
+        from torcheeg.transforms.pyg import ToG
+        
+        dataset = SEEDVDataset(root_path='./EEG_raw',
+                                online_transform=transforms.Compose([
+                                    ToG(SEED_V_ADJACENCY_MATRIX)
+                                ]),
+                                label_transform=transforms.Select('emotion'))
+        print(dataset[0])
+        # EEG signal (torch_geometric.data.Data),
+        # coresponding baseline signal (torch_geometric.data.Data),
+        # label (int)
+        
+    Args:
+        root_path (str): Downloaded data files in matlab (unzipped EEG_raw.zip) formats (default: :obj:`'./EEG_raw'`)
+        chunk_size (int): Number of data points included in each EEG chunk as training or test samples. If set to -1, the EEG signal of a trial is used as a sample of a chunk. (default: :obj:`800`)
+        overlap (int): The number of overlapping data points between different chunks when dividing EEG chunks. (default: :obj:`0`)
+        num_channel (int): Number of channels used, of which the first 62 channels are EEG signals. (default: :obj:`62`)
+        online_transform (Callable, optional): The transformation of the EEG signals and baseline EEG signals. The input is a :obj:`np.ndarray`, and the ouput is used as the first and second value of each element in the dataset. (default: :obj:`None`)
+        offline_transform (Callable, optional): The usage is the same as :obj:`online_transform`, but executed before generating IO intermediate results. (default: :obj:`None`)
+        label_transform (Callable, optional): The transformation of the label. The input is an information dictionary, and the ouput is used as the third value of each element in the dataset. (default: :obj:`None`)
+        before_trial (Callable, optional): The hook performed on the trial to which the sample belongs. It is performed before the offline transformation and thus typically used to implement context-dependent sample transformations, such as moving averages, etc. The input of this hook function is a 2D EEG signal with shape (number of electrodes, number of data points), whose ideal output shape is also (number of electrodes, number of data points).
+        after_trial (Callable, optional): The hook performed on the trial to which the sample belongs. It is performed after the offline transformation and thus typically used to implement context-dependent sample transformations, such as moving averages, etc. The input and output of this hook function should be a sequence of dictionaries representing a sequence of EEG samples. Each dictionary contains two key-value pairs, indexed by :obj:`eeg` (the EEG signal matrix) and :obj:`key` (the index in the database) respectively.
+        io_path (str): The path to generated unified data IO, cached as an intermediate result. If set to None, a random path will be generated. (default: :obj:`None`)
+        io_size (int): Maximum size database may grow to; used to size the memory mapping. If database grows larger than ``map_size``, an exception will be raised and the user must close and reopen. (default: :obj:`1048576`)
+        io_mode (str): Storage mode of EEG signal. When io_mode is set to :obj:`lmdb`, TorchEEG provides an efficient database (LMDB) for storing EEG signals. LMDB may not perform well on limited operating systems, where a file system based EEG signal storage is also provided. When io_mode is set to :obj:`pickle`, pickle-based persistence files are used. When io_mode is set to :obj:`memory`, memory are used. (default: :obj:`lmdb`)
+        num_worker (int): Number of subprocesses to use for data loading. 0 means that the data will be loaded in the main process. (default: :obj:`0`)
+        verbose (bool): Whether to display logs during processing, such as progress bars, etc. (default: :obj:`True`)    
+    '''
+
+    def __init__(self,
+                 root_path: str = './EEG_raw',
+                 chunk_size: int = 800,
+                 overlap: int = 0,
+                 num_channel: int = 62,
+                 online_transform: Union[None, Callable] = None,
+                 offline_transform: Union[None, Callable] = None,
+                 label_transform: Union[None, Callable] = None,
+                 before_trial: Union[None, Callable] = None,
+                 after_trial: Union[Callable, None] = None,
+                 after_session: Union[Callable, None] = None,
+                 after_subject: Union[Callable, None] = None,
+                 io_path: Union[None, str] = None,
+                 io_size: int = 1048576,
+                 io_mode: str = 'lmdb',
+                 num_worker: int = 0,
+                 verbose: bool = True):
+        if io_path is None:
+            io_path = get_random_dir_path(dir_prefix='datasets')
+
+        # pass all arguments to super class
+        params = {
+            'root_path': root_path,
+            'chunk_size': chunk_size,
+            'overlap': overlap,
+            'num_channel': num_channel,
+            'online_transform': online_transform,
+            'offline_transform': offline_transform,
+            'label_transform': label_transform,
+            'before_trial': before_trial,
+            'after_trial': after_trial,
+            'after_session': after_session,
+            'after_subject': after_subject,
+            'io_path': io_path,
+            'io_size': io_size,
+            'io_mode': io_mode,
+            'num_worker': num_worker,
+            'verbose': verbose
+        }
+        super().__init__(**params)
+        # save all arguments to __dict__
+        self.__dict__.update(params)
+
+    @staticmethod
+    def process_record(file: Any = None,
+                       chunk_size: int = 800,
+                       overlap: int = 0,
+                       num_channel: int = 62,
+                       before_trial: Union[None, Callable] = None,
+                       offline_transform: Union[None, Callable] = None,
+                       **kwargs):
+        file_name = os.path.basename(file)
+        # split with _, the first part is the subject_id, the second part is the session_id, the third part is the date
+        subject_id, session_id, date = file_name.split('_')[:3]
+
+        labels = [[4, 1, 3, 2, 0, 4, 1, 3, 2, 0, 4, 1, 3, 2, 0],
+                  [2, 1, 3, 0, 4, 4, 0, 3, 2, 1, 3, 4, 1, 2, 0],
+                  [2, 1, 3, 0, 4, 4, 0, 3, 2, 1, 3, 4, 1, 2, 0]]
+
+        trial_labels = labels[int(session_id) - 1]
+
+        eeg_raw = mne.io.read_raw_cnt(file)
+
+        useless_ch = ['M1', 'M2', 'VEO', 'HEO']
+        eeg_raw.drop_channels(useless_ch)
+
+        data_matrix = eeg_raw.get_data()
+
+        start_end_list = [
+            {
+                'start_seconds': [
+                    30, 132, 287, 555, 773, 982, 1271, 1628, 1730, 2025, 2227,
+                    2435, 2667, 2932, 3204
+                ],
+                'end_seconds': [
+                    102, 228, 524, 742, 920, 1240, 1568, 1697, 1994, 2166, 2401,
+                    2607, 2901, 3172, 3359
+                ]
+            },
+            {
+                'start_seconds': [
+                    30, 299, 548, 646, 836, 1000, 1091, 1392, 1657, 1809, 1966,
+                    2186, 2333, 2490, 2741
+                ],
+                'end_seconds': [
+                    267, 488, 614, 773, 967, 1059, 1331, 1622, 1777, 1908, 2153,
+                    2302, 2428, 2709, 2817
+                ]
+            },
+            {
+                'start_seconds': [
+                    30, 353, 478, 674, 825, 908, 1200, 1346, 1451, 1711, 2055,
+                    2307, 2457, 2726, 2888
+                ],
+                'end_seconds': [
+                    321, 418, 643, 764, 877, 1147, 1284, 1418, 1679, 1996, 2275,
+                    2425, 2664, 2857, 3066
+                ]
+            },
+        ]
+        start_seconds = start_end_list[int(session_id) - 1]['start_seconds']
+        end_seconds = start_end_list[int(session_id) - 1]['end_seconds']
+
+        write_pointer = 0
+
+        for trial_id, (start_second,
+                       end_second) in enumerate(zip(start_seconds,
+                                                    end_seconds)):
+
+            trial_meta_info = {
+                'subject_id': subject_id,
+                'session_id': session_id,
+                'date': date,
+                'trial_id': trial_id,
+                'emotion': trial_labels[trial_id]
+            }
+
+            trial_samples = data_matrix[:,
+                                        start_second * 1000:end_second * 1000]
+
+            # downsample to 200Hz
+            trial_samples = trial_samples[:, ::5]
+
+            #  EEG data are then processed with a bandpass filter between 1 Hz and 75 Hz.
+            trial_samples = mne.filter.filter_data(trial_samples,
+                                                   sfreq=200,
+                                                   l_freq=1,
+                                                   h_freq=75)
+
+            if not before_trial is None:
+                trial_samples = before_trial(trial_samples)
+
+            # extract experimental signals
+            start_at = 0
+            if chunk_size <= 0:
+                dynamic_chunk_size = trial_samples.shape[1] - start_at
+            else:
+                dynamic_chunk_size = chunk_size
+
+            # chunk with chunk size
+            end_at = dynamic_chunk_size
+            # calculate moving step
+            step = dynamic_chunk_size - overlap
+
+            while end_at <= trial_samples.shape[1]:
+                clip_sample = trial_samples[:num_channel, start_at:end_at]
+
+                t_eeg = clip_sample
+                if not offline_transform is None:
+                    t_eeg = offline_transform(eeg=clip_sample)['eeg']
+
+                clip_id = f'{file_name}_{write_pointer}'
+                write_pointer += 1
+
+                record_info = {
+                    'clip_id': clip_id,
+                    'start_at': start_at,
+                    'end_at': end_at
+                }
+                record_info.update(trial_meta_info)
+
+                yield {'eeg': t_eeg, 'key': clip_id, 'info': record_info}
+
+                start_at = start_at + step
+                end_at = start_at + dynamic_chunk_size
+
+    def set_records(self, root_path: str = './EEG_raw', **kwargs):
+        assert os.path.exists(
+            root_path
+        ), f'root_path ({root_path}) does not exist. Please download the dataset and set the root_path to the downloaded path.'
+
+        file_list = os.listdir(root_path)
+        file_list = [
+            os.path.join(root_path, file) for file in file_list
+            if file.endswith('.cnt')
+        ]
+        return file_list
+
+    def __getitem__(self, index: int) -> Tuple[any, any, int, int, int]:
+        info = self.read_info(index)
+
+        eeg_index = str(info['clip_id'])
+        eeg_record = str(info['_record_id'])
+        eeg = self.read_eeg(eeg_record, eeg_index)
+
+        signal = eeg
+        label = info
+
+        if self.online_transform:
+            signal = self.online_transform(eeg=eeg)['eeg']
+
+        if self.label_transform:
+            label = self.label_transform(y=info)['y']
+
+        return signal, label
+
+    @property
+    def repr_body(self) -> Dict:
+        return dict(
+            super().repr_body, **{
+                'root_path': self.root_path,
+                'chunk_size': self.chunk_size,
+                'overlap': self.overlap,
+                'num_channel': self.num_channel,
+                'online_transform': self.online_transform,
+                'offline_transform': self.offline_transform,
+                'label_transform': self.label_transform,
+                'before_trial': self.before_trial,
+                'after_trial': self.after_trial,
+                'num_worker': self.num_worker,
+                'verbose': self.verbose,
+                'io_size': self.io_size
+            })
diff --git a/torcheeg/datasets/module/emotion_recognition/seed_v_feature.py b/torcheeg/datasets/module/emotion_recognition/seed_v_feature.py
new file mode 100644
index 0000000..a0a4d03
--- /dev/null
+++ b/torcheeg/datasets/module/emotion_recognition/seed_v_feature.py
@@ -0,0 +1,222 @@
+import os
+import pickle as pkl
+from typing import Any, Callable, Dict, Tuple, Union
+
+import numpy as np
+
+from ....utils import get_random_dir_path
+from ..base_dataset import BaseDataset
+
+
+class SEEDVFeatureDataset(BaseDataset):
+    r'''
+    The SEED-V dataset provided by the BCMI laboratory, which is led by Prof. Bao-Liang Lu. Since the SEED dataset provides features based on matlab, this class implements the processing of these feature files to initialize the dataset. The relevant information of the dataset is as follows:
+
+    - Author: Liu et al.
+    - Year: 2021
+    - Download URL: https://bcmi.sjtu.edu.cn/home/seed/seed-v.html
+    - Reference: Liu W, Qiu J L, Zheng W L, et al. Comparing recognition performance and robustness of multimodal deep learning models for multimodal emotion recognition[J]. IEEE Transactions on Cognitive and Developmental Systems, 2021, 14(2): 715-729.
+    - Stimulus: 15 pieces of stimulating material.
+    - Signals: Electroencephalogram (62 channels at 200Hz) and eye movement data of 20 subjects (20 females). Each subject conducts the experiments in three sessions, and each session contains 15 trials (3 per emotional category) totally 20 people x 3 sessions x 15 trials.
+    - Rating: disgust (0), fear (1), sad (2), neutral (3), happy (4).
+
+    In order to use this dataset, the download folder :obj:`EEG_DE_features` is required, containing the following folder:
+    
+    - 1_123.npz
+    - 2_123.npz
+    - ...
+
+    An example dataset for CNN-based methods:
+
+    .. code-block:: python
+
+        from torcheeg.datasets import SEEDVFeatureDataset
+        from torcheeg import transforms
+        from torcheeg.datasets.constants.emotion_recognition.seed_v import SEED_V_CHANNEL_LOCATION_DICT
+        
+        dataset = SEEDVFeatureDataset(root_path='./EEG_DE_features',
+                                       offline_transform=transforms.ToGrid         (SEED_V_CHANNEL_LOCATION_DICT),
+                                       online_transform=transforms.ToTensor(),
+                                       label_transform=transforms.Select('emotion'))
+        print(dataset[0])
+        # EEG signal (torch.Tensor[5, 9, 9]),
+        # coresponding baseline signal (torch.Tensor[5, 9, 9]),
+        # label (int)
+
+    An example dataset for GNN-based methods:
+
+    .. code-block:: python
+
+        from torcheeg.datasets import SEEDVFeatureDataset
+        from torcheeg import transforms
+        from torcheeg.datasets.constants.emotion_recognition.seed import SEED_ADJACENCY_MATRIX
+        from torcheeg.transforms.pyg import ToG
+        
+        dataset = SEEDVFeatureDataset(root_path='./EEG_DE_features',
+                                       online_transform=ToG(SEED_ADJACENCY_MATRIX),
+                                       label_transform=transforms.Select('emotion'))
+        print(dataset[0])
+        # EEG signal (torch_geometric.data.Data),
+        # coresponding baseline signal (torch_geometric.data.Data),
+        # label (int)
+        
+    Args:
+        root_path (str): Downloaded data files in matlab (unzipped ExtractedFeatures.zip) formats (default: :obj:`'./ExtractedFeatures'`)
+        num_channel (int): Number of channels used, of which the first 62 channels are EEG signals. (default: :obj:`62`)
+        online_transform (Callable, optional): The transformation of the EEG signals and baseline EEG signals. The input is a :obj:`np.ndarray`, and the ouput is used as the first and second value of each element in the dataset. (default: :obj:`None`)
+        offline_transform (Callable, optional): The usage is the same as :obj:`online_transform`, but executed before generating IO intermediate results. (default: :obj:`None`)
+        label_transform (Callable, optional): The transformation of the label. The input is an information dictionary, and the ouput is used as the third value of each element in the dataset. (default: :obj:`None`)
+        before_trial (Callable, optional): The hook performed on the trial to which the sample belongs. It is performed before the offline transformation and thus typically used to implement context-dependent sample transformations, such as moving averages, etc. The input of this hook function is a 3D EEG signal with shape (number of windows, number of electrodes, number of features), whose ideal output shape is also (number of windows, number of electrodes, number of features).
+        after_trial (Callable, optional): The hook performed on the trial to which the sample belongs. It is performed after the offline transformation and thus typically used to implement context-dependent sample transformations, such as moving averages, etc. The input and output of this hook function should be a sequence of dictionaries representing a sequence of EEG samples. Each dictionary contains two key-value pairs, indexed by :obj:`eeg` (the EEG signal matrix) and :obj:`key` (the index in the database) respectively.
+        io_path (str): The path to generated unified data IO, cached as an intermediate result. If set to None, a random path will be generated. (default: :obj:`None`)
+        io_size (int): Maximum size database may grow to; used to size the memory mapping. If database grows larger than ``map_size``, an exception will be raised and the user must close and reopen. (default: :obj:`1048576`)
+        io_mode (str): Storage mode of EEG signal. When io_mode is set to :obj:`lmdb`, TorchEEG provides an efficient database (LMDB) for storing EEG signals. LMDB may not perform well on limited operating systems, where a file system based EEG signal storage is also provided. When io_mode is set to :obj:`pickle`, pickle-based persistence files are used. When io_mode is set to :obj:`memory`, memory are used. (default: :obj:`lmdb`)
+        num_worker (int): Number of subprocesses to use for data loading. 0 means that the data will be loaded in the main process. (default: :obj:`0`)
+        verbose (bool): Whether to display logs during processing, such as progress bars, etc. (default: :obj:`True`)    
+    '''
+
+    def __init__(self,
+                 root_path: str = './EEG_DE_features',
+                 num_channel: int = 62,
+                 online_transform: Union[None, Callable] = None,
+                 offline_transform: Union[None, Callable] = None,
+                 label_transform: Union[None, Callable] = None,
+                 before_trial: Union[None, Callable] = None,
+                 after_trial: Union[Callable, None] = None,
+                 after_session: Union[Callable, None] = None,
+                 after_subject: Union[Callable, None] = None,
+                 io_path: Union[None, str] = None,
+                 io_size: int = 1048576,
+                 io_mode: str = 'lmdb',
+                 num_worker: int = 0,
+                 verbose: bool = True):
+        if io_path is None:
+            io_path = get_random_dir_path(dir_prefix='datasets')
+
+        # pass all arguments to super class
+        params = {
+            'root_path': root_path,
+            'num_channel': num_channel,
+            'online_transform': online_transform,
+            'offline_transform': offline_transform,
+            'label_transform': label_transform,
+            'before_trial': before_trial,
+            'after_trial': after_trial,
+            'after_session': after_session,
+            'after_subject': after_subject,
+            'io_path': io_path,
+            'io_size': io_size,
+            'io_mode': io_mode,
+            'num_worker': num_worker,
+            'verbose': verbose
+        }
+        super().__init__(**params)
+        # save all arguments to __dict__
+        self.__dict__.update(params)
+
+    @staticmethod
+    def process_record(num_channel: int = 62,
+                       offline_transform: Union[None, Callable] = None,
+                       before_trial: Union[None, Callable] = None,
+                       file: Any = None,
+                       **kwargs):
+        # get file name from path
+        file_name = os.path.basename(file)
+
+        # split with '_', the fist part is subject id
+        subject_id = file_name.split('_')[0]
+
+        # load the file
+        data_npz = np.load(file)
+        data = pkl.loads(data_npz['data'])
+        label = pkl.loads(data_npz['label'])
+
+        write_pointer = 0
+
+        # loop all trials
+        for global_trial_id in range(len(data.keys())):
+            trial_samples = data[list(data.keys())[global_trial_id]]
+            trial_labels = label[global_trial_id]
+
+            # split trial to 3 sessions
+            session_id = global_trial_id // 15
+            trial_id = global_trial_id % 15
+
+            trial_meta_info = {
+                'subject_id': subject_id,
+                'session_id': session_id,
+                'trial_id': trial_id
+            }
+
+            if before_trial:
+                trial_samples = before_trial(trial_samples)
+
+            # loop all clips
+            for i in range(trial_samples.shape[0]):
+                clip_sample = trial_samples[i]
+                clip_label = trial_labels[i]
+
+                clip_id = f'{file_name}_{write_pointer}'
+                write_pointer += 1
+
+                record_info = {
+                    'start_at': i * 800,
+                    'end_at': (i + 1) *
+                    800,  # The size of the sliding time windows for feature 
+                    'clip_id': clip_id,
+                    'emotion': int(clip_label)
+                }
+                record_info.update(trial_meta_info)
+
+                t_eeg = clip_sample.reshape(62, 5)[:num_channel]
+                if not offline_transform is None:
+                    t_eeg = offline_transform(eeg=t_eeg)['eeg']
+
+                yield {'eeg': t_eeg, 'key': clip_id, 'info': record_info}
+
+    def set_records(self, root_path: str = './EEG_DE_features', **kwargs):
+        assert os.path.exists(
+            root_path
+        ), f'root_path ({root_path}) does not exist. Please download the dataset and set the root_path to the downloaded path.'
+
+        file_path_list = os.listdir(root_path)
+        file_path_list = [
+            os.path.join(root_path, file_path) for file_path in file_path_list
+            if file_path.endswith('.npz')
+        ]
+
+        return file_path_list
+
+    def __getitem__(self, index: int) -> Tuple[any, any, int, int, int]:
+        info = self.read_info(index)
+
+        eeg_index = str(info['clip_id'])
+        eeg_record = str(info['_record_id'])
+        eeg = self.read_eeg(eeg_record, eeg_index)
+
+        signal = eeg
+        label = info
+
+        if self.online_transform:
+            signal = self.online_transform(eeg=eeg)['eeg']
+
+        if self.label_transform:
+            label = self.label_transform(y=info)['y']
+
+        return signal, label
+
+    @property
+    def repr_body(self) -> Dict:
+        return dict(
+            super().repr_body, **{
+                'root_path': self.root_path,
+                'num_channel': self.num_channel,
+                'online_transform': self.online_transform,
+                'offline_transform': self.offline_transform,
+                'label_transform': self.label_transform,
+                'before_trial': self.before_trial,
+                'after_trial': self.after_trial,
+                'num_worker': self.num_worker,
+                'verbose': self.verbose,
+                'io_size': self.io_size
+            })
diff --git a/torcheeg/datasets/module/folder_dataset.py b/torcheeg/datasets/module/folder_dataset.py
index 7e65409..2c43523 100644
--- a/torcheeg/datasets/module/folder_dataset.py
+++ b/torcheeg/datasets/module/folder_dataset.py
@@ -48,7 +48,10 @@ class FolderDataset(BaseDataset):
     An example dataset for GNN-based methods:
 
     .. code-block:: python
-    
+
+        from torcheeg.datasets import FolderDataset
+        from torcheeg import transforms
+
         sfreq = 128  # Sampling rate
         n_channels = 14  # Number of channels
         duration = 5  # Data collected for 5 seconds
diff --git a/torcheeg/datasets/module/motor_imagery/bciciv_2a.py b/torcheeg/datasets/module/motor_imagery/bciciv_2a.py
index 916fe33..3fade39 100644
--- a/torcheeg/datasets/module/motor_imagery/bciciv_2a.py
+++ b/torcheeg/datasets/module/motor_imagery/bciciv_2a.py
@@ -32,6 +32,9 @@ class BCICIV2aDataset(BaseDataset):
 
     .. code-block:: python
 
+        from torcheeg.datasets import BCICIV2aDataset
+        from torcheeg import transforms
+
         dataset = BCICIV2aDataset(root_path='./BCICIV_2a_mat',
                                   online_transform=transforms.Compose([
                                       transforms.To2d(),
diff --git a/torcheeg/datasets/module/personal_identification/m3cv.py b/torcheeg/datasets/module/personal_identification/m3cv.py
index 5458967..c06ee27 100644
--- a/torcheeg/datasets/module/personal_identification/m3cv.py
+++ b/torcheeg/datasets/module/personal_identification/m3cv.py
@@ -29,7 +29,10 @@ class M3CVDataset(BaseDataset):
     An example dataset for CNN-based methods:
 
     .. code-block:: python
-    
+
+        from torcheeg.datasets import M3CVDataset
+        from torcheeg import transforms
+
         dataset = M3CVDataset(root_path='./aistudio',
                               offline_transform=transforms.Compose([
                                   transforms.BandDifferentialEntropy(),
@@ -49,6 +52,9 @@ class M3CVDataset(BaseDataset):
 
     .. code-block:: python
 
+        from torcheeg.datasets import M3CVDataset
+        from torcheeg import transforms
+    
         dataset = M3CVDataset(io_path=f'./m3cv',
                               root_path='./aistudio',
                               online_transform=transforms.Compose([
@@ -67,7 +73,12 @@ class M3CVDataset(BaseDataset):
     An example dataset for GNN-based methods:
 
     .. code-block:: python
-    
+
+        from torcheeg.datasets import M3CVDataset
+        from torcheeg import transforms
+        from torcheeg.datasets.constants.personal_identification.m3cv import M3CV_ADJACENCY_MATRIX
+        from torcheeg.transforms.pyg import ToG
+        
         dataset = M3CVDataset(io_path=f'./m3cv',
                               root_path='./aistudio',
                               online_transform=transforms.Compose([
diff --git a/torcheeg/datasets/module/sleep_stage_detection/sleep_edfx.py b/torcheeg/datasets/module/sleep_stage_detection/sleep_edfx.py
index 37da960..4d12401 100644
--- a/torcheeg/datasets/module/sleep_stage_detection/sleep_edfx.py
+++ b/torcheeg/datasets/module/sleep_stage_detection/sleep_edfx.py
@@ -31,7 +31,10 @@ class SleepEDFxDataset(BaseDataset):
     An example dataset for CNN-based methods:
 
     .. code-block:: python
-    
+
+        from torcheeg.datasets import SleepEDFxDataset
+        from torcheeg import transforms
+        
         dataset = SleepEDFxDataset(root_path="./sleep-edf-database-expanded-1.0.0",
                            num_channels=4,
                            chunk_size=3000,
diff --git a/torcheeg/datasets/module/ssvep/tsu_benchmark.py b/torcheeg/datasets/module/ssvep/tsu_benchmark.py
index 9fff4ba..9d11e7e 100644
--- a/torcheeg/datasets/module/ssvep/tsu_benchmark.py
+++ b/torcheeg/datasets/module/ssvep/tsu_benchmark.py
@@ -33,6 +33,10 @@ class TSUBenckmarkDataset(BaseDataset):
 
     .. code-block:: python
 
+        from torcheeg.datasets import TSUBenckmarkDataset
+        from torcheeg import transforms
+        from torcheeg.datasets.constants.ssvep.tsubenchmark import TSUBenckmark_CHANNEL_LOCATION_DICT
+
         dataset = TSUBenckmarkDataset(root_path='./TSUBenchmark',
                                       offline_transform=transforms.Compose([
                                           transforms.BandDifferentialEntropy(),
diff --git a/torcheeg/model_selection/k_fold.py b/torcheeg/model_selection/k_fold.py
index 612b74a..bf8341f 100644
--- a/torcheeg/model_selection/k_fold.py
+++ b/torcheeg/model_selection/k_fold.py
@@ -28,6 +28,11 @@ class KFold:
 
     .. code-block:: python
 
+        from torcheeg.model_selection import KFold
+        from torcheeg.datasets import DEAPDataset
+        from torcheeg import transforms
+        from torcheeg.utils import DataLoader
+
         cv = KFold(n_splits=5, shuffle=True)
         dataset = DEAPDataset(root_path='./data_preprocessed_python',
                               online_transform=transforms.Compose([
diff --git a/torcheeg/model_selection/k_fold_cross_subject.py b/torcheeg/model_selection/k_fold_cross_subject.py
index b0a5bb1..ec47684 100644
--- a/torcheeg/model_selection/k_fold_cross_subject.py
+++ b/torcheeg/model_selection/k_fold_cross_subject.py
@@ -27,6 +27,11 @@ class KFoldCrossSubject:
 
     .. code-block:: python
 
+        from torcheeg.model_selection import KFoldCrossSubject
+        from torcheeg.datasets import DEAPDataset
+        from torcheeg import transforms
+        from torcheeg.utils import DataLoader
+
         cv = KFoldCrossSubject(n_splits=5, shuffle=True)
         dataset = DEAPDataset(root_path='./data_preprocessed_python',
                               online_transform=transforms.Compose([
diff --git a/torcheeg/model_selection/k_fold_cross_trial.py b/torcheeg/model_selection/k_fold_cross_trial.py
index 5590e24..7649835 100644
--- a/torcheeg/model_selection/k_fold_cross_trial.py
+++ b/torcheeg/model_selection/k_fold_cross_trial.py
@@ -28,6 +28,11 @@ class KFoldCrossTrial:
 
     .. code-block:: python
 
+        from torcheeg.model_selection import KFoldCrossTrial
+        from torcheeg.datasets import DEAPDataset
+        from torcheeg import transforms
+        from torcheeg.utils import DataLoader
+
         cv = KFoldCrossTrial(n_splits=5, shuffle=True)
         dataset = DEAPDataset(root_path='./data_preprocessed_python',
                               online_transform=transforms.Compose([
diff --git a/torcheeg/model_selection/k_fold_groupby_trial.py b/torcheeg/model_selection/k_fold_groupby_trial.py
index 4e9edd7..f5445f0 100644
--- a/torcheeg/model_selection/k_fold_groupby_trial.py
+++ b/torcheeg/model_selection/k_fold_groupby_trial.py
@@ -28,6 +28,11 @@ class KFoldGroupbyTrial:
 
     .. code-block:: python
 
+        from torcheeg.model_selection import KFoldGroupbyTrial
+        from torcheeg.datasets import DEAPDataset
+        from torcheeg import transforms
+        from torcheeg.utils import DataLoader
+
         cv = KFoldGroupbyTrial(n_splits=5, shuffle=False)
         dataset = DEAPDataset(root_path='./data_preprocessed_python',
                               online_transform=transforms.Compose([
diff --git a/torcheeg/model_selection/k_fold_per_subject.py b/torcheeg/model_selection/k_fold_per_subject.py
index df12266..9950557 100644
--- a/torcheeg/model_selection/k_fold_per_subject.py
+++ b/torcheeg/model_selection/k_fold_per_subject.py
@@ -25,6 +25,11 @@ class KFoldPerSubject:
 
     .. code-block:: python
 
+        from torcheeg.datasets import DEAPDataset
+        from torcheeg import transforms
+        from torcheeg.model_selection import KFoldPerSubject
+        from torcheeg.utils import DataLoader
+
         cv = KFoldPerSubject(n_splits=5, shuffle=True)
         dataset = DEAPDataset(root_path='./data_preprocessed_python',
                               online_transform=transforms.Compose([
@@ -47,6 +52,11 @@ class KFoldPerSubject:
 
     .. code-block:: python
 
+        from torcheeg.datasets import DEAPDataset
+        from torcheeg import transforms
+        from torcheeg.model_selection import KFoldPerSubject
+        from torcheeg.utils import DataLoader
+
         cv = KFoldPerSubject(n_splits=5, shuffle=True)
         dataset = DEAPDataset(root_path='./data_preprocessed_python',
                               online_transform=transforms.Compose([
diff --git a/torcheeg/model_selection/k_fold_per_subject_cross_trial.py b/torcheeg/model_selection/k_fold_per_subject_cross_trial.py
index 69d6f2f..f43bf5a 100644
--- a/torcheeg/model_selection/k_fold_per_subject_cross_trial.py
+++ b/torcheeg/model_selection/k_fold_per_subject_cross_trial.py
@@ -26,6 +26,11 @@ class KFoldPerSubjectCrossTrial:
 
     .. code-block:: python
 
+        from torcheeg.model_selection import KFoldPerSubjectCrossTrial
+        from torcheeg.datasets import DEAPDataset
+        from torcheeg import transforms
+        from torcheeg.utils import DataLoader
+
         cv = KFoldPerSubjectCrossTrial(n_splits=5, shuffle=True)
         dataset = DEAPDataset(root_path='./data_preprocessed_python',
                               online_transform=transforms.Compose([
@@ -48,6 +53,11 @@ class KFoldPerSubjectCrossTrial:
 
     .. code-block:: python
 
+        from torcheeg.model_selection import KFoldPerSubjectCrossTrial
+        from torcheeg.datasets import DEAPDataset
+        from torcheeg import transforms
+        from torcheeg.utils import DataLoader
+
         cv = KFoldPerSubjectCrossTrial(n_splits=5, shuffle=True)
         dataset = DEAPDataset(root_path='./data_preprocessed_python',
                               online_transform=transforms.Compose([
diff --git a/torcheeg/model_selection/k_fold_per_subject_groupby_trial.py b/torcheeg/model_selection/k_fold_per_subject_groupby_trial.py
index 74e61f9..ecce230 100644
--- a/torcheeg/model_selection/k_fold_per_subject_groupby_trial.py
+++ b/torcheeg/model_selection/k_fold_per_subject_groupby_trial.py
@@ -26,6 +26,11 @@ class KFoldPerSubjectGroupbyTrial:
 
     .. code-block:: python
 
+        from torcheeg.model_selection import KFoldPerSubjectGroupbyTrial
+        from torcheeg.datasets import DEAPDataset
+        from torcheeg import transforms
+        from torcheeg.utils import DataLoader
+
         cv = KFoldPerSubjectGroupbyTrial(n_splits=5, shuffle=True)
         dataset = DEAPDataset(root_path='./data_preprocessed_python',
                               online_transform=transforms.Compose([
@@ -48,6 +53,11 @@ class KFoldPerSubjectGroupbyTrial:
 
     .. code-block:: python
 
+        from torcheeg.model_selection import KFoldPerSubjectGroupbyTrial
+        from torcheeg.datasets import DEAPDataset
+        from torcheeg import transforms
+        from torcheeg.utils import DataLoader
+
         cv = KFoldPerSubjectGroupbyTrial(n_splits=5, shuffle=True)
         dataset = DEAPDataset(root_path='./data_preprocessed_python',
                               online_transform=transforms.Compose([
diff --git a/torcheeg/model_selection/leave_one_subject_out.py b/torcheeg/model_selection/leave_one_subject_out.py
index 2a1b546..e795cc3 100644
--- a/torcheeg/model_selection/leave_one_subject_out.py
+++ b/torcheeg/model_selection/leave_one_subject_out.py
@@ -25,6 +25,11 @@ class LeaveOneSubjectOut:
     
     .. code-block:: python
 
+        from torcheeg.model_selection import LeaveOneSubjectOut
+        from torcheeg.datasets import DEAPDataset
+        from torcheeg import transforms
+        from torcheeg.utils import DataLoader
+
         cv = LeaveOneSubjectOut()
         dataset = DEAPDataset(root_path='./data_preprocessed_python',
                               online_transform=transforms.Compose([
diff --git a/torcheeg/model_selection/split.py b/torcheeg/model_selection/split.py
index a2d8d56..e661310 100644
--- a/torcheeg/model_selection/split.py
+++ b/torcheeg/model_selection/split.py
@@ -32,6 +32,11 @@ def train_test_split(dataset: BaseDataset,
 
     .. code-block:: python
 
+        from torcheeg.datasets import DEAPDataset
+        from torcheeg.model_selection import train_test_split
+        from torcheeg import transforms
+        from torcheeg.utils import DataLoader
+
         dataset = DEAPDataset(root_path='./data_preprocessed_python',
                               online_transform=transforms.Compose([
                                   transforms.To2d(),
diff --git a/torcheeg/model_selection/split_cross_trial.py b/torcheeg/model_selection/split_cross_trial.py
index 9727826..65d9a5f 100644
--- a/torcheeg/model_selection/split_cross_trial.py
+++ b/torcheeg/model_selection/split_cross_trial.py
@@ -32,6 +32,11 @@ def train_test_split_cross_trial(dataset: BaseDataset,
 
     .. code-block:: python
 
+        from torcheeg.datasets import DEAPDataset
+        from torcheeg.model_selection import train_test_split_cross_trial
+        from torcheeg import transforms
+        from torcheeg.utils import DataLoader
+
         dataset = DEAPDataset(root_path='./data_preprocessed_python',
                               online_transform=transforms.Compose([
                                   transforms.To2d(),
diff --git a/torcheeg/model_selection/split_groupby_trial.py b/torcheeg/model_selection/split_groupby_trial.py
index 309213c..c405f61 100644
--- a/torcheeg/model_selection/split_groupby_trial.py
+++ b/torcheeg/model_selection/split_groupby_trial.py
@@ -32,6 +32,11 @@ def train_test_split_groupby_trial(dataset: BaseDataset,
 
     .. code-block:: python
 
+        from torcheeg.datasets import DEAPDataset
+        from torcheeg.model_selection import train_test_split_groupby_trial
+        from torcheeg import transforms
+        from torcheeg.utils import DataLoader
+
         dataset = DEAPDataset(root_path='./data_preprocessed_python',
                               online_transform=transforms.Compose([
                                   transforms.To2d(),
diff --git a/torcheeg/model_selection/split_per_subject_cross_trial.py b/torcheeg/model_selection/split_per_subject_cross_trial.py
index 1bdc353..5678b14 100644
--- a/torcheeg/model_selection/split_per_subject_cross_trial.py
+++ b/torcheeg/model_selection/split_per_subject_cross_trial.py
@@ -32,6 +32,11 @@ def train_test_split_per_subject_cross_trial(dataset: BaseDataset,
 
     .. code-block:: python
 
+        from torcheeg.datasets import DEAPDataset
+        from torcheeg.model_selection import train_test_split_per_subject_cross_trial
+        from torcheeg import transforms
+        from torcheeg.utils import DataLoader
+
         dataset = DEAPDataset(root_path='./data_preprocessed_python',
                               online_transform=transforms.Compose([
                                   transforms.ToTensor(),
diff --git a/torcheeg/model_selection/split_per_subject_groupby_trial.py b/torcheeg/model_selection/split_per_subject_groupby_trial.py
index 136f1cf..ace2b49 100644
--- a/torcheeg/model_selection/split_per_subject_groupby_trial.py
+++ b/torcheeg/model_selection/split_per_subject_groupby_trial.py
@@ -33,6 +33,11 @@ def train_test_split_per_subject_groupby_trial(dataset: BaseDataset,
 
     .. code-block:: python
 
+        from torcheeg.datasets import DEAPDataset
+        from torcheeg.model_selection import train_test_split_per_subject_groupby_trial
+        from torcheeg import transforms
+        from torcheeg.utils import DataLoader
+
         dataset = DEAPDataset(root_path='./data_preprocessed_python',
                               online_transform=transforms.Compose([
                                   transforms.ToTensor(),
diff --git a/torcheeg/model_selection/subcategory.py b/torcheeg/model_selection/subcategory.py
index 237212d..919c5ad 100644
--- a/torcheeg/model_selection/subcategory.py
+++ b/torcheeg/model_selection/subcategory.py
@@ -21,6 +21,11 @@ class Subcategory:
 
     .. code-block:: python
 
+        from torcheeg.datasets import M3CVDataset
+        from torcheeg.model_selection import Subcategory
+        from torcheeg import transforms
+        from torcheeg.utils import DataLoader
+        
         cv = Subcategory()
         dataset = M3CVDataset(root_path='./aistudio',
                               online_transform=transforms.Compose(
diff --git a/torcheeg/models/cnn/ccnn.py b/torcheeg/models/cnn/ccnn.py
index e7faeaf..6e69912 100644
--- a/torcheeg/models/cnn/ccnn.py
+++ b/torcheeg/models/cnn/ccnn.py
@@ -16,19 +16,28 @@ class CCNN(nn.Module):
 
     .. code-block:: python
 
-        dataset = DEAPDataset(io_path=f'./deap',
-                    root_path='./data_preprocessed_python',
-                    offline_transform=transforms.Compose([
-                        transforms.BandDifferentialEntropy(),
-                        transforms.ToGrid(DEAP_CHANNEL_LOCATION_DICT)
-                    ]),
-                    online_transform=transforms.ToTensor(),
-                    label_transform=transforms.Compose([
-                        transforms.Select('valence'),
-                        transforms.Binary(5.0),
-                    ]))
+        from torcheeg.datasets import DEAPDataset
+        from torcheeg import transforms
+        from torcheeg.datasets.constants import DEAP_CHANNEL_LOCATION_DICT
+        from torcheeg.models import CCNN
+        from torch.utils.data import DataLoader
+
+        dataset = DEAPDataset(root_path='./data_preprocessed_python',
+                              offline_transform=transforms.Compose([
+                                  transforms.BandDifferentialEntropy(),
+                                  transforms.ToGrid(DEAP_CHANNEL_LOCATION_DICT)
+                              ]),
+                              online_transform=transforms.ToTensor(),
+                              label_transform=transforms.Compose([
+                                  transforms.Select('valence'),
+                                  transforms.Binary(5.0),
+                              ]))
+
         model = CCNN(num_classes=2, in_channels=4, grid_size=(9, 9))
 
+        x, y = next(iter(DataLoader(dataset, batch_size=64)))
+        model(x)
+
     Args:
         in_channels (int): The feature dimension of each electrode. (default: :obj:`4`)
         grid_size (tuple): Spatial dimensions of grid-like EEG representation. (default: :obj:`(9, 9)`)
diff --git a/torcheeg/models/cnn/eegnet.py b/torcheeg/models/cnn/eegnet.py
index 8b58530..bb2e09d 100644
--- a/torcheeg/models/cnn/eegnet.py
+++ b/torcheeg/models/cnn/eegnet.py
@@ -24,16 +24,21 @@ class EEGNet(nn.Module):
 
     .. code-block:: python
 
-        dataset = DEAPDataset(io_path=f'./deap',
-                    root_path='./data_preprocessed_python',
-                    online_transform=transforms.Compose([
-                        transforms.To2d(),
-                        transforms.ToTensor(),
-                    ]),
-                    label_transform=transforms.Compose([
-                        transforms.Select('valence'),
-                        transforms.Binary(5.0),
-                    ]))
+        from torcheeg.datasets import DEAPDataset
+        from torcheeg import transforms
+        from torcheeg.models import EEGNet
+        from torch.utils.data import DataLoader
+
+        dataset = DEAPDataset(root_path='./data_preprocessed_python',
+                              online_transform=transforms.Compose([
+                                  transforms.To2d(),
+                                  transforms.ToTensor(),
+                              ]),
+                              label_transform=transforms.Compose([
+                                  transforms.Select('valence'),
+                                  transforms.Binary(5.0),
+                              ]))
+
         model = EEGNet(chunk_size=128,
                        num_electrodes=32,
                        dropout=0.5,
@@ -44,6 +49,9 @@ class EEGNet(nn.Module):
                        D=2,
                        num_classes=2)
 
+        x, y = next(iter(DataLoader(dataset, batch_size=64)))
+        model(x)
+
     Args:
         chunk_size (int): Number of data points included in each EEG chunk, i.e., :math:`T` in the paper. (default: :obj:`151`)
         num_electrodes (int): The number of electrodes, i.e., :math:`C` in the paper. (default: :obj:`60`)
diff --git a/torcheeg/models/cnn/fbccnn.py b/torcheeg/models/cnn/fbccnn.py
index ec63628..9c4c1cb 100644
--- a/torcheeg/models/cnn/fbccnn.py
+++ b/torcheeg/models/cnn/fbccnn.py
@@ -15,18 +15,27 @@ class FBCCNN(nn.Module):
 
     .. code-block:: python
 
-        dataset = DEAPDataset(io_path=f'./deap',
-                    root_path='./data_preprocessed_python',
-                    online_transform=transforms.Compose([
-                        transforms.BandPowerSpectralDensity(),
-                        transforms.ToGrid(DEAP_CHANNEL_LOCATION_DICT)
-                    ]),
-                    label_transform=transforms.Compose([
-                        transforms.Select('valence'),
-                        transforms.Binary(5.0),
-                    ]))
+        from torcheeg.datasets import DEAPDataset
+        from torcheeg import transforms
+        from torcheeg.datasets.constants import DEAP_CHANNEL_LOCATION_DICT
+        from torcheeg.models import FBCCNN
+        from torch.utils.data import DataLoader
+
+        dataset = DEAPDataset(root_path='./data_preprocessed_python',
+                              online_transform=transforms.Compose([
+                                  transforms.BandPowerSpectralDensity(),
+                                  transforms.ToGrid(DEAP_CHANNEL_LOCATION_DICT)
+                              ]),
+                              label_transform=transforms.Compose([
+                                  transforms.Select('valence'),
+                                  transforms.Binary(5.0),
+                              ]))
+
         model = FBCCNN(num_classes=2, in_channels=4, grid_size=(9, 9))
 
+        x, y = next(iter(DataLoader(dataset, batch_size=64)))
+        model(x)
+
     Args:
         in_channels (int): The feature dimension of each electrode, i.e., :math:`N` in the paper. (default: :obj:`4`)
         grid_size (tuple): Spatial dimensions of grid-like EEG representation. (default: :obj:`(9, 9)`)
diff --git a/torcheeg/models/cnn/fbcnet.py b/torcheeg/models/cnn/fbcnet.py
index 7c35673..c46c11f 100644
--- a/torcheeg/models/cnn/fbcnet.py
+++ b/torcheeg/models/cnn/fbcnet.py
@@ -99,23 +99,31 @@ class FBCNet(nn.Module):
 
     .. code-block:: python
 
-        dataset = DEAPDataset(io_path=f'./deap',
-                    root_path='./data_preprocessed_python',
-                    chunk_size=512,
-                    num_baseline=1,
-                    baseline_chunk_size=512,
-                    offline_transform=transforms.BandSignal(),
-                    online_transform=transforms.ToTensor(),
-                    label_transform=transforms.Compose([
-                        transforms.Select('valence'),
-                        transforms.Binary(5.0),
-                    ]))
+        from torcheeg.datasets import DEAPDataset
+        from torcheeg import transforms
+        from torcheeg.models import FBCNet
+        from torch.utils.data import DataLoader
+
+        dataset = DEAPDataset(root_path='./data_preprocessed_python',
+                              chunk_size=512,
+                              num_baseline=1,
+                              baseline_chunk_size=512,
+                              offline_transform=transforms.BandSignal(),
+                              online_transform=transforms.ToTensor(),
+                              label_transform=transforms.Compose([
+                                  transforms.Select('valence'),
+                                  transforms.Binary(5.0),
+                              ]))
+
         model = FBCNet(num_classes=2,
                        num_electrodes=32,
                        chunk_size=512,
                        in_channels=4,
                        num_S=32)
 
+        x, y = next(iter(DataLoader(dataset, batch_size=64)))
+        model(x)
+
     Args:
         num_electrodes (int): The number of electrodes. (default: :obj:`28`)
         chunk_size (int): Number of data points included in each EEG chunk. (default: :obj:`1000`)
diff --git a/torcheeg/models/cnn/fbmsnet.py b/torcheeg/models/cnn/fbmsnet.py
index 25d0d07..2ee413b 100644
--- a/torcheeg/models/cnn/fbmsnet.py
+++ b/torcheeg/models/cnn/fbmsnet.py
@@ -2,7 +2,7 @@
 from typing import Tuple, Optional
 import torch
 import torch.nn as nn
-from .fbcnet import VarLayer, MaxLayer, StdLayer, LogVarLayer, LinearWithConstraint, MeanLayer, swish,Conv2dWithConstraint
+from .fbcnet import VarLayer, MaxLayer, StdLayer, LogVarLayer, LinearWithConstraint, MeanLayer, swish, Conv2dWithConstraint
 
 
 ## CONV_SAME_PADDING
@@ -17,6 +17,7 @@ def _same_pad_arg(input_size, kernel_size, stride, dilation, **_):
     pad_w = _calc_same_pad(iw, kw, stride[1], dilation[1])
     return [pad_w // 2, pad_w - pad_w // 2, pad_h // 2, pad_h - pad_h // 2]
 
+
 def conv2d_same(x,
                 weight: torch.Tensor,
                 bias: Optional[torch.Tensor] = None,
@@ -50,8 +51,8 @@ def __init__(self,
                              dilation, groups, bias)
 
     def forward(self, x):
-        return conv2d_same(x, self.weight, self.bias, self.stride,
-                           self.padding, self.dilation, self.groups)
+        return conv2d_same(x, self.weight, self.bias, self.stride, self.padding,
+                           self.dilation, self.groups)
 
 
 ## MIX_CONV
@@ -136,8 +137,7 @@ def __init__(self,
         self.out_channels = sum(out_splits)
 
         for idx, (k, in_ch,
-                  out_ch) in enumerate(zip(kernel_size, in_splits,
-                                           out_splits)):
+                  out_ch) in enumerate(zip(kernel_size, in_splits, out_splits)):
             conv_groups = out_ch if depthwise else 1
             self.add_module(
                 str(idx),
@@ -158,9 +158,6 @@ def forward(self, x):
         return x
 
 
-
-
-
 class FBMSNet(nn.Module):
     r'''
         FBMSNet, a novel multiscale temporal convolutional neural network for MI decoding tasks, employs Mixed Conv to extract multiscale temporal features which  enhance the intra-class compactness and improve the inter-class separability with the joint supervision of the center loss andcenter loss.
@@ -173,48 +170,36 @@ class FBMSNet(nn.Module):
 
         .. code-block:: python
 
-            # Define 9 nonoverlapping frequency bands, each with a 4 Hz bandwidth and spanning from 4 to 40 Hz.
-            Freq_range_per_band = {'sub band1': [4, 8],
-                                'sub band2': [8, 12],
-                                'sub band3': [12, 16],
-                                'sub band4': [16, 20],
-                                'sub band5': [20, 24],
-                                'sub band6': [24, 28],
-                                'sub band7': [28, 32],
-                                'sub band8': [32, 36],
-                                'sub band9': [36, 40]}
-            dataset =BCICIV2aDataset(io_path=f'./tmp_out/bciciv2a/band_9_filters',
-                                    root_path='./BCICIV_2a_mat',
-                                    chunk_size=512,
-                                    offline_transform=transforms.BandSignal(band_dict=Freq_range_per_band,
-                                                                            sampling_rate=250),
-                                    online_transform=transforms.ToTensor(),
-                                    label_transform=transforms.Compose([
-                                    transforms.Select('label'),
-                                    transforms.Lambda(lambda x:x-1),
-                        ]))
-            data = Dataloader(dataset)
-
-            model = FBMSNet(num_classes=4,
-                            num_electrodes=22,
-                            chunk_size=512,
-                            in_channels=9 )
-
-        There are two ways to use the model. The first one, the effective way to get the prediction result but it don't output the decoded feature. 
-
-        .. code-block:: python
-
-            x,y = next(iter(data))
-            pred = model(x)
-
-        To obtain the decoded feature, use :obj:`decoder` method. If we want to obtain prediction results based on the encoded features, use :obj:`classifier` method.
-
-        .. code-block:: python
-
-            x,y = next(iter(data))
-            feature = model.decoder(x)
-            pred = model.classifier(feature)
-
+            from torcheeg.datasets import BCICIV2aDataset
+            from torcheeg import transforms
+            from torcheeg.models import FBMSNet
+            from torch.utils.data import DataLoader
+
+            freq_range_per_band = {
+                'sub band1': [4, 8],
+                'sub band2': [8, 12],
+                'sub band3': [12, 16],
+                'sub band4': [16, 20],
+                'sub band5': [20, 24],
+                'sub band6': [24, 28],
+                'sub band7': [28, 32],
+                'sub band8': [32, 36],
+                'sub band9': [36, 40]
+            }
+            dataset = BCICIV2aDataset(root_path='./BCICIV_2a_mat',
+                                      chunk_size=512,
+                                      offline_transform=transforms.BandSignal(band_dict=freq_range_per_band,
+                                                                              sampling_rate=250),
+                                      online_transform=transforms.ToTensor(),
+                                      label_transform=transforms.Compose(
+                                          [transforms.Select('label'),
+                                          transforms.Lambda(lambda x: x - 1)]))
+
+            model = FBMSNet(num_classes=4, num_electrodes=22, chunk_size=512, in_channels=9)
+
+            x, y = next(iter(DataLoader(dataset, batch_size=64)))
+            model(x)
+            
         Args:
             num_electrodes (int): The number of electrodes. 
             chunk_size (int): Number of data points included in each EEG chunk. 
@@ -224,9 +209,6 @@ class FBMSNet(nn.Module):
             temporal (str): The temporal layer used, with options including VarLayer, StdLayer, LogVarLayer, MeanLayer, and MaxLayer, used to compute statistics using different techniques in the temporal dimension. (default: :obj:`LogVarLayer`)
             num_feature (int): The number of Mixed Conv output channels which can stand for various kinds of feature. (default: :obj:`36`)
             dilatability (int): The expansion multiple of the channels after the input bands pass through spatial convolutional blocks. (default: :obj:`8`
-
-        .. automethod:: decoder
-        .. automethod:: classifier
     '''
 
     def __init__(self,
@@ -309,13 +291,13 @@ def LastBlock(self, inF, outF, weight_norm=True, *args, **kwargs):
                                  *args,
                                  **kwargs), nn.LogSoftmax(dim=1))
 
-    def decoder(self, x):
+    def forward(self, x):
         r'''
         Args:
-            x (torch.Tensor): EEG signal representation, the ideal input shape is :obj:`[n, in_channel, num_electrodes, chunk_size ]`. Here, :obj:`n` corresponds to the batch size, :obj:`in_channels` corresponds to the number of sub bands.
+            x (torch.Tensor): EEG signal representation, the ideal input shape is :obj:`[n, in_channel, num_electrodes, chunk_size ]`. Here, :obj:`n` corresponds to the batch size
 
         Returns:
-           torch.Tensor[size of batch, length of deep feature code]: The extracted deep features.
+            torch.Tensor[size of batch,number of classes]: The predicted probability that the samples belong to the classes.
         '''
         x = self.mixConv2d(x)
         x = self.scb(x)
@@ -324,29 +306,9 @@ def decoder(self, x):
             int(x.shape[3] / self.stride_factor)
         ])
         x = self.temporal_layer(x)
-        return torch.flatten(x, start_dim=1)
-
-    def classifier(self, feature):
-        r'''
-        With feature which is ouput by decoder inputed,the classifier ouput the predicted probability that the samples belong to the classes. 
-
-        Args:
-            feature (torch.Tensor): The extracted deep features. The ideal input shape is :obj:`[batch size,1152]`where feature dim is fixed as :obj:`1152`.
-        Returns:
-           torch.Tensor[size of batch, num_classes]: The predicted probability that the samples belong to the classes.
-        '''
-        return self.fc(feature)
-
-    def forward(self, x):
-        r'''
-        Args:
-            x (torch.Tensor): EEG signal representation, the ideal input shape is :obj:`[n, in_channel, num_electrodes, chunk_size ]`. Here, :obj:`n` corresponds to the batch size
+        x = torch.flatten(x, start_dim=1)
 
-        Returns:
-            torch.Tensor[size of batch,number of classes]: The predicted probability that the samples belong to the classes.
-        '''
-        f = self.decoder(x)
-        return self.classifier(f)
+        return self.fc(x)
 
     def feature_dim(self, in_channels, num_electrodes, chunk_size):
         data = torch.ones((1, in_channels, num_electrodes, chunk_size))
diff --git a/torcheeg/models/cnn/mtcnn.py b/torcheeg/models/cnn/mtcnn.py
index 8afd313..26e921b 100644
--- a/torcheeg/models/cnn/mtcnn.py
+++ b/torcheeg/models/cnn/mtcnn.py
@@ -15,7 +15,14 @@ class MTCNN(nn.Module):
     Below is a recommended suite for use in emotion recognition tasks:
 
     .. code-block:: python
-    
+
+        from torcheeg.datasets import DEAPDataset
+        from torcheeg import transforms
+        from torcheeg.datasets.constants import DEAP_CHANNEL_LOCATION_DICT, DEAP_CHANNEL_LIST
+        from torcheeg.models import MTCNN
+        from torcheeg.datasets.constants.emotion_recognition.utils import format_channel_location_dict
+        from torch.utils.data import DataLoader
+
         DEAP_LOCATION_LIST = [['-', '-', 'AF3', 'FP1', '-', 'FP2', 'AF4', '-', '-'],
                               ['F7', '-', 'F3', '-', 'FZ', '-', 'F4', '-', 'F8'],
                               ['-', 'FC5', '-', 'FC1', '-', 'FC2', '-', 'FC6', '-'],
@@ -26,21 +33,24 @@ class MTCNN(nn.Module):
                               ['-', '-', '-', 'O1', 'OZ', 'O2', '-', '-', '-']]
         DEAP_CHANNEL_LOCATION_DICT = format_channel_location_dict(DEAP_CHANNEL_LIST, DEAP_LOCATION_LIST)
 
-        dataset = DEAPDataset(io_path=f'./deap',
-                    root_path='./data_preprocessed_python',
-                    online_transform=transforms.Compose([
-                        transforms.Concatenate([
-                            transforms.BandDifferentialEntropy(),
-                            transforms.BandPowerSpectralDensity()
-                        ]),
-                        transforms.ToGrid(DEAP_CHANNEL_LOCATION_DICT)
-                    ]),
-                    label_transform=transforms.Compose([
-                        transforms.Select('valence'),
-                        transforms.Binary(5.0),
-                    ]))
+        dataset = DEAPDataset(root_path='./data_preprocessed_python',
+                              online_transform=transforms.Compose([
+                                  transforms.Concatenate([
+                                      transforms.BandDifferentialEntropy(),
+                                      transforms.BandPowerSpectralDensity()
+                                  ]),
+                                  transforms.ToGrid(DEAP_CHANNEL_LOCATION_DICT)
+                              ]),
+                              label_transform=transforms.Compose([
+                                  transforms.Select('valence'),
+                                  transforms.Binary(5.0),
+                              ]))
+
         model = MTCNN(num_classes=2, in_channels=8, grid_size=(8, 9), dropout=0.2)
 
+        x, y = next(iter(DataLoader(dataset, batch_size=64)))
+        model(x)
+
     Args:
         in_channels (int): The feature dimension of each electrode, i.e., :math:`N` in the paper. (default: :obj:`4`)
         grid_size (tuple): Spatial dimensions of grid-like EEG representation. (default: :obj:`(8, 9)`)
diff --git a/torcheeg/models/cnn/sst_emotion_net.py b/torcheeg/models/cnn/sst_emotion_net.py
index 29d5be2..1a6dc5d 100644
--- a/torcheeg/models/cnn/sst_emotion_net.py
+++ b/torcheeg/models/cnn/sst_emotion_net.py
@@ -18,33 +18,42 @@ class SSTEmotionNet(nn.Module):
     Below is a recommended suite for use in emotion recognition tasks:
 
     .. code-block:: python
-    
-        dataset = DEAPDataset(io_path=f'./deap',
-                    root_path='./data_preprocessed_python',
-                    offline_transform=transforms.Compose([
-                        transforms.BaselineRemoval(),
-                        transforms.Concatenate([
-                            transforms.Compose([
-                                transforms.BandDifferentialEntropy(sampling_rate=128),
-                                transforms.MeanStdNormalize()
-                            ]),
-                            transforms.Compose([
-                                transforms.Downsample(num_points=32),
-                                transforms.MinMaxNormalize()
-                            ])
-                        ]),
-                        transforms.ToInterpolatedGrid(DEAP_CHANNEL_LOCATION_DICT)
-                    ]),
-                    online_transform=transforms.Compose([
-                        transforms.ToTensor(),
-                        transforms.Resize((16, 16))
-                    ]),
-                    label_transform=transforms.Compose([
-                        transforms.Select('valence'),
-                        transforms.Binary(5.0),
-                    ]))
+
+        from torcheeg.datasets import DEAPDataset
+        from torcheeg import transforms
+        from torcheeg.datasets.constants import DEAP_CHANNEL_LOCATION_DICT
+        from torcheeg.models import SSTEmotionNet
+        from torch.utils.data import DataLoader
+
+        dataset = DEAPDataset(root_path='./data_preprocessed_python',
+                              offline_transform=transforms.Compose([
+                                  transforms.BaselineRemoval(),
+                                  transforms.Concatenate([
+                                      transforms.Compose([
+                                          transforms.BandDifferentialEntropy(sampling_rate=128),
+                                          transforms.MeanStdNormalize()
+                                      ]),
+                                      transforms.Compose([
+                                          transforms.Downsample(num_points=32),
+                                          transforms.MinMaxNormalize()
+                                      ])
+                                  ]),
+                                  transforms.ToInterpolatedGrid(DEAP_CHANNEL_LOCATION_DICT)
+                              ]),
+                              online_transform=transforms.Compose([
+                                  transforms.ToTensor(),
+                                  transforms.Resize((16, 16))
+                              ]),
+                              label_transform=transforms.Compose([
+                                  transforms.Select('valence'),
+                                  transforms.Binary(5.0),
+                              ]))
+
         model = SSTEmotionNet(temporal_in_channels=32, spectral_in_channels=4, grid_size=(16, 16), num_classes=2)
 
+        x, y = next(iter(DataLoader(dataset, batch_size=64)))
+        model(x)
+
     Args:
         grid_size (tuple): Spatial dimensions of grid-like EEG representation. (default: :obj:`(16, 16)`)
         spectral_in_channels (int): How many 2D maps are stacked in the 3D spatial-spectral representation. (default: :obj:`5`)
diff --git a/torcheeg/models/cnn/stnet.py b/torcheeg/models/cnn/stnet.py
index 7a88a2e..28b0191 100644
--- a/torcheeg/models/cnn/stnet.py
+++ b/torcheeg/models/cnn/stnet.py
@@ -51,18 +51,27 @@ class STNet(nn.Module):
 
     .. code-block:: python
 
-        dataset = DEAPDataset(io_path=f'./deap',
-                    root_path='./data_preprocessed_python',
-                    offline_transform=transforms.Compose([
-                        transforms.ToGrid(DEAP_CHANNEL_LOCATION_DICT)
-                    ]),
-                    online_transform=transforms.ToTensor(),
-                    label_transform=transforms.Compose([
-                        transforms.Select('valence'),
-                        transforms.Binary(5.0),
-                    ]))
+        from torcheeg.datasets import DEAPDataset
+        from torcheeg import transforms
+        from torcheeg.datasets.constants import DEAP_CHANNEL_LOCATION_DICT
+        from torcheeg.models import STNet
+        from torch.utils.data import DataLoader
+
+        dataset = DEAPDataset(root_path='./data_preprocessed_python',
+                              offline_transform=transforms.Compose([
+                                  transforms.ToGrid(DEAP_CHANNEL_LOCATION_DICT)
+                              ]),
+                              online_transform=transforms.ToTensor(),
+                              label_transform=transforms.Compose([
+                                  transforms.Select('valence'),
+                                  transforms.Binary(5.0),
+                              ]))
+
         model = STNet(num_classes=2, chunk_size=128, grid_size=(9, 9), dropout=0.2)
 
+        x, y = next(iter(DataLoader(dataset, batch_size=64)))
+        model(x)
+
     Args:
         chunk_size (int): Number of data points included in each EEG chunk, i.e., :math:`T` in the paper. (default: :obj:`128`)
         grid_size (tuple): Spatial dimensions of grid-like EEG representation. (default: :obj:`(9, 9)`)
diff --git a/torcheeg/models/cnn/tsception.py b/torcheeg/models/cnn/tsception.py
index 950c375..ec2c539 100644
--- a/torcheeg/models/cnn/tsception.py
+++ b/torcheeg/models/cnn/tsception.py
@@ -14,27 +14,33 @@ class TSCeption(nn.Module):
 
     .. code-block:: python
 
-        dataset = DEAPDataset(io_path=f'./deap',
-                    root_path='./data_preprocessed_python',
-                    chunk_size=512,
-                    num_baseline=1,
-                    baseline_chunk_size=512,
-                    offline_transform=transforms.Compose([
-                        PickElectrode(PickElectrode.to_index_list(
-                        ['FP1', 'AF3', 'F3', 'F7',
-                        'FC5', 'FC1', 'C3', 'T7',
-                        'CP5', 'CP1', 'P3', 'P7',
-                        'PO3','O1', 'FP2', 'AF4',
-                        'F4', 'F8', 'FC6', 'FC2',
-                        'C4', 'T8', 'CP6', 'CP2',
-                        'P4', 'P8', 'PO4', 'O2'], DEAP_CHANNEL_LIST)),
-                        transforms.To2d()
-                    ]),
-                    online_transform=transforms.ToTensor(),
-                    label_transform=transforms.Compose([
-                        transforms.Select('valence'),
-                        transforms.Binary(5.0),
-                    ]))
+        from torcheeg.datasets import DEAPDataset
+        from torcheeg import transforms
+        from torcheeg.datasets.constants import DEAP_CHANNEL_LIST
+        from torcheeg.models import TSCeption
+        from torch.utils.data import DataLoader
+
+        dataset = DEAPDataset(root_path='./data_preprocessed_python',
+                              chunk_size=512,
+                              num_baseline=1,
+                              baseline_chunk_size=512,
+                              offline_transform=transforms.Compose([
+                                  transforms.PickElectrode(PickElectrode.to_index_list(
+                                  ['FP1', 'AF3', 'F3', 'F7',
+                                  'FC5', 'FC1', 'C3', 'T7',
+                                  'CP5', 'CP1', 'P3', 'P7',
+                                  'PO3','O1', 'FP2', 'AF4',
+                                  'F4', 'F8', 'FC6', 'FC2',
+                                  'C4', 'T8', 'CP6', 'CP2',
+                                  'P4', 'P8', 'PO4', 'O2'], DEAP_CHANNEL_LIST)),
+                                  transforms.To2d()
+                              ]),
+                              online_transform=transforms.ToTensor(),
+                              label_transform=transforms.Compose([
+                                  transforms.Select('valence'),
+                                  transforms.Binary(5.0),
+                              ]))
+
         model = TSCeption(num_classes=2,
                           num_electrodes=28,
                           sampling_rate=128,
@@ -43,6 +49,9 @@ class TSCeption(nn.Module):
                           hid_channels=32,
                           dropout=0.5)
 
+        x, y = next(iter(DataLoader(dataset, batch_size=64)))
+        model(x)
+
     Args:
         num_electrodes (int): The number of electrodes. (default: :obj:`28`)
         num_T (int): The number of multi-scale 1D temporal kernels in the dynamic temporal layer, i.e., :math:`T` kernels in the paper. (default: :obj:`15`)
@@ -53,6 +62,7 @@ class TSCeption(nn.Module):
         sampling_rate (int): The sampling rate of the EEG signals, i.e., :math:`f_s` in the paper. (default: :obj:`128`)
         dropout (float): Probability of an element to be zeroed in the dropout layers. (default: :obj:`0.5`)
     '''
+
     def __init__(self,
                  num_electrodes: int = 28,
                  num_T: int = 15,
@@ -77,25 +87,39 @@ def __init__(self,
         self.pool = 8
         # by setting the convolutional kernel being (1,lenght) and the strids being 1 we can use conv2d to
         # achieve the 1d convolution operation
-        self.Tception1 = self.conv_block(in_channels, num_T, (1, int(self.inception_window[0] * sampling_rate)), 1, self.pool)
-        self.Tception2 = self.conv_block(in_channels, num_T, (1, int(self.inception_window[1] * sampling_rate)), 1, self.pool)
-        self.Tception3 = self.conv_block(in_channels, num_T, (1, int(self.inception_window[2] * sampling_rate)), 1, self.pool)
+        self.Tception1 = self.conv_block(
+            in_channels, num_T,
+            (1, int(self.inception_window[0] * sampling_rate)), 1, self.pool)
+        self.Tception2 = self.conv_block(
+            in_channels, num_T,
+            (1, int(self.inception_window[1] * sampling_rate)), 1, self.pool)
+        self.Tception3 = self.conv_block(
+            in_channels, num_T,
+            (1, int(self.inception_window[2] * sampling_rate)), 1, self.pool)
 
-        self.Sception1 = self.conv_block(num_T, num_S, (int(num_electrodes), 1), 1, int(self.pool * 0.25))
-        self.Sception2 = self.conv_block(num_T, num_S, (int(num_electrodes * 0.5), 1), (int(num_electrodes * 0.5), 1),
+        self.Sception1 = self.conv_block(num_T, num_S, (int(num_electrodes), 1),
+                                         1, int(self.pool * 0.25))
+        self.Sception2 = self.conv_block(num_T, num_S,
+                                         (int(num_electrodes * 0.5), 1),
+                                         (int(num_electrodes * 0.5), 1),
                                          int(self.pool * 0.25))
         self.fusion_layer = self.conv_block(num_S, num_S, (3, 1), 1, 4)
         self.BN_t = nn.BatchNorm2d(num_T)
         self.BN_s = nn.BatchNorm2d(num_S)
         self.BN_fusion = nn.BatchNorm2d(num_S)
 
-        self.fc = nn.Sequential(nn.Linear(num_S, hid_channels), nn.ReLU(), nn.Dropout(dropout),
+        self.fc = nn.Sequential(nn.Linear(num_S, hid_channels), nn.ReLU(),
+                                nn.Dropout(dropout),
                                 nn.Linear(hid_channels, num_classes))
 
-    def conv_block(self, in_channels: int, out_channels: int, kernel: int, stride: int, pool_kernel: int) -> nn.Module:
+    def conv_block(self, in_channels: int, out_channels: int, kernel: int,
+                   stride: int, pool_kernel: int) -> nn.Module:
         return nn.Sequential(
-            nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=kernel, stride=stride),
-            nn.LeakyReLU(), nn.AvgPool2d(kernel_size=(1, pool_kernel), stride=(1, pool_kernel)))
+            nn.Conv2d(in_channels=in_channels,
+                      out_channels=out_channels,
+                      kernel_size=kernel,
+                      stride=stride), nn.LeakyReLU(),
+            nn.AvgPool2d(kernel_size=(1, pool_kernel), stride=(1, pool_kernel)))
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
         r'''
diff --git a/torcheeg/models/ddpm/bcddpm.py b/torcheeg/models/ddpm/bcddpm.py
index 323e0ab..bba0c6b 100644
--- a/torcheeg/models/ddpm/bcddpm.py
+++ b/torcheeg/models/ddpm/bcddpm.py
@@ -132,7 +132,9 @@ class BCUNet(nn.Module):
 
     .. code-block:: python
 
-        .. code-block:: python
+        import torch
+
+        from torcheeg.models.ddpm import BCUNet
 
         noise = torch.randn(1, 4, 9, 9)
         t = torch.randint(low=1, high=1000, size=(1, ))
diff --git a/torcheeg/models/ddpm/bddpm.py b/torcheeg/models/ddpm/bddpm.py
index a454ff6..e914e39 100644
--- a/torcheeg/models/ddpm/bddpm.py
+++ b/torcheeg/models/ddpm/bddpm.py
@@ -132,6 +132,10 @@ class BUNet(nn.Module):
 
     .. code-block:: python
 
+        import torch
+
+        from torcheeg.models import BUNet
+        
         noise = torch.randn(1, 4, 9, 9)
         t = torch.randint(low=1, high=1000, size=(1, ))
         unet = BUNet()
diff --git a/torcheeg/models/flow/bcglow.py b/torcheeg/models/flow/bcglow.py
index 75446b6..e332fd9 100644
--- a/torcheeg/models/flow/bcglow.py
+++ b/torcheeg/models/flow/bcglow.py
@@ -626,6 +626,10 @@ class BCGlow(nn.Module):
 
     .. code-block:: python
 
+        import torch
+
+        from torcheeg.models.flow import BGlow
+        
         eeg = torch.randn(1, 4, 32, 32)
         y = torch.randint(0, 2, (2, ))
         model = BGlow(num_classes=2)
diff --git a/torcheeg/models/flow/bglow.py b/torcheeg/models/flow/bglow.py
index d077a18..e73fbfa 100644
--- a/torcheeg/models/flow/bglow.py
+++ b/torcheeg/models/flow/bglow.py
@@ -627,6 +627,10 @@ class BGlow(nn.Module):
     
     .. code-block:: python
 
+        import torch
+
+        from torcheeg.models.flow.bglow import BGlow
+        
         eeg = torch.randn(1, 4, 32, 32)
         model = BGlow()
         nll_loss = model(eeg)
diff --git a/torcheeg/models/gan/bcgan.py b/torcheeg/models/gan/bcgan.py
index 44a2efa..99de88d 100644
--- a/torcheeg/models/gan/bcgan.py
+++ b/torcheeg/models/gan/bcgan.py
@@ -12,6 +12,10 @@ class BCGenerator(nn.Module):
 
     .. code-block:: python
 
+        import torch
+
+        from torcheeg.models.gan.bcgan import BCGenerator
+
         g_model = BCGenerator(in_channels=128, num_classes=3)
         z = torch.normal(mean=0, std=1, size=(1, 128))
         y = torch.randint(low=0, high=3, size=(1,))
diff --git a/torcheeg/models/gan/bgan.py b/torcheeg/models/gan/bgan.py
index f35a62a..b2d12fc 100644
--- a/torcheeg/models/gan/bgan.py
+++ b/torcheeg/models/gan/bgan.py
@@ -10,6 +10,10 @@ class BGenerator(nn.Module):
 
     .. code-block:: python
 
+        import torch
+
+        from torcheeg.models.gan.bgan import BGenerator
+        
         g_model = BGenerator(in_channels=128)
         z = torch.normal(mean=0, std=1, size=(1, 128))
         fake_X = g_model(z)
diff --git a/torcheeg/models/gan/eegfusenet.py b/torcheeg/models/gan/eegfusenet.py
index 030beba..2925820 100644
--- a/torcheeg/models/gan/eegfusenet.py
+++ b/torcheeg/models/gan/eegfusenet.py
@@ -12,6 +12,10 @@ class EEGfuseNet(nn.Module):
 
     .. code-block:: python
 
+        import torch
+
+        from torcheeg.models.gan.eegfusenet import EEGfuseNet
+        
         model = EEGfuseNet(num_electrodes=20,
                            hid_channels_gru=16,
                            num_layers_gru=1,
diff --git a/torcheeg/models/gnn/dgcnn.py b/torcheeg/models/gnn/dgcnn.py
index 944f55c..6a0c436 100644
--- a/torcheeg/models/gnn/dgcnn.py
+++ b/torcheeg/models/gnn/dgcnn.py
@@ -98,8 +98,11 @@ class DGCNN(nn.Module):
 
     .. code-block:: python
 
-        dataset = SEEDDataset(io_path=f'./seed',
-                              root_path='./Preprocessed_EEG',
+        from torcheeg.models import DGCNN
+        from torcheeg.datasets import SEEDDataset
+        from torcheeg import transforms
+
+        dataset = SEEDDataset(root_path='./Preprocessed_EEG',
                               offline_transform=transforms.BandDifferentialEntropy(band_dict={
                                   "delta": [1, 4],
                                   "theta": [4, 8],
@@ -114,8 +117,12 @@ class DGCNN(nn.Module):
                                   transforms.Select('emotion'),
                                   transforms.Lambda(lambda x: x + 1)
                               ]))
+
         model = DGCNN(in_channels=5, num_electrodes=62, hid_channels=32, num_layers=2, num_classes=2)
 
+        x, y = next(iter(DataLoader(dataset, batch_size=64)))
+        model(x)
+
     Args:
         in_channels (int): The feature dimension of each electrode. (default: :obj:`5`)
         num_electrodes (int): The number of electrodes. (default: :obj:`62`)
diff --git a/torcheeg/models/gnn/lggnet.py b/torcheeg/models/gnn/lggnet.py
index 149fe76..43557bf 100644
--- a/torcheeg/models/gnn/lggnet.py
+++ b/torcheeg/models/gnn/lggnet.py
@@ -121,8 +121,12 @@ class LGGNet(nn.Module):
 
     .. code-block:: python
 
-        dataset = SEEDDataset(io_path=f'./seed',
-                              root_path='./Preprocessed_EEG',
+        from torcheeg.datasets import SEEDDataset
+        from torcheeg.models import LGGNet
+        from torcheeg import transforms
+        from torcheeg.datasets.constants.emotion_recognition.seed import SEED_GENERAL_REGION_LIST
+
+        dataset = SEEDDataset(root_path='./Preprocessed_EEG',
                               offline_transform=transforms.Compose([
                                   transforms.MeanStdNormalize(),
                                   transforms.To2d()
@@ -135,6 +139,9 @@ class LGGNet(nn.Module):
                                   transforms.Lambda(lambda x: x + 1)
                               ]))
         model = LGGNet(region_list=SEED_GENERAL_REGION_LIST, chunk_size=128, num_electrodes=32, hid_channels=32, num_classes=2)
+        
+        x, y = next(iter(DataLoader(dataset, batch_size=64)))
+        model(x)
 
     The current built-in :obj:`region_list` includs:
 
diff --git a/torcheeg/models/pyg/gin.py b/torcheeg/models/pyg/gin.py
index 4292235..aeee99d 100644
--- a/torcheeg/models/pyg/gin.py
+++ b/torcheeg/models/pyg/gin.py
@@ -18,16 +18,26 @@ class GIN(nn.Module):
 
     .. code-block:: python
 
-        dataset = DEAPDataset(io_path=f'./deap',
-                    root_path='./data_preprocessed_python',
-                    offline_transform=transforms.BandDifferentialEntropy(),
-                    online_transform=ToG(SEED_STANDARD_ADJACENCY_MATRIX),
-                    label_transform=transforms.Compose([
-                        transforms.Select('valence'),
-                        transforms.Binary(5.0),
-                    ]))
+        from torcheeg.datasets import DEAPDataset
+        from torcheeg import transforms
+        from torcheeg.transforms.pyg import ToG
+        from torcheeg.datasets.constants import SEED_STANDARD_ADJACENCY_MATRIX
+        from torcheeg.models import GIN
+        from torch_geometric.data import DataLoader
+
+        dataset = DEAPDataset(root_path='./data_preprocessed_python',
+                              offline_transform=transforms.BandDifferentialEntropy(),
+                              online_transform=ToG(SEED_STANDARD_ADJACENCY_MATRIX),
+                              label_transform=transforms.Compose([
+                                  transforms.Select('valence'),
+                                  transforms.Binary(5.0),
+                              ]))
+
         model = GIN(in_channels=4, hid_channels=64, num_classes=2)
 
+        x, y = next(iter(DataLoader(dataset, batch_size=64)))
+        model(x)
+
     Args:
         in_channels (int): The feature dimension of each electrode. (default: :obj:`4`)
         hid_channels (int): The number of hidden nodes in the GRU layers and the fully connected layer. (default: :obj:`64`)
diff --git a/torcheeg/models/pyg/rgnn.py b/torcheeg/models/pyg/rgnn.py
index db4bcb4..78fc3b0 100644
--- a/torcheeg/models/pyg/rgnn.py
+++ b/torcheeg/models/pyg/rgnn.py
@@ -101,8 +101,14 @@ class RGNN(torch.nn.Module):
 
     .. code-block:: python
 
-        dataset = SEEDDataset(io_path=f'./seed',
-                              root_path='./Preprocessed_EEG',
+        from torcheeg.datasets import SEEDDataset
+        from torcheeg.models import RGNN
+        from torcheeg.transforms.pyg import ToG
+        from torcheeg.datasets.constants import SEED_STANDARD_ADJACENCY_MATRIX
+        from torch_geometric.data import DataLoader
+
+
+        dataset = SEEDDataset(root_path='./Preprocessed_EEG',
                               offline_transform=transforms.BandDifferentialEntropy(),
                               online_transform=ToG(SEED_STANDARD_ADJACENCY_MATRIX),
                               label_transform=transforms.Compose([
@@ -110,6 +116,7 @@ class RGNN(torch.nn.Module):
                                   transforms.Lambda(lambda x: int(x) + 1),
                               ]),
                               num_worker=8)
+
         model = RGNN(adj=torch.Tensor(SEED_STANDARD_ADJACENCY_MATRIX),
                      in_channels=5,
                      num_electrodes=62,
@@ -119,6 +126,9 @@ class RGNN(torch.nn.Module):
                      dropout=0.7,
                      learn_edge_weights=True)
 
+        x, y = next(iter(DataLoader(dataset, batch_size=64)))
+        model(x)
+
     Args:
         adj (torch.Tensor): The adjacency matrix corresponding to the EEG representation, where 1.0 means the node is adjacent and 0.0 means the node is not adjacent. The matrix shape should be [num_electrodes, num_electrodes].
         num_electrodes (int): The number of electrodes. (default: :obj:`62`)
diff --git a/torcheeg/models/rnn/gru.py b/torcheeg/models/rnn/gru.py
index ccd67a9..1bf8a4c 100644
--- a/torcheeg/models/rnn/gru.py
+++ b/torcheeg/models/rnn/gru.py
@@ -15,15 +15,23 @@ class GRU(nn.Module):
 
     .. code-block:: python
 
-        dataset = DEAPDataset(io_path=f'./deap',
-                    root_path='./data_preprocessed_python',
-                    online_transform=transforms.ToTensor(),
-                    label_transform=transforms.Compose([
-                        transforms.Select('valence'),
-                        transforms.Binary(5.0),
-                    ]))
+        from torcheeg.datasets import DEAPDataset
+        from torcheeg import transforms
+        from torcheeg.models import GRU
+        from torch.utils.data import DataLoader
+
+        dataset = DEAPDataset(root_path='./data_preprocessed_python',
+                              online_transform=transforms.ToTensor(),
+                              label_transform=transforms.Compose([
+                                  transforms.Select('valence'),
+                                  transforms.Binary(5.0),
+                              ]))
+
         model = GRU(num_electrodes=32, hid_channels=64, num_classes=2)
 
+        x, y = next(iter(DataLoader(dataset, batch_size=64)))
+        model(x)
+
     Args:
         num_electrodes (int): The number of electrodes, i.e., :math:`C` in the paper. (default: :obj:`32`)
         hid_channels (int): The number of hidden nodes in the GRU layers and the fully connected layer. (default: :obj:`64`)
diff --git a/torcheeg/models/rnn/lstm.py b/torcheeg/models/rnn/lstm.py
index 5ac64a3..df66478 100644
--- a/torcheeg/models/rnn/lstm.py
+++ b/torcheeg/models/rnn/lstm.py
@@ -15,14 +15,22 @@ class LSTM(nn.Module):
 
     .. code-block:: python
 
-        dataset = DEAPDataset(io_path=f'./deap',
-                    root_path='./data_preprocessed_python',
-                    online_transform=transforms.ToTensor(),
-                    label_transform=transforms.Compose([
-                        transforms.Select('valence'),
-                        transforms.Binary(5.0),
-                    ]))
-        model = GRU(num_electrodes=32, hid_channels=64, num_classes=2)
+        from torcheeg.datasets import DEAPDataset
+        from torcheeg import transforms
+        from torcheeg.models import LSTM
+        from torch.utils.data import DataLoader
+
+        dataset = DEAPDataset(root_path='./data_preprocessed_python',
+                              online_transform=transforms.ToTensor(),
+                              label_transform=transforms.Compose([
+                                  transforms.Select('valence'),
+                                  transforms.Binary(5.0),
+                              ]))
+
+        model = LSTM(num_electrodes=32, hid_channels=64, num_classes=2)
+
+        x, y = next(iter(DataLoader(dataset, batch_size=64)))
+        model(x)
 
     Args:
         num_electrodes (int): The number of electrodes, i.e., :math:`C` in the paper. (default: :obj:`32`)
diff --git a/torcheeg/models/transformer/arjun_vit.py b/torcheeg/models/transformer/arjun_vit.py
index 174ea4f..a9ea253 100644
--- a/torcheeg/models/transformer/arjun_vit.py
+++ b/torcheeg/models/transformer/arjun_vit.py
@@ -117,24 +117,32 @@ class ArjunViT(nn.Module):
 
     .. code-block:: python
 
-        dataset = DEAPDataset(io_path=f'./deap',
-                    root_path='./data_preprocessed_python',
-                    offline_transform=transforms.Compose([
-                        transforms.MeanStdNormalize(),
-                        transforms.To2d()
-                    ]),
-                    online_transform=transforms.Compose([
-                        transforms.ToTensor(),
-                    ]),
-                    label_transform=transforms.Compose([
-                        transforms.Select('valence'),
-                        transforms.Binary(5.0),
-                    ]))
+        from torcheeg.datasets import DEAPDataset
+        from torcheeg import transforms
+        from torcheeg.models import ArjunViT
+        from torch.utils.data import DataLoader
+
+        dataset = DEAPDataset(root_path='./data_preprocessed_python',
+                              offline_transform=transforms.Compose([
+                                  transforms.MeanStdNormalize(),
+                                  transforms.To2d()
+                              ]),
+                              online_transform=transforms.Compose([
+                                  transforms.ToTensor(),
+                              ]),
+                              label_transform=transforms.Compose([
+                                  transforms.Select('valence'),
+                                  transforms.Binary(5.0),
+                              ]))
+
         model = ArjunViT(chunk_size=128,
                          t_patch_size=50,
                          num_electrodes=32,
                          num_classes=2)
 
+        x, y = next(iter(DataLoader(dataset, batch_size=64)))
+        model(x)
+
     Args:
        num_electrodes (int): The number of electrodes. (default: :obj:`32`)
         chunk_size (int): Number of data points included in each EEG chunk. (default: :obj:`128`)
diff --git a/torcheeg/models/transformer/atcnet.py b/torcheeg/models/transformer/atcnet.py
index 6bfd6f0..016c992 100644
--- a/torcheeg/models/transformer/atcnet.py
+++ b/torcheeg/models/transformer/atcnet.py
@@ -10,12 +10,17 @@ class ATCNet(nn.Module):
     - URL: https://github.com/Altaheri/EEG-ATCNet
 
     .. code-block:: python
-    
+        
+        import torch
+        
+        from torcheeg.models import ATCNet
+
         model = ATCNet(in_channels=1,
                        num_classes=4,
                        num_windows=3,
                        num_electrodes=22,
                        chunk_size=128)
+
         input = torch.rand(2, 1, 22, 128) # (batch_size, in_channels, num_electrodes,chunk_size) 
         output = model(input)
 
diff --git a/torcheeg/models/transformer/conformer.py b/torcheeg/models/transformer/conformer.py
index f575ba1..f154a28 100644
--- a/torcheeg/models/transformer/conformer.py
+++ b/torcheeg/models/transformer/conformer.py
@@ -170,8 +170,12 @@ class Conformer(nn.Module):
 
     .. code-block:: python
 
-        dataset = SEEDDataset(io_path=f'./seed',
-                              root_path='./Preprocessed_EEG',
+        from torcheeg.models import Conformer
+        from torcheeg.datasets import SEEDDataset
+        from torcheeg import transforms
+        from torch.utils.data import DataLoader
+
+        dataset = SEEDDataset(root_path='./Preprocessed_EEG',
                               offline_transform=transforms.Compose([
                                   transforms.MinMaxNormalize(axis=-1),
                                   transforms.To2d()
@@ -181,6 +185,7 @@ class Conformer(nn.Module):
                                   transforms.Select('emotion'),
                                   transforms.Lambda(lambda x: x + 1)
                               ]))
+
         model = Conformer(num_electrodes=62,
                           sampling_rate=200,
                           hid_channels=40,
@@ -191,6 +196,9 @@ class Conformer(nn.Module):
                           forward_dropout=0.5,
                           num_classes=2)
 
+        x, y = next(iter(DataLoader(dataset, batch_size=64)))
+        model(x)
+
     Args:
         num_electrodes (int): The number of electrodes. (default: :obj:`62`)
         sampling_rate (int): The sampling rate of EEG signals. (default: :obj:`200`)
diff --git a/torcheeg/models/transformer/simple_vit.py b/torcheeg/models/transformer/simple_vit.py
index 0cdf4e0..931995b 100644
--- a/torcheeg/models/transformer/simple_vit.py
+++ b/torcheeg/models/transformer/simple_vit.py
@@ -143,6 +143,11 @@ class SimpleViT(nn.Module):
 
     .. code-block:: python
 
+        from torcheeg.datasets import DEAPDataset
+        from torcheeg import transforms
+        from torcheeg.models import SimpleViT
+        from torch.utils.data import DataLoader
+
         dataset = DEAPDataset(io_path=f'./deap',
                     root_path='./data_preprocessed_python',
                     offline_transform=transforms.Compose([
@@ -156,39 +161,53 @@ class SimpleViT(nn.Module):
                         transforms.Select('valence'),
                         transforms.Binary(5.0),
                     ]))
+
         model = SimpleViT(chunk_size=128,
                           grid_size=(9, 9),
                           t_patch_size=32,
                           num_classes=2)
 
+        x, y = next(iter(DataLoader(dataset, batch_size=64)))
+        model(x)
+
     It can also be used for the analysis of features such as DE, PSD, etc:
 
     .. code-block:: python
 
-        dataset = DEAPDataset(io_path=f'./deap',
-                    root_path='./data_preprocessed_python',
-                    offline_transform=transforms.Compose([
-                        transforms.BandDifferentialEntropy({
-                            "delta": [1, 4],
-                            "theta": [4, 8],
-                            "alpha": [8, 14],
-                            "beta": [14, 31],
-                            "gamma": [31, 49]
-                        }),
-                        transforms.ToGrid(DEAP_CHANNEL_LOCATION_DICT)
-                    ]),
-                    online_transform=transforms.Compose([
-                        transforms.ToTensor(),
-                    ]),
-                    label_transform=transforms.Compose([
-                        transforms.Select('valence'),
-                        transforms.Binary(5.0),
-                    ]))
+        from torcheeg.datasets import DEAPDataset
+        from torcheeg import transforms
+        from torcheeg.models import SimpleViT
+        from torch.utils.data import DataLoader
+        from torcheeg.datasets.constants import DEAP_CHANNEL_LOCATION_DICT
+
+
+        dataset = DEAPDataset(root_path='./data_preprocessed_python',
+                              offline_transform=transforms.Compose([
+                                  transforms.BandDifferentialEntropy({
+                                      "delta": [1, 4],
+                                      "theta": [4, 8],
+                                      "alpha": [8, 14],
+                                      "beta": [14, 31],
+                                      "gamma": [31, 49]
+                                  }),
+                                  transforms.ToGrid(DEAP_CHANNEL_LOCATION_DICT)
+                              ]),
+                              online_transform=transforms.Compose([
+                                  transforms.ToTensor(),
+                              ]),
+                              label_transform=transforms.Compose([
+                                  transforms.Select('valence'),
+                                  transforms.Binary(5.0),
+                              ]))
+
         model = SimpleViT(chunk_size=5,
                           grid_size=(9, 9),
                           t_patch_size=1,
                           num_classes=2)
 
+        x, y = next(iter(DataLoader(dataset, batch_size=64)))
+        model(x)
+
     Args:
         chunk_size (int): Number of data points included in each EEG chunk as training or test samples. (default: :obj:`128`)
         grid_size (tuple): Spatial dimensions of grid-like EEG representation. (default: :obj:`(9, 9)`)
diff --git a/torcheeg/models/transformer/vanilla_transformer.py b/torcheeg/models/transformer/vanilla_transformer.py
index e72b33f..d7f8f4c 100644
--- a/torcheeg/models/transformer/vanilla_transformer.py
+++ b/torcheeg/models/transformer/vanilla_transformer.py
@@ -87,16 +87,21 @@ class VanillaTransformer(nn.Module):
 
     .. code-block:: python
 
-        dataset = DEAPDataset(io_path=f'./deap',
-                    root_path='./data_preprocessed_python',
-                    offline_transform=transforms.To2d(),
-                    online_transform=transforms.Compose([
-                        transforms.ToTensor(),
-                    ]),
-                    label_transform=transforms.Compose([
-                        transforms.Select('valence'),
-                        transforms.Binary(5.0),
-                    ]))
+        from torcheeg.datasets import DEAPDataset
+        from torcheeg.models import VanillaTransformer
+        from torcheeg import transforms
+        from torch.utils.data import DataLoader
+
+        dataset = DEAPDataset(root_path='./data_preprocessed_python',
+                              offline_transform=transforms.To2d(),
+                              online_transform=transforms.Compose([
+                                  transforms.ToTensor(),
+                              ]),
+                              label_transform=transforms.Compose([
+                                  transforms.Select('valence'),
+                                  transforms.Binary(5.0),
+                              ]))
+
         model = VanillaTransformer(chunk_size=128,
                             num_electrodes=32,
                             patch_size=32,
@@ -106,6 +111,9 @@ class VanillaTransformer(nn.Module):
                             head_channels=64,
                             mlp_channels=64,
                             num_classes=2)
+        
+        x, y = next(iter(DataLoader(dataset, batch_size=64)))
+        model(x)
 
     Args:
         chunk_size (int): Number of data points included in each EEG chunk. (default: :obj:`128`)
diff --git a/torcheeg/models/transformer/vit.py b/torcheeg/models/transformer/vit.py
index cfd282f..44c6811 100644
--- a/torcheeg/models/transformer/vit.py
+++ b/torcheeg/models/transformer/vit.py
@@ -116,24 +116,33 @@ class ViT(nn.Module):
 
     .. code-block:: python
 
-        dataset = DEAPDataset(io_path=f'./deap',
-                    root_path='./data_preprocessed_python',
-                    offline_transform=transforms.Compose([
-                        transforms.MinMaxNormalize(axis=-1),
-                        transforms.ToGrid(DEAP_CHANNEL_LOCATION_DICT)
-                    ]),
-                    online_transform=transforms.Compose([
-                        transforms.ToTensor(),
-                    ]),
-                    label_transform=transforms.Compose([
-                        transforms.Select('valence'),
-                        transforms.Binary(5.0),
-                    ]))
+        from torcheeg.datasets import DEAPDataset
+        from torcheeg import transforms
+        from torcheeg.models import ViT
+        from torch.utils.data import DataLoader
+        from torcheeg.datasets.constants import DEAP_CHANNEL_LOCATION_DICT
+
+        dataset = DEAPDataset(root_path='./data_preprocessed_python',
+                              offline_transform=transforms.Compose([
+                                  transforms.MinMaxNormalize(axis=-1),
+                                  transforms.ToGrid(DEAP_CHANNEL_LOCATION_DICT)
+                              ]),
+                              online_transform=transforms.Compose([
+                                  transforms.ToTensor(),
+                              ]),
+                              label_transform=transforms.Compose([
+                                  transforms.Select('valence'),
+                                  transforms.Binary(5.0),
+                              ]))
+
         model = ViT(chunk_size=128,
                     grid_size=(9, 9),
                     t_patch_size=32,
                     num_classes=2)
 
+        x, y = next(iter(DataLoader(dataset, batch_size=64)))
+        model(x)
+
     It can also be used for the analysis of features such as DE, PSD, etc:
 
     .. code-block:: python
diff --git a/torcheeg/models/vae/bcvae.py b/torcheeg/models/vae/bcvae.py
index 9b70752..1c3cf8d 100644
--- a/torcheeg/models/vae/bcvae.py
+++ b/torcheeg/models/vae/bcvae.py
@@ -12,6 +12,10 @@ class BCEncoder(nn.Module):
 
     .. code-block:: python
 
+        import torch
+
+        from torcheeg.models import BCEncoder
+        
         encoder = BCEncoder(in_channels=4, num_classes=3)
         y = torch.randint(low=0, high=3, size=(1,))
         mock_eeg = torch.randn(1, 4, 9, 9)
diff --git a/torcheeg/models/vae/bvae.py b/torcheeg/models/vae/bvae.py
index 0f1a158..d08953c 100644
--- a/torcheeg/models/vae/bvae.py
+++ b/torcheeg/models/vae/bvae.py
@@ -10,6 +10,10 @@ class BEncoder(nn.Module):
 
     .. code-block:: python
 
+        import torch
+
+        from torcheeg.models import BEncoder
+        
         encoder = BEncoder(in_channels=4)
         mock_eeg = torch.randn(1, 4, 9, 9)
         mu, logvar = encoder(mock_eeg)
diff --git a/torcheeg/trainers/classifier.py b/torcheeg/trainers/classifier.py
index 9295c63..bbedeee 100644
--- a/torcheeg/trainers/classifier.py
+++ b/torcheeg/trainers/classifier.py
@@ -22,7 +22,7 @@ def classification_metrics(metric_list: List[str], num_classes: int):
     for metric in metric_list:
         if metric not in allowed_metrics:
             raise ValueError(
-                f"{metric} is not allowed. Please choose 'precision', 'recall', 'f1_score', 'accuracy', 'matthews', 'auroc', 'kappa'."
+                f"{metric} is not allowed. Please choose 'precision', 'recall', 'f1score', 'accuracy', 'matthews', 'auroc', 'kappa'."
             )
     metric_dict = {
         'accuracy':
@@ -70,7 +70,7 @@ class ClassifierTrainer(pl.LightningModule):
             weight_decay (float): The weight decay. (default: :obj:`0.0`)
             devices (int): The number of devices to use. (default: :obj:`1`)
             accelerator (str): The accelerator to use. Available options are: 'cpu', 'gpu'. (default: :obj:`"cpu"`)
-            metrics (list of str): The metrics to use. Available options are: 'precision', 'recall', 'f1_score', 'accuracy', 'matthews', 'auroc', and 'kappa'. (default: :obj:`["accuracy"]`)
+            metrics (list of str): The metrics to use. Available options are: 'precision', 'recall', 'f1score', 'accuracy', 'matthews', 'auroc', and 'kappa'. (default: :obj:`["accuracy"]`)
         
         .. automethod:: fit
         .. automethod:: test
diff --git a/torcheeg/trainers/domain_adaption/ada.py b/torcheeg/trainers/domain_adaption/ada.py
index 572a008..a3c86a9 100644
--- a/torcheeg/trainers/domain_adaption/ada.py
+++ b/torcheeg/trainers/domain_adaption/ada.py
@@ -83,14 +83,33 @@ class ADATrainer(_MMDLikeTrainer):
 
     .. code-block:: python
 
+        from torcheeg.models import CCNN
+        from torcheeg.trainers import ADATrainer
+
+        class Extractor(CCNN):
+            def forward(self, x):
+                x = self.conv1(x)
+                x = self.conv2(x)
+                x = self.conv3(x)
+                x = self.conv4(x)
+                x = x.flatten(start_dim=1)
+                return x
+
+        class Classifier(CCNN):
+            def forward(self, x):
+                x = self.lin1(x)
+                x = self.lin2(x)
+                return x
+
+        extractor = Extractor(in_channels=5, num_classes=3)
+        classifier = Classifier(in_channels=5, num_classes=3)
+
         trainer = ADATrainer(extractor,
-                            classifier,
-                            num_classes=10,
-                            devices=1,
-                            weight_visit=0.6,
-                            accelerator='gpu')
-        trainer.fit(source_loader, target_loader, val_loader)
-        trainer.test(test_loader)
+                             classifier,
+                             num_classes=3,
+                             devices=1,
+                             weight_visit=0.6,
+                             accelerator='gpu')
 
     Args:
         extractor (nn.Module): The feature extraction model learns the feature representation of the EEG signal by forcing the correlation matrixes of source and target data to be close.
@@ -106,7 +125,7 @@ class ADATrainer(_MMDLikeTrainer):
         warmup_epochs (int): The number of epochs for the warmup phase, during which the weight of the associative loss is 0. (default: :obj:`0`)
         devices (int): The number of devices to use. (default: :obj:`1`)
         accelerator (str): The accelerator to use. Available options are: 'cpu', 'gpu'. (default: :obj:`"cpu"`)
-        metrics (list of str): The metrics to use. Available options are: 'precision', 'recall', 'f1_score', 'accuracy', 'matthews', 'auroc', and 'kappa'. (default: :obj:`["accuracy"]`)
+        metrics (list of str): The metrics to use. Available options are: 'precision', 'recall', 'f1score', 'accuracy', 'matthews', 'auroc', and 'kappa'. (default: :obj:`["accuracy"]`)
 
     .. automethod:: fit
     .. automethod:: test
diff --git a/torcheeg/trainers/domain_adaption/center.py b/torcheeg/trainers/domain_adaption/center.py
index 58affd3..b88214e 100644
--- a/torcheeg/trainers/domain_adaption/center.py
+++ b/torcheeg/trainers/domain_adaption/center.py
@@ -68,91 +68,62 @@ def backward(ctx, grad_output):
 
 class CenterLossTrainer(ClassifierTrainer):
     r'''
-        A trainer trains classification model contains a decoder and a classifier. As for Center loss, it can make the output of the decoder close to the mean of decoded features within the same class. PLease refer to the following infomation to comprehend how the center loss works.
+        A trainer trains classification model contains a extractor and a classifier. As for Center loss, it can make the output of the extractor close to the mean of decoded features within the same class. PLease refer to the following infomation to comprehend how the center loss works.
 
         - Paper: FBMSNet: A Filter-Bank Multi-Scale Convolutional Neural Network for EEG-Based Motor Imagery Decoding
         - URL: https://ieeexplore.ieee.org/document/9837422
         - Related Project: https://github.com/Want2Vanish/FBMSNet
 
-        .. code-block:: python
-
-            trainer = CenterLossTrainer(decoder = decoder, 
-                                             classifier = classifier,
-                                             num_classes = your_classes,
-                                             feature_dim = your_decoded_dim)
-                                             
-            trainer.fit(train_loader, val_loader)
-            trainer.test(test_loader)
-
-        The model structure is required to contains a decoder block which generates the deep feature code and a classifier connected to the decoder to judge which class the feature code belong to.
-        Firstly, we should prepare a :obj:`decoder` model and a :obj:`classifier` model for  decoding and classifying from decoding ouput respectly. 
-        Here we take FBMSNet as example. :obj:`torcheeg.models.FBMSNet` contains decoder and classifer method already and what We need to do is just to inherit the model to define a decoder and a classifier,and then override the :obj:`forward` method . 
+        The model structure is required to contains a extractor block which generates the deep feature code and a classifier connected to the extractor to judge which class the feature code belong to.
+        Firstly, we should prepare a :obj:`extractor` model and a :obj:`classifier` model for  decoding and classifying from decoding ouput respectly. 
+        Here we take FBMSNet as example. :obj:`torcheeg.models.FBMSNet` contains extractor and classifer method already and what We need to do is just to inherit the model to define a extractor and a classifier,and then override the :obj:`forward` method . 
 
         .. code-block:: python
 
             from torcheeg.models import FBMSNet
-
-            class FBMSDecoder(FBMSNet):
-                def forward(self,x):
-                    return self.decoder(x)
-
-            class FBMSClassifier(FBMSNet):
-                def forward(self,x):
-                    return 
+            from torcheeg.trainers import CenterLossTrainer
+
+            class Extractor(FBMSNet):
+                def forward(self, x):
+                    x = self.mixConv2d(x)
+                    x = self.scb(x)
+                    x = x.reshape([
+                        *x.shape[0:2], self.stride_factor,
+                        int(x.shape[3] / self.stride_factor)
+                    ])
+                    x = self.temporal_layer(x)
+                    return torch.flatten(x, start_dim=1)
+
+            class Classifier(FBMSNet):
+                def forward(self, x):
+                    return self.fc(x)
                 
-            decoder  = FBMSDecoder(num_classes=4,
+            extractor  = Extractor(num_classes=4,
                                    num_electrodes=22,
                                    chunk_size=512,
                                    in_channels=9)
 
-            classifier = FBMSClassifier(num_classes=4,
-                                        num_electrodes=22,
-                                        chunk_size=512,
-                                        in_channels=9)
+            classifier = Classifier(num_classes=4,
+                                    num_electrodes=22,
+                                    chunk_size=512,
+                                    in_channels=9)
             
-            trainer = CenterLossTrainer(decoder=decoder, 
+            trainer = CenterLossTrainer(extractor=extractor, 
                                         classifier=classifier,
                                         num_classes=4,
                                         feature_dim=1152)
         
-        Custom model is OK. Feel free to refer to  this example:
-    
-        .. code-block:: python
-
-
-            class MyDecoder(nn.Module):
-                def __init__(self):
-                    self.layer = nn.Linear(128,64)   #(input dim, decoded dim)
-
-                def forward(self,x):
-                    return self.layer(x)
-
-            class MyClassifier(nn.Module):
-                def __init__(self):
-                    self.layer = nn.Linear(64,2)      #(decoded dim, num_classes)
-
-                def forward(self,x):classifier
-                    return self.layer(x)
-                
-            decoder  = MyDecoder()
-            classifier = MyClassifier()
-
-            trainer = CenterLossTrainer(decoder = decoder, 
-                                             classifier = classifier,
-                                             num_classes = 2,
-                                             feature_dim = 64)
-        
         Args:
-            decoder (nn.Module): The decoder which transforms eegsignal into 1D feature code.
-            classifier (nn.Module): The classifier that predict from the decoder output which class the siginals belong to.
-            feature_dim (int): The dimemsion of decoder output code whose mean values we can loosely regard as the "center". 
+            extractor (nn.Module): The extractor which transforms eegsignal into 1D feature code.
+            classifier (nn.Module): The classifier that predict from the extractor output which class the siginals belong to.
+            feature_dim (int): The dimemsion of extractor output code whose mean values we can loosely regard as the "center". 
             num_classes (int, optional): The number of categories in the dataset. 
             lammda (float): The weight of the center loss in total loss. (default: :obj:`5e-4`)
             lr (float): The learning rate. (default: :obj:`0.001`)
             weight_decay (float): The weight decay. (default: :obj:`0.0`)
             devices (int): The number of devices to use. (default: :obj:`1`)
             accelerator (str): The accelerator to use. Available options are: 'cpu', 'gpu'. (default: :obj:`"cpu"`)
-            metrics (list of str): The metrics to use. Available options are: 'precision', 'recall', 'f1_score', 'accuracy', 'matthews', 'auroc', and 'kappa'. (default: :obj:`['accuracy', 'precision', 'recall', 'f1score']`)
+            metrics (list of str): The metrics to use. Available options are: 'precision', 'recall', 'f1score', 'accuracy', 'matthews', 'auroc', and 'kappa'. (default: :obj:`['accuracy', 'precision', 'recall', 'f1score']`)
 
         .. automethod:: fit
         .. automethod:: test
@@ -160,7 +131,7 @@ def forward(self,x):classifier
 
     def __init__(
             self,
-            decoder,
+            extractor,
             classifier,
             feature_dim: int,
             num_classes: int,
@@ -173,10 +144,10 @@ def __init__(
                                   'f1score']):
 
         super(CenterLossTrainer,
-              self).__init__(decoder, num_classes, lr, weight_decay, devices,
+              self).__init__(extractor, num_classes, lr, weight_decay, devices,
                              accelerator, metrics)
 
-        self.decoder = decoder
+        self.extractor = extractor
         self.classifier = classifier
         self.center_loss = CentersLoss(num_classes, feature_dim)
         self.lammda = lammda
@@ -230,7 +201,7 @@ def training_step(self, batch, batch_idx) -> None:
         model_optimizer.zero_grad()
 
         # center loss
-        feat = self.decoder(x)
+        feat = self.extractor(x)
         centerloss = self.center_loss(y, feat)
 
         # prediction cross entropy loss
@@ -283,7 +254,7 @@ def validation_step(self, batch: Tuple[torch.Tensor],
                         batch_idx: int) -> torch.Tensor:
         x, y = batch
         # calculate feat y_pred
-        feat = self.decoder(x)
+        feat = self.extractor(x)
         y_hat = self.classifier(feat)
 
         # get loss (pred_loss,center loss,total_loss)
@@ -333,7 +304,7 @@ def test_step(self, batch: Tuple[torch.Tensor],
                   batch_idx: int) -> torch.Tensor:
         x, y = batch
         # centerloss
-        feat = self.decoder(x)
+        feat = self.extractor(x)
         centerloss = self.center_loss(y, feat)
 
         # predict loss
@@ -371,7 +342,7 @@ def on_test_epoch_end(self) -> None:
         self.test_metrics.reset()
 
     def configure_optimizers(self):
-        parameters = list(self.decoder.parameters())
+        parameters = list(self.extractor.parameters())
         parameters.extend(list(self.classifier.parameters()))
         trainable_parameters = list(
             filter(lambda p: p.requires_grad, parameters))
diff --git a/torcheeg/trainers/domain_adaption/coral.py b/torcheeg/trainers/domain_adaption/coral.py
index 37d0bad..2f426d2 100644
--- a/torcheeg/trainers/domain_adaption/coral.py
+++ b/torcheeg/trainers/domain_adaption/coral.py
@@ -36,14 +36,33 @@ class CORALTrainer(_MMDLikeTrainer):
 
     .. code-block:: python
 
+        from torcheeg.models import CCNN
+        from torcheeg.trainers import CORALTrainer
+
+        class Extractor(CCNN):
+            def forward(self, x):
+                x = self.conv1(x)
+                x = self.conv2(x)
+                x = self.conv3(x)
+                x = self.conv4(x)
+                x = x.flatten(start_dim=1)
+                return x
+
+        class Classifier(CCNN):
+            def forward(self, x):
+                x = self.lin1(x)
+                x = self.lin2(x)
+                return x
+
+        extractor = Extractor(in_channels=5, num_classes=3)
+        classifier = Classifier(in_channels=5, num_classes=3)
+
         trainer = CORALTrainer(extractor,
-                             classifier,
-                             num_classes=10,
-                             devices=1,
-                             weight_domain=1.0,
-                             accelerator='gpu')
-        trainer.fit(source_loader, target_loader, val_loader)
-        trainer.test(test_loader)
+                               classifier,
+                               num_classes=3,
+                               devices=1,
+                               weight_domain=1.0,
+                               accelerator='gpu')
 
     Args:
         extractor (nn.Module): The feature extraction model learns the feature representation of the EEG signal by forcing the correlation matrixes of source and target data to be close.
@@ -57,7 +76,7 @@ class CORALTrainer(_MMDLikeTrainer):
         warmup_epochs (int): The number of epochs for the warmup phase, during which the weight of the CORAL loss is 0. (default: :obj:`0`)
         devices (int): The number of devices to use. (default: :obj:`1`)
         accelerator (str): The accelerator to use. Available options are: 'cpu', 'gpu'. (default: :obj:`"cpu"`)
-        metrics (list of str): The metrics to use. Available options are: 'precision', 'recall', 'f1_score', 'accuracy', 'matthews', 'auroc', and 'kappa'. (default: :obj:`["accuracy"]`)
+        metrics (list of str): The metrics to use. Available options are: 'precision', 'recall', 'f1score', 'accuracy', 'matthews', 'auroc', and 'kappa'. (default: :obj:`["accuracy"]`)
 
     .. automethod:: fit
     .. automethod:: test
diff --git a/torcheeg/trainers/domain_adaption/dan.py b/torcheeg/trainers/domain_adaption/dan.py
index 32ab7f0..19126e0 100644
--- a/torcheeg/trainers/domain_adaption/dan.py
+++ b/torcheeg/trainers/domain_adaption/dan.py
@@ -62,14 +62,33 @@ class DANTrainer(_MMDLikeTrainer):
 
     .. code-block:: python
 
+        from torcheeg.models import CCNN
+        from torcheeg.trainers import DANTrainer
+
+        class Extractor(CCNN):
+            def forward(self, x):
+                x = self.conv1(x)
+                x = self.conv2(x)
+                x = self.conv3(x)
+                x = self.conv4(x)
+                x = x.flatten(start_dim=1)
+                return x
+
+        class Classifier(CCNN):
+            def forward(self, x):
+                x = self.lin1(x)
+                x = self.lin2(x)
+                return x
+
+        extractor = Extractor(in_channels=5, num_classes=3)
+        classifier = Classifier(in_channels=5, num_classes=3)
+
         trainer = DANTrainer(extractor,
                              classifier,
-                             num_classes=10,
+                             num_classes=3,
                              devices=1,
                              weight_domain=1.0,
                              accelerator='gpu')
-        trainer.fit(source_loader, target_loader, val_loader)
-        trainer.test(test_loader)
 
     Args:
         extractor (nn.Module): The feature extraction model learns the feature representation of the EEG signal by forcing the correlation matrixes of source and target data to be close.
@@ -83,7 +102,7 @@ class DANTrainer(_MMDLikeTrainer):
         warmup_epochs (int): The number of epochs for the warmup phase, during which the weight of the DAN loss is 0. (default: :obj:`0`)
         devices (int): The number of devices to use. (default: :obj:`1`)
         accelerator (str): The accelerator to use. Available options are: 'cpu', 'gpu'. (default: :obj:`"cpu"`)
-        metrics (list of str): The metrics to use. Available options are: 'precision', 'recall', 'f1_score', 'accuracy', 'matthews', 'auroc', and 'kappa'. (default: :obj:`["accuracy"]`)
+        metrics (list of str): The metrics to use. Available options are: 'precision', 'recall', 'f1score', 'accuracy', 'matthews', 'auroc', and 'kappa'. (default: :obj:`["accuracy"]`)
 
     .. automethod:: fit
     .. automethod:: test
diff --git a/torcheeg/trainers/domain_adaption/dann.py b/torcheeg/trainers/domain_adaption/dann.py
index c99289c..7ebd589 100644
--- a/torcheeg/trainers/domain_adaption/dann.py
+++ b/torcheeg/trainers/domain_adaption/dann.py
@@ -17,14 +17,34 @@ class DANNTrainer(_DANNLikeTrainer):
 
     .. code-block:: python
 
+        from torcheeg.models import CCNN
+        from torcheeg.trainers import DANNTrainer
+
+        class Extractor(CCNN):
+            def forward(self, x):
+                x = self.conv1(x)
+                x = self.conv2(x)
+                x = self.conv3(x)
+                x = self.conv4(x)
+                x = x.flatten(start_dim=1)
+                return x
+
+        class Classifier(CCNN):
+            def forward(self, x):
+                x = self.lin1(x)
+                x = self.lin2(x)
+                return x
+
+        extractor = Extractor(in_channels=5, num_classes=3)
+        classifier = Classifier(in_channels=5, num_classes=3)
+        domain_classifier = Classifier(in_channels=5, num_classes=2)
+
         trainer = DANNTrainer(extractor,
                               classifier,
                               domain_classifier,
-                              num_classes=10,
+                              num_classes=3,
                               devices=1,
                               accelerator='gpu')
-        trainer.fit(source_loader, target_loader, val_loader)
-        trainer.test(test_loader)
 
     Args:
         extractor (nn.Module): The feature extraction model learns the feature representation of the EEG signal by forcing the correlation matrixes of source and target data to be close.
@@ -39,7 +59,7 @@ class DANNTrainer(_DANNLikeTrainer):
         warmup_epochs (int): The number of epochs for the warmup phase, during which the weight of the DANN loss is 0. (default: :obj:`0`)
         devices (int): The number of devices to use. (default: :obj:`1`)
         accelerator (str): The accelerator to use. Available options are: 'cpu', 'gpu'. (default: :obj:`"cpu"`)
-        metrics (list of str): The metrics to use. Available options are: 'precision', 'recall', 'f1_score', 'accuracy', 'matthews', 'auroc', and 'kappa'. (default: :obj:`["accuracy"]`)
+        metrics (list of str): The metrics to use. Available options are: 'precision', 'recall', 'f1score', 'accuracy', 'matthews', 'auroc', and 'kappa'. (default: :obj:`["accuracy"]`)
 
     .. automethod:: fit
     .. automethod:: test
diff --git a/torcheeg/trainers/domain_adaption/ddc.py b/torcheeg/trainers/domain_adaption/ddc.py
index 5eb5b56..3b2f5b5 100644
--- a/torcheeg/trainers/domain_adaption/ddc.py
+++ b/torcheeg/trainers/domain_adaption/ddc.py
@@ -24,14 +24,33 @@ class DDCTrainer(_MMDLikeTrainer):
 
     .. code-block:: python
 
+        from torcheeg.models import CCNN
+        from torcheeg.trainers import DDCTrainer
+
+        class Extractor(CCNN):
+            def forward(self, x):
+                x = self.conv1(x)
+                x = self.conv2(x)
+                x = self.conv3(x)
+                x = self.conv4(x)
+                x = x.flatten(start_dim=1)
+                return x
+
+        class Classifier(CCNN):
+            def forward(self, x):
+                x = self.lin1(x)
+                x = self.lin2(x)
+                return x
+
+        extractor = Extractor(in_channels=5, num_classes=3)
+        classifier = Classifier(in_channels=5, num_classes=3)
+
         trainer = DDCTrainer(extractor,
                              classifier,
-                             num_classes=10,
+                             num_classes=3,
                              devices=1,
                              weight_domain=1.0,
                              accelerator='gpu')
-        trainer.fit(source_loader, target_loader, val_loader)
-        trainer.test(test_loader)
 
     Args:
         extractor (nn.Module): The feature extraction model learns the feature representation of the EEG signal by forcing the correlation matrixes of source and target data to be close.
@@ -45,7 +64,7 @@ class DDCTrainer(_MMDLikeTrainer):
         warmup_epochs (int): The number of epochs for the warmup phase, during which the weight of the DDC loss is 0. (default: :obj:`0`)
         devices (int): The number of devices to use. (default: :obj:`1`)
         accelerator (str): The accelerator to use. Available options are: 'cpu', 'gpu'. (default: :obj:`"cpu"`)
-        metrics (list of str): The metrics to use. Available options are: 'precision', 'recall', 'f1_score', 'accuracy', 'matthews', 'auroc', and 'kappa'. (default: :obj:`["accuracy"]`)
+        metrics (list of str): The metrics to use. Available options are: 'precision', 'recall', 'f1score', 'accuracy', 'matthews', 'auroc', and 'kappa'. (default: :obj:`["accuracy"]`)
 
     .. automethod:: fit
     .. automethod:: test
diff --git a/torcheeg/trainers/domain_adaption/jan.py b/torcheeg/trainers/domain_adaption/jan.py
index 2b6e231..47ad1e0 100644
--- a/torcheeg/trainers/domain_adaption/jan.py
+++ b/torcheeg/trainers/domain_adaption/jan.py
@@ -58,14 +58,33 @@ class JANTrainer(_MMDLikeTrainer):
 
     .. code-block:: python
 
+        from torcheeg.models import CCNN
+        from torcheeg.trainers import JANTrainer
+
+        class Extractor(CCNN):
+            def forward(self, x):
+                x = self.conv1(x)
+                x = self.conv2(x)
+                x = self.conv3(x)
+                x = self.conv4(x)
+                x = x.flatten(start_dim=1)
+                return x
+
+        class Classifier(CCNN):
+            def forward(self, x):
+                x = self.lin1(x)
+                x = self.lin2(x)
+                return x
+
+        extractor = Extractor(in_channels=5, num_classes=3)
+        classifier = Classifier(in_channels=5, num_classes=3)
+
         trainer = JANTrainer(extractor,
-                            classifier,
-                            num_classes=10,
-                            devices=1,
-                            weight_visit=0.6,
-                            accelerator='gpu')
-        trainer.fit(source_loader, target_loader, val_loader)
-        trainer.test(test_loader)
+                             classifier,
+                             num_classes=3,
+                             devices=1,
+                             weight_visit=0.6,
+                             accelerator='gpu')
 
     Args:
         extractor (nn.Module): The feature extraction model learns the feature representation of the EEG signal by forcing the correlation matrixes of source and target data to be close.
@@ -81,7 +100,7 @@ class JANTrainer(_MMDLikeTrainer):
         warmup_epochs (int): The number of epochs for the warmup phase, during which the weight of the associative loss is 0. (default: :obj:`0`)
         devices (int): The number of devices to use. (default: :obj:`1`)
         accelerator (str): The accelerator to use. Available options are: 'cpu', 'gpu'. (default: :obj:`"cpu"`)
-        metrics (list of str): The metrics to use. Available options are: 'precision', 'recall', 'f1_score', 'accuracy', 'matthews', 'auroc', and 'kappa'. (default: :obj:`["accuracy"]`)
+        metrics (list of str): The metrics to use. Available options are: 'precision', 'recall', 'f1score', 'accuracy', 'matthews', 'auroc', and 'kappa'. (default: :obj:`["accuracy"]`)
 
     .. automethod:: fit
     .. automethod:: test
diff --git a/torcheeg/trainers/finetune.py b/torcheeg/trainers/finetune.py
index 7805d24..7589c8d 100644
--- a/torcheeg/trainers/finetune.py
+++ b/torcheeg/trainers/finetune.py
@@ -104,7 +104,7 @@ def classification_metrics(metric_list: List[str], num_classes: int):
     for metric in metric_list:
         if metric not in allowed_metrics:
             raise ValueError(
-                f"{metric} is not allowed. Please choose 'precision', 'recall', 'f1_score', 'accuracy'"
+                f"{metric} is not allowed. Please choose 'precision', 'recall', 'f1score', 'accuracy'"
             )
     metric_dict = {
         'accuracy':
@@ -152,7 +152,7 @@ class FinetuneTrainer(pl.LightningModule):
             warmup_lr (float): The learning rate to warmup to. (default: :obj:`1e-5`)
             devices (int): The number of devices to use. (default: :obj:`1`)
             accelerator (str): The accelerator to use. Available options are: 'cpu', 'gpu'. (default: :obj:`"cpu"`)
-            metrics (list of str): The metrics to use. Available options are: 'precision', 'recall', 'f1_score', 'accuracy', 'matthews', 'auroc', and 'kappa'. (default: :obj:`["accuracy"]`)
+            metrics (list of str): The metrics to use. Available options are: 'precision', 'recall', 'f1score', 'accuracy', 'matthews', 'auroc', and 'kappa'. (default: :obj:`["accuracy"]`)
         
         .. automethod:: fit
         .. automethod:: test
diff --git a/torcheeg/trainers/generative/beta_vae.py b/torcheeg/trainers/generative/beta_vae.py
index c500370..fa08ebe 100644
--- a/torcheeg/trainers/generative/beta_vae.py
+++ b/torcheeg/trainers/generative/beta_vae.py
@@ -27,11 +27,12 @@ class BetaVAETrainer(pl.LightningModule):
 
     .. code-block:: python
         
+        from torcheeg.models import BEncoder, BDecoder
+        from torcheeg.trainers import BetaVAETrainer
+
         encoder = BEncoder(in_channels=4)
         decoder = BDecoder(in_channels=64, out_channels=4)
         trainer = BetaVAETrainer(encoder, decoder)
-        trainer.fit(train_loader, val_loader)
-        trainer.test(test_loader)
 
     Args:
         encoder (nn.Module): The encoder, whose inputs are EEG signals, outputs are two batches of vectors of the same dimension, representing the mean and variance estimated in the reparameterization trick.
diff --git a/torcheeg/trainers/generative/ddpm.py b/torcheeg/trainers/generative/ddpm.py
index ae50cf5..8fbfbf1 100644
--- a/torcheeg/trainers/generative/ddpm.py
+++ b/torcheeg/trainers/generative/ddpm.py
@@ -191,9 +191,11 @@ class DDPMTrainer(pl.LightningModule):
 
     .. code-block:: python
         
+        from torcheeg.trainers import DDPMTrainer
+        from torcheeg.models import BUNet
+
+        model = BUNet(in_channels=4)
         trainer = DDPMTrainer(model)
-        trainer.fit(train_loader, val_loader, max_epochs=1)
-        trainer.test(test_loader)
 
     Args:
         model (nn.Module): The denoising model takes the noisy samples and the current denoising conditions as input to predict the denoised samples. In this class, the current denoising condition is the current denoising time step. Typically, this model will be a UNet.
diff --git a/torcheeg/trainers/generative/glow.py b/torcheeg/trainers/generative/glow.py
index 1e9eccd..a169d0f 100644
--- a/torcheeg/trainers/generative/glow.py
+++ b/torcheeg/trainers/generative/glow.py
@@ -28,8 +28,6 @@ class GlowTrainer(pl.LightningModule):
         
         model = BGlow(in_channels=4)
         trainer = GlowTrainer(model)
-        trainer.fit(train_loader, val_loader)
-        trainer.test(test_loader)
 
     Args:
         model (nn.Module): Normalized flow model, it needs to implement two interfaces, log_probs and sample. Among them, log_probs takes the original sample as input to calculate the log probs to the target distribution, and sample takes num and temperature as input to calculate the generated sample.
diff --git a/torcheeg/trainers/generative/wgan_gp.py b/torcheeg/trainers/generative/wgan_gp.py
index d13764f..6834bab 100644
--- a/torcheeg/trainers/generative/wgan_gp.py
+++ b/torcheeg/trainers/generative/wgan_gp.py
@@ -49,8 +49,6 @@ class WGANGPTrainer(pl.LightningModule):
         g_model = BGenerator(in_channels=128)
         d_model = BDiscriminator(in_channels=4)
         trainer = WGANGPTrainer(generator, discriminator)
-        trainer.fit(train_loader, val_loader)
-        trainer.test(test_loader)
 
     Args:
         generator (nn.Module): The generator model for EEG signal generation, whose inputs are Gaussian distributed random vectors, outputs are generated EEG signals. The dimensions of the input vector should be defined on the :obj:`in_channel` attribute. The output layer does not need to have a softmax activation function.
diff --git a/torcheeg/trainers/imbalance/eq.py b/torcheeg/trainers/imbalance/eq.py
index 286a51c..307405e 100644
--- a/torcheeg/trainers/imbalance/eq.py
+++ b/torcheeg/trainers/imbalance/eq.py
@@ -54,13 +54,11 @@ class EQLossTrainer(ClassifierTrainer):
 
         .. code-block:: python
 
-            trainer = EQLossTrainer(model, num_classes=2, class_frequency=train_loader)
-            trainer.fit(train_loader, val_loader)
-            trainer.test(test_loader)
+            from torcheeg.models import CCNN
+            from torcheeg.trainers import EQLossTrainer
 
+            model = CCNN(in_channels=5, num_classes=2)
             trainer = EQLossTrainer(model, num_classes=2, class_frequency=[10, 20], gamma=0.9, lambd=0.005)
-            trainer.fit(train_loader, val_loader)
-            trainer.test(test_loader)
 
         Args:
             model (nn.Module): The classification model, and the dimension of its output should be equal to the number of categories in the dataset. The output layer does not need to have a softmax activation function.
@@ -72,7 +70,7 @@ class EQLossTrainer(ClassifierTrainer):
             weight_decay (float): The weight decay. (default: :obj:`0.0`)
             devices (int): The number of devices to use. (default: :obj:`1`)
             accelerator (str): The accelerator to use. Available options are: 'cpu', 'gpu'. (default: :obj:`"cpu"`)
-            metrics (list of str): The metrics to use. Available options are: 'precision', 'recall', 'f1_score', 'accuracy', 'matthews', 'auroc', and 'kappa'. (default: :obj:`["accuracy"]`)
+            metrics (list of str): The metrics to use. Available options are: 'precision', 'recall', 'f1score', 'accuracy', 'matthews', 'auroc', and 'kappa'. (default: :obj:`["accuracy"]`)
         
         .. automethod:: fit
         .. automethod:: test
diff --git a/torcheeg/trainers/imbalance/focal.py b/torcheeg/trainers/imbalance/focal.py
index a8747b4..cb56899 100644
--- a/torcheeg/trainers/imbalance/focal.py
+++ b/torcheeg/trainers/imbalance/focal.py
@@ -52,13 +52,11 @@ class FocalLossTrainer(ClassifierTrainer):
 
         .. code-block:: python
 
-            trainer = FocalLossTrainer(model, num_classes=2, class_frequency=train_loader)
-            trainer.fit(train_loader, val_loader)
-            trainer.test(test_loader)
+            from torcheeg.models import CCNN
+            from torcheeg.trainers import FocalLossTrainer
 
+            model = CCNN(in_channels=5, num_classes=2)
             trainer = FocalLossTrainer(model, num_classes=2, class_frequency=[10, 20], gamma=1.0)
-            trainer.fit(train_loader, val_loader)
-            trainer.test(test_loader)
 
         Args:
             model (nn.Module): The classification model, and the dimension of its output should be equal to the number of categories in the dataset. The output layer does not need to have a softmax activation function.
diff --git a/torcheeg/trainers/imbalance/la.py b/torcheeg/trainers/imbalance/la.py
index f89267b..163458e 100644
--- a/torcheeg/trainers/imbalance/la.py
+++ b/torcheeg/trainers/imbalance/la.py
@@ -48,13 +48,11 @@ class LALossTrainer(ClassifierTrainer):
 
         .. code-block:: python
 
-            trainer = LALossTrainer(model, num_classes=2, class_frequency=train_loader)
-            trainer.fit(train_loader, val_loader)
-            trainer.test(test_loader)
+            from torcheeg.models import CCNN
+            from torcheeg.trainers import LALossTrainer
 
+            model = CCNN(in_channels=5, num_classes=2)
             trainer = LALossTrainer(model, num_classes=2, class_frequency=[10, 20], tau=1.0)
-            trainer.fit(train_loader, val_loader)
-            trainer.test(test_loader)
 
         Args:
             model (nn.Module): The classification model, and the dimension of its output should be equal to the number of categories in the dataset. The output layer does not need to have a softmax activation function.
@@ -66,7 +64,7 @@ class LALossTrainer(ClassifierTrainer):
             weight_decay (float): The weight decay. (default: :obj:`0.0`)
             devices (int): The number of devices to use. (default: :obj:`1`)
             accelerator (str): The accelerator to use. Available options are: 'cpu', 'gpu'. (default: :obj:`"cpu"`)
-            metrics (list of str): The metrics to use. Available options are: 'precision', 'recall', 'f1_score', 'accuracy', 'matthews', 'auroc', and 'kappa'. (default: :obj:`["accuracy"]`)
+            metrics (list of str): The metrics to use. Available options are: 'precision', 'recall', 'f1score', 'accuracy', 'matthews', 'auroc', and 'kappa'. (default: :obj:`["accuracy"]`)
         
         .. automethod:: fit
         .. automethod:: test
diff --git a/torcheeg/trainers/imbalance/ldam.py b/torcheeg/trainers/imbalance/ldam.py
index 4589cad..21475e9 100644
--- a/torcheeg/trainers/imbalance/ldam.py
+++ b/torcheeg/trainers/imbalance/ldam.py
@@ -69,13 +69,11 @@ class LDAMLossTrainer(ClassifierTrainer):
 
         .. code-block:: python
 
-            trainer = LDAMLossTrainer(model, num_classes=2, class_frequency=train_loader)
-            trainer.fit(train_loader, val_loader)
-            trainer.test(test_loader)
+            from torcheeg.models import CCNN
+            from torcheeg.trainers import LDAMLossTrainer
 
+            model = CCNN(in_channels=5, num_classes=2)
             trainer = LDAMLossTrainer(model, num_classes=2, class_frequency=[10, 20], max_margin=0.5, scaling=30)
-            trainer.fit(train_loader, val_loader)
-            trainer.test(test_loader)
 
         Args:
             model (nn.Module): The classification model, and the dimension of its output should be equal to the number of categories in the dataset. The output layer does not need to have a softmax activation function.
diff --git a/torcheeg/trainers/imbalance/wce.py b/torcheeg/trainers/imbalance/wce.py
index 1812a0b..3db3274 100644
--- a/torcheeg/trainers/imbalance/wce.py
+++ b/torcheeg/trainers/imbalance/wce.py
@@ -13,13 +13,11 @@ class WCELossTrainer(ClassifierTrainer):
 
         .. code-block:: python
 
-            trainer = WCELossTrainer(model, num_classes=2, class_frequency=train_loader)
-            trainer.fit(train_loader, val_loader)
-            trainer.test(test_loader)
+            from torcheeg.models import CCNN
+            from torcheeg.trainers import WCELossTrainer
 
+            model = CCNN(in_channels=5, num_classes=2)
             trainer = WCELossTrainer(model, num_classes=2, class_frequency=[10, 20])
-            trainer.fit(train_loader, val_loader)
-            trainer.test(test_loader)
 
         Args:
             model (nn.Module): The classification model, and the dimension of its output should be equal to the number of categories in the dataset. The output layer does not need to have a softmax activation function.
diff --git a/torcheeg/trainers/self_supervised/byol.py b/torcheeg/trainers/self_supervised/byol.py
index 0d45907..df97f94 100644
--- a/torcheeg/trainers/self_supervised/byol.py
+++ b/torcheeg/trainers/self_supervised/byol.py
@@ -23,16 +23,33 @@ class BYOLTrainer(pl.LightningModule):
 
     .. code-block:: python
 
+        from torcheeg.models import CCNN
+        from torcheeg.trainers import BYOLTrainer
+
+        class Extractor(CCNN):
+            def forward(self, x):
+                x = self.conv1(x)
+                x = self.conv2(x)
+                x = self.conv3(x)
+                x = self.conv4(x)
+                x = x.flatten(start_dim=1)
+                return x
+
+        extractor = Extractor(in_channels=5, num_classes=3)
+
         trainer = BYOLTrainer(extractor,
                               extract_channels=256,
                               devices=1,
                               accelerator='gpu')
-        trainer.fit(train_loader, val_loader)
 
     NOTE: The first element of each batch in :obj:`train_loader` and :obj:`val_loader` should be a two-tuple, representing two random transformations (views) of data. You can use :obj:`Contrastive` to achieve this functionality.
 
     .. code-block:: python
 
+        from torcheeg.datasets import DEAPDataset
+        from torcheeg import transforms
+        from torcheeg.datasets.constants import DEAP_CHANNEL_LOCATION_DICT
+        
         contras_dataset = DEAPDataset(
             io_path=f'./io/deap',
             root_path='./data_preprocessed_python',
@@ -53,10 +70,6 @@ class BYOLTrainer(pl.LightningModule):
             baseline_chunk_size=128,
             num_baseline=3)
 
-        trainer = BYOLTrainer(extractor,
-                              extract_channels=256,
-                              devices=1,
-                              accelerator='gpu')
         trainer.fit(train_loader, val_loader)
 
     Args:
diff --git a/torcheeg/trainers/self_supervised/sim_clr.py b/torcheeg/trainers/self_supervised/sim_clr.py
index f7d7f11..1d7dc71 100644
--- a/torcheeg/trainers/self_supervised/sim_clr.py
+++ b/torcheeg/trainers/self_supervised/sim_clr.py
@@ -22,15 +22,31 @@ class SimCLRTrainer(pl.LightningModule):
 
     .. code-block:: python
 
+        from torcheeg.models import CCNN
+        from torcheeg.trainers import BYOLTrainer
+
+        class Extractor(CCNN):
+            def forward(self, x):
+                x = self.conv1(x)
+                x = self.conv2(x)
+                x = self.conv3(x)
+                x = self.conv4(x)
+                x = x.flatten(start_dim=1)
+                return x
+
+        extractor = Extractor(in_channels=5, num_classes=3)
         trainer = SimCLRTrainer(extractor,
                                 devices=1,
                                 accelerator='gpu')
-        trainer.fit(train_loader, val_loader)
 
     NOTE: The first element of each batch in :obj:`train_loader` and :obj:`val_loader` should be a two-tuple, representing two random transformations (views) of data. You can use :obj:`Contrastive` to achieve this functionality.
 
     .. code-block:: python
 
+        from torcheeg.datasets import DEAPDataset
+        from torcheeg import transforms
+        from torcheeg.datasets.constants import DEAP_CHANNEL_LOCATION_DICT
+        
         contras_dataset = DEAPDataset(
             io_path=f'./io/deap',
             root_path='./data_preprocessed_python',
@@ -51,9 +67,6 @@ class SimCLRTrainer(pl.LightningModule):
             baseline_chunk_size=128,
             num_baseline=3)
 
-        trainer = SimCLRTrainer(extractor,
-                                devices=1,
-                                accelerator='gpu')
         trainer.fit(train_loader, val_loader)
 
     Args:
diff --git a/torcheeg/transforms/__init__.py b/torcheeg/transforms/__init__.py
index 12bb0f7..13d37d6 100644
--- a/torcheeg/transforms/__init__.py
+++ b/torcheeg/transforms/__init__.py
@@ -2,4 +2,5 @@
 from .any import *
 from .label import *
 from .numpy import *
-from .torch import *
\ No newline at end of file
+from .torch import *
+from .hooks import *
\ No newline at end of file
diff --git a/torcheeg/transforms/any/baseline.py b/torcheeg/transforms/any/baseline.py
index 743a2bf..98e3348 100644
--- a/torcheeg/transforms/any/baseline.py
+++ b/torcheeg/transforms/any/baseline.py
@@ -11,14 +11,16 @@ class BaselineRemoval(EEGTransform):
 
     .. code-block:: python
 
-        transform = Compose([
-            BandDifferentialEntropy(apply_to_baseline=True),
-            ToTensor(apply_to_baseline=True),
-            BaselineRemoval(),
-            ToGrid(DEAP_CHANNEL_LOCATION_DICT)
+        from torcheeg import transforms
+
+        t = transforms.Compose([
+            transforms.BandDifferentialEntropy(apply_to_baseline=True),
+            transforms.ToTensor(apply_to_baseline=True),
+            transforms.BaselineRemoval(),
+            transforms.ToGrid(DEAP_CHANNEL_LOCATION_DICT)
         ])
 
-        transform(eeg=np.random.randn(32, 128), baseline=np.random.randn(32, 128))['eeg'].shape
+        t(eeg=np.random.randn(32, 128), baseline=np.random.randn(32, 128))['eeg'].shape
         >>> (4, 9, 9)
     
     .. automethod:: __call__
diff --git a/torcheeg/transforms/any/compose.py b/torcheeg/transforms/any/compose.py
index cb2cd26..b64260c 100644
--- a/torcheeg/transforms/any/compose.py
+++ b/torcheeg/transforms/any/compose.py
@@ -9,25 +9,29 @@ class Compose(BaseTransform):
 
     .. code-block:: python
 
-        transform = Compose([
-            ToTensor(),
-            Resize(size=(64, 64)),
-            RandomNoise(p=0.1),
-            RandomMask(p=0.1)
+        from torcheeg import transforms
+
+        t = transforms.Compose([
+            transforms.ToTensor(),
+            transforms.Resize(size=(64, 64)),
+            transforms.RandomNoise(p=0.1),
+            transforms.RandomMask(p=0.1)
         ])
-        transform(eeg=torch.randn(128, 9, 9))['eeg'].shape
+        t(eeg=torch.randn(128, 9, 9))['eeg'].shape
         >>> (128, 64, 64)
 
     :obj:`Compose` supports transformers with different data dependencies. The above example combines multiple torch-based transformers, the following example shows a sequence of numpy-based transformer.
 
     .. code-block:: python
 
-        transform = Compose([
-            BandDifferentialEntropy(),
-            MeanStdNormalize(),
-            ToGrid(DEAP_CHANNEL_LOCATION_DICT)
+        from torcheeg import transforms
+
+        t = transforms.Compose([
+            transforms.BandDifferentialEntropy(),
+            transforms.MeanStdNormalize(),
+            transforms.ToGrid(DEAP_CHANNEL_LOCATION_DICT)
         ])
-        transform(eeg=np.random.randn(32, 128))['eeg'].shape
+        t(eeg=np.random.randn(32, 128))['eeg'].shape
         >>> (128, 9, 9)
 
     Args:
diff --git a/torcheeg/transforms/any/lambd.py b/torcheeg/transforms/any/lambd.py
index ebd7bfb..d09efd5 100644
--- a/torcheeg/transforms/any/lambd.py
+++ b/torcheeg/transforms/any/lambd.py
@@ -9,8 +9,10 @@ class Lambda(BaseTransform):
 
     .. code-block:: python
 
-        transform = Lambda(targets=['y'], lambda x: x + 1)
-        transform(y=1)['y']
+        from torcheeg import transforms
+
+        t = transforms.Lambda(targets=['y'], lambda x: x + 1)
+        t(y=1)['y']
         >>> 2
 
     Args:
diff --git a/torcheeg/transforms/any/pdb.py b/torcheeg/transforms/any/pdb.py
index 995f2c9..9eda0b5 100644
--- a/torcheeg/transforms/any/pdb.py
+++ b/torcheeg/transforms/any/pdb.py
@@ -10,14 +10,16 @@ class PDB(BaseTransform):
 
     .. code-block:: python
 
-        transform = Compose([
-            ToTensor(),
-            Resize(size=(64, 64)),
-            PDB(),
-            RandomNoise(p=0.1),
-            RandomMask(p=0.1)
+        from torcheeg import transforms
+
+        t = transforms.Compose([
+            transforms.ToTensor(),
+            transforms.Resize(size=(64, 64)),
+            transforms.PDB(),
+            transforms.RandomNoise(p=0.1),
+            transforms.RandomMask(p=0.1)
         ])
-        transform(eeg=torch.randn(128, 9, 9))['eeg'].shape
+        t(eeg=torch.randn(128, 9, 9))['eeg'].shape
         >>> (128, 64, 64)
     
     Args:
diff --git a/torcheeg/transforms/hooks/__init__.py b/torcheeg/transforms/hooks/__init__.py
new file mode 100644
index 0000000..f5b9d35
--- /dev/null
+++ b/torcheeg/transforms/hooks/__init__.py
@@ -0,0 +1,2 @@
+from .before_hook import *
+from .after_hook import *
\ No newline at end of file
diff --git a/torcheeg/transforms/hooks/after_hook.py b/torcheeg/transforms/hooks/after_hook.py
new file mode 100644
index 0000000..764fa0a
--- /dev/null
+++ b/torcheeg/transforms/hooks/after_hook.py
@@ -0,0 +1,294 @@
+import numpy as np
+import torch
+
+from typing import List, Union
+
+
+def after_hook_normalize(
+        data: List[Union[np.ndarray, torch.Tensor]],
+        eps: float = 1e-6) -> List[Union[np.ndarray, torch.Tensor]]:
+    r'''
+    A common hook function used to normalize the signal of the whole trial/session/subject after dividing it into chunks and transforming the divided chunks.
+
+    It is used as follows:
+
+    .. code-block:: python
+
+        from torcheeg.datasets import DEAPDataset
+        from torcheeg.transforms import after_hook_normalize
+        
+        dataset = DEAPDataset(root_path='./data_preprocessed_python',
+                              offline_transform=transforms.Compose([
+                                  transforms.BandDifferentialEntropy(),
+                                  transforms.ToGrid(DEAP_CHANNEL_LOCATION_DICT)
+                              ]),
+                              online_transform=transforms.ToTensor(),
+                              after_trial=after_hook_normalize,
+                              num_worker=4,
+                              label_transform=transforms.Compose([
+                                  transforms.Select('valence'),
+                                  transforms.Binary(5.0),
+                              ]))
+
+    If you want to pass in parameters, use partial to generate a new function:
+
+    .. code-block:: python
+
+        from functools import partial
+        from torcheeg.datasets import DEAPDataset
+        from torcheeg.transforms import after_hook_normalize
+
+        DEAPDataset(root_path='./data_preprocessed_python',
+                              offline_transform=transforms.Compose([
+                                  transforms.BandDifferentialEntropy(),
+                                  transforms.ToGrid(DEAP_CHANNEL_LOCATION_DICT)
+                              ]),
+                              online_transform=transforms.ToTensor(),
+                              after_trial=partial(after_hook_normalize, eps=1e-5),
+                              num_worker=4,
+                              label_transform=transforms.Compose([
+                                  transforms.Select('valence'),
+                                  transforms.Binary(5.0),
+                              ]))
+
+    Args:
+        data (list): A list of :obj:`np.ndarray` or :obj:`torch.Tensor`, one of which corresponds to an EEG signal in trial.
+        eps (float): The term added to the denominator to improve numerical stability (default: :obj:`1e-6`)
+        
+    Returns:
+        list: The normalized results of a trial. It is a list of :obj:`np.ndarray` or :obj:`torch.Tensor`, one of which corresponds to an EEG signal in trial.
+    '''
+    if isinstance(data[0], np.ndarray):
+        data = np.stack(data, axis=0)
+
+        min_v = data.min(axis=0, keepdims=True)
+        max_v = data.max(axis=0, keepdims=True)
+        data = (data - min_v) / (max_v - min_v + eps)
+
+        return [sample for sample in data]
+    elif isinstance(data[0], torch.Tensor):
+        data = torch.stack(data, dim=0)
+
+        min_v, _ = data.min(axis=0, keepdims=True)
+        max_v, _ = data.max(axis=0, keepdims=True)
+        data = (data - min_v) / (max_v - min_v + eps)
+
+        return [sample for sample in data]
+    else:
+        raise ValueError(
+            'The after_hook_normalize only supports np.ndarray and torch.Tensor. Please make sure the outputs of offline_transform ({}) are np.ndarray or torch.Tensor.'
+            .format(type(data[0])))
+
+
+def after_hook_running_norm(
+        data: List[Union[np.ndarray, torch.Tensor]],
+        decay_rate: float = 0.9,
+        eps: float = 1e-6) -> List[Union[np.ndarray, torch.Tensor]]:
+    r'''
+    A common hook function used to normalize the signal of the whole trial/session/subject after dividing it into chunks and transforming the divided chunks.
+
+    It is used as follows:
+
+    .. code-block:: python
+
+        from torcheeg.datasets import DEAPDataset
+        from torcheeg.transforms import after_hook_running_norm
+        from torcheeg.datasets.constants import DEAP_CHANNEL_LOCATION_DICT
+
+        dataset = DEAPDataset(root_path='./data_preprocessed_python',
+                              offline_transform=transforms.Compose([
+                                  transforms.BandDifferentialEntropy(),
+                                  transforms.ToGrid(DEAP_CHANNEL_LOCATION_DICT)
+                              ]),
+                              online_transform=transforms.ToTensor(),
+                              after_trial=after_hook_running_norm,
+                              label_transform=transforms.Compose([
+                                  transforms.Select('valence'),
+                                  transforms.Binary(5.0),
+                              ]))
+
+    If you want to pass in parameters, use partial to generate a new function:
+
+    .. code-block:: python
+
+        from functools import partial
+        from torcheeg.datasets import DEAPDataset
+        from torcheeg.transforms import after_hook_running_norm
+        
+        dataset = DEAPDataset(root_path='./data_preprocessed_python',
+                              offline_transform=transforms.Compose([
+                                  transforms.BandDifferentialEntropy(),
+                                  transforms.ToGrid(DEAP_CHANNEL_LOCATION_DICT)
+                              ]),
+                              online_transform=transforms.ToTensor(),
+                              after_trial=partial(after_hook_running_norm, decay_rate=0.9, eps=1e-6),
+                              label_transform=transforms.Compose([
+                                  transforms.Select('valence'),
+                                  transforms.Binary(5.0),
+                              ]))
+    
+    Args:
+        data (list): A list of :obj:`np.ndarray` or :obj:`torch.Tensor`, one of which corresponds to an EEG signal in trial.
+        decay_rate (float): The decay rate used in the running normalization (default: :obj:`0.9`)
+        eps (float): The term added to the denominator to improve numerical stability (default: :obj:`1e-6`)
+
+    Returns:
+        list: The normalized results of a trial. It is a list of :obj:`np.ndarray` or :obj:`torch.Tensor`, one of which corresponds to an EEG signal in trial.
+    '''
+    if isinstance(data[0], np.ndarray):
+        data = np.stack(data, axis=0)
+
+        running_mean = np.zeros_like(data[0])
+        running_var = np.zeros_like(data[0])
+
+        for i, current_sample in enumerate(data):
+            running_mean = decay_rate * running_mean + (
+                1 - decay_rate) * current_sample
+            running_var = decay_rate * running_var + (
+                1 - decay_rate) * np.square(current_sample - running_mean)
+            data[i] = (data[i] - running_mean) / np.sqrt(running_var + eps)
+
+        return [sample for sample in data]
+    elif isinstance(data[0], torch.Tensor):
+        data = torch.stack(data, dim=0)
+
+        running_mean = torch.zeros_like(data[0])
+        running_var = torch.zeros_like(data[0])
+
+        for i, current_sample in enumerate(data):
+            running_mean = decay_rate * running_mean + (
+                1 - decay_rate) * current_sample
+            running_var = decay_rate * running_var + (
+                1 - decay_rate) * torch.square(current_sample - running_mean)
+            data[i] = (data[i] - running_mean) / torch.sqrt(running_var + eps)
+
+        return [sample for sample in data]
+    else:
+        raise ValueError(
+            'The after_hook_running_norm only supports np.ndarray and torch.Tensor. Please make sure the outputs of offline_transform ({}) are np.ndarray or torch.Tensor.'
+            .format(type(data[0])))
+
+
+def after_hook_linear_dynamical_system(
+        data: List[Union[np.ndarray, torch.Tensor]],
+        V0: float = 0.01,
+        A: float = 1,
+        T: float = 0.0001,
+        C: float = 1,
+        sigma: float = 1) -> List[Union[np.ndarray, torch.Tensor]]:
+    r'''
+    A common hook function used to normalize the signal of the whole trial/session/subject after dividing it into chunks and transforming the divided chunks.
+
+    It is used as follows:
+
+    .. code-block:: python
+
+        from torcheeg.datasets import DEAPDataset
+        from torcheeg.transforms import after_hook_linear_dynamical_system
+
+        dataset = DEAPDataset(root_path='./data_preprocessed_python',
+                              offline_transform=transforms.Compose([
+                                  transforms.BandDifferentialEntropy(),
+                                  transforms.ToGrid(DEAP_CHANNEL_LOCATION_DICT)
+                              ]),
+                              online_transform=transforms.ToTensor(),
+                              after_trial=after_hook_linear_dynamical_system,
+                              label_transform=transforms.Compose([
+                                  transforms.Select('valence'),
+                                  transforms.Binary(5.0),
+                              ]))
+
+    If you want to pass in parameters, use partial to generate a new function:
+
+    .. code-block:: python
+
+        from functools import partial
+        from torcheeg.datasets import DEAPDataset
+        from torcheeg.transforms import after_hook_linear_dynamical_system
+
+        dataset = DEAPDataset(root_path='./data_preprocessed_python',
+                              offline_transform=transforms.Compose([
+                                  transforms.BandDifferentialEntropy(),
+                                  transforms.ToGrid(DEAP_CHANNEL_LOCATION_DICT)
+                              ]),
+                              online_transform=transforms.ToTensor(),
+                              after_trial=partial(after_hook_linear_dynamical_system, V0=0.01, A=1, T=0.0001, C=1, sigma=1),
+                              label_transform=transforms.Compose([
+                                  transforms.Select('valence'),
+                                  transforms.Binary(5.0),
+                              ]))
+    
+    Args:
+        data (list): A list of :obj:`np.ndarray` or :obj:`torch.Tensor`, one of which corresponds to an EEG signal in trial.
+        V0 (float): The initial variance of the linear dynamical system (default: :obj:`0.01`)
+        A (float): The coefficient of the linear dynamical system (default: :obj:`1`)
+        T (float): The term added to the diagonal of the covariance matrix (default: :obj:`0.0001`)
+        C (float): The coefficient of the linear dynamical system (default: :obj:`1`)
+        sigma (float): The variance of the linear dynamical system (default: :obj:`1`)
+        
+    Returns:
+        list: The normalized results of a trial. It is a list of :obj:`np.ndarray` or :obj:`torch.Tensor`, one of which corresponds to an EEG signal in trial.
+    '''
+    if isinstance(data[0], np.ndarray):
+        # save the data[0].shape and flatten them
+        shape = data[0].shape
+        data = np.stack([sample.flatten() for sample in data], axis=0)
+
+        ave = np.mean(data, axis=0)
+        u0 = ave
+        X = data.transpose((1, 0))
+
+        [m, n] = X.shape
+        P = np.zeros((m, n))
+        u = np.zeros((m, n))
+        V = np.zeros((m, n))
+        K = np.zeros((m, n))
+
+        K[:, 0] = (V0 * C / (C * V0 * C + sigma)) * np.ones((m, ))
+        u[:, 0] = u0 + K[:, 0] * (X[:, 0] - C * u0)
+        V[:, 0] = (np.ones((m, )) - K[:, 0] * C) * V0
+
+        for i in range(1, n):
+            P[:, i - 1] = A * V[:, i - 1] * A + T
+            K[:, i] = P[:, i - 1] * C / (C * P[:, i - 1] * C + sigma)
+            u[:,
+              i] = A * u[:, i - 1] + K[:, i] * (X[:, i] - C * A * u[:, i - 1])
+            V[:, i] = (np.ones((m, )) - K[:, i] * C) * P[:, i - 1]
+
+        X = u
+
+        return [sample.reshape(shape) for sample in X.transpose((1, 0))]
+
+    elif isinstance(data[0], torch.Tensor):
+        shape = data[0].shape
+        data = torch.stack([sample.flatten() for sample in data], dim=0)
+
+        ave = torch.mean(data, dim=0)
+        u0 = ave
+        X = data.transpose(1, 0)
+
+        [m, n] = X.shape
+        P = torch.zeros((m, n))
+        u = torch.zeros((m, n))
+        V = torch.zeros((m, n))
+        K = torch.zeros((m, n))
+
+        K[:, 0] = (V0 * C / (C * V0 * C + sigma)) * torch.ones((m, ))
+        u[:, 0] = u0 + K[:, 0] * (X[:, 0] - C * u0)
+        V[:, 0] = (torch.ones((m, )) - K[:, 0] * C) * V0
+
+        for i in range(1, n):
+            P[:, i - 1] = A * V[:, i - 1] * A + T
+            K[:, i] = P[:, i - 1] * C / (C * P[:, i - 1] * C + sigma)
+            u[:,
+              i] = A * u[:, i - 1] + K[:, i] * (X[:, i] - C * A * u[:, i - 1])
+            V[:, i] = (torch.ones((m, )) - K[:, i] * C) * P[:, i - 1]
+
+        X = u
+
+        return [sample.reshape(shape) for sample in X.transpose(1, 0)]
+
+    else:
+        raise ValueError(
+            'The after_hook_linear_dynamical_system only supports np.ndarray and torch.Tensor. Please make sure the outputs of offline_transform ({}) are np.ndarray or torch.Tensor.'
+            .format(type(data[0])))
\ No newline at end of file
diff --git a/torcheeg/transforms/hooks/before_hook.py b/torcheeg/transforms/hooks/before_hook.py
new file mode 100644
index 0000000..52ca59d
--- /dev/null
+++ b/torcheeg/transforms/hooks/before_hook.py
@@ -0,0 +1,56 @@
+import numpy as np
+
+
+def before_hook_normalize(data: np.ndarray,
+                          eps: float = 1e-6,
+                          axis=0) -> np.ndarray:
+    r'''
+    A common hook function used to normalize the signal of the whole trial/session/subject before dividing it into chunks.
+
+    It is used as follows:
+
+    .. code-block:: python
+
+        from functools import partial
+        from torcheeg.datasets import SEEDFeatureDataset
+        from torcheeg.transforms import before_hook_normalize
+
+        dataset = SEEDFeatureDataset(root_path='./ExtractedFeatures',
+                                     feature=['de_movingAve'],
+                                     offline_transform=transforms.ToGrid       (SEED_CHANNEL_LOCATION_DICT),
+                                     online_transform=transforms.ToTensor(),
+                                     before_trial=before_hook_normalize,
+                                     label_transform=transforms.Compose([
+                                         transforms.Select('emotion'),
+                                         transforms.Lambda(lambda x: x + 1)
+                                     ]))
+
+    If you want to pass in parameters, use partial to generate a new function:
+
+    .. code-block:: python
+
+        from functools import partial
+        from torcheeg.datasets import SEEDFeatureDataset
+        from torcheeg.transforms import before_hook_normalize
+
+        dataset = SEEDFeatureDataset(root_path='./ExtractedFeatures',
+                                     feature=['de_movingAve'],
+                                     offline_transform=transforms.ToGrid       (SEED_CHANNEL_LOCATION_DICT),
+                                     online_transform=transforms.ToTensor(),
+                                     before_trial=partial(before_hook_normalize, eps=1e-5),
+                                     label_transform=transforms.Compose([
+                                         transforms.Select('emotion'),
+                                         transforms.Lambda(lambda x: x + 1)
+                                     ]))
+
+    Args:
+        data (np.ndarray): The input EEG signals or features of a trial.
+        axis (int): The axis along which to normalize the data (default: :obj:`0`)
+        eps (float): The term added to the denominator to improve numerical stability (default: :obj:`1e-6`)
+        
+    Returns:
+        np.ndarray: The normalized results of a trial.
+    '''
+    min_v = data.min(axis=axis, keepdims=True)
+    max_v = data.max(axis=axis, keepdims=True)
+    return (data - min_v) / (max_v - min_v + eps)
\ No newline at end of file
diff --git a/torcheeg/transforms/label/binary.py b/torcheeg/transforms/label/binary.py
index e7706e9..a5c85b0 100644
--- a/torcheeg/transforms/label/binary.py
+++ b/torcheeg/transforms/label/binary.py
@@ -11,16 +11,20 @@ class Binary(LabelTransform):
     
     .. code-block:: python
 
-        transform = Binary(threshold=5.0)
-        transform(y=4.5)['y']
+        from torcheeg import transforms
+
+        t = transforms.Binary(threshold=5.0)
+        t(y=4.5)['y']
         >>> 0
 
     :obj:`Binary` allows simultaneous binarization using the same threshold for multiple labels.
 
     .. code-block:: python
 
-        transform = Binary(threshold=5.0)
-        transform(y=[4.5, 5.5])['y']
+        from torcheeg import transforms
+
+        t = transforms.Binary(threshold=5.0)
+        t(y=[4.5, 5.5])['y']
         >>> [0, 1]
 
     Args:
@@ -59,16 +63,20 @@ class BinaryOneVSRest(LabelTransform):
     
     .. code-block:: python
 
-        transform = BinaryOneVSRest(positive=1)
-        transform(y=2)['y']
+        from torcheeg import transforms
+
+        t = BinaryOneVSRest(positive=1)
+        t(y=2)['y']
         >>> 0
 
     :obj:`Binary` allows simultaneous binarization using the same threshold for multiple labels.
 
     .. code-block:: python
 
-        transform = BinaryOneVSRest(positive=1)
-        transform(y=[1, 2])['y']
+        from torcheeg import transforms
+
+        t = transforms.BinaryOneVSRest(positive=1)
+        t(y=[1, 2])['y']
         >>> [1, 0]
 
     Args:
@@ -99,14 +107,16 @@ class BinariesToCategory(LabelTransform):
     
     .. code-block:: python
 
-        transform = BinariesToCategory()
-        transform(y=[0, 0])['y']
+        from torcheeg import transforms
+
+        t = transforms.BinariesToCategory()
+        t(y=[0, 0])['y']
         >>> 0
-        transform(y=[0, 1])['y']
+        t(y=[0, 1])['y']
         >>> 1
-        transform(y=[1, 0])['y']
+        t(y=[1, 0])['y']
         >>> 2
-        transform(y=[1, 1])['y']
+        t(y=[1, 1])['y']
         >>> 3
     
     .. automethod:: __call__
diff --git a/torcheeg/transforms/label/fix.py b/torcheeg/transforms/label/fix.py
index ce7629d..7cf3bef 100644
--- a/torcheeg/transforms/label/fix.py
+++ b/torcheeg/transforms/label/fix.py
@@ -9,16 +9,20 @@ class FixCategory(LabelTransform):
 
     .. code-block:: python
 
-        transform = FixCategory(value=0)
-        transform(y=3)['y']
+        from torcheeg import transforms
+
+        t = transforms.FixCategory(value=0)
+        t(y=3)['y']
         >>> 0
 
     :obj:`FixCategory` allows multiple values to be selected and returned as a list. Suitable for multi-classification tasks or multi-task learning.
 
     .. code-block:: python
 
-        transform = FixCategory(value=[0, 1])
-        transform(y=[1, 2])['y']
+        from torcheeg import transforms
+
+        t = transforms.FixCategory(value=[0, 1])
+        t(y=[1, 2])['y']
         >>> [0, 1]
 
     Args:
diff --git a/torcheeg/transforms/label/mapping.py b/torcheeg/transforms/label/mapping.py
index c533c01..34902ad 100644
--- a/torcheeg/transforms/label/mapping.py
+++ b/torcheeg/transforms/label/mapping.py
@@ -9,24 +9,28 @@ class Mapping(LabelTransform):
     
     .. code-block:: python
 
-        transform = Mapping({
+        from torcheeg import transforms
+
+        t = Mapping({
             'left_hand': 0,
             'right_hand': 1,
         })
-        transform(y='left_hand')['y']
+        t(y='left_hand')['y']
         >>> 0
 
     :obj:`Mapping` allows simultaneous binarization using the same threshold for multiple labels.
 
     .. code-block:: python
 
-        transform = Mapping({
+        from torcheeg import transforms
+        
+        t = Mapping({
             'left_hand': 0,
             'right_hand': 1,
             'left_feet': 0,
             'right_feet': 1
         })
-        transform(y=['left_hand', 'left_feet'])['y']
+        t(y=['left_hand', 'left_feet'])['y']
         >>> [0, 0]
 
     Args:
diff --git a/torcheeg/transforms/label/select.py b/torcheeg/transforms/label/select.py
index 3f30d51..3c366a6 100644
--- a/torcheeg/transforms/label/select.py
+++ b/torcheeg/transforms/label/select.py
@@ -9,16 +9,20 @@ class Select(LabelTransform):
 
     .. code-block:: python
 
-        transform = Select(key='valence')
-        transform(y={'valence': 4.5, 'arousal': 5.5, 'subject_id': 7})['y']
+        from torcheeg import transforms
+
+        t = transforms.Select(key='valence')
+        t(y={'valence': 4.5, 'arousal': 5.5, 'subject_id': 7})['y']
         >>> 4.5
 
     :obj:`Select` allows multiple values to be selected and returned as a list. Suitable for multi-classification tasks or multi-task learning.
 
     .. code-block:: python
+        
+        from torcheeg import transforms
 
-        transform = Select(key=['valence', 'arousal'])
-        transform(y={'valence': 4.5, 'arousal': 5.5, 'subject_id': 7})['y']
+        t = transforms.Select(key=['valence', 'arousal'])
+        t(y={'valence': 4.5, 'arousal': 5.5, 'subject_id': 7})['y']
         >>> [4.5, 5.5]
 
     Args:
diff --git a/torcheeg/transforms/label/string.py b/torcheeg/transforms/label/string.py
index 1996c7c..8dba4f0 100644
--- a/torcheeg/transforms/label/string.py
+++ b/torcheeg/transforms/label/string.py
@@ -11,20 +11,22 @@ class StringToInt(LabelTransform):
     
     .. code-block:: python
 
-        transform = StringToInt()
-        transform(y='None')['y']
+        from torcheeg import transforms
+
+        t = transforms.StringToInt()
+        t(y='None')['y']
         >>> 0
 
-        transform = StringToInt()
-        transform(y='sub001')['y']
+        t = transforms.StringToInt()
+        t(y='sub001')['y']
         >>> 1
 
     :obj:`StringToInt` allows converting a list of strings to a list of numbers with the same conversion behavior as a single string.
 
     .. code-block:: python
 
-        transform = StringToInt()
-        transform(y=['sub001', '4'])['y']
+        t = transforms.StringToInt()
+        t(y=['sub001', '4'])['y']
         >>> 1, 4
 
     .. automethod:: __call__
diff --git a/torcheeg/transforms/numpy/band.py b/torcheeg/transforms/numpy/band.py
index 6a2572a..a587b8b 100644
--- a/torcheeg/transforms/numpy/band.py
+++ b/torcheeg/transforms/numpy/band.py
@@ -64,8 +64,10 @@ class BandSignal(BandTransform):
 
     .. code-block:: python
 
-        transform = BandSignal()
-        transform(eeg=np.random.randn(32, 128))['eeg'].shape
+        from torcheeg import transforms
+
+        t = transforms.BandSignal()
+        t(eeg=np.random.randn(32, 128))['eeg'].shape
         >>> (4, 32, 128)
 
     Args:
@@ -121,8 +123,10 @@ class BandDifferentialEntropy(BandTransform):
     
     .. code-block:: python
 
-        transform = BandDifferentialEntropy()
-        transform(eeg=np.random.randn(32, 128))['eeg'].shape
+        from torcheeg import transforms
+
+        t = transforms.BandDifferentialEntropy()
+        t(eeg=np.random.randn(32, 128))['eeg'].shape
         >>> (32, 4)
 
     Args:
@@ -160,8 +164,10 @@ class BandDifferentialEntropyV1(EEGTransform):
 
     .. code-block:: python
 
-        transform = BandDifferentialEntropyV1()
-        transform(eeg=np.random.randn(32, 128))['eeg'].shape
+        from torcheeg import transforms
+
+        t = transforms.BandDifferentialEntropyV1()
+        t(eeg=np.random.randn(32, 128))['eeg'].shape
         >>> (32, 4)
 
     Args:
@@ -253,8 +259,10 @@ class BandPowerSpectralDensity(EEGTransform):
 
     .. code-block:: python
 
-        transform = BandPowerSpectralDensity()
-        transform(eeg=np.random.randn(32, 128))['eeg'].shape
+        from torcheeg import transforms
+
+        t = transforms.BandPowerSpectralDensity()
+        t(eeg=np.random.randn(32, 128))['eeg'].shape
         >>> (32, 4)
 
     Args:
@@ -347,8 +355,10 @@ class BandMeanAbsoluteDeviation(BandTransform):
 
     .. code-block:: python
 
-        transform = BandMeanAbsoluteDeviation()
-        transform(eeg=np.random.randn(32, 128))['eeg'].shape
+        from torcheeg import transforms
+
+        t = transforms.BandMeanAbsoluteDeviation()
+        t(eeg=np.random.randn(32, 128))['eeg'].shape
         >>> (32, 4)
 
     Args:
@@ -382,8 +392,10 @@ class BandKurtosis(BandTransform):
 
     .. code-block:: python
 
-        transform = BandKurtosis()
-        transform(eeg=np.random.randn(32, 128))['eeg'].shape
+        from torcheeg import transforms
+
+        t = transforms.BandKurtosis()
+        t(eeg=np.random.randn(32, 128))['eeg'].shape
         >>> (32, 4)
 
     Args:
@@ -429,8 +441,10 @@ class BandSkewness(BandTransform):
 
     .. code-block:: python
 
-        transform = BandSkewness()
-        transform(eeg=np.random.randn(32, 128))['eeg'].shape
+        from torcheeg import transforms
+
+        t = transforms.BandSkewness()
+        t(eeg=np.random.randn(32, 128))['eeg'].shape
         >>> (32, 4)
 
     Args:
diff --git a/torcheeg/transforms/numpy/band_pyeeg.py b/torcheeg/transforms/numpy/band_pyeeg.py
index 2e39ede..faf3b1a 100644
--- a/torcheeg/transforms/numpy/band_pyeeg.py
+++ b/torcheeg/transforms/numpy/band_pyeeg.py
@@ -87,8 +87,10 @@ class BandApproximateEntropy(BandTransform):
 
     .. code-block:: python
 
-        transform = BandApproximateEntropy()
-        transform(eeg=np.random.randn(32, 128))['eeg'].shape
+        from torcheeg import transforms
+
+        t = transforms.BandApproximateEntropy()
+        t(eeg=np.random.randn(32, 128))['eeg'].shape
         >>> (32, 4)
 
     Args:
@@ -175,8 +177,10 @@ class BandSampleEntropy(BandTransform):
 
     .. code-block:: python
 
-        transform = BandSampleEntropy()
-        transform(eeg=np.random.randn(32, 128))['eeg'].shape
+        from torcheeg import transforms
+
+        t = transforms.BandSampleEntropy()
+        t(eeg=np.random.randn(32, 128))['eeg'].shape
         >>> (32, 4)
 
     Args:
@@ -259,8 +263,10 @@ class BandSVDEntropy(BandTransform):
 
     .. code-block:: python
 
-        transform = BandSVDEntropy()
-        transform(eeg=np.random.randn(32, 128))['eeg'].shape
+        from torcheeg import transforms
+
+        t = transforms.BandSVDEntropy()
+        t(eeg=np.random.randn(32, 128))['eeg'].shape
         >>> (32, 4)
 
     Args:
@@ -338,8 +344,10 @@ class BandDetrendedFluctuationAnalysis(BandTransform):
 
     .. code-block:: python
 
-        transform = BandDetrendedFluctuationAnalysis()
-        transform(eeg=np.random.randn(32, 128))['eeg'].shape
+        from torcheeg import transforms
+
+        t = transforms.BandDetrendedFluctuationAnalysis()
+        t(eeg=np.random.randn(32, 128))['eeg'].shape
         >>> (32, 4)
 
     Args:
@@ -441,8 +449,10 @@ class BandHiguchiFractalDimension(BandTransform):
 
     .. code-block:: python
 
-        transform = BandHiguchiFractalDimension()
-        transform(eeg=np.random.randn(32, 128))['eeg'].shape
+        from torcheeg import transforms
+
+        t = transforms.BandHiguchiFractalDimension()
+        t(eeg=np.random.randn(32, 128))['eeg'].shape
         >>> (32, 4)
 
     Args:
@@ -519,8 +529,10 @@ class BandHjorth(BandTransform):
 
     .. code-block:: python
 
-        transform = BandHjorth()
-        transform(eeg=np.random.randn(32, 128))['eeg'].shape
+        from torcheeg import transforms
+
+        t = transforms.BandHjorth()
+        t(eeg=np.random.randn(32, 128))['eeg'].shape
         >>> (32, 4)
 
     Args:
@@ -611,8 +623,10 @@ class BandHurst(BandTransform):
 
     .. code-block:: python
 
-        transform = BandHurst()
-        transform(eeg=np.random.randn(32, 128))['eeg'].shape
+        from torcheeg import transforms
+
+        t = transforms.BandHurst()
+        t(eeg=np.random.randn(32, 128))['eeg'].shape
         >>> (32, 4)
 
     If the output H=0.5,the behavior of the EEG signals is similar to random walk. If H<0.5, the EEG signals cover less "distance" than a random walk, vice verse.
@@ -669,8 +683,10 @@ class BandPetrosianFractalDimension(BandTransform):
 
     .. code-block:: python
 
-        transform = BandHiguchiFractalDimension()
-        transform(eeg=np.random.randn(32, 128))['eeg'].shape
+        from torcheeg import transforms
+
+        t = transforms.BandHiguchiFractalDimension()
+        t(eeg=np.random.randn(32, 128))['eeg'].shape
         >>> (32, 4)
 
     Args:
@@ -757,8 +773,10 @@ class BandBinPower(EEGTransform):
 
     .. code-block:: python
 
-        transform = BandBinPower()
-        transform(eeg=np.random.randn(32, 128))['eeg'].shape
+        from torcheeg import transforms
+
+        t = transforms.BandBinPower()
+        t(eeg=np.random.randn(32, 128))['eeg'].shape
         >>> (32, 4)
 
     Args:
@@ -830,8 +848,10 @@ class BandSpectralEntropy(EEGTransform):
 
     .. code-block:: python
 
-        transform = BandSampleEntropy()
-        transform(eeg=np.random.randn(32, 128))['eeg'].shape
+        from torcheeg import transforms
+
+        t = transforms.BandSampleEntropy()
+        t(eeg=np.random.randn(32, 128))['eeg'].shape
         >>> (32, 4)
 
     Args:
diff --git a/torcheeg/transforms/numpy/coefficient.py b/torcheeg/transforms/numpy/coefficient.py
index e276d4f..ca00982 100644
--- a/torcheeg/transforms/numpy/coefficient.py
+++ b/torcheeg/transforms/numpy/coefficient.py
@@ -12,8 +12,10 @@ class ARRCoefficient(EEGTransform):
 
     .. code-block:: python
 
-        transform = ARRCoefficient(order=4)
-        transform(eeg=np.random.randn(32, 128))['eeg'].shape
+        from torcheeg import transforms
+
+        t = transforms.ARRCoefficient(order=4)
+        t(eeg=np.random.randn(32, 128))['eeg'].shape
         >>> (32, 4)
 
     Args:
diff --git a/torcheeg/transforms/numpy/concatenate.py b/torcheeg/transforms/numpy/concatenate.py
index 93f2352..cc9b884 100644
--- a/torcheeg/transforms/numpy/concatenate.py
+++ b/torcheeg/transforms/numpy/concatenate.py
@@ -11,11 +11,13 @@ class Concatenate(EEGTransform):
 
     .. code-block:: python
 
-        transform = Concatenate([
-            BandDifferentialEntropy(),
-            BandMeanAbsoluteDeviation()
+        from torcheeg import transforms
+
+        t = transforms.Concatenate([
+            transforms.BandDifferentialEntropy(),
+            transforms.BandMeanAbsoluteDeviation()
         ])
-        transform(eeg=np.random.randn(32, 128))['eeg'].shape
+        t(eeg=np.random.randn(32, 128))['eeg'].shape
         >>> (32, 8)
 
     Args:
@@ -85,30 +87,34 @@ class MapChunk(EEGTransform):
 
     .. code-block:: python
 
-        transform = MapChunk(
-            BandDifferentialEntropy(),
+        from torcheeg import transforms
+
+        t = transforms.MapChunk(
+            transforms.BandDifferentialEntropy(),
             chunk_size=250,
             overlap=0
         )
-        transform(eeg=np.random.randn(64, 1000))['eeg'].shape
+        t(eeg=np.random.randn(64, 1000))['eeg'].shape
         >>> (64, 16)
 
     TorchEEG allows feature fusion at multiple scales:
 
     .. code-block:: python
 
-        transform = Concatenate([
-            MapChunk(
-                BandDifferentialEntropy()
+        from torcheeg import transforms
+
+        t = transforms.Concatenate([
+            transforms.MapChunk(
+                transforms.BandDifferentialEntropy()
                 chunk_size=250,
                 overlap=0),  # 4 chunk * 4-dim feature
-            MapChunk(
-                BandDifferentialEntropy()
+            transforms.MapChunk(
+                transforms.BandDifferentialEntropy()
                 chunk_size=500,
                 overlap=0),  # 2 chunk * 4-dim feature
-            BandDifferentialEntropy()  # 1 chunk * 4-dim feature
+            transforms.BandDifferentialEntropy()  # 1 chunk * 4-dim feature
         ])
-        transform(eeg=np.random.randn(64, 1000))['eeg'].shape
+        t(eeg=np.random.randn(64, 1000))['eeg'].shape
         >>> (64, 28) # 4 * 4 + 2 * 4 + 1 * 4
 
     Args:
diff --git a/torcheeg/transforms/numpy/correlation.py b/torcheeg/transforms/numpy/correlation.py
index c431180..5758757 100644
--- a/torcheeg/transforms/numpy/correlation.py
+++ b/torcheeg/transforms/numpy/correlation.py
@@ -45,8 +45,10 @@ class PearsonCorrelation(CorrelationTransform):
 
     .. code-block:: python
 
-        transform = PearsonCorrelation()
-        transform(eeg=np.random.randn(32, 128))['eeg'].shape
+        from torcheeg import transforms
+
+        t = transforms.PearsonCorrelation()
+        t(eeg=np.random.randn(32, 128))['eeg'].shape
         >>> (1, 32, 32)
 
     Args:
@@ -91,8 +93,10 @@ class PhaseLockingCorrelation(CorrelationTransform):
 
     .. code-block:: python
 
-        transform = PhaseLockingCorrelation()
-        transform(eeg=np.random.randn(32, 128))['eeg'].shape
+        from torcheeg import transforms
+
+        t = transforms.PhaseLockingCorrelation()
+        t(eeg=np.random.randn(32, 128))['eeg'].shape
         >>> (1, 32, 32)
 
     Args:
diff --git a/torcheeg/transforms/numpy/downsample.py b/torcheeg/transforms/numpy/downsample.py
index 9b45f23..fa15e9e 100644
--- a/torcheeg/transforms/numpy/downsample.py
+++ b/torcheeg/transforms/numpy/downsample.py
@@ -11,9 +11,11 @@ class Downsample(EEGTransform):
 
     .. code-block:: python
 
-        transform = Downsample(num_points=32, axis=-1)
+        from torcheeg import transforms
+
+        t = transforms.Downsample(num_points=32, axis=-1)
         # normalize along the first dimension (electrode dimension)
-        transform(eeg=np.random.randn(32, 128))['eeg'].shape
+        t(eeg=np.random.randn(32, 128))['eeg'].shape
         >>> (32, 32)
 
     Args:
diff --git a/torcheeg/transforms/numpy/flatten.py b/torcheeg/transforms/numpy/flatten.py
index d9fa34b..b287236 100644
--- a/torcheeg/transforms/numpy/flatten.py
+++ b/torcheeg/transforms/numpy/flatten.py
@@ -11,8 +11,10 @@ class Flatten(EEGTransform):
 
     .. code-block:: python
 
-        transform = Flatten()
-        transform(eeg=np.random.randn(62, 5))['eeg'].shape
+        from torcheeg import transforms
+        
+        t = transforms.Flatten()
+        t(eeg=np.random.randn(62, 5))['eeg'].shape
         >>> (310,)
 
     .. automethod:: __call__
diff --git a/torcheeg/transforms/numpy/normalize.py b/torcheeg/transforms/numpy/normalize.py
index 867e221..3019a1e 100644
--- a/torcheeg/transforms/numpy/normalize.py
+++ b/torcheeg/transforms/numpy/normalize.py
@@ -11,14 +11,16 @@ class MeanStdNormalize(EEGTransform):
 
     .. code-block:: python
 
-        transform = MeanStdNormalize(axis=0)
+        from torcheeg import transforms
+
+        t = transforms.MeanStdNormalize(axis=0)
         # normalize along the first dimension (electrode dimension)
-        transform(eeg=np.random.randn(32, 128))['eeg'].shape
+        t(eeg=np.random.randn(32, 128))['eeg'].shape
         >>> (32, 128)
 
-        transform = MeanStdNormalize(axis=1)
+        t = transforms.MeanStdNormalize(axis=1)
         # normalize along the second dimension (temproal dimension)
-        transform(eeg=np.random.randn(32, 128))['eeg'].shape
+        t(eeg=np.random.randn(32, 128))['eeg'].shape
         >>> (32, 128)
 
     Args:
@@ -93,14 +95,18 @@ class MinMaxNormalize(EEGTransform):
 
     .. code-block:: python
 
-        transform = MinMaxNormalize(axis=0)
+        from torcheeg import transforms
+
+        t = transforms.MinMaxNormalize(axis=0)
         # normalize along the first dimension (electrode dimension)
-        transform(eeg=np.random.randn(32, 128))['eeg'].shape
+        t(eeg=np.random.randn(32, 128))['eeg'].shape
         >>> (32, 128)
 
-        transform = MinMaxNormalize(axis=1)
+        from torcheeg import transforms
+        
+        t = transforms.MinMaxNormalize(axis=1)
         # normalize along the second dimension (temproal dimension)
-        transform(eeg=np.random.randn(32, 128))['eeg'].shape
+        t(eeg=np.random.randn(32, 128))['eeg'].shape
         >>> (32, 128)
 
     Args:
diff --git a/torcheeg/transforms/numpy/pick.py b/torcheeg/transforms/numpy/pick.py
index a69dd85..2e41e5d 100644
--- a/torcheeg/transforms/numpy/pick.py
+++ b/torcheeg/transforms/numpy/pick.py
@@ -11,7 +11,10 @@ class PickElectrode(EEGTransform):
 
     .. code-block:: python
 
-        transform = PickElectrode(PickElectrode.to_index_list(
+        from torcheeg import transforms
+        from torcheeg.datasets.constants import DEAP_CHANNEL_LIST
+
+        t = transforms.PickElectrode(transforms.PickElectrode.to_index_list(
             ['FP1', 'AF3', 'F3', 'F7',
              'FC5', 'FC1', 'C3', 'T7',
              'CP5', 'CP1', 'P3', 'P7',
@@ -19,7 +22,7 @@ class PickElectrode(EEGTransform):
              'F4', 'F8', 'FC6', 'FC2',
              'C4', 'T8', 'CP6', 'CP2',
              'P4', 'P8', 'PO4', 'O2'], DEAP_CHANNEL_LIST))
-        transform(eeg=np.random.randn(32, 128))['eeg'].shape
+        t(eeg=np.random.randn(32, 128))['eeg'].shape
         >>> (28, 128)
 
     Args:
diff --git a/torcheeg/transforms/numpy/rearrange.py b/torcheeg/transforms/numpy/rearrange.py
index 45ca87a..188160a 100644
--- a/torcheeg/transforms/numpy/rearrange.py
+++ b/torcheeg/transforms/numpy/rearrange.py
@@ -11,12 +11,14 @@ class RearrangeElectrode(EEGTransform):
 
     .. code-block:: python
 
-        transform = RearrangeElectrode(
+        from torcheeg import transforms
+
+        t = transforms.RearrangeElectrode(
             source=['FP1', 'F3', 'F7'],
             target=['F3', 'F7', 'FP1', 'AF2'],
             missing='mean'
         )
-        transform(eeg=np.random.randn(3, 128))['eeg'].shape
+        t(eeg=np.random.randn(3, 128))['eeg'].shape
         >>> (4, 128)
 
     Args:
diff --git a/torcheeg/transforms/numpy/spectrum.py b/torcheeg/transforms/numpy/spectrum.py
index f93eecb..7a4b418 100644
--- a/torcheeg/transforms/numpy/spectrum.py
+++ b/torcheeg/transforms/numpy/spectrum.py
@@ -14,28 +14,34 @@ class CWTSpectrum(EEGTransform):
 
         .. code-block:: python
 
-            transform = CWTSpectrum()
-            transform(eeg=np.random.randn(32, 1000))['eeg'].shape
+            from torcheeg import transforms
+
+            t = transforms.CWTSpectrum()
+            t(eeg=np.random.randn(32, 1000))['eeg'].shape
             >>> (32, 128, 1000)
 
         Part of the existing work uses :obj:`Resize` to warp the output spectrum to a specified size suitable for CNN processing.
 
         .. code-block:: python
 
-            transform = Compose([
+            from torcheeg import transforms
+        
+            t = Compose([
                 CWTSpectrum(),
                 ToTensor(),
                 Resize([260, 260])
             ])
-            transform(eeg=np.random.randn(32, 1000))['eeg'].shape
+            t(eeg=np.random.randn(32, 1000))['eeg'].shape
             >>> (32, 128, 1000)
 
         When contourf is set to True, a spectrogram of filled contours will be generated for each channel and converted to np.ndarray and returned. This option is usually used for single-channel analysis or visualization of a single channel.
 
         .. code-block:: python
 
-            transform = CWTSpectrum(contourf=True)
-            transform(eeg=np.random.randn(32, 1000))['eeg'].shape
+            from torcheeg import transforms
+
+            t = CWTSpectrum(contourf=True)
+            t(eeg=np.random.randn(32, 1000))['eeg'].shape
             >>> (32, 480, 640, 4)
 
         Args:
@@ -137,8 +143,10 @@ class DWTDecomposition(EEGTransform):
 
         .. code-block:: python
 
-            transform = DWTDecomposition()
-            transform(eeg=np.random.randn(32, 1000))['eeg'].shape
+            from torcheeg import transforms
+
+            t = transforms.DWTDecomposition()
+            t(eeg=np.random.randn(32, 1000))['eeg'].shape
             >>> (32, 500)
 
         Args:
diff --git a/torcheeg/transforms/numpy/to.py b/torcheeg/transforms/numpy/to.py
index 7517eca..31a8af8 100644
--- a/torcheeg/transforms/numpy/to.py
+++ b/torcheeg/transforms/numpy/to.py
@@ -13,8 +13,10 @@ class To2d(EEGTransform):
 
     .. code-block:: python
 
-        transform = To2d()
-        transform(eeg=np.random.randn(32, 128))['eeg'].shape
+        from torcheeg import transforms
+
+        t = transforms.To2d()
+        t(eeg=np.random.randn(32, 128))['eeg'].shape
         >>> (1, 32, 128)
 
     .. automethod:: __call__
@@ -49,8 +51,11 @@ class ToGrid(EEGTransform):
 
     .. code-block:: python
 
-        transform = ToGrid(DEAP_CHANNEL_LOCATION_DICT)
-        transform(eeg=np.random.randn(32, 128))['eeg'].shape
+        from torcheeg import transforms
+        from torcheeg.datasets.constants import DEAP_CHANNEL_LOCATION_DICT
+
+        t = transforms.ToGrid(DEAP_CHANNEL_LOCATION_DICT)
+        t(eeg=np.random.randn(32, 128))['eeg'].shape
         >>> (128, 9, 9)
 
     Args:
@@ -144,8 +149,11 @@ class ToInterpolatedGrid(EEGTransform):
 
     .. code-block:: python
     
-        transform = ToInterpolatedGrid(DEAP_CHANNEL_LOCATION_DICT)
-        transform(eeg=np.random.randn(32, 128))['eeg'].shape
+        from torcheeg import transforms
+        from torcheeg.datasets.constants import DEAP_CHANNEL_LOCATION_DICT
+
+        t = ToInterpolatedGrid(DEAP_CHANNEL_LOCATION_DICT)
+        t(eeg=np.random.randn(32, 128))['eeg'].shape
         >>> (128, 9, 9)
 
     Especially, missing values on the grid are supplemented using cubic interpolation
diff --git a/torcheeg/transforms/pyg/to.py b/torcheeg/transforms/pyg/to.py
index 1454436..7ae9606 100644
--- a/torcheeg/transforms/pyg/to.py
+++ b/torcheeg/transforms/pyg/to.py
@@ -21,8 +21,11 @@ class ToG(EEGTransform):
 
     .. code-block:: python
 
-        transform = ToG(adj=DEAP_ADJACENCY_MATRIX)
-        transform(eeg=np.random.randn(32, 128))['eeg']
+        from torcheeg.transforms.pyg import ToG
+        from torcheeg.datasets.constants import DEAP_ADJACENCY_MATRIX
+
+        t = ToG(adj=DEAP_ADJACENCY_MATRIX)
+        t(eeg=np.random.randn(32, 128))['eeg']
         >>> torch_geometric.data.Data
 
     Args:
@@ -127,20 +130,22 @@ class ToDynamicG(EEGTransform):
 
     .. code-block:: python
 
-        transform = ToDynamicG(edge_func='gaussian_distance', sigma=1.0, top_k=10, complete_graph=False)
-        transform(eeg=np.random.randn(32, 128))['eeg']
+        from torcheeg.transforms.pyg import ToDynamicG
+
+        t = ToDynamicG(edge_func='gaussian_distance', sigma=1.0, top_k=10, complete_graph=False)
+        t(eeg=np.random.randn(32, 128))['eeg']
         >>> Data(edge_index=[2, 320], x=[32, 128], edge_weight=[320])
 
-        transform = ToDynamicG(edge_func='absolute_pearson_correlation_coefficient', threshold=0.1, binary=True)
-        transform(eeg=np.random.randn(32, 128))['eeg']
+        t = ToDynamicG(edge_func='absolute_pearson_correlation_coefficient', threshold=0.1, binary=True)
+        t(eeg=np.random.randn(32, 128))['eeg']
         >>> Data(edge_index=[2, 310], x=[32, 128], edge_weight=[310])
 
-        transform = ToDynamicG(edge_func='phase_locking_value')
-        transform(eeg=np.random.randn(32, 128))['eeg']
+        t = ToDynamicG(edge_func='phase_locking_value')
+        t(eeg=np.random.randn(32, 128))['eeg']
         >>> Data(edge_index=[2, 992], x=[32, 128], edge_weight=[992])
 
-        transform = ToDynamicG(edge_func=lambda x, y: (x * y).mean())
-        transform(eeg=np.random.randn(32, 128))['eeg']
+        t = ToDynamicG(edge_func=lambda x, y: (x * y).mean())
+        t(eeg=np.random.randn(32, 128))['eeg']
         >>> Data(edge_index=[2, 1024], x=[32, 128], edge_weight=[1024])
 
     Args:
diff --git a/torcheeg/transforms/torch/contrastive.py b/torcheeg/transforms/torch/contrastive.py
index e4a55a6..7e4e984 100644
--- a/torcheeg/transforms/torch/contrastive.py
+++ b/torcheeg/transforms/torch/contrastive.py
@@ -12,10 +12,12 @@ class Contrastive(EEGTransform):
 
     .. code-block:: python
 
-        transform = Contrastive(RandomNoise(), num_views=2)
-        transform(eeg=torch.randn(32, 128))['eeg'][0].shape
+        from torcheeg import transforms
+
+        t = Contrastive(transforms.RandomNoise(), num_views=2)
+        t(eeg=torch.randn(32, 128))['eeg'][0].shape
         >>> (32, 128)
-        transform(eeg=torch.randn(32, 128))['eeg'][1].shape
+        t(eeg=torch.randn(32, 128))['eeg'][1].shape
         >>> (32, 128)
 
     .. automethod:: __call__
diff --git a/torcheeg/transforms/torch/random.py b/torcheeg/transforms/torch/random.py
index 521586e..c6f2e87 100644
--- a/torcheeg/transforms/torch/random.py
+++ b/torcheeg/transforms/torch/random.py
@@ -34,8 +34,10 @@ class RandomNoise(RandomEEGTransform):
     
     .. code-block:: python
 
-        transform = RandomNoise(p=0.5)
-        transform(eeg=torch.randn(32, 128))['eeg'].shape
+        from torcheeg import transforms
+
+        t = transforms.RandomNoise(p=0.5)
+        t(eeg=torch.randn(32, 128))['eeg'].shape
         >>> (32, 128)
 
     Args:
diff --git a/torcheeg/transforms/torch/resize.py b/torcheeg/transforms/torch/resize.py
index e9ec5f3..d1742a1 100644
--- a/torcheeg/transforms/torch/resize.py
+++ b/torcheeg/transforms/torch/resize.py
@@ -12,8 +12,10 @@ class Resize(EEGTransform):
 
     .. code-block:: python
 
-        transform = ToTensor(size=(64, 64))
-        transform(eeg=torch.randn(128, 9, 9))['eeg'].shape
+        from torcheeg import transforms
+
+        t = transforms.ToTensor(size=(64, 64))
+        t(eeg=torch.randn(128, 9, 9))['eeg'].shape
         >>> (128, 64, 64)
 
     Args:
diff --git a/torcheeg/transforms/torch/to.py b/torcheeg/transforms/torch/to.py
index c942006..648f905 100644
--- a/torcheeg/transforms/torch/to.py
+++ b/torcheeg/transforms/torch/to.py
@@ -13,8 +13,10 @@ class ToTensor(EEGTransform):
 
     .. code-block:: python
 
-        transform = ToTensor()
-        transform(eeg=np.random.randn(32, 128))['eeg'].shape
+        from torcheeg import transforms
+
+        t = transforms.ToTensor()
+        t(eeg=np.random.randn(32, 128))['eeg'].shape
         >>> (32, 128)
 
     Args:
diff --git a/torcheeg/utils/pyg/visualize.py b/torcheeg/utils/pyg/visualize.py
index 4120d0b..671451d 100644
--- a/torcheeg/utils/pyg/visualize.py
+++ b/torcheeg/utils/pyg/visualize.py
@@ -32,6 +32,11 @@ def plot_graph(data: Data,
     - ...
 
     .. code-block:: python
+        
+        from torcheeg.utils.pyg import plot_graph
+        from torcheeg.datasets.constants import DEAP_CHANNEL_LOCATION_DICT
+        from torcheeg.transforms.pyg import ToG
+        import numpy as np
 
         eeg = np.random.randn(32, 128)
         g = ToG(DEAP_ADJACENCY_MATRIX)(eeg=eeg)['eeg']
diff --git a/torcheeg/utils/visualize.py b/torcheeg/utils/visualize.py
index a2a7176..530c33d 100644
--- a/torcheeg/utils/visualize.py
+++ b/torcheeg/utils/visualize.py
@@ -36,6 +36,9 @@ def plot_raw_topomap(tensor: torch.Tensor,
 
     .. code-block:: python
 
+        from torcheeg.utils import plot_raw_topomap
+        from torcheeg.constants import DEAP_CHANNEL_LIST
+
         eeg = torch.randn(32, 128)
         img = plot_raw_topomap(eeg,
                          channel_list=DEAP_CHANNEL_LIST,
@@ -93,6 +96,9 @@ def plot_feature_topomap(tensor: torch.Tensor,
 
     .. code-block:: python
 
+        from torcheeg.utils import plot_feature_topomap
+        from torcheeg.constants import DEAP_CHANNEL_LIST
+
         eeg = torch.randn(32, 4)
         img = plot_feature_topomap(eeg,
                          channel_list=DEAP_CHANNEL_LIST,
@@ -164,6 +170,11 @@ def plot_signal(tensor: torch.Tensor,
 
     .. code-block:: python
 
+        import torch
+
+        from torcheeg.utils import plot_signal
+        from torcheeg.constants import DEAP_CHANNEL_LIST
+
         eeg = torch.randn(32, 128)
         img = plot_signal(eeg,
                           channel_list=DEAP_CHANNEL_LIST,
@@ -205,6 +216,8 @@ def plot_3d_tensor(tensor: torch.Tensor,
 
     .. code-block:: python
 
+        from torcheeg.utils import plot_3d_tensor
+
         eeg = torch.randn(128, 9, 9)
         img = plot_3d_tensor(eeg)
         # If using jupyter, the output image will be drawn on notebooks.
@@ -250,6 +263,10 @@ def plot_2d_tensor(tensor: torch.Tensor,
 
     .. code-block:: python
 
+        import torch
+
+        from torcheeg.utils import plot_2d_tensor
+
         eeg = torch.randn(9, 9)
         img = plot_2d_tensor(eeg)
         # If using jupyter, the output image will be drawn on notebooks.
@@ -291,6 +308,11 @@ def plot_adj_connectivity(adj: torch.Tensor,
 
     .. code-block:: python
 
+        import torch
+        
+        from torcheeg.utils import plot_adj_connectivity
+        from torcheeg.constants import SEED_CHANNEL_LIST
+        
         adj = torch.randn(62, 62) # relationship between 62 electrodes
         img = plot_adj_connectivity(adj, SEED_CHANNEL_LIST)
         # If using jupyter, the output image will be drawn on notebooks.


Test patch:
diff --git a/test/datasets/test_emotion_recognition.py b/test/datasets/test_emotion_recognition.py
index 43dc439..cc0b1aa 100644
--- a/test/datasets/test_emotion_recognition.py
+++ b/test/datasets/test_emotion_recognition.py
@@ -4,18 +4,54 @@
 import unittest
 
 from torcheeg import transforms
-from torcheeg.datasets import (AMIGOSDataset, DEAPDataset, DREAMERDataset,
-                               MAHNOBDataset, SEEDDataset, SEEDFeatureDataset,
-                               SEEDIVDataset, SEEDIVFeatureDataset,
-                               MPEDFeatureDataset, BCI2022Dataset)
+from torcheeg.datasets import (AMIGOSDataset, BCI2022Dataset, DEAPDataset,
+                               DREAMERDataset, MAHNOBDataset,
+                               MPEDFeatureDataset, SEEDDataset,
+                               SEEDFeatureDataset, SEEDIVDataset,
+                               SEEDIVFeatureDataset, SEEDVDataset,
+                               SEEDVFeatureDataset)
 
 
 class TestEmotionRecognitionDataset(unittest.TestCase):
+
     def setUp(self):
         if os.path.exists('./tmp_out/'):
             shutil.rmtree('./tmp_out/')
         os.mkdir('./tmp_out/')
 
+    def test_seed_v_dataset(self):
+        io_path = f'./tmp_out/seed_v_{"".join(random.sample("zyxwvutsrqponmlkjihgfedcba", 20))}'
+        root_path = './tmp_in/EEG_raw'
+
+        dataset = SEEDVDataset(io_path=io_path,
+                              root_path=root_path,
+                              online_transform=transforms.ToTensor(),
+                              label_transform=transforms.Select('emotion'),
+                              num_worker=4)
+
+        self.assertEqual(len(dataset), 29168)
+        first_item = dataset[0]
+        self.assertEqual(first_item[0].shape, (62, 800))
+        last_item = dataset[29167]
+        self.assertEqual(last_item[0].shape, (62, 800))
+
+    def test_seed_v_feature_dataset(self):
+        io_path = f'./tmp_out/seed_v_feature_{"".join(random.sample("zyxwvutsrqponmlkjihgfedcba", 20))}'
+        root_path = './tmp_in/EEG_DE_features'
+
+        dataset = SEEDVFeatureDataset(
+            io_path=io_path,
+            root_path=root_path,
+            online_transform=transforms.ToTensor(),
+            label_transform=transforms.Select('emotion'),
+            num_worker=4)
+
+        self.assertEqual(len(dataset), 29168)
+        first_item = dataset[0]
+        self.assertEqual(first_item[0].shape, (62, 5))
+        last_item = dataset[29167]
+        self.assertEqual(last_item[0].shape, (62, 5))
+
     def test_mped_feature_dataset(self):
         io_path = f'./tmp_out/mped_feature_{"".join(random.sample("zyxwvutsrqponmlkjihgfedcba", 20))}'
         root_path = './tmp_in/EEG_feature'
@@ -112,25 +148,6 @@ def test_dreamer_dataset(self):
         last_item = dataset[85743]
         self.assertEqual(last_item[0].shape, (14, 128))
 
-    def test_seed_dataset(self):
-        io_path = f'./tmp_out/seed_{"".join(random.sample("zyxwvutsrqponmlkjihgfedcba", 20))}'
-        root_path = './tmp_in/Preprocessed_EEG'
-
-        dataset = SEEDDataset(io_path=io_path,
-                              root_path=root_path,
-                              online_transform=transforms.ToTensor(),
-                              label_transform=transforms.Compose([
-                                  transforms.Select('emotion'),
-                                  transforms.Lambda(lambda x: int(x) + 1),
-                              ]),
-                              num_worker=4)
-
-        self.assertEqual(len(dataset), 152730)
-        first_item = dataset[0]
-        self.assertEqual(first_item[0].shape, (62, 200))
-        last_item = dataset[152729]
-        self.assertEqual(last_item[0].shape, (62, 200))
-
     def test_seed_feature_dataset(self):
         io_path = f'./tmp_out/seed_feature_{"".join(random.sample("zyxwvutsrqponmlkjihgfedcba", 20))}'
         root_path = './tmp_in/ExtractedFeatures'
diff --git a/test/models/test_gnn.py b/test/models/test_gnn.py
index dbc3420..4ff4842 100644
--- a/test/models/test_gnn.py
+++ b/test/models/test_gnn.py
@@ -3,7 +3,7 @@
 import torch
 from torch_geometric.data import Batch, Data
 
-from torcheeg.datasets.constants.emotion_recognition.deap import \
+from torcheeg.datasets.constants import \
     DEAP_GENERAL_REGION_LIST
 from torcheeg.models import DGCNN, LGGNet
 from torcheeg.models.pyg import GIN, RGNN
diff --git a/test/datasets/test_hooks.py b/test/transforms/test_hooks.py
similarity index 51%
rename from test/datasets/test_hooks.py
rename to test/transforms/test_hooks.py
index cf45459..ffe810f 100644
--- a/test/datasets/test_hooks.py
+++ b/test/transforms/test_hooks.py
@@ -3,18 +3,24 @@
 import shutil
 import unittest
 
+import numpy as np
+import torch
+
 from torcheeg import transforms
 from torcheeg.datasets import DEAPDataset
-from torcheeg.datasets.functional.hooks import before_trial_normalize, after_trial_normalize, after_trial_moving_avg
+from torcheeg.transforms import (after_hook_normalize, after_hook_running_norm,
+                                 after_hook_linear_dynamical_system,
+                                 before_hook_normalize)
 
 
 class TestHooks(unittest.TestCase):
+
     def setUp(self):
         if os.path.exists('./tmp_out/'):
             shutil.rmtree('./tmp_out/')
         os.mkdir('./tmp_out/')
 
-    def test_before_trial_after_trial(self):
+    def test_before_hook(self):
         io_path = f'./tmp_out/deap_{"".join(random.sample("zyxwvutsrqponmlkjihgfedcba", 20))}'
         root_path = './tmp_in/data_preprocessed_python'
 
@@ -26,30 +32,17 @@ def test_before_trial_after_trial(self):
                                   transforms.Binary(5.0),
                               ]),
                               num_worker=4,
-                              before_trial=before_trial_normalize)
+                              before_trial=before_hook_normalize)
         self.assertEqual(len(dataset), 76800)
         first_item = dataset[0]
         self.assertEqual(first_item[0].shape, (32, 128))
         last_item = dataset[76799]
         self.assertEqual(last_item[0].shape, (32, 128))
 
+    def test_after_hook(self):
+        root_path = './tmp_in/data_preprocessed_python'
         io_path = f'./tmp_out/deap_{"".join(random.sample("zyxwvutsrqponmlkjihgfedcba", 20))}'
-        dataset = DEAPDataset(io_path=io_path,
-                              root_path=root_path,
-                              online_transform=transforms.ToTensor(),
-                              label_transform=transforms.Compose([
-                                  transforms.Select('valence'),
-                                  transforms.Binary(5.0),
-                              ]),
-                              num_worker=4,
-                              after_trial=after_trial_normalize)
-        self.assertEqual(len(dataset), 76800)
-        first_item = dataset[0]
-        self.assertEqual(first_item[0].shape, (32, 128))
-        last_item = dataset[76799]
-        self.assertEqual(last_item[0].shape, (32, 128))
 
-        io_path = f'./tmp_out/deap_{"".join(random.sample("zyxwvutsrqponmlkjihgfedcba", 20))}'
         dataset = DEAPDataset(io_path=io_path,
                               root_path=root_path,
                               online_transform=transforms.ToTensor(),
@@ -58,13 +51,43 @@ def test_before_trial_after_trial(self):
                                   transforms.Binary(5.0),
                               ]),
                               num_worker=4,
-                              after_trial=after_trial_moving_avg)
+                              after_subject=after_hook_normalize)
         self.assertEqual(len(dataset), 76800)
         first_item = dataset[0]
         self.assertEqual(first_item[0].shape, (32, 128))
         last_item = dataset[76799]
         self.assertEqual(last_item[0].shape, (32, 128))
 
+        fake_data_np = [np.random.rand(32, 128) for _ in range(32)]
+        fake_data_torch = [torch.rand(32, 128) for _ in range(32)]
+
+        # Test after_hook_normalize
+        normalized_data = after_hook_normalize(fake_data_np)
+        self.assertEqual(len(normalized_data), 32)
+        self.assertEqual(normalized_data[0].shape, (32, 128))
+
+        normalized_data = after_hook_normalize(fake_data_torch)
+        self.assertEqual(len(normalized_data), 32)
+        self.assertEqual(normalized_data[0].shape, (32, 128))
+
+        # Test after_hook_running_norm
+        normalized_data = after_hook_running_norm(fake_data_np)
+        self.assertEqual(len(normalized_data), 32)
+        self.assertEqual(normalized_data[0].shape, (32, 128))
+
+        normalized_data = after_hook_running_norm(fake_data_torch)
+        self.assertEqual(len(normalized_data), 32)
+        self.assertEqual(normalized_data[0].shape, (32, 128))
+
+        # Test after_hook_linear_dynamical_system
+        normalized_data = after_hook_linear_dynamical_system(fake_data_np)
+        self.assertEqual(len(normalized_data), 32)
+        self.assertEqual(normalized_data[0].shape, (32, 128))
+
+        normalized_data = after_hook_linear_dynamical_system(fake_data_torch)
+        self.assertEqual(len(normalized_data), 32)
+        self.assertEqual(normalized_data[0].shape, (32, 128))
+
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/test/utils/test_visualize.py b/test/utils/test_visualize.py
index 7a362b6..62e83da 100644
--- a/test/utils/test_visualize.py
+++ b/test/utils/test_visualize.py
@@ -2,7 +2,7 @@
 
 import numpy as np
 import torch
-from torcheeg.datasets.constants.emotion_recognition.deap import (DEAP_ADJACENCY_MATRIX, DEAP_CHANNEL_LIST,
+from torcheeg.datasets.constants import (DEAP_ADJACENCY_MATRIX, DEAP_CHANNEL_LIST,
                                                                   DEAP_CHANNEL_LOCATION_DICT, DEAP_LOCATION_LIST)
 from torcheeg.datasets.constants.emotion_recognition.seed import \
     SEED_CHANNEL_LIST, SEED_GENERAL_REGION_LIST