Bagaimana jarak Euclidean dapat dihitung dengan NumPy?

529

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))
Nathan Fellman
sumber

Jawaban:

885

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.

masukkan deskripsi gambar di sini

u0b34a0f6ae
sumber
13
Dokumen linalg.norm dapat ditemukan di sini: docs.scipy.org/doc/numpy/reference/generated/... Satu-satunya komentar saya yang sebenarnya adalah menunjukkan hubungan antara suatu norma (dalam hal ini norma Frobenius / 2-norma yang merupakan default untuk fungsi norma) dan metrik (dalam hal ini jarak Euclidean).
Mark Lavin
7
Jika OP ingin menghitung jarak antara array koordinat juga dimungkinkan untuk menggunakan scipy.spatial.distance.cdist .
mnky9800n
2
pertanyaan saya adalah: mengapa menggunakan ini berlawanan dengan ini? stackoverflow.com/a/21986532/189411 dari scipy.spatial import distance a = (1,2,3) b = (4,5,6) dst = distance.euclidean (a, b)
Domenico Monaco
2
tautan yang diperbarui ke fungsi cdist SciPy: docs.scipy.org/doc/scipy/reference/generated/…
Steven C. Howell
bahkan ada metode yang lebih cepat daripada numpy.linalg.norm: semantive.com/blog/…
Muhammad Ashfaq
161

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)
Sebuah visi
sumber
56
Jika Anda mencari efisiensi, lebih baik menggunakan fungsi numpy. Jarak scipy dua kali lebih lambat dari numpy.linalg.norm (ab) (dan numpy.sqrt (numpy.sum ((ab) ** 2)))). Di mesin saya, saya mendapatkan 19,7 μs dengan scipy (v0.15.1) dan 8,9 μs dengan numpy (v1.9.2). Bukan perbedaan yang relevan dalam banyak kasus tetapi jika dalam lingkaran dapat menjadi lebih signifikan. Dari pandangan sekilas pada kode scipy, nampaknya lebih lambat karena memvalidasi array sebelum menghitung jarak.
Algold
@MikePalmice ya, fungsi-fungsi aneh sepenuhnya kompatibel dengan numpy. Tapi lihat apa yang disarankan aigold di sini (yang juga bekerja pada array numpy, tentu saja)
Avision
@Avision tidak yakin apakah itu akan bekerja untuk saya karena matriks saya memiliki jumlah baris yang berbeda; mencoba mengurangi mereka untuk mendapatkan satu matriks tidak bekerja
penggemar Bjorks nomor satu
@ MikePalmice apa sebenarnya yang Anda coba hitung dengan dua matriks ini? apa input / output yang diharapkan?
Avision
untuk tindak lanjut. Ada deskripsi di sini: stats.stackexchange.com/questions/322620/… . Saya memiliki 2 tabel 'operasi'; masing-masing memiliki label 'kode', tetapi dua set label sama sekali berbeda. tujuan saya adalah untuk menemukan kode terbaik atau terdekat dari tabel kedua yang sesuai dengan kode tetap di yang pertama (saya tahu apa jawabannya dari inspeksi manual, tetapi ingin skala hingga ratusan tabel nanti). Jadi subset pertama diperbaiki; Saya menghitung rata-rata dari ini dan semua himpunan bagian kode ke-2, lalu urutkan
Penggemar nomor satu Bjorks
108

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.

