Spaces:
Runtime error
Runtime error
File size: 5,057 Bytes
3b96cb1 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 |
# Copyright (c) OpenMMLab. All rights reserved.
from typing import Optional, Tuple, Union
import numpy as np
import torch
from mmengine.model import BaseModule
from torch import Tensor
from mmdet.registry import MODELS
from .utils import weighted_loss
@weighted_loss
def l2_loss(pred: Tensor, target: Tensor) -> Tensor:
"""L2 loss.
Args:
pred (torch.Tensor): The prediction.
target (torch.Tensor): The learning target of the prediction.
Returns:
torch.Tensor: Calculated loss
"""
assert pred.size() == target.size()
loss = torch.abs(pred - target)**2
return loss
@MODELS.register_module()
class L2Loss(BaseModule):
"""L2 loss.
Args:
reduction (str, optional): The method to reduce the loss.
Options are "none", "mean" and "sum".
loss_weight (float, optional): The weight of loss.
"""
def __init__(self,
neg_pos_ub: int = -1,
pos_margin: float = -1,
neg_margin: float = -1,
hard_mining: bool = False,
reduction: str = 'mean',
loss_weight: float = 1.0):
super(L2Loss, self).__init__()
self.neg_pos_ub = neg_pos_ub
self.pos_margin = pos_margin
self.neg_margin = neg_margin
self.hard_mining = hard_mining
self.reduction = reduction
self.loss_weight = loss_weight
def forward(self,
pred: Tensor,
target: Tensor,
weight: Optional[Tensor] = None,
avg_factor: Optional[float] = None,
reduction_override: Optional[str] = None) -> Tensor:
"""Forward function.
Args:
pred (torch.Tensor): The prediction.
target (torch.Tensor): The learning target of the prediction.
weight (torch.Tensor, optional): The weight of loss for each
prediction. Defaults to None.
avg_factor (float, optional): Average factor that is used to
average the loss. Defaults to None.
reduction_override (str, optional): The reduction method used to
override the original reduction method of the loss.
Defaults to None.
"""
assert reduction_override in (None, 'none', 'mean', 'sum')
reduction = (
reduction_override if reduction_override else self.reduction)
pred, weight, avg_factor = self.update_weight(pred, target, weight,
avg_factor)
loss_bbox = self.loss_weight * l2_loss(
pred, target, weight, reduction=reduction, avg_factor=avg_factor)
return loss_bbox
def update_weight(self, pred: Tensor, target: Tensor, weight: Tensor,
avg_factor: float) -> Tuple[Tensor, Tensor, float]:
"""Update the weight according to targets."""
if weight is None:
weight = target.new_ones(target.size())
invalid_inds = weight <= 0
target[invalid_inds] = -1
pos_inds = target == 1
neg_inds = target == 0
if self.pos_margin > 0:
pred[pos_inds] -= self.pos_margin
if self.neg_margin > 0:
pred[neg_inds] -= self.neg_margin
pred = torch.clamp(pred, min=0, max=1)
num_pos = int((target == 1).sum())
num_neg = int((target == 0).sum())
if self.neg_pos_ub > 0 and num_neg / (num_pos +
1e-6) > self.neg_pos_ub:
num_neg = num_pos * self.neg_pos_ub
neg_idx = torch.nonzero(target == 0, as_tuple=False)
if self.hard_mining:
costs = l2_loss(
pred, target, reduction='none')[neg_idx[:, 0],
neg_idx[:, 1]].detach()
neg_idx = neg_idx[costs.topk(num_neg)[1], :]
else:
neg_idx = self.random_choice(neg_idx, num_neg)
new_neg_inds = neg_inds.new_zeros(neg_inds.size()).bool()
new_neg_inds[neg_idx[:, 0], neg_idx[:, 1]] = True
invalid_neg_inds = torch.logical_xor(neg_inds, new_neg_inds)
weight[invalid_neg_inds] = 0
avg_factor = (weight > 0).sum()
return pred, weight, avg_factor
@staticmethod
def random_choice(gallery: Union[list, np.ndarray, Tensor],
num: int) -> np.ndarray:
"""Random select some elements from the gallery.
It seems that Pytorch's implementation is slower than numpy so we use
numpy to randperm the indices.
"""
assert len(gallery) >= num
if isinstance(gallery, list):
gallery = np.array(gallery)
cands = np.arange(len(gallery))
np.random.shuffle(cands)
rand_inds = cands[:num]
if not isinstance(gallery, np.ndarray):
rand_inds = torch.from_numpy(rand_inds).long().to(gallery.device)
return gallery[rand_inds]
|