Öklid mesafesi NumPy ile nasıl hesaplanabilir?

3D'de iki puanım var:

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

Ve mesafeyi hesaplamak istiyorum:

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

NumPy veya genel olarak Python ile bunu yapmanın en iyi yolu nedir? Sahibim:

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

Kullanım numpy.linalg.norm:

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

Bunun arkasındaki teoriyi Veri Madenciliğine Giriş bölümünde bulabilirsiniz.

Bunun nedeni eserler Öklit mesafesi olan l2 normu ve varsayılan değeri Ord numpy.linalg.norm parametre 2'dir.

SciPy'de bunun bir işlevi var. Buna Öklid deniyor .

Misal:

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

Aynı anda birden fazla mesafeyi hesaplamak isteyen herkes için, perfplot (küçük bir proje) kullanarak küçük bir karşılaştırma yaptım .

İlk öneri, dizilerinizin boyutu olacak (3, n)(ve açıkça C-bitişik olacak şekilde) verilerinizi düzenlemektir . Ekleyerek bitişik birinci boyutta olursa, işler daha hızlı ve kullandığınız takdirde çok fazla önemli değil sqrt-sumile axis=0, linalg.normbirlikte axis=0veya

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

ki bu hafif bir farkla en hızlı değişkendir. (Bu aslında sadece bir satır için de geçerlidir.)

İkinci ekseni axis=1özetlediğiniz değişkenlerin hepsi oldukça yavaştır.

Grafiği yeniden oluşturmak için kod:

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

Çeşitli performans notları ile basit cevaba açıklamak istiyorum. np.linalg.norm belki de ihtiyacınız olandan daha fazlasını yapar:

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

İlk olarak - bu işlev bir liste üzerinde çalışmak ve tüm değerleri döndürmek için tasarlanmıştır, örneğin pAnokta kümesiyle arasındaki mesafeyi karşılaştırmak için sP:

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

Birkaç şeyi hatırlayın:

• Python işlev çağrıları pahalıdır.
• [Normal] Python ad aramalarını önbelleğe almaz.

Yani

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

göründüğü kadar masum değil.

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

İlk olarak - her dediğimizde, "np" için küresel bir arama, "linalg" için kapsamlı bir arama ve "norm" için kapsamlı bir arama yapmalıyız ve sadece işlevi çağırmanın yükü onlarca python'a eşit olabilir Talimatlar.

Son olarak, sonucu saklamak ve iade için yeniden yüklemek için iki işlem harcadık ...

İyileştirmede ilk geçiş: aramayı daha hızlı yapın, mağazayı atlayın

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

Çok daha akıcı hale getirdik:

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

Yine de, işlev çağrısı ek yükü hala bir iş anlamına gelir. Ve matematiği kendiniz daha iyi yapıp yapamayacağınızı belirlemek için kriterler yapmak istersiniz:

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

Bazı platformlarda, **0.5daha hızlıdır math.sqrt. Kilometreniz değişebilir.

**** Gelişmiş performans notları.

Neden mesafeyi hesaplıyorsunuz? Tek amaç bunu göstermekse,

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

hareket etmek. Ancak mesafeleri karşılaştırıyorsanız, aralık kontrolleri vb. Yapıyorsanız, bazı yararlı performans gözlemleri eklemek istiyorum.

İki durumu ele alalım: mesafeye göre sıralama veya bir menzil sınırlamasını karşılayan öğelere bir listeyi kaldırma.

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

Hatırlamamız gereken ilk şey , mesafeyi ( ) hesaplamak için Pisagor kullandığımızdır, bu dist = sqrt(x^2 + y^2 + z^2)yüzden çok fazla sqrtçağrı yapıyoruz . Matematik 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

Kısacası, aslında mesafeyi X ^ 2 yerine X biriminde gerektirene kadar, hesaplamaların en zor kısmını ortadan kaldırabiliriz.

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

Harika, her iki işlev de artık pahalı kare kökler yapmıyor. Çok daha hızlı olacak. Ayrıca in_range öğesini bir jeneratöre dönüştürerek de geliştirebiliriz:

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

Özellikle aşağıdaki gibi bir şey yapıyorsanız bunun faydaları vardır:

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

Ama yapacağınız bir sonraki şey bir mesafe gerektiriyorsa,

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

tuples vermeyi düşünün:

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)

