2 Pytorch预备知识

2 Pytorch预备知识

根据《动手学深度学习PYTORCH版》第2章所做的笔记

2.1 环境配置

略

2.2 数据操作

在Pytorch中，torch.Tensor是存储和变换数据的主要工具，相比于numpy.array，Tensor提供GPU计算和自动求梯度等更多功能。

2.2.1 创建Tensor

• torch.empty(5, 3) # 未初始化
• torch.rand(5, 3) # 随机初始化
• torch.zeros(5, 3, dtype=torch.long) # 全0的long型Tensor
• torch.tensor([5.5, 3]) # 直接根据数据创建
• x = x.new_ones(5, 3, dtype=torch.float64) # 返回的tensor默认具有相同的 torch.dtype和torch.device
• x = torch.randn_like(x, dtype=torch.float) # 指定新的数据类型
• x.shape 或 x.size() # 获取Tensor的形状

其他创建方法可以查询官方API，这些创建方法都可以在创建的时候指定dtype和device。

2.2.2 操作

1. 算术操作

   • x + y
   • torch.add(x, y) 或 torch.add(x, y, out=result)
   • y.add_(x) # adds x to y (inplace)

2. 索引

   • 索引出来的结果和原数据共享内存，修改一个，另一个会跟着修改
   • 高级的选择函数

   函数	功能
   index_select(input, dim, index)	在指定维度dim上选取
   masked_select(input, mask)	使用ByteTensor进行选取
   non_zero(input)	非零元素的下标
   gather(input, dim, index)	根据index，在维度dim上选取数据，输出的size与index一样

3. 改变形状

   # view返回的新tensor与源tensor共享内存（其实是同一个tensor），修改一个，另一个会跟着改变。（view仅仅是改变了对这个张量的观察角度）
   z = x.view(-1, 5)  
   
   # 返回一个真正新的副本
   # reshape()并不能保证返回的是其拷贝
   # 推荐先用clone创造一个副本然后使用view
   y = x.clone().view(15)
   # 使用clone的另一个好处是会被记录在计算图中，即梯度回传到副本时也会传到源Tensor
   
   # item()可将一个标量Tensor转换成一个Python number
   

4. 线性代数

   函数	功能
   trace	矩阵的迹（对角线元素之和）
   diag	对角线元素
   triu/tril	矩阵的上三角/下三角，可指定偏移量
   mm/bmm	矩阵乘法，batch的矩阵乘法
   addmm/addbmm/addmv/addr/badbmm..	矩阵运算
   t	转置
   dot/cross	内积/外积
   inverse	求逆矩阵
   svd	奇异值分解

   转置、索引、切片、数学运算、线性代数、随机数等操作，可参考官方文档。

2.2.3 广播机制

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

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

2.2.4 运算的内存开销

索引、view不会开辟新内存，而像 y = x+y 这样的运算会新开内存，然后将y指向新内存。

# 如果两个实例的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的内存，可以使用索引来进行替换操作
y[:] = y + x 
print(id(y) == id_before)  # True

# 还可以使用运算符全名函数中的out参数或者自加运算符 += (也即 add_() )达到上述效果
torch.add(x, y, out=y)  # y += x, y.add_(x)
print(id(y) == id_before)  # True

2.2.5 Tensor和Numpy相互转换

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

torch.tensor()也可以将array转换成Tensor，此方法总是会进行数据拷贝（消耗更多的时间和空间），所以返回的Tensor和原数据不再共享内存。

1. Tensor转Numpy

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

2. 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)
   

   所有在CPU上的Tensor（除了CharTensor）都支持与Numpy数组相互转换。

   x = np.ones(2)
   y = torch.tensor(x)
   x += 1
   print(x, y)
   

2.2.6 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()还可同时更改数据类型

2.3 自动求梯度

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

2.3.1 概念

Tensor

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

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

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

Function

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

下面通过一些例子来理解这些概念。

2.3.2 Tensor

x = torch.ones(2, 2, requires_grad=True) 
print(x) 
print(x.grad_fn)
# 直接创建的称为叶子节点，对应的grad_fn是None

y = x + 2 
print(y) 
print(y.grad_fn)
# y通过一个加法操作创建，它有一个为<AddBackward>的grad_fn

z = y * y * 3 
out = z.mean() 
print(z, out, sep='\n')

# 通过.requires_grad_()用in-place的方式改变requires_grad属性
a.requires_grad_(True)

2.3.3 梯度

# 标量调用backward()时不需要指定求导变量
out.backward()  # 等价于out.backward(torch.tensor(1.))
print(x.grad)  # out关于x的梯度d(out)/dx

如果函数 y=f(x)的自变量和因变量都为向量，那么y关于x的梯度就是一个雅可比矩阵（Jacobian matrix）：

而 torch.autograd 这个包就是用来计算一些雅可比矩阵的乘积的。

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

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

• 简单来说就是为了避免向量（甚至更高维张量）对张量求导，而转换成标量对张量求导；
• Pytorch不允许张量对张量求导，只允许标量对张量求导，求导结果是和自变量同形的张量；
• 所以必要时我们要把张量通过将其所有元素加权求和的方式转换为标量，举个例子，假设 y 由自变量 x 计算而来， w 是和 y 同形的张量，则 y.backward(w) 的含义是：先计算 L = torch.sum(y * w) ，则 L 是个标量，然后求 L 对自变量 x 的导数。

注意， x.grad 是和 x 同形的张量。

中断梯度追踪：

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

此外，如果想要修改 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)