a SicΉ@sdZddlmZddlmZddlZddlmZm Z m Z m Z m Z m Z gdZGdd d eZd d Zhd Zd dZe jddZddZe jd,ddZe jd-ddZddZddZddZd.d d!Zd"d#ZGd$d%d%Z ed&d'gZ!d(d)Z"d*d+Z#dS)/z= Contains the primary optimization and contraction routines. ) namedtuple)DecimalN)backendsblashelpersparserpathssharing) contract_pathcontractformat_const_einsum_strContractExpression shape_onlyc@s eZdZdZddZddZdS)PathInfoaA printable object to contain information about a contraction path. Attributes ---------- naive_cost : int The estimate FLOP cost of a naive einsum contraction. opt_cost : int The estimate FLOP cost of this optimized contraction path. largest_intermediate : int The number of elements in the largest intermediate array that will be produced during the contraction. c s||_||_||_||_||_||_t||_t||_|j|j|_ | |_ |_ fdd| dD|_ d|||_tt| |_dS)Ncs"g|]}tfdd|DqS)c3s|]}|VqdSN).0k size_dictrO/var/www/html/django/DPS/env/lib/python3.9/site-packages/opt_einsum/contract.py *z/PathInfo.__init__...)tuple)rksrrr *rz%PathInfo.__init__..,z{}->{})contraction_listinput_subscriptsoutput_subscriptpathindices scale_listr naive_costopt_costspeedup size_listrsplitshapesformateqmaxlargest_intermediate) selfrrr r"r!r#r$r%r'rrrr__init__s  zPathInfo.__init__c Csd}d|jdt|jdt|jd|jd|jd|jd|j d d j|d g }t |j D]t\}}|\}}}}} |durd |d |j } nd} tddtdt|} |j|| || | f} |dj| qld |S)N)scalingZBLAScurrent remainingz Complete contraction: {} z Naive scaling: {} z Optimized scaling: {} z Naive FLOP count: {:.3e} z Optimized FLOP count: {:.3e} z Theoretical speedup: {:.3e} z) Largest intermediate: {:.3e} elements zQ-------------------------------------------------------------------------------- z{:>6} {:>11} {:>22} {:>37} zP--------------------------------------------------------------------------------r->z...r8z {:>4} {:>14} {:>22} {:>{}})r*r+lenr"r,r#r$r%r&r- enumeraterjoinr append) r.header path_printn contractionindsidx_rm einsum_strr2do_blas remaining_strZsize_remainingpath_runrrr__repr__.s&     zPathInfo.__repr__N)__name__ __module__ __qualname____doc__r/rErrrrrs rcCs@|dkrt|S|durdS|dkr8|dkr0dStdt|S)N max_inputrz)Memory limit must be larger than 0, or -1)r, ValueErrorint) memory_limitr'rrr_choose_memory_argJsrO>rNuse_blasr!optimizer) einsum_callc. st|t}t|r"td||dd}|dd}|dd}|dd}|d d }t|\}} }|d d d D} |r|ndd |Dt| } t| d d} it D]\} }| }t|t|krt d| | t |D]j\}}t ||}|vr`|dkr4||<n*|d|fvrht d|| ||q||<qq‡fdd | gD}t ||}t}tdd| Dt| dk}t| ||}t|ttjfs|}nP|dkrtt|g}n6t|tjr|| | |}nt|}|| | |}g}g}g}g}t |D]T\}}ttt|d d}t|| | }|\}} } }!t|!| t|}"||"|t|!|t|fdd |D}#fdd |D}$|rt|#|| |$}%nd}%|t|dkr| }&nd|#}'dt||'j d}&t!|#|$|&}(|&|(d |#d|&})tdkr|t}*nd}*|| |)|*|%f}+||+qDt|},|r||fSt"||| | ||||,| }-||-fS)a Find a contraction order 'path', without performing the contraction. Parameters ---------- subscripts : str Specifies the subscripts for summation. *operands : list of array_like These are the arrays for the operation. optimize : str, list or bool, optional (default: ``auto``) Choose the type of path. - if a list is given uses this as the path. - ``'optimal'`` An algorithm that explores all possible ways of contracting the listed tensors. Scales factorially with the number of terms in the contraction. - ``'branch-all'`` An algorithm like optimal but that restricts itself to searching 'likely' paths. Still scales factorially. - ``'branch-2'`` An even more restricted version of 'branch-all' that only searches the best two options at each step. Scales exponentially with the number of terms in the contraction. - ``'greedy'`` An algorithm that heuristically chooses the best pair contraction at each step. - ``'auto'`` Choose the best of the above algorithms whilst aiming to keep the path finding time below 1ms. use_blas : bool Use BLAS functions or not memory_limit : int, optional (default: None) Maximum number of elements allowed in intermediate arrays. shapes : bool, optional Whether ``contract_path`` should assume arrays (the default) or array shapes have been supplied. Returns ------- path : list of tuples The einsum path PathInfo : str A printable object containing various information about the path found. Notes ----- The resulting path indicates which terms of the input contraction should be contracted first, the result of this contraction is then appended to the end of the contraction list. Examples -------- We can begin with a chain dot example. In this case, it is optimal to contract the b and c tensors represented by the first element of the path (1, 2). The resulting tensor is added to the end of the contraction and the remaining contraction, ``(0, 1)``, is then executed. >>> a = np.random.rand(2, 2) >>> b = np.random.rand(2, 5) >>> c = np.random.rand(5, 2) >>> path_info = opt_einsum.contract_path('ij,jk,kl->il', a, b, c) >>> print(path_info[0]) [(1, 2), (0, 1)] >>> print(path_info[1]) Complete contraction: ij,jk,kl->il 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 A more complex index transformation example. >>> I = np.random.rand(10, 10, 10, 10) >>> C = np.random.rand(10, 10) >>> path_info = oe.contract_path('ea,fb,abcd,gc,hd->efgh', C, C, I, C, C) >>> print(path_info[0]) [(0, 2), (0, 3), (0, 2), (0, 1)] >>> print(path_info[1]) Complete contraction: ea,fb,abcd,gc,hd->efgh 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 z8einsum_path: Did not understand the following kwargs: {}rQautorNNr)FrRrPTrcSsg|] }t|qSr)setrxrrrrrz!contract_path..cSsg|] }|jqSrshaperUrrrrrr6zZEinstein sum subscript '{}' does not contain the correct number of indices for operand {}.rzJSize of label '{}' for operand {} ({}) does not match previous terms ({}).csg|]}t|qSr)rcompute_size_by_dict)rtermrrrrrcss|]}t|VqdSr)r7rUrrrrrz contract_path..r)reversecsg|]}|qSrpoprU) input_listrrr!rcsg|]}|qSrr]rU) input_shpsrrr"rrK)keyr3)#rT_VALID_CONTRACT_KWARGSr7 TypeErrorr*r^rparse_einsum_inputr(replacer8rLrMrOsumr flop_count isinstancestrr PathOptimizerrrange get_path_fnsortedlistfind_contractionr:rYrcan_blasr9findfind_output_shaper).operandskwargsunknown_kwargs path_typerNr)einsum_call_argrPrr input_sets output_setr"tnumrZshcnumchardimr' memory_argZnum_ops inner_productr$r!Zpath_optimizer cost_listr#r contract_indsZcontract_tupleout_inds idx_removed idx_contractcost tmp_inputsZ tmp_shapesrB idx_resultZall_input_indsZ shp_resultrAr2r>r%r<r)r_r`rrr ]sg                     r cOstd|dd}t|dts0||i|S|d|dd}}t|std|vrj|dt|7}t|}||g|Ri|S)zOBase einsum, but with pre-parse for valid characters if a string is given. einsumbackendnumpyrrNr3) rget_funcr^rirjrhas_valid_einsum_chars_onlyfind_output_strconvert_to_valid_einsum_chars)rtrufnrArrr_einsumMs  rcCs ||Sr) transpose)rVaxesrrr_default_transposedsrrcCstd|t}|||S)zBase transpose. r)rrr)rVrrrrrr _transposeisrcCstd|}||||dS)zBase tensordot. tensordot)r)rr)rVyrrrrrr _tensordotqs rc s|dd}|durd}gdfdd|D}|durLt|i|S|dd}|d d }|d d}|d d}|d i}fdd|D} t| rtd| |r|d} t|||d|d\}} |rt| | |fi|St|| fd |i|S)a@ contract(subscripts, *operands, out=None, dtype=None, order='K', casting='safe', use_blas=True, optimize=True, memory_limit=None, backend='numpy') Evaluates the Einstein summation convention on the operands. A drop in replacement for NumPy's einsum function that optimizes the order of contraction to reduce overall scaling at the cost of several intermediate arrays. Parameters ---------- subscripts : str Specifies the subscripts for summation. *operands : list of array_like These are the arrays for the operation. out : array_like A output array in which set the resulting output. dtype : str The dtype of the given contraction, see np.einsum. order : str The order of the resulting contraction, see np.einsum. casting : str The casting procedure for operations of different dtype, see np.einsum. use_blas : bool Do you use BLAS for valid operations, may use extra memory for more intermediates. optimize : str, list or bool, optional (default: ``auto``) Choose the type of path. - if a list is given uses this as the path. - ``'optimal'`` An algorithm that explores all possible ways of contracting the listed tensors. Scales factorially with the number of terms in the contraction. - ``'dp'`` A faster (but essentially optimal) algorithm that uses dynamic programming to exhaustively search all contraction paths without outer-products. - ``'greedy'`` An cheap algorithm that heuristically chooses the best pairwise contraction at each step. Scales linearly in the number of terms in the contraction. - ``'random-greedy'`` Run a randomized version of the greedy algorithm 32 times and pick the best path. - ``'random-greedy-128'`` Run a randomized version of the greedy algorithm 128 times and pick the best path. - ``'branch-all'`` An algorithm like optimal but that restricts itself to searching 'likely' paths. Still scales factorially. - ``'branch-2'`` An even more restricted version of 'branch-all' that only searches the best two options at each step. Scales exponentially with the number of terms in the contraction. - ``'auto'`` Choose the best of the above algorithms whilst aiming to keep the path finding time below 1ms. - ``'auto-hq'`` Aim for a high quality contraction, choosing the best of the above algorithms whilst aiming to keep the path finding time below 1sec. memory_limit : {None, int, 'max_input'} (default: None) Give the upper bound of the largest intermediate tensor contract will build. - None or -1 means there is no limit - 'max_input' means the limit is set as largest input tensor - a positive integer is taken as an explicit limit on the number of elements The default is None. Note that imposing a limit can make contractions exponentially slower to perform. backend : str, optional (default: ``auto``) Which library to use to perform the required ``tensordot``, ``transpose`` and ``einsum`` calls. Should match the types of arrays supplied, See :func:`contract_expression` for generating expressions which convert numpy arrays to and from the backend library automatically. Returns ------- out : array_like The result of the einsum expression. Notes ----- This function should produce a result identical to that of NumPy's einsum function. The primary difference is ``contract`` will attempt to form intermediates which reduce the overall scaling of the given einsum contraction. By default the worst intermediate formed will be equal to that of the largest input array. For large einsum expressions with many input arrays this can provide arbitrarily large (1000 fold+) speed improvements. For contractions with just two tensors this function will attempt to use NumPy's built-in BLAS functionality to ensure that the given operation is preformed optimally. When NumPy is linked to a threaded BLAS, potential speedups are on the order of 20-100 for a six core machine. Examples -------- See :func:`opt_einsum.contract_path` or :func:`numpy.einsum` rQTrS)outdtypeordercastingcsi|]\}}|vr||qSrrrrvvalid_einsum_kwargsrr rzcontract..FrPrNNr_gen_expression_constants_dictcsg|]\}}|vr|qSrrrrrrrrzcontract..z+Did not understand the following kwargs: {}r)rQrNrRrP) r^itemsrr7rdr*r r_core_contract) rtruZ optimize_arg einsum_kwargsrPrNrZgen_expressionconstants_dictrvZfull_strrrrrr zs4\       r cCs|jjddS)N.r) __class__rGr()rVrrr infer_backendsrcCs*|dkr |St|d}t|s&dS|S)zuFind out what backend we should use, dipatching based on the first array if ``backend='auto'`` is specified. rSrr)rrZ has_tensordot)arraysrrrr parse_backends   rrSFc s|dd}|du}t|}t| }t|D]~\}} | \} } } } |rxtfdd| Drx||dfSfdd| D}|o|dt|k}| r|d| vs|r|| d \}}|d \}}d fd d||D}gg}}D]$}| | || | |qt |t |t |f|d }||ksJ|rt t |j|}t|||d }|r||dd<n(|r||d<t| g|Rd|i|} |~~q2|r|SdSdS)zInner loop used to perform an actual contraction given the output from a ``contract_path(..., einsum_call=True)`` call. rNc3s|]}|duVqdSrrrUrtrrr%rz!_core_contract..csg|]}|qSrr]rUrrrr(rz"_core_contract..rZEINSUMr3rr6c3s|]}|vr|VqdSrr)rs)r@rrr4r)rrrr)r^rrZ has_einsumr8anyr7r(r9r:rrrrmapindexrr)rtrrevaluate_constantsrZ out_array specified_outZ no_einsumnumr>r?rA_Z blas_flag tmp_operands handle_out input_str results_index input_left input_right tensor_resultleft_pos right_posrnew_viewrr)r@rtrrs@     rcsts|Sd|vr$|d\}}d}n|dd}}}fddt|dD}dd|||}|dd}|S)zAdd brackets to the constant terms in ``einsum_str``. For example: >>> format_const_einsum_str('ab,bc,cd->ad', [0, 2]) 'bc,[ab,cd]->ad' No-op if there are no constants. r3r6cs&g|]\}}|vrd|n|qS)z[{}])r*)rit constantsrrrlrz+format_const_einsum_str..rz{}{}{}z],[)r(r8r*r9rf)rArlhsrhsarrowZ wrapped_termsZformatted_einsum_strrrrr [s r c@s^eZdZdZddZdddZddZd d Zdd dZdddZ ddZ ddZ ddZ d S)rzHelper class for storing an explicit ``contraction_list`` which can then be repeatedly called solely with the array arguments. cKsX||_||_t|||_|dd|_|jt||_||_ ||_ i|_ i|_ dS)Nrr) rrr keysr>count_full_num_argsr7num_args_full_contraction_listr_evaluated_constants_backend_expressions)r.r>rrrrrrr/yszContractExpression.__init__rScstfddtjD}t||}zt||\}}Wn&ty^||dd\}}Yn0|j|<|_dS)aFConvert any constant operands to the correct backend form, and perform as many contractions as possible to create a new list of operands, stored in ``self._evaluated_constants[backend]``. This also makes sure ``self.contraction_list`` only contains the remaining, non-const operations. csg|]}j|dqSr)rgetrrr.rrrrz9ContractExpression.evaluate_constants..T)rrN)rlrrrrKeyErrorrr)r.rZ tmp_const_opsnew_opsZnew_contraction_listrrrrs   z%ContractExpression.evaluate_constantscCs8z |j|WSty2|||j|YS0dS)zRetrieve or generate the cached list of constant operators (mixed in with None representing non-consts) and the remaining contraction list. N)rrr)r.rrrr_get_evaluated_constantss    z+ContractExpression._get_evaluated_constantscCs@z |j|WSty:t|||}||j|<|YS0dSr)rrrZbuild_expression)r.rrrrrr_get_backend_expressions    z*ContractExpression._get_backend_expressionNFcCs0|r |jn|j}tt||f|||d|jS)z&The normal, core contraction. )rrr)rrrror)r.rrrrrrrr _contractszContractExpression._contractcCs:|rt|||S||||}|dur6||d<|S|S)aSpecial contraction, i.e., contraction with a different backend but converting to and from that backend. Retrieves or generates a cached expression using ``arrays`` as templates, then calls it with ``arrays``. If ``evaluate_constants=True``, perform a partial contraction that prepares the constant tensors and operations with the right backend. Nr)rrr)r.rrrrresultrrr_contract_with_conversions z,ContractExpression._contract_with_conversionc sB|dd}|dd}t||}|dd}|r@td||rJ|jn|j}t||krrtd|jt||jr|st|| |}fd d |D}n|}zDt |rt d d |Dr|j ||||d WS|j||||d WSty<} z6| jrt| jnd} d| f} | | _WYd} ~ n d} ~ 00dS)aEvaluate this expression with a set of arrays. Parameters ---------- arrays : seq of array The arrays to supply as input to the expression. out : array, optional (default: ``None``) If specified, output the result into this array. backend : str, optional (default: ``numpy``) Perform the contraction with this backend library. If numpy arrays are supplied then try to convert them to and from the correct backend array type. rNrrSrFzbThe only valid keyword arguments to a `ContractExpression` call are `out=` or `backend=`. Got: {}.zKThis `ContractExpression` takes exactly {} array arguments but received {}.cs g|]}|durtn|qSr)next)ropZops_varrrrrz/ContractExpression.__call__..css|]}t|tjVqdSr)rinpndarrayrUrrrrrz.ContractExpression.__call__..)rr6zInternal error while evaluating `ContractExpression`. Note that few checks are performed - the number and rank of the array arguments must match the original expression. The internal error was: '{}')r^rrLr*rrr7riterrrZ has_backendallrrargsrj) r.rrurrrZcorrect_num_argsZ ops_constopserrZ original_msgmsgrrr__call__s8       zContractExpression.__call__cCs*|jrdt|j}nd}d|j|S)Nz, constants={}r6z)rr*rnr>)r.Zconstants_reprrrrrEszContractExpression.__repr__cCs|g}t|jD]J\}}|d|d|d|d|drVd|dndq|jrx|d|jd|S) Nz {}. rz'{}'r[rKz [{}]r6z einsum_kwargs={})rEr8rr:r*rr9)r.rrcrrr__str__ s 0zContractExpression.__str__)rS)NrSF)F) rFrGrHrIr/rrrrrrrErrrrrrus   4rShapedrXcCst|S)z^Dummy ``numpy.ndarray`` which has a shape only - for generating contract expressions. )rrWrrrrsrcs|ddstddD]"}||ddurtd|qt|tsZt|f\}d|d<|dd fd d D}||d <fd dtD}t |g|Ri|S)aGenerate a reusable expression for a given contraction with specific shapes, which can, for example, be cached. Parameters ---------- subscripts : str Specifies the subscripts for summation. shapes : sequence of integer tuples Shapes of the arrays to optimize the contraction for. constants : sequence of int, optional The indices of any constant arguments in ``shapes``, in which case the actual array should be supplied at that position rather than just a shape. If these are specified, then constant parts of the contraction between calls will be reused. Additionally, if a GPU-enabled backend is used for example, then the constant tensors will be kept on the GPU, minimizing transfers. kwargs : Passed on to ``contract_path`` or ``einsum``. See ``contract``. Returns ------- expr : ContractExpression Callable with signature ``expr(*arrays, out=None, backend='numpy')`` where the array's shapes should match ``shapes``. Notes ----- - The `out` keyword argument should be supplied to the generated expression rather than this function. - The `backend` keyword argument should also be supplied to the generated expression. If numpy arrays are supplied, if possible they will be converted to and back from the correct backend array type. - The generated expression will work with any arrays which have the same rank (number of dimensions) as the original shapes, however, if the actual sizes are different, the expression may no longer be optimal. - Constant operations will be computed upon the first call with a particular backend, then subsequently reused. Examples -------- Basic usage: >>> expr = contract_expression("ab,bc->ac", (3, 4), (4, 5)) >>> a, b = np.random.rand(3, 4), np.random.rand(4, 5) >>> c = expr(a, b) >>> np.allclose(c, a @ b) True Supply ``a`` as a constant: >>> expr = contract_expression("ab,bc->ac", a, (4, 5), constants=[0]) >>> expr ac', constants=[0])> >>> c = expr(b) >>> np.allclose(c, a @ b) True rQTz9Can only generate expressions for optimized contractions.)rrNzX'{}' should only be specified when calling a `ContractExpression`, not when building it.rrrcsi|]}||qSrrr)r)rrrlrz'contract_expression..rcs$g|]\}}|vr|nt|qSr)r)rrrrrrrprz'contract_expression..) rrLr*rirjrconvert_interleaved_inputr^r8r ) subscriptsr)ruargrZ dummy_arraysr)rr)rcontract_expression s=   r)r)r)rSF)$rI collectionsrdecimalrrrr6rrrrr r __all__objectrrOrcr Zeinsum_cache_wraprrZtranspose_cache_wraprZtensordot_cache_wraprr rrrr rrrrrrrrs8   ;q    I"