numpy arrays और matrices के बीच अंतर क्या हैं? मुझे किसका उपयोग करना चाहिए?

Question

प्रत्येक के फायदे और नुकसान क्या हैं?

जो मैंने देखा है, उससे कोई भी दूसरे के लिए प्रतिस्थापन के रूप में काम कर सकता है, तो मुझे दोनों का उपयोग करने से परेशान होना चाहिए या क्या मुझे उनमें से केवल एक को चिपकना चाहिए?

क्या कार्यक्रम की शैली मेरी पसंद को प्रभावित करेगी? मैं numpy का उपयोग कर कुछ मशीन सीख रहा हूँ, तो वास्तव में बहुत सारे matrices हैं, लेकिन बहुत सारे वैक्टर (सरणी)।

Answer 1

बेवकूफ matrices सख्ती से 2-आयामी हैं, जबकि numpy arrays (ndarrays) एन-आयामी हैं। मैट्रिक्स ऑब्जेक्ट्स ndarray का उप-वर्ग हैं, इसलिए वे सभी एंटरप्राइज़ के गुणों और विधियों का उत्तराधिकारी हैं।

numpy matrices का मुख्य लाभ यह है कि वे मैट्रिक्स गुणा के लिए सुविधाजनक नोटेशन प्रदान करते हैं: यदि ए और बी matrices हैं, तो एक * बी उनके मैट्रिक्स उत्पाद है।

import numpy as np 

a=np.mat('4 3; 2 1') 
b=np.mat('1 2; 3 4') 
print(a) 
# [[4 3] 
# [2 1]] 
print(b) 
# [[1 2] 
# [3 4]] 
print(a*b) 
# [[13 20] 
# [ 5 8]] 

दूसरी ओर, अजगर 3.5 के रूप में, NumPy इन्फ़िक्स मैट्रिक्स @ ऑपरेटर का उपयोग गुणा है, तो आप अजगर> = 3.5 में ndarrays साथ आव्यूह गुणन का एक ही सुविधा प्राप्त कर सकते हैं समर्थन करता है।

import numpy as np 

a=np.array([[4, 3], [2, 1]]) 
b=np.array([[1, 2], [3, 4]]) 
print(a@b) 
# [[13 20] 
# [ 5 8]] 

दोनों मैट्रिक्स वस्तुओं और ndarrays पक्षांतरित वापस जाने के लिए .T है, लेकिन मैट्रिक्स वस्तुओं भी संयुग्म पक्षांतरित के लिए .H, और उलटा के लिए .I है।

इसके विपरीत, numpy arrays लगातार नियम का पालन करते हैं कि संचालन लागू तत्व-वार (नए @ ऑपरेटर को छोड़कर) लागू होते हैं। इस प्रकार, यदि a और b NumPy सरणी हैं, तो a*b सरणी तत्व के लिहाज से घटकों गुणा करके गठित:

c=np.array([[4, 3], [2, 1]]) 
d=np.array([[1, 2], [3, 4]]) 
print(c*d) 
# [[4 6] 
# [6 4]] 

आव्यूह गुणन का परिणाम प्राप्त करने के लिए, आप अजगर में np.dot (या @ का उपयोग> = 3.5, जैसा कि ऊपर दिखाया गया है):

print(np.dot(c,d)) 
# [[13 20] 
# [ 5 8]] 

** ऑपरेटर भी अलग ढंग से व्यवहार करती है:

print(a**2) 
# [[22 15] 
# [10 7]] 
print(c**2) 
# [[16 9] 
# [ 4 1]] 

चूंकि a एक मैट्रिक्स है, a**2 मैट्रिक्स उत्पाद a*a देता है। चूंकि c एक ndarray है, c**2 प्रत्येक घटक वर्ग तत्व-वार के साथ एक ndarray देता है।

मैट्रिक्स ऑब्जेक्ट्स और ndarrays (np.ravel, आइटम चयन और अनुक्रम व्यवहार के साथ करने के लिए) के बीच अन्य तकनीकी अंतर हैं।

numpy arrays का मुख्य लाभ यह है कि वे 2-आयामी matrices से अधिक सामान्य हैं। क्या होता है जब आप 3-आयामी सरणी चाहते हैं? फिर आपको एक ndarray का उपयोग करना है, मैट्रिक्स ऑब्जेक्ट नहीं।इस प्रकार, मैट्रिक्स ऑब्जेक्ट्स का उपयोग करना सीखना अधिक काम है - आपको मैट्रिक्स ऑब्जेक्ट ऑपरेशंस और ndarray ऑपरेशंस सीखना होगा।

