Comment calculer la distance euclidienne avec NumPy?

J'ai deux points en 3D:

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

Et je veux calculer la distance:

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

Quelle est la meilleure façon de le faire avec NumPy, ou avec Python en général? J'ai:

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

Utilisation numpy.linalg.norm:

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

Vous pouvez trouver la théorie derrière cela dans Introduction to Data Mining

Cela fonctionne car la distance euclidienne est la norme l2 et la valeur par défaut du paramètre ord dans numpy.linalg.norm est 2.

Il y a une fonction pour cela dans SciPy. Cela s'appelle euclidien .

Exemple:

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

Pour tous ceux qui souhaitent calculer plusieurs distances à la fois, j'ai fait une petite comparaison en utilisant perfplot (un petit projet à moi).

Le premier conseil est d'organiser vos données de manière à ce que les tableaux aient une dimension (3, n)(et soient évidemment contigus en C). Si l'ajout se produit dans la première dimension contiguë, les choses sont plus rapides et peu importe si vous utilisez sqrt-sumavec axis=0, linalg.normavec axis=0ou

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

qui est, par une légère marge, la variante la plus rapide. (Cela vaut également pour une seule ligne.)

Les variantes où vous résumez le deuxième axe axis=1, sont toutes beaucoup plus lentes.

Code pour reproduire l'intrigue:

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)",
)

Je veux exposer la réponse simple avec diverses notes de performance. np.linalg.norm fera peut-être plus que ce dont vous avez besoin:

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

Premièrement - cette fonction est conçue pour travailler sur une liste et renvoyer toutes les valeurs, par exemple pour comparer la distance de pAà l'ensemble de points sP:

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

Rappelez-vous plusieurs choses:

• Les appels de fonction Python sont chers.
• [Normal] Python ne met pas en cache les recherches de nom.

Donc

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

n'est pas aussi innocent qu'il n'y paraît.

>>> 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

Premièrement - chaque fois que nous l'appelons, nous devons faire une recherche globale pour "np", une recherche de portée pour "linalg" et une recherche de portée pour "norm", et la surcharge de simplement appeler la fonction peut correspondre à des dizaines de python instructions.

Enfin, nous avons gaspillé deux opérations pour stocker le résultat et le recharger pour le retour ...

Première passe à l'amélioration: accélérer la recherche, sauter le magasin

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

Nous obtenons le beaucoup plus rationalisé:

>>> 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

Cependant, la surcharge de l'appel de fonction représente encore un peu de travail. Et vous voudrez faire des repères pour déterminer si vous feriez mieux de faire les calculs vous-même:

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

Sur certaines plateformes, **0.5est plus rapide que math.sqrt. Votre kilométrage peut varier.

**** Notes de performance avancées.

Pourquoi calculez-vous la distance? Si le seul but est de l'afficher,

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

avancer. Mais si vous comparez des distances, effectuez des vérifications de portée, etc., j'aimerais ajouter quelques observations utiles sur les performances.

Prenons deux cas: tri par distance ou élimination d'une liste des éléments qui répondent à une contrainte de plage.

# 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)

La première chose dont nous devons nous souvenir est que nous utilisons Pythagore pour calculer la distance ( dist = sqrt(x^2 + y^2 + z^2)), donc nous faisons beaucoup d' sqrtappels. Math 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

En bref: jusqu'à ce que nous ayons réellement besoin de la distance dans une unité de X plutôt que X ^ 2, nous pouvons éliminer la partie la plus difficile des calculs.

# 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)

Génial, les deux fonctions ne font plus de racines carrées coûteuses. Ce sera beaucoup plus rapide. Nous pouvons également améliorer in_range en le convertissant en générateur:

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

Cela a surtout des avantages si vous faites quelque chose comme:

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

Mais si la prochaine chose que vous allez faire nécessite une distance,

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

pensez à donner des tuples:

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)

