《动手学深度学习（Dive into Deeplearning）》（第二版）——第二章 _2.1 数据操作

第二章 预备知识

§ 2.0 开始

  从本篇开始，我们就进入一开始的预备知识的学习，如果有相关基础的朋友可以选择跳过这章直接进行后续的学习，为了方便大家能够更好地同时学习书本以及沐神直播视频的内容，我也在此放入这部分整理好的视频以及沐神的B站主页传送门：

04 数据操作 + 数据预处理【动手学深度学习v2】
沐神的B站主页

  希望大家在能够结合视频和书本进行相应的学习，那么我们就开始这一章的旅程啦~~

---

§ 2.1 数据操作

  为了能够完成各种操作，我们需要某种方法来存储和操作数据。我们需要做两件重要的事情：

1. 获取数据；
2. 在将数据读入计算机后对其进行处理。

  如果没有某种方法来存储数据，那么获取数据是没有意义的。因此我们首先需要了解的一个就是 n 维数组，也称为张量（tensor）。

  使用过Python中使用最广泛的科学计算包NumPy的读者会对本部分很熟悉。无论使用哪个深度学习框架，它的张量类（在MXNet中为ndarray，在 PyTorch 和TensorFlow中为Tensor）都与Numpy的ndarray类似，但又比Numpy的ndarray多一些重要功能：

• 首先，GPU 很好地支持加速计算，而NumPy仅支持CPU计算；
• 其次，张量类支持自动微分。这些功能使得张量类更适合深度学习。

  那么我们在深度学习中最常见的就是张量，如果没有特殊说明，今后所说的张量均指的是张量类的实例。

---

2.1.1 入门

  从本节开始，我们就一步一步慢慢熟悉一下在PyTorch中关于张量的一些操作。
  首先我们导入torch。值得注意的是，虽然他的名字是PyTorch，但是我们导入的包是torch。

import torch

  张量表示由一个数值组成的数组，这个数组可以有多个维度，我们不妨将这些维度想象成轴，那么具有一个轴的张量相当于是一维，在数学上对应的名字为向量（Vector）；而具有两个轴的张量也就是二维，在数学上对应的是矩阵（matrix）；轴数越多对应维度越高。张量中的每个值都称为张量的元素（element）。除非额外指定，否则新的张量将存储在内存中，并采用基于CPU的计算。

  我们开始进行一些基本操作的熟悉。

• 通过arange创建一个行向量，包含从0到11总共12个整数。

x = torch.arange(12)
x

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

• 通过张量的shape属性访问张量的形状，当然也可以使用size函数，此处处理的是一个向量，所以shape和size相同：

x.shape

x.size()

torch.Size([12])

torch.Size([12])

• numel函数可以方便的知道张量的元素个数：

x.numel()

12

• reshape函数可以改变一个张量的形状而不改变元素数量和元素值：

X = x.reshape(3, 4)
X

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

不需要通过手动指定每个维度来改变形状，张量在给出其他部分后可以自动计算出一个维度。我们可以通过在希望张量自动推断的维度放置-1来调用此功能。在上面的例子中，我们可以用x.reshape(-1,4)或x.reshape(3,-1)来取代x.reshape(3,4)。

• 有时，我们希望使用全0、全1、其他常量或者从特定分布中随机采样的数字来初始化矩阵。zeros函数和ones函数可以帮助我们构建一个全0和全1的张量：

torch.zeros((2, 3, 4))		# 构建一个全0矩阵

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

torch.ones((2, 3, 4))		# 构建一个全1矩阵

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

• randn函数可以帮助我们构建每个元素都从均值为0、标准差为1的标准高斯（正态）分布中随机采样的矩阵：

torch.randn(3, 4)		# 构建一个元素为高斯分布的矩阵

tensor([[-0.1957, -0.0284,  1.0563,  0.2526],
        [-0.4205,  0.2026,  0.2376, -0.3273],
        [-0.6187,  0.3032, -0.0050, -0.6948]])

• 当然我们也能使用最原始的方法，直接赋值生成张量，在这里，最外层的列表对应于轴 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 运算

  一些最简单且最有用的操作是 按元素（elementwise） 操作。它们将标准标量运算符应用于数组的每个元素。

