深度学习+pytorch自学笔记（一）——PyTorch基础

背景
本人目前为大四学生，已被清华大学拟录取。

由于研究生目前初定的方向会涉及到深度学习的内容，导师说会利用pytorch进行缺陷检测等，涉及精密测量、先进制造等相关领域。因此，于毕业论文差不多初步完成之际开始自学。

为了便于知识的整理，因此打算将每一次的学习内容，整理成笔记，方便自己查看巩固，以及其他志同道合的朋友参考查阅。编译器为PyCharm，参考书籍为软件工程朋友推荐的《动手学深度学习(pytorch版），参考网址为：https://tangshusen.me/Dive-into-DL-PyTorch/#/
请大家也多多支持这一个很好用的平台~

大部分内容为书中内容，也有部分自己实验和添加的内容，如涉及侵权，会进行删除。

正文——预备知识之数据操作

一、张量创建
torch.tensor是存储和数据变换的主要工具。Tensor和NumPy的多维数组非常类似。"tensor"这个单词一般可译作“张量”，张量可以看作是一个多维数组。标量可以看作是0维张量，向量可以看作1维张量，矩阵可以看作是二维张量。

实验程序：

import torch

x1 = torch.empty(5, 3)   # 生成空的未初始化矩阵，不一定都是0
print(x1)

x2 = torch.rand(5, 4)   # 生成随机矩阵
print(x2)

x3 = torch.zeros(5, 4, dtype=torch.long)  # 生成全零矩阵
print(x3)

x4 = torch.tensor([3, 4, 5])  # 将列表转换维tensor类型,括号内即为一个列表
print(x4)

x5 = x4.new_ones([5, 3], dtype=torch.double)  # 构造全1的数组
print(x5)
x6 = torch.rand_like(x5, dtype=torch.float)  # 生成相同维度的随机矩阵
print(x6.size())   # 通过shape或者size()来获取Tensor的形状
print(x6.shape)

输出：

tensor([[-6.9496e+17,  8.2396e-43, -6.9521e+17],
        [ 8.2396e-43, -6.9521e+17,  8.2396e-43],
        [-6.9521e+17,  8.2396e-43, -6.9505e+17],
        [ 8.2396e-43, -6.9505e+17,  8.2396e-43],
        [-6.9511e+17,  8.2396e-43, -6.9511e+17]])
tensor([[7.8935e-01, 9.3383e-02, 3.0014e-01, 9.6596e-01],
        [2.7844e-01, 5.4451e-01, 3.6072e-01, 5.3084e-02],
        [5.4204e-04, 7.0943e-01, 5.9118e-02, 8.3227e-01],
        [8.9181e-01, 5.5108e-01, 1.8990e-01, 1.3730e-01],
        [1.2313e-01, 1.6050e-01, 8.0627e-02, 8.3281e-01]])
tensor([[0, 0, 0, 0],
        [0, 0, 0, 0],
        [0, 0, 0, 0],
        [0, 0, 0, 0],
        [0, 0, 0, 0]])
tensor([3, 4, 5])
tensor([[1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.]], dtype=torch.float64)
torch.Size([5, 3])
torch.Size([5, 3])

注意区分ones和new_ones：

Ones用法为torch.ones(size)，用于生成全1的Tensor
new_ones用法为x.new_ones(size)，相当于按照x的格式创建全1的Tensor，数据维数大小可以不一样，但返回的tensor默认具有相同的torch.dtype和torch.device

实验程序：

x1 = torch.rand(5, 3, dtype=torch.float64)   # 生成空的矩阵
print(x1)

x2 = x1.new_ones(4,2)
print(x2)

输出：

tensor([[0.7335, 0.0657, 0.6401],
        [0.2703, 0.3244, 0.6803],
        [0.2112, 0.4806, 0.9889],
        [0.4633, 0.3383, 0.0990],
        [0.8081, 0.4392, 0.2116]], dtype=torch.float64)
tensor([[1., 1.],
        [1., 1.],
        [1., 1.],
        [1., 1.]], dtype=torch.float64)

二、加法操作

实验程序：

import torch

# 加法操作

x = torch.ones([5, 3], dtype=torch.float64)  # 构造全1的数组
print(x)
y = torch.rand(5, 3)  # 构造随机的矩阵
print(y)

# 形式1
print(x + y)
# 形式2
print(torch.add(x, y))
# 形式2的延伸，相当于提前准备好未初始化的矩阵用以存储数据
result = torch.empty(5, 3)
torch.add(x, y, out=result)
print(result)
# 形式3，把x加到y
y.add_(x)
print(y)  # 注：PyTorch操作inplace版本都有后缀_, 例如x.copy_(y), x.t_()

输出：

tensor([[1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.]], dtype=torch.float64)
tensor([[0.8245, 0.0606, 0.3033],
        [0.3946, 0.7993, 0.4337],
        [0.4153, 0.4044, 0.5313],
        [0.7801, 0.9384, 0.5885],
        [0.8220, 0.4210, 0.2487]])
tensor([[1.8245, 1.0606, 1.3033],
        [1.3946, 1.7993, 1.4337],
        [1.4153, 1.4044, 1.5313],
        [1.7801, 1.9384, 1.5885],
        [1.8220, 1.4210, 1.2487]], dtype=torch.float64)
tensor([[1.8245, 1.0606, 1.3033],
        [1.3946, 1.7993, 1.4337],
        [1.4153, 1.4044, 1.5313],
        [1.7801, 1.9384, 1.5885],
        [1.8220, 1.4210, 1.2487]], dtype=torch.float64)
tensor([[1.8245, 1.0606, 1.3033],
        [1.3946, 1.7993, 1.4337],
        [1.4153, 1.4044, 1.5313],
        [1.7801, 1.9384, 1.5885],
        [1.8220, 1.4210, 1.2487]])
tensor([[1.8245, 1.0606, 1.3033],
        [1.3946, 1.7993, 1.4337],
        [1.4153, 1.4044, 1.5313],
        [1.7801, 1.9384, 1.5885],
        [1.8220, 1.4210, 1.2487]])

三、索引操作

使用类似NumPy的索引操作来访问Tensor的一部分，需要注意的是：索引出来的结果与原数据共享内存，也即修改一个，另一个会跟着修改。（即索引操作不会开辟新内存）

实验程序：

import torch

# 索引操作

x = torch.rand(5, 3)  # 构造随机的矩阵
print(x)
y = x[0, :]
y += 1
print(y)
print(x[0, :])  #  源tensor也被改了

输出：

tensor([[0.1548, 0.8131, 0.6500],
        [0.1102, 0.9023, 0.2479],
        [0.7993, 0.7871, 0.9030],
        [0.4501, 0.8379, 0.1531],
        [0.3526, 0.2742, 0.0726]])
tensor([1.1548, 1.8131, 1.6500])
tensor([1.1548, 1.8131, 1.6500])

四、改变形状

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

实验程序：

import torch

# 改变形状操作

x = torch.rand(5, 3)  # 构造随机的矩阵
print(x)
y = x.view(15)
print(y)
z = x.view(-1, 5)  # -1所指的维度可以根据其他维度的值推出来，共5乘3，15个数据，15除以列数5，即为3
print(z)
print(x.size(), y.size(), z.size())

x += 1
print(x)
print(y)  # 也改变了，加了1

输出：

tensor([[0.7290, 0.2468, 0.8701],
        [0.1917, 0.6616, 0.3862],
        [0.7022, 0.5750, 0.9600],
        [0.5191, 0.5216, 0.9340],
        [0.8556, 0.7966, 0.5382]])
tensor([0.7290, 0.2468, 0.8701, 0.1917, 0.6616, 0.3862, 0.7022, 0.5750, 0.9600,
        0.5191, 0.5216, 0.9340, 0.8556, 0.7966, 0.5382])
tensor([[0.7290, 0.2468, 0.8701, 0.1917, 0.6616],
        [0.3862, 0.7022, 0.5750, 0.9600, 0.5191],
        [0.5216, 0.9340, 0.8556, 0.7966, 0.5382]])
torch.Size([5, 3]) torch.Size([15]) torch.Size([3, 5])
tensor([[1.7290, 1.2468, 1.8701],
        [1.1917, 1.6616, 1.3862],
        [1.7022, 1.5750, 1.9600],
        [1.5191, 1.5216, 1.9340],
        [1.8556, 1.7966, 1.5382]])
tensor([1.7290, 1.2468, 1.8701, 1.1917, 1.6616, 1.3862, 1.7022, 1.5750, 1.9600,
        1.5191, 1.5216, 1.9340, 1.8556, 1.7966, 1.5382])

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

实验程序：

import torch

# 改变形状操作

x = torch.rand(5, 3)  # 构造随机的矩阵
print(x)
x_cp = x.clone().view(15)# 即在x的副本上重新排布
x -= 1
print(x)
print(x_cp) # 发现仍为原来的x重新排布，没有减1

输出：

tensor([[0.8101, 0.1689, 0.3846],
        [0.5727, 0.4532, 0.7488],
        [0.9889, 0.2006, 0.5058],
        [0.7462, 0.0380, 0.6668],
        [0.5924, 0.6542, 0.8962]])
tensor([[-0.1899, -0.8311, -0.6154],
        [-0.4273, -0.5468, -0.2512],
        [-0.0111, -0.7994, -0.4942],
        [-0.2538, -0.9620, -0.3332],
        [-0.4076, -0.3458, -0.1038]])
tensor([0.8101, 0.1689, 0.3846, 0.5727, 0.4532, 0.7488, 0.9889, 0.2006, 0.5058,
        0.7462, 0.0380, 0.6668, 0.5924, 0.6542, 0.8962])

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

实验程序：

import torch

# 改变形状操作

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

输出：

tensor([0.0013])
0.0013380988966673613

五、线性代数

六、广播机制

广播机制含义：当对两个形状不同的Tensor按元素运算时，可能会触发广播（broadcasting）机制：先适当复制元素使这两个Tensor形状相同后再按元素运算。

实验程序：

import torch

# 广播机制

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列的矩阵按元素相加。

七、内存开销

索引不会开辟新内存。

而y=x+y的操作会开辟新内存，将y指向新内存。

为了演示这一点，我们可以使用Python自带的id函数：如果两个实例的ID一致，那么它们所对应的内存地址相同；反之则不同。

实验程序：

import torch

# 内存开销

x1 = torch.tensor([1, 2])
y1 = torch.tensor([3, 4])
id_before1 = id(y1)
y1 = y1 + x1  #开辟了y1新内存
print(id(y1) == id_before1)  # False

x2 = torch.tensor([1, 2])
y2 = torch.tensor([3, 4])
id_before2 = id(y2)
y2[:] = y2 + x2  # 把x + y的结果通过[:]写进y对应的内存中
# torch.add(x2, y2, out=y2)
# y2 += x2
# y2.add_(x2)
print(id(y2) == id_before2)   # True

输出：

False
True

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

八、Tensor和NumPy的相互转换

我们很容易用numpy()和from_numpy()将Tensor和NumPy中的数组相互转换。

但是需要注意的一点是： 这两个函数所产生的的Tensor和NumPy中的数组共享相同的内存（所以他们之间的转换很快），改变其中一个时另一个也会改变。
还有一个常用的方法就是直接用torch.tensor()将NumPy数组转换成Tensor，需要注意的是该方法总是会进行数据拷贝，返回的Tensor和原来的数据不再共享内存。

实验程序：

import torch
import numpy as np

# tensor转化为numpy

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

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


# numpy转化为tensor
x = np.ones(5)
y = torch.from_numpy(x)
print(x, y)

x += 1
print(x, y)
y += 1
print(x, y)
#由于这两种转换共享内存，对其中一个操作，都会层层的加

test = torch.tensor(x)
x += 1
print(x, test)
#tensor()的方法不共享内存，所以x和test值不一样

输出：

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.]
[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)
[4. 4. 4. 4. 4.] tensor([3., 3., 3., 3., 3.], dtype=torch.float64)

