NumPy-তে linear algebra — vector, matrix, dot product আর norm

এই পর্ব গণিতের ক্লাস নয়, NumPy-র হাতের কাজ। Vector কী, দুটি vector-এর মধ্যে কোণ বা মিল (similarity) কীভাবে ভাবতে হয়, সেই জ্যামিতিক ছবিটি আসবে পর্ব ৩৩-এ (Vector আর similarity — dot product, cosine আর embedding-এর ধারণা)। এখানে আমরা দেখব কম্পিউটারে সেই হিসাবগুলো কীভাবে লেখা হয়, কোন লাইনটি চুপচাপ ভুল ফল দেয়, আর ফল ঠিক কি না কীভাবে যাচাই করবেন। NumPy array-র shape আর dtype এসেছে পর্ব ১৩-এ, broadcasting পর্ব ১৫-এ; এখানে শুধু যতটুকু লাগে ততটুকু মনে করিয়ে দেওয়া হবে। কোড পাতাতেই চলবে (ব্রাউজারের ভেতরে Python, Pyodide); প্রথমবার চালাতে কয়েক সেকেন্ড লাগতে পারে।

১ · Vector আর matrix — NumPy-তে দুটিই শুধু array

বাজারঘরের (এই কোর্সের কাল্পনিক অনলাইন দোকান) তিনটি জনপ্রিয় পণ্য ধরুন: চাল প্রতি কেজি ৭৫ টাকা, মসুর ডাল প্রতি কেজি ১৩০ টাকা, সয়াবিন তেল প্রতি লিটার ১৯০ টাকা। দোকানের দেয়ালে টাঙানো দামের এই তালিকাটি তিনটি সংখ্যার একটি সারি। গণিতের ভাষায় এটি একটি vector: ক্রম মেনে সাজানো কয়েকটি সংখ্যা, যেখানে প্রতিটি অবস্থানের একটি অর্থ আছে (প্রথম ঘর চাল, দ্বিতীয় ঘর ডাল, তৃতীয় ঘর তেল)।

import numpy as np
price = np.array([75, 130, 190])      # চাল/কেজি, ডাল/কেজি, তেল/লিটার
price.shape                           # (3,)  — ১-মাত্রার, ৩টি ঘর

এবার চারটি অর্ডার। প্রথম অর্ডারে ২ কেজি চাল, ১ কেজি ডাল আর ১ লিটার তেল; দ্বিতীয়টিতে ৫ কেজি চাল আর ২ কেজি ডাল, তেল নেই; এভাবে আরও দুটি। প্রতিটি অর্ডার নিজেও তিন ঘরের একটি vector, আর চারটি অর্ডার পাশাপাশি সাজালে পাওয়া যায় একটি টেবিল: সারি মানে অর্ডার, কলাম মানে পণ্য। এই আয়তাকার সংখ্যার টেবিলটিই matrix.

qty = np.array([[2, 1, 1],    # অর্ডার ১
                [5, 2, 0],    # অর্ডার ২
                [1, 0, 2],    # অর্ডার ৩
                [3, 1, 1]])   # অর্ডার ৪
qty.shape                     # (4, 3) — ৪টি সারি, ৩টি কলাম

খেয়াল করুন, NumPy-তে আলাদা কোনো “vector” বা “matrix” type নেই। দুটিই সেই একই ndarray, শুধু মাত্রার সংখ্যা (ndim) আলাদা। কোন array কোন ভূমিকায় আছে, তা বলে দেয় তার shape. পুরো এই পর্বে একটি অভ্যাস গড়ে তুলুন: যেকোনো গুণের আগে দুই পাশের shape জোরে পড়ুন। এই পর্বের প্রায় প্রতিটি বাগ shape পড়লেই ধরা পড়ে।

একটি সূক্ষ্ম কথা এখনই জেনে রাখুন। খাতায় গণিত লেখার সময় vector-কে সাধারণত হয় খাড়া কলাম (column vector) হিসেবে, নয়তো শোয়ানো সারি (row vector) হিসেবে লেখা হয়। NumPy-র ১-মাত্রার array-র এমন কোনো দিক নেই: (3,) shape-এর array সারিও নয়, কলামও নয়, শুধু তিনটি সংখ্যা। গুণের সময় NumPy প্রসঙ্গ দেখে ঠিক করে নেয় এটিকে কীভাবে ধরবে। এটি সুবিধার, তবে অংশ ৪-এ দেখবেন কোথায় এটি বিভ্রান্তি তৈরি করে।

২ · * না @ — ঘরে ঘরে গুণ আর matrix গুণ

ম্যানেজার জানতে চান প্রতিটি অর্ডারের মোট বিল কত। নতুনদের প্রথম চেষ্টা প্রায়ই হয় qty * price. কোডটি চলে, কোনো error আসে না, একটি সংখ্যার টেবিলও আসে। কিন্তু সেটি মোট বিল নয়।

