pytorch入门 - VGG16神经网络

1. VGG16背景介绍

VGG-16是由牛津大学Visual Geometry Group(VGG)在2014年提出的深度卷积神经网络模型，它在当年的ImageNet大规模视觉识别挑战赛(ILSVRC)中取得了优异的成绩。

VGG-16的主要贡献在于展示了通过使用更小的卷积核(3×3)和增加网络深度可以显著提升模型性能。

VGG网络系列包括VGG-11、VGG-13、VGG-16和VGG-19等不同深度的变体，其中VGG-16是最为流行的一个版本。"16"表示网络中包含权重参数的层数(13个卷积层和3个全连接层)。

VGG网络的主要特点包括：

• 全部使用3×3的小卷积核
• 通过堆叠多个卷积层增加网络深度
• 每经过一个池化层，特征图数量翻倍
• 简单而统一的架构设计

2. VGG16架构详解

VGG-16的网络架构可以分为两个主要部分：卷积层部分和全连接层部分。

卷积层部分

VGG-16包含5个卷积块，每个块后接一个最大池化层：

1. ​​Block1​​: 2个卷积层(64通道) + 最大池化
2. ​​Block2​​: 2个卷积层(128通道) + 最大池化
3. ​​Block3​​: 3个卷积层(256通道) + 最大池化
4. ​​Block4​​: 3个卷积层(512通道) + 最大池化
5. ​​Block5​​: 3个卷积层(512通道) + 最大池化

所有卷积层都使用3×3的卷积核，padding=1保持空间尺寸不变，激活函数使用ReLU。池化层使用2×2的窗口，stride=2，将特征图尺寸减半。

全连接层部分

卷积层后接3个全连接层：

1. 第一个全连接层：4096个神经元
2. 第二个全连接层：4096个神经元
3. 第三个全连接层：1000个神经元(对应ImageNet的1000类)

在训练时，全连接层使用了Dropout(0.5)来防止过拟合。

3. 每层参数计算详解

让我们详细计算VGG16各层的参数数量。假设输入为224×224×3的RGB图像。

卷积层参数计算

卷积层的参数数量计算公式为：

参数数量 = (卷积核宽度 × 卷积核高度 × 输入通道数 + 1) × 输出通道数

(其中+1是偏置项)

以Block1的第一个卷积层为例：

• 输入通道：3
• 输出通道：64
• 卷积核：3×3
  
  参数数量 = (3×3×3 + 1)×64 = 28×64 = 1,792

全连接层参数计算

全连接层的参数数量计算公式为：

参数数量 = (输入特征数 + 1) × 输出特征数

以第一个全连接层为例：

• 输入特征数：512×7×7 = 25,088
• 输出特征数：4096
  
  参数数量 = (25,088 + 1)×4,096 = 102,764,544

VGG16总参数

整个VGG16网络约有1.38亿参数，其中大部分(约1.24亿)来自第一个全连接层。

4. 代码实现详解

以下是完整的VGG16实现代码，我们将逐部分解释：

模型定义 (models.py)

import os
import sys

sys.path.append(os.getcwd())

import torch
from torch import nn
from torchsummary import summary

