基于字典高效替换数组中的元素 - NumPy / Python
Efficiently replace elements in array based on dictionary - NumPy / Python
首先，如果此问题已在其他地方得到解答，我深表歉意。我能找到的只是关于替换给定值的元素的问题，而不是多个值的元素。
背景
我有几千大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)
感谢您的快速帮助！
鉴于您使用的是 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：带有数组数据的 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
与原始数据相比，此数据的优势在于阵列数据的空间局部性可实现高效的数据获取，这在迭代中使用。
另外，既然你提到了 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]
numpy_indexed 库（免责声明：我是它的作者）提供了以高效矢量化方式实现此操作的功能：
import numpy_indexed as npi
output_array = npi.remap(input_array.flatten(), list(mapping.keys()), list(mapping.values())).reshape(input_array.shape)
注意；我没有测试它；但它应该按照这些思路工作。效率应该对大输入有利，并且映射中的项目很多；我想象类似于 divakars 的方法 2；没有他的方法3快。但是这个解决方案更多的是针对通用性；它也适用于非正整数的输入；甚至 nd 数组（f.i。用其他颜色替换图像中的颜色等）。
我认为 Divakar #3 方法假定映射字典涵盖目标数组中的所有值（或至少是最大值）。否则，为避免索引超出范围错误，您必须更换行
mapping_ar = np.zeros(k.max()+1,dtype=v.dtype) 和
mapping_ar = np.zeros(array.max()+1,dtype=v.dtype)
这会增加相当大的开销。
首先，如果此问题已在其他地方得到解答，我深表歉意。我能找到的只是关于替换给定值的元素的问题，而不是多个值的元素。
背景
我有几千大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)
感谢您的快速帮助！
鉴于您使用的是 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：带有数组数据的 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
与原始数据相比，此数据的优势在于阵列数据的空间局部性可实现高效的数据获取，这在迭代中使用。
另外，既然你提到了 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]
numpy_indexed 库（免责声明：我是它的作者）提供了以高效矢量化方式实现此操作的功能：
import numpy_indexed as npi
output_array = npi.remap(input_array.flatten(), list(mapping.keys()), list(mapping.values())).reshape(input_array.shape)
注意；我没有测试它；但它应该按照这些思路工作。效率应该对大输入有利，并且映射中的项目很多；我想象类似于 divakars 的方法 2；没有他的方法3快。但是这个解决方案更多的是针对通用性；它也适用于非正整数的输入；甚至 nd 数组（f.i。用其他颜色替换图像中的颜色等）。
我认为 Divakar #3 方法假定映射字典涵盖目标数组中的所有值（或至少是最大值）。否则，为避免索引超出范围错误，您必须更换行
mapping_ar = np.zeros(k.max()+1,dtype=v.dtype) 和
mapping_ar = np.zeros(array.max()+1,dtype=v.dtype)
这会增加相当大的开销。