কারণটি পর্ব ১৫-এর broadcasting. * চিহ্নটি NumPy-তে সবসময় element-wise: দুই পাশের মিলে যাওয়া ঘরগুলো আলাদা আলাদা গুণ হয়। qty-র shape (4, 3), price-এর (3,); broadcasting-এর নিয়মে price-কে প্রতিটি সারির নিচে বসিয়ে দেওয়া হয়, তাই ফল হয় (4, 3): প্রতিটি অর্ডারের প্রতিটি পণ্যের আলাদা দাম, যাকে রসিদের “লাইন-আইটেম” বলা যায়। আর @ চিহ্নটি matrix গুণ: প্রতিটি সারির ঘরগুলো দামের সঙ্গে গুণ করে যোগ করে, তাই ফল হয় (4,), প্রতিটি অর্ডারের একটি করে মোট। নিচের কোড চালিয়ে দুটি ফল পাশাপাশি দেখুন।

import numpy as np

# বাজারঘরের দাম (টাকা): চাল/কেজি, ডাল/কেজি, তেল/লিটার
price = np.array([75, 130, 190])
# ৪টি অর্ডার × ৩টি পণ্য: কোন অর্ডারে কতটা
qty = np.array([[2, 1, 1],
                [5, 2, 0],
                [1, 0, 2],
                [3, 1, 1]])

line = qty * price      # element-wise: প্রতিটি ঘর আলাদা গুণ
total = qty @ price     # matrix গুণ: প্রতিটি সারির weighted sum

print("qty:", qty.shape, " price:", price.shape)
print("qty * price → shape", line.shape)
print(line)
print("qty @ price → shape", total.shape, total)
print("line.sum(axis=1):", line.sum(axis=1))
print("একই কি?", np.array_equal(total, line.sum(axis=1)))

# দুটি vector-এর ক্ষেত্রেও একই ফাঁদ
q = qty[0]
print("q * price:", q * price, "← এটি মোট নয়")
print("q @ price:", q @ price, " np.dot:", np.dot(q, price))

qty: (4, 3)  price: (3,)
qty * price → shape (4, 3)
[[150 130 190]
 [375 260   0]
 [ 75   0 380]
 [225 130 190]]
qty @ price → shape (4,) [470 635 455 545]
line.sum(axis=1): [470 635 455 545]
একই কি? True
q * price: [150 130 190] ← এটি মোট নয়
q @ price: 470  np.dot: 470

৩ · Matrix × vector মানে weighted sum — সারি ধরে ধরে

চায়ের দোকানের হিসাব খাতার কথা ভাবুন। দিনের শেষে দোকানি প্রতিটি খদ্দেরের লাইন দেখেন: “২ কাপ চা, ১টা বিস্কুট, ১টা কলা”। তারপর প্রতিটি জিনিসের সংখ্যাকে তার দামের সঙ্গে গুণ করে যোগ করেন। এটিই matrix-vector গুণ: প্রতিটি সারির জন্য একটি weighted sum, মানে “ওজন দেওয়া যোগফল”, যেখানে ওজন হলো দাম। গণিতের ভাষায়, যদি ফলটির নাম t হয়, তাহলে i-তম অর্ডারের জন্য:

t_i = ∑_j q_ij · p_j = q_i1p₁ + q_i2p₂ + q_i3p₃

এখানে qij মানে i-তম অর্ডারে j-তম পণ্যের পরিমাণ (qty[i, j]), pj মানে j-তম পণ্যের দাম, আর ∑ (সিগমা) মানে “সব j-এর জন্য যোগ করুন”। নিচের ধাপে চারটি সারি একটি একটি করে হিসাব হতে দেখুন। “পরে” চাপুন।

1total = np.zeros(4)2for i in range(4):3    total[i] = (qty[i] * price).sum()4# একই কাজ এক লাইনে: qty @ price

একই গুণকে আরেকভাবেও পড়া যায়, আর দ্বিতীয় পড়াটিও কাজের। সারি ধরে না দেখে কলাম ধরে দেখুন: qty @ price = 75 × (চালের কলাম) + 130 × (ডালের কলাম) + 190 × (তেলের কলাম)। মানে ফলটি qty-র কলামগুলোর একটি weighted মিশ্রণ, ওজন হলো দাম। গণিতে একে বলে কলামগুলোর linear combination. অংশ ৬-এ rank বোঝার সময় এই দ্বিতীয় ছবিটি লাগবে।

@, np.dot আর np.matmul — কোনটি কখন

২-মাত্রা পর্যন্ত তিনটিই একই ফল দেয়, তাই অনেক কোডে এরা মিশে থাকে। পার্থক্য আসে কিনারায়। ডেস্কটপে NumPy 2.5.1 দিয়ে চালানো একটি ছোট পরীক্ষা (সত্যিকারের run):

>>> a = np.ones((2, 3, 4)); b = np.ones((2, 4, 5))
>>> np.dot(a, b).shape, (a @ b).shape
((2, 3, 2, 5), (2, 3, 5))
>>> 3 @ price
ValueError: matmul: Input operand 0 does not have enough dimensions (has 0, gufunc core with signature (n?,k),(k,m?)->(n?,m?) requires 1)

