【人工智能学习之YOLOV3网络搭建实战】

YOLoV3

import torch
from torch import nn
upsample_par = 2
conv_par = [
    [32,64,3,2],
    [64,128,3,2],
    [128,256,3,2],
    [256,512,3,2],
    [512,1024,3,2]
]
res_par = [
    [1,64],
    [2,128],
    [8,256],
    [8,512],
    [4,1024]
]
set_par13 = [res_par[4][1],512]
set_par26 = [set_par13[1]+res_par[3][1],256]
set_par52 = [set_par26[1]+res_par[2][1],128]
out_par = [256,128,64]
class Convilutional(nn.Module):
    def __init__(self,input,output,kernel,stride):
        super().__init__()
        self.conv = nn.Sequential(
            nn.Conv2d(input,output,kernel,stride,kernel//2),
            nn.BatchNorm2d(output),
            nn.LeakyReLU()
        )
    def forward(self,x):
        return self.conv(x)
class ResBlock(nn.Module):
    def __init__(self,input):
        super().__init__()
        self.res_block = nn.Sequential(
            Convilutional(input, int(input/2), 1, 1),
            Convilutional(int(input/2), input, 3, 1),
        )
    def forward(self,x):
        return self.res_block(x)+x
class Darknet53(nn.Module):
    def __init__(self):
        super().__init__()
        self.inputlayer = Convilutional(3,32,3,1)
        layer = []
        for idx in range(5):
            layer.append(Convilutional(*conv_par[idx]))
            for num in range(res_par[idx][0]):
                layer.append(ResBlock(res_par[idx][1]))
            if idx == 2:
                self.layer_out1 = nn.Sequential(*layer)
            if idx == 3:
                self.layer_out2 = nn.Sequential(*layer)
        self.layer_out3 = nn.Sequential(*layer)
        pass
    def forward(self,x):
        return self.layer_out1(self.inputlayer(x)),self.layer_out2(self.inputlayer(x)),self.layer_out3(self.inputlayer(x))
class ConvilutionalSet(nn.Module):
    def __init__(self, input, output):
        super().__init__()
        self.convilutional_set = nn.Sequential(
            Convilutional(input, output, 1, 1),
            Convilutional(output, input, 3, 1),
            Convilutional(input, output, 1, 1),
            Convilutional(output, input, 3, 1),
            Convilutional(input, output, 1, 1),
        )
    def forward(self,x):
        return self.convilutional_set(x)
class YoLoV3(nn.Module):
    def __init__(self):
        super().__init__()
        self.darknet = Darknet53()
        self.upsam = nn.Upsample(scale_factor=upsample_par)
        self.set_13 = ConvilutionalSet(*set_par13)
        self.conv_go_13 = Convilutional(set_par13[1],set_par13[1],1,1)
        self.conv_out_13 =nn.Sequential(
            Convilutional(set_par13[1], set_par13[1], 3, 1),
            nn.Conv2d(set_par13[1], out_par[0], 1, 1)
        )
        self.set_26 = ConvilutionalSet(*set_par26)
        self.conv_go_26 = Convilutional(set_par26[1], set_par26[1], 1, 1)
        self.conv_out_26 = nn.Sequential(
            Convilutional(set_par26[1], set_par26[1], 3, 1),
            nn.Conv2d(set_par26[1], out_par[1], 1, 1)
        )
        self.set_52 = ConvilutionalSet(*set_par52)
        self.conv_out_52 = nn.Sequential(
            Convilutional(set_par52[1], set_par52[1], 3, 1),
            nn.Conv2d(set_par52[1], out_par[2], 1, 1)
        )
    def forward(self,x):
        dark_out52,dark_out26,dark_out13 = self.darknet(x)
        cs13 = self.set_13(dark_out13)
        predict1 = self.conv_out_13(cs13)
        concatenate26 = torch.cat((self.upsam(self.conv_go_13(cs13)),dark_out26),dim=1)
        cs26 = self.set_26(concatenate26)
        predict2 = self.conv_out_26(cs26)
        concatenate52 = torch.cat((self.upsam(self.conv_go_26(cs26)), dark_out52), dim=1)
        cs52 = self.set_52(concatenate52)
        predict3 = self.conv_out_52(cs52)
        return predict1,predict2,predict3

if __name__ == '__main__':
    x = torch.randn(2, 3, 416, 416)
    net = YoLoV3()
    for idx in range(3):
        print(net(x)[idx].shape)

yaml参数文件保存

import yaml
upsample_par = 2
conv_par = [
    [32,64,3,2],
    [64,128,3,2],
    [128,256,3,2],
    [256,512,3,2],
    [512,1024,3,2]
]
res_par = [
    [1,64],
    [2,128],
    [8,256],
    [8,512],
    [4,1024]
]
set_par13 = [res_par[4][1],512]
set_par26 = [set_par13[1]+res_par[3][1],256]
set_par52 = [set_par26[1]+res_par[2][1],128]
out_par = [256,128,64]
class yaml_data():
    def read_yaml(self,path='./par_data.yaml'):
        with open(path, 'r', encoding='utf-8') as file:
            upsample_par,conv_par,res_par,set_par13,set_par26,set_par52,out_par = yaml.safe_load_all(file)
            print(upsample_par,conv_par,res_par,set_par13,set_par26,set_par52,out_par)
        return upsample_par,conv_par,res_par,set_par13,set_par26,set_par52,out_par
    def write_yaml(self,path='./par_data.yaml'):
        with open(path,'w',encoding='utf-8') as file:
            yaml.safe_dump_all([upsample_par,conv_par,res_par,set_par13,set_par26,set_par52,out_par],file)

yamldata = yaml_data()
# yamldata.write_yaml()
yamldata.read_yaml()

主干网络的感受野计算

# 感受野
k_list = [3, 3, 1, 3, 3, 1, 3, 1, 3, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1,
3, 1, 3, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 3, 1, 3, 1, 3, 1, 3,
1, 3 ]
s_list = [1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1,
1, 1]
def prod(nums):
    if len(nums) == 1:
        return nums[0]
    else:
        return nums[0] * prod(nums[1:])

def look_areas(n):
    if n-1 == 0:
        return k_list[0]
    return look_areas(n-1) + (k_list[n-1] - 1)*prod(s_list[0:n-1])


print(look_areas(52))