Indexing আর slicing — boolean mask, fancy index, view আর copy

আগের পর্বে (পর্ব ১৩ · NumPy array — shape, dtype আর list-এর চেয়ে কেন দ্রুত) দেখেছেন, NumPy array হলো একই ধরনের সংখ্যার একটি টানা সারি, যার একটি shape আর একটি dtype আছে। এই পর্বের প্রশ্ন একটিই: সেই array থেকে ঠিক যে সংখ্যাগুলো দরকার, সেগুলো কীভাবে তুলবেন, আর তোলার পর হাতে যা পেলেন তা নতুন সংখ্যা, নাকি পুরোনো সংখ্যারই আরেকটি জানালা। দ্বিতীয় প্রশ্নটিই ডেটার কাজে সবচেয়ে বেশি নিঃশব্দ ভুলের জন্ম দেয়। Python-এর list-এর slicing আপনি list পর্বে দেখেছেন; NumPy একই চিহ্ন ব্যবহার করে, কিন্তু ফল আলাদা। এই পর্বের সব কোড পাতাতেই চলবে, Pyodide দিয়ে; প্রথমবার চালালে NumPy নামতে কয়েক সেকেন্ড লাগতে পারে।

১ · বাজারঘরের বিক্রির খাতা — একটি ঘর, একটি সারি, একটি কলাম

সিনেমা হলের টিকিটের কথা ভাবুন: “সারি D, আসন ১২”। দুটি সংখ্যা দিলেই একটি আসন ঠিক হয়ে যায়। শুধু “সারি D” বললে পুরো একটি সারি, আর “সব সারির ১২ নম্বর আসন” বললে একটি খাড়া কলাম। 2-D array-তে indexing ঠিক এমন: প্রথম সংখ্যা সারি, দ্বিতীয় সংখ্যা কলাম, আর দুটিই গোনা শুরু হয় 0 থেকে।

এই পর্বের পুরো সময় আমরা বাজারঘরের (এই কোর্সের কাল্পনিক অনলাইন দোকান) এক সপ্তাহের বিক্রির খাতা নিয়ে কাজ করব। পাঁচটি জেলা সারিতে, সাতটি দিন কলামে, আর প্রতিটি ঘরে সেদিন সেই জেলার বিক্রি, হাজার টাকায়। ডেটা বানানো হয়েছে seed দেওয়া random generator দিয়ে, তাই প্রত্যেক পাঠক একই সংখ্যা পাবেন:

import numpy as np
rng = np.random.default_rng(42)              # seed ৪২: সবার একই সংখ্যা
sales = rng.integers(20, 90, size=(5, 7))    # ৫ জেলা × ৭ দিন, হাজার টাকা
# সারি: 0 ঢাকা, 1 চট্টগ্রাম, 2 রাজশাহী, 3 খুলনা, 4 সিলেট
# কলাম: 0 শনি, 1 রবি, 2 সোম, 3 মঙ্গল, 4 বুধ, 5 বৃহঃ, 6 শুক্র
print(sales)
[[26 74 65 50 50 80 26]
 [68 34 26 56 88 71 73]
 [70 75 55 28 78 51 55]
 [45 32 84 74 65 48 77]
 [58 51 51 35 26 58 82]]

rng.integers(20, 90, ...) 20 থেকে 89 পর্যন্ত পূর্ণসংখ্যা দেয় (90 বাদ), আর এর dtype সব যন্ত্রে int64, ব্রাউজারের ভেতরের Python-এও। নিচের ছবিতে একই খাতা, প্রতিটি সারি আর কলামের ঠিকানাসহ।

1-D আর 2-D-তে একটি ঘর

একটি সারি আলাদা করে নিলে সেটি একটি 1-D array, আর সেখানে একটি সংখ্যা দিলেই একটি ঘর:

dhaka = sales[0]          # [26 74 65 50 50 80 26]  ঢাকার পুরো সপ্তাহ
dhaka[1]                  # 74   রবিবার
dhaka[-1]                 # 26   শেষ দিন, শুক্রবার
sales[2, 4]               # 78   রাজশাহী, বুধবার
sales[-1, -2]             # 58   শেষ জেলা (সিলেট), শেষের আগের দিন (বৃহঃ)
sales[2][4]               # 78   একই ফল, কিন্তু দুই ধাপে (নিচে দেখুন কেন এড়াবেন)

Negative index মানে শেষ থেকে গোনা: -1 শেষটি, -2 তার আগেরটি। নিয়মটি সহজ: দৈর্ঘ্য n হলে a[-k] আর a[n - k] একই ঘর। তাই ৭ দিনের সারিতে -2 মানে 7 - 2 = 5, বৃহস্পতিবার। সীমার বাইরে গেলে (যেমন sales[5, 0] বা dhaka[-8]) NumPy সাথে সাথে IndexError দেয়; এখানে কোনো চুপচাপ ভুল নেই।

