PyTorch实战 | 使用卷积神经网络对CIFAR10图片进行分类(附源码)

简介: 首先通过torch.randn()生成四维的随机数据,由于我们之前定义网络中Conv2d()函数接收的数据要求是四维的,其中第一维度代表样本数据的个数,第二维代表数据的通道数,第3、4维代表数据大小,这里是32×32的网格。然后将生成的数据送入neural_net(),这里会自动调用该对象的forward()方法进行模型训练并输出结果。

最近一直在分享机器学习算法原理的讲解文章,实战内容一直在托更,今天以CIFAR10图片分类作为CNN的实战练习项目。以下从网络的定义、训练到测试,全面清晰地给出操作步骤,供大家学习参考。


01神经网络


如下所示为一个基本的卷积神经网络的模型,将图像输入之后经过卷积操作提取特征,再经过降采样操作后输出到下一层。经过多次多个卷积、池化层之后结果输出到全连接层,经过全连接映射到最终结果。


640.png


一个神经网络的典型训练过程可以分为如下几步:


  1. 定义神经网络,包含一些可学习参数(或者叫权重)
  2. 将数据输入网络进行训练,并计算损失值
  3. 将梯度反向传播给网络的参数,据此更新网络的权重,并再次训练


定义网络


如下所示为我们定义的神经网络类NeuralNet。


首先它继承自父类nn.Module,从import可以看到从torch中分别引入了torch.nn和torch.functional,其中nn用于保存常用的神经网络类,而functional库中则是一些网络操作。nn.Module类有两个子类必须重写的方法,初始化方法__init__用于定义网络结构,forward()中定义网络训练操作,当网络对象被调用时会自动执行该方法。

在构造函数__init__中我们定义网络的结构,这里定义了网络的两个卷积层为torch.nn库中的二维卷积函数Conv2d(),nn.Conv2d(1, 6, (5, 5))代表输入数据的通道数为1,输出通道数为5,卷积核为5×5,卷积核长和宽一致的话可以简写为5。用nn.Linear实现全连接操作,输入数据长度为16 * 5 * 5,这是由于之前conv2输出的16通道的5×5的数据,输出长度120的数据。经过三个全连接层输出长度为10

在forward()方法中实现网络的训练过程,将输入数据input_x经过conv1的卷积操作后经过激活函数relu,最后经过池化操作max_pool2d得到第一个卷积层的输出layer1,同样操作后得到第二个卷积层layer2。将卷积的结果通过flat_features()降维,经过第二个卷积层layer2为四维数据[1, 16, 5, 5],通过tensor.size()[1:]选择第一个维度以后的维度相乘得到features为1655=400,通过tensor.view(-1,400)将其转化为长度400的二维数据。最后经过三个全连接层后输出。


import torch
from torch import nn
from torch.nn import functional as Func
class NeuralNet(nn.Module):
def __init__(self):
super(NeuralNet, self).__init__()
        # 两个卷积层
self.conv1 = nn.Conv2d(1, 6, (5, 5))
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, input_x):
        # 进行两次卷积、池化操作
layer1 = Func.max_pool2d(Func.relu(self.conv1(input_x)), (2, 2))
layer2 = Func.max_pool2d(Func.relu(self.conv2(layer1)), (2, 2))
        # 降维
flat = self.flat_features(layer2)
        # 经过三个全连接层
fc1 = Func.relu(self.fc1(flat))
fc2 = Func.relu(self.fc2(fc1))
fc3 = self.fc3(fc2)
return fc3
def flat_features(self, tensor):
features = 1
for size in tensor.size()[1:]:
features *= size
flat = tensor.view(-1, features)
return flat
# 创建一个neural_net对象并打印
neural_net = NeuralNet()
print(neural_net)
'''
NeuralNet(
  (conv1): Conv2d(1, 6, kernel_size=(5, 5), stride=(1, 1))
  (conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))
  (fc1): Linear(in_features=400, out_features=120, bias=True)
  (fc2): Linear(in_features=120, out_features=84, bias=True)
  (fc3): Linear(in_features=84, out_features=10, bias=True)
)
'''


训练网络


如下所示为将数据送入网络训练并计算损失值的过程。


先通过torch.randn()生成四维的随机数据,由于我们之前定义网络中Conv2d()函数接收的数据要求是四维的,其中第一维度代表样本数据的个数,第二维代表数据的通道数,第3、4维代表数据大小,这里是32×32的网格。然后将生成的数据送入neural_net(),这里会自动调用该对象的forward()方法进行模型训练并输出结果。

