Pytorch图像分类：03使用PyTorch搭建VGG模型

最新推荐文章于 2024-09-07 17:44:40 发布

心之所向h

最新推荐文章于 2024-09-07 17:44:40 发布

阅读量834

点赞数 24

分类专栏： Pytorch图像分类文章标签： pytorch 分类人工智能

本文链接：https://blog.csdn.net/qq_54695558/article/details/140807026

版权

Pytorch图像分类专栏收录该内容

6 篇文章 0 订阅

订阅专栏

【简介】：基于flower_data使用PyTorch搭建VGG模型进行图片分类
【参考】：4.1 VGG网络详解及感受野的计算_哔哩哔哩_bilibili
【代码完整版】：03 VGG(github.com)

注：本人还在学习初期，此文是为了梳理自己所学整理的，有些说法是自己的理解，不一定对，如有差错，请批评指正！

一、基础知识

1.背景

VGGNet是牛津大学计算机视觉组（Visual Geometry Group）和Google DeepMind公司的研究员在2014年一起研发的深度卷积神经网络。

2.网络的亮点

网络的亮点是通过将大量的3x3卷积堆叠成块来替代大尺度卷积核，可以通过堆叠两个3x3的卷积核来替代5x5的卷积核，堆叠三个3x3的卷积核来替代7x7的卷积核，原因是它们拥有相同的感受野，但若使用3x3卷积块所需要的参数会减少很多。

补充：感受野指的是输出特征图上一个单元对应输入层上的区域大小，计算感受野的步骤与计算特征图的步骤相反。
这里有两个问题，一是为什么堆叠三个3x3的卷积核可以来替代7x7的卷积核？二是为什么使用堆叠的卷积核可以减小参数？
首先回答第一个：🤔为什么堆叠三个3x3的卷积核可以来替代7x7的卷积核？

计算特征图的过程是这样的：
在这里插入图片描述
如果输入层经过3个卷积层之后，特征图的大小变为1x1,则倒推回去，输入层的大小为7x7，也就是为什么堆叠3个3x3的卷积可以替代一个7x7的卷积的原因，因为它们的感受野一样，输出也是一样的。
感受野推导
🤔那为什么使用堆叠的卷积核可以减小参数？
参数S=宽度W×高度H×通道数C×卷积核的个数N
在这里插入图片描述
可以看到，使用堆叠的卷积核的参数比使用一个大的卷积核的参数少了很多。

3.网络结构

接下来，在详细分析下网络结构之前，这里需要知道的是：

由于conv中的kernel_size=3,stride=1,padding=1,经公式 $out_{size}=(in_{size}-F_{size}+2P)/S+1$ 知：卷积前后，特征图的W和H都没变，变的是Channel，这与卷积核的个数有关；
由于maxpool中的kernel_size=2,stride=2知：池化后W、H减半。

vgg
具体过程为：
①当输入为224x224x3时，经过64个3x3的卷积后，特征图变为224x224x64，再经过64个3x3的卷积后，特征图仍为224x224x64，经过一个最大池化后，宽高减半，为112x112x64；
②再经过两组128个3x3的卷积后，特征图变为112x112x128,经过一个最大池化后，为56x56x128；
③经过三组256个3x3的卷积后，特征图变为56x56x256，经过一个池化层后变为28x28x256;
④经过三组512个3x3的卷积后，特征图变为28x28x512，经过一个池化层后变为14x14x512;
⑤再经过三组512个3x3的卷积后，特征图变为14x14x512，经过一个池化层后变为7x7x512;
⑥最后再经过三个全连接层和一个softmax()函数。

二、搭建模型

1.搭建AlexNet模型

