手把手教你使用pytorch搭建基于cifar数据集的Alxnet网络

作者:lmx 钓鱼代码，能跑，但别当作业交

数据集准备 

import torch
import torchvision
import torch.nn as nn
import numpy as np
import torchvision.transforms as transforms
#超参数定义
EPOCH = 10
BATCH_SIZE = 64
LR = 0.001
#定义对数据的预处理
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5)),  #归一化
])

# 下载CIFAR-10数据集到当前data文件夹中
train_dataset = torchvision.datasets.CIFAR10(root='F:\PYWORK\pytorch\dataset\cifar-10-python',
                                             train=True,
                                             transform=transform,
                                             download=False)
test_dataset = torchvision.datasets.CIFAR10(root='F:\PYWORK\pytorch\dataset\cifar-10-python',
                                             train=False,
                                             transform=transform,
                                             download=False)

数据集预处理

from torch.utils.data import DataLoader
#使用DataLoader进行数据分批，dataset代表传入的数据集，batch_size表示每个batch有多少个样本
#shuffle表示在每个epoch开始的时候，对数据进行重新排序
#数据分批之前：torch.Size([3, 32, 32])：Tensor[[32*32][32*32][32*32]],每一个元素都是归一化之后的RGB的值；数据分批之后：torch.Size([64, 3, 32, 32])
#数据分批之前：train_data([50000[3*[32*32]]])
#数据分批之后：train_loader([50000/64*[64*[3*[32*32]]]])
train_loader = DataLoader(dataset=train_dataset,batch_size=BATCH_SIZE,shuffle=True,num_workers=2)
test_loader = DataLoader(dataset=test_dataset,batch_size=BATCH_SIZE,shuffle=True,num_workers=2)

可以看一下数据集 

import matplotlib.pyplot as plt
classes = ('plane', 'car', 'bird', 'cat',
           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
# 可以画一下cifar数据集
dataiter = iter(train_dataset)
plt.show()
for i in range(10):
    images, labels = dataiter.__next__()
    print(images.size())
    images = images.numpy().transpose(1, 2, 0)  # 把channel那一维放到最后
    plt.title(str(classes[labels]))
    plt.imshow(images)
    plt.pause(1)

images=torch.from_numpy(images)

 定义网络，优化器，损失函数

import torch
import torch.nn as nn
import torch.nn.functional as F
 
class Model(nn.Module):
    def __init__(self, **kwargs):
        super(Model, self).__init__(**kwargs)

        # 第一层是 4*4 的卷积，输入的channels是3，输出的channels是64,步长 2,没有 padding
        # Conv2d 的第一个参数为输入通道，第二个参数为输出通道，第三个参数为卷积核大小
        # ReLU 的参数为inplace，True表示直接对输入进行修改，False表示创建新创建一个对象进行修改
        # 3*32*32
        self.conv1 = nn.Sequential(
            
            nn.Conv2d(3,64,kernel_size=4,stride=2),# 64*15*15
            nn.ReLU(True)
        )
        
        
        # 第二层为 2*2 的池化，步长为1，没有padding
        self.max_pool1 = nn.MaxPool2d(kernel_size=2, stride=1)# 64*14*14
        
        #第三层是3*3的卷积，输入的channels是64，输出的channels是256,步长为1, padding为1
        self.conv2 = nn.Sequential(
            nn.Conv2d(64, 256, kernel_size=3, padding=1),#256*14*14
            nn.ReLU(True)
        )
        
        #第四层是 2*2 的池化， 步长是2，没有padding
        self.max_pool2 = nn.MaxPool2d(kernel_size=2,stride=2)#256*7*7

        # 使用三个连续的卷积层和较小的卷积窗口。
        # 除了最后的卷积层，输出通道的数量进一步增加。
        # 在前两个卷积层之后，汇聚层不用于减少输入的高度和宽度
        
        self.conv3= nn.Sequential(
            nn.Conv2d(256, 384, kernel_size=3, padding=1),#384*7*7
            nn.ReLU(True)
        )

        self.conv4= nn.Sequential(
            nn.Conv2d(384, 384, kernel_size=3, padding=1),#384*7*7
            nn.ReLU(True)
        )

        self.conv5= nn.Sequential(
            nn.Conv2d(384,256, kernel_size=3, padding=1),#256*7*7
            nn.ReLU(True)
        )

        # 第八层是 2*2 的池化， 步长是 1，没有padding
        self.max_pool3 = nn.MaxPool2d(kernel_size=2,stride=1)#256*6*6
        
        #第九层张量展平
        self.flaten1=nn.Flatten()

        #第10层是全连接层，输入是 9216 ，输出是4608
        self.fc1 = nn.Sequential(
            nn.Linear(9216,4608),
            nn.ReLU(True),
            nn.Dropout(p=0.5)
        )
        
        # 第六层是全连接层，输入是 4608， 输出是4608
        self.fc2 = nn.Sequential(
            nn.Linear(4608, 4608),
            nn.ReLU(True),
            nn.Dropout(p=0.5)
        )
        
        # 第七层是全连接层，输入是4608， 输出是 10
        self.fc3 = nn.Linear(4608, 10)

    def forward(self, x):
        x = self.conv1(x)
        x = self.max_pool1(x)
        x = self.conv2(x)
        x = self.max_pool2(x)
        x = self.conv3(x)
        x = self.conv4(x)
        x = self.conv5(x)
        x = self.max_pool3(x)
        x = self.flaten1(x)
        x = self.fc1(x)
        x = self.fc2(x)
        x = self.fc3(x)
        return x  

#实例化model
model=Model()
#调用gpu
model=model.cuda()
#优化器选用SGD
optimize=torch.optim.SGD(model.parameters(),lr=0.05)
#损失函数选用交叉熵损失函数
loss_fn=nn.CrossEntropyLoss()  
#输出模型
print(model)

看一下模型各层的参数

#打印模型各层参数
from torchsummary import summary
summary(model, (3, 32, 32)) 

训练模型

for epoch in range(25):
    Loss=0
    sum=0
    for i,data in enumerate(train_loader):
        #取出数据及标签
        inputs,labels = data
        #梯度清空
        optimize.zero_grad()
        #前向传播
        pred=model(inputs.cuda())
        #计算损失
        loss=loss_fn(pred,labels.cuda())
        #反向传播
        loss.backward()
        #梯度更新
        optimize.step()
        # 计算损失
        Loss=Loss+loss
        sum=i
    print(Loss/sum)

查看正确率

correct = 0 #定义的预测正确的图片数
total = 0#总共图片个数
# 在使用pytorch时，并不是所有的操作都需要进行计算图的生成（计算过程的构建，以便梯度反向传播等操作）。而对于tensor的计算操作，默认是要进行计算图的构建的，在这种情况下，可以使用 with torch.no_grad():，强制之后的内容不进行计算图构建。
with torch.no_grad():
    for data in test_loader:
        images,labels = data
        outputs = model(images.cuda())
        _,predict = torch.max(outputs,1)
        total += labels.size(0)
        correct += (predict == labels.cuda()).sum()
print('测试集中的准确率为：%d%%'%(100*correct/total))

最后结果我训练的能达到81%