• 对于任意具有相同形状的张量，常见的标准算术运算符（+、-、*、/ 和 **）都可以被升级为按元素运算。我们可以在同一形状的任意两个张量上调用按元素操作：

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		# **运算符是求幂运算

(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])

• 当然，除了按元素计算外，我们还可以执行线性代数运算，包括向量点积和矩阵乘法，将在后面的小节提到。
• 我们还能将多个张量 连结 在一起，我们只需要提供张量列表，并指出沿哪个轴连结。下面的例子是分别按照轴0和轴1进行连结的结果：

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

• 我们还可以通过逻辑运算符构建二元张量：

X == Y

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

• sum函数可以对张量中的所有元素进行求和产生一个只有一个元素的张量：

X.sum()

tensor(66.)

---

2.1.3 广播机制

  在这里面有一个很有意思的机制非常值得注意，如果你对这个不了解，可能是后续再进行数据处理的时候会容易出错，也许一开始处理的数据不是按照你所预想的方式进行操作，从而导致最后的得到的结果差强人意。
  这个机制就是广播机制（broadcasting mechanism）。这种机制的工作方式如下：

• 首先，通过适当复制元素来扩展一个或两个数组，以便在转换之后，两个张量具有相同的形状；
• 其次，对生成的数组执行按元素操作。
    大多数情况下我们将沿着张量中长度为1的轴进行广播。我们构建两个不同形状的张量 a 和 b 分别是 $3\times 1$ 和 $1\times 2$矩阵，如果直接相加形状就不匹配。但是在这里将他们直接相加的话，它会自动帮我们将矩阵 a 复制列，矩阵 b 复制行，然后再按照元素相加：

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

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

---

2.1.4 索引和切片

  对于这部分的知识我就不在此处赘述了，索引和切片相信大家都非常熟悉的，除了在这里其他时候也经常使用，numpy也好，其他语言也有这样的。因此如果还有不熟悉的朋友可以点击传送门索引和切片进行学习~~

---

2.1.5 内存

  在python中，内存需要值得引起注意。运行一些操作可能会导致为新结果分配内存。例如，如果我们用 Y = X + Y，我们将取消引用 Y 指向的张量，而是指向新分配的内存处的张量。

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

False

Python 首先计算 Y + X，为结果分配新的内存，然后使 Y 指向内存中的这个新位置。

  重新分配内存有时候是不被建议的。

• 首先，我们不想总是不必要地分配内存。在机器学习中，我们可能有数百兆的参数，并且在一秒内多次更新所有参数。通常情况下，我们希望原地执行这些更新；
• 其次，我们可能通过多个变量指向相同参数。如果我们不原地更新，其他引用仍然会指向旧的内存位置，这样我们的某些代码可能会无意中引用旧的参数。

  当然我们执行原地操作也很简单：

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

id(Z): 140240382523520
id(Z): 140240382523520

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

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

True

---

2.1.6 Python对象的转换

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

(numpy.ndarray, torch.Tensor)

  要将大小为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 总结

  深度学习存储和操作数据的主要接口是张量（ $n$ 维数组）。它提供了各种功能，包括基本数学运算、广播、索引、切片、内存节省和转换其他 Python 对象。
  打好这些基础才能在接下来的学习中更加游刃有余。

---

课后练习

问题1：运行本节中的代码。将本节中的条件语句 X == Y 更改为 X < Y 或 X > Y，然后看看你可以得到什么样的张量。

import torch
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]] )
x > y, x < y

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

问题2：用其他形状（例如三维张量）替换广播机制中按元素操作的两个张量。结果是否与预期相同？

import torch
a = torch.arange(6).reshape((2, 3, 1))
b = torch.arange(4).reshape((1, 1, 4))
a, b, a + b

(tensor([[[0],
          [1],
          [2]],
 
         [[3],
          [4],
          [5]]]),
 tensor([[[0, 1, 2, 3]]]),
 tensor([[[0, 1, 2, 3],
          [1, 2, 3, 4],
          [2, 3, 4, 5]],
 
         [[3, 4, 5, 6],
          [4, 5, 6, 7],
          [5, 6, 7, 8]]]))

---

这一节就到这了，我们下一节再见~~