def forward(self, feats): assert len(feats) == len(self.fpn_strides), \ "The size of feats is not equal to size of fpn_strides" anchors, anchor_points, num_anchors_list, stride_tensor =\ generate_anchors_for_grid_cell( feats, self.fpn_strides, self.grid_cell_scale, self.grid_cell_offset) anchor_centers_split = paddle.split(anchor_points / stride_tensor, num_anchors_list) cls_score_list, bbox_pred_list = [], [] for feat, scale_reg, anchor_centers, stride in zip( feats, self.scales_regs, anchor_centers_split, self.fpn_strides): b, _, h, w = get_static_shape(feat) inter_feats = [] for inter_conv in self.inter_convs: feat = F.relu(inter_conv(feat)) inter_feats.append(feat) feat = paddle.concat(inter_feats, axis=1) # task decomposition avg_feat = F.adaptive_avg_pool2d(feat, (1, 1)) cls_feat = self.cls_decomp(feat, avg_feat) reg_feat = self.reg_decomp(feat, avg_feat) # cls prediction and alignment cls_logits = self.tood_cls(cls_feat) if self.use_align_head: cls_prob = F.relu(self.cls_prob_conv1(feat)) cls_prob = F.sigmoid(self.cls_prob_conv2(cls_prob)) cls_score = (F.sigmoid(cls_logits) * cls_prob).sqrt() else: cls_score = F.sigmoid(cls_logits) cls_score_list.append(cls_score.flatten(2).transpose([0, 2, 1])) # reg prediction and alignment reg_dist = scale_reg(self.tood_reg(reg_feat).exp()) reg_dist = reg_dist.flatten(2).transpose([0, 2, 1]) reg_bbox = batch_distance2bbox(anchor_centers.unsqueeze(0), reg_dist) if self.use_align_head: reg_offset = F.relu(self.reg_offset_conv1(feat)) reg_offset = self.reg_offset_conv2(reg_offset) reg_bbox = reg_bbox.transpose([0, 2, 1]).reshape([b, 4, h, w]) anchor_centers = anchor_centers.reshape([1, h, w, 2]) bbox_pred = self._reg_grid_sample(reg_bbox, reg_offset, anchor_centers) bbox_pred = bbox_pred.flatten(2).transpose([0, 2, 1]) else: bbox_pred = reg_bbox if not self.training: bbox_pred *= stride bbox_pred_list.append(bbox_pred) cls_score_list = paddle.concat(cls_score_list, axis=1) bbox_pred_list = paddle.concat(bbox_pred_list, axis=1) return cls_score_list, bbox_pred_list, anchors, num_anchors_list, stride_tensor
def forward(self, pos_input_ids, neg_input_ids, pos_token_type_ids=None, neg_token_type_ids=None, pos_position_ids=None, neg_position_ids=None, pos_attention_mask=None, neg_attention_mask=None): _, pos_cls_embedding = self.ptm(pos_input_ids, pos_token_type_ids, pos_position_ids, pos_attention_mask) _, neg_cls_embedding = self.ptm(neg_input_ids, neg_token_type_ids, neg_position_ids, neg_attention_mask) pos_embedding = self.dropout(pos_cls_embedding) neg_embedding = self.dropout(neg_cls_embedding) pos_sim = self.similarity(pos_embedding) neg_sim = self.similarity(neg_embedding) pos_sim = F.sigmoid(pos_sim) neg_sim = F.sigmoid(neg_sim) labels = paddle.full(shape=[pos_cls_embedding.shape[0]], fill_value=1.0, dtype='float32') loss = F.margin_ranking_loss(pos_sim, neg_sim, labels, margin=self.margin) return loss
def forward(self, sender_receiver, is_training): # Construct permutation input sender_emb = self.feature_emb_edge( paddle.cast(sender_receiver[0, :], 'int32')) receiver_emb = self.feature_emb_edge( paddle.cast(sender_receiver[1, :], 'int32')) _input = paddle.multiply(sender_emb, receiver_emb) h_relu = self.dropout(self.relu(self.linear1(_input))) loc = self.linear2(h_relu) if is_training: u = paddle.rand(loc.shape, dtype=loc.dtype) u.stop_gradient = False logu = paddle.log2(u) logmu = paddle.log2(1 - u) sum_log = loc + logu - logmu s = F.sigmoid(sum_log / self.temp) s = s * (self.inter_max - self.inter_min) + self.inter_min else: s = F.sigmoid(loc) * (self.inter_max - self.inter_min) + self.inter_min s = paddle.clip(s, min=0, max=1) l0_penaty = F.sigmoid( loc - self.temp * np.log2(-self.inter_min / self.inter_max)).mean() return s, l0_penaty
def hierarchical_self_supervision(self, em, adj): def row_shuffle(embedding): return embedding[paddle.randperm(paddle.shape(embedding)[0])] def row_column_shuffle(embedding): embedding = paddle.transpose(embedding, perm=[1, 0]) corrupted_embedding = paddle.transpose(embedding[paddle.randperm( paddle.shape(embedding)[0])], perm=[1, 0]) return corrupted_embedding[paddle.randperm( paddle.shape(corrupted_embedding)[0])] def score(x1, x2): return paddle.sum(paddle.multiply(x1, x2), axis=1) user_embeddings = em edge_embeddings = paddle.matmul(adj, user_embeddings) # Local MIN pos = score(user_embeddings, edge_embeddings) neg1 = score(row_shuffle(user_embeddings), edge_embeddings) neg2 = score(row_column_shuffle(edge_embeddings), user_embeddings) local_loss = paddle.sum(-paddle.log(F.sigmoid(pos - neg1)) - paddle.log(F.sigmoid(neg1 - neg2))) # Global MIN graph = paddle.mean(edge_embeddings, axis=0) pos = score(edge_embeddings, graph) neg1 = score(row_column_shuffle(edge_embeddings), graph) global_loss = paddle.sum(-paddle.log(F.sigmoid(pos - neg1))) return global_loss + local_loss
def forward(self, feats, targets=None): assert len(feats) == len(self.anchors) yolo_outputs = [] for i, feat in enumerate(feats): yolo_output = self.yolo_outputs[i](feat) if self.data_format == 'NHWC': yolo_output = paddle.transpose(yolo_output, [0, 3, 1, 2]) yolo_outputs.append(yolo_output) if self.training: return self.loss(yolo_outputs, targets, self.anchors) else: if self.iou_aware: y = [] for i, out in enumerate(yolo_outputs): na = len(self.anchors[i]) ioup, x = out[:, 0:na, :, :], out[:, na:, :, :] b, c, h, w = x.shape no = c // na x = x.reshape((b, na, no, h * w)) ioup = ioup.reshape((b, na, 1, h * w)) obj = x[:, :, 4:5, :] ioup = F.sigmoid(ioup) obj = F.sigmoid(obj) obj_t = (obj**(1 - self.iou_aware_factor)) * ( ioup**self.iou_aware_factor) obj_t = _de_sigmoid(obj_t) loc_t = x[:, :, :4, :] cls_t = x[:, :, 5:, :] y_t = paddle.concat([loc_t, obj_t, cls_t], axis=2) y_t = y_t.reshape((b, c, h, w)) y.append(y_t) return y else: return yolo_outputs
def forward(self, x): out = self.conv1(x) rp = F.adaptive_max_pool2d(out, (self.s, 1)) cp = F.adaptive_max_pool2d(out, (1, self.s)) p = paddle.reshape(self.conv_p(rp), (x.shape[0], self.k, self.s, self.s)) q = paddle.reshape(self.conv_q(cp), (x.shape[0], self.k, self.s, self.s)) p = F.sigmoid(p) q = F.sigmoid(q) p = p / paddle.sum(p, axis=3, keepdim=True) q = q / paddle.sum(q, axis=2, keepdim=True) p = paddle.reshape(p, (x.shape[0], self.k, 1, self.s, self.s)) p = paddle.expand(p, (x.shape[0], self.k, x.shape[1] // self.k, self.s, self.s)) p = paddle.reshape(p, (x.shape[0], x.shape[1], self.s, self.s)) q = paddle.reshape(q, (x.shape[0], self.k, 1, self.s, self.s)) q = paddle.expand(q, (x.shape[0], self.k, x.shape[1] // self.k, self.s, self.s)) q = paddle.reshape(q, (x.shape[0], x.shape[1], self.s, self.s)) p = self.resize_mat(p, x.shape[2] // self.s) q = self.resize_mat(q, x.shape[2] // self.s) y = paddle.matmul(p, x) y = paddle.matmul(y, q) y = self.conv2(y) return y
def obj_weighted_reg(self, sx, sy, sw, sh, tx, ty, tw, th, tobj): loss_x = ops.sigmoid_cross_entropy_with_logits(sx, F.sigmoid(tx)) loss_y = ops.sigmoid_cross_entropy_with_logits(sy, F.sigmoid(ty)) loss_w = paddle.abs(sw - tw) loss_h = paddle.abs(sh - th) loss = paddle.add_n([loss_x, loss_y, loss_w, loss_h]) weighted_loss = paddle.mean(loss * F.sigmoid(tobj)) return weighted_loss
def forward(self, feats): assert len(feats) == len(self.fpn_strides), \ "The size of feats is not equal to size of fpn_strides" anchors, num_anchors_list, stride_tensor_list = self._generate_anchors( feats) cls_score_list, bbox_pred_list = [], [] for feat, scale_reg, anchor, stride in zip(feats, self.scales_regs, anchors, self.fpn_strides): b, _, h, w = feat.shape inter_feats = [] for inter_conv in self.inter_convs: feat = F.relu(inter_conv(feat)) inter_feats.append(feat) feat = paddle.concat(inter_feats, axis=1) # task decomposition avg_feat = F.adaptive_avg_pool2d(feat, (1, 1)) cls_feat = self.cls_decomp(feat, avg_feat) reg_feat = self.reg_decomp(feat, avg_feat) # cls prediction and alignment cls_logits = self.tood_cls(cls_feat) if self.use_align_head: cls_prob = F.relu(self.cls_prob_conv1(feat)) cls_prob = F.sigmoid(self.cls_prob_conv2(cls_prob)) cls_score = (F.sigmoid(cls_logits) * cls_prob).sqrt() else: cls_score = F.sigmoid(cls_logits) cls_score_list.append(cls_score.flatten(2).transpose([0, 2, 1])) # reg prediction and alignment reg_dist = scale_reg(self.tood_reg(reg_feat).exp()) reg_dist = reg_dist.transpose([0, 2, 3, 1]).reshape([b, -1, 4]) anchor_centers = bbox_center(anchor).unsqueeze(0) / stride reg_bbox = self._batch_distance2bbox( anchor_centers.tile([b, 1, 1]), reg_dist) if self.use_align_head: reg_bbox = reg_bbox.reshape([b, h, w, 4]).transpose([0, 3, 1, 2]) reg_offset = F.relu(self.reg_offset_conv1(feat)) reg_offset = self.reg_offset_conv2(reg_offset) bbox_pred = self._deform_sampling(reg_bbox, reg_offset) bbox_pred = bbox_pred.flatten(2).transpose([0, 2, 1]) else: bbox_pred = reg_bbox if not self.training: bbox_pred *= stride bbox_pred_list.append(bbox_pred) cls_score_list = paddle.concat(cls_score_list, axis=1) bbox_pred_list = paddle.concat(bbox_pred_list, axis=1) anchors = paddle.concat(anchors) anchors.stop_gradient = True stride_tensor_list = paddle.concat(stride_tensor_list).unsqueeze(0) stride_tensor_list.stop_gradient = True return cls_score_list, bbox_pred_list, anchors, num_anchors_list, stride_tensor_list
def forward(self, x): f_det = self.det_conv1(x) f_det = self.det_conv2(f_det) f_score = self.score_conv(f_det) f_score = F.sigmoid(f_score) f_geo = self.geo_conv(f_det) f_geo = (F.sigmoid(f_geo) - 0.5) * 2 * 800 pred = {'f_score': f_score, 'f_geo': f_geo} return pred
def get_outputs(self, xin): outputs = [] origin_preds = [] x_shifts = [] y_shifts = [] expanded_strides = [] for k, (cls_conv, reg_conv, stride_this_level, x) in enumerate( zip(self.cls_convs, self.reg_convs, self.strides, xin)): x = self.stems[k](x) cls_x = x reg_x = x cls_feat = cls_conv(cls_x) cls_output = self.cls_preds[k](cls_feat) reg_feat = reg_conv(reg_x) reg_output = self.reg_preds[k](reg_feat) obj_output = self.obj_preds[k](reg_feat) if self.training: output = paddle.concat([reg_output, obj_output, cls_output], 1) # output.shape=[N, 1 * 80 * 80, 85] output里面有解码后的xywh # grid.shape= [1, 1 * 80 * 80, 2] 格子左上角xy坐标,单位是这个特征图的stride output, grid = self.get_output_and_grid( output, k, stride_this_level) x_shifts.append( grid[:, :, 0]) # [1, 1 * 80 * 80] 格子左上角x坐标,单位是这个特征图的stride y_shifts.append( grid[:, :, 1]) # [1, 1 * 80 * 80] 格子左上角y坐标,单位是这个特征图的stride # [1, 1 * 80 * 80] 这个特征图的stride复制hsize*wsize份,意思是每个格子持有一个stride expanded_stride = paddle.ones( (1, grid.shape[1]), dtype=xin[0].dtype) * stride_this_level expanded_strides.append(expanded_stride) if self.use_l1: # 如果使用L1损失。不使用马赛克增强后会使用L1损失。 batch_size = reg_output.shape[0] # 批大小 hsize, wsize = reg_output.shape[-2:] # 格子行数、列数 # L1损失监督的是未解码的xywh reg_output = reg_output.reshape( (batch_size, self.n_anchors, 4, hsize, wsize)) reg_output = reg_output.transpose((0, 1, 3, 4, 2)).reshape( (batch_size, -1, 4)) origin_preds.append(reg_output.clone()) else: output = paddle.concat( [reg_output, F.sigmoid(obj_output), F.sigmoid(cls_output)], 1) outputs.append(output) return outputs, x_shifts, y_shifts, expanded_strides, origin_preds
def dmr_fcn_attention(item_eb, item_his_eb, context_his_eb, mask, mode='SUM'): mask = paddle.equal(mask, paddle.ones_like(mask)) item_eb_tile = paddle.tile(item_eb, [1, paddle.shape(mask)[1]]) # B, T*E item_eb_tile = paddle.reshape( item_eb_tile, [-1, paddle.shape(mask)[1], item_eb.shape[-1]]) # B, T, E if context_his_eb is None: query = item_eb_tile else: query = paddle.concat([item_eb_tile, context_his_eb], axis=-1) query = self.query_layer2(query) query = self.query_prelu2(query) dmr_all = paddle.concat( [ query, item_his_eb, query - item_his_eb, query * item_his_eb ], axis=-1) att_layer_1 = self.att_layer1_layer2(dmr_all) att_layer_1 = F.sigmoid(att_layer_1) att_layer_2 = self.att_layer2_layer2(att_layer_1) att_layer_2 = F.sigmoid(att_layer_2) att_layer_3 = self.att_layer3_layer2(att_layer_2) # B, T, 1 att_layer_3 = paddle.reshape( att_layer_3, [-1, 1, paddle.shape(item_his_eb)[1]]) # B,1,T scores = att_layer_3 scores = scores.reshape([-1, 1, self.history_length]) ## # Mask key_masks = paddle.unsqueeze(mask, 1) # B,1,T paddings = paddle.ones_like(scores) * (-2**32 + 1) paddings_no_softmax = paddle.zeros_like(scores) scores = paddle.where(key_masks, scores, paddings) # [B, 1, T] scores_no_softmax = paddle.where(key_masks, scores, paddings_no_softmax) scores = F.softmax(scores) if mode == 'SUM': output = paddle.matmul(scores, item_his_eb) # [B, 1, H] output = paddle.sum(output, axis=1) # B,E else: scores = paddle.reshape(scores, [-1, paddle.shape(item_his_eb)[1]]) output = item_his_eb * paddle.unsqueeze(scores, -1) output = paddle.reshape(output, paddle.shape(item_his_eb)) return output, scores, scores_no_softmax
def forward_eval(self, fpn_feats, export_post_process=True): if self.eval_size: anchor_points, stride_tensor = self.anchor_points, self.stride_tensor else: anchor_points, stride_tensor = self._generate_anchors(fpn_feats) cls_logits_list, bboxes_reg_list = [], [] for i, fpn_feat in enumerate(fpn_feats): conv_cls_feat, conv_reg_feat = self.conv_feat(fpn_feat, i) if self.conv_feat.share_cls_reg: cls_logits = self.head_cls_list[i](conv_cls_feat) cls_score, bbox_pred = paddle.split( cls_logits, [self.cls_out_channels, 4 * (self.reg_max + 1)], axis=1) else: cls_score = self.head_cls_list[i](conv_cls_feat) bbox_pred = self.head_reg_list[i](conv_reg_feat) if self.dgqp_module: quality_score = self.dgqp_module(bbox_pred) cls_score = F.sigmoid(cls_score) * quality_score if not export_post_process: # Now only supports batch size = 1 in deploy # TODO(ygh): support batch size > 1 cls_score_out = F.sigmoid(cls_score).reshape( [1, self.cls_out_channels, -1]).transpose([0, 2, 1]) bbox_pred = bbox_pred.reshape([1, (self.reg_max + 1) * 4, -1]).transpose([0, 2, 1]) else: b, _, h, w = fpn_feat.shape l = h * w cls_score_out = F.sigmoid( cls_score.reshape([b, self.cls_out_channels, l])) bbox_pred = bbox_pred.transpose([0, 2, 3, 1]) bbox_pred = self.distribution_project(bbox_pred) bbox_pred = bbox_pred.reshape([b, l, 4]) cls_logits_list.append(cls_score_out) bboxes_reg_list.append(bbox_pred) if export_post_process: cls_logits_list = paddle.concat(cls_logits_list, axis=-1) bboxes_reg_list = paddle.concat(bboxes_reg_list, axis=1) bboxes_reg_list = batch_distance2bbox(anchor_points, bboxes_reg_list) bboxes_reg_list *= stride_tensor return (cls_logits_list, bboxes_reg_list)
def forward(self, sparse_inputs, dense_inputs): # print("sparse_inputs:",sparse_inputs) # print("dense_inputs:",dense_inputs) # EmbeddingLayer sparse_inputs_concat = paddle.concat(sparse_inputs, axis=1) #Tensor(shape=[bs, 26]) sparse_embeddings = self.embedding( sparse_inputs_concat) # shape=[bs, 26, dim] # print("sparse_embeddings shape:",sparse_embeddings.shape) sparse_embeddings_re = paddle.reshape( sparse_embeddings, shape=[-1, self.sparse_num_field * self.sparse_feature_dim]) dense_embeddings = self.dense_emb( dense_inputs) # # shape=[bs, 13, dim] feat_embeddings = paddle.concat( [sparse_embeddings_re, dense_embeddings], 1) # print("feat_embeddings:",feat_embeddings.shape) # Model Structaul: Stacked or Parallel if self.is_Stacked: # CrossNetLayer cross_out = self.DeepCrossLayer_(feat_embeddings) # MLPLayer dnn_output = self.DNN_(cross_out) # print('----dnn_output shape----',dnn_output.shape) logit = self.fc(dnn_output) predict = F.sigmoid(logit) else: # CrossNetLayer cross_out = self.DeepCrossLayer_(feat_embeddings) # MLPLayer dnn_output = self.DNN_(feat_embeddings) last_out = paddle.concat([dnn_output, cross_out], axis=-1) # print('----last_out_output shape----',last_out.shape) logit = self.fc(last_out) predict = F.sigmoid(logit) return predict
def forward(self, inputs): x = self.conv1(inputs) # 每个卷积层使用Sigmoid激活函数,后面跟着一个2x2的池化 x = F.sigmoid(x) x = self.max_pool1(x) x = F.sigmoid(x) x = self.conv2(x) x = self.max_pool2(x) x = self.conv3(x) # 尺寸的逻辑:输入层将数据拉平[B,C,H,W] -> [B,C*H*W] x = paddle.reshape(x, [x.shape[0], -1]) x = self.fc1(x) x = F.sigmoid(x) x = self.fc2(x) return x
def forward(self, center_words, target_words, label=None): """# 定义网络的前向计算逻辑 # center_words是一个tensor(mini-batch),表示中心词 # target_words是一个tensor(mini-batch),表示目标词 # label是一个tensor(mini-batch),表示这个词是正样本还是负样本(用0或1表示) # 用于在训练中计算这个tensor中对应词的同义词,用于观察模型的训练效果""" # 首先,通过embedding_para(self.embedding)参数,将mini-batch中的词转换为词向量 # 这里center_words和eval_words_emb查询的是一个相同的参数 # 而target_words_emb查询的是另一个参数 center_words_emb = self.embedding(center_words) target_words_emb = self.embedding_out(target_words) # 我们通过点乘的方式计算中心词到目标词的输出概率,并通过sigmoid函数估计这个词是正样本还是负样本的概率。 word_sim = paddle.multiply(center_words_emb, target_words_emb) # 向量点乘, 对应元素相乘 word_sim = paddle.sum(word_sim, axis=-1) word_sim = paddle.reshape(word_sim, shape=[-1]) if label is not None: # 通过估计的输出概率定义损失函数,注意我们使用的是binary_cross_entropy_with_logits函数 # 将sigmoid计算和cross entropy合并成一步计算可以更好的优化,所以输入的是word_sim,而不是pred loss = F.binary_cross_entropy_with_logits(word_sim, label) loss = paddle.mean(loss) return loss else: return F.sigmoid(word_sim)
def forward(self, x): x.stop_gradient = False x = x.transpose([0, 3, 2, 1]) x = self.bn0(x) x = x.transpose([0, 3, 2, 1]) x = self.conv_block1(x, pool_size=(2, 2), pool_type='avg') x = F.dropout(x, p=0.2, training=self.training) x = self.conv_block2(x, pool_size=(2, 2), pool_type='avg') x = F.dropout(x, p=0.2, training=self.training) x = self.conv_block3(x, pool_size=(2, 2), pool_type='avg') x = F.dropout(x, p=0.2, training=self.training) x = self.conv_block4(x, pool_size=(2, 2), pool_type='avg') x = F.dropout(x, p=0.2, training=self.training) x = x.mean(axis=3) x = x.max(axis=2) + x.mean(axis=2) x = F.dropout(x, p=0.5, training=self.training) x = F.relu(self.fc1(x)) if self.extract_embedding: output = F.dropout(x, p=0.5, training=self.training) else: output = F.sigmoid(self.fc_audioset(x)) return output
def __call__(self, x, file_names=None, multilabel=False): assert isinstance(x, paddle.Tensor) if file_names is not None: assert x.shape[0] == len(file_names) x = F.softmax(x, axis=-1) if not multilabel else F.sigmoid(x) x = x.numpy() y = [] for idx, probs in enumerate(x): index = probs.argsort(axis=0)[-self.topk:][::-1].astype( "int32") if not multilabel else np.where( probs >= 0.5)[0].astype("int32") clas_id_list = [] score_list = [] label_name_list = [] for i in index: clas_id_list.append(i.item()) score_list.append(probs[i].item()) if self.class_id_map is not None: label_name_list.append(self.class_id_map[i.item()]) result = { "class_ids": clas_id_list, "scores": np.around(score_list, decimals=5).tolist(), } if file_names is not None: result["file_name"] = file_names[idx] if label_name_list is not None: result["label_names"] = label_name_list y.append(result) return y
def forward(self, x, targets=None): f_score = self.conv_f_score1(x) f_score = self.conv_f_score2(f_score) f_score = self.conv_f_score3(f_score) f_score = self.conv1(f_score) f_score = F.sigmoid(f_score) # f_border f_border = self.conv_f_boder1(x) f_border = self.conv_f_boder2(f_border) f_border = self.conv_f_boder3(f_border) f_border = self.conv2(f_border) f_char = self.conv_f_char1(x) f_char = self.conv_f_char2(f_char) f_char = self.conv_f_char3(f_char) f_char = self.conv_f_char4(f_char) f_char = self.conv_f_char5(f_char) f_char = self.conv3(f_char) f_direction = self.conv_f_direc1(x) f_direction = self.conv_f_direc2(f_direction) f_direction = self.conv_f_direc3(f_direction) f_direction = self.conv4(f_direction) predicts = {} predicts['f_score'] = f_score predicts['f_border'] = f_border predicts['f_char'] = f_char predicts['f_direction'] = f_direction return predicts
def GRU(x, h_nei, W_z, W_r, U_r, W_h): hidden_size = x.shape[-1] sum_h = paddle.sum(h_nei, axis=1) z_input = paddle.concat([x, sum_h], axis=1) z = F.sigmoid(W_z(z_input)) r_1 = paddle.reshape(W_r(x), shape=[-1, 1, hidden_size]) r_2 = U_r(h_nei) r = F.sigmoid(r_1 + r_2) gated_h = r * h_nei sum_gated_h = paddle.sum(gated_h, axis=1) h_input = paddle.concat([x, sum_gated_h], axis=1) pre_h = F.tanh(W_h(h_input)) new_h = (1.0 - z) * sum_h + z * pre_h return new_h
def forward(self, source_image, kp_driving, kp_source): if self.scale_factor != 1: source_image = self.down(source_image) bs, _, h, w = source_image.shape out_dict = dict() heatmap_representation = self.create_heatmap_representations( source_image, kp_driving, kp_source) sparse_motion = self.create_sparse_motions(source_image, kp_driving, kp_source) deformed_source = self.create_deformed_source_image( source_image, sparse_motion) out_dict['sparse_deformed'] = deformed_source buf = paddle.concat([heatmap_representation, deformed_source], axis=2) buf = buf.reshape((bs, -1, h, w)) prediction = self.hourglass(buf) mask = self.mask(prediction) mask = F.softmax(mask, axis=1) out_dict['mask'] = mask mask = mask.unsqueeze(2) sparse_motion = paddle.transpose(sparse_motion, (0, 1, 4, 2, 3)) deformation = paddle.sum(sparse_motion * mask, axis=1) deformation = paddle.transpose(deformation, (0, 2, 3, 1)) out_dict['deformation'] = deformation # Sec. 3.2 in the paper if self.occlusion: occlusion_map = F.sigmoid(self.occlusion(prediction)) out_dict['occlusion_map'] = occlusion_map return out_dict
def forward(self, graph, feature, edge_feat=None): if self.feat_drop > 1e-5: feature = self.feat_dropout(feature) q = self.q(feature) k = self.k(feature) v = self.v(feature) q = paddle.reshape(q, [-1, self.num_heads, self.hidden_size]) k = paddle.reshape(k, [-1, self.num_heads, self.hidden_size]) v = paddle.reshape(v, [-1, self.num_heads, self.hidden_size]) if edge_feat is not None: if self.feat_drop > 1e-5: edge_feat = self.feat_dropout(edge_feat) edge_feat = paddle.reshape(edge_feat, [-1, self.num_heads, self.hidden_size]) output = self.send_recv(graph, q, k, v, edge_feat=edge_feat) if self.skip_feat is not None: skip_feat = self.skip_feat(feature) if self.gate is not None: gate = F.sigmoid( self.gate( paddle.concat([skip_feat, output, skip_feat - output], axis=-1))) output = gate * skip_feat + (1 - gate) * output else: output = skip_feat + output if self.layer_norm is not None: output = self.layer_norm(output) if self.activation is not None: output = self.activation(output) return output
def forward(self, slot_inputs): self.all_vars = [] embs = [] self.inference_feed_vars = [] for s_input in slot_inputs: emb = paddle.static.nn.sparse_embedding( input=s_input, size=[self.dict_dim, self.emb_dim], padding_idx=0, entry=self.entry, param_attr=paddle.ParamAttr(name="embedding")) self.inference_feed_vars.append(emb) bow = paddle.fluid.layers.sequence_pool(input=emb, pool_type='sum') self.all_vars.append(bow) #paddle.fluid.layers.Print(bow) embs.append(bow) y_dnn = paddle.concat(x=embs, axis=1) self.all_vars.append(y_dnn) for n_layer in self._mlp_layers: y_dnn = n_layer(y_dnn) self.all_vars.append(y_dnn) self.predict = F.sigmoid(paddle.clip(y_dnn, min=-15.0, max=15.0)) self.all_vars.append(self.predict) return self.predict
def generate_proposal(self, inputs, rpn_head_out, anchor_out, is_train): # TODO: delete im_info try: im_shape = inputs['im_info'] except: im_shape = inputs['im_shape'] rpn_rois_list = [] rpn_prob_list = [] rpn_rois_num_list = [] for (rpn_score, rpn_delta), (anchor, var) in zip(rpn_head_out, anchor_out): rpn_prob = F.sigmoid(rpn_score) rpn_rois, rpn_rois_prob, rpn_rois_num, post_nms_top_n = self.proposal_generator( scores=rpn_prob, bbox_deltas=rpn_delta, anchors=anchor, variances=var, im_shape=im_shape, is_train=is_train) if len(rpn_head_out) == 1: return rpn_rois, rpn_rois_num rpn_rois_list.append(rpn_rois) rpn_prob_list.append(rpn_rois_prob) rpn_rois_num_list.append(rpn_rois_num) start_level = 2 end_level = start_level + len(rpn_head_out) rois_collect, rois_num_collect = ops.collect_fpn_proposals( rpn_rois_list, rpn_prob_list, start_level, end_level, post_nms_top_n, rois_num_per_level=rpn_rois_num_list) return rois_collect, rois_num_collect
def run_batch(model, optimizer, data_loader, epoch_i, desc, loss_fn): total_loss = 0 logits_list = [] ground_truth = [] for batch in tqdm(data_loader, desc=f"{desc} Epoch {epoch_i}"): logits, labels = do_compute(model, batch) loss = loss_fn(logits, labels) loss = paddle.mean(paddle.sum(loss, -1)) if model.training: loss.backward() optimizer.step() optimizer.clear_grad() total_loss += loss.item() logits_list.append(F.sigmoid(logits).tolist()) ground_truth.append(labels.tolist()) total_loss /= len(data_loader) logits_list = np.concatenate(logits_list) ground_truth = np.concatenate(ground_truth) metrics = None if not model.training: metrics = do_compute_metrics(ground_truth, logits_list) return total_loss, metrics
def forward(self, out_transformer, body_feats, inputs=None): r""" Args: out_transformer (Tuple): (feats: [num_levels, batch_size, num_queries, hidden_dim], memory: [batch_size, \sum_{l=0}^{L-1} H_l \cdot W_l, hidden_dim], reference_points: [batch_size, num_queries, 2]) body_feats (List(Tensor)): list[[B, C, H, W]] inputs (dict): dict(inputs) """ feats, memory, reference_points = out_transformer reference_points = inverse_sigmoid(reference_points.unsqueeze(0)) outputs_bbox = self.bbox_head(feats) # It's equivalent to "outputs_bbox[:, :, :, :2] += reference_points", # but the gradient is wrong in paddle. outputs_bbox = paddle.concat([ outputs_bbox[:, :, :, :2] + reference_points, outputs_bbox[:, :, :, 2:] ], axis=-1) outputs_bbox = F.sigmoid(outputs_bbox) outputs_logit = self.score_head(feats) if self.training: assert inputs is not None assert 'gt_bbox' in inputs and 'gt_class' in inputs return self.loss(outputs_bbox, outputs_logit, inputs['gt_bbox'], inputs['gt_class']) else: return (outputs_bbox[-1], outputs_logit[-1], None)
def forward(self, logits, label): """ Args: logits (Tensor): Logit tensor, the data type is float32, float64. Shape is (N, C), where C is number of classes, and if shape is more than 2D, this is (N, C, D1, D2,..., Dk), k >= 1. label (Tensor): Label tensor, the data type is int64. Shape is (N), where each value is 0 <= label[i] <= C-1, and if shape is more than 2D, this is (N, D1, D2,..., Dk), k >= 1. Returns: loss """ boundary_targets = F.conv2d(paddle.unsqueeze(label, axis=1).astype('float32'), self.laplacian_kernel, padding=1) boundary_targets = paddle.clip(boundary_targets, min=0) boundary_targets = boundary_targets > 0.1 boundary_targets = boundary_targets.astype('float32') boundary_targets_x2 = F.conv2d(paddle.unsqueeze(label, axis=1).astype('float32'), self.laplacian_kernel, stride=2, padding=1) boundary_targets_x2 = paddle.clip(boundary_targets_x2, min=0) boundary_targets_x4 = F.conv2d(paddle.unsqueeze(label, axis=1).astype('float32'), self.laplacian_kernel, stride=4, padding=1) boundary_targets_x4 = paddle.clip(boundary_targets_x4, min=0) boundary_targets_x8 = F.conv2d(paddle.unsqueeze(label, axis=1).astype('float32'), self.laplacian_kernel, stride=8, padding=1) boundary_targets_x8 = paddle.clip(boundary_targets_x8, min=0) boundary_targets_x8_up = F.interpolate(boundary_targets_x8, boundary_targets.shape[2:], mode='nearest') boundary_targets_x4_up = F.interpolate(boundary_targets_x4, boundary_targets.shape[2:], mode='nearest') boundary_targets_x2_up = F.interpolate(boundary_targets_x2, boundary_targets.shape[2:], mode='nearest') boundary_targets_x2_up = boundary_targets_x2_up > 0.1 boundary_targets_x2_up = boundary_targets_x2_up.astype('float32') boundary_targets_x4_up = boundary_targets_x4_up > 0.1 boundary_targets_x4_up = boundary_targets_x4_up.astype('float32') boundary_targets_x8_up = boundary_targets_x8_up > 0.1 boundary_targets_x8_up = boundary_targets_x8_up.astype('float32') boudary_targets_pyramids = paddle.stack((boundary_targets, boundary_targets_x2_up, boundary_targets_x4_up), axis=1) boudary_targets_pyramids = paddle.squeeze(boudary_targets_pyramids, axis=2) boudary_targets_pyramid = F.conv2d(boudary_targets_pyramids, self.fuse_kernel) boudary_targets_pyramid = boudary_targets_pyramid > 0.1 boudary_targets_pyramid = boudary_targets_pyramid.astype('float32') if logits.shape[-1] != boundary_targets.shape[-1]: logits = F.interpolate( logits, boundary_targets.shape[2:], mode='bilinear', align_corners=True) bce_loss = F.binary_cross_entropy_with_logits(logits, boudary_targets_pyramid) dice_loss = self.fixed_dice_loss_func(F.sigmoid(logits), boudary_targets_pyramid) detail_loss = bce_loss + dice_loss label.stop_gradient = True return detail_loss
def static_graph_case(self): main = fluid.Program() start = fluid.Program() with fluid.unique_name.guard(): with fluid.program_guard(main, start): self.channel_last = self.data_format == "NDHWC" if self.channel_last: x = x = fluid.data("input", (-1, -1, -1, -1, self.in_channels), dtype=self.dtype) else: x = fluid.data("input", (-1, self.in_channels, -1, -1, -1), dtype=self.dtype) weight = fluid.data("weight", self.weight_shape, dtype=self.dtype) if not self.no_bias: bias = fluid.data("bias", self.bias_shape, dtype=self.dtype) y = F.conv_transpose3d(x, weight, None if self.no_bias else bias, output_size=self.output_size, padding=self.padding, stride=self.stride, dilation=self.dilation, groups=self.groups, data_format=self.data_format) if self.act == 'sigmoid': y = F.sigmoid(y)
def get_loss(self, pred_hm, pred_wh, target_hm, box_target, target_weight): pred_hm = paddle.clip(F.sigmoid(pred_hm), 1e-4, 1 - 1e-4) hm_loss = self.hm_loss(pred_hm, target_hm) H, W = target_hm.shape[2:] mask = paddle.reshape(target_weight, [-1, H, W]) avg_factor = paddle.sum(mask) + 1e-4 base_step = self.down_ratio shifts_x = paddle.arange(0, W * base_step, base_step, dtype='int32') shifts_y = paddle.arange(0, H * base_step, base_step, dtype='int32') shift_y, shift_x = paddle.tensor.meshgrid([shifts_y, shifts_x]) base_loc = paddle.stack([shift_x, shift_y], axis=0) base_loc.stop_gradient = True pred_boxes = paddle.concat( [0 - pred_wh[:, 0:2, :, :] + base_loc, pred_wh[:, 2:4] + base_loc], axis=1) pred_boxes = paddle.transpose(pred_boxes, [0, 2, 3, 1]) boxes = paddle.transpose(box_target, [0, 2, 3, 1]) boxes.stop_gradient = True pred_boxes, boxes, mask = self.filter_box_by_weight( pred_boxes, boxes, mask) mask.stop_gradient = True wh_loss = self.wh_loss(pred_boxes, boxes, iou_weight=mask.unsqueeze(1)) wh_loss = wh_loss / avg_factor ttf_loss = {'hm_loss': hm_loss, 'wh_loss': wh_loss} return ttf_loss
def evaluate(model, criterion, metric, data_loader): """ Given a dataset, it evals model and computes the metric. Args: model(obj:`paddle.nn.Layer`): A model to classify texts. criterion(obj:`paddle.nn.Layer`): It can compute the loss. metric(obj:`paddle.metric.Metric`): The evaluation metric. data_loader(obj:`paddle.io.DataLoader`): The dataset loader which generates batches. """ model.eval() metric.reset() losses = [] for batch in data_loader: input_ids, token_type_ids, labels = batch logits = model(input_ids, token_type_ids) loss = criterion(logits, labels) probs = F.sigmoid(logits) losses.append(loss.numpy()) metric.update(probs, labels) auc, f1_score = metric.accumulate() print("eval loss: %.5f, auc: %.5f, f1 score: %.5f" % (np.mean(losses), auc, f1_score)) model.train() metric.reset()
def forward(self, inputs, drop_connect_rate=None): """ :param inputs: input tensor :param drop_connect_rate: drop connect rate (float, between 0 and 1) :return: output of block """ # Expansion and Depthwise Convolution x = inputs if self._block_args.expand_ratio != 1: x = self._swish(self._bn0(self._expand_conv(inputs))) x = self._swish(self._bn1(self._depthwise_conv(x))) # Squeeze and Excitation if self.has_se: x_squeezed = F.adaptive_avg_pool2d(x, 1) x_squeezed = self._se_expand( self._swish(self._se_reduce(x_squeezed))) x = F.sigmoid(x_squeezed) * x x = self._bn2(self._project_conv(x)) # Skip connection and drop connect input_filters, output_filters = self._block_args.input_filters, self._block_args.output_filters if self.id_skip and self._block_args.stride == 1 and input_filters == output_filters: if drop_connect_rate: x = drop_connect(x, prob=drop_connect_rate, training=self.training) x = x + inputs # skip connection return x