得到输出结果y_output之后通过和目标值进行比较即可得出损失值,这里仍然使用randn创建目标值y_target,注意目标值要和输出值维度相同,我们输入的样本数量为1,最后经全连接层fc3产生的结果长度为10,所以y_output维度为(1, 10),因此y_target也是二维1×10的数据。定义评价函数criterion为nn.MSELoss(),即计算输出和目标的均方误差(mean-squared error)。


x = torch.randn(1, 1, 32, 32)   # 随机产生输入数据
y_output = neural_net(x)  # 输入数据并进行训练
y_target = torch.randn(1, 10)   # 随机产生目标数据
criterion = nn.MSELoss()    # 定义评价函数
loss = criterion(y_output, y_target)  # 计算损失值


反向传播


由之前定义的网络可知我们的从输入到输出,数据经过的函数操作如下。


input -> conv2d -> relu -> maxpool2d -> conv2d -> relu -> maxpool2d
        -> view -> linear -> relu -> linear -> relu -> linear
        -> MSELoss
        -> los


通过tensor的grad_fn属性记录了这些函数操作,例如从loss向前回退查看grad_fn


print(loss.grad_fn)  # MSELoss
print(loss.grad_fn.next_functions[0][0])  # Linear
print(loss.grad_fn.next_functions[0][0].next_functions[0][0])  # ReLU


我们进行反向传播操作,然后就可以查看各层网络参数的梯度


neural_net.zero_grad()  # 清零所有参数(parameter)的梯度缓存
loss.backward()  # 反向传播
print(neural_net.conv1.bias.grad)  # 查看梯度
# tensor([-0.0046, -0.0087,  0.0390,  0.0045, -0.0096,  0.0028])


根据得到的梯度对网络的参数进行更新,例如这里使用随机梯度下降法进行更新,其公式为weight = weight - learning_rate * gradient,即在原有权重的基础上,根据学习率learning_rate减少一定梯度。如下所示遍历网络的所有参数neural_net.parameters并对其进行更新。


learning_rate = 0.01
for param in neural_net.parameters():
    param.data.sub_(param.grad.data * learning_rate)


然而在使用神经网络时,我们可能希望使用各种不同的更新规则,如SGD、Nesterov-SGD、Adam、RMSProp等。在torch.optim库实现了所有的这些方法,如下所示,首先创建优化器optimizer,然后进行多次迭代训练。


import torch.optim as optim
# 创建优化器(optimizer)
optimizer = optim.SGD(neural_net.parameters(), lr=0.01)
# 在训练的迭代中:
for epoch in range(100):
    optimizer.zero_grad()  # 清零梯度缓存
    output = neural_net(x)
    loss = criterion(y_output, y_target)
    loss.backward()
    optimizer.step()  # 自动更新参数


02CIFAR10图片识别

卷积神经网络一个常用的领域就是图片分类,而图片分类中最经典的就是对CIFAR10图片数据集进行分类。它是一个包含“飞机”,“汽车”,“鸟”,“猫”,“鹿”,“狗”,“青蛙”,“马”,“船”,“卡车”10中类别的图片库。在CIFAR-10里面的图片数据大小是3x32x32,即:三通道彩色图像,图像大小是32x32像素。


准备数据


pytorch的torchvision提供了CIFAR10库,通过torchvision.datasets.CIFAR10加载该数据集。root为数据集的路径,如果该路径下没有数据,则会从指定站点下载并保存到该路径,train属性标志是训练集还是测试集数据。transform指定了对数据进行的预处理操作。例如这里将两个预处理操作通过Compose放在了transform中,第一步ToTensor将数据转化为张量,第二步通过Normalize()将数据化为正态分布值。前面的(0.5,0.5,0.5)是 R G B 三个通道上的均值,后面(0.5, 0.5, 0.5)是三个通道的标准差,Normalize对每个通道执行以下操作:image =(图像-平均值)/ std。当mean,std都是0.5时将使图像在[-1,1]范围内归一化。例如,最小值0将转换(0-0.5)/0.5=-1

接着使用DataLoader将数据分为多个批次,batch_size指定每个批次包含几个图片,shuffle为是否打乱图片,num_workers指定多个线程去加载数据。当训练很快、加载数据时间过慢时会导致模型等待数据加载而变慢,这时可以采用多线程来加载数据。


