i\5BSrSSKrSSKrSSKrSSKrSSKrSSKJr SSKJ r J r SSK J r SSK Jr /S Qr"S S \ R(5rSS jrS rSr"SS\5rSSjr\R6"\SS9rg!\a SSKrSr \RRrNkf=f)zB Support for random optimizers, including the random-greedy path. N)deque)helperspaths)choices)seedc[U5n[RRXVs/sHo3U- PM snSS9$s snf)Nr)psize)sumnprandomchoice) populationweightsnormws V/var/www/html/banglarbhumi/venv/lib/python3.13/site-packages/opt_einsum/path_random.pyrandom_choicesrs<7|yy .IA4x.IPQRR.Is= ) RandomGreedy random_greedyrandom_greedy_128c\rSrSrSrSSjr\S5r\S5r\RS5rSr S r S r S r S rS rg)RandomOptimizera%Base class for running any random path finder that benefits from repeated calling, possibly in a parallel fashion. Custom random optimizers should subclass this, and the ``setup`` method should be implemented with the following signature:: def setup(self, inputs, output, size_dict): # custom preparation here ... return trial_fn, trial_args Where ``trial_fn`` itself should have the signature:: def trial_fn(r, *trial_args): # custom computation of path here return ssa_path, cost, size Where ``r`` is the run number and could for example be used to seed a random number generator. See ``RandomGreedy`` for an example. Parameters ---------- max_repeats : int, optional The maximum number of repeat trials to have. max_time : float, optional The maximum amount of time to run the algorithm for. minimize : {'flops', 'size'}, optional Whether to favour paths that minimize the total estimated flop-count or the size of the largest intermediate created. parallel : {bool, int, or executor-pool like}, optional Whether to parallelize the random trials, by default ``False``. If ``True``, use a ``concurrent.futures.ProcessPoolExecutor`` with the same number of processes as cores. If an integer is specified, use that many processes instead. Finally, you can supply a custom executor-pool which should have an API matching that of the python 3 standard library module ``concurrent.futures``. Namely, a ``submit`` method that returns ``Future`` objects, themselves with ``result`` and ``cancel`` methods. pre_dispatch : int, optional If running in parallel, how many jobs to pre-dispatch so as to avoid submitting all jobs at once. Should also be more than twice the number of workers to avoid under-subscription. Default: 128. Attributes ---------- path : list[tuple[int]] The best path found so far. costs : list[int] The list of each trial's costs found so far. sizes : list[int] The list of each trial's largest intermediate size so far. See Also -------- RandomGreedy NcUS;a [S5eXlX lX0l[R "U5UlX@lXPl/Ul /Ul [S5[S5S.Ul SUl g)N)flopsr z.`minimize` should be one of {'flops', 'size'}.infr) ValueError max_repeatsmax_timeminimizer get_better_fnbetterparallel pre_dispatchcostssizesfloatbest_repeats_start)selfr r!r"r%r&s r__init__RandomOptimizer.__init__Usn , ,MN N&  ))(3  (  #ElE%LA cH[R"URS5$)z$The best path found so far. ssa_path)r ssa_to_linearr*r,s rpathRandomOptimizer.pathgs""499Z#899r/cUR$N) _parallelr3s rr%RandomOptimizer.parallelms ~~r/cN[USS5(aURR5 XlSUlUSLaSUlgUSLaSSKJn U"5UlSUlg[U[R5(aSSKJn U"U5UlSUlgXlg)N_managing_executorFTr)ProcessPoolExecutor) getattr _executorshutdownr8r;concurrent.futuresr< isinstancenumbersNumber)r,r%r<s rr%r9qs 4-u 5 5 NN # # %!"' u !DN  t  >02DN&*D #  h / / >0:DN&*D # "r/c## [5UlUHn[UR5UR:a8URR UR R "X$/UQ765 M^URR5R5v M UR(a>URR5R5v UR(aM=gg7f)zVLazily generate results from an executor without submitting all jobs at once. N) r_futureslenr&appendr>submitpopleftresult)r,repeatstrial_fnargsrs r_gen_results_parallel%RandomOptimizer._gen_results_parallels A4==!D$5$55 $$T^^%:%:8%N%NO--'')002 2  mm--'')002 2mmms C*C0.C0cfURb$URHnUR5 M ggr7)r>rEcancel)r,fs r_cancel_futuresRandomOptimizer._cancel_futuress( >> %]] # &r/c[er7)NotImplementedError)r,inputsoutput size_dicts rsetupRandomOptimizer.setups!!r/cP^^URXU5 URb[R"5nURXU5ummUR[ UR 5-nX`R-n[Xg5nURbURUTT5n O UU4SjU5n U Hupn UR RU 5 URRU 5 URXURSURS5n U (a*XRS'XRS'XRS'URcM[R"5WUR-:dM O UR5 UR $)Nc36># UHnT"U/TQ76v M g7fr7).0rN trial_argsrLs r +RandomOptimizer.__call__..s@1hq.:.srr r1)_check_args_against_first_callr!timer[r+rFr'r ranger>rOrGr(r$r*rTr4)r,rXrYrZ memory_limitt0r_startr_stoprKtrialsr1costr found_new_bestrarLs @@r__call__RandomOptimizer.__call__s[ ++FIF == $B#zz&)D*%%DJJ7+++( >> %//:NF@@F%+ HD JJ  d # JJ  d #"[[TYYw5GSYIZ[N%) '"$( &!(0 *% ) b4==>P0P!%+$ yyr/c^[USS5(aURR5 gg)Nr;F)r=r>r?r3s r__del__RandomOptimizer.__del__s' 4-u 5 5 NN # # % 6r/)r>rEr;r8r+r*r$r'r r!r"r%r&r() NrF)__name__ __module__ __qualname____firstlineno____doc__r-propertyr4r%setterrOrTr[rnrq__static_attributes__r_r/rrrsg5l $:: __""63  "'R&r/rcSn/nU(aPXR:aK[R"U5upxpX;dX;aM1URXxX45 US- nU(aXR:aMKUS:XagUS:XaUS$UV s/sH oSSPM n n U Sn U(aU[S[ U 55-nUS:XaU Vs/sH oU :XaSOSPM nnO,U Vs/sHn[ R "X- *U- 5PM! nn[[U5US9unURU5upxpUHn[R"UU5 M XxX4$s sn fs snfs snf)aCA contraction 'chooser' that weights possible contractions using a Boltzmann distribution. Explicitly, given costs ``c_i`` (with ``c_0`` the smallest), the relative weights, ``w_i``, are computed as: w_i = exp( -(c_i - c_0) / temperature) Additionally, if ``rel_temperature`` is set, scale ``temperature`` by ``abs(c_0)`` to account for likely fluctuating cost magnitudes during the course of a contraction. Parameters ---------- queue : list The heapified list of candidate contractions. remaining : dict[str, int] Mapping of remaining inputs' indices to the ssa id. temperature : float, optional When choosing a possible contraction, its relative probability will be proportional to ``exp(-cost / temperature)``. Thus the larger ``temperature`` is, the further random paths will stray from the normal 'greedy' path. Conversely, if set to zero, only paths with exactly the same cost as the best at each step will be explored. rel_temperature : bool, optional Whether to normalize the ``temperature`` at each step to the scale of the best cost. This is generally beneficial as the magnitude of costs can vary significantly throughout a contraction. nbranch : int, optional How many potential paths to calculate probability for and choose from at each step. Returns ------- cost, k1, k2, k12 rrNg)r) heapqheappoprGmaxabsmathexprrfpopheappush)queue remainingnbranch temperaturerel_temperaturenrrlk1k2k12rr'cmincenergieschosenothers rthermal_chooserrseF AG AK!MM%0" ""5 "*+ Q AK AvAvqz(/ 0fAYq\E 0 8Ds1c$i(( c3895adA)59BGGADHHqx[;67GU1Xx8GF F+Db ue$ R - 1:Hs2E3E &E c [[[U55n[U5n[[ [ U555nSnSnUHupx[ R"XXGX5upURU5 URU5 UR[ U55 URU 5 XZ- n[U[R"X55nM XV4$)z3Compute the flops and max size of an ssa path. r)listmap frozensetsetrfrFrcalc_k12_flopsdiscardaddrGrrcompute_size_by_dict) r1rXrYrZr total_costmax_sizeijrflops12s rssa_path_compute_costrs#i( )F v FE#f+&'IJH++FI!W !! c&k" c x!=!=c!MN  r/c|US:XaSn[U5 [R"XX4U5n[XaX#5upxXgU4$)zKA single, repeatable, greedy trial run. Returns ``ssa_path`` and cost. rN) random_seedrssa_greedy_optimizer) rNrXrYrZ choose_fncost_fnr1rlr s r_trial_greedy_ssa_path_and_costr3sD Av N((wWH&xKJD 4 r/cF^\rSrSrSrSU4Sjjr\S5rSrSr U=r $)riBa Parameters ---------- cost_fn : callable, optional A function that returns a heuristic 'cost' of a potential contraction with which to sort candidates. Should have signature ``cost_fn(size12, size1, size2, k12, k1, k2)``. temperature : float, optional When choosing a possible contraction, its relative probability will be proportional to ``exp(-cost / temperature)``. Thus the larger ``temperature`` is, the further random paths will stray from the normal 'greedy' path. Conversely, if set to zero, only paths with exactly the same cost as the best at each step will be explored. rel_temperature : bool, optional Whether to normalize the ``temperature`` at each step to the scale of the best cost. This is generally beneficial as the magnitude of costs can vary significantly throughout a contraction. If False, the algorithm will end up branching when the absolute cost is low, but stick to the 'greedy' path when the cost is high - this can also be beneficial. nbranch : int, optional How many potential paths to calculate probability for and choose from at each step. kwargs Supplied to RandomOptimizer. See Also -------- RandomOptimizer c V>XlX lX0lX@l[TU]"S0UD6 g)Nr_)rrrrsuperr-)r,rrrrkwargs __class__s rr-RandomGreedy.__init__bs) &.  "6"r/cURS:Xag[R"[URURUR S9$)zThe function that chooses which contraction to take - make this a property so that ``temperature`` and ``nbranch`` etc. can be updated between runs. rN)rrr)r functoolspartialrrrr3s rrRandomGreedy.choose_fnisC <<1   -1-=-=)-151E1EG Gr/cF[nXX0RUR4nXE4$r7)rrr)r,rXrYrZfnrMs rr[RandomGreedy.setupws" , >>4<<Hxr/)rrrr)zmemory-removed-jitterg?T) rurvrwrxryr-rzrr[r| __classcell__)rs@rrrBs-># G Gr/rc *[S0UD6nU"XX#5$)z r_)r)rXrYidx_dictrgoptimizer_kwargs optimizers rrr}s0/0I VX <rs   !0* As&e))s&lGT *  8?8v=%%mEe !S))..K!s A88#BB