11.2 内存优化

11.2 内存优化

NumPy 内存优化：提升性能的关键

NumPy 的强大之处在于其能够高效地处理大型数据集。然而，不合理的内存使用方式可能会成为性能瓶颈。本篇文章将深入探讨 NumPy 中内存优化的策略，帮助你编写更高效的代码，充分利用硬件资源。

11.2.1 数据类型选择：精打细算，量体裁衣

NumPy 提供了多种数据类型（dtype），每种类型在内存中占据的空间大小不同。选择合适的数据类型是内存优化的第一步。

原则：

• 够用就好： 避免使用过大的数据类型。如果数据范围在 int8 的范围内，就不要使用 int64。

• 考虑符号： 如果数据都是非负数，使用无符号类型（如 uint8）可以节省一半的内存空间。

• 精度需求： 浮点数类型 float32 通常比 float64 更节省空间，但精度较低。根据实际需求选择。

代码示例：

import numpy as np
# 假设存储年龄，最大年龄不超过 150
age = np.array([25, 30, 45, 60, 120], dtype=np.uint8)
print(age.dtype)  # 输出：uint8
# 假设存储身高，精度到厘米级别
height = np.array([1.75, 1.80, 1.65, 1.90], dtype=np.float32)
print(height.dtype) # 输出：float32
# 比较内存占用
age_int64 = np.array([25, 30, 45, 60, 120], dtype=np.int64)
print(f"uint8 array size: {age.nbytes} bytes")      # 输出：uint8 array size: 5 bytes
print(f"int64 array size: {age_int64.nbytes} bytes")  # 输出：int64 array size: 40 bytes
​

详解：

• np.uint8 只需要 1 字节存储一个年龄，而 np.int64 需要 8 字节。

• 通过合理选择数据类型，可以将内存占用减少到原来的八分之一。

11.2.2 视图（View）与副本（Copy）：避免不必要的复制

NumPy 的切片操作会返回视图（View），而不是副本（Copy）。这意味着视图与原始数组共享内存，修改视图会影响原始数组。理解视图和副本的区别对于内存优化至关重要。

原则：

• 利用视图： 尽可能使用视图，避免不必要的复制。

• 明确复制： 如果需要修改数组而不影响原始数据，使用 copy() 方法创建副本。

代码示例：

import numpy as np
# 创建一个数组
arr = np.arange(10)
# 创建一个视图
view = arr[2:5]
print(f"Original array: {arr}")  # 输出：Original array: [0 1 2 3 4 5 6 7 8 9]
print(f"View: {view}")          # 输出：View: [2 3 4]
# 修改视图
view[0] = 100
print(f"Original array after modifying view: {arr}") # 输出：Original array after modifying view: [  0   1 100   3   4   5   6   7   8   9]
print(f"View after modification: {view}")           # 输出：View after modification: [100   3   4]
# 创建一个副本
copy = arr[2:5].copy()
copy[0] = 200
print(f"Original array after modifying copy: {arr}") # 输出：Original array after modifying copy: [  0   1 100   3   4   5   6   7   8   9]
print(f"Copy after modification: {copy}")           # 输出：Copy after modification: [200   3   4]
​

详解：

• 修改视图 view 会影响原始数组 arr。

• 修改副本 copy 不会影响原始数组 arr。

• 使用 copy() 方法会分配新的内存空间，消耗更多资源。

11.2.3 就地操作（In-place Operations）：减少临时变量

NumPy 提供了一些就地操作，可以直接修改数组本身，而无需创建新的数组。这可以减少内存占用，提高性能。

原则：

• 优先使用就地操作： 比如 +=，*=, /=, -= 等。

• 避免创建临时数组： 尽量避免在循环中创建大量临时数组。

代码示例：

import numpy as np
# 创建一个数组
arr = np.arange(10)
# 使用就地操作
arr += 1
print(f"Array after in-place addition: {arr}") # 输出：Array after in-place addition: [ 1  2  3  4  5  6  7  8  9 10]
# 避免创建临时数组 (低效)
def add_one_inefficient(arr):
    for i in range(len(arr)):
        arr[i] = arr[i] + 1  # 创建临时数组存储 arr[i] + 1
# 使用NumPy广播机制 (高效)
def add_one_efficient(arr):
    arr += 1  # 就地操作，不创建临时数组
​

详解：

• arr += 1 直接修改 arr，无需创建新的数组。

• 避免在循环中使用 arr[i] = arr[i] + 1，因为它会创建临时数组存储 arr[i] + 1。NumPy的广播机制更加高效。

11.2.4 稀疏矩阵：存储非零元素

当处理包含大量零元素的矩阵时，使用稀疏矩阵可以显著减少内存占用。NumPy 本身不直接支持稀疏矩阵，但可以与 SciPy 库结合使用。

原则：

• 识别稀疏数据： 如果矩阵中大部分元素为零，考虑使用稀疏矩阵。

• 选择合适的稀疏矩阵格式： SciPy 提供了多种稀疏矩阵格式，如 COO, CSR, CSC 等。

代码示例：