masukkan deskripsi gambar di sini


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)",
)
Nico Schlömer
sumber
3
Terima kasih. Saya belajar sesuatu yang baru hari ini! Untuk array dimensi tunggal, string akan menjadii,i->
Tirtha R
4
itu akan menjadi lebih keren jika ada perbandingan konsumsi memori
dragonLOLz
Saya ingin menggunakan kode Anda, tetapi saya kesulitan memahami bagaimana data seharusnya diatur. Bisakah Anda memberi contoh? Bagaimana dataharus terlihat seperti?
Johannes Wiesner
1
Proyek dan temuannya sangat rapi. Saya sudah melakukan beberapa plot setengah jadi dengan sifat yang sama, jadi saya pikir saya akan beralih ke proyek Anda dan berkontribusi perbedaan, jika Anda suka mereka.
Fisikawan Gila
42

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))
kfsone
sumber
1
Mengapa tidak menambahkan fungsi yang dioptimalkan untuk numpy? Perpanjangan untuk panda juga akan bagus untuk pertanyaan seperti ini stackoverflow.com/questions/47643952/…
Keith
3
Saya mengedit pendekatan matematika pertama Anda untuk jarak. Anda menggunakan pointZyang tidak ada. Saya pikir yang Anda maksud adalah dua titik dalam ruang tiga dimensi dan saya mengeditnya. Jika saya salah, tolong beri tahu saya.
Bram Vanroy
37

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)
Nathan Fellman
sumber
1
dapatkah Anda menggunakan implementasi sqrt dan / atau jumlah numpy? Itu harus membuatnya lebih cepat (?).
u0b34a0f6ae
1
Saya menemukan ini di sisi lain dari jalinan norm = lambda x: N.sqrt(N.square(x).sum()); norm(x-y)
u0b34a0f6ae
2
goreskan itu. itu pasti ada di suatu tempat. ini dia:numpy.linalg.norm(x-y)
u0b34a0f6ae
13

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
Xavier Guihot
sumber
12

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)))
Demz
sumber
Melakukan matematika langsung dengan python bukanlah ide yang baik karena python sangat lambat, khususnya for a, b in zip(a, b). Tapi tidak ada yang berguna.
Sigex
10

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)
Alan Wang
sumber
Ini tidak berlaku lagi. (mpl 3.0)
Nico Schlömer
8

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
travelingbones
sumber
8

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.

pengguna118662
sumber
48
Anda salah paham bagaimana menggunakan numpy ... Jangan gunakan loop atau daftar pemahaman. Jika Anda mengulanginya, dan menerapkan fungsi ke setiap item, maka, ya, fungsi numpy akan lebih lambat. Intinya adalah untuk membuat vektor hal-hal.
Joe Kington
Jika saya memindahkan panggilan numpy.array ke loop di mana saya membuat poin, saya mendapatkan hasil yang lebih baik dengan numpy_calc_dist, tetapi masih 10x lebih lambat daripada tercepat_calc_dist. Jika saya memiliki banyak poin dan saya perlu menemukan jarak antara masing-masing pasangan, saya tidak yakin apa lagi yang bisa saya lakukan untuk mendapatkan keuntungan yang numpy.
user118662
15
Saya menyadari bahwa utas ini sudah tua, tetapi saya hanya ingin memperkuat apa yang dikatakan Joe. Anda tidak menggunakan numpy dengan benar. Apa yang Anda hitung adalah jumlah jarak dari setiap titik di p1 ke setiap titik di p2. Solusi dengan numpy / scipy lebih dari 70 kali lebih cepat pada mesin saya. Buat p1 dan p2 ke dalam array (bahkan menggunakan loop jika Anda mendefinisikannya sebagai dicts). Maka Anda bisa mendapatkan jumlah total dalam satu langkah scipy.spatial.distance.cdist(p1, p2).sum(),. Hanya itu saja.
Scott B
3
Atau gunakan numpy.linalg.norm(p1-p2).sum()untuk mendapatkan jumlah antara setiap titik di p1 dan titik yang sesuai di p2 (yaitu tidak setiap titik di p1 ke setiap titik di p2). Dan jika Anda ingin setiap titik di p1 ke setiap titik di p2 dan tidak ingin menggunakan scipy seperti dalam komentar saya sebelumnya, maka Anda dapat menggunakan np.apply_along_axis bersama dengan numpy.linalg.norm untuk tetap melakukannya, jauh lebih cepat maka solusi "tercepat" Anda.
Scott B
2
NumPy versi sebelumnya memiliki implementasi norma yang sangat lambat. Dalam versi saat ini, tidak perlu untuk semua ini.
Fred Foo
8

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)
PuercoPop
sumber
5
ini akan memberi saya kuadrat jarak. Anda kehilangan sqrt di sini.
Nathan Fellman
6

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

distance = np.sqrt(np.sum((a-b)**2))
Alejandro Sazo
sumber
6

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

hakiko
sumber
5

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)
Andy Lee
sumber
1
Numpy juga menerima daftar sebagai input (tidak perlu secara eksplisit melewati array yang numpy)
Alejandro Sazo
4

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
ePi272314
sumber
3

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
Gennady Nikitin
sumber
2
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)
Ankur Nadda
sumber
2
Apa perbedaan dari jawaban ini ?
xskxzr
2
import math

dist = math.hypot(math.hypot(xa-xb, ya-yb), za-zb)
Jonas De Schouwer
sumber
2

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.

Jonas De Schouwer
sumber
1

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
johncasey
sumber
1
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)))

Uddhav Gautam
sumber