numpy.einsum_path

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

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

Параметры

subscriptsstr

Указывает подстрочные индексы для суммирования.

*operandslist of array_like

Это массивы для операции.

optimize{bool, list, tuple, ‘greedy’, ‘optimal’}

Выберите тип пути. Если предоставлена кортеж, второй аргумент предполагается максимальный размер промежуточного массива. Если предоставлен только один аргумент, используется максимальный размер входного или выходного массива в качестве максимального размера промежуточного массива.

• если указан список, начинающийся с einsum_path, использует этот список как путь сокращения
• если False, оптимизация не применяется
• если True, по умолчанию используется алгоритм ‘greedy’
• ‘optimal’ Алгоритм, который комбинированно исследует все возможные способы сокращения перечисленных тензоров и выбирает путь с наименьшей стоимостью. Масштабируется экспоненциально с числом членов в сокращении.
• ‘greedy’ Алгоритм, который на каждом шаге выбирает лучшую пару сокращений. По существу, этот алгоритм ищет наибольшие внутренние, аддитивные и затем внешние произведения на каждом шаге. Масштабируется кубически с числом членов в сокращении. Эквивалентен пути ‘optimal’ для большинства сокращений.

По умолчанию ‘greedy’.

Возвращает

pathlist of tuples

Список кортежей, представляющий путь 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