Làm thế nào có thể tính khoảng cách Euclide với NumPy?

Tôi có hai điểm trong 3D:

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

Và tôi muốn tính khoảng cách:

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

Cách tốt nhất để làm điều này với NumPy hoặc với Python nói chung là gì? Tôi có:

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

Sử dụng numpy.linalg.norm:

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

Bạn có thể tìm thấy lý thuyết đằng sau điều này trong Giới thiệu về Khai thác dữ liệu

Điều này hoạt động vì khoảng cách Euclide là định mức l2 và giá trị mặc định của tham số ord trong numpy.linalg.norm là 2.

Có một chức năng cho điều đó trong SciPy. Nó được gọi là Euclide .

Thí dụ:

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

Đối với bất kỳ ai quan tâm đến việc tính toán nhiều khoảng cách cùng một lúc, tôi đã thực hiện một so sánh nhỏ bằng cách sử dụng perfplot (một dự án nhỏ của tôi).

Lời khuyên đầu tiên là tổ chức dữ liệu của bạn sao cho các mảng có thứ nguyên (3, n)(và rõ ràng là tiếp giáp C). Nếu việc thêm xảy ra ở chiều thứ nhất liền kề, mọi thứ sẽ nhanh hơn và không quá quan trọng nếu bạn sử dụng sqrt-sumvới axis=0, linalg.normvới axis=0, hoặc

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

đó là, bởi một biên độ nhỏ, biến thể nhanh nhất. (Điều đó thực sự đúng cho chỉ một hàng là tốt.)

Các biến thể nơi bạn tổng hợp trên trục thứ hai axis=1, tất cả đều chậm hơn.

Mã để tái tạo cốt truyện:

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

Tôi muốn giải thích về câu trả lời đơn giản với các ghi chú hiệu suất khác nhau. np.linalg.norm sẽ làm nhiều hơn bạn cần:

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

Thứ nhất - chức năng này được thiết kế để hoạt động trên một danh sách và trả về tất cả các giá trị, ví dụ để so sánh khoảng cách từ pAđến tập hợp các điểm sP:

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

Ghi nhớ một số điều:

• Các cuộc gọi hàm Python rất tốn kém.
• [Thường xuyên] Python không tra cứu tên bộ đệm.

Vì thế

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

không ngây thơ như vẻ ngoài của nó

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

Đầu tiên - mỗi khi chúng ta gọi nó, chúng ta phải thực hiện tra cứu toàn cầu cho "np", một tìm kiếm có phạm vi cho "linalg" và một tìm kiếm có phạm vi cho "định mức" và chi phí đơn giản là gọi hàm có thể tương đương với hàng chục con trăn hướng dẫn.

Cuối cùng, chúng tôi đã lãng phí hai thao tác để lưu trữ kết quả và tải lại để trả lại ...

Vượt qua đầu tiên ở cải tiến: làm cho việc tra cứu nhanh hơn, bỏ qua cửa hàng

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

Chúng tôi nhận được sắp xếp hợp lý hơn nhiều:

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

Tuy nhiên, chức năng gọi qua chức năng vẫn lên tới một số công việc. Và bạn sẽ muốn làm điểm chuẩn để xác định xem bạn có thể tự mình làm toán tốt hơn không:

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

Trên một số nền tảng, **0.5là nhanh hơn math.sqrt. Số dặm của bạn có thể thay đổi.

**** Ghi chú hiệu suất nâng cao.

Tại sao bạn tính khoảng cách? Nếu mục đích duy nhất là hiển thị nó,

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

di chuyển dọc. Nhưng nếu bạn đang so sánh khoảng cách, thực hiện kiểm tra phạm vi, v.v., tôi muốn thêm một số quan sát hiệu suất hữu ích.

Chúng ta hãy thực hiện hai trường hợp: sắp xếp theo khoảng cách hoặc loại bỏ danh sách thành các mục đáp ứng ràng buộc phạm vi.

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

Điều đầu tiên chúng ta cần nhớ là chúng ta đang sử dụng Pythagoras để tính khoảng cách ( dist = sqrt(x^2 + y^2 + z^2)) vì vậy chúng ta đang thực hiện rất nhiều sqrtcuộc gọi. Toán 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

Tóm lại: cho đến khi chúng tôi thực sự yêu cầu khoảng cách trong một đơn vị X chứ không phải X ^ 2, chúng tôi có thể loại bỏ phần khó nhất trong các phép tính.

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

Tuyệt vời, cả hai chức năng không còn làm bất kỳ căn bậc hai đắt tiền. Điều đó sẽ nhanh hơn nhiều. Chúng tôi cũng có thể cải thiện in_range bằng cách chuyển đổi nó thành trình tạo:

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

Điều này đặc biệt có lợi ích nếu bạn đang làm một cái gì đó như:

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

