Question

我想用datatyp uint8添加numpy数组。我知道这些数组中的值可能足够大，可以发生溢出。所以我得到了类似的东西：

a = np.array([100, 200, 250], dtype=np.uint8)
b = np.array([50, 50, 50], dtype=np.uint8)
a += b

现在，a是[150 250 44]。但是，我希望uint8的值太大而不是uint8允许的最大值，而不是溢出。所以我想要的结果是[150 250 255]。

我可以使用以下代码获得此结果：

a = np.array([100, 200, 250], dtype=np.uint8)
b = np.array([50, 50, 50], dtype=np.uint8)
c = np.zeros((1,3), dtype=np.uint16)
c += a
c += b
c[c>255] = 255
a = np.array(c, dtype=np.uint8)

问题是，我的数组非常大，因此创建具有更大数据类型的第三个数组可能是内存问题。是否有快速且更有效的内存方式来实现所描述的结果？

Answer 1

你可以通过创建dtype uint8的第三个数组，以及一个bool数组~~（它们一起比一个uint16数组更高的内存效率）~~来实现这一点。

np.putmask对于避免临时数组非常有用。

a = np.array([100, 200, 250], dtype=np.uint8)
b = np.array([50, 50, 50], dtype=np.uint8)
c = 255 - b  # a temp uint8 array here
np.putmask(a, c < a, c)  # a temp bool array here
a += b

但是，正如@moarningsun正确指出的那样，bool数组占用与uint8数组相同的内存量，因此这不一定有用。可以通过避免在任何给定时间具有多个临时数组来解决这个问题：

a = np.array([100, 200, 250], dtype=np.uint8)
b = np.array([50, 50, 50], dtype=np.uint8)
b = 255 - b  # old b is gone shortly after new array is created
np.putmask(a, b < a, b)  # a temp bool array here, then it's gone
a += 255 - b  # a temp array here, then it's gone

此方法用于交换CPU的内存消耗。

另一种方法是预先计算所有可能的结果，即O（1）额外内存（即独立于数组的大小）：

c = np.clip(np.arange(256) + np.arange(256)[..., np.newaxis], 0, 255).astype(np.uint8)
c
=> array([[  0,   1,   2, ..., 253, 254, 255],
          [  1,   2,   3, ..., 254, 255, 255],
          [  2,   3,   4, ..., 255, 255, 255],
          ..., 
          [253, 254, 255, ..., 255, 255, 255],
          [254, 255, 255, ..., 255, 255, 255],
          [255, 255, 255, ..., 255, 255, 255]], dtype=uint8)

c[a,b]
=> array([150, 250, 255], dtype=uint8)

如果阵列非常大，这种方法的内存效率最高。同样，它在处理时间上也很昂贵，因为它用较慢的2dim-array索引替换超快整数加法。

说明工作原理

上面c数组的构造使用了一个numpy广播技巧。添加形状(N,)和形状(1,N)数组的数组广播为(N,N) - 就像，因此结果是所有可能总和的NxN数组。然后，我们剪辑它。我们得到一个2dim数组，满足：c[i,j]=min(i+j,255)每个i，j。

然后剩下的是使用花式索引来获取正确的值。使用您提供的输入，我们访问：

c[( [100, 200, 250] , [50, 50, 50] )]

第一个索引数组指第一个暗淡，第二个指向第二个暗淡。因此，结果是一个与索引数组（(N,)）形状相同的数组，由值[ c[100,50] , c[200,50] , c[250,50] ]组成。

Answer 2

这是一种方式：

>>> a = np.array([100, 200, 250], dtype=np.uint8)
>>> b = np.array([50, 50, 50], dtype=np.uint8)
>>> a+=b; a[a<b]=255
>>> a
array([150, 250, 255], dtype=uint8)

Answer 3

如何做

>>> a + np.minimum(255 - a, b)
array([150, 250, 255], dtype=uint8)

通常使用

获取数据类型的最大值

np.iinfo(np.uint8).max

Answer 4

你可以使用Numba真正地实现它，例如：

import numba

@numba.jit('void(u1[:],u1[:])', locals={'temp': numba.uint16})
def add_uint8_inplace_clip(a, b):
    for i in range(a.shape[0]):
        temp = a[i] + b[i]
        a[i] = temp if temp<256 else 255

add_uint8_inplace_clip(a, b)

或者使用Numexpr，例如：

import numexpr

numexpr.evaluate('where((a+b)>255, 255, a+b)', out=a, casting='unsafe')

Numexpr upcasts uint8到int32内部，然后再将其放回uint8数组。

Answer 5

def non_overflowing_sum(a, b)
    c = np.uint16(a)+b
    c[np.where(c>255)] = 255
    return np.uint8( c )

它也会交换内存，但我发现更优雅，并且在返回转换后临时uint16被释放

Answer 6

OpenCV具有这样的功能：cv2.addWeighted

Answer 7

这里有a function in numpy：

numpy.nan_to_num(x)[source]

用零和inf替换有限数字的nan。

返回一个数组或标量替换非数字（NaN），零，（正）无穷大，数字非常大，负无穷大，数字非常小（或负数）。

具有与x相同形状的新数组，x中元素的dtype具有最高精度。

如果x不精确，则NaN被零替换，无穷大（-infinity）被适合输出dtype的最大（最小或最负）浮点值替换。如果x不精确，则返回x的副本。

我不确定它是否适用于uint8，因为输出中提到浮点，但对于其他读者来说，它可能很有用

添加numpy数组时避免溢出

7 个答案: