Vectorization আর broadcasting — loop ছাড়াই হিসাব

আগের দুই পর্বে NumPy array-র shape আর dtype (পর্ব ১৩ · NumPy array — shape, dtype আর list-এর চেয়ে কেন দ্রুত) আর indexing ও slicing (পর্ব ১৪ · Indexing আর slicing — boolean mask, fancy index, view আর copy) এসেছে। এই পর্বে সেই array দিয়ে আসল হিসাব। দুটি ধারণা: vectorization মানে loop না লিখে পুরো array-র ওপর একটি expression লেখা, আর broadcasting মানে ভিন্ন shape-এর দুটি array-কে কপি না করে মিলিয়ে নেওয়ার নিয়ম। কেন খাঁটি Python-এর loop সংখ্যায় ধীর, তার প্রথম মাপ দেখেছেন পর্ব ৯-এর শেষ অংশে। এই পাতার সব কোড ব্রাউজারেই চলে (Pyodide, মানে WebAssembly-তে বানানো আসল CPython); প্রথমবার NumPy নামাতে কয়েক সেকেন্ড লাগতে পারে।

১ · Element-wise হিসাব — একসঙ্গে সব ঘরে একই কাজ

NumPy-তে দুটি একই shape-এর array-র মধ্যে +, -, *, /, ** বা তুলনার চিহ্ন (>, ==) লিখলে কাজটি হয় element-wise: প্রথম ঘরের সঙ্গে প্রথম ঘর, দ্বিতীয়টির সঙ্গে দ্বিতীয়টি। ফলও একই shape-এর একটি নতুন array.

price = np.array([120, 450, 80])      # টাকা
qty   = np.array([  2,   1,  5])
price * qty                           # array([240, 450, 400])
price * qty > 300                     # array([False,  True,  True])
np.sqrt(np.array([9.0, 16.0]))        # array([3., 4.])

এখানে দুটি জিনিস লক্ষ করুন। এক, Python-এর list-এ [120, 450] * 2 লিখলে list দুবার পাশাপাশি জুড়ে যায়, সংখ্যা দ্বিগুণ হয় না; array-তে একই চিহ্নের মানে সম্পূর্ণ আলাদা। দুই, np.sqrt, np.exp, np.log, np.maximum-এর মতো function-গুলোও element-wise কাজ করে। NumPy এদের বলে ufunc (universal function): C-তে লেখা ছোট একটি loop, যা একটি dtype-এর সংখ্যার ওপর টানা চলে। a + b লেখা আসলে np.add(a, b) ডাকা। ufunc-এর পুরো পরিবার, axis ধরে যোগফল আর random সংখ্যা আসবে পর্ব ১৬ · গাণিতিক কাজ, aggregation আর random-এ।

Element-wise হিসাবের ভেতরে আসলে কী হয়, ছোট করে বলি। Python-এর loop-এ প্রতিটি উপাদানের জন্য interpreter-কে type দেখতে হয়, গুণের নিয়ম খুঁজতে হয়, ফলের জন্য একটি নতুন Python object বানাতে হয়। ufunc-এ এই যাচাই পুরো array-র জন্য একবার হয় (দুটিই int64, তাই int64-এর গুণ), তারপর compiled কোড কাঁচা সংখ্যাগুলোর ওপর দিয়ে চলে যায়। আধুনিক CPU একটি নির্দেশে কয়েকটি সংখ্যা একসঙ্গে গুণ করতে পারে (SIMD), আর NumPy-র অনেক ufunc তা কাজে লাগায়। “Vectorization” শব্দটি এই দুই অর্থেই ব্যবহার হয়: Python-এর ভাষায় loop-হীন array expression, আর CPU-র ভাষায় একসঙ্গে কয়েকটি সংখ্যার নির্দেশ। এই কোর্সে প্রথম অর্থটিই প্রধান।

২ · Loop থেকে array expression — বাজারঘরের অর্ডারের মোট দাম

বাজারঘরের (এই কোর্সের কাল্পনিক অনলাইন দোকান) প্রতিটি অর্ডারে একটি দাম (পয়সায়), একটি পরিমাণ আর একটি ছাড়ের হার আছে, আর মোটের ওপর ১৫% ভ্যাট বসে (এখানে শুধু উদাহরণের হার; আসল ভ্যাটের নিয়ম হিসাবের নীতি থেকে নিন)। একটি অর্ডারের মোট:

মোট = দাম × পরিমাণ × (১ − ছাড়) × (১ + ভ্যাট)