• @ (= np.matmul): ৩ বা বেশি মাত্রায় শেষ দুটি মাত্রাকে matrix ধরে, আগের মাত্রাগুলোকে “batch” ধরে; ওপরে দুটি (3, 4) @ (4, 5) গুণ পাশাপাশি হয়ে (2, 3, 5). Scalar (একক সংখ্যা) দিয়ে গুণ করতে দেয় না; সেখানে * লিখতে হয়।
• np.dot: ১ আর ২ মাত্রায় একই, কিন্তু বেশি মাত্রায় সম্পূর্ণ আলাদা নিয়ম মানে (প্রথমটির শেষ মাত্রা আর দ্বিতীয়টির শেষের-আগের মাত্রা ধরে যোগ), ফলে (2, 3, 2, 5)-এর মতো অপ্রত্যাশিত shape আসে। Scalar-ও নেয়।
• পরামর্শ: matrix গুণের জন্য @, scalar গুণের জন্য *, আর ৩+ মাত্রায় np.dot এড়িয়ে চলুন। NumPy 2.0 থেকে দুটি vector-এর dot product ব্যাচ ধরে করার জন্য np.vecdot-ও আছে।

৪ · Shape-এর নিয়ম — ভেতরের মাত্রা মিলতে হবে, আর transpose

Matrix গুণের একটিমাত্র নিয়ম মুখস্থ রাখলেই চলে: বাঁয়ের শেষ মাত্রা আর ডানের প্রথম মাত্রা সমান হতে হবে, আর ফলের shape হয় বাকি দুটি বাইরের মাত্রা।

(m, k) @ (k, n) → (m, n)

এখানে m হলো বাঁয়ের সারির সংখ্যা, n ডানের কলামের সংখ্যা, আর k হলো সেই “ভেতরের” মাত্রা, যার ধরে গুণ করে যোগ হয়। বাজারঘরে k হলো পণ্যের সংখ্যা: অর্ডারের প্রতিটি কলাম আর দামের প্রতিটি ঘর একই পণ্যের কথা বলছে বলেই তাদের গুণ করে যোগ করার অর্থ আছে। ভেতরের মাত্রা না মিললে অর্থটাই থাকে না, তাই NumPy error দেয়। নিচের ছবিতে নিয়মটি দেখুন।

এবার নিয়মটি কয়েকটি ভিন্ন shape-এ ধাপে ধাপে খাটিয়ে দেখি। প্রতিটি ধাপে আগে নিজে ফলের shape বলার চেষ্টা করুন, তারপর মিলিয়ে নিন।

(4, 3) @ (3,)  →  (4,)
[470 635 455 545]

P = [[ 75,  72],      # ঢাকা শাখা, চট্টগ্রাম শাখা
     [130, 135],
     [190, 185]]
(4, 3) @ (3, 2)  →  (4, 2)
[[470 464]
 [635 630]
 [455 442]
 [545 536]]

qty.T.shape  →  (3, 4)
(3, 4) @ (4,)  →  (3,)
[11  4  4]     # চাল ১১ কেজি, ডাল ৪, তেল ৪ লিটার

(4, 3) @ (4,)  →  ValueError
matmul: … mismatch in its
core dimension 0 …
(size 4 is different from 3)

price.T.shape          →  (3,)    # কিছুই বদলায়নি
price[:, None].shape   →  (3, 1)  # এবার সত্যিকারের কলাম
(qty @ price[:, None]).shape  →  (4, 1)

Transpose (A.T) কোনো সংখ্যা বদলায় না, শুধু পড়ার দিক বদলায়: A.T[i, j] = A[j, i]. NumPy-তে এটি নতুন array বানায় না, একই মেমরির একটি নতুন “দৃষ্টি” (view) দেয়, তাই বিশাল matrix-এও এটি প্রায় বিনা খরচে হয় (view আর copy-র খুঁটিনাটি পর্ব ১৪-এ)। দুটি দরকারি সূত্র মনে রাখুন: (A @ B).T == B.T @ A.T (ক্রম উল্টে যায়), আর A.T @ A সবসময় বর্গাকার, shape (k, k); least squares আর PCA দুই জায়গাতেই এটি আসবে।

৫ · Identity, inverse আর linear system — রসিদ থেকে দাম বের করা

এবার প্রশ্নটি উল্টো। ধরুন বাজারঘরের দামের তালিকার ফাইলটি হারিয়ে গেছে, কিন্তু তিনটি পুরোনো রসিদ আছে। প্রতিটিতে লেখা কোন পণ্য কতটা, আর মোট কত টাকা; আলাদা দাম লেখা নেই।

অজানা দাম তিনটির নাম দিই x1, x2, x3. প্রতিটি রসিদ একটি সমীকরণ দেয়, যেমন প্রথমটি 2x₁ + x₂ + x₃ = 470. তিনটি সমীকরণ একসঙ্গে লিখলে পাওয়া যায় একটি linear system, matrix-এর ভাষায় এক লাইনে:

