pytorch深度学习60分钟闪电战

https://pytorch.org/tutorials/beginner/deep_learning_60min_blitz.html
官方推荐的一篇教程

Tensors

#Construct a 5x3 matrix, uninitialized:
x = torch.empty(5, 3)

#Construct a randomly initialized matrix:
x = torch.rand(5, 3)

# Construct a matrix filled zeros and of dtype long:
x = torch.zeros(5, 3, dtype=torch.long)

# Construct a tensor directly from data:
x = torch.tensor([5.5, 3])

# create a tensor based on an existing tensor. These methods will reuse properties of the input tensor, e.g. dtype, unless new values are provided by user
x = x.new_ones(5, 3, dtype=torch.double)      # new_* methods take in sizes
print(x)
x = torch.randn_like(x, dtype=torch.float)    # override dtype!    #沿用了x已有的属性,只是修改dtype
print(x)                                      # result has the same size

tensor操作的语法有很多写法,以加法为例

#1
x = x.new_ones(5, 3, dtype=torch.double)
y = torch.rand(5, 3)
print(x + y)

#2
print(torch.add(x, y))

#3
result = torch.empty(5, 3)
torch.add(x, y, out=result)
print(result)

##注意以_做后缀的方法,都会改变原始的变量
#4 Any operation that mutates a tensor in-place is post-fixed with an _. For example: x.copy_(y), x.t_(), will change x.
# adds x to y
y.add_(x)
print(y)

改变tensor的size,使用torch.view:

x = torch.randn(4, 4)
y = x.view(16)
z = x.view(-1, 8)  # the size -1 is inferred from other dimensions
print(x.size(), y.size(), z.size())

输出如下:
torch.Size([4, 4]) torch.Size([16]) torch.Size([2, 8])

numpy array和torch tensor的相互转换

  • torch tensor转换为numpy array
a = torch.ones(5)
print(a)
输出tensor([1., 1., 1., 1., 1.])

#torch tensor--->numpy array
b = a.numpy()
print(b)
输出[1. 1. 1. 1. 1.]

#注意!:a,b同时发生了变化
a.add_(1)
print(a)
print(b)
输出tensor([2., 2., 2., 2., 2.])
   [2. 2. 2. 2. 2.]
  • numpy array转换为torch tensor
a = np.ones(5)
b = torch.from_numpy(a)
np.add(a, 1, out=a)

所有的cpu上的tensor,除了chartensor,都支持和numpy之间的互相转换.

All the Tensors on the CPU except a CharTensor support converting to NumPy and back.

CUDA Tensors

Tensors can be moved onto any device using the .to method.

#let us run this cell only if CUDA is available
#We will use ``torch.device`` objects to move tensors in and out of 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
    print(z)
    print(z.to("cpu", torch.double))       # ``.to`` can also change dtype together!  

--->
tensor([0.6635], device='cuda:0')
tensor([0.6635], dtype=torch.float64)

AUTOGRAD

The autograd package provides automatic differentiation for all operations on Tensors. It is a define-by-run framework, which means that your backprop is defined by how your code is run, and that every single iteration can be different.

Generally speaking, torch.autograd is an engine for computing vector-Jacobian product

.requires_grad属性设为true,则可以追踪tensor上的所有操作(比如加减乘除)

torch.Tensor is the central class of the package. If you set its attribute .requires_grad as True, it starts to track all operations on it. When you finish your computation you can call .backward() and have all the gradients computed automatically. The gradient for this tensor will be accumulated into .grad attribute.

autograd包实现自动的求解梯度.

神经网络

torch.nn包可以用来构建神经网络.
nn依赖autogard来不断地更新model中各层的参数. nn.Module包含layers,forward方法.

典型的神经网络的训练过程如下:

  • 定义一个神经网络,含learnable parameters或者叫weights
  • 对数据集的所有数据作为Input输入网络
  • 计算loss
  • 反向传播计算weights的梯度
  • 更新weights,一个典型的简单规则:weight = weight - learning_rate * gradient

定义网络

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

class Net(nn.Module):

    def __init__(self):
        super(Net, self).__init__()
        # 1 input image channel, 6 output channels, 5x5 square convolution
        # kernel
        self.conv1 = nn.Conv2d(1, 6, 5)    #输入是1个矩阵,输出6个矩阵,filter是5*5矩阵.即卷积层1使用6个filter.
        self.conv2 = nn.Conv2d(6, 16, 5)   #输入是6个矩阵,输出16个矩阵,filter是5*5矩阵.即卷积层2使用16个filter.
        # an affine operation: y = Wx + b
        self.fc1 = nn.Linear(16 * 5 * 5, 120)   #全连接层,fc=fullconnect  作用是分类
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        # Max pooling over a (2, 2) window
        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)
        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:]  # 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)
)

