name yolox as yolov5_af

config/__init__.py

@@ -1,12 +1,12 @@
 # ------------------ Model Config ------------------
-from .yolov1_config   import build_yolov1_config
-from .yolov2_config   import build_yolov2_config
-from .yolov3_config   import build_yolov3_config
-from .yolov5_config   import build_yolov5_config
-from .yolox_config    import build_yolox_config
-from .yolov7_config   import build_yolov7_config
-from .yolov8_config   import build_yolov8_config
-from .rtdetr_config   import build_rtdetr_config
+from .yolov1_config    import build_yolov1_config
+from .yolov2_config    import build_yolov2_config
+from .yolov3_config    import build_yolov3_config
+from .yolov5_config    import build_yolov5_config
+from .yolov5_af_config import build_yolov5af_config
+from .yolov7_af_config import build_yolov7af_config
+from .yolov8_config    import build_yolov8_config
+from .rtdetr_config    import build_rtdetr_config
 
 def build_config(args):
     print('==============================')
@@ -18,12 +18,12 @@ def build_config(args):
         cfg = build_yolov2_config(args)
     elif 'yolov3' in args.model:
         cfg = build_yolov3_config(args)
+    elif 'yolov5_af' in args.model:
+        cfg = build_yolov5af_config(args)
     elif 'yolov5' in args.model:
         cfg = build_yolov5_config(args)
-    elif 'yolox' in args.model:
-        cfg = build_yolox_config(args)
-    elif 'yolov7' in args.model:
-        cfg = build_yolov7_config(args)
+    elif 'yolov7_af' in args.model:
+        cfg = build_yolov7af_config(args)
     elif 'yolov8' in args.model:
         cfg = build_yolov8_config(args)
     # RT-DETR

config/yolox_config.py → config/yolov5_af_config.py

@@ -1,14 +1,14 @@
 # yolo Config
 
 
-def build_yolox_config(args):
-    if args.model == 'yolox_s':
-        return YoloxSConfig()
+def build_yolov5af_config(args):
+    if args.model == 'yolov5_af_s':
+        return Yolov5AFSConfig()
     else:
         raise NotImplementedError("No config for model: {}".format(args.model))
     
-# YOLOx-Base config
-class YoloxBaseConfig(object):
+# YOLOv5AF-Base config
+class Yolov5AFBaseConfig(object):
     def __init__(self) -> None:
         # ---------------- Model config ----------------
         self.width    = 1.0
@@ -87,7 +87,7 @@ class YoloxBaseConfig(object):
         self.normalize_coords = False
         self.mosaic_prob = 1.0
         self.mixup_prob  = 0.0
-        self.copy_paste  = 1.0           # approximated by the YOLOX's mixup
+        self.copy_paste  = 0.0           # approximated by the YOLOX's mixup
         self.multi_scale = [0.5, 1.25]   # multi scale: [img_size * 0.5, img_size * 1.25]
         ## Pixel mean & std
         self.pixel_mean = [0., 0., 0.]
@@ -112,8 +112,8 @@ class YoloxBaseConfig(object):
         for k, v in config_dict.items():
             print("{} : {}".format(k, v))
 
-# YOLOx-S
-class YoloxSConfig(YoloxBaseConfig):
+# YOLOv5AF-S
+class Yolov5AFSConfig(Yolov5AFBaseConfig):
     def __init__(self) -> None:
         super().__init__()
         # ---------------- Model config ----------------
@@ -124,4 +124,4 @@ class YoloxSConfig(YoloxBaseConfig):
         # ---------------- Data process config ----------------
         self.mosaic_prob = 1.0
         self.mixup_prob  = 0.0
-        self.copy_paste  = 1.0
+        self.copy_paste  = 0.5

config/yolov7_config.py → config/yolov7_af_config.py

@@ -1,16 +1,16 @@
 # yolo Config
 
 
-def build_yolov7_config(args):
-    if args.model == 'yolov7_s':
-        return Yolov7SConfig()
-    elif args.model == 'yolov7_l':
-        return Yolov7LConfig()
+def build_yolov7af_config(args):
+    if args.model == 'yolov7_af_s':
+        return Yolov7AFSConfig()
+    elif args.model == 'yolov7_af_l':
+        return Yolov7AFLConfig()
     else:
         raise NotImplementedError("No config for model: {}".format(args.model))
     
-# YOLOv7-Base config
-class Yolov7BaseConfig(object):
+# YOLOv7AF-Base config
+class Yolov7AFBaseConfig(object):
     def __init__(self) -> None:
         # ---------------- Model config ----------------
         self.width    = 1.0
