[Pytorch]＜动手学深度学习＞pytorch笔记-----预备知识

原书籍地址:https://raw.githubusercontent.com/OUCMachineLearning/OUCML/master/BOOK/Dive-into-DL-PyTorch.pdf

Pytorch版出处:Dive-into-DL-PyTorch

1.创建Tensor

首先导入torch包

import torch

1.创建大小为5x3的未初始化的Tensor并输出

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

结果:
tensor([[0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.]])

2.创建大小为5x3的随机初始化的Tensor并输出

x = torch.rand(5,3)
print(x)
​
结果:
tensor([[0.6797, 0.8230, 0.9613],
        [0.4785, 0.9738, 0.7968],
        [0.4069, 0.4334, 0.9884],
        [0.7137, 0.2509, 0.7648],
        [0.6860, 0.7839, 0.6713]])

3.创建大小为5x3的long类型全0的Tensor并输出

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

结果:
tensor([[0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0]])

4.直接输入数据创建

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

结果:
tensor([5.5000, 3.0000])

5.重用现有的Tensor并根据默认设定的Tensor设置,会默认重用现有的一些属性,比如数据类型

比如重用上面的x,使用new_ones方法重新赋值

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

结果:
tensor([[1, 1, 1],
        [1, 1, 1],
        [1, 1, 1],
        [1, 1, 1],
        [1, 1, 1]])
tensor([[-0.1084,  1.1410, -0.1979],
        [ 0.4108, -0.3062,  1.4644],
        [ 0.0127,  0.4850,  1.2830],
        [ 1.7580, -1.1581,  1.0869],
        [-0.5030,  0.8562,  1.4382]])

6.通过一些函数获取Tensor的形状

使用shape函数或size()来获取

print(x.size())
print(x.shape)

结果:
torch.Size([5, 3])
torch.Size([5, 3])

2.Tensor的操作

1.加法

x = torch.ones(5, 3, dtype=torch.long)
y = torch.rand(5, 3)
# 加法形式一
print(x + y)
# 加法形式二
print(torch.add(x, y))
# 加法形式三
result = torch.empty(5, 3)
torch.add(x, y, out=result)
print(result)
# 加法形式四
y.add_(x)
print(y)

结果均为:
tensor([[1.1353, 1.2257, 1.1745],
        [1.1782, 1.5084, 1.6610],
        [1.9066, 1.0172, 1.4697],
        [1.6617, 1.0318, 1.8769],
        [1.9799, 1.6620, 1.2080]])

2.索引

使用类似NumPy的索引操作来访问Tensor的一部分，索引出来的结果与原数据共享内存，也即修改一个，另一个会跟着修改。

x = torch.rand(5, 3)
y = torch.rand(5, 3)
y = x[0, :] #这里的0表示第0行的元素
y += 1
print(y)
print(x[0, :]) # 源tensor也被改了

结果:
tensor([1.1774, 1.2149, 1.6591])
tensor([1.1774, 1.2149, 1.6591])

3.改变形状

使用view()函数改变形状

注意view()返回的新Tensor与源Tensor虽然可能有不同的size，但是是共享data的，也即更改其中的一个，另外一个也会跟着改变。(顾名思义，view仅仅是改变了对这个张量的观察角度，内部数据并未改变)

x = torch.rand(5, 3)
y = x.view(15)
z = x.view(-1, 5)  # -1所指的维度可以根据其他维度的值推出来 即多少×5=15 计算机自动补全是3
print(x.size(), y.size(), z.size())

结果:
torch.Size([5, 3]) torch.Size([15]) torch.Size([3, 5])

如果想返回一个真正新的副本（即不共享data内存）该怎么办呢？Pytorch还提供了一个reshape()可以改变形状，但是此函数并不能保证返回的是其拷贝，所以不推荐使用。

推荐先用clone创造一个副本然后再使用view

x = torch.rand(5, 3)

x_cp = x.clone().view(15)
x -= 1
print(x)
print(x_cp)