Bu, özellikle aralık kontrollerini zincirleyebiliyorsanız ('X'in yakınında ve Y'nin Nm'si içinde olan şeyleri bul') yararlı olabilir, çünkü mesafeyi tekrar hesaplamanız gerekmez.

Peki, gerçekten büyük bir liste arıyoruz thingsve birçoğunun dikkate almaya değer olmadığını tahmin edersek ne olur ?

Aslında çok basit bir optimizasyon var:

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

Bunun faydalı olup olmadığı 'şeylerin' boyutuna bağlı olacaktır.

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

Ve yine, dist_sq vermeyi düşünün. Hotdog örneğimiz daha sonra:

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

Bu problem çözme yönteminin başka bir örneği :

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)

Başlangıç ​​olarak Python 3.8, mathmodül doğrudan distiki nokta arasındaki öklid mesafesini döndüren işlevi sağlar (tuples veya koordinat listeleri olarak verilir):

from math import dist

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

Ve listelerle çalışıyorsanız:

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

Aşağıdaki gibi yapılabilir. Ne kadar hızlı olduğunu bilmiyorum ama NumPy kullanmıyor.

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

Matplotlib.mlab'de 'dist' işlevi buluyorum, ancak bunun yeterince kullanışlı olduğunu düşünmüyorum.

Sadece referans için buraya gönderiyorum.

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)

Seviyorum np.dot(nokta ürün):

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

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

Güzel bir astar:

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

Ancak, hız bir sorunsa, makinenizde denemenizi tavsiye ederim. Kare için operatörle mathkütüphane kullanmanın makinemde tek astarlı NumPy çözümünden çok daha hızlı olduğunu gördüm.sqrt**

Testlerimi bu basit programı kullanarak çalıştırdım:

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

Makinemde şu math_calc_disthızdan çok daha hızlı çalışır numpy_calc_dist: 1,5 saniye ve 23,5 saniye.

Ölçülebilir bir fark elde etmek için fastest_calc_distve math_calc_distben TOTAL_LOCATIONS6000 kadar zorunda kaldı. Sonra fastest_calc_dist~ 50 saniye math_calc_distsürer ~ 60 saniye sürer.

Ayrıca her ikisini de benim makinemdeki alternatiflerden daha yavaş deneyebilir numpy.sqrtve deneyebilirsiniz .numpy.squaremath

Testlerim Python 2.6.6 ile yapıldı.

Sadece vektörleri ve sonra iç ürünü çıkarabilirsiniz.

Örneğinizin ardından,

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)

Onlara sahip olduğunuz ave btanımladığınız gibi şunları da kullanabilirsiniz:

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

Python 3.8 ile çok kolay.

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

math.dist(p, q)

Her biri koordinat dizisi (veya yinelenebilir) olarak verilen iki nokta p ve q arasındaki Öklid mesafesini döndürün. İki nokta aynı boyuta sahip olmalıdır.

Kabaca şuna eşit:

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

İşte Python'da liste olarak gösterilen iki nokta verilen Python'daki Öklid mesafesi için bazı özlü kod.

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

Python 3.8'den beri

Python 3.8'den beri mathmodül bu fonksiyonu içermektedir math.dist().
Bkz . Https://docs.python.org/3.8/library/math.html#math.dist .

math.dist (p1, p2)
Her biri koordinat dizisi (veya yinelenebilir) olarak verilen iki p1 ve p2 noktası arasındaki Öklid mesafesini döndürür.

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

Çok boyutlu uzay için Öklid mesafesini hesaplayın:

 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)

Formülü kolayca kullanabilirsiniz

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

aslında, ytx, Δy ve Δz karelerini ekleyerek ve sonucu köklendirerek mesafeyi hesaplamak için Pisagor teoremini kullanmaktan başka bir şey yapmaz.

İlk önce iki matris arasındaki farkı bulun. Ardından, numpy'nin multiply komutuyla eleman akıllıca çarpma uygulayın. Bundan sonra, akıllıca çarpılan yeni matrisin elemanının toplamını bulun. Son olarak, toplamın karekökünü bulun.

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]

Sen ilk değişiklik listesini numpy dizisi ve bunun gibi yapın: print(np.linalg.norm(np.array(a) - np.array(b))). Doğrudan python listesinden ikinci yöntem:print(np.linalg.norm(np.subtract(a,b)))