A x = b, যেখানে A = পরিমাণের matrix (3, 3), x = অজানা দাম (3,), b = রসিদের মোট (3,)

অংশ ৩-এ আমরা A আর x জেনে b বের করেছিলাম; এখন A আর b জেনে x চাই। সাধারণ সংখ্যায় 3x = 12 হলে দুই পাশকে 3 দিয়ে ভাগ করি। Matrix-এ “ভাগ” নেই, আছে inverse: A−1 এমন একটি matrix, যার সঙ্গে A গুণ করলে পাওয়া যায় identity matrix I. Identity হলো matrix জগতের “1”: কর্ণ বরাবর 1, বাকি সব 0, আর যেকোনো vector-কে I দিয়ে গুণ করলে vector বদলায় না (np.eye(3)). তাত্ত্বিকভাবে তাই x = A⁻¹b. কিন্তু কম্পিউটারে এভাবে হিসাব করা প্রায় কখনোই সেরা পথ নয় (কেন, অংশ ৬-এ)। NumPy-র ঠিক কাজটির জন্য আলাদা function আছে: np.linalg.solve(A, b).

Solve ভেতরে কী করে, তা বুঝতে স্কুলের সেই পুরোনো পদ্ধতিটিই যথেষ্ট: এক সমীকরণ থেকে আরেকটি বিয়োগ করে একটি একটি অজানা সরিয়ে ফেলা, যার নাম Gaussian elimination. নিচের ধাপে হাতে করে দেখুন। সুবিধার জন্য রসিদ ৩-কে ওপরে আনা হয়েছে, কারণ তার প্রথম সংখ্যা 1.

1[A │ b], রসিদ ৩ ওপরে2R2 ← R2 − 2·R13R3 ← R3 − 5·R14R3 ← R3 − 2·R25নিচ থেকে ওপরে বসানো6np.allclose(A @ x, b)

np.linalg.solve ঠিক এই কাজটিই করে, তবে একটু বুদ্ধি করে: প্রতিটি ধাপে কলামের সবচেয়ে বড় (absolute) সংখ্যাটিকে ওপরে আনে (partial pivoting), যাতে ছোট সংখ্যা দিয়ে ভাগ করে ভুল বড় না হয়। আর elimination-এর হিসাবটি দুটি ত্রিভুজাকার matrix-এ জমা রাখে, যার নাম LU decomposition. এই কাজ NumPy নিজে লেখে না, ডাকে LAPACK নামের বহু দশকের পরীক্ষিত library. এবার নিজে চালিয়ে দেখুন, সঙ্গে একটি “বিপদের” উদাহরণও আছে।

import numpy as np

# তিনটি রসিদ: চাল (কেজি), ডাল (কেজি), তেল (লিটার)
A = np.array([[2, 1, 1],
              [5, 2, 0],
              [1, 0, 2]], dtype=float)
b = np.array([470, 635, 455], dtype=float)   # রসিদের মোট টাকা

x = np.linalg.solve(A, b)                    # A @ x = b থেকে x
print("দাম (চাল, ডাল, তেল):", x)
print("A @ x    :", A @ x)
print("allclose :", np.allclose(A @ x, b))
print("det, rank:", np.linalg.det(A), np.linalg.matrix_rank(A))
print("cond     :", round(np.linalg.cond(A), 2))
print("নতুন অর্ডার [3,1,1]-এর মোট:", np.array([3, 1, 1]) @ x)

# তৃতীয় রসিদ যদি প্রথম দুটির যোগফল হয়: নতুন তথ্য নেই
S = A.copy()
S[2] = S[0] + S[1]
bs = np.array([470, 635, 1105], dtype=float)
print("S-এর rank:", np.linalg.matrix_rank(S), " cond:", f"{np.linalg.cond(S):.1e}")
try:
    xs = np.linalg.solve(S, bs)
    print("solve উত্তর দিল:", xs.round(2))
    print("রসিদ মেলে?", np.allclose(S @ xs, bs))
except np.linalg.LinAlgError as e:
    print("LinAlgError:", e)

দাম (চাল, ডাল, তেল): [ 75. 130. 190.]
A @ x    : [470. 635. 455.]
allclose : True
det, rank: -3.999999999999999 3
cond     : 18.81
নতুন অর্ডার [3,1,1]-এর মোট: 545.0
S-এর rank: 2  cond: 2.5e+16
solve উত্তর দিল: [100.33  66.67 202.67]
রসিদ মেলে? True

দুটি ছোট কথা। প্রথমত, np.allclose কেন, == কেন নয়? Float-এর হিসাবে শেষ অঙ্কে সামান্য গোলমাল থাকতেই পারে (det হুবহু −4 না হয়ে −3.999… দেখাতে পারে), তাই সহনশীলতা (tolerance) রেখে তুলনা করাই নিয়ম; float-এর এই আচরণ এসেছে পর্ব ৯-এ, আর ভেতরের গঠন আছে Computer Architecture কোর্সের floating point পর্বে। দ্বিতীয়ত, A বর্গাকার না হলে (সমীকরণ আর অজানার সংখ্যা আলাদা) solve চলেই না; সেই ক্ষেত্রটি অংশ ৮-এর least squares.

