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
