सारणिक, प्रतिलोम और ट्रांसपोज़
np.linalg.det से मैट्रिक्स के सारणिक, np.linalg.inv से प्रतिलोम और .T से ट्रांसपोज़ की गणना कीजिए।
सारणिक, प्रतिलोम और ट्रांसपोज़, CoddyKit पर Pandas & NumPy Academy का एक निःशुल्क पाठ है। यह 4 में से 2वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह Pandas & NumPy Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Pandas & NumPy Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
आव्यूह का ट्रांसपोज़
किसी आव्यूह का ट्रांसपोज़ उसे उसके विकर्ण पर पलट देता है: पंक्तियाँ स्तंभ बन जाती हैं और स्तंभ पंक्तियाँ। यदि A का आकार (m, n) है, तो A.T का आकार (n, m) होगा। रैखिक बीजगणित में ट्रांसपोज़ हर जगह दिखाई देते हैं: सहप्रसरण आव्यूहों की गणना, ग्रेडिएंट के पीछे की ओर प्रसार का कार्यान्वयन, और पंक्ति-सदिश तथा स्तंभ-सदिश परंपराओं के बीच रूपांतरण में। NumPy .T विशेषता से ट्रांसपोज़ तक पहुँच देता है—कोई प्रति नहीं बनाई जाती, यह केवल पुनर्व्यवस्थित स्ट्राइड वाला दृश्य होता है।
import numpy as np
A = np.array([[1, 2, 3],
[4, 5, 6]])
print('A shape:', A.shape) # (2, 3)
print('A.T shape:', A.T.shape) # (3, 2)
print(A.T)व्यवहार में ट्रांसपोज़
एक सामान्य रूप A.T @ A की गणना करना है, जिससे एक सममित वर्ग आव्यूह प्राप्त होता है। यह न्यूनतम वर्ग प्रतिगमन, PCA और सामान्य समीकरणों में दिखाई देता है। यदि A का आकार (n, p) है, तो A.T @ A का आकार (p, p) होगा। परिणाम हमेशा सममित होता है, क्योंकि (A.T @ A)[i,j] == (A.T @ A)[j,i]। कई संख्यात्मक हलकर्ता दक्षता के लिए इस गुण का उपयोग करते हैं।
import numpy as np
A = np.array([[1.0, 2.0],
[3.0, 4.0],
[5.0, 6.0]]) # shape (3, 2)
ATA = A.T @ A # shape (2, 2), symmetric
print('A.T @ A:')
print(ATA)
print('Is symmetric:', np.allclose(ATA, ATA.T))सारणिक: इसका अर्थ
किसी वर्ग आव्यूह का सारणिक एक अदिश मान होता है, जिसमें ज्यामितीय जानकारी निहित होती है: यह बताता है कि आव्यूह क्षेत्रफल (2-D) या आयतन (उच्च आयामों में) को कितने गुना करता है। सारणिक का शून्य होना बताता है कि आव्यूह एकवाची है—यह स्थान को कम आयाम वाले उपस्थान पर समेट देता है और इसका कोई प्रतिलोम नहीं होता। अशून्य सारणिक यह सुनिश्चित करता है कि आव्यूह प्रतिलोमनीय है। NumPy इसकी गणना np.linalg.det() से करता है।
import numpy as np
# Non-singular matrix
A = np.array([[3.0, 1.0],
[2.0, 4.0]])
print('det(A):', np.linalg.det(A)) # 3*4 - 1*2 = 10
# Singular matrix (row 2 = 2 * row 1)
B = np.array([[1.0, 2.0],
[2.0, 4.0]])
print('det(B):', np.linalg.det(B)) # ~0np.linalg.inv() से प्रतिलोम की गणना
किसी आव्यूह A का प्रतिलोम, जिसे A⁻¹ लिखा जाता है, A @ A⁻¹ = I को संतुष्ट करता है, जहाँ I इकाई आव्यूह है। प्रतिलोम केवल वर्ग और गैर-एकवाची आव्यूहों के लिए मौजूद होते हैं। np.linalg.inv(A) संख्यात्मक रूप से प्रतिलोम की गणना करता है। व्यवहार में आपको प्रतिलोमों की स्पष्ट रूप से गणना बहुत कम करनी चाहिए, क्योंकि यह संख्यात्मक रूप से अस्थिर होती है; इसके बजाय समीकरणों की प्रणालियों के लिए np.linalg.solve() को प्राथमिकता दें। फिर भी, प्रतिलोमों को वैचारिक रूप से समझना आवश्यक है।
import numpy as np
A = np.array([[3.0, 1.0],
[2.0, 4.0]])
A_inv = np.linalg.inv(A)
print('Inverse:')
print(A_inv)
# Verify: A @ A_inv should be identity
I = A @ A_inv
print('A @ A_inv (should be I):')
print(np.round(I, 10))प्रत्यक्ष प्रतिलोम की संख्यात्मक अस्थिरता
किसी आव्यूह का प्रतिलोम निकालकर फिर उससे गुणा करने पर चल-बिंदु त्रुटियाँ उत्पन्न होती हैं और बढ़ती जाती हैं। उदाहरण के लिए, A_inv @ b को हल करना सीधे np.linalg.solve(A, b) बुलाने की तुलना में कम सटीक है। अच्छी स्थिति वाला आव्यूह (जिसका सारणिक शून्य से पर्याप्त दूर हो) इन त्रुटियों के प्रति कम संवेदनशील होता है। स्थिति संख्या (np.linalg.cond(A)) यह मापती है कि आव्यूह एकवाची होने के कितना निकट है—बड़ी स्थिति संख्याएँ संख्यात्मक समस्या का संकेत देती हैं।
import numpy as np
A = np.array([[1.0, 2.0],
[1.0001, 2.0]])
print('Condition number:', np.linalg.cond(A))
# Very high condition number -> near-singular, unstable inversion
b = np.array([3.0, 3.0001])
# Prefer solve over inv @ b
print('Solution via solve:', np.linalg.solve(A, b))लंबवत् आव्यूह और उनके ट्रांसपोज़
आव्यूहों का एक विशेष वर्ग लंबवत् आव्यूह है, जिनके लिए A.T @ A = I होता है। इसका अर्थ है कि ट्रांसपोज़ ही प्रतिलोम है, जिससे लंबवत् आव्यूहों का प्रतिलोम निकालना अत्यंत कम खर्चीला हो जाता है। घूर्णन आव्यूह और QR अपघटन का Q गुणक लंबवत् होते हैं। लंबवत् आव्यूह के स्तंभ एक लंबसममान आधार बनाते हैं—प्रत्येक स्तंभ की लंबाई इकाई होती है और वह हर दूसरे स्तंभ के लंबवत् होता है।
import numpy as np
# 90-degree rotation matrix is orthogonal
theta = np.pi / 2
R = np.array([[np.cos(theta), -np.sin(theta)],
[np.sin(theta), np.cos(theta)]])
print('R.T @ R (should be identity):')
print(np.round(R.T @ R, 10))
print('Is orthogonal:', np.allclose(R.T @ R, np.eye(2)))गैर-वर्ग आव्यूहों के लिए छद्म-प्रतिलोम
सामान्य प्रतिलोम केवल वर्ग आव्यूहों के लिए मौजूद होता है, लेकिन मूर-पेनरोज़ छद्म-प्रतिलोम किसी भी आव्यूह तक प्रतिलोम की अवधारणा का विस्तार करता है। np.linalg.pinv(A) इसकी गणना SVD का उपयोग करके करता है। यह अतिनिर्धारित प्रणालियों (अज्ञातों से अधिक समीकरणों वाली प्रणालियों) के न्यूनतम-वर्ग हल का आधार है, और रैखिक प्रतिगमन ठीक यही हल करता है। यदि A वर्ग और प्रतिलोमनीय है, तो pinv(A) और inv(A) समान होते हैं।
import numpy as np
# Over-determined system: 3 equations, 2 unknowns
A = np.array([[1.0, 1.0],
[1.0, 2.0],
[1.0, 3.0]])
b = np.array([2.0, 3.0, 5.0])
# Least-squares solution using pseudo-inverse
x = np.linalg.pinv(A) @ b
print('Best-fit solution:', x)
# Or use lstsq directly
x2, _, _, _ = np.linalg.lstsq(A, b, rcond=None)
print('lstsq solution:', x2)सारणिक का चिह्न और आयतन का मापन
सारणिक का चिह्न बताता है कि रूपांतरण अभिविन्यास को बनाए रखता है या उलट देता है। धनात्मक सारणिक का अर्थ है कि अभिविन्यास बना रहता है (जैसे घूर्णन में); ऋणात्मक सारणिक का अर्थ है कि अभिविन्यास पलट जाता है (जैसे परावर्तन में)। परम मान आयतन-स्केलिंग गुणक देता है। 2×2 आव्यूह [[a,b],[c,d]] के लिए det = a*d - b*c होता है। NumPy किसी भी आकार के वर्ग आव्यूहों को कुशलता से संभालता है।
import numpy as np
# Identity: det = 1 (no scaling, no flip)
I = np.eye(3)
print('det(I):', np.linalg.det(I)) # 1.0
# Scaling by 2 in all directions: det = 8 = 2^3
S = 2 * np.eye(3)
print('det(2I):', np.linalg.det(S)) # 8.0
# Reflection: det = -1
F = np.array([[-1.0, 0.0],
[ 0.0, 1.0]])
print('det(reflection):', np.linalg.det(F))स्थिरता के लिए np.linalg.slogdet() का उपयोग
बड़े आव्यूहों के लिए, आव्यूह के एकवाची न होने पर भी सारणिक अतिप्रवाह कर सकता है या घटकर शून्य हो सकता है। np.linalg.slogdet(A) (sign, log_abs_det) लौटाता है—अर्थात् चिह्न और सारणिक के परम मान का प्राकृतिक लघुगणक—जिससे संख्यात्मक अतिप्रवाह से बचा जाता है। इसका व्यापक उपयोग प्रायिकतामूलक मॉडलों (गॉसियन संभाव्यता) में होता है, जहाँ संख्याओं को संभालने योग्य बनाए रखने के लिए लॉग-स्थान में काम किया जाता है।
import numpy as np
A = np.random.rand(100, 100)
# Direct det might underflow for large matrices
sign, logdet = np.linalg.slogdet(A)
print('Sign:', sign)
print('Log|det|:', logdet)
print('Actual det (may be ~0 due to float):', np.linalg.det(A))
print('Reconstructed |det|:', np.exp(logdet))व्यावहारिक अभ्यास: हाथ से बनाम NumPy से 2x2 हल करना
2×2 आव्यूह [[a, b], [c, d]] के लिए प्रतिलोम (1/det) * [[d, -b], [-c, a]] होता है, जहाँ det = ad - bc है। इस सूत्र को जानने से आपको NumPy के परिणाम की त्वरित जाँच करने में सहायता मिलती है। इससे बड़े किसी भी आव्यूह के लिए प्रतिलोम की विश्लेषणात्मक गणना अव्यावहारिक है—इसी कारण हम np.linalg.inv() का उपयोग करते हैं। संख्यात्मक परिणामों को हमेशा np.allclose(A @ A_inv, np.eye(n)) से सत्यापित करें।
import numpy as np
a, b, c, d = 3.0, 1.0, 2.0, 4.0
A = np.array([[a, b], [c, d]])
det = a*d - b*c
# Manual inverse
A_inv_manual = (1/det) * np.array([[d, -b], [-c, a]])
print('Manual inv:')
print(A_inv_manual)
# NumPy inverse
print('np.linalg.inv:')
print(np.linalg.inv(A))
print('Match:', np.allclose(A_inv_manual, np.linalg.inv(A)))पाइपलाइन में ट्रांसपोज़ और प्रतिलोम का संयोजन
रैखिक बीजगणित का एक सामान्य रूप ट्रांसपोज़ और प्रतिलोम को जोड़ता है: (A.T @ A)⁻¹ @ A.T की गणना करने पर साधारण न्यूनतम वर्गों में प्रयुक्त प्रक्षेपण आव्यूह मिलता है। NumPy में इसे np.linalg.inv(A.T @ A) @ A.T के रूप में लिखा जा सकता है, लेकिन फिर भी np.linalg.lstsq संख्यात्मक रूप से अधिक बेहतर है। अंतर्निहित रूप को जानने से आपको यह समझने में सहायता मिलती है कि हलकर्ता क्या कर रहा है और आव्यूहों के लगभग एकवाची होने पर समस्याओं को दूर करने में मदद मिलती है।
import numpy as np
# Design matrix for simple linear regression (with bias)
X = np.column_stack([np.ones(5), np.array([1., 2., 3., 4., 5.])])
y = np.array([2.1, 3.9, 6.2, 8.1, 9.8])
# OLS via normal equations: beta = (X.T @ X)^-1 @ X.T @ y
beta = np.linalg.inv(X.T @ X) @ X.T @ y
print('Coefficients (intercept, slope):', np.round(beta, 3))
# Verify with lstsq
beta2, _, _, _ = np.linalg.lstsq(X, y, rcond=None)
print('lstsq result:', np.round(beta2, 3))त्वरित जाँच
इस पाठ में दिए गए डेटा विश्लेषण की अवधारणाओं की अपनी समझ जाँचें।
पाठ का पुनरावलोकन
इस पाठ में आपने सीखा: A.T वह ट्रांसपोज़ है जो पंक्तियों और स्तंभों को बदलता है, np.linalg.inv() आव्यूह के प्रतिलोम की गणना करता है, लेकिन इसका सीधे उपयोग बहुत कम करना चाहिए (solve या lstsq को प्राथमिकता दें), और np.linalg.det() सारणिक लौटाता है, जो एकवाची आव्यूहों के लिए शून्य होता है। आगे हम np.linalg.solve से रैखिक प्रणालियों को सीधे हल करना सीखेंगे।
एआई शिक्षक के साथ Python सीखें — निःशुल्क
अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।
- पाठ्यक्रम
- 30
- पाठ
- 120
अक्सर पूछे जाने वाले प्रश्न
क्या “सारणिक, प्रतिलोम और ट्रांसपोज़” पाठ निःशुल्क है?
हाँ—“सारणिक, प्रतिलोम और ट्रांसपोज़” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और Pandas & NumPy Academy पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। Pandas & NumPy Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
“सारणिक, प्रतिलोम और ट्रांसपोज़” में मैं क्या सीखूँगा?
np.linalg.det से मैट्रिक्स के सारणिक, np.linalg.inv से प्रतिलोम और .T से ट्रांसपोज़ की गणना कीजिए। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Pandas & NumPy Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।
क्या Pandas & NumPy Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?
पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Pandas & NumPy Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 2वाँ पाठ है।
“सारणिक, प्रतिलोम और ट्रांसपोज़” पाठ पूरा करने में कितना समय लगता है?
CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।
क्या मैं इस Pandas & NumPy Academy पाठ में कोड लिख और चला सकता हूँ?
हाँ। हर Pandas & NumPy Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।
इस पाठ्यक्रम के सभी पाठ
- np.matmul और @ से मैट्रिक्स गुणन
- सारणिक, प्रतिलोम और ट्रांसपोज़
- रैखिक समीकरण-तंत्र का हल
- आइगेनमान और SVD का परिचय