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’ Алгоритм, который на каждом шаге выбирает наилучшее сокращение пары. Эффективно, этот алгоритм ищет наибольшие внутренние, Hadamard и затем внешние произведения на каждом шаге. Масштабируется кубически с количеством членов в сокращении. Эквивалентен пути ‘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