NumPy 1.14 - numpy.tensordot()

numpy.tensordot




numpy

numpy.tensordot

numpy.tensordot(a, b, axes=2) [source]

Arrays> = 1-D के लिए निर्दिष्ट कुल्हाड़ियों के साथ टैंसर डॉट उत्पाद की गणना करें।

दो टेनर्स (एक से अधिक या बराबर आयाम की सरणियाँ), a और b , और array_like ऑब्जेक्ट को दो array_like ऑब्जेक्ट, (a_axes, b_axes) , 's और b ' तत्वों (घटकों) के उत्पादों को (a_axes, b_axes) हैं। a_axes और b_axes द्वारा निर्दिष्ट कुल्हाड़ियों। तीसरा तर्क एक एकल गैर-नकारात्मक पूर्णांक_ जैसे स्केलर, N ; यदि यह ऐसा है, तो b के अंतिम N आयाम और b के पहले N आयामों को अभिव्यक्त किया गया है।

पैरामीटर:

a, b : array_like, len (आकार)> = 1

"डॉट" के लिए सेंसर।

कुल्हाड़ियों : int या (2) array_like

  • integer_like यदि कोई इंट एन, क्रम में b के अंतिम एन एक्सिस और b के पहले एन एक्सिस पर योग करता है। संबंधित कुल्हाड़ियों के आकार मेल खाना चाहिए।
  • (2), array_like या, एक्सिस की एक सूची को अभिव्यक्त करने के लिए, पहले क्रम में a , दूसरे से b । दोनों तत्व array_like समान लंबाई के होने चाहिए।

यह भी देखें

dot , einsum

टिप्पणियाँ

तीन सामान्य उपयोग के मामले हैं:
  • axes = 0 : टेंसर उत्पाद a \ otimes b
  • axes = 1 : टेंसर डॉट उत्पाद a \ cdot b
  • axes = 2 : (डिफ़ॉल्ट) दसियों दोहरे संकुचन एक: ख

जब axes को पूर्णांक_ समान किया जाता है, तो मूल्यांकन का क्रम होगा: पहले -N में अक्ष और 0 में अक्ष, और अंतिम में -1 और अक्ष में N का अक्ष।

जब योग करने के लिए एक से अधिक अक्ष होते हैं - और वे अंतिम (प्रथम) अक्ष नहीं होते हैं ( b ) - तर्क axes में एक ही लंबाई के दो अनुक्रम शामिल होते हैं, जिसमें पहली धुरी में पहले से अधिक योग होते हैं दोनों क्रम, दूसरा अक्ष दूसरा और आगे।

उदाहरण

एक "पारंपरिक" उदाहरण:

>>> a = np.arange(60.).reshape(3,4,5)
>>> b = np.arange(24.).reshape(4,3,2)
>>> c = np.tensordot(a,b, axes=([1,0],[0,1]))
>>> c.shape
(5, 2)
>>> c
array([[ 4400.,  4730.],
       [ 4532.,  4874.],
       [ 4664.,  5018.],
       [ 4796.,  5162.],
       [ 4928.,  5306.]])
>>> # A slower but equivalent way of computing the same...
>>> d = np.zeros((5,2))
>>> for i in range(5):
...   for j in range(2):
...     for k in range(3):
...       for n in range(4):
...         d[i,j] += a[k,n,i] * b[n,k,j]
>>> c == d
array([[ True,  True],
       [ True,  True],
       [ True,  True],
       [ True,  True],
       [ True,  True]])

+ और * के ओवरलोडिंग का फायदा उठाते हुए एक विस्तारित उदाहरण:

>>> a = np.array(range(1, 9))
>>> a.shape = (2, 2, 2)
>>> A = np.array(('a', 'b', 'c', 'd'), dtype=object)
>>> A.shape = (2, 2)
>>> a; A
array([[[1, 2],
        [3, 4]],
       [[5, 6],
        [7, 8]]])
array([[a, b],
       [c, d]], dtype=object)
>>> np.tensordot(a, A) # third argument default is 2 for double-contraction
array([abbcccdddd, aaaaabbbbbbcccccccdddddddd], dtype=object)
>>> np.tensordot(a, A, 1)
array([[[acc, bdd],
        [aaacccc, bbbdddd]],
       [[aaaaacccccc, bbbbbdddddd],
        [aaaaaaacccccccc, bbbbbbbdddddddd]]], dtype=object)
>>> np.tensordot(a, A, 0) # tensor product (result too long to incl.)
array([[[[[a, b],
          [c, d]],
          ...
>>> np.tensordot(a, A, (0, 1))
array([[[abbbbb, cddddd],
        [aabbbbbb, ccdddddd]],
       [[aaabbbbbbb, cccddddddd],
        [aaaabbbbbbbb, ccccdddddddd]]], dtype=object)
>>> np.tensordot(a, A, (2, 1))
array([[[abb, cdd],
        [aaabbbb, cccdddd]],
       [[aaaaabbbbbb, cccccdddddd],
        [aaaaaaabbbbbbbb, cccccccdddddddd]]], dtype=object)
>>> np.tensordot(a, A, ((0, 1), (0, 1)))
array([abbbcccccddddddd, aabbbbccccccdddddddd], dtype=object)
>>> np.tensordot(a, A, ((2, 1), (1, 0)))
array([acccbbdddd, aaaaacccccccbbbbbbdddddddd], dtype=object)