Vector space — span, basis, linear independence আর rank

AI-এর ভিত্তি কোর্সের পর্ব ৩৩-এ vector-এর যোগ, scalar গুণ, norm আর dot product এসেছে, আর পর্ব ১৭-এ matrix গুণ, solve, lstsq আর condition number. পর্ব ৫৮-এ dummy trap-এ “rank 4” কথাটি একবার দেখা দিয়েছিল। এই পর্বে সেই হিসাবগুলো আবার করব না; প্রশ্ন হলো তাদের নিচের জ্যামিতি: কয়েকটি vector মিলে কতটা জায়গা ঢাকে, কোন কলাম আসলে নতুন তথ্য দেয়, আর না দিলে model-এর কী হয়। চালানো যায় এমন চারটি ব্লক পাতাতেই চলে (ব্রাউজারের Python, NumPy আর SciPy); প্রথমবার প্যাকেজ নামতে কয়েক সেকেন্ড লাগে।

১ · Vector space আর subspace — যোগ আর গুণে যে জগৎ বন্ধ থাকে

একটি vector space হলো কিছু বস্তুর (যাদের vector বলি) একটি সংগ্রহ V, যেখানে দুটি কাজ সংজ্ঞায়িত: দুটি vector যোগ আর একটি vector-কে একটি বাস্তব সংখ্যা (scalar) দিয়ে গুণ। শর্ত হলো ফলাফল V-এর ভেতরেই থাকবে, আর পরিচিত নিয়মগুলো খাটবে: যোগ ক্রম-নিরপেক্ষ ও সহযোজী, একটি শূন্য vector 0 আছে, প্রতিটি v-এর একটি −v আছে, আর গুণ যোগের ওপর বণ্টিত হয় (a(u + v) = au + av), সঙ্গে 1·v = v. পূর্ণ তালিকায় আটটি নিয়ম; মুখস্থ করার দরকার নেই, কারণ ML-এ আমরা প্রায় সবসময় Rⁿ নিয়ে কাজ করি, অর্থাৎ n-টি বাস্তব সংখ্যার তালিকা, যেখানে সব নিয়ম আপনা থেকেই সত্য।

তবু বিমূর্ত সংজ্ঞাটির দাম আছে। ২ ঘাত পর্যন্ত সব polynomial (a + bx + cx²), একটি নির্দিষ্ট আকারের সব matrix, বা সব function-ও vector space; এজন্যই পরে kernel method-এ (পর্ব ২৯) “function-কে vector হিসেবে দেখা” স্বাভাবিক লাগবে। ইতিহাসে Hermann Grassmann ১৮৪৪ সালের Ausdehnungslehre-তে linear independence আর dimension-এর ধারণার অনেকটা দেন, তবে সেই সময় তাঁর কাজ খুব কম পাঠক পায়; আর Giuseppe Peano ১৮৮৮ সালে vector space-এর প্রায় আধুনিক স্বতঃসিদ্ধ সংজ্ঞা লেখেন বলে সাধারণত উল্লেখ করা হয়।

Subspace — বড় জগতের ভেতরে ছোট, কিন্তু সম্পূর্ণ জগৎ

V-এর একটি উপসংগ্রহ W নিজেই vector space হলে তাকে subspace বলে। পরীক্ষাটি তিন লাইনের:

1. শূন্য vector 0 W-তে আছে।
2. W-এর যেকোনো দুটি vector-এর যোগফল W-তে থাকে (যোগে বন্ধ)।
3. W-এর যেকোনো vector-কে যেকোনো scalar দিয়ে গুণ করলে W-তে থাকে (গুণে বন্ধ)।

R²-এর subspace আসলে মাত্র তিন রকম: শুধু {0}, মূলবিন্দু দিয়ে যাওয়া কোনো রেখা, আর পুরো সমতল। R³-এ এর সঙ্গে যোগ হয় মূলবিন্দু দিয়ে যাওয়া সমতল। ML-এ সবচেয়ে গুরুত্বপূর্ণ subspace দুটি এই পর্বের শেষ অর্ধে আসবে: একটি matrix-এর column space আর null space. আর একটি সতর্কতা: “রেখা” শুনলে মূলবিন্দু দিয়ে যাওয়ার শর্তটি ভুলবেন না। Linear regression-এর y = wx + b রেখাটি b ≠ 0 হলে subspace নয়; এজন্যই design matrix-এ সব-1-এর একটি কলাম যোগ করে intercept-কে “মূলবিন্দুর রেখা”-র ভাষায় আনা হয়।

