আমার 3D এ দুটি পয়েন্ট রয়েছে:
(xa, ya, za)
(xb, yb, zb)এবং আমি দূরত্ব গণনা করতে চাই:
dist = sqrt((xa-xb)^2 + (ya-yb)^2 + (za-zb)^2)নুমপি বা সাধারণভাবে পাইথনের সাথে এটি করার সর্বোত্তম উপায় কী? আমার আছে:
import numpy
a = numpy.array((xa ,ya, za))
b = numpy.array((xb, yb, zb))উত্তর:
ব্যবহার numpy.linalg.norm:
dist = numpy.linalg.norm(a-b)আপনি এর পিছনে তত্ত্বটি ডেটা মাইনিংয়ের পরিচিতিতে খুঁজে পেতে পারেন
এই কাজ কারণ ইউক্লিডিয় দূরত্ব হয় L2 আদর্শ এবং ডিফল্ট মান Ord numpy.linalg.norm মাপদণ্ড 2।
সায়পাইতে এর জন্য একটি ফাংশন রয়েছে। একে ইউক্লিডিয়ান বলা হয় ।
উদাহরণ:
from scipy.spatial import distance
a = (1, 2, 3)
b = (4, 5, 6)
dst = distance.euclidean(a, b)একবারে একাধিক দূরত্ব গণনা করতে আগ্রহী যে কারও জন্য, আমি পারফ্লোট (আমার একটি ছোট প্রকল্প) ব্যবহার করে কিছুটা তুলনা করেছি ।
প্রথম পরামর্শটি হ'ল আপনার ডেটাটি এমনভাবে সাজানো যাতে অ্যারেগুলির মাত্রা থাকে (3, n)(এবং এটি স্পষ্টত সি-স্বচ্ছল)। যোগ সংলগ্ন প্রথম মাত্রা মধ্যে এমনটা হয়, তাহলে কিছু দ্রুত, এবং এটি না ব্যাপার অত্যধিক যদি আপনি ব্যবহার করে sqrt-sumসঙ্গে axis=0, linalg.normসঙ্গে axis=0, অথবা
a_min_b = a - b
numpy.sqrt(numpy.einsum('ij,ij->j', a_min_b, a_min_b))যা সামান্য ব্যবধানে, দ্রুততম বৈকল্পিক। (এটি সত্য মাত্র এক সারির জন্যও সত্য holds
দ্বিতীয় অক্ষের উপরে আপনি যে রূপগুলি যোগ করেন 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)",
)i,i->
data?
আমি বিভিন্ন পারফরম্যান্স নোট সহ সহজ উত্তরটি ব্যাখ্যা করতে চাই। 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কয়েকটি জিনিস মনে রাখবেন:
সুতরাং
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প্রথমত - যতবার আমরা এটি ডাকি, আমাদের "এনপি" এর জন্য একটি বিশ্বব্যাপী অনুসন্ধান করতে হবে, "লিনালগ" এর জন্য একটি স্কোপযুক্ত অনুসন্ধান এবং "আদর্শ" এর জন্য একটি স্কোপযুক্ত অনুসন্ধান করতে হবে এবং কেবলমাত্র ফাংশনটি কল করার ওভারহেড কয়েক ডজন পাইথনের সমান হতে পারে নির্দেশাবলী।
সবশেষে, আমরা ফলাফল সংরক্ষণ করতে এবং দুটি পুনরায় লোড করার জন্য দুটি অপারেশন নষ্ট করেছি ...
উন্নতিতে প্রথম পাস: দ্রুত অনুসন্ধান করুন, স্টোরটি এড়িয়ে যান
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)))বরাবর অগ্রসর. তবে আপনি যদি দূরত্বের তুলনা করে, পরিসীমা চেক ইত্যাদি করেন, আমি কিছু কার্যকর সম্পাদনা পর্যবেক্ষণ যোগ করতে চাই।
আসুন দুটি ক্ষেত্রে নেওয়া যাক: দূরত্ব অনুসারে বাছাই করা বা আইটেমগুলিতে একটি সীমাবদ্ধতা বা সীমার সীমাবদ্ধতা পূরণ করে to
# 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)দুর্দান্ত, উভয় ফাংশন আর কোনও ব্যয়বহুল স্কোয়ার শিকড় করবে না। এটি আরও দ্রুত হবে। আমরা জেনারেটরে রূপান্তর করে ইন-অ্যারেঞ্জও উন্নত করতে পারি:
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)))ফলনশীল tuples বিবেচনা করুন:
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)এটি বিশেষত কার্যকর হতে পারে যদি আপনি পরিসীমা চেকগুলি চেন করতে পারেন ('এক্স এর কাছাকাছি এবং 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 ...এবং আবারও, ডিস্ট_স্কুয়ার ফলন বিবেচনা করুন। আমাদের হটডগ উদাহরণটি তখন পরিণত হয়:
# 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))pointZকরছিলেন যা বিদ্যমান ছিল না। আমি মনে করি আপনি যা বোঝাতে চেয়েছিলেন তা ত্রি-মাত্রিক স্থানে দুটি পয়েন্ট ছিল এবং আমি সেই অনুযায়ী সম্পাদনা করেছি। যদি আমি ভুল ছিলাম, দয়া করে আমাকে জানান।
এই সমস্যা সমাধানের পদ্ধতির আরেকটি উদাহরণ :
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)norm = lambda x: N.sqrt(N.square(x).sum()); norm(x-y)
numpy.linalg.norm(x-y)
শুরু করে Python 3.8, mathমডিউলটি সরাসরি distফাংশন সরবরাহ করে , যা দুটি পয়েন্টের মধ্যে ইউক্লিডিয়ান দূরত্ব দেয় (টিউপলস বা স্থানাঙ্কের তালিকা হিসাবে দেওয়া হয়):
from math import dist
dist((1, 2, 6), (-2, 3, 2)) # 5.0990195135927845এবং যদি আপনি তালিকাগুলি নিয়ে কাজ করছেন:
dist([1, 2, 6], [-2, 3, 2]) # 5.0990195135927845এটি নিম্নলিখিত মত করা যেতে পারে। আমি জানি না এটি কত দ্রুত, তবে এটি নম্পপি ব্যবহার করছে না।
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)))for a, b in zip(a, b)। কিন্তু দরকারী কম।
আমি matplotlib.mlab এ একটি 'ডিস্ট' ফাংশন পাই, তবে আমি মনে করি না এটি যথেষ্ট কার্যকর think
আমি এখানে এখানে রেফারেন্স পোস্ট করছি।
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লাইব্রেরি ব্যবহার করা আমার মেশিনে ওয়ান-লাইনার নম্পপি সমাধানের চেয়ে আরও দ্রুত।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_dist1.5 সেকেন্ডের চেয়ে অনেক বেশি দ্রুত চলে ।
মধ্যে একটি পরিমাপযোগ্য পার্থক্য পেতে fastest_calc_distএবং math_calc_distআমি ছিল TOTAL_LOCATIONS6000. তারপর fastest_calc_dist50 সেকেন্ড সময় লাগে ~ যখন math_calc_dist60 সেকেন্ড সময় লাগে ~।
আপনি পরীক্ষা করতে পারেন numpy.sqrtএবং numpy.squareযদিও উভয়ই mathআমার মেশিনের বিকল্পগুলির চেয়ে ধীর ছিল ।
আমার পরীক্ষাগুলি পাইথন ২.6..6 দিয়ে চালানো হয়েছিল।
scipy.spatial.distance.cdist(p1, p2).sum(),। হ্যাঁ, ওটাই.
numpy.linalg.norm(p1-p2).sum()পি 1 এর প্রতিটি পয়েন্ট এবং পি 2 এর সাথে সম্পর্কিত পয়েন্টের মধ্যে যোগফল পেতে ব্যবহার করুন (অর্থাত্ প 1 এর প্রতিটি বিন্দুতে পি 2 এর প্রতিটি পয়েন্ট নয়)। এবং আপনি যদি পি 1 এর প্রতিটি বিন্দু পি 2 এর প্রতিটি বিন্দুতে চান এবং আমার আগের মতামত মতো স্কিপি ব্যবহার করতে না চান তবে আপনি এখনও এটি করতে আরও অনেক দ্রুত করতে nump.linalg.norm এর সাথে np.apply_along_axis ব্যবহার করতে পারেন তারপরে আপনার "দ্রুততম" সমাধান।
আপনি কেবল ভেক্টরগুলি বিয়োগ করতে পারেন এবং তারপরে অভ্যন্তরীণ উত্পাদন করতে পারেন।
আপনার উদাহরণ অনুসরণ করে,
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))পাইথন ৩.৮ সহ এটি খুব সহজ।
https://docs.python.org/3/library/math.html#math.dist
math.dist(p, q)দুটি বিন্দু পি এবং কিউর মধ্যে ইউক্লিডিয়ান দূরত্ব ফিরিয়ে আনুন, প্রত্যেকটি স্থানাঙ্কের সিক্যুয়েন্স (বা পুনরাবৃত্ত) হিসাবে দেওয়া হয়। দুটি পয়েন্টের অবশ্যই একই মাত্রা থাকতে হবে।
মোটামুটি সমান:
sqrt(sum((px - qx) ** 2.0 for px, qx in zip(p, q)))
পাইথনে ইউক্লিডিয়ান দূরত্বের জন্য কয়েকটি সংক্ষিপ্ত কোড এখানে পাইথনের দুটি তালিকা হিসাবে প্রতিনিধিত্ব করা হয়েছে।
def distance(v1,v2):
return sum([(x-y)**2 for (x,y) in zip(v1,v2)])**(0.5)পাইথন ৩.৮ যেহেতু mathমডিউলটিতে ফাংশন অন্তর্ভুক্ত রয়েছে math.dist()।
এখানে https://docs.python.org/3.8/library/math.html#math.dist দেখুন ।
math.dist (p1, p2)
দুটি পয়েন্ট পি 1 এবং পি 2 এর মধ্যে ইউক্লিডিয়ান দূরত্বটি প্রদান করুন, প্রত্যেকটি স্থানাঙ্কের ক্রম (বা পুনরাবৃত্ত) হিসাবে দেওয়া হবে।
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.0990195135927845import 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)))actuallyx, andy এবং Δz এর বর্গাকার যোগ করে ফলাফলকে মূলোৎপাটন করে দূরত্ব নির্ণয়ের জন্য পাইথাগোরসের উপপাদ্যটি ব্যবহার করা ছাড়া আর কিছুই নেই।
প্রথমে দুটি ম্যাট্রিকের পার্থক্য সন্ধান করুন। তারপরে, নিমপির মাল্টিপল কমান্ড সহ উপাদান অনুসারে গুণিত প্রয়োগ করুন। এর পরে, মৌলিক গুণিত নতুন ম্যাট্রিক্সের সংমিশ্রণটি সন্ধান করুন। অবশেষে, যোগফলের বর্গমূল সন্ধান করুন।
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_distanceimport 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)))। পাইথন তালিকা থেকে সরাসরি দ্বিতীয় পদ্ধতি:print(np.linalg.norm(np.subtract(a,b)))