你只需要定义forward函数,backward函数(即计算梯度的函数)是autograd包自动定义的.你可以在forward函数里使用任何tensor操作.

model的参数获取.

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

输出如下:
10
torch.Size([6, 1, 5, 5])

以MNIST识别为例,输入图像为3232.我们用一个随机的3232输入演示一下.

input = torch.randn(1, 1, 32, 32)
out = net(input)
print(out)

输出如下:
tensor([[ 0.0659, -0.0456,  0.1248, -0.1571, -0.0991, -0.0494,  0.0046, -0.0767,
         -0.0345,  0.1010]], grad_fn=<AddmmBackward>)

#清空所有的parameter的gradient buffer.用随机的梯度反向传播。
#Zero the gradient buffers of all parameters and backprops with random gradients:
net.zero_grad()
out.backward(torch.randn(1, 10))

回忆一下部分概念

  • torch.Tensor - A multi-dimensional array with support for autograd operations like backward(). Also holds the gradient w.r.t. the tensor.
  • nn.Module - Neural network module. Convenient way of encapsulating parameters, with helpers for moving them to GPU, exporting, loading, etc.
  • nn.Parameter - A kind of Tensor, that is automatically registered as a parameter when assigned as an attribute to a Module.
  • autograd.Function - Implements forward and backward definitions of an autograd operation. Every Tensor operation creates at least a single Function node that connects to functions that created a Tensor and encodes its history.

损失函数

nn package有好几种损失函数.以nn.MSELoss为例

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)

输出
tensor(0.6918, grad_fn=<MseLossBackward>)

Now, if you follow loss in the backward direction, using its .grad_fn attribute, you will see a graph of computations that looks like this:
input -> conv2d -> relu -> maxpool2d -> conv2d -> relu -> maxpool2d
-> view -> linear -> relu -> linear -> relu -> linear
-> MSELoss
-> loss

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
输出如下:
<MseLossBackward object at 0x7ff3406e1be0>
<AddmmBackward object at 0x7ff3406e1da0>
<AccumulateGrad object at 0x7ff3406e1da0>

反向传播

调用loss.backward()重新计算梯度

#首先清空现有的gradient buffer
net.zero_grad()     # zeroes the gradient buffers of all parameters

print('conv1.bias.grad before backward')
print(net.conv1.bias.grad)

loss.backward()

print('conv1.bias.grad after backward')
print(net.conv1.bias.grad)

输出如下:
conv1.bias.grad before backward
tensor([0., 0., 0., 0., 0., 0.])
conv1.bias.grad after backward
tensor([-0.0080,  0.0043, -0.0006,  0.0142, -0.0017, -0.0082])

更新权重

最常见的是使用随机梯度下降法更新权重:
weight = weight - learning_rate * gradient
简单实现如下

learning_rate = 0.01
for f in net.parameters():
    f.data.sub_(f.grad.data * learning_rate)

torch.optim包封装了各种各样的优化方法, SGD, Nesterov-SGD, Adam, RMSProp等等.

import torch.optim as optim

# create your optimizer
optimizer = optim.SGD(net.parameters(), lr=0.01)

# in your training loop:
optimizer.zero_grad()   # zero the gradient buffers
output = net(input)
loss = criterion(output, target)
loss.backward()
optimizer.step()    # Does the update

训练一个分类器

并行计算

原文地址:https://www.cnblogs.com/sdu20112013/p/10609826.html

时间: 2024-10-08 18:08:05

pytorch深度学习60分钟闪电战的相关文章

【PyTorch深度学习60分钟快速入门 】Part1:PyTorch是什么?

0x00 PyTorch是什么? PyTorch是一个基于Python的科学计算工具包,它主要面向两种场景: 用于替代NumPy,可以使用GPU的计算力 一种深度学习研究平台,可以提供最大的灵活性和速度 0x01 开始学习 1.Tensors Tensors(张量)类似于numpy的ndarrays,不过Tensors还可以运行于GPU上以提升计算速度. from __future__ import print_function import torch 创建一个5x3且未初始化的矩阵: x =

【PyTorch深度学习60分钟快速入门 】Part3:神经网络