২ · Linear combination আর span — দুটি তীর দিয়ে কতদূর যাওয়া যায়

কয়েকটি vector v₁, …, v_k আর কয়েকটি scalar c₁, …, c_k নিয়ে c₁v₁ + … + c_kv_k হলো একটি linear combination. সম্ভাব্য সব c বসিয়ে যত vector পাওয়া যায়, তাদের সংগ্রহ হলো span:

span{v₁, …, v_k} = { c₁v₁ + … + c_kv_k : প্রতিটি c_i ∈ R }

Span সবসময় একটি subspace: c সব শূন্য নিলে 0 আসে, আর দুটি combination-এর যোগফল বা গুণিতক আবার একটি combination. রিকশার উপমায়: একটি রাস্তা ধরে শুধু সামনে-পেছনে গেলে একটি রেখার বাইরে যাওয়া যায় না; দুটি ভিন্ন দিকের রাস্তা পেলে, যত খুশি মিশিয়ে, শহরের যেকোনো মোড়ে পৌঁছানো যায়। নিচের stepper u = (2, 1) আর v = (1, 3) দিয়ে span গড়ে।

শেষ ধাপটি পুরো পর্বের মূল প্রশ্ন: কয়টি vector আছে, তা নয়; কয়টি সত্যিকারের ভিন্ন দিক আছে, সেটাই গুরুত্বপূর্ণ। একটি লক্ষ্য vector b কয়েকটি vector-এর span-এ আছে কি না, তা আসলে একটি linear system-এর প্রশ্ন: vector-গুলোকে কলাম করে matrix A বানালে “b ∈ span” মানে Ax = b-এর অন্তত একটি সমাধান আছে। কম্পিউটারে সহজ পরীক্ষা: A-তে b-কে আরেকটি কলাম হিসেবে জুড়ে দিলে যদি নতুন দিক না আসে (rank না বাড়ে), তাহলে b আগেই span-এ ছিল। Rank-এর পূর্ণ সংজ্ঞা অংশ ৫-এ; আপাতত “স্বাধীন দিকের সংখ্যা” ধরে নিন।

৩ · Linear independence — কোনো vector কি বাড়তি?

v₁, …, v_k vector-গুলো linearly independent, যদি

c₁v₁ + c₂v₂ + … + c_kv_k = 0 হলে অবশ্যই c₁ = c₂ = … = c_k = 0

অর্থাৎ শূন্যে পৌঁছানোর একমাত্র উপায় “কিছুই না নেওয়া”। যদি সব-শূন্য নয় এমন কোনো c দিয়ে শূন্য পাওয়া যায়, vector-গুলো dependent, আর তখন যে v_j-এর c_j ≠ 0, তাকে বাকিদের মিশ্রণ হিসেবে লেখা যায়: v_j = −(1/c_j)·(বাকি পদের যোগফল)। সে span-এ নতুন কিছু যোগ করে না, বাদ দিলেও span একই থাকে। চায়ের দোকানের হিসাব খাতায় “চা”, “বিস্কুট” আর “চা + বিস্কুট মোট” তিনটি কলাম থাকলে তৃতীয়টি বাড়তি: প্রথম দুটি জানলেই সেটি জানা।

হাতে একটি উদাহরণ। R³-এ a = (1, 0, 2), b = (0, 1, 1), c = (2, 3, 7). c = αa + βb লেখার চেষ্টা করি: প্রথম উপাদান থেকে α = 2, দ্বিতীয় থেকে β = 3, আর তৃতীয়তে 2·2 + 3·1 = 7, মিলে গেছে। তাই 2a + 3b − c = 0, একটি সব-শূন্য নয় এমন combination (2, 3, −1). তিনটি vector dependent; তাদের span R³ নয়, একটি সমতল, যার প্রতিটি বিন্দু (x, y, 2x + y) আকারের। এই সমতলে (3, −1, 5) আছে (2·3 − 1 = 5), কিন্তু (1, 1, 1) নেই, কারণ 2 + 1 ≠ 1.

