update model_name

nets/backbone.py

@@ -25,9 +25,9 @@ class Conv(nn.Module):
     def fuseforward(self, x):
         return self.act(self.conv(x))
     
-class Block(nn.Module):
+class Multi_Concat_Block(nn.Module):
     def __init__(self, c1, c2, c3, n=4, e=1, ids=[0]):
-        super(Block, self).__init__()
+        super(Multi_Concat_Block, self).__init__()
         c_ = int(c2 * e)
         
         self.ids = ids
@@ -58,9 +58,9 @@ class MP(nn.Module):
     def forward(self, x):
         return self.m(x)
     
-class Transition(nn.Module):
+class Transition_Block(nn.Module):
     def __init__(self, c1, c2):
-        super(Transition, self).__init__()
+        super(Transition_Block, self).__init__()
         self.cv1 = Conv(c1, c2, 1, 1)
         self.cv2 = Conv(c1, c2, 1, 1)
         self.cv3 = Conv(c2, c2, 3, 2)
@@ -93,19 +93,19 @@ class Backbone(nn.Module):
         )
         self.dark2 = nn.Sequential(
             Conv(transition_channels * 2, transition_channels * 4, 3, 2),
-            Block(transition_channels * 4, block_channels * 2, transition_channels * 8, n=n, ids=ids),
+            Multi_Concat_Block(transition_channels * 4, block_channels * 2, transition_channels * 8, n=n, ids=ids),
         )
         self.dark3 = nn.Sequential(
-            Transition(transition_channels * 8, transition_channels * 4),
-            Block(transition_channels * 8, block_channels * 4, transition_channels * 16, n=n, ids=ids),
+            Transition_Block(transition_channels * 8, transition_channels * 4),
+            Multi_Concat_Block(transition_channels * 8, block_channels * 4, transition_channels * 16, n=n, ids=ids),
         )
         self.dark4 = nn.Sequential(
-            Transition(transition_channels * 16, transition_channels * 8),
-            Block(transition_channels * 16, block_channels * 8, transition_channels * 32, n=n, ids=ids),
+            Transition_Block(transition_channels * 16, transition_channels * 8),
+            Multi_Concat_Block(transition_channels * 16, block_channels * 8, transition_channels * 32, n=n, ids=ids),
         )
         self.dark5 = nn.Sequential(
-            Transition(transition_channels * 32, transition_channels * 16),
-            Block(transition_channels * 32, block_channels * 8, transition_channels * 32, n=n, ids=ids),
+            Transition_Block(transition_channels * 32, transition_channels * 16),
+            Multi_Concat_Block(transition_channels * 32, block_channels * 8, transition_channels * 32, n=n, ids=ids),
         )
         
         if pretrained:

nets/yolo.py

@@ -2,7 +2,7 @@ import numpy as np
 import torch
 import torch.nn as nn
 
-from nets.backbone import Backbone, Block, Conv, SiLU, Transition, autopad
+from nets.backbone import Backbone, Multi_Concat_Block, Conv, SiLU, Transition_Block, autopad
 
 
 class SPPCSPC(nn.Module):
@@ -240,17 +240,17 @@ class YoloBody(nn.Module):
         self.sppcspc                = SPPCSPC(transition_channels * 32, transition_channels * 16)
         self.conv_for_P5            = Conv(transition_channels * 16, transition_channels * 8)
         self.conv_for_feat2         = Conv(transition_channels * 32, transition_channels * 8)
-        self.conv3_for_upsample1    = Block(transition_channels * 16, panet_channels * 4, transition_channels * 8, e=e, n=n, ids=ids)
+        self.conv3_for_upsample1    = Multi_Concat_Block(transition_channels * 16, panet_channels * 4, transition_channels * 8, e=e, n=n, ids=ids)
 
         self.conv_for_P4            = Conv(transition_channels * 8, transition_channels * 4)
         self.conv_for_feat1         = Conv(transition_channels * 16, transition_channels * 4)
-        self.conv3_for_upsample2    = Block(transition_channels * 8, panet_channels * 2, transition_channels * 4, e=e, n=n, ids=ids)
+        self.conv3_for_upsample2    = Multi_Concat_Block(transition_channels * 8, panet_channels * 2, transition_channels * 4, e=e, n=n, ids=ids)
 
-        self.down_sample1           = Transition(transition_channels * 4, transition_channels * 4)
-        self.conv3_for_downsample1  = Block(transition_channels * 16, panet_channels * 4, transition_channels * 8, e=e, n=n, ids=ids)
+        self.down_sample1           = Transition_Block(transition_channels * 4, transition_channels * 4)
+        self.conv3_for_downsample1  = Multi_Concat_Block(transition_channels * 16, panet_channels * 4, transition_channels * 8, e=e, n=n, ids=ids)
 
-        self.down_sample2           = Transition(transition_channels * 8, transition_channels * 8)
-        self.conv3_for_downsample2  = Block(transition_channels * 32, panet_channels * 8, transition_channels * 16, e=e, n=n, ids=ids)
+        self.down_sample2           = Transition_Block(transition_channels * 8, transition_channels * 8)
+        self.conv3_for_downsample2  = Multi_Concat_Block(transition_channels * 32, panet_channels * 8, transition_channels * 16, e=e, n=n, ids=ids)
 
         self.rep_conv_1 = conv(transition_channels * 4, transition_channels * 8, 3, 1)
         self.rep_conv_2 = conv(transition_channels * 8, transition_channels * 16, 3, 1)

nets/yolo_training.py

@@ -8,7 +8,6 @@ import torch.nn as nn
 import torch.nn.functional as F
 
 
-
 def smooth_BCE(eps=0.1):  # https://github.com/ultralytics/yolov3/issues/238#issuecomment-598028441
     # return positive, negative label smoothing BCE targets
     return 1.0 - 0.5 * eps, 0.5 * eps