Pytorch Tutorial 学习笔记（一）
介绍Pytorch
Pytorch是一个机器学习集成开发包，可以实现GPU张量计算以及神经网络自动求梯度。
官网链接：https://pytorch.org/tutorials/
Pytorch张量
import torch ##导入pytorch
z = torch.zeros(5, 3) ##生成五行三维元素为零的张量
print(z)
print(z.dtype) ##生成数据类型
输出：
tensor([[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.]])
torch.float32 ##32位浮点数
i = torch.ones((5, 3), dtype=torch.int16) ##元素为16位值为1的整数
print(i)
输出：
tensor([[1, 1, 1],
[1, 1, 1],
[1, 1, 1],
[1, 1, 1],
[1, 1, 1]], dtype=torch.int16)
torch.manual_seed(1729) ##随机数种子，一般不用区分GPU和CPU版本
r1 = torch.rand(2, 2)
print('A random tensor:')
print(r1)
r2 = torch.rand(2, 2)
print('\nA different random tensor:')
print(r2)
torch.manual_seed(1729)
r3 = torch.rand(2, 2)
print('\nShould match r1:')
print(r3)
输出：
A random tensor:
tensor([[0.3126, 0.3791],
[0.3087, 0.0736]])
A different random tensor:
tensor([[0.4216, 0.0691],
[0.2332, 0.4047]])
Should match r1:
tensor([[0.3126, 0.3791],
[0.3087, 0.0736]]) ## 因为随机数种子r1和r3一样所以生成的张量也一样，都是2行2维
生成随机数总结
- torch.rand(*sizes,out=None)
返回一个区间（0，1）的均匀分布的张量，形状随size决定
- torch.randn(*sizes,out=None)
均值为0,方差为1的标准正太分布，形状由参数决定
- torch.nomal(means,std,size,out=None)
均值为means,方差为std,形状由size决定的正太分布
- torch.linspace(start,end,steps=*,out=None)
从start到end间隔为steps的一维张量
- torch.manual_seed()
固定随机数种子，如官方教程所显示生成一样的随机数
Pytorch模型示例
卷积神经网络示例
import torch # for all things PyTorch
import torch.nn as nn # for torch.nn.Module, the parent object for PyTorch models
import torch.nn.functional as F # for the activation function
class LeNet(nn.Module):
def __init__(self):
super(LeNet, self).__init__()
# 输入灰度图，6个输出通道，3*3的卷积核
self.conv1 = nn.Conv2d(1, 6, 3)
self.conv2 = nn.Conv2d(6, 16, 3)
# an affine operation: y = Wx + b
self.fc1 = nn.Linear(16 * 6 * 6, 120) # 6*6 图片维度
self.fc2 = nn.Linear(120, 84)
self.fc3 = nn.Linear(84, 10)
def forward(self, x):
# 最大池化层，相当于在（2，2）的窗口中选择最大的一个数
x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
# If the size is a square you can only specify a single number
x = F.max_pool2d(F.relu(self.conv2(x)), 2)
#view函数相当于reshape，-1表示自动调整张量的分布情况，张量总数保持不变
x = x.view(-1, self.num_flat_features(x))
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = self.fc3(x)
return x
def num_flat_features(self, x):
size = x.size()[1:] # 除去batch维度
num_features = 1
for s in size:
num_features *= s
return num_features
导入数据集
# 导入需要的包
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
import matplotlib
import matplotlib.pyplot as plt
import numpy as np
# 将numpy数据转为tensor类型，在GPU中计算
transform = transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
# 下载数据集CIFAR10，train=True表示开始训练，训练网络时会根据计算结果对网络参数进行调整，如果false则不进行调整。
trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
download=True, transform=transform)
# 导入训练数据，batch_size=4表示每次同时导入四张图片， shuffle=True表示一个epoch训练时会打乱图片顺序，num_workers表示多线程导入
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
shuffle=True, num_workers=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')
import matplotlib.pyplot as plt
import numpy as np
# 显示图片
def imshow(img):
img = img / 2 + 0.5 # unnormalize
npimg = img.numpy()
plt.imshow(np.transpose(npimg, (1, 2, 0)))
# 加载图片，是随机的
dataiter = iter(trainloader)
images, labels = dataiter.next()
# 显示图片
imshow(torchvision.utils.make_grid(images))
# 输出标签也就是类别
print(' '.join('%5s' % classes[labels[j]] for j in range(4)))
优化网络参数
神经网络是一个不断学习的过程，可以类比人类学习过程，需要外界反馈来调整认知，所以还要定义损失函数以及优化措施，损失函数就相当于上了一节课之后做练习题做错的数目，优化措施就好比老师根据你的错题指定薄弱点来提升学习水平，最后在测试数据集进行测试就相当于考试，测验自己的最终水平，每个人都有自己的优点缺点，网络也是一样，不同的网络可能需要不同的反馈和优化方法，所以我们在实际做任务过程中需要对症下药。
criterion = nn.CrossEntropyLoss() # 交叉熵损失
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9) # 随机梯度下降进行优化
训练纪元epoch
我们要做很多次高考题才能上考场，神经网络也是一样，做的越多越熟练，所以一个epoch就相当于做了一遍历年高考题，一般来说，我们在训练神经网络时，要尽可能让它多做几遍，No Pain No Gain。
for epoch in range(2): # 在训练集上所有图片训练两遍
running_loss = 0.0
for i, data in enumerate(trainloader, 0):
# 得到数据和类别标签
inputs, labels = data
# 将梯度归零，如果不将梯度归零的话，在第二个epoch上梯度会累加，就像我们需要新买一本练习册做第二遍题
optimizer.zero_grad()
# 前向传播，误差反向传播相当于反馈，优化
outputs = net(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
# 输出损失函数
running_loss += loss.item()
if i % 2000 == 1999: # 在一次纪元中，每2000次加载数据输出一次loss
print('[%d, %5d] loss: %.3f' %
(epoch + 1, i + 1, running_loss / 2000))
running_loss = 0.0
print('Finished Training')
输出：
[1, 2000] loss: 2.174
[1, 4000] loss: 1.810
[1, 6000] loss: 1.673
[1, 8000] loss: 1.598
[1, 10000] loss: 1.542
[1, 12000] loss: 1.475
[2, 2000] loss: 1.395
[2, 4000] loss: 1.364
[2, 6000] loss: 1.334
[2, 8000] loss: 1.321
[2, 10000] loss: 1.300
[2, 12000] loss: 1.269
Finished Training
进行测试
训练完数据集后需要进行测试，相当于期末闭卷考，所以没有反馈以及优化措施
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)) # 计算得分率，分类正确得一分
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。