নিচের ব্লক এই কথাগুলো NumPy দিয়ে যাচাই করে। np.linalg.matrix_rank একটি matrix-এর স্বাধীন কলামের সংখ্যা দেয়; কলামের সংখ্যার সমান হলে কলামগুলো independent. শেষ অংশে একটি নতুন basis-এ coordinates বের করা হয়েছে, যার ছবি অংশ ৪-এ।

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

u, v, w = np.array([2., 1.]), np.array([1., 3.]), np.array([4., 2.])
for name, M in [("u, v", np.column_stack([u, v])), ("u, w", np.column_stack([u, w]))]:
    r = np.linalg.matrix_rank(M)
    print(f"{name}: rank {r} of {M.shape[1]} ->", "independent" if r == M.shape[1] else "dependent")

a, b, c = np.array([1., 0., 2.]), np.array([0., 1., 1.]), np.array([2., 3., 7.])
A = np.column_stack([a, b, c])
print("rank [a b c] =", np.linalg.matrix_rank(A), "| c - 2a - 3b =", c - 2 * a - 3 * b)

for t in (np.array([3., -1., 5.]), np.array([1., 1., 1.])):     # t কি span-এ আছে?
    r1 = np.linalg.matrix_rank(A)
    r2 = np.linalg.matrix_rank(np.column_stack([A, t]))
    print(t, "in span" if r1 == r2 else "NOT in span", f"(rank A = {r1}, rank [A|t] = {r2})")

B = np.column_stack([u, v])          # নতুন basis {u, v}, কলাম হিসেবে
p = np.array([4., 7.])
coords = np.linalg.solve(B, p)       # B @ coords = p
print("p in basis {u, v}:", coords, "| check B @ coords =", B @ coords)
q = np.array([1., -1.])
print("q in basis {u, v}:", np.linalg.solve(B, q))

u, v: rank 2 of 2 -> independent
u, w: rank 1 of 2 -> dependent
rank [a b c] = 2 | c - 2a - 3b = [0. 0. 0.]
[ 3. -1.  5.] in span (rank A = 2, rank [A|t] = 2)
[1. 1. 1.] NOT in span (rank A = 2, rank [A|t] = 3)
p in basis {u, v}: [1. 2.] | check B @ coords = [4. 7.]
q in basis {u, v}: [ 0.8 -0.6]

৪ · Basis, dimension আর coordinates — একই বিন্দুর নতুন ঠিকানা

একটি subspace W-এর basis হলো এমন vector-এর সেট যা (ক) W-কে span করে আর (খ) linearly independent. প্রথম শর্ত বলে “যথেষ্ট আছে”, দ্বিতীয়টি বলে “বাড়তি নেই”। একটি গুরুত্বপূর্ণ উপপাদ্য: একই W-এর সব basis-এ vector-এর সংখ্যা সমান। এই সংখ্যার নাম W-এর dimension, dim W. Rⁿ-এর dimension n; সবচেয়ে পরিচিত basis হলো standard basis e₁ = (1, 0, …, 0), …, e_n = (0, …, 0, 1). অংশ ৩-এর সমতলের dimension ২, কারণ a আর b তার একটি basis.

Basis-এর সবচেয়ে কাজের বৈশিষ্ট্য: W-এর প্রতিটি vector-কে basis-এর combination হিসেবে ঠিক একভাবে লেখা যায়। প্রমাণ এক লাইনের: দুইভাবে লেখা গেলে, x = ∑c_ib_i = ∑d_ib_i, বিয়োগ করলে ∑(c_i − d_i)b_i = 0, আর independence বলে প্রতিটি c_i − d_i = 0. এই একক সংখ্যাগুলোই x-এর coordinates সেই basis-এ, লেখা হয় [x]_B. ঢাকার একটি বাড়ির ঠিকানা “রোড ৪, বাড়ি ৭” বা GPS-এর অক্ষাংশ-দ্রাঘিমাংশ, দুই রকমই হয়; বাড়ি একটিই, ঠিকানার ব্যবস্থা আলাদা।

