def __init__(self, in_channels=8, out_channels=8):
super(SimpleConv, self).__init__()
self.in_channels = in_channels
self.out_channels = out_channels
self.activation = nn.ReLU()
self.conv_net = nn.Sequential(
nn.Conv1d(in_channels=self.in_channels,
out_channels=16,
kernel_size=5,
stride=1,
padding=2),
nn.ReLU(),
nn.Conv1d(in_channels=16,
out_channels=32,
kernel_size=5,
stride=1,
padding=2),
nn.ReLU(),
nn.Conv1d(in_channels=32,
out_channels=16,
kernel_size=5,
stride=1,
padding=2),
nn.ReLU(),
nn.Conv1d(in_channels=16,
out_channels=self.out_channels,
kernel_size=5,
stride=1,
padding=2),
nn.ReLU(),
)
init_sequential_weights(self.conv_net)
self.num_halving_layers = 0
def build_weight_model(self):
"""Returns a function point-wise function that transforms the
(in_channels + 1)-dimensional representation to dimensionality
out_channels.
Returns:
torch.nn.Module: Linear layer applied point-wise to channels.
"""
model = nn.Sequential(nn.Linear(self.in_channels, self.out_channels), )
init_sequential_weights(model)
return model
def __init__(
self,
in_channels=8,
conv_channels=64, #MGM addition -- rename "hidden_channels to conv_channels"
out_channels=8,
num_layers=7,
kernel_size=15,
separable=True):
super(DepthSepConv1d, self).__init__(
) #MGM addition -- replace "Conv1D by DepthSepConv1D" in this line
self.in_channels = in_channels
self.conv_channels = conv_channels
self.out_channels = out_channels #MGM addition
self.num_halving_layers = 0 #MGM addition
# Switch between depthwise separable and standard convolutions
layer = SeparableConv1d if separable else Conv1d
self.activation = nn.ReLU()
# Initialize operations with single hidden layer
operations = nn.ModuleList([
layer(in_channels=in_channels,
out_channels=conv_channels,
kernel_size=kernel_size)
])
operations.append(nn.ReLU())
# Add hidden layers as required
for _ in range(1, num_layers - 1):
operations.append(
layer(in_channels=conv_channels,
out_channels=conv_channels,
kernel_size=kernel_size))
operations.append(nn.ReLU())
# Add final convolution layer
operations.append(
layer(in_channels=conv_channels,
out_channels=out_channels,
kernel_size=kernel_size))
# Initialize network
self.conv_net = nn.Sequential(*operations)
init_sequential_weights(self.conv_net)
def __init__(self, input_dim, latent_dim, output_dim):
super(StandardDecoder, self).__init__()
self.input_dim = input_dim
self.latent_dim = latent_dim
self.output_dim = output_dim
post_pooling_fn = nn.Sequential(
BatchLinear(self.latent_dim + self.input_dim, self.latent_dim),
nn.ReLU(),
BatchLinear(self.latent_dim, self.latent_dim),
nn.ReLU(),
BatchLinear(self.latent_dim, 2 * self.output_dim),
)
self.post_pooling_fn = init_sequential_weights(post_pooling_fn)
self.sigma_fn = nn.functional.softplus
def __init__(self, input_dim, latent_dim, use_attention=False):
super(StandardEncoder, self).__init__()
self.latent_dim = latent_dim
self.input_dim = input_dim
self.use_attention = use_attention
pre_pooling_fn = nn.Sequential(
BatchLinear(self.input_dim, self.latent_dim),
nn.ReLU(),
BatchLinear(self.latent_dim, self.latent_dim),
nn.ReLU(),
BatchLinear(self.latent_dim, self.latent_dim),
)
self.pre_pooling_fn = init_sequential_weights(pre_pooling_fn)
if self.use_attention:
self.pooling_fn = CrossAttention()
else:
self.pooling_fn = MeanPooling(pooling_dim=1)