如何有效地将 X 模 Y 添加到 numpy 数组中的每个元素？

Question

假设我有一个非常大的值数组，介于 1 和 180 之间，这些值位于 uint8s 的数组中（最高可达 255）。我想为每个值加上 90（模 180）：

original = np.array([1, 2, 3, 170, 171, 172], dtype=np.uint8)
modified = (original + 90) % 180

不幸的是，这会产生不正确的结果，因为在添加 90 时，较大的数字会在第一步中溢出它们的 uint8 整数：170 + 90 = 260，它大于 255。

# (170 + 90) % 180 is 80, not 4 :(
array([91, 92, 93,  4,  5,  6], dtype=uint8)

我在对性能非常敏感的环境中操作，我的输入列表非常大。因此，我想避免将此数组转换为更大数据类型的惩罚，并且我想使用高效的操作（例如，避免循环遍历数组并单独处理每个值）。

我怎样才能做到这一点？

Answer 1

您可以简单地将数组转换为np.unit16：

>>> ((original.astype(np.uint16) + 90) % 180).astype(np.uint8)
array([91, 92, 93, 80, 81, 82], dtype=uint8)

如果您只想使用 uint8 来实现这一点，您可以只增加那些大于 255-90 的元素：

>>> modified = (original + 90) % 180
>>> modified[original >= 255-90] += 256-180
>>> modified
array([91, 92, 93, 80, 81, 82], dtype=uint8)

Answer 2

import numpy as np

分配一个由大小为 (10, 10) 的整数组成的随机 numpy 数组，其元素的最大值可以为 255。

np_array = np.random.randint(255, size=(10, 10))

对每个元素加 90 并对其进行取模。

np_array = (np_array + 90) % 180

Answer 3

这是一个有一些数学但没有向上转换的 -

def add_with_modulus(original, addval, modulusval=180):
    v = original + addval
    v[modulusval-original<=addval] += 256-modulusval
    return v

用法：add_with_modulus(original, addval=90, modulusval=180).

Answer 4

一个非常简单的选项，因为您正在处理uint8，所以只需提前计算数组中每个可能值的结果并使用它：

import numpy as np
original = np.array([1, 2, 3, 170, 171, 172], dtype=np.uint8)
value_map = ((np.arange(256) + 90) % 180).astype(np.uint8)
modified = value_map[original]
print(modified)
# [91 92 93 80 81 82]

这样做的好处是它不会占用超过 256 个元素 value_map 的任何额外内存，并且对于任何更大的数组，您也将节省大部分计算。

针对强制转换运行时间基准：

import numpy as np

def add_val_mod_cast(a, val, mod):
    return ((a.astype(np.uint16) + val) % mod).astype(np.uint8)

def add_val_mod_map(a, val, mod):
    value_map = ((np.arange(256) + val) % mod).astype(np.uint8)
    return value_map[a]

np.random.seed(0)
a = np.random.randint(256, size=10_000_000).astype(np.uint8)
val = 90
mod = 180
print((add_val_mod_cast(a, val, mod) == add_val_mod_map(a, val, mod)).all())
# True
%timeit add_val_mod_cast(a, val, mod)
# 72.6 ms ± 2.7 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
%timeit add_val_mod_map(a, val, mod)
# 40.8 ms ± 606 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)