九、Tensor on GPU（换电脑之后再实验）

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

# 以下代码只有在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()还可以同时更改数据类型

十、自动求梯度

1.基本概念

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

如果将Tensor属性.requires_grad设置为True，它将开始追踪(track)在其上的所有操作（这样就可以利用链式法则进行梯度传播了）。完成计算后，可以调用.backward()来完成所有梯度计算。此Tensor的梯度将累积到.grad属性中。

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

每个Tensor都有一个.grad_fn属性，该属性即创建该Tensor的Function, 就是说该Tensor是不是通过某些运算得到的，若是，则grad_fn返回一个与这些运算相关的对象，否则是None。

实验程序：

import torch

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

y = x + 2
print(y)
print(y.grad_fn)#返回运算对象，即加法AddBackward

print(x.is_leaf, y.is_leaf) # True False,判断是否是叶子节点

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

输出：

tensor([[1., 1.],
        [1., 1.]], requires_grad=True)
None
tensor([[3., 3.],
        [3., 3.]], grad_fn=<AddBackward0>)
<AddBackward0 object at 0x0000022E2C271548>
True False
tensor([[27., 27.],
        [27., 27.]], grad_fn=<MulBackward0>) tensor(27., grad_fn=<MeanBackward0>)

注意x是直接创建的，所以它没有grad_fn。