sales[2, 4] আর sales[2][4] একই সংখ্যা দেয়, কিন্তু কাজ আলাদা। প্রথমটি এক ধাপে ঠিকানা হিসাব করে সরাসরি ঘরে যায়। দ্বিতীয়টি আগে sales[2] দিয়ে একটি নতুন array object (সারির view) বানায়, তারপর সেখান থেকে [4] নেয়। পড়ার সময় তফাত শুধু গতিতে, কিন্তু অংশ ৫ আর ৮-এ দেখবেন, এমন দুই ধাপের লেখা কখনো কখনো কিছুই বদলায় না। তাই অভ্যাস হিসেবে সবসময় এক বন্ধনীতে কমা দিয়ে লিখুন: a[i, j].

সারি আর কলাম তোলা

একটি index বাদ দিলে, বা তার জায়গায় : (মানে “সবগুলো”) দিলে, পুরো একটি দিক উঠে আসে:

sales[1]         # [68 34 26 56 88 71 73]   চট্টগ্রামের সারি, shape (7,)
sales[1, :]      # একই জিনিস, স্পষ্ট করে লেখা
sales[:, -1]     # [26 73 55 77 82]         সব জেলার শুক্রবার, shape (5,)
sales[..., -1]   # একই; ... মানে "বাকি সব দিক পুরোটা"

... (Ellipsis) লেখে “আগের বা পরের যত দিক আছে, সব পুরো নেওয়া হবে”। 2-D-তে এটি :-এর সমান, তাই এখানে লাভ সামান্য। কিন্তু পর্ব ১৮-এ ছবির array আসবে shape (উচ্চতা, প্রস্থ, ৩) নিয়ে, আর সেখানে img[..., 0] মানে “সব pixel-এর লাল channel”, দিকের সংখ্যা যাই হোক না কেন। খেয়াল করুন, সারি বা কলাম একটি integer দিয়ে তুললে একটি দিক হারিয়ে যায়: 2-D থেকে 1-D. এই কথাটি অংশ ২-এর শেষে আবার আসবে।

২ · Slicing — start:stop:step আর বাদ-পড়া শেষ সীমা

Slice লেখা হয় start:stop:step: কোথা থেকে শুরু, কোথায় থামা, কত ঘর লাফ। নিয়ম তিনটি। start ধরা হয়, stop ধরা হয় না। কিছু না লিখলে start মানে শুরু, stop মানে শেষ, step মানে 1. আর step negative হলে উল্টো দিকে হাঁটা। Python list-এর slicing-এর নিয়মও ঠিক এই, তাই এটি নতুন কিছু নয়।

a = np.arange(10)      # [0 1 2 3 4 5 6 7 8 9]
a[2:5]                 # [2 3 4]        5 বাদ
a[2:8:3]               # [2 5]          2, 5, (8 বাদ)
a[-3:]                 # [7 8 9]        শেষ তিনটি
a[::-2]                # [9 7 5 3 1]    উল্টো, এক ঘর বাদ দিয়ে
a[7:2]                 # []             ধাপ +1, কিন্তু 7 থেকে 2-এ যাওয়া যায় না: ফাঁকা
a[5:100]               # [5 6 7 8 9]    সীমার বাইরের stop চুপচাপ কেটে ছোট হয়

শেষ দুটি লাইন গুরুত্বপূর্ণ: index সীমার বাইরে গেলে IndexError হয়, কিন্তু slice সীমার বাইরে গেলে কোনো error হয় না, শুধু ছোট বা ফাঁকা ফল আসে। তাই ভুল slice প্রায়ই নিঃশব্দে ভুল ডেটা দেয়।

একটি slice-এ কয়টি উপাদান — হিসাবের সূত্র

পরীক্ষায় প্রায়ই জিজ্ঞাসা করা হয় “এই slice-এর shape কী?”। ধনাত্মক step-এর জন্য, start আর stop সীমার ভেতরে কেটে নেওয়ার পর, উপাদানের সংখ্যা:

n = max(0, ⌈(stop − start) / step⌉)

এখানে ⌈x⌉ মানে x-এর চেয়ে ছোট নয় এমন সবচেয়ে ছোট পূর্ণসংখ্যা (ওপরের দিকে round). a[2:8:3]: (8 − 2) / 3 = 2, তাই ২টি উপাদান। a[1:8:3]: (8 − 1) / 3 ≈ 2.33, ওপরে নিলে ৩টি: 1, 4, 7. বাজারঘরের খাতায় sales[1:4, ::3]: সারি (4 − 1) / 1 = ৩টি, কলাম (7 − 0) / 3 ≈ 2.33 থেকে ৩টি (0, 3, 6), তাই shape (3, 3). আর sales[:, 1:6:2]: কলাম 1, 3, 5, shape (5, 3). দুটিই নিজে চালিয়ে মিলিয়ে নিয়েছি।

2-D slice — প্রতিটি দিকে আলাদা slice

2-D-তে কমার দুই পাশে দুটি আলাদা slice বসে: প্রথমটি কোন সারি, দ্বিতীয়টি কোন কলাম। ফল তাদের ছেদ, একটি আয়তাকার টুকরো। নিচের ধাপে sales[1:3, ::2] ঘরে ঘরে দেখুন। “পরে” চাপুন।

Shape-এর চমক — a[0] বনাম a[0:1]

এক সারির ডেটা দুইভাবে তোলা যায়, আর দুটির shape আলাদা। এই পার্থক্য পরে model-এ ডেটা দেওয়ার সময় সবচেয়ে বেশি error ঘটায়, কারণ scikit-learn-এর মতো library সবসময় 2-D (সারি × feature) চায়।

কোনটি ঠিক, তা নির্ভর করে পরের কাজের ওপর। একটি কলামকে আরেকটি 2-D array-এর পাশে জোড়া দিতে বা model-এ একটি feature দিতে (5, 1) লাগে; গড় বা যোগফলের জন্য (5,) যথেষ্ট। পরের পর্বে broadcasting শিখলে দেখবেন, (5,) আর (5, 1) একসঙ্গে মেলালে একেবারে ভিন্ন ফল আসে।

৩ · View — একই খাতা, নতুন জানালা

দোকানের হিসাব খাতার একটি পাতার ফটোকপি আর সেই পাতায় একটি স্বচ্ছ ফ্রেম রাখার কথা ভাবুন। ফটোকপিতে কিছু লিখলে আসল খাতা বদলায় না। কিন্তু ফ্রেমের ভেতর দিয়ে লিখলে কলম সরাসরি আসল পাতাতেই পড়ে; ফ্রেম শুধু ঠিক করে কোন অংশ দেখা যাবে। NumPy-র basic slice হলো এই ফ্রেম, যার নাম view. আর .copy() হলো ফটোকপি, যার নাম copy.

কেন NumPy এমন করে? কারণ slice বানাতে কোনো সংখ্যা সরাতে হয় না। ছবি ১৪.১-এর memory-তে ফিরে যান: সারিগুলো row-major ক্রমে পরপর বসানো। sales-এর strides (56, 8): পরের সারিতে যেতে 56 byte, পরের কলামে 8 byte. sales[:, ::2] মানে “প্রতিটি সারিতে এক কলাম বাদ দিয়ে”, তাই এর strides হয় (56, 16). শুরুর ঠিকানা আর strides বদলালেই নতুন array তৈরি, data একটিও কপি হয় না। ফলে কোটি সংখ্যার array-তেও slice নেওয়া প্রায় শূন্য সময়ে হয়, আর বাড়তি memory লাগে না। দামটি হলো: দুটি নাম, একই সংখ্যা। একটিতে লিখলে অন্যটিও বদলায়।

নিচের কোড সেটি নিজের চোখে দেখায়। np.shares_memory(a, b) বলে দুটি array-এর memory কোথাও মেলে কি না, আর .base বলে একটি view কোন array-এর memory ধার করেছে (নিজের memory থাকলে None).

import numpy as np
rng = np.random.default_rng(42)
sales = rng.integers(20, 90, size=(5, 7))   # ৫ জেলা × ৭ দিন, হাজার টাকা

first2 = sales[:, :2]                # slice: view
print("shape:", first2.shape)
print("shares_memory:", np.shares_memory(first2, sales))
print("base is sales:", first2.base is sales)

first2[0, 0] = 999                   # view-এ লেখা
print("sales[0, 0] =", sales[0, 0])  # মূল array-ও বদলেছে

safe = sales[:, :2].copy()           # নিজস্ব memory
safe[0, 1] = -1
print("sales[0, 1] =", sales[0, 1])  # বদলায়নি
print("copy:", np.shares_memory(safe, sales), safe.base)

cols = sales[:, [0, 2]]              # fancy index: copy
print("fancy:", np.shares_memory(cols, sales), cols.base is None)
print("strides:", sales.strides, sales[:, ::2].strides)

shape: (5, 2)
shares_memory: True
base is sales: True
sales[0, 0] = 999
sales[0, 1] = 74
copy: False None
fancy: False False
strides: (56, 8) (56, 16)

কখন .copy() ডাকবেন

• টুকরো বদলাবেন, কিন্তু মূল অক্ষত রাখতে চান: যেমন পরীক্ষামূলকভাবে কিছু মান কেটে দেখা। trial = sales[:, :3].copy().
• বড় array-এর ছোট টুকরো অনেক দিন রাখবেন: view বেঁচে থাকলে পুরো মূল array-এর memory-ও ছাড়া যায় না। এক GB-র array থেকে ১০টি সারির view রেখে বাকিটা del করলেও পুরো GB আটকে থাকে। small = big[:10].copy() দিলে শুধু ১০টি সারির memory থাকে।
• Function-এ পাওয়া array বদলাতে হবে: ডাকা জায়গার array চুপচাপ বদলে দেওয়া একটি side effect; পর্ব ১১-এর পরিচ্ছন্ন কোডের নিয়মে শুরুতেই x = x.copy() ভালো অভ্যাস।

আর কখন দরকার নেই? শুধু পড়তে, যোগ-গড় করতে, বা ছবি আঁকতে view-ই যথেষ্ট আর দ্রুত। অকারণ copy বড় ডেটায় memory দ্বিগুণ করে। Python-এর list-এ কিন্তু উল্টো: lst[1:3] একটি নতুন list (shallow copy). দুই জগতের এই পার্থক্য নিয়ে Python কোর্সের mutability, alias আর copy পর্ব সহায়ক।

৪ · Boolean mask — শর্ত দিয়ে ছাঁকা, গোনা আর বদলানো

পরীক্ষার খাতা দেখার পর শিক্ষক প্রতিটি নামের পাশে “পাশ” বা “ফেল” লেখেন। এবার সেই পাশ-ফেলের তালিকা দিয়েই বলা যায়: “যারা পাশ করেছে, তাদের নম্বর দেখান” বা “কতজন পাশ করেছে”। Boolean mask ঠিক এই তালিকা। sales > 75 লিখলে NumPy প্রতিটি ঘরের জন্য আলাদা করে তুলনা করে, আর একই shape-এর একটি True/False array দেয়। কোনো loop লিখতে হয় না, এটিই vectorization-এর প্রথম স্বাদ।

sales > 75          # shape (5, 7), dtype bool
[[False False False False False  True False]
 [False False False False  True False False]
 [False False False False  True False False]
 [False False  True False False False  True]
 [False False False False False False  True]]

এই mask দিয়ে তিনটি কাজ হয়। বাছাই: sales[mask] শুধু True ঘরের মানগুলো দেয়, একটি 1-D array হিসেবে (2-D আকার থাকে না, কারণ True ঘরগুলো আয়তাকার নয়)। গোনা: True মানে 1 আর False মানে 0 ধরে mask.sum() গোনে কয়টি ঘর শর্ত মানে, আর mask.mean() দেয় কত ভাগ। mask.sum(axis=1) প্রতিটি সারিতে আলাদা করে গোনে। বসানো: sales[mask] = x শুধু True ঘরগুলোতে x বসায়। নিচের ধাপে চট্টগ্রামের সপ্তাহ দিয়ে তিনটি কাজ দেখুন।

1d = sales[1]          # চট্টগ্রাম (view)2mask = d > 703d[mask]4mask.sum(), mask.mean()5d[mask] = 70          # ৭০-এ কাটা6print(sales[1])

চালিয়ে দেখুন — ভালো দিন গোনা আর ভুল এন্ট্রি সারানো

বাস্তবের ডেটায় ভুল থাকে। ধরুন রাজশাহীর মঙ্গলবারের 28 হাজার কেউ ভুল করে 280 লিখেছেন। নিচের কোড প্রথমে ৭৫ হাজারের বেশি বিক্রির দিন গোনে, তারপর একটি ব্যবসায়িক নিয়ম দিয়ে (একটি জেলায় একদিনে ২০০ হাজারের বেশি বিক্রি অসম্ভব) সন্দেহজনক ঘর খুঁজে সেই জেলার median দিয়ে বদলায়। এমন অস্বাভাবিক মানকে বলে outlier.

import numpy as np
rng = np.random.default_rng(42)
sales = rng.integers(20, 90, size=(5, 7))
sales[2, 3] = 280                    # ভুল এন্ট্রি: 28-এর পেছনে বাড়তি 0
districts = np.array(["ঢাকা", "চট্টগ্রাম", "রাজশাহী", "খুলনা", "সিলেট"])
days = np.array(["শনি", "রবি", "সোম", "মঙ্গল", "বুধ", "বৃহঃ", "শুক্র"])

good = sales > 75                    # একই shape-এর True/False array
print("৭৫-এর বেশি দিন:", good.sum(), "| ভাগ:", round(good.mean(), 3))
print("প্রতি জেলায়:", good.sum(axis=1))
print("ঢাকার ভালো দিন:", days[good[0]], sales[0][good[0]])

bad = sales > 200                    # ব্যবসার নিয়ম: একদিনে ২০০-র বেশি অসম্ভব
r, c = np.nonzero(bad)
print("সন্দেহজনক:", districts[r], days[c], sales[bad])

row_med = np.median(sales, axis=1)   # প্রতি জেলার median
print("median:", row_med)
sales[r, c] = row_med[r]             # শুধু সেই ঘরগুলোতে বসানো
print("রাজশাহী এখন:", sales[2])
print("সর্বোচ্চ এখন:", sales.max())

৭৫-এর বেশি দিন: 7 | ভাগ: 0.2
প্রতি জেলায়: [1 1 2 2 1]
ঢাকার ভালো দিন: ['বৃহঃ'] [80]
সন্দেহজনক: ['রাজশাহী'] ['মঙ্গল'] [280]
median: [50. 68. 70. 65. 51.]
রাজশাহী এখন: [70 75 55 70 78 51 55]
সর্বোচ্চ এখন: 88

৫ · শর্ত জোড়া — &, |, ~, আর কেন and চলে না

“৫০ থেকে ৭৫-এর মধ্যে” একটি জোড়া শর্ত। NumPy-তে ঘরে ঘরে “এবং” হলো &, “অথবা” হলো |, আর “না” হলো ~. প্রতিটি শর্ত অবশ্যই বন্ধনীর ভেতরে: (sales >= 50) & (sales <= 75). কেন বন্ধনী, আর কেন Python-এর চেনা and চলে না, নিচের কোড আসল error দিয়েই দেখায়।

import numpy as np
rng = np.random.default_rng(42)
sales = rng.integers(20, 90, size=(5, 7))

mid = (sales >= 50) & (sales <= 75)
extreme = (sales < 30) | (sales > 85)
print("50–75:", mid.sum(), "| খুব কম বা বেশি:", extreme.sum())
print("বাকি:", (~(mid | extreme)).sum(), "| মোট:", sales.size)

try:
    (sales >= 50) and (sales <= 75)
except ValueError as e:
    print("and ->", type(e).__name__ + ":", e)

try:
    sales >= 50 & sales <= 75        # বন্ধনী নেই
except ValueError as e:
    print("বন্ধনী ছাড়া ->", type(e).__name__)

print("50 & sales[0] =", 50 & sales[0])
print("any/all:", (sales > 85).any(), (sales >= 20).all())

50–75: 19 | খুব কম বা বেশি: 6
বাকি: 10 | মোট: 35
and -> ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()
বন্ধনী ছাড়া -> ValueError
50 & sales[0] = [18  2  0 50 50 16 18]
any/all: True True

np.where — মান বাছাই আর ঠিকানা খোঁজা

np.where-এর দুটি আলাদা চেহারা আছে, আর দুটিকে গুলিয়ে ফেলা খুব সাধারণ ভুল।

তিনটি argument: ঘরে ঘরে বাছাই। np.where(শর্ত, x, y) প্রতিটি ঘরে শর্ত True হলে x থেকে, False হলে y থেকে মান নেয়, আর একটি নতুন array দেয়; মূল array বদলায় না। Excel-এর IF function-এর মতো, কিন্তু পুরো টেবিলে একসঙ্গে।

np.where(sales[0] >= 60, "ভালো", "কম")
# ['কম' 'ভালো' 'ভালো' 'কম' 'কম' 'ভালো' 'কম']
np.where(sales > 80, 80, sales)[1]     # ৮০-এর ওপরে কেটে, চট্টগ্রামের সারি
# [68 34 26 56 80 71 73]               (np.clip(sales, None, 80)-ও একই কাজ করে)

একটি argument: True ঘরের ঠিকানা। np.where(শর্ত) আর np.nonzero(শর্ত) একই জিনিস: প্রতিটি দিকের জন্য একটি index array, একটি tuple-এ। 1-D হলেও ফল tuple, তাই শেষে একটি কমা দেখা যায়, যা অনেককে চমকে দেয়। NumPy-র docs নিজেই এই রূপের বদলে সরাসরি np.nonzero লিখতে পরামর্শ দেয়, কারণ নামটিই কাজ বলে দেয়।

np.where(sales[0] > 70)          # (array([1, 5]),)   ঢাকার রবি আর বৃহঃ
np.nonzero(sales > 80)           # (array([1, 3, 4]), array([4, 2, 6]))
np.argwhere(sales > 80)          # [[1 4] [3 2] [4 6]]   প্রতি সারিতে একটি (সারি, কলাম) জোড়া
np.flatnonzero(sales > 80)       # [11 23 34]          সমতল index: সারি × 7 + কলাম

np.nonzero-এর দুটি array পাশাপাশি পড়তে হয়: (1, 4), (3, 2), (4, 6), মানে চট্টগ্রামের বুধ (88), খুলনার সোম (84), সিলেটের শুক্র (82). np.argwhere একই তথ্য জোড়া হিসেবে সাজায়, যা ছাপার জন্য সুবিধার; আর index হিসেবে আবার ব্যবহার করতে np.nonzero-এর tuple সরাসরি চলে: sales[np.nonzero(sales > 80)] দেয় [88 84 82], যা sales[sales > 80]-এর সমান।

৬ · Fancy index — তালিকা দিয়ে বাছাই, আর সবসময় copy

বাজার করার ফর্দের কথা ভাবুন: “৩ নম্বর তাক, তারপর ১ নম্বর তাক”। ক্রম আপনার ইচ্ছামতো, একই তাক দুবারও লেখা যায়। NumPy-তে integer-এর একটি list বা array দিয়ে index করাকে বলে fancy indexing (অফিসিয়াল নাম advanced indexing). sales[[3, 1]] দেয় খুলনা আর চট্টগ্রামের সারি, ঠিক এই ক্রমে; sales[[0, 0, 4]] ঢাকার সারি দুবার আর সিলেটের একবার।

Slice-এর সঙ্গে মূল পার্থক্য: তালিকার index-গুলো কোনো নিয়মিত লাফ মেনে চলে না (৩, তারপর ১), তাই শুধু শুরুর ঠিকানা আর strides দিয়ে এদের বর্ণনা করা যায় না। NumPy-কে তাই সংখ্যাগুলো নতুন memory-তে কপি করতে হয়। Fancy index সবসময় copy দেয়, আর boolean mask দিয়ে পড়াও একই কারণে copy. নিচের ধাপে দেখুন এর ফল কী।

1top = sales[[3, 1]]        # খুলনা, চট্টগ্রাম2np.shares_memory(top, sales)3top[0, 0] = 04sales[[3, 1]][0, 0] = 0    # শিকলবাঁধা5sales[[3, 1], 0] = 0       # এক ধাপে

দুটি তালিকা একসঙ্গে — জোড়া, নাকি জাল (np.ix_)

দুটি দিকেই তালিকা দিলে NumPy সেগুলো জোড়া হিসেবে পড়ে, প্রথমটির সঙ্গে প্রথমটি, দ্বিতীয়টির সঙ্গে দ্বিতীয়টি। “ঢাকা আর রাজশাহীর রবি আর মঙ্গলবার” চাইলে অনেকে লেখেন sales[[0, 2], [1, 3]], আর পান মাত্র দুটি সংখ্যা: (0, 1) আর (2, 3) ঘর। চারটি ঘরের পুরো জাল (প্রতিটি সারি × প্রতিটি কলাম) চাইলে np.ix_ লাগে, যা তালিকা দুটিকে এমন আকারে সাজায় যাতে সব জোড়া তৈরি হয়।

sales[[0, 2], [1, 3]]                    # [74 28]      শুধু (0,1) আর (2,3)
sales[np.ix_([0, 2], [1, 3])]            # [[74 50]
                                         #  [75 28]]    ২ × ২ জাল
sales[np.ix_([0, 2], [1, 3, 5])]         # [[74 50 80]
                                         #  [75 28 51]] ২ × ৩ জাল
sales[[0, 2]][:, [1, 3]]                 # একই জাল, কিন্তু দুটি copy বানিয়ে

শেষ লাইনটিও ঠিক ফল দেয়, কারণ এটি শুধু পড়া। কিন্তু একই রূপে বসাতে গেলে (sales[[0, 2]][:, [1, 3]] = 0) সেই শিকলবাঁধা ফাঁদ: কিছুই বদলাবে না। বসানোর জন্য sales[np.ix_([0, 2], [1, 3])] = 0 লিখুন। পর্ব ১৫-এ broadcasting শিখলে বুঝবেন np.ix_ ভেতরে আসলে কী করে: সারির তালিকাকে shape (2, 1) আর কলামের তালিকাকে (1, 2) বানায়, যাতে broadcasting সব জোড়া তৈরি করে।

৭ · সেরাটি আর সেরা k-টি — argmax, argsort, argpartition

ক্রিকেটের স্কোরকার্ডে “সর্বোচ্চ রান” জানা এক জিনিস, আর “সর্বোচ্চ রান কে করেছে” জানা আরেক জিনিস। sales.max() প্রথম প্রশ্নের উত্তর দেয়: 88. কিন্তু ডেটার কাজে প্রায় সবসময় দ্বিতীয়টি লাগে: কোন জেলা, কোন দিন। NumPy-র যে function-এর নাম arg দিয়ে শুরু, সেগুলো মান নয়, index দেয়। আর সেই index দিয়ে অন্য array (জেলার নাম, দিনের নাম) থেকে তথ্য তোলা যায়, যা fancy indexing-এর সবচেয়ে কাজের ব্যবহার।

• argmax / argmin: সবচেয়ে বড় বা ছোট মানের index. 2-D-তে axis না দিলে array-কে সমতল ধরে একটি সংখ্যা দেয় (11), যাকে np.unravel_index দিয়ে (সারি, কলাম)-এ ফেরানো যায়। axis=1 দিলে প্রতিটি সারির সেরার index. সমান মান থাকলে প্রথমটি।
• argsort: এমন index-এর ক্রম, যা দিয়ে সাজালে array ছোট থেকে বড় হয়: a[np.argsort(a)] সাজানো a. খরচ O(n log n), মানে n দ্বিগুণ হলে কাজ দ্বিগুণের একটু বেশি।
• argpartition: np.argpartition(a, -k) index এমনভাবে সাজায় যে শেষ k-টি অবস্থানে বড় k-টির index থাকে, কিন্তু সেই k-টির নিজেদের মধ্যে ক্রম নিশ্চিত নয়, বাকিগুলোরও নয়। ভেতরে introselect নামের একটি selection অ্যালগরিদম চলে, গড়ে O(n) খরচে। বড় n আর ছোট k-তে (১০ লাখ পণ্যের মধ্যে সেরা ১০টি) এটি পুরো sort-এর চেয়ে সস্তা।

import numpy as np
rng = np.random.default_rng(42)
sales = rng.integers(20, 90, size=(5, 7))
districts = np.array(["ঢাকা", "চট্টগ্রাম", "রাজশাহী", "খুলনা", "সিলেট"])
days = np.array(["শনি", "রবি", "সোম", "মঙ্গল", "বুধ", "বৃহঃ", "শুক্র"])

total = sales.sum(axis=1)
order = np.argsort(total)            # ছোট থেকে বড়, index ফেরত দেয়
print("মোট:", total, "| argsort:", order)

top3 = order[::-1][:3]               # উল্টে প্রথম তিনটি
print("argsort top-3:", districts[top3], total[top3])

part = np.argpartition(total, -3)[-3:]   # বড় তিনটি, ক্রম নিশ্চিত নয়
print("argpartition:", part, districts[part])
part = part[np.argsort(total[part])[::-1]]  # শুধু ৩টি সাজানো
print("সাজানো:", districts[part], total[part])

flat = sales.argmax()                # সমতল (flat) index
i, j = np.unravel_index(flat, sales.shape)
print("argmax:", flat, "->", (int(i), int(j)), districts[i], days[j], sales[i, j])
print("প্রতি জেলার সেরা দিন:", days[sales.argmax(axis=1)])

মোট: [371 416 412 425 361] | argsort: [4 0 2 1 3]
argsort top-3: ['খুলনা' 'চট্টগ্রাম' 'রাজশাহী'] [425 416 412]
argpartition: [2 3 1] ['রাজশাহী' 'খুলনা' 'চট্টগ্রাম']
সাজানো: ['খুলনা' 'চট্টগ্রাম' 'রাজশাহী'] [425 416 412]
argmax: 11 -> (1, 4) চট্টগ্রাম বুধ 88
প্রতি জেলার সেরা দিন: ['বৃহঃ' 'বুধ' 'বুধ' 'সোম' 'শুক্র']

AI-এর কাজে top-k সর্বত্র: k-nearest neighbors-এ সবচেয়ে কাছের k-টি প্রতিবেশী (পর্ব ৫৭-এ NumPy দিয়ে নিজে লিখবেন), একটি recommendation system-এ সবচেয়ে মানানসই ১০টি পণ্য, embedding দিয়ে খোঁজায় (পর্ব ৬৯) সবচেয়ে কাছের লেখা, আর ভাষার model-এ পরের token বাছাইয়ের “top-k sampling”. সবখানে একই দুই ধাপ: অনেক স্কোর থেকে argpartition দিয়ে k-টি, তারপর সেগুলো সাজানো।

৮ · সাধারণ ভুল আর view-copy-র তালিকা

Indexing-এর ভুলগুলোর বিশেষত্ব হলো, এরা প্রায় কখনো error দেয় না। কোড চলে, সংখ্যা ছাপে, শুধু সংখ্যাগুলো ভুল। এমন silent bug ধরার একমাত্র উপায় হলো ভুলগুলো আগে থেকে চেনা।

ভুল ১ — শিকলবাঁধা assignment, যা কিছুই বদলায় না

sales[sales > 80][0] = 0        # কিছুই বদলায় না: mask দিয়ে পড়া একটি copy
sales[[3, 1]][0, 0] = 0         # কিছুই বদলায় না: fancy index একটি copy
sales[:, 1][[0, 2]] = 0         # বদলায়! প্রথম ধাপ slice (view), তারপর view-এ লেখা
sales[[0, 2], 1] = 0            # সবচেয়ে পরিষ্কার: এক বন্ধনীতে সব ঠিকানা

প্রথম দুটি লাইনে chained assignment একটি নামহীন copy-তে লেখে। তৃতীয়টি কাজ করে শুধু ভাগ্যক্রমে, কারণ প্রথম ধাপটি basic slice. কোনটি view আর কোনটি copy, তা মনে রেখে শিকল লেখার চেয়ে নিয়মটি সহজ: লেখার সময় সব ঠিকানা এক বন্ধনীতে। pandas-এ এই সমস্যাটি আরও পরিচিত, আর তার সমাধানের ইতিহাস ভাবনার প্রশ্ন ৩-এ।

ভুল ২ — শেষ সীমার এক-ঘর ভুল (off-by-one)

“সোম থেকে বুধবার” মানে কলাম 2, 3, 4. অনেকে লেখেন sales[:, 2:4], আর পান shape (5, 2), বুধবার বাদ। ঠিক হলো sales[:, 2:5], shape (5, 3). নিয়মটি মনে রাখার একটি সহজ কৌশল: stop − start = কয়টি ঘর। ৩টি দিন চাইলে stop = start + 3. দশমিক দিনের হিসাবে, শতাংশে, বা সময়ের জানালায় (শেষ ৭ দিন = a[-7:]) একই নিয়ম।

ভুল ৩ — shape-এর চমক

• sales[0] হলো (7,), sales[0:1] হলো (1, 7): model-এ একটি সারি দিতে গেলে প্রথমটিতে প্রায়ই “Expected 2D array” ধরনের error আসে।
• 2-D array-তে mask দিলে ফল 1-D: sales[sales > 80] হলো [88 84 82], shape (3,)। কোন জেলা, কোন দিন, সেই তথ্য হারিয়ে যায়; দরকার হলে np.nonzero বা np.where(শর্ত, sales, 0), যা আকার রাখে।
• sales[2, 4] একটি NumPy scalar (np.int64), array নয়; এর ndim 0. ছোট কথা, কিন্তু JSON-এ লেখার সময় int(...) দিয়ে Python সংখ্যায় না আনলে error হতে পারে।

কোনটি view, কোনটি copy — এক নজরে

তালিকা মুখস্থ না করে নিয়মটি বুঝুন: শুরুর ঠিকানা আর নিয়মিত লাফ (strides) দিয়ে যদি ফলটি বর্ণনা করা যায়, তাহলে view; না গেলে copy. আর সন্দেহ হলে আন্দাজ নয়, np.shares_memory(x, a) চালিয়ে দেখুন। NumPy-র গতি আর memory নিয়ে আরও বিস্তারিত পর্ব ১৯ · NumPy-র গতি — memory, dtype, view আর কখন loop-ই ঠিক-এ আসবে।

৯ · AI-এর যুগে — AI সহকারীর indexing কোড যাচাই

“যেসব দিনে বিক্রি ৫০ থেকে ৭৫-এর মধ্যে, সেগুলো বের করার কোড চাই” লিখলে একটি AI সহকারী সাথে সাথে NumPy বা pandas কোড দেবে। এই পর্বের বিষয়গুলোতে AI সহকারীর ভুলের একটি চেনা ধরন আছে, কারণ ভুল কোডও প্রায়ই চলে:

• mask জোড়ায় and/or লেখে, বা & দেয় কিন্তু বন্ধনী দেয় না; তারপর error এলে try/except: pass দিয়ে চাপা দেয়।
• শিকলবাঁধা assignment লেখে (a[mask][0] = x), বা function-এর ভেতরে slice বদলে ডাকা জায়গার array চুপচাপ বদলে দেয়, কারণ ধরে নেয় slice মানে copy.
• পুরোনো বা বানানো API: NumPy 1.24 থেকে সরিয়ে দেওয়া np.float আর np.int, অস্তিত্বহীন np.argtopk; আবার উল্টোটাও ঘটে, খুব নতুন সংস্করণে যোগ হওয়া parameter (যেমন np.argsort-এর descending) আপনার পুরোনো version-এ নেই। আর pandas 3-এ যা আর কাজ করে না, সেই শিকলবাঁধা df[...][...] = x.
• argpartition-এর ফলকে সাজানো ধরে নেয়, বা argsort()[:3] দিয়ে সবচেয়ে কম তিনটিকে “সেরা” বলে; আর পরে model-এর কাজে পুরো ডেটার mask বা ranking দিয়ে test অংশ বাছাই করে data leakage ঘটায়।

AI-এর কোড হাতে পেলে — যাচাইয়ের চেকলিস্ট

• নিজে চালিয়েছি, আর ৩–৪টি ঘর হাতে মিলিয়েছি (যেমন sales[2, 4] সত্যিই রাজশাহীর বুধবার কি না)
• প্রতিটি ধাপের পর .shape ছেপে দেখেছি; (n,) আর (n, 1)-এর পার্থক্য কোথাও চুপচাপ ঢুকে পড়েনি
• mask-এ and/or/not নেই, প্রতিটি তুলনা বন্ধনীতে; কোথাও a[x][y] = ... ধরনের শিকলবাঁধা লেখা নেই
• যে function array পায়, সে তা বদলায় কি না দেখেছি; বদলালে .copy() আছে, আর np.shares_memory দিয়ে যাচাই করেছি
• প্রতিটি অচেনা function আর parameter নিজের NumPy version-এর অফিসিয়াল docs-এ (numpy.org) মিলিয়েছি; top-k-এর ক্রম আর tie-এর নিয়ম হাতে যাচাই করেছি
• কোনো warning বা error লুকানো হয়নি; মান বদলালে কয়টি ঘর বদলেছে গুনে লিখেছি; ক্রেতার নাম-ফোনের মতো আসল ডেটা AI-তে পেস্ট করিনি