Найти ближайшего соседа по более pythonic пути

Question

A - точка, а P - список точек. Я хочу, чтобы выяснить, какие точки Р [я] является наиболее близким к А, то есть я хочу найти P[i_0] с:

i_0 = argmin_i || A - P[i]||^2 

я сделать это таким образом:

import numpy as np 

# P is a list of 4 points 
P = [np.array([-1, 0, 7, 3]), np.array([5, -2, 8, 1]), np.array([0, 2, -3, 4]), np.array([-9, 11, 3, 4])] 
A = np.array([1, 2, 3, 4]) 
distance = 1000000000  # better would be : +infinity 
closest = None 

for p in P: 
    delta = sum((p - A)**2) 
    if delta < distance: 
    distance = delta 
    closest = p 

print closest # the closest point to A among all the points in P 

Он работает, но как это сделать короче/более путинским?

В целом в Python (и даже без использования Numpy) как найти k_0 такие, что D[k_0] = min D[k]? т.е. k_0 = argmin_k D[k]

Answer 1

Более Pythonic способ реализации того же алгоритма, который вы используете, чтобы заменить петлю с вызовом min с key функции:

closest = min(P, key=lambda p: sum((p - A)**2)) 

Следует заметить, что я использую для ** exponentiation (^ - это оператор binary-xor в Python).

Answer 2

Использование встроенного min путь для этого:

import math 
p1 = [1,2] 
plst = [[1,3], [10,10], [5,5]] 
res = min(plst, key=lambda x: math.sqrt(pow(p1[0]-x[0], 2) + pow(p1[1]-x[1], 2))) 
print res 
[1, 3] 

Обратите внимание, что я использовал только простые списки питона.

Answer 3

версия NumPy в однострочнике:

clostest = P[np.argmin(np.apply_along_axis(lambda p: np.sum((p - A) **2), 1, P))] 

Answer 4

Полностью Векторизованный подход в NumPy. Как и у @ MikeMüller, но используя numpy's broadcasting, чтобы избежать лямбда-функций.

С примерных данными:

>>> P = [np.array([-1, 0, 7, 3]), np.array([5, -2, 8, 1]), np.array([0, 2, -3, 4]), np.array([-9, 11, 3, 4])] 
>>> A = np.array([1, 2, 3, 4]) 

И делает P 2D-NumPy массив:

>>> P = np.asarray(P) 
>>> P 
array([[-1, 0, 7, 3], 
     [ 5, -2, 8, 1], 
     [ 0, 2, -3, 4], 
     [-9, 11, 3, 4]]) 

Это может быть вычислено в одной строке с помощью NumPy:

>>> P[np.argmin(np.sum((P - A)**2, axis=1))] 

Обратите внимание, что P - A, с P.shape = (N, 4) и A.shape = (4,) будет загружать субстрат во все строки P (Pi = Pi - A).

Для небольших N (количество строк в P), питонический подход, вероятно, быстрее. При больших значениях N это должно быть значительно быстрее.