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
