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)