numpy.einsum_path

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

通过考虑创建中间数组，计算einsum表达式的最低成本收缩顺序。

参数

subscriptsSTR

指定求和的下标。

*operands数组列表

这些是操作的数组。

optimizebool，list，tuple，'贪婪'，'最佳'

选择路径类型。如果提供了元组，则第二个参数假定为创建的最大中间大小。如果只提供一个参数，则最大的输入或输出数组大小将用作最大的中间大小。

• 如果给出了以 einsum_path ，将其用作收缩路径

• 如果为false，则不进行优化

• 如果为true，则默认为“贪婪”算法

• “最优”是一种结合探索所有可能收缩所列张量的方法并选择成本最低的路径的算法。与收缩中的项数成指数关系。

• “贪婪”一种算法，在每一步中选择最佳的对收缩。有效地，该算法在每个步骤中搜索最大的内部产品、Hadamard和外部产品。按收缩中的项数立体缩放。相当于大多数收缩的“最佳”路径。

默认值为“贪婪”。

返回

path元组列表

einsum路径的列表表示形式。

string_reprSTR

einsum路径的可打印表示。

参见

einsum, linalg.multi_dot

笔记

结果路径指示应首先收缩哪些输入收缩项，然后将收缩结果附加到收缩列表的末尾。然后可以重复此列表，直到所有中间收缩完成。

实例

我们可以从一个链点例子开始。在这种情况下，将 b 和 c 张量首先由路径的第一个元素表示 (1, 2) . 产生的张量加到收缩和剩余收缩的末端。 (0, 1) 然后完成。

>>> np.random.seed(123)
>>> 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 # may vary
         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 # may vary
         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

numpy.einsum numpy.linalg.matrix_power