refactor(loss): 移除不使用代码

Author: zjZSTU

py/lib/models/multi_part_loss.py

@@ -43,132 +43,9 @@ def forward(self, preds, targets):
         :param targets: (N, S*S, (B*5+C))
         :return:
         """
-        # print('loss 1', self._process1(preds, targets))
-        # print('loss 2', self._process2(preds, targets))
-        return self._process3(preds, targets)
+        return self._process(preds, targets)
 
-    def _process1(self, preds, targets):
-        N = preds.shape[0]
-        total_loss = 0.0
-        for pred, target in zip(preds, targets):
-            """
-            逐个图像计算
-            pred: [S*S, (B*5+C)]
-            target: [S*S, (B*5+C)]
-            """
-            # 分类概率
-            # [S*S, C]
-            pred_probs = pred[:, :self.C]
-            target_probs = target[:, :self.C]
-            # 置信度
-            # [S*S, B]
-            pred_confidences = pred[:, self.C:(self.C + self.B)]
-            target_confidences = target[:, self.C:(self.C + self.B)]
-            # 边界框坐标
-            pred_bboxs = pred[:, (self.C + self.B):]
-            target_bboxs = target[:, (self.C + self.B):]
-
-            for i in range(self.S * self.S):
-                """
-                逐个网格计算
-                """
-                pred_single_probs = pred_probs[i]
-                target_single_probs = target_probs[i]
-
-                pred_single_confidences = pred_confidences[i]
-                target_single_confidences = target_confidences[i]
-
-                pred_single_bboxs = pred_bboxs[i]
-                target_single_bboxs = target_bboxs[i]
-
-                # 是否存在置信度（如果存在，则target的置信度必然大于0）
-                is_obj = target_single_confidences[0] > 0
-                # 计算置信度损失 假定该网格不存在对象
-                total_loss += self.noobj * self.sum_squared_error(pred_single_confidences, target_single_confidences)
-                if is_obj:
-                    # 如果存在
-                    # 计算分类损失
-                    total_loss += self.sum_squared_error(pred_single_probs, target_single_probs)
-
-                    # 计算所有预测边界框和标注边界框的IoU
-                    pred_single_bboxs = pred_single_bboxs.reshape(-1, 4)
-                    target_single_bboxs = target_single_bboxs.reshape(-1, 4)
-
-                    scores = self.iou(pred_single_bboxs, target_single_bboxs)
-                    # 提取IoU最大的下标
-                    bbox_idx = torch.argmax(scores)
-                    # 计算置信度损失
-                    total_loss += (1 - self.noobj) * \
-                                  self.sum_squared_error(pred_single_confidences[bbox_idx],
-                                                         target_single_confidences[bbox_idx])
-                    # 计算边界框损失
-                    total_loss += self.coord * self.bbox_loss(pred_single_bboxs[bbox_idx].reshape(-1, 4),
-                                                              target_single_bboxs[bbox_idx].reshape(-1, 4))
-
-        return total_loss / N
-
-    def _process2(self, preds, targets):
-        N = preds.shape[0]
-        total_loss = 0.0
-        for pred, target in zip(preds, targets):
-            """
-            逐个图像计算
-            pred: [S*S, (B*5+C)]
-            target: [S*S, (B*5+C)]
-            """
-            # 分类概率
-            # [S*S, C]
-            pred_probs = pred[:, :self.C]
-            target_probs = target[:, :self.C]
-            # 置信度
-            # [S*S, B]
-            pred_confidences = pred[:, self.C:(self.C + self.B)]
-            target_confidences = target[:, self.C:(self.C + self.B)]
-            # 边界框坐标
-            # [S*S, B*4] -> [S*S, B, 4]
-            pred_bboxs = pred[:, (self.C + self.B):].reshape(self.S * self.S, self.B, 4)
-            target_bboxs = target[:, (self.C + self.B):].reshape(self.S * self.S, self.B, 4)
-
-            # 统一计算置信度损失
-            total_loss += self.noobj * self.sum_squared_error(pred_confidences, target_confidences)
-            # 计算每个网格预测边界框的IoU
-            # Input: [S*S, B, 4] -> [S*S*B, 4]
-            # Output: [S*S*B] -> [S*S, B]
-            iou_scores = self.iou(pred_bboxs.reshape(-1, 4), target_bboxs.reshape(-1, 4)).reshape(self.S * self.S,
-                                                                                                  self.B)
-            # 计算其中最大IoU所属下标
-            # [S*S]
-            top_idxs = torch.argmax(iou_scores, dim=1)
-            top_len = len(top_idxs)
-            # 提取对应的边界框以及置信度
-            # [S*S, 4]
-            top_pred_bboxs = pred_bboxs[range(top_len), top_idxs]
-            top_pred_confidences = pred_confidences[range(top_len), top_idxs]
-            top_target_bboxs = target_bboxs[range(top_len), top_idxs]
-            top_target_confidences = target_confidences[range(top_len), top_idxs]
-
-            # 计算网格中是否存在目标
-            # [S*S, C] -> [S*S]
-            obj_idxs = torch.sum(target_probs, dim=1) > 0
-            # 提取对应的目标分类概率、置信度以及边界框坐标
-            # [S*S, C]
-            obj_pred_probs = pred_probs[obj_idxs]
-            obj_pred_confidences = top_pred_confidences[obj_idxs]
-            obj_pred_bboxs = top_pred_bboxs[obj_idxs]
-
-            obj_target_probs = target_probs[obj_idxs]
-            obj_target_confidences = top_target_confidences[obj_idxs]
-            obj_target_bboxs = top_target_bboxs[obj_idxs]
-
-            # 计算置信度损失
-            total_loss += (1 - self.noobj) * self.sum_squared_error(obj_pred_confidences, obj_target_confidences)
-            # 分类概率损失
-            total_loss += self.sum_squared_error(obj_pred_probs, obj_target_probs)
-            # 坐标损失
-            total_loss += self.coord * self.bbox_loss(obj_pred_bboxs, obj_target_bboxs)
-        return total_loss / N
-
-    def _process3(self, preds, targets):
+    def _process(self, preds, targets):
         N = preds.shape[0]
         ## 预测
         # 提取每个网格的分类概率