sssm.sssm_core.model

Classes

Config
Context_Cont_configs
Model	Mixin class for all classifiers in scikit-learn.
TC
augmentations
base_Model	Base class for all neural network modules.

Module Contents

class sssm.sssm_core.model.Config

Bases: object

Context_Cont

TC

augmentation

batch_size = 3500

beta1 = 0.9

beta2 = 0.99

drop_last = True

dropout = 0.35

features_len = 15

final_out_channels = 128

input_channels = 1

kernel_size = 25

lr = 0.0003

num_classes = 7

num_epoch = 50

optimizer = 'adam'

stride = 3

class sssm.sssm_core.model.Context_Cont_configs

Bases: object

temperature = 0.2

use_cosine_similarity = True

class sssm.sssm_core.model.Model(device='cuda', model_name='model.pt', model_path=None)

Bases: sklearn.base.ClassifierMixin, sklearn.base.BaseEstimator

Mixin class for all classifiers in scikit-learn.

This mixin defines the following functionality:

• _estimator_type class attribute defaulting to “classifier”;

• score method that default to accuracy_score().

• enforce that fit requires y to be passed through the requires_y tag.

Read more in the User Guide.

Examples

>>> import numpy as np
>>> from sklearn.base import BaseEstimator, ClassifierMixin
>>> # Mixin classes should always be on the left-hand side for a correct MRO
>>> class MyEstimator(ClassifierMixin, BaseEstimator):
...     def __init__(self, *, param=1):
...         self.param = param
...     def fit(self, X, y=None):
...         self.is_fitted_ = True
...         return self
...     def predict(self, X):
...         return np.full(shape=X.shape[0], fill_value=self.param)
>>> estimator = MyEstimator(param=1)
>>> X = np.array([[1, 2], [2, 3], [3, 4]])
>>> y = np.array([1, 0, 1])
>>> estimator.fit(X, y).predict(X)
array([1, 1, 1])
>>> estimator.score(X, y)
0.66...

__load_model(model_path=None, model_name='model.pt')

__predict(data)

__rearrange_output(proba, fea, n_epoch)

__sliding_window_sample(X=None, step=50)

plot_predictions(epoch_ind=0)

predict(X=None, step=50)

input data, predict sleep event for each time step :param X: (n_epoch, n_time) :param step: 300 >= step >= 1 :return: predict_proba, pred, filtered pred, feature

predict_proba(X=None, step=50)

input data, predict sleep event for each time step :param X: (n_epoch, n_time) :param step: 300 >= step >= 1 :return: predict_proba, pred, filtered pred, feature

to_json()

to_pandas(overall_threshold=0.5, describe=False, event_threshold=None)

LABEL_LONG = ['Spindle', 'K-complex', 'Slow wave', 'Sawtooth', 'Vertex Sharp', 'Background', 'Arousal']

LABEL_SHORT = ['SS', 'KC', 'SW', 'SAW', 'VSW', 'BG', 'AR']

N_TIME = 300

device

feature = None

input_data_length = None

model

pred = None

proba = None

step = None

class sssm.sssm_core.model.TC

Bases: object

hidden_dim = 128

timesteps = 5

class sssm.sssm_core.model.augmentations

Bases: object

jitter_ratio = 2

jitter_scale_ratio = 1.5

max_seg = 12

class sssm.sssm_core.model.base_Model(configs)

Bases: torch.nn.Module

Base class for all neural network modules.

Your models should also subclass this class.

Modules can also contain other Modules, allowing to nest them in a tree structure. You can assign the submodules as regular attributes:

import torch.nn as nn
import torch.nn.functional as F

class Model(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(1, 20, 5)
        self.conv2 = nn.Conv2d(20, 20, 5)

    def forward(self, x):
        x = F.relu(self.conv1(x))
        return F.relu(self.conv2(x))

Submodules assigned in this way will be registered, and will have their parameters converted too when you call to(), etc.

Note

As per the example above, an __init__() call to the parent class must be made before assignment on the child.

Variables:

training (bool) – Boolean represents whether this module is in training or evaluation mode.

forward(x_in)

conv_block1

conv_block2

conv_block3

logits

model_output_dim