NumPy 1.14 - numpy.einsum_path()

numpy.einsum_path




numpy

numpy.einsum_path

numpy.einsum_path(subscripts, *operands, optimize='greedy') [source]

मध्यवर्ती सरणियों के निर्माण पर विचार करके एक einsum अभिव्यक्ति के लिए सबसे कम लागत संकुचन आदेश का मूल्यांकन करता है।

पैरामीटर:

ग्राहक : str

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

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

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

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

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

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

डिफ़ॉल्ट 'लालची' है।

यह दिखाता है:

पथ : ट्यूपल्स की सूची

एक सूची का प्रतिनिधित्व einsum पथ।

string_repr : str

आइंसम पथ का एक प्रिंट करने योग्य प्रतिनिधित्व।

यह भी देखें

einsum , linalg.multi_dot

टिप्पणियाँ

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

उदाहरण

हम एक श्रृंखला डॉट उदाहरण के साथ शुरू कर सकते हैं। इस मामले में, पथ के पहले तत्व (1, 2) द्वारा reprsented के रूप में पहले b और c दसियों को अनुबंधित करना इष्टतम है। परिणामी टेंसर को संकुचन के अंत में जोड़ा जाता है और शेष संकुचन (0, 1) को पूरा किया जाता है।

>>> a = np.random.rand(2, 2)
>>> b = np.random.rand(2, 5)
>>> c = np.random.rand(5, 2)
>>> path_info = np.einsum_path('ij,jk,kl->il', a, b, c, optimize='greedy')
>>> print(path_info[0])
['einsum_path', (1, 2), (0, 1)]
>>> print(path_info[1])
  Complete contraction:  ij,jk,kl->il
         Naive scaling:  4
     Optimized scaling:  3
      Naive FLOP count:  1.600e+02
  Optimized FLOP count:  5.600e+01
   Theoretical speedup:  2.857
  Largest intermediate:  4.000e+00 elements
-------------------------------------------------------------------------
scaling                  current                                remaining
-------------------------------------------------------------------------
   3                   kl,jk->jl                                ij,jl->il
   3                   jl,ij->il                                   il->il

एक अधिक जटिल सूचकांक परिवर्तन उदाहरण है।

>>> I = np.random.rand(10, 10, 10, 10)
>>> C = np.random.rand(10, 10)
>>> path_info = np.einsum_path('ea,fb,abcd,gc,hd->efgh', C, C, I, C, C,
                               optimize='greedy')
>>> print(path_info[0])
['einsum_path', (0, 2), (0, 3), (0, 2), (0, 1)]
>>> print(path_info[1])
  Complete contraction:  ea,fb,abcd,gc,hd->efgh
         Naive scaling:  8
     Optimized scaling:  5
      Naive FLOP count:  8.000e+08
  Optimized FLOP count:  8.000e+05
   Theoretical speedup:  1000.000
  Largest intermediate:  1.000e+04 elements
--------------------------------------------------------------------------
scaling                  current                                remaining
--------------------------------------------------------------------------
   5               abcd,ea->bcde                      fb,gc,hd,bcde->efgh
   5               bcde,fb->cdef                         gc,hd,cdef->efgh
   5               cdef,gc->defg                            hd,defg->efgh
   5               defg,hd->efgh                               efgh->efgh