结果:
tensor([[-0.1021, -0.3046, -0.5882],
        [-0.6889, -0.1760, -0.0528],
        [-0.9359, -0.2146, -0.4469],
        [-0.3987, -0.9937, -0.6773],
        [-0.4352, -0.1891, -0.3560]])
tensor([0.8979, 0.6954, 0.4118, 0.3111, 0.8240, 0.9472, 0.0641, 0.7854, 0.5531,
        0.6013, 0.0063, 0.3227, 0.5648, 0.8109, 0.6440])

可以看到 原x整体-1了,而复制的x_cp并未减一,同时其形状更改成一维了

另外一个常用的函数就是item(), 它可以将一个标量Tensor转换成一个Python number：

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

结果:
tensor([-1.0325])
-1.032474160194397

3.广播机制(不等形式矩阵之间操作自动扩展)

前面我们看到如何对两个形状相同的Tensor做按元素运算。当对两个形状不同的Tensor按元素运算时，可能会触发广播（broadcasting）机制：先适当复制元素使这两个Tensor形状相同后再按元素运算。例如：

x = torch.arange(1, 3).view(1, 2)
print(x)
y = torch.arange(1, 4).view(3, 1)
print(y)
print(x + y)

输出:
​tensor([[1, 2]])
tensor([[1],
        [2],
        [3]])
tensor([[2, 3],
        [3, 4],
        [4, 5]])
​

由于x和y分别是1行2列和3行1列的矩阵，如果要计算x + y，那么x中第一行的2个元素被广播（复制）到了第二行和第三行，而y中第一列的3个元素被广播（复制）到了第二列。如此，就可以对2个3行2列的矩阵按元素相加。

4.运算时的内存机制

索引操作是不会开辟新内存的，而像y = x + y这样的运算是会新开内存的，然后将y指向新内存。为了演示这一点，我们可以使用Python自带的id函数：如果两个实例的ID一致，那么它们所对应的内存地址相同；反之则不同。

x = torch.tensor([1, 2])
y = torch.tensor([3, 4])
id_before = id(y)
y = y + x
print(id(y) == id_before) # False 

如果想指定结果到原来的y的内存，我们可以使用前面介绍的索引来进行替换操作。在下面的例子中，我们把x + y的结果通过[:]写进y对应的内存中。

x = torch.tensor([1, 2])
y = torch.tensor([3, 4])
id_before = id(y)
y[:] = y + x
print(id(y) == id_before) # True

我们还可以使用运算符全名函数中的out参数或者自加运算符+=(也即add_())达到上述效果，例如torch.add(x, y, out=y)和y += x(y.add_(x))。

x = torch.tensor([1, 2])
y = torch.tensor([3, 4])
id_before = id(y)
torch.add(x, y, out=y) # y += x, y.add_(x)
print(id(y) == id_before) # True

 注：虽然view返回的Tensor与源Tensor是共享data的，但是依然是一个新的Tensor（因为Tensor除了包含data外还有一些其他属性），二者id（内存地址）并不一致。

5.Tensor和Numpy互相转换

numpy()和from_numpy()将Tensor和NumPy中的数组相互转换。

注： 这两个函数所产生的的Tensor和NumPy中的数组共享相同的内存（所以他们之间的转换很快），改变其中一个时另一个也会改变！

还有一个常用的将NumPy中的array转换成Tensor的方法就是torch.tensor(), 需要注意的是，此方法总是会进行数据拷贝（就会消耗更多的时间和空间），所以返回的Tensor和原来的数据不再共享内存。

使用numpy()将Tensor转换成NumPy数组:

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

a += 1
print(a, b)
b += 1
print(a, b)

输出:
​tensor([1., 1., 1., 1., 1.]) [1. 1. 1. 1. 1.]
tensor([2., 2., 2., 2., 2.]) [2. 2. 2. 2. 2.]
tensor([3., 3., 3., 3., 3.]) [3. 3. 3. 3. 3.]
​

使用from_numpy()将NumPy数组转换成Tensor:

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

a += 1
print(a, b)
b += 1
print(a, b)

