2013-03-28 8 views
14

मैं समझता हूँ कि कैसे numpy साथ -1 डी सरणी (रेखीय बीजगणित में वेक्टर) को संभालने के लिए कोशिश के साथ -1 डी सरणी। निम्न उदाहरण में, मैं दो numpy.array ए और बी उत्पन्न: 1 पंक्ति, 3 कॉलम, लेकिन numpy के लिए नहीं:numpy: विभिन्न आकार

>>> import numpy as np 
>>> a = np.array([1,2,3]) 
>>> b = np.array([[1],[2],[3]]).reshape(1,3) 
>>> a.shape 
(3,) 
>>> b.shape 
(1, 3) 

मेरे लिए, ए और बी अनुसार रेखीय बीजगणित परिभाषा एक ही आकार की है।

अब, numpy डॉट उत्पाद:

>>> np.dot(a,a) 
14 
>>> np.dot(b,a) 
array([14]) 
>>> np.dot(b,b) 
Traceback (most recent call last): 
    File "<stdin>", line 1, in <module> 
ValueError: objects are not aligned 

मैं तीन अलग-अलग उत्पादन की है। डॉट (ए, ए) और डॉट (बी, ए) के बीच क्या अंतर है? क्यों डॉट (बी, बी) काम नहीं करता है?

मैं भी उन डॉट उत्पादों के साथ कुछ differencies है:

>>> c = np.ones(9).reshape(3,3) 
>>> np.dot(a,c) 
array([ 6., 6., 6.]) 
>>> np.dot(b,c) 
array([[ 6., 6., 6.]]) 

उत्तर

16

सूचना आप केवल 1 डी सरणियों के साथ काम नहीं कर रहे:

In [6]: a.ndim 
Out[6]: 1 

In [7]: b.ndim 
Out[7]: 2 

तो, b एक 2D सरणी है। तुम भी b.shape के उत्पादन में इस देखें: (1,3) के रूप में दो आयामों को इंगित करता है (3,) एक आयाम है।

np.dot के व्यवहार -1 डी और 2 डी सरणियों (docs से) के लिए अलग है:

2 डी सरणियों के लिए यह आव्यूह गुणन के बराबर है, और 1 डी के लिए के भीतर उत्पाद के लिए सरणियों वेक्टर

यही कारण है कि आपको अलग-अलग परिणाम मिलते हैं, क्योंकि आप 1 डी और 2 डी सरणी मिश्रण कर रहे हैं। चूंकि b एक 2D सरणी है, np.dot(b, b) दो 1x3 मैट्रिक्स, जो विफल रहता है पर एक आव्यूह गुणन कोशिश करता है।


-1 डी सरणियों के साथ, np.dot वैक्टर की एक आंतरिक उत्पाद करता है:

In [44]: a = np.array([1,2,3]) 

In [45]: b = np.array([1,2,3]) 

In [46]: np.dot(a, b) 
Out[46]: 14 

In [47]: np.inner(a, b) 
Out[47]: 14 
2 डी सरणियों के साथ

, यह एक आव्यूह गुणन (ताकि 1x3 x 3x1 = 1x1, 3x1 या एक्स 1x3 है = 3x3):

In [49]: a = a.reshape(1,3) 

In [50]: b = b.reshape(3,1) 

In [51]: a 
Out[51]: array([[1, 2, 3]]) 

In [52]: b 
Out[52]: 
array([[1], 
     [2], 
     [3]]) 

In [53]: np.dot(a,b) 
Out[53]: array([[14]]) 

In [54]: np.dot(b,a) 
Out[54]: 
array([[1, 2, 3], 
     [2, 4, 6], 
     [3, 6, 9]]) 

In [55]: np.dot(a,a) 
--------------------------------------------------------------------------- 
ValueError        Traceback (most recent call last) 
<ipython-input-55-32e36f9db916> in <module>() 
----> 1 np.dot(a,a) 

ValueError: objects are not aligned 
+0

उत्तर के लिए धन्यवाद। तो अगर मैं कुछ रैखिक बीजगणित numpy के साथ करना चाहता हूँ तो सबसे अच्छा अभ्यास क्या है? मेरे सभी वेक्टर को 2 डी numpy.array में कनवर्ट करें? मैं दो अलग-अलग आकार से थोड़ा उलझन में हूं ... – Marcel

+0

मैं खुद को बहुत अधिक रैखिक बीजगणित नहीं कर रहा हूं, लेकिन मुझे लगता है कि यह इस बात पर निर्भर करता है कि आप वास्तव में क्या करना चाहते हैं। बस वेक्टर उत्पाद और अन्य सरल कुशलता/गणना, फिर 1 डी ठीक है। यदि आप मैट्रिक्स गणना आदि करना चाहते हैं, तो आपको 2 डी का उपयोग करना चाहिए। – joris

+3

सबसे अच्छी रणनीति वैक्टर और 2 डी सरणियों के लिए 1 डी सरणियों का उपयोग करने के मैट्रिक्स प्रतिनिधित्व करने के लिए किया जाएगा। आकार '(1,3)' के साथ 2 डी सरणी जैसे निर्माण मुख्य रूप से सरणी जादू के लिए आवश्यक हैं, लेकिन मानक रैखिक बीजगणित सामग्री नहीं है। रेखीय बीजगणित के संदर्भ में यह एक '1x3' मैट्रिक्स की नहीं बहुत उपयोगी वस्तु के अनुरूप होगा। – flonk

संबंधित मुद्दे