numpy

Question

में दो 1 डी वैक्टरों का डॉट उत्पाद वेक्टर गुणा की गणना करने के लिए python में numpy के साथ काम कर रहा हूं। मेरे पास आयाम x x x का वेक्टर x है और मैं x * x_transpose की गणना करना चाहता हूं। यह मुझे समस्याएं देता है क्योंकि x.T या x.transpose() 1 आयामी वेक्टर को प्रभावित नहीं करता है (numpy लंबवत और क्षैतिज वैक्टर का प्रतिनिधित्व करता है)।

लेकिन मैं numpy में एक (एन एक्स 1) एक्स (1 एक्स एन) वेक्टर गुणा की गणना कैसे करूं?

numpy.dot (x, x.T) एक स्केलर देता है, जैसा कि मैं चाहता हूं 2 डी मैट्रिक्स नहीं।

Answer 1

आप अनिवार्य रूप से एक Outer Product परिकलित कर रहे हैं।

आप np.outer का उपयोग कर सकते हैं।

In [15]: a=[1,2,3] 

In [16]: np.outer(a,a) 
Out[16]: 
array([[1, 2, 3], 
     [2, 4, 6], 
     [3, 6, 9]]) 

Answer 2

आप एक आंतरिक उत्पाद चाहते हैं तो बाहरी उत्पाद के लिए numpy.dot(x,x) का उपयोग का उपयोग numpy.outer(x,x)

Answer 3

जबकि np.outer यह करने के लिए सबसे आसान तरीका है, मैंने सोचा था मैं तो बस आप कैसे यह करने के लिए (N,) आकार सरणी में हेरफेर हो सकता है उल्लेख चाहते हैं:

In [17]: a = np.arange(4) 
In [18]: np.dot(a[:,None], a[None,:]) 
Out[18]: 
array([[0, 0, 0, 0], 
     [0, 1, 2, 3], 
     [0, 2, 4, 6], 
     [0, 3, 6, 9]]) 

In [19]: np.outer(a,a) 
Out[19]: 
array([[0, 0, 0, 0], 
     [0, 1, 2, 3], 
     [0, 2, 4, 6], 
     [0, 3, 6, 9]]) 

आप कहाँ वैकल्पिक रूप से बदल सकते np.newaxis के साथ।

यह करने के लिए एक और अधिक विदेशी रास्ता np.einsum साथ है:

In [20]: np.einsum('i,j', a, a) 
Out[20]: 
array([[0, 0, 0, 0], 
     [0, 1, 2, 3], 
     [0, 2, 4, 6], 
     [0, 3, 6, 9]]) 

और सिर्फ मनोरंजन के लिए, कुछ समय है, जो की संभावना जा रहे हार्डवेयर और numpy संस्करण/संकलन के आधार पर भिन्न करने के लिए:

छोटे -ish वेक्टर

In [36]: a = np.arange(5, dtype=np.float64) 

In [37]: %timeit np.outer(a,a) 
100000 loops, best of 3: 17.7 µs per loop 

In [38]: %timeit np.dot(a[:,None],a[None,:]) 
100000 loops, best of 3: 11 µs per loop 

In [39]: %timeit np.einsum('i,j', a, a) 
1 loops, best of 3: 11.9 µs per loop 

In [40]: %timeit a[:, None] * a 
100000 loops, best of 3: 9.68 µs per loop 

और कुछ थोड़ा बड़ा

In [42]: a = np.arange(500, dtype=np.float64) 

In [43]: %timeit np.outer(a,a) 
1000 loops, best of 3: 605 µs per loop 

In [44]: %timeit np.dot(a[:,None],a[None,:]) 
1000 loops, best of 3: 1.29 ms per loop 

In [45]: %timeit np.einsum('i,j', a, a) 
1000 loops, best of 3: 359 µs per loop 

In [46]: %timeit a[:, None] * a 
1000 loops, best of 3: 597 µs per loop 

Answer 4

एक अन्य वैकल्पिक उपयोगकर्ता numpy.matrix को

>>> a = np.matrix([1,2,3]) 
>>> a 
matrix([[1, 2, 3]]) 
>>> a.T * a 
matrix([[1, 2, 3], 
     [2, 4, 6], 
     [3, 6, 9]]) 

आम तौर पर numpy.arrays का उपयोग करने को प्राथमिकता दी जाती है। हालांकि, numpy.matrices का उपयोग लंबे अभिव्यक्तियों के लिए अधिक पठनीय हो सकता है।

Answer 5

एक और विकल्प पंक्ति/कॉलम वेक्टर को 2-आयामों के साथ परिभाषित करना है, उदा।

a = np.array([1, 2, 3], ndmin=2) 
np.dot(a.T, a) 

array([[1, 2, 3], 
    [2, 4, 6], 
    [3, 6, 9]])