Bagaimana jarak Euclidean dapat dihitung dengan NumPy?

Saya memiliki dua poin dalam 3D:

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

Dan saya ingin menghitung jarak:

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

Apa cara terbaik untuk melakukan ini dengan NumPy, atau dengan Python secara umum? Saya sudah:

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

Gunakan numpy.linalg.norm:

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

Anda dapat menemukan teori di balik ini di Pengantar Penambangan Data

Ini berfungsi karena Euclidean distance adalah norma l2 dan nilai default parameter ord di numpy.linalg.norm adalah 2.

Ada fungsi untuk itu di SciPy. Ini disebut Euclidean .

Contoh:

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

Bagi siapa pun yang tertarik menghitung banyak jarak sekaligus, saya telah melakukan sedikit perbandingan menggunakan perfplot (proyek kecil saya).

Saran pertama adalah mengatur data Anda sedemikian rupa sehingga array memiliki dimensi (3, n)(dan jelas bersebelahan C). Jika menambahkan terjadi di dimensi pertama yang berdekatan, segala sesuatunya lebih cepat, dan tidak masalah jika Anda gunakan sqrt-sumdengan axis=0, linalg.normdengan axis=0, atau

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

yang, dengan sedikit perbedaan, varian tercepat. (Itu benar-benar berlaku hanya untuk satu baris juga.)

Varian di mana Anda meringkas pada sumbu kedua axis=1,, semuanya jauh lebih lambat.

Kode untuk mereproduksi plot:

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

Saya ingin menguraikan jawaban sederhana dengan berbagai catatan kinerja. np.linalg.norm mungkin akan melakukan lebih dari yang Anda butuhkan:

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

Pertama - fungsi ini dirancang untuk mengerjakan daftar dan mengembalikan semua nilai, misalnya untuk membandingkan jarak dari pAke set poin sP:

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

Ingat beberapa hal:

• Panggilan fungsi python mahal.
• [Biasa] Python tidak mencari nama cache.

Begitu

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

tidak sesugu kelihatannya.

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

Pertama - setiap kali kita menyebutnya, kita harus melakukan pencarian global untuk "np", pencarian lingkup untuk "linalg" dan pencarian lingkup untuk "norma", dan overhead hanya memanggil fungsi dapat menyamakan dengan puluhan python instruksi.

Terakhir, kami membuang dua operasi untuk menyimpan hasilnya dan memuatnya kembali ...

Pass pertama pada peningkatan: membuat pencarian lebih cepat, lewati toko

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

Kami mendapatkan yang lebih efisien:

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

Fungsi panggilan overhead masih sejumlah pekerjaan, meskipun. Dan Anda ingin melakukan tolok ukur untuk menentukan apakah Anda bisa melakukan sendiri matematika dengan lebih baik:

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

Pada beberapa platform, **0.5lebih cepat daripada math.sqrt. Jarak tempuh Anda mungkin beragam.

**** Catatan kinerja lanjutan.

Mengapa Anda menghitung jarak? Jika satu-satunya tujuan adalah untuk menampilkannya,

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

berjalan terus. Tetapi jika Anda membandingkan jarak, melakukan pemeriksaan jarak, dll., Saya ingin menambahkan beberapa pengamatan kinerja yang bermanfaat.

Mari kita ambil dua kasing: mengurutkan berdasarkan jarak atau memilah daftar item yang memenuhi batasan jangkauan.

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

Hal pertama yang perlu kita ingat adalah bahwa kita menggunakan Pythagoras untuk menghitung jarak ( dist = sqrt(x^2 + y^2 + z^2)) jadi kita membuat banyak sqrtpanggilan. Matematika 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

Singkatnya: sampai kita benar-benar membutuhkan jarak dalam satuan X daripada X ^ 2, kita dapat menghilangkan bagian tersulit dari perhitungan.

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

Hebat, kedua fungsi tidak lagi melakukan akar kuadrat mahal. Itu akan jauh lebih cepat. Kami juga dapat meningkatkan in_range dengan mengonversinya menjadi generator:

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

Ini terutama memiliki manfaat jika Anda melakukan sesuatu seperti:

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

Tetapi jika hal berikutnya yang akan Anda lakukan membutuhkan jarak,

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

pertimbangkan menghasilkan tupel:

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)

