回到正题，上文我们简述什么是张量，今天就来看看张量的几种运算方法和特点。
对于深度神经网络出现的所有变换，都可以简化为一些张量运算。
前面的文章中我们通过叠加 Dense 层来构建网络。
keras.layers.Dense(512, activation='relu') 复制代码
这个层可以理解为一个函数，输入一个 2D 张量，输出另一个 2D 张量。函数表示如下（其中 W：2D 张量，b：向量）。
output=relu(dot(W, input )+b)\text {output}=\operatorname{relu}(\operatorname{dot}(W, \text { input })+b)output=relu(dot(W, input )+b)
这里就有三个张量运算：
- 输入张量和张量 W 之间的点积(dot)
- 2D 张量与向量 b 之间的加法
- relu 运算。relu(x) 是 max(x, 0)
下面我们分别看看这些运算如何实现。
逐元素运算
上面的是三个运算都是逐元素运算，即该运算独立地应用于张量中的每个元素。我们先用 numpy 来实现relu运算和张量加法。
>>> import numpy as np >>> x = np.array([[1, -2, 3], [4, -5, 6]]) >>> y = np.array([[1, -2, 3], [4, -5, 6]]) >>> z = x + y >>> z array([[ 2, -4, 6], [ 8, -10, 12]]) >>> np.maximum(z, 0) array([[ 2, 0, 6], [ 8, 0, 12]]) 复制代码
我们可以自己简单实现一下上面的逐元素relu运算。
>>> def simple_relu(x): x = x.copy() for i in range(x.shape[0]): for j in range(x.shape[1]): x[i, j] = max(x[i, j], 0) return x >>> simple_relu(z) array([[ 2, 0, 6], [ 8, 0, 12]]) 复制代码
虽然效果看起来一样，速度确实天差地别，Numpy 内置函数都已经过优化，这些函数将大量运算交给 BLAS（基础线性代数子程序）实现。BLAS 是低层次的、高度并行的、高效的张量操作程序，通常用 Fortran 或C语言来实现。
张量点积 & 逐元素乘积
点积运算，也叫张量积，是最常见也最有用的张量运算。与逐元素的运算不同，它将输入张量的元素合并在一起。在 Numpy 中，使用 dot 来实现点积。
dot(向量，向量)
两个向量之间的点积是一个标量，而且只有元素个数相同的向量之间才能做点积。看个例子。
>>> import numpy as np >>> np.dot([1, 2, 3], [4, 5, 6]) 32 复制代码
OUT=1×4+2×5+3×6=32{\color{Blue} OUT} = 1 \times 4+2 \times 5+3 \times 6 = 32OUT=1×4+2×5+3×6=32
dot(矩阵，向量)
对一个向量 x 和一个矩阵 y 做点积，结果是一个向量，其中每个元素是 x 与 y 的每一列之间的点积。
>>> np.dot([1, 2], [[4, 5, 6], [7, 8, 9]]) array([18, 21, 24]) 复制代码
[1×4+2×7, 1×5+2×8, 1×6+2×9][1 \times 4+2 \times 7, \ 1 \times 5+2 \times 8,\ 1 \times 6+2 \times 9][1×4+2×7,1×5+2×8,1×6+2×9]
注意：如果两个张量中有一个的 ndim 大于 1，那么 dot 运算就不再是对称的，也就是说， dot(x, y) 不等于 dot(y, x)。
以上面的例子来说，如果要互换 x，y 的位置，那么向量的维度要与矩阵的第0维大小相同。
>>> np.dot([[4, 5, 6], [7, 8, 9]], [1, 2, 3]) array([32, 50]) 复制代码
dot(矩阵，矩阵)
两个矩阵之间的点积是最常用的，对于两个矩阵 x 和 y，只有 x.shape[1] == y.shape[0] 时，才能够使用点积，结果是一个 (x.shape[0], y.shape[1]) 的矩阵，其元素为 x 的行与 y 的列之间的点积
>>> np.dot([[1, 2, 3], [4, 5, 6]], [[1, 2], [3, 4], [5, 6]]) array([[22, 28], [49, 64]]) 复制代码
OUT=[1×1+2×3+3×51×2+2×4+3×64×1+5×3+6×54×2+5×4+6×6]{\color{Blue} OUT} = \begin{bmatrix} 1\times1+2\times3+3\times5 & 1\times2+2\times4+3\times6 \\ 4\times1+5\times3+6\times5 & 4\times2+5\times4+6\times6 \\ \end{bmatrix}OUT=[1×1+2×3+3×54×1+5×3+6×51×2+2×4+3×64×2+5×4+6×6]
图解如下
高维向量点积
对于更高维的张量点积，规则与 2D 张量类似。
- (a, b, c, d) . (d,) -> (a, b, c)
- (a, b, c, d) . (d, e) -> (a, b, c, e)
广播机制
如果将两个形状不同的张量相加，较小的张量会被广播（broadcast），以匹配较大张量的形状。看个例子。
>>> x = np.array([[1, 2, 3], [3, 4, 5]]) >>> y = np.array([[1], [3]]) >>> x + y array([[2, 3, 4], [6, 7, 8]]) 复制代码
最后的结果返回一个形状为(2,3)的矩阵。
张量变形(reshape)
张量变形是指改变张量的行和列，以得到想要的形状。但元素的个数不会改变。看个例子。
>>> x = np.array([[1, 2, 3], [4, 5, 6]]) >>> x array([[1, 2, 3], [4, 5, 6]]) >>> x.shape (2, 3) >>> y = x.reshape(3, 2) >>> y array([[1, 2], [3, 4], [5, 6]]) >>> y.shape (3, 2) >>> z = x.reshape(6, 1) >>> z array([[1], [2], [3], [4], [5], [6]]) >>> z.shape (6, 1) 复制代码
矩阵转置
转置也是张量变形的一种。对矩阵做转置是指将行和列互换， 使 x[i, :] 变为 x[:, i]。
>>> x = np.array([[1, 2, 3], [4, 5, 6]]) >>> x.shape (2, 3) >>> y = np.transpose(x) >>> y.shape (3, 2) 复制代码
本文简述了一下，几种张量运算的用法，还有很多其他用法没有涉及到，有需要的可以自行翻阅相关资料进行学习。
