Pytorch Tutorial (1) -- DEEP LEARNING WITH PYTORCH: A 60 MINUTE BLITZ - Markdown版本

ith PyTorch: A 60 Minute Blitz)

0.基础准备

官方网页：https://pytorch.org/tutorials/beginner/deep_learning_60min_blitz.html#deep-learning-with-pytorch-a-60-minute-blitz

1.安装torchvision

conda install torchvision -c pytorch

2.更新了一堆，以下是torchvision文档

https://pytorch.org/docs/master/torchvision/

---

1.What is PyTorch?

0.导入模块

https://blog.csdn.net/xiaotao_1/article/details/79460365（py27与py3的print不兼容怎么办？）

from __future__ import print_function
import torch

1.Tensor

torch.tensor类似numpy.ndarrays，但是写出来的语法可以用GPU加速

1.创建一个5*3没有初始化的矩阵

x = torch.empty(5, 3)
print(x)

2.创建一个5*3随机初始化的矩阵

x = torch.rand(5, 3)
print(x)

3.创建一个类型为long的0矩阵

x = torch.zeros(5, 3, dtype=torch.long)
print(x)

4.根据给定数据值创建张量

x = torch.tensor([5.5, 3])
print(x)

5.根据已有的张量创建新的张量

该方法会使用输入张量的属性，如dtype，除非用户新赋值

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!
print(x)                                      # result has the same size

6.获得矩阵的大小

torch.size是tuple，可以进行tuple一切操作
print(x.size())

---

2.Operations

1.加法操作符

1.方法一

y = torch.rand(5, 3)
print(x + y)

2.方法二

print(torch.add(x, y))

使用参数out定义输出张亮变量，方便继续操作

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

3.方法三

注意：任何一个原地改变张量的操作符

# adds x to y
y.add_(x)
print(y)

2.辅助操作

1.输出某一列向量的值

print(x)
print(x[:, 1])

2.将张量重新塑形（使用torch.view）

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

3.提取单元素张量数值

如果有一个张量只有一个元素，使用.item()可以将其数值作为python数字

x = torch.randn(1)
print(x)
print(x.item())

3.关于操作符部分，查看文档学习更多

https://pytorch.org/docs/stable/torch.html

---

3.NUMPY BRIDGE

torch.tensor<->numpy.array

1.Torch Tensor->NumPy Array

a = torch.ones(5)
print("a =", a)
b = a.numpy()
print("b =", b)

变更tensor的数值（torch tensor和numpy array共享表层存储空间，改一个数值，剩下的都会被改）

a.add_(1)
print("a =", a)
print("b =", b)

2.NumPy Array->Torch Tensor

import numpy as np
a = np.ones(5)
b = torch.from_numpy(a)
np.add(a, 1, out=a)
print(a)
print(b)

---

4.CUDA TENSORS

1.使用.to方法，可以将向量移至任何设备
2.使用torch.device方法，能将向量移进和移出GPU

x = torch.tensor(0.163)
if torch.cuda.is_available():
    device = torch.device("cuda")          # 创建一个a CUDA device
    y = torch.ones_like(x, device=device)  # 直接在GPU上创建tensor，并不懂one_like代表什么
    x = x.to(device)                       # or just use strings ``.to("cuda")``
    z = x + y
    print(x)
    print(y)
    print(z)
    print(z.to("cpu", torch.double))       # ``.to`` 可以改变dtype类型

2.AUTOGRAD: AUTOMATIC DIFFERENTIATION

AUTOGRAD：自动求导
autograd在pytorch中是所有神经网络的核心，autograd包提供对于Tensor所有操作的自动求导，这是运行时定义的框架（即后向传播是根据你的代码如何运行而定义的，即每一次单独的迭代可以是不同的）

1.Tensor和Function

一、基础内容

1.Tensor

①设置追踪操作：torch.Tensor是这个包里最核心的类，当将.requires_grad属性设置为True时，就开始跟踪所有在Tensor上的运算的操作。
②自动计算梯度：当你完成计算，你可以调用.backward()，可以自动计算所有的梯度。该Tensor的梯度将会被自动积累到.grad属性
③停止追踪：停止一个Tensor追踪历史，可以调用.detach()，停止当前和后续的计算历史跟踪
④停止跟踪（评估模型用到）：为了阻止跟踪历史/使用内存，也可以用torch.no_grad()抹掉代码块，该方法在评估一个模型的时候特别有帮助，因为这个模型可能具备requires_grad=True可训练的参数，但是我们并不需要他们的梯度

2.Function

①引用属性fn： 另一个对于自动求导的实现非常有帮助的类——Function
Tensor和Function互相连接，构建一个非循环图，它将整个计算历史编码。每一个tensor有一个.grad_fn属性，它引用了已经创建的Tensor的Function属性，除非是用户自己创建的Tensors，他们的grad_fn=None.

②求导数：如果想求导数，可以在一个Tensor上调用.backward()属性，

• 如果Tensor是一个标量（Tensor中只有一个元素），则不需要指定任何参数到.backward()中，
• 如果大于一个参数时，你需要指定一个gradient参数（来匹配tensor的形状）

二、代码案例

import torch

创建tensor并开始追踪计算

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

y是由运算生成的，因此后面有grad_fn属性（如果是用户创建的就没有了）

y = x + 2
print(y)

跟踪乘积，跟踪均值操作

z = y * y * 3
out = z.mean()
print(z, out)

requires_grad_(...)原位改变Tensor的requires_grad标签，如果没给定requires_grad标签值，默认为False

a = torch.randn(2, 2)
print(a)
a = ((a * 3) / (a - 1))
print(a)
print(a.requires_grad)

a.requires_grad_(True)
print(a.requires_grad)

print("--------")

b = (a * a)
print(b)

b = (a * a).sum()
print(b)

打印标签位置
print(b.grad_fn)

2.GRADIENTS

一、基础知识

①反向传播：out包含一个标量，out.backward.()等价于out.backward(torch.tensor(1.))

out.backward()

还是不懂啥意思，尝试将图后向传播，但是图已经被释放，需要第一次后向传播的时候让retain_graph=True
②求梯度d(out)/dx：虽然说对x求导，但是最终求的是关于x的最后一个式子z=3(x+2)^2求导

print(x.grad)

③雅克比矩阵：

④求雅克比向量积torch.autograd：
内容：给定一个向量v，计算雅克比矩阵J和向量v的内积。如果v是标量函数对y的梯度，根据链式求导法则，J⋅v最终结果对应标量函数对x的梯度

意义：便于将外部梯度送入一个非标量输出的模型

详查文档 https://pytorch.org/docs/autograd

二、代码案例

Jacobian-vector product

x = torch.randn(3, requires_grad=True)
print(y)

y = x * 2
print(y)

while y.data.norm() < 1000: #计算范数值
    y = y * 2

print(y)

当y不再是标量，torch.autograd不能直接计算雅克比矩阵，但是如果只想得到雅克比矩阵矢量积，将向量v作为一个参数向backward传递

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

使用with torch.no_grad():停止在.requires_grad=True上追踪autograd历史

print(x.requires_grad)
print((x**2).requires_grad)

x.requires_grad=False
print(x.requires_grad)

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

注意：keyword can’t be an expression

3.NEURAL NETWORKS

4.TRAINING A CLASSIFIER

5.OPTIONAL: DATA PARALLELISM

6.答疑

1.什么是dtype
[答] 这个是numpy里面的， 数组元素的类型可以通过dtype属性获得，主要查看array 里面的数据类型

返回首层