而y是通过一个加法操作创建的，所以它有一个为的grad_fn。

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

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

实验程序:

import torch

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
<SumBackward0 object at 0x000002099AE2AEC8>

2.求梯度

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

实验程序：

import torch

x = torch.ones(2, 2, requires_grad=True)
y = x + 2
z = y * y * 3
out = z.mean()
out.backward() # 等价于 out.backward(torch.tensor(1.))即也可以传入一个同形的tensor
# 完成计算后，可以调用.backward()来完成所有梯度计算。此Tensor的梯度将累积到.grad属性中
print(x.grad)

输出：

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

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

实验程序：

import torch

x = torch.ones(2, 2, requires_grad=True)
y = x + 2
z = y * y * 3
out = z.mean()
out.backward() # 等价于 out.backward(torch.tensor(1.))即也可以传入一个同形的tensor
# 完成计算后，可以调用.backward()来完成所有梯度计算。此Tensor的梯度将累积到.grad属性中

# 再来反向传播一次，注意grad是累加的
out2 = x.sum()
out2.backward()# 对xi求一次导，即为1
print(x.grad)

out3 = x.sum()
x.grad.data.zero_()#将grad中的数清零，防止累加
out3.backward()
print(x.grad)

输出：

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

不允许张量对张量求导，只允许标量对张量求导，求导结果是和自变量同形的张量。

