`i58ddlZdZdZdZdZdZdZdZdS) Nc`t||}td|dz }|r|dz }||zS)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_factors k/home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/cupy/linalg/_einsum_opt.py _flop_countrsC@)/JJLAy1}%%I Q ) ##c*d}|D] }|||z}|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 r)indicesidx_dictretis r rr,s-0 C  x{ Jrct}|}g}t|D])\}}||vr||z}||||z}*||z}||z } ||||| |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_removeds r _find_contractionr%JsX55L""JI ++  U )   E !LL   U # # # % JJl*J*,K Z    ; ==rc dg|fg}tt|dz D]}g}|D]}|\}} } tjtt||z dD]q} t | | |} | \} }}}t | |}||kr1|t ||t| |z}| | gz}||||fr|r|}t|dd}|ttt||z gz }|cSt|dkr*ttt|gSt|dd}|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)] rrc|dSNrrxs r z_optimal_path..s 1Q4rkeyc|dSr)rr*s r r,z_optimal_path..s 1Q4r) rangelen itertools combinationsr%rrrmintuple)rrr memory_limit full_results iteration iter_resultscurrcostrr concontr#new_input_setsr$rnew_size total_costnew_pospaths r _optimal_pathrCs@J'(L3z??Q.//  ! K KD)- &D)Y -eC OOi4O.P.PRSTT K K)iDDHLE NK1XFFl**" k3s88XNNO #se+##Z.$IJJJJ K&  'LL|888;D U5Z9!<==>>? ?DKKK <AeC OO,,--.. | 0 0 0 3D Krct||}|\}} } } t|} | |krdSfd|D} t| | z }t| | t |}| |f}||z|krdS||| 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. Nc3DK|]}t|VdSN)r).0prrs r z._parse_possible_contraction..sJ55%&'1 x!!555555r)r%rsumrr1)rrrrr6 path_cost naive_costcontract idx_resultr>r$rr? old_sizes removed_sizer;sorts ` ` r _parse_possible_contractionrRsF!J CCH>H,L |[#i..( K KD M4 D DJ&&t )^ ,,rc|d}|\}}g}|D]\}\}}} ||vs||vr| |t||kz t||kz =| |t||kz t||kz =| d|dd|t||kz t||kz |t||kz t||kz f} ||| | f|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_resultsr;r+ycon_setsmod_cons r _update_other_resultsr` s(AwH FBK") 6 6fq!h ==AMM  R#b1f++%BF 3 4 R#b1f++%BF 3 4DGBK(((c!b&kk/CBKK/SR[[3q2v;;1NND'845555 rc t|dkrdgSt|dkrdgSttt|||}|\}}}}t||t||} t jtt|d} g} d} g} tt|dz D]}| D]\}||d||dr0t|||||| | }|| |]t| dkrt jtt|dD].}t|||||| | }|| |/t| dkr>| ttt|nt| d}t| |} |d}t|dz fd tD} | |d| |ddz } | 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')rrrNc|dSr)rr*s r r,z_greedy_path..s QqTrr-c3 K|]}|fV dSrFr)rGrnew_tensor_poss r rIz_greedy_path..s(HHQa(HHHHHHr) r1r%r0rr2r3 isdisjointrRrr5r4r`)rrrr6rMrNr>r$rrL comb_iterknown_contractionsrKrBr8rresultrXrds @r _greedy_pathri7sJ :!v ZA  x! c*oo J88H LL%&--f555%&&!++ E%J"8"899:::%>>:::33EtLL!W Z1,HHHH%2G2GHHH  DGT!WQZ Kr)r2rrr%rCrRr`rirrr rjs%$%$%$P<:>:>:>zFFFR:-:-:-z'''Teeeeer