用缺失值填充字典

Question

让b 成为一个带有一些值的字典：

 b = {}  
 b[90, 1] = 100, b[90, 55] = 101, b[90, 127] = 102
 b[70, 1] = 40, b[70, 45] = 41, b[70, 107] = 42

如何一次性填充dict 及其缺失值作为最近邻，例如0 <= i <= 127、0 <= j <= 127？ （它将在字典中提供 16384 个键，所以这对我的应用程序来说没问题）。

例如，我想要b[73, 40] = b[70, 45] = 41，即二维平面中的最近邻。

这是我尝试过的：

for i in range(127):
  for j in range(127):
    closest_key = min(b.keys(), key=lambda c: (c[0] - i) ** 2 + (c[1] - j) ** 2)
    b[i, j] = b[closest_key]

但它很慢可能是因为有 127*127 循环，我们在其中再次循环所有元素以计算距离！

我们如何以更有效的方式填充缺失值和最近邻的字典？

Answer 1

您正在b 内部搜索最接近的键。但是b 不仅包含原始密钥，还包含您在每次迭代中输入的新密钥。只检查初始键会更快、更正确：

initial_keys = set(b.keys())
for i in xrange(127):
    for j in xrange(127):
        if (i, j) not in initial_keys:
            closest_key = min(
                initial_keys, key=lambda c: (c[0] - i) ** 2 + (c[1] - j) ** 2
            )
            b[i, j] = b[closest_key]

这样算法的运行时间从O(n^4)下降到O(k * n^2)，其中n是维度大小，k是初始键的数量。

编辑：

您可以使用numpy 大大提高速度：

import numpy as np

s = set(b.keys())
x = np.array([k[0] for k in s])
y = np.array([k[1] for k in s])
for i in xrange(128):
    for j in xrange(128):
        if (i, j) not in s:
            argmin = np.argmin((x - i) ** 2 + (y - j) ** 2)
            b[i, j] = b[x[argmin], y[argmin]]

Answer 2

字典绝对不适合这种用途 - 除非您对 O(n) 的复杂性感到满意（然后，使用列表会更清楚）。可以想象，a class of hashing functions 可以用来实现适当的“字典”——但 python 的 dict 绝对不能胜任这项任务。

如果您需要适当的性能，您将需要使用另一种数据结构。最简单的是K-d tree。有一个实现inside scipy。

您可能想查看专门针对nearest neighbor search 的维基百科文章

---

当然，如果您重复查询相同的值（如 Raydel Miranda 的回答），您可以使用字典作为缓存。但将其用作缓存 - 不用于存储/查询您的实际数据！

Answer 3

您可以尝试按需计算，并使用结果构建缓存。这种方法的优点是，如果您不需要使用某个点，它将永远不会被计算。

完整示例：

b = {}  
b[90, 1] = 100
b[90, 55] = 101
b[90, 127] = 102
b[70, 1] = 40
b[70, 45] = 41
b[70, 107] = 42

class NeighbourDist:

  def __init__(self, source_dict):
    # Original dict.
    self.__source_dict = source_dict
    # Dict used for cache.
    self.__cache_dict = {}


  def __calculate_distance(self, x0, x1, y0, y1):
    """ Calculate distance beetwen two points. """
    dx = x1 - x0
    dy = y1 - y0
    d = (dx**2 + dy**2)**0.5
    return d

  def __getitem__(self, key):
    """
    Look for the key in the cached dict, if not has been calculated yet
    then proceed to calculate it.
    Return the result and store in __cache_dict.
    """
    cached = self.__cache_dict.get(key)
    if cached is not None:
      return cached
    else:
      x0, y0 = key
      min_n = 0
      min_  = 1e100
      for (x1, y1) in self.__source_dict.keys():
        dist = self.__calculate_distance(x0, x1, y0, y1)
        if min_ > dist:
          min_ = dist
          min_n = self.__source_dict[x1, y1]
      self.__cache_dict[key] = min_n
      return min_n

if '__main__' == __name__:
  d = NeighbourDist(b)
  print(d[73, 40]) # >>> 41
  print(d[73, 40]) # >>> 41, Second time the result is obtained from the cached dict.