iΉJSrSSKJr SSKJr SSKrSSKJrJ r J r J r J r J r /SQr"SS \5rS r1S krS r\ R(S 5rSr\ R.SSj5r\ R2SSj5rSrSrSrSSjrSr"SS5r \"SS/5r!Sr"Sr#g)z= Contains the primary optimization and contraction routines. ) namedtuple)DecimalN)backendsblashelpersparserpathssharing) contract_pathcontractformat_const_einsum_strContractExpression shape_onlyc$\rSrSrSrSrSrSrg)PathInfoa~A 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 ^ XlX lX0lXPlX@lX`l[ U5Ul[ U5UlURUR- Ul Xl T Ul URS5V s/sHn [U 4SjU 55PM sn UlSRX#5Ul[ [#U 55Ulgs sn f)N,c3.># UH nTUv M g7fN).0k size_dicts S/var/www/html/banglarbhumi/venv/lib/python3.13/site-packages/opt_einsum/contract.py $PathInfo.__init__..*s62aYq\2sz{}->{})contraction_listinput_subscriptsoutput_subscriptpathindices scale_listr naive_costopt_costspeedup size_listrsplittupleshapesformateqmaxlargest_intermediate) selfrr r!r#r"r$r%r&r(rkss ` r__init__PathInfo.__init__s 0 0 0  $!*-) 6 ""AQAWAWX[A\]A\2u6266A\] //"2E$+C N$;!^sCc SnSRUR5SR[UR55SR[ UR 55SRUR 5SRUR5SRUR5SRUR5S S R"U6S / n[UR5Hup4UupVpxn Ub"S RU5S -UR-n OSn [ SS[ S[U55- 5n UR UXX4n URSR"U 65 M SRU5$)N)scalingBLAScurrent 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) r0header path_printn contractionindsidx_rm einsum_strr8do_blas remaining_strsize_remainingpath_runs r__repr__PathInfo.__repr__.s_< , 2 2477 ;=\=c=cdghlhthtdu=v + 2 23t3G HJmJtJtK!"E"L"LT]]"[ / 6 6t|| D 8 ? ?@Y@Y Z\k * 1 16 :H  ((=(=>NA;F 8D*$ # 3d :T=R=R R %  BRZ)A$ABN*G_H   ?FFQ R?wwz"")rr-r#r r/r%r&r!r"r$r+rr(r'N)__name__ __module__ __qualname____firstlineno____doc__r2rL__static_attributes__rrNrrrs <$#rNrcrUS:Xa [U5$UcgUS:aUS:Xag[S5e[U5$)N max_inputrz)Memory limit must be larger than 0, or -1)r. ValueErrorint) memory_limitr(s r_choose_memory_argr[JsG{"9~a 2 HI I | rN>r"r+optimizeuse_blas einsum_callrZc b [U5[- n[U5(a[SR U55eUR SS5nUR SS5nUR SS5nUR SS5nUR S S 5n[ R"U5upnURS 5n U V s/sHn [U 5PM n n U(aUn OUV s/sHoRPM n n [U 5n[URS S 55n0n[U 5HunnU Un[U5[U5:wa[S R U UU55e[U5H\unn[UU5nUU;a=UUS:XaUUU'M*USUU4;a [SR UUUUU55eMWUUU'M^ M X/-Vs/sHn[R"UU5PM nn[!UU5n[U 5n[#SU 55[U5- S:n[R$"UUUU5n['U[([*R,45(dUnOfUS::a[/[1U55/nOJ['U[*R,5(a U"XUU5nO [*R2"U5nU"XUU5n/n/n/n/n [U5GHunn![/[5[7U!5S S95n![R8"U!X5n"U"un#n n$n%[R$"U%U$[U!5U5n&UR;U&5 UR;[U%55 UR;[R"U#U55 U!V s/sHoR U 5PM n'n U!V s/sHoR U 5PM n(n U(a[<R>"U'U#U$U(5n)OSn)U[U5- S:XaU n*O4S RAU'5n+S RA[5U#U+RBS95n*[ RD"U'U(U*5n,U R;U*5 U R;U,5 S RAU'5S-U*-n-[U 5S::a [/U 5n.OSn.U!U$U-U.U)4n/U R;U/5 GM [#U5n0U(aUU 4$[GU XUUUUU0UU5 n1UU14$s sn fs sn fs snfs sn fs sn f)a2 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: {}r\autorZNr+Fr^r]Trr<zZEinstein sum subscript '{}' does not contain the correct number of indices for operand {}.rzJSize of label '{}' for operand {} ({}) does not match previous terms ({}).c38# UHn[U5v M g7fr)r=rxs rr contract_path..s4AQsr)reverserW)keyr9)$set_VALID_CONTRACT_KWARGSr= TypeErrorr,popr parse_einsum_inputr)shapereplacer>rXrYrcompute_size_by_dictr[sum flop_count isinstancestrr PathOptimizerr*range get_path_fnsortedlistfind_contractionr@rcan_blasr?findfind_output_shaper)2operandskwargsunknown_kwargs path_typerZr+einsum_call_argr]r r! input_listrc input_sets input_shps output_setr#rtnumtermshcnumchardimr( memory_argnum_ops inner_productr%r"path_optimizer cost_listr$r contract_indscontract_tupleout_inds idx_removed idx_contractcost tmp_inputs tmp_shapesrH idx_resultall_input_inds shp_resultrGr8rDr&rBs2 rr r ]sN[#99N >RYYZhijj :v.I::nd3L ZZ% (Fjj6Ozz*d+H4:3L3LX3V0"'',J",-*Q#a&*J-  '/0x!ggx 0%&J"**334GI + d   r7c$i IIOPZ[_P`bfIgi i#D/JD$bh-Cy T?a'&)IdOIdO 44$&3396$iPToWZ3[]]5#& $* ,(LVXjKjkKj4--dI>KjIk#L)?AnnQ' ?1>?AnnQ' ? mmJ+zRGG 3t9  #)J WWZ0Nn6I6I!JKJ--j*jQ *%*%XXj)D0:=  z?b j)II$k:y'R  ,Y /\9~H)))*,[R"SU5nU"XUS9$)zBase tensordot. tensordot)r)rr)rcyrrrs r _tensordotrqs#   ; 0B a rNcURSS5nUSLaSn/SQnUR5VVs0sHupEXC;dM XE_M nnnUSLa [U0UD6$URSS5nURSS5nURS S5n URS S5n URS 05n UR5VVs/sHupEXC;dM UPM n nn[U 5(a[ S R U 55eU (aUS n [ UUUSUS.6upU (a [W X40UD6$[X4S U 0UD6$s snnfs snnf)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` r\Tr`)outdtypeordercastingFr]rZNr_gen_expression_constants_dictz+Did not understand the following kwargs: {}r)r\rZr^r]) rlitemsrr=rkr,r r_core_contract)r~r optimize_argvalid_einsum_kwargsrv einsum_kwargsr]rZrgen_expressionconstants_dictrfull_strrs rr r zsex::j$/Lt >(. Sfq!:RTQTMSu2M22zz*d+H::nd3LjjF+GZZ 159NZZ 126N'-llnUnFQ8TanNU >ELL^\]]A;"/8D# UH nTUSLv M g7frr)rrcr~s rr!_core_contract..%s%H4ahqkT&94srEINSUMr9rr<c36># UHoT;dM Uv M g7frr)rsrFs rrr4s#[/G!TZ?AA/Gs  )rrrr)rlrr has_einsumr>anyr=r)r?r@r|rr*mapindexrr)r~rrevaluate_constantsr out_array specified_out no_einsumnumrDrErG_ blas_flagrc tmp_operands handle_out input_str results_index input_left input_right tensor_resultleft_pos right_posrnew_viewrrFs` @rrrs  !!%.IT)MHg.G''00I&&671<.fjY #%H4%H"H"H-d33 3156A Q 6#KqS9I5J(J  ()3y(2'7'7'= $I}&/ooc&: #J GG#[zK/G#[[M#%biH  23  !1!1!!45 ">> format_const_einsum_str('ab,bc,cd->ad', [0, 2]) 'bc,[ab,cd]->ad' No-op if there are no constants. r9r<rz[{}]z{}{}{}z],[)r)r>r,r?ro) rG constantslhsrhsarrowit wrapped_termsformatted_einsum_strs rrr[s  z##D)$b"%KTUXU^U^_bUcKdeKd41V]]1%Q>KdMe#??388M+BEO077sC  fs$B$cZ\rSrSrSrSrSSjrSrSrSSjr SS jr S r S r S r S rg)riuzHelper class for storing an explicit ``contraction_list`` which can then be repeatedly called solely with the array arguments. c X lX@l[XR55UlUR S5S-UlUR [U5- UlX l X0l 0Ul 0Ul g)Nrr) rrrkeysrDcount_full_num_argsr=num_args_full_contraction_listr_evaluated_constants_backend_expressions)r0rDrrrs rr2ContractExpression.__init__yss 0*2;@S@S@UV*//4q8++c..AA '7#-$&!$&!rNc0[UR5Vs/sHo RRUS5PM nn[ X15n[ R "XU5upEX@RU'XPl gs snf![a U"X1SS.6upEN0f=f)aConvert 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. NT)rr) rvrrgetrrrKeyErrorrr)r0rr tmp_const_opsnew_opsnew_contraction_lists rr%ContractExpression.evaluate_constantssEJ$J]J]D^_D^q--11!T:D^ _ 7 k,4,G,G`d,e )G.5!!'* 4`  k,0-ei,j )G) ks%A9 A>>BBcURU$![a# URU5 URUs$f=f)zRetrieve or generate the cached list of constant operators (mixed in with None representing non-consts) and the remaining contraction list. )rrr)r0rs r_get_evaluated_constants+ContractExpression._get_evaluated_constantssF  6,,W5 5 6  # #G ,,,W5 5 6s *>>cURU$![a* [R"X!U5nX0RU'Us$f=fr)rrrbuild_expression)r0rrrs r_get_backend_expression*ContractExpression._get_backend_expressionsL ,,W5 5 **7DAB13 % %g .I s1AANcU(a URO URn[[U5U4UUUS.URD6$)z&The normal, core contraction. )rrr)rrrryr)r0rrrrrs r _contractContractExpression._contractsP;M466RVRgRgd6l.4"%&-1C 4 !% 2 2 4 4rNc|U(a[R"X1U5$URX5"U6nUbXRS'U$U$)a[Special 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. r)rrr)r0rrrrresults r_contract_with_conversion,ContractExpression._contract_with_conversionsE ..wE E--f>G ?GJ rNc~URSS5nURSS5n[X5nURSS5nU(a[SRU55eU(a URO UR n[ U5U:wa.[SRUR [ U555eUR(aBU(d;[U5URU5pUV s/sHoc [U5OU PM n n OUn [R"U5(a'[S U55(aURXXES 9$URXXES 9$s sn f![aFn U R (a[#U R 5OS n S RU 54n XleSn A ff=f) 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. rNrr`rFzbThe only valid keyword arguments to a `ContractExpression` call are `out=` or `backend=`. Got: {}.zKThis `ContractExpression` takes exactly {} array arguments but received {}.c3V# UHn[U[R5v M! g7fr)rsnpndarrayrbs rr.ContractExpression.__call__..s!4_X^STZ2::5N5NX^s'))rr<zInternal 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: '{}')rlrrXr,rrr=riterrnextr has_backendallr rargsrt)r0rrrrrcorrect_num_argsops_var ops_constopopserr original_msgmsgs r__call__ContractExpression.__call__sjj%**Y/0#ZZ(>#G>[ [L ,/HH3sxx="L228&2FJCH   s&6E'AE,E,, F<6AF77F<cUR(a%SR[UR55nOSnSRURU5$)Nz, constants={}r<z)rr,rxrD)r0constants_reprs rrLContractExpression.__repr__sD   -44VDrr@r,rr?)r0rrcs r__str__ContractExpression.__str__ s ]]_ d334DA HH[''A. / HHV]]1Q4(QrUGNN1R5,APRS T5    HH)001C1CD EwwqzrN) rrrrrrDrrr)r`)Nr`F)F)rOrPrQrRrSr2rrrrr rrLr%rTrrNrrrus6' 5( 6 4*2hWrNrShapedrnc[U5$)zVDummy ``numpy.ndarray`` which has a shape only - for generating contract expressions. )r')rns rrrs %=rNcURSS5(d [S5eSH0nURUS5cM[SRU55e [U[5(d[ R "U4U-5upSUS'URSS 5nUVs0sHoUX_M nnXbS '[U5VVs/sHupWXT;aUO [U5PM nnn[U/UQ70UD6$s snfs snnf) 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 r\Tz9Can only generate expressions for optimized contractions.)rrNzX'{}' should only be specified when calling a `ContractExpression`, not when building it.rrrr) rrXr,rsrtr convert_interleaved_inputrlr>rr ) subscriptsr+rargrrrr dummy_arrayss rcontract_expressionr. sz ::j$ ' 'TUU! ::c4 ,KKQ6RU;X X" j# & &#==znv>UV $F  ;+I,56IqlIN6 . HQQWGXYGXtqAZ]:GXLY J 8 8 88 7Zs %C7C<)r)r`F)$rS collectionsrdecimalrrrr<rrrr r r __all__objectrr[rjr einsum_cache_wraprrtranspose_cache_wraprtensordot_cache_wraprr rrrrrr'rr.rrNrr6s#== f8#v8#v  cm` //,   AXH0  FR 4^^B Hwi (R9rN