class VGG16(nn.Module):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        # Block1: 2个卷积层(64通道) + 最大池化
        self.block1 = nn.Sequential(
            nn.Conv2d(in_channels=1, out_channels=64, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.Conv2d(in_channels=64, out_channels=64, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2, stride=2),
        )

        # Block2: 2个卷积层(128通道) + 最大池化
        self.block2 = nn.Sequential(
            nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.Conv2d(in_channels=128, out_channels=128, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2, stride=2),
        )

        # Block3: 3个卷积层(256通道) + 最大池化
        self.block3 = nn.Sequential(
            nn.Conv2d(in_channels=128, out_channels=256, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.Conv2d(in_channels=256, out_channels=256, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.Conv2d(in_channels=256, out_channels=256, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2, stride=2),
        )

        # Block4: 3个卷积层(512通道) + 最大池化
        self.block4 = nn.Sequential(
            nn.Conv2d(in_channels=256, out_channels=512, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.Conv2d(in_channels=512, out_channels=512, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.Conv2d(in_channels=512, out_channels=512, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2, stride=2),
        )

        # Block5: 3个卷积层(512通道) + 最大池化
        self.block5 = nn.Sequential(
            nn.Conv2d(in_channels=512, out_channels=512, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.Conv2d(in_channels=512, out_channels=512, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.Conv2d(in_channels=512, out_channels=512, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2, stride=2),
        )

        # 全连接层部分
        self.block6 = nn.Sequential(
            nn.Flatten(),
            nn.Linear(in_features=512 * 7 * 7, out_features=4096),
            nn.ReLU(),
            nn.Dropout(p=0.5),
            nn.Linear(in_features=4096, out_features=4096),
            nn.ReLU(),
            nn.Dropout(p=0.5),
            nn.Linear(4096, 10),
        )

        # 权重初始化
        for m in self.modules():
            print(m)
            if isinstance(m, nn.Conv2d):
                nn.init.kaiming_normal_(m.weight, mode="fan_out", nonlinearity="relu")
                if m.bias is not None:
                    nn.init.constant_(m.bias, 0)
            if isinstance(m, nn.Linear):
                nn.init.normal_(m.weight, 0, 0.01)

    def forward(self, x):
        x = self.block1(x)
        x = self.block2(x)
        x = self.block3(x)
        x = self.block4(x)
        x = self.block5(x)
        x = self.block6(x)
        return x

if __name__ == "__main__":
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model = VGG16().to(device=device)
    print(model)
    summary(model, input_size=(1, 224, 224), device=str(device))

训练代码 (train.py)

import os
import sys

sys.path.append(os.getcwd())

import time
from torchvision.datasets import FashionMNIST
from torchvision import transforms
from torch.utils.data import DataLoader, random_split
import numpy as np
import matplotlib.pyplot as plt
import torch
from torch import nn, optim
import copy
import pandas as pd

from VGG16_model.model import VGG16

def train_val_date_load():
    train_dataset = FashionMNIST(
        root="./data",
        train=True,
        download=True,
        transform=transforms.Compose(
            [
                transforms.Resize(size=224),
                transforms.ToTensor(),
            ]
        ),
    )

    train_date, val_data = random_split(
        train_dataset,
        [
            int(len(train_dataset) * 0.8),
            len(train_dataset) - int(len(train_dataset) * 0.8),
        ],
    )

    train_loader = DataLoader(
        dataset=train_date, batch_size=16, shuffle=True, num_workers=1
    )

    val_loader = DataLoader(
        dataset=val_data, batch_size=16, shuffle=True, num_workers=1
    )

    return train_loader, val_loader

def train_model_process(model, train_loader, val_loader, epochs=10):
    device = "cuda" if torch.cuda.is_available() else "cpu"
    optimizer = optim.Adam(model.parameters(), lr=0.001)
    criterion = nn.CrossEntropyLoss()
    model.to(device)

    best_model_wts = copy.deepcopy(model.state_dict())
    best_acc = 0.0
    train_loss_all = []
    val_loss_all = []
    train_acc_all = []
    val_acc_all = []

    since = time.time()

    for epoch in range(epochs):
        print(f"Epoch {epoch + 1}/{epochs}")

        train_loss = 0.0
        train_correct = 0
        val_loss = 0.0
        val_correct = 0
        train_num = 0
        val_num = 0

        for step, (images, labels) in enumerate(train_loader):
            images = images.to(device)
            labels = labels.to(device)
            model.train()
            outputs = model(images)
            pre_lab = torch.argmax(outputs, dim=1)
            loss = criterion(outputs, labels)
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()

            train_loss += loss.item() * images.size(0)
            train_correct += torch.sum(pre_lab == labels.data)
            train_num += labels.size(0)

            print(
                "Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}, Acc:{:.4f}".format(
                    epoch + 1,
                    epochs,
                    step + 1,
                    len(train_loader),
                    loss.item(),
                    torch.sum(pre_lab == labels.data),
                )
            )

        for step, (images, labels) in enumerate(val_loader):
            images = images.to(device)
            labels = labels.to(device)
            model.eval()
            with torch.no_grad():
                outputs = model(images)
                pre_lab = torch.argmax(outputs, dim=1)
                loss = criterion(outputs, labels)
                val_loss += loss.item() * images.size(0)
                val_correct += torch.sum(pre_lab == labels.data)
                val_num += labels.size(0)

                print(
                    "Epoch [{}/{}], Step [{}/{}], Val Loss: {:.4f}, Acc:{:.4f}".format(
                        epoch + 1,
                        epochs,
                        step + 1,
                        len(val_loader),
                        loss.item(),
                        torch.sum(pre_lab == labels.data),
                    )
                )

        train_loss_all.append(train_loss / train_num)
        val_loss_all.append(val_loss / val_num)
        train_acc = train_correct.double() / train_num
        val_acc = val_correct.double() / val_num
        train_acc_all.append(train_acc.item())
        val_acc_all.append(val_acc.item())
        print(
            f"Train Loss: {train_loss / train_num:.4f}, Train Acc: {train_acc:.4f}, "
            f"Val Loss: {val_loss / val_num:.4f}, Val Acc: {val_acc:.4f}"
        )
        if val_acc_all[-1] > best_acc:
            best_acc = val_acc_all[-1]
            best_model_wts = copy.deepcopy(model.state_dict())

    time_elapsed = time.time() - since
    print(
        f"Training complete in {time_elapsed // 60:.0f}m {time_elapsed % 60:.0f}s\n"
        f"Best val Acc: {best_acc:.4f}"
    )

    torch.save(model.state_dict(), "./models/vgg16_net_best_model.pth")
    train_process = pd.DataFrame(
        data={
            "epoch": range(1, epochs + 1),
            "train_loss_all": train_loss_all,
            "val_loss_all": val_loss_all,
            "train_acc_all": train_acc_all,
            "val_acc_all": val_acc_all,
        }
    )

    return train_process

def matplot_acc_loss(train_process):
    plt.figure(figsize=(12, 5))
    plt.subplot(1, 2, 1)
    plt.plot(train_process["epoch"], train_process["train_loss_all"], label="Train Loss")
    plt.plot(train_process["epoch"], train_process["val_loss_all"], label="Val Loss")
    plt.xlabel("Epoch")
    plt.ylabel("Loss")
    plt.title("Loss vs Epoch")
    plt.legend()

    plt.subplot(1, 2, 2)
    plt.plot(train_process["epoch"], train_process["train_acc_all"], label="Train Acc")
    plt.plot(train_process["epoch"], train_process["val_acc_all"], label="Val Acc")
    plt.xlabel("Epoch")
    plt.ylabel("Accuracy")
    plt.title("Accuracy vs Epoch")
    plt.legend()

    plt.tight_layout()
    plt.ion()
    plt.show()
    plt.savefig("./models/vgg16_net_output.png")

if __name__ == "__main__":
    traindatam, valdata = train_val_date_load()
    result = train_model_process(VGG16(), traindatam, valdata, 10)
    matplot_acc_loss(result)

测试代码 (test.py)

import os
import sys

sys.path.append(os.getcwd())

import torch
from torch.utils.data import DataLoader, random_split
from torchvision import datasets, transforms
from torchvision.datasets import FashionMNIST
from VGG16_model.model import VGG16

def test_data_load():
    test_dataset = FashionMNIST(
        root="./data",
        train=False,
        download=True,
        transform=transforms.Compose(
            [
                transforms.Resize(size=224),
                transforms.ToTensor(),
            ]
        ),
    )

    test_loader = DataLoader(
        dataset=test_dataset, batch_size=16, shuffle=True, num_workers=1
    )

    return test_loader

print(test_data_load())

def test_model_process(model, test_loader):
    device = "cuda" if torch.cuda.is_available() else "cpu"
    model.to(device)
    model.eval()

    correct = 0
    total = 0

    with torch.no_grad():
        for images, labels in test_loader:
            images, labels = images.to(device), labels.to(device)
            outputs = model(images)
            _, predicted = torch.max(outputs, 1)
            total += labels.size(0)
            correct += torch.sum(predicted == labels.data)

    accuracy = correct / total * 100
    print(f"Test Accuracy: {accuracy:.2f}%")

if __name__ == "__main__":
    test_loader = test_data_load()
    model = VGG16()
    model.load_state_dict(torch.load("./models/vgg16_net_best_model.pth"))
    test_model_process(model, test_loader)

5. 代码实现关键点解析

模型定义关键点

1. ​​卷积块设计​​：每个卷积块包含多个卷积层，使用3×3卷积核和ReLU激活函数，最后接一个2×2的最大池化层。

2. ​​权重初始化​​：使用Kaiming初始化方法初始化卷积层权重，使用正态分布初始化全连接层权重。

3. ​​输入适配​​：原始VGG16设计用于224×224×3的输入，这里调整为224×224×1以适应FashionMNIST数据集。

训练过程关键点

1. ​​数据加载​​：使用FashionMNIST数据集，调整大小为224×224以适应VGG16。

2. ​​训练循环​​：包含完整的训练和验证过程，记录每轮的损失和准确率。

3. ​​模型保存​​：保存验证集上表现最好的模型参数。

4. ​​可视化​​：绘制训练和验证的损失及准确率曲线。

测试过程关键点

1. ​​模型加载​​：从保存的文件加载最佳模型参数。

2. ​​评估模式​​：使用model.eval()和torch.no_grad()确保评估过程不计算梯度。

3. ​​准确率计算​​：统计所有测试样本的预测准确率。

6. 总结

VGG-16是一个经典的深度卷积神经网络，其主要特点包括：

1. ​​简单统一的设计​​：全部使用3×3卷积核和2×2池化层，结构清晰。

2. ​​深度优势​​：通过增加网络深度提高了特征提取能力。

3. ​​小卷积核优势​​：多个小卷积核堆叠可以模拟大感受野，同时减少参数数量。

4. ​​广泛应用​​：虽然现在有更高效的网络，但VGG16仍广泛用于特征提取和迁移学习。