Pytorch速成教程整体流程

Posted 桦树无泪

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Pytorch速成教程整体流程相关的知识,希望对你有一定的参考价值。

目录

0 简介

1 张量的概念和生成

2 自动微分

2.1 Tensor类

2.2 梯度

3 神经网络

 3.1 定义网络

3.2 查看模型参数

3.3 测试网络

3.4 损失函数更新权重

4 训练分类器

4.1 数据处理生成Dataload

4.2 定义卷积网络

4.3 定义损失函数

4.4 遍历DataLoader进行训练

4.5 测试

5 GPU训练


0 简介

跟numpy功能一样,但可以GPU加速,和numpy可以相互转化。

1 张量的概念和生成

张量是torch里的多维数组,和numpy中的ndarrays相似

生成张量的方法:

  • 空张量
# 这个是用来生成一个为未初始化的5*3的张量,切记不是全零
x = torch.empty(5, 3
  • 随机化0-1张量
# 这个是生成一个均匀分布的初始化的,每个元素从0~1的张量,与第一个要区别开,另外,还有其它的随机张量生成函数,如torch.randn()、torch.normal()、torch.linespace(),分别是标准正态分布,离散正态分布,线性间距向量
x = torch.rand(5, 3)
  • 全0张量
# 这个是初始化一个全零张量,可以指定每个元素的类型。
x = torch.zeros(5, 3, dtype=torch.long)
  • 已有矩阵转化为张量
x = torch.tensor([5.5, 3])
  • size函数来看它的shape
print(x.size())
  • 张量加法
print(torch.add(x, y))
  • 张量的大小
print(x.item())
  • torch转numpy

在使用Cpu的情况下,张量和array将共享他们的物理位置,改变其中一个的值,另一个也会随之变化。

a = torch.ones(5)
b = a.numpy()
  • numpy转torch
a = np.ones(5)
b = torch.from_numpy(a)
  • GPU下转化
if torch.cuda.is_available():
    device = torch.device("cuda")          # a CUDA device object
    y = torch.ones_like(x, device=device)  # directly create a tensor on GPU
    x = x.to(device)                       # or just use strings ``.to("cuda")``
    z = x + y

2 自动微分

在pytorch中,神经网络的核心是自动微分

2.1 Tensor类

orch.Tensor 是这个包的核心类。如果它的属性requires_grad是True,那么PyTorch就会追踪所有与之相关的operation。当完成(正向)计算之后, 我们可以调用backward(),PyTorch会自动的把所有的梯度都计算好。与这个tensor相关的梯度都会累加到它的grad属性里。

如果不想计算这个tensor的梯度,我们可以调用detach(),这样它就不会参与梯度的计算了。为了阻止PyTorch记录用于梯度计算相关的信息(从而节约内存),我们可以使用 with torch.no_grad()。这在模型的预测时非常有用,因为预测的时候我们不需要计算梯度,否则我们就得一个个的修改Tensor的requires_grad属性,这会非常麻烦。

关于autograd的实现还有一个很重要的Function类。Tensor和Function相互连接从而形成一个有向无环图, 这个图记录了计算的完整历史。每个tensor有一个grad_fn属性来引用创建这个tensor的Function(用户直接创建的Tensor,这些Tensor的grad_fn是None)。

如果你想计算梯度,可以对一个Tensor调用它的backward()方法。如果这个Tensor是一个scalar(只有一个数),那么调用时不需要传任何参数。如果Tensor多于一个数,那么需要传入和它的shape一样的参数,表示反向传播过来的梯度。

创建tensor时设置属性requires_grad=True,PyTorch就会记录用于反向梯度计算的信息:

    x = torch.ones(2, 2, requires_grad=True)
    print(x)

然后我们通过operation产生新的tensor:

y = x + 2
print(y)

是通过operation产生的tensor,因此它的grad_fn不是None。

    print(y.grad_fn)
    # <AddBackward0 object at 0x7f35409a68d0>

再通过y得到z和out 

    z = y * y * 3
    out = z.mean()
     
    print(z, out)
    # z = tensor([[ 27.,  27.],[ 27.,  27.]]) 
    # out = tensor(27.)

requires_grad_()函数会修改一个Tensor的requires_grad。

a = torch.randn(2, 2)
a = ((a * 3) / (a - 1))
print(a.requires_grad)
a.requires_grad_(True)
print(a.requires_grad)
b = (a * a).sum()
print(b.grad_fn)
输出:
    False
    True
    <SumBackward0 object at 0x7f35766827f0>

2.2 梯度

现在我们里反向计算梯度。因为out是一个scalar,因此out.backward()等价于out.backward(torch.tensor(1))。

v = torch.tensor([0.1, 1.0, 0.0001], dtype=torch.float)
y.backward(v)

print(x.grad) #数量的梯度,即各个方向的导数的集合
"""
tensor([1.0240e+02, 1.0240e+03, 1.0240e-01])
"""
#停止计算微分
print(x.requires_grad)
print((x ** 2).requires_grad)

with torch.no_grad():
   print((x ** 2).requires_grad)
"""
True
True
False
"""

3 神经网络

神经网络定义过程

  • 定义神经网络及其参数;
  • 在数据集上多次迭代循环;
  • 通过神经网络处理数据集;
  • 计算损失(输出和正确的结果之间相差的距离);
  • 用梯度对参数反向影响;
  • 更新神经网络的权重,weight = weight - rate * gradient;

 3.1 定义网络

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


# 汉字均为我个人理解,英文为原文标注。
class Net(nn.Module):

 #1、初始化定义  
  def __init__(self):
        # 继承原有模型
        super(Net, self).__init__()
        # 1 input image channel, 6 output channels, 5x5 square convolution
        # kernel
        # 定义了两个卷积层
        # 第一层是输入1维的(说明是单通道,灰色的图片)图片,输出6维的的卷积层(说明用到了6个卷积核,而每个卷积核是5*5的)。
        self.conv1 = nn.Conv2d(1, 6, 5)
        # 第一层是输入1维的(说明是单通道,灰色的图片)图片,输出6维的的卷积层(说明用到了6个卷积核,而每个卷积核是5*5的)。
        self.conv2 = nn.Conv2d(6, 16, 5)
        # an affine operation: y = Wx + b
        # 定义了三个全连接层,即fc1与conv2相连,将16张5*5的卷积网络一维化,并输出120个节点。
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        # 将120个节点转化为84个。
        self.fc2 = nn.Linear(120, 84)
        # 将84个节点输出为10个,即有10个分类结果。
        self.fc3 = nn.Linear(84, 10)

 #2、搭建网络   我们只需要定义forward函数,而backward函数会自动通过autograd创建。
    def forward(self, x):
        # Max pooling over a (2, 2) window
        # 用relu激活函数作为一个池化层,池化的窗口大小是2*2,这个也与上文的16*5*5的计算结果相符(一开始我没弄懂为什么fc1的输入点数是16*5*5,后来发现,这个例子是建立在lenet5上的)。
        # 这句整体的意思是,先用conv1卷积,然后激活,激活的窗口是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
        # 作用同上,然后有个需要注意的地方是在窗口是正方形的时候,2的写法等同于(2,2)。
        # 这句整体的意思是,先用conv2卷积,然后激活,激活的窗口是2*2。
        x = F.max_pool2d(F.relu(self.conv2(x)), 2)
        # 实际上view()类似于reshape()的用法,将张量重新规划格式 -1代表待定
        x = x.view(-1, self.num_flat_features(x)) #一维化
        # 用一下全连接层fc1,然后做一个激活。
        x = F.relu(self.fc1(x))
        # 用一下全连接层fc2,然后做一个激活。
        x = F.relu(self.fc2(x))
        # 用一下全连接层fc3。
        x = self.fc3(x)
        return x

    def num_flat_features(self, x):
        # 承接上文的引用,这里需要注意的是,由于pytorch只接受图片集的输入方式(原文的单词是batch),所以第一个代表个数的维度被忽略。
        size = x.size()[1:]  # all dimensions except the batch dimension
        num_features = 1
        for s in size:
            num_features *= s
        return num_features


net = Net()
print(net)

"""
Net(
  (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)
)
"""

3.2 查看模型参数

# 现在我们已经构建好模型了,但是还没有开始用bp呢,如果你对前面的内容有一些印象的话,你就会想起来不需要我们自己去搭建,我们只需要用某一个属性就可以了,autograd。

# 现在我们需要来看一看我们的模型,下列语句可以帮助你看一下这个模型的一些具体情况。

params = list(net.parameters())
print(len(params))
print(params[0].size())  # conv1's .weight

"""
10
torch.Size([6, 1, 5, 5])
"""

3.3 测试网络

input = torch.randn(1, 1, 32, 32)
out = net(input)
print(out)
# tensor([[-0.0198,  0.0438,  0.0930, -0.0267, -0.0344,  0.0330,  0.0664,
0.1244, -0.0379,  0.0890]])

