ユークリッド距離はどのようにしてNumPyで計算できますか？

3Dには2つのポイントがあります。

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

使用numpy.linalg.norm：

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

この背後にある理論は、Introduction to Data Miningにあります。

これは、ユークリッド距離がl2ノルムであり、numpy.linalg.norm のordパラメータのデフォルト値が2であるため機能します。

SciPyにはそのための関数があります。それはユークリッドと呼ばれています。

例：

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

一度に複数の距離を計算したい人のために、perfplot（私の小さなプロジェクト）を使用して少し比較しました。

最初のアドバイスは、配列が次元を持つように(3, n)（そして明らかにC隣接するように）データを編成することです。隣接する最初の次元で追加が発生する場合、処理は高速になり、sqrt-sumwith axis=0、linalg.normwith axis=0、またはを使用してもそれほど重要ではありません。

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

これは、わずかなマージンで、最速のバリアントです。（これは実際には1つの行にも当てはまります。）

2番目の軸で合計したバリアントは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)",
)

簡単な答えをさまざまなパフォーマンスノートで説明したいと思います。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に相当します。指示。

最後に、結果を保存してリロードして返すために、2つの操作を無駄にしました...

改善の最初のパス：ルックアップを高速化し、ストアをスキップします

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

一緒に移動。ただし、距離を比較したり、範囲チェックなどを行っている場合は、いくつかの有用なパフォーマンスの観察結果を追加したいと思います。

2つのケースを考えてみましょう：距離によるソート、または範囲制約を満たすアイテムへのリストの選別。

# 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 ^ 2ではなくXの単位で距離が必要になるまで、計算の最も難しい部分を排除できます。

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

この問題解決方法の別のインスタンス：

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)

から開始してPython 3.8、mathモジュールは直接dist関数を提供します。この関数は、2点間のタプルまたは座標のリストとして与えられるユークリッド距離を返します。

from math import dist

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

リストを操作している場合：

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

それは次のように行うことができます。私はそれがどれほど速いかわかりませんが、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)))

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)

私は好きですnp.dot（ドット製品）：

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

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

素敵なワンライナー：

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

私のマシンでは、1.5秒math_calc_distよりもnumpy_calc_dist23.5秒よりもはるかに速く実行されます。

間の測定可能な差異取得するfastest_calc_distとmath_calc_distIをアップしたTOTAL_LOCATIONS後〜6000 fastest_calc_distながら〜50秒かかりmath_calc_dist〜60秒かかります。

あなたはまたして試すことができますnumpy.sqrtし、numpy.square両方がより遅かったもののmath、私のマシン上での選択肢。

私のテストはPython 2.6.6で実行されました。

ベクトルを減算してからinnerproductを減算できます。

あなたの例に従って、

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)

持つaとbあなたがそれらを定義したとして、あなたも使用することができます。

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

Python 3.8では、非常に簡単です。

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

math.dist(p, q)

2つの点pとqの間のユークリッド距離を返します。各点は、座標のシーケンス（または反復可能）として指定されます。2つの点は同じ次元でなければなりません。

次とほぼ同等：

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

Pythonでリストとして表される2つの点を指定したPythonのユークリッド距離の簡潔なコードを次に示します。

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

Python 3.8以降

Python 3.8以降、mathモジュールには関数が含まれていますmath.dist()。
こちらhttps://docs.python.org/3.8/library/math.html#math.distを参照してください。

math.dist（p1、p2）
2つのポイント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

多次元空間のユークリッド距離を計算します。

 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)

簡単に数式を使用できます

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

これは実際には、ピタゴラスの定理を使用して距離を計算する以外に何もしません。

最初に2つの行列の差を求めます。次に、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

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

最初にリストをnumpy配列に変更し、次のようにしますprint(np.linalg.norm(np.array(a) - np.array(b)))。次のように直接Pythonリストから2番目の方法：print(np.linalg.norm(np.subtract(a,b)))