np.matmul और @ से मैट्रिक्स गुणन
np.matmul और @ ऑपरेटर से मैट्रिक्सों का सही गुणन कीजिए तथा तत्व-दर-तत्व * और वास्तविक मैट्रिक्स गुणन में अंतर समझिए।
np.matmul और @ से मैट्रिक्स गुणन, CoddyKit पर Pandas & NumPy Academy का एक निःशुल्क पाठ है। यह 4 में से 1वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह Pandas & NumPy Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Pandas & NumPy Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
मैट्रिक्स गुणन क्यों महत्वपूर्ण है
मैट्रिक्स गुणन डेटा विज्ञान और मशीन लर्निंग का आधार है। यह न्यूरल नेटवर्क, आयाम-ह्रास और रैखिक रूपांतरणों के पीछे काम करता है। Python में NumPy आपको मैट्रिक्स गुणा करने के दो सरल तरीके देता है: np.matmul() फ़ंक्शन और Python 3.5 में प्रस्तुत किया गया @ ऑपरेटर। दोनों तेज़, वेक्टराइज़्ड और नेस्टेड Python लूप की तुलना में कहीं अधिक दक्ष हैं।
मैट्रिक्स गुणन के नियम
दो मैट्रिक्स A और B के लिए, गुणनफल A @ B तभी मान्य होता है जब A में स्तंभों की संख्या, B में पंक्तियों की संख्या के बराबर हो। यदि A का आकार (m, n) और B का आकार (n, k) है, तो परिणाम का आकार (m, k) होगा। इस नियम को आंतरिक-आयाम बाधा कहा जाता है और आप NumPy का कोई भी फ़ंक्शन उपयोग करें, यह लागू रहता है।
import numpy as np
A = np.array([[1, 2], [3, 4]]) # shape (2, 2)
B = np.array([[5, 6], [7, 8]]) # shape (2, 2)
C = A @ B
print(C) # [[19 22] [43 50]]np.matmul बनाम @ ऑपरेटर
2-D सारणियों के लिए np.matmul(A, B) और A @ B समान परिणाम देते हैं। @ ऑपरेटर केवल वाक्य-विन्यास की सुविधा है — यह पर्दे के पीछे __matmul__ को बुलाता है, जिसे NumPy उसी C-स्तरीय BLAS रूटीन से लागू करता है। रोज़मर्रा के कोड में पठनीयता के लिए @ का उपयोग करें; जब फ़ंक्शन को कॉल करने योग्य वस्तु के रूप में देना हो या विशेष स्थितियों को स्पष्ट रूप से संभालना हो, तब np.matmul का उपयोग करें।
import numpy as np
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])
print(np.matmul(A, B)) # same as A @ B
print(A @ B) # same result@, * और np.dot में अंतर
NumPy में गुणा करने वाले तीन फ़ंक्शन हैं जिन्हें आसानी से गड़बड़ समझा जा सकता है। A * B तत्व-वार गुणन (Hadamard गुणनफल) है। 2-D सारणियों के लिए np.dot(A, B) का व्यवहार np.matmul जैसा है, लेकिन अधिक आयामों के लिए इसका अर्थ अलग होता है। A @ B सख्ती से मैट्रिक्स गुणन है और गणितीय परिभाषा का ठीक-ठीक पालन करता है — मैट्रिक्स के काम के लिए np.dot की जगह इसे प्राथमिकता दें।
import numpy as np
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])
print('element-wise:', A * B) # [[5 12] [21 32]]
print('matmul:', A @ B) # [[19 22] [43 50]]मैट्रिक्स गुणन क्रमविनिमेय नहीं है
अदिश गुणन के विपरीत, मैट्रिक्स गुणन क्रमविनिमेय नहीं होता: A @ B सामान्यतः B @ A से अलग होता है। दोनों दिशाओं में आकार संगत हों, यह भी आवश्यक नहीं है। रूपांतरण लिखते समय यह महत्वपूर्ण है — संक्रियाओं का क्रम परिणाम बदल देता है। हमेशा ध्यान रखें कि कौन-सा मैट्रिक्स बाईं ओर है और कौन-सा दाईं ओर।
import numpy as np
A = np.array([[1, 2], [3, 4]])
B = np.array([[0, 1], [1, 0]])
print('A @ B:', A @ B) # [[2 1] [4 3]]
print('B @ A:', B @ A) # [[3 4] [1 2]] -- different!बैच मैट्रिक्स गुणन
जब आपकी सारणियों में दो से अधिक आयाम होते हैं, तो np.matmul और @ अतिरिक्त अग्रणी आयामों को बैच आयाम मानते हैं और मैट्रिक्सों का समानांतर गुणन करते हैं। उदाहरण के लिए, (32, 3, 4) आकार वाली सारणी को (32, 4, 5) आकार वाली सारणी से गुणा करने पर (32, 3, 5) आकार का परिणाम मिलता है — एक साथ 32 स्वतंत्र 3×4 @ 4×5 गुणन। डीप लर्निंग ढाँचे छोटे बैचों को इसी तरह दक्षता से संसाधित करते हैं।
import numpy as np
batch_A = np.random.rand(32, 3, 4)
batch_B = np.random.rand(32, 4, 5)
result = batch_A @ batch_B
print(result.shape) # (32, 3, 5)मैट्रिक्स-वेक्टर गुणन
एक सामान्य विशेष स्थिति मैट्रिक्स को वेक्टर से गुणा करना है। यदि A का आकार (m, n) है और v लंबाई n वाली 1-D सारणी है, तो A @ v लंबाई m वाली 1-D सारणी देता है। NumPy आकारों का संरेखण अपने-आप संभालता है — आपको v को स्तंभ वेक्टर में बदलने की आवश्यकता नहीं है। यह पैटर्न हर जगह दिखाई देता है: रैखिक प्रतिगमन में भार लागू करने, फीचरों का प्रक्षेपण करने और हर पंक्ति के लिए एक साथ डॉट गुणनफल निकालने में।
import numpy as np
A = np.array([[1, 2, 3], [4, 5, 6]]) # (2, 3)
v = np.array([1, 0, -1]) # (3,)
print(A @ v) # [1-3, 4-6] = [-2, -2]प्रदर्शन: @ बनाम Python लूप
NumPy का मैट्रिक्स गुणन अनुकूलित BLAS/LAPACK रूटीन को बुलाता है और संकलित C कोड में चलता है। इसी कार्य को करने वाला शुद्ध Python का नेस्टेड लूप बड़े मैट्रिक्सों के लिए सामान्यतः 100–1000 गुना धीमा होता है। जब डेटा-प्रवाह में बार-बार मैट्रिक्स गुणन की आवश्यकता हो — फीचर रूपांतरण, PCA प्रक्षेपण या भार अद्यतन — तो हमेशा @ या np.matmul का उपयोग करें और आंतरिक लूप स्वयं कभी न लिखें।
import numpy as np, time
A = np.random.rand(500, 500)
B = np.random.rand(500, 500)
t0 = time.time()
C = A @ B
print(f'NumPy: {(time.time()-t0)*1000:.1f} ms') # single-digit msकई मैट्रिक्स गुणनों को जोड़ना
आप एक ही अभिव्यक्ति में कई @ संक्रियाएँ जोड़ सकते हैं: A @ B @ C का मूल्यांकन बाएँ से दाएँ होता है। MATLAB के mtimes के विपरीत, NumPy गुणन का क्रम अपने-आप अनुकूलित नहीं करता; इसलिए यदि मैट्रिक्सों के आकार बहुत अलग हों, तो गति के लिए क्रम महत्वपूर्ण हो सकता है। तीन या अधिक मैट्रिक्सों के लिए np.linalg.multi_dot([A, B, C]) का उपयोग करने पर विचार करें, जो अपने-आप सबसे दक्ष युग्म चुनता है।
import numpy as np
A = np.random.rand(100, 20)
B = np.random.rand(20, 50)
C = np.random.rand(50, 10)
result = np.linalg.multi_dot([A, B, C])
print(result.shape) # (100, 10)आकार संबंधी सामान्य त्रुटियाँ और उन्हें ठीक करने के तरीके
आव्यूह गुणन में सबसे सामान्य त्रुटि आकार का मेल न खाना है: ValueError: matmul: Input operand 1 has a mismatch in its core dimension 0। इसका समाधान है कि A.shape से आकार जाँचें और सुनिश्चित करें कि आंतरिक आयाम समान हों। यदि आपके पास (n,) आकार का पंक्ति सदिश है, जिसे स्तंभ सदिश (n, 1) के रूप में लिया जाना है, तो v.reshape(-1, 1) का उपयोग करें। यदि आपको ट्रांसपोज़ चाहिए, तो A.T का उपयोग करें।
import numpy as np
A = np.ones((3, 4))
B = np.ones((3, 4)) # wrong -- inner dims 4 != 3
try:
A @ B
except ValueError as e:
print('Error:', e)
print('Fix:', (A @ B.T).shape) # (3, 3)व्यावहारिक उदाहरण: विशेषता रूपांतरण
डेटा विज्ञान में एक सामान्य उपयोग-स्थिति यह है: आपके पास (n_samples, n_features) आकार का डेटासेट X और (n_features, n_outputs) आकार का भार आव्यूह W है। आव्यूह गुणनफल X @ W प्रत्येक नमूने पर एक साथ रैखिक रूपांतरण लागू करता है और (n_samples, n_outputs) आकार का परिणाम देता है। यही तंत्रिका नेटवर्क की रैखिक परत और रैखिक प्रतिगमन के पूर्वानुमान की मूल गणना है।
import numpy as np
n_samples, n_features, n_outputs = 200, 10, 3
X = np.random.rand(n_samples, n_features)
W = np.random.rand(n_features, n_outputs)
b = np.zeros(n_outputs)
predictions = X @ W + b # shape (200, 3)
print(predictions.shape)त्वरित जाँच
NumPy के आव्यूह गुणन की अपनी समझ जाँचें।
पाठ का पुनरावलोकन
इस पाठ में आपने सीखा: np.matmul और @ वास्तविक आव्यूह गुणन लागू करते हैं (तत्व-दर-तत्व गुणन नहीं), दोनों आव्यूहों के आंतरिक आयाम समान होने चाहिए, और @ अग्रणी आयामों पर बैच गुणन का समर्थन करता है। आगे हम सारणिक, प्रतिलोम और ट्रांसपोज़ का अध्ययन करेंगे—वे संक्रियाएँ जो बताती हैं कि किसी आव्यूह को 'पूर्ववत' किया जा सकता है या नहीं।
एआई शिक्षक के साथ Python सीखें — निःशुल्क
अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।
- पाठ्यक्रम
- 30
- पाठ
- 120
अक्सर पूछे जाने वाले प्रश्न
क्या “np.matmul और @ से मैट्रिक्स गुणन” पाठ निःशुल्क है?
हाँ—“np.matmul और @ से मैट्रिक्स गुणन” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और Pandas & NumPy Academy पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। Pandas & NumPy Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
“np.matmul और @ से मैट्रिक्स गुणन” में मैं क्या सीखूँगा?
np.matmul और @ ऑपरेटर से मैट्रिक्सों का सही गुणन कीजिए तथा तत्व-दर-तत्व * और वास्तविक मैट्रिक्स गुणन में अंतर समझिए। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Pandas & NumPy Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।
क्या Pandas & NumPy Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?
पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Pandas & NumPy Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 1वाँ पाठ है।
“np.matmul और @ से मैट्रिक्स गुणन” पाठ पूरा करने में कितना समय लगता है?
CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।
क्या मैं इस Pandas & NumPy Academy पाठ में कोड लिख और चला सकता हूँ?
हाँ। हर Pandas & NumPy Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।
इस पाठ्यक्रम के सभी पाठ
- np.matmul और @ से मैट्रिक्स गुणन
- सारणिक, प्रतिलोम और ट्रांसपोज़
- रैखिक समीकरण-तंत्र का हल
- आइगेनमान और SVD का परिचय