o i5@sDddlZddZddZddZdd Zd d Zd d ZddZdS)NcCs,t||}td|d}|r|d7}||S)aCopied from _flop_count in numpy/core/einsumfunc.py Computes the number of FLOPS in the contraction. Parameters ---------- idx_contraction : iterable The indices involved in the contraction inner : bool Does this contraction require an inner product? num_terms : int The number of terms in a contraction size_dictionary : dict The size of each of the indices in idx_contraction Returns ------- flop_count : int The total number of FLOPS required for the contraction. Examples -------- >>> _flop_count('abc', False, 1, {'a': 2, 'b':3, 'c':5}) 90 >>> _flop_count('abc', True, 2, {'a': 2, 'b':3, 'c':5}) 270 )_compute_size_by_dictmax)idx_contractioninner num_termssize_dictionary overall_size op_factorr T/home/ubuntu/veenaModal/venv/lib/python3.10/site-packages/cupy/linalg/_einsum_opt.py _flop_counts r cCsd}|D]}|||9}q|S)aCopied from _compute_size_by_dict in numpy/core/einsumfunc.py Computes the product of the elements in indices based on the dictionary idx_dict. Parameters ---------- indices : iterable Indices to base the product on. idx_dict : dictionary Dictionary of index sizes Returns ------- ret : int The resulting product. Examples -------- >>> _compute_size_by_dict('abbc', {'a': 2, 'b':3, 'c':5}) 90 rr )indicesidx_dictretir r r r,src Csnt}|}g}t|D]\}}||vr||O}q ||||O}q ||@}||} ||||| |fS)aDCopied from _find_contraction in numpy/core/einsumfunc.py Finds the contraction for a given set of input and output sets. Parameters ---------- positions : iterable Integer positions of terms used in the contraction. input_sets : list List of sets that represent the lhs side of the einsum subscript output_set : set Set that represents the rhs side of the overall einsum subscript Returns ------- new_result : set The indices of the resulting contraction remaining : list List of sets that have not been contracted, the new set is appended to the end of this list idx_removed : set Indices removed from the entire contraction idx_contraction : set The indices used in the current contraction Examples -------- # A simple dot product test case >>> pos = (0, 1) >>> isets = [set('ab'), set('bc')] >>> oset = set('ac') >>> _find_contraction(pos, isets, oset) ({'a', 'c'}, [{'a', 'c'}], {'b'}, {'a', 'b', 'c'}) # A more complex case with additional terms in the contraction >>> pos = (0, 2) >>> isets = [set('abd'), set('ac'), set('bdc')] >>> oset = set('ac') >>> _find_contraction(pos, isets, oset) ({'a', 'c'}, [{'a', 'c'}, {'a', 'c'}], {'b', 'd'}, {'a', 'b', 'c', 'd'}) )setcopy enumerateappend) positions input_sets output_set idx_contract idx_remain remainingindvalue new_result idx_removedr r r _find_contractionJs,     r c Cs(dg|fg}tt|dD]j}g}|D]D}|\}} } ttt||dD]0} t| | |} | \} }}}t| |}||kr?q'|t||t| |}| | g}||||fq'q|r^|}qt|dddd}|t tt||g7}|St|dkrt tt|gSt|dddd}|S)aCopied from _optimal_path in numpy/core/einsumfunc.py Computes all possible pair contractions, sieves the results based on ``memory_limit`` and returns the lowest cost path. This algorithm scales factorial with respect to the elements in the list ``input_sets``. Parameters ---------- input_sets : list List of sets that represent the lhs side of the einsum subscript output_set : set Set that represents the rhs side of the overall einsum subscript idx_dict : dictionary Dictionary of index sizes memory_limit : int The maximum number of elements in a temporary array Returns ------- path : list The optimal contraction order within the memory limit constraint. Examples -------- >>> isets = [set('abd'), set('ac'), set('bdc')] >>> oset = set('') >>> idx_sizes = {'a': 1, 'b':2, 'c':3, 'd':4} >>> _optimal_path(isets, oset, idx_sizes, 5000) [(0, 2), (0, 1)] rrcS|dSNrr xr r r z_optimal_path..keycSr"r#r r$r r r r&r') rangelen itertools combinationsr rr rmintuple)rrr memory_limit full_results iteration iter_resultscurrcostrrconcontrnew_input_setsrrnew_size total_costnew_pospathr r r _optimal_paths4       r=cst||}|\}} } } t|} | |krdSfdd|D} t| | }t| | t|}| |f}|||kr=dS||| gS)a*Copied from _parse_possible_contraction in numpy/core/einsumfunc.py Compute the cost (removed size + flops) and resultant indices for performing the contraction specified by ``positions``. Parameters ---------- positions : tuple of int The locations of the proposed tensors to contract. input_sets : list of sets The indices found on each tensors. output_set : set The output indices of the expression. idx_dict : dict Mapping of each index to its size. memory_limit : int The total allowed size for an intermediary tensor. path_cost : int The contraction cost so far. naive_cost : int The cost of the unoptimized expression. Returns ------- cost : (int, int) A tuple containing the size of any indices removed, and the flop cost. positions : tuple of int The locations of the proposed tensors to contract. new_input_sets : list of sets The resulting new list of indices if this proposed contraction is performed. Nc3s|] }t|VqdSN)r).0prrr r s  z._parse_possible_contraction..)r rsumr r+)rrrrr0 path_cost naive_costcontract idx_resultr8rrr9 old_sizes removed_sizer5sortr rAr _parse_possible_contractions #       rKc Cs|d}|\}}g}|D]\\}\}}} ||vs||vrq | |t||kt||k=| |t||kt||k=| d|dd|t||kt||k|t||kt||kf} ||| | fq |S)aXCopied from _update_other_results in numpy/core/einsumfunc.py Update the positions and provisional input_sets of ``results`` based on performing the contraction result ``best``. Remove any involving the tensors contracted. Parameters ---------- results : list List of contraction results produced by ``_parse_possible_contraction``. best : list The best contraction of ``results`` i.e. the one that will be performed. Returns ------- mod_results : list The list of modified results, updated with outcome of ``best`` contraction. rr!)intinsertr) resultsbestbest_conbxby mod_resultsr5r%ycon_setsmod_conr r r _update_other_results s8rXc st|dkr dgSt|dkrdgSttt|||}|\}}}}t||t||} ttt|d} g} d} g} tt|dD]}| D]#}||d||drWqGt|||||| | }|durj| |qGt| dkrttt|dD]}t|||||| | }|dur| |q{t| dkr| t tt|| St | ddd }t | |} |d}t|dfd d tD} | |d| |dd7} qC| S) aCopied from _greedy_path in numpy/core/einsumfunc.py Finds the path by contracting the best pair until the input list is exhausted. The best pair is found by minimizing the tuple ``(-prod(indices_removed), cost)``. What this amounts to is prioritizing matrix multiplication or inner product operations, then Hadamard like operations, and finally outer operations. Outer products are limited by ``memory_limit``. This algorithm scales cubically with respect to the number of elements in the list ``input_sets``. Parameters ---------- input_sets : list List of sets that represent the lhs side of the einsum subscript output_set : set Set that represents the rhs side of the overall einsum subscript idx_dict : dictionary Dictionary of index sizes memory_limit_limit : int The maximum number of elements in a temporary array Returns ------- path : list The greedy contraction order within the memory limit constraint. Examples -------- >>> isets = [set('abd'), set('ac'), set('bdc')] >>> oset = set('') >>> idx_sizes = {'a': 1, 'b':2, 'c':3, 'd':4} >>> _greedy_path(isets, oset, idx_sizes, 5000) [(0, 2), (0, 1)] r)rr!)rrrNcSr"r#r r$r r r r&r'z_greedy_path..r(c3s|]}|fVqdSr>r )r?rnew_tensor_posr r rBsz_greedy_path..) r+r r*r r,r- isdisjointrKrr/r.rX)rrrr0rFrGr8rrrE comb_iterknown_contractionsrDr<r2rresultrPr rYr _greedy_path7sZ %         r_)r,r rr r=rKrXr_r r r r s(=I= *