张量

张量（tensor）也就是𝑛 维数组，是深度学习中基本的数据结构，张量类可以很好地使用GPU加速计算，其次，张量类支持自动微分，它类似于numpy中的ndarray，但功能更多更强大。

---

入门

创建一个行向量 x

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

通过张量的shape属性来访问张量（沿每个轴的长度）的形状

x.shape
# torch.Size([12])

获取张量中元素的总数

x.numel()
# 12

将一维张量x中的12个元素变成3行4列的矩阵

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

已知行数，自动确定列数

x.reshape(3,-1)

创建一个形状为（2,3,4）的所有元素都为0/1的张量

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.]]])
torch.ones((2, 3, 4))

创建一个形状为（3,4）的张量，里面的元素符合标准高斯分布

torch.randn(3, 4)
# tensor([[ 0.4315, -0.8804, -0.1730, -1.2925],
#         [ 0.3317, -1.1386, -0.6625,  0.3001],
#         [ 0.0371, -0.4246,  0.0326,  0.1565]])

使用Python列表创建张量

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

---

运算符

对于形状相同的张量，常见的标准算术运算符（+、-、、/和*）都可以被升级为按元素运算

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

连结（concatenate）张量：torch.cat
dim参数为按照shape的第几个轴进行连结。第一个输出张量的轴-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.]]))

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

X == Y
# tensor([[False,  True, False,  True],
#         [False, False, False, False],
#         [False, False, False, False]])

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

X.sum()
# tensor(66.)

---

广播机制

由于a和b分别是 3×1 和 1×2 矩阵，如果让它们相加，它们的形状不匹配。 我们将两个矩阵广播为一个更大的 3×2 矩阵，如下所示：矩阵a将复制列， 矩阵b将复制行，然后再按元素相加。

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
# tensor([[0, 1],
#         [1, 2],
#         [2, 3]])

---

索引和切片

第一个元素的索引是0，最后一个元素索引是-1； 1:3表示第一个元素到第三个元素之前的元素，:代表所有元素

X[-1]
X[1:3]
X[:] = 9