Basis B-এর vector-গুলোকে কলাম করে matrix B বানালে x = B·[x]_B, তাই নতুন coordinates পেতে একটি linear system সমাধান করতে হয়: B c = x. এটিই change of basis. নিচের stepper p = (4, 7)-এর ঠিকানা B = {u, v}-তে বের করে।

অংশ ৩-এর ব্লকের শেষ দুই লাইন ঠিক এই সংখ্যা দুটি দেয়: solve(B, p) = (1, 2) আর solve(B, q) = (0.8, −0.6). ML-এ basis বদল সব জায়গায়: AI-এর ভিত্তি কোর্সের পর্ব ৬৫-এর PCA ডেটাকে একটি নতুন orthonormal basis-এ লেখে, যার প্রথম কয়েকটি coordinate বেশিরভাগ variance ধরে; পর্ব ০৮ (Eigenvalue আর eigenvector — ধারণা থেকে PCA পর্যন্ত) সেই basis কোথা থেকে আসে তা দেখাবে। Standardization বা unit বদল (টাকা থেকে হাজার টাকা) সরলতম basis বদল: প্রতিটি অক্ষ আলাদাভাবে টানা।

৫ · Row reduction দিয়ে rank — খাতায় হিসাব

একটি m × n matrix A-এর (m সারি, n কলাম) rank হলো তার স্বাধীন কলামের সর্বোচ্চ সংখ্যা। হাতে বের করার পথ Gaussian elimination, বা row reduction: একটি সারির গুণিতক আরেকটি থেকে বিয়োগ করা, সারি অদলবদল, বা একটি সারিকে শূন্য-নয় সংখ্যা দিয়ে গুণ। এই তিন কাজে কলামগুলোর মধ্যের linear সম্পর্ক বদলায় না (প্রমাণের ভাব: প্রতিটি কাজ একটি invertible matrix দিয়ে বাম দিক থেকে গুণ, আর Ax = 0-এর সমাধান একই থাকে)। লক্ষ্য row echelon form: প্রতিটি শূন্য-নয় সারির প্রথম শূন্য-নয় সংখ্যা, যাকে pivot বলে, আগের সারির pivot-এর ডানে, আর সব-শূন্য সারি নিচে। তখন rank = pivot-এর সংখ্যা.

প্রায় দুই হাজার বছর আগের চীনা গণিত-গ্রন্থ Nine Chapters on the Mathematical Art-এ (সংকলনের সময় নিয়ে মতভেদ আছে) প্রায় এই পদ্ধতিতেই একঘাত সমীকরণ সমাধান করা হয়েছে; Gauss-এর নাম যুক্ত হয়েছে অনেক পরে। নিচের stepper একটি ৩ × ৪ matrix ধাপে ধাপে কমায়, তারপর তার থেকে column space আর null space পড়ে।

৬ · Column space, null space আর rank–nullity

একটি m × n matrix A দুটি জগতের মধ্যে সেতু: x ∈ Rⁿ নিয়ে Ax ∈ R^m দেয়। এতে দুটি স্বাভাবিক subspace তৈরি হয়।

• Column space C(A) ⊆ R^m: A-এর কলামগুলোর span, অর্থাৎ সব সম্ভাব্য Ax. Ax = b সমাধানযোগ্য ঠিক তখনই, যখন b ∈ C(A). dim C(A) = rank A.
• Null space N(A) ⊆ Rⁿ: যেসব x-এর জন্য Ax = 0. এর dimension-কে বলে nullity. N(A) সবসময় subspace: A·0 = 0, আর An₁ = An₂ = 0 হলে A(n₁ + c·n₂) = 0.

