如何使用NumPy计算欧几里得距离?


529

我在3D中有两点:

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

我想计算距离:

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

使用NumPy或一般使用Python的最佳方法是什么?我有:

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

Answers:


883

用途numpy.linalg.norm

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

您可以在“数据挖掘导论”中找到其背后的理论

这是有效的,因为欧几里得距离l2范数,并且numpy.linalg.norm 中ord参数的默认值为2。

enter image description here


13
linalg.norm文档可在以下位置找到:docs.scipy.org/doc/numpy/reference/generated/… 我唯一真正的评论是指出一种规范之间的联系(在本例中为Frobenius norm / 2-norm这是范数函数的默认值)和指标(在本例中为欧几里得距离)。
Mark Lavin

7
如果OP要计算坐标数组之间的距离,则还可以使用scipy.spatial.distance.cdist
mnky9800n

2
我的问题是:为什么要与此相反使用?stackoverflow.com/a/21986532/189411 来自scipy.spatial导入距离a =(1,2,3)b =(4,5,6)dst = distance.euclidean(a,b)
Domenico摩纳哥


还有更更快的方法比numpy.linalg.norm: semantive.com/blog/...
穆罕默德·阿什法克

161

SciPy中有一个功能。称为欧几里得

例:

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

56
如果您想提高效率,最好使用numpy函数。scipy距离是numpy.linalg.norm(ab)(和numpy.sqrt(numpy.sum((ab)** 2)))的两倍。在我的机器上,使用scipy(v0.15.1)获得19.7 µs,使用numpy(v1.9.2)获得8.9 µs。在许多情况下没有明显的区别,但是如果在循环中可能会变得更加重要。快速浏览scipy代码似乎比较慢,因为它在计算距离之前先验证了数组。
Algold

@MikePalmice是的,scipy函数与numpy完全兼容。但是,看看aigold在这里提出的建议(当然,它也适用于numpy数组)
Avision

@Avision不确定它是否对我有用,因为我的矩阵有不同的行数;试图减去它们以获得一个矩阵是行不通的
比约克斯排名第一的粉丝

@MikePalmice您到底想用这两个矩阵计算什么?预期的输入/输出是什么?
Avision

待跟进。这里有一个描述:stats.stackexchange.com/questions/322620/…。我有2个“操作”表;每个标签都有一个“代码”标签,但是两组标签完全不同。我的目标是从第二张表中找到与第一张表中的固定代码相对应的最佳或最接近的代码(我知道手动检查的答案应该是什么,但是以后希望扩展到数百张表)。因此,第一个子集是固定的;我计算出平均值和第二个的所有代码子集,然后排序
比约克斯排名第一的粉丝

108

对于有兴趣一次计算多个距离的任何人,我已经使用perfplot(我的一个小项目)进行了一些比较。

第一个建议是组织数据,使数组具有维(3, n)(并且显然是C连续的)。如果添加在连续的第一个维度发生,事情是更快,它没有太大的关系,如果您使用sqrt-sumaxis=0linalg.normaxis=0,或

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

这是最快的变体。(实际上也只适用于一行。)

您在第二个轴上进行汇总的变体axis=1都慢得多。

在此处输入图片说明


复制剧情的代码:

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

3
谢谢。我今天学到了新东西!对于一维数组,字符串将为i,i->
Tirtha R

4
如果对内存消耗进行比较,它会变得更加酷
dragonLOLz19年

我想使用您的代码,但是我在努力理解应该如何组织数据方面很费力。你能给个例子吗?data看起来如何?
约翰尼斯·威斯纳

1
真正整洁的项目和发现。我一直在做一些相同性质的半透视图,所以我想我会切换到您的项目并贡献差异,如果您喜欢的话。
疯狂物理学家

42

我想用各种性能说明来解释简单答案。np.linalg.norm可能会做比您需要的更多的工作:

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

首先-该功能的目的是工作在一个列表,并返回所有的值,例如到距离比较pA的点的集合sP

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

记住几件事:

  • Python函数调用非常昂贵。
  • [常规] Python不缓存名称查找。

所以

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

没有看起来那么天真。

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

首先,每次调用时,我们都必须对“ np”进行全局查找,对“ linalg”进行有范围的查找,对“ norm”进行有范围的查找,以及仅调用的开销该函数就相当于数十个python。说明。

最后,我们浪费了两个操作来存储结果并重新加载以返回结果...

改进的第一步:加快查找速度,跳过商店

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

我们得到了更加简化:

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

但是,函数调用开销仍然需要完成一些工作。而且,您需要进行基准测试以确定您自己做数学是否会更好:

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

在某些平台上,**0.5速度比math.sqrt。你的旅费可能会改变。

****高级性能说明。

为什么要计算距离?如果唯一的目的是显示它,

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

向前走。但是,如果您要比较距离,进行范围检查等,我想添加一些有用的性能观察。

让我们采取两种情况:按距离排序或将列表筛选为满足范围约束的项目。

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

我们需要记住的第一件事是我们正在使用毕达哥拉斯来计算距离(dist = sqrt(x^2 + y^2 + z^2)),因此我们进行了很多sqrt通话。数学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

简而言之:直到我们实际需要以X而不是X ^ 2为单位的距离,我们才能消除计算中最困难的部分。

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

太好了,这两个函数不再需要任何昂贵的平方根。这样会更快。我们还可以通过将in_range转换为生成器来改进它:

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

如果您正在执行以下操作,则这尤其有好处:

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

但是,如果接下来要做的事情需要一段距离,

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

考虑产生元组:

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)

如果您可以进行范围检查(“找到在X附近且在Y Nm之内的东西”,因为您不必再​​次计算距离),这将特别有用。

