~\;j\5BdZddlZddlZddlZddlZddlZddlmZddlm Z m Z  ddl m Z ddl mZgd ZGd d e j(Zdd Zd ZdZGddeZddZej6edZy#e$r ddlZdZ ejjZYkwxYw)zB Support for random optimizers, including the random-greedy path. N)deque)helperspaths)choices)seedct|}tjj||Dcgc]}||z  c}dScc}w)Nr)psize)sumnprandomchoice) populationweightsnormws _G:\00. PROJECTS\API\Inventory\templateJSON\kerjaOCR\Lib\site-packages\opt_einsum/path_random.pyrandom_choicesrs>7|yy .IAq4x.IPQRR.Is ? ) RandomGreedy random_greedyrandom_greedy_128czeZdZdZd dZedZedZejdZdZ dZ d Z d Z d Z y) RandomOptimizeraBase 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 Nc|dvr td||_||_||_t j ||_||_||_g|_ g|_ tdtdd|_ d|_ y)N)flopsr z.`minimize` should be one of {'flops', 'size'}.infr) ValueError max_repeatsmax_timeminimizer get_better_fnbetterparallel pre_dispatchcostssizesfloatbest_repeats_start)selfrr r!r$r%s r__init__zRandomOptimizer.__init__Usx , ,MN N&    ))(3   (  #ElE%LA cFtj|jdS)z$The best path found so far. ssa_path)r ssa_to_linearr)r+s rpathzRandomOptimizer.pathgs""499Z#899r-c|jSN) _parallelr1s rr$zRandomOptimizer.parallelms ~~r-c:t|ddr|jj||_d|_|durd|_y|durddlm}||_d|_yt|tjrddlm}|||_d|_y||_y)N_managing_executorFTr)ProcessPoolExecutor) getattr _executorshutdownr5r7concurrent.futuresr8 isinstancenumbersNumber)r+r$r8s rr$zRandomOptimizer.parallelqs 4-u 5 NN # # %!"' u !DN  t  >02DN&*D #  h / >0:DN&*D # "r-c#Kt|_|D]}t|j|jkr8|jj |j j ||g|]|jjj|jr8|jjj|jr7yyw)zVLazily generate results from an executor without submitting all jobs at once. N) r_futureslenr%appendr:submitpopleftresult)r+repeatstrial_fnargsrs r_gen_results_parallelz%RandomOptimizer._gen_results_parallels A4==!D$5$55 $$%:T^^%:%:8Q%N%NO--'')002 2  mm--'')002 2mms CC" C"c`|j"|jD]}|jyyr4)r:rAcancel)r+fs r_cancel_futureszRandomOptimizer._cancel_futuress( >> %]] # &r-ctr4)NotImplementedError)r+inputsoutput size_dicts rsetupzRandomOptimizer.setups!!r-cD|j||||jtj}|j|||\|jt |j z}||jz}t||}|j|j|} n fd|D} | D]\} } } |j j| |jj| |j| | |jd|jd} | r-| |jd<| |jd<| |jd<|jtj|jzkDsn|j|j S)Nc30K|] }|gywr4).0rJ trial_argsrHs r z+RandomOptimizer.__call__..s@1hq.:.srr r/)_check_args_against_first_callr timerUr*rBr&rranger:rKrCr'r#r)rOr2)r+rRrSrT memory_limitt0r_startr_stoprGtrialsr/costr found_new_bestrZrHs @@r__call__zRandomOptimizer.__call__sm ++FFIF == $B#zz&&)D*%%DJJ74+++( >> %//:NF@@F%+ HdD JJ  d # JJ  d #"[[tTYYw5GSYIZ[N%) '"$( &!(0 *% ) b4==>P0P!%+$ yyr-cTt|ddr|jjyy)Nr7F)r9r:r;r1s r__del__zRandomOptimizer.__del__s$ 4-u 5 NN # # % 6r-) NrF)__name__ __module__ __qualname____doc__r,propertyr2r$setterrKrOrUrfrhrXr-rrrsg5l $:: __""63  "'R&r-rctd}g}|rJ||krEtj|\}}} } ||vs| |vr*|j||| | f|dz }|r||krE|dk(ry|dk(r|dS|D cgc] } | dd } } | d} |r|tdt | z}|dk(r| Dcgc] }|| k(rdnd }}n)| Dcgc]}t j || z |z  }}tt||\}|j|\}}} } |D]}tj||||| | fScc} wcc}wcc}w)aA 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) heapqheappoprCmaxabsmathexprr^popheappush)queue remainingnbranch temperaturerel_temperaturenrrdk1k2k12rr&cmincenergieschosenothers rthermal_chooserrsF AG AK!MM%0b"c Y "I"5 b"c*+ Q AK AvAvqz(/ 0fVAYq\E 0 8Ds1c$i(( c3895adA)59BGGADHHq4x[;67GU1Xx8GF F+D"b# ue$ R - 1:Hs%D+D05#D5c ttt|}t|}tt t |}d}d}|D]\}}t j||||||\} } |j||j||jt ||j| || z }t|tj| |}||fS)z3Compute the flops and max size of an ssa path. r)listmap frozensetsetr^rBrcalc_k12_flopsdiscardaddrCrtrcompute_size_by_dict) r/rRrSrTr{ total_costmax_sizeijrflops12s rssa_path_compute_costrs#i( )F v FE#f+&'IJH1++FFIq!YW W!! c&k" cg x!=!=c9!MN x r-c|dk(rd}t|tj|||||}t||||\}}|||fS)zKA single, repeatable, greedy trial run. Returns ``ssa_path`` and cost. rN) random_seedrssa_greedy_optimizer) rJrRrSrT choose_fncost_fnr/rdr s r_trial_greedy_ssa_path_and_costr3sP Av N((IwWH&xKJD$ T4 r-c:eZdZdZdfd ZedZdZxZS)ra- 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 \||_||_||_||_t |di|y)NrX)rr}r~r|superr,)r+rr}r~r|kwargs __class__s rr,zRandomGreedy.__init__bs1 &.  "6"r-c|jdk(rytjt|j|j|j S)zThe function that chooses which contraction to take - make this a property so that ``temperature`` and ``nbranch`` etc. can be updated between runs. rN)r}r|r~)r| functoolspartialrr}r~r1s rrzRandomGreedy.choose_fnisC <<1   -1-=-=)-151E1EG Gr-cLt}||||j|jf}||fSr4)rrr)r+rRrSrTfnrIs rrUzRandomGreedy.setupws( , 4>>4<<H4xr-)zmemory-removed-jitterg?T) rkrlrmrnr,rorrU __classcell__)rs@rrrBs(># G Gr-rc .tdi|}|||||S)z rX)r)rRrSidx_dictr_optimizer_kwargs optimizers rrr}s#0/0I VVX| <r] collectionsrrrrrrrr ImportErrornumpyr __all__ PathOptimizerrrrrrrrrrXr-rrs   !0* As&e))s&lGT *  8?8v=&I%%mEe !S))..K!s A99"BB