def __init__(self, config, input_shape=None):
super(Net, self).__init__(config, input_shape)
self.NUM_CLASSES = P.GLB_PARAMS[P.KEY_DATASET_METADATA][
P.KEY_DS_NUM_CLASSES]
self.DROPOUT_P = config.CONFIG_OPTIONS.get(P.KEY_DROPOUT_P, 0.5)
# Here we define the layers of our network
# Seventh convolutional layer
self.conv7 = nn.Conv2d(
self.get_input_shape()[0], 384,
3) # 256 input channels, 384 output channels, 3x3 convolutions
self.bn7 = nn.BatchNorm2d(384) # Batch Norm layer
# Eightth convolutional layer
self.conv8 = nn.Conv2d(
384, 512,
3) # 384 input channels, 512 output channels, 3x3 convolutions
self.bn8 = nn.BatchNorm2d(512) # Batch Norm layer
self.CONV_OUTPUT_SIZE = utils.shape2size(
utils.tens2shape(self.get_dummy_fmap()[self.CONV_OUTPUT]))
# FC Layers
self.fc9 = nn.Linear(
self.CONV_OUTPUT_SIZE, 4096
) # conv_output_size-dimensional input, 4096-dimensional output
self.bn9 = nn.BatchNorm1d(4096) # Batch Norm layer
self.fc10 = nn.Linear(
4096, self.NUM_CLASSES
) # 4096-dimensional input, NUM_CLASSES-dimensional output (one per class)
def gauss(x, w, sigma=None):
# Serialized version of distance computation using less memory
x_unf = unfold_map2d(x, w.size(2), w.size(3))
d = torch.zeros(x_unf.size(0),
w.size(0),
x_unf.size(2),
x_unf.size(3),
device=x.device) # batch, out-ch, height, width
for i in range(
w.size(0) // P.HEBB_UPD_GRP +
(1 if w.size(0) % P.HEBB_UPD_GRP != 0 else 0)):
start = i * P.HEBB_UPD_GRP
end = min((i + 1) * P.HEBB_UPD_GRP, w.size(0))
w_i = w[start:end, :, :, :]
w_i = w_i.view(1, w_i.size(0), 1, 1,
-1) # batch, out-ch, height, width, filter
d[:, start:end, :, :] = torch.norm(
x_unf - w_i, p=2, dim=4
) # w_i broadcast over x_unf batch, height and width dims, x_unf broadcast over w out_ch dim
if sigma is None:
return torch.exp(-d.pow(2) / (2 * utils.shape2size(tuple(w[0].size())))
) # heuristic: use number of dimensions as variance
# if sigma is None: return torch.exp(-d.pow(2) / (2 * torch.norm(w.view(w.size(0), 1, -1) - w.view(1, w.size(0), -1), p=2, dim=2).max().pow(2)/(w.size(0)**(2/(utils.shape2size(tuple(w[0].size()))))))) # heuristic: normalization condition
# if sigma is None: return torch.exp(-d.pow(2) / (2 * d.mean().pow(2)))
return torch.exp(-d.pow(2) / (2 * (sigma.view(1, -1, 1, 1).pow(2))))
def __init__(self, config, input_shape=None):
super(Net, self).__init__(config, input_shape)
self.NUM_CLASSES = P.GLB_PARAMS[P.KEY_DATASET_METADATA][
P.KEY_DS_NUM_CLASSES]
self.DROPOUT_P = config.CONFIG_OPTIONS.get(P.KEY_DROPOUT_P, 0.5)
# Here we define the layers of our network
# Fourth convolutional layer
self.conv4 = nn.Conv2d(
self.get_input_shape()[0], 256,
3) # 192 input channels, 256 output channels, 3x3 convolutions
self.bn4 = nn.BatchNorm2d(256) # Batch Norm layer
self.CONV_OUTPUT_SIZE = utils.shape2size(
self.get_output_fmap_shape(self.CONV_OUTPUT))
# FC Layers
self.fc5 = nn.Linear(
self.CONV_OUTPUT_SIZE, 4096
) # conv_output_size-dimensional input, 4096-dimensional output
self.bn5 = nn.BatchNorm1d(4096) # Batch Norm layer
self.fc6 = nn.Linear(
4096, self.NUM_CLASSES
) # 4096-dimensional input, NUM_CLASSES-dimensional output (one per class)
def __init__(self, config, input_shape=None):
super(Net, self).__init__(config, input_shape)
self.NUM_CLASSES = P.GLB_PARAMS[P.KEY_DATASET_METADATA][
P.KEY_DS_NUM_CLASSES]
self.DROPOUT_P = config.CONFIG_OPTIONS.get(P.KEY_DROPOUT_P, 0.5)
# Here we define the layers of our network
# First convolutional layer
self.conv1 = nn.Conv2d(
3, 96, 7) # 3 input channels, 96 output channels, 7x7 convolutions
self.bn1 = nn.BatchNorm2d(96) # Batch Norm layer
# Second convolutional layer
self.conv2 = nn.Conv2d(
96, 128,
3) # 96 input channels, 128 output channels, 3x3 convolutions
self.bn2 = nn.BatchNorm2d(128) # Batch Norm layer
# Third convolutional layer
self.conv3 = nn.Conv2d(
128, 192,
3) # 128 input channels, 192 output channels, 3x3 convolutions
self.bn3 = nn.BatchNorm2d(192) # Batch Norm layer
# Fourth convolutional layer
self.conv4 = nn.Conv2d(
192, 192,
3) # 192 input channels, 192 output channels, 3x3 convolutions
self.bn4 = nn.BatchNorm2d(192) # Batch Norm layer
# Fifth convolutional layer
self.conv5 = nn.Conv2d(
192, 256,
3) # 192 input channels, 256 output channels, 3x3 convolutions
self.bn5 = nn.BatchNorm2d(256) # Batch Norm layer
# Sixth convolutional layer
self.conv6 = nn.Conv2d(
256, 256,
3) # 256 input channels, 256 output channels, 3x3 convolutions
self.bn6 = nn.BatchNorm2d(256) # Batch Norm layer
# Seventh convolutional layer
self.conv7 = nn.Conv2d(
256, 384,
3) # 256 input channels, 384 output channels, 3x3 convolutions
self.bn7 = nn.BatchNorm2d(384) # Batch Norm layer
# Eightth convolutional layer
self.conv8 = nn.Conv2d(
384, 512,
3) # 384 input channels, 512 output channels, 3x3 convolutions
self.bn8 = nn.BatchNorm2d(512) # Batch Norm layer
self.CONV_OUTPUT_SIZE = utils.shape2size(
utils.tens2shape(self.get_dummy_fmap()[self.CONV_OUTPUT]))
# FC Layers
self.fc9 = nn.Linear(
self.CONV_OUTPUT_SIZE, 4096
) # conv_output_size-dimensional input, 4096-dimensional output
self.bn9 = nn.BatchNorm1d(4096) # Batch Norm layer
self.fc10 = nn.Linear(
4096, self.NUM_CLASSES
) # 4096-dimensional input, NUM_CLASSES-dimensional output (one per class)
def __init__(self, config, input_shape=None):
super(Net, self).__init__(config, input_shape)
self.INPUT_SIZE = utils.shape2size(self.get_input_shape())
self.NUM_CLASSES = P.GLB_PARAMS[P.KEY_DATASET_METADATA][
P.KEY_DS_NUM_CLASSES]
self.DROPOUT_P = config.CONFIG_OPTIONS.get(P.KEY_DROPOUT_P, 0.5)
# FC Layers
self.fc = nn.Linear(
self.INPUT_SIZE, self.NUM_CLASSES
) # input_size-dimensional input, NUM_CLASSES-dimensional output (one per class)
def __init__(self, config, input_shape=None): super(Net, self).__init__(config, input_shape) self.NUM_CLASSES = P.GLB_PARAMS[P.KEY_DATASET_METADATA][P.KEY_DS_NUM_CLASSES] self.DROPOUT_P = config.CONFIG_OPTIONS.get(P.KEY_DROPOUT_P, 0.5) # Here we define the layers of our network # First convolutional layer self.conv1 = nn.Conv2d(3, 96, 5) # 3 input channels, 96 output channels, 5x5 convolutions self.bn1 = nn.BatchNorm2d(96) # Batch Norm layer self.CONV_OUTPUT_SIZE = utils.shape2size(utils.tens2shape(self.get_dummy_fmap()[self.CONV_OUTPUT])) # FC Layers self.fc2 = nn.Linear(self.CONV_OUTPUT_SIZE, self.NUM_CLASSES) # conv_output_shape-dimensional input, 10-dimensional output (one per class)
def __init__(self, config, input_shape=None):
super(Net, self).__init__(config, input_shape)
self.NUM_CLASSES = P.GLB_PARAMS[P.KEY_DATASET_METADATA][
P.KEY_DS_NUM_CLASSES]
self.DROPOUT_P = config.CONFIG_OPTIONS.get(P.KEY_DROPOUT_P, 0.5)
self.INPUT_SIZE = utils.shape2size(self.get_input_shape())
# Here we define the layers of our network
# FC Layers
self.fc1 = nn.Linear(
self.INPUT_SIZE,
4096) # input_size-dimensional input, 4096-dimensional output
self.bn1 = nn.BatchNorm1d(4096) # Batch Norm layer
self.fc2 = nn.Linear(
4096, self.NUM_CLASSES
) # 4096-dimensional input, NUM_CLASSES-dimensional output (one per class)
def __init__(self, config, input_shape=None):
super(Net, self).__init__(config, input_shape)
self.NUM_CLASSES = P.GLB_PARAMS[P.KEY_DATASET_METADATA][P.KEY_DS_NUM_CLASSES]
self.DROPOUT_P = config.CONFIG_OPTIONS.get(P.KEY_DROPOUT_P, 0.5)
self.NUM_LATENT_VARS = config.CONFIG_OPTIONS.get(PP.KEY_VAE_NUM_LATENT_VARS, 256)
self.ELBO_BETA = config.CONFIG_OPTIONS.get(P.KEY_ELBO_BETA, 1.)
self.ALPHA_L = config.CONFIG_OPTIONS.get(P.KEY_ALPHA_L, 1.)
self.ALPHA_G = config.CONFIG_OPTIONS.get(P.KEY_ALPHA_G, 0.)
# Here we define the layers of our network and the variables to store internal gradients
# First convolutional layer
self.conv1 = nn.Conv2d(3, 96, 5) # 3 input chennels, 96 output channels, 5x5 convolutions
self.bn1 = nn.BatchNorm2d(96) # Batch Norm layer
self.conv1_delta_w = torch.zeros_like(self.conv1.weight)
self.conv1_delta_bias = torch.zeros_like(self.conv1.bias)
self.bn1_delta_w = torch.zeros_like(self.bn1.weight)
self.bn1_delta_bias = torch.zeros_like(self.bn1.bias)
# Second convolutional layer
self.conv2 = nn.Conv2d(96, 128, 3) # 96 input chennels, 128 output channels, 3x3 convolutions
self.bn2 = nn.BatchNorm2d(128) # Batch Norm layer
self.conv2_delta_w = torch.zeros_like(self.conv2.weight)
self.conv2_delta_bias = torch.zeros_like(self.conv2.bias)
self.bn2_delta_w = torch.zeros_like(self.bn2.weight)
self.bn2_delta_bias = torch.zeros_like(self.bn2.bias)
# Third convolutional layer
self.conv3 = nn.Conv2d(128, 192, 3) # 128 input chennels, 192 output channels, 3x3 convolutions
self.bn3 = nn.BatchNorm2d(192) # Batch Norm layer
self.conv3_delta_w = torch.zeros_like(self.conv3.weight)
self.conv3_delta_bias = torch.zeros_like(self.conv3.bias)
self.bn3_delta_w = torch.zeros_like(self.bn3.weight)
self.bn3_delta_bias = torch.zeros_like(self.bn3.bias)
# Fourth convolutional layer
self.conv4 = nn.Conv2d(192, 256, 3) # 192 input chennels, 256 output channels, 3x3 convolutions
self.bn4 = nn.BatchNorm2d(256) # Batch Norm layer
self.conv4_delta_w = torch.zeros_like(self.conv4.weight)
self.conv4_delta_bias = torch.zeros_like(self.conv4.bias)
self.bn4_delta_w = torch.zeros_like(self.bn4.weight)
self.bn4_delta_bias = torch.zeros_like(self.bn4.bias)
self.OUTPUT_FMAP_SHAPE = {k: utils.tens2shape(v) for k, v in self.get_dummy_fmap().items() if isinstance(v, torch.Tensor)}
self.OUTPUT_FMAP_SIZE = {k: utils.shape2size(self.OUTPUT_FMAP_SHAPE[k]) for k in self.OUTPUT_FMAP_SHAPE.keys()}
self.CONV_OUTPUT_SIZE = self.OUTPUT_FMAP_SIZE[self.CONV_OUTPUT]
# FC Layers
self.fc5 = nn.Linear(self.CONV_OUTPUT_SIZE, 4096) # conv_output_size-dimensional input, 4096-dimensional output
self.bn5 = nn.BatchNorm1d(4096) # Batch Norm layer
self.fc5_delta_w = torch.zeros_like(self.fc5.weight)
self.fc5_delta_bias = torch.zeros_like(self.fc5.bias)
self.bn5_delta_w = torch.zeros_like(self.bn5.weight)
self.bn5_delta_bias = torch.zeros_like(self.bn5.bias)
self.fc6 = nn.Linear(4096, self.NUM_CLASSES) # 4096-dimensional input, NUM_CLASSES-dimensional output (one per class)
# Latent variable mapping layers
self.fc_mu1 = nn.Linear(self.OUTPUT_FMAP_SIZE[self.BN1], self.NUM_LATENT_VARS) # bn1_output_size-dimensional input, NUM_LATENT_VARS-dimensional output
self.fc_var1 = nn.Linear(self.OUTPUT_FMAP_SIZE[self.BN1], self.NUM_LATENT_VARS) # bn1_output_size-dimensional input, NUM_LATENT_VARS-dimensional output
self.fc_mu1_delta_w = torch.zeros_like(self.fc_mu1.weight)
self.fc_mu1_delta_bias = torch.zeros_like(self.fc_mu1.bias)
self.fc_var1_delta_w = torch.zeros_like(self.fc_var1.weight)
self.fc_var1_delta_bias = torch.zeros_like(self.fc_var1.bias)
self.fc_mu2 = nn.Linear(self.OUTPUT_FMAP_SIZE[self.BN2], self.NUM_LATENT_VARS) # bn2_output_size-dimensional input, NUM_LATENT_VARS-dimensional output
self.fc_var2 = nn.Linear(self.OUTPUT_FMAP_SIZE[self.BN2], self.NUM_LATENT_VARS) # bn2_output_size-dimensional input, NUM_LATENT_VARS-dimensional output
self.fc_mu2_delta_w = torch.zeros_like(self.fc_mu2.weight)
self.fc_mu2_delta_bias = torch.zeros_like(self.fc_mu2.bias)
self.fc_var2_delta_w = torch.zeros_like(self.fc_var2.weight)
self.fc_var2_delta_bias = torch.zeros_like(self.fc_var2.bias)
self.fc_mu3 = nn.Linear(self.OUTPUT_FMAP_SIZE[self.BN3], self.NUM_LATENT_VARS) # bn3_output_size-dimensional input, NUM_LATENT_VARS-dimensional output
self.fc_var3 = nn.Linear(self.OUTPUT_FMAP_SIZE[self.BN3], self.NUM_LATENT_VARS) # bn3_output_size-dimensional input, NUM_LATENT_VARS-dimensional output
self.fc_mu3_delta_w = torch.zeros_like(self.fc_mu3.weight)
self.fc_mu3_delta_bias = torch.zeros_like(self.fc_mu3.bias)
self.fc_var3_delta_w = torch.zeros_like(self.fc_var3.weight)
self.fc_var3_delta_bias = torch.zeros_like(self.fc_var3.bias)
self.fc_mu4 = nn.Linear(self.OUTPUT_FMAP_SIZE[self.BN4], self.NUM_LATENT_VARS) # bn4_output_size-dimensional input, NUM_LATENT_VARS-dimensional output
self.fc_var4 = nn.Linear(self.OUTPUT_FMAP_SIZE[self.BN4], self.NUM_LATENT_VARS) # bn4_output_size-dimensional input, NUM_LATENT_VARS-dimensional output
self.fc_mu4_delta_w = torch.zeros_like(self.fc_mu4.weight)
self.fc_mu4_delta_bias = torch.zeros_like(self.fc_mu4.bias)
self.fc_var4_delta_w = torch.zeros_like(self.fc_var4.weight)
self.fc_var4_delta_bias = torch.zeros_like(self.fc_var4.bias)
self.fc_mu5 = nn.Linear(4096, self.NUM_LATENT_VARS) # 4096-dimensional input, NUM_LATENT_VARS-dimensional output
self.fc_var5 = nn.Linear(4096, self.NUM_LATENT_VARS) # 4096-dimensional input, NUM_LATENT_VARS-dimensional output
self.fc_mu5_delta_w = torch.zeros_like(self.fc_mu5.weight)
self.fc_mu5_delta_bias = torch.zeros_like(self.fc_mu5.bias)
self.fc_var5_delta_w = torch.zeros_like(self.fc_var5.weight)
self.fc_var5_delta_bias = torch.zeros_like(self.fc_var5.bias)
# Decoding Layers
self.dec_fc0 = nn.Linear(self.NUM_LATENT_VARS, 4096) # NUM_LATENT_VARS-dimensional input, 4096-dimensional output
self.dec_bn0 = nn.BatchNorm1d(4096) # Batch Norm layer
self.dec_fc1 = nn.Linear(4096, self.CONV_OUTPUT_SIZE) # 4096-dimensional input, CONV_OUTPUT_SIZE-dimensional output
self.dec_fc0_delta_w = torch.zeros_like(self.dec_fc0.weight)
self.dec_fc0_delta_bias = torch.zeros_like(self.dec_fc0.bias)
self.dec_bn0_delta_w = torch.zeros_like(self.dec_bn0.weight)
self.dec_bn0_delta_bias = torch.zeros_like(self.dec_bn0.bias)
self.dec_fc1_delta_w = torch.zeros_like(self.dec_fc1.weight)
self.dec_fc1_delta_bias = torch.zeros_like(self.dec_fc1.bias)
self.dec_fc2 = nn.Linear(self.NUM_LATENT_VARS, self.OUTPUT_FMAP_SIZE[self.BN4]) # NUM_LATENT_VARS-dimensional input, bn4_output_size-dimensional output
self.dec_bn2 = nn.BatchNorm2d(256) # Batch Norm layer
self.dec_conv2 = nn.ConvTranspose2d(256, 192, 3) # 256 input chennels, 192 output channels, 3x3 transpose convolutions
self.dec_fc2_delta_w = torch.zeros_like(self.dec_fc2.weight)
self.dec_fc2_delta_bias = torch.zeros_like(self.dec_fc2.bias)
self.dec_bn2_delta_w = torch.zeros_like(self.dec_bn2.weight)
self.dec_bn2_delta_bias = torch.zeros_like(self.dec_bn2.bias)
self.dec_conv2_delta_w = torch.zeros_like(self.dec_conv2.weight)
self.dec_conv2_delta_bias = torch.zeros_like(self.dec_conv2.bias)
self.dec_fc3 = nn.Linear(self.NUM_LATENT_VARS, self.OUTPUT_FMAP_SIZE[self.BN3]) # NUM_LATENT_VARS-dimensional input, bn3_output_size-dimensional output
self.dec_bn3 = nn.BatchNorm2d(192) # Batch Norm layer
self.dec_conv3 = nn.ConvTranspose2d(192, 128, 3) # 192 input chennels, 128 output channels, 3x3 transpose convolutions
self.dec_fc3_delta_w = torch.zeros_like(self.dec_fc3.weight)
self.dec_fc3_delta_bias = torch.zeros_like(self.dec_fc3.bias)
self.dec_bn3_delta_w = torch.zeros_like(self.dec_bn3.weight)
self.dec_bn3_delta_bias = torch.zeros_like(self.dec_bn3.bias)
self.dec_conv3_delta_w = torch.zeros_like(self.dec_conv3.weight)
self.dec_conv3_delta_bias = torch.zeros_like(self.dec_conv3.bias)
self.dec_fc4 = nn.Linear(self.NUM_LATENT_VARS, self.OUTPUT_FMAP_SIZE[self.BN2]) # NUM_LATENT_VARS-dimensional input, bn2_output_size-dimensional output
self.dec_bn4 = nn.BatchNorm2d(128) # Batch Norm layer
self.dec_conv4 = nn.ConvTranspose2d(128, 96, 3) # 128 input chennels, 96 output channels, 3x3 transpose convolutions
self.dec_fc4_delta_w = torch.zeros_like(self.dec_fc4.weight)
self.dec_fc4_delta_bias = torch.zeros_like(self.dec_fc4.bias)
self.dec_bn4_delta_w = torch.zeros_like(self.dec_bn4.weight)
self.dec_bn4_delta_bias = torch.zeros_like(self.dec_bn4.bias)
self.dec_conv4_delta_w = torch.zeros_like(self.dec_conv4.weight)
self.dec_conv4_delta_bias = torch.zeros_like(self.dec_conv4.bias)
self.dec_fc5 = nn.Linear(self.NUM_LATENT_VARS, self.OUTPUT_FMAP_SIZE[self.BN1]) # NUM_LATENT_VARS-dimensional input, bn1_output_size-dimensional output
self.dec_bn5 = nn.BatchNorm2d(96) # Batch Norm layer
self.dec_conv5 = nn.ConvTranspose2d(96, 3, 5) # 96 input chennels, 3 output channels, 5x5 transpose convolutions
self.dec_fc5_delta_w = torch.zeros_like(self.dec_fc5.weight)
self.dec_fc5_delta_bias = torch.zeros_like(self.dec_fc5.bias)
self.dec_bn5_delta_w = torch.zeros_like(self.dec_bn5.weight)
self.dec_bn5_delta_bias = torch.zeros_like(self.dec_bn5.bias)
self.dec_conv5_delta_w = torch.zeros_like(self.dec_conv5.weight)
self.dec_conv5_delta_bias = torch.zeros_like(self.dec_conv5.bias)
# Internal ELBO loss function
self.loss = ELBOMetric(self.ELBO_BETA)
def nc_base(w):
return w.size(0)**(1 / (utils.shape2size(tuple(w[0].size()))))
def weight_init_std(w):
stdv = 1 / (utils.shape2size(w[0].size()))**0.5
torch.nn.init.uniform_(w, -stdv, stdv)
return w
def nc_raised_ang_sim(w):
return 1 / (-math.log(1 - 1 / (w.size(0)**
(1 /
(utils.shape2size(tuple(w[0].size())))))))
def nc_raised_cos_sim(w):
return 1 / (-math.log(
(1 + torch.cos(1 / (w.size(0)**
(1 /
(utils.shape2size(tuple(w[0].size()))))))) / 2))
def __init__(self, config, input_shape=None):
super(Net, self).__init__(config, input_shape)
self.NUM_CLASSES = P.GLB_PARAMS[P.KEY_DATASET_METADATA][
P.KEY_DS_NUM_CLASSES]
self.DROPOUT_P = config.CONFIG_OPTIONS.get(P.KEY_DROPOUT_P, 0.5)
# Here we define the layers of our network
# First convolutional layer
self.conv1 = nn.Conv2d(
3, 96, 7) # 3 input channels, 96 output channels, 7x7 convolutions
self.bn1 = nn.BatchNorm2d(96) # Batch Norm layer
# Second convolutional layer
self.conv2 = nn.Conv2d(
96, 128,
3) # 96 input channels, 128 output channels, 3x3 convolutions
self.bn2 = nn.BatchNorm2d(128) # Batch Norm layer
# Third convolutional layer
self.conv3 = nn.Conv2d(
128, 192,
3) # 128 input channels, 192 output channels, 3x3 convolutions
self.bn3 = nn.BatchNorm2d(192) # Batch Norm layer
# Fourth convolutional layer
self.conv4 = nn.Conv2d(
192, 192,
3) # 192 input channels, 192 output channels, 3x3 convolutions
self.bn4 = nn.BatchNorm2d(192) # Batch Norm layer
# Fifth convolutional layer
self.conv5 = nn.Conv2d(
192, 256,
3) # 192 input channels, 256 output channels, 3x3 convolutions
self.bn5 = nn.BatchNorm2d(256) # Batch Norm layer
# Sixth convolutional layer
self.conv6 = nn.Conv2d(
256, 256,
3) # 256 input channels, 256 output channels, 3x3 convolutions
self.bn6 = nn.BatchNorm2d(256) # Batch Norm layer
# Seventh convolutional layer
self.conv7 = nn.Conv2d(
256, 384,
3) # 256 input channels, 384 output channels, 3x3 convolutions
self.bn7 = nn.BatchNorm2d(384) # Batch Norm layer
# Eightth convolutional layer
self.conv8 = nn.Conv2d(
384, 512,
3) # 384 input channels, 512 output channels, 3x3 convolutions
self.bn8 = nn.BatchNorm2d(512) # Batch Norm layer
self.CONV_OUTPUT_SHAPE = self.get_output_fmap_shape(self.CONV_OUTPUT)
self.CONV_OUTPUT_SIZE = utils.shape2size(self.CONV_OUTPUT_SHAPE)
# FC Layers
self.fc9 = nn.Linear(
self.CONV_OUTPUT_SIZE, 4096
) # conv_output_size-dimensional input, 4096-dimensional output
self.bn9 = nn.BatchNorm1d(4096) # Batch Norm layer
self.fc_mu = nn.Linear(
4096, self.NUM_LATENT_VARS
) # conv_output_size-dimensional input, NUM_LATENT_VARS-dimensional output
self.fc_var = nn.Linear(
4096, self.NUM_LATENT_VARS
) # conv_output_size-dimensional input, NUM_LATENT_VARS-dimensional output
# Decoding Layers
self.dec_fc0 = nn.Linear(
self.NUM_LATENT_VARS,
4096) # NUM_LATENT_VARS-dimensional input, 4096-dimensional output
self.dec_bn0 = nn.BatchNorm1d(4096) # Batch Norm layer
self.dec_fc1 = nn.Linear(
4096, self.CONV_OUTPUT_SIZE
) # 4096-dimensional input, CONV_OUTPUT_SIZE-dimensional output
self.dec_bn1 = nn.BatchNorm1d(
self.CONV_OUTPUT_SIZE) # Batch Norm layer
self.dec_conv2 = nn.ConvTranspose2d(
512, 384, 3
) # 512 input channels, 384 output channels, 3x3 transpose convolutions
self.dec_bn2 = nn.BatchNorm2d(384) # Batch Norm layer
self.dec_conv3 = nn.ConvTranspose2d(
384, 256, 3
) # 384 input channels, 256 output channels, 3x3 transpose convolutions
self.dec_bn3 = nn.BatchNorm2d(256) # Batch Norm layer
self.dec_conv4 = nn.ConvTranspose2d(
256, 256, 3
) # 256 input channels, 256 output channels, 3x3 transpose convolutions
self.dec_bn4 = nn.BatchNorm2d(256) # Batch Norm layer
self.dec_conv5 = nn.ConvTranspose2d(
256, 192, 3
) # 256 input channels, 192 output channels, 3x3 transpose convolutions
self.dec_bn5 = nn.BatchNorm2d(192) # Batch Norm layer
self.dec_conv6 = nn.ConvTranspose2d(
192, 192, 3
) # 192 input channels, 192 output channels, 3x3 transpose convolutions
self.dec_bn6 = nn.BatchNorm2d(192) # Batch Norm layer
self.dec_conv7 = nn.ConvTranspose2d(
192, 128, 3
) # 192 input channels, 128 output channels, 3x3 transpose convolutions
self.dec_bn7 = nn.BatchNorm2d(128) # Batch Norm layer
self.dec_conv8 = nn.ConvTranspose2d(
128, 96, 3
) # 128 input channels, 96 output channels, 3x3 transpose convolutions
self.dec_bn8 = nn.BatchNorm2d(96) # Batch Norm layer
self.dec_conv9 = nn.ConvTranspose2d(
96, 3, 7
) # 96 input channels, 3 output channels, 7x7 transpose convolutions
self.dec_bn9 = nn.BatchNorm2d(3) # Batch Norm layer
def __init__(self, config, input_shape=None):
super(Net, self).__init__(config, input_shape)
self.NUM_CLASSES = P.GLB_PARAMS[P.KEY_DATASET_METADATA][
P.KEY_DS_NUM_CLASSES]
self.DROPOUT_P = config.CONFIG_OPTIONS.get(P.KEY_DROPOUT_P, 0.5)
self.NUM_LATENT_VARS = config.CONFIG_OPTIONS.get(
PP.KEY_VAE_NUM_LATENT_VARS, 256)
# Here we define the layers of our network
# First convolutional layer
self.conv1 = nn.Conv2d(
3, 96, 5) # 3 input channels, 96 output channels, 5x5 convolutions
self.bn1 = nn.BatchNorm2d(96) # Batch Norm layer
# Second convolutional layer
self.conv2 = nn.Conv2d(
96, 128,
3) # 96 input channels, 128 output channels, 3x3 convolutions
self.bn2 = nn.BatchNorm2d(128) # Batch Norm layer
# Third convolutional layer
self.conv3 = nn.Conv2d(
128, 192,
3) # 128 input channels, 192 output channels, 3x3 convolutions
self.bn3 = nn.BatchNorm2d(192) # Batch Norm layer
# Fourth convolutional layer
self.conv4 = nn.Conv2d(
192, 256,
3) # 192 input channels, 256 output channels, 3x3 convolutions
self.bn4 = nn.BatchNorm2d(256) # Batch Norm layer
self.CONV_OUTPUT_SHAPE = utils.tens2shape(
self.get_dummy_fmap()[self.CONV_OUTPUT])
self.CONV_OUTPUT_SIZE = utils.shape2size(self.CONV_OUTPUT_SHAPE)
# FC Layers
self.fc5 = nn.Linear(
self.CONV_OUTPUT_SIZE, 4096
) # conv_output_size-dimensional input, 4096-dimensional output
self.bn5 = nn.BatchNorm1d(4096) # Batch Norm layer
self.fc6 = nn.Linear(
4096, self.NUM_CLASSES
) # 4096-dimensional input, NUM_CLASSES-dimensional output (one per class)
self.fc_mu = nn.Linear(
4096, self.NUM_LATENT_VARS
) # 4096-dimensional input, NUM_LATENT_VARS-dimensional output
self.fc_var = nn.Linear(
4096, self.NUM_LATENT_VARS
) # 4096-dimensional input, NUM_LATENT_VARS-dimensional output
# Decoding Layers
self.dec_fc0 = nn.Linear(
self.NUM_LATENT_VARS,
4096) # NUM_LATENT_VARS-dimensional input, 4096-dimensional output
self.dec_bn0 = nn.BatchNorm1d(4096) # Batch Norm layer
self.dec_fc1 = nn.Linear(
4096, self.CONV_OUTPUT_SIZE
) # 4096-dimensional input, CONV_OUTPUT_SIZE-dimensional output
self.dec_bn1 = nn.BatchNorm1d(
self.CONV_OUTPUT_SIZE) # Batch Norm layer
self.dec_conv2 = nn.ConvTranspose2d(
256, 192, 3
) # 256 input channels, 192 output channels, 3x3 transpose convolutions
self.dec_bn2 = nn.BatchNorm2d(192) # Batch Norm layer
self.dec_conv3 = nn.ConvTranspose2d(
192, 128, 3
) # 192 input channels, 128 output channels, 3x3 transpose convolutions
self.dec_bn3 = nn.BatchNorm2d(128) # Batch Norm layer
self.dec_conv4 = nn.ConvTranspose2d(
128, 96, 3
) # 128 input channels, 96 output channels, 3x3 transpose convolutions
self.dec_bn4 = nn.BatchNorm2d(96) # Batch Norm layer
self.dec_conv5 = nn.ConvTranspose2d(
96, 3, 5
) # 96 input channels, 3 output channels, 5x5 transpose convolutions
self.dec_bn5 = nn.BatchNorm2d(3) # Batch Norm layer