还是将模型整体分为特征提取和分类器两部分，文章给出了6种模型结构（A,A-LRNB,C,D,E）这里我们只搭建A,B,D,E，上次搭建AlexNet用的是nn.Sequential模块将层结构(多个nn.Conv2d-nn.ReLU-nn.MaxPool2d）进行打包，对于这里的特征提取部分来说，每个模型就有十几层，且有4种模型配置，若还是以这种方式写，则就太麻烦了，那怎么才能简化代码呢？
在这里插入图片描述
可以看到，在特征提取部分，只有两种基本结构：卷积-池化，层与层之间不同的只是卷积的数量，所以，固定的是函数nn.Conv2d和nn.MaxPool2d，需要改变的只是里面的参数，而这里面的参数，kernel_size和stride、padding都已经确定了，要变的只是channel而已，这就好办了，我们可以将一类模型的配置存储在一个列表里面，以A为例：

[64,'M',128,'M',256,256,'M',512,512,'M',512,512,'M']

数字代表卷积核的个数，'M’表示池化层，以一个字典来存储这四种配置：

cfgs={
    'vgg11':[64,'M',128,'M',256,256,'M',512,512,'M',512,512,'M'],
    'vgg13':[64,64,'M',128,128,'M',256,256,'M',512,512,'M',512,512,'M'],
    'vgg16':[64,64,'M',128,128,'M',256,256,256,'M',512,512,512,'M',512,512,512,'M'],
    'vgg19':[64,64,'M',128,128,'M',256,256,256,256,'M',512,512,512,512,'M',512,512,512,512,'M']
}

根据配置组合feature部分（由于feature部分的复杂性，我们将其单独拎出来，用一个函数实现）：

def make_fatures(cfg:list):
    layers=[]
    in_channels=3
    for v in cfg:
        if v=="M":
            layers+=[nn.MaxPool2d(kernel_size=2,stride=2)]
        else:
            conv2d=nn.Conv2d(in_channels,v,kernel_size=3,padding=1)
            layers+=[conv2d,nn.ReLU(True)]
            in_channels=v
    return nn.Sequential(*layers)

该函数的参数是我们刚才设置的配置列表，通过for循环遍历配置列表，然后得到有卷积操作和池化操作的一个列表，最后通过nn.Sequential将我们的列表以非关键字参数的形式传入。
🤔什么是非关键字参数呢？如何理解这里的 return nn.Sequential(*layers)?
非关键字参数就是可变参数，( * arg,**arg2)的形式，使用非关键字参数可以使函数的参数个数不受限制。
从nn.Sequential的定义来看，输入要么是有序字典orderdict，要么是一系列的模型在这里插入图片描述
而我们的是列表，所以这里需要用 * 拆分一下，由于这里是实参，list将被拆分成一个个元素送入nn.Sequential，就是上图第一种形式，这里补充一下 * 的用法：

*加在实参上：代表的是将输入迭代器拆成一个个元素。
*加在形参上：单个星号代表这个位置接收任意多个非关键字参数，转化成元组方式，如下：

而 ** kwargs 表示关键字参数，它本质上是一个 dict，如：

解决了features部分，现在来写主体部分，在model.py文件里面，定义VGG类，这里面还是有两个主要函数__init__()和forward(),分别用于定义网络模型在正向传播过程中需要用到的层结构、进行正向传播，此外，还有一个_initialize_weights用于模型权重的初始化。

import torch
from torch import nn
class VGG(nn.Module):
    def __init__(self,features,num_classes=1000,init_weights=False):
        super(VGG,self).__init__()
        self.features=features
        self.classifier=nn.Sequential(
            nn.Dropout(p=0.5),
            nn.Linear(7*7*512,4096),
            nn.ReLU(inplace=True),

            nn.Dropout(p=0.5),
            nn.Linear(4096, 4096),
            nn.ReLU(inplace=True),

            nn.Linear(4096, num_classes),
        )

        if init_weights:
            self._initialize_weights()
    def forward(self,x):
        x=self.features(x)
        x=torch.flatten(x,start_dim=1)
        x=self.classifier(x)
        return x

    def _initialize_weights(self):
        for m in self.modules():
            if isinstance(m,nn.Conv2d):
                nn.init.xavier_uniform_(m.weight)
                if m.bias is not None:
                    nn.init.constant_(m.bias,0)
            elif isinstance(m,nn.Linear):
                nn.init.xavier_uniform_(m.weight)
                nn.init.constant_(m.bias, 0)

最后，实例化VGG网络：

def vgg(model_name="vgg16",**kwargs):
    model=VGG(make_features(cfgs[model_name]),**kwargs)#**kwargs表示可变长度的字典变量
    return model

2.训练

2.1数据预处理

1）定义数据预处理函数

data_transform={
    "train":transforms.Compose([
        transforms.RandomResizedCrop(224),
        transforms.RandomHorizontalFlip(),
        transforms.ToTensor(),
        transforms.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5))
    ]),
    "val":transforms.Compose([
        transforms.Resize((224,224)),
        transforms.ToTensor(),
        transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
    ])
}

2）读取数据，进行数据预处理

train_data=datasets.ImageFolder(root="../data/flower_data/"+"train",
                                transform=data_transform["train"])

validate_data=datasets.ImageFolder(root="../data/flower_data/"+"val",
                                transform=data_transform["val"])

3）加载数据

train_loader=DataLoader(train_data,batch_size=32,shuffle=True,num_workers=0)
validate_loader=DataLoader(validate_data,batch_size=32,shuffle=False,num_workers=0)

4）将类名写入json文件
🤔为什么要将类名写入json文件？
保存类名，是为了方便预测时直接获取类名。
JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式，是用于存储和交换数据的语法，易于人阅读和编写。

python里面的语言对象一般只有python能读懂，为了能比较好储存，而且能够让别的编程语言也能读懂这些数据，就会用json来转换储存。或者说把json数据类型的转化成python的数据类型。

