np.meshgridদস্তাবেজটিতে আসলে এর উদ্দেশ্য ইতিমধ্যে উল্লেখ করা হয়েছে:
np.meshgrid
স্থানাঙ্কী ভেক্টর থেকে সমন্বিত ম্যাট্রিকগুলি ফেরত দিন।
এক-মাত্রিক সমন্বিত অ্যারে এক্স 1, এক্স 2, ..., এক্সএন প্রদত্ত এনডি গ্রিডগুলির উপর এনডি স্কেলারার / ভেক্টর ক্ষেত্রগুলির ভেক্টরাইজড মূল্যায়নের জন্য এনডি সমন্বয়কারী অ্যারেগুলি তৈরি করুন।
সুতরাং এটির প্রাথমিক উদ্দেশ্য একটি সমন্বিত ম্যাট্রিক্স তৈরি করা।
আপনি সম্ভবত নিজেকে জিজ্ঞাসা করেছেন:
কেন আমাদের সমন্বিত ম্যাট্রিক তৈরি করতে হবে?
পাইথন / নুমপির সাথে আপনার সমন্বিত ম্যাট্রিকগুলির কারণ হ'ল স্থানাঙ্কগুলি থেকে মানগুলির সাথে সরাসরি সম্পর্ক নেই, যখন আপনার স্থানাঙ্কগুলি শূন্য দিয়ে শুরু হয় এবং খাঁটি ইতিবাচক পূর্ণসংখ্য হয় are তারপরে আপনি কেবল সূচি হিসাবে কোনও অ্যারের সূচকগুলি ব্যবহার করতে পারেন। তবে যখন এটি না হয় আপনার কোনওভাবে আপনার ডেটার পাশাপাশি স্থানাঙ্কগুলি সঞ্চয় করতে হবে store গ্রিডগুলি এখানে।
মনে করুন আপনার ডেটা হ'ল:
1 2 1
2 5 2
1 2 1
তবে প্রতিটি মান 2 কিলোমিটার প্রশস্ত অঞ্চল অনুভূমিকভাবে এবং 3 কিলোমিটার উল্লম্বভাবে উপস্থাপন করে। মনে করুন আপনার উত্সটি উপরের বাম কোণে এবং আপনি যে অ্যারে ব্যবহার করতে পারেন তার দূরত্ব উপস্থাপন করতে চান:
import numpy as np
h, v = np.meshgrid(np.arange(3)*3, np.arange(3)*2)
ভি কোথায়:
array([[0, 0, 0],
[2, 2, 2],
[4, 4, 4]])
এবং এইচ:
array([[0, 3, 6],
[0, 3, 6],
[0, 3, 6]])
তাই আপনি যদি দুই সূচকের আছে, এর কথা বলা যাক xএবং y(যে কেন ফেরত মান meshgridসাধারণত xxবা xsপরিবর্তে xএই ক্ষেত্রে আমি পছন্দ মধ্যে hঅনুভূমিকভাবে জন্য!) তারপর আপনি এক্স বিন্দু তুল্য পেতে পারেন, Y পয়েন্ট এবং এর তুল্য ব্যবহার করে সেই সময়ে মান:
h[x, y] # horizontal coordinate
v[x, y] # vertical coordinate
data[x, y] # value
এটি স্থানাঙ্কগুলির উপর নজর রাখতে আরও সহজ করে তোলে এবং (আরও গুরুত্বপূর্ণভাবে) আপনি তাদের এগুলি ফাংশনগুলিতে পাঠাতে পারেন যা স্থানাঙ্কগুলি জানতে হবে।
কিছুটা দীর্ঘ ব্যাখ্যা
তবে np.meshgridস্বয়ংক্রিয়ভাবে প্রায়শই সরাসরি ব্যবহৃত হয় না, বেশিরভাগই কেবল একইরকম একটি বস্তু np.mgridবা একটি ব্যবহার করে np.ogrid। এখানে np.mgridপ্রতিনিধিত্ব করে sparse=Falseএবং যদি (আমি পড়ুন আর্গুমেন্ট )। নোট তার মাঝে একটি গুরুত্বপূর্ণ পার্থক্য হল যে
এবং এবং : প্রথম দুই ফিরে মান (যদি সেখানে দুটি বা তার বেশি) বিপরীত হয়। প্রায়শই এটি গুরুত্বপূর্ণ নয় তবে আপনার প্রসঙ্গের উপর নির্ভর করে অর্থপূর্ণ পরিবর্তনশীল নাম দেওয়া উচিত।np.ogridsparse=Truesparsenp.meshgridnp.meshgridnp.ogridnp.mgrid
উদাহরণস্বরূপ, 2 ডি গ্রিডের ক্ষেত্রে এবং matplotlib.pyplot.imshowএটি প্রথম দিকে ফিরে আসা আইটেম np.meshgrid xএবং দ্বিতীয়টির নামকরণ করা বোধগম্য হয় yযখন এটি অন্যভাবে np.mgridএবং অন্যদিকে np.ogrid।
>>> import numpy as np
>>> yy, xx = np.ogrid[-5:6, -5:6]
>>> xx
array([[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]])
>>> yy
array([[-5],
[-4],
[-3],
[-2],
[-1],
[ 0],
[ 1],
[ 2],
[ 3],
[ 4],
[ 5]])
যেমন পূর্বেই বলা হয়েছে যে তুলনা করার সময় আউটপুটটি বিপরীত হয় np.meshgrid, সে কারণেই আমি এটিকে তার yy, xxপরিবর্তে আনপ্যাক করেছি xx, yy:
>>> xx, yy = np.meshgrid(np.arange(-5, 6), np.arange(-5, 6), sparse=True)
>>> xx
array([[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]])
>>> yy
array([[-5],
[-4],
[-3],
[-2],
[-1],
[ 0],
[ 1],
[ 2],
[ 3],
[ 4],
[ 5]])
এটি ইতিমধ্যে স্থানাঙ্কগুলির মতো দেখায়, 2D প্লটের জন্য বিশেষত x এবং y লাইন।
ভিজ্যুয়ালাইজ:
yy, xx = np.ogrid[-5:6, -5:6]
plt.figure()
plt.title('ogrid (sparse meshgrid)')
plt.grid()
plt.xticks(xx.ravel())
plt.yticks(yy.ravel())
plt.scatter(xx, np.zeros_like(xx), color="blue", marker="*")
plt.scatter(np.zeros_like(yy), yy, color="red", marker="x")
np.mgrid এবং ঘন / গ্রিড আউট গ্রিড
>>> yy, xx = np.mgrid[-5:6, -5:6]
>>> xx
array([[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]])
>>> yy
array([[-5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5],
[-4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4],
[-3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3],
[-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2],
[-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
[ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3],
[ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4],
[ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5]])
একইটি এখানে প্রযোজ্য: তুলনায় আউটপুটটি বিপরীত হয় np.meshgrid:
>>> xx, yy = np.meshgrid(np.arange(-5, 6), np.arange(-5, 6))
>>> xx
array([[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]])
>>> yy
array([[-5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5],
[-4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4],
[-3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3],
[-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2],
[-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
[ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3],
[ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4],
[ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5]])
ogridএই অ্যারেগুলির বিপরীতে -5 <= xx <= 5 এ সমস্ত xx এবং yyস্থানাঙ্ক থাকে ; -5 <= yy <= 5 গ্রিড।
yy, xx = np.mgrid[-5:6, -5:6]
plt.figure()
plt.title('mgrid (dense meshgrid)')
plt.grid()
plt.xticks(xx[0])
plt.yticks(yy[:, 0])
plt.scatter(xx, yy, color="red", marker="x")
কার্যকারিতার
এটি কেবল 2 ডি-তে সীমাবদ্ধ নয়, এই ফাংশনগুলি স্বেচ্ছাসেবী মাত্রার জন্য কাজ করে (ভাল, পাইথনে কাজ করার জন্য সর্বাধিক সংখ্যক যুক্তি দেওয়া হয় এবং সর্বাধিক সংখ্যক মাত্রা যা NumPy অনুমতি দেয়):
>>> x1, x2, x3, x4 = np.ogrid[:3, 1:4, 2:5, 3:6]
>>> for i, x in enumerate([x1, x2, x3, x4]):
... print('x{}'.format(i+1))
... print(repr(x))
x1
array([[[[0]]],
[[[1]]],
[[[2]]]])
x2
array([[[[1]],
[[2]],
[[3]]]])
x3
array([[[[2],
[3],
[4]]]])
x4
array([[[[3, 4, 5]]]])
>>> # equivalent meshgrid output, note how the first two arguments are reversed and the unpacking
>>> x2, x1, x3, x4 = np.meshgrid(np.arange(1,4), np.arange(3), np.arange(2, 5), np.arange(3, 6), sparse=True)
>>> for i, x in enumerate([x1, x2, x3, x4]):
... print('x{}'.format(i+1))
... print(repr(x))
# Identical output so it's omitted here.
এমনকি যদি এটি 1 ডি-তে কাজ করে তবে দুটি (অনেক বেশি সাধারণ) 1 ডি গ্রিড তৈরির কার্য রয়েছে:
যুক্তি startএবং stopযুক্তি ছাড়াও এটি তর্ককে সমর্থন করে step(এমনকী জটিল পদক্ষেপ যা পদক্ষেপের সংখ্যাকে উপস্থাপন করে):
>>> x1, x2 = np.mgrid[1:10:2, 1:10:4j]
>>> x1 # The dimension with the explicit step width of 2
array([[1., 1., 1., 1.],
[3., 3., 3., 3.],
[5., 5., 5., 5.],
[7., 7., 7., 7.],
[9., 9., 9., 9.]])
>>> x2 # The dimension with the "number of steps"
array([[ 1., 4., 7., 10.],
[ 1., 4., 7., 10.],
[ 1., 4., 7., 10.],
[ 1., 4., 7., 10.],
[ 1., 4., 7., 10.]])
অ্যাপ্লিকেশন
আপনি নির্দিষ্টভাবে উদ্দেশ্য সম্পর্কে জিজ্ঞাসা করেছিলেন এবং বাস্তবে, যদি আপনার একটি সমন্বিত সিস্টেমের প্রয়োজন হয় তবে এই গ্রিডগুলি অত্যন্ত কার্যকর।
উদাহরণস্বরূপ আপনার যদি একটি NumPy ফাংশন থাকে যা দুটি মাত্রায় দূরত্ব গণনা করে:
def distance_2d(x_point, y_point, x, y):
return np.hypot(x-x_point, y-y_point)
এবং আপনি প্রতিটি বিন্দুর দূরত্ব জানতে চান:
>>> ys, xs = np.ogrid[-5:5, -5:5]
>>> distances = distance_2d(1, 2, xs, ys) # distance to point (1, 2)
>>> distances
array([[9.21954446, 8.60232527, 8.06225775, 7.61577311, 7.28010989,
7.07106781, 7. , 7.07106781, 7.28010989, 7.61577311],
[8.48528137, 7.81024968, 7.21110255, 6.70820393, 6.32455532,
6.08276253, 6. , 6.08276253, 6.32455532, 6.70820393],
[7.81024968, 7.07106781, 6.40312424, 5.83095189, 5.38516481,
5.09901951, 5. , 5.09901951, 5.38516481, 5.83095189],
[7.21110255, 6.40312424, 5.65685425, 5. , 4.47213595,
4.12310563, 4. , 4.12310563, 4.47213595, 5. ],
[6.70820393, 5.83095189, 5. , 4.24264069, 3.60555128,
3.16227766, 3. , 3.16227766, 3.60555128, 4.24264069],
[6.32455532, 5.38516481, 4.47213595, 3.60555128, 2.82842712,
2.23606798, 2. , 2.23606798, 2.82842712, 3.60555128],
[6.08276253, 5.09901951, 4.12310563, 3.16227766, 2.23606798,
1.41421356, 1. , 1.41421356, 2.23606798, 3.16227766],
[6. , 5. , 4. , 3. , 2. ,
1. , 0. , 1. , 2. , 3. ],
[6.08276253, 5.09901951, 4.12310563, 3.16227766, 2.23606798,
1.41421356, 1. , 1.41421356, 2.23606798, 3.16227766],
[6.32455532, 5.38516481, 4.47213595, 3.60555128, 2.82842712,
2.23606798, 2. , 2.23606798, 2.82842712, 3.60555128]])
যদি একটি খোলা গ্রিডের পরিবর্তে ঘন গ্রিডে পাস হয় তবে আউটপুটটি অভিন্ন হবে। NumPys সম্প্রচার এটি সম্ভব করে তোলে!
আসুন ফলাফলটি কল্পনা করুন:
plt.figure()
plt.title('distance to point (1, 2)')
plt.imshow(distances, origin='lower', interpolation="none")
plt.xticks(np.arange(xs.shape[1]), xs.ravel()) # need to set the ticks manually
plt.yticks(np.arange(ys.shape[0]), ys.ravel())
plt.colorbar()
এবং এটি তখনও হয় যখন নুমপিস mgridএবং ogridখুব সুবিধাজনক হয়ে যায় কারণ এটি আপনাকে সহজেই আপনার গ্রিডগুলির রেজোলিউশন পরিবর্তন করতে দেয়:
ys, xs = np.ogrid[-5:5:200j, -5:5:200j]
# otherwise same code as above
যাইহোক, যেহেতু imshowসমর্থন করে না xএবং yইনপুটগুলি নিজের হাতে টিকগুলি পরিবর্তন করতে হবে। এটি সত্যিই সুবিধাজনক হবে যদি এটি xএবং yস্থানাঙ্কগুলি গ্রহণ করে , তাই না?
NumPy এর সাথে ফাংশনগুলি লেখা সহজ যা গ্রিডগুলির সাথে প্রাকৃতিকভাবে আচরণ করে। তদুপরি, নম্পপি, সায়পি, ম্যাটপ্ল্লোলিবের বেশ কয়েকটি ফাংশন রয়েছে যা আপনাকে গ্রিডে পাস করার আশা করে।
আমি ছবি পছন্দ করি তাই আসুন ঘুরে দেখি matplotlib.pyplot.contour:
ys, xs = np.mgrid[-5:5:200j, -5:5:200j]
density = np.sin(ys)-np.cos(xs)
plt.figure()
plt.contour(xs, ys, density)
স্থানাঙ্কগুলি ইতিমধ্যে সঠিকভাবে কীভাবে সেট করা আছে তা লক্ষ্য করুন! আপনি সবেমাত্র পাস করে থাকলে এটি হবে না density।
বা অ্যাস্ট্রপি মডেলগুলি ব্যবহার করে অন্য একটি মজাদার উদাহরণ দেওয়ার জন্য ( এবার আমি স্থানাঙ্কগুলির বিষয়ে খুব বেশি যত্নশীল নই, আমি কেবল কয়েকটি গ্রিড তৈরি করতে এগুলি ব্যবহার করি ):
from astropy.modeling import models
z = np.zeros((100, 100))
y, x = np.mgrid[0:100, 0:100]
for _ in range(10):
g2d = models.Gaussian2D(amplitude=100,
x_mean=np.random.randint(0, 100),
y_mean=np.random.randint(0, 100),
x_stddev=3,
y_stddev=3)
z += g2d(x, y)
a2d = models.AiryDisk2D(amplitude=70,
x_0=np.random.randint(0, 100),
y_0=np.random.randint(0, 100),
radius=5)
z += a2d(x, y)
যদিও এটি শুধুমাত্র "চেহারার জন্য" স্কিপি ইত্যাদিতে ফাংশনাল মডেল এবং ফিটিং সম্পর্কিত উদাহরণস্বরূপ (উদাহরণস্বরূপ scipy.interpolate.interp2d,
scipy.interpolate.griddataএমনকি উদাহরণগুলি দেখান np.mgrid) সম্পর্কিত বিভিন্ন ফাংশনগুলির জন্য গ্রিড প্রয়োজন। এগুলির বেশিরভাগই খোলা গ্রিড এবং ঘন গ্রিডগুলির সাথে কাজ করে তবে কিছু কিছু কেবল তাদের মধ্যে একটির সাথে কাজ করে।
xxএবং ব্যাখ্যা করেন নিyy। আমার কাছে রহস্যজনক অংশটি ছিল কেন সেই জুটির ফলাফলটি, এবং তারা দেখতে কেমন তা ফিরিয়ে দেয়। হাই ফানের উত্তরটি তার পক্ষে কার্যকর। আমার ধারণা এটি সুবিধার জন্য এটি করে, যেহেতু প্লট এর মতো দুটি পরামিতি চায়।