Datasets
Models
Diff of
/neural.py
[000000]
..
[6536f9]
Switch to unified view
| a | b/neural.py | ||
|---|---|---|---|
| 1 | import torch |
||
| 2 | from torch import nn |
||
| 3 | |||
| 4 | class DeepECG(nn.Module): |
||
| 5 | |||
| 6 | def __init__(self, input_shape: int, hidden_units: int, output_shape: int, final): |
||
| 7 | super().__init__() |
||
| 8 | self.block_1 = nn.Sequential( |
||
| 9 | nn.Conv1d(in_channels=input_shape, |
||
| 10 | out_channels=hidden_units, |
||
| 11 | kernel_size=3, |
||
| 12 | stride=1), |
||
| 13 | nn.ReLU(), |
||
| 14 | nn.MaxPool1d(kernel_size=1, |
||
| 15 | stride=2) |
||
| 16 | ) |
||
| 17 | self.block_2 = nn.Sequential( |
||
| 18 | nn.Conv1d(in_channels=hidden_units, |
||
| 19 | out_channels=hidden_units, |
||
| 20 | kernel_size=3, |
||
| 21 | stride=1), |
||
| 22 | nn.ReLU(), |
||
| 23 | nn.LocalResponseNorm(size=5, alpha=0.0002, beta=0.75, k=1.0), |
||
| 24 | nn.MaxPool1d(kernel_size=1, |
||
| 25 | stride=2) |
||
| 26 | ) |
||
| 27 | self.block_3 = nn.Sequential( |
||
| 28 | nn.Conv1d(in_channels=hidden_units, |
||
| 29 | out_channels=hidden_units, |
||
| 30 | kernel_size=3, |
||
| 31 | stride=1), |
||
| 32 | nn.ReLU(), |
||
| 33 | nn.MaxPool1d(kernel_size=3, |
||
| 34 | stride=2) |
||
| 35 | ) |
||
| 36 | self.block_4 = nn.Sequential( |
||
| 37 | nn.Conv1d(in_channels=hidden_units, |
||
| 38 | out_channels=hidden_units, |
||
| 39 | kernel_size=3, |
||
| 40 | stride=1), |
||
| 41 | nn.ReLU(), |
||
| 42 | nn.LocalResponseNorm(size=5, alpha=0.0002, beta=0.75, k=1.0), |
||
| 43 | ) |
||
| 44 | self.block_5 = nn.Sequential( |
||
| 45 | nn.Conv1d(in_channels=hidden_units, |
||
| 46 | out_channels=hidden_units, |
||
| 47 | kernel_size=3, |
||
| 48 | stride=1), |
||
| 49 | nn.ReLU() |
||
| 50 | ) |
||
| 51 | self.block_6 = nn.Sequential( |
||
| 52 | nn.Conv1d(in_channels=hidden_units, |
||
| 53 | out_channels=hidden_units, |
||
| 54 | kernel_size=3, |
||
| 55 | stride=1), |
||
| 56 | nn.ReLU(), |
||
| 57 | nn.LocalResponseNorm(size=5, alpha=0.0002, beta=0.75, k=1.0), |
||
| 58 | nn.Dropout(0.5) |
||
| 59 | ) |
||
| 60 | |||
| 61 | self.classifier = nn.Sequential( |
||
| 62 | nn.Flatten(), |
||
| 63 | nn.Linear(in_features=final, out_features=output_shape), |
||
| 64 | ) |
||
| 65 | |||
| 66 | def forward(self, x: torch.Tensor): |
||
| 67 | x = self.block_1(x) |
||
| 68 | x = self.block_2(x) |
||
| 69 | x = self.block_3(x) |
||
| 70 | x = self.block_4(x) |
||
| 71 | x = self.block_5(x) |
||
| 72 | x = self.block_6(x) |
||
| 73 | x = self.classifier(x) |
||
| 74 | return x |
||
| 75 | |||
| 76 | |||
| 77 | class DeepECG_DUMMY(nn.Module): |
||
| 78 | |||
| 79 | def __init__(self, input_shape: int, hidden_units: int, output_shape: int): |
||
| 80 | super().__init__() |
||
| 81 | self.block_1 = nn.Sequential( |
||
| 82 | nn.Conv1d(in_channels=input_shape, |
||
| 83 | out_channels=hidden_units, |
||
| 84 | kernel_size=3, |
||
| 85 | stride=1), |
||
| 86 | nn.ReLU(), |
||
| 87 | nn.MaxPool1d(kernel_size=1, |
||
| 88 | stride=2) |
||
| 89 | ) |
||
| 90 | self.block_2 = nn.Sequential( |
||
| 91 | nn.Conv1d(in_channels=hidden_units, |
||
| 92 | out_channels=hidden_units, |
||
| 93 | kernel_size=3, |
||
| 94 | stride=1), |
||
| 95 | nn.ReLU(), |
||
| 96 | nn.LocalResponseNorm(size=5, alpha=0.0002, beta=0.75, k=1.0), |
||
| 97 | nn.MaxPool1d(kernel_size=1, |
||
| 98 | stride=2) |
||
| 99 | ) |
||
| 100 | self.block_3 = nn.Sequential( |
||
| 101 | nn.Conv1d(in_channels=hidden_units, |
||
| 102 | out_channels=hidden_units, |
||
| 103 | kernel_size=3, |
||
| 104 | stride=1), |
||
| 105 | nn.ReLU(), |
||
| 106 | nn.MaxPool1d(kernel_size=3, |
||
| 107 | stride=2) |
||
| 108 | ) |
||
| 109 | self.block_4 = nn.Sequential( |
||
| 110 | nn.Conv1d(in_channels=hidden_units, |
||
| 111 | out_channels=hidden_units, |
||
| 112 | kernel_size=3, |
||
| 113 | stride=1), |
||
| 114 | nn.ReLU(), |
||
| 115 | nn.LocalResponseNorm(size=5, alpha=0.0002, beta=0.75, k=1.0), |
||
| 116 | ) |
||
| 117 | self.block_5 = nn.Sequential( |
||
| 118 | nn.Conv1d(in_channels=hidden_units, |
||
| 119 | out_channels=hidden_units, |
||
| 120 | kernel_size=3, |
||
| 121 | stride=1), |
||
| 122 | nn.ReLU() |
||
| 123 | ) |
||
| 124 | self.block_6 = nn.Sequential( |
||
| 125 | nn.Conv1d(in_channels=hidden_units, |
||
| 126 | out_channels=hidden_units, |
||
| 127 | kernel_size=3, |
||
| 128 | stride=1), |
||
| 129 | nn.ReLU(), |
||
| 130 | nn.LocalResponseNorm(size=5, alpha=0.0002, beta=0.75, k=1.0), |
||
| 131 | nn.Dropout(0.5) |
||
| 132 | ) |
||
| 133 | |||
| 134 | |||
| 135 | |||
| 136 | def forward(self, x: torch.Tensor): |
||
| 137 | x = self.block_1(x) |
||
| 138 | x = self.block_2(x) |
||
| 139 | x = self.block_3(x) |
||
| 140 | x = self.block_4(x) |
||
| 141 | x = self.block_5(x) |
||
| 142 | x = self.block_6(x) |
||
| 143 | a = x.shape[1] |
||
| 144 | b = x.shape[2] |
||
| 145 | return a*b |