神经网络的工程基础（零）—

神经网络的工程基础（零）——PyTorch基础

news2024/11/18 2:21:16

一、PyTorch的数据基础：张量（Tensor）

工欲善其事，必先利其器。在讨论如何实现梯度下降法之前，首先探讨一下PyTorch这个强大的工具。PyTorch是一种备受欢迎的开源机器学习框架，被广泛用于构建、训练和部署神经网络模型，因具有灵活性、动态计算图和卓越的GPU支持而成为神经网络领域的首选。

PyTorch的基础数据结构是张量。张量的创建方式如程序清单1所示（完整代码）。

程序清单1 张量的创建

 1 |  # 使用tensor封装的函数创建tensor
 2 |  zeros = torch.zeros(2, 3)
 3 |  tensor([[0., 0., 0.],
 4 |          [0., 0., 0.]])
 5 |  
 6 |  ones = torch.ones(2, 3)
 7 |  tensor([[1., 1., 1.],
 8 |          [1., 1., 1.]])
 9 |  
10 |  torch.manual_seed(1024)
11 |  random = torch.rand(3, 4)
12 |  tensor([[0.8090, 0.7935, 0.2099, 0.9279],
13 |          [0.8136, 0.7422, 0.4769, 0.4955],
14 |          [0.3602, 0.1178, 0.7852, 0.0228]])
15 |  
16 |  # 从Python对象创建
17 |  data = [[2, 3, 4], [1, 0, 1]]
18 |  t_data = torch.tensor(data)
19 |  tensor([[2, 3, 4],
20 |          [1, 0, 1]])
21 |  
22 |  ## 从numpy对象创建
23 |  import numpy as np
24 |  
25 |  n_data = np.array(data)
26 |  tn_data = torch.from_numpy(n_data)
27 |  tensor([[2, 3, 4],
28 |          [1, 0, 1]])
29 |  
30 |  ## Numpy bridge，也就是说对numpy对象的改变会传导到tensor
31 |  n_data += 1
32 |  torch.all(torch.from_numpy(n_data) == tn_data)
33 |  tensor(True)

张量的形状（Shape）是至关重要的概念，它定义了张量的维度以及每个维度的大小。在实际应用中，可以通过使用一系列函数来改变张量的形状，使其适应不同的运算需求，如程序清单2所示。

程序清单2 改变张量的形状

 1 |  # 增加或减少数据的维度
 2 |  a = torch.rand(3, 4)  # (3, 4)
 3 |  ## 增加维度
 4 |  b = a.unsqueeze(0)    # (1, 3, 4)
 5 |  ## 减少维度
 6 |  c = b.squeeze(0)      # (3, 4)
 7 |  ## 数据相同，但是维度不同
 8 |  print(torch.all(c.eq(b)))    # tensor(True)
 9 |  print(c.shape == b.shape)    # False
10 |  
11 |  # 变换tensor形状
12 |  data = torch.tensor(range(0, 10))   # tensor([1, 2, 3, 4, 5, 6, 7, 8, 9])
13 |  view1 = data.view(2, 5)
14 |  tensor([[0, 1, 2, 3, 4],
15 |          [5, 6, 7, 8, 9]])
16 |  transpose1 = view1.T
17 |  tensor([[0, 5],
18 |          [1, 6],
19 |          [2, 7],
20 |          [3, 8],
21 |          [4, 9]])
22 |  ## 非毗邻存储的对象不能进行view操作
23 |  print(view1.is_contiguous(), transpose1.is_contiguous()) 
24 |  True False
25 |  ## 下面的操作会报错
26 |  view2 = transpose1.view(1, 10)

程序清单2的第4—6行使用unsqueeze和squeeze函数来增加或减少张量的维度。需要注意的是，这些操作并不会改变张量实际存储的数据，也不会在实质上改变张量的形状。相反，它们只是在张量的形状中添加或删除一个空的维度。具体的变化可以在第8行和第9行中看到。
为了改变张量的形状，可以使用view函数，如第12—15行所示。但需要注意的是，view函数只能用在毗邻存储的张量¹对象上。非毗邻存储的张量只能使用reshape函数来改变形状。尽管这两个函数在功能上相似，但在计算效率上存在显著差异：相较于 view 函数，reshape 的计算开销要大得多。因此，在实际应用中，最好优先选择使用 view 函数。

二、张量的基本计算

张量的运算分为两种：逐元素操作（Element-Wise Operations）和矩阵乘法，这些计算方法在处理数据和构建神经网络模型时都具有重要作用。程序清单6-3中讨论了这些操作，并介绍了PyTorch中的广播机制（Broadcasting Semantics），它在处理不同形状的张量时起到了重要的作用。

程序清单3 张量的常见运算

 1 |  # 逐元素操作
 2 |  twos = torch.ones(2, 2) * 2
 3 |  tensor([[2., 2.],
 4 |          [2., 2.]])
 5 |  powers = twos ** torch.tensor([[1, 2], [3, 4]])
 6 |  tensor([[ 2.,  4.],
 7 |          [ 8., 16.]])
 8 |  
 9 |  ## tensor广播，tensor broadcasting
10 |  a = torch.tensor(range(1, 7)).view(2, 3)
11 |  tensor([[1, 2, 3],
12 |          [4, 5, 6]])
13 |  b = torch.tensor(range(1, 4)).view(   3)
14 |  tensor([1, 2, 3])
15 |  print(a * b)
16 |  tensor([[ 1,  4,  9],
17 |          [ 4, 10, 18]])    
18 |  ## 关于广播，更复杂的例子
19 |  a =     torch.ones(4, 1, 3, 2)
20 |  b = a * torch.rand(   5, 1, 2)
21 |  print(b.shape)
22 |  torch.Size([4, 5, 3, 2])
23 |  
24 |  # 矩阵运算
25 |  mat1 = torch.randn(3, 4)    # (3, 4)
26 |  mat2 = torch.randn(4, 5)    # (4, 5)
27 |  re = mat1 @ mat2            # (3, 5)
28 |  ## 矩阵运算的广播
29 |  mat1 = torch.randn(5, 1, 3, 4)   # (5, 1, 3, 4)
30 |  mat2 = torch.randn(   8, 4, 5)   # (   8, 4, 5)
31 |  re = mat1 @ mat2                 # (5, 8, 3, 5)

逐元素操作要求进行运算的两个张量的形状必须相同，如程序清单3中的第2—7行所示。然而，在实际应用中，常常需要对形状不同的张量进行操作。为此，PyTorch引入了广播机制，它允许在一定条件下对形状不同的张量进行逐元素操作，如第9—22行所示。
广播机制的流程相对复杂，如图1所示，需要注意几个关键步骤。首先，从后向前逐个比较两个张量的维度；接着，对缺失的维度进行扩充（类似于unsqueeze函数的操作）；然后，检查广播规则，即两个张量的各分量要么相等，要么其中一个等于1；最后，复制数据，实现广播操作。
广播机制不仅适用于逐元素操作，它同样影响着张量的矩阵乘法。不同之处在于，当执行矩阵乘法时，广播机制只会作用于前面的维度，而不涉及最后两维，如第29—31行所示。