import torch
import torchvision
# 定义数据预处理操作
transform=torchvision.transforms.Compose([
    torchvision.transforms.ToTensor(),
    torchvision.transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
# 加载数据
data_path = 'D:/Temp/MachineLearning/data'
train_set = torchvision.datasets.CIFAR10(root=data_path, train=True, download=True, transform=transform)
test_set = torchvision.datasets.CIFAR10(root=data_path, train=False, download=True, transform=transform)
# 封装为批数据
train_loader = torch.utils.data.DataLoader(train_set, batch_size=4, shuffle=True, num_workers=2)
test_loader = torch.utils.data.DataLoader(test_set, batch_size=4, shuffle=False, num_workers=2)
# 定义标签值
classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')


我们通过matplotlib打印其中的一个批次图片和标签。由于之前将图片标准化,所以需要进行反标准化操作。由于CiFAR10的图片数据为3×32×32,需要使用transpose将其转为32×32×3。

import matplotlib.pyplot as plt
import numpy as np
# 输出图像的函数
def imshow(img):
    img = img / 2 + 0.5     # 反标准化
    npimg = img.numpy()
    plt.imshow(np.transpose(npimg, (1, 2, 0)))
    plt.show()
# 获取一个批次的训练图片、标签
images, labels = iter(train_loader).next()
# 显示图片
imshow(torchvision.utils.make_grid(images))
# 打印图片标签
print(' '.join('%5s' % classes[labels[j]] for j in range(4)))


显示结果如下:


640.png


定义网络和参数


如下定义卷积网络类并创建一个对象net,以及定义训练的损失函数和优化器。


import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
# 定义卷积网络
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()
criterion = nn.CrossEntropyLoss()   # 损失函数
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9) # 优化器


训练并保存模型


如下所示进行两轮叠代训练,每轮按批次取出训练集的数据投入模型进行训练

for epoch in range(2):  # 进行两轮迭代训练
    running_loss = 0.0
    # 按批次取出数据进行训练
    for i, data in enumerate(train_loader, 0):
        inputs, labels = data   # 获取数据和标签
        optimizer.zero_grad()   # 清零梯度缓存
        outputs = net(inputs)   #  得到预测结果
        loss = criterion(outputs, labels)   # 计算损失
        loss.backward()     # 反向传播
        optimizer.step()    # 更新参数
        # 每隔两千次输出一次平均损失值
        running_loss += loss.item()
        if i % 2000 == 1999:
            print('[%d, %5d] loss: %.3f' % (epoch + 1, i + 1, running_loss / 2000))
            running_loss = 0.0
print('Finished Training')
# 保存训练好的模型
MODEL_PATH = './cifar_net.pth'
torch.save(net.state_dict(), MODEL_PATH)


载入模型进行测试


模型以及训练好并保存了,那么模型的预测效果如何呢?这就需要在测试集数据上进行检测了,如下所示,我们首先读取保存的模型,然后将测试集的图片数据images投入模型进行预测,然后取得预测值predicted,将其和测试集的标签labels进行比对,统计预测正确的个数correct,除以总数total就是准去率了。

# 加载模型
net = Net()
net.load_state_dict(torch.load(MODEL_PATH))
correct = 0
total = 0
with torch.no_grad():
    for data in test_loader:
        images, labels = data
        outputs = net(images)   # 将测试集图片投入模型
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)     # 统计测试集总样本数
        correct += (predicted == labels).sum().item()   # 累计预测正确的个数
print('在整个测试集上的准确率为: %d %%' % (100 * correct / total))


使用GPU


如果需要使用GPU进行网络训练,需要将模型net和训练集的数据images、标签labels都放到GPU设备上。

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")  # 获取GPU设备
print(device)
net = Net()
net.to(device)    # 将模型放在GPU上
for epoch in range(2):  # 进行两轮迭代训练
    running_loss = 0.0
    # 按批次取出数据进行训练
    for i, data in enumerate(train_loader, 0):
        inputs, labels = data   
        inputs, labels = inputs.to(device),labels.to(device)  # 将训练数据放到GPU
        ......

相关实践学习
部署Stable Diffusion玩转AI绘画(GPU云服务器)
本实验通过在ECS上从零开始部署Stable Diffusion来进行AI绘画创作,开启AIGC盲盒。
相关文章
|
19天前
|
机器学习/深度学习 TensorFlow 算法框架/工具
利用Python和TensorFlow构建简单神经网络进行图像分类
利用Python和TensorFlow构建简单神经网络进行图像分类
44 3
|
2月前
|
机器学习/深度学习 Serverless 索引
分类网络中one-hot的作用
在分类任务中,使用神经网络时,通常需要将类别标签转换为一种合适的输入格式。这时候,one-hot编码(one-hot encoding)是一种常见且有效的方法。one-hot编码将类别标签表示为向量形式,其中只有一个元素为1,其他元素为0。
48 3
|
2月前
|
存储 分布式计算 负载均衡
|
13天前
|
SQL 安全 网络安全
网络安全与信息安全:关于网络安全漏洞、加密技术、安全意识等方面的知识分享
【10月更文挑战第40天】在数字化时代,网络安全和信息安全已成为我们生活中不可或缺的一部分。本文将介绍网络安全漏洞、加密技术以及安全意识等方面的知识,帮助读者更好地了解网络安全的重要性,并提供一些实用的技巧和建议,以保护个人和组织的信息安全。
40 6
|
7天前
|
安全 网络安全 数据安全/隐私保护
网络安全与信息安全:关于网络安全漏洞、加密技术、安全意识等方面的知识分享
在数字化时代,网络安全和信息安全已成为我们生活中不可或缺的一部分。本文将介绍网络安全漏洞、加密技术和安全意识等方面的知识,并提供一些实用的技巧和建议,帮助读者更好地保护自己的网络安全和信息安全。
|
7天前
|
安全 算法 网络安全
网络安全与信息安全:关于网络安全漏洞、加密技术、安全意识等方面的知识分享
在当今数字化时代,网络安全和信息安全已经成为了全球关注的焦点。随着技术的发展,网络攻击手段日益狡猾,而防范措施也必须不断更新以应对新的挑战。本文将深入探讨网络安全的常见漏洞,介绍加密技术的基本概念和应用,并强调培养良好安全意识的重要性。通过这些知识的分享,旨在提升公众对网络安全的认识,共同构建更加安全的网络环境。
|
6天前
|
存储 安全 网络安全
云计算与网络安全:探索云服务、网络安全和信息安全的交汇点
在数字化时代,云计算已成为企业和个人存储、处理数据的关键技术。然而,随着云服务的普及,网络安全问题也日益凸显。本文将深入探讨云计算与网络安全的关系,分析云服务中的安全挑战,并提出相应的解决方案。同时,我们还将介绍一些实用的代码示例,帮助读者更好地理解和应对网络安全问题。
|
9天前
|
安全 算法 网络协议
网络安全与信息安全:关于网络安全漏洞、加密技术、安全意识等方面的知识分享
在数字时代,网络安全和信息安全已经成为了我们生活中不可或缺的一部分。本文将介绍网络安全漏洞、加密技术和安全意识等方面的内容,帮助读者更好地了解网络安全的重要性和应对措施。通过阅读本文,您将了解到网络安全的基本概念、常见的网络安全漏洞、加密技术的原理和应用以及如何提高个人和组织的网络安全意识。
|
6天前
|
SQL 安全 网络安全
网络安全与信息安全:关于网络安全漏洞、加密技术、安全意识等方面的知识分享
在数字化时代,网络安全和信息安全已经成为了我们生活中不可或缺的一部分。本文将深入探讨网络安全漏洞、加密技术和安全意识等方面的内容,帮助读者更好地了解网络安全的重要性,并提高自己的网络安全防护意识。通过本文的学习,你将能够了解到网络安全的基本概念、常见的网络安全漏洞、加密技术的应用以及如何提高自己的安全意识。让我们一起来探索这个充满挑战和机遇的领域吧!
|
10天前
|
存储 安全 算法
网络安全与信息安全:漏洞、加密与意识的三重防线
在数字时代的浪潮中,网络安全与信息安全成为维护数据完整性、确保个人隐私和企业资产安全的基石。本文将深入探讨网络漏洞的成因、加密技术的应用以及安全意识的培养,旨在通过技术与教育的结合,构建起一道坚固的防御体系。我们将从实际案例出发,分析常见的网络安全威胁,揭示如何通过加密算法保护数据安全,并强调提升个人和组织的安全意识在防范网络攻击中的重要性。