NumPy 1.14 - numpy.einsum()

numpy.einsum




numpy

numpy.einsum

numpy.einsum(subscripts, *operands, out=None, dtype=None, order='K', casting='safe', optimize=False) [source]

ऑपरेंड पर आइंस्टीन योग सम्मेलन का मूल्यांकन करता है।

आइंस्टीन सम्‍मेलन अधिवेशन का उपयोग करते हुए, कई सामान्य बहुआयामी सरणी परिचालनों को सरल शैली में दर्शाया जा सकता है। यह फ़ंक्शन ऐसे योगों की गणना करने का एक तरीका प्रदान करता है। इस फ़ंक्शन को समझने का सबसे अच्छा तरीका नीचे दिए गए उदाहरणों को आज़माना है, जो बताते हैं कि कितने सामान्य संख्या में कार्य einsum को कॉल के रूप में कार्यान्वित किए जा सकते हैं।

पैरामीटर:

ग्राहक : str

सारांश के लिए सदस्यता निर्दिष्ट करता है।

ऑपरेंड : array_like की सूची

ये ऑपरेशन के लिए सरणियाँ हैं।

बाहर : {ndarray, कोई नहीं}, वैकल्पिक

यदि प्रदान किया जाता है, तो गणना इस सरणी में की जाती है।

dtype : {data-type, none }, वैकल्पिक

यदि प्रदान किया गया है, तो गणना को निर्दिष्ट डेटा प्रकार का उपयोग करने के लिए मजबूर करता है। ध्यान दें कि रूपांतरणों की अनुमति देने के लिए आपको अधिक उदार casting पैरामीटर भी देना पड़ सकता है। डिफ़ॉल्ट कोई भी नहीं है।

आदेश : {'C', 'F', 'A', 'K'}, वैकल्पिक

आउटपुट के मेमोरी लेआउट को नियंत्रित करता है। 'C' का मतलब है कि यह C सन्निहित होना चाहिए। 'एफ' का अर्थ है कि यह फोरट्रान सन्निहित होना चाहिए, 'ए' का मतलब है कि यह 'एफ' होना चाहिए अगर इनपुट सभी 'एफ', 'सी' अन्यथा हों। 'के' का मतलब है कि यह लेआउट के करीब होना चाहिए जितना कि इनपुट संभव है, इसमें मनमाने ढंग से अनुमत कुल्हाड़ियों भी शामिल हैं। डिफ़ॉल्ट 'के' है।

कास्टिंग : {'नहीं', 'इक्विव', 'सेफ', 'समान_किंडन', 'असुरक्षित'}, वैकल्पिक

नियंत्रित करता है कि किस प्रकार की डेटा कास्टिंग हो सकती है। इसे 'असुरक्षित' पर सेट करने की अनुशंसा नहीं की जाती है, क्योंकि यह संचय को प्रतिकूल रूप से प्रभावित कर सकता है।

  • 'नहीं' का अर्थ है कि डेटा प्रकारों को बिल्कुल नहीं डाला जाना चाहिए।
  • 'इक्विव' का मतलब केवल बाइट-ऑर्डर परिवर्तन की अनुमति है।
  • s सुरक्षित ’का मतलब केवल वे ही जातियां हैं जो मूल्यों को संरक्षित कर सकती हैं।
  • 'same_kind' का अर्थ है केवल एक प्रकार के भीतर सुरक्षित जाति या जाति, जैसे कि float64 से float32 तक की अनुमति है।
  • 'असुरक्षित' का अर्थ है कि कोई भी डेटा रूपांतरण हो सकता है।

डिफ़ॉल्ट 'सुरक्षित' है।

अनुकूलन : {असत्य, सत्य, 'लालची', 'इष्टतम'}, वैकल्पिक

यदि मध्यवर्ती अनुकूलन होना चाहिए, तो नियंत्रण। कोई अनुकूलन नहीं होगा यदि गलत और सही 'लालची' एल्गोरिथ्म के लिए डिफ़ॉल्ट होगा। np.einsum_path फ़ंक्शन से एक स्पष्ट संकुचन सूची भी स्वीकार करता है। अधिक विवरण के लिए np.einsum_path देखें। डिफ़ॉल्ट गलत है।

यह दिखाता है:

आउटपुट : ndarray

आइंस्टीन योग सम्मेलन पर आधारित गणना।

टिप्पणियाँ

