计算机视觉PyTorch实现图像分类（二） - AlexNet

手写数字识别-AlexNet

1.深度学习工程结构

构建深度学习模型，实现数据训练测试是一个很复杂过程，建立一个合理的工程结构，把工程模型拆分成几个文件，每个文件负责深度学习工程一部分。常见的深度学习工程文件排列：

project/
      data.py
      utils.py
      model.py
      train.py
      inference.py

如上图所示，project表示整个工程的目录。

• data.py：实现数据载入的功能，包含数据载入相关的Dataset类和DataLoader类
• utils.py：包含深度学习工程一些工具，如对模型的模块和参数的一些预处理
• model.py：构建深度模型
• train.py：训练模型
• inference：测试集预测

2.数据集准备 data.py

pytorch自带数据集

from torchvision.datasets import MNIST
import torchvision.transforms as transforms
from torch.utils.data import DataLoader

data_train=MNIST('./data',
                 download=True,
                 transform=transforms.Compose([
                     transforms.Resize((32,32)),
                     transforms.ToTensor()]))
data_test=MNIST('./data',
                train=False,                
                download=True,
                transform=transforms.Compose([
                     transforms.Resize((32,32)),
                     transforms.ToTensor()]))

data_train_loader=DataLoader(data_train,batch_size=256,shuffle=True,num_workers=8)
data_test_loader=DataLoader(data_test,batch_size=1024,num_workers=8)

如上代码所示，首先构建data_train和data_test来下载数据，接着将下载的数据，保存到data_train_loader和data_test_loader中。

• download=True，表示数据会下载到对应data文件夹下
• transforms.Reszie，对每个数据图像进行转化
• transforms.ToTensor：将图像转变为浮点张量
• batch_size：每批训练的样本数量
• shuffle：是否打乱数据集顺序
• num_workers：表示使用几个线程来迭代批次，多线程迭代速度更快

自己的数据集
这里只展示训练集分割

class Dataset(Dataset):
    def __init__(self):
        #读取数据，这里可以使用自己方式pd.read_csv
        data = np.loadtxt('../data.csv.gz', delimiter=',', dtype=np.float32) # 使用numpy读取数据
        self.x_data = torch.from_numpy(data[:, 0:-1])
        self.y_data = torch.from_numpy(data[:, [-1]])
        self.len = data.shape[0]
    
    def __getitem__(self, index):
        return self.x_data[index], self.y_data[index]

    def __len__(self):
        return self.len

# 实例化这个类，然后我们就得到了Dataset类型的数据，记下来就将这个类传给DataLoader，就可以了。    
Dataset = Dataset()

data_train_loader = DataLoader(dataset=Dataset,
                          batch_size=256,
                          shuffle=True，
                          num_workers=8)

3.模型构建 model.py

AlexNet模型：

这里由于输出的是对十个数字的概率情况，分类种类为10，因此最后softmax数量为10

import torch.nn as nn
import torch


class AlexNet(nn.Module):
    def __init__(self, num_classes=10, init_weights=False):
        super(AlexNet, self).__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 48, kernel_size=11, stride=4, padding=2),  # input[3, 224, 224]  output[48, 55, 55]
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),                  # output[48, 27, 27]
            nn.Conv2d(48, 128, kernel_size=5, padding=2),           # output[128, 27, 27]
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),                  # output[128, 13, 13]
            nn.Conv2d(128, 192, kernel_size=3, padding=1),          # output[192, 13, 13]
            nn.ReLU(inplace=True),
            nn.Conv2d(192, 192, kernel_size=3, padding=1),          # output[192, 13, 13]
            nn.ReLU(inplace=True),
            nn.Conv2d(192, 128, kernel_size=3, padding=1),          # output[128, 13, 13]
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),                  # output[128, 6, 6]
        )
        self.classifier = nn.Sequential(
            nn.Dropout(p=0.5),
            nn.Linear(128 * 6 * 6, 2048),
            nn.ReLU(inplace=True),
            nn.Dropout(p=0.5),
            nn.Linear(2048, 2048),
            nn.ReLU(inplace=True),
            nn.Linear(2048, num_classes),
        )


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

4.模型训练 train.py

import torch
import torch.nn as nn
import torch.optim as optim
from model import AlexNet
from data import data_train_loader


#定义模型
model=AlexNet()
#训练模型
model.train()
#定义学习率
lr=0.01
#定义损失函数
criterion=nn.CrossEntropyLoss()
#定义优化器
optimizer=optim.SGD(model.parameters(),lr=lr,momentum=0.9,weight_decay=5e-4)

train_loss=0
correct=0
total=0

#定义训练多少批次
epoch=20
for epoch in range(21):
    epoch= epoch+ 1
    for i,data in enumerate(data_train_loader):
        inputs,labels=data
         # 每次迭代清空上一次梯度
        optimizer.zero_grad()
        outputs=model(inputs)
        loss=criterion(outputs,labels)
        # 反向传播
        loss.backward()
        # 更新梯度
        optimizer.step()
        
        train_loss+=loss.item()
        _,predicted = outputs.max(1)
        total += labels.size(0)
        correct += predicted.eq(labels).sum().item()
        
        print(" epoch: {}".format(epoch))
        print(i,'loss: %.3f | acc: %.3f%%(%d/%d)'%(train_loss/(i+1),100.*correct/total,correct,total))

这里插入一个模型的保存和重新加载模型的方法。模型保存分为

• 1.整个网络结构和参数一起保存

#模型保存
torch.save(AlexNet,'AlexNet.pkl')
#模型加载
AlexNet=torch.load('AlexNet.pkl')

• 2.只保存网络参数

#模型保存
torch.save(AlexNet.state_dict(),'AlexNet_params.pkl')
#模型加载
AlexNet=nn.Sequential('定义好网络层')
AlexNet.load_state_dict(torch.load('AlexNet_params.pkl'))

5.模型预测（推断） inference.py

import torch
import torch.nn as nn
from model import AlexNet

#定义模型参数
save_info={
    "iter_num":iter_num, #迭代步数
    "optimizer":optimizer.state_dict(), #优化器的参数
    "model":model.state_dict()} #模型的参数
#加载模型
model_path='AlexNet.pkl'
save_info=torch.load(model_path)
model=AlexNet()

#定义损失函数
criterion=nn.CrossEntropyLoss()
#载入模型参数
model.load_state_dict(save_info["model"])
model.eval() #切换测试状态

test_loss=0
correct=0
total=0

for i,data in enumerate(data_test_loader):
     inputs,labels=data
     outputs=model(inputs)
     loss=criterion(outputs,labels)

     test_loss+=loss.item()
     _,predicted = outputs.max(1)
     total += labels.size(0)
     correct += predicted.eq(labels).sum().item()

      print(i,'loss: %.3f | acc: %.3f%%(%d/%d)'%(test_loss/(i+1),100.*correct/total,correct,total))