#默认的梯度会累加,因此我们通常在backward之前清除掉之前的梯度值:
net.zero_grad()
out.backward(torch.randn(1, 10))

3.4 损失函数更新权重

1、计算损失
# 这一部分是来搞定损失函数
output = net(input)
target = torch.randn(10)  # a dummy target, for example
target = target.view(1, -1)  # make it the same shape as output
criterion = nn.MSELoss()
loss = criterion(output, target)
print(loss)

2、查看结果
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

3、计算梯度
#在调用loss.backward()之前,我们需要清除掉tensor里之前的梯度,否则会累加进去。
net.zero_grad() 
loss.backward()

4、更新权重 (梯度下降)
learning_rate = 0.01
for f in net.parameters():
   f.data.sub_(f.grad.data * learning_rate)
  • 使用优化包即使用optimizer,我们也需要清零梯度。但是我们不需要一个个的清除,而是用optimizer.zero_grad()一次清除所有。
import torch.optim as optim
 
# 创建optimizer,需要传入参数和learning rate
optimizer = optim.SGD(net.parameters(), lr=0.01)
 
# 清除梯度
optimizer.zero_grad()  
output = net(input)
loss = criterion(output, target)
loss.backward()
optimizer.step()    # optimizer会自动帮我们更新参数

4 训练分类器

