&`i3ddlZddlmZddlmZmZmZddlZddlm Z ddl m Z ddl mZddlmZddlmZdd lmZdd lmZdd lmZ ddlZn #e$rdZYnwxYwejeZGd d Zed d!deedeedeedeedeedeedeedeede deede deeeffdZ!Gdd eZ"dS)"N) ModuleType)DictOptionalUnion)usage)_MLflowLoggerUtil)TRAINING_ITERATION)Trial)LoggerCallback)TIMESTEPS_TOTAL)_in_tune_session) PublicAPIceZdZdZdZdS) _NoopModulectSN)r)selfitems o/home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/ray/air/integrations/mlflow.py __getattr__z_NoopModule.__getattr__s }}cdSrrargskwargss r__call__z_NoopModule.__call__strN)__name__ __module__ __qualname__rrrrrrrs2rralpha) stabilityFTconfig tracking_uri registry_uri experiment_idexperiment_nametracking_tokenartifact_locationrun_namecreate_experiment_if_not_existstagsrank_zero_onlyreturnc tstdd} d} trGtj} | } | } nFtj} | r&| dkrtSn#t$rd} d} YnwxYw|r| ni}|p| }|p| }t}| |||||||||p|| d||t!j|jS)aSet up a MLflow session. This function can be used to initialize an MLflow session in a (distributed) training or tuning run. The session will be created on the trainable. By default, the MLflow experiment ID is the Ray trial ID and the MLlflow experiment name is the Ray trial name. These settings can be overwritten by passing the respective keyword arguments. The ``config`` dict is automatically logged as the run parameters (excluding the mlflow settings). In distributed training with Ray Train, only the zero-rank worker will initialize mlflow. All other workers will return a noop client, so that logging is not duplicated in a distributed run. This can be disabled by passing ``rank_zero_only=False``, which will then initialize mlflow in every training worker. Note: for Ray Tune, there's no concept of worker ranks, so the `rank_zero_only` is ignored. This function will return the ``mlflow`` module or a noop module for non-rank zero workers ``if rank_zero_only=True``. By using ``mlflow = setup_mlflow(config)`` you can ensure that only the rank zero worker calls the mlflow API. Args: config: Configuration dict to be logged to mlflow as parameters. tracking_uri: The tracking URI for MLflow tracking. If using Tune in a multi-node setting, make sure to use a remote server for tracking. registry_uri: The registry URI for the MLflow model registry. experiment_id: The id of an already created MLflow experiment. All logs from all trials in ``tune.Tuner()`` will be reported to this experiment. If this is not provided or the experiment with this id does not exist, you must provide an``experiment_name``. This parameter takes precedence over ``experiment_name``. experiment_name: The name of an already existing MLflow experiment. All logs from all trials in ``tune.Tuner()`` will be reported to this experiment. If this is not provided, you must provide a valid ``experiment_id``. tracking_token: A token to use for HTTP authentication when logging to a remote tracking server. This is useful when you want to log to a Databricks server, for example. This value will be used to set the MLFLOW_TRACKING_TOKEN environment variable on all the remote training processes. artifact_location: The location to store run artifacts. If not provided, MLFlow picks an appropriate default. Ignored if experiment already exists. run_name: Name of the new MLflow run that will be created. If not set, will default to the ``experiment_name``. create_experiment_if_not_exists: Whether to create an experiment with the provided name if it does not already exist. Defaults to False. tags: Tags to set for the new run. rank_zero_only: If True, will return an initialized session only for the rank 0 worker in distributed training. If False, will initialize a session for all workers. Defaults to True. Example: Per default, you can just call ``setup_mlflow`` and continue to use MLflow like you would normally do: .. code-block:: python from ray.air.integrations.mlflow import setup_mlflow def training_loop(config): mlflow = setup_mlflow(config) # ... mlflow.log_metric(key="loss", val=0.123, step=0) In distributed data parallel training, you can utilize the return value of ``setup_mlflow``. This will make sure it is only invoked on the first worker in distributed training runs. .. code-block:: python from ray.air.integrations.mlflow import setup_mlflow def training_loop(config): mlflow = setup_mlflow(config) # ... mlflow.log_metric(key="loss", val=0.123, step=0) You can also use MlFlow's autologging feature if using a training framework like Pytorch Lightning, XGBoost, etc. More information can be found here (https://mlflow.org/docs/latest/tracking.html#automatic-logging). .. code-block:: python from ray.air.integrations.mlflow import setup_mlflow def train_fn(config): mlflow = setup_mlflow(config) mlflow.autolog() xgboost_results = xgb.train(config, ...) z?mlflow was not found - please install with `pip install mlflow`Nr)r$r%r&r'r(r)r+T)r*r, set_active)mlflow RuntimeErrorr raytune get_context get_trial_idget_trial_nametrainget_world_rankrcopyr setup_mlflow start_run log_params air_usagetag_setup_mlflow_mlflow)r#r$r%r&r'r(r)r*r+r,r-default_trial_iddefault_trial_namecontext_config mlflow_utils rr;r; sb   M    "    %,/H,@,@,B,BG&3355 !(!7!7!9!9  .1i.C.C.E.EG %'"8"8":":a"?"?"}}$ """!" &-fkkmmm2G!5%5M%;);O$%%K!!#'%+(G,_  7###    sBB88C C ceZdZdZ dddddddddeedeedeedeed eed ed efd Zd Z ddZ de dddefdZ ddddefdZ dS)MLflowLoggerCallbacka MLflow Logger to automatically log Tune results and config to MLflow. MLflow (https://mlflow.org) Tracking is an open source library for recording and querying experiments. This Ray Tune ``LoggerCallback`` sends information (config parameters, training results & metrics, and artifacts) to MLflow for automatic experiment tracking. Keep in mind that the callback will open an MLflow session on the driver and not on the trainable. Therefore, it is not possible to call MLflow functions like ``mlflow.log_figure()`` inside the trainable as there is no MLflow session on the trainable. For more fine grained control, use :func:`ray.air.integrations.mlflow.setup_mlflow`. Args: tracking_uri: The tracking URI for where to manage experiments and runs. This can either be a local file path or a remote server. This arg gets passed directly to mlflow initialization. When using Tune in a multi-node setting, make sure to set this to a remote server and not a local file path. registry_uri: The registry URI that gets passed directly to mlflow initialization. experiment_name: The experiment name to use for this Tune run. If the experiment with the name already exists with MLflow, it will be reused. If not, a new experiment will be created with that name. tags: An optional dictionary of string keys and values to set as tags on the run tracking_token: Tracking token used to authenticate with MLflow. save_artifact: If set to True, automatically save the entire contents of the Tune local_dir as an artifact to the corresponding run in MlFlow. log_params_on_trial_end: If set to True, log parameters to MLflow at the end of the trial instead of at the beginning Example: .. code-block:: python from ray.air.integrations.mlflow import MLflowLoggerCallback tags = { "user_name" : "John", "git_commit_hash" : "abc123"} tune.run( train_fn, config={ # define search space here "parameter_1": tune.choice([1, 2, 3]), "parameter_2": tune.choice([4, 5, 6]), }, callbacks=[MLflowLoggerCallback( experiment_name="experiment1", tags=tags, save_artifact=True, log_params_on_trial_end=True)]) NF)r%r'r,r( save_artifactlog_params_on_trial_endr$r%r'r,r(rHrIc||_||_||_||_||_||_||_t|_tj j j rtddSdS)NzWhen using MLflowLoggerCallback with Ray Client, it is recommended to use a remote tracking server. If you are using a MLflow tracking server backed by the local filesystem, then it must be setup on the server side and not on the client side.)r$r%r'r,r(should_save_artifactrIrrEr3utilclient is_connectedloggerwarning)rr$r%r'r,r(rHrIs r__init__zMLflowLoggerCallback.__init__s)(. ,$1!'>$,.. 8?  + + - -  NN       rc|j|j|j|j|j|ji|_i|_dS)N)r$r%r'r()rEr;r$r%r'r(r, _trial_runsrs rsetupzMLflowLoggerCallback.setupsY %%** 0. &    9 DIrtrialr cZ||jvrh|j}t||d<|j|t|}|jj|j|<|j|}|j}|j s|j ||dSdS)N trial_name)r,r*run_id params_to_log) rSr,r:strrEr<inforYr#rIr=)rrUr,runrYr#s rlog_trial_startz$MLflowLoggerCallback.log_trial_start.s ( ( (9>>##D!$UD ",,$U,LLC&)hoD U #!%(+ M   ' 'vV ' L L L L L M Mr iterationresultc|tp |t}|j|}|j|||dS)N)rYmetrics_to_logstep)getr r rSrE log_metrics)rr_rUr`rcrYs rlog_trial_resultz%MLflowLoggerCallback.log_trial_result@sPzz/**Hf5G.H!%( $$F6PT$UUUUUrfailedc|j|}|jr!|j||j|sdnd}|j}|jr|j|||j||dS)N)rYdirFINISHEDFAILEDrX)rYstatus) rSrKrEsave_artifacts local_pathr#rIr=end_run)rrUrgrYrlr#s r log_trial_endz"MLflowLoggerCallback.log_trial_endEs!%(  $ Q   + +6u?O + P P P$*7x  ' M   ' 'vV ' L L L   v >>>>>rr)rUr )F)rrr __doc__rr[rboolrQrTr^intrfrprrrrGrGs288x'+'+)-#(,#(-smsm  "#  tn ! "&@   MMMM$V#VgVtVVVV ??7?D??????rrG) NNNNNNNNFNT)#loggingtypesrtypingrrrr3ray.air._internalrr>ray.air._internal.mlflowrray.air.constantsr ray.tune.experimentr ray.tune.loggerr ray.tune.resultr %ray.tune.trainable.trainable_fn_utilsr ray.util.annotationsrr1 ImportError getLoggerrrOrr[rrr;rGrrrrs(((((((((( 000000666666000000%%%%%%******++++++BBBBBB******MMMM FFF  8 $ $ W!"&"&#'%)$('+",1`` TN`3-`3-`C= ` c] ` SM ` }`sm`&*` 4.`` :{ "#````FP?P?P?P?P?>P?P?P?P?P?s AAA