৬ · কেন inverse নয়, solve — condition number আর হারানো অঙ্ক

একটি তুলনা দিয়ে শুরু করি। দাঁড়িপাল্লায় দুটি প্রায়-সমান বস্তার ওজনের পার্থক্য মাপতে গেলে পাল্লার সামান্য কাঁপুনিও ফলকে অনেকখানি বদলে দেয়। কিছু সমীকরণ-ব্যবস্থাও এমন স্পর্শকাতর: ইনপুটে খুব ছোট বদল (একটি রসিদে এক পয়সার ভুল, বা float-এর শেষ অঙ্কের গোলমাল) উত্তরে বিশাল বদল আনে। এমন matrix-কে বলে ill-conditioned, আর কতটা স্পর্শকাতর তার মাপ হলো condition number, np.linalg.cond(A).

মোটা দাগের নিয়মটি মনে রাখার মতো: condition number যদি প্রায় 10^k হয়, তাহলে উত্তরে প্রায় k-টি দশমিক অঙ্ক হারানোর ঝুঁকি থাকে। float64-এ মোটামুটি ১৫–১৬টি অর্থপূর্ণ অঙ্ক থাকে (এর মাপ np.finfo(float).eps, প্রায় 2.2 × 10⁻¹⁶). তাই cond 10³ হলে প্রায় ১২–১৩টি অঙ্ক টেকে, চিন্তার কিছু নেই; cond 10¹³ হলে টেকে মাত্র দু-তিনটি; আর cond 10¹⁶ ছুঁলে উত্তরের কোনো অঙ্কই ভরসার নয়। এটি একটি মোটা হিসাব, নিখুঁত সীমা নয়, কিন্তু সতর্ক হওয়ার জন্য যথেষ্ট।

এবার inverse বনাম solve-এর আসল তুলনা। পরীক্ষার জন্য বিখ্যাতভাবে কঠিন একটি matrix নেওয়া হলো, Hilbert matrix: H[i, j] = 1/(i + j + 1). এর সারিগুলো একে অপরের এত কাছাকাছি যে ১০×১০ আকারেই এটি খুব ill-conditioned. আমরা আসল উত্তর আগে থেকে ঠিক করে দিই (সব 1), সেখান থেকে b বানাই, তারপর দুই পথে উত্তর ফিরে পাওয়ার চেষ্টা করি। দুটি জিনিস মাপা হবে: উত্তর আসল উত্তর থেকে কতটা দূরে (ভুল), আর পাওয়া উত্তর সমীকরণে বসালে কতটা অমিল থাকে (residual).

import numpy as np

n = 10
i = np.arange(n)
H = 1.0 / (i[:, None] + i[None, :] + 1)   # Hilbert matrix: H[i, j] = 1/(i+j+1)
x_true = np.ones(n)                        # আসল উত্তর আমরা জানি
b = H @ x_true

x_solve = np.linalg.solve(H, b)
x_inv = np.linalg.inv(H) @ b

def err(x):    # উত্তরের আপেক্ষিক ভুল
    return np.linalg.norm(x - x_true) / np.linalg.norm(x_true)

def resid(x):  # সমীকরণ কতটা মেলে না
    return np.linalg.norm(H @ x - b) / np.linalg.norm(b)

print(f"cond(H) = {np.linalg.cond(H):.1e}")
print(f"solve  : ভুল {err(x_solve):.1e}  residual {resid(x_solve):.1e}")
print(f"inv @ b: ভুল {err(x_inv):.1e}  residual {resid(x_inv):.1e}")
print(f"float64-এর eps: {np.finfo(float).eps:.1e}")
print("আনুমানিক হারানো অঙ্ক:", round(np.log10(np.linalg.cond(H))))

A = np.array([[2, 1, 1], [5, 2, 0], [1, 0, 2]], dtype=float)
print(f"রসিদের সিস্টেমের cond = {np.linalg.cond(A):.1f}")

cond(H) = 1.6e+13
solve  : ভুল 1.7e-04  residual 1.2e-16
inv @ b: ভুল 4.1e-03  residual 2.4e-05
float64-এর eps: 2.2e-16
আনুমানিক হারানো অঙ্ক: 13
রসিদের সিস্টেমের cond = 18.8

তুলনার জন্য একই পরীক্ষা ডেস্কটপে (Windows, Python 3.14.4, NumPy 2.5.1, সত্যিকারের run, এক বারের মাপ) ছোট-বড় তিনটি আকারে চালানো হয়েছিল:

সারণিটি তিনটি শিক্ষা দেয়। এক, cond যত বড়, উত্তরের ভুল তত বড়, দুই পথেই; n = 12-তে solve-এর উত্তরও ৩২% ভুল, কারণ সমস্যাটিই float64-এর সাধ্যের বাইরে। দুই, solve-এর residual সব আকারেই প্রায় machine precision-এর ঘরে: সে যে উত্তর দেয়, তা অন্তত “প্রায় একই রকম একটি সমস্যার” নিখুঁত উত্তর (একে backward stable বলে)। inverse-এর residual অনেক বড়। তিন, এই সংখ্যাগুলো একটি মেশিনের একটি run; ভিন্ন LAPACK, BLAS বা CPU-তে শেষ অঙ্ক বদলাবে, কিন্তু প্রবণতাটি সাধারণভাবে এমনই থাকে বলে সংখ্যাগত গণিতের পাঠ্যবইগুলো জানায়।

Determinant আর rank — সংক্ষেপে

Determinant (np.linalg.det) একটি বর্গাকার matrix থেকে পাওয়া একটি সংখ্যা। এটি শূন্য হলে matrix-টির inverse নেই (তাকে বলে singular). পরীক্ষার খাতায় এটি খুব জনপ্রিয়, কিন্তু কম্পিউটারে “matrix কতটা ভালো” বোঝার জন্য খারাপ মাপ: matrix-এর সব সংখ্যাকে 0.1 দিয়ে গুণ করলে ১০×১০ matrix-এর det 10¹⁰ গুণ ছোট হয়, অথচ সমীকরণ মেলানো একটুও কঠিন হয় না। ওপরের run-এ আরও দেখেছেন, singular matrix-এর det-ও float-এ হুবহু শূন্য না এসে খুব ছোট একটি সংখ্যা আসতে পারে। তাই ব্যবহারিক কাজে det-এর বদলে cond দেখুন।

Rank (np.linalg.matrix_rank) বলে matrix-এর কয়টি সারি (বা কলাম) সত্যিকারের নতুন তথ্য দেয়। অংশ ৫-এর উদাহরণে তৃতীয় রসিদ যদি প্রথম দুটির যোগফল হয়, তাহলে সারি তিনটি হলেও rank 2: তিনটি অজানার জন্য সমীকরণ আসলে দুটি, তাই দাম অনন্যভাবে বের করা সম্ভবই নয়। NumPy rank বের করে singular value দেখে, একটি tolerance মেনে; খুব ছোট singular value-কে শূন্য ধরে। বাস্তবের ডেটায় এটিই বেশি ঘটে: দুটি feature প্রায় একই তথ্য দেয় (যেমন কেজিতে ওজন আর গ্রামে ওজন), আর তখন matrix প্রায়-singular, cond আকাশছোঁয়া।

৭ · Norm — দৈর্ঘ্য, দূরত্ব আর L1, L2, max

বাজারঘর চায় একই ধরনের ক্রেতাদের এক দলে রাখতে, যাতে “আপনার মতো ক্রেতারা এটিও কিনেছেন” ধরনের প্রস্তাব দেওয়া যায়। প্রথম প্রশ্ন: দুজন ক্রেতা “কতটা কাছাকাছি”? প্রত্যেক ক্রেতার মাসিক কেনাকাটা একটি vector (চাল, ডাল, তেল, চিনি), তাই প্রশ্নটি হলো দুটি vector-এর মধ্যে দূরত্ব। আর দূরত্ব মানে পার্থক্য-vector-এর norm, মানে তার “দৈর্ঘ্য”। কিন্তু দৈর্ঘ্য মাপার উপায় একটি নয়।

ঢাকার রাস্তার কথা ভাবুন। বাসা থেকে বাজার পূর্বে ৪ ব্লক আর উত্তরে ৩ ব্লক। রিকশা দালানের ভেতর দিয়ে যেতে পারে না, রাস্তা ধরে যায়: 4 + 3 = 7 ব্লক। এটি L1 norm, যার আরেক নাম Manhattan দূরত্ব। কাক সোজা উড়ে যায়: √(4² + 3²) = 5 ব্লক। এটি L2 norm, স্কুলের পিথাগোরাসের দূরত্ব, যার আরেক নাম Euclidean distance. আর যদি প্রশ্ন হয় “কোন দিকে সবচেয়ে বেশি সরতে হবে”, উত্তর 4: এটি max norm (L∞, Chebyshev দূরত্ব)।

সূত্রে, n ঘরের একটি vector d-এর জন্য (|·| মানে চিহ্ন বাদ দেওয়া মান, absolute value):

‖d‖₁ = ∑ |d_j| · ‖d‖₂ = √(∑ d_j²) · ‖d‖_∞ = max |d_j|

NumPy-তে তিনটিই np.linalg.norm: দ্বিতীয় argument না দিলে L2, 1 দিলে L1, np.inf দিলে max. দুটি সতর্কতা: ২-মাত্রার array দিলে default হলো পুরো matrix-এর Frobenius norm (সব ঘরের বর্গের যোগের বর্গমূল), সারি ধরে নয়; সারি ধরে চাইলে axis=1 দিতে হয়। আর matrix-এ ord=1 মানে কলামের যোগফলের সর্বোচ্চ, vector-এর L1 নয়। NumPy 2.0 থেকে এই বিভ্রান্তি এড়াতে আলাদা np.linalg.vector_norm আর np.linalg.matrix_norm-ও আছে। এবার তিনজন ক্রেতার দূরত্ব মাপি।

