मैट्रिक्स गुणन रेखीय बीजगणित में एक मूलभूत संक्रिया है।
हम आमतौर पर इसका उपयोग कई अनुप्रयोगों जैसे इमेज प्रोसेसिंग, मशीन लर्निंग, और कई अन्य में करते हैं। NumPy वैज्ञानिक कंप्यूटिंग के लिए एक उल्लेखनीय Python पैकेज है।
हालाँकि, इस पोस्ट में, हम NumPy का उपयोग किए बिना पायथन में मैट्रिक्स गुणन करने के विभिन्न तरीकों को देखेंगे।
हम उपयोग करेंगे स्थिर फंदा, अंतर्निहित मानचित्र () फ़ंक्शन, और सूची समझ।
इसके अलावा, हम प्रत्येक कार्यनीति के लाभ और कमियों को देखेंगे, साथ ही यह भी देखेंगे कि उनमें से प्रत्येक को कब लागू करना है। यदि आप रैखिक बीजगणित में नए हैं और आव्यूह गुणन के बारे में अधिक जानना चाहते हैं; पढ़ना जारी रखें।
हम मैट्रिक्स गुणन का उपयोग कहाँ करते हैं?
मैट्रिक्स गुणन का प्रयोग किया जाता है कंप्यूटर ग्राफिक्स 2D और 3D दृश्यों को बदलने के लिए। उदाहरण के लिए, आप स्क्रीन पर वस्तुओं को घुमा सकते हैं, स्केल कर सकते हैं और उनका अनुवाद कर सकते हैं। चित्रों को पिक्सल के सरणियों के रूप में दर्शाने के लिए इमेज प्रोसेसिंग में मैट्रिक्स का उपयोग किया जाता है। इसके अलावा, छवि फ़िल्टरिंग जैसे संचालन करने के लिए मैट्रिक्स का उपयोग किया जा सकता है।
हम मैट्रिक्स का भी उपयोग करते हैं यंत्र अधिगम. वे डेटा और मॉडल मापदंडों का प्रतिनिधित्व करने में हमारी मदद कर सकते हैं। हम कंप्यूटिंग डॉट उत्पादों और मैट्रिक्स-वेक्टर उत्पादों जैसे कई संचालन कर सकते हैं।
निश्चय ही यह संक्रिया वैज्ञानिक संक्रियाओं में भी अत्यधिक लाभप्रद है। भौतिक मात्राओं का वर्णन करने के लिए हम इसका उपयोग भौतिकी और इंजीनियरिंग में कर सकते हैं। इसलिए, हम वैक्टर और टेन्सर के साथ काम कर सकते हैं।
हम NumPy का उपयोग करना क्यों नहीं चुन सकते हैं?
जबकि NumPy एक है पायथन पुस्तकालय, यह हमेशा आव्यूह गुणन के लिए आदर्श विकल्प नहीं होता है। हम आकार और निर्भरता, सीखने और विरासत प्रणाली जैसे कारणों से NumPy का उपयोग नहीं करना चुन सकते हैं।
पायथन के अंतर्निर्मित कार्यों का उपयोग करना या कस्टम कोड विकसित करना कुछ मामलों में अधिक कुशल हो सकता है। हालाँकि, यह ध्यान रखना महत्वपूर्ण है कि NumPy एक मजबूत पुस्तकालय है। इसके अलावा, आप इसे मैट्रिक्स गुणन के लिए भी उपयोग कर सकते हैं।
अब, देखते हैं कि हम NumPy के बिना मैट्रिक्स गुणन कैसे प्राप्त कर सकते हैं।
नेस्टेड लूप विधि
नेस्टेड लूप्स तकनीक पायथन में मैट्रिक्स गुणन को निष्पादित करने के लिए नेस्टेड लूप्स का उपयोग करती है। फ़ंक्शन प्रत्येक मैट्रिक्स तत्व पर पुनरावृत्त करता है। और, यह नेस्टेड लूप्स की एक श्रृंखला का उपयोग करके उन्हें गुणा करता है। फ़ंक्शन परिणाम देता है, जो एक नए मैट्रिक्स में संग्रहीत होता है।
यह तरीका समझने में आसान है। हालाँकि, यह अन्य तरीकों की तरह कुशल नहीं हो सकता है, विशेष रूप से बड़े मेट्रिसेस के लिए। फिर भी, यदि आप रैखिक बीजगणित में नए हैं तो यह आपके लिए एक बढ़िया विकल्प है।
def matrix_multiplication(A, B):
# Determine the matrices' dimensions.
rows_A = len(A)
cols_A = len(A[0])
rows_B = len(B)
cols_B = len(B[0])
# परिणाम मैट्रिक्स को शून्य पर सेट करें।
result = [[0 for row in range(cols_B)] for col in
range(rows_A)]
# Iterate through rows of A
for s in range(rows_A):
# Iterate through columns of B
for j in range(cols_B):
# Iterate through rows of B
for k in range(cols_A):
result[s][j] += A[s][k] * B[k][j]
return result
आइए इसका एक उदाहरण देखें कि यह कैसे करना है। आप इस उदाहरण का परीक्षण करने के लिए नीचे कोड की इन पंक्तियों को जोड़ सकते हैं।
# Sample matrices
A = [[1, 4, 3], [4, 9, 6]]
B = [[7, 8], [9, 10], [11, 12]]
# Perform matrix multiplication
result = matrix_multiplication(A, B)
# Print the result
print(result)
# Output: [[76, 84], [175, 194]]
लाभ:
- समझने में आसान।
- नौसिखियों या मैट्रिक्स गुणन की गहरी समझ चाहने वालों के लिए बढ़िया।
नुकसान:
- वैकल्पिक तकनीकों के रूप में उतना प्रभावी नहीं है, विशेष रूप से बड़े मेट्रिसेस के लिए।
- यह वैकल्पिक दृष्टिकोणों के रूप में पठनीय नहीं है।
नक्शा () फ़ंक्शन विधि
पायथन में मैट्रिक्स गुणन करने के लिए मानचित्र () फ़ंक्शन विधि एक वैकल्पिक दृष्टिकोण प्रदान करती है। इस दृष्टिकोण में, हम अंतर्निहित मानचित्र () फ़ंक्शन का उपयोग करते हैं। इसलिए, हम एक कार्यात्मक प्रोग्रामिंग टूल का उपयोग करते हैं जो प्रत्येक चलने योग्य तत्व (सूची, टपल, आदि) के लिए प्रदान किए गए फ़ंक्शन को लागू करता है। साथ ही, मानचित्र() फ़ंक्शन दो पैरामीटर, एक फ़ंक्शन और पुनरावर्तनीय स्वीकार करता है। और, यह एक पुनरावर्तक देता है जो फ़ंक्शन को प्रत्येक चलने योग्य तत्व पर लागू करता है।
इस दृष्टिकोण में, हम मैट्रिक्स के प्रत्येक सदस्य के माध्यम से जाते हैं और नेस्टेड मैप () फ़ंक्शन का उपयोग करके गुणा करते हैं।
ज़िप () फ़ंक्शन का उपयोग समानांतर में मेट्रिसेस के प्रत्येक तत्व के माध्यम से पुनरावृति करने के लिए किया जाता है।
अंत में, परिणाम जोड़ने के लिए योग () फ़ंक्शन का उपयोग किया जाता है।
def matrix_multiplication(A, B):
# To get the dimensions of the matrices
rows_A = len(A)
cols_A = len(A[0])
rows_B = len(B)
cols_B = len(B[0])
# We use map() function for multiplication.
result = [[sum(a * b for a, b in zip(row_a, col_b)) for
col_b in zip(*B)] for row_a in A]
return result
अब, फिर से, हम एक उदाहरण के साथ अपने कोड का परीक्षण कर सकते हैं।
# Example matrices
A = [[3, 2, 3], [4, 5, 6]]
B = [[7, 8], [9, 10], [11, 12]]
# Use map() function to perform matrix multiplication
result = list(map(lambda x: list(map(lambda y: sum(i*j
for i,j in zip(x,y)), zip(*B))), A))
# Print the result
print(result)
# Output: [[72, 80], [139, 154]]
फायदे
- स्टैक्ड लूप दृष्टिकोण से अधिक प्रभावी
- कोड को सरल बनाने के लिए यह कार्यात्मक प्रोग्रामिंग का उपयोग करता है।
नुकसान
- कुछ लोग जो कार्यात्मक प्रोग्रामिंग से परिचित नहीं हैं, वे इसे कम पठनीय पा सकते हैं।
- नेस्टेड लूप तकनीक की तुलना में यह कम समझ में आता है।
सूची बोध विधि
सूची की समझ आपको कोड की एक पंक्ति में एक नई सूची बनाने में सक्षम बनाती है। इसलिए, यह मौजूदा सूची के प्रत्येक सदस्य के लिए एक अभिव्यक्ति लागू करने से है।
इस दृष्टिकोण में, प्रत्येक मैट्रिक्स सदस्य के माध्यम से बार-बार पुनरावृति करके गुणन किया जाता है। हम स्तरित सूची समझ का उपयोग कर रहे हैं।
# Sample matrices
A = [[1, 12, 3], [14, 5, 6]]
B = [[7, 8], [9, 10], [12, 12]]
# Matrix multiplication using list comprehension
result = [[sum(A[i][k] * B[k][j] for k in range(len(A[0])))
for j in range(len(B[0]))] for i in range(len(A))]
# Print the result
print(result)
[[151, 164], [215, 234]]
लाभ
- मानचित्र () फ़ंक्शन विधि की तुलना में, छोटा और अधिक पठनीय।
नुकसान
- यह विशेष रूप से बड़े मैट्रिक्स के लिए मानचित्र () फ़ंक्शन का उपयोग करने से कम प्रभावी हो सकता है।
- नेस्टेड लूप दृष्टिकोण से यह अधिक कठिन है।
निष्कर्ष
इस पोस्ट में, हमने पायथन में मेट्रिसेस को गुणा करते समय NumPy का उपयोग करने के विकल्पों पर ध्यान दिया। हमने नेस्टेड लूप्स, बिल्ट-इन मैप () फंक्शन और लिस्ट कॉम्प्रिहेंशन में मैट्रिक्स मल्टीप्लीकेशन किया।
सबसे अच्छी रणनीति आपकी परियोजना की विशेष जरूरतों पर निर्भर करेगी।
प्रत्येक रणनीति के अपने पेशेवरों और विपक्ष हैं। यह सुनिश्चित करने के लिए कि फ़ंक्शन ठीक से काम कर रहा है, विभिन्न मैट्रिक्स आयामों और मानों के साथ कुछ टेस्ट केस जोड़ना एक अच्छा विचार है।
इन तरीकों को कितनी अच्छी तरह निष्पादित किया जाता है, इसकी तुलना करने के लिए आपको कुछ प्रदर्शन परीक्षण भी शामिल करना चाहिए।
एक जवाब लिखें