pytorch实战——训练一个简单的分类器(CIFAR10 数据集)

步骤

  • 数据处理(读取、归一化、加载)
  • 创建网络模型(卷积&池化&全连接、前向传播、损失函数、优化器)
  • 训练网络(epoch、batch_size、打印信息)
  • 测试模型性能(加载测试数据、部分预测、整体准确率)

文件目录结构
├── data
│ └── cifar-10-batches-py
│ ├── batches.meta
│ ├── data_batch_1
│ ├── data_batch_2
│ ├── data_batch_3
│ ├── data_batch_4
│ ├── data_batch_5
│ ├── readme.html
│ └── test_batch
├── data.py
├── model.py
├── train.py
└── validate.py

数据处理(data.py)

import torch
import torchvision
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
import numpy as np

# torchvision.transforms.Compose()类的主要作用是串联多个图片变换的操作
# 即其内是对图片的一系列操作
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])


def getData():
    trainset = torchvision.datasets.CIFAR10(root='data/',
                                            train=True,
                                            download=False,
                                            transform=transform)

    trainloader = torch.utils.data.DataLoader(trainset,
                                              batch_size=4,
                                              shuffle=True,
                                              num_workers=4)
    # 使用cpu,所以batch_size设的不大
    # num_workers 通俗可理解为开几个cpu线程处理数据

    testset = torchvision.datasets.CIFAR10(root='data/',
                                           train=False,
                                           download=False,
                                           transform=transform)

    testloader = torch.utils.data.DataLoader(testset,
                                             batch_size=4,
                                             shuffle=False,
                                             num_workers=2)
    return trainloader, testloader


# 下面是数据展示
trainloader, testloader = getData()

classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse',
           'ship', 'truck')


def imshow(img):
    img = img / 2 + 0.5
    # unnormalize(反归一化),因为前面数据进行load时使用的
    # transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
    # 是先减0.5再除以0.5,现在反过来
    npimg = img.numpy()
    plt.imshow(np.transpose(npimg, (1, 2, 0)))
    # plt.imshow在现实的时候输入的是(imagesize,imagesize,channels),
    # 此处imshow(img)中,参数img的格式为(channels,imagesize,imagesize),
    # 所以要转换一下
    plt.show()


# 获取随机数据
dataiter = iter(testloader)
images, labels = dataiter.next()
# images 返回维度为[4, 3, 32, 32]的tensor,labels返回维度为[4]的tensor

# print(images.shape)
# print(labels.shape)

#print(sum(1 for _ in dataiter))

# 显示图像标签
print(' '.join('%5s' % classes[labels[j]] for j in range(4)))

# 展示图像
imshow(torchvision.utils.make_grid(images))

关于transforms.Compose()类用法详解,参见 transforms.Compose()类详解

为什么要进行图片归一化(-1, 1),因为数据如果分布在(0,1)之间,可能实际的bias,就是神经网络的输入b会比较大,而模型初始化时b=0的,这样会导致神经网络收敛比较慢,经过Normalize后,可以加快模型的收敛速度。对RGB图片而言,数据范围是[0-255]的,需要先经过ToTensor除以255归一化到[0,1]之后,再通过Normalize计算过后,将数据归一化到[-1,1]。transforms.Normalize()用法参见 transforms.Normalize()
torchvision.utils.make_grid()可将若干幅图像拼成一幅图像。

创建网络模型(model.py)

import torch.nn as nn
import torch.nn.functional as F


class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = x.view(-1, 16 * 5 * 5)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

net = Net()

nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True))

  • in_channel: 输入数据的通道数,例RGB图片通道数为3;
  • out_channel: 输出数据的通道数,根据模型进行调整;
  • kennel_size: 卷积核大小,可以是int,或tuple;kennel_size=2,意味着卷积大小2, kennel_size=(2,3),意味着卷积在第一维度大小为2,在第二维度大小为3在这里插入代码片
  • stride:步长,默认为1,与kennel_size类似,stride=2,意味在所有维度步长为2, stride=(2,3),意味着在第一维度步长为2,意味着在第二维度步长为3;
  • padding:默认零填充

nn.MaxPool2d(kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False)

  • kernel_size(int or tuple): max pooling的窗口大小,

  • stride(int or tuple, optional): max pooling的窗口移动的步长。默认值是kernel_size

  • padding(int or tuple, optional):输入的每一条边补充0的层数

  • dilation(int or tuple, optional): 一个控制窗口中元素步幅的参数

  • return_indices: 如果等于True,会返回输出最大值的序号,对于上采样操作会有帮助

  • ceil_mode: 如果等于True,计算输出信号大小的时候,会使用向上取整,代替默认的向下取整的操作


nn.Linear(in_features, out_features, bias=True)

  • in_features指的是输入的二维张量的大小,即输入的 [batch_size, size] 中的size。

  • out_features指的是输出的二维张量的大小,即输出的二维张量的形状为 [batch_size,output_size],当然,它也代表了该全连接层的神经元个数。


训练网络(train.py)

import torch.optim as optim
import torch.nn as nn
import torch
from data import getData
from model import Net, net

## 开启GPU训练阀门
# device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
# net.to(device)

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

trainloader, testloader = getData()

for epoch in range(2):  # 多批次循环

    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        # 获取输入
        inputs, labels = data
		# inputs, labels = inputs.to(device), labels.to(device)
		# 若 GPU 训练要用
		
        # 梯度置0
        optimizer.zero_grad()

        # 正向传播,反向传播,优化
        outputs = net(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        # 打印状态信息
        running_loss += loss.item()
        if i % 2000 == 1999:  # 每2000批次打印一次
            print('[%d, %5d] loss: %.3f' %
                  (epoch + 1, i + 1, running_loss / 2000))
            running_loss = 0.0

print('Finished Training')

# torch.save(net, 'cifarModel')

交叉熵损失 nn.CrossEntropyLoss()
optimizer.zero_grad()将梯度置0,即在每一次反向传播之前都需将梯度置0,这样才能正确的更新参数(不置0的话,梯度会叠加上次计算过的梯度,导致计算不准)。optimizer.step()进行梯度更新。


测试模型性能(validata.py)

import torch
import torchvision

from data import getData, imshow

net = torch.load("cifarModel")

classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse',
           'ship', 'truck')

_, testloader = getData()

dataiter = iter(testloader)
images, labels = dataiter.next()

# 显示图片
imshow(torchvision.utils.make_grid(images))
print('GroundTruth: ', ' '.join('%5s' % classes[labels[j]] for j in range(4)))

outputs = net(images)

_, predicted = torch.max(outputs, 1)

print('Predicted: ', ' '.join('%5s' % classes[predicted[j]] for j in range(4)))

correct = 0
total = 0
with torch.no_grad():
    for data in testloader:
        images, labels = data
        outputs = net(images)
        # images, labels = images.to(device), labels.to(device)
        # outputs = net(images.cuda()) # GPU 上训练的则用此句
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print('acc on the 10000 images: %d %%' % (100 * correct / total))

这里验证模型,是加载的训练好的保存的模型。torch.max() 是对softmax归一化后的数据返回每行最大值(one-hot)及其索引,来确认分类结果。


小结

  • 注意数据集的加载及读取方法(预处理)
  • 网络模型的搭建(几层卷积层,卷积核大小怎么设置,线性层kernel怎么设置)
  • GPU训练(测试时也要加载到GPU)
  • 注意数据转换(cuda、tensor、numpy .etc)
参考
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值