এর একটি জ্যামিতিক ব্যাখ্যা আছে: A ইনপুটের n-টি মাত্রার কিছু “পিষে” শূন্যে পাঠায় (null space), আর বাকিগুলো আউটপুটে টিকে থাকে (column space). কোনো মাত্রা হারায় না, শুধু ভাগ হয়। আরও একটি অবাক করা তথ্য: row space-এর (সারিগুলোর span) dimension-ও rank-এর সমান। অর্থাৎ স্বাধীন সারির সংখ্যা = স্বাধীন কলামের সংখ্যা, যদিও সারি থাকে Rⁿ-এ আর কলাম R^m-এ। কারণ: row operation row space বদলায় না, আর echelon form-এর শূন্য-নয় সারি, অর্থাৎ pivot-যুক্ত সারি, স্বাধীন; তাদের সংখ্যাই pivot-এর সংখ্যা। তাই rank A ≤ min(m, n).

একটি ফল ML-এর জন্য সোনার মতো: x আর x + n একই আউটপুট দেয়, যদি n ∈ N(A), কারণ A(x + n) = Ax + An = Ax. অর্থাৎ null space শূন্য না হলে Ax = b-এর সমাধান (থাকলে) অসংখ্য। নিচের ব্লক SciPy-র scipy.linalg.null_space দিয়ে stepper-এর সব কথা যাচাই করে। এই function SVD দিয়ে null space-এর একটি orthonormal basis দেয়, তাই তার vector-গুলো হাতে পাওয়া (−2, 1, 0, 0)-এর মতো সুন্দর দেখাবে না; কিন্তু একই subspace span করে কি না, তা rank দিয়ে পরীক্ষা করা যায়।

import numpy as np
from scipy.linalg import null_space
np.set_printoptions(precision=3, suppress=True)

A = np.array([[1, 2, 0, 1],
              [2, 4, 1, 4],
              [3, 6, 1, 5]], dtype=float)
r = np.linalg.matrix_rank(A)
N = null_space(A)                          # null space-এর orthonormal basis, কলামে
print("shape", A.shape, "| rank", r, "| nullity", N.shape[1], "| rank + nullity =", r + N.shape[1])
print("null space basis (columns):\n", N)
print(f"max |A @ N| = {np.abs(A @ N).max():.1e}")

n1, n2 = np.array([-2., 1, 0, 0]), np.array([-1., 0, -2, 1])   # হাতে row reduction থেকে
print("A @ n1 =", A @ n1, "| A @ n2 =", A @ n2)
print("rank [N n1 n2] =", np.linalg.matrix_rank(np.column_stack([N, n1, n2])))

C = A[:, [0, 2]]                           # pivot কলাম: column space-এর basis
for j in (1, 3):
    k = np.round(np.linalg.lstsq(C, A[:, j])[0], 6) + 0.0
    print(f"col{j} = {k[0]:g}*col0 + {k[1]:g}*col2")

x = np.array([1., 1, 1, 1])
print("A @ x =", A @ x, "| A @ (x + 5*n1) =", A @ (x + 5 * n1))

shape (3, 4) | rank 2 | nullity 2 | rank + nullity = 4
null space basis (columns):
 [[ 0.898 -0.042]
 [-0.438 -0.198]
 [ 0.045 -0.876]
 [-0.022  0.438]]
max |A @ N| = 1.1e-15
A @ n1 = [0. 0. 0.] | A @ n2 = [0. 0. 0.]
rank [N n1 n2] = 2
col1 = 2*col0 + 0*col2
col3 = 1*col0 + 2*col2
A @ x = [ 4. 11. 15.] | A @ (x + 5*n1) = [ 4. 11. 15.]

৭ · ML-এ rank — বাড়তি কলাম, dummy trap আর অস্থির coefficient

Linear model-এ অনুমান ŷ = Xw, যেখানে design matrix X-এর প্রতিটি সারি একজন গ্রাহক আর প্রতিটি কলাম একটি feature. এখন অংশ ৬-এর সব কথা সরাসরি খাটে। সব সম্ভাব্য অনুমান ŷ মিলে X-এর column space; least squares y-এর সবচেয়ে কাছের ŷ এই subspace থেকে বাছে (তার জ্যামিতি, অর্থাৎ projection, পর্ব ০৭-এ)। আর X-এর null space শূন্য না হলে, w আর w + n একই ŷ দেয়: সবচেয়ে ভালো অনুমান একটিই, কিন্তু তা দেওয়ার মতো coefficient অসংখ্য। এই অবস্থার নাম rank-ঘাটতি (rank deficient), আর উল্টোটি, rank = কলামের সংখ্যা, হলো full column rank.

