YOLOV5代码阅读

yolo.py目录

v FILE

v ROOT

c Detect(nn.Module)

m __init__(self, nc=80, anchors=(), ch=(), inplace=True)

m forward(self, x)

m _make_grid(self, nx=20, ny=20, i=0, torch_1_10=check_version(torch.__version__, '1.10.0'))

f anchor_grid

f dynamic

f export

f grid

f inplace

f m

f nc

f nl

f nc

f no

f stride

c Segment(Detect)

m __init__(self, nc=80, anchors=(), nm=32, npr=256, ch=(), inplace=True)

m forward(self, x)

f detect

f m

f nm

f no

f npr

f proto

c BaseModel(nn.Module)

m forward(self, x, profile=False, visualize=False)

m _forward_once(self, x, profile=False, visualize=False)

m _profile_one_layer(self, m, x, dt)

m fuse(self)

m info(self, verbose=False, img_size=640)

m _apply(self, fn)

c DetectionModel(BaseModel)

m __init__(self, cfg='yolov5s.yaml', ch=3, nc=None, anchors=None)

m forward(self, x, augment=False, profile=False, visualize=False)

m _forward_augment(self, x)

m _descale_pred(self, p, flips, scale, img_size)

m _clip_augmented(self, y)

m _initialize_biases(self, cf=None)

f inplace

f model

f names

f save

f stride

f yaml

f yaml_file

v Model

c SegmentationModel(DetectionModel)

m __init__(self, cfg='yolov5s-seg.yaml', ch=3, nc=None, anchors=None)

c ClassificationModel(BaseModel)

m __init__(self, cfg=None, model=None, nc=1000, cutoff=10)

m _from_detection_model(self, model, nc=1000, cutoff=10)

m _from_yaml(self, cfg)

f model

f nc

f save

f stride

f parse_model(d, ch)

---

common.py 

class SPPF(nn.Module):
    # Spatial Pyramid Pooling - Fast (SPPF) layer for YOLOv5 by Glenn Jocher实现空间金字塔池化
    def __init__(self, c1, c2, k=5):  # equivalent to SPP(k=(5, 9, 13))
        super().__init__()
        c_ = c1 // 2  # hidden channels
        self.cv1 = Conv(c1, c_, 1, 1)
        self.cv2 = Conv(c_ * 4, c2, 1, 1)
        self.m = nn.MaxPool2d(kernel_size=k, stride=1, padding=k // 2)

    def forward(self, x):
        x = self.cv1(x)
        with warnings.catch_warnings():
            warnings.simplefilter('ignore')  # suppress torch 1.9.0 max_pool2d() warning
            y1 = self.m(x)
            y2 = self.m(y1)
            return self.cv2(torch.cat((x, y1, y2, self.m(y2)), 1))

这个类具有两个主要部分：初始化函数__init__和前向传播函数forward。

在__init__函数中，首先计算了隐藏通道数c_，然后初始化了两个卷积层（cv1和cv2），最后定义了一个最大池化层self.m。

在forward函数中，输入x首先通过cv1卷积层处理，然后经过两次池化操作（self.m(x)和self.m(y1)），最后将结果拼接起来并通过cv2卷积层处理。

代码中用到了警告处理，用于忽略特定类型的警告，这里是PyTorch 1.9.0版本的中max_pool2d()函数的警告。

总的来说，这个SPPF类是为了在YOLOv5中实现空间金字塔池化（Spatial Pyramid Pooling）。这种池化方式可以在不同尺度上提取特征，从而使模型能够更好地理解和处理输入数据的多样性。

---

class Focus(nn.Module):
    # Focus wh information into c-space
    def __init__(self, c1, c2, k=1, s=1, p=None, g=1, act=True):  # ch_in, ch_out, kernel, stride, padding, groups
        super().__init__()
        self.conv = Conv(c1 * 4, c2, k, s, p, g, act=act)
        # self.contract = Contract(gain=2)

    def forward(self, x):  # x(b,c,w,h) -> y(b,4c,w/2,h/2)
        return self.conv(torch.cat((x[..., ::2, ::2], x[..., 1::2, ::2], x[..., ::2, 1::2], x[..., 1::2, 1::2]), 1))
        # return self.conv(self.contract(x))

init函数接受7个参数（c1,c2,k,s,p,g,act）（输入通道数、输出通道数、核数、步长、是否填充、组数、是否使用激活函数），并且这些参数可以用于配置Conv函数。

前向传播函数定义了输入数据x通过网络时的前向传播过程。它对输入的四分之三的空间信息用torch.cat进行连接，然后通过卷积层进行运算。

---

class GhostConv(nn.Module):
    # Ghost Convolution https://github.com/huawei-noah/ghostnet
    def __init__(self, c1, c2, k=1, s=1, g=1, act=True):  # ch_in, ch_out, kernel, stride, groups
        super().__init__()
        c_ = c2 // 2  # hidden channels
        self.cv1 = Conv(c1, c_, k, s, None, g, act=act)
        self.cv2 = Conv(c_, c_, 5, 1, None, c_, act=act)

    def forward(self, x):
        y = self.cv1(x)
        return torch.cat((y, self.cv2(y)), 1)

隐藏通道数为c2的一半，forward前向传播函数先进行一次卷积，再将卷积结果进行第二次卷积，并将两次的卷积结果通过torch.cat 拼接。提高网络性能和模型精度的轻量级卷积方法。

---

class Ghost