怎么做？
python–>json:主要用到json.dumps()
import json
x = {'name':'你猜','age':19,'city':'四川'}
#用dumps将python编码成json字符串
y = json.dumps(x)
print(y)
z = json.dumps(x, indent=2)#indent表示数据格式缩进2个字符显示
print(z)
json->python:主要用到json.loads()
import json
jsonData = '{"a":1,"b":2,"c":3,"d":4,"e":5}';
text = json.loads(jsonData)
print(text)

#获取 类名-idx
flower_list=train_data.class_to_idx#{'daisy': 0, 'dandelion': 1, 'roses': 2, 'sunflowers': 3, 'tulips': 4}
flower_dict=dict((val,key) for key,val in flower_list.items())
json_str=json.dumps(flower_dict,indent=4)
with open('class_indices.json','w') as json_file:
    json_file.write(json_str)

到时在predict.py中:

# read class_indice
json_path='./class_indices.json'
assert os.path.exists(json_path), "file: '{}' does not exist".format(json_path)

with open(json_path,"r") as file:
    class_indice=json.load(file)

2.2定义模型、损失函数、优化器

model_name="vgg16"
net=vgg(model_name=model_name,num_classes=5,init_weights=True)
net=net.to(device)
loss_fn=nn.CrossEntropyLoss()
optimizer=torch.optim.Adam(net.parameters(),lr=0.0001)

2.3模型训练

epoches=3
val_num=len(validate_data)
save_path='./VGG.pth'
best_acc=0.0
for epoch in range(epoches):
    #train +running_loss in epoch
    net.train()
    running_loss=0.0;
    train_bar=tqdm(train_loader,file=sys.stdout)
    for step,data in enumerate(train_bar):
        # data=data.to(device)#AttributeError: 'list' object has no attribute 'to'
        images,labels=data

        optimizer.zero_grad()
        outputs=net(images.to(device))
        loss=loss_fn(outputs,labels.to(device))
        loss.backward()
        optimizer.step()

        running_loss+=loss
        # print("train epoch[{}/{}] running loss:{:.3f}").format(epoch+1,epoches,running_loss)
        train_bar.desc="train epoch[{}/{}] running loss:{:.3f}".format(epoch+1,epoches,loss)


    #validate
    net.eval()
    acc = 0.0
    val_bar=tqdm(validate_loader,file=sys.stdout)
    with torch.no_grad():
        for val_data in (val_bar):
            val_images,val_labels=val_data
            outputs=net(val_images.to(device))
            pred=torch.max(outputs,dim=1)[1]
            acc+=torch.eq(pred,val_labels.to(device)).sum().item()
        val_accuracy=acc/val_num
        val_bar.desc="[epoch {}] training loss:{:.3f} val accuracy:{:.3f}".format(epoch+1,running_loss,val_accuracy)

    if val_accuracy > best_acc:
        best_acc = val_accuracy
        torch.save(net.state_dict(), save_path)
print("Finished Training!")

3.预测

3.1数据预处理

①定义数据预处理工具包

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

data_transform = transforms.Compose(
    [transforms.Resize((224, 224)),
     transforms.ToTensor(),
     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])

②准备数据

# load image
    img_path = "./tulip.jpg"
    assert os.path.exists(img_path), "file: '{}' dose not exist.".format(img_path)
    img = Image.open(img_path)
    plt.imshow(img)
    # [N, C, H, W]
    img = data_transform(img)
    # expand batch dimension
    img = torch.unsqueeze(img, dim=0)

③读取json文件获取类名

    # read class_indict
    json_path = './class_indices.json'
    assert os.path.exists(json_path), "file: '{}' dose not exist.".format(json_path)

    with open(json_path, "r") as f:
        class_indict = json.load(f)

3.2模型

定义并加载模型

 # create model
    model = vgg(model_name="vgg16", num_classes=5).to(device)
    # load model weights
    weights_path = "./vgg16Net.pth"
    assert os.path.exists(weights_path), "file: '{}' dose not exist.".format(weights_path)
    model.load_state_dict(torch.load(weights_path, map_location=device))

3.3预测

    model.eval()
    with torch.no_grad():
        # predict class
        output = torch.squeeze(model(img.to(device))).cpu()
        predict = torch.softmax(output, dim=0)
        predict_cla = torch.argmax(predict).numpy()

    print_res = "class: {}   prob: {:.3}".format(class_indict[str(predict_cla)],
                                                 predict[predict_cla].numpy())
    plt.title(print_res)
    for i in range(len(predict)):
        print("class: {:10}   prob: {:.3}".format(class_indict[str(i)],
                                                  predict[i].numpy()))
    plt.show()

输出>:

class: daisy        prob: 0.00585
class: dandelion    prob: 0.000423
class: roses        prob: 0.299
class: sunflowers   prob: 0.00268
class: tulips       prob: 0.692