def forward(self, x): x = F.leaky_relu_(self.conv_channels_up(x)) x = self.convList0(x) x = hollowSampleFunction.hollowUpSampleTensor(x) x = self.convList1(x) x = F.leaky_relu_(self.conv_channels_down(x)) return x
def forward(self, x): out = F.leaky_relu_(self.bn1(self.conv1(x))) out = F.leaky_relu_(self.bn2(self.conv2(out))) out = self.bn3(self.conv3(out)) out += self.shortcut(x) out = F.leaky_relu_(out) return out
def forward(self, x): x = F.leaky_relu_(self.conv1(x)) x = self.conv1_bn(self.pool1(x)) x = self.conv2_bn(F.leaky_relu_(self.conv2(x))) x = self.conv3(x) x = x.reshape(x.shape[0], -1) return x
def _forward(self, x1_pyramid, x2_pyramid, neg=False): flows = [] for i, (x1, x2) in enumerate(zip(x1_pyramid, x2_pyramid)): if i == 0: corr = self.corr(x1, x2) feat, flow = self.flow_estimators[i](corr) if neg: flow = -F.relu(-flow) else: flow = F.relu(flow) else: # predict the normalized disparity to keep consistent with MonoDepth # for reusing the hyper-parameters up_flow = F.interpolate(flow, scale_factor=2, mode='bilinear', align_corners=True) zeros = torch.zeros_like(up_flow) x2_warp = flow_warp( x2, torch.cat([up_flow, zeros], dim=1), ) corr = self.corr(x1, x2_warp) F.leaky_relu_(corr) feat, flow = self.flow_estimators[i](torch.cat( [corr, x1, up_flow], dim=1)) flow = flow + up_flow if neg: flow = -F.relu(-flow) else: flow = F.relu(flow) if self.context_networks[i]: flow_fine = self.context_networks[i](torch.cat( [flow, feat], dim=1)) flow = flow + flow_fine if neg: flow = -F.relu(-flow) else: flow = F.relu(flow) if neg: flows.append(-flow) else: flows.append(flow) if len(flows) == self.n_out: break flows = [ F.interpolate(flow * 4, scale_factor=4, mode='bilinear', align_corners=True) for flow in flows ] return flows[::-1]
def forward(self, inputs: Tensor, targets: Tensor = None, batch_seen: int = None) -> Tensor: """ dynamic convolutional recurrent neural network :param inputs: [B, n_hist, N, input_dim] :param supports: list of tensors, each tensor is with shape [N, N] :param targets: exists for training, tensor, [B, n_pred, N, output_dim] :param batch_seen: int, the number of batches the model has seen :return: [B, n_pred, N, output_dim],[] """ if self.method == 'big': graph = list() nodevec1 = self.nodevec1 nodevec2 = self.nodevec2 n = nodevec1.size(0) self.graph0 = F.leaky_relu_(torch.mm(nodevec1, nodevec2)) graph.append(self.graph0) nodevec1 = nodevec1.mm(self.w1) + self.b1.repeat(n, 1) nodevec2 = (nodevec2.T.mm(self.w1) + self.b1.repeat(n, 1)).T self.graph1 = F.leaky_relu_(torch.mm(nodevec1, nodevec2)) graph.append(self.graph1) nodevec1 = nodevec1.mm(self.w2) + self.b2.repeat(n, 1) nodevec2 = (nodevec2.T.mm(self.w2) + self.b2.repeat(n, 1)).T self.graph2 = F.leaky_relu_(torch.mm(nodevec1, nodevec2)) graph.append(self.graph2) else: graph = self._mahalanobis_distance_cal() states = self.encoder(inputs, graph) outputs = self.decoder(graph, states, targets, self._compute_sampling_threshold(batch_seen)) return outputs, graph
def forward(self, x): x = self.fc1_bn(F.leaky_relu_(self.fc1(x))) x = self.fc2_bn(F.leaky_relu_(self.fc2(x))) x = x.reshape(x.shape[0], 32, 16, 16) x = self.conv1_bn(F.leaky_relu_(self.conv1(x))) x = nn.Tanh()(self.conv2(x)) return x
def forward(self, input): x = self.pool_and_inject(input) left_side = F.leaky_relu_( self.left_conv2(F.leaky_relu_(self.left_conv1(x)))) right_side = F.leaky_relu_( self.right_conv2(F.leaky_relu_(self.right_conv1(x)))) x = torch.cat((left_side, right_side), 1) x = F.leaky_relu_(self.conv3(x)) return x + input
def forward(self, style_embeddings, class_embeddings): style_embeddings = F.leaky_relu_(self.style_input(style_embeddings), negative_slope=0.2) class_embeddings = F.leaky_relu_(self.class_input(class_embeddings), negative_slope=0.2) x = torch.cat((style_embeddings, class_embeddings), dim=1) x = x.view(x.size(0), 128, 2, 2) x = self.deconv_model(x) return x
def forward(self, x): y = F.leaky_relu_(self.hc(x)) # batchSize * 1 * 128 * 128 -> batchSize * 512 * 128 * 128 y = F.leaky_relu_(self.conv(y)) # batchSize * 512 * 128 * 128 -> batchSize * 256 * 128 * 128 y = y.view(y.shape[0], 1, 256, y.shape[2], y.shape[3]) # batchSize * 256 * 128 * 128 -> batchSize * 1 * 256 * 128 * 128 y = y.permute(0, 1, 3, 4, 2) # batchSize * 1 * 256 * 128 * 128 -> batchSize * 1 * 128 * 128 * 256 return y
def forward(self, inputs): x = self.layer_1(inputs) x = F.leaky_relu_(x) x = self.conv_1(x) x = self.layer_2(x) x = F.leaky_relu_(x) x = self.conv_2(x) x = x + inputs return x
def forward(self, input): if (self.downSample == True): return self.k * F.leaky_relu_( self.convDown(input)) + (1 - self.k) * F.leaky_relu_( self.pixConv(pixelShuffleFunction.pixel_unshuffle( input, 2))) else: return self.k * F.leaky_relu_( self.convUp(input)) + (1 - self.k) * F.leaky_relu_( F.pixel_shuffle(self.pixConv(input), 2))
def forward(self, x): z = F.linear(x, self.W[0]) F.leaky_relu_(z, negative_slope=self.negative_slope) for W, U in zip(self.W[1:-1], self.U[:-1]): z = F.linear(x, W) + F.linear(z, F.softplus(U)) * self.negative_slope z = F.leaky_relu_(z, negative_slope=self.negative_slope) z = F.linear(x, self.W[-1]) + F.linear(z, F.softplus(self.U[-1])) return F.relu(z) + self.eps * (x**2).sum(1)[:, None]
def encode(self, X): """ Encode the image X. """ res = X for ii in range(self.n_conv): res = F.leaky_relu_(self.conv_bn[ii](self.conv[ii](res))) res = res.view(-1, self.d_fc) for M in self.encoders: res = F.leaky_relu_(M(res)) return self.mu_layer(res), self.var_layer(res)
def forward(self, x, return_latents=False, return_rgb=True, randomize_noise=True): """Forward function for GFPGANv1Clean. Args: x (Tensor): Input images. return_latents (bool): Whether to return style latents. Default: False. return_rgb (bool): Whether return intermediate rgb images. Default: True. randomize_noise (bool): Randomize noise, used when 'noise' is False. Default: True. """ conditions = [] unet_skips = [] out_rgbs = [] # encoder feat = F.leaky_relu_(self.conv_body_first(x), negative_slope=0.2) for i in range(self.log_size - 2): feat = self.conv_body_down[i](feat) unet_skips.insert(0, feat) feat = F.leaky_relu_(self.final_conv(feat), negative_slope=0.2) # style code style_code = self.final_linear(feat.view(feat.size(0), -1)) if self.different_w: style_code = style_code.view(style_code.size(0), -1, self.num_style_feat) # decode for i in range(self.log_size - 2): # add unet skip feat = feat + unet_skips[i] # ResUpLayer feat = self.conv_body_up[i](feat) # generate scale and shift for SFT layers scale = self.condition_scale[i](feat) conditions.append(scale.clone()) shift = self.condition_shift[i](feat) conditions.append(shift.clone()) # generate rgb images if return_rgb: out_rgbs.append(self.toRGB[i](feat)) # decoder image, _ = self.stylegan_decoder([style_code], conditions, return_latents=return_latents, input_is_latent=self.input_is_latent, randomize_noise=randomize_noise) return image, out_rgbs
def message(self, x_j: Tensor, x_i: Tensor, edge_attr: Tensor, index: Tensor, ptr: OptTensor, size_i: Optional[int]) -> Tensor: x_j = F.leaky_relu_(self.lin1(torch.cat([x_j, edge_attr], dim=-1))) alpha_j = (x_j * self.att_l).sum(dim=-1) alpha_i = (x_i * self.att_r).sum(dim=-1) alpha = alpha_j + alpha_i alpha = F.leaky_relu_(alpha) alpha = softmax(alpha, index, ptr, size_i) alpha = F.dropout(alpha, p=self.dropout, training=self.training) return self.lin2(x_j) * alpha.unsqueeze(-1)
def forward(self, x): x = self.conv1(x) x = F.leaky_relu_(x) x = self.conv2(x) x = self.bn2(x) x = F.leaky_relu_(x) x = self.conv3(x) x = self.bn3(x) x = F.leaky_relu_(x) x = self.conv4(x) x = self.bn4(x) return F.sigmoid(x)
def forward(self, x, y, z): x = F.leaky_relu_(self.conv1(x)) x = self.conv1_bn(self.pool1(x)) x = self.conv2_bn(F.leaky_relu_(self.conv2(x))) x = self.conv3(x) x = x.reshape(x.shape[0], -1) y = y.reshape(y.shape[0], -1) z = z.reshape(z.shape[0], -1) x = torch.cat([x,y,z],dim=1) output = F.relu_(self.input_linear(x)) output = F.relu(self.output_1(output)) output = self.output_2(output) return output
def forward(self, user_nodes, item_nodes): x = F.normalize(self.id_embedding).cuda() x = F.leaky_relu_(self.conv_embed_1(x, self.edge_index)) x1 = F.leaky_relu_(self.conv_embed_2(x, self.edge_index)) x2 = F.leaky_relu(self.conv_embed_3(x1, self.edge_index)) x = torch.cat((x, x1, x2), dim=1) self.result_embed = x user_tensor = x[user_nodes] self.t_feat = torch.tensor(scatter_('mean', self.word_embedding(self.words_tensor[1]), self.words_tensor[0])).cuda() item_feat = torch.cat((self.v_feat[item_nodes-self.num_user], self.a_feat[item_nodes-self.num_user], self.t_feat[item_nodes-self.num_user]), dim=1) item_tensor = x[item_nodes] + F.leaky_relu_(self.linear_layer1(item_feat)) scores = torch.sum(user_tensor*item_tensor, dim=1) return scores
def forward(self, x): x = self.conv1(x) x = F.leaky_relu_(x) x = self.conv2(x) x = self.bn2(x) x = F.leaky_relu_(x) x = self.conv3(x) x = self.bn3(x) x = F.leaky_relu_(x) x = self.conv4(x) x = self.bn4(x) # x_sigmod = F.sigmoid(x) # return x_sigmod, x return x
def accuracy(self, dataset, topk=10, neg_num=1000): all_set = set(list(np.arange(neg_num))) sum_pre = 0.0 sum_recall = 0.0 sum_ndcg = 0.0 sum_item = 0 bar = tqdm(total=len(dataset)) for data in dataset: bar.update(1) if len(data) < 1002: continue sum_item += 1 user = data[0] neg_items = data[1:1001] pos_items = data[1001:] batch_user_tensor = torch.tensor(user).cuda() batch_pos_tensor = torch.tensor(pos_items).cuda() batch_neg_tensor = torch.tensor(neg_items).cuda() pos_item_feat = torch.cat((self.v_feat[batch_pos_tensor-self.num_user], self.a_feat[batch_pos_tensor-self.num_user], self.t_feat[batch_pos_tensor-self.num_user]), dim=1) neg_item_feat = torch.cat((self.v_feat[batch_neg_tensor-self.num_user], self.a_feat[batch_neg_tensor-self.num_user], self.t_feat[batch_neg_tensor-self.num_user]), dim=1) user_embed = self.result_embed[batch_user_tensor] pos_v_embed = self.result_embed[batch_pos_tensor] + F.leaky_relu_(self.linear_layer1(pos_item_feat)) neg_v_embed = self.result_embed[batch_neg_tensor] + F.leaky_relu_(self.linear_layer1(neg_item_feat)) num_pos = len(pos_items) pos_score = torch.sum(pos_v_embed*user_embed, dim=1) neg_score = torch.sum(neg_v_embed*user_embed, dim=1) _, index_of_rank_list = torch.topk(torch.cat((neg_score, pos_score)), topk) index_set = set([iofr.cpu().item() for iofr in index_of_rank_list]) num_hit = len(index_set.difference(all_set)) sum_pre += float(num_hit/topk) sum_recall += float(num_hit/num_pos) ndcg_score = 0.0 for i in range(num_pos): label_pos = neg_num + i if label_pos in index_of_rank_list: index = list(index_of_rank_list.cpu().numpy()).index(label_pos) ndcg_score = ndcg_score + math.log(2) / math.log(index + 2) sum_ndcg += ndcg_score/num_pos bar.close() return sum_pre/sum_item, sum_recall/sum_item, sum_ndcg/sum_item
def forward(self, style_emb, class_label): # Get class dim class_emb = torch.index_select(self.word_dict, dim=0, index=class_label) # 1. FC style_emb = F.leaky_relu_(self._fc_style(style_emb), negative_slope=0.2) class_emb = F.leaky_relu_(self._fc_class(class_emb), negative_slope=0.2) # 2. Convolution x = torch.cat((style_emb, class_emb), dim=1) x = x.view(x.size(0), 128, 2, 2) x = self._deconv_blocks(x) # Return return x
def forward(self, input): '''input: (batch_size, 784) ''' batch_size = input.shape[0] x = input.view(batch_size, 1, 28, 28) x = F.leaky_relu_(self.conv1(x), 0.2) x = F.leaky_relu_(self.bn2(self.conv2(x)), 0.2) x = F.leaky_relu_(self.bn3(self.conv3(x)), 0.2) x = x.view(-1, x.shape[1] * x.shape[2] * x.shape[3]) x = self.fc_final(x) x = torch.sigmoid(x) return x
def forward(self, edge_index): if self.is_word: features = torch.tensor( scatter_('mean', self.features(self.word_tensor[1]), self.word_tensor[0])).cuda() else: features = F.leaky_relu(self.MLP(self.features)) if self.has_norm: preference = F.normalize(self.preference) features = F.normalize(features) for i in range(self.num_routing): x = torch.cat((preference, features), dim=0) x_hat_1 = self.conv_embed_1(x, edge_index) preference = preference + x_hat_1[:self.num_user] if self.has_norm: preference = F.normalize(preference) x = torch.cat((preference, features), dim=0) edge_index = torch.cat((edge_index, edge_index[[1, 0]]), dim=1) x_hat_1 = self.conv_embed_1(x, edge_index) if self.has_act: x_hat_1 = F.leaky_relu_(x_hat_1) return x + x_hat_1, self.conv_embed_1.alpha.view(-1, 1)
def forward(self, x): out = F.leaky_relu_(self.conv1(x), negative_slope=0.2) # upsample/downsample out = F.interpolate(out, scale_factor=self.scale_factor, mode='bilinear', align_corners=False) out = F.leaky_relu_(self.conv2(out), negative_slope=0.2) # skip x = F.interpolate(x, scale_factor=self.scale_factor, mode='bilinear', align_corners=False) skip = self.skip(x) out = out + skip return out
def forward(self, x, edge_index, edge_attr, batch): """""" # Atom Embedding: x = F.leaky_relu_(self.lin1(x)) h = F.elu_(self.atom_convs[0](x, edge_index, edge_attr)) h = F.dropout(h, p=self.dropout, training=self.training) x = self.atom_grus[0](h, x).relu_() for conv, gru in zip(self.atom_convs[1:], self.atom_grus[1:]): h = F.elu_(conv(x, edge_index)) h = F.dropout(h, p=self.dropout, training=self.training) x = gru(h, x).relu_() # Molecule Embedding: row = torch.arange(batch.size(0), device=batch.device) edge_index = torch.stack([row, batch], dim=0) out = global_add_pool(x, batch).relu_() for t in range(self.num_timesteps): h = F.elu_(self.mol_conv((x, out), edge_index)) h = F.dropout(h, p=self.dropout, training=self.training) out = self.mol_gru(h, out).relu_() # Predictor: out = F.dropout(out, p=self.dropout, training=self.training) return self.lin2(out)
def forward(self, batched_data): """""" x, edge_index, edge_attr, batch = batched_data.x, batched_data.edge_index, batched_data.edge_attr, batched_data.batch # Atom Embedding: x = F.leaky_relu_(self.atom_encoder(x)) edge_attr = self.bond_encoder(edge_attr) h = F.elu_(self.atom_convs[0](x, edge_index, edge_attr)) h = F.dropout(h, p=self.drop_ratio, training=self.training) x = self.atom_grus[0](h, x).relu_() for conv, gru in zip(self.atom_convs[1:], self.atom_grus[1:]): h = F.elu_(conv(x, edge_index)) h = F.dropout(h, p=self.drop_ratio, training=self.training) x = gru(h, x).relu_() # Molecule Embedding: row = torch.arange(batch.size(0), device=batch.device) edge_index = torch.stack([row, batch], dim=0) out = global_add_pool(x, batch).relu_() for t in range(self.num_timesteps): h = F.elu_(self.mol_conv((x, out), edge_index)) h = F.dropout(h, p=self.drop_ratio, training=self.training) out = self.mol_gru(h, out).relu_() # Predictor: out = F.dropout(out, p=self.drop_ratio, training=self.training) return self.graph_pred_linear(out)
def correlate(input1, input2, args): out_corr = spatial_correlation_sample(input1, input2, **args) # collate dimensions 1 and 2 in order to be treated as a # regular 4D tensor b, ph, pw, h, w = out_corr.size() out_corr = out_corr.view(b, ph * pw, h, w) / input1.size(1) return F.leaky_relu_(out_corr, 0.1)
def forward(self, edge_index, weight_vector): x = self.id_embedding edge_index = torch.cat((edge_index, edge_index[[1, 0]]), dim=1) if self.has_norm: x = F.normalize(x) x_hat_1 = self.conv_embed_1(x, edge_index, weight_vector) if self.has_act: x_hat_1 = F.leaky_relu_(x_hat_1) x_hat_2 = self.conv_embed_2(x_hat_1, edge_index, weight_vector) if self.has_act: x_hat_2 = F.leaky_relu_(x_hat_2) return x + x_hat_1 + x_hat_2
def decode(self, Z): """ Decode the latent representation Z. """ res = Z for M in self.decoders[:]: res = F.leaky_relu_(M(res)) res = res.view(-1, self.n_last_channels, self.d_last_image, self.d_last_image) for ii in range(self.n_conv - 1): res = F.leaky_relu_(self.deconv[ii](self.deconv_bn[ii](res))) res = torch.sigmoid(self.deconv[-1](self.deconv_bn[-1](res))) return res
def forward(self, input, flip_feat=None): # Encoder # No norm on the first layer e1 = self.e1_c(input) e2 = self.e2_norm(self.e2_c(F.leaky_relu_(e1, negative_slope=0.2))) e3 = self.e3_norm(self.e3_c(F.leaky_relu_(e2, negative_slope=0.2))) e4 = self.e4_norm(self.e4_c(F.leaky_relu_(e3, negative_slope=0.2))) e5 = self.e5_norm(self.e5_c(F.leaky_relu_(e4, negative_slope=0.2))) e6 = self.e6_norm(self.e6_c(F.leaky_relu_(e5, negative_slope=0.2))) e7 = self.e7_norm(self.e7_c(F.leaky_relu_(e6, negative_slope=0.2))) # No norm in the inner_most layer e8 = self.e8_c(F.leaky_relu_(e7, negative_slope=0.2)) # Decoder d1 = self.d1_norm(self.d1_dc(F.relu_(e8))) d2 = self.d2_norm(self.d2_dc(F.relu_(self.cat_feat(d1, e7)))) d3 = self.d3_norm(self.d3_dc(F.relu_(self.cat_feat(d2, e6)))) d4 = self.d4_norm(self.d4_dc(F.relu_(self.cat_feat(d3, e5)))) d5 = self.d5_norm(self.d5_dc(F.relu_(self.cat_feat(d4, e4)))) tmp, innerFeat = self.shift( self.innerCos(F.relu_(self.cat_feat(d5, e3))), flip_feat) d6 = self.d6_norm(self.d6_dc(tmp)) d7 = self.d7_norm(self.d7_dc(F.relu_(self.cat_feat(d6, e2)))) # No norm on the last layer d8 = self.d8_dc(F.relu_(self.cat_feat(d7, e1))) d8 = torch.tanh(d8) return d8, innerFeat