Cela peut être particulièrement utile si vous pouvez enchaîner des vérifications de plage (`` trouver des choses qui sont proches de X et à Nm de Y '', car vous n'avez pas à calculer à nouveau la distance).

Mais qu'en est-il si nous recherchons une très grande liste thingset que nous prévoyons que beaucoup d'entre eux ne méritent pas d'être pris en considération?

Il y a en fait une optimisation très simple:

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

Son utilité dépendra de la taille des «choses».

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 ...

Et encore une fois, envisagez de fournir le dist_sq. Notre exemple de hot-dog devient alors:

# 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))

Un autre exemple de cette méthode de résolution de problèmes :

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)

En commençant Python 3.8, le mathmodule fournit directement la distfonction, qui retourne la distance euclidienne entre deux points (donnée sous forme de tuples ou de listes de coordonnées):

from math import dist

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

Et si vous travaillez avec des listes:

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

Cela peut être fait comme suit. Je ne sais pas à quelle vitesse c'est, mais il n'utilise pas 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)))

Je trouve une fonction 'dist' dans matplotlib.mlab, mais je ne pense pas que ce soit assez pratique.

Je le poste ici juste pour référence.

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)

J'aime np.dot(produit scalaire):

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

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

Une belle doublure:

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

Cependant, si la vitesse est un problème, je recommanderais d'expérimenter sur votre machine. J'ai trouvé que l'utilisation de la mathbibliothèque sqrtavec l' **opérateur pour le carré est beaucoup plus rapide sur ma machine que la solution NumPy à une ligne.

J'ai exécuté mes tests en utilisant ce programme simple:

#!/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

Sur ma machine, math_calc_disttourne beaucoup plus vite que numpy_calc_dist: 1,5 seconde contre 23,5 secondes.

Pour obtenir une différence mesurable entre fastest_calc_distet math_calc_distj'ai dû jusqu'à TOTAL_LOCATIONS6000. Prend ensuite fastest_calc_dist~ 50 secondes tandis que math_calc_distprend ~ 60 secondes.

Vous pouvez également expérimenter avec numpy.sqrtet numpy.squarebien que les deux soient plus lents que les mathalternatives sur ma machine.

Mes tests ont été exécutés avec Python 2.6.6.

Vous pouvez simplement soustraire les vecteurs puis le produit interne.

En suivant votre exemple,

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)

Ayant aet bcomme vous les avez définis, vous pouvez également utiliser:

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

Avec Python 3.8, c'est très simple.

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

math.dist(p, q)

Renvoie la distance euclidienne entre deux points p et q, chacun étant donné comme une séquence (ou itérable) de coordonnées. Les deux points doivent avoir la même dimension.

À peu près équivalent à:

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

Voici un code concis pour la distance euclidienne en Python étant donné deux points représentés sous forme de listes en Python.

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

Depuis Python 3.8

Depuis Python 3.8, le mathmodule inclut la fonction math.dist().
Voir ici https://docs.python.org/3.8/library/math.html#math.dist .

math.dist (p1, p2)
Retourne la distance euclidienne entre deux points p1 et p2, chacun étant donné comme une séquence (ou itérable) de coordonnées.

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

Calculez la distance euclidienne pour l'espace multidimensionnel:

 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)

Vous pouvez facilement utiliser la formule

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

ce qui ne fait en fait rien de plus que d'utiliser le théorème de Pythagore pour calculer la distance, en ajoutant les carrés de Δx, Δy et Δz et enracinant le résultat.

Trouvez d'abord la différence de deux matrices. Ensuite, appliquez la multiplication par élément avec la commande multiply de numpy. Après cela, trouvez la somme de la nouvelle matrice multipliée par élément. Enfin, trouvez la racine carrée de la sommation.

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]

Vous devez d' abord la liste des modifications à tableau numpy et faire comme ceci: print(np.linalg.norm(np.array(a) - np.array(b))). Deuxième méthode directement à partir de la liste python:print(np.linalg.norm(np.subtract(a,b)))