&`ikddlZddlZddlZddlZddlZddlZddlZddlZddlm Z m Z ddl m Z ddl m Z ddlmZmZmZmZmZmZmZddlZddlmZddlmZddlmZmZddlm Z m!Z!m"Z"dd l#m$Z$dd l%m&Z&m'Z'dd l(m)Z)dd l*m+Z+dd l,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;mZ>ddl?m@Z@ddlAmBZBddlCmDZDmEZEerddlFmGZGejHeIZJdZKdZLeEGddZMdS)N)redirect_stderrredirect_stdout)datetime)Path) TYPE_CHECKINGAnyCallableDictListOptionalUnion)try_to_create_directory)exception_causeskip_exceptions)TIME_THIS_ITER_S TIMESTAMPTRAINING_ITERATION)_TrainingResult)StorageContext_exists_at_fs_path)DEFAULT_STORAGE_PATH)PlacementGroupFactory) DEBUG_METRICSDONEEPISODES_THIS_ITEREPISODES_TOTALHOSTNAMENODE_IPPIDRESULT_DUPLICATESHOULD_CHECKPOINT STDERR_FILE STDOUT_FILE TIME_TOTAL_STIMESTEPS_THIS_ITERTIMESTEPS_TOTALTRIAL_ID TRIAL_INFO) UtilMonitor)disable_ipython)Tee) DeveloperAPI PublicAPI)Logger z_dict_checkpoint.pklc zeZdZdZ d;deeefdeeeefgdfdee fdZ e deeefdee fd Z e defd Zd Z ddeedefdZedeedeffdZ d>d ee eefd!eefd"Z!d?d#Z"d$edefd%Z# d>deeefdeeeefgdffd&Z$d'Z%d(Z&d)Z'e(d*Z)e(d+Z*e(d,Z+e(dee fd-Z,e(d.Z-e(d/Z.d0Z/d1Z0dedeefd2Z1d3eefd4Z2defd5Z3d6efd7Z4d8Z5d e ed!efd9Z6d:Z7dS)@ TrainableaAbstract class for trainable models, functions, etc. A call to ``train()`` on a trainable will execute one logical iteration of training. As a rule of thumb, the execution time of one train call should be large enough to avoid overheads (i.e. more than a few seconds), but short enough to report progress periodically (i.e. at most a few minutes). Calling ``save()`` should save the training state of a trainable to disk, and ``restore(path)`` should restore a trainable to the given state. Generally you only need to implement ``setup``, ``step``, ``save_checkpoint``, and ``load_checkpoint`` when subclassing Trainable. Other implementation methods that may be helpful to override are ``log_result``, ``reset_config``, ``cleanup``, and ``_export_model``. Tune will convert this class into a Ray actor, which runs on a separate process. By default, Tune will also change the current working directory of this process to its corresponding trial-level log directory ``self.logdir``. This is designed so that different trials that run on the same physical node won't accidentally write to the same location and overstep each other. The behavior of changing the working directory can be disabled by setting the `RAY_CHDIR_TO_TRIAL_DIR=0` environment variable. This allows access to files in the original working directory, but relative paths should be used for read only purposes, and you must make sure that the directory is synced on all nodes if running on multiple machines. The `TUNE_ORIG_WORKING_DIR` environment variable was the original workaround for accessing paths relative to the original working directory. This environment variable is deprecated, and the `RAY_CHDIR_TO_TRIAL_DIR` environment variable described above should be used instead. This class supports checkpointing to and restoring from remote storage. Nconfiglogger_creatorr.storagec|pi|_|jtd}|rt dx|_|_||j|dx|_x|_ |_ dx|_ x|_ |_ d|_|jtd}|jt d}d|_d|_d|_d|_d|_d|_d|_d|_d|_||_||_||_t;j|_t>j !|_"||_#|r&|j$sJtJ&d||'|||(tSj*|jt;j|jz }|tVkr-tJ,d-||j.dd}t_||_0dS) atInitialize a Trainable. Sets up logging and points ``self.logdir`` to a directory in which training outputs should be placed. Subclasses should prefer defining ``setup()`` instead of overriding ``__init__()`` directly. Args: config: Trainable-specific configuration data. By default will be saved as ``self.config``. logger_creator: (Deprecated) Function that creates a ray.tune.Logger object. If unspecified, a default logger is created. storage: StorageContext object that contains persistent storage paths NrFz!StorageContext on the TRAINABLE: zTrainable.setup took {:.3f} seconds. If your trainable is slow to initialize, consider setting reuse_actors=True to reduce actor creation overheads. log_sys_usage)start)1r2popr(is_actorr*_result_logger_logdir_create_logger_stdout_context _stdout_fp_stdout_stream_stderr_context _stderr_fp_stderr_stream_stderr_logging_handlerr#r" _iteration _time_total_timesteps_total_episodes_total_time_since_restore_timesteps_since_restore_iterations_since_restore _last_result _restored _trial_info _stdout_file _stderr_filetime _start_timerayutilget_node_ip_address _local_ip_storage trial_fs_pathloggerdebug_open_logfilessetupcopydeepcopySETUP_TIME_THRESHOLDinfoformatgetr)_monitor) selfr2r3r4 trial_info stdout_file stderr_file setup_timer7s p/home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/ray/tune/trainable/trainable.py__init__zTrainable.__init___s.,l [__Z66 ==??     .21dl DK888GKKKt1DGKKKt1D'+$kook488 kook488  $##& ()%)*& %''9;;5577  I( ( (( LLGgGG H H H K555 4=--...Y[[4#33 , , , KK$VJ//      ?? #-888 returncdS)aKProvides a static resource requirement for the given configuration. This can be overridden by sub-classes to set the correct trial resource allocation, so the user does not need to. .. testcode:: @classmethod def default_resource_request(cls, config): return PlacementGroupFactory([{"CPU": 1}, {"CPU": 1}]) Args: config[Dict[str, Any]]: The Trainable's config dict. Returns: PlacementGroupFactory: A PlacementGroupFactory consumed by Tune for queueing. Nclsr2s ridefault_resource_requestz"Trainable.default_resource_requests .trkcdS)zReturns a help string for configuring this trainable's resources. Args: config: The Trainer's config dict. rnros ri resource_helpzTrainable.resource_helps rrkc6|jtjfSN)rVosgetpidrds riget_current_ip_pidzTrainable.get_current_ip_pids~ry{{**rkFnowtime_this_iter timestampdebug_metrics_onlyc|tj}t|jd|dd|r|n2t t j|t|t|j ttjtt!jt$|jd|jd|jd|ji }|jr |j|d<|rd |D}|S) zReturn a dict with metrics auto-filled by the trainable. If ``debug_metrics_only`` is True, only metrics that don't require at least one iteration will be returned (``ray.tune.result.DEBUG_METRICS``). Ndate%Y-%m-%d_%H-%M-%Sr}r2time_since_restoreiterations_since_restoretimesteps_since_restorec,i|]\}}|tv||Srn)r).0kvs ri z5Trainable.get_auto_filled_metrics..s(TTT41amASAS!QASASASrk)rtodayr'trial_idstrftimeintrQmktime timetuplerr$rFrrwrxrplatformnoderrVr2rIrKrJitems)rdr{r|r}r~ autofilleds riget_auto_filled_metricsz!Trainable.get_auto_filled_metricss ;.""C dm CLL!455 iVSS]]__9U9U5V5V n $*  hmoo T^ dk $": &(F    ( R484QJ0 1  UTT:+;+;+=+=TTTJrkc tjjjj}||kS#t $rYdSwxYw)NF)rS_privateworker global_workeractor_idnil Exception)rdrs rir:zTrainable.is_actorsL |*8AHx||~~- -   55 s25 AA buffer_time_smax_buffer_lengthcg}tj}||z}||ks|s|}|||tdrnf|t drnJ|t rn/t||krntj}||k||S)aRuns multiple iterations of training. Calls ``train()`` internally. Collects and combines multiple results. This function will run ``self.train()`` repeatedly until one of the following conditions is met: 1) the maximum buffer length is reached, 2) the maximum buffer time is reached, or 3) a checkpoint was created. Even if the maximum time is reached, it will always block until at least one result is received. Args: buffer_time_s: Maximum time to buffer. The next result received after this amount of time has passed will return the whole buffer. max_buffer_length: Maximum number of results to buffer. F)rQtrainappendrbrr!r len)rdrrresultsr{send_buffer_atresults ritrain_bufferedzTrainable.train_buffereds"ikk},N""'"ZZ\\F NN6 " " "zz$&& -u55 ,-- W!222)++CN""'""rkctj} |}n1#t$r$}t|}|t |d}~wwxYwt |t s Jdt|vr|S|}|xj dz c_ |xj dz c_ | t|t}ntj|z }|xj |z c_ |xj|z c_| td}|t"d| t$D|jd|_|xj|t$z c_|xj|t$z c_| t*)|jd|_|xj|t*z c_|j |t.|j|j |t0|j|t2|j t5j}||||||j}|r||| ||j!r|j"#|j$r|j%#||_&|j'r|j'(|S)aRuns one logical iteration of training. Calls ``step()`` internally. Subclasses should override ``step()`` instead to return results. This method automatically fills the following fields in the result: `done` (bool): training is terminated. Filled only if not provided. `time_this_iter_s` (float): Time in seconds this iteration took to run. This may be overridden in order to override the system-computed time difference. `time_total_s` (float): Accumulated time in seconds for this entire experiment. `training_iteration` (int): The index of this training iteration, e.g. call to train(). This is incremented after `step()` is called. `pid` (str): The pid of the training process. `date` (str): A formatted date of when the result was processed. `timestamp` (str): A UNIX timestamp of when the result was processed. This may be overridden. `hostname` (str): Hostname of the machine hosting the training process. `node_ip` (str): Node ip of the machine hosting the training process. Returns: A dict that describes training progress. Nzstep() needs to return a dict.Fr)r{r|r}))rQsteprrr isinstancedictr r]rErKrbrrFrIr setdefaultrr%rGrJrrHr&rrrrupdaterrcget_data log_resultr>r@flushrArCrLrWpersist_artifacts) rdr8reskippedr|result_timestampr{ monitor_datas rirzTrainable.train"s.H  8YY[[FF 8 8 8%a((Gw77 7 8&$''II)III' v % %M 1 &&!+&& ::& ' ' 3#$45NN!Y[[50N N*   N2  !::i66$&&& ::) * * 6$,()%  ! !V,?%@ @ ! !  ) )V4G-H H ) ) ::( ) ) 5#+'($  F+=$> >   ,   ot/D E E E   +   nd.B C C C,do>>>n  ( (BR )     }--//  ( MM, ' ' '    (   % % ' ' '   (   % % ' ' '" = . M + + - - - s* AAAcZ|j|j|j|j|jt jdS)N) iterationtimesteps_total time_totalepisodes_total last_result ray_version)rErGrFrHrLrS __version__rys ri get_statezTrainable.get_states3#4*"2,?    rkcheckpoint_dircheckpoint_dict_or_pathct|trVt|td5}t j||dddn #1swxYwYn0t|tr||krtd|d|tj j |}|j r|j ni}|jrp|j||j|}t%||}|j|jjjnt%||}|S)aReport a checkpoint saved via Trainable.save_checkpoint. Need to handle both dict or path checkpoint returned by the user's `save_checkpoint` method. This is to get class trainables to work with storage backend used by function trainables. This basically re-implements `tune.report` for class trainables, making sure to persist the checkpoint to storage. wbNzoThe returned checkpoint path from `save_checkpoint` must be None or the same as the provided path argument.Got z !=  checkpointmetrics)force)rrr_DICT_CHECKPOINT_FILE_NAMEopen ray_pickledumpstr ValueErrorrStune Checkpointfrom_directoryrLr]rW_update_checkpoint_indexpersist_current_checkpointrr sync_configsync_artifacts_on_checkpoint)rdrrflocal_checkpointrpersisted_checkpointcheckpoint_results ri"_report_class_trainable_checkpointz,Trainable._report_class_trainable_checkpoints -t 4 4 n&@AAFFtLL &J&J # $ G G 7!!  B  B nDAAAA151E1Ed1K1K /AA A AA$ $ $$  % , ,T-> ? ? ?  rkcheckpoint_pathzray.tune.Checkpointc@t|tr$tjj|}t|tjjrt |i}n|}t|t sJt||j}|j }| td|_ | td|_d|_d|_| t"|_d|_| t(|_t-|j|js$t3d|jjd|jt|tjjjs|5}t=|}|t>z }| rRtC|d5}tEj#|}dddn #1swxYwY|$|n|$|dddn #1swxYwYn|$|d|_%tL'd |j(d |dS) aRestores training state from a given model checkpoint. These checkpoints are returned from calls to save(). Subclasses should override ``load_checkpoint()`` instead to restore state. This method restores additional metadata saved with the checkpoint. `checkpoint_path` should match with the return from ``save()``. Args: checkpoint_path: training result that was returned by a previous call to `save()`. rrr6z`Could not recover from checkpoint as it does not exist on storage anymore. Got storage fs type `z ` and path: rbNTz Restored on z from checkpoint: ))rrrSrrrrtyperrrbrrEr$rFrIrKr&rGrJrrHr filesystempathr type_namerr as_directoryrrexistsrrloadload_checkpointrMrYr`rV) rdrrrcheckpoint_metricsrdict_checkpoint_filercheckpoint_dicts rirestorezTrainable.restores* os + + R!h1@@QQO osx': ; ; A /?TV W W W  1@ +_==VVtDU?V?VVV=&1 .6,001CQGG-11,BB#& )*&!3 6 6 G G()%155nEE!*"7II +(2(=(G++$++ $ 2 DEE 4((** 9n"&~"6"6'69S'S$'..0092D99=Q*4/!*<*<===============((9999((888 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9  !2 3 3 3 Q4>QQZQQRRRRRs60>I.H IH IH .IIIexport_formats export_dircpt|tr|g}|p|j}|||S)aExports model based on export_formats. Subclasses should override _export_model() to actually export model to local directory. Args: export_formats: Format or list of (str) formats that should be exported. export_dir: Optional dir to place the exported model. Defaults to self.logdir. Returns: A dict that maps ExportFormats to successfully exported models. )rrlogdir _export_modelrdrrs ri export_modelzTrainable.export_modelDs@" nc * * .,-N.4; !!.*===rkc||_||_|td}|r||_|j|j|rCt d| | |nt d|d|td}|td}||||||}|sdSd|_d|_d|_d|_d|_d|_d|_d|_dS) zResets trial for use with new config. Subclasses should override reset_config() to actually reset actor behavior for the new config.Nz Logger reset.z:Did not reset logger. Got: trainable.reset(logger_creator=z).Frr6T)r2rWr9r(rNr;rcloserYrZr=r]r#r"_close_logfilesr[ reset_configrErFrGrHrIrJrKrM)rd new_configr3r4rerfrgsuccesss riresetzTrainable.resetZs !  ^^J55  *)D  !!### !!###   LL ) ) )     1 1> B B B B LLE2@EEE    !nn[$77  nn[$77   K555##J// 5 $##& ()%)*&trkrcdS)aResets configuration without restarting the trial. This method is optional, but can be implemented to speed up algorithms such as PBT, and to allow performance optimizations such as running experiments with reuse_actors=True. Args: new_config: Updated hyperparameter configuration for the trainable. Returns: True if reset was successful else False. Frn)rdrs rirzTrainable.reset_configs urkc@|r#|||_|jj|_dSddlm}t jd}tttj |t|_|||jd|_dS)zCreate logger from logger creator. Sets _logdir and _result_logger. `_logdir` is the **per trial** directory for the Trainable. r) UnifiedLoggerr)prefixdirN)loggers) r;rr<ray.tune.loggerrrrrrrrr)rdr2r3r logdir_prefixs rir=zTrainable._create_loggers  T"0."8"8D .5DLLL 5 5 5 5 5 5$N,,556IJJM #$8 9 9 9#+$*>DL#0- d"S"S"SD   rkc|rt|j|z }t |d|_t tj|j|_ t|j |_ |j |rt|j|z }t |d|_ t tj|j |_t!|j|_|j t%jd}t%j|j |_|j|t.j|jdSdS)z0Create loggers. Open stdout and stderr logfiles.za+zA[%(levelname)s %(asctime)s] %(filename)s: %(lineno)d %(message)sN)rr< expanduseras_posixrr?r+sysstdoutr@rr> __enter__rBstderrrCrrAlogging Formatter StreamHandlerrD setFormatterrSrY addHandler)rdrfrg stdout_path stderr_path formatters rir[zTrainable._open_logfiless{  - -- ;GGIIRRTTK";55DO"%cj$/"B"BD #243F#G#GD  * * , , ,  @ -- ;GGIIRRTTK";55DO"%cj$/"B"BD #243F#G#GD  * * , , , )I ,3+@+Q+QD (  ( 5 5i @ @ @ J ! !$"> ? ? ? ? ? @ @rkc|jr$tj|j|jrU|j|jddd|j d|_|j rW|j |j ddd|j d|_ dSdS)z!Close stdout and stderr logfiles.N) rDrSrY removeHandlerr>r@r__exit__r?rrArCrBrys rirzTrainable._close_logfiless  ' C J $ $T%A B B B   (   % % ' ' '  ) )$d ; ; ; O ! ! # # ##'D   (   % % ' ' '  ) )$d ; ; ; O ! ! # # ##'D  ( (rkcP|j|j|jr2|j|j||dS)zReleases all resources used by this trainable. Calls ``Trainable.cleanup`` internally. Subclasses should override ``Trainable.cleanup`` for custom cleanup procedures. N) r;rrrcis_alivestopjoincleanuprrys rirzTrainable.stops !!### !!### = ! ! # # ! M   M     rkc|jS)zDirectory of the results and checkpoints for this Trainable. Note that the current working directory will also be changed to this. )r<rys rirzTrainable.logdirs |rkc,|jr |jjSdS)zTrial name for the corresponding trial of this Trainable. This is not set if not using Tune. .. testcode:: from ray.tune import Trainable name = Trainable().trial_name default)rN trial_namerys rir%zTrainable.trial_names    #. .9rkc,|jr |jjSdS)zTrial ID for the corresponding trial of this Trainable. This is not set if not using Tune. .. testcode:: from ray.tune import Trainable trial_id = Trainable().trial_id r$)rNrrys rirzTrainable.trial_ids    #, ,9rkc,|jr |jjSdS)zResources currently assigned to the trial of this Trainable. This is not set if not using Tune. .. testcode:: from ray.tune import Trainable trial_resources = Trainable().trial_resources N)rNtrial_resourcesrys rir(zTrainable.trial_resourcess    #3 34rkc|jS)zCurrent training iteration. This value is automatically incremented every time `train()` is called and is automatically inserted into the training result dict. rErys rirzTrainable.iteration& rkc|jS)zCurrent training iteration (same as `self.iteration`). This value is automatically incremented every time `train()` is called and is automatically inserted into the training result dict. r*rys ritraining_iterationzTrainable.training_iteration0r+rkc|jS)z(Returns configuration passed in by Tune.)r2rys ri get_configzTrainable.get_config:s {rkct)aSubclasses should override this to implement train(). The return value will be automatically passed to the loggers. Users can also return `tune.result.DONE` or `tune.result.SHOULD_CHECKPOINT` as a key to manually trigger termination or checkpointing of this trial. Note that manual checkpointing only works when subclassing Trainables. .. versionadded:: 0.8.7 Returns: A dict that describes training progress. NotImplementedErrorrys rirzTrainable.step>s "!rkct)aSubclasses should override this to implement ``save()``. Warning: Do not rely on absolute paths in the implementation of ``Trainable.save_checkpoint`` and ``Trainable.load_checkpoint``. Use ``validate_save_restore`` to catch ``Trainable.save_checkpoint``/ ``Trainable.load_checkpoint`` errors before execution. >>> from ray.tune.utils import validate_save_restore >>> MyTrainableClass = ... # doctest: +SKIP >>> validate_save_restore(MyTrainableClass) # doctest: +SKIP .. versionadded:: 0.8.7 Args: checkpoint_dir: The directory where the checkpoint file must be stored. In a Tune run, if the trial is paused, the provided path may be temporary and moved. Returns: A dict or None. If dict, the return value will be automatically serialized by Tune. In that case, ``Trainable.load_checkpoint()`` will receive the dict upon restore. Example: >>> trainable, trainable1, trainable2 = ... # doctest: +SKIP >>> print(trainable1.save_checkpoint("/tmp/checkpoint_1")) # doctest: +SKIP "/tmp/checkpoint_1" >>> print(trainable2.save_checkpoint("/tmp/checkpoint_2")) # doctest: +SKIP {"some": "data"} >>> trainable.save_checkpoint("/tmp/bad_example") # doctest: +SKIP "/tmp/NEW_CHECKPOINT_PATH/my_checkpoint_file" # This will error. r1)rdrs rirzTrainable.save_checkpointOs F"!rkrct)aSubclasses should override this to implement restore(). Warning: In this method, do not rely on absolute paths. The absolute path of the checkpoint_dir used in ``Trainable.save_checkpoint`` may be changed. If ``Trainable.save_checkpoint`` returned a prefixed string, the prefix of the checkpoint string returned by ``Trainable.save_checkpoint`` may be changed. This is because trial pausing depends on temporary directories. The directory structure under the checkpoint_dir provided to ``Trainable.save_checkpoint`` is preserved. See the examples below. Example: >>> import os >>> from ray.tune.trainable import Trainable >>> class Example(Trainable): ... def save_checkpoint(self, checkpoint_path): ... my_checkpoint_path = os.path.join(checkpoint_path, "my/path") ... return my_checkpoint_path ... def load_checkpoint(self, my_checkpoint_path): ... print(my_checkpoint_path) >>> trainer = Example() >>> # This is used when PAUSED. >>> checkpoint_result = trainer.save() # doctest: +SKIP >>> trainer.restore(checkpoint_result) # doctest: +SKIP If `Trainable.save_checkpoint` returned a dict, then Tune will directly pass the dict data as the argument to this method. Example: >>> from ray.tune.trainable import Trainable >>> class Example(Trainable): ... def save_checkpoint(self, checkpoint_path): ... return {"my_data": 1} ... def load_checkpoint(self, checkpoint_dict): ... print(checkpoint_dict["my_data"]) .. versionadded:: 0.8.7 Args: checkpoint: If dict, the return value is as returned by ``save_checkpoint``. Otherwise, the directory the checkpoint was stored in. r1)rdrs rirzTrainable.load_checkpointts d"!rkcdS)zSubclasses should override this for custom initialization. .. versionadded:: 0.8.7 Args: config: Hyperparameters and other configs given. Copy of `self.config`. Nrn)rdr2s rir\zTrainable.setups  rkrc:|j|dS)aSubclasses can optionally override this to customize logging. The logging here is done on the worker process rather than the driver. .. versionadded:: 0.8.7 Args: result: Training result returned by step(). N)r; on_result)rdrs rirzTrainable.log_results! %%f-----rkcdS)aSubclasses should override this for any cleanup on stop. If any Ray actors are launched in the Trainable (i.e., with a RLlib trainer), be sure to kill the Ray actor process here. This process should be lightweight. Per default, You can kill a Ray actor by calling `ray.kill(actor)` on the actor or removing all references to it and waiting for garbage collection .. versionadded:: 0.8.7 Nrnrys rir!zTrainable.cleanups  rkciS)a&Subclasses should override this to export model. Args: export_formats: List of formats that should be exported. export_dir: Directory to place exported models. Return: A dict that maps ExportFormats to successfully exported models. rnrs rirzTrainable._export_models  rkc\t||ott||Srv)hasattrcallablegetattr)rdkeys ri_implements_methodzTrainable._implements_methods)tS!!BhwtS/A/A&B&BBrk)NNN)NNNF)rrv)NN)8__name__ __module__ __qualname____doc__r rrr r rrj classmethodrrqrtrzrfloatrboolrrr:rrrr rrr,rrr rrrr=r[rrpropertyrr%rr(rr-r/rrrr\rr!rr?rnrkrir1r19s""L"&?C,0 I9I9S#XI9!$sCx.!18!;<I9.) I9I9I9I9V#s(^ ' ([04[+++ #'*.#'#( !! h !!!C= ! ! !  !!!!F&&E&c&&&&Pmmm^   6!!6!>#DIsN3>AI#>>>>,....`t&@DTTS#XT!$sCx.!18!;<TTTT0@@@4(((   XX X *?!@X XX""""#"c#"htn#"#"#"#"J2"(4.2"2"2"2"h  D      . . . . .   DI 3    CCCCCrkr1)Nr]rrwrrrrrQ contextlibrrrpathlibrtypingrrr r r r r rSray.cloudpickle cloudpicklerray._common.utilsrray.air._internal.utilrrray.air.constantsrrr&ray.train._internal.checkpoint_managerrray.train._internal.storagerrray.train.constantsr#ray.tune.execution.placement_groupsrray.tune.resultrrrrrrrr r!r"r#r$r%r&r'r(ray.tune.utilsr)ray.tune.utils.logr*ray.tune.utils.utilr+ray.util.annotationsr,r-r r. getLoggerr@rYr_rr1rnrkrirZs    77777777LLLLLLLLLLLLLLLLLL $$$$$$555555CCCCCCCCMMMMMMMMMMBBBBBBJJJJJJJJ444444EEEEEE$'&&&&&......######88888888'&&&&&&  8 $ $4 dCdCdCdCdCdCdC dCdCdCrk