संस्करण 1.6.0 में नया।

सबस्क्राइब स्ट्रिंग सबस्क्रिप्ट लेबल की अल्पविराम से अलग की गई सूची है, जहां प्रत्येक लेबल संबंधित ऑपरेंड के एक आयाम को संदर्भित करता है। एक ऑपरेंड में बार-बार सदस्यता के लेबल विकर्ण लेते हैं। उदाहरण के लिए, np.einsum('ii', a) , np.einsum('ii', a) के बराबर है।

जब भी कोई लेबल दोहराया जाता है, तो उसे np.einsum('i,i', a, b) किया जाता है, इसलिए np.einsum('i,i', a, b) np.inner(a,b) बराबर है। यदि कोई लेबल केवल एक बार दिखाई देता है, तो उसे np.einsum('i', a) नहीं किया जाता है, इसलिए np.einsum('i', a) बिना किसी बदलाव के एक दृश्य उत्पन्न करता है।

आउटपुट में लेबल का क्रम डिफ़ॉल्ट वर्णमाला द्वारा होता है। इसका मतलब यह है कि np.einsum('ij', a) 2D व्यूह को प्रभावित नहीं करता है, जबकि np.einsum('ji', a) इसका स्थानान्तरण लेता है।

आउटपुट सबस्क्रिप्ट लेबल को निर्दिष्ट करके भी आउटपुट को नियंत्रित किया जा सकता है। यह लेबल ऑर्डर को निर्दिष्ट करता है, और योग को वांछित होने पर अस्वीकृत या मजबूर करने की अनुमति देता है। कॉल np.einsum('i->', a) np.sum(a, axis=-1) और np.einsum('ii->i', a) की तरह है np.einsum('ii->i', a) np.diag(a) np.einsum('ii->i', a) की तरह है । अंतर यह है कि einsum डिफ़ॉल्ट रूप से प्रसारण की अनुमति नहीं देता है।

प्रसारण को सक्षम और नियंत्रित करने के लिए, एक दीर्घवृत्त का उपयोग करें। डिफ़ॉल्ट NumPy- शैली का प्रसारण प्रत्येक शब्द के बाईं ओर एक दीर्घवृत्त जोड़कर किया जाता है, जैसे np.einsum('...ii->...i', a) । पहली और आखिरी कुल्हाड़ियों के साथ ट्रेस लेने के लिए, आप np.einsum('i...i', a) , या np.einsum('i...i', a) -मोस्ट इंडेक्स की बजाए एक मैट्रिक्स-मैट्रिक्स उत्पाद करने के लिए कर सकते हैं, आप कर सकते हैं np.einsum('ij...,jk...->ik...', a, b)

जब केवल एक ही ऑपरेंड होता है, तो कोई एक्सिस समिट नहीं किया जाता है, और कोई आउटपुट पैरामीटर नहीं दिया जाता है, ऑपरेंड में एक व्यू एक नए एरे के बजाय वापस आ जाता है। इस प्रकार, विकर्ण को np.einsum('ii->i', a) रूप में लेने से np.einsum('ii->i', a) एक दृश्य उत्पन्न होता है।

सब्सक्राइबर्स और einsum(op0, sublist0, op1, sublist1, ..., [sublistout]) प्रदान करने का एक वैकल्पिक तरीका है einsum(op0, sublist0, op1, sublist1, ..., [sublistout]) । नीचे दिए गए उदाहरणों में दो पैरामीटर विधियों के साथ संबंधित einsum कॉल है।

संस्करण 1.10.0 में नया।

जब भी इनपुट ऐरे को राइट किया जाता है, तो आइंसम से लौटाए गए दृश्य लेखन योग्य होते हैं। उदाहरण के लिए, np.einsum('ijk...->kji...', a) अब np.swapaxes(a, 0, 2) और np.einsum('ii->i', a) np.swapaxes(a, 0, 2) के समान प्रभाव पड़ेगा np.einsum('ii->i', a) एक 2 डी सरणी के विकर्ण का एक लेखन दृश्य लौटाएगा।

संस्करण 1.12.0 में नया।

optimize तर्क जोड़ा गया है जो एक einsum अभिव्यक्ति के संकुचन आदेश का अनुकूलन करेगा। तीन या अधिक ऑपरेंड वाले संकुचन के लिए यह गणना के दौरान बड़े मेमोरी फुटप्रिंट की लागत पर कम्प्यूटेशनल दक्षता को बढ़ा सकता है।

