计算机视觉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))