Як можна обчислити евклідову відстань за допомогою NumPy?

У мене в 3D є два моменти:

(xa, ya, za)
(xb, yb, zb)

І я хочу обчислити відстань:

dist = sqrt((xa-xb)^2 + (ya-yb)^2 + (za-zb)^2)

Який найкращий спосіб зробити це з NumPy або взагалі з Python? Я маю:

import numpy
a = numpy.array((xa ,ya, za))
b = numpy.array((xb, yb, zb))

Використання numpy.linalg.norm:

dist = numpy.linalg.norm(a-b)

Ви можете знайти теорію, що стоїть за цим, у Введенні до обміну даними

Це працює, тому що евклідова відстань дорівнює l2, а значення за замовчуванням параметра ord в numpy.linalg.norm дорівнює 2.

Для SciPy є функція для цього. Його називають Евклідовим .

Приклад:

from scipy.spatial import distance
a = (1, 2, 3)
b = (4, 5, 6)
dst = distance.euclidean(a, b)

Для всіх, хто цікавиться обчисленням кількох відстаней одночасно, я провів невелике порівняння, використовуючи perfplot ( мій невеликий проект).

Перша порада - організувати свої дані таким чином, щоб масиви мали розмірність (3, n)(і, очевидно, є C-суміжними). При додаванні відбувається в прилеглій першому вимірі, все швидше, і це не має значення надто багато , якщо ви використовуєте sqrt-sumз axis=0, linalg.normз axis=0, або

a_min_b = a - b
numpy.sqrt(numpy.einsum('ij,ij->j', a_min_b, a_min_b))

який незначним запасом є найшвидшим варіантом. (Це насправді справедливо і для лише одного ряду.)

Варіанти, коли ви підсумовуєте над другою віссю, axis=1всі значно повільніші.

Код для відтворення сюжету:

import numpy
import perfplot
from scipy.spatial import distance


def linalg_norm(data):
    a, b = data[0]
    return numpy.linalg.norm(a - b, axis=1)


def linalg_norm_T(data):
    a, b = data[1]
    return numpy.linalg.norm(a - b, axis=0)


def sqrt_sum(data):
    a, b = data[0]
    return numpy.sqrt(numpy.sum((a - b) ** 2, axis=1))


def sqrt_sum_T(data):
    a, b = data[1]
    return numpy.sqrt(numpy.sum((a - b) ** 2, axis=0))


def scipy_distance(data):
    a, b = data[0]
    return list(map(distance.euclidean, a, b))


def sqrt_einsum(data):
    a, b = data[0]
    a_min_b = a - b
    return numpy.sqrt(numpy.einsum("ij,ij->i", a_min_b, a_min_b))


def sqrt_einsum_T(data):
    a, b = data[1]
    a_min_b = a - b
    return numpy.sqrt(numpy.einsum("ij,ij->j", a_min_b, a_min_b))


def setup(n):
    a = numpy.random.rand(n, 3)
    b = numpy.random.rand(n, 3)
    out0 = numpy.array([a, b])
    out1 = numpy.array([a.T, b.T])
    return out0, out1


perfplot.save(
    "norm.png",
    setup=setup,
    n_range=[2 ** k for k in range(22)],
    kernels=[
        linalg_norm,
        linalg_norm_T,
        scipy_distance,
        sqrt_sum,
        sqrt_sum_T,
        sqrt_einsum,
        sqrt_einsum_T,
    ],
    logx=True,
    logy=True,
    xlabel="len(x), len(y)",
)

Я хочу пояснити просту відповідь різними примітками про виконання. np.linalg.norm зробить можливо більше, ніж потрібно:

dist = numpy.linalg.norm(a-b)

По-перше - ця функція призначена для роботи над списком і повернення всіх значень, наприклад для порівняння відстані від pAнабору точок sP:

sP = set(points)
pA = point
distances = np.linalg.norm(sP - pA, ord=2, axis=1.)  # 'distances' is a list

Запам’ятайте кілька речей:

• Дзвінки з функції Python дорогі.
• [Regular] Python не кешує пошукові імена.

Тому

def distance(pointA, pointB):
    dist = np.linalg.norm(pointA - pointB)
    return dist

не такий невинний, як виглядає.

>>> dis.dis(distance)
  2           0 LOAD_GLOBAL              0 (np)
              2 LOAD_ATTR                1 (linalg)
              4 LOAD_ATTR                2 (norm)
              6 LOAD_FAST                0 (pointA)
              8 LOAD_FAST                1 (pointB)
             10 BINARY_SUBTRACT
             12 CALL_FUNCTION            1
             14 STORE_FAST               2 (dist)

  3          16 LOAD_FAST                2 (dist)
             18 RETURN_VALUE