বাস্তবে এটি প্রায়ই নিরীহ চেহারায় আসে। বাজারঘরের analyst গ্রাহকের খাবার, মুদি আর অন্যান্য খরচের পাশাপাশি “মোট খরচ” কলামও রাখলেন। মোট = তিনটির যোগফল, অর্থাৎ X-এর null space-এ (0, 1, 1, 1, −1) vector আছে। একইভাবে one-hot encoding-এ তিনটি জেলার তিনটি 0/1 কলামের যোগফল প্রতিটি সারিতে ১, যা intercept-এর সব-1 কলামের সমান: null space-এ (1, −1, −1, −1). এটিই dummy-variable trap, এখন rank-এর ভাষায়। AI-এর ভিত্তি কোর্সের পর্ব ৫৮-এ এর ব্যবহারিক রূপ এসেছে; নিচের ব্লক তার কারণ দেখায়: null vector খুঁজে বের করে, তার বরাবর coefficient সরিয়ে দেখায় অনুমান বদলায় না, তারপর দেখায় “প্রায়” নির্ভরশীল কলাম আরও বিপজ্জনক।

import numpy as np
from scipy.linalg import null_space

rng = np.random.default_rng(42)
n = 40                                    # কাল্পনিক বাজারঘরের ৪০ জন গ্রাহক, খরচ হাজার টাকায়
food = rng.uniform(1, 8, n).round(2)
groc = rng.uniform(1, 6, n).round(2)
other = rng.uniform(0, 4, n).round(2)
y = 0.10 * food + 0.15 * groc + 0.05 * other + rng.normal(0, 0.05, n)  # মাসিক লাভ
one = np.ones(n)
total = food + groc + other               # “মোট খরচ”: বাকি তিনটির যোগফল

def fit(X, label):
    w, _, r, s = np.linalg.lstsq(X, y)
    print(f"{label:<13} rank {r}/{X.shape[1]}  cond {s[0] / s[-1]:.1e}  w = {np.round(w, 3)}")
    return w

np.set_printoptions(suppress=True)
X5 = np.column_stack([one, food, groc, other, total])
w_a = fit(X5, "with total")
nv = null_space(X5)[:, 0]
print("null vector:", np.round(nv / nv[1], 3) + 0.0)
w_b = w_a + 2.0 * nv / nv[1]              # null space বরাবর সরানো আরেকটি সমাধান
print("other w     :", np.round(w_b, 3), " max pred diff", f"{np.abs(X5 @ w_a - X5 @ w_b).max():.1e}")
X5n = X5.copy(); X5n[:, 4] += rng.normal(0, 0.001, n)   # “মোট”-এ প্রায় ১ টাকার গোলমাল
fit(X5n, "total+noise")
fit(np.column_stack([one, food, groc, other]), "drop total")
Z = np.eye(3)[rng.integers(0, 3, n)]      # ঢাকা, চট্টগ্রাম, সিলেটের one-hot
D = np.column_stack([one, Z])
print("one-hot + intercept: rank", np.linalg.matrix_rank(D), "of", D.shape[1],
      " null:", np.round(null_space(D)[:, 0] / null_space(D)[0, 0], 3) + 0.0)

with total    rank 4/5  cond 9.3e+15  w = [-0.039  0.023  0.079 -0.024  0.078]
null vector: [ 0.  1.  1.  1. -1.]
other w     : [-0.039  2.023  2.079  1.976 -1.922]  max pred diff 1.0e-14
total+noise   rank 5/5  cond 2.7e+04  w = [-0.042 -3.813 -3.756 -3.859  3.914]
drop total    rank 4/4  cond 2.6e+01  w = [-0.039  0.101  0.158  0.054]
one-hot + intercept: rank 3 of 4  null: [ 1. -1. -1. -1.]

