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

По умолчанию используется «жадный».

Возвращает

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