输出:
[1. 1. 1. 1. 1.] tensor([1., 1., 1., 1., 1.], dtype=torch.float64)
[2. 2. 2. 2. 2.] tensor([2., 2., 2., 2., 2.], dtype=torch.float64)
[3. 3. 3. 3. 3.] tensor([3., 3., 3., 3., 3.], dtype=torch.float64)

直接用torch.tensor()将NumPy数组转换成Tensor，需要注意的是该方法总是会进行数据拷贝，返回的Tensor和原来的数据不再共享内存。

c = torch.tensor(a)
a += 1
print(a, c)

输出:
​[4. 4. 4. 4. 4.] tensor([3., 3., 3., 3., 3.], dtype=torch.float64)
​

 6.Tensor on GPU

用方法to()可以将Tensor在CPU和GPU（需要硬件支持）之间相互移动。

x = torch.ones(5)
# 以下代码只有在PyTorch GPU版本上才会执行
if torch.cuda.is_available():
    device = torch.device("cuda")          # GPU
    y = torch.ones_like(x, device=device)  # 直接创建一个在GPU上的Tensor
    x = x.to(device)                       # 等价于 .to("cuda")
    z = x + y
    print(z)
    print(z.to("cpu", torch.double))       # to()还可以同时更改数据类型

 7.求梯度

在深度学习中，我们经常需要对函数求梯度（gradient）。PyTorch提供的autograd包能够根据输入和前向传播过程自动构建计算图，并执行反向传播。

梯度的使用

Tensor是这个包的核心类，如将属性.requires_grad设置为True，它将开始追踪(track)在其上的所有操作（这样就可以利用链式法则进行梯度传播了）。完成计算后，可以调用.backward()来完成所有梯度计算。此Tensor的梯度将累积到.grad属性中。如果不想被继续追踪，可以调用.detach()将其从追踪记录中分离出来,还可以用with torch.no_grad()将不想被追踪的操作代码块包裹起来，这种方法在评估模型的时候很常用，因为在评估模型时，我们并不需要计算可训练参数（requires_grad=True）的梯度。

Function是另外一个很重要的类。Tensor和Function互相结合就可以构建一个记录有整个计算过程的有向无环图（DAG）。每个Tensor都有一个.grad_fn属性，该属性即创建该Tensor的Function, 就是说该Tensor是不是通过某些运算得到的，若是，则grad_fn返回一个与这些运算相关的对象，否则是None。

注意在y.backward()时，如果y是标量，则不需要为backward()传入任何参数；否则，需要传入一个与y同形的Tensor.

创建一个Tensor并设置requires_grad=True:

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

输出：

tensor([[1., 1.],
        [1., 1.]], requires_grad=True)
None

再做一下运算操作：

y = x + 2
print(y)
print(y.grad_fn)

输出：

tensor([[3., 3.],
        [3., 3.]], grad_fn=)

注意x是直接创建的，所以它没有grad_fn, 而y是通过一个加法操作创建的，所以它有一个为的grad_fn。

像x这种直接创建的称为叶子节点，叶子节点对应的grad_fn是None。

print(x.is_leaf, y.is_leaf) # True False

再来点复杂度运算操作：

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

输出：

tensor([[27., 27.],
        [27., 27.]], grad_fn=) tensor(27., grad_fn=)

通过.requires_grad_()来用in-place的方式改变requires_grad属性：

a = torch.randn(2, 2) # 缺失情况下默认 requires_grad = False
a = ((a * 3) / (a - 1))
print(a.requires_grad) # False
a.requires_grad_(True)
print(a.requires_grad) # True
b = (a * a).sum()
print(b.grad_fn)

输出：

False
True

对backward()函数的使用

因为out是一个标量，所以调用backward()时不需要指定求导变量：

out.backward() # 等价于 out.backward(torch.tensor(1.))

我们来看看out关于x的梯度 [Math Processing Error]

dxd(out)​:

print(x.grad)

输出：

tensor([[4.5000, 4.5000],
        [4.5000, 4.5000]])

我们令out为o , 因为

 

所以

 所以上面的输出是正确的。

注意：grad在反向传播过程中是累加的(accumulated)，这意味着每一次运行反向传播，梯度都会累加之前的梯度，所以一般在反向传播之前需把梯度清零。

