def forward(self, pred, target, weight=None):
losses = -1.0 * (target * F.log(pred) +
(1.0 - target) * F.log(1 - pred))
if weight is not None:
return (losses * weight).sum()
else:
return losses.sum()
def get_focal_loss(
score: Tensor,
label: Tensor,
ignore_label: int = -1,
background: int = 0,
alpha: float = 0.5,
gamma: float = 0,
norm_type: str = "fg",
) -> Tensor:
r"""Focal Loss for Dense Object Detection:
<https://arxiv.org/pdf/1708.02002.pdf>
.. math::
FL(p_t) = -\alpha_t(1-p_t)^\gamma \log(p_t)
Args:
score (Tensor):
the predicted score with the shape of :math:`(B, A, C)`
label (Tensor):
the assigned label of boxes with shape of :math:`(B, A)`
ignore_label (int):
the value of ignore class. Default: -1
background (int):
the value of background class. Default: 0
alpha (float):
parameter to mitigate class imbalance. Default: 0.5
gamma (float):
parameter to mitigate easy/hard loss imbalance. Default: 0
norm_type (str): current support 'fg', 'none':
'fg': loss will be normalized by number of fore-ground samples
'none": not norm
Returns:
the calculated focal loss.
"""
class_range = F.arange(1, score.shape[2] + 1)
label = F.add_axis(label, axis=2)
pos_part = (1 - score)**gamma * F.log(score)
neg_part = score**gamma * F.log(1 - score)
pos_loss = -(label == class_range) * pos_part * alpha
neg_loss = -(label != class_range) * (label != ignore_label) * neg_part * (
1 - alpha)
loss = pos_loss + neg_loss
if norm_type == "fg":
fg_mask = (label != background) * (label != ignore_label)
return loss.sum() / F.maximum(fg_mask.sum(), 1)
elif norm_type == "none":
return loss.sum()
else:
raise NotImplementedError
def calculate_psnr(im1, im2, border=0):
if not im1.shape == im2.shape:
raise ValueError('Input images must have the same dimensions.')
h, w = im1.shape[:2]
im1 = im1[border:h - border, border:w - border]
im2 = im2[border:h - border, border:w - border]
mse = F.mean((im1 - im2)**2)
if mse == 0:
return float('inf')
return 10 * F.log(1.0 / mse) / F.log(10.)
def encode(self, bbox: Tensor, gt: Tensor) -> Tensor:
bbox_width, bbox_height, bbox_ctr_x, bbox_ctr_y = self._box_ltrb_to_cs_opr(bbox)
gt_width, gt_height, gt_ctr_x, gt_ctr_y = self._box_ltrb_to_cs_opr(gt)
target_dx = (gt_ctr_x - bbox_ctr_x) / bbox_width
target_dy = (gt_ctr_y - bbox_ctr_y) / bbox_height
target_dw = F.log(gt_width / bbox_width)
target_dh = F.log(gt_height / bbox_height)
target = F.stack([target_dx, target_dy, target_dw, target_dh], axis=1)
target -= self.reg_mean
target /= self.reg_std
return target
def forward(self, input):
"""
Forward pass of the function.
"""
return (1 / self.alpha) * F.log(
(1 + F.exp(self.alpha * input)) / (1 + F.exp(self.alpha * (input - 1)))
)
def _bce_loss_with_logits(output, labels, **kwargs):
r"""
Sigmoid cross entropy with logits, see tensorflow
https://www.tensorflow.org/api_docs/python/tf/nn/sigmoid_cross_entropy_with_logits
"""
loss = F.maximum(output, 0) - output * labels + F.log(1 + F.exp(-F.abs(output)))
return loss.mean()
def roi_pool(
rpn_fms,
rois,
stride,
pool_shape,
pooler_type="roi_align",
):
rois = rois.detach()
assert len(stride) == len(rpn_fms)
canonical_level = 4
canonical_box_size = 224
min_level = int(math.log2(stride[0]))
max_level = int(math.log2(stride[-1]))
num_fms = len(rpn_fms)
box_area = (rois[:, 3] - rois[:, 1]) * (rois[:, 4] - rois[:, 2])
assigned_level = F.floor(canonical_level +
F.log(F.sqrt(box_area) / canonical_box_size) /
np.log(2)).astype("int32")
assigned_level = F.minimum(assigned_level, max_level)
assigned_level = F.maximum(assigned_level, min_level)
assigned_level = assigned_level - min_level
# avoid empty assignment
assigned_level = F.concat([
assigned_level,
F.arange(num_fms, dtype="int32", device=assigned_level.device)
], )
rois = F.concat([rois, F.zeros((num_fms, rois.shape[-1]))])
pool_list, inds_list = [], []
for i in range(num_fms):
_, inds = F.cond_take(assigned_level == i, assigned_level)
level_rois = rois[inds]
if pooler_type == "roi_pool":
pool_fm = F.nn.roi_pooling(rpn_fms[i],
level_rois,
pool_shape,
mode="max",
scale=1.0 / stride[i])
elif pooler_type == "roi_align":
pool_fm = F.nn.roi_align(
rpn_fms[i],
level_rois,
pool_shape,
mode="average",
spatial_scale=1.0 / stride[i],
sample_points=2,
aligned=True,
)
pool_list.append(pool_fm)
inds_list.append(inds)
fm_order = F.argsort(F.concat(inds_list, axis=0))
pool_feature = F.concat(pool_list, axis=0)
pool_feature = pool_feature[fm_order][:-num_fms]
return pool_feature
def encode(self, bbox: Tensor, gt: Tensor) -> Tensor:
(bbox_width, bbox_height, bbox_ctr_x, bbox_ctr_y,) = self._box_ltrb_to_cs_opr(
bbox
)
gt_width, gt_height, gt_ctr_x, gt_ctr_y = self._box_ltrb_to_cs_opr(gt)
target_dx = (gt_ctr_x - bbox_ctr_x) / bbox_width
target_dy = (gt_ctr_y - bbox_ctr_y) / bbox_height
target_dw = F.log(gt_width / bbox_width)
target_dh = F.log(gt_height / bbox_height)
target = self._concat_new_axis(target_dx, target_dy, target_dw, target_dh)
if self.reg_mean is not None:
target -= self.reg_mean
if self.reg_std is not None:
target /= self.reg_std
return target
def softmax_loss(pred, label, ignore_label=-1):
max_pred = F.zero_grad(pred.max(axis=1, keepdims=True))
pred -= max_pred
log_prob = pred - F.log(F.exp(pred).sum(axis=1, keepdims=True))
mask = 1 - F.equal(label, ignore_label)
vlabel = label * mask
loss = -(F.indexing_one_hot(log_prob, vlabel, 1) * mask)
return loss
def roi_pool(
rpn_fms,
rois,
stride,
pool_shape,
roi_type="roi_align",
):
assert len(stride) == len(rpn_fms)
canonical_level = 4
canonical_box_size = 224
min_level = math.log2(stride[0])
max_level = math.log2(stride[-1])
num_fms = len(rpn_fms)
box_area = (rois[:, 3] - rois[:, 1]) * (rois[:, 4] - rois[:, 2])
level_assignments = F.floor(canonical_level +
F.log(box_area.sqrt() / canonical_box_size) /
np.log(2))
level_assignments = F.minimum(level_assignments, max_level)
level_assignments = F.maximum(level_assignments, min_level)
level_assignments = level_assignments - min_level
# avoid empty assignment
level_assignments = F.concat(
[level_assignments,
mge.tensor(np.arange(num_fms, dtype=np.int32))], )
rois = F.concat([rois, mge.zeros((num_fms, rois.shapeof(-1)))])
pool_list, inds_list = [], []
for i in range(num_fms):
mask = level_assignments == i
_, inds = F.cond_take(mask == 1, mask)
level_rois = rois.ai[inds]
if roi_type == "roi_pool":
pool_fm = F.roi_pooling(rpn_fms[i],
level_rois,
pool_shape,
mode="max",
scale=1.0 / stride[i])
elif roi_type == "roi_align":
pool_fm = F.roi_align(
rpn_fms[i],
level_rois,
pool_shape,
mode="average",
spatial_scale=1.0 / stride[i],
sample_points=2,
aligned=True,
)
pool_list.append(pool_fm)
inds_list.append(inds)
fm_order = F.concat(inds_list, axis=0)
fm_order = F.argsort(fm_order.reshape(1, -1))[1].reshape(-1)
pool_feature = F.concat(pool_list, axis=0)
pool_feature = pool_feature.ai[fm_order][:-num_fms]
return pool_feature
def softmax_loss(score, label, ignore_label=-1):
max_score = F.zero_grad(score.max(axis=1, keepdims=True))
score -= max_score
log_prob = score - F.log(F.exp(score).sum(axis=1, keepdims=True))
mask = (label != ignore_label)
vlabel = label * mask
loss = -(F.indexing_one_hot(log_prob, vlabel.astype("int32"), 1) *
mask).sum()
loss = loss / F.maximum(mask.sum(), 1)
return loss
def softmax_loss_opr(pred, label, ignore_label=-1):
max_pred = pred.max(axis=1, keepdims=True).detach()
pred -= max_pred
log_prob = pred - F.log(F.exp(pred).sum(axis=1, keepdims=True))
mask = 1 - F.equal(label, ignore_label)
vlabel = label * mask.astype(np.float32)
loss = -(F.nn.indexing_one_hot(log_prob, vlabel.astype(np.int32),
1).flatten() * mask)
return loss
def softmax_cross_entropy(pred, label, axis=1, ignore_index=255):
offset = F.zero_grad(pred.max(axis=axis, keepdims=True))
pred = pred - offset
log_prob = pred - F.log(F.exp(pred).sum(axis=axis, keepdims=True))
mask = 1 - F.equal(label, ignore_index)
vlabel = label * mask
loss = -(F.indexing_one_hot(log_prob, vlabel, axis) *
mask).sum() / F.maximum(mask.sum(), 1)
return loss
def bbox_transform_opr(bbox, gt):
""" Transform the bounding box and ground truth to the loss targets.
The 4 box coordinates are in axis 1"""
bbox_width = bbox[:, 2] - bbox[:, 0] + 1
bbox_height = bbox[:, 3] - bbox[:, 1] + 1
bbox_ctr_x = bbox[:, 0] + 0.5 * bbox_width
bbox_ctr_y = bbox[:, 1] + 0.5 * bbox_height
gt_width = gt[:, 2] - gt[:, 0] + 1
gt_height = gt[:, 3] - gt[:, 1] + 1
gt_ctr_x = gt[:, 0] + 0.5 * gt_width
gt_ctr_y = gt[:, 1] + 0.5 * gt_height
target_dx = (gt_ctr_x - bbox_ctr_x) / bbox_width
target_dy = (gt_ctr_y - bbox_ctr_y) / bbox_height
target_dw = F.log(gt_width / bbox_width)
target_dh = F.log(gt_height / bbox_height)
target = F.stack([target_dx, target_dy, target_dw, target_dh], axis=1)
return target
def forward(self, x):
"""
Forward pass of the function
"""
if self.alpha == 0.0:
return x
if self.alpha < 0.0:
return -F.log(1 - self.alpha * (x + self.alpha)) / self.alpha
if self.alpha > 0.0:
return (F.exp(self.alpha * x) - 1) / self.alpha + self.alpha
def softmax_loss(scores: Tensor,
labels: Tensor,
ignore_label: int = -1) -> Tensor:
max_scores = F.zero_grad(scores.max(axis=1, keepdims=True))
scores -= max_scores
log_prob = scores - F.log(F.exp(scores).sum(axis=1, keepdims=True))
mask = labels != ignore_label
vlabels = labels * mask
loss = -(F.indexing_one_hot(log_prob, vlabels.astype("int32"), 1) *
mask).sum()
loss = loss / F.maximum(mask.sum(), 1)
return loss
def ns_loss_gen(output_fake):
r"""
Non-saturating loss for generator.
Args:
output_fake (Tensor): Discriminator output logits for fake images.
Returns:
Tensor: A scalar tensor loss output.
"""
output_fake = F.sigmoid(output_fake)
return -F.log(output_fake + 1e-8).mean()
def roi_pool(rpn_fms, rois, stride, pool_shape, roi_type='roi_align',
labels=None, bbox_targets=None):
assert len(stride) == len(rpn_fms)
canonical_level = 4
canonical_box_size = 224
min_level = math.log2(stride[0])
max_level = math.log2(stride[-1])
num_fms = len(rpn_fms)
box_sizes = F.sqrt((rois[:, 3] - rois[:, 1]) * (rois[:, 4] - rois[:, 2]))
level_assignments = F.floor(
canonical_level + F.log(box_sizes / canonical_box_size) / np.log(2)
)
level_assignments = F.minimum(level_assignments, max_level)
level_assignments = F.maximum(level_assignments, min_level)
level_assignments = level_assignments - min_level
available_masks = F.concat(
[mge.ones(level_assignments.shapeof()[0]), mge.zeros(num_fms)], axis=0)
level_assignments = F.concat([level_assignments, mge.tensor(np.arange(num_fms, dtype=np.int32))], axis=0)
rois = F.concat([rois, mge.zeros((num_fms, rois.shapeof()[-1]))], axis=0)
if labels is not None:
labels = F.concat([labels, mge.ones((num_fms, labels.shapeof()[-1]))], axis=0)
bbox_targets = F.concat([bbox_targets, mge.zeros((num_fms, bbox_targets.shapeof()[-1]))], axis=0)
pool_list, inds_list = [], []
for i in range(len(rpn_fms)):
mask = level_assignments == i
inds = mask_to_inds(mask)
rois_fm = rois.ai[inds]
if roi_type == 'roi_pool':
pool_fm = F.roi_pooling(
rpn_fms[i], rois_fm, pool_shape, mode='max', scale=1.0/stride[i])
elif roi_type == 'roi_align':
pool_fm = F.roi_align(
rpn_fms[i], rois_fm, pool_shape, mode='average',
spatial_scale=1.0/stride[i], sample_points=2, aligned=True)
pool_list.append(pool_fm)
inds_list.append(inds)
fm_order = F.concat(inds_list, axis=0)
pool_feature = F.concat(pool_list, axis=0)
ordered_available_masks = available_masks.ai[fm_order]
available_inds = mask_to_inds(ordered_available_masks)
pool_feature = pool_feature.ai[available_inds]
rois = rois.ai[fm_order, :].ai[available_inds, :]
if labels is not None:
labels = labels.ai[fm_order].ai[available_inds]
bbox_targets = bbox_targets.ai[fm_order, :].ai[available_inds, :]
return pool_feature, rois, F.zero_grad(labels), F.zero_grad(bbox_targets)
else:
return pool_feature, rois, None, None
def sigmoid_cross_entropy_retina(pred,
label,
ignore_label=-1,
background=0,
alpha=0.5,
gamma=0):
device = pred.device
mask = 1 - F.equal(label, ignore_label).astype(np.float32)
vlabel = label * mask
n, m, c = pred.shape
zero_mat = F.zeros([n, m, c + 1]).to(device)
index = F.expand_dims(vlabel, 2).astype(np.int32)
one_hot = F.scatter(zero_mat, 2, index, F.ones([n, m, 1]))
onehot = one_hot[:, :, 1:]
pos_part = F.pow(1 - pred, gamma) * onehot * F.log(pred)
neg_part = F.pow(pred, gamma) * (1 - onehot) * F.log(1 - pred)
loss = -(alpha * pos_part + (1 - alpha) * neg_part).sum(axis=2) * mask
positive_mask = (label > 0)
return loss.sum() / F.maximum(positive_mask.sum(), 1)
def forward(self, pred, target, weight=None):
"""
pred: (B*H*W, 4)
weight: (B*H*W, )
"""
pred_left = pred[:, 1]
pred_top = pred[:, 0]
pred_right = pred[:, 3]
pred_bottom = pred[:, 2]
target_left = target[:, 1]
target_top = target[:, 0]
target_right = target[:, 3]
target_bottom = target[:, 2]
target_aera = (target_left + target_right) * (target_top +
target_bottom)
pred_aera = (pred_left + pred_right) * (pred_top + pred_bottom)
w_intersect = F.minimum(pred_left, target_left) + F.minimum(
pred_right, target_right)
h_intersect = F.minimum(pred_bottom, target_bottom) + F.minimum(
pred_top, target_top)
g_w_intersect = F.maximum(pred_left, target_left) + F.maximum(
pred_right, target_right)
g_h_intersect = F.maximum(pred_bottom, target_bottom) + F.maximum(
pred_top, target_top)
ac_uion = g_w_intersect * g_h_intersect
area_intersect = w_intersect * h_intersect
area_union = target_aera + pred_aera - area_intersect
ious = (area_intersect + 1.0) / (area_union + 1.0)
gious = ious - (ac_uion - area_union) / ac_uion
if self.loc_loss_type == 'iou':
losses = -F.log(ious)
elif self.loc_loss_type == 'linear_iou':
losses = 1 - ious
elif self.loc_loss_type == 'giou':
losses = 1 - gious
else:
raise NotImplementedError
if weight is not None:
return (losses * weight).sum()
else:
return losses.sum()
def iou_loss(
pred: Tensor, target: Tensor, box_mode: str = "xyxy", loss_type: str = "iou", eps: float = 1e-8,
) -> Tensor:
if box_mode == "ltrb":
pred = F.concat([-pred[..., :2], pred[..., 2:]], axis=-1)
target = F.concat([-target[..., :2], target[..., 2:]], axis=-1)
elif box_mode != "xyxy":
raise NotImplementedError
pred_area = F.maximum(pred[..., 2] - pred[..., 0], 0) * F.maximum(
pred[..., 3] - pred[..., 1], 0
)
target_area = F.maximum(target[..., 2] - target[..., 0], 0) * F.maximum(
target[..., 3] - target[..., 1], 0
)
w_intersect = F.maximum(
F.minimum(pred[..., 2], target[..., 2]) - F.maximum(pred[..., 0], target[..., 0]), 0
)
h_intersect = F.maximum(
F.minimum(pred[..., 3], target[..., 3]) - F.maximum(pred[..., 1], target[..., 1]), 0
)
area_intersect = w_intersect * h_intersect
area_union = pred_area + target_area - area_intersect
ious = area_intersect / F.maximum(area_union, eps)
if loss_type == "iou":
loss = -F.log(F.maximum(ious, eps))
elif loss_type == "linear_iou":
loss = 1 - ious
elif loss_type == "giou":
g_w_intersect = F.maximum(pred[..., 2], target[..., 2]) - F.minimum(
pred[..., 0], target[..., 0]
)
g_h_intersect = F.maximum(pred[..., 3], target[..., 3]) - F.minimum(
pred[..., 1], target[..., 1]
)
ac_union = g_w_intersect * g_h_intersect
gious = ious - (ac_union - area_union) / F.maximum(ac_union, eps)
loss = 1 - gious
return loss
def forward(self, a):
# add
if self.mode == "add":
x = a + mge.tensor(np.float32(10))
y = a + mge.tensor(self.data1)
z = x + y
# sub
elif self.mode == "sub":
x = a - mge.tensor(np.float32(10))
y = a - mge.tensor(self.data1)
z = x - y
# mul
elif self.mode == "mul":
x = a * mge.tensor(np.float32(10))
y = mge.tensor(self.data1) * a
z = x * y
# div
elif self.mode == "div":
y = mge.tensor(self.data1) / a
x = a / mge.tensor(np.float32(2))
z = y / x
# cycle_div
elif self.mode == "cycle_div":
z = a / mge.tensor(self.data1)
# abs
elif self.mode == "abs":
z = F.abs(a)
# exp
elif self.mode == "exp":
z = F.exp(a)
# log
elif self.mode == "log":
z = F.log(a)
else:
raise NotImplementedError('no such elemwise mode "%s"' % self.mode)
return z
def get_focal_loss(
score: Tensor,
label: Tensor,
ignore_label: int = -1,
background: int = 0,
alpha: float = 0.5,
gamma: float = 0,
norm_type: str = "fg",
) -> Tensor:
r"""Focal Loss for Dense Object Detection:
<https://arxiv.org/pdf/1708.02002.pdf>
.. math::
FL(p_t) = -\alpha_t(1-p_t)^\gamma \log(p_t)
Args:
score (Tensor):
the predicted score with the shape of :math:`(B, A, C)`
label (Tensor):
the assigned label of boxes with shape of :math:`(B, A)`
ignore_label (int):
the value of ignore class. Default: -1
background (int):
the value of background class. Default: 0
alpha (float):
parameter to mitigate class imbalance. Default: 0.5
gamma (float):
parameter to mitigate easy/hard loss imbalance. Default: 0
norm_type (str): current support 'fg', 'none':
'fg': loss will be normalized by number of fore-ground samples
'none": not norm
Returns:
the calculated focal loss.
"""
mask = 1 - (label == ignore_label)
valid_label = label * mask
score_shp = score.shape
zero_mat = mge.zeros(
F.concat([score_shp[0], score_shp[1], score_shp[2] + 1], axis=0),
dtype=np.float32,
)
one_mat = mge.ones(
F.concat([score_shp[0], score_shp[1], tensor(1)], axis=0), dtype=np.float32,
)
one_hot = basic.indexing_set_one_hot(
zero_mat, 2, valid_label.astype(np.int32), one_mat
)[:, :, 1:]
pos_part = F.power(1 - score, gamma) * one_hot * F.log(score)
neg_part = F.power(score, gamma) * (1 - one_hot) * F.log(1 - score)
loss = -(alpha * pos_part + (1 - alpha) * neg_part).sum(axis=2) * mask
if norm_type == "fg":
positive_mask = label > background
return loss.sum() / F.maximum(positive_mask.sum(), 1)
elif norm_type == "none":
return loss.sum()
else:
raise NotImplementedError
def safelog(x, eps=None):
if eps is None:
eps = np.finfo(x.dtype).eps
return F.log(F.maximum(x, eps))
def forward(self, a):
# add
if self.mode == "add":
x = a + mge.tensor(np.float32(10))
y = a + mge.tensor(self.data1)
z = x + y
# sub
elif self.mode == "sub":
x = a - mge.tensor(np.float32(10))
y = a - mge.tensor(self.data1)
z = x - y
# mul
elif self.mode == "mul":
x = a * mge.tensor(np.float32(10))
y = mge.tensor(self.data1) * a
z = x * y
# div
elif self.mode == "max":
x = a + mge.tensor(self.data)
y = a + mge.tensor(self.data2)
z = F.maximum(x, y)
elif self.mode == "min":
x = a + mge.tensor(self.data)
y = a + mge.tensor(self.data2)
z = F.minimum(x, y)
elif self.mode == "pow":
z = a**2
elif self.mode == "ceil":
z = F.ceil(a)
elif self.mode == "floor":
z = F.floor(a)
elif self.mode == "div":
y = mge.tensor(self.data1) / a
x = a / mge.tensor(np.float32(2))
z = y / x
# cycle_div
elif self.mode == "cycle_div":
z = a / mge.tensor(self.data1)
# abs
elif self.mode == "abs":
z = F.abs(a)
# exp
elif self.mode == "exp":
z = F.exp(a)
# log
elif self.mode == "log":
z = F.log(a)
elif self.mode == "fuse_add_relu":
y = a + mge.tensor(self.data2)
z = F.relu(y)
elif self.mode == "fuse_mul_add3":
y = a * mge.tensor(self.data1)
z = y + mge.tensor(self.data2)
elif self.mode == "fuse_add_sigmoid":
y = a + mge.tensor(self.data2)
z = F.sigmoid(y)
else:
raise NotImplementedError('no such elemwise mode "%s"' % self.mode)
return z
def get_kl_divergence(mean, var):
return 1 / 2 * (mean**2 + var - F.log(var) - 1).sum(axis=1).mean()
def g(x):
return log(exp(x))
def f(x):
return log(exp(x))
def g(x, y):
return log(exp(x) + exp(y))
def softplus(x: Tensor) -> Tensor:
return F.log(1 + F.exp(-F.abs(x))) + F.relu(x)