По-перше - кожен раз, коли ми його називаємо, ми повинні робити глобальний пошук для "np", масштабного пошуку для "linalg" та масштабного пошуку для "norm", а накладні витрати просто виклику функції можуть дорівнювати десяткам python інструкції.

Нарешті, ми витратили дві операції на збереження результату та перезавантаження його для повернення ...

Спочатку пройдіть вдосконалення: зробіть пошук швидше, пропустіть магазин

def distance(pointA, pointB, _norm=np.linalg.norm):
    return _norm(pointA - pointB)

Ми отримуємо набагато більш обтічний:

>>> dis.dis(distance)
  2           0 LOAD_FAST                2 (_norm)
              2 LOAD_FAST                0 (pointA)
              4 LOAD_FAST                1 (pointB)
              6 BINARY_SUBTRACT
              8 CALL_FUNCTION            1
             10 RETURN_VALUE

Однак функціональний виклик все ще становить деяку роботу. І вам захочеться зробити орієнтири, щоб визначити, чи краще вам робити математику самостійно:

def distance(pointA, pointB):
    return (
        ((pointA.x - pointB.x) ** 2) +
        ((pointA.y - pointB.y) ** 2) +
        ((pointA.z - pointB.z) ** 2)
    ) ** 0.5  # fast sqrt

На деяких платформах **0.5це швидше, ніж math.sqrt. Ваш пробіг може відрізнятися.

**** Нотатки про покращені показники.

Чому ви обчислюєте відстань? Якщо єдиною метою є його відображення,

 print("The target is %.2fm away" % (distance(a, b)))

рухатися по. Але якщо ви порівнюєте відстані, робите перевірку дальності і т.д., я хотів би додати кілька корисних спостережень.

Візьмемо два випадки: сортування за дистанцією або складання списку до елементів, що відповідають обмеженню діапазону.

# Ultra naive implementations. Hold onto your hat.

def sort_things_by_distance(origin, things):
    return things.sort(key=lambda thing: distance(origin, thing))

def in_range(origin, range, things):
    things_in_range = []
    for thing in things:
        if distance(origin, thing) <= range:
            things_in_range.append(thing)

Перше, що нам потрібно пам’ятати, це те, що ми використовуємо Піфагора для обчислення відстані ( dist = sqrt(x^2 + y^2 + z^2)), тому ми робимо багато sqrtдзвінків. Математика 101:

dist = root ( x^2 + y^2 + z^2 )
:.
dist^2 = x^2 + y^2 + z^2
and
sq(N) < sq(M) iff M > N
and
sq(N) > sq(M) iff N > M
and
sq(N) = sq(M) iff N == M

Якщо коротко: поки нам фактично не потрібна відстань в одиниці X, а не X ^ 2, ми можемо усунути найважчу частину обчислень.

# Still naive, but much faster.

def distance_sq(left, right):
    """ Returns the square of the distance between left and right. """
    return (
        ((left.x - right.x) ** 2) +
        ((left.y - right.y) ** 2) +
        ((left.z - right.z) ** 2)
    )

def sort_things_by_distance(origin, things):
    return things.sort(key=lambda thing: distance_sq(origin, thing))

def in_range(origin, range, things):
    things_in_range = []

    # Remember that sqrt(N)**2 == N, so if we square
    # range, we don't need to root the distances.
    range_sq = range**2

    for thing in things:
        if distance_sq(origin, thing) <= range_sq:
            things_in_range.append(thing)

Чудово, що обидві функції більше не виконують дорогих квадратних коренів. Це буде набагато швидше. Ми також можемо покращити in_range, перетворивши його в генератор:

def in_range(origin, range, things):
    range_sq = range**2
    yield from (thing for thing in things
                if distance_sq(origin, thing) <= range_sq)

Особливо це має переваги, якщо ви робите щось на кшталт:

if any(in_range(origin, max_dist, things)):
    ...

Але якщо наступне, що ви збираєтеся зробити, вимагає відстані,

for nearby in in_range(origin, walking_distance, hotdog_stands):
    print("%s %.2fm" % (nearby.name, distance(origin, nearby)))

розглянути можливість отримання кортежів:

def in_range_with_dist_sq(origin, range, things):
    range_sq = range**2
    for thing in things:
        dist_sq = distance_sq(origin, thing)
        if dist_sq <= range_sq: yield (thing, dist_sq)