4.1 数据处理生成Dataload

特别是对于视觉领域,我们写了一个叫做torchvision的包,他可以将很多知名数据的数据即涵盖在内。并且,通过torchvision.datasets 和 torch.utils.data.DataLoader 进行数据的转化。在本里中我们将会使用 CIFAR10 数据集,它有以下各类: ‘airplane’, ‘automobile’, ‘bird’, ‘cat’, ‘deer’, ‘dog’, ‘frog’, ‘horse’, ‘ship’, ‘truck’。在这个数据集中的图像尺寸都是33232的。

import torch
import torchvision
import torchvision.transforms as transforms

#数据归一化
transform = transforms.Compose(
	[transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
#训练集
trainset = torchvision.datasets.CIFAR10(root='/path/to/data', train=True,
	download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
	shuffle=True, num_workers=2)
#测试集
testset = torchvision.datasets.CIFAR10(root='/path/to/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')

4.2 定义卷积网络

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()

4.3 定义损失函数

import torch.optim as optim
#这里使用交叉熵损失函数,Optimizer使用带冲量的SGD。     
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

4.4 遍历DataLoader进行训练

for epoch in range(2):  # 这里只迭代2个epoch,实际应该进行更多次训练 
 
	running_loss = 0.0
    #enumerate将其组成一个索引序列,利用它可以同时获得索引和值
	for i, data in enumerate(trainloader, 0):
		# 得到输入
		inputs, labels = data
		
		# 梯度清零 
		optimizer.zero_grad()
		
		# forward + backward + optimize
		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')

4.5 测试

  • 取样测试
#next() 返回迭代器的下一个项目。
#next() 函数要和生成迭代器的iter() 函数一起使用。

# 1 选取图片
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)))
# 2 预测结果
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)
	_, 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))
  • 每类的测试
class_correct = list(0. for i in range(10))
class_total = list(0. for i in range(10))
with torch.no_grad():
	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 : 52 %
Accuracy of   car : 66 %
Accuracy of  bird : 49 %
Accuracy of   cat : 34 %
Accuracy of  deer : 30 %
Accuracy of   dog : 45 %
Accuracy of  frog : 72 %
Accuracy of horse : 71 %
Accuracy of  ship : 76 %
Accuracy of truck : 55 %

5 GPU训练

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(device)
# cuda:0
class Net2(nn.Module):
def __init__(self):
super(Net2, self).__init__()
self.conv1 = nn.Conv2d(3, 6, 5).to(device)
self.pool = nn.MaxPool2d(2, 2).to(device)
self.conv2 = nn.Conv2d(6, 16, 5).to(device)
self.fc1 = nn.Linear(16 * 5 * 5, 120).to(device)
self.fc2 = nn.Linear(120, 84).to(device)
self.fc3 = nn.Linear(84, 10).to(device)
 
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 = Net2()
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
 
for epoch in range(20):
 
	running_loss = 0.0
	for i, data in enumerate(trainloader, 0):
		# 得到输入
		inputs, labels = data 
		inputs, labels = inputs.to(device), labels.to(device) 
		# 梯度清零 
		optimizer.zero_grad()
		
		# forward + backward + optimize
		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')

以上是关于Pytorch速成教程整体流程的主要内容,如果未能解决你的问题,请参考以下文章

MMdetection框架速成系列 第03部分:简述整体构建细节与模块+训练测试模块流程剖析+深入解析代码模块与核心实现

极&#183;Java速成教程 -

极*Java速成教程 -

经典教程|10 分钟速成 Python3

响应式网页设计Bootstrap开发速成 从入门到精通学习总结入门教程

人工智能作业一——PyTorch安装教程