# 再来反向传播一次，注意grad是累加的
out2 = x.sum()
out2.backward()
print(x.grad)

out3 = x.sum()
x.grad.data.zero_()
out3.backward()
print(x.grad)

输出：

tensor([[5.5000, 5.5000],
        [5.5000, 5.5000]])
tensor([[1., 1.],
        [1., 1.]])

为什么在y.backward()时，如果y是标量，则不需要为backward()传入任何参数；否则，需要传入一个与y同形的Tensor? 简单来说就是为了避免向量（甚至更高维张量）对张量求导，而转换成标量对张量求导。举个例子，假设形状为 m x n 的矩阵 X 经过运算得到了 p x q 的矩阵 Y，Y 又经过运算得到了 s x t 的矩阵 Z。那么按照前面讲的规则，dZ/dY 应该是一个 s x t x p x q 四维张量，dY/dX 是一个 p x q x m x n的四维张量。问题来了，怎样反向传播？怎样将两个四维张量相乘？？？这要怎么乘？？？就算能解决两个四维张量怎么乘的问题，四维和三维的张量又怎么乘？导数的导数又怎么求，这一连串的问题，感觉要疯掉…… 为了避免这个问题，我们不允许张量对张量求导，只允许标量对张量求导，求导结果是和自变量同形的张量。所以必要时我们要把张量通过将所有张量的元素加权求和的方式转换为标量，举个例子，假设y由自变量x计算而来，w是和y同形的张量，则y.backward(w)的含义是：先计算l = torch.sum(y * w)，则l是个标量，然后求l对自变量x的导数。

来看一些实际例子。

x = torch.tensor([1.0, 2.0, 3.0, 4.0], requires_grad=True)
y = 2 * x
z = y.view(2, 2)
print(z)

输出：

tensor([[2., 4.],
        [6., 8.]], grad_fn=)

现在 z 不是一个标量，所以在调用backward时需要传入一个和z同形的权重向量进行加权求和得到一个标量。

v = torch.tensor([[1.0, 0.1], [0.01, 0.001]], dtype=torch.float)
z.backward(v)
print(x.grad)

输出：

tensor([2.0000, 0.2000, 0.0200, 0.0020])

注意，x.grad是和x同形的张量,假设 x 经过一番计算得到 z，那么 z.backward(v) 求的不是 z 对 v 的导数，而是 l = torch.sum(y*v) 对 x 的导数。w 可以视为 y 的各分量的权重。即这里的v对应位置与x相乘,求的是y=2x的导数,均为2,再与v的tensor相乘得到结果.

再来看看中断梯度追踪的例子：

x = torch.tensor(1.0, requires_grad=True)
y1 = x ** 2 
with torch.no_grad():
    y2 = x ** 3
y3 = y1 + y2

print(x.requires_grad)
print(y1, y1.requires_grad) # True
print(y2, y2.requires_grad) # False
print(y3, y3.requires_grad) # True

输出：

True
tensor(1., grad_fn=) True
tensor(1.) False
tensor(2., grad_fn=) True

可以看到，上面的y2是没有grad_fn而且y2.requires_grad=False的，而y3是有grad_fn的。如果我们将y3对x求梯度的话会是多少呢？

y3.backward()
print(x.grad)

输出：

tensor(2.)

上面提到，y2.requires_grad=False，所以不能调用 y2.backward()，会报错：

RuntimeError: element 0 of tensors does not require grad and does not have a grad_fn

此外，如果我们想要修改tensor的数值，但是又不希望被autograd记录（即不会影响反向传播），那么我么可以对tensor.data进行操作。

x = torch.ones(1,requires_grad=True)

print(x.data) # 还是一个tensor
print(x.data.requires_grad) # 但是已经是独立于计算图之外

y = 2 * x
x.data *= 100 # 只改变了值，不会记录在计算图，所以不会影响梯度传播

y.backward()
print(x) # 更改data的值也会影响tensor的值
print(x.grad)

输出：

tensor([1.])
False
tensor([100.], requires_grad=True)
tensor([2.])