তিনটি সমাধান প্রচলিত, প্রতিটির নিজস্ব দাম। (১) বাড়তি কলাম বাদ দেওয়া: one-hot-এ একটি category বাদ (OneHotEncoder(drop="first") বা pandas-এর drop_first=True), তখন বাকিদের coefficient সেই বাদ দেওয়া category-র তুলনায় পড়তে হয়। (২) Ridge regression: loss-এ λ‖w‖² যোগ করলে X^TX + λI সবসময় invertible (λ > 0), তাই একক উত্তর আসে; null space বরাবর সরানো coefficient-এর দৈর্ঘ্য বাড়ায়, তাই ridge সবচেয়ে ছোটটি বাছে। কেন এমন হয়, পর্ব ১০ (Positive definite matrix)-এ আর পর্ব ১৭ (Regularization-এর তত্ত্ব)-এ। (৩) অনুমানের জন্য কিছু না করা: শুধু ŷ দরকার হলে rank-ঘাটতি অনুমান নষ্ট করে না, কারণ ŷ column space-এর একটি বিন্দু, একক। সমস্যা শুধু coefficient-এর ব্যাখ্যায়, আর ভবিষ্যতে যদি সম্পর্কটি ভাঙে, যেমন production-এ “মোট”-এ ডেলিভারি চার্জ যোগ হলো, তখন। Multicollinearity-র পরিসংখ্যানিক দিক (VIF, standard error) AI-এর ভিত্তি কোর্সের পর্ব ৫৮-এ আছে।

৮ · Numerical rank — float-এ “শূন্য” কত ছোট

খাতায় rank গোনা সহজ: সারি শূন্য হলো কি না দেখলেই হয়। কম্পিউটারে floating-point সংখ্যায় হিসাবের প্রতিটি ধাপে সামান্য রাউন্ডিং হয়, তাই “শূন্য” প্রায় কখনো ঠিক শূন্য থাকে না; অংশ ৬-এর ব্লকে A @ N-এর মান 10⁻¹⁵-এর ঘরে ছিল। তাই matrix_rank row reduction করে না। সে SVD দিয়ে matrix-এর singular value-গুলো বের করে, যা অ-ঋণাত্মক সংখ্যা σ₁ ≥ σ₂ ≥ … ≥ 0; নিখুঁত হিসাবে শূন্য-নয় singular value-এর সংখ্যাই rank. SVD-র পূর্ণ জ্যামিতি পর্ব ০৯ (SVD — low-rank approximation, pseudo-inverse আর recommender-এর ভিত্তি)-এ; এখানে শুধু এটুকু দরকার: সবচেয়ে ছোট singular value বলে matrix নির্ভরশীলতার কত কাছে আছে।

কোনটিকে শূন্য ধরা হবে, তার জন্য একটি সীমা বা tolerance লাগে। NumPy-র ডিফল্ট, ডকুমেন্টেশন অনুযায়ী MATLAB-এর সঙ্গে একই:

tol = σ_max × max(m, n) × ε_mach

এখানে σ_max সবচেয়ে বড় singular value, m × n matrix-এর আকার, আর ε_mach হলো machine epsilon, float64-এ প্রায় 2.2 × 10⁻¹⁶. যে singular value tol-এর চেয়ে বড়, শুধু সেগুলো গোনা হয়; এই গণনাকে বলে numerical rank. NumPy 2.0 থেকে rtol প্যারামিটারও আছে, যা সীমাটিকে σ_max-এর ভগ্নাংশ হিসেবে নেয়। নিচের ব্লকে তৃতীয় কলাম = প্রথম দুটির যোগফল + delta × গোলমাল, delta শূন্য থেকে 10⁻³ পর্যন্ত।

import numpy as np
import matplotlib.pyplot as plt

rng = np.random.default_rng(42)
n = 50
x1 = rng.normal(size=n)
x2 = rng.normal(size=n)
noise = rng.normal(size=n)
eps = np.finfo(float).eps
print(f"machine eps = {eps:.2e}")
plt.figure(figsize=(6.4, 3.4), layout="constrained")
for delta in [0, 1e-15, 1e-12, 1e-8, 1e-3]:
    X = np.column_stack([x1, x2, x1 + x2 + delta * noise])   # তৃতীয় কলাম প্রায় নির্ভরশীল
    s = np.linalg.svd(X, compute_uv=False)
    tol = s[0] * max(X.shape) * eps                          # NumPy-র ডিফল্ট সীমা
    r_def = np.linalg.matrix_rank(X)
    r_loose = np.linalg.matrix_rank(X, rtol=1e-6)            # ডেটার নিজের নির্ভুলতা ধরে
    print(f"delta={delta:<6g} s_min={s[-1]:.1e} tol={tol:.1e} rank={r_def} rank(rtol=1e-6)={r_loose}")
    plt.semilogy([1, 2, 3], s, "o-", label=f"delta = {delta:g}")
