【深度学习】计算的向量化（Vectorization），实现简化代码，加速计算（CPU/GPU并行计算）

当我们 应用深度学习算法，实现 大网络（网络的参数量 $n$ 很大），多样本（样本数量 $m$ 很大） 情形下的 大规模 计算处理时，通过 向量化 的方式，将 高度重复的计算组织成 并行的向量运算，对于 简化代码，加速运算 有着非常重要的作用。

P.S.： 本文用到的数学符号（Notation）可以参考【深度学习符号表示】

向量化简介

拿逻辑回归中 $z=w^{T}x+b$ 的计算举例，$w$、$x$都是列向量，维度为 $n_x$。如果你有很多的特征，那么就会有一个非常大的向量。

非向量化（for循环逐个计算）做法

如果按照正常的非向量化的编程逻辑，实现思路如下（Python）。

z = 0
for i in range(n_x):
    z += w[i] * x[i]
z += b

向量化做法

作为对比，$w^{T}x$ 的向量化计算能够非常直接地实现。

z = np.dot(w, x) + b

除了能够代码简化，向量化还能够通过并行化计算提高计算效率，我们看下面的例子。

import time  # 导入时间库
import numpy as np  # 导入numpy库


a = np.array([1, 2, 3, 4])  # 创建一个数据a
print(a)
# [1 2 3 4]

a = np.random.rand(1000000)
b = np.random.rand(1000000)  # 通过round随机得到两个一百万维度的数组
tic = time.time()  # 现在测量一下当前时间

# 向量化的版本
c = np.dot(a, b)
toc = time.time()
print(c)
print("Vectorized version:" + str(1000 * (toc - tic)) + "ms")  # 打印一下向量化的版本的时间

# 继续增加非向量化的版本
c = 0
tic = time.time()
for i in range(1000000):
    c += a[i] * b[i]
toc = time.time()
print(c)
print("For loop:" + str(1000 * (toc - tic)) + "ms")  # 打印for循环的版本的时间

运行结果如下图：

上面我们使用了向量化和非向量化两种方式进行了相同的计算，向量化版本花费了 0.996 毫秒，而非向量化版本的 for 循环花费了 925 毫秒，非向量化版本花费的时间是向量化的 900 多倍。这意味着如果向量化方法需要花费一分钟去运行的数据，使用 for 循环将会花费 15 个小时去运行。

由此可见，向量化计算有多快。

向量化计算为什么快？

你可能听过很多类似这样的话，“大规模的深度学习使用了 GPU 或者图像处理单元实现”。实际上面的示例只用了 CPU 去实现。

事实上，CPU 和 GPU 都有并行化的指令，他们有时候会叫做 SIMD 指令，这个代表了一个单独指令处理多维数据（GPU 更加擅长 SIMD 计算，CPU 虽不及 GPU，不过事实上也不是太差）。

通过调用 numpy库 或者 TensorFlow / PyTorch 等深度学习框架 中的 向量运算（线性运算）函数，我们能够让 python 充分利用 CPU 或者 GPU 的并行化计算能力。

numpy库有很多向量函数，比如

np.log()  # 按元素计算对数函数
np.abs()  # 按元素取绝对值
np.maximum()  # 计算元素中的最大值
np.maximum(v, 0)  # 计算每个元素和0相比的最大值
v ** 2  # 计算每个元素的平方
1 / v  # 计算每个元素的倒数

向量化实例

① 对向量中每个元素进行数学运算

比如做指数操作。

非向量化方法：初始化向量 $u=np.zeros(n,1)$，然后通过循环依次计算每个元素 $v^i$

u = np.zeros((n, 1))
for i in range(n):
	u[i] = math.exp(v[i])

向量化方法：通过 python 的 numpy 内置函数 np.exp()

import numpy as np
u = np.exp(v)

② 逻辑回归的前向传播

假设我们需要对 m 个训练样本进行前向传播运算。

非向量化的做法：挨个样本进行计算，首先要对第一个样本进行预测，$z^{(1)}=w^T{x}^{(1)}+b$，计算激活函数 $a^{(1)}=\sigma (z^{(1)})$，再计算第一个样本的预测值 $y$。然后对第二个样本进行预测，第三个样本，依次类推。 $m$ 个训练样本，就需要这样重复做 $m$ 次。

向量化的做法：我们可以将训练输入定义成一个 $n_x$ 行 $m$ 列的矩阵 $X$ 的形式，即一个$(n_x,m)$形状的numpy数组。同样，我们构建一个 $1\times m$ 的行向量 $Z$ 用来存储 $[z^{(1)},z^{(m)},...,z^{(m)}]$，然后 $Z$ 就可以通过下面的方式求得。

以上操作就可以通过 Z = np.dot(w.T, X) + b 一句 numpy 命令来实现。

同样的，从 $Z$ 到 $A=[a^{(1)},a^{(m)},...,a^{(m)}]$ 我们也可以使用向量方式 A = 1.0 / (1.0 + np.exp(-Z)) 来实现统一的 sigmoid函数 运算。

③ 逻辑回归的梯度下降

那么，要如何同时计算 $m$ 个数据的梯度？

根据 $w$ 和 $b$ 的梯度计算公式：

$dw=\frac{1}{m}{\sum }_{i=1}^m{x}^{(i)}d{z}^{(i)}$

$db=\frac{1}{m}{\sum }_{i=1}^{m}d{z}^{(i)}$

其中，$d{z}^{(1)}=a^{(1)}-y^{(1)}$ , $d{z}^{(2)}=a^{(2)}-y^{(2)}$…

那么，我们可以将所有的 $dz$ 按列堆叠(横向排列)，定义一个 $1\times m$ 形状的新的变量

$dZ=[d{z}^{(1)},d{z}^{(2)}...d{z}^{(m)}]$。

再定义 $Y=[y^{(1)},y^{(2)}...y^{(m)}]$，则 $dZ=A-Y$ 。

那么很容易就能得到 $db$ 的向量化代码，db = (1 / m) ∗ np.sum(A - Y)

对于$dw$，为了更直观，我们先将其展开，得到

则 $dw$ 的向量化形式，$dw=\frac{1}{m}\ast X\ast Z^T$，对应代码 dw = (1 / m) ∗ X * dZ.T

最终我们得到高度向量化的，高效的逻辑回归的实现

前五个公式完成前向和后向传播，后两个公式进行梯度下降更新参数。

P.S.：如果你觉得梯度的向量化计算比较困难，建议是写出一个很小很明确的向量化例子，在纸上演算梯度，然后对其一般化，得到一个高效的向量化操作形式。

---

吴恩达 DeepLearning.ai