Подтвердить что ты не робот

Избегайте переполнения при добавлении массивов numpy

Я хочу добавить массивы numpy с datatyp uint8. Я знаю, что значения в этих массивах могут быть достаточно большими для переполнения. Поэтому я получаю что-то вроде:

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)

Проблема в том, что мои массивы действительно большие, поэтому создание третьего массива с большим типом данных может быть проблемой памяти. Есть ли быстрый и эффективный способ памяти для достижения описанного результата?

4b9b3361

ОТВЕТЫ

Ответ 1

Вы можете достичь этого, создав третий массив dtype uint8, а также массив bool (которые вместе обладают большей эффективностью в памяти, чем один массив uint16).

np.putmask полезно для избежания массива temp.

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 gone
a += 255 - b  # a temp array here, then it gone

Этот подход учитывает потребление памяти для ЦП.

Другим подходом является предварительное вычисление всех возможных результатов, которые представляют собой 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.

ОБЪЯСНЕНИЕ КАК ЭТО РАБОТАЕТ

Построение массива c, описанное выше, использует теневой трюк с несколькими цифрами. Добавление массива формы (N,) и массива формы (1,N) передается как (N,N) -like, таким образом, результат представляет собой массив NxN всех возможных сумм. Затем мы закрепим его. Мы получаем массив 2dim, который удовлетворяет: c[i,j]=min(i+j,255) для каждого i, j.

Тогда то, что осталось, использует причудливую индексацию захвата правильных значений. Работая с введенным вами вводом, мы получаем:

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

Первый индексный массив относится к 1-м тусклым, а второй - к 2-му dim. Таким образом, результатом является массив той же формы, что и массивы индексов ((N,)), состоящие из значений [ c[100,50] , c[200,50] , c[250,50] ].

Ответ 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)

Ответ 3

Как сделать

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

в общем случае получить максимальное значение для вашего типа данных с помощью

np.iinfo(np.uint8).max

Ответ 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 to int32 внутренне, прежде чем поместить его обратно в массив uint8.

Ответ 5

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

он тоже торгует памятью, но я нашел более элегантным, и временный uint16 освобождается после преобразования по возвращении

Ответ 6

Там функция в numpy для этого:

numpy.nan_to_num(x)[source]

Замените нан нулем и inf конечными числами.

Возвращает массив или скаляр, заменяющий не число (NaN) нулевой, положительной бесконечностью с очень большим числом и отрицательной бесконечностью с очень маленьким (или отрицательным) числом.

Новый массив с такой же формой, как x и dtype элемента в x с наибольшей точностью.

Если x неточно, то NaN заменяется на нуль, а бесконечность (-infinity) заменяется наибольшим (наименьшим или самым отрицательным) значением с плавающей запятой, которое соответствует выходному dtype. Если x неточно, то возвращается копия x.

Я не уверен, что он будет работать с uint8 из-за упоминания о плавающей запятой в выходе, но для других читателей это может быть полезно

Ответ 7

OpenCV имеет такую функцию: cv2.addWeighted