Loop দিয়ে লিখলে প্রতিটি অর্ডারের জন্য এই সূত্র একবার। Array দিয়ে লিখলে সূত্রটি একবারই, পুরো কলামের ওপর। রূপান্তরের নিয়মটি যান্ত্রিক: loop-এর ভেতরের price[i]-কে price দিয়ে বদলান, i মুছে দিন, আর if থাকলে তাকে np.where বা boolean mask দিয়ে বদলান (mask এসেছে পর্ব ১৪-এ)।

এবার এক লাখ অর্ডারে তিনটি পথ মেপে দেখি: খাঁটি Python (list আর comprehension), array expression, আর np.vectorize দিয়ে মোড়ানো Python function (এর কথা অংশ ৮-এ)। হিসাব পয়সায়; ছাড় আর ভ্যাটের পরে ভগ্নাংশ আসে, তাই শেষে পূর্ণ পয়সায় round. দুই পথেই round একই নিয়মে হয় (Python-এর round আর np.round দুটিই ঠিক মাঝখানের মানকে জোড় সংখ্যার দিকে নেয়), তাই ফল হুবহু মেলার কথা।

import time
import numpy as np

rng = np.random.default_rng(42)
n = 100_000                                     # এক লাখ অর্ডার
price = rng.integers(5_000, 300_000, size=n, dtype=np.int64)  # পয়সায়
qty = rng.integers(1, 6, size=n, dtype=np.int64)
disc = rng.choice([0.0, 0.05, 0.10], size=n)    # ছাড়ের হার
VAT = 0.15

t0 = time.perf_counter()                        # ১) Python loop
P, Q, D = price.tolist(), qty.tolist(), disc.tolist()
loop = [round(p * q * (1 - d) * (1 + VAT)) for p, q, d in zip(P, Q, D)]
t1 = time.perf_counter()                        # ২) array expression
vec = np.round(price * qty * (1 - disc) * (1 + VAT)).astype(np.int64)
t2 = time.perf_counter()                        # ৩) np.vectorize
f = np.vectorize(lambda p, q, d: round(p * q * (1 - d) * (1 + VAT)))
npv = f(price, qty, disc)
t3 = time.perf_counter()

