记录：VGG16的环境配置、运行结果

一、环境配置（unbantu20）

Anaconda：

1、清华镜像选择Anaconda3-2020.11-Linux-x86_64.sh进行下载。
2、进入下载文件所在目录，再执行bash Anaconda3-2020.11-Linux-x86_64.sh进行安装。
3、将Anaconda添加到用户环境变量中，使用vim编辑器打开 .bashrc 环境变量文件：vim ~/.bashrc，文4、件末尾插入export PATH=“/home/用户名/anaconda3/bin:$PATH”，保存。

Pytorch：

1、进入 Pytorch 官网，下滑找到配置列表，按照图示参数进行选择下载，先复制命令。
2、创建虚拟环境：conda create -n pytorch1110 python=3.6
3、激活虚拟环境：conda activate pytorch1110
4、输入下载命令

Pycharm：

1、在软件中心安装
2、新建项目，选择创建好的pytorch1110环境

二、VGG16：

代码：

import torch
import torch.nn as nn
from torchvision import transforms, datasets
from torch.utils.data.dataloader import DataLoader
from torch import optim
from tqdm import tqdm
from torch.autograd import Variable


batch_size = 128        # 批的大小
learning_rate = 1e-3    # 学习率
epochs = 5      # 遍历训练集的次数

# 设置transforms
transform = transforms.Compose([
    transforms.ToTensor(),  # numpy -> Tensor
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))  # 归一化
])
# 下载训练集
train_set = datasets.CIFAR10(root='/home/orange/datas/cifar-10-python', train=True, download=True, transform=transform)
# 下载测试集
test_set = datasets.CIFAR10(root='/home/orange/datas/cifar-10-python', train=False, download=True, transform=transform)
# 批量读取数据
train_loader = DataLoader(train_set, batch_size=batch_size, shuffle=True, num_workers=4, pin_memory=True)
test_loader = DataLoader(test_set, batch_size=batch_size, shuffle=True, num_workers=4, pin_memory=True)
classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