@@ -93,7 +93,7 @@ class Yolov7BaseConfig(object):
         self.box_format = 'xyxy'
         self.normalize_coords = False
         self.mosaic_prob = 1.0
-        self.mixup_prob  = 0.15
+        self.mixup_prob  = 0.0
         self.copy_paste  = 0.0           # approximated by the YOLOX's mixup
         self.multi_scale = [0.5, 1.25]   # multi scale: [img_size * 0.5, img_size * 1.25]
         ## Pixel mean & std
@@ -120,7 +120,7 @@ class Yolov7BaseConfig(object):
             print("{} : {}".format(k, v))
 
 # YOLOv7-S
-class Yolov7SConfig(Yolov7BaseConfig):
+class Yolov7AFSConfig(Yolov7AFBaseConfig):
     def __init__(self) -> None:
         super().__init__()
         # ---------------- Model config ----------------
@@ -133,10 +133,10 @@ class Yolov7SConfig(Yolov7BaseConfig):
         # ---------------- Data process config ----------------
         self.mosaic_prob = 1.0
         self.mixup_prob  = 0.0
-        self.copy_paste  = 1.0
+        self.copy_paste  = 0.5
 
 # YOLOv7-L
-class Yolov7LConfig(Yolov7BaseConfig):
+class Yolov7AFLConfig(Yolov7AFBaseConfig):
     def __init__(self) -> None:
         super().__init__()
         # ---------------- Model config ----------------

models/__init__.py

@@ -2,14 +2,14 @@
 # -*- coding:utf-8 -*-
 
 import torch
-from .yolov1.build import build_yolov1
-from .yolov2.build import build_yolov2
-from .yolov3.build import build_yolov3
-from .yolov5.build import build_yolov5
-from .yolox.build  import build_yolox
-from .yolov7.build import build_yolov7
-from .yolov8.build import build_yolov8
-from .rtdetr.build import build_rtdetr
+from .yolov1.build    import build_yolov1
+from .yolov2.build    import build_yolov2
+from .yolov3.build    import build_yolov3
+from .yolov5.build    import build_yolov5
+from .yolov5_af.build import build_yolov5af
+from .yolov7_af.build import build_yolov7af
+from .yolov8.build    import build_yolov8
+from .rtdetr.build    import build_rtdetr
 
 # build object detector
 def build_model(args, cfg, is_val=False):
@@ -23,15 +23,15 @@ def build_model(args, cfg, is_val=False):
     ## Modified YOLOv3
     elif 'yolov3' in args.model:
         model, criterion = build_yolov3(cfg, is_val)
+    ## YOLOX
+    elif 'yolov5_af' in args.model:
+        model, criterion = build_yolov5af(cfg, is_val)
     ## Modified YOLOv5
     elif 'yolov5' in args.model:
         model, criterion = build_yolov5(cfg, is_val)
-    ## YOLOX
-    elif 'yolox' in args.model:
-        model, criterion = build_yolox(cfg, is_val)
     ## Modified Anchor-free YOLOv7
-    elif 'yolov7' in args.model:
-        model, criterion = build_yolov7(cfg, is_val)
+    elif 'yolov7_af' in args.model:
+        model, criterion = build_yolov7af(cfg, is_val)
     ## YOLOv8
     elif 'yolov8' in args.model:
         model, criterion = build_yolov8(cfg, is_val)

models/yolox/build.py → models/yolov5_af/build.py

@@ -1,13 +1,13 @@
 import torch.nn as nn
 
 from .loss import SetCriterion
-from .yolox import Yolox
+from .yolov5_af import Yolov5AF
 
 
 # build object detector
-def build_yolox(cfg, is_val=False):
+def build_yolov5af(cfg, is_val=False):
     # -------------- Build YOLO --------------
-    model = Yolox(cfg, is_val)
+    model = Yolov5AF(cfg, is_val)
 
     # -------------- Initialize YOLO --------------
     for m in model.modules():

models/yolox/yolox.py → models/yolov5_af/yolov5_af.py

@@ -3,23 +3,23 @@ import torch
 import torch.nn as nn
 
 # --------------- Model components ---------------