import numpy as np

# মাসে কেনা: চাল (কেজি), ডাল (কেজি), তেল (লিটার), চিনি (কেজি)
names = ["রিনা", "সুমন", "আলম"]
X = np.array([[20, 4, 5, 2],
              [ 5, 2, 1, 1],
              [18, 6, 4, 3]])

d = X[0] - X[2]                       # রিনা − আলম
print("পার্থক্য:", d)
print("L1 :", np.linalg.norm(d, 1), "=", np.abs(d).sum())
print("L2 :", round(np.linalg.norm(d), 3), "=", round(np.sqrt((d ** 2).sum()), 3))
print("max:", np.linalg.norm(d, np.inf), "=", np.abs(d).max())

diff = X[:, None, :] - X[None, :, :]  # (3,1,4) − (1,3,4) → (3,3,4)
print("সব জোড়ার L1:\n", np.abs(diff).sum(axis=2))
print("সব জোড়ার L2:\n", np.linalg.norm(diff, axis=2).round(2))

Xg = X.astype(float)
Xg[:, 3] *= 1000                      # চিনি এবার গ্রামে
dg = np.linalg.norm(Xg[:, None, :] - Xg[None, :, :], axis=2)
print(names, "থেকে রিনার L2 (চিনি গ্রামে):", dg[0].round(1))

পার্থক্য: [ 2 -2  1 -1]
L1 : 6.0 = 6
L2 : 3.162 = 3.162
max: 2.0 = 2
সব জোড়ার L1:
 [[ 0 22  6]
 [22  0 22]
 [ 6 22  0]]
সব জোড়ার L2:
 [[ 0.   15.68  3.16]
 [15.68  0.   14.07]
 [ 3.16 14.07  0.  ]]
['রিনা', 'সুমন', 'আলম'] থেকে রিনার L2 (চিনি গ্রামে): [   0.  1000.1 1000. ]

৮ · পরের পর্বগুলোর সেতু — least squares, neural layer আর eigenvalue

Least squares — সমীকরণ বেশি, উত্তর “সবচেয়ে কাছের”

বাস্তবে রসিদ তিনটি নয়, শত শত; আর সবগুলো নিখুঁতও নয়। কোথাও ডেলিভারির খরচ মিশে গেছে, কোথাও দোকানি ৫ টাকা ছাড় দিয়েছেন। তখন A লম্বা (সারি বেশি, কলাম কম), আর এমন কোনো দাম নেই যা সব রসিদ হুবহু মেলায়। এর সমাধান least squares: এমন x খোঁজা, যাতে অমিলের বর্গের যোগফল ‖Ax − b‖₂² সবচেয়ে কম হয়। NumPy-তে np.linalg.lstsq. পাঁচটি রসিদ দিয়ে ডেস্কটপে চালানো একটি উদাহরণ (সত্যিকারের run, Python 3.14.4, NumPy 2.5.1):

>>> Q5 = np.array([[2, 1, 1], [5, 2, 0], [1, 0, 2], [3, 1, 1], [0, 2, 1]], dtype=float)
>>> t5 = np.array([472, 633, 455, 548, 447], dtype=float)   # সামান্য গোলমালসহ মোট
>>> x, res, rank, sv = np.linalg.lstsq(Q5, t5)
>>> x
array([ 75.6 , 128.35, 190.63])
>>> res, rank
(array([14.7]), np.int32(3))
>>> Q5 @ x
array([470.18, 634.69, 456.86, 545.78, 447.33])

(np.set_printoptions(precision=2) দিয়ে ছাপা; rank-এর int32 এসেছে ভেতরের LAPACK routine থেকে; অন্য build-এ dtype আলাদা দেখাতে পারে।) পাঁচটি সমীকরণ, তিনটি অজানা: উত্তর [75.6, 128.35, 190.63], আসল দামের (75, 130, 190) খুব কাছে, কিন্তু হুবহু নয়, কারণ রসিদগুলোতেই গোলমাল ছিল। res হলো অমিলের বর্গের যোগফল, 14.7 (যেমন প্রথম রসিদে 472 − 470.18 = 1.82). এটিই linear regression-এর হৃদয়: feature-এর matrix, লক্ষ্যের vector, আর সবচেয়ে ভালো ওজন। পর্ব ৫৮-এ (Linear regression — loss, gradient descent আর closed form) এই একই সমস্যা gradient descent আর closed form দুই পথে সমাধান হবে; closed form-এর বিখ্যাত সূত্রে A.T @ A-এর inverse আসে, আর অংশ ৬ পড়ার পর আপনি জানেন কেন বাস্তব library সরাসরি সেই inverse বানায় না।

Neural network-এর একটি layer = matrix গুণ + bias