神经网络可以通过使用torch.nn包来构建. 既然你已经了解了autograd,而nn依赖于autograd来定义模型并对其求微分.一个nn.Module包含多个网络层,以及一个返回输出的方法forward(input) . 例如,查看下图中的对数字图片分类的网络: 这是一个简单的前馈网络.它接受输入,并将输入依次通过多个层,然后给出输出结果. 对于神经网络来说,一个经典的训练过程包括以下步骤: 定义一个包含一些可学习的参数(或权重)的神经网络 对输入数据集进行迭代 通过网络处理输入 计算损失

【PyTorch深度学习60分钟快速入门 】Part2:Autograd自动化微分

在PyTorch中,集中于所有神经网络的是autograd包.首先,我们简要地看一下此工具包,然后我们将训练第一个神经网络. autograd包为张量的所有操作提供了自动微分.它是一个运行式定义的框架,这意味着你的后向传播是由你的代码运行方式来定义的,并且每一个迭代都可以是不同的. 下面,让我们使用一些更简单的术语和例子来解释这个问题. 0x01 变量(Variable) autograd.Variable是autograd包的核心类,它封装了一个张量,并支持几乎所有在该张量上定义的操作.一旦完

分享《深度学习之Pytorch(廖星宇著)》+《PyTorch深度学习实战(侯宜军 著)》+源代码

下载:https://pan.baidu.com/s/1ewm1x3UeMe283PQVbDVIoA 更多资料分享:https://www.cnblogs.com/javapythonstudy/ <深度学习之Pytorch(廖星宇著)>PDF,232页,带书签,文字可以复制粘贴.<PyTorch深度学习实战(侯宜军 著)>PDF,121页,带书签,文字可以复制粘贴.配套源代码. 如图: 原文地址:https://www.cnblogs.com/javapythonstudy/p/

对比学习:《深度学习之Pytorch》《PyTorch深度学习实战》+代码

PyTorch是一个基于Python的深度学习平台,该平台简单易用上手快,从计算机视觉.自然语言处理再到强化学习,PyTorch的功能强大,支持PyTorch的工具包有用于自然语言处理的Allen NLP,用于概率图模型的Pyro,扩展了PyTorch的功能.通过学习<深度学习入门之PyTorch>,可以从机器学习和深度学习的基础理论入手,从零开始学习 PyTorch,了解 PyTorch 基础,以及如何用 PyTorch 框架搭建模型.学到机器学习中的线性回归和 Logistic 回归.深度

分析《Pytorch 深度学习》PDF中文+mobi+epub+源代码

深度学习为世界上的智能系统(比如Google Voice.Siri和Alexa)提供了动力.随着硬件(如GPU)和软件框架(如PyTorch.Keras.TensorFlow和CNTK)的进步以及大数据的可用性,人们在文本.视觉和分析等领域更容易实施相应问题的解决方案. 使用PyTorch轻松开发深度学习应用程序推荐学习<Pytorch 深度学习>.<Pytorch 深度学习>对当今前沿的深度学习库PyTorch进行了讲解.凭借其易学习性.高效性以及与Python开发的天然亲近性,

PyTorch 60 分钟入门教程:PyTorch 深度学习官方入门中文教程

什么是 PyTorch? PyTorch 是一个基于 Python 的科学计算包,主要定位两类人群: NumPy 的替代品,可以利用 GPU 的性能进行计算. 深度学习研究平台拥有足够的灵活性和速度 开始学习 Tensors (张量) Tensors 类似于 NumPy 的 ndarrays ,同时  Tensors 可以使用 GPU 进行计算. from future import print_function import torch 构造一个5x3矩阵,不初始化. x = torch.em

[PyTorch入门之60分钟入门闪击战]之神经网络

神经网络 来源于这里. 神经网络可以使用torch.nn包构建. 现在你对autograd已经有了初步的了解,nn依赖于autograd定义模型并区分它们.一个nn.Module包含了层(layers),和一个用来返回output的方法forward(input). 以下面这个区分数字图像的网络为例: 上图是一个简单的前馈网络.它接受输入,一个层接一层地通过几层网络,最后给出输出. 典型的神经网络训练程序如下: 定义具有一些可学习参数(或权重)的神经网络 迭代输入的数据集 通过网络处理输入 计算

[PyTorch入门之60分钟入门闪击战]之训练分类器

训练分类器 目前为止,你已经知道如何定义神经网络.计算损失和更新网络的权重.现在你可能在想,那数据呢? What about data? 通常,当你需要处理图像.文本.音频或者视频数据时,你可以使用标准Python包来将数据导入到numpy 数组中.然后再将数组转换成torch.Tensor. 对于图像,可用的包有:Pillow.OpenCV 对于音频,可用的包有:scipy和librosa 对于文本,无论是基于原始的Python或Cython的加载,或是NLTK和SpaCy都是可以的. 对于视