-from .yolox_backbone import YoloxBackbone
-from .yolox_neck     import SPPF
-from .yolox_pafpn    import YoloxPaFPN
-from .yolox_head     import YoloxDetHead
-from .yolox_pred     import YoloxDetPredLayer
+from .yolov5_af_backbone import Yolov5Backbone
+from .yolov5_af_neck     import SPPF
+from .yolov5_af_pafpn    import Yolov5PaFPN
+from .yolov5_af_head     import Yolov5DetHead
+from .yolov5_af_pred     import Yolov5AFDetPredLayer
 
 # --------------- External components ---------------
 from utils.misc import multiclass_nms
 
 
-# YOLOx
-class Yolox(nn.Module):
+# Yolov5AF
+class Yolov5AF(nn.Module):
     def __init__(self,
                  cfg,
                  is_val = False,
                  ) -> None:
-        super(Yolox, self).__init__()
+        super(Yolov5AF, self).__init__()
         # ---------------------- Basic setting ----------------------
         self.cfg = cfg
         self.num_classes = cfg.num_classes
@@ -31,17 +31,17 @@ class Yolox(nn.Module):
         
         # ---------------------- Network Parameters ----------------------
         ## Backbone
-        self.backbone = YoloxBackbone(cfg)
+        self.backbone = Yolov5Backbone(cfg)
         self.pyramid_feat_dims = self.backbone.feat_dims[-3:]
         ## Neck: SPP
         self.neck     = SPPF(cfg, self.pyramid_feat_dims[-1], self.pyramid_feat_dims[-1])
         self.pyramid_feat_dims[-1] = self.neck.out_dim
         ## Neck: FPN
-        self.fpn      = YoloxPaFPN(cfg, self.pyramid_feat_dims)
+        self.fpn      = Yolov5PaFPN(cfg, self.pyramid_feat_dims)
         ## Head
-        self.head     = YoloxDetHead(cfg, self.fpn.out_dims)
+        self.head     = Yolov5DetHead(cfg, self.fpn.out_dims)
         ## Pred
