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))
1139923 次
23 に答える
1173
dist = numpy.linalg.norm(a-b)
この背後にある理論は、データマイニングの概要にあります。
これは、ユークリッド距離がl2ノルムであり、のordパラメーターのデフォルト値numpy.linalg.normが2であるために機能します。
于 2009-09-09T20:12:50.387 に答える
222
SciPyにはそのための関数があります。それはユークリッドと呼ばれています。
例：
from scipy.spatial import distance
a = (1, 2, 3)
b = (4, 5, 6)
dst = distance.euclidean(a, b)
于 2014-02-24T11:32:29.257 に答える
159
一度に複数の距離を計算することに興味がある人のために、perfplot（私の小さなプロジェクト）を使用して少し比較しました。
最初のアドバイスは、配列が次元を持つように(3, n)（そして明らかにC連続であるように）データを編成することです。隣接する最初の次元で追加が行われる場合、処理は高速になり、、、、またはで使用sqrt-sumしてもそれほど重要ではありません。axis=0linalg.normaxis=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
b = perfplot.bench(
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,
],
xlabel="len(x), len(y)",
)
b.save("norm.png")
于 2017-12-12T14:46:25.077 に答える
54
簡単な答えをいろいろなパフォーマンスノートで説明したいと思います。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をジェネレーターに変換することで、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))
于 2017-11-28T22:54:12.557 に答える
39
この問題解決方法の別の例：
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)
于 2009-09-09T19:56:36.423 に答える
14
次のように行うことができます。どれくらい速いかわかりませんが、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)))
于 2012-10-31T10:33:48.733 に答える
12
素敵なワンライナー：
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
私のマシンでは、 23.5秒に対して1.5秒math_calc_distよりもはるかに高速に実行されます。numpy_calc_dist
との間の測定可能な差を取得するfastest_calc_distにmath_calc_distは、最大TOTAL_LOCATIONS6000秒にする必要がありました。その後fastest_calc_dist、約50秒math_calc_distかかりますが、約60秒かかります。
実験することもできますがnumpy.sqrt、numpy.squareどちらもmath私のマシンの代替手段よりも低速でした。
私のテストはPython2.6.6で実行されました。
于 2010-11-12T21:40:53.507 に答える
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)
于 2014-01-06T04:46:53.100 に答える
9
ベクトルを減算してから内積を減算するだけです。
あなたの例に従って、
a = numpy.array((xa, ya, za))
b = numpy.array((xb, yb, zb))
tmp = a - b
sum_squared = numpy.dot(tmp.T, tmp)
result = numpy.sqrt(sum_squared)
于 2011-09-10T19:08:12.743 に答える
8
私は好きですnp.dot（ドット積）：
a = numpy.array((xa,ya,za))
b = numpy.array((xb,yb,zb))
distance = (np.dot(a-b,a-b))**.5
于 2016-09-02T22:14:11.440 に答える
6
それらを持っaてb、あなたがそれらを定義したように、あなたはまた使うことができます：
distance = np.sqrt(np.sum((a-b)**2))
于 2016-12-28T15:48:41.497 に答える
6
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)))
于 2019-12-05T12:27:37.493 に答える
5
Pythonでリストとして表される2つのポイントが与えられた場合の、Pythonでのユークリッド距離の簡潔なコードを次に示します。
def distance(v1,v2):
return sum([(x-y)**2 for (x,y) in zip(v1,v2)])**(0.5)
于 2016-05-17T18:22:33.240 に答える
5
Python3.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
于 2019-10-15T18:21:58.817 に答える
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
于 2017-06-14T11:58:32.627 に答える
3
import math
dist = math.hypot(math.hypot(xa-xb, ya-yb), za-zb)
于 2018-02-22T16:41:05.227 に答える
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)
于 2018-02-10T06:09:01.000 に答える
2
あなたは簡単に式を使うことができます
distance = np.sqrt(np.sum(np.square(a-b)))
これは、実際には、ピタゴラスの定理を使用して、Δx、Δy、およびΔzの二乗を加算し、結果をルート化することによって、距離を計算するだけです。
于 2018-04-19T17:50:09.797 に答える
2
他の回答は浮動小数点数に対して機能しますが、オーバーフローとアンダーフローの影響を受ける整数dtypeの距離を正しく計算しません。scipy.distance.euclideanこの問題もあることに注意してください：
>>> a1 = np.array([1], dtype='uint8')
>>> a2 = np.array([2], dtype='uint8')
>>> a1 - a2
array([255], dtype=uint8)
>>> np.linalg.norm(a1 - a2)
255.0
>>> from scipy.spatial import distance
>>> distance.euclidean(a1, a2)
255.0
多くの画像ライブラリは画像をdtype="uint8"のndarrayとして表すため、これは一般的です。これは、非常に暗い灰色のピクセルで構成されるグレースケール画像があり（たとえば、すべてのピクセルに色がある#000001場合）、それを黒の画像（#000000）と比較すると、すべてのセルで構成されることになり、次のように登録されることを意味しますx-y。2552つの画像は互いに非常に離れています。符号なし整数型（uint8など）の場合、numpyの距離を次のように安全に計算できます。
np.linalg.norm(np.maximum(x, y) - np.minimum(x, y))
符号付き整数型の場合、最初にfloatにキャストできます。
np.linalg.norm(x.astype("float") - y.astype("float"))
特に画像データについては、opencvのnormメソッドを使用できます。
import cv2
cv2.norm(x, y, cv2.NORM_L2)
于 2020-09-04T21:52:57.747 に答える
1
最初に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
于 2018-07-26T15:11:18.997 に答える
1
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)))
于 2020-03-12T02:49:21.877 に答える
1
NumPyまたは一般的なPythonでこれを行うための最良の方法は何ですか？私は持っています：
最善の方法は最も安全で最速です
アンダーフローとオーバーフローの可能性について信頼できる結果を得るためのhypotの使用は、独自のsqroot計算機を作成する場合と比較してごくわずかです。
math.hypot、np.hypotvsvanillaを見てみましょうnp.sqrt(np.sum((np.array([i, j, k])) ** 2, axis=1))
i, j, k = 1e+200, 1e+200, 1e+200
math.hypot(i, j, k)
# 1.7320508075688773e+200
np.sqrt(np.sum((np.array([i, j, k])) ** 2))
# RuntimeWarning: overflow encountered in square
スピードに関してmath.hypotの方が見栄えが良い
%%timeit
math.hypot(i, j, k)
# 100 ns ± 1.05 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
%%timeit
np.sqrt(np.sum((np.array([i, j, k])) ** 2))
# 6.41 µs ± 33.3 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
アンダーフロー
i, j = 1e-200, 1e-200
np.sqrt(i**2+j**2)
# 0.0
オーバーフロー
i, j = 1e+200, 1e+200
np.sqrt(i**2+j**2)
# inf
アンダーフローなし
i, j = 1e-200, 1e-200
np.hypot(i, j)
# 1.414213562373095e-200
オーバーフローなし
i, j = 1e+200, 1e+200
np.hypot(i, j)
# 1.414213562373095e+200
于 2021-09-18T09:51:41.523 に答える