翻译: 2.1深度学习pytorch数据处理

Posted 2022-03-10 AI架构师易筋

为了完成任何事情，我们需要某种方式来存储和操作数据。一般来说，我们需要对数据做两件重要的事情：（i）获取它们；(ii) 一旦它们进入计算机就对其进行处理。如果没有某种方式来存储数据，获取数据是没有意义的，所以让我们先来玩弄合成数据。首先，我们介绍 𝑛 维数组，也称为张量。

如果您使用过 NumPy，这是 Python 中使用最广泛的科学计算包，那么您会发现本节很熟悉。无论您使用哪个框架，它的张量类（ndarray在 MXNet 中， Tensor在 PyTorch 和 TensorFlow 中）都与 NumPy 相似， ndarray但具有一些杀手级功能。首先，GPU 得到很好的支持以加速计算，而 NumPy 仅支持 CPU 计算。其次，张量类支持自动微分。这些属性使张量类适用于深度学习。在整本书中，当我们说张量时，我们指的是张量类的实例，除非另有说明。

2.1.1 入门

在本节中，我们的目标是让您开始并运行，为您配备基本的数学和数值计算工具，您将在阅读本书的过程中建立这些工具。如果您难以理解一些数学概念或库函数，请不要担心。以下部分将在实际示例的背景下重新审视这些材料，并且会深入了解。另一方面，如果您已经有一些背景并想更深入地了解数学内容，请跳过此部分。

首先，我们导入torch. 请注意，虽然它被称为 PyTorch，但我们应该导入torch而不是pytorch.

import torch

张量表示一个（可能是多维的）数值数组。对于一个轴，张量称为向量。有两个轴的张量称为矩阵。和 𝑘>2 轴，我们删除专门的名称，只是将对象称为 𝑘th 阶张量.

PyTorch 提供了多种函数来创建预先填充了值的新张量。例如，通过调用arange(n)，我们可以创建一个等距值的向量，从 0（包括）开始，到n（不包括）结束。默认情况下，间隔大小为 1 . 除非另有说明，否则新张量存储在主内存中并指定用于基于 CPU 的计算。

x = torch.arange(12, dtype=torch.float32)
x

tensor([ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10., 11.])

我们可以通过检查张量的属性来访问张量的形状（沿每个轴的长度） 。shape

x.shape

torch.Size([12])

如果我们只想知道张量中元素的总数，即所有形状元素的乘积，我们可以检查它的大小。因为我们在这里处理的是一个向量，所以它的单个元素 shape与其大小相同。

x.numel()

12

要改变张量的形状而不改变元素的数量或它们的值，我们可以调用该reshape函数。例如，我们可以将张量 ，x从形状为 (12,) 的行向量转换为形状为 (3, 4) 的矩阵。这个新张量包含完全相同的值，但将它们视为组织为 3 行和 4 列的矩阵。重申一下，虽然形状发生了变化，但元素没有。请注意，大小不会因重塑而改变。

X = x.reshape(3, 4)
X

tensor([[ 0.,  1.,  2.,  3.],
        [ 4.,  5.,  6.,  7.],
        [ 8.,  9., 10., 11.]])

通过手动指定每个维度来重塑是不必要的。如果我们的目标形状是一个形状为（高度，宽度）的矩阵，那么在我们知道宽度之后，隐式给出高度。为什么我们必须自己执行除法？在上面的例子中，为了得到一个有 3 行的矩阵，我们同时指定它应该有 3 行和 4 列。幸运的是，张量可以自动计算出剩下的一维。-1我们通过放置我们希望张量自动推断的维度来调用此功能。在我们的例子中，我们可以等效地调用 or ，而不是调用。x.reshape(3, 4) x.reshape(-1, 4) x.reshape(3, -1)

通常，我们希望我们的矩阵使用零、一、其他一些常数或从特定分布中随机采样的数字进行初始化。我们可以创建一个张量来表示一个所有元素都设置为 0 且形状为 (2, 3, 4) 的张量，如下所示：

torch.zeros((2, 3, 4))

tensor([[[0., 0., 0., 0.],
         [0., 0., 0., 0.],
         [0., 0., 0., 0.]],

        [[0., 0., 0., 0.],
         [0., 0., 0., 0.],
         [0., 0., 0., 0.]]])

同样，我们可以创建每个元素设置为 1 的张量，如下所示：

torch.ones((2, 3, 4))

tensor([[[1., 1., 1., 1.],
         [1., 1., 1., 1.],
         [1., 1., 1., 1.]],

        [[1., 1., 1., 1.],
         [1., 1., 1., 1.],
         [1., 1., 1., 1.]]])

通常，我们希望从某个概率分布中随机抽取张量中每个元素的值。例如，当我们构造数组作为神经网络中的参数时，我们通常会随机初始化它们的值。下面的代码片段创建了一个形状为 (3, 4) 的张量。它的每个元素都是从标准高斯（正态）分布中随机采样的，均值为 0，标准差为 1。

