def forward(self,x): device =torch.device("cuda" if torch.cuda.is_available() else "cpu") weight = torch.tensor([0.25],device=device) x=self.flatten(x) x=F.prelu(self.ln1(x),weight) x=F.prelu(self.ln2(x),weight) x=F.prelu(self.ln3(x),weight) return x
def forward_(self, pos_x, neg_x, edge_index): # type: (Tensor, Tensor, Tensor) -> Tuple[Tensor, Tensor, Tensor] """Returns the latent space for the input arguments, their corruptions and their summary representation.""" pos_z = F.prelu(self.gcn(pos_x, edge_index), self.reluWeight) neg_z = F.prelu(self.gcn(neg_x, edge_index), self.reluWeight) summary = torch.sigmoid(torch.mean(pos_z, dim=0)) return pos_z, neg_z, summary
def forward_(self, pos_x, neg_x, first_edge_index, second_edge_index): # type: (Tensor, Tensor, Tensor, Tensor) -> Tuple[Tensor, Tensor, Tensor] pos_x = F.prelu(self.gcn1(pos_x, second_edge_index), self.prelu1) pos_z = F.prelu(self.gcn2(pos_x, first_edge_index), self.prelu2) neg_x = F.prelu(self.gcn1(neg_x, second_edge_index), self.prelu1) neg_z = F.prelu(self.gcn2(neg_x, first_edge_index), self.prelu2) summary = torch.sigmoid(torch.mean(pos_z, dim=0)) return pos_z, neg_z, summary
def inverse(self, x): inv = F.prelu(x, 1 / torch.exp(self.alphas)) logdet = (inv >= 0).float() * torch.ones(size=( self.hparams['channels'], )) + (inv < 0).float() * self.alphas logdet = torch.sum(logdet, dim=1) #print("Prelu logdet "+str(logdet)) return (inv, logdet)
def forward(self, x): mp_ks = 2 mp_strd = 2 x = self.prelu1_1(self.conv1(x)) x = self.prelu1_2(self.conv2(x)) x = F.max_pool2d(x, kernel_size=mp_ks, stride=mp_strd) x = self.prelu2_1(self.conv3(x)) x = self.prelu2_2(self.conv4(x)) x = F.max_pool2d(x, kernel_size=mp_ks, stride=mp_strd) x = self.prelu3_1(self.conv5(x)) x = self.prelu3_2(self.conv6(x)) x = F.max_pool2d(x, kernel_size=mp_ks, stride=mp_strd) x = x.view(-1, 3 * 3 * 512) # Flatten features3d = self.fc1(x) # features2d = self.fc2(features3d) x = F.prelu(features3d, self.prelu_weight) x = self.fc3(x) return features3d, x
def forward(self, x): if self.batchnorm1 == 'On': x = self.fc0_bn(x) x = self.fc1(x) x = F.prelu(x, torch.tensor(0.1)) if self.batchnorm1 == 'On': x = self.fc1_bn(x) x = self.fc1_do(x) x = self.fc2(x) x = F.prelu(x, torch.tensor(0.1)) if self.batchnorm2 == 'On': x = self.fc2_bn(x) x = self.fc2_do(x) x = self.fc3(x) return x
def prelu(input, *args, **kwargs): output = F.prelu(input.F, *args, **kwargs) return SparseTensor( output, coordinate_map_key=input.coordinate_map_key, coordinate_manager=input.coordinate_manager, )
def forward(self, x): p = self.convP1(x) #print('conv1 shape: ' + str(x.shape)) p = self.convP1_drop(p) #print('drop shape: ' + str(x.shape)) #Size changes from (20, 64, 64) to (30, 32, 32) p = F.max_pool2d(p, kernel_size=2) #print('pool1 shape: ' + str(x.shape)) p = F.prelu(p, torch.tensor(.25)) #Size changes from (20, 32, 32) to (30, 32, 32) p = self.convP2(p) #print('conv2 shape: ' + str(x.shape)) p = self.convP2_drop(p) #print('drop shape: ' + str(x.shape)) #Size changes from (30, 32, 32) to (30, 16, 16) p = F.max_pool2d(p, kernel_size=2) #print('pool2 shape: ' + str(x.shape)) p = F.prelu(p, torch.tensor(.25)) p = p.view((-1, 1024)) #print('post view shape: ' + str(x.shape)) p = self.fcP1(p) v = self.convV1(x) #print('conv1 shape: ' + str(x.shape)) v = self.convV1_drop(v) #print('drop shape: ' + str(x.shape)) #Size changes from (20, 64, 64) to (30, 32, 32) v = F.max_pool2d(v, kernel_size=2) #print('pool1 shape: ' + str(x.shape)) v = F.prelu(v, torch.tensor(.25)) #Size changes from (20, 32, 32) to (30, 32, 32) v = self.convV2(v) #print('conv2 shape: ' + str(x.shape)) v = self.convV2_drop(v) #print('drop shape: ' + str(x.shape)) #Size changes from (30, 32, 32) to (30, 16, 16) v = F.max_pool2d(v, kernel_size=2) #print('pool2 shape: ' + str(x.shape)) v = F.prelu(v, torch.tensor(.25)) v = v.view((-1, 1024)) #print('post view shape: ' + str(x.shape)) v = self.fcV1(v) return p, v
def forward(self, input): input = F.prelu(input, self.weight) input = clamp(input, -self.clip_val, self.clip_val, self.inplace) input = (input + 1) / 2 input = LinearQuantizeSTE.apply(input, self.scale_factor, self.dequantize, self.inplace) input = input * 2 - 1 return input
def forward(self, x, y, z, w, w0, w1, w2, w3): x = F.prelu(x, w0) x = F.prelu(x, self.w4) y = F.prelu(y, w1) y = F.prelu(y, self.w5) z = F.prelu(z, w2) z = F.prelu(z, self.w6) w = F.prelu(w, w3) w = F.prelu(w, self.w7) return x, y, z, w
def forward(self, batch): if self.tied: for i in range(self.num_layers): # if self.tied: # W1 = self.W1[:, :, 0] # W2 = self.W2[:, :, 0] # else: # W1 = self.W1[: ,:, i] # W2 = self.W2[:, :, i] batch = F.linear(batch, weight=self.W1[:, :, 0], bias=self.b[:, i]) if self.layer_normalization: batch = self.normed(batch) batch = F.prelu(batch, self.slope) # batch = torch.sigmoid(batch) if self.symmetric: batch = F.linear(batch, weight=self.W1[:, :, 0].t(), bias=self.c[:, i]) else: batch = F.linear(batch, weight=self.W2[:, :, 0], bias=self.c[:, i]) else: for i in range(self.num_layers): batch = F.linear(batch, weight=self.W1[:, :, i], bias=self.b[:, i]) if self.layer_normalization: batch = self.normed(batch) batch = F.prelu(batch, self.slope) # batch = torch.sigmoid(batch) if self.symmetric: batch = F.linear(batch, weight=self.W1[:, :, i].t(), bias=self.c[:, i]) else: batch = F.linear(batch, weight=self.W2[:, :, i], bias=self.c[:, i]) return batch
def standard_unit(input_tensor, inchannel, outchannel, kernel_size=3, padding=1): w1 = torch.empty(outchannel, inchannel, kernel_size, kernel_size) b1 = torch.empty(outchannel) torch.nn.init.kaiming_normal_(w1) torch.nn.init.kaiming_normal_(b1) x = F.conv2d(input_tensor, w1, b1, padding=padding) x = F.batch_norm(x) x = F.prelu(x) x = F.dropout2d(x, dropout_rate) w2 = torch.empty(outchannel, outchannel, kernel_size, kernel_size) b2 = torch.empty(outchannel) torch.nn.init.kaiming_normal_(w2) torch.nn.init.kaiming_normal_(b2) x = F.conv2d(x, w1, b1, padding=padding) x = F.batch_norm(x) x = F.prelu(x) x = F.dropout2d(x, dropout_rate) return x
def adpW(self,x): # x = F.normalize(x) x = self.adp_metric_embedding1(x) # x = self.adp_metric_embedding1_bn(x) x = F.prelu(x) x = self.adp_metric_embedding2(x) # x = self.adp_metric_embedding2_bn(x) diag_matrix = [] for i in range(x.size(0)): diag_matrix.append(torch.diag(x[i,:])) x = torch.stack(diag_matrix) W = torch.matmul(self.transform_matrix,torch.matmul(x,self.transform_matrix)) return W
def embedding_(self, x, first_edge_index, second_edge_index): r"""Generates learned representation of the input nodes.""" x = F.prelu(self.gcn1(x, second_edge_index), self.prelu1) x = F.prelu(self.gcn2(x, first_edge_index), self.prelu2) return x
def forward(self, inputs, weights): return F.prelu(inputs + inputs, weights)
def forward(self, x): from torch.nn import functional as F weights = torch.FloatTensor(torch.rand(self.num_params).numpy()) return F.prelu(x, weight=weights)
def _prelu(self, tensor): return F.prelu(tensor, self.weight)
'relu': F.relu, 'sigmoid': torch.sigmoid, 'tanh': torch.tanh, 'softabs': lambda x, epsilon: torch.sqrt(torch.pow(x, 2.0) + epsilon), 'softmax': nnef_softmax, 'softplus': lambda x: torch.log(torch.exp(x) + 1.0), 'elu': F.elu, 'prelu': lambda x, alpha: F.prelu(x, alpha), 'leaky_relu': lambda x, alpha: F.leaky_relu(x, alpha), 'max_pool_with_index': nnef_max_pool_with_index, 'max_pool': nnef_max_pool, 'avg_pool': nnef_avg_pool, 'rms_pool': nnef_rms_pool, 'linear': nnef_linear, 'separable_conv': nnef_separable_conv, 'separable_deconv':
def forward(self, input: torch.Tensor) -> torch.Tensor: return F.prelu(input, self.weight)
sumproducts = np.matmul(x1_list, x2_list) #print(sumproducts) # 2) vectorize_Relu #x = np.array([x1_list, x2_list]) x = torch.randn(np.random.randint(3, 10), np.random.randint(3, 10), np.random.randint(3, 10)) y = F.relu(x) # 3) vectorize_Prelu a = torch.tensor(0.1) y = F.prelu(x, a) print(x) print(x.shape) # Problem 3 # 1) slice fixed point def result_slice_fixed_points(df, length, position): for i in range(df.shape[0]): result = torch.tensor(df.shape) print(result.shape) #result[i] = df[position:position+length] print(df[position:position + length]) return result
def forward(self, input): self.weight.clamp(0, 0.5) return F.prelu(input, self.weight) / torch.sqrt(1. + self.weight**2)
def PRELU_2d(self, x, alph): y = F.prelu(x, alph) return y
def forward(self, x): y = F.prelu(x, torch.exp(self.alphas)) return y
def forward(self, x): self.minusscalar0_second = torch.autograd.Variable(torch.from_numpy( _weights_dict['minusscalar0_second']['value']), requires_grad=False) self.mulscalar0_second = torch.autograd.Variable(torch.from_numpy( _weights_dict['mulscalar0_second']['value']), requires_grad=False) minusscalar0 = x - self.minusscalar0_second mulscalar0 = minusscalar0 * self.mulscalar0_second conv_1_conv2d_pad = F.pad(mulscalar0, (1, 1, 1, 1)) conv_1_conv2d = self.conv_1_conv2d(conv_1_conv2d_pad) conv_1_batchnorm = self.conv_1_batchnorm(conv_1_conv2d) conv_1_relu = F.prelu( conv_1_batchnorm, torch.from_numpy(_weights_dict['conv_1_relu']['weights'])) conv_2_dw_conv2d_pad = F.pad(conv_1_relu, (1, 1, 1, 1)) conv_2_dw_conv2d = self.conv_2_dw_conv2d(conv_2_dw_conv2d_pad) conv_2_dw_batchnorm = self.conv_2_dw_batchnorm(conv_2_dw_conv2d) conv_2_dw_relu = F.prelu( conv_2_dw_batchnorm, torch.from_numpy(_weights_dict['conv_2_dw_relu']['weights'])) conv_2_conv2d = self.conv_2_conv2d(conv_2_dw_relu) conv_2_batchnorm = self.conv_2_batchnorm(conv_2_conv2d) conv_2_relu = F.prelu( conv_2_batchnorm, torch.from_numpy(_weights_dict['conv_2_relu']['weights'])) conv_3_dw_conv2d_pad = F.pad(conv_2_relu, (1, 1, 1, 1)) conv_3_dw_conv2d = self.conv_3_dw_conv2d(conv_3_dw_conv2d_pad) conv_3_dw_batchnorm = self.conv_3_dw_batchnorm(conv_3_dw_conv2d) conv_3_dw_relu = F.prelu( conv_3_dw_batchnorm, torch.from_numpy(_weights_dict['conv_3_dw_relu']['weights'])) conv_3_conv2d = self.conv_3_conv2d(conv_3_dw_relu) conv_3_batchnorm = self.conv_3_batchnorm(conv_3_conv2d) conv_3_relu = F.prelu( conv_3_batchnorm, torch.from_numpy(_weights_dict['conv_3_relu']['weights'])) conv_4_dw_conv2d_pad = F.pad(conv_3_relu, (1, 1, 1, 1)) conv_4_dw_conv2d = self.conv_4_dw_conv2d(conv_4_dw_conv2d_pad) conv_4_dw_batchnorm = self.conv_4_dw_batchnorm(conv_4_dw_conv2d) conv_4_dw_relu = F.prelu( conv_4_dw_batchnorm, torch.from_numpy(_weights_dict['conv_4_dw_relu']['weights'])) conv_4_conv2d = self.conv_4_conv2d(conv_4_dw_relu) conv_4_batchnorm = self.conv_4_batchnorm(conv_4_conv2d) conv_4_relu = F.prelu( conv_4_batchnorm, torch.from_numpy(_weights_dict['conv_4_relu']['weights'])) conv_5_dw_conv2d_pad = F.pad(conv_4_relu, (1, 1, 1, 1)) conv_5_dw_conv2d = self.conv_5_dw_conv2d(conv_5_dw_conv2d_pad) conv_5_dw_batchnorm = self.conv_5_dw_batchnorm(conv_5_dw_conv2d) conv_5_dw_relu = F.prelu( conv_5_dw_batchnorm, torch.from_numpy(_weights_dict['conv_5_dw_relu']['weights'])) conv_5_conv2d = self.conv_5_conv2d(conv_5_dw_relu) conv_5_batchnorm = self.conv_5_batchnorm(conv_5_conv2d) conv_5_relu = F.prelu( conv_5_batchnorm, torch.from_numpy(_weights_dict['conv_5_relu']['weights'])) conv_6_dw_conv2d_pad = F.pad(conv_5_relu, (1, 1, 1, 1)) conv_6_dw_conv2d = self.conv_6_dw_conv2d(conv_6_dw_conv2d_pad) conv_6_dw_batchnorm = self.conv_6_dw_batchnorm(conv_6_dw_conv2d) conv_6_dw_relu = F.prelu( conv_6_dw_batchnorm, torch.from_numpy(_weights_dict['conv_6_dw_relu']['weights'])) conv_6_conv2d = self.conv_6_conv2d(conv_6_dw_relu) conv_6_batchnorm = self.conv_6_batchnorm(conv_6_conv2d) conv_6_relu = F.prelu( conv_6_batchnorm, torch.from_numpy(_weights_dict['conv_6_relu']['weights'])) conv_7_dw_conv2d_pad = F.pad(conv_6_relu, (1, 1, 1, 1)) conv_7_dw_conv2d = self.conv_7_dw_conv2d(conv_7_dw_conv2d_pad) conv_7_dw_batchnorm = self.conv_7_dw_batchnorm(conv_7_dw_conv2d) conv_7_dw_relu = F.prelu( conv_7_dw_batchnorm, torch.from_numpy(_weights_dict['conv_7_dw_relu']['weights'])) conv_7_conv2d = self.conv_7_conv2d(conv_7_dw_relu) conv_7_batchnorm = self.conv_7_batchnorm(conv_7_conv2d) conv_7_relu = F.prelu( conv_7_batchnorm, torch.from_numpy(_weights_dict['conv_7_relu']['weights'])) conv_8_dw_conv2d_pad = F.pad(conv_7_relu, (1, 1, 1, 1)) conv_8_dw_conv2d = self.conv_8_dw_conv2d(conv_8_dw_conv2d_pad) conv_8_dw_batchnorm = self.conv_8_dw_batchnorm(conv_8_dw_conv2d) conv_8_dw_relu = F.prelu( conv_8_dw_batchnorm, torch.from_numpy(_weights_dict['conv_8_dw_relu']['weights'])) conv_8_conv2d = self.conv_8_conv2d(conv_8_dw_relu) conv_8_batchnorm = self.conv_8_batchnorm(conv_8_conv2d) conv_8_relu = F.prelu( conv_8_batchnorm, torch.from_numpy(_weights_dict['conv_8_relu']['weights'])) conv_9_dw_conv2d_pad = F.pad(conv_8_relu, (1, 1, 1, 1)) conv_9_dw_conv2d = self.conv_9_dw_conv2d(conv_9_dw_conv2d_pad) conv_9_dw_batchnorm = self.conv_9_dw_batchnorm(conv_9_dw_conv2d) conv_9_dw_relu = F.prelu( conv_9_dw_batchnorm, torch.from_numpy(_weights_dict['conv_9_dw_relu']['weights'])) conv_9_conv2d = self.conv_9_conv2d(conv_9_dw_relu) conv_9_batchnorm = self.conv_9_batchnorm(conv_9_conv2d) conv_9_relu = F.prelu( conv_9_batchnorm, torch.from_numpy(_weights_dict['conv_9_relu']['weights'])) conv_10_dw_conv2d_pad = F.pad(conv_9_relu, (1, 1, 1, 1)) conv_10_dw_conv2d = self.conv_10_dw_conv2d(conv_10_dw_conv2d_pad) conv_10_dw_batchnorm = self.conv_10_dw_batchnorm(conv_10_dw_conv2d) conv_10_dw_relu = F.prelu( conv_10_dw_batchnorm, torch.from_numpy(_weights_dict['conv_10_dw_relu']['weights'])) conv_10_conv2d = self.conv_10_conv2d(conv_10_dw_relu) conv_10_batchnorm = self.conv_10_batchnorm(conv_10_conv2d) conv_10_relu = F.prelu( conv_10_batchnorm, torch.from_numpy(_weights_dict['conv_10_relu']['weights'])) conv_11_dw_conv2d_pad = F.pad(conv_10_relu, (1, 1, 1, 1)) conv_11_dw_conv2d = self.conv_11_dw_conv2d(conv_11_dw_conv2d_pad) conv_11_dw_batchnorm = self.conv_11_dw_batchnorm(conv_11_dw_conv2d) conv_11_dw_relu = F.prelu( conv_11_dw_batchnorm, torch.from_numpy(_weights_dict['conv_11_dw_relu']['weights'])) conv_11_conv2d = self.conv_11_conv2d(conv_11_dw_relu) conv_11_batchnorm = self.conv_11_batchnorm(conv_11_conv2d) conv_11_relu = F.prelu( conv_11_batchnorm, torch.from_numpy(_weights_dict['conv_11_relu']['weights'])) conv_12_dw_conv2d_pad = F.pad(conv_11_relu, (1, 1, 1, 1)) conv_12_dw_conv2d = self.conv_12_dw_conv2d(conv_12_dw_conv2d_pad) conv_12_dw_batchnorm = self.conv_12_dw_batchnorm(conv_12_dw_conv2d) conv_12_dw_relu = F.prelu( conv_12_dw_batchnorm, torch.from_numpy(_weights_dict['conv_12_dw_relu']['weights'])) conv_12_conv2d = self.conv_12_conv2d(conv_12_dw_relu) conv_12_batchnorm = self.conv_12_batchnorm(conv_12_conv2d) conv_12_relu = F.prelu( conv_12_batchnorm, torch.from_numpy(_weights_dict['conv_12_relu']['weights'])) conv_13_dw_conv2d_pad = F.pad(conv_12_relu, (1, 1, 1, 1)) conv_13_dw_conv2d = self.conv_13_dw_conv2d(conv_13_dw_conv2d_pad) conv_13_dw_batchnorm = self.conv_13_dw_batchnorm(conv_13_dw_conv2d) conv_13_dw_relu = F.prelu( conv_13_dw_batchnorm, torch.from_numpy(_weights_dict['conv_13_dw_relu']['weights'])) conv_13_conv2d = self.conv_13_conv2d(conv_13_dw_relu) conv_13_batchnorm = self.conv_13_batchnorm(conv_13_conv2d) conv_13_relu = F.prelu( conv_13_batchnorm, torch.from_numpy(_weights_dict['conv_13_relu']['weights'])) conv_14_dw_conv2d_pad = F.pad(conv_13_relu, (1, 1, 1, 1)) conv_14_dw_conv2d = self.conv_14_dw_conv2d(conv_14_dw_conv2d_pad) conv_14_dw_batchnorm = self.conv_14_dw_batchnorm(conv_14_dw_conv2d) conv_14_dw_relu = F.prelu( conv_14_dw_batchnorm, torch.from_numpy(_weights_dict['conv_14_dw_relu']['weights'])) conv_14_conv2d = self.conv_14_conv2d(conv_14_dw_relu) conv_14_batchnorm = self.conv_14_batchnorm(conv_14_conv2d) conv_14_relu = F.prelu( conv_14_batchnorm, torch.from_numpy(_weights_dict['conv_14_relu']['weights'])) conv_15_conv2d_pad = F.pad(conv_14_relu, (1, 1, 1, 1)) conv_15_conv2d = self.conv_15_conv2d(conv_15_conv2d_pad) conv_15_batchnorm = self.conv_15_batchnorm(conv_15_conv2d) conv_15_relu = F.prelu( conv_15_batchnorm, torch.from_numpy(_weights_dict['conv_15_relu']['weights'])) flatten0 = conv_15_relu.view(conv_15_relu.size(0), -1) fc1 = self.fc1(flatten0) return fc1
def forward(self, input): weight = torch.reshape(self.weight, [1, self.n_channels, 1, self.n_features]) return F.prelu(input, weight)
def forward(self, input): return (F.prelu(input, self.weight) - self.post_mean) / self.post_stdv
def prelu_basic(inputs, weight): return F.prelu(inputs+inputs, weight)
def prelu(input, *args, **kwargs): return _wrap_tensor(input, F.prelu(input.F, *args, **kwargs))
def forward(self, x): y = block.conv(x) y = F.prelu(self.bn1(self.conv1(y)), self.weight) y = F.selu(self.bn2(self.conv2(y))) return x + y
def test_prelu(self): inp = torch.randn(1, 3, 32, 32, device='cuda', dtype=self.dtype) weight = torch.randn(1, device='cuda', dtype=self.dtype) output = F.prelu(inp, weight)
def forward(self, x): stem_conv1_pad = F.pad(x, (1, 1, 1, 1)) stem_conv1 = self.stem_conv1(stem_conv1_pad) stem_bn2 = self.stem_bn2(stem_conv1) stem_relu1 = F.prelu( stem_bn2, torch.from_numpy(self.weights_dict['stem_relu1']['weights'])) stage1_unit1_bn1 = self.stage1_unit1_bn1(stem_relu1) stage1_unit1_convr = self.stage1_unit1_convr(stem_relu1) stage1_unit1_conv1_pad = F.pad(stage1_unit1_bn1, (1, 1, 1, 1)) stage1_unit1_conv1 = self.stage1_unit1_conv1(stage1_unit1_conv1_pad) stage1_unit1_bnr = self.stage1_unit1_bnr(stage1_unit1_convr) stage1_unit1_bn2 = self.stage1_unit1_bn2(stage1_unit1_conv1) stage1_unit1_prelu2 = F.prelu( stage1_unit1_bn2, torch.from_numpy( self.weights_dict['stage1_unit1_prelu2']['weights'])) stage1_unit1_conv2_pad = F.pad(stage1_unit1_prelu2, (1, 1, 1, 1)) stage1_unit1_conv2 = self.stage1_unit1_conv2(stage1_unit1_conv2_pad) stage1_unit1_bn4 = self.stage1_unit1_bn4(stage1_unit1_conv2) plus0 = stage1_unit1_bn4 + stage1_unit1_bnr stage2_unit1_bn1 = self.stage2_unit1_bn1(plus0) stage2_unit1_convr = self.stage2_unit1_convr(plus0) stage2_unit1_conv1_pad = F.pad(stage2_unit1_bn1, (1, 1, 1, 1)) stage2_unit1_conv1 = self.stage2_unit1_conv1(stage2_unit1_conv1_pad) stage2_unit1_bnr = self.stage2_unit1_bnr(stage2_unit1_convr) stage2_unit1_bn2 = self.stage2_unit1_bn2(stage2_unit1_conv1) stage2_unit1_prelu2 = F.prelu( stage2_unit1_bn2, torch.from_numpy( self.weights_dict['stage2_unit1_prelu2']['weights'])) stage2_unit1_conv2_pad = F.pad(stage2_unit1_prelu2, (1, 1, 1, 1)) stage2_unit1_conv2 = self.stage2_unit1_conv2(stage2_unit1_conv2_pad) stage2_unit1_bn4 = self.stage2_unit1_bn4(stage2_unit1_conv2) plus1 = stage2_unit1_bn4 + stage2_unit1_bnr stage2_unit2_bn1 = self.stage2_unit2_bn1(plus1) stage2_unit2_conv1_pad = F.pad(stage2_unit2_bn1, (1, 1, 1, 1)) stage2_unit2_conv1 = self.stage2_unit2_conv1(stage2_unit2_conv1_pad) stage2_unit2_bn2 = self.stage2_unit2_bn2(stage2_unit2_conv1) stage2_unit2_prelu2 = F.prelu( stage2_unit2_bn2, torch.from_numpy( self.weights_dict['stage2_unit2_prelu2']['weights'])) stage2_unit2_conv2_pad = F.pad(stage2_unit2_prelu2, (1, 1, 1, 1)) stage2_unit2_conv2 = self.stage2_unit2_conv2(stage2_unit2_conv2_pad) stage2_unit2_bn4 = self.stage2_unit2_bn4(stage2_unit2_conv2) plus2 = stage2_unit2_bn4 + plus1 stage3_unit1_bn1 = self.stage3_unit1_bn1(plus2) stage3_unit1_convr = self.stage3_unit1_convr(plus2) stage3_unit1_conv1_pad = F.pad(stage3_unit1_bn1, (1, 1, 1, 1)) stage3_unit1_conv1 = self.stage3_unit1_conv1(stage3_unit1_conv1_pad) stage3_unit1_bnr = self.stage3_unit1_bnr(stage3_unit1_convr) stage3_unit1_bn2 = self.stage3_unit1_bn2(stage3_unit1_conv1) stage3_unit1_prelu2 = F.prelu( stage3_unit1_bn2, torch.from_numpy( self.weights_dict['stage3_unit1_prelu2']['weights'])) stage3_unit1_conv2_pad = F.pad(stage3_unit1_prelu2, (1, 1, 1, 1)) stage3_unit1_conv2 = self.stage3_unit1_conv2(stage3_unit1_conv2_pad) stage3_unit1_bn4 = self.stage3_unit1_bn4(stage3_unit1_conv2) plus3 = stage3_unit1_bn4 + stage3_unit1_bnr stage3_unit2_bn1 = self.stage3_unit2_bn1(plus3) stage3_unit2_conv1_pad = F.pad(stage3_unit2_bn1, (1, 1, 1, 1)) stage3_unit2_conv1 = self.stage3_unit2_conv1(stage3_unit2_conv1_pad) stage3_unit2_bn2 = self.stage3_unit2_bn2(stage3_unit2_conv1) stage3_unit2_prelu2 = F.prelu( stage3_unit2_bn2, torch.from_numpy( self.weights_dict['stage3_unit2_prelu2']['weights'])) stage3_unit2_conv2_pad = F.pad(stage3_unit2_prelu2, (1, 1, 1, 1)) stage3_unit2_conv2 = self.stage3_unit2_conv2(stage3_unit2_conv2_pad) stage3_unit2_bn4 = self.stage3_unit2_bn4(stage3_unit2_conv2) plus4 = stage3_unit2_bn4 + plus3 stage3_unit3_bn1 = self.stage3_unit3_bn1(plus4) stage3_unit3_conv1_pad = F.pad(stage3_unit3_bn1, (1, 1, 1, 1)) stage3_unit3_conv1 = self.stage3_unit3_conv1(stage3_unit3_conv1_pad) stage3_unit3_bn2 = self.stage3_unit3_bn2(stage3_unit3_conv1) stage3_unit3_prelu2 = F.prelu( stage3_unit3_bn2, torch.from_numpy( self.weights_dict['stage3_unit3_prelu2']['weights'])) stage3_unit3_conv2_pad = F.pad(stage3_unit3_prelu2, (1, 1, 1, 1)) stage3_unit3_conv2 = self.stage3_unit3_conv2(stage3_unit3_conv2_pad) stage3_unit3_bn4 = self.stage3_unit3_bn4(stage3_unit3_conv2) plus5 = stage3_unit3_bn4 + plus4 stage3_unit4_bn1 = self.stage3_unit4_bn1(plus5) stage3_unit4_conv1_pad = F.pad(stage3_unit4_bn1, (1, 1, 1, 1)) stage3_unit4_conv1 = self.stage3_unit4_conv1(stage3_unit4_conv1_pad) stage3_unit4_bn2 = self.stage3_unit4_bn2(stage3_unit4_conv1) stage3_unit4_prelu2 = F.prelu( stage3_unit4_bn2, torch.from_numpy( self.weights_dict['stage3_unit4_prelu2']['weights'])) stage3_unit4_conv2_pad = F.pad(stage3_unit4_prelu2, (1, 1, 1, 1)) stage3_unit4_conv2 = self.stage3_unit4_conv2(stage3_unit4_conv2_pad) stage3_unit4_bn4 = self.stage3_unit4_bn4(stage3_unit4_conv2) plus6 = stage3_unit4_bn4 + plus5 stage3_unit5_bn1 = self.stage3_unit5_bn1(plus6) stage3_unit5_conv1_pad = F.pad(stage3_unit5_bn1, (1, 1, 1, 1)) stage3_unit5_conv1 = self.stage3_unit5_conv1(stage3_unit5_conv1_pad) stage3_unit5_bn2 = self.stage3_unit5_bn2(stage3_unit5_conv1) stage3_unit5_prelu2 = F.prelu( stage3_unit5_bn2, torch.from_numpy( self.weights_dict['stage3_unit5_prelu2']['weights'])) stage3_unit5_conv2_pad = F.pad(stage3_unit5_prelu2, (1, 1, 1, 1)) stage3_unit5_conv2 = self.stage3_unit5_conv2(stage3_unit5_conv2_pad) stage3_unit5_bn4 = self.stage3_unit5_bn4(stage3_unit5_conv2) plus7 = stage3_unit5_bn4 + plus6 stage4_unit1_bn1 = self.stage4_unit1_bn1(plus7) stage4_unit1_convr = self.stage4_unit1_convr(plus7) stage4_unit1_conv1_pad = F.pad(stage4_unit1_bn1, (1, 1, 1, 1)) stage4_unit1_conv1 = self.stage4_unit1_conv1(stage4_unit1_conv1_pad) stage4_unit1_bnr = self.stage4_unit1_bnr(stage4_unit1_convr) stage4_unit1_bn2 = self.stage4_unit1_bn2(stage4_unit1_conv1) stage4_unit1_prelu2 = F.prelu( stage4_unit1_bn2, torch.from_numpy( self.weights_dict['stage4_unit1_prelu2']['weights'])) stage4_unit1_conv2_pad = F.pad(stage4_unit1_prelu2, (1, 1, 1, 1)) stage4_unit1_conv2 = self.stage4_unit1_conv2(stage4_unit1_conv2_pad) stage4_unit1_bn4 = self.stage4_unit1_bn4(stage4_unit1_conv2) plus8 = stage4_unit1_bn4 + stage4_unit1_bnr stage4_unit2_bn1 = self.stage4_unit2_bn1(plus8) stage4_unit2_conv1_pad = F.pad(stage4_unit2_bn1, (1, 1, 1, 1)) stage4_unit2_conv1 = self.stage4_unit2_conv1(stage4_unit2_conv1_pad) stage4_unit2_bn2 = self.stage4_unit2_bn2(stage4_unit2_conv1) stage4_unit2_prelu2 = F.prelu( stage4_unit2_bn2, torch.from_numpy( self.weights_dict['stage4_unit2_prelu2']['weights'])) stage4_unit2_conv2_pad = F.pad(stage4_unit2_prelu2, (1, 1, 1, 1)) stage4_unit2_conv2 = self.stage4_unit2_conv2(stage4_unit2_conv2_pad) stage4_unit2_bn4 = self.stage4_unit2_bn4(stage4_unit2_conv2) plus9 = stage4_unit2_bn4 + plus8 out_bn2 = self.out_bn2(plus9) out_relu2 = F.prelu( out_bn2, torch.from_numpy(self.weights_dict['out_relu2']['weights'])) out_conv1_pad = F.pad(out_relu2, (1, 1, 1, 1)) out_conv1 = self.out_conv1(out_conv1_pad) out_bn3 = self.out_bn3(out_conv1) out_relu3 = F.relu(out_bn3) out_fc1 = self.out_fc1(out_relu3.view(out_relu3.size(0), -1)) out_embedding = self.out_embedding(out_fc1) return out_embedding