Це може бути особливо корисно, якщо ви можете перевірити діапазон діапазону ("знайдіть речі, що знаходяться біля X і в межах Nm від Y", оскільки вам не доведеться знову обчислювати відстань).

Але що робити, якщо ми шукаємо справді великий список, thingsі ми очікуємо, що багато з них не варто розглядати?

Насправді існує дуже проста оптимізація:

def in_range_all_the_things(origin, range, things):
    range_sq = range**2
    for thing in things:
        dist_sq = (origin.x - thing.x) ** 2
        if dist_sq <= range_sq:
            dist_sq += (origin.y - thing.y) ** 2
            if dist_sq <= range_sq:
                dist_sq += (origin.z - thing.z) ** 2
                if dist_sq <= range_sq:
                    yield thing

Чи корисно це, буде залежати від розміру "речі".

def in_range_all_the_things(origin, range, things):
    range_sq = range**2
    if len(things) >= 4096:
        for thing in things:
            dist_sq = (origin.x - thing.x) ** 2
            if dist_sq <= range_sq:
                dist_sq += (origin.y - thing.y) ** 2
                if dist_sq <= range_sq:
                    dist_sq += (origin.z - thing.z) ** 2
                    if dist_sq <= range_sq:
                        yield thing
    elif len(things) > 32:
        for things in things:
            dist_sq = (origin.x - thing.x) ** 2
            if dist_sq <= range_sq:
                dist_sq += (origin.y - thing.y) ** 2 + (origin.z - thing.z) ** 2
                if dist_sq <= range_sq:
                    yield thing
    else:
        ... just calculate distance and range-check it ...

І ще раз, подумайте про отримання dist_sq. Нашим прикладом хот-догів стає:

# Chaining generators
info = in_range_with_dist_sq(origin, walking_distance, hotdog_stands)
info = (stand, dist_sq**0.5 for stand, dist_sq in info)
for stand, dist in info:
    print("%s %.2fm" % (stand, dist))

Ще один приклад цього способу вирішення проблеми :

def dist(x,y):   
    return numpy.sqrt(numpy.sum((x-y)**2))

a = numpy.array((xa,ya,za))
b = numpy.array((xb,yb,zb))
dist_a_b = dist(a,b)

Починаючи Python 3.8, mathмодуль безпосередньо забезпечує distфункцію, яка повертає евклідову відстань між двома точками (задані у вигляді кортежів або списків координат):

from math import dist

dist((1, 2, 6), (-2, 3, 2)) # 5.0990195135927845

А якщо ви працюєте зі списками:

dist([1, 2, 6], [-2, 3, 2]) # 5.0990195135927845

Це можна зробити наступним чином. Я не знаю, наскільки це швидко, але це не використання NumPy.

from math import sqrt
a = (1, 2, 3) # Data point 1
b = (4, 5, 6) # Data point 2
print sqrt(sum( (a - b)**2 for a, b in zip(a, b)))

Я знаходжу функцію «dist» у matplotlib.mlab, але не думаю, що це досить зручно.

Я розміщую це тут лише для довідки.

import numpy as np
import matplotlib as plt

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

# Distance between a and b
dis = plt.mlab.dist(a, b)

Мені подобається np.dot(крапковий продукт):

a = numpy.array((xa,ya,za))
b = numpy.array((xb,yb,zb))

distance = (np.dot(a-b,a-b))**.5

Гарний однолінійний:

dist = numpy.linalg.norm(a-b)

Однак якщо швидкість викликає занепокоєння, я рекомендую експериментувати на вашій машині. Я виявив, що використання mathбібліотеки sqrtз **оператором для квадрата набагато швидше на моїй машині, ніж однолінійне рішення NumPy.

Я провів свої тести за допомогою цієї простої програми:

#!/usr/bin/python
import math
import numpy
from random import uniform

def fastest_calc_dist(p1,p2):
    return math.sqrt((p2[0] - p1[0]) ** 2 +
                     (p2[1] - p1[1]) ** 2 +
                     (p2[2] - p1[2]) ** 2)

def math_calc_dist(p1,p2):
    return math.sqrt(math.pow((p2[0] - p1[0]), 2) +
                     math.pow((p2[1] - p1[1]), 2) +
                     math.pow((p2[2] - p1[2]), 2))

def numpy_calc_dist(p1,p2):
    return numpy.linalg.norm(numpy.array(p1)-numpy.array(p2))

TOTAL_LOCATIONS = 1000

