NumPyを使ってユークリッド距離を計算する方法を教えてください。
3Dには2つの点があります。
(xa, ya, za)
(xb, yb, zb)
そして距離を計算したいのですが。
dist = sqrt((xa-xb)^2 + (ya-yb)^2 + (za-zb)^2)
NumPyやPython全般でこれを行うための最善の方法は何ですか？私は持っています：
a = numpy.array((xa ,ya, za))
b = numpy.array((xb, yb, zb))
numpy.linalg.norm ：を使用してください。
dist = numpy.linalg.norm(a-b)
SciPyにはそのための関数があります。それは ユークリッド と呼ばれます。
例：
from scipy.spatial import distance
a = (1, 2, 3)
b = (4, 5, 6)
dst = distance.euclidean(a, b)
一度に複数の距離を計算することに興味がある人のために、 perfplot （私の小さなプロジェクト）を使って少し比較しました。それは判明した
a_min_b = a - b
numpy.sqrt(numpy.einsum('ij,ij->i', a_min_b, a_min_b))
aとbの最短距離で行の距離を計算します。これは実際には1行だけにも当てはまります。
プロットを再現するコード：
import matplotlib
import numpy
import perfplot
from scipy.spatial import distance
def linalg_norm(data):
a, b = data
return numpy.linalg.norm(a-b, axis=1)
def sqrt_sum(data):
a, b = data
return numpy.sqrt(numpy.sum((a-b)**2, axis=1))
def scipy_distance(data):
a, b = data
return list(map(distance.euclidean, a, b))
def mpl_dist(data):
a, b = data
return list(map(matplotlib.mlab.dist, a, b))
def sqrt_einsum(data):
a, b = data
a_min_b = a - b
return numpy.sqrt(numpy.einsum('ij,ij->i', a_min_b, a_min_b))
perfplot.show(
setup=lambda n: numpy.random.Rand(2, n, 3),
n_range=[2**k for k in range(20)],
kernels=[linalg_norm, scipy_distance, mpl_dist, sqrt_sum, sqrt_einsum],
logx=True,
logy=True,
xlabel='len(x), len(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)
簡単な答えをさまざまなパフォーマンスメモで説明します。 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)）を計算するために Pythagoras を使っているので、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))
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)
次のようにすることができます。私はそれがどのくらい速いのかわかりませんが、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)))
素敵なワンライナー：
dist = numpy.linalg.norm(a-b)
ただし、速度が問題になる場合は、私はあなたのマシンで実験することをお勧めします。私は、mathライブラリのsqrtを正方形の**演算子と一緒に使用する方が、ワンライナーNumPyソリューションよりもはるかに高速であることがわかりました。
私はこの簡単なプログラムを使って私のテストを実行しました：
#!/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_distとmath_calc_distの間の測定可能な違いを得るために、私はTOTAL_LOCATIONSを6000まで上げなければなりませんでした。それからfastest_calc_distは 〜50秒 を持ちますが、math_calc_distは 〜60秒 を持ちます。
numpy.sqrtとnumpy.squareを試してみることもできますが、どちらも私のマシンのmathの選択肢よりも遅くなりました。
私のテストはPython 2.6.6で実行されました。
ベクトルを引いてから内積するだけです。
あなたの例に従うと、
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)
単純なコードで理解しやすいです。
私はnp.dot（内積）が好きです。
a = numpy.array((xa,ya,za))
b = numpy.array((xb,yb,zb))
distance = (np.dot(a-b,a-b))**.5
定義したとおりにaとbを持っていれば、次のものも使用できます。
distance = np.sqrt(np.sum((a-b)**2))
これは、Pythonのリストとして表される2つの点を考慮した、Pythonのユークリッド距離の簡潔なコードです。
def distance(v1,v2):
return sum([(x-y)**2 for (x,y) in Zip(v1,v2)])**(0.5)
あなたは簡単に式を使うことができます
distance = np.sqrt(np.sum(np.square(a-b)))
これは実際にはピタゴラスの定理を使って距離を計算し、Δx、Δy、Δzの2乗を加えて結果を根づかせることに他ならない。
多次元空間のユークリッド距離を計算します。
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 math
dist = math.hypot(math.hypot(xa-xb, ya-yb), za-zb)
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つの行列の差を求めます。次に、numpyのmultiplyコマンドで要素ごとの乗算を適用します。その後、要素ごとに乗算された新しい行列の合計を求めます。最後に、総和の平方根を求めます。
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