Ini bisa sangat berguna jika Anda dapat melakukan serangkaian cek ('temukan hal-hal yang mendekati X dan dalam Nm dari Y', karena Anda tidak perlu menghitung jarak lagi).

Tetapi bagaimana jika kita mencari daftar yang sangat besar thingsdan kita mengantisipasi banyak dari mereka tidak layak dipertimbangkan?

Sebenarnya ada optimasi yang sangat sederhana:

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

Apakah ini berguna akan tergantung pada ukuran 'barang'.

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

Dan lagi, pertimbangkan untuk menghasilkan dist_sq. Contoh hotdog kami kemudian menjadi:

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

Contoh lain dari metode pemecahan masalah ini :

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)

Dimulai Python 3.8, mathmodul secara langsung menyediakan distfungsi, yang mengembalikan jarak euclidean antara dua titik (diberikan sebagai tupel atau daftar koordinat):

from math import dist

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

Dan jika Anda bekerja dengan daftar:

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

Itu bisa dilakukan seperti berikut ini. Saya tidak tahu seberapa cepat itu, tetapi tidak menggunakan 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)))

Saya menemukan fungsi 'dist' di matplotlib.mlab, tapi saya rasa itu tidak cukup berguna.

Saya mempostingnya di sini hanya untuk referensi.

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)

Saya suka np.dot(produk titik):

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

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

Satu kalimat bagus:

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

Namun, jika kecepatan menjadi perhatian saya akan merekomendasikan bereksperimen pada mesin Anda. Saya telah menemukan bahwa menggunakan mathperpustakaan sqrtdengan** operator untuk kuadrat jauh lebih cepat pada mesin saya daripada solusi NumPy satu-liner.

Saya menjalankan tes saya menggunakan program sederhana ini:

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

Di komputer saya, math_calc_distberjalan lebih cepat daripadanumpy_calc_dist : 1,5 detik versus 23,5 detik.

Untuk mendapatkan perbedaan yang terukur antara fastest_calc_distdan math_calc_distsaya harus mencapai TOTAL_LOCATIONS6000. Kemudian fastest_calc_distbutuh ~ 50 detik sementaramath_calc_dist butuh ~ 60 detik.

Anda juga dapat bereksperimen dengan numpy.sqrtdan numpy.squaremeskipun keduanya lebih lambat darimath alternatif di mesin saya.

Tes saya dijalankan dengan Python 2.6.6.

Anda bisa mengurangi vektor dan kemudian produk dalam.

Mengikuti contoh Anda,

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)

Memiliki adan bseperti yang Anda tetapkan, Anda juga dapat menggunakan:

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

Dengan Python 3.8, ini sangat mudah.

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

math.dist(p, q)

Kembalikan jarak Euclidean antara dua titik p dan q, masing-masing diberikan sebagai urutan (atau iterable) koordinat. Kedua titik harus memiliki dimensi yang sama.

Setara dengan:

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

Berikut adalah beberapa kode ringkas untuk jarak Euclidean di Python yang diberikan dua titik yang direpresentasikan sebagai daftar dalam Python.

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

Sejak Python 3.8

Sejak Python 3.8 mathmodul ini menyertakan fungsi math.dist().
Lihat di sini https://docs.python.org/3.8/library/math.html#math.dist .

math.dist (p1, p2)
Kembalikan jarak Euclidean antara dua titik p1 dan p2, masing-masing diberikan sebagai urutan (atau iterable) dari koordinat.

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

Hitung jarak Euclidean untuk ruang multidimensi:

 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)

Anda dapat dengan mudah menggunakan formula

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

yang sebenarnya tidak lebih dari menggunakan teorema Pythagoras untuk menghitung jarak, dengan menambahkan kuadrat Δx, Δy dan Δz dan me-rooting hasilnya.

Cari perbedaan dua matriks terlebih dahulu. Kemudian, terapkan elemen multiplikasi bijak dengan perintah gandakan numpy. Setelah itu, cari penjumlahan dari elemen yang bijak dikalikan matriks baru. Akhirnya, temukan akar kuadrat dari penjumlahan.

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]

Anda berubah Daftar pertama yang array yang numpy dan melakukan seperti ini: print(np.linalg.norm(np.array(a) - np.array(b))). Metode kedua langsung dari daftar python sebagai:print(np.linalg.norm(np.subtract(a,b)))