def test_full_matrices(self): mat_shape = (2, 3) mat = np.random.random(mat_shape).astype("float64") x = paddle.to_tensor(mat) u, s, vh = paddle.linalg.svd(x, full_matrices=True) assert (u.shape == [2, 2]) assert (vh.shape == [3, 3]) x_recover = u.matmul(paddle.diag(s)).matmul(vh[0:2]) if ((paddle.abs(x_recover - x) > 1e-4).any()): raise RuntimeError("mat can't be recovered\n")
def test_svd_forward(self): """ u matmul diag(s) matmul vt must become X """ single_input = self._input_data.reshape( [-1, self._input_shape[-2], self._input_shape[-1]])[0] paddle.disable_static() dy_x = paddle.to_tensor(single_input) dy_u, dy_s, dy_vt = paddle.linalg.svd(dy_x) dy_out_x = dy_u.matmul(paddle.diag(dy_s)).matmul(dy_vt) if (paddle.abs(dy_out_x - dy_x) < 1e-7).all(): ... else: print("EXPECTED:\n", dy_x) print("GOT :\n", dy_out_x) raise RuntimeError("Check SVD Failed") paddle.enable_static()
def loss_boxes(self, outputs, targets, indices, num_boxes): """Compute the losses related to the bounding boxes, the L1 regression loss and the GIoU loss targets dicts must contain the key "boxes" containing a tensor of dim [nb_target_boxes, 4] The target boxes are expected in format (center_x, center_y, w, h), normalized by the image size. """ assert 'pred_boxes' in outputs idx = self._get_src_permutation_idx(indices) src_boxes = outputs['pred_boxes'][idx] target_boxes = torch2paddle.concat([t['boxes'][i] for t, (_, i) in zip(targets, indices)], dim=0) loss_bbox = F.l1_loss(src_boxes, target_boxes, reduction='none') losses = {} losses['loss_bbox'] = loss_bbox.sum() / num_boxes loss_giou = 1 - paddle.diag(box_ops.generalized_box_iou(box_ops. box_cxcywh_to_xyxy(src_boxes), box_ops.box_cxcywh_to_xyxy( target_boxes))) losses['loss_giou'] = loss_giou.sum() / num_boxes return losses
def forward(self, query_input_ids, title_input_ids, query_token_type_ids=None, query_position_ids=None, query_attention_mask=None, title_token_type_ids=None, title_position_ids=None, title_attention_mask=None): query_cls_embedding = self.get_pooled_embedding( query_input_ids, query_token_type_ids, query_position_ids, query_attention_mask) title_cls_embedding = self.get_pooled_embedding( title_input_ids, title_token_type_ids, title_position_ids, title_attention_mask) logits1 = self.classifier(query_cls_embedding) logits2 = self.classifier(title_cls_embedding) kl_loss = self.rdrop_loss(logits1, logits2) cosine_sim = paddle.matmul(query_cls_embedding, title_cls_embedding, transpose_y=True) # substract margin from all positive samples cosine_sim() margin_diag = paddle.full(shape=[query_cls_embedding.shape[0]], fill_value=self.margin, dtype=paddle.get_default_dtype()) cosine_sim = cosine_sim - paddle.diag(margin_diag) # scale cosine to ease training converge cosine_sim *= self.sacle labels = paddle.arange(0, query_cls_embedding.shape[0], dtype='int64') labels = paddle.reshape(labels, shape=[-1, 1]) loss = F.cross_entropy(input=cosine_sim, label=labels) return loss, kl_loss
def orthogonal_(tensor, gain=1): r"""Fills the input `Tensor` with a (semi) orthogonal matrix, as described in `Exact solutions to the nonlinear dynamics of learning in deep linear neural networks` - Saxe, A. et al. (2013). The input tensor must have at least 2 dimensions, and for tensors with more than 2 dimensions the trailing dimensions are flattened. Args: tensor: an n-dimensional `torch.Tensor`, where :math:`n \geq 2` gain: optional scaling factor Examples: >>> w = torch.empty(3, 5) >>> nn.init.orthogonal_(w) """ if tensor.ndimension() < 2: raise ValueError( "Only tensors with 2 or more dimensions are supported") rows = tensor.shape[0] # .size(0) cols = tensor.numel() // rows flattened = tensor.new(rows, cols).normal_(0, 1) if rows < cols: flattened.t_() # Compute the qr factorization q, r = paddle.to_tensor(np.linalg.qr(flattened.numpy())) # q, r = torch.qr(flattened) # Make Q uniform according to https://arxiv.org/pdf/math-ph/0609050.pdf d = paddle.diag(r, 0) ph = d.sign() q *= ph if rows < cols: q.t_() with paddle.no_grad(): tensor.view_as(q).copy_(q) tensor.mul_(gain) return tensor
def forward(self, query_input_ids, title_input_ids, query_token_type_ids=None, query_position_ids=None, query_attention_mask=None, title_token_type_ids=None, title_position_ids=None, title_attention_mask=None): query_cls_embedding = self.get_pooled_embedding( query_input_ids, query_token_type_ids, query_position_ids, query_attention_mask) title_cls_embedding = self.get_pooled_embedding( title_input_ids, title_token_type_ids, title_position_ids, title_attention_mask) cosine_sim = paddle.matmul(query_cls_embedding, title_cls_embedding, transpose_y=True) pos_sim = paddle.max(cosine_sim, axis=-1) # subtract 10000 from all diagnal elements of cosine_sim mask_socre = paddle.full(shape=[query_cls_embedding.shape[0]], fill_value=10000, dtype=paddle.get_default_dtype()) tmp_cosin_sim = cosine_sim - paddle.diag(mask_socre) hardest_negative_sim = paddle.max(tmp_cosin_sim, axis=-1) labels = paddle.full(shape=[query_cls_embedding.shape[0]], fill_value=1.0, dtype='float32') loss = F.margin_ranking_loss(pos_sim, hardest_negative_sim, labels, margin=self.margin) return loss
def test_diag_v2_type(): x = [1, 2, 3] output = paddle.diag(x)
def run_static(self, use_gpu=False): x = paddle.static.data(name='input', shape=[10, 10], dtype='float32') x2 = paddle.static.data(name='input2', shape=[100], dtype='float64') x3 = paddle.static.data(name='input3', shape=[100], dtype='int64') x4 = paddle.static.data(name='input4', shape=[2000, 2000], dtype='float32') x5 = paddle.static.data(name='input5', shape=[2000], dtype='float32') x6 = paddle.static.data(name='input6', shape=[2000, 1500], dtype='float32') result0 = paddle.diag(x) result1 = paddle.diag(x, offset=1) result2 = paddle.diag(x, offset=-1) result3 = paddle.diag(x, name='aaa') result4 = paddle.diag(x2, padding_value=8) result5 = paddle.diag(x3, padding_value=8.0) result6 = paddle.diag(x3, padding_value=-8) result7 = paddle.diag(x4) result8 = paddle.diag(x4, offset=1) result9 = paddle.diag(x4, offset=-1) result10 = paddle.diag(x5) result11 = paddle.diag(x5, offset=1) result12 = paddle.diag(x5, offset=-1) result13 = paddle.diag(x6, offset=-1) place = fluid.CUDAPlace(0) if use_gpu else fluid.CPUPlace() exe = fluid.Executor(place) exe.run(fluid.default_startup_program()) res0, res1, res2, res4, res5, res6, res7, res8, res9, res10, res11, res12, res13 = exe.run( feed={ "input": self.input_np, "input2": self.input_np2, 'input3': self.input_np3, 'input4': self.input_np4, 'input5': self.input_np5, 'input6': self.input_np6 }, fetch_list=[ result0, result1, result2, result4, result5, result6, result7, result8, result9, result10, result11, result12, result13 ]) self.assertTrue(np.allclose(res0, self.expected0)) self.assertTrue(np.allclose(res1, self.expected1)) self.assertTrue(np.allclose(res2, self.expected2)) self.assertTrue('aaa' in result3.name) self.assertTrue(np.allclose(res4, self.expected3)) self.assertTrue(np.allclose(res5, self.expected4)) self.assertTrue(np.allclose(res6, self.expected5)) self.assertTrue(np.allclose(res7, self.expected6)) self.assertTrue(np.allclose(res8, self.expected7)) self.assertTrue(np.allclose(res9, self.expected8)) self.assertTrue(np.allclose(res10, self.expected9)) self.assertTrue(np.allclose(res11, self.expected10)) self.assertTrue(np.allclose(res12, self.expected11)) self.assertTrue(np.allclose(res13, self.expected12))
def run_imperative(self): x = paddle.to_tensor(self.input_np) y = paddle.diag(x) self.assertTrue(np.allclose(y.numpy(), self.expected0)) y = paddle.diag(x, offset=1) self.assertTrue(np.allclose(y.numpy(), self.expected1)) y = paddle.diag(x, offset=-1) self.assertTrue(np.allclose(y.numpy(), self.expected2)) x = paddle.to_tensor(self.input_np2) y = paddle.diag(x, padding_value=8) self.assertTrue(np.allclose(y.numpy(), self.expected3)) x = paddle.to_tensor(self.input_np3) y = paddle.diag(x, padding_value=8.0) self.assertTrue(np.allclose(y.numpy(), self.expected4)) y = paddle.diag(x, padding_value=-8) self.assertTrue(np.allclose(y.numpy(), self.expected5)) x = paddle.to_tensor(self.input_np4) y = paddle.diag(x) self.assertTrue(np.allclose(y.numpy(), self.expected6)) y = paddle.diag(x, offset=1) self.assertTrue(np.allclose(y.numpy(), self.expected7)) y = paddle.diag(x, offset=-1) self.assertTrue(np.allclose(y.numpy(), self.expected8)) x = paddle.to_tensor(self.input_np5) y = paddle.diag(x) self.assertTrue(np.allclose(y.numpy(), self.expected9)) y = paddle.diag(x, offset=1) self.assertTrue(np.allclose(y.numpy(), self.expected10)) y = paddle.diag(x, offset=-1) self.assertTrue(np.allclose(y.numpy(), self.expected11)) x = paddle.to_tensor(self.input_np6) y = paddle.diag(x, offset=-1) self.assertTrue(np.allclose(y.numpy(), self.expected12))
def get_odm_loss(self, odm_target, s2anet_head_out, reg_loss_type='gwd'): (labels, label_weights, bbox_targets, bbox_weights, bbox_gt_bboxes, pos_inds, neg_inds) = odm_target fam_cls_branch_list, fam_reg_branch_list, odm_cls_branch_list, odm_reg_branch_list = s2anet_head_out odm_cls_losses = [] odm_bbox_losses = [] st_idx = 0 num_total_samples = len(pos_inds) + len( neg_inds) if self.sampling else len(pos_inds) num_total_samples = max(1, num_total_samples) for idx, feat_size in enumerate(self.featmap_sizes_list): feat_anchor_num = feat_size[0] * feat_size[1] # step1: get data feat_labels = labels[st_idx:st_idx + feat_anchor_num] feat_label_weights = label_weights[st_idx:st_idx + feat_anchor_num] feat_bbox_targets = bbox_targets[st_idx:st_idx + feat_anchor_num, :] feat_bbox_weights = bbox_weights[st_idx:st_idx + feat_anchor_num, :] # step2: calc cls loss feat_labels = feat_labels.reshape(-1) feat_label_weights = feat_label_weights.reshape(-1) odm_cls_score = odm_cls_branch_list[idx] odm_cls_score = paddle.squeeze(odm_cls_score, axis=0) odm_cls_score1 = odm_cls_score feat_labels = paddle.to_tensor(feat_labels) feat_labels_one_hot = paddle.nn.functional.one_hot( feat_labels, self.cls_out_channels + 1) feat_labels_one_hot = feat_labels_one_hot[:, 1:] feat_labels_one_hot.stop_gradient = True num_total_samples = paddle.to_tensor( num_total_samples, dtype='float32', stop_gradient=True) odm_cls = F.sigmoid_focal_loss( odm_cls_score1, feat_labels_one_hot, normalizer=num_total_samples, reduction='none') feat_label_weights = feat_label_weights.reshape( feat_label_weights.shape[0], 1) feat_label_weights = np.repeat( feat_label_weights, self.cls_out_channels, axis=1) feat_label_weights = paddle.to_tensor(feat_label_weights) feat_label_weights.stop_gradient = True odm_cls = odm_cls * feat_label_weights odm_cls_total = paddle.sum(odm_cls) odm_cls_losses.append(odm_cls_total) # # step3: regression loss feat_bbox_targets = paddle.to_tensor( feat_bbox_targets, dtype='float32') feat_bbox_targets = paddle.reshape(feat_bbox_targets, [-1, 5]) feat_bbox_targets.stop_gradient = True odm_bbox_pred = odm_reg_branch_list[idx] odm_bbox_pred = paddle.squeeze(odm_bbox_pred, axis=0) odm_bbox_pred = paddle.reshape(odm_bbox_pred, [-1, 5]) odm_bbox = self.smooth_l1_loss(odm_bbox_pred, feat_bbox_targets) loss_weight = paddle.to_tensor( self.reg_loss_weight, dtype='float32', stop_gradient=True) odm_bbox = paddle.multiply(odm_bbox, loss_weight) feat_bbox_weights = paddle.to_tensor( feat_bbox_weights, stop_gradient=True) if reg_loss_type == 'l1': odm_bbox = odm_bbox * feat_bbox_weights odm_bbox_total = paddle.sum(odm_bbox) / num_total_samples elif reg_loss_type == 'iou' or reg_loss_type == 'gwd': odm_bbox = paddle.sum(odm_bbox, axis=-1) feat_bbox_weights = paddle.sum(feat_bbox_weights, axis=-1) try: from rbox_iou_ops import rbox_iou except Exception as e: print("import custom_ops error, try install rbox_iou_ops " \ "following ppdet/ext_op/README.md", e) sys.stdout.flush() sys.exit(-1) # calc iou odm_bbox_decode = self.delta2rbox(self.refine_anchor_list[idx], odm_bbox_pred) bbox_gt_bboxes = paddle.to_tensor( bbox_gt_bboxes, dtype=odm_bbox_decode.dtype, place=odm_bbox_decode.place) bbox_gt_bboxes.stop_gradient = True iou = rbox_iou(odm_bbox_decode, bbox_gt_bboxes) iou = paddle.diag(iou) if reg_loss_type == 'gwd': bbox_gt_bboxes_level = bbox_gt_bboxes[st_idx:st_idx + feat_anchor_num, :] odm_bbox_total = self.gwd_loss(odm_bbox_decode, bbox_gt_bboxes_level) odm_bbox_total = odm_bbox_total * feat_bbox_weights odm_bbox_total = paddle.sum(odm_bbox_total) / num_total_samples odm_bbox_losses.append(odm_bbox_total) st_idx += feat_anchor_num odm_cls_loss = paddle.add_n(odm_cls_losses) odm_cls_loss_weight = paddle.to_tensor( self.cls_loss_weight[1], dtype='float32', stop_gradient=True) odm_cls_loss = odm_cls_loss * odm_cls_loss_weight odm_reg_loss = paddle.add_n(odm_bbox_losses) return odm_cls_loss, odm_reg_loss
def gcl_loss(self, z_2d, z_3d): z_2d = self.projection_2d(z_2d) z_3d = self.projection_3d(z_3d) f = lambda x: paddle.exp(x / self.gcl_tau) between_sim = f(self.sim(z_2d, z_3d)) return -paddle.log(paddle.diag(between_sim) / between_sim.sum(1))-paddle.log(paddle.diag(between_sim) / between_sim.sum(0))
def diag(x): return convertTensor(paddle.diag(x, offset=0, padding_value=0, name=None))
def get_loss(self, head_outs, targets): pred_cls, pred_bboxes, pred_obj,\ anchor_points, stride_tensor, num_anchors_list = head_outs gt_labels = targets['gt_class'] gt_bboxes = targets['gt_bbox'] pred_scores = (pred_cls * pred_obj).sqrt() # label assignment center_and_strides = paddle.concat( [anchor_points, stride_tensor, stride_tensor], axis=-1) pos_num_list, label_list, bbox_target_list = [], [], [] for pred_score, pred_bbox, gt_box, gt_label in zip( pred_scores.detach(), pred_bboxes.detach() * stride_tensor, gt_bboxes, gt_labels): pos_num, label, _, bbox_target = self.assigner( pred_score, center_and_strides, pred_bbox, gt_box, gt_label) pos_num_list.append(pos_num) label_list.append(label) bbox_target_list.append(bbox_target) labels = paddle.to_tensor(np.stack(label_list, axis=0)) bbox_targets = paddle.to_tensor(np.stack(bbox_target_list, axis=0)) bbox_targets /= stride_tensor # rescale bbox # 1. obj score loss mask_positive = (labels != self.num_classes) loss_obj = F.binary_cross_entropy(pred_obj, mask_positive.astype( pred_obj.dtype).unsqueeze(-1), reduction='sum') num_pos = sum(pos_num_list) if num_pos > 0: num_pos = paddle.to_tensor(num_pos, dtype=self._dtype).clip(min=1) loss_obj /= num_pos # 2. iou loss bbox_mask = mask_positive.unsqueeze(-1).tile([1, 1, 4]) pred_bboxes_pos = paddle.masked_select(pred_bboxes, bbox_mask).reshape([-1, 4]) assigned_bboxes_pos = paddle.masked_select( bbox_targets, bbox_mask).reshape([-1, 4]) bbox_iou = bbox_overlaps(pred_bboxes_pos, assigned_bboxes_pos) bbox_iou = paddle.diag(bbox_iou) loss_iou = self.iou_loss(pred_bboxes_pos.split(4, axis=-1), assigned_bboxes_pos.split(4, axis=-1)) loss_iou = loss_iou.sum() / num_pos # 3. cls loss cls_mask = mask_positive.unsqueeze(-1).tile( [1, 1, self.num_classes]) pred_cls_pos = paddle.masked_select(pred_cls, cls_mask).reshape( [-1, self.num_classes]) assigned_cls_pos = paddle.masked_select(labels, mask_positive) assigned_cls_pos = F.one_hot(assigned_cls_pos, self.num_classes + 1)[..., :-1] assigned_cls_pos *= bbox_iou.unsqueeze(-1) loss_cls = F.binary_cross_entropy(pred_cls_pos, assigned_cls_pos, reduction='sum') loss_cls /= num_pos # 4. l1 loss if targets['epoch_id'] >= self.l1_epoch: loss_l1 = F.l1_loss(pred_bboxes_pos, assigned_bboxes_pos, reduction='sum') loss_l1 /= num_pos else: loss_l1 = paddle.zeros([1]) loss_l1.stop_gradient = False else: loss_cls = paddle.zeros([1]) loss_iou = paddle.zeros([1]) loss_l1 = paddle.zeros([1]) loss_cls.stop_gradient = False loss_iou.stop_gradient = False loss_l1.stop_gradient = False loss = self.loss_weight['obj'] * loss_obj + \ self.loss_weight['cls'] * loss_cls + \ self.loss_weight['iou'] * loss_iou if targets['epoch_id'] >= self.l1_epoch: loss += (self.loss_weight['l1'] * loss_l1) yolox_losses = { 'loss': loss, 'loss_cls': loss_cls, 'loss_obj': loss_obj, 'loss_iou': loss_iou, 'loss_l1': loss_l1, } return yolox_losses
def fill_diagonal(self,value,wrap=False): diag_v = paddle.diag(self) diag_v = torch.mm(paddle.eye(self.shape[0], self.shape[1]), paddle.expand_as(diag_v, self)+value) return self-diag_v