def __init__(self): super(ImgEncoderFg, self).__init__() assert arch.G in [4, 8, 16] # Adjust stride such that the output dimension of the volume matches (G, G, ...) last_stride = 2 if arch.G in [8, 4] else 1 second_to_last_stride = 2 if arch.G in [4] else 1 # Foreground Image Encoder in the paper # Encoder: (B, C, Himg, Wimg) -> (B, E, G, G) # G is H=W in the paper self.enc = nn.Sequential( nn.Conv2d(3, 16, 4, 2, 1), nn.CELU(), nn.GroupNorm(4, 16), nn.Conv2d(16, 32, 4, 2, 1), nn.CELU(), nn.GroupNorm(8, 32), nn.Conv2d(32, 64, 4, 2, 1), nn.CELU(), nn.GroupNorm(8, 64), nn.Conv2d(64, 128, 3, second_to_last_stride, 1), nn.CELU(), nn.GroupNorm(16, 128), nn.Conv2d(128, 256, 3, last_stride, 1), nn.CELU(), nn.GroupNorm(32, 256), nn.Conv2d(256, arch.img_enc_dim_fg, 1), nn.CELU(), nn.GroupNorm(16, arch.img_enc_dim_fg)) # Residual Connection in the paper # Remark: this residual connection is not important # Lateral connection (B, E, G, G) -> (B, E, G, G) self.enc_lat = nn.Sequential( nn.Conv2d(arch.img_enc_dim_fg, arch.img_enc_dim_fg, 3, 1, 1), nn.CELU(), nn.GroupNorm(16, arch.img_enc_dim_fg), nn.Conv2d(arch.img_enc_dim_fg, arch.img_enc_dim_fg, 3, 1, 1), nn.CELU(), nn.GroupNorm(16, arch.img_enc_dim_fg)) # Residual Encoder in the paper # Remark: also not important # enc + lateral -> enc (B, 2*E, G, G) -> (B, 128, G, G) self.enc_cat = nn.Sequential( nn.Conv2d(arch.img_enc_dim_fg * 2, 128, 3, 1, 1), nn.CELU(), nn.GroupNorm(16, 128)) # Image encoding -> latent distribution parameters (B, 128, G, G) -> (B, D, G, G) self.z_scale_net = nn.Conv2d(128, (arch.z_where_scale_dim) * 2, 1) self.z_shift_net = nn.Conv2d(128, (arch.z_where_shift_dim) * 2, 1) self.z_pres_net = nn.Conv2d(128, arch.z_pres_dim, 1) self.z_depth_net = nn.Conv2d(128, arch.z_depth_dim * 2, 1) # (G, G). Grid center offset. (offset_x[i, j], offset_y[i, j]) is the center for cell (i, j) offset_y, offset_x = torch.meshgrid( [torch.arange(arch.G), torch.arange(arch.G)]) # (2, G, G). I do this just to ensure that device is correct. self.register_buffer('offset', torch.stack((offset_x, offset_y), dim=0).float())
def __init__(self, c_in, c_out, kernel_size, stride, padding, dilation, affine=True): super(DilConv, self).__init__() self.op = nn.Sequential( nn.CELU(0.075), nn.Conv2d(c_in, c_in, kernel_size=kernel_size, stride=stride, padding=padding, dilation=dilation, groups=c_in, bias=False), nn.Conv2d(c_in, c_out, kernel_size=1, padding=0, bias=False), nn.BatchNorm2d(c_out, affine=affine), )
def __init__(self, inp_chnl, out_chnl): super(ConvCEluGrNorm, self).__init__() self.conv = nn.Conv2d(in_channels=inp_chnl, out_channels=out_chnl, kernel_size=3, padding=1, bias=False) self.norm = nn.GroupNorm(num_groups=16, num_channels=out_chnl) self.celu = nn.CELU(inplace=True)
def __init__(self, input_shape, num_layers, neurons, activator_id=5, optimizer_id=0): super().__init__() self.num_layers = num_layers # number of layers self.neurons = neurons # number of neurons in each layer e.g. for 2 layers, neurons=[10,20] self.activator_id = activator_id # activation function, can be one of the following: ELU, Hardshrink, LeakyReLU, LogSigmoid, PReLU, ReLU, ReLU6, RReLU, SELU, CELU, Sigmoid self.optimizer_id = optimizer_id # optimizer id, can be one of the following: Adadelta, Adagrad, Adam, Adamax, ASGD, RMSprop, Rprop, SGD # set activation function if (activator_id == 0): self.activator = nn.ELU() elif (activator_id == 1): self.activator = nn.Hardshrink() elif (activator_id == 2): self.activator = nn.LeakyReLU() elif (activator_id == 3): self.activator = nn.LogSigmoid() elif (activator_id == 4): self.activator = nn.PReLU() elif (activator_id == 5): self.activator = nn.ReLU() elif (activator_id == 6): self.activator = nn.ReLU6() elif (activator_id == 7): self.activator = nn.RReLU() elif (activator_id == 8): self.activator = nn.SELU() elif (activator_id == 9): self.activator = nn.CELU() # network architecture if (num_layers == 1): self.layers = nn.Sequential( nn.Linear(input_shape, self.neurons[0]), self.activator, nn.Linear(self.neurons[0], 1)) elif (num_layers == 2): self.layers = nn.Sequential( nn.Linear(input_shape, self.neurons[0]), self.activator, nn.Linear(self.neurons[0], self.neurons[1]), self.activator, nn.Linear(self.neurons[1], 1)) elif (num_layers == 3): self.layers = nn.Sequential( nn.Linear(input_shape, self.neurons[0]), self.activator, nn.Linear(self.neurons[0], self.neurons[1]), self.activator, nn.Linear(self.neurons[1], self.neurons[2]), self.activator, nn.Linear(self.neurons[2], 1)) elif (num_layers == 4): self.layers = nn.Sequential( nn.Linear(input_shape, self.neurons[0]), self.activator, nn.Linear(self.neurons[0], self.neurons[1]), self.activator, nn.Linear(self.neurons[1], self.neurons[2]), self.activator, nn.Linear(self.neurons[2], self.neurons[3]), self.activator, nn.Linear(self.neurons[3], 1))
def __init__(self, in_planes, out_planes, kernel_size=3, stride=1, groups=1, padding=None): if padding is None: padding = (kernel_size - 1) // 2 super(ConvBNCELU, self).__init__( nn.Conv2d(in_planes, out_planes, kernel_size=kernel_size, stride=stride, padding=padding, groups=groups, bias=False), nn.BatchNorm2d(out_planes), nn.CELU(inplace=True), )
def __init__(self, dim, low_dim=16, kernel_size=3, padding=1, stride=1): super(Low_ResBlock, self).__init__() self.conv = nn.Sequential( nn.Conv2d(dim, low_dim, kernel_size=1, stride=1, padding=0), nn.BatchNorm2d(low_dim), nn.CELU(), nn.Conv2d(low_dim, low_dim, kernel_size=3, stride=1, padding=1, groups=low_dim), nn.BatchNorm2d(low_dim), nn.CELU(), nn.Conv2d(low_dim, dim, kernel_size=1, stride=1, padding=0), nn.BatchNorm2d(dim), nn.CELU(), )
def __init__(self, in_planes, planes, stride=1, activation='ReLU', softplus_beta=1): super(PreActBlock, self).__init__() self.bn1 = normal_func(in_planes, track_running_stats=track_running_stats, affine=affine) self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=3, stride=stride, padding=1, bias=False) self.bn2 = normal_func(planes, track_running_stats=track_running_stats, affine=affine) self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=1, padding=1, bias=False) if stride != 1 or in_planes != self.expansion * planes: self.shortcut = nn.Sequential( nn.Conv2d(in_planes, self.expansion * planes, kernel_size=1, stride=stride, bias=False)) if activation == 'ReLU': self.relu = nn.ReLU(inplace=True) print('ReLU') elif activation == 'Softplus': self.relu = nn.Softplus(beta=softplus_beta, threshold=20) print('Softplus') elif activation == 'GELU': self.relu = nn.GELU() print('GELU') elif activation == 'ELU': self.relu = nn.ELU(alpha=1.0, inplace=True) print('ELU') elif activation == 'LeakyReLU': self.relu = nn.LeakyReLU(negative_slope=0.1, inplace=True) print('LeakyReLU') elif activation == 'SELU': self.relu = nn.SELU(inplace=True) print('SELU') elif activation == 'CELU': self.relu = nn.CELU(alpha=1.2, inplace=True) print('CELU') elif activation == 'Tanh': self.relu = nn.Tanh() print('Tanh')
def function(self): if self.value == 0: return nn.ReLU() elif self.value == 1: return nn.GELU() elif self.value == 2: return nn.CELU() else: raise ValueError("Invalid activation function type.")
def __init__(self, atom_vertex_dim, atom_edge_dim, orbital_vertex_dim=NotImplemented, orbital_edge_dim=NotImplemented, output_dim=NotImplemented, mp_step=6, s2s_step=6): super(MultiNet, self).__init__() self.atom_vertex_dim = atom_vertex_dim self.atom_edge_dim = atom_edge_dim self.orbital_vertex_dim = orbital_vertex_dim self.orbital_edge_dim = orbital_edge_dim self.output_dim = output_dim self.mp_step = mp_step self.s2s_step = s2s_step # atom net atom_edge_gc = nn.Sequential(nn.Linear(atom_edge_dim[1], atom_vertex_dim[1] ** 2), nn.Dropout(0.2)) self.atom_vertex_conv = NNConv(atom_vertex_dim[1], atom_vertex_dim[1], atom_edge_gc, aggr="mean", root_weight=True) self.atom_vertex_gru = nn.GRU(atom_vertex_dim[1], atom_vertex_dim[1]) self.atom_s2s = Set2Set(atom_vertex_dim[1], processing_steps=s2s_step) self.atom_lin0 = nn.Sequential(nn.Linear(atom_vertex_dim[0], 2 * atom_vertex_dim[0]), nn.CELU(), nn.Linear(2 * atom_vertex_dim[0], atom_vertex_dim[1]), nn.CELU()) self.atom_lin1 = nn.Sequential(nn.Linear(atom_edge_dim[0], 2 * atom_edge_dim[0]), nn.CELU(), nn.Linear(2 * atom_edge_dim[0], atom_edge_dim[1]), nn.CELU()) self.atom_lin2 = nn.Sequential(nn.Linear(2 * atom_vertex_dim[1], 4 * atom_vertex_dim[1]), nn.CELU()) # orbital net orbital_edge_gc = nn.Sequential(nn.Linear(orbital_edge_dim[1], orbital_vertex_dim[1] ** 2), nn.Dropout(0.2)) self.orbital_vertex_conv = NNConv(orbital_vertex_dim[1], orbital_vertex_dim[1], orbital_edge_gc, aggr="mean", root_weight=True) self.orbital_vertex_gru = nn.GRU(orbital_vertex_dim[1], orbital_vertex_dim[1]) self.orbital_s2s = Set2Set(orbital_vertex_dim[1], processing_steps=s2s_step) self.orbital_lin0 = nn.Sequential(nn.Linear(orbital_vertex_dim[0], 2 * orbital_vertex_dim[0]), nn.CELU(), nn.Linear(2 * orbital_vertex_dim[0], orbital_vertex_dim[1]), nn.CELU()) self.orbital_lin1 = nn.Sequential(nn.Linear(orbital_edge_dim[0], 2 * orbital_edge_dim[0]), nn.CELU(), nn.Linear(2 * orbital_edge_dim[0], orbital_edge_dim[1]), nn.CELU()) self.orbital_lin2 = nn.Sequential(nn.Linear(2 * orbital_vertex_dim[1], 4 * orbital_vertex_dim[1]), nn.CELU()) # cross net self.cross_lin0 = nn.Sequential( nn.Linear(4 * atom_vertex_dim[1] + 4 * orbital_vertex_dim[1], 4 * output_dim), nn.CELU(), nn.Linear(4 * output_dim, output_dim) ) self.cross_o2a_lin = nn.Sequential(nn.Linear(orbital_vertex_dim[1], 2 * orbital_vertex_dim[1]), nn.CELU(), nn.Linear(2 * orbital_vertex_dim[1], int(atom_vertex_dim[1] / 2)), nn.CELU()) self.cross_o2a_s2s = Set2Set(int(atom_vertex_dim[1] / 2), processing_steps=s2s_step) self.cross_o2a_gru = nn.GRU(atom_vertex_dim[1], atom_vertex_dim[1]) self.cross_a2o_lin = nn.Sequential(nn.Linear(atom_vertex_dim[1], 2 * atom_vertex_dim[1]), nn.CELU(), nn.Linear(2 * atom_vertex_dim[1], orbital_vertex_dim[1]), nn.CELU()) self.cross_a2o_gru = nn.GRU(orbital_vertex_dim[1], orbital_vertex_dim[1])
def __init__(self): nn.Module.__init__(self) embed_size = ARCH.GLIMPSE_SIZE // 16 self.enc = nn.Sequential( nn.Conv2d(3, 16, 3, 2, 1), nn.CELU(), nn.GroupNorm(1, 16), nn.Conv2d(16, 32, 3, 2, 1), nn.CELU(), nn.GroupNorm(2, 32), nn.Conv2d(32, 64, 3, 2, 1), nn.CELU(), nn.GroupNorm(4, 64), nn.Conv2d(64, 128, 3, 2, 1), nn.CELU(), nn.GroupNorm(8, 128), ) self.enc_what = nn.Linear(128 * embed_size**2, ARCH.BG_PROPOSAL_DIM)
def conv_bn_relu(c_in, c_out, kernel_size=(3, 3), padding=(1, 1)): return nn.Sequential( nn.Conv2d(c_in, c_out, kernel_size=kernel_size, padding=padding, bias=False), GhostBatchNorm(c_out, num_splits=16), nn.CELU(alpha=0.3), )
def get_act(act="relu"): if act == "relu": return nn.ReLU() elif act == "elu": return nn.ELU() elif act == "celu": return nn.CELU() elif act == "leaky_relu": return nn.LeakyReLU() elif act == "sigmoid": return nn.Sigmoid() elif act == "tanh": return nn.Tanh() elif act == "linear": return nn.Identity() elif act == 'softplus': return nn.modules.activation.Softplus() else: return None
def __init__(self, dimensions): super(sdae, self).__init__() self.dimensions = dimensions encoder_units = build_units(dimensions) self.encoder = nn.Sequential(*encoder_units) decoder_units = build_units(list(reversed(dimensions))) decoder_units[-1].add_module('activation', nn.CELU()) # unit = [('activation', nn.Softplus())] # decoder_units.append(nn.Sequential(OrderedDict(unit))) self.decoder = nn.Sequential(*decoder_units)
def str2act(act): activations = { 'relu': nn.ReLU(), 'selu': nn.SELU(), 'celu': nn.CELU(), 'softplus': nn.Softplus(), 'softmax': nn.Softmax(), 'sigmoid': nn.Sigmoid() } return activations[act]
def __init__(self, inplanes, planes, stride=1, norm_layer=None): super().__init__() if norm_layer is None: norm_layer = nn.BatchNorm2d self.stride = stride self.conv1 = conv3x3(inplanes, planes, stride=1) self.pool = nn.MaxPool2d(2) self.bn = norm_layer(planes) self.relu = nn.CELU(inplace=True, alpha=.075)
def block(input_dim, output_dim): return nn.Sequential( nn.ConvTranspose2d(input_dim, output_dim, 5, stride=2, padding=2, output_padding=1, bias=False), nn.BatchNorm2d(output_dim), nn.CELU())
def __init__(self, in_channel, out_channel, kernel_size, ratio, groups=1): super(resblock, self).__init__() self.layers = nn.Sequential( # nn.GroupNorm(num_groups=groups, num_channels=in_channel), nn.CELU(), nn.Conv1d(in_channel, out_channel, kernel_size, padding=(kernel_size - 1) // 2, groups=groups), # nn.GroupNorm(num_groups=groups, num_channels=out_channel), nn.CELU(), nn.Conv1d(out_channel, out_channel, kernel_size, padding=(kernel_size - 1) // 2, groups=groups)) self.ratio = ratio
def __init__(self, in_channels, out_channels, ks=4, stride=2, padding=1, dilation=1, bn_enable=False, upsample=False, act_enable=True, act_type="relu"): super(DecoderBlockM1, self).__init__() self.in_channels = in_channels self.out_channels = out_channels self.ks = ks self.stride = stride self.padding = padding self.dilation = dilation self.bn_enable = bn_enable self.upsample = upsample self.act_enable = act_enable self.act_type = act_type assert self.act_type in [ "relu", "celu", "fts+" ], "Error. Unknown activation function: {}".format(self.act_type) self.deconv = nn.Upsample( scale_factor=2, mode='bilinear') if self.upsample else nn.ConvTranspose2d( in_channels=self.in_channels, out_channels=self.out_channels, kernel_size=self.ks, stride=self.stride, padding=self.padding, dilation=self.dilation) if self.upsample: self.conv = nn.Conv2d(in_channels=self.in_channels, out_channels=self.out_channels, kernel_size=1) if self.bn_enable: self.bn = nn.BatchNorm2d(self.out_channels) if self.act_enable: if self.act_type == "relu": self.act = nn.ReLU(inplace=True) elif self.act_type == "celu": self.act = nn.CELU(inplace=True) elif self.act_type == "fts+": self.act = FTSwishPlus() else: raise ValueError("Unknown value: {}".format(self.act_type))
def get_act(name: str, inplace: bool = True, params: Optional[dict] = None) -> activation: """ get activation module from pytorch must be one of: relu, lrelu, linear, tanh, sigmoid Args: name (str): name of activation function desired inplace (bool): flag activation to do operations in-place (if option available) params (dict): dictionary of parameters (as per pytorch documentation) Returns: act (activation): instance of activation class """ if name.lower() == 'relu': act = nn.ReLU(inplace=inplace) elif name.lower() == 'lrelu': act = nn.LeakyReLU( inplace=inplace) if params is None else nn.LeakyReLU( inplace=inplace, **params) elif name.lower() == 'prelu': act = nn.PReLU() if params is None else nn.PReLU(**params) elif name.lower() == 'elu': act = nn.ELU(inplace=inplace) if params is None else nn.ELU( inplace=inplace, **params) elif name.lower() == 'celu': act = nn.CELU(inplace=inplace) if params is None else nn.CELU( inplace=inplace, **params) elif name.lower() == 'selu': act = nn.SELU(inplace=inplace) elif name.lower() == 'linear': act = nn.LeakyReLU(1, inplace=inplace) # hack to get linear output elif name.lower() == 'tanh': act = nn.Tanh() elif name.lower() == 'sigmoid': act = nn.Sigmoid() else: raise SynthNNError( f'Activation: "{name}" not a valid activation function or not supported.' ) return act
def __init__(self, in_plane, out_plane): super(HourGlass_upBlock, self).__init__() self.conv = nn.Sequential( nn.ConvTranspose2d(in_plane, out_plane, kernel_size=4, stride=2, padding=1), nn.BatchNorm2d(out_plane), nn.CELU(inplace=True), )
def __init__(self, config): """ in_channels : 一般就是 word embedding 的维度,或者 hidden size 的维度 out_channels : int kernel_sizes : list 为了保证输出长度=输入长度,必须为奇数: 3, 5, 7... activation : [relu, lrelu, prelu, selu, celu, gelu, sigmoid, tanh] pooling_strategy : [max, avg, cls] dropout: : float """ super(CNN, self).__init__() # self.xxx = config.xxx self.in_channels = config.in_channels self.out_channels = config.out_channels self.kernel_sizes = config.kernel_sizes self.activation = config.activation self.pooling_strategy = config.pooling_strategy self.dropout = config.dropout self.keep_length = config.keep_length for kernel_size in self.kernel_sizes: assert kernel_size % 2 == 1, "kernel size has to be odd numbers." # convolution self.convs = nn.ModuleList([ nn.Conv1d(in_channels=self.in_channels, out_channels=self.out_channels, kernel_size=k, stride=1, padding=k // 2 if self.keep_length else 0, dilation=1, groups=1, bias=False) for k in self.kernel_sizes ]) # activation function assert self.activation in ['relu', 'lrelu', 'prelu', 'selu', 'celu', 'gelu', 'sigmoid', 'tanh'], \ 'activation function must choose from [relu, lrelu, prelu, selu, celu, gelu, sigmoid, tanh]' self.activations = nn.ModuleDict([ ['relu', nn.ReLU()], ['lrelu', nn.LeakyReLU()], ['prelu', nn.PReLU()], ['selu', nn.SELU()], ['celu', nn.CELU()], ['gelu', GELU()], ['sigmoid', nn.Sigmoid()], ['tanh', nn.Tanh()], ]) # pooling assert self.pooling_strategy in [ 'max', 'avg', 'cls' ], 'pooling strategy must choose from [max, avg, cls]' self.dropout = nn.Dropout(self.dropout)
def __init__(self, args): self.args = args super(AttEncoder, self).__init__() self.temporal_img_conv_net = nn.Sequential( nn.Conv2d(img_encode_dim, temporal_img_enc_hid_dim, 1), nn.CELU(), nn.GroupNorm(8, temporal_img_enc_hid_dim)) self.temporal_img_enc_net = nn.Linear( temporal_img_enc_hid_dim * self.args.num_cell_h // 2 * self.args.num_cell_w // 2, temporal_img_enc_dim)
def __init__(self, config, device='cpu'): super(DSSMFour, self).__init__() # self.device = device # # 此部分的信息有待处理 # self.latent_out = config.latent_out_1 # self.hidden_size = config.hidden_size # self.kernel_out = config.kernel_out_1 # self.kernel_size = config.kernel_size # self.max_len = config.max_len # self.kmax = config.kmax # # self.embeddings = nn.Embedding(config.vocab_size, self.hidden_size) # # layers for query # self.query_conv = nn.Conv1d(self.hidden_size, self.kernel_out, self.kernel_size) # 16* 64 * 1 # self.pool_1 = nn.MaxPool1d(2) # self.query_conv_2 = nn.Conv1d(16, 32, self.kernel_size) # self.query_sem = nn.Linear(self.max_len, self.latent_out) ## config.latent_out_1 需要输出的语义维度中间 # # # learning gamma # if config.loss == 'bce': # self.learn_gamma = nn.Conv1d(self.latent_out * 2, 1, 1) # else: # self.learn_gamma = nn.Linear(2 * self.latent_out, 2) # # self.soft = nn.Softmax(dim=1) # # self.norm = nn.BatchNorm1d(2 * self.latent_out) # 此部分的信息有待处理 self.latent_out = config.latent_out_1 self.hidden_size = config.hidden_size self.kernel_out = config.kernel_out_1 self.kernel_size = config.kernel_size self.max_len = config.max_len self.embeddings = nn.Embedding(config.vocab_size, self.hidden_size) self.convs = nn.Sequential( nn.Conv1d(in_channels=self.hidden_size, out_channels=self.kernel_out, kernel_size=self.kernel_size), nn.LeakyReLU(), nn.BatchNorm1d(self.kernel_out), nn.Conv1d(in_channels=self.kernel_out, out_channels=16, kernel_size=1), nn.LeakyReLU(), nn.MaxPool1d(2), nn.BatchNorm1d(16)) # nn.BatchNorm1d(num_features=config.feature_size), # nn.ReLU(), # nn.MaxPool1d(kernel_size=self.max_len + 1))])) self.learn_gamma = nn.Conv1d(32, 16, 32) self.lrelu = nn.CELU() self.norm = nn.BatchNorm1d(16) self.fc = nn.Linear(in_features=16, out_features=2)
def __init__(self): super(ZWhatEnc, self).__init__() if glimpse_size == 32: self.enc_cnn = nn.Sequential( nn.Conv2d(3, 16, 4, 2, 1), nn.CELU(), nn.GroupNorm(4, 16), nn.Conv2d(16, 32, 4, 2, 1), nn.CELU(), nn.GroupNorm(8, 32), nn.Conv2d(32, 64, 4, 2, 1), nn.CELU(), nn.GroupNorm(8, 64), nn.Conv2d(64, 64, 3, 1, 1), nn.CELU(), nn.GroupNorm(8, 64), nn.Conv2d(64, z_what_enc_dim, 4), nn.CELU(), nn.GroupNorm(16, z_what_enc_dim) ) elif glimpse_size == 64: self.enc_cnn = nn.Sequential( nn.Conv2d(3, 16, 4, 2, 1), nn.CELU(), nn.GroupNorm(4, 16), nn.Conv2d(16, 32, 4, 2, 1), nn.CELU(), nn.GroupNorm(8, 32), nn.Conv2d(32, 64, 4, 2, 1), nn.CELU(), nn.GroupNorm(8, 64), nn.Conv2d(64, 128, 4, 2, 1), nn.CELU(), nn.GroupNorm(16, 128), nn.Conv2d(128, 128, 4), nn.CELU(), nn.GroupNorm(16, 128), ) self.enc_what = nn.Linear(128, z_what_dim * 2)
def __init__(self, z_size=16): super(encoder, self).__init__() self.contract_layers = nn.Sequential( nn.Conv2d(4, 32, 3, stride=2, bias=False), nn.CELU(), # nn.BatchNorm2d(32), nn.Conv2d(32, 32, 3, stride=2, bias=False), nn.CELU(), # nn.BatchNorm2d(32), nn.Conv2d(32, 64, 3, stride=2, bias=False), nn.CELU(), # nn.BatchNorm2d(64), nn.Conv2d(64, 64, 3, stride=2, bias=False), nn.CELU(), # nn.BatchNorm2d(64) ) self.linear1 = nn.Linear(64 * 7 * 7, 256) self.linear2_logvar = nn.Linear(256, z_size) self.linea2_mu = nn.Linear(256, z_size) self.relu = nn.ReLU()
def __init__(self, input_size, output_size, use_multiply=True, linear_block=nn.Linear): super().__init__() self._activation = nn.CELU() self._linear = linear_block(input_size, output_size) self._use_multiply = use_multiply if self._use_multiply: self._to_multiplier = linear_block(output_size, output_size)
def __init__(self, in_out_nz, mapper_inter_nz, mapper_inter_layer): super(Mapping, self).__init__() linear = nn.ModuleList() linear.append(nn.BatchNorm1d(in_out_nz)) if mapper_inter_layer >= 2: linear.append( nn.Linear(in_features=in_out_nz, out_features=mapper_inter_nz)) linear.append(nn.BatchNorm1d(mapper_inter_nz)) linear.append(nn.CELU()) for i in range(mapper_inter_layer - 2): linear.append( nn.Linear(in_features=mapper_inter_nz, out_features=mapper_inter_nz)) linear.append(nn.CELU()) linear.append( nn.Linear(in_features=mapper_inter_nz, out_features=in_out_nz)) else: linear.append( nn.Linear(in_features=in_out_nz, out_features=in_out_nz)) self.linear = linear
def __init__(self): super(ZWhatEnc, self).__init__() self.enc_cnn = nn.Sequential( nn.Conv2d(3, 16, 3, 1, 1), nn.CELU(), nn.GroupNorm(4, 16), nn.Conv2d(16, 32, 4, 2, 1), nn.CELU(), nn.GroupNorm(8, 32), nn.Conv2d(32, 32, 3, 1, 1), nn.CELU(), nn.GroupNorm(4, 32), nn.Conv2d(32, 64, 4, 2, 1), nn.CELU(), nn.GroupNorm(8, 64), nn.Conv2d(64, 128, 4, 2, 1), nn.CELU(), nn.GroupNorm(8, 128), nn.Conv2d(128, 256, 4), nn.CELU(), nn.GroupNorm(16, 256), ) self.enc_what = nn.Linear(256, arch.z_what_dim * 2)
def __init__(self, cfg): super(Deeplabv3plus, self).__init__() self.backbone = resnet50(pretrained=True, os=cfg.OUTPUT_STRIDE) in_plane = 2048 self.aspp = ASPP(in_plane, cfg.ASPP_OUTDIM) self.dropout = nn.Dropout(0.5) self.upsample_sub = nn.UpsamplingBilinear2d(scale_factor=4) self.upsample_aspp = nn.UpsamplingBilinear2d( scale_factor=cfg.OUTPUT_STRIDE // 4) in_dim = 256 self.shortconv = nn.Sequential( nn.Conv2d(in_dim, cfg.SHORTCUT_DIM, 1, 1, 0, bias=False), nn.BatchNorm2d(cfg.SHORTCUT_DIM), nn.ReLU(inplace=True)) self.cat_conv = nn.Sequential( nn.Conv2d(cfg.ASPP_OUTDIM + cfg.SHORTCUT_DIM, cfg.ASPP_OUTDIM, kernel_size=3, stride=1, padding=2, dilation=2, bias=False), nn.BatchNorm2d(cfg.ASPP_OUTDIM), nn.CELU(alpha=0.075, inplace=False), nn.Dropout(0.5), nn.Conv2d(cfg.ASPP_OUTDIM, cfg.ASPP_OUTDIM, 3, 1, 1, bias=False), nn.BatchNorm2d(cfg.ASPP_OUTDIM), nn.CELU(alpha=0.075, inplace=False), nn.Dropout(0.1)) self.clt_conv = nn.Conv2d(cfg.ASPP_OUTDIM, cfg.NUM_CLASS, 1, 1, 0, bias=False) for m in self.modules(): if isinstance(m, nn.Conv2d): nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu') if isinstance(m, nn.BatchNorm2d): nn.init.constant_(m.weight, 1) nn.init.constant_(m.bias, 0)
def __init__(self): super(Anti_spoof_net_CNN, self).__init__() self.resize_32 = nn.Upsample(size=32, mode='nearest') self.resize_64 = nn.Upsample(size=64, mode='nearest') self.cnn0 = nn.Conv2d(in_channels=3, out_channels=64, kernel_size=3, stride=1, padding=1) nn.init.xavier_normal(self.cnn0.weight) self.bn0 = nn.BatchNorm2d(64) self.non_linearity0 = nn.CELU(alpha=1.0, inplace=False) self.block1 = block(True) self.block2 = block(False) self.block3 = block(False) #Feature map: self.cnn4 = nn.Conv2d(in_channels=384, out_channels=128, kernel_size=3, stride=1, padding=1) self.cnn5 = nn.Conv2d(in_channels=128, out_channels=3, kernel_size=3, stride=1, padding=1) self.cnn6 = nn.Conv2d(in_channels=3, out_channels=1, kernel_size=3, stride=1, padding=1) #Depth map: self.cnn7 = nn.Conv2d(in_channels=384, out_channels=128, kernel_size=3, stride=1, padding=1) self.cnn8 = nn.Conv2d(in_channels=128, out_channels=64, kernel_size=3, stride=1, padding=1) self.cnn9 = nn.Conv2d(in_channels=64, out_channels=1, kernel_size=3, stride=1, padding=1)