Skip to content

Chambon2018 documentation

This page details the implementation of the chambon2018 model published here.

To train the model one could use the train -experiment chambon2018 command.

physioex.train.networks.chambon2018.Chambon2018Net

Bases: SeqtoSeq

A neural network model based on Chambon et al. (2018).

This model utilizes an epoch encoder and a sequence encoder for classification.

Parameters:

Name Type Description Default
module_config

The configuration for the model.

 module_config

Returns:

Type Description

torch.Tensor: The computed loss value.
Source code in physioex/train/networks/chambon2018.py 
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
class Chambon2018Net(SeqtoSeq):
    """
    A neural network model based on Chambon et al. (2018).

    This model utilizes an epoch encoder and a sequence encoder for classification.

    Args:
        module_config: The configuration for the model.

    Returns:
        torch.Tensor: The computed loss value.
    """
    def __init__(self, module_config=module_config):
        super(Chambon2018Net, self).__init__(None, None, module_config)

        epoch_encoder = SleepStagerChambon2018(
            n_chans=module_config["n_channels"],
            sfreq=module_config["sfreq"],
            n_outputs=module_config["n_classes"],
            n_times=module_config["n_times"],
            return_feats=True,
        )

        sequence_encoder = SequenceEncoder(
            epoch_encoder.len_last_layer * module_config["seq_len"],
            module_config["n_classes"],
            module_config["latent_space_dim"],
        )

        super(Chambon2018Net, self).__init__(
            epoch_encoder, sequence_encoder, module_config
        )

    def compute_loss(
        self,
        embeddings,
        outputs,
        targets,
        log: str = "train",
        log_metrics: bool = False,
    ):
        """
        Computes the loss for the Chambon2018Net model.

        Args:
            embeddings: The embeddings.
            outputs: The model outputs.
            targets: The target values.
            log (str): The logging information.
            log_metrics (bool): Whether to log metrics.

        Returns:
            torch.Tensor: The computed loss value.
        """
        batch_size, n_class = outputs.size()
        outputs = outputs.reshape(batch_size, 1, n_class)
        embeddings = embeddings.reshape(batch_size, 1, -1)

        return super().compute_loss(embeddings, outputs, targets, log, log_metrics)

__init__(module_config=module_config)

Source code in physioex/train/networks/chambon2018.py 
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
def __init__(self, module_config=module_config):
    super(Chambon2018Net, self).__init__(None, None, module_config)

    epoch_encoder = SleepStagerChambon2018(
        n_chans=module_config["n_channels"],
        sfreq=module_config["sfreq"],
        n_outputs=module_config["n_classes"],
        n_times=module_config["n_times"],
        return_feats=True,
    )

    sequence_encoder = SequenceEncoder(
        epoch_encoder.len_last_layer * module_config["seq_len"],
        module_config["n_classes"],
        module_config["latent_space_dim"],
    )

    super(Chambon2018Net, self).__init__(
        epoch_encoder, sequence_encoder, module_config
    )

compute_loss(embeddings, outputs, targets, log='train', log_metrics=False)

Computes the loss for the Chambon2018Net model.

Parameters:

Name Type Description Default
embeddings

The embeddings.

 required
outputs

The model outputs.

 required
targets

The target values.

 required
log str

The logging information.

 'train'
log_metrics bool

Whether to log metrics.

 False

Returns:

Type Description

torch.Tensor: The computed loss value.
Source code in physioex/train/networks/chambon2018.py 
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
def compute_loss(
    self,
    embeddings,
    outputs,
    targets,
    log: str = "train",
    log_metrics: bool = False,
):
    """
    Computes the loss for the Chambon2018Net model.

    Args:
        embeddings: The embeddings.
        outputs: The model outputs.
        targets: The target values.
        log (str): The logging information.
        log_metrics (bool): Whether to log metrics.

    Returns:
        torch.Tensor: The computed loss value.
    """
    batch_size, n_class = outputs.size()
    outputs = outputs.reshape(batch_size, 1, n_class)
    embeddings = embeddings.reshape(batch_size, 1, -1)

    return super().compute_loss(embeddings, outputs, targets, log, log_metrics)

