def train_pm(model, optimizer): # 开启0号GPU训练 use_gpu = True paddle.set_device('gpu:0') if use_gpu else paddle.set_device('cpu') print('start training ... ') model.train() epoch_num = 5 # 定义数据读取器,训练数据读取器和验证数据读取器 train_loader = data_loader(DATADIR, batch_size=10, mode='train') valid_loader = valid_data_loader(DATADIR2, CSVFILE) for epoch in range(epoch_num): for batch_id, data in enumerate(train_loader()): x_data, y_data = data img = paddle.to_tensor(x_data) label = paddle.to_tensor(y_data) # 运行模型前向计算,得到预测值 logits = model(img) loss = F.binary_cross_entropy_with_logits(logits, label) avg_loss = paddle.mean(loss) if batch_id % 10 == 0: print("epoch: {}, batch_id: {}, loss is: {}".format( epoch, batch_id, avg_loss.numpy())) # 反向传播,更新权重,清除梯度 avg_loss.backward() opt.step() opt.clear_grad() model.eval() accuracies = [] losses = [] for batch_id, data in enumerate(valid_loader()): x_data, y_data = data img = paddle.to_tensor(x_data) label = paddle.to_tensor(y_data) # 运行模型前向计算,得到预测值 logits = model(img) # 二分类,sigmoid计算后的结果以0.5为阈值分两个类别 # 计算sigmoid后的预测概率,进行loss计算 pred = F.sigmoid(logits) loss = F.binary_cross_entropy_with_logits(logits, label) # 计算预测概率小于0.5的类别 pred2 = pred * (-1.0) + 1.0 # 得到两个类别的预测概率,并沿第一个维度级联 pred = paddle.concat([pred2, pred], axis=1) acc = paddle.metric.accuracy(pred, paddle.cast(label, dtype='int64')) accuracies.append(acc.numpy()) losses.append(loss.numpy()) print("[validation] accuracy/loss: {}/{}".format( np.mean(accuracies), np.mean(losses))) model.train() paddle.save(model.state_dict(), 'palm.pdparams') paddle.save(opt.state_dict(), 'palm.pdopt')
def _binary_crossentropy(self, input, target, class_num): if self.epsilon is not None: target = self._labelsmoothing(target, class_num) cost = F.binary_cross_entropy_with_logits( logit=input, label=target) else: cost = F.binary_cross_entropy_with_logits( logit=input, label=target) return cost
def _binary_crossentropy(self, input, target): if self._label_smoothing: target = self._labelsmoothing(target) cost = F.binary_cross_entropy_with_logits(logit=input, label=target) else: cost = F.binary_cross_entropy_with_logits(logit=input, label=target) avg_cost = paddle.mean(cost) return avg_cost
def obj_loss(self, pbox, gbox, pobj, tobj, anchor, downsample): # pbox pbox = decode_yolo(pbox, anchor, downsample) pbox = xywh2xyxy(pbox) pbox = paddle.concat(pbox, axis=-1) b = pbox.shape[0] pbox = pbox.reshape((b, -1, 4)) # gbox gxy = gbox[:, :, 0:2] - gbox[:, :, 2:4] * 0.5 gwh = gbox[:, :, 0:2] + gbox[:, :, 2:4] * 0.5 gbox = paddle.concat([gxy, gwh], axis=-1) iou = iou_similarity(pbox, gbox) iou.stop_gradient = True iou_max = iou.max(2) # [N, M1] iou_mask = paddle.cast(iou_max <= self.ignore_thresh, dtype=pbox.dtype) iou_mask.stop_gradient = True pobj = pobj.reshape((b, -1)) tobj = tobj.reshape((b, -1)) obj_mask = paddle.cast(tobj > 0, dtype=pbox.dtype) obj_mask.stop_gradient = True loss_obj = F.binary_cross_entropy_with_logits( pobj, obj_mask, reduction='none') loss_obj_pos = (loss_obj * tobj) loss_obj_neg = (loss_obj * (1 - obj_mask) * iou_mask) return loss_obj_pos + loss_obj_neg
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 get_loss(self, pred_scores, pred_deltas, anchors, inputs): """ pred_scores (list[Tensor]): Multi-level scores prediction pred_deltas (list[Tensor]): Multi-level deltas prediction anchors (list[Tensor]): Multi-level anchors inputs (dict): ground truth info, including im, gt_bbox, gt_score """ anchors = [paddle.reshape(a, shape=(-1, 4)) for a in anchors] anchors = paddle.concat(anchors) scores = [ paddle.reshape(paddle.transpose(v, perm=[0, 2, 3, 1]), shape=(v.shape[0], -1, 1)) for v in pred_scores ] scores = paddle.concat(scores, axis=1) deltas = [ paddle.reshape(paddle.transpose(v, perm=[0, 2, 3, 1]), shape=(v.shape[0], -1, 4)) for v in pred_deltas ] deltas = paddle.concat(deltas, axis=1) score_tgt, bbox_tgt, loc_tgt, norm = self.rpn_target_assign( inputs, anchors) scores = paddle.reshape(x=scores, shape=(-1, )) deltas = paddle.reshape(x=deltas, shape=(-1, 4)) score_tgt = paddle.concat(score_tgt) score_tgt.stop_gradient = True pos_mask = score_tgt == 1 pos_ind = paddle.nonzero(pos_mask) valid_mask = score_tgt >= 0 valid_ind = paddle.nonzero(valid_mask) # cls loss if valid_ind.shape[0] == 0: loss_rpn_cls = paddle.zeros([1], dtype='float32') else: score_pred = paddle.gather(scores, valid_ind) score_label = paddle.gather(score_tgt, valid_ind).cast('float32') score_label.stop_gradient = True loss_rpn_cls = F.binary_cross_entropy_with_logits( logit=score_pred, label=score_label, reduction="sum") # reg loss if pos_ind.shape[0] == 0: loss_rpn_reg = paddle.zeros([1], dtype='float32') else: loc_pred = paddle.gather(deltas, pos_ind) loc_tgt = paddle.concat(loc_tgt) loc_tgt = paddle.gather(loc_tgt, pos_ind) loc_tgt.stop_gradient = True loss_rpn_reg = paddle.abs(loc_pred - loc_tgt).sum() return { 'loss_rpn_cls': loss_rpn_cls / norm, 'loss_rpn_reg': loss_rpn_reg / norm }
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 evaluation(model, params_file_path): # 开启0号GPU预估 use_gpu = True paddle.set_device('gpu:0') if use_gpu else paddle.set_device('cpu') print('start evaluation .......') # 加载模型参数 model_state_dict = paddle.load(params_file_path) model.load_dict(model_state_dict) model.eval() eval_loader = data_loader(DATADIR, batch_size=10, mode='eval') acc_set = [] avg_loss_set = [] for batch_id, data in enumerate(eval_loader()): x_data, y_data = data img = paddle.to_tensor(x_data) label = paddle.to_tensor(y_data) y_data = y_data.astype(np.int64) label_64 = paddle.to_tensor(y_data) # 计算预测和精度 prediction, acc = model(img, label_64) # 计算损失函数值 loss = F.binary_cross_entropy_with_logits(prediction, label) avg_loss = paddle.mean(loss) acc_set.append(float(acc.numpy())) avg_loss_set.append(float(avg_loss.numpy())) # 求平均精度 acc_val_mean = np.array(acc_set).mean() avg_loss_val_mean = np.array(avg_loss_set).mean() print('loss={}, acc={}'.format(avg_loss_val_mean, acc_val_mean))
def __call__(self, ioup, pbox, gbox): iou = bbox_iou( pbox, gbox, giou=self.giou, diou=self.diou, ciou=self.ciou) iou.stop_gradient = True loss_iou_aware = F.binary_cross_entropy_with_logits( ioup, iou, reduction='none') loss_iou_aware = loss_iou_aware * self.loss_weight return loss_iou_aware
def structure_loss(pred, mask): bce = F.binary_cross_entropy_with_logits(pred, mask) pred = F.sigmoid(pred) inter = (pred * mask).sum(axis=(2, 3)) union = (pred + mask).sum(axis=(2, 3)) iou = 1 - (inter + 1) / (union - inter + 1) return bce + iou.mean()
def sigmoid_cross_entropy_with_logits(input, label, ignore_index=-100, normalize=False): output = F.binary_cross_entropy_with_logits(input, label, reduction='none') mask_tensor = paddle.cast(label != ignore_index, 'float32') output = paddle.multiply(output, mask_tensor) if normalize: sum_valid_mask = paddle.sum(mask_tensor) output = output / sum_valid_mask return output
def loss_cls(self, y_hat, y): y_mask = paddle.where(y == -1, paddle.to_tensor([0.]), paddle.ones_like(y)) y_cal = paddle.where(y == -1, paddle.to_tensor([0.]), y) loss = F.binary_cross_entropy_with_logits(y_hat, y_cal, reduction='none') loss = loss.sum() / y_mask.sum() for layer in self.mpnn_3d.edge2edge_layers: w_g = paddle.stack([conv.G.weight for conv in layer.conv_layer]) loss += self.spa_weight * paddle.sum((w_g[1:, :, :] - w_g[:-1, :, :])**2) return loss
def cls_loss(self, pcls, tcls): if self.label_smooth: delta = min(1. / self.num_classes, 1. / 40) pos, neg = 1 - delta, delta # 1 for positive, 0 for negative tcls = pos * paddle.cast( tcls > 0., dtype=tcls.dtype) + neg * paddle.cast( tcls <= 0., dtype=tcls.dtype) loss_cls = F.binary_cross_entropy_with_logits( pcls, tcls, reduction='none') return loss_cls
def sigmoid_focal_loss(logit, label, normalizer=1.0, alpha=0.25, gamma=2.0): prob = F.sigmoid(logit) ce_loss = F.binary_cross_entropy_with_logits(logit, label, reduction="none") p_t = prob * label + (1 - prob) * (1 - label) loss = ce_loss * ((1 - p_t)**gamma) if alpha >= 0: alpha_t = alpha * label + (1 - alpha) * (1 - label) loss = alpha_t * loss return loss.mean(1).sum() / normalizer
def get_loss(self, mask_logits, mask_label, mask_target, mask_weight): mask_label = F.one_hot(mask_label, self.num_classes).unsqueeze([2, 3]) mask_label = paddle.expand_as(mask_label, mask_logits) mask_label.stop_gradient = True mask_pred = paddle.gather_nd(mask_logits, paddle.nonzero(mask_label)) shape = mask_logits.shape mask_pred = paddle.reshape(mask_pred, [shape[0], shape[2], shape[3]]) mask_target = mask_target.cast('float32') mask_weight = mask_weight.unsqueeze([1, 2]) loss_mask = F.binary_cross_entropy_with_logits( mask_pred, mask_target, weight=mask_weight, reduction="mean") return loss_mask
def forward(self, logit, label): eps = 1e-6 if len(label.shape) != len(logit.shape): label = paddle.unsqueeze(label, 1) # label.shape should equal to the logit.shape if label.shape[1] != logit.shape[1]: label = label.squeeze(1) label = F.one_hot(label, logit.shape[1]) label = label.transpose((0, 3, 1, 2)) mask = (label != self.ignore_index) mask = paddle.cast(mask, 'float32') if isinstance(self.weight, str): pos_index = (label == 1) neg_index = (label == 0) pos_num = paddle.sum(pos_index.astype('float32')) neg_num = paddle.sum(neg_index.astype('float32')) sum_num = pos_num + neg_num weight_pos = 2 * neg_num / (sum_num + eps) weight_neg = 2 * pos_num / (sum_num + eps) self.weight = weight_pos * label + weight_neg * (1 - label) if isinstance(self.pos_weight, str): pos_index = (label == 1) neg_index = (label == 0) pos_num = paddle.sum(pos_index.astype('float32')) neg_num = paddle.sum(neg_index.astype('float32')) sum_num = pos_num + neg_num self.pos_weight = 2 * neg_num / (sum_num + eps) label = label.astype('float32') bce_loss = F.binary_cross_entropy_with_logits( logit, label, weight=self.weight, reduction='none', pos_weight=self.pos_weight) dice_loss = F.dice_loss( logit, label, epsilon=eps ) loss = (bce_loss + dice_loss) / 2. loss = loss * mask loss = paddle.mean(loss) / paddle.mean(mask + eps) label.stop_gradient = True mask.stop_gradient = True return loss
def train(self): model = self.model epoch = 0 global_step = 0 model.train() with tqdm(total=self.num_train_steps) as pbar: while True: for step, batch in enumerate(self.dataloader): outputs = model( input_ids=batch[0], token_type_ids=batch[1], attention_mask=batch[2], entity_ids=batch[3], entity_position_ids=batch[4], entity_token_type_ids=batch[5], entity_attention_mask=batch[6]) loss = F.binary_cross_entropy_with_logits( outputs.reshape([-1]), batch[7].reshape([-1]).astype('float32')) if self.args.gradient_accumulation_steps > 1: loss = loss / self.args.gradient_accumulation_steps loss.backward() if (step + 1) % self.args.gradient_accumulation_steps == 0: self.optimizer.step() self.scheduler.step() self.optimizer.clear_grad() pbar.set_description("epoch: %d loss: %.7f" % (epoch, loss)) pbar.update() global_step += 1 if global_step == self.num_train_steps: break output_dir = self.args.output_dir model.save_pretrained(output_dir) if global_step == self.num_train_steps: break epoch += 1 return model, global_step
def forward(self, logit, label): if logit.ndim == 4: logit = logit.squeeze(2).squeeze(3) assert logit.ndim == 2, "The shape of logit should be [N, C, 1, 1] or [N, C], but the logit dim is {}.".format( logit.ndim) batch_size, num_classes = paddle.shape(logit) se_label = paddle.zeros([batch_size, num_classes]) for i in range(batch_size): hist = paddle.histogram(label[i], bins=num_classes, min=0, max=num_classes - 1) hist = hist.astype('float32') / hist.sum().astype('float32') se_label[i] = (hist > 0).astype('float32') loss = F.binary_cross_entropy_with_logits(logit, se_label) return loss
def varifocal_loss(pred, target, alpha=0.75, gamma=2.0, iou_weighted=True, use_sigmoid=True): """`Varifocal Loss <https://arxiv.org/abs/2008.13367>`_ Args: pred (Tensor): The prediction with shape (N, C), C is the number of classes target (Tensor): The learning target of the iou-aware classification score with shape (N, C), C is the number of classes. alpha (float, optional): A balance factor for the negative part of Varifocal Loss, which is different from the alpha of Focal Loss. Defaults to 0.75. gamma (float, optional): The gamma for calculating the modulating factor. Defaults to 2.0. iou_weighted (bool, optional): Whether to weight the loss of the positive example with the iou target. Defaults to True. """ # pred and target should be of the same size assert pred.shape == target.shape if use_sigmoid: pred_new = F.sigmoid(pred) else: pred_new = pred target = target.cast(pred.dtype) if iou_weighted: focal_weight = target * (target > 0.0).cast('float32') + \ alpha * (pred_new - target).abs().pow(gamma) * \ (target <= 0.0).cast('float32') else: focal_weight = (target > 0.0).cast('float32') + \ alpha * (pred_new - target).abs().pow(gamma) * \ (target <= 0.0).cast('float32') if use_sigmoid: loss = F.binary_cross_entropy_with_logits( pred, target, reduction='none') * focal_weight else: loss = F.binary_cross_entropy(pred, target, reduction='none') * focal_weight loss = loss.sum(axis=1) return loss
def __call__(self, ioup, pbox, gbox, anchor, downsample, scale=1.): b = pbox.shape[0] ioup = ioup.reshape((b, -1)) pbox = decode_yolo(pbox, anchor, downsample) gbox = decode_yolo(gbox, anchor, downsample) pbox = xywh2xyxy(pbox).reshape((b, -1, 4)) gbox = xywh2xyxy(gbox).reshape((b, -1, 4)) iou = bbox_iou(pbox, gbox, giou=self.giou, diou=self.diou, ciou=self.ciou) iou.stop_gradient = True loss_iou_aware = F.binary_cross_entropy_with_logits(ioup, iou, reduction='none') loss_iou_aware = loss_iou_aware * self.loss_weight return loss_iou_aware
def forward(self, center_words, target_words, label): # 首先,通过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]) pred = F.sigmoid(word_sim) # 通过估计的输出概率定义损失函数,注意我们使用的是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) # 返回前向计算的结果,飞桨会通过backward函数自动计算出反向结果。 return pred, loss
def sigmoid_focal_loss(inputs, targets, alpha, gamma, reduction="sum"): assert reduction in ["sum", "mean" ], f'do not support this {reduction} reduction?' p = F.sigmoid(inputs) ce_loss = F.binary_cross_entropy_with_logits( inputs, targets, reduction="none") p_t = p * targets + (1 - p) * (1 - targets) loss = ce_loss * ((1 - p_t)**gamma) if alpha >= 0: alpha_t = alpha * targets + (1 - alpha) * (1 - targets) loss = alpha_t * loss if reduction == "mean": loss = loss.mean() elif reduction == "sum": loss = loss.sum() return loss
def obj_loss(self, pbox, gbox, pobj, tobj, anchor, downsample): b, h, w, na = pbox.shape[:4] pbox = decode_yolo(pbox, anchor, downsample) pbox = pbox.reshape((b, -1, 4)) pbox = xywh2xyxy(pbox) gbox = xywh2xyxy(gbox) iou = iou_similarity(pbox, gbox) iou.stop_gradient = True iou_max = iou.max(2) # [N, M1] iou_mask = paddle.cast(iou_max <= self.ignore_thresh, dtype=pbox.dtype) iou_mask.stop_gradient = True pobj = pobj.reshape((b, -1)) tobj = tobj.reshape((b, -1)) obj_mask = paddle.cast(tobj > 0, dtype=pbox.dtype) obj_mask.stop_gradient = True loss_obj = F.binary_cross_entropy_with_logits(pobj, obj_mask, reduction='none') loss_obj_pos = (loss_obj * tobj) loss_obj_neg = (loss_obj * (1 - obj_mask) * iou_mask) return loss_obj_pos + loss_obj_neg
def yolov3_loss(self, x, t, gt_box, anchor, downsample, scale=1., eps=1e-10): na = len(anchor) b, c, h, w = x.shape no = c // na x = x.reshape((b, na, no, h, w)).transpose((0, 3, 4, 1, 2)) xy, wh, obj = x[:, :, :, :, 0:2], x[:, :, :, :, 2:4], x[:, :, :, :, 4:5] if self.iou_aware_loss: ioup, pcls = x[:, :, :, :, 5:6], x[:, :, :, :, 6:] else: pcls = x[:, :, :, :, 5:] t = t.transpose((0, 3, 4, 1, 2)) txy, twh, tscale = t[:, :, :, :, 0:2], t[:, :, :, :, 2:4], t[:, :, :, :, 4:5] tobj, tcls = t[:, :, :, :, 5:6], t[:, :, :, :, 6:] tscale_obj = tscale * tobj loss = dict() if abs(scale - 1.) < eps: loss_xy = tscale_obj * F.binary_cross_entropy_with_logits( xy, txy, reduction='none') else: xy = scale * F.sigmoid(xy) - 0.5 * (scale - 1.) loss_xy = tscale_obj * paddle.abs(xy - txy) loss_xy = loss_xy.sum([1, 2, 3, 4]).mean() loss_wh = tscale_obj * paddle.abs(wh - twh) loss_wh = loss_wh.sum([1, 2, 3, 4]).mean() loss['loss_loc'] = loss_xy + loss_wh x[:, :, :, :, 0:2] = scale * F.sigmoid(x[:, :, :, :, 0:2]) - 0.5 * (scale - 1.) box, tbox = x[:, :, :, :, 0:4], t[:, :, :, :, 0:4] if self.iou_loss is not None: # box and tbox will not change though they are modified in self.iou_loss function, so no need to clone loss_iou = self.iou_loss(box, tbox, anchor, downsample, scale) loss_iou = loss_iou * tscale_obj.reshape((b, -1)) loss_iou = loss_iou.sum(-1).mean() loss['loss_iou'] = loss_iou if self.iou_aware_loss is not None: # box and tbox will not change though they are modified in self.iou_aware_loss function, so no need to clone loss_iou_aware = self.iou_aware_loss(ioup, box, tbox, anchor, downsample, scale) loss_iou_aware = loss_iou_aware * tobj.reshape((b, -1)) loss_iou_aware = loss_iou_aware.sum(-1).mean() loss['loss_iou_aware'] = loss_iou_aware loss_obj = self.obj_loss(box, gt_box, obj, tobj, anchor, downsample) loss_obj = loss_obj.sum(-1).mean() loss['loss_obj'] = loss_obj loss_cls = self.cls_loss(pcls, tcls) * tobj loss_cls = loss_cls.sum([1, 2, 3, 4]).mean() loss['loss_cls'] = loss_cls return loss
def adv_loss(logits, target): assert target in [1, 0] targets = paddle.full_like(logits, fill_value=target) loss = F.binary_cross_entropy_with_logits(logits, targets) return loss