torch.tensor([[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])

tensor([[2, 1, 4, 3],
        [1, 2, 3, 4],
        [4, 3, 2, 1]])

2.1.2. 运算

这本书不是关于软件工程的。我们的兴趣不仅限于简单地从/向数组读取和写入数据。我们想对这些数组执行数学运算。一些最简单和最有用的操作是元素操作。这些将标准标量操作应用于数组的每个元素。对于将两个数组作为输入的函数，逐元素运算对两个数组中的每对对应元素应用一些标准二元运算符。我们可以从任何从标量映射到标量的函数创建一个元素函数。

在数学符号中，我们将通过签名 表示这样的一元标量运算符（接受一个输入） 𝑓:ℝ→ℝ . 这只是意味着该函数是从任何实数映射的（ ℝ ) 到另一个上。同样，我们用签名表示二元标量运算符（取两个实际输入，并产生一个输出） 𝑓:ℝ,ℝ→ℝ . 给定任意两个向量 𝐮 和 𝐯 形状相同，二元算子 𝑓 ，我们可以产生一个向量 𝐜=𝐹(𝐮,𝐯) 通过设置 𝑐𝑖←𝑓(𝑢𝑖,𝑣𝑖) 对所有人 𝑖 ， 在哪里 𝑐𝑖,𝑢𝑖 ， 和 𝑣𝑖 是 𝑖th 向量的元素 𝐜,𝐮 ， 和 𝐯 . 在这里，我们产生了向量值 𝐹:ℝ𝑑,ℝ𝑑→ℝ𝑑 通过 将标量函数提升为元素向量运算。

常见的标准算术运算符（+、-、*、/和**）都已升级为任意形状的任何形状相同的张量的元素运算。我们可以在任何两个相同形状的张量上调用元素操作。在下面的示例中，我们使用逗号来表示一个 5 元素元组，其中每个元素都是元素运算的结果。

2.1.2.1。运算

常见的标准算术运算符（+、-、*、/和**）已全部提升为元素运算。

x = torch.tensor([1.0, 2, 4, 8])
y = torch.tensor([2, 2, 2, 2])
x + y, x - y, x * y, x / y, x ** y  # The ** operator is exponentiation

(tensor([ 3.,  4.,  6., 10.]),
 tensor([-1.,  0.,  2.,  6.]),
 tensor([ 2.,  4.,  8., 16.]),
 tensor([0.5000, 1.0000, 2.0000, 4.0000]),
 tensor([ 1.,  4., 16., 64.]))

可以按元素应用更多操作，包括像幂运算这样的一元运算符。

torch.exp(x)

tensor([2.7183e+00, 7.3891e+00, 5.4598e+01, 2.9810e+03])

除了元素计算之外，我们还可以执行线性代数运算，包括向量点积和矩阵乘法。我们将在2.3 节中解释线性代数的关键部分（没有假设的先验知识）。