physioex.train.networks.chambon2018.SequenceEncoder

Bases: Module

The sequence encoder neural network module used in Chambon 2018.

This module encodes the input sequences by concatenating them and using a linear layer to perform classification.

Parameters:

Name Type Description Default
input_dim int

The dimension of the input.

 required
n_classes int

The number of classes for classification.

 required
latent_dim int

The dimension of the latent space i.e. intermediate layer between encodings and classification.

 required

Returns:

Type Description

torch.Tensor: The output tensor after classification.
Source code in physioex/train/networks/chambon2018.py 
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
class SequenceEncoder(nn.Module):
    """
    The sequence encoder neural network module used in Chambon 2018.

    This module encodes the input sequences by concatenating them and using a linear layer to perform classification.

    Args:
        input_dim (int): The dimension of the input.
        n_classes (int): The number of classes for classification.
        latent_dim (int): The dimension of the latent space i.e. intermediate layer between encodings and classification.

    Returns:
        torch.Tensor: The output tensor after classification.
    """
    def __init__(self, input_dim: int, n_classes: int, latent_dim: int):
        super(SequenceEncoder, self).__init__()
        self.drop = nn.Dropout(0.5)
        self.proj = nn.Linear(input_dim, latent_dim)
        self.norm = nn.LayerNorm(latent_dim)
        self.clf = nn.Linear(latent_dim, n_classes)

    def forward(self, x):
        """
        Forward pass of the sequence encoder.

        Args:
            x: torch.Tensor - The input tensor.

        Returns:
            torch.Tensor: The output tensor after classification.
        """
        x = self.encode(x)
        x = self.clf(x)
        return x

    def encode(self, x):
        """
        Encodes the input tensor.

        Args:
            x: torch.Tensor - The input tensor.

        Returns:
            torch.Tensor: The encoded tensor.
        """
        batch_size, sequence_lenght, input_dim = x.size()
        x = x.reshape(batch_size, sequence_lenght * input_dim)
        x = self.drop(x)
        x = nn.ReLU()(self.proj(x))
        x = self.norm(x)
        return x

__init__(input_dim, n_classes, latent_dim)

Source code in physioex/train/networks/chambon2018.py 
25
26
27
28
29
30
def __init__(self, input_dim: int, n_classes: int, latent_dim: int):
    super(SequenceEncoder, self).__init__()
    self.drop = nn.Dropout(0.5)
    self.proj = nn.Linear(input_dim, latent_dim)
    self.norm = nn.LayerNorm(latent_dim)
    self.clf = nn.Linear(latent_dim, n_classes)

forward(x)

Forward pass of the sequence encoder.

Parameters:

Name Type Description Default
x

torch.Tensor - The input tensor.

 required

Returns:

Type Description

torch.Tensor: The output tensor after classification.
Source code in physioex/train/networks/chambon2018.py 
32
33
34
35
36
37
38
39
40
41
42
43
44
def forward(self, x):
    """
    Forward pass of the sequence encoder.

    Args:
        x: torch.Tensor - The input tensor.

    Returns:
        torch.Tensor: The output tensor after classification.
    """
    x = self.encode(x)
    x = self.clf(x)
    return x

encode(x)

Encodes the input tensor.

Parameters:

Name Type Description Default
x

torch.Tensor - The input tensor.

 required

Returns:

Type Description

torch.Tensor: The encoded tensor.
Source code in physioex/train/networks/chambon2018.py 
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
def encode(self, x):
    """
    Encodes the input tensor.

    Args:
        x: torch.Tensor - The input tensor.

    Returns:
        torch.Tensor: The encoded tensor.
    """
    batch_size, sequence_lenght, input_dim = x.size()
    x = x.reshape(batch_size, sequence_lenght * input_dim)
    x = self.drop(x)
    x = nn.ReLU()(self.proj(x))
    x = self.norm(x)
    return x