plt.axhline(tol, color="k", ls="--", lw=1, label="default tol")
plt.xticks([1, 2, 3]); plt.xlabel("singular value index"); plt.ylabel("singular value (log)")
plt.title("A nearly dependent column: the smallest singular value"); plt.legend(fontsize=7)
plt.show()

machine eps = 2.22e-16
delta=0      s_min=2.3e-15 tol=1.0e-13 rank=2 rank(rtol=1e-6)=2
delta=1e-15  s_min=5.1e-15 tol=1.0e-13 rank=2 rank(rtol=1e-6)=2
delta=1e-12  s_min=4.0e-12 tol=1.0e-13 rank=3 rank(rtol=1e-6)=2
delta=1e-08  s_min=4.0e-08 tol=1.0e-13 rank=3 rank(rtol=1e-6)=2
delta=0.001  s_min=4.0e-03 tol=1.0e-13 rank=3 rank(rtol=1e-6)=3

শিক্ষাটি হলো, numerical rank একটি সিদ্ধান্ত, শুধু হিসাব নয়। ডিফল্ট tol শুধু রাউন্ডিংয়ের ভুল ধরে; আপনার ডেটা যদি টাকায় পূর্ণসংখ্যায় মাপা হয়, বা সেন্সরের নির্ভুলতা তিন অঙ্ক, তাহলে তার চেয়ে ছোট পার্থক্য তথ্য নয়, গোলমাল। NumPy-র ডকুমেন্টেশনও বলে, ডেটার মাপের অনিশ্চয়তা জানা থাকলে সেই অনুযায়ী tolerance বাছা উচিত। Condition number = σ_max / σ_min; অংশ ৭-এর “total+noise” ক্ষেত্রটি rank পরীক্ষায় পাস করেছিল, কিন্তু condition number প্রায় 10⁴ জানিয়ে দিয়েছিল যে coefficient-এ ভরসা কম। তাই বাস্তবে rank-এর সঙ্গে সবসময় singular value বা condition number-ও দেখুন।

৯ · AI-এর যুগে — linear algebra-র দাবি আর AI-এর কোড যাচাই

AI assistant linear algebra-র সংজ্ঞা সাধারণত ঠিক বলে, কিন্তু হাতের হিসাবে (row reduction, null space) আর NumPy-র খুঁটিনাটিতে আত্মবিশ্বাসী ভুল করে। ML কোডে এর প্রভাব নীরব, কারণ rank-ঘাটতি কোনো error দেয় না।

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

• প্রতিটি row operation নিজে একবার কষে দেখেছি; শেষ উত্তর A @ n = 0 দিয়ে মিলিয়েছি
• Column space-এর basis আসল A-এর কলাম থেকে নেওয়া, আর rank + nullity = কলামের সংখ্যা
• Design matrix-এর shape, rank আর condition number ছাপিয়ে দেখেছি; rank < কলাম হলে কোন কলাম বাড়তি তা খুঁজেছি
• Coefficient ব্যাখ্যা করার আগে কয়েকটি seed বা bootstrap-এ তাদের স্থিতিশীলতা দেখেছি, আর একটি সরল baseline-এর সঙ্গে তুলনা করেছি
• ডেটা আগে ভাগ করেছি; scaling বা encoding শুধু train থেকে শিখেছি, test set তালা দেওয়া
• AI-এর দেওয়া function আর প্যারামিটার নিজের NumPy/SciPy version-এর docs-এ মিলিয়েছি
• কোনো আসল গ্রাহকের ব্যক্তিগত ডেটা AI-তে পেস্ট করিনি