a Sic\5@sdZddlZddlZddlZddlZddlZddlmZddlm Z m Z zddl m Z ddl mZWn*eyddlZdd Z ej jZYn0gd ZGd d d e jZdddZddZddZGdddeZdddZejeddZdS)zB Support for random optimizers, including the random-greedy path. N)deque)helperspaths)choices)seedcs(t|tjj|fdd|DddS)Ncsg|] }|qSr).0wnormrR/var/www/html/django/DPS/env/lib/python3.9/site-packages/opt_einsum/path_random.py z"random_choices..r)psize)sumnprandomchoice) populationweightsrr r random_choicessr) RandomGreedy random_greedyrandom_greedy_128c@sheZdZdZdddZed d Zed d Zejd d ZddZ ddZ ddZ ddZ ddZ dS)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 NflopsFcCsd|dvrtd||_||_||_t||_||_||_g|_ g|_ t dt dd|_ d|_ dS)N)rrz.`minimize` should be one of {'flops', 'size'}.infr) ValueError max_repeatsmax_timeminimizer get_better_fnbetterparallel pre_dispatchcostssizesfloatbest_repeats_start)selfr"r#r$r'r(rrr __init__Us zRandomOptimizer.__init__cCst|jdS)z$The best path found so far. ssa_path)r ssa_to_linearr,r.rrr pathgszRandomOptimizer.pathcCs|jSN) _parallelr2rrr r'mszRandomOptimizer.parallelcCst|ddr|j||_d|_|dur4d|_dS|durZddlm}||_d|_dSt|tj rddlm}|||_d|_dS||_dS)N_managing_executorFTr)ProcessPoolExecutor) getattr _executorshutdownr5r6concurrent.futuresr7 isinstancenumbersNumber)r.r'r7rrr r'qs$      ccsnt|_|D]D}t|j|jkr@|j|jj||g|Rq |jVq |jrj|jVqRdS)zVLazily generate results from an executor without submitting all jobs at once. N) r_futureslenr(appendr9submitpopleftresult)r.repeatstrial_fnargsrrrr _gen_results_parallelsz%RandomOptimizer._gen_results_parallelcCs"|jdur|jD] }|qdSr4)r9r?cancel)r.frrr _cancel_futuress  zRandomOptimizer._cancel_futurescCstdSr4)NotImplementedError)r.inputsoutput size_dictrrr setupszRandomOptimizer.setupcs|||||jdur t}||||\|jt|j}||j}t||}|j durp| |} nfdd|D} | D]\} } } |j | |j | | | | |jd|jd} | r| |jd<| |jd<| |jd<|jdurt||jkrq q||jS)Nc3s|]}|gRVqdSr4r)r rHZ trial_argsrFrr rz+RandomOptimizer.__call__..rrr0)_check_args_against_first_callr#timerQr-r@r)r"ranger9rIrAr*r&r,rLr3)r.rNrOrP memory_limitt0Zr_startZr_stoprEZtrialsr0costrZfound_new_bestrrRr __call__s,         zRandomOptimizer.__call__cCst|ddr|jdS)Nr6F)r8r9r:r2rrr __del__s zRandomOptimizer.__del__)rNrFr)__name__ __module__ __qualname____doc__r/propertyr3r'setterrIrLrQrZr[rrrr rs6    )rTcsd}g}|rT||krTt|\}}} } ||vs| |vr8q|||| | f|d7}q|dkr`dS|dkrp|dSdd|D} | d|rtdt9dkrfdd| D} nfdd| D} tt|| d \} || \}}} } |D]}t||q||| | fS) 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 rrNcSsg|]}|ddqS)rr)r rrrr rrz#thermal_chooser..gcsg|]}|krdndqS)rrrr c)cminrr rrcs g|]}t| qSr)mathexprcre temperaturerr rr)r) heapqheappoprAmaxabsrrVpopheappush)queue remainingnbranchrirel_temperaturenrrYk1k2k12r)ZenergiesZchosenotherrrhr thermal_choosers0#  ryc Csttt|}t|}ttt|}d}d}|D]f\}}t||||||\} } ||||| t|| | || 7}t |t | |}q2||fS)z3Compute the flops and max size of an ssa path. r)listmap frozensetsetrVr@rcalc_k12_flopsdiscardaddrArlrcompute_size_by_dict) r0rNrOrPrq total_costmax_sizeijrwflops12rrr ssa_path_compute_costs    rc CsB|dkr d}t|t|||||}t||||\}}|||fS)zKA single, repeatable, greedy trial run. Returns ``ssa_path`` and cost. rN) random_seedrssa_greedy_optimizer) rHrNrOrP choose_fncost_fnr0rYrrrr _trial_greedy_ssa_path_and_cost3s rcs6eZdZdZd fdd Zedd Zd d ZZS) 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 memory-removed-jitter?Trbc s.||_||_||_||_tjfi|dSr4)rrirsrrsuperr/)r.rrirsrrkwargs __class__rr r/bs zRandomGreedy.__init__cCs&|jdkrdStjt|j|j|jdS)zThe function that chooses which contraction to take - make this a property so that ``temperature`` and ``nbranch`` etc. can be updated between runs. rN)rirrrs)rr functoolspartialryrirsr2rrr ris zRandomGreedy.choose_fncCst}||||j|jf}||fSr4)rrr)r.rNrOrPfnrGrrr rQwszRandomGreedy.setup)rrTrb) r\r]r^r_r/r`rrQ __classcell__rrrr rBs  rcKstfi|}|||||S)z )r)rNrOidx_dictrWoptimizer_kwargs optimizerrrr r}srr)r")rbrT)N)r_rrjrfr=rU collectionsrrrrrrrr ImportErrornumpyr__all__ PathOptimizerrryrrrrrrrrrr s.   7 J;