numpy.einsum_path

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

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

Параметры:

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

Возвращает:

path : список кортежей Представление пути 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