优化NumPy数组与列表相减的性能：深度解析与最佳实践

import time
import numpy as np

image = np.random.rand(4000, 4000, 3).astype("float32")
values = [0.43, 0.44, 0.45]

st = time.time()
image -= values
et = time.time()
print("实现方案1 耗时:", et - st)

import time
import numpy as np

image = np.random.rand(4000, 4000, 3).astype("float32")
values = [0.43, 0.44, 0.45]

st = time.time()
for i in range(3):
    image[..., i] -= values[i]
et = time.time()
print("实现方案2 耗时:", et - st)

实现方案2 耗时: 0.030953645706176758
实现方案1 耗时: 0.8593623638153076

import numpy as np
import time

image_test = np.random.rand(4000, 4000, 3).astype("float32")
values_np = np.array([0.43, 0.44, 0.45], dtype=np.float32) # 使用float32避免后续类型转换问题

# 原始图像的副本，用于每次测试
original_image = image_test.copy()

print("--- 广播数组大小对性能的影响 ---")

# 减去一个小的广播数组 (类似方案1的问题)
image_test = original_image.copy()
st = time.time()
image_test -= values_np # 此时values_np会被广播
et = time.time()
print(f"原始广播 (shape={values_np.shape}): {et - st:.6f} 秒")

# 展平数组并减去不同大小的重复数组
view = original_image.reshape(-1, 3) # (16000000, 3)
values_to_subtract = values_np

for i in range(0, 7):
    factor = 2**i
    # 构造一个更大但仍需广播的数组
    # 注意：这里为了测试广播开销，我们仍然让NumPy进行广播，而不是直接构造一个完整匹配的数组
    # 实际测试中，np.tile会构造一个匹配的数组
    if i == 0:
        # 初始的 (3,) 形状
        sub_array = values_to_subtract
    else:
        # 构造一个形状为 (3 * factor,) 的数组，然后广播到 (N, 3)
        # 这种测试方式是模拟原始答案中对 np.tile 的使用
        # 实际操作中，为了避免 np.tile 本身的开销，更应关注广播机制本身
        pass # 这里的测试逻辑与原答案略有不同，原答案是改变被减数组的最后一维

# 重新进行原始答案中的测试，更准确地反映np.tile的影响
print("\n--- 使用 np.tile 构造不同大小的被减数组 ---")
image_for_tile_test = original_image.copy()
view_for_tile_test = image_for_tile_test.reshape(-1, 3)

for factor_val in [1, 2, 4, 8, 128, 4000]:
    # 构造一个形状为 (3*factor_val,) 的数组，然后广播到 (N, 3*factor_val)
    # 这里的测试是改变 view 的形状来匹配 np.tile 构造的数组
    # 这与原始答案的意图更接近，即被减数组越大，广播开销相对越小
    temp_view = original_image.copy().reshape(-1, 3 * factor_val) # 假设可以reshape
    tile_values = np.tile(values_np, factor_val)
    st = time.time()
    temp_view -= tile_values
    et = time.time()
    print(f"np.tile(values, {factor_val}) 耗时: {et - st:.6f} 秒")

# 注意：当 `np.tile` 生成的数组过大时，其本身的生成时间会成为瓶颈，
# 并且可能超出CPU缓存，导致内存访问变慢。

import numpy as np
import time

image_test = np.random.rand(4000, 4000, 3).astype("float32")
values_np_float32 = np.array([0.43, 0.44, 0.45], dtype=np.float32)

st = time.time()
image_test -= values_np_float32 # 此时values_np_float32是np.float32类型
et = time.time()
print(f"使用np.float32数组进行广播减法 耗时: {et - st:.6f} 秒")

import time
import numpy as np

# 重新初始化图像以进行公平测试
image_optimized = np.random.rand(4000, 4000, 3).astype("float32")
values_list = [0.43, 0.44, 0.45]

st = time.time()
# 1. 将Python列表转换为np.float32数组
values_np_float32 = np.array(values_list, dtype=np.float32)
# 2. 构造一个与image数组最后一维匹配的广播数组
#    这里我们不需要np.tile，因为values_np_float32的形状 (3,) 已经可以正确广播到 image (4000, 4000, 3)
#    NumPy的广播规则会自动处理 (N, M, 3) - (3,) -> (N, M, 3)
image_optimized -= values_np_float32
et = time.time()
print("优化方案 (直接广播np.float32数组) 耗时:", et - st)

# 如果需要更复杂的广播模式，例如原答案中的 np.tile 示例
# 假设 image 形状是 (H, W, C)，我们希望减去一个 (C,) 的数组
# 最直接的方式就是上面所示的，NumPy会自动广播。
# 原答案中 np.tile 的用法是针对一种特殊情况，即需要创建一个与 image.shape[1] 相关的重复模式
# 例如 image -= np.tile(np.array(values, dtype=np.float32), image.shape[1]).reshape(-1, 3)
# 这种用法通常在 image 已经被 reshape 成 (N, M) 并且 M 是 C 的倍数时才适用，
# 或者当需要广播的维度与原始 image 的维度不完全匹配时。
# 对于 image (H, W, C) 减去 values (C,)，NumPy的自动广播是最简洁高效的。

# 示例：将 HWC 转换为 CHW 布局
# original_image_hwc = np.random.rand(4000, 4000, 3).astype("float32")
# image_chw = original_image_hwc.transpose(2, 0, 1) # 从 (H, W, C) 变为 (C, H, W)

# 在 CHW 布局下进行操作
# for i in range(image_chw.shape[0]):
#     image_chw[i, :, :] -= values_np_float32[i]
# 这种方式在某些计算库中可能更受欢迎，但在纯NumPy中，HWC与广播的结合也已高度优化。