python - 基于字典高效替换数组中的元素 - NumPy/Python

Question

首先，如果这个问题在其他地方得到了回答，我深表歉意。我所能找到的只是关于替换给定值的元素的问题，而不是多个值的元素。

背景

我有几千个大型 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 x 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))

迪瓦卡，方法三:

%%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)

迪瓦卡，方法二:

%%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)

迪瓦卡，方法一:

%%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)

eelco:

%%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)

亚图

%%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)

感谢您的 super 快速帮助!

Answer 1

方法 #1:使用数组数据的 Loopy one

一种方法是提取数组中的键和值，然后使用类似的循环 -

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

与原始数据相比，此数据的优势在于阵列数据的空间局部性，可在迭代中使用，以实现高效的数据获取。

此外，由于您提到了千个大型 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]