Во-первых, мои извинения, если на это ответили в другом месте. Все, что я мог найти, это вопросы о замене элементов данного значения, а не элементов с несколькими значениями.

Фон

У меня есть несколько тысяч больших np.arrays, вот так:

# generate dummy data
input_array = np.zeros((100,100))
input_array[0:10,0:10] = 1
input_array[20:56, 21:43] = 5
input_array[34:43, 70:89] = 8

В этих массивах я хочу заменить значения на основе словаря:

mapping = {1:2, 5:3, 8:6}

Подходить

В настоящее время я использую простой цикл в сочетании с необычной индексацией:

output_array = np.zeros_like(input_array)

for key in mapping:
    output_array[input_array==key] = mapping[key]

Проблема

Мои массивы имеют размеры 2000 к 2000 году, словари имеют около 1000 записей, поэтому эти циклы занимают вечность.

Вопрос

Есть ли функция, которая просто принимает массив и отображение в виде словаря (или аналогичного) и выводит измененные значения?

Помощь очень ценится!

Обновление:

Решения:

Я проверил отдельные решения в Ipython, используя

%%timeit -r 10 -n 10

Входные данные

import numpy as np
np.random.seed(123)

sources = range(100)
outs = [a for a in range(100)]
np.random.shuffle(outs)
mapping = {sources[a]:outs[a] for a in(range(len(sources)))}

Для каждого решения:

np.random.seed(123)
input_array = np.random.randint(0,100, (1000,1000))

Дивакар, метод 3:

%%timeit -r 10 -n 10
k = np.array(list(mapping.keys()))
v = np.array(list(mapping.values()))

mapping_ar = np.zeros(k.max()+1,dtype=v.dtype) #k,v from approach #1
mapping_ar[k] = v
out = mapping_ar[input_array]

5.01 ms ± 641 µs per loop (mean ± std. dev. of 10 runs, 10 loops each)

Дивакар, метод 2:

%%timeit -r 10 -n 10
k = np.array(list(mapping.keys()))
v = np.array(list(mapping.values()))

sidx = k.argsort() #k,v from approach #1

k = k[sidx]
v = v[sidx]

idx = np.searchsorted(k,input_array.ravel()).reshape(input_array.shape)
idx[idx==len(k)] = 0
mask = k[idx] == input_array
out = np.where(mask, v[idx], 0)

56.9 ms ± 609 µs per loop (mean ± std. dev. of 10 runs, 10 loops each)

Дивакар, метод 1:

%%timeit -r 10 -n 10

k = np.array(list(mapping.keys()))
v = np.array(list(mapping.values()))

out = np.zeros_like(input_array)
for key,val in zip(k,v):
    out[input_array==key] = val

113 ms ± 6.2 ms per loop (mean ± std. dev. of 10 runs, 10 loops each)

Элко :

%%timeit -r 10 -n 10
output_array = npi.remap(input_array.flatten(), list(mapping.keys()), list(mapping.values())).reshape(input_array.shape)

143 ms ± 4.47 ms per loop (mean ± std. dev. of 10 runs, 10 loops each)

Yatu

%%timeit -r 10 -n 10

keys, choices = list(zip(*mapping.items()))
# [(1, 5, 8), (2, 3, 6)]
conds = np.array(keys)[:,None,None]  == input_array
np.select(conds, choices)

157 ms ± 5 ms per loop (mean ± std. dev. of 10 runs, 10 loops each)

Оригинальный, петлевой метод:

%%timeit -r 10 -n 10
output_array = np.zeros_like(input_array)

for key in mapping:
    output_array[input_array==key] = mapping[key]

187 ms ± 6.44 ms per loop (mean ± std. dev. of 10 runs, 10 loops each)

Спасибо за помощь Superquick!

13
warped 2 Май 2019 в 12:50

4 ответа

Лучший ответ

Подход № 1: петля с данными массива

Один из подходов - извлечь ключи и значения из массивов, а затем использовать аналогичный цикл -

k = np.array(list(mapping.keys()))
v = np.array(list(mapping.values()))

out = np.zeros_like(input_array)
for key,val in zip(k,v):
    out[input_array==key] = val

Преимущество этого по сравнению с оригинальным - пространственная локальность данных массива для эффективной выборки данных, которая используется в итерациях.

Кроме того, поскольку вы упомянули thousand large np.arrays. Таким образом, если словарь mapping остается прежним, этот шаг для получения версий массива - k и v будет одноразовым процессом установки.

Подход № 2. Векторизация с searchsorted

Векторизованное можно предложить, используя np.searchsorted -

sidx = k.argsort() #k,v from approach #1

k = k[sidx]
v = v[sidx]

idx = np.searchsorted(k,input_array.ravel()).reshape(input_array.shape)
idx[idx==len(k)] = 0
mask = k[idx] == input_array
out = np.where(mask, v[idx], 0)

Подход № 3. Векторизованный с массивом отображения для целочисленных ключей

Векторизованный можно предложить использовать массив отображения для целочисленных ключей, который при индексации входным массивом приведет нас непосредственно к окончательному результату -

mapping_ar = np.zeros(k.max()+1,dtype=v.dtype) #k,v from approach #1
mapping_ar[k] = v
out = mapping_ar[input_array]
1
Divakar 2 Май 2019 в 10:22

numpy_indexed библиотека (отказ от ответственности: я ) предоставляет функциональные возможности для реализации этой операции в эффективном векторизованном виде:

import numpy_indexed as npi
output_array = npi.remap(input_array.flatten(), list(mapping.keys()), list(mapping.values())).reshape(input_array.shape)

Запись; Я не проверял это; но это должно работать в этом направлении. Эффективность должна быть хорошей для больших входов и множества элементов в отображении; Я представляю себе похожий на метод дивакаров 2; не так быстро, как его метод 3. Но это решение направлено больше на общность; и это также будет работать для входных данных, которые не являются положительными целыми числами; или даже nd-массивы (например, замена цветов на изображении другими цветами и т. д.).

1
Eelco Hoogendoorn 2 Май 2019 в 12:21

Я думаю, что метод Divakar # 3 предполагает, что условие отображения охватывает все значения (или, по крайней мере, максимальное значение) в целевом массиве. В противном случае, чтобы избежать ошибок индекса вне диапазона, необходимо заменить строку

mapping_ar = np.zeros(k.max()+1,dtype=v.dtype) с

mapping_ar = np.zeros(array.max()+1,dtype=v.dtype)

Это добавляет значительные накладные расходы.

0
Trenton 1 Ноя 2019 в 09:59

Учитывая, что вы используете массивы NumPy, я бы посоветовал вам сделать отображение с использованием NUMPY. Вот векторизованный подход с использованием np.select :

mapping = {1:2, 5:3, 8:6}
keys, choices = list(zip(*mapping.items()))
# [(1, 5, 8), (2, 3, 6)]
# we can use broadcasting to obtain a 3x100x100
# array to use as condlist
conds = np.array(keys)[:,None,None]  == input_array
# use conds as arrays of conditions and the values 
# as choices
np.select(conds, choices)

array([[2, 2, 2, ..., 0, 0, 0],
       [2, 2, 2, ..., 0, 0, 0],
       [2, 2, 2, ..., 0, 0, 0],
       ...,
       [0, 0, 0, ..., 0, 0, 0],
       [0, 0, 0, ..., 0, 0, 0],
       [0, 0, 0, ..., 0, 0, 0]])
1
yatu 2 Май 2019 в 10:44