-        self.pred     = YoloxDetPredLayer(cfg)
+        self.pred     = Yolov5AFDetPredLayer(cfg)
 
     def post_process(self, obj_preds, cls_preds, box_preds):
         """

models/yolox/yolox_backbone.py → models/yolov5_af/yolov5_af_backbone.py

@@ -2,16 +2,16 @@ import torch
 import torch.nn as nn
 
 try:
-    from .yolox_basic import BasicConv, CSPBlock
+    from .yolov5_af_basic import BasicConv, CSPBlock
 except:
-    from  yolox_basic import BasicConv, CSPBlock
+    from  yolov5_af_basic import BasicConv, CSPBlock
 
 
 # --------------------- Yolov3's Backbone -----------------------
 ## Modified DarkNet
-class YoloxBackbone(nn.Module):
+class Yolov5Backbone(nn.Module):
     def __init__(self, cfg):
-        super(YoloxBackbone, self).__init__()
+        super(Yolov5Backbone, self).__init__()
         # ------------------ Basic setting ------------------
         self.model_scale = cfg.scale
         self.feat_dims = [round(64   * cfg.width),
@@ -118,7 +118,7 @@ if __name__ == '__main__':
             self.use_pretrained = True
 
     cfg = BaseConfig()
-    model = YoloxBackbone(cfg)
+    model = Yolov5Backbone(cfg)
     x = torch.randn(1, 3, 640, 640)
     t0 = time.time()
     outputs = model(x)

models/yolox/yolox_head.py → models/yolov5_af/yolov5_af_head.py

@@ -2,9 +2,9 @@ import torch
 import torch.nn as nn
 
 try:
-    from .yolox_basic import BasicConv
+    from .yolov5_af_basic import BasicConv
 except:
-    from  yolox_basic import BasicConv
+    from  yolov5_af_basic import BasicConv
 
 
 ## Single-level Detection Head
@@ -91,7 +91,7 @@ class DetHead(nn.Module):
         return cls_feats, reg_feats
     
 ## Multi-level Detection Head
-class YoloxDetHead(nn.Module):
+class Yolov5DetHead(nn.Module):
     def __init__(self, cfg, in_dims):
         super().__init__()
         ## ----------- Network Parameters -----------
@@ -153,7 +153,7 @@ if __name__=='__main__':
     pyramid_feats = [torch.randn(1, cfg.head_dim, 80, 80),
                      torch.randn(1, cfg.head_dim, 40, 40),
                      torch.randn(1, cfg.head_dim, 20, 20)]
-    head = YoloxDetHead(cfg, [cfg.head_dim]*3)
+    head = Yolov5DetHead(cfg, [cfg.head_dim]*3)
 
 
     # Inference

models/yolox/yolox_neck.py → models/yolov5_af/yolov5_af_neck.py

@@ -1,7 +1,7 @@
 import torch
 import torch.nn as nn
 
-from .yolox_basic import BasicConv
+from .yolov5_af_basic import BasicConv
 
 
 # Spatial Pyramid Pooling - Fast (SPPF) layer for YOLOv5 by Glenn Jocher

models/yolox/yolox_pafpn.py → models/yolov5_af/yolov5_af_pafpn.py

@@ -3,14 +3,14 @@ import torch
 import torch.nn as nn
 import torch.nn.functional as F
 
-from .yolox_basic import BasicConv, CSPBlock
+from .yolov5_af_basic import BasicConv, CSPBlock
 
 
-# YoloxFPN
-class YoloxPaFPN(nn.Module):
+# Yolov5FPN
+class Yolov5PaFPN(nn.Module):
     def __init__(self, cfg, in_dims: List = [256, 512, 1024],
                  ):
-        super(YoloxPaFPN, self).__init__()
+        super(Yolov5PaFPN, self).__init__()
         self.in_dims = in_dims
         c3, c4, c5 = in_dims
 

models/yolox/yolox_pred.py → models/yolov5_af/yolov5_af_pred.py

@@ -4,7 +4,7 @@ from typing import List
 
 # -------------------- Detection Pred Layer --------------------
 ## Single-level pred layer
-class DetPredLayer(nn.Module):
+class AFDetPredLayer(nn.Module):
     def __init__(self,
                  cls_dim      :int,
                  reg_dim      :int,
@@ -94,7 +94,7 @@ class DetPredLayer(nn.Module):
         return outputs
 
 ## Multi-level pred layer
-class YoloxDetPredLayer(nn.Module):
+class Yolov5AFDetPredLayer(nn.Module):
     def __init__(self, cfg):
         super().__init__()
         # --------- Basic Parameters ----------
@@ -103,12 +103,12 @@ class YoloxDetPredLayer(nn.Module):
         # ----------- Network Parameters -----------
         ## pred layers
         self.multi_level_preds = nn.ModuleList(
-            [DetPredLayer(cls_dim      = round(cfg.head_dim * cfg.width),
-                          reg_dim      = round(cfg.head_dim * cfg.width),
-                          stride       = cfg.out_stride[level],
-                          num_classes  = cfg.num_classes,)
-                          for level in range(cfg.num_levels)
-                          ])
+            [AFDetPredLayer(cls_dim      = round(cfg.head_dim * cfg.width),
+                            reg_dim      = round(cfg.head_dim * cfg.width),
+                            stride       = cfg.out_stride[level],
+                            num_classes  = cfg.num_classes,)
+                            for level in range(cfg.num_levels)
+                            ])
 
     def forward(self, cls_feats, reg_feats):
         all_anchors = []

models/yolov7/build.py → models/yolov7_af/build.py

@@ -1,13 +1,13 @@
 import torch.nn as nn
 
 from .loss import SetCriterion
-from .yolov7 import Yolov7
+from .yolov7_af import Yolov7AF
 
 
 # build object detector
-def build_yolov7(cfg, is_val=False):
+def build_yolov7af(cfg, is_val=False):
     # -------------- Build YOLO --------------
-    model = Yolov7(cfg, is_val)
+    model = Yolov7AF(cfg, is_val)
 
     # -------------- Initialize YOLO --------------
     for m in model.modules():

models/yolov7/yolov7.py → models/yolov7_af/yolov7_af.py

@@ -3,23 +3,23 @@ import torch
 import torch.nn as nn
 
 # --------------- Model components ---------------
-from .yolov7_backbone import Yolov7Backbone
-from .yolov7_neck     import SPPFBlockCSP
-from .yolov7_pafpn    import Yolov7PaFPN
-from .yolov7_head     import Yolov7DetHead
-from .yolov7_pred     import Yolov7DetPredLayer
+from .yolov7_af_backbone import Yolov7Backbone
+from .yolov7_af_neck     import SPPFBlockCSP
+from .yolov7_af_pafpn    import Yolov7PaFPN
+from .yolov7_af_head     import Yolov7DetHead
+from .yolov7_af_pred     import Yolov7AFDetPredLayer
 
 # --------------- External components ---------------
 from utils.misc import multiclass_nms
 
 
 # Anchor-free YOLOv7
-class Yolov7(nn.Module):
+class Yolov7AF(nn.Module):
     def __init__(self,
                  cfg,
                  is_val = False,
                  ) -> None:
-        super(Yolov7, self).__init__()
+        super(Yolov7AF, self).__init__()
         # ---------------------- Basic setting ----------------------
         self.cfg = cfg
         self.num_classes = cfg.num_classes
@@ -41,7 +41,7 @@ class Yolov7(nn.Module):
         ## Head
         self.head     = Yolov7DetHead(cfg, self.fpn.out_dims)
         ## Pred
-        self.pred     = Yolov7DetPredLayer(cfg, self.head.cls_head_dim, self.head.reg_head_dim)
+        self.pred     = Yolov7AFDetPredLayer(cfg, self.head.cls_head_dim, self.head.reg_head_dim)
 
     def post_process(self, cls_preds, box_preds):
         """

