numpy
numpy.dot

वाक्य - विन्यास

• numpy.dot (ए, बी, आउट = कोई नहीं)

पैरामीटर

टिप्पणियों

मैट्रिक्स गुणन

मैट्रिक्स गुणन दो प्रकार से डॉट फंक्शन के साथ किया जा सकता है। एक तरीका है numpy.ndarray के डॉट सदस्य फ़ंक्शन का उपयोग करना।

>>> import numpy as np
>>> A = np.ones((4,4))
>>> A
array([[ 1.,  1.,  1.,  1.],
       [ 1.,  1.,  1.,  1.],
       [ 1.,  1.,  1.,  1.],
       [ 1.,  1.,  1.,  1.]])
>>> B = np.ones((4,2))
>>> B
array([[ 1.,  1.],
       [ 1.,  1.],
       [ 1.,  1.],
       [ 1.,  1.]])
>>> A.dot(B)
array([[ 4.,  4.],
       [ 4.,  4.],
       [ 4.,  4.],
       [ 4.,  4.]])

मैट्रिक्स गुणा करने का दूसरा तरीका संख्यात्मक लाइब्रेरी फ़ंक्शन के साथ है।

>>> np.dot(A,B)
array([[ 4.,  4.],
       [ 4.,  4.],
       [ 4.,  4.],
       [ 4.,  4.]])

वेक्टर डॉट उत्पाद

डॉट फ़ंक्शन का उपयोग वेक्टर डॉट उत्पादों को दो एक-आयामी सुन्न सरणियों के बीच गणना करने के लिए भी किया जा सकता है।

>>> v = np.array([1,2])
>>> w = np.array([1,2])
>>> v.dot(w)
5
>>> np.dot(w,v)
5
>>> np.dot(v,w)
5

बाहर पैरामीटर

Numpy डॉट फंक्शन में एक वैकल्पिक पैरामीटर है = कोई नहीं। यह पैरामीटर आपको परिणाम लिखने के लिए एक सरणी निर्दिष्ट करने की अनुमति देता है। यह सरणी ठीक उसी आकार और प्रकार की होनी चाहिए, जिस सरणी को वापस किया गया होगा, या एक अपवाद फेंक दिया जाएगा।

>>> I = np.eye(2)
>>> I
array([[ 1.,  0.],
       [ 0.,  1.]])
>>> result = np.zeros((2,2))
>>> result
array([[ 0.,  0.],
       [ 0.,  0.]])
>>> np.dot(I, I, out=result)
array([[ 1.,  0.],
       [ 0.,  1.]])
>>> result
array([[ 1.,  0.],
       [ 0.,  1.]])

आइए परिणाम के dtype को int में बदलने का प्रयास करें।

>>> np.dot(I, I, out=result)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: output array is not acceptable (must have the right type, nr dimensions, and be a C-Array)

और अगर हम एक अलग अंतर्निहित मेमोरी ऑर्डर का उपयोग करने का प्रयास करते हैं, तो फोरट्रान-शैली कहते हैं (इसलिए पंक्तियों के बजाय कॉलम सन्निहित हैं), एक त्रुटि भी परिणाम होती है।

>>> result = np.zeros((2,2), order='F')
>>> np.dot(I, I, out=result)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: output array is not acceptable (must have the right type, nr dimensions, and be a C-Array)

वैक्टर के सरणियों पर मैट्रिक्स का संचालन

numpy.dot का उपयोग मैट्रिक्स द्वारा वैक्टर की एक सूची को गुणा करने के लिए किया जा सकता है लेकिन वैक्टर का उन्मुखीकरण ऊर्ध्वाधर होना चाहिए ताकि आठ दो घटक वैक्टर की एक सूची दो आठ घटक वैक्टर की तरह दिखाई दे:

>>> a
array([[ 1.,  2.],
       [ 3.,  1.]])
>>> b
array([[  1.,   2.,   3.,   4.,   5.,   6.,   7.,   8.],
       [  9.,  10.,  11.,  12.,  13.,  14.,  15.,  16.]])
>>> np.dot(a, b)
array([[ 19.,  22.,  25.,  28.,  31.,  34.,  37.,  40.],
       [ 12.,  16.,  20.,  24.,  28.,  32.,  36.,  40.]])

यदि वैक्टर की सूची को उसके दूसरे तरीके के चक्कर के साथ रखा गया है (जो कि अक्सर होता है) तो सरणी को इस तरह डॉट ऑपरेशन से पहले और उसके बाद ट्रांसप्लान्ट करना होगा:

>>> b
array([[  1.,   9.],
       [  2.,  10.],
       [  3.,  11.],
       [  4.,  12.],
       [  5.,  13.],
       [  6.,  14.],
       [  7.,  15.],
       [  8.,  16.]])
>>> np.dot(a, b.T).T
array([[ 19.,  12.],
       [ 22.,  16.],
       [ 25.,  20.],
       [ 28.,  24.],
       [ 31.,  28.],
       [ 34.,  32.],
       [ 37.,  36.],
       [ 40.,  40.]])

हालाँकि डॉट फंक्शन बहुत तेज़ है, कभी-कभी इइनसुम का उपयोग करना बेहतर होता है। ऊपर के बराबर होगा:

>>> np.einsum('...ij,...j', a, b)

जो थोड़ा धीमा है, लेकिन मैट्रिसेस की इसी सूची से वर्टिकल की सूची को गुणा करने की अनुमति देता है। यह डॉट का उपयोग करके एक बहुत जटिल प्रक्रिया होगी:

>>> a
array([[[ 0,  1],
        [ 2,  3]],
       [[ 4,  5],
        [ 6,  7]],
       [[ 8,  9],
        [10, 11]],
       [[12, 13],
        [14, 15]],
       [[16, 17],
        [18, 19]],
       [[20, 21],
        [22, 23]],
       [[24, 25],
        [26, 27]],
       [[28, 29],
        [30, 31]]])
>>> np.einsum('...ij,...j', a, b)
array([[   9.,   29.],
       [  58.,   82.],
       [ 123.,  151.],
       [ 204.,  236.],
       [ 301.,  337.],
       [ 414.,  454.],
       [ 543.,  587.],
       [ 688.,  736.]])

numpy.dot का उपयोग किसी सूची में प्रत्येक वेक्टर के डॉट उत्पाद को खोजने के लिए किया जा सकता है, जिसकी सूची किसी अन्य सूची में संबंधित वेक्टर के साथ है, तत्व-वार गुणन और अंतिम अक्ष के साथ योग की तुलना में यह काफी गन्दा और धीमा है। कुछ इस तरह से (जिसकी गणना के लिए बहुत बड़े सरणी की आवश्यकता होती है लेकिन ज्यादातर को अनदेखा किया जाता है)

>>> np.diag(np.dot(b,b.T))
array([  82.,  104.,  130.,  160.,  194.,  232.,  274.,  320.])

तत्व-वार गुणा और योग का उपयोग कर डॉट उत्पाद

>>> (b * b).sum(axis=-1)
array([  82.,  104.,  130.,  160.,  194.,  232.,  274.,  320.])

Einsum का उपयोग करके प्राप्त किया जा सकता है

>>> np.einsum('...j,...j', b, b)
array([  82.,  104.,  130.,  160.,  194.,  232.,  274.,  320.])