एक कार्यक्रम, अपने जीवन मुश्किल बनाता है क्योंकि आप वस्तु अपने चर हैं कि किस प्रकार का ट्रैक रखने के लिए है दोनों मैट्रिक्स और सरणियों का उपयोग करता है ऐसा न हो कि गुणा वापसी कुछ आप की उम्मीद नहीं है लेखन।

इसके विपरीत, यदि आप पूरी तरह से ndarrays के साथ चिपके रहते हैं, तो आप मैट्रिक्स ऑब्जेक्ट्स कर सकते हैं, और कुछ भी अलग-अलग फ़ंक्शन/नोटेशन को छोड़कर कर सकते हैं।

यदि आप न्यूप्पी मैट्रिक्स उत्पाद नोटेशन (जो लगभग पाइथन> = 3.5 में अंडाकारों के साथ सुंदरता से प्राप्त किया जा सकता है) की दृश्य अपील को छोड़ने के इच्छुक हैं, तो मुझे लगता है कि NumPy arrays निश्चित रूप से जाने का तरीका हैं।

पीएस। बेशक, आपको np.asmatrix और np.asarray के बाद आपको एक दूसरे को बदलने की अनुमति देता है ( लंबे समय तक सरणी 2-आयामी) के रूप में आपको अन्य को देखने की ज़रूरत नहीं है।

---

NumPy arrays के बीच मतभेद बनाम NumPy matrix तों here का सारांश है।

Answer 2

बस एक केस को unutbu की सूची में जोड़ने के लिए।

मैटैब जैसे मैट्री मैट्रिस या मैट्रिक्स भाषाओं की तुलना में numpy ndarrays के लिए सबसे बड़ा व्यावहारिक अंतरों में से एक यह है कि आयाम कम करने के संचालन में संरक्षित नहीं है। Matrices हमेशा 2 डी होते हैं, जबकि एक सरणी का मतलब, उदाहरण के लिए, एक आयाम कम है।

उदाहरण के लिए पहुंचाना एक मैट्रिक्स या सरणी की पंक्तियों:

सरणी के साथ मैट्रिक्स

>>> m = np.mat([[1,2],[2,3]]) 
>>> m 
matrix([[1, 2], 
     [2, 3]]) 
>>> mm = m.mean(1) 
>>> mm 
matrix([[ 1.5], 
     [ 2.5]]) 
>>> mm.shape 
(2, 1) 
>>> m - mm 
matrix([[-0.5, 0.5], 
     [-0.5, 0.5]]) 

साथ

>>> a = np.array([[1,2],[2,3]]) 
>>> a 
array([[1, 2], 
     [2, 3]]) 
>>> am = a.mean(1) 
>>> am.shape 
(2,) 
>>> am 
array([ 1.5, 2.5]) 
>>> a - am #wrong 
array([[-0.5, -0.5], 
     [ 0.5, 0.5]]) 
>>> a - am[:, np.newaxis] #right 
array([[-0.5, 0.5], 
     [-0.5, 0.5]]) 

मैं भी लगता है कि मिश्रण सरणियों और मैट्रिक्स कई "खुश को जन्म देता है "डीबगिंग घंटे। हालांकि, scipy.sparse matrices हमेशा गुणा जैसे ऑपरेटरों के मामले में matrices हैं।

Answer 3

Scipy.org recommends that you use arrays:

* 'सरणी' या 'मैट्रिक्स'? मुझे किस का उपयोग करना चाहिए? - लघु उत्तर

सरणी का उपयोग करें।

• वे मानक वेक्टर/मैट्रिक्स/टेंसर प्रकार के numpy हैं। कई numpy फ़ंक्शन रिटर्न सरणी, matrices नहीं।

• तत्व-वार संचालन और रैखिक बीजगणित संचालन के बीच स्पष्ट अंतर है।

• यदि आप चाहें तो मानक वैक्टर या पंक्ति/कॉलम वैक्टर हो सकते हैं।

सरणी प्रकार का उपयोग कर के ही नुकसान यह है कि आप उपयोग * के बजाय dot करना होगा (कम) दो tensors (अदिश उत्पाद, मैट्रिक्स वेक्टर गुणा आदि) गुणा करने के लिए है।

Answer 4

जैसा कि अन्य ने उल्लेख किया है, शायद matrix का मुख्य लाभ यह था कि यह मैट्रिक्स गुणा के लिए सुविधाजनक संकेत प्रदान करता था।

हालांकि, in Python 3.5 there is finally a dedicated infix operator for matrix multiplication: @।

हाल NumPy संस्करणों के साथ, यह ndarray रों के साथ प्रयोग किया जा सकता है:

A = numpy.ones((1, 3)) 
B = numpy.ones((3, 3)) 
A @ B 

तो आजकल, और भी अधिक, जब संदेह में, आप ndarray से चिपके चाहिए।