文章目录
- 模型损失计算
- 1. 分类损失构建
- 1.1 分类损失函数：SigmoidFocalClassificationLoss
- 2. 回归损失构建
- 2.1 回归损失函数：WeightedSmoothL1Loss
- 3. 角度损失构建
- 3.1 角度损失函数：WeightedCrossEntropyLoss
- 4. 总结
模型损失计算
在进行anchor的正负样本分配后，具体来说就是对iou最大以及满足阈值的anchor进行相应的类别分配以及gt编码信息分配，以及正样本的权重分配，最后的所有预测信息以及anchor分配信息保存在self.forward_ret_dict这个字典中，现在就是利用这个字典来进行损失的计算。
在调用PointPillars算法的get_training_loss函数时，最后是根据dense_head结构中的get_loss函数来实现的。主要是两个函数：self.get_cls_layer_loss() 和 self.get_box_reg_layer_loss()。分别计算分类损失以及回归损失。其中self.get_box_reg_layer_loss()中还包括了角方向的分类损失。
结构图如下所示：
下面分别介绍PointPillars算法的是分类损失、回归损失、角度损失的构建。
1. 分类损失构建
首先，对于现在分配好的正负样本anchor，需要为前景anchor和背景anchor设置其分类。其中labels中如果>0的则为正样本的anchor，<0的则为背景anchor。这里对于前景还是背景的anchor分类损失权重都设置为1。而对于那些在正负样本之间的阈值分类权重设置为0.
cls_preds = self.forward_ret_dict['cls_preds'] # (16, 248, 216, 18) 网络类别预测
box_cls_labels = self.forward_ret_dict['box_cls_labels'] # (16,321408) 前景anchor类别
batch_size = int(cls_preds.shape[0]) # 16
cared = box_cls_labels >= 0 # 关心的anchor (16,321408)
positives = box_cls_labels > 0 # 前景anchor (16,321408)
negatives = box_cls_labels == 0 # 背景anchor (16,321408)
negative_cls_weights = negatives * 1.0 # 背景anchor赋予权重
cls_weights = (negative_cls_weights + 1.0 * positives).float() # 背景 + 前景权重=分类损失权重，这里其实前景背景anchor的分类权重都设置为1 (在阈值之间的anchor会被忽略)
reg_weights = positives.float() # 回归损失权重
不过在使用上，由于每个点云帧的正负样本比例都不一，所以还会进行一个正样本的倒数来权衡。也就是对当前的权重均除以当前点云帧前景anchor的数量。此时的权重一般均为小数，不会大于1.
# 构建正负样本的分类权重
pos_normalizer = positives.sum(1, keepdim=True).float() # 统计每个点云帧的正样本数量（截断为1，避免无法计算weight） eg:[[162.],[166.],[155.],[108.]]
cls_weights /= torch.clamp(pos_normalizer, min=1.0) # 正则化分类损失
随后，对于目标label构建其独热编码形式。比如：lable为1，那么其构造的one-hot vector为：[0,1,0,0]。由于label的第一个维度表示背景，所以需要剔除掉第一列，构建成(16, 321408, k)的大小。随后将预测的anchor label的维度也进行reshape，同样构建成(16, 321408, k)的大小，这里的k表示当前需要预测的anchor类别数量。然后送入具体的分类损失函数SigmoidFocalClassificationLoss进行具体的计算。
# 构建target的独热编码
cls_targets = box_cls_labels * cared.type_as(box_cls_labels) # (16,321408)
one_hot_targets = torch.zeros( # (16,321408,4) 零矩阵
*list(cls_targets.shape), self.num_class + 1, dtype=cls_preds.dtype, device=cls_targets.device
)
one_hot_targets.scatter_(-1, cls_targets.unsqueeze(dim=-1).long(), 1.0) # 将目标标签转换为one-hot编码形式
cls_preds = cls_preds.view(batch_size, -1, self.num_class) # (16, 248, 216, 18) --> (16, 321408, 3)
one_hot_targets = one_hot_targets[..., 1:] # 去除背景列
cls_loss_src = self.cls_loss_func(cls_preds, one_hot_targets, weights=cls_weights) # [N, M] 分类损失的计算
最后将损失函数计算到的结果除以batch_size进行归一化处理，然后保存在字典中。完成了分类损失的计算。
cls_loss = cls_loss_src.sum() / batch_size # 归一化操作
cls_loss = cls_loss * self.model_cfg.LOSS_CONFIG.LOSS_WEIGHTS['cls_weight']
tb_dict = {
'rpn_loss_cls': cls_loss.item()
}
1.1 分类损失函数：SigmoidFocalClassificationLoss
详细代码如下所示：
# 分类损失函数: cls_loss
class SigmoidFocalClassificationLoss(nn.Module):
"""
Sigmoid focal cross entropy loss.
"""
def __init__(self, gamma: float = 2.0, alpha: float = 0.25):
"""
Args:
gamma: Weighting parameter to balance loss for hard and easy examples.
alpha: Weighting parameter to balance loss for positive and negative examples.
"""
super(SigmoidFocalClassificationLoss, self).__init__()
self.alpha = alpha # 0.25
self.gamma = gamma # 2.0
@staticmethod
def sigmoid_cross_entropy_with_logits(input: torch.Tensor, target: torch.Tensor):
""" PyTorch Implementation for tf.nn.sigmoid_cross_entropy_with_logits:
max(x, 0) - x * z + log(1 + exp(-abs(x)))
in: https://www.tensorflow.org/api_docs/python/tf/nn/sigmoid_cross_entropy_with_logits
Args:
input: (B, #anchors, #classes) float tensor.
Predicted logits for each class
target: (B, #anchors, #classes) float tensor.
One-hot encoded classification targets
Returns:
loss: (B, #anchors, #classes) float tensor.
Sigmoid cross entropy loss without reduction
"""
loss = torch.clamp(input, min=0) - input * target + \
torch.log1p(torch.exp(-torch.abs(input)))
return loss
def forward(self, input: torch.Tensor, target: torch.Tensor, weights: torch.Tensor):
"""
Args:
input: (B, #anchors, #classes) float tensor. (16, 321408, 3)
Predicted logits for each class
target: (B, #anchors, #classes) float tensor. (16, 321408, 3)
One-hot encoded classification targets
weights: (B, #anchors) float tensor. (16, 321408)
Anchor-wise weights.
Returns:
weighted_loss: (B, #anchors, #classes) float tensor after weighting.
"""
pred_sigmoid = torch.sigmoid(input) # (16, 321408, 3)
alpha_weight = target * self.alpha + (1 - target) * (1 - self.alpha) # α平衡因子 (16, 321408, 3)
pt = target * (1.0 - pred_sigmoid) + (1.0 - target) * pred_sigmoid # (16, 321408, 3)
focal_weight = alpha_weight * torch.pow(pt, self.gamma) # (16, 321408, 3)
bce_loss = self.sigmoid_cross_entropy_with_logits(input, target) # (16, 321408, 3)
loss = focal_weight * bce_loss
if weights.shape.__len__() == 2 or \
(weights.shape.__len__() == 1 and target.shape.__len__() == 2):
weights = weights.unsqueeze(-1) # (16, 321408) -> (16, 321408, 1)
assert weights.shape.__len__() == loss.shape.__len__()
return loss * weights
这里的基于加权focal loss的多类交叉熵分类损失计算中，其中的focal loss是严格按照公式来实现的（一开始我看得还有点懵逼）。对input取sigmod本质上是转换为logit的操作，这是因为在网络层中的最后一层输出没有增加nn.Sigmoid，所以需要在这里补上。按照Focal loss的公式如下：
可以注意，当tagrget为1时，也就是y=1，此时的focal weight为：-α(1-y’)，对应代码中的
alpha_weight = target * self.alpha
pt = target * (1.0 - pred_sigmoid)
但target为0时，也就是y=0，此时的focal weight为：-(1-α)y’，对应代码中的
alpha_weight = (1 - target) * (1 - self.alpha)
pt = (1.0 - target) * pred_sigmoid
在这里，只是将以上的两种结果用一条公式来表示：
alpha_weight = target * self.alpha + (1 - target) * (1 - self.alpha) # α平衡因子 (16, 321408, 3)
pt = target * (1.0 - pred_sigmoid) + (1.0 - target) * pred_sigmoid # (16, 321408, 3)
对于多类交叉熵的计算，这里额外自定义了一个sigmoid_cross_entropy_with_logits函数来处理。假设x = logits, z = labels，那么其将交叉熵损失函数：z * -log(sigmoid(x)) + (1 - z) * -log(1 - sigmoid(x))；推导成：max(x, 0) - x * z + log(1 + exp(-abs(x)))。推导过程如下所示，两者是等价的，具体资料见链接：https://www.tensorflow.org/api_docs/python/tf/nn/sigmoid_cross_entropy_with_logits
随后，将focal权重与交叉熵损失相乘，便得到了focal loss，这里额外的对每个anchor进行加权处理。不过前景背景的anchor权重均为1，在阈值之间的anchor权重为0（对于car类别来说，筛选的阈值范围是0.45-0.6，小于0.45是背景anchor，大于0.6是前景anchor）。也就是说会忽略掉前景背景之外的anchor的分类损失。
2. 回归损失构建
利用同样的方法，来构建回归权重，不过这里的回归权重前景anchor为1，背景anchor为0，阈值外的anchor也设置为0。同时也除以每个点云帧的前景anchor数量来进行归一化处理。
box_cls_labels = self.forward_ret_dict['box_cls_labels']
positives = box_cls_labels > 0
reg_weights = positives.float() # 根据掩码来构建出前景权重(1)，背景权重为0
pos_normalizer = positives.sum(1, keepdim=True).float() # 正则化
reg_weights /= torch.clamp(pos_normalizer, min=1.0) # 设定一个裁剪的最小值
此时的总anchor是一个list列表，存储的是每个类别生成的anchor，现在对其进行拼接起来，然后repeat batchsize次，目的是对每个点云都分配相同的anchor。因为其中以及包含了3个类别和2个方向：(1, 248, 216, 3, 2, 7) -> (1, 321408, 7) -> (16, 321408, 7)。同时，对于每个网格点预测的anchor回归信息也进行reshape处理：(16, 248, 216, 42) -> (16, 321408, 7)。此时，预测的anchor信息和目标的anchor信息的维度就是一致的，都是 (16, 321408, 7)的大小。
anchors = torch.cat(self.anchors, dim=-3) # (1, 248, 216, 3, 2, 7)
anchors = anchors.view(1, -1, anchors.shape[-1]).repeat(batch_size, 1, 1) # 对anchor进行重复batch_size遍 (1, 248, 216, 3, 2, 7) -> (1, 321408, 7) -> (16, 321408, 7)
box_preds = box_preds.view(batch_size, -1,
box_preds.shape[-1] // self.num_anchors_per_location if not self.use_multihead else
box_preds.shape[-1]) # (16, 321408, 7)
在PointPillars算法中，继承了SECOND算法的方向损失思路。对于损失部分，SECOND对位置信息xyz以及尺寸信息whl都采用了和VoxelNet一样的方法，也就是直接回归预测，但是对于角度预测进行了改进。这是由于VoxelNet直接预测弧度偏移，但在0和π的情况下会遇到一个对立的问题，因为这两个角度对应的是同一个盒子，但当其中一个被误认为是另一个时，会产生很大的损失。这里SECOND对于角度的损失函数设置为：Lθ = SmoothL1(sin(θp − θt))。
现在对此损失函数进行分析。SmoothL1函数是偶函数，而Sin函数是奇函数。假设有两个对称的anchor对ground truth的角度偏移为-20与20。那么，先经过了奇函数再经过一个偶函数，这两个框与ground truth所得到的损失是一致的。也就是 SmoothL1(sin(20)) = SmoothL1(sin(-20))。这样就可以解决对立情况损失较大的问题，现在可以将对立损失改为一致，同时还可以根据角度偏移函数模拟出iou。但是由于两个相反方向的损失一致，如何判别正负方向。SECOND的解决方案是再输出一个direction head（方向分类器）来判别，如果anchor绕GT的z轴旋转大于0，则结果为正；否则为负。
所以，在代码中对应的sin(θp − θt)部分是通过add_sin_difference函数来实现的。在具体的相减部分是放在了具体的损失公式计算上，实现了残差项的同一操作。
@staticmethod
def add_sin_difference(boxes1, boxes2, dim=6):
"""
针对角度添加sin损失，有效防止-pi和pi方向相反时损失过大,这里只是分别构建了sina * cosb与cosa * sinb部分
但是sin(a - b) = sina * cosb - cosa * sinb公式中还存在相减的部分，这个相减的部分在WeightedSmoothL1Loss中与其他参数一同处理了
以至于不需要单独对方向进行处理
"""
assert dim != -1
rad_pred_encoding = torch.sin(boxes1[..., dim:dim + 1]) * torch.cos(boxes2[..., dim:dim + 1]) # sina * cosb (16, 321408, 1)
rad_tg_encoding = torch.cos(boxes1[..., dim:dim + 1]) * torch.sin(boxes2[..., dim:dim + 1]) # cosa * sinb (16, 321408, 1)
boxes1 = torch.cat([boxes1[..., :dim], rad_pred_encoding, boxes1[..., dim + 1:]], dim=-1) # 将sina * cosb部分替换预测的heading列 (16, 321408, 7)
boxes2 = torch.cat([boxes2[..., :dim], rad_tg_encoding, boxes2[..., dim + 1:]], dim=-1) # 将cosa * sinb替换真实编码的heading列 (16, 321408, 7)
return boxes1, boxes2
随后利用WeightedSmoothL1Loss来进行具体的回归损失计算。将计算出来的回归损失进行保存。
box_preds_sin, reg_targets_sin = self.add_sin_difference(box_preds, box_reg_targets) # 针对角度添加sin损失，有效防止-pi和pi方向相反时损失过大
loc_loss_src = self.reg_loss_func(box_preds_sin, reg_targets_sin, weights=reg_weights) # 回归损失的具体计算过程 (16, 321408, 7)
loc_loss = loc_loss_src.sum() / batch_size # 归一化
loc_loss = loc_loss * self.model_cfg.LOSS_CONFIG.LOSS_WEIGHTS['loc_weight']
box_loss = loc_loss
tb_dict = {
'rpn_loss_loc': loc_loss.item()
}
2.1 回归损失函数：WeightedSmoothL1Loss
一般对于回归损失的构建都是基于smooth l1损失，不过这里同样对每个anchor的回归损失进行加权，具体来说前景的anchor权重为1，其他anchor权重为0。也就是对于回归损失来说，只计算前景anchor的损失值，这个从逻辑上来说是完全合适的。
# 回归损失函数: reg_loss
class WeightedSmoothL1Loss(nn.Module):
"""
Code-wise Weighted Smooth L1 Loss modified based on fvcore.nn.smooth_l1_loss
https://github.com/facebookresearch/fvcore/blob/master/fvcore/nn/smooth_l1_loss.py
| 0.5 * x ** 2 / beta if abs(x) < beta
smoothl1(x) = |
| abs(x) - 0.5 * beta otherwise,
where x = input - target.
"""
def __init__(self, beta: float = 1.0 / 9.0, code_weights: list = None):
"""
Args:
beta: Scalar float.
L1 to L2 change point.
For beta values < 1e-5, L1 loss is computed.
code_weights: (#codes) float list if not None.
Code-wise weights.
"""
super(WeightedSmoothL1Loss, self).__init__()
self.beta = beta # 0.11111
if code_weights is not None:
self.code_weights = np.array(code_weights, dtype=np.float32)
self.code_weights = torch.from_numpy(self.code_weights).cuda() # cuda: [1,1,1,1,1,1,1]
@staticmethod
def smooth_l1_loss(diff, beta):
if beta < 1e-5:
loss = torch.abs(diff)
else:
n = torch.abs(diff)
loss = torch.where(n < beta, 0.5 * n ** 2 / beta, n - 0.5 * beta)
return loss
def forward(self, input: torch.Tensor, target: torch.Tensor, weights: torch.Tensor = None):
"""
Args:
input: (B, #anchors, #codes) float tensor.
Ecoded predicted locations of objects.
target: (B, #anchors, #codes) float tensor.
Regression targets.
weights: (B, #anchors) float tensor if not None.
Returns:
loss: (B, #anchors) float tensor.
Weighted smooth l1 loss without reduction.
"""
target = torch.where(torch.isnan(target), input, target) # ignore nan targets
diff = input - target # 差值计算，包含了角度
# code-wise weighting
if self.code_weights is not None:
diff = diff * self.code_weights.view(1, 1, -1)
loss = self.smooth_l1_loss(diff, self.beta) # (16, 321408, 7)
# anchor-wise weighting
if weights is not None:
assert weights.shape[0] == loss.shape[0] and weights.shape[1] == loss.shape[1]
loss = loss * weights.unsqueeze(-1)
return loss
3. 角度损失构建
在回归损失构建中，如果增加了一个角度预测的head，那么还会增加一个方向的预测。首先利用self.get_direction_target函数来构建目标的方向矩阵。首先根据编码信息还原回去gt的真实选择角度，然后将这个角度限制在0-2π中，超过π的赋值为1，在0-π范围的赋值为0，同时为其构建成一个独热编码的形式，最后返回的维度是：(16, 321408，2)
@staticmethod
def get_direction_target(anchors, reg_targets, one_hot=True, dir_offset=0, num_bins=2):
"""
Args:
anchors: (16, 321408, 7)
reg_targets: (16, 321408, 7)
one_hot: True
dir_offset: 0.78539
num_bins: 2
"""
batch_size = reg_targets.shape[0] # 16
anchors = anchors.view(batch_size, -1, anchors.shape[-1]) # (16, 321408, 7)
rot_gt = reg_targets[..., 6] + anchors[..., 6]
offset_rot = common_utils.limit_period(rot_gt - dir_offset, 0, 2 * np.pi) # 将角度限制在0到2*pi之间,来确定是否反向
dir_cls_targets = torch.floor(offset_rot / (2 * np.pi / num_bins)).long() # 取值为0和1，num_bins=2 (16, 321408)
dir_cls_targets = torch.clamp(dir_cls_targets, min=0, max=num_bins - 1) # (16, 321408)
if one_hot: # 对目标构建成one-hot编码形式
dir_targets = torch.zeros(*list(dir_cls_targets.shape), num_bins, dtype=anchors.dtype,
device=dir_cls_targets.device) # (16, 321408，2)
dir_targets.scatter_(-1, dir_cls_targets.unsqueeze(dim=-1).long(), 1.0)
dir_cls_targets = dir_targets
return dir_cls_targets # (16, 321408，2)
那么，现在将方向预测的特征矩阵也reshape成(16, 321408，2)的维度大小。这里对于每个anchor的权重分配，同样是指预测正样本的方向，所以也只给前景anchor赋予每个点云帧前景anchor数量的归一化权重。前景anchor之外的其他anchor在这项损失中进行忽略处理。随后，进行具体的方向损失计算。随后绝对损失继续归一化与加权，并存储在字典中即可。
# 构建分类损失
if box_dir_cls_preds is not None: # 方向预测是否为空
dir_targets = self.get_direction_target(
anchors, # (16, 321408, 7)
box_reg_targets, # (16, 321408, 7)
dir_offset=self.model_cfg.DIR_OFFSET, # 方向偏移量 0.78539 = π/4
num_bins=self.model_cfg.NUM_DIR_BINS # BINS的方向数 = 2
)
dir_logits = box_dir_cls_preds.view(batch_size, -1, self.model_cfg.NUM_DIR_BINS) # (16, 248, 216, 12) -> (16, 321408, 2)
weights = positives.type_as(dir_logits) # 只对正样本预测方向 (16, 321408)
weights /= torch.clamp(weights.sum(-1, keepdim=True), min=1.0) # (16, 321408)
dir_loss = self.dir_loss_func(dir_logits, dir_targets, weights=weights) # 具体方向损失计算函数
dir_loss = dir_loss.sum() / batch_size
dir_loss = dir_loss * self.model_cfg.LOSS_CONFIG.LOSS_WEIGHTS['dir_weight']
box_loss += dir_loss
tb_dict['rpn_loss_dir'] = dir_loss.item()
3.1 角度损失函数：WeightedCrossEntropyLoss
对于角度损失来说，就简单用了加权的交叉熵损失来计算，代码如下：
# 角回归损失函数: dir_loss
class WeightedCrossEntropyLoss(nn.Module):
"""
Transform input to fit the fomation of PyTorch offical cross entropy loss
with anchor-wise weighting.
"""
def __init__(self):
super(WeightedCrossEntropyLoss, self).__init__()
def forward(self, input: torch.Tensor, target: torch.Tensor, weights: torch.Tensor):
"""
Args:
input: (B, #anchors, #classes) float tensor.
Predited logits for each class.
target: (B, #anchors, #classes) float tensor.
One-hot classification targets.
weights: (B, #anchors) float tensor.
Anchor-wise weights.
Returns:
loss: (B, #anchors) float tensor.
Weighted cross entropy loss without reduction
"""
input = input.permute(0, 2, 1) # (16, 2, 321408)
target = target.argmax(dim=-1) # (16. 321408)
loss = F.cross_entropy(input, target, reduction='none') * weights # (16. 321408)
return loss
4. 总结
对于分类、回归、角度损失的权重在配置文件中可以进行更改，同时对于回归的各参数也可以分别设置权重，配置文件如下所示：
LOSS_CONFIG: # 可以配置cls_loss/reg_loss/dir_loss(分别为CLS_LOSS_TYPE、REG_LOSS_TYPE、DIR_LOSS_TYPE)
LOSS_WEIGHTS: { # 这里每个部分的权重分配是与论文一致的
'cls_weight': 1.0,
'loc_weight': 2.0,
'dir_weight': 0.2,
'code_weights': [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0] # anchor信息的各指标权重
}
在构建完3个损失之后，在tb_dict字典中就会有3个损失结果，同时将这3个结果进行相加得到了总rpn损失，如下所示：