Nhưng nếu điều tiếp theo bạn sẽ làm đòi hỏi một khoảng cách,

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

xem xét năng suất bộ:

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)

Điều này có thể đặc biệt hữu ích nếu bạn có thể kiểm tra phạm vi chuỗi ('tìm những thứ ở gần X và trong Nm của Y', vì bạn không phải tính lại khoảng cách).

Nhưng nếu chúng ta đang tìm kiếm một danh sách thực sự lớn thingsvà chúng ta dự đoán rất nhiều trong số chúng không đáng để xem xét thì sao?

Thực sự có một tối ưu hóa rất đơn giản:

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

Điều này có hữu ích hay không sẽ phụ thuộc vào kích thước của 'vật'.

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

Và một lần nữa, hãy xem xét mang lại dist_sq. Ví dụ hotdog của chúng tôi sau đó trở thành:

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

Một ví dụ khác của phương pháp giải quyết vấn đề này :

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)

Bắt đầu Python 3.8, mathmô-đun trực tiếp cung cấp disthàm, trả về khoảng cách euclide giữa hai điểm (được đưa ra dưới dạng bộ hoặc danh sách tọa độ):

from math import dist

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

Và nếu bạn đang làm việc với danh sách:

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

Nó có thể được thực hiện như sau. Tôi không biết nó nhanh như thế nào, nhưng nó không sử dụng 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)))

Tôi tìm thấy chức năng 'dist' trong matplotlib.mlab, nhưng tôi không nghĩ nó đủ tiện dụng.

Tôi đang đăng nó ở đây chỉ để tham khảo.

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)

Tôi thích np.dot(chấm sản phẩm):

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

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

Một lớp lót đẹp:

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

Tuy nhiên, nếu tốc độ là mối quan tâm tôi sẽ khuyên bạn nên thử nghiệm trên máy của mình. Tôi đã thấy rằng việc sử dụng maththư viện sqrtvới **toán tử cho hình vuông trên máy của tôi nhanh hơn nhiều so với giải pháp NumPy một lớp.

Tôi đã chạy thử nghiệm bằng chương trình đơn giản này:

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

Trên máy của tôi, math_calc_distchạy nhanh hơn nhiều numpy_calc_dist: 1,5 giây so với 23,5 giây.

Để có được sự khác biệt có thể đo được giữa fastest_calc_distvà math_calc_disttôi đã phải lên TOTAL_LOCATIONStới 6000. Sau đó fastest_calc_distmất ~ 50 giây trong khi math_calc_distmất ~ 60 giây.

Bạn cũng có thể thử nghiệm numpy.sqrtvà numpy.squaremặc dù cả hai đều chậm hơn các mathlựa chọn thay thế trên máy của tôi.

Các thử nghiệm của tôi đã được chạy với Python 2.6.6.

Bạn chỉ có thể trừ các vectơ và sau đó sản phẩm bên trong.

Theo gương của bạn,

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)

Có avà bnhư bạn đã xác định chúng, bạn cũng có thể sử dụng:

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

Với Python 3.8, nó rất dễ dàng.

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

math.dist(p, q)

Trả về khoảng cách Euclide giữa hai điểm p và q, mỗi điểm được đưa ra dưới dạng một chuỗi (hoặc có thể lặp lại) của tọa độ. Hai điểm phải có cùng chiều.

Khá tương đương với:

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

Đây là một số mã ngắn gọn cho khoảng cách Euclide trong Python với hai điểm được biểu thị dưới dạng danh sách trong Python.

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

Kể từ Python 3,8

Vì Python 3.8, mathmô-đun bao gồm hàm math.dist().
Xem tại đây https://docs.python.org/3.8/l Library / math.html # math.dist .

math.dist (p1, p2)
Trả về khoảng cách Euclide giữa hai điểm p1 và p2, mỗi điểm được đưa ra dưới dạng một chuỗi (hoặc có thể lặp lại) của tọa độ.

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

Tính khoảng cách Euclide cho không gian đa chiều:

 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)

Bạn có thể dễ dàng sử dụng công thức

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

điều này thực sự không có gì khác hơn là sử dụng định lý của Pythagoras để tính khoảng cách, bằng cách thêm các bình phương Δx, y và Δz và root kết quả.

Tìm sự khác biệt của hai ma trận đầu tiên. Sau đó, áp dụng phép nhân phần tử khôn ngoan với lệnh nhân của numpy. Sau đó, tìm tổng của phần tử ma trận mới nhân lên. Cuối cùng, tìm căn bậc hai của tổng.

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]

Trước tiên, bạn thay đổi danh sách thành mảng numpy và làm như thế này : print(np.linalg.norm(np.array(a) - np.array(b))). Phương pháp thứ hai trực tiếp từ danh sách python như:print(np.linalg.norm(np.subtract(a,b)))