Neural network শুনলে জটিল কিছু মনে হয়, কিন্তু তার একটি সাধারণ (dense বা fully connected) layer আসলে এই পর্বেরই হিসাব: ইনপুট vector x, একটি weight matrix W, একটি bias vector b, আর ফল W @ x + b, তারপর একটি সরল অরৈখিক (non-linear) function. ৩টি ইনপুট থেকে ২টি আউটপুট হলে W-এর shape (2, 3). একসঙ্গে অনেক সারি (batch) দিলে সাধারণত লেখা হয় X @ W.T + b: (4, 3) @ (3, 2) → (4, 2), আর b broadcasting-এ প্রতিটি সারিতে যোগ হয়। ডেস্কটপে চালানো (সত্যিকারের run):

>>> W = np.array([[0.2, -0.5, 0.1], [0.4, 0.3, -0.2]]); b = np.array([0.1, -0.3])
>>> W @ np.array([1.0, 2.0, 3.0]) + b
array([-0.4,  0.1])
>>> X = np.array([[1., 2., 3.], [0., 1., 0.], [2., 0., 1.], [1., 1., 1.]])
>>> (X @ W.T + b).shape
(4, 2)

হাতে মিলিয়ে নিন: প্রথম আউটপুট 0.2×1 − 0.5×2 + 0.1×3 + 0.1 = 0.2 − 1.0 + 0.3 + 0.1 = −0.4. Network-এর “শেখা” মানে আসলে এই W আর b-এর সংখ্যাগুলো বদলানো। পর্ব ৬৮-এ (Neural network-এর ধারণা — perceptron থেকে ছোট network, NumPy দিয়ে) ঠিক এই লাইনগুলো দিয়ে একটি ছোট network বানানো হবে। আর আধুনিক AI কেন GPU-তে চলে, তার একটি বড় উত্তর এখানেই: বিশাল মডেলের হিসাবের বড় অংশই এমন matrix গুণ, যা একসঙ্গে হাজারো ঘরে করা যায়।

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

“এই সমীকরণগুলো NumPy দিয়ে সমাধান করো” বা “ক্রেতাদের দূরত্ব বের করো” লিখলে AI সহকারী দ্রুত কোড দেয়, আর সেই কোড প্রায়ই চলে। কিন্তু এই পর্বের বিষয়গুলোতে চলা মানেই ঠিক নয়, কারণ ভুল shape বা ভুল পদ্ধতি সাধারণত error দেয় না। AI সহকারীরা প্রায়ই যা করে:

• @-এর জায়গায় * লেখে, বা উল্টো; (n,) আর (n, 1) গুলিয়ে ফেলে, আর ভুল মাত্রা মেলাতে অন্ধভাবে .T বা reshape বসিয়ে দেয়।
• np.linalg.inv(A) @ b লেখে, condition number না দেখেই; singular বা প্রায়-singular matrix-এ except: pass দিয়ে error চাপা দেয়, বা pinv দিয়ে “চুপচাপ একটি উত্তর” বের করে ফেলে।
• পুরোনো বা বানানো API লেখে: np.matrix, NumPy 2-এ সরানো np.float, অথবা এমন parameter (np.linalg.norm(x, p=1)-এর মতো, যেখানে আসল নাম ord) যা নেই।
• দূরত্ব মাপার আগে এককের পার্থক্য (কেজি বনাম গ্রাম, টাকা বনাম হাজার টাকা) উপেক্ষা করে, আর scaling-এর জন্য mean ও standard deviation পুরো ডেটা থেকে নিয়ে test ডেটার তথ্য train-এ মিশিয়ে ফেলে; শেষে train ডেটাতেই মাপা ফল দেখায়।
• বিশ্বাসযোগ্য শোনায় কিন্তু না-মাপা দাবি করে: “এই matrix সবসময় invertible”, “এটি ১০০ গুণ দ্রুত”, বা একটি residual বা error-এর মান হাতে বানিয়ে লেখে।

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

• প্রতিটি গুণের আগে আর পরে .shape দেখেছি; * আর @ ঠিক জায়গায় আছে, আর কোথাও অকারণে .T বসানো হয়নি
• ২–৩টি সারির ফল হাতে হিসাব করে মিলিয়েছি, আর উত্তর মূল সমীকরণে বসিয়ে np.allclose দিয়ে দেখেছি
• inv(A) @ b-এর বদলে solve বা lstsq; np.linalg.cond আর matrix_rank দেখেছি
• দূরত্বের আগে প্রতিটি কলামের একক আর মাপ দেখেছি; scaling-এর মান শুধু train ডেটা থেকে নিয়েছি
• প্রতিটি অচেনা function আর parameter নিজের NumPy version-এর অফিসিয়াল docs-এ (numpy.org) মিলিয়েছি; কোনো warning বা LinAlgError লুকানো হয়নি
• গতি বা নির্ভুলতার দাবি নিজে মেপেছি, একটি সরল baseline-এর সঙ্গে তুলনা করেছি, আর ক্রেতার আসল ডেটা AI-তে পেস্ট করিনি