p1 = dict()
p2 = dict()
for i in range(0, TOTAL_LOCATIONS):
    p1[i] = (uniform(0,1000),uniform(0,1000),uniform(0,1000))
    p2[i] = (uniform(0,1000),uniform(0,1000),uniform(0,1000))

total_dist = 0
for i in range(0, TOTAL_LOCATIONS):
    for j in range(0, TOTAL_LOCATIONS):
        dist = fastest_calc_dist(p1[i], p2[j]) #change this line for testing
        total_dist += dist

print total_dist

На моїй машині math_calc_distпрацює набагато швидше, ніж numpy_calc_dist: 1,5 секунди проти 23,5 секунди.

Щоб отримати відмірну різницю між мені, fastest_calc_distі math_calc_distмені довелося до TOTAL_LOCATIONS6000. Потім fastest_calc_distпотрібно ~ 50 секунд, а math_calc_distзаймає ~ 60 секунд.

Ви також можете експериментувати, numpy.sqrtі numpy.squareхоча обидва були повільнішими, ніж mathальтернативи на моїй машині.

Мої тести проводилися з Python 2.6.6.

Ви можете просто відняти вектори, а потім внутрішнєвиробити.

Наслідуючи ваш приклад,

a = numpy.array((xa, ya, za))
b = numpy.array((xb, yb, zb))

tmp = a - b
sum_squared = numpy.dot(tmp.T, tmp)
result = sqrt(sum_squared)

Маючи aта bвизначені ними, ви також можете використовувати:

distance = np.sqrt(np.sum((a-b)**2))

З Python 3.8 це дуже просто.

https://docs.python.org/3/library/math.html#math.dist

math.dist(p, q)

Поверніть евклідову відстань між двома точками p і q, кожна з яких є послідовністю (або ітерабельним) координат. Дві точки повинні мати однаковий вимір.

Приблизно еквівалентний:

sqrt(sum((px - qx) ** 2.0 for px, qx in zip(p, q)))

Ось декілька стислих кодів для евклідової відстані в Python із двома точками, представленими як списки в Python.

def distance(v1,v2): 
    return sum([(x-y)**2 for (x,y) in zip(v1,v2)])**(0.5)

З моменту Python 3.8

Оскільки Python 3.8, mathмодуль включає функцію math.dist().
Дивіться тут https://docs.python.org/3.8/library/math.html#math.dist .

math.dist (p1, p2)
Повернути евклідову відстань між двома точками p1 та p2, кожна з яких задана у вигляді послідовності (або ітерабельної) координат.

import math
print( math.dist( (0,0),   (1,1)   )) # sqrt(2) -> 1.4142
print( math.dist( (0,0,0), (1,1,1) )) # sqrt(3) -> 1.7321

Обчисліть евклідову відстань для багатовимірного простору:

 import math

 x = [1, 2, 6] 
 y = [-2, 3, 2]

 dist = math.sqrt(sum([(xi-yi)**2 for xi,yi in zip(x, y)]))
 5.0990195135927845

import numpy as np
from scipy.spatial import distance
input_arr = np.array([[0,3,0],[2,0,0],[0,1,3],[0,1,2],[-1,0,1],[1,1,1]]) 
test_case = np.array([0,0,0])
dst=[]
for i in range(0,6):
    temp = distance.euclidean(test_case,input_arr[i])
    dst.append(temp)
print(dst)

import math

dist = math.hypot(math.hypot(xa-xb, ya-yb), za-zb)

Ви можете легко використовувати формулу

distance = np.sqrt(np.sum(np.square(a-b)))

що насправді не що інше, як використання теореми Піфагора для обчислення відстані, додавши квадрати Δx, Δy і Δz і вкорінивши результат.

Знайдіть різницю двох матриць спочатку. Потім застосуйте мудрене множення елементів за допомогою команди множення numpy. Після цього знайдіть підсумовування елемента, мудро помноживши нову матрицю. Нарешті, знайдіть квадратний корінь підсумовування.

def findEuclideanDistance(a, b):
    euclidean_distance = a - b
    euclidean_distance = np.sum(np.multiply(euclidean_distance, euclidean_distance))
    euclidean_distance = np.sqrt(euclidean_distance)
    return euclidean_distance

import numpy as np
# any two python array as two points
a = [0, 0]
b = [3, 4]

Ви перший список змін в Numpy масив і зробити так: print(np.linalg.norm(np.array(a) - np.array(b))). Другий метод безпосередньо зі списку python як:print(np.linalg.norm(np.subtract(a,b)))