# 定义网络模型
class VGG16(nn.Module):
    def __init__(self, num_classes=10):
        super(VGG16, self).__init__()
        self.features = nn.Sequential(

            # ---block1：2次卷积、一次池化---
            # 1 224*224*3 -> 224*224*64
            nn.Conv2d(3, 64, kernel_size=3, padding=1),
            # 将数据拉回到均值为0，方差为1的正太分布上
            # 一方面使得数据分布一致，另一方面避免梯度消失。
            nn.BatchNorm2d(64),
            # inplace-选择是否进行覆盖运算
            # 对从上层网络Conv2d中传递下来的tensor直接进行修改，
            # 这样能够节省运算内存，不用多存储其他变量
            nn.ReLU(True),
            # 2 224*224*64 -> 224*224*64
            nn.Conv2d(64, 64, kernel_size=3, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(True),
            # 224*224*64 -> 112*112*64
            nn.MaxPool2d(kernel_size=2, stride=2),

            # ---block2：2次卷积、一次池化---
            # 3 112*112*64 -> 112*112*128
            nn.Conv2d(64, 128, kernel_size=3, padding=1),
            nn.BatchNorm2d(128),
            nn.ReLU(True),
            # 4 112*112*128 -> 112*112*128
            nn.Conv2d(128, 128, kernel_size=3, padding=1),
            nn.BatchNorm2d(128),
            nn.ReLU(True),
            # 112*112*128 -> 56*56*128
            nn.MaxPool2d(kernel_size=2, stride=2),

            # ---block3：3次卷积、一次池化---
            # 5 56*56*128 -> 56*56*256
            nn.Conv2d(128, 256, kernel_size=3, padding=1),
            nn.BatchNorm2d(256),
            nn.ReLU(True),
            # 6 56*56*256 -> 56*56*256
            nn.Conv2d(256, 256, kernel_size=3, padding=1),
            nn.BatchNorm2d(256),
            nn.ReLU(True),
            # 7 56*56*256 -> 56*56*256
            nn.Conv2d(256, 256, kernel_size=3, padding=1),
            nn.BatchNorm2d(256),
            nn.ReLU(True),
            # 56*56*256 -> 28*28*256
            nn.MaxPool2d(kernel_size=2, stride=2),

            # ---block4：3次卷积、一次池化---
            # 8 28*28*256 -> 28*28*512
            nn.Conv2d(256, 512, kernel_size=3, padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(True),
            # 9 28*28*512 -> 28*28*512
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(True),
            # 10 28*28*512 -> 28*28*512
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(True),
            # 28*28*512 -> 14*14*512
            nn.MaxPool2d(kernel_size=2, stride=2),
            
            # ---block5：3次卷积、一次池化---
            # 11 14*14*512 -> 14*14*512
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(True),
            # 12 14*14*512 -> 14*14*512
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(True),
            # 13 14*14*512 -> 14*14*512
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(True),
            # 14*14*512 -> 7*7*512
            nn.MaxPool2d(kernel_size=2, stride=2),
			
            nn.AvgPool2d(kernel_size=1, stride=1),
        )
        # 三次全连接
        self.classifier = nn.Sequential(
            # 14 第一次
            nn.Linear(512, 4096),
            nn.ReLU(True),
            nn.Dropout(),
            # 15 第二次
            nn.Linear(4096, 4096),
            nn.ReLU(True),
            nn.Dropout(),
            # 16 第三次
            nn.Linear(4096, num_classes),
        )

    def forward(self, x):
        out = self.features(x)
        #        print(out.shape)
        out = out.view(out.size(0), -1)
        #        print(out.shape)
        out = self.classifier(out)
        #        print(out.shape)
        return out


# 创建model实例对象，并检测是否支持使用GPU
model = VGG16()
use_gpu = torch.cuda.is_available()  # 判断是否有GPU加速
if use_gpu:
    model = model.cuda()

# 定义loss和optimizer
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=learning_rate)

# 训练模型
for epoch in range(epochs):
    print('*' * 25, 'epoch {}'.format(epoch + 1), '*' * 25)  # .format为输出格式，format括号里的即为左边花括号的输出
    running_loss = 0.0
    running_acc = 0.0
    for i, data in tqdm(enumerate(train_loader, 1)):
        img, label = data
        # cuda
        if use_gpu:
            img = img.cuda()
            label = label.cuda()
        img = Variable(img)
        label = Variable(label)
        # 向前传播
        out = model(img)
        loss = criterion(out, label)
        running_loss += loss.item() * label.size(0)
        _, pred = torch.max(out, 1)  # 预测最大值所在的位置标签
        num_correct = (pred == label).sum()
        accuracy = (pred == label).float().mean()
        running_acc += num_correct.item()
        # 向后传播
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    print('Finish {} epoch, Loss: {:.6f}, Acc: {:.6f}'.format(epoch + 1, running_loss / (len(train_set)),
                                                              running_acc / (len(train_set))))

    model.eval()  # 模型评估
    eval_loss = 0
    eval_acc = 0
    for data in test_loader:  # 测试模型
        img, label = data
        if use_gpu:
            img = Variable(img, volatile=True).cuda()
            label = Variable(label, volatile=True).cuda()
        else:
            img = Variable(img, volatile=True)
            label = Variable(label, volatile=True)
        out = model(img)
        loss = criterion(out, label)
        eval_loss += loss.item() * label.size(0)
        _, pred = torch.max(out, 1)
        num_correct = (pred == label).sum()
        eval_acc += num_correct.item()
    print('Test Loss: {:.6f}, Acc: {:.6f}'.format(eval_loss / (len(test_set)), eval_acc / (len(test_set))))
    print()


# 保存模型
torch.save(model.state_dict(), '/home/orange/PycharmProjects/models/VGG16')

结果：