models/yolov7/yolov7_backbone.py → models/yolov7_af/yolov7_af_backbone.py

@@ -2,9 +2,9 @@ import torch
 import torch.nn as nn
 
 try:
-    from .yolov7_basic import BasicConv, MDown, ELANLayer
+    from .yolov7_af_basic import BasicConv, MDown, ELANLayer
 except:
-    from  yolov7_basic import BasicConv, MDown, ELANLayer
+    from  yolov7_af_basic import BasicConv, MDown, ELANLayer
 
 
 # ELANNet

models/yolov7/yolov7_head.py → models/yolov7_af/yolov7_af_head.py

@@ -1,7 +1,7 @@
 import torch
 import torch.nn as nn
 
-from .yolov7_basic import BasicConv
+from .yolov7_af_basic import BasicConv
 
 
 # -------------------- Detection Head --------------------

models/yolov7/yolov7_neck.py → models/yolov7_af/yolov7_af_neck.py

@@ -1,6 +1,6 @@
 import torch
 import torch.nn as nn
-from .yolov7_basic import BasicConv
+from .yolov7_af_basic import BasicConv
 
 
 # Spatial Pyramid Pooling - Fast (SPPF) layer for YOLOv5 by Glenn Jocher

models/yolov7/yolov7_pafpn.py → models/yolov7_af/yolov7_af_pafpn.py

@@ -3,7 +3,7 @@ import torch
 import torch.nn as nn
 import torch.nn.functional as F
 
-from .yolov7_basic import BasicConv, ELANLayerFPN, MDown
+from .yolov7_af_basic import BasicConv, ELANLayerFPN, MDown
 
 
 # PaFPN-ELAN (YOLOv7's)

models/yolov7/yolov7_pred.py → models/yolov7_af/yolov7_af_pred.py

@@ -6,7 +6,7 @@ import torch.nn.functional as F
 
 # -------------------- Detection Pred Layer --------------------
 ## Single-level pred layer
-class DetPredLayer(nn.Module):
+class AFDetPredLayer(nn.Module):
     def __init__(self,
                  cls_dim     :int = 256,
                  reg_dim     :int = 256,
@@ -81,7 +81,7 @@ class DetPredLayer(nn.Module):
         return outputs
 
 ## Multi-level pred layer
-class Yolov7DetPredLayer(nn.Module):
+class Yolov7AFDetPredLayer(nn.Module):
     def __init__(self,
                  cfg,
                  cls_dim,
@@ -96,14 +96,14 @@ class Yolov7DetPredLayer(nn.Module):
         # ----------- Network Parameters -----------
         ## pred layers
         self.multi_level_preds = nn.ModuleList(
-            [DetPredLayer(cls_dim     = cls_dim,
-                          reg_dim     = reg_dim,
-                          stride      = cfg.out_stride[level],
-                          reg_max     = cfg.reg_max,
-                          num_classes = cfg.num_classes,
-                          num_coords  = 4 * cfg.reg_max)
-                          for level in range(cfg.num_levels)
-                          ])
+            [AFDetPredLayer(cls_dim     = cls_dim,
+                            reg_dim     = reg_dim,
+                            stride      = cfg.out_stride[level],
+                            reg_max     = cfg.reg_max,
+                            num_classes = cfg.num_classes,
+                            num_coords  = 4 * cfg.reg_max)
+                            for level in range(cfg.num_levels)
+                            ])
         ## proj conv
         proj_init = torch.arange(cfg.reg_max, dtype=torch.float)
         self.proj_conv = nn.Conv2d(cfg.reg_max, 1, kernel_size=1, bias=False).requires_grad_(False)