numpy.einsum_path

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

Определяет порядок сокращения с наименьшей стоимостью для выражения einsum, учитывая создание промежуточных массивов.

Параметры:

subscripts : str Определяет подстроки для суммирования. *operands : list of array_like Это массивы для операции. optimize : {bool, list, tuple, ‘greedy’, ‘optimal’} Выберите тип пути. Если предоставлена кортеж, второй аргумент предполагается максимальным размером созданного промежуточного массива. Если предоставлен только один аргумент, используется наибольший размер входного или выходного массива в качестве максимального размера промежуточного массива. если указан список, начинающийся с einsum_path, использует его в качестве пути сокращения если False, оптимизация не применяется если True, используется алгоритм по умолчанию «greedy» ‘optimal’ Алгоритм, который комбинированно исследует все возможные способы сокращения перечисленных тензоров и выбирает путь с наименьшей стоимостью. Масштабируется экспоненциально с количеством членов в сокращении. ‘greedy’ Алгоритм, выбирающий наилучшее сокращение пары на каждом шаге. По сути, этот алгоритм ищет наибольшие внутренние, Hadamard и внешние произведения на каждом шаге. Масштабируется кубически с количеством членов в сокращении. Эквивалентен пути ‘optimal’ для большинства сокращений. По умолчанию используется ‘greedy’.

Возвращает:

path : list of tuples Список, представляющий путь einsum. string_repr : str Печатаемая форма представления пути einsum.

См. также

einsum, linalg.multi_dot

Примечания

Полученный путь указывает, какие члены входного сокращения должны быть сокращены в первую очередь, результат этого сокращения затем добавляется в конец списка сокращений. Этот список можно затем перебрать, пока все промежуточные сокращения не будут завершены.

Примеры

Мы можем начать с примера цепочечного умножения. В этом случае оптимально сначала сократить тензоры b и c, как представлено в первом элементе пути (1, 2). Результирующий тензор добавляется в конец списка сокращений, и затем выполняется оставшееся сокращение (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