11.1 向量化 (Vectorization)

11.1 向量化 (Vectorization)

NumPy 性能优化：深入向量化 (Vectorization)

1. 什么是向量化？

向量化是指利用 NumPy 数组的特性，将标量操作转换为数组操作。简单来说，就是用 NumPy 数组对象上的运算代替显式的 Python 循环。 传统的 Python 循环需要解释器逐行执行代码，效率较低。 而 NumPy 的向量化操作则将整个数组传递给底层的 C 代码，由 C 代码高效地完成计算，从而大大提升了速度。

Graph TD 图示：

2. 向量化的优势

• 性能提升: 向量化是 NumPy 性能提升的关键。避免了 Python 循环的开销，利用底层 C 代码的优化，速度提升非常显著。

• 代码简洁: 向量化操作通常可以用更简洁的代码实现相同的功能，提高代码的可读性和可维护性。

• 广播机制: 向量化与广播机制结合使用，可以方便地处理不同形状的数组之间的运算，进一步简化代码。

• 可读性增强: 向量化的代码通常更接近数学表达式，更容易理解其含义。

3. 如何实现向量化

NumPy 提供了丰富的向量化操作，可以用于各种数学和逻辑运算。主要包括：

• 算术运算: +, -, *, /, **, //, % 等运算符可以直接作用于 NumPy 数组，实现元素级别的算术运算。

• 比较运算: ==, !=, >, <, >=, <= 等运算符可以用于比较数组中的元素，返回布尔类型的数组。

• 逻辑运算: & (and), | (or), ~ (not), ^ (xor) 等运算符可以用于对布尔数组进行逻辑运算。

• 通用函数 (ufuncs): NumPy 提供了大量的通用函数，例如 np.sin(), np.cos(), np.exp(), np.log() 等，可以对数组中的每个元素应用相同的函数。

• 聚合函数: NumPy 提供了聚合函数，例如 np.sum(), np.mean(), np.max(), np.min(), np.std(), np.var() 等，可以对数组中的元素进行统计计算。

4. 代码实践与详解

下面通过一些具体的代码示例来演示向量化的用法和优势。

4.1 算术运算

import numpy as np
import time
# 创建两个大的 NumPy 数组
size = 1000000
a = np.arange(size)
b = np.arange(size)
# 使用循环进行加法运算
start_time = time.time()
result_loop = [a[i] + b[i] for i in range(size)]
end_time = time.time()
loop_time = end_time - start_time
print(f"Loop time: {loop_time:.4f} seconds")
# 使用向量化进行加法运算
start_time = time.time()
result_vectorized = a + b
end_time = time.time()
vectorized_time = end_time - start_time
print(f"Vectorized time: {vectorized_time:.4f} seconds")
print(f"Vectorization speedup: {loop_time / vectorized_time:.2f}x")
# 验证结果是否相同
print(f"Results are equal: {np.all(result_loop == result_vectorized)}")
​

代码详解:

• 首先，我们创建了两个大小为 1000000 的 NumPy 数组 a 和 b。

• 然后，我们使用 Python 循环对两个数组进行加法运算，并记录运行时间。

• 接着，我们使用 NumPy 的向量化操作 a + b 进行加法运算，并记录运行时间。

• 最后，我们计算向量化操作相对于循环操作的加速比，并验证结果是否相同。

运行结果分析:

可以看到，向量化操作的速度比循环操作快得多。加速比通常在几十倍甚至上百倍。这是因为向量化操作利用了 NumPy 底层的 C 代码，避免了 Python 循环的开销。

4.2 比较运算和逻辑运算

import numpy as np
# 创建一个 NumPy 数组
arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
# 使用比较运算找到大于 5 的元素
greater_than_5 = arr > 5
print(f"Elements greater than 5: {greater_than_5}")
# 使用逻辑运算找到大于 5 且小于 8 的元素
greater_than_5_and_less_than_8 = (arr > 5) & (arr < 8)
print(f"Elements greater than 5 and less than 8: {greater_than_5_and_less_than_8}")
# 使用布尔索引选择满足条件的元素
selected_elements = arr[greater_than_5_and_less_than_8]
print(f"Selected elements: {selected_elements}")
​

代码详解:

• 我们首先创建了一个 NumPy 数组 arr。

• 然后，我们使用比较运算符 > 找到大于 5 的元素，结果是一个布尔类型的数组 greater_than_5。

• 接着，我们使用逻辑运算符 & 找到大于 5 且小于 8 的元素，结果也是一个布尔类型的数组 greater_than_5_and_less_than_8。

