如何在 O(1) 中的 numpy 中获得反向映射？

Question

我有一个numpy数组，它的元素是唯一的，例如：

b = np.array([5, 4, 6, 8, 1, 2])

（Edit2：b 可以有大数和浮点数。上面的例子是为了简单起见）

我得到数字，它们是 b 中的元素。

我想在b 中找到它们的索引，这意味着我想在b 中进行从值到索引的反向映射。

我可以的

for number in input:
    ind = np.where(number==b)

每次调用 where 时都会遍历整个数组。

我也可以创建一个字典，

d = {}
for i, element in enumerate(list(b)):
    d[element] = i

我可以在“预处理”时创建这个字典，但我仍然会留下一个看起来很奇怪的字典，大部分是 numpy 代码，这似乎（在我看来）不是 numpy 的用途。

如何在 numpy 中进行这种反向映射？

使用情况（需要 O(1) 时间和内存）：

print("index of 8 is: ", foo(b, 8))

---

• Edit1：不是this 的副本

按照here 的解释使用 in1d 并不能解决我的问题。使用他们的例子：

b = np.array([1, 2, 3, 10, 4])

我希望能够在运行时在 O(1) 中找到例如 10 在 b 中的索引。

进行预处理

mapping = np.in1d(b, b).nonzero()[0]

>> [0, 1, 2, 3, 4]

（可以使用np.arange(len(b)) 完成）

并没有真正的帮助，因为当10 作为输入时，用这种方法不可能在 O(1) 时间内告诉它的索引。

Answer 1

通过利用 numpy 的高级索引，它比您想象的要简单。

我们要做的是创建我们的目标数组，然后将 ussign b 分配为索引。我们将使用 arange 分配我们想要的索引。

>>> t = np.zeros((np.max(b) + 1,))
>>> t[b] = np.arange(0, b.size)
>>> t
array([0., 4., 5., 0., 1., 0., 2., 0., 3.])

您可以使用nans 或 -1 而不是零来构造目标以帮助检测无效查找。

内存使用：这在空间和时间上都是最佳性能，因为它完全由 numpy 处理。

如果你能容忍冲突，你就可以实现一个穷人的哈希表。假设我们有货币，例如：

h = np.int32(b * 100.0) % 101  # Typically some prime number
t = np.zeros((101,))
t[h] = np.arange(0, h.size)

# Retrieving a value v; keep in mind v can be an ndarray itself.
t[np.int32(v * 100.0) % 101]

如果您知道您的数据集是什么样子，您可以执行任何其他步骤来修改地址。

这是关于 numpy 有用的限制。

Answer 2

解决方案

如果您想要恒定时间（即O(1)），那么您需要预先计算某种查找表。如果您想使用另一个 Numpy 数组创建查找表，它实际上必须是一个稀疏数组，其中大多数值是“空的”。这是一种可行的方法，其中将空值标记为-1：

b = np.array([5, 4, 6, 8, 1, 2])

_b_ix = np.array([-1]*(b.max() + 1))
_b_ix[b] = np.arange(b.size)
# _b_ix: array([-1,  4,  5, -1,  1,  0,  2, -1,  3])

def foo(*val):
    return _b_ix[list(val)]

测试：

print("index of 8 is: %s" % foo(8))
print("index of 0,5,1,8 is: %s" % foo(0,5,1,8))

输出：

index of 8 is: [3]
index of 0,5,1,8 is: [-1  0  4  3]

警告

正如其他回答者指出的那样，在生产代码中，您绝对应该使用字典来解决这个问题。为什么？好吧，一方面，假设您的数组b 包含float 值，或任何非int 值。那么基于 Numpy 的查找表将根本不起作用。

因此，只有当您对使用字典有根深蒂固的哲学反对意见时（例如，dict 碾过您的宠物猫），您才应该使用上述答案。 这是生成反向查找字典的好方法：

ix = {k:v for v,k in enumerate(b.flat)}

Answer 3

您可以使用dict、zip 和numpy.arrange 来创建反向查找：

import numpy 

b = np.array([5, 4, 6, 8, 1, 2])
d = dict(zip(b, np.arange(0,len(b))))
print(d)

给予：

{5: 0, 4: 1, 6: 2, 8: 3, 1: 4, 2: 5}

Answer 4

如果您想进行多次查找，可以在初始 O(n) 遍历之后在 O(1) 中执行这些操作以创建查找字典。

b = np.array([5, 4, 6, 8, 1, 2])
lookup_dict = {e:i for i,e in enumerate(b)}
def foo(element):
    return lookup_dict[element]

这适用于您的测试：

>>> print('index of 8 is:', foo(8))
index of 8 is:  3

---

请注意，如果自上次调用 foo() 以来 b 可能已更改，我们必须重新创建字典。