举个例子，假设y由自变量x计算而来，w是和y同形的张量，则y.backward(w)的含义是：先计算l = torch.sum(y * w)，则l是个标量，然后求l对自变量x的导数。

程序实例：

import torch

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

v = torch.tensor([[1.0, 0.1], [0.01, 0.001]], dtype=torch.float) # 现在 z 不是一个标量，所以在调用backward时需要传入一个和z同形的权重向量进行加权求和得到一个标量
z.backward(v)
print(x.grad) # x.grad是和x同形的张量

输出：

tensor([[2., 4.],
        [6., 8.]], grad_fn=<ViewBackward>)
tensor([2.0000, 0.2000, 0.0200, 0.0020])

结果解释：

3.终止追踪

如果不想要被继续追踪，可以调用.detach()将其从追踪记录中分离出来，这样就可以防止将来的计算被追踪，这样梯度就传不过去了。此外，还可以用with torch.no_grad()将不想被追踪的操作代码块包裹起来，这种方法在评估模型的时候很常用，因为在评估模型时，我们并不需要计算可训练参数（requires_grad=True）的梯度。

实验程序：

import torch

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

y3.backward()
print(x.grad)

输出：

True
tensor(1., grad_fn=<PowBackward0>) True
tensor(1.) False
tensor(2., grad_fn=<AddBackward0>) True
tensor(2.)

上面的y2是没有grad_fn而且y2.requires_grad=False的，而y3是有grad_fn的

而y3对x求导结果是2
是因为：
由于 y2 的定义是被torch.no_grad():包裹的，所以与 y2有关的梯度是不会回传的，只有与 y1有关的梯度才会回传，即 x^2对 x 的梯度。

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

实验程序：

import torch

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

print(x.data) # 还是一个tensor
print(x.data.requires_grad) # 但是已经是独立于计算图之外
print(x.data.is_leaf) # x.data还是叶子节点
y = 2 * x
x.data *= 100 # 只改变了值，不会记录在计算图，所以不会影响梯度传播

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

输出：

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