import numpy as np
from scipy.sparse import csr_matrix
# 创建一个稀疏矩阵
data = np.array([1, 2, 3, 4, 5, 6])
row = np.array([0, 0, 1, 2, 2, 2])
col = np.array([0, 2, 2, 0, 1, 2])
sparse_matrix = csr_matrix((data, (row, col)), shape=(3, 3))
print(sparse_matrix)
# 转换为密集矩阵
dense_matrix = sparse_matrix.toarray()
print(dense_matrix)
​

详解：

• csr_matrix 是一种常用的稀疏矩阵格式，只存储非零元素及其坐标。

• 稀疏矩阵可以显著减少内存占用，尤其是在处理大型稀疏数据时。

11.2.5 内存映射文件：处理大型数据集

当数据集太大，无法完全加载到内存中时，可以使用内存映射文件。内存映射文件允许你将磁盘上的文件映射到内存中，像操作数组一样操作文件。

原则：

• 处理超大型数据集： 当数据集超出内存限制时，考虑使用内存映射文件。

• 按需加载数据： 只加载需要的部分数据到内存中。

代码示例：

import numpy as np
# 创建一个大型数组并保存到磁盘
arr = np.arange(100000000, dtype=np.float32)
np.save('large_array.npy', arr)
# 使用内存映射文件加载数组
mmapped_arr = np.load('large_array.npy', mmap_mode='r')
print(mmapped_arr.shape)
# 访问数组元素
print(mmapped_arr[1000000])
# 修改数组元素 (需要 mmap_mode='r+')
# mmapped_arr[1000000] = 2.0
​

详解：

• mmap_mode='r' 表示只读模式，mmap_mode='r+' 表示读写模式。

• 内存映射文件可以让你像操作数组一样操作磁盘上的文件，而无需将整个文件加载到内存中。

11.2.6 数组重塑与步长：理解内存布局

NumPy 数组的内存布局是连续的，理解数组的步长（strides）对于优化内存访问至关重要。

原则：

• 理解步长： 步长表示在内存中从一个元素移动到下一个元素所需的字节数。

• 优化内存访问模式： 尽量按照数组的内存布局顺序访问元素，避免跳跃式访问。

• 使用 reshape 创建视图： reshape 操作通常会返回视图，而不是副本。

代码示例：

import numpy as np
# 创建一个二维数组
arr = np.arange(12).reshape(3, 4)
print(f"Original array:\n{arr}")
# 查看数组的步长
print(f"Array strides: {arr.strides}")  # 输出：(16, 4) (假设 dtype=int32)
# 转置数组
transposed_arr = arr.T
print(f"Transposed array:\n{transposed_arr}")
print(f"Transposed array strides: {transposed_arr.strides}") # 输出：(4, 16)
# 创建一个视图
reshaped_arr = arr.reshape(4, 3)
print(f"Reshaped array:\n{reshaped_arr}")
print(f"Reshaped array strides: {reshaped_arr.strides}") # 输出：(12, 4)
# 连续内存访问
for i in range(arr.shape[0]):
    for j in range(arr.shape[1]):
        print(arr[i, j], end=" ")
    print()
# 非连续内存访问 (转置后的数组)
# 这种访问方式效率较低，因为内存访问是不连续的
for i in range(transposed_arr.shape[0]):
    for j in range(transposed_arr.shape[1]):
        print(transposed_arr[i, j], end=" ")
    print()
​

详解：

• 步长 (16, 4) 表示在行方向上移动一个元素需要 16 字节，在列方向上移动一个元素需要 4 字节 (假设 dtype=int32，每个元素 4 字节)。

• 转置操作会改变数组的步长，导致内存访问模式发生变化。

• 连续内存访问效率更高，因为可以充分利用 CPU 的缓存。

11.2.7 使用 itemsize 和 nbytes 检查内存占用

可以使用 itemsize 属性获取数组中每个元素的大小（以字节为单位），使用 nbytes 属性获取数组的总大小（以字节为单位）。

代码示例：

import numpy as np
arr = np.array([1, 2, 3, 4, 5], dtype=np.int32)
print(f"Item size: {arr.itemsize} bytes") # 输出：Item size: 4 bytes
print(f"Total size: {arr.nbytes} bytes") # 输出：Total size: 20 bytes
​

11.2.8 图解：内存优化策略

图解说明：

1. 开始： 从分析数据开始。

2. 选择合适的数据类型： 根据数据范围和精度需求，选择最合适的数据类型。

3. 使用视图避免复制： 尽可能使用视图，避免不必要的复制操作。

4. 使用就地操作： 使用就地操作，减少临时变量的创建。

5. 数据是否稀疏： 如果数据包含大量零元素，考虑使用稀疏矩阵。

6. 使用稀疏矩阵： 使用 SciPy 库提供的稀疏矩阵格式。

7. 使用内存映射文件： 如果数据集太大，无法完全加载到内存中，使用内存映射文件。

8. 理解数组步长和内存布局： 理解数组的步长，优化内存访问模式。

9. 结束： 完成内存优化。

总结

NumPy 内存优化是一个多方面的过程，需要根据具体情况选择合适的策略。通过合理选择数据类型、避免不必要的复制、使用就地操作、利用稀疏矩阵、使用内存映射文件以及理解数组的内存布局，可以显著减少内存占用，提高 NumPy 代码的性能。记住，优化是一个迭代的过程，需要不断地分析和调整。