अधिक विवरण के लिए np.einsum_path देखें।

उदाहरण

>>> a = np.arange(25).reshape(5,5)
>>> b = np.arange(5)
>>> c = np.arange(6).reshape(2,3)
>>> np.einsum('ii', a)
60
>>> np.einsum(a, [0,0])
60
>>> np.trace(a)
60
>>> np.einsum('ii->i', a)
array([ 0,  6, 12, 18, 24])
>>> np.einsum(a, [0,0], [0])
array([ 0,  6, 12, 18, 24])
>>> np.diag(a)
array([ 0,  6, 12, 18, 24])
>>> np.einsum('ij,j', a, b)
array([ 30,  80, 130, 180, 230])
>>> np.einsum(a, [0,1], b, [1])
array([ 30,  80, 130, 180, 230])
>>> np.dot(a, b)
array([ 30,  80, 130, 180, 230])
>>> np.einsum('...j,j', a, b)
array([ 30,  80, 130, 180, 230])
>>> np.einsum('ji', c)
array([[0, 3],
       [1, 4],
       [2, 5]])
>>> np.einsum(c, [1,0])
array([[0, 3],
       [1, 4],
       [2, 5]])
>>> c.T
array([[0, 3],
       [1, 4],
       [2, 5]])
>>> np.einsum('..., ...', 3, c)
array([[ 0,  3,  6],
       [ 9, 12, 15]])
>>> np.einsum(',ij', 3, C)
array([[ 0,  3,  6],
       [ 9, 12, 15]])
>>> np.einsum(3, [Ellipsis], c, [Ellipsis])
array([[ 0,  3,  6],
       [ 9, 12, 15]])
>>> np.multiply(3, c)
array([[ 0,  3,  6],
       [ 9, 12, 15]])
>>> np.einsum('i,i', b, b)
30
>>> np.einsum(b, [0], b, [0])
30
>>> np.inner(b,b)
30
>>> np.einsum('i,j', np.arange(2)+1, b)
array([[0, 1, 2, 3, 4],
       [0, 2, 4, 6, 8]])
>>> np.einsum(np.arange(2)+1, [0], b, [1])
array([[0, 1, 2, 3, 4],
       [0, 2, 4, 6, 8]])
>>> np.outer(np.arange(2)+1, b)
array([[0, 1, 2, 3, 4],
       [0, 2, 4, 6, 8]])
>>> np.einsum('i...->...', a)
array([50, 55, 60, 65, 70])
>>> np.einsum(a, [0,Ellipsis], [Ellipsis])
array([50, 55, 60, 65, 70])
>>> np.sum(a, axis=0)
array([50, 55, 60, 65, 70])
>>> a = np.arange(60.).reshape(3,4,5)
>>> b = np.arange(24.).reshape(4,3,2)
>>> np.einsum('ijk,jil->kl', a, b)
array([[ 4400.,  4730.],
       [ 4532.,  4874.],
       [ 4664.,  5018.],
       [ 4796.,  5162.],
       [ 4928.,  5306.]])
>>> np.einsum(a, [0,1,2], b, [1,0,3], [2,3])
array([[ 4400.,  4730.],
       [ 4532.,  4874.],
       [ 4664.,  5018.],
       [ 4796.,  5162.],
       [ 4928.,  5306.]])
>>> np.tensordot(a,b, axes=([1,0],[0,1]))
array([[ 4400.,  4730.],
       [ 4532.,  4874.],
       [ 4664.,  5018.],
       [ 4796.,  5162.],
       [ 4928.,  5306.]])
>>> a = np.arange(6).reshape((3,2))
>>> b = np.arange(12).reshape((4,3))
>>> np.einsum('ki,jk->ij', a, b)
array([[10, 28, 46, 64],
       [13, 40, 67, 94]])
>>> np.einsum('ki,...k->i...', a, b)
array([[10, 28, 46, 64],
       [13, 40, 67, 94]])
>>> np.einsum('k...,jk', a, b)
array([[10, 28, 46, 64],
       [13, 40, 67, 94]])
>>> # since version 1.10.0
>>> a = np.zeros((3, 3))
>>> np.einsum('ii->i', a)[:] = 1
>>> a
array([[ 1.,  0.,  0.],
       [ 0.,  1.,  0.],
       [ 0.,  0.,  1.]])