但是,如果我们要搜索的清单很大,那things又有很多不值得考虑的地方怎么办?

实际上有一个非常简单的优化:

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

这是否有用将取决于“事物”的大小。

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

再次考虑产生dist_sq。然后我们的热狗示例变为:

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

1
为什么不向numpy添加这样的优化函数呢?大熊猫的扩展也将像这样的问题是巨大的stackoverflow.com/questions/47643952/...
基斯

3
我编辑了您关于距离的第一个数学方法。您使用的pointZ是不存在的。我认为您的意思是在三维空间中有两个点,因此我进行了相应的编辑。如果我错了,请告诉我。
Bram Vanroy

37

此问题解决方法的另一个实例:

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)

1
您可以使用numpy的sqrt和/或sum实现吗?那应该使其更快(?)。
u0b34a0f6ae

1
我在互连网的另一端找到了它norm = lambda x: N.sqrt(N.square(x).sum()); norm(x-y)
u0b34a0f6ae

2
刮一下。它必须在某个地方。这是:numpy.linalg.norm(x-y)
u0b34a0f6ae

13

从开始Python 3.8math模块直接提供dist函数,该函数返回两点之间的欧几里得距离(以元组或坐标列表形式给出):

from math import dist

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

如果您正在使用列表:

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

12

可以像下面这样完成。我不知道它有多快,但是它没有使用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)))

直接在python中进行数学运算不是一个好主意,因为python非常慢,特别是for a, b in zip(a, b)。但是仍然有用。
Sigex,

10

我在matplotlib.mlab中找到了一个“ dist”函数,但我认为它并不方便。

我将其发布在这里仅供参考。

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)

这不再适用。(mpl 3.0)
NicoSchlömer'19

8

我喜欢np.dot(点积):

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

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

8

一个不错的单线:

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

但是,如果需要考虑速度,建议您在计算机上进行实验。我发现在我的机器上使用带有操作符的平方math函数库比单行NumPy解决方案快得多。sqrt**

我使用以下简单程序运行了测试:

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

在我的机器上,math_calc_dist运行速度比numpy_calc_dist:1.5秒和23.5秒。

为了获得与之间的可测量差异fastest_calc_distmath_calc_dist我必须达到TOTAL_LOCATIONS6000。然后fastest_calc_dist花费〜50 秒,而math_calc_dist花费〜60秒。

您也可以尝试用numpy.sqrtnumpy.square,虽然均高于较慢math我的机器上的替代品。

我的测试是使用Python 2.6.6运行的。


48
您严重误解了如何使用numpy ... 不要使用循环或列表推导。如果您要遍历并将函数应用于每个项目,那么是的,numpy函数会比较慢。重点是对事物进行矢量化处理。
乔·肯顿2010年

如果我将numpy.array调用移到创建点的循环中,使用numpy_calc_dist确实可以获得更好的结果,但它仍然比fastest_calc_dist慢10倍。如果我有那么多点,并且我需要找出每对之间的距离,那么我不确定还能采取什么措施来使numpy受益。
user118662

15
我知道这个线程很旧,但是我只是想强化乔所说的话。您没有正确使用numpy。您正在计算的是从p1中的每个点到p2中的每个点的距离之和。使用numpy / scipy的解决方案在我的计算机上的速度要快70倍以上。将p1和p2放入一个数组(如果将它们定义为dict,即使使用循环也是如此)。然后,您可以一步获得总和scipy.spatial.distance.cdist(p1, p2).sum()。这就对了。
Scott B

3
或用于numpy.linalg.norm(p1-p2).sum()获取p1中每个点与p2中相应点之间的总和(即,不是p1中的每个点到p2中的每个点)。而且,如果您确实希望将p1中的每个点都指向p2中的每个点,并且不想像我之前的评论一样使用scipy,则可以将np.apply_along_axis和numpy.linalg.norm一起使用,以更快,更快速地完成此任务。那么您的“最快”解决方案。
Scott B

2
以前版本的NumPy的规范实施速度非常慢。在当前版本中,不需要所有这些。
Fred Foo

8

您可以先减去向量,然后减去内积。

按照您的示例,

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)

5
这将给我距离的平方。您在这里错过了sqrt。
内森·费尔曼


6

使用Python 3.8,这非常容易。

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

math.dist(p, q)

返回两个点p和q之间的欧几里得距离,每个点以坐标序列(或可迭代)给出。这两个点必须具有相同的尺寸。

大致相当于:

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


5

这是一些Python中的欧几里得距离的简洁代码,给出了用Python列表表示的两个点。

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

1
Numpy还接受列表作为输入(无需显式传递numpy数组)
Alejandro Sazo

4

从python 3.8开始

从Python 3.8开始,该math模块包含函数math.dist()
请参阅https://docs.python.org/3.8/library/math.html#math.dist

math.dist(p1,p2)
返回两个点p1和p2之间的欧几里得距离,每个点均以坐标序列(或可迭代)给出。

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

3

计算多维空间的欧几里得距离:

 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

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)

2
这个答案有什么区别?
xskxzr



1

首先找到两个矩阵的差。然后,使用numpy的乘法命令应用逐元素乘法。之后,找到逐元素相乘的新矩阵的总和。最后,找到求和的平方根。

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

1
import numpy as np
# any two python array as two points
a = [0, 0]
b = [3, 4]

您首先将列表更改为numpy array并执行以下操作:print(np.linalg.norm(np.array(a) - np.array(b)))。直接从python列表中获取的第二种方法为:print(np.linalg.norm(np.subtract(a,b)))

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.