• 最后，我们使用布尔索引 arr[greater_than_5_and_less_than_8] 选择满足条件的元素。

运行结果分析:

这段代码演示了如何使用比较运算和逻辑运算对 NumPy 数组进行过滤和选择。布尔索引是 NumPy 中非常强大的特性，可以方便地选择满足特定条件的元素。

4.3 通用函数 (ufuncs)

import numpy as np
import math
# 创建一个 NumPy 数组
arr = np.array([1, 2, 3, 4, 5])
# 使用 np.sin() 函数计算每个元素的正弦值
sin_arr = np.sin(arr)
print(f"Sine of array elements: {sin_arr}")
# 使用 np.exp() 函数计算每个元素的指数值
exp_arr = np.exp(arr)
print(f"Exponential of array elements: {exp_arr}")
# 对比使用math.sin和np.sin的时间
size = 1000000
a = np.arange(size)
start_time = time.time()
result_loop = [math.sin(x) for x in a]
end_time = time.time()
loop_time = end_time - start_time
print(f"Loop time with math.sin: {loop_time:.4f} seconds")
start_time = time.time()
result_vectorized = np.sin(a)
end_time = time.time()
vectorized_time = end_time - start_time
print(f"Vectorized time with np.sin: {vectorized_time:.4f} seconds")
print(f"Vectorization speedup: {loop_time / vectorized_time:.2f}x")
​

代码详解:

• 我们首先创建了一个 NumPy 数组 arr。

• 然后，我们使用 np.sin() 函数计算每个元素的正弦值，结果是一个包含正弦值的 NumPy 数组 sin_arr。

• 接着，我们使用 np.exp() 函数计算每个元素的指数值，结果是一个包含指数值的 NumPy 数组 exp_arr。

运行结果分析:

np.sin() 和 np.exp() 等通用函数可以对 NumPy 数组中的每个元素应用相同的函数，而无需使用循环。这些函数经过高度优化，性能非常出色。 同时对比了math.sin和np.sin在大量数据下的性能差距，进一步说明了向量化的优势。

4.4 聚合函数

import numpy as np
# 创建一个 NumPy 数组
arr = np.array([1, 2, 3, 4, 5])
# 使用 np.sum() 函数计算数组元素的总和
sum_arr = np.sum(arr)
print(f"Sum of array elements: {sum_arr}")
# 使用 np.mean() 函数计算数组元素的平均值
mean_arr = np.mean(arr)
print(f"Mean of array elements: {mean_arr}")
# 使用 np.max() 函数找到数组元素的最大值
max_arr = np.max(arr)
print(f"Maximum of array elements: {max_arr}")
​

代码详解:

• 我们首先创建了一个 NumPy 数组 arr。

• 然后，我们使用 np.sum() 函数计算数组元素的总和。

• 接着，我们使用 np.mean() 函数计算数组元素的平均值。

• 最后，我们使用 np.max() 函数找到数组元素的最大值。

运行结果分析:

np.sum(), np.mean(), np.max() 等聚合函数可以对 NumPy 数组中的元素进行统计计算，而无需使用循环。这些函数经过高度优化，性能非常出色。

5. 避免非向量化操作

尽管 NumPy 提供了强大的向量化功能，但仍然有一些操作可能会导致性能下降。以下是一些需要避免的非向量化操作：

• 显式循环: 尽量避免使用 Python 循环来处理 NumPy 数组，除非没有其他替代方案。

• np.vectorize: np.vectorize 函数可以将一个 Python 函数转换为一个通用函数，但它的性能通常不如直接使用 NumPy 的向量化操作。 它仅仅是一个方便的工具，并不能真正地提升性能。

• 在循环中修改数组形状: 在循环中频繁地修改数组的形状会导致内存重新分配，从而降低性能。

6. 总结

向量化是 NumPy 性能优化的核心概念。通过利用 NumPy 数组的特性，将标量操作转换为数组操作，可以避免 Python 循环的开销，从而显著提高运算速度。 NumPy 提供了丰富的向量化操作，包括算术运算、比较运算、逻辑运算、通用函数和聚合函数。 掌握向量化的技巧，可以编写出更简洁、更高效的 NumPy 代码。 在处理大规模数据集时，向量化是必不可少的优化手段。

通过上述例子和解释，相信你已经对 NumPy 的向量化有了更深入的理解。 记住，向量化是 NumPy 性能优化的关键，掌握它将使你能够编写出更高效的 NumPy 代码。