part-0_4.pdf
https://zh-v2.d2l.ai/chapter_preliminaries/ndarray.html
https://courses.d2l.ai/zh-v2/assets/notebooks/chapter_preliminaries/ndarray.slides.html

点击查看【bilibili】

N维数组样例

N维数组是机器学习和神经网络的主要数据结构

image.png
image.png

创建数组

需要

  • 形状
  • 每个元素的数据类型
  • 每个元素的值

image.png

访问元素

image.png

数据操作

导入torch

张量表示由一个数值组成的数组，这个数组可能有多个维度

  1. >>> import torch
  2. >>> x = torch.arange(12)
  3. >>> x
  4. tensor([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])

放入一个array

可以通过张量的shape属性来访问张量（沿每个轴的长度）的形状 和张量中元素的总数

  1. >>> x.shape
  2. torch.Size([12])
  3. >>> x.numel()
  4. 12

要想改变一个张量的形状而不改变元素数量和元素值，可以调用reshape函数

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

使用全0、全1、其他常量，或者从特定分布中随机采样的数字

  1. >>> torch.zeros((2, 3, 4))
  2. tensor([[[0., 0., 0., 0.],
  3.          [0., 0., 0., 0.],
  4.          [0., 0., 0., 0.]],
  6.         [[0., 0., 0., 0.],
  7.          [0., 0., 0., 0.],
  8.          [0., 0., 0., 0.]]])
  9. >>> torch.ones((2, 3, 4));
  10. tensor([[[1., 1., 1., 1.],
  11.          [1., 1., 1., 1.],
  12.          [1., 1., 1., 1.]],
  14.         [[1., 1., 1., 1.],
  15.          [1., 1., 1., 1.],
  16.          [1., 1., 1., 1.]]])
  17. >>> torch.randn(3, 4);
  18. tensor([[ 0.0500, -0.3205,  1.1392, -0.1057],
  19.         [ 1.6262,  0.9511, -0.3953,  1.1746],
  20.         [-0.0074, -0.2217, -0.1776, -1.1396]])

通过提供包含数值的Python列表（或嵌套列表），来为所需张量中的每个元素赋予确定值

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

常见的标准算术运算符（+、-、、/和*）都可以被升级为按元素运算

  1. >>> x = torch.tensor([1.0, 2, 4, 8])
  2. >>> y = torch.tensor([2, 2, 2, 2])
  3. >>> x + y, x - y, x * y, x / y, x ** y
  4. (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.]))

“按元素”方式可以应用更多的计算

  1. >>> torch.exp(x)
  2. tensor([2.7183e+00, 7.3891e+00, 5.4598e+01, 2.9810e+03])

我们也可以把多个张量连结（concatenate）在一起

  1. >>> X = torch.arange(12, dtype=torch.float32).reshape((3,4))
  2. >>> Y = torch.tensor([[2.0, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
  3. >>> torch.cat((X, Y), dim=0), torch.cat((X, Y), dim=1)
  4. (tensor([[ 0.,  1.,  2.,  3.],
  5.         [ 4.,  5.,  6.,  7.],
  6.         [ 8.,  9., 10., 11.],
  7.         [ 2.,  1.,  4.,  3.],
  8.         [ 1.,  2.,  3.,  4.],
  9.         [ 4.,  3.,  2.,  1.]]), 
  10. tensor([[ 0.,  1.,  2.,  3.,  2.,  1.,  4.,  3.],
  11.         [ 4.,  5.,  6.,  7.,  1.,  2.,  3.,  4.],
  12.         [ 8.,  9., 10., 11.,  4.,  3.,  2.,  1.]]))

dim=0: 按第0行合并 dim=1: 按第1列合并

通过逻辑运算符构建二元张量

  1. >>> X == Y
  2. tensor([[False,  True, False,  True],
  3.         [False, False, False, False],
  4.         [False, False, False, False]])

对张量中的所有元素进行求和，会产生一个单元素张量

  1. >>> X.sum()
  2. tensor(66.)

即使形状不同，我们仍然可以通过调用 广播机制（broadcasting mechanism）来执行按元素操作

  1. >>> a = torch.arange(3).reshape((3, 1))
  2. >>> b = torch.arange(2).reshape((1, 2))
  3. >>> a, b
  4. (tensor([[0],
  5.         [1],
  6.         [2]]), 
  7.  tensor([[0, 1]]))
  8. >>> a + b
  9. tensor([[0, 1],
  10.         [1, 2],
  11.         [2, 3]])

张量和数组虽然数学概念不同, 但有时会混用. 对张量进行”扩展”为矩阵

可以用[-1]选择最后一个元素，可以用[1:3]选择第二个和第三个元素

  1. >>> X[-1], X[1:3]
  2. (tensor([ 8.,  9., 10., 11.]), 
  3.  tensor([[ 4.,  5.,  6.,  7.],
  4.          [ 8.,  9., 10., 11.]]))

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

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

为多个元素赋值相同的值，我们只需要索引所有元素，然后为它们赋值

  1. >>> X[0:2, :] = 12
  2. >>> X
  3. tensor([[12., 12., 12., 12.],
  4.         [12., 12., 12., 12.],
  5.         [ 8.,  9., 10., 11.]])

运行一些操作可能会导致为新结果分配内存

  1. >>> before = id(Y)
  2. >>> Y = Y + X
  3. >>> id(Y) == before
  4. False

执行原地操作

  1. >>> Z = torch.zeros_like(Y)
  2. >>> print('id(Z):', id(Z))
  3. id(Z): 140482931687568
  4. >>> Z[:] = X + Y
  5. >>> print('id(Z):', id(Z))
  6. id(Z): 140482931687568

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

  1. >>> before = id(X)
  2. >>> print('id(X):', id(X))
  3. id(X): 140482931691248
  4. >>> X += Y
  5. >>> print('id(X):', id(X))
  6. id(X): 140482931691248
  7. >>> X = X + Y
  8. >>> print('id(X):', id(X))
  9. id(X): 140482931716160

转换为NumPy张量（ndarray）

  1. >>> A = X.numpy()
  2. >>> B = torch.tensor(A)
  3. >>> type(A), type(B)
  4. (<class 'numpy.ndarray'>, <class 'torch.Tensor'>)

将大小为1的张量转换为Python标量

  1. >>> a = torch.tensor([3.5])
  2. >>> a, a.item(), float(a), int(a)
  3. (tensor([3.5000]), 3.5, 3.5, 3)