我们还可以将多个张量连接在一起，将它们端到端堆叠以形成更大的张量。我们只需要提供张量列表并告诉系统沿着哪个轴连接。下面的示例显示了当我们沿行（轴 0，形状的第一个元素）与列（轴 1，形状的第二个元素）连接两个矩阵时会发生什么。我们可以看到第一个输出张量的axis-0长度（ 6 ) 是两个输入张量的轴 0 长度之和 ( 3+3 ); 而第二个输出张量的轴 1 长度（ 8 ) 是两个输入张量的轴 1 长度之和 ( 4+4 ）。

X = torch.arange(12, dtype=torch.float32).reshape((3,4))
Y = torch.tensor([[2.0, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
torch.cat((X, Y), dim=0), torch.cat((X, Y), dim=1)

(tensor([[ 0.,  1.,  2.,  3.],
         [ 4.,  5.,  6.,  7.],
         [ 8.,  9., 10., 11.],
         [ 2.,  1.,  4.,  3.],
         [ 1.,  2.,  3.,  4.],
         [ 4.,  3.,  2.,  1.]]),
 tensor([[ 0.,  1.,  2.,  3.,  2.,  1.,  4.,  3.],
         [ 4.,  5.,  6.,  7.,  1.,  2.,  3.,  4.],
         [ 8.,  9., 10., 11.,  4.,  3.,  2.,  1.]]))

有时，我们想通过逻辑语句构造一个二进制张量。举个例子。对于每个位置，如果 和在该位置相等，则新张量中的相应条目取值为 1，这意味着逻辑语句 在该位置为真；否则该位置为 0。

X == Y

tensor([[False,  True, False,  True],
        [False, False, False, False],
        [False, False, False, False]])

将张量中的所有元素相加得到一个只有一个元素的张量。

X.sum()

tensor(66.)

2.1.3 广播机制

在上一节中，我们看到了如何对两个相同形状的张量执行元素操作。在某些情况下，即使形状不同，我们仍然可以通过调用广播机制来执行元素操作。这种机制的工作方式如下：首先，通过适当地复制元素来扩展一个或两个数组，以便在此转换之后，两个张量具有相同的形状。其次，对结果数组执行元素操作。

在大多数情况下，我们沿着一个数组最初只有长度 1 的轴进行广播，例如在以下示例中：

a = torch.arange(3).reshape((3, 1))
b = torch.arange(2).reshape((1, 2))
a, b

(tensor([[0],
         [1],
         [2]]),
 tensor([[0, 1]]))

因为a和b是 3×1 和 1×2 矩阵，如果我们想添加它们，它们的形状不匹配。我们 将两个矩阵的条目广播到一个更大的 3×2 矩阵如下：对于矩阵a，它复制列，对于矩阵b，它在将两个元素相加之前复制行。

a + b

tensor([[0, 1],
        [1, 2],
        [2, 3]])

2.1.4 索引和切片

就像在任何其他 Python 数组中一样，张量中的元素可以通过索引访问。与任何 Python 数组一样，第一个元素的索引为 0，范围被指定为包括第一个但在最后一个元素之前。与标准 Python 列表一样，我们可以使用负索引根据它们与列表末尾的相对位置来访问元素。

因此，[-1]选择最后一个元素并[1:3]选择第二个和第三个元素，如下所示：

X[-1], X[1:3]

(tensor([ 8.,  9., 10., 11.]),
 tensor([[ 4.,  5.,  6.,  7.],
         [ 8.,  9., 10., 11.]]))

除了读取之外，我们还可以通过指定索引来写入矩阵的元素。

X[1, 2] = 9
X

tensor([[ 0.,  1.,  2.,  3.],
        [ 4.,  5.,  9.,  7.],
        [ 8.,  9., 10., 11.]])

如果我们想为多个元素分配相同的值，我们只需索引所有元素，然后为它们分配值。例如， 访问第一行和第二行，其中获取沿轴 1（列）的所有元素。虽然我们讨论了矩阵的索引，但这显然也适用于向量和超过 2 维的张量。[0:2, :]:

X[0:2, :] = 12
X

tensor([[12., 12., 12., 12.],
        [12., 12., 12., 12.],
        [ 8.,  9., 10., 11.]])

2.1.5 节省内存

运行操作可能会导致将新内存分配给主机结果。例如，如果我们写，我们将取消引用曾经指向的张量，而是指向新分配的内存。在下面的示例中，我们使用 Python 的函数来演示这一点，它为我们提供了被引用对象在内存中的确切地址。运行后，我们会发现指向不同的位置。这是因为 Python 首先计算，为结果分配新内存，然后指向内存中的这个新位置。

before = id(Y)
Y = Y + X
id(Y) == before

False

出于两个原因，这可能是不可取的。首先，我们不想一直跑来跑去分配不必要的内存。在机器学习中，我们可能有数百兆字节的参数，并且每秒更新所有参数多次。通常，我们会希望就地执行这些更新。其次，我们可能会从多个变量中指向相同的参数。如果我们没有就地更新，其他引用仍将指向旧的内存位置，这使得我们的部分代码可能无意中引用过时的参数。
幸运的是，执行就地操作很容易。我们可以使用切片符号将操作的结果分配给先前分配的数组，例如. 为了说明这个概念，我们首先创建一个与另一个形状相同的新矩阵，用于分配一块Y[:] =

Z = torch.zeros_like(Y)
print('id(Z):', id(Z))
Z[:] = X + Y
print('id(Z):', id(Z))

id(Z): 139729336478400
id(Z): 139729336478400

如果 的值X在后续计算中没有被重用，我们也可以使用or来减少操作的内存开销。X[:] = X + Y

before = id(X)
X += Y
id(X) == before

True

转换为 NumPy 张量 ( ndarray)，反之亦然，很容易。torch 张量和 numpy 数组将共享它们的底层内存位置，通过就地操作更改一个也会更改另一个。

A = X.numpy()
B = torch.from_numpy(A)
type(A), type(B)

(numpy.ndarray, torch.Tensor)

要将 size-1 张量转换为 Python 标量，我们可以调用 item函数或 Python 的内置函数。

a = torch.tensor([3.5])
a, a.item(), float(a), int(a)

(tensor([3.5000]), 3.5, 3.5, 3)

2.1.7 总结

为深度学习存储和操作数据的主要接口是张量 ( 𝑛 维数组）。它提供了多种功能，包括基本数学运算、广播、索引、切片、内存节省以及转换为其他 Python 对象。

参考

https://d2l.ai/chapter_preliminaries/ndarray.html