print("প্রথম ৩টি অর্ডার (পয়সা):", vec[:3])
print("তিন পথের ফল এক?", np.array_equal(vec, loop), np.array_equal(vec, npv))
print("মোট বিক্রি (টাকা):", vec.sum() // 100)
for name, t in [("loop", t1 - t0), ("array", t2 - t1), ("np.vectorize", t3 - t2)]:
    print(f"{name:13}{t * 1000:8.1f} ms")
print(f"array প্রায় {(t1 - t0) / (t2 - t1):.0f} গুণ দ্রুত loop-এর চেয়ে")

প্রথম ৩টি অর্ডার (পয়সা): [162128 724449 615094]
তিন পথের ফল এক? True True
মোট বিক্রি (টাকা): 499916713
loop             39.8 ms
array             2.4 ms
np.vectorize     47.9 ms
array প্রায় 17 গুণ দ্রুত loop-এর চেয়ে

৩ · Broadcasting-এর নিয়ম — ডান দিক থেকে মেলানো

অংশ ২-এ price * 1.15 লিখেছেন: একটি এক লাখ ঘরের array আর একটি মাত্র সংখ্যা। Shape আলাদা, তবু কাজ হলো। কারণ NumPy সংখ্যাটিকে এমনভাবে ব্যবহার করেছে যেন সেটি এক লাখ ঘরে বসানো, কিন্তু আসলে এক লাখ কপি বানায়নি। এটিই broadcasting-এর সবচেয়ে সরল রূপ। একই নিয়ম আরও সাধারণ: একটি টেবিলের প্রতিটি সারিতে একটি সারি যোগ করা, বা প্রতিটি কলামে একটি কলাম।

NumPy-র অফিসিয়াল docs (Broadcasting পাতা) নিয়মটি এভাবে বলে; বাংলায় তিনটি বাক্যে:

একটি উদাহরণে নিয়ম তিনটি একসঙ্গে দেখি: a-এর shape (3, 1) (তিনটি সারির একটি কলাম), b-এর shape (4,) (চারটি সংখ্যার একটি সারি)। নিচের ছবি আর তার পরের ধাপগুলো একই হিসাব।

# shape (3, 1)
a = np.array([[10], [20], [30]])
# shape (4,)
b = np.array([1, 2, 3, 4])
a + b   # ফলের shape কী?

a.shape :  (3, 1)
b.shape :  (   4)
বাঁয়ে 1 বসিয়ে:
b.shape :  (1, 4)

a.shape :  (3, 1)
b.shape :  (1, 4)
           ─────
শেষ ঘর: 1 আর 4
একটি 1, তাই মেলে → 4

a.shape :  (3, 1)
b.shape :  (1, 4)
           ─────
প্রথম ঘর: 3 আর 1
একটি 1, তাই মেলে → 3
ফলের shape = (3, 4)

a টানা হলো ডানে:
[[10 10 10 10]
 [20 20 20 20]
 [30 30 30 30]]
b টানা হলো নিচে:
[[1 2 3 4]
 [1 2 3 4]
 [1 2 3 4]]
strides → (8, 0)

a + b
[[11 12 13 14]
 [21 22 23 24]
 [31 32 33 34]]

Strides হলো প্রতিটি মাত্রায় এক ঘর এগোতে মেমরিতে কত বাইট সরতে হয় তার হিসাব; view আর copy এসেছে পর্ব ১৪-এ, আর strides-সহ মেমরির পুরো ছবি পর্ব ১৯ · NumPy-র গতি — memory, dtype, view আর কখন loop-ই ঠিক-এ। Broadcasting-এর মূল কৌশল এই stride 0: টানা মাত্রায় NumPy পা না সরিয়ে একই সংখ্যা পড়তে থাকে।

৪ · Shape-এর হিসাব — কোন জোড়া মেলে, কোনটি error দেয়

Broadcasting-এ দক্ষ হওয়ার একমাত্র উপায় অনেকগুলো shape-এর জোড়া নিজে মিলিয়ে দেখা। নিচের টেবিলের প্রতিটি সারি ডান দিক থেকে মেলানো হয়েছে; NumPy docs-এর উদাহরণের মতো কয়েকটি জোড়াও রাখা আছে। প্রথমে ফলের কলাম ঢেকে নিজে চেষ্টা করুন।

কয়েকটি সারি আলাদা করে দেখার মতো। (256, 256, 3) আর (3,) হলো একটি রঙিন ছবি (উচ্চতা × প্রস্থ × লাল-সবুজ-নীল) আর তিনটি channel-এর জন্য তিনটি সংখ্যা; প্রতিটি pixel-এর লাল ভাগ প্রথম সংখ্যা দিয়ে, সবুজ দ্বিতীয়টি দিয়ে গুণ হয়। ছবি নিয়ে পুরো কাজ আসবে পর্ব ১৮ · ছবি মানেই array-এ। (0, 3)-এর সারিটি মনে করিয়ে দেয়, 0 মাপের মাত্রাও নিয়ম মানে: 0 আর 1 মেলে, ফল 0, মানে একটি খালি array, error নয়। আর শেষ সারিতে ডানের জোড়া (1 আর 3) মিলেছে, কিন্তু পরের জোড়ায় আটকে গেছে; একটি জোড়া না মিললেই পুরো হিসাব বাতিল।

সবচেয়ে বেশি ভুল হয় (3, 4) আর (3,)-এ। মানুষের চোখে “৩টি সারি, ৩টি মান, প্রতিটি সারিতে একটি” স্পষ্ট লাগে। কিন্তু NumPy বাঁ দিক থেকে নয়, ডান দিক থেকে মেলায়। নিচের ধাপে দেখুন কেন এটি ভেঙে পড়ে, আর ঠিক করার পথ।

sales = np.array(
  [[12, 15,  9, 14],  # ঢাকা
   [ 8,  6, 10,  8],  # চট্টগ্রাম
   [ 3,  5,  4,  4]]) # সিলেট
m = sales.mean(axis=1)
# m = [12.5  8.   4. ]
sales - m   # ?

sales.shape : (3, 4)
m.shape     : (   3)
বাঁয়ে 1     : (1, 3)

4 আর 3:
সমান নয়, কোনোটি 1 নয়
→ মেলে না
বাকি মাত্রা দেখার দরকারই নেই

ValueError: operands
could not be broadcast
together with shapes
(3,4) (3,)
# আসলে এক লাইনে ছাপা হয়

m_col = m[:, None]
# বা m.reshape(-1, 1)
sales - m_col
# (3, 4) − (3, 1) → (3, 4)
[[-0.5  2.5 -3.5  1.5]
 [ 0.  -2.   2.   0. ]
 [-1.   1.   0.   0. ]]

এবার নিয়মগুলো একটি ছোট function-এ লিখে NumPy-র সঙ্গে মিলিয়ে দেখি। predict শুধু নিয়ম তিনটি মানে; actual সত্যিই দুটি শূন্যের array যোগ করে দেখে NumPy কী করে। দুটির উত্তর প্রতিটি জোড়ায় মিললে বুঝবেন নিয়মটি ঠিক বুঝেছেন।

import numpy as np

def predict(a, b):
    """NumPy docs-এর নিয়মে ফলের shape, নয়তো কারণসহ error."""
    n = max(len(a), len(b))
    a = (1,) * (n - len(a)) + tuple(a)      # না থাকা মাত্রা = 1
    b = (1,) * (n - len(b)) + tuple(b)
    out = []
    for x, y in zip(reversed(a), reversed(b)):   # ডান দিক থেকে
        if x == y or y == 1:
            out.append(x)
        elif x == 1:
            out.append(y)
        else:
            return f"error ({x} বনাম {y})"
    return tuple(reversed(out))

def actual(a, b):                           # NumPy নিজে কী বলে
    try:
        return (np.zeros(a) + np.zeros(b)).shape
    except ValueError:
        return "ValueError"

pairs = [((3, 4), (4,)), ((3, 1), (4,)), ((5, 7), (5, 1)),
         ((5, 7), (5,)), ((2, 1, 3), (4, 1)), ((6, 1, 2), (1, 6, 2)),
         ((8, 1, 6, 1), (7, 1, 5)), ((3,), ()), ((2, 3), (3, 2)),
         ((0, 3), (1, 3))]
for a, b in pairs:
    p, r = predict(a, b), actual(a, b)
    same = p == r or (p[0] == "e" and r == "ValueError")
    print(f"{str(a):13}{str(b):10}→ {str(p):17}{str(r):13}{'মিলেছে' if same else 'মেলেনি'}")
print(np.broadcast_shapes((8, 1, 6, 1), (7, 1, 5)))

(3, 4)       (4,)      → (3, 4)           (3, 4)       মিলেছে
(3, 1)       (4,)      → (3, 4)           (3, 4)       মিলেছে
(5, 7)       (5, 1)    → (5, 7)           (5, 7)       মিলেছে
(5, 7)       (5,)      → error (7 বনাম 5) ValueError   মিলেছে
(2, 1, 3)    (4, 1)    → (2, 4, 3)        (2, 4, 3)    মিলেছে
(6, 1, 2)    (1, 6, 2) → (6, 6, 2)        (6, 6, 2)    মিলেছে
(8, 1, 6, 1) (7, 1, 5) → (8, 7, 6, 5)     (8, 7, 6, 5) মিলেছে
(3,)         ()        → (3,)             (3,)         মিলেছে
(2, 3)       (3, 2)    → error (3 বনাম 2) ValueError   মিলেছে
(0, 3)       (1, 3)    → (0, 3)           (0, 3)       মিলেছে
(8, 7, 6, 5)

৫ · কলাম বানানো — np.newaxis, None, reshape(-1, 1) আর keepdims

অংশ ৪-এর সমাধানে সব কাজ হলো একটি মাপ 1-এর মাত্রা ঠিক জায়গায় বসানো। এর চারটি প্রচলিত উপায় আছে, আর চারটিই একই ফল দেয়:

np.newaxis আসলে None-এরই আরেক নাম (লেখকের যন্ত্রে np.newaxis is None চালালে True); index-এর যে জায়গায় এটি বসে, সেখানে মাপ 1-এর একটি নতুন মাত্রা ঢোকে। reshape-এ -1 মানে “এই মাত্রার মাপ আপনি হিসাব করে নিন”: ১২টি উপাদানের array-তে reshape(-1, 1) দিলে (12, 1), reshape(-1, 4) দিলে (3, 4). দুটি পথেই ডেটা কপি হয় না, একটি নতুন view তৈরি হয়। আর scikit-learn-এর প্রায় সব model ইনপুট হিসেবে ২-মাত্রার টেবিল (সারি = নমুনা, কলাম = feature) চায়; একটি মাত্র feature থাকলে x.reshape(-1, 1) সেই কারণেই সবখানে দেখবেন (scikit-learn আসবে পরের মডিউলগুলোতে)।

keepdims সবচেয়ে কাজের অভ্যাস। sales.sum(axis=1)-এর shape (3,), কিন্তু sales.sum(axis=1, keepdims=True)-এর shape (3, 1): যে axis ধরে যোগ হলো, সেটি হারিয়ে না গিয়ে মাপ 1 হয়ে থাকে। ফলে ফলটি কোনো বাড়তি কাজ ছাড়াই মূল (3, 4) টেবিলের সঙ্গে ঠিক দিকে broadcast হয়, আর টেবিলটি বর্গাকার হলেও ভুল দিকে যাওয়ার সুযোগ থাকে না।

৬ · রোজকার তিন ছাঁচ — centering, সারির শতাংশ আর outer product

Centering — প্রতিটি জেলার নিজের গড় থেকে দূরত্ব

বাজারঘরের ম্যানেজার জানতে চান, কোন জেলায় কোন দিন “স্বাভাবিকের চেয়ে বেশি” অর্ডার এসেছে। ঢাকার ৬০টি অর্ডার আর সিলেটের ৬০টির মানে এক নয়, কারণ দুই জেলার স্বাভাবিক মাত্রা আলাদা। তাই প্রতিটি জেলার সংখ্যা থেকে সেই জেলারই গড় বাদ দেওয়া হয়। একে বলে centering: নতুন মানগুলোর গড় শূন্য, ধনাত্মক মানে গড়ের বেশি, ঋণাত্মক মানে কম। মেশিন লার্নিং-এর অনেক পদ্ধতির (যেমন PCA, আর scaling-এর পর gradient-ভিত্তিক মডেল) আগে ঠিক এই ধাপটি করা হয়, সাধারণত কলাম ধরে। নিচের ধাপে কোড চলতে দেখুন।

1sales = np.array([[12, 15, 9, 14],
  [8, 6, 10, 8], [3, 5, 4, 4]])2m = sales.mean(axis=1,
         keepdims=True)3centred = sales - m4centred.sum(axis=1)

সারির শতাংশ — প্রতিটি জেলার সপ্তাহ কোন দিনে ভারী

একই ছাঁচে ভাগ: প্রতিটি সারিকে তার নিজের যোগফল দিয়ে ভাগ করলে প্রতিটি দিনের ভাগ (শতাংশ) পাওয়া যায়, আর প্রতিটি সারির যোগফল ১০০. এবার আসল আকারে চালাই: পাঁচ জেলা × সাত দিন, seed দেওয়া অর্ডার-সংখ্যা। কোডের শুরুতে ইচ্ছে করে ভুল পথটিও আছে, যাতে আসল error বার্তাটি নিজের চোখে দেখেন।

import numpy as np
np.set_printoptions(precision=1, suppress=True)

rng = np.random.default_rng(42)
districts = ["ঢাকা", "চট্টগ্রাম", "রাজশাহী", "সিলেট", "খুলনা"]
sales = rng.integers(20, 120, size=(5, 7))      # ৫ জেলা × ৭ দিন, অর্ডার-সংখ্যা
print("sales.shape:", sales.shape)

try:                                            # ভুল চেষ্টা: (5, 7) − (5,)
    sales - sales.mean(axis=1)
except ValueError as e:
    print("ValueError:", e)

mean_col = sales.mean(axis=1, keepdims=True)    # প্রতিটি জেলার গড়, (5, 1)
print("mean_col.shape:", mean_col.shape)
centred = sales - mean_col                      # (5, 7) − (5, 1) → (5, 7)
for name, row, m in zip(districts, centred, mean_col[:, 0]):
    print(f"{name:<9} গড় {m:5.1f} →", row)
print("প্রতিটি সারির যোগফল:", centred.sum(axis=1).round(10))

pct = sales / sales.sum(axis=1, keepdims=True) * 100   # সারির শতাংশ
print("ঢাকার ৭ দিনের ভাগ (%):", pct[0])
print("প্রতিটি সারিতে মোট %:", pct.sum(axis=1))

sales.shape: (5, 7)
ValueError: operands could not be broadcast together with shapes (5,7) (5,) 
mean_col.shape: (5, 1)
ঢাকা      গড়  67.0 → [-39.  30.  18.  -4.  -4.  38. -39.]
চট্টগ্রাম গড়  76.6 → [ 12.4 -36.6 -47.6  -4.6  40.4  16.4  19.4]
রাজশাহী   গড়  75.7 → [ 15.3  22.3  -4.7 -43.7  27.3 -10.7  -5.7]
সিলেট     গড়  78.7 → [-21.7 -40.7  33.3  19.3   5.3 -18.7  23.3]
খুলনা     গড়  65.3 → [  8.7  -1.3  -0.3 -23.3 -36.3   9.7  42.7]
প্রতিটি সারির যোগফল: [ 0.  0.  0.  0. -0.]
ঢাকার ৭ দিনের ভাগ (%): [ 6.  20.7 18.1 13.4 13.4 22.4  6. ]
প্রতিটি সারিতে মোট %: [100. 100. 100. 100. 100.]

Outer product — প্রতিটি জোড়ার গুণফলের টেবিল

বাজারঘরের দাম-তালিকায় তিনটি পণ্য (চাল কেজি ৬০, ডাল কেজি ১২০, আলু কেজি ৪৫ টাকা) আর চারটি পরিমাণ (১, ২, ৫, ১০ কেজি)। প্রতিটি পণ্য-পরিমাণ জোড়ার দাম চাই, মানে একটি ৩ × ৪ টেবিল। দামকে কলাম আর পরিমাণকে সারি হিসেবে রাখলে broadcasting নিজেই সেই টেবিল বানায়:

price = np.array([60, 120, 45])
kg    = np.array([1, 2, 5, 10])
price[:, None] * kg          # (3, 1) × (4,) → (3, 4)
# [[  60  120  300  600]
#  [ 120  240  600 1200]
#  [  45   90  225  450]]
np.outer(price, kg)          # একই ফল

দুটি vector-এর প্রতিটি জোড়ার গুণফলের এই টেবিলের নাম outer product. দৈর্ঘ্য m আর n হলে ফল m × n. ছবি ১৫.১-এর যোগটিও আসলে একই ছাঁচ, শুধু গুণের বদলে যোগ (np.add.outer) ব্যবহার হয়। Linear algebra-য় outer product-এর ভূমিকা (rank-1 matrix, covariance) আসবে পর্ব ১৭ · NumPy-তে linear algebra-এ।

৭ · Distance matrix — ছয়টি ডেলিভারি পয়েন্ট আর মেমরির হিসাব

বাজারঘরের একজন ডেলিভারিম্যান গুদাম থেকে বের হয়ে পাঁচটি বাড়িতে যাবেন। রুট ঠিক করার আগে প্রতিটি জায়গা থেকে প্রতিটি জায়গার দূরত্ব লাগে, রিকশাওয়ালা যেমন মনে মনে জানেন কোন মোড় থেকে কোন গলি কত দূর। এই টেবিলের নাম distance matrix: সারি i, কলাম j-এর ঘরে বিন্দু i থেকে j-এর দূরত্ব। kNN, clustering, আর রুট খোঁজার মতো অনেক AI কাজের ভেতরে এই টেবিলটিই থাকে।

দুটি বিন্দু (x₁, y₁) আর (x₂, y₂)-এর সরলরেখার (Euclidean) দূরত্ব:

d = √((x₁ − x₂)² + (y₁ − y₂)²)

এখানে √ মানে বর্গমূল। n টি বিন্দুর shape (n, 2) , প্রতিটি সারিতে x আর y. কৌশলটি হলো একই array-কে দুইভাবে দেখা: P[:, None, :]-এর shape (n, 1, 2) (“প্রতিটি i”), আর P[None, :, :]-এর shape (1, n, 2) , মানে “প্রতিটি j”. বিয়োগ করলে ডান থেকে 2↔2, 1↔n, n↔1, ফল (n, n, 2): প্রতিটি জোড়ার x আর y-এর পার্থক্য। তারপর বর্গ, শেষ axis ধরে যোগ, বর্গমূল, আর ফল (n, n). ছয়টি বিন্দু নিয়ে চালিয়ে দেখি, double loop-এর সঙ্গে মিলিয়ে, আর তারপর ১০০০টি বিন্দুতে মেমরি মাপি।

import math
import numpy as np
np.set_printoptions(precision=2, suppress=True)

# ছয়টি ডেলিভারি পয়েন্ট, গুদাম থেকে (x, y) কিলোমিটারে
P = np.array([[0.0, 0.0], [3.0, 4.0], [6.0, 0.0],
              [1.0, 7.0], [8.0, 6.0], [2.0, 2.0]])

diff = P[:, None, :] - P[None, :, :]           # (6,1,2) − (1,6,2) → (6,6,2)
D = np.sqrt((diff ** 2).sum(axis=-1))          # (6, 6)
print("diff.shape:", diff.shape, " D.shape:", D.shape)
print(D)

L = [[math.dist(a, b) for b in P.tolist()] for a in P.tolist()]
print("double loop-এর সঙ্গে মিলেছে?", np.allclose(D, L))
print("সমমিত?", np.allclose(D, D.T), " কর্ণ শূন্য?", np.all(np.diag(D) == 0))

m = 1000                                       # ১০০০টি পয়েন্ট হলে
Q = np.random.default_rng(42).random((m, 2))
big = Q[:, None, :] - Q[None, :, :]           # মাঝের অস্থায়ী array
Dbig = np.sqrt((big ** 2).sum(axis=-1))
for name, arr in [("পয়েন্ট Q", Q), ("মাঝের big", big), ("ফল Dbig", Dbig)]:
    print(f"{name:10}{str(arr.shape):15}{arr.nbytes:>12,} বাইট")

diff.shape: (6, 6, 2)  D.shape: (6, 6)
[[ 0.    5.    6.    7.07 10.    2.83]
 [ 5.    0.    5.    3.61  5.39  2.24]
 [ 6.    5.    0.    8.6   6.32  4.47]
 [ 7.07  3.61  8.6   0.    7.07  5.1 ]
 [10.    5.39  6.32  7.07  0.    7.21]
 [ 2.83  2.24  4.47  5.1   7.21  0.  ]]
double loop-এর সঙ্গে মিলেছে? True
সমমিত? True  কর্ণ শূন্য? True
পয়েন্ট Q (1000, 2)            16,000 বাইট
মাঝের big (1000, 1000, 2)  16,000,000 বাইট
ফল Dbig   (1000, 1000)      8,000,000 বাইট

এখান থেকে একটি সরল হিসাব। n টি বিন্দুতে মাঝের array n × n × 2 × 8 বাইট, মানে n²-এর সঙ্গে বাড়ে। বিন্দু ১০ গুণ (১০,০০০) হলে মেমরি ১০০ গুণ: ১৬০ কোটি বাইট, প্রায় ১.৬ GB, শুধু একটি অস্থায়ী array-র জন্য। আরও ১০ গুণ (১ লাখ বিন্দু) হলে ১৬০ GB, যা সাধারণ ল্যাপটপে বরাদ্দই হয় না। লেখকের যন্ত্রে (Python 3.14.4, NumPy 2.5.1) এমন একটি array চাইলে এই সত্যিকারের MemoryError এসেছিল:

>>> np.zeros((100_000, 100_000, 2))
MemoryError: Unable to allocate 149. GiB for an array with shape (100000, 100000, 2) and data type float64

১৬০ GB আর ১৪৯ GiB একই পরিমাণ: GiB-তে ১ GiB = 2³⁰ বাইট। বড় ডেটায় তিনটি প্রচলিত পথ আছে। এক, ভাগে ভাগে (chunk) হিসাব: একবারে ১০০০টি সারি নিয়ে (1000, n) টুকরো বানানো। দুই, অস্থায়ী array এড়ানোর গাণিতিক কৌশল: ‖a − b‖² = ‖a‖² + ‖b‖² − 2 a·b, যেখানে ‖a‖ মানে vector-এর দৈর্ঘ্য আর a·b হলো dot product; এতে (n, n, 2) নয়, সরাসরি (n, n) তৈরি হয় (dot product আর norm আসবে পর্ব ১৭-এ)। তিন, তৈরি টুল: SciPy-র scipy.spatial.distance.cdist, বা scikit-learn-এর pairwise_distances_chunked, যা ভাগে ভাগে কাজ করে। আর অনেক সময় পুরো টেবিলের দরকারই নেই: “প্রতিটি বাড়ির সবচেয়ে কাছের ৩টি বাড়ি” চাইলে KD-tree-র মতো কাঠামো পুরো n × n টেবিল না বানিয়েই উত্তর দেয়।

৮ · np.vectorize-এর সত্য, আর কখন loop-ই ঠিক

নাম শুনে মনে হয় np.vectorize যেকোনো Python function-কে vectorized করে দ্রুত বানিয়ে দেয়। আসলে তা করে না। NumPy-র docs-এ numpy.vectorize-এর পাতায় স্পষ্ট লেখা আছে যে এটি মূলত সুবিধার জন্য, গতির জন্য নয়, আর এর ভেতরের কাজ মূলত একটি for loop. অর্থাৎ এটি আপনার function-কে প্রতিটি উপাদানের জন্য একবার করে ডাকে, প্রতিবার Python-এর পুরো খরচসহ। অংশ ২-এর মাপে ঠিক এটিই দেখেছেন: np.vectorize-এর সময় comprehension-এর কাছাকাছি (ব্রাউজারের run-এ একটু বেশিও), আর array expression-এর বহু গুণ।

তাহলে এর কাজ কী? এটি broadcasting-এর সুবিধা দেয়: scalar-এর জন্য লেখা একটি function-কে আপনি সরাসরি array, এমনকি ভিন্ন shape-এর array দিয়েও ডাকতে পারেন, আর ফল আসে NumPy array হিসেবে। ছোট ডেটায়, পরীক্ষার কোডে, বা যেখানে function-টির ভেতরে জটিল if-else আর বাইরের library ডাকা আছে, সেখানে এটি সুবিধার। গতির জন্য আসল পথ হলো function-টিকে NumPy-র ufunc আর np.where দিয়ে নতুন করে লেখা।

কখন loop-ই ঠিক, তার একটি পরিষ্কার উদাহরণ: বাজারঘরের গুদামে চালের স্টক ৫০০ কেজি, অর্ডারগুলো একে একে আসে, আর স্টক শূন্যের নিচে নামার আগের অর্ডারগুলোই শুধু পূরণ হবে। প্রতিটি অর্ডারের সিদ্ধান্ত আগের সব অর্ডারের ওপর নির্ভর করে। এমন কিছু কাজ np.cumsum-এর মতো কৌশলে vectorize করা যায়, কিন্তু নিয়ম জটিল হলে (ফেরত, আংশিক পূরণ, অগ্রাধিকার) সাধারণ loop-ই পরিষ্কার আর যথেষ্ট দ্রুত। আর loop-কেও দ্রুত করার পথ আছে (Numba-র মতো compiler), যার আলোচনা, মাপজোক আর memory layout আসবে পর্ব ১৯ · NumPy-র গতি — memory, dtype, view আর কখন loop-ই ঠিক-এ। সাধারণ মাপজোকের নিয়ম আছে Python কোর্সের পারফরম্যান্স পর্বে।

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

টেবিলের প্রতিটি কলাম standardize করার বা বিন্দুগুলোর দূরত্ব বের করার কোড চাইলে একটি AI সহকারী কয়েক সেকেন্ডে NumPy কোড দেবে। বেশির ভাগ সময় তা চলবে। কিন্তু broadcasting-এর ভুল প্রায়ই error দেয় না, ভুল shape-এর একটি বিশ্বাসযোগ্য ফল দেয়। AI সহকারীরা প্রায়ই যা করে:

• (n,) আর (n, 1) মিশিয়ে ফেলে: y_true একটি কলাম আর y_pred একটি সারি হলে ((y_true - y_pred) ** 2).mean() একটি n × n টেবিলের গড় দেয়, কোনো error ছাড়াই। লেখকের যন্ত্রে ৪টি মানের এমন উদাহরণে আসল ফল 0.0, কিন্তু কোড ফেরত দিয়েছিল 2.5.
• বর্গাকার টেবিলে axis উল্টে দেয়, বা keepdims ছাড়া সারির গড় বাদ দেয়; ফল ভুল, কিন্তু shape ঠিক দেখায়।
• “দ্রুত করতে” np.vectorize বসায়, বা বড় ডেটায় (n, n, d)-এর অস্থায়ী array বানায়, যা আপনার ডেটায় মেমরি ছাড়িয়ে যাবে।
• পুরোনো API লেখে (NumPy 1.24-এ সরানো np.float, np.int, বা নতুন কোডে অনুৎসাহিত np.matrix-নির্ভর কোড), বা নেই এমন parameter বানায়; আর error চাপা দিতে np.seterr(all="ignore") বা warnings.filterwarnings("ignore") বসায়।
• গতির দাবি করে মাপ ছাড়াই (“এটি ১০০ গুণ দ্রুত”), আর train আর test ডেটা একসঙ্গে রেখে পুরো ডেটার গড় দিয়ে centering করে, যা পরে মডেলের মাপকে ভুলভাবে ভালো দেখায় (data leakage; split আগে, তারপর শুধু train-এর গড়)।

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

• প্রতিটি গুরুত্বপূর্ণ লাইনের পরে .shape ছেপে দেখেছি, আর ফলের shape যা আশা করেছিলাম তাই
• কোথাও (n,) আর (n, 1) মিশে n × n টেবিল তৈরি হয়নি; সারি ধরে কমানোর পরে keepdims=True বা [:, None] আছে
• ছোট ডেটায় একটি সাধারণ loop-এর ফলের সঙ্গে np.allclose দিয়ে মিলিয়েছি, আর ২–৩টি ঘর হাতে হিসাব করেছি
• সবচেয়ে বড় অস্থায়ী array-র মেমরি (shape-এর গুণফল × dtype-এর বাইট) আসল ডেটার মাপে হিসাব করেছি
• গতির দাবি time.perf_counter দিয়ে নিজে মেপেছি; np.vectorize-কে গতির সমাধান ধরিনি
• নিজের NumPy version-এর অফিসিয়াল docs-এ প্রতিটি অচেনা function মিলিয়েছি; কোনো warning চাপা নেই; centering-এর গড় শুধু train ডেটা থেকে; আসল ক্রেতার ডেটা AI-তে পেস্ট করিনি