参考：https:pytorch.orgtutorialsbeginnerblitzcifar10_tutorial.html#sphx-glr-beginner-blitz-ci
参考：https://pytorch.org/tutorials/beginner/blitz/cifar10_tutorial.html#sphx-glr-beginner-blitz-cifar10-tutorial-py
到这里，你已经知道怎么定义神经网络，计算损失和更新网络的权重
现在你应该考虑：
What about data?
通常，当你必须要处理一些图片、文本、音频或视频数据时，你可以使用标准的python包去下载数据到一个numpy数组中。然后你可以转换该数组为torch.*Tensor
- 对于图像，如Pillow、OpenCV这些包就很有用
- 对于音频，如scipy、librosa这些包
- 对于文本，要么是原始python，要么是基于下载的Cython,或者是NLTK和SpaCy也都很有用
尤其是对于视图，我们创建了一个名为torchvision的包，有着用于如Imagenet、CIFAR10、MNIST等普通数据库的数据下载器和用于图像的数据转换器,即torchvision.datasets和torch.utils.data.DataLoader
这提供了很大的便利，也防止编写样板代码
在这个教程中，我们将使用CIFAR10数据集，它有着 ‘airplane’, ‘automobile’, ‘bird’, ‘cat’, ‘deer’, ‘dog’, ‘frog’, ‘horse’, ‘ship’, ‘truck’等类别，下面是CIFAR-10中大小为3*32*32的图像,即32*32像素大小的3通道颜色的图像
Training an image classifier训练一个图像分类器
我们将会按顺序进行下面的操作：
1.使用torchvision下载和归一化训练和测试数据集
2.定义卷积神经网络
3.定义损失函数
4.在训练数据中训练网络
5.在测试数据中测试网络
1. Loading and normalizing CIFAR10
使用torchvision，它能很容易地去下载CIFAR10数据
import torch
import torchvision
import torchvision.transforms as transforms
torchvision数据集的输出是范围在[0,1]的PILImage图像。我们转换它们成有着标准化范围[-1,1]的张量
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
//获取训练数据
trainset = torchvision.datasets.CIFAR10(
root='./data', #下载的数据存放的位置
train=True, #说明下载的是训练数据而不是测试数据
download=True, #确定要进行下载
transform=transform #下载的数据要进行的格式转换
)
trainloader = torch.utils.data.DataLoader( #对数据进行批处理
trainset, #指明使用的数据集
batch_size=4, #一批数据的大小，即一批数据有四张图片
shuffle=True, #是否随机打乱图片进行分批，是则为true
num_workers=2 #获取数据的线程为2
)
//获取测试数据
testset = torchvision.datasets.CIFAR10(root='./data', train=False,download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=4,shuffle=False, num_workers=2)
//指明数据的类别
classes = ('plane', 'car', 'bird', 'cat','deer', 'dog', 'frog', 'horse', 'ship', 'truck')
运行后首先进行数据的下载：
(deeplearning2) userdeMBP:classifier cifar user$ python cifar10_tutorial.py
Downloading https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to ./data/cifar-10-python.tar.gz
100.0%Files already downloaded and verified
下面展示一些训练图像：
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.imshow在显示时需要的输入是（imgsize,imgsieze,channels)，但是这里是（channels,imgsize,imgsieze)，所以需要将位置换换
plt.show()
# 随机得到一些训练图像
dataiter = iter(trainloader) #生成迭代器
images, labels = dataiter.next() #每次运行next()就会调用trainloader，获得一个之前定义的batch_size=4的批处理图片集，即4张图片
# 展示图像
imshow(torchvision.utils.make_grid(images)) #make_grid的作用是将若干幅图像拼成一幅图像,在想要展示一批数据的时候十分有用
# 输出图像标签
print(' '.join('%5s' % classes[labels[j]] for j in range(4)))
然后点击关闭图片，就会继续向下运行，就能够得到预测的结果：
2. Define a Convolutional Neural Network定义一个卷积神经网络
从之前的神经网络部分复制神经网络，并修改其应用于3通道图片（而不是之前的1通道图片）
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) #卷积层，参数为（inchannel,outchannel=number of filter,siza of filter,stride,padding）
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) #全连接层，最后输出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展平成16 * 5 * 5，然后就可以进行下面的全连接层操作
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = self.fc3(x)
return x
net = Net()
3. Define a Loss function and optimizer定义一个损失函数和优化器
使用分类Cross-Entropy损失和带有动量的SGD优化
import torch.optim as optim
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
4. Train the network 训练网络
循环数据迭代，并输入到网络，然后进行优化
for epoch in range(2): # 多次循环数据集，这里循环训练整个数据集两次
running_loss = 0.0
for i, data in enumerate(trainloader, 0): #enumerate枚举数据并从下标0开始
# 得到输入数据
inputs, labels = data
# 将参数的梯度都设为0
optimizer.zero_grad()
# forward + backward + optimize
outputs = net(inputs) #forward
loss = criterion(outputs, labels) #计算损失
loss.backward() #后向传播
optimizer.step() #将优化后的参数输入网络，再次进行训练
#打印数据
running_loss += loss.item() #用于从tensor中获取python数字
if i % 2000 == 1999: # 每处理2000次小批处理数据后打印一次结果
print('[%d, %5d] loss: %.3f' %(epoch + 1, i + 1, running_loss / 2000))
running_loss = 0.0 #然后清0
print('Finished Training')
然后返回输出为：
[1, 2000] loss: 2.195
[1, 4000] loss: 1.848
[1, 6000] loss: 1.654
[1, 8000] loss: 1.578
[1, 10000] loss: 1.511
[1, 12000] loss: 1.459
[2, 2000] loss: 1.382
[2, 4000] loss: 1.375
[2, 6000] loss: 1.344
[2, 8000] loss: 1.314
[2, 10000] loss: 1.317
[2, 12000] loss: 1.284
Finished Training
5. Test the network on the test data在测试数据中测试网络
我们对网络进行了两次遍历训练数据集的训练。但我们还是需要查看网络是否学习了所有的东西
我们将会通过预测神经网络输出的类型标签来检查它，并与事实相对照。如果预测是正确的，我们将样本添加到正确预测列表中。
好的,第一步，让我们从测试集中显示一个图像来熟悉它。
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)))
然后出现四张图片：
然后点击关闭图片，就会返回实际该图片的标签：
('GroundTruth: ', ' cat ship ship plane')
然后让我们看看神经网络认为上面的例子是什么：
输出是这10个类的能量。一个类的能量越高，网络越认为图像属于特定的类。所以，让我们得到最高能量的指数:
_, predicted = torch.max(outputs, 1)
print('Predicted: ', ' '.join('%5s' % classes[predicted[j]] for j in range(4)))
返回预测值：
('Predicted: ', ' cat plane truck plane')
让我们看看网络在整个数据集中表现得怎么样
correct = 0
total = 0
with torch.no_grad(): #设置为不计算梯度
for data in testloader:
images, labels = data
outputs = net(images)
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item() #相等
print('Accuracy of the network on the 10000 test images: %d %%' % (100 * correct / total))
⚠️(predicted == labels).sum().item()作用：可见(predicted == labels).sum().item()作用
返回：
Accuracy of the network on the 10000 test images: 53 %
这看起来比随机抽取10%的正确率(从10个类中随机抽取一个类)要好得多。看来网络学到了一些东西。
那么是哪些类执行得好，哪些类执行得不好呢？
class_correct = list(0. for i in range(10))
class_total = list(0. for i in range(10))
with torch.no_grad(): #设置在进行forward时不计算梯度
for data in testloader:
images, labels = data
outputs = net(images)
_, predicted = torch.max(outputs, 1)
c = (predicted == labels).squeeze()
for i in range(4):
label = labels[i]
class_correct[label] += c[i].item()
class_total[label] += 1
for i in range(10):
print('Accuracy of %5s : %2d %%' % (
classes[i], 100 * class_correct[i] / class_total[i]))
返回：
Accuracy of plane : 45 %
Accuracy of car : 67 %
Accuracy of bird : 45 %
Accuracy of cat : 31 %
Accuracy of deer : 53 %
Accuracy of dog : 24 %
Accuracy of frog : 66 %
Accuracy of horse : 58 %
Accuracy of ship : 69 %
Accuracy of truck : 77 %
接下来就是设置运行在GPU上：
就像你把张量传输到GPU上一样，你把神经网络传输到GPU上。
让我们首先定义我们的设备为第一个可见的cuda设备，如果我们有cuda可用:
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
# Assuming that we are on a CUDA machine, this should print a CUDA device:
print(device)
因为我是在CPU上运行的，所以这里print(device)会返回cpu
本节的其余部分假设设备是CUDA设备。
然后这些方法递归遍历所有模块，将它们的参数和缓冲区转换为CUDA张量:
记住，你必须在每一步都把输入和目标值的发送到GPU中：
inputs, labels = inputs.to(device), labels.to(device)
为什么我没有注意到GPU与CPU相比的巨大加速?因为你的网络实在是太小了。
练习:
尝试增加网络的宽度(即第一个nn.Conv2d卷积层的参数2)和第二个nn.Conv2d卷积层的参数1 — 他们需要相同的数字，看看你得到什么样的加速。
实现目标:
- 高层次地理解PyTorch张量库和神经网络。
- 训练一个小的神经网络对图像进行分类
![[echarts] 同指标对比柱状图相关的知识介绍及应用示例](https://img7.php1.cn/3cdc5/c7bc/ae9/d860963d11bbd36d.jpeg)
京公网安备 11010802041100号