o xi?@s:UddlmZddlZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl Z ddlZddlmZmZddlmZmZddlmZmZmZddlmZddlmZddlmZmZmZm Z dd l!m"Z"m#Z#m$Z$m%Z%m&Z&ddl'Z'ddl(Z'ddl)Z'dd l'm*Z*dd l+m,Z,dd l-m.Z.m/Z/dd l0m1Z1ddl2m3Z3ddl4m5Z5m6Z6ddl7m8Z8m9Z9m:Z:m;Z;ddlm?Z?ddl@mAZAmBZBmCZCmDZDmEZEmFZFmGZGddlHmIZImJZJddlKmLZLmMZMddl)mNZNmOZOmPZPmQZQmRZRmSZSmTZTddlUmVZVmWZWmXZXddlYmZZZddl[m\Z\ddl]m^Z^ddl_m`Z`maZambZbmcZcmdZdmeZemfZfmgZgmhZhmiZimjZjmkZkddllmmZmddlnmoZompZpmqZqmrZrddlsmtZtdd lumvZverdd!lmwZwddlxZxdd"lymzZ{dd#l7m|Z|m}Z}m~Z~dd$lmZdd%lmZdd&lmZdd'lmZGd(d)d)ewZGd*d+d+ewZGd,d-d-ewZGd.d/d/ewd0d1Zed2Zd3Ze d4ZGd5d6d6eZGd7d8d8e%ZGd9d:d:Ze&d;Ze d<Zd]d@dAZdBadCedD<d]dEdFZd]dGdHZeGdIdJdJZGdKdLdLZ  0 d^d_dTdUZzejej_Wn eyYnw  d`dad[d\ZdS)b) annotationsN)MappingSequence) dataclassfield)datetime timedeltatimezone)IntEnum) TracebackType) TYPE_CHECKINGCallableTextIOTypeVar)Any ConcatenateLiteral NamedTuple ParamSpec)trigger) get_sentry) CommError UsageError) url_registry) wandb_torch) CustomChart Visualize) MetricRecordPollExitResponseResult RunRecord) Deprecated) wb_logging) FilesDictGlobStr LinkStats PolicyNamelink_or_copy_with_policy unlink_pathvalidate_glob_path)register_post_import_hookunregister_post_import_hook) FilePathStrStrPath)_is_artifact_object_is_artifact_string_is_artifact_version_weave_dict!_is_py_requirements_or_dockerfile_resolve_aliasesadd_import_hookparse_artifact_string) wandb_config wandb_metric wandb_summary) TypeRegistry) InterfaceBase) SummaryRecord) config_util deprecation filenames filesystem interruptipythonmoduleprinterprogress proto_utilredirect telemetry) ExitHooks)HandleAbandonedErrorMailboxClosedError MailboxHandlewait_with_progress) AlertLevel) _WandbSetup) TypedDict)Api)GetSummaryResponseInternalMessagesResponseSampledHistoryResponseArtifact)Backend)InterfaceQueue)Settingsc@s.eZdZUded<ded<ded<ded<dS) GitSourceDictstrremotecommit list[str] entrypoint Sequence[str]argsN__name__ __module__ __qualname____annotations__rfrfG/home/ubuntu/.local/lib/python3.10/site-packages/wandb/sdk/wandb_run.pyrYos  rYc@s&eZdZUded<ded<ded<dS)ArtifactSourceDictrZartifactr]r^r_r`Nrarfrfrfrgrhus  rhc@eZdZUded<ded<dS)ImageSourceDictrZimager_r`Nrarfrfrfrgrkz  rkc@sFeZdZUded<ded<ded<ded<ded<d ed <d ed <d S) JobSourceDictrZ_version source_typez4GitSourceDict | ArtifactSourceDict | ImageSourceDictsourcedict[str, Any] input_types output_types str | Noneruntimedict[str, str]servicesNrarfrfrfrgrn~s  rnF)totalwandb<z[a-zA-Z0-9_-]+$c@seZdZdZdZdS) TeardownStager5N)rbrcrdEARLYLATErfrfrfrgr|sr|c@rj) TeardownHookzCallable[[], None]callr|stageNrarfrfrfrgrrmrc@seZdZUdZded<ded<ded<ded<ded<ded < d3d4ddZd5ddZed6dd Zd7d&d'Z d5d(d)Z d5d*d+Z d5d,d-Z d5d.d/Z d5d0d1Zd2S)8RunStatusCheckerzPeriodically polls the background process for relevant updates. - check if the user has requested a stop. - check the network status. - check the run sync status. threading.Lock_stop_status_lockMailboxHandle[Result] | None_stop_status_handle_network_status_lock_network_status_handle_internal_messages_lock_internal_messages_handle run_idrZ interfacer:settingsrXstop_polling_intervalintretry_polling_interval"internal_messages_polling_intervalreturnNonecCs||_||_||_||_||_||_t|_t |_ d|_ tj |j ddd|_t |_d|_tj |jddd|_t |_d|_tj |jddd|_dS)N ChkStopThrT)targetnamedaemon NetStatThr IntMsgThr)_run_id _interface_stop_polling_interval_retry_polling_interval#_internal_messages_polling_interval _settings threadingEvent _join_eventLockrrThreadcheck_stop_status _stop_threadrrcheck_network_status_network_status_threadrrcheck_internal_messages_internal_messages_thread)selfrrrrrrrfrfrg__init__s8      zRunStatusChecker.__init__cCs"|j|j|jdSN)rstartrrrrfrfrgrs  zRunStatusChecker.startlockhandlecCsF||r|WddSWddS1swYdSr)cancel)rrrfrfrg_abandon_status_checks  "z&RunStatusChecker._abandon_status_check set_handlertimeoutrequestprocessc Cs2d}d}|st}|sz|}Wn tyYdSw|s J||jr1 WddS||Wdn1s?wYz|j|d} WntyVYdSty`d} Ynw| |dWdn1srwY| r|| d}t|} t|| d} |jj | d}|rdSdS)NFrr) time monotonicrJris_setwait_orrI TimeoutErrormaxwait) rrrrrr local_handlejoin_requested time_proberesult time_elapsed wait_timerfrfrg_loop_check_statussD          z#RunStatusChecker._loop_check_statusc d dd}tj7zjjfddjjj|d Wnty1 jj Yn wWddSWddS1sEwYdS) NrrrrcSsZ|jj}|jD]#}|jdks|jdkrt|jqt|jd|jdqdS)Nrz encountered (z), retrying request)responsenetwork_status_responsenetwork_responseshttp_status_coderztermloghttp_response_textrstrip)rnetwork_statushrrfrfrg_process_network_status s zFRunStatusChecker.check_network_status.._process_network_statusc td|S)Nrsetattrxrrfrg z7RunStatusChecker.check_network_status..rrrrrrrrr) r" log_to_runrrrrrdeliver_network_statusBrokenPipeErrorrr)rrrfrrgr s(     "z%RunStatusChecker.check_network_statusc r) NrrrrcSs6ddlm}|jj}|jr|stdSdSdS)Nr)pyagent) wandb.agentsrrstop_status_responserun_should_stop is_runningr@interrupt_main)rr stop_statusrfrfrg_process_stop_status(s z@RunStatusChecker.check_stop_status.._process_stop_statuscr)Nrrrrrfrgr6rz4RunStatusChecker.check_stop_status..rr) r"rrrrrrdeliver_stop_statusrrr)rrrfrrgr's(     "z"RunStatusChecker.check_stop_statusc sd fdd }tj7zjjfddjjj|d Wnty3 jj Yn wWddSWddS1sGwYdS) NrrrrcsDjjr jjs jjrdS|jj}|jjD] }tj |ddqdS)NFrepeat) r show_warningsquietsilentrinternal_messages_responsemessageswarningrztermwarn)rinternal_messagesmsgrrfrg_process_internal_messagesBs zLRunStatusChecker.check_internal_messages.._process_internal_messagescr)NrrrrrfrgrQrz:RunStatusChecker.check_internal_messages..rr) r"rrrrrrdeliver_internal_messagesrrr)rrrfrrgrAs(    "z(RunStatusChecker.check_internal_messagescCs>|j||j|j||j|j||j|jdSr) rsetrrrrrrrrrfrfrgstop\s zRunStatusChecker.stopcCs*||j|j|jdSr)rrjoinrrrrfrfrgrks  zRunStatusChecker.joinN)rrr)rrZrr:rrXrrrrrrrrrr)rrrr) rrrrrrrrrrrr)rbrcrd__doc__rerr staticmethodrrrrrrrrfrfrfrgrs*  *   -   r_P_Tfunc"Callable[Concatenate[Run, _P], _T]rctd fd d }|S) a Decorate a Run method to set the run ID in the logging context. Any logs during the execution of the method go to the run's log file and not to other runs' log files. This is meant for use on all public methods and some callbacks. Private methods can be assumed to be called from some public method somewhere. The general rule is to use it on methods that can be called from a context that isn't specific to this run (such as all user code or internal methods that aren't run-specific). rRunr`_P.argskwargs _P.kwargsrrcs^t|dr |jj}n|j}t||g|Ri|WdS1s(wYdS)Nr)hasattrrr _attach_idr"r)rr`rrrrfrgwrappers   $z_log_to_run..wrapperNrrr`rrrrr functoolswrapsrr rfr rg _log_to_runvs rrZ _is_attachingcr) zDecorate a Run method to auto-attach when in a new process. When in a forked process or using a pickled Run instance, this automatically connects to the service process to "attach" to the existing run. rrr`rrrrrcs|jdu}t|dd}|r5|tkr5tr$tdjddtdjaz tj|dWdandaw|g|Ri|S)N _attach_pidzTrying to attach ``z# while in the middle of attaching `runr) r getattrosgetpidr RuntimeErrorrbrz_attach)rr`ris_using_service attach_pidr rfrgr s    z_attach..wrapperNr r rrfr rgrs rcr) zBDecorate a Run method to raise an error after the run is finished.rrr`rrrrrcs@t|dds|g|Ri|Sd|jdjd}t|)N _is_finishedFzRun (z) is finished. The call to `zE` will be ignored. Please make sure that you are using an active run.)ridrbr)rr`rmessager rfrg wrapper_fns  z&_raise_if_finished..wrapper_fnNr r )rr"rfr rg_raise_if_finisheds r#c@sDeZdZUeddZded<eddZded<eddZded<dS) RunStatusr)defaultrsync_items_totalsync_items_pendingNzdatetime | None sync_time)rbrcrdrr&rer'r(rfrfrfrgr$s r$csL eZdZUdZded<ded<ded<ded<d ed <d ed <d ed<ded<ded<ded<ded<ded<ded<ded<ded<ded<ded<d ed!<d"ed#<d$ed%<d&ed'<d(ed)<ded*<ded+<d,ed-<d.ed/<d.ed0<d1ed2<ded3<ded4<d5ed6<ded7<d8ed9<d:ed;<d > >dddEdFZ > > >dddGdHZddIdJZddMdNZddPdQZ ddRdSZ ddTdUZ dfdZd[ Z dd^d_Z ddadbZddddeZeddgdhZeeeddidjZeeeddkdlZeeeddndoZeeeddqdrZeeeddsdtZejeeddvdtZeeeddwdxZejeeddzdxZeeedd|d}Zejeeddd}ZeeedddZeeedddZdddZeeedddZ eeedddZ!eeedddZ"eeedddZ#eeedddZ$eeedddZ%eeedddZ&eeedddZ'eeedddZ(dddZ)eeedddZ*edddZ+eeedddZ,eeedd>e-e.j/fdddZ0edddZ1eedddZ2edddZ3eeedddZ4eeedddZ5 > > >ddddZ6 > > >ddddZ7dddZ8dddZ9dddÄZ:eeddddɄZ;eedd dd˄Z< >d d ddфZ=ee > > >dd dd؄Z>ed dd܄Z?dddބZ@eedddZAedddZBedddZCedddZD >ddddZEdddZFe > >d dddZGedddZHeedddZIe ddddZJdddZKdddZLdd d ZMdddZNdddZOdddZPdddZQ > >d dddZReee > >d dddZSeee > d d!d&d'ZTd"d*d+ZUee > >d#d$d/d0ZVee > >d d%d3d4ZWe >dd&d5d6ZXeeed'd8d9ZYd(d>d?ZZ >dd)dCdDZ[ddEdFZ\dd&dGdHZ]ddIdJZ^ddKdLZ_ddMdNZ`ddOdPZaddQdRZbddSdTZcddUdVZdd*dXdYZe >dd+d_d`Zf > >d d,dfdgZg >dd-dhdiZhddjdkZiejd.dmdnZkeee > > > > > >d/d0dudvZl > > > > > >d/d0dwdxZmee > y z > Őd1d2ddZnee >dd3ddZoeee >dd4ddZpeee > > >dd5ddZqeee > > > >d6d7ddZreee > > > >d6d8ddZseee > > > >d6d8ddZt > > > > > Őd9d:ddZudd;ddZvdddZw > > >dd<ddZxeee > >d d=ddZyeeed>ddZzeee > >d d?ddZ{eee > >d d@ddZ|dAddZ}dBdǐdȄZ~eeeddɐdʄZeeeedCd̐d̈́ZddΐdτZddАdфZddҐdӄZddԐdՄZej > > > >d6dDdېd܄Zej >ddEdݐdބZejdFdߐdZej > >d dGddZejdHddZejdIddZej >ddJddZZS(KraA unit of computation logged by W&B. Typically, this is an ML experiment. Call [`wandb.init()`](https://docs.wandb.ai/ref/python/init/) to create a new run. `wandb.init()` starts a new run and returns a `wandb.Run` object. Each run is associated with a unique ID (run ID). W&B recommends using a context (`with` statement) manager to automatically finish the run. For distributed training experiments, you can either track each process separately using one run per process or track all processes to a single run. See [Log distributed training experiments](https://docs.wandb.ai/guides/track/log/distributed-training) for more information. You can log data to a run with `wandb.Run.log()`. Anything you log using `wandb.Run.log()` is sent to that run. See [Create an experiment](https://docs.wandb.ai/guides/track/create-an-experiment/) or [`wandb.init`](https://docs.wandb.ai/ref/python/init/) API reference page or more information. There is a another `Run` object in the [`wandb.apis.public`](https://docs.wandb.ai/ref/python/public-api/api/) namespace. Use this object is to interact with runs that have already been created. Attributes: summary: (Summary) A summary of the run, which is a dictionary-like object. For more information, see [Log summary metrics](https://docs.wandb.ai/guides/track/log/log-summary/). Examples: Create a run with `wandb.init()`: ```python import wandb # Start a new run and log some data # Use context manager (`with` statement) to automatically finish the run with wandb.init(entity="entity", project="project") as run: run.log({"accuracy": acc, "loss": loss}) ``` telemetry.TelemetryRecord_telemetry_objbool_telemetry_obj_active_telemetry_obj_dirtybytes_telemetry_obj_flushedlist[TeardownHook]_teardown_hookszBackend | None_backendzInterfaceQueue | None_internal_run_interfacez_WandbSetup | None_wlzredirect.RedirectBase | None _out_redir _err_redirz!Callable[[str, str], None] | None _redirect_cb_redirect_raw_cbzfilesystem.CRDedupedFile | None_output_writer_atexit_cleanup_calledzExitHooks | None_hooks int | None _exit_codezRunStatusChecker | None_run_status_checkerSampledHistoryResponse | None_sampled_historyGetSummaryResponse | None_final_summaryr_poll_exit_handlePollExitResponse | None_poll_exit_responseInternalMessagesResponse | None_internal_messages_response_stdout_slave_fd_stderr_slave_fdr]_artifact_slotsr _init_pidrrur  _is_attachedrrXr_forkeddict[str, Any] | None_launch_artifactsprinter.Printer_printerzwandb_summary.SummarysummaryNrconfig sweep_config launch_configrrcCs6t|_d|_|jr||_dS|j||||ddS)N)rrSrTrU)rrrKr _noopr_init)rrrSrTrUrfrfrgr9s  z Run.__init__c Cs"||_t|_|j|j|j|j|j|jd}|j |t it |j |_|j|jd|_d|_d|_t|_t||_d|_d|_d|_d|_d|_d|_g|_d|_ d|_!d|_"d|_#d|_$d|_%d|_&i|_'d|_(d|_)d|_*d|_+d|_,d|_-t./|_0d|_1d|_2d|_3d|_4t5j6t |jddi|_7i|_8|pt }|jj |ddd|r|jj9|d dd |r|jj9|d dd t:j;<}|r||j|d <t:j;=}|r||j|d <t:j;>}|r||j|d<d|_?d|_@d|_AtBC|_Dd|_E|jjF|_?dS)N_wandbrFuser)tagsprocess_contextTallow_val_change ignore_lockedsweep)rZ_allow_val_changelaunchlaunch_queue_namelaunch_queue_entitylaunch_trace_id)Grr6Config_config _set_callback_config_callback_set_artifact_callback_config_artifact_callback _set_settings_updatedictr8Summary%_summary_get_current_summary_callbackrR_set_update_callback_summary_update_callback_step_starting_step_start_runtimer _start_timerC new_printerrQ_torch_historyr2r3r4_cached_public_apir;r1r9r5r6rHrIr= _exit_result_used_artifact_slotsr>r@rBrErGrCrGTelemetryRecordr*r,r/r-r:rconfigure_scope_launch_artifact_mapping&_unique_launch_artifact_sequence_names merge_lockedrzenvget_launch_queue_nameget_launch_queue_entityget_launch_trace_idr rLrrrrrMr) rrrSrTrU wandb_keyrcrdrerfrfrgrWPs         z Run._initc Cs|jjr1tjddur1z ttjdd}Wnttfy)t dYdSw| |dS|jjr|jj rtj |jj r||jj t|jj }t|}Wdn1s`wY|diddur|dd}| |dSdSdSdSdS)NWANDB_ARTIFACTSz{}z3Malformed WANDB_ARTIFACTS, using original artifacts overrides artifacts)rrbrenvirongetjsonloads ValueError SyntaxErrorrzr _initialize_launch_artifact_mapslaunch_config_pathpathexistssaveopenread)rrfprUrfrfrg!_handle_launch_artifact_overridess0  z%Run._handle_launch_artifact_overridesrrrcCsl|D]/\}}||j|<|d}t|dkr3|ddd}|j|r.|j|q||j|<qdS)N:r}r/)itemsr~splitlenrrpop)rrkeyitemartifact_sequence_tuple_or_slot sequence_namerfrfrgrs     z$Run._initialize_launch_artifact_maps telem_objcCs2t|dr|jr dS|j|d|_|dS)Nr*T)rrr* MergeFromr-_telemetry_flush)rrrfrfrg_telemetry_callbacks   zRun._telemetry_callbackcCspt|dsdS|js dS|jsdS|jr4|jjr6|j}||jkr$dS|jj|j||_d|_dSdSdS)Nr*F) rr,r-r2rr*SerializeToStringr/_publish_telemetry)r serializedrfrfrgrs    zRun._telemetry_flushcCs d|_dS)NT)_frozenrrfrfrg_freeze z Run._freezeattrrZvalueobjectcs8t|ddrt||std|dt||dS)Nrz Attribute z is not supported on Run object.)rr Exceptionsuper __setattr__)rrr __class__rfrgrszRun.__setattr__memodict[int, Any]cC|Srrf)rrrfrfrg __deepcopy__zRun.__deepcopy__rcCs*|jsdS|j}|s dSt||j|jdS)z$Return run state as a custom pickle.N)r rKr)rr rnrKr)rr rfrfrg __getstate__ szRun.__getstate__statecCsB|sdS|d}|s dS|dtkrtd|j|dS)z#Set run state from a custom pickle.Nr rKz5attach in the same process is not supported currently)rrrr__dict__update)rrr rfrfrg __setstate__s zRun.__setstate__wandb_torch.TorchHistorycCs|jdur t|_|jSr)rxr TorchHistoryrrfrfrg_torch)s  z Run._torchcCs|jjddS)z'A frozen copy of run's Settings object.T)deep)r model_copyrrfrfrgr/sz Run.settingscC|jjS)z| dd dd}t d|d WYd}~dSd}~ww|j rc|j j re|j j |dSdSdS) NrTz Value error,z Value error, r5z [type=rzInvalid tag detected: z Tags not updated.)rGrr set_run_tagstuplerrrrZrrzrr2rr)rr[re error_msgrfrfrgr[zs   cC|jjdusJ|jjS)zIdentifier for this run.N)rrrrfrfrgr zRun.idcCr)zBIdentifier for the sweep associated with the run, if there is one.)rsweep_idrrfrfrgrrz Run.sweep_idcCs&ddd|jj|jj|jjfDS)Nrcss|] }|dur|VqdSrrf).0rrfrfrg sz Run._get_path..)rrentityprojectrrrfrfrg _get_paths z Run._get_pathcCs|S)zPath to the run. Run paths include entity, project, and run ID, in the format `entity/project/run_id`. )rrrfrfrgrrzRun.pathfloatcCr)z4Unix timestamp (in seconds) of when the run started.)rvrrfrfrg start_timerzRun.start_timecCr)zNThe first step of the run. )rtrrfrfrg starting_stepszRun.starting_stepcCr)z-True if the run was resumed, False otherwise.)rresumedrrfrfrgrrz Run.resumedcCr)zCurrent value of the step. This counter is incremented by `wandb.Run.log()`. )rsrrfrfrgsteps zRun.stepcCr)z,True if the run is offline, False otherwise.)r_offlinerrfrfrgofflinerz Run.offlinecCr)z-True if the run is disabled, False otherwise.)rrVrrfrfrgdisabledrz Run.disabledcCr)a+Returns the name of the group associated with this run. Grouping runs together allows related experiments to be organized and visualized collectively in the W&B UI. This is especially useful for scenarios such as distributed training or cross-validation, where multiple runs should be viewed and managed as a unified experiment. In shared mode, where all processes share the same run object, setting a group is usually unnecessary, since there is only one run and no grouping is required. r)r run_grouprrfrfrggroups z Run.groupcCr)aName of the job type associated with the run. View a run's job type in the run's Overview page in the W&B App. You can use this to categorize runs by their job type, such as "training", "evaluation", or "inference". This is useful for organizing and filtering runs in the W&B UI, especially when you have multiple runs with different job types in the same project. For more information, see [Organize runs](https://docs.wandb.ai/guides/runs/#organize-runs). r)r run_job_typerrfrfrgjob_types z Run.job_typecCtjtdddd|jS)zThis method is deprecated and will be removed in a future release. Use `run.project` instead. Name of the W&B project associated with the run. T)run__project_namezpThe project_name method is deprecated and will be removed in a future release. Please use `run.project` instead.rr!)r=warn_and_record_deprecationr!rrrfrfrg project_names zRun.project_namecCr)z0Name of the W&B project associated with the run.N)rrrrfrfrgrrz Run.projectcCr)aThis method is deprecated and will be removed in a future release. Use `run.project_url` instead. URL of the W&B project associated with the run, if there is one. Offline runs do not have a project URL. T)run__get_project_urlzwThe get_project_url method is deprecated and will be removed in a future release. Please use `run.project_url` instead.r)r=rr! project_urlrrfrfrgget_project_url   zRun.get_project_urlcC|jjr tddS|jjS)zzURL of the W&B project associated with the run, if there is one. Offline runs do not have a project URL. URL not available in offline runN)rrrzrrrrfrfrgr2 zRun.project_url.root include_fn2Callable[[str, str], bool] | Callable[[str], bool] exclude_fnArtifact | NonecCs|ddlm}|durK|jjr7d}|jjr|jj}n|jjr-|jjdr)|jj}n|jj}|jj d|}n |jj d|jj }t j d|}||d}d} |durvtj|}t|||D]} d } tj| |} |j| | d qct|jjD]#\} } }|D]}tj| |} tj| |jj} d } |j| | d qq}| st d dS||}|jjd d |jiid d|S)aSave the current state of your code to a W&B Artifact. By default, it walks the current directory and logs all files that end with `.py`. Args: root: The relative (to `os.getcwd()`) or absolute path to recursively find code from. name: (str, optional) The name of our code artifact. By default, we'll name the artifact `source-$PROJECT_ID-$ENTRYPOINT_RELPATH`. There may be scenarios where you want many runs to share the same artifact. Specifying name allows you to achieve that. include_fn: A callable that accepts a file path and (optionally) root path and returns True when it should be included and False otherwise. This defaults to `lambda path, root: path.endswith(".py")`. exclude_fn: A callable that accepts a file path and (optionally) root path and returns `True` when it should be excluded and `False` otherwise. This defaults to a function that excludes all files within `/.wandb/` and `/wandb/` directories. Examples: Basic usage ```python import wandb with wandb.init() as run: run.log_code() ``` Advanced usage ```python import wandb with wandb.init() as run: run.log_code( root="../", include_fn=lambda path: path.endswith(".py") or path.endswith(".ipynb"), exclude_fn=lambda path, root: os.path.relpath(path, root).startswith( "cache/" ), ) ``` Returns: An `Artifact` object if code was logged rInternalArtifactNzfileId=-zsource-codeFTrz_No relevant files were detected in the specified directory. No code will be logged to your run.rX code_path)r^)&wandb.sdk.artifacts._internal_artifactrr_jupyter notebook_namex_jupyter_path startswithx_jupyter_namerrprogram_relpathrzutilmake_artifact_name_saferrabspathr> filtered_dirrelpathadd_filewalk _tmp_code_dirrr _log_artifactrgrr)rrrrrrr name_stringart files_added file_path save_namedirpath_filesfnamerirfrfrglog_code?sP 9      z Run.log_codecCr)a This method is deprecated and will be removed in a future release. Use `run.sweep_url` instead. The URL of the sweep associated with the run, if there is one. Offline runs do not have a sweep URL. T)run__get_sweep_urlzsThe get_sweep_url method is deprecated and will be removed in a future release. Please use `run.sweep_url` instead.r)r=rr! sweep_urlrrfrfrg get_sweep_urlrzRun.get_sweep_urlcCr)zrURL of the sweep associated with the run, if there is one. Offline runs do not have a sweep URL. rN)rrrzrr'rrfrfrgr's z Run.sweep_urlcCr)zThis method is deprecated and will be removed in a future release. Use `run.url` instead. URL of the W&B run, if there is one. Offline runs do not have a URL. T) run__get_urlzgThe get_url method is deprecated and will be removed in a future release. Please use `run.url` instead.r)r=rr!urlrrfrfrgget_urls z Run.get_urlcCr)z]The url for the W&B run, if there is one. Offline runs will not have a url. rN)rrrzrrun_urlrrfrfrgr*rzRun.urlcCr)zThe name of the W&B entity associated with the run. Entity can be a username or the name of a team or organization. r)rrrrfrfrgrs z Run.entityr repo code_versioncCstj|d:}|rt|r||j_|rt|r||j_|r0t|r8||j_WddSWddSWddS1sCwYdS)Nr)rGrRE_LABELmatchlabel code_string repo_stringr.)rr r-r.rrfrfrg_label_internals "zRun._label_internalrcKs|jjrdSd|fd|fd|ffD]\}}|r*t|s*tjd|d|dddq|D] }tjd |d ddq-|j|||d |dS) Nr r-r.zLabel added for 'z' with invalid identifier 'z ' (ignored).Frz Label added for unsupported key z (ignored).)r r-r.)r label_disabler/r0rzrr4r)rr r-r.rkvrfrfrg_labels   z Run._labellinescCs|sdSt|}|s dSi}|dp|d}|r||d<|dp(|d}|r/||d<|dp8|d}|r?||d<|jdi|dS) Nr cr-rversionr7r.rf)rG_parse_label_linesrr4)rr9parsed label_dictr r-code_verrfrfrg_label_probe_liness  zRun._label_probe_linescCs>tjd}|s dSt|dd}|sdS|}||dS)N__main__r)sysmodulesrr splitlinesrA)rmdocdoclinesrfrfrg_label_probe_main(s  zRun._label_probe_mainnotebookc Cstdd}z|}|dgd}|d}t|tr"|}Wnty>}ztd|WYd}~dSd}~ww|rH||dSdS)Nzprobe notebookcellsrrqzUnable to probe notebook: ) loggerinfo probe_ipynbr isinstancerZrrrA)rrJr9datacell0rrfrfrg_label_probe_notebook4s"   zRun._label_probe_notebookFheighthiddencCsl|jjrdStrtrdSzddlm}Wnty't dYdSw|| | ||dS)zDisplay this run in Jupyter.Fr)displayz-.display() only works in jupyter environmentsT) rrrA in_jupyterin_vscode_notebookIPythonrV ImportErrorrzrHTMLto_html)rrTrUrVrfrfrgrVDs  z Run.displaycCsdtrddl}|t|S|jjd}d|d}d}|r'|d7}t}|d|d |d S) zGenerate HTML containing an iframe displaying the current run. If the run is being displayed in a VSCode notebook, the string representation of the run is returned instead. rNz ?jupyter=truezborder:none;width:100%;height:zpx;rz display:none;z )rArXhtmlescaperZrr, toggle_button)rrTrUr]r*styleprefixrfrfrgr\Ws   z Run.to_htmlinclude Any | NoneexcluderwcCsd|jddiS)Nz text/htmlT)rU)r\)rrbrdrfrfrg_repr_mimebundle_nszRun._repr_mimebundle_rtuple[str, ...] | str | NonevalrPdict[str, object] | NonecCsJtd|d|d||jr!|jjr#|jjj|||ddSdSdS)Nz config_cb  )rrgrP)rLrMr2rpublish_config)rrrgrPrfrfrgrisszRun._config_callbackstr | Artifact | dictrUc Csddlm}ddlm}t|r-t|tsJ|}||d|j }|s(J| |St |rlt|t s8Jt |\}}} i} |durOd|i} || }n|}| r]|||j}n|j|d}|sgJ| |St|ru| |Stdt|)NrpublicrTr base_urlr z.Cannot call _config_artifact_callback on type ) wandb.apisrmwandb.sdk.artifacts.artifactrUr0rOrn _public_api_from_idclient use_artifactr/rZr4rP_client _artifactr.rtype) rrrgrmrU public_apiriartifact_stringrnis_idrrfrfrgrks4        zRun._config_artifact_callbackcCs|jd|f|ddS)NrX)rrgri)rrrgrfrfrg_set_config_wandbszRun._set_config_wandbsummary_recordr;cCs^tj|d }d|j_Wdn1swY|jr+|jjr-|jj||dSdSdSr)rGrr set_summaryr2rpublish_summary)rr}rrfrfrgrrs  zRun._summary_update_callbackcCsr|jr tdiS|jr|jjsiS|jj}z |j|jjd}Wn t y.iYSw|j j }t |jS)Nz*Summary data not available in finished runr)rrzrr2rdeliver_get_summaryrrsummary_timeoutrrget_summary_responserEdict_from_proto_listr)rrrrrfrfrgrps    z)Run._summary_get_current_summary_callback metric_recordrcCs(|jr|jjr|jj|dSdSdSr)r2r_publish_metric)rrrfrfrg_metric_callbackszRun._metric_callbackr$cCs8|jr|jjs dStt|dfgd}|jj|dS)a Mark a run file to be uploaded with the run. This is a W&B-internal function: it can be used by other internal wandb code. Args: fname: The path to the file in the run's files directory, relative to the run's files directory. Nnow)r#)r2rrnr$ publish_files)rr$r#rfrfrg _publish_files zRun._publish_file key_prefixc Cst}i}|D]=\}}|r|d|n|}t|tr'|||||<q t|tr6|||||<q t|trF|||}||q |D]}| |qI|S)zPops all charts from a dictionary including nested charts. This function will return a mapping of the charts and a dot-separated key for each chart. Indicating the path to the chart in the data dictionary. r) rrrOraddrrn_pop_all_chartsrr) rrPrkeys_to_removechartsr6r7r nested_chartsrfrfrgrs"           zRun._pop_all_chartscCsv|s|S||}|D]+\}}|||j|jj|jjdt|tr.|j ||jj <q t|t r8|j ||<q |S)a>Process and replace chart objects with their underlying table values. This processes the chart objects passed to `wandb.Run.log()`, replacing their entries in the given dictionary (which is saved to the run's history) and adding them to the run's config. Args: data: Dictionary containing data that may include plot objects Plot objects can be nested in dictionaries, which will be processed recursively. Returns: The processed dictionary with custom charts transformed into tables. rgr) rrset_keyrispec config_value config_keyrOrtable table_keyr)rrPrr6r7rfrfrg_serialize_custom_chartss     zRun._serialize_custom_chartsrr\ bool | NonecCsV|jr|jjs dS|}||}ttjddk}|jjj|||j|||ddS)N tensorboardr) user_steprflush publish_step) r2rcopyrrrzpatchedpublish_partial_historyrs)rrPrr\not_using_tensorboardrfrfrg_partial_history_callbacks  zRun._partial_history_callbackcCs.|jr|jjr|jjj||dddSdSdS)NTnowait)r2rpublish_output)rrrPrfrfrg_console_callback5szRun._console_callbackcCsJt|dd}|tkrdS|jr!|jjr#|jjj||dddSdSdS)NrrTr)rrrr2rpublish_output_raw)rrrP console_pidrfrfrg_console_raw_callback;s  zRun._console_raw_callbackTrlogdirr root_logdircCs:td|||jr|jjr|jj|||dSdSdS)Nztensorboard callback: %s, %s)rLrMr2rpublish_tbdata)rrrrrfrfrg_tensorboard_callbackJszRun._tensorboard_callbacklibraryrNcC ||_dSr)r4)rrrfrfrg _set_libraryRrzRun._set_librarybackendrVcCrr)r2)rrrfrfrg _set_backendUrzRun._set_backendrrWcCrr)r3)rrrfrfrg_set_internal_run_interfaceXrzRun._set_internal_run_interfacehookscCrr)r1)rrrfrfrg_set_teardown_hooks[rzRun._set_teardown_hooksrun_objr cCs|jr |j|_|j|_|jr|jd|_|jr|j|_|jr0t |jj }|j j |ddd|jrMi}|jj D] }t|j||j<q9|rM|j ||jrU|j|j_|jr]|j|j_|jre|j|j_|jrm|j|j_|jru|j|j_|jr}|j|j_|jr|j|j_|jrt|j|j_ |j!r|j!|j_!|j"r|j"|j_"|j#r|j#|j_#|j$r|j$j%r|j$j%|j_&|j$j'r|j$j'|j_(|j)r|j)|_*t+j,dt-|jddS)Ng.ATr]rZ)r\r[).rrtrsrToMicrosecondsrvrvrurSr<dict_no_value_from_proto_listrrgrmrRrr value_jsonrrrrrrrr display_namerrrr[rrrhostrgit remote_urlgit_remote_urlr\ git_commitforkedrMrr}rn)rrc_dict summary_dictorigrfrfrg _set_run_obj^sb               zRun._set_run_objcCshddlm}z||jj|jj|jj|jjdd}|j|j_|j|j_WdSt y3t dYdSw)Nr5)GitRepoF)rr[rr\lazyz:Cannot find valid git repo associated with this directory.) lib.gitlibrrgit_root git_remoterrr last_commitrrzr)rrr-rfrfrg_populate_git_infos   zRun._populate_git_info data_typedict[int | str, str]cCs~|||d}||jdvri|jd|<||jd|vr'|jd||}nd}||kr=||jd||<|jdSdS)aStore a singleton item to wandb config. A singleton in this context is a piece of data that is continually logged with the same value in each history step, but represented as a single item in the config. We do this to avoid filling up history with a lot of repeated unnecessary data Add singleton can be called many times in one run, and it will only be updated when the value changes. The last value logged will be the one persisted to the server. )rwrrrXN)rgpersist)rrrr value_extra old_valuerfrfrg_add_singletons zRun._add_singletoncCst|ts tdtdd|Drtd|||||durJt|jks+|jr2t j dddt t j dd krBt j d dd||j krJ||_ |durR|dusT|r]|j d 7_ dSdS) Nz%wandb.log must be passed a dictionarycss|] }t|t VqdSr)rOrZ)rrrfrfrgrszRun._log..z1Key values passed to `wandb.log` must be strings.zNote that setting step in multiprocessing can result in data loss. Please use `run.define_metric(...)` to define a custom metric to log your step values.FrrrzStep cannot be set when using tensorboard syncing. Please use `run.define_metric(...)` to define a custom metric to log your step values.r5)rOr TypeErroranyrrrrKrLrzrrrrs)rrPrr\rfrfrg_logs*   zRun._logcCs||durtj|d }d|j_Wdn1swY|jjr4|dur4tjdt dddd|j |||d dS) aUpload run data. Use `log` to log data from runs, such as scalars, images, video, histograms, plots, and tables. See [Log objects and media](https://docs.wandb.ai/guides/track/log) for code snippets, best practices, and more. Basic usage: ```python import wandb with wandb.init() as run: run.log({"train-loss": 0.5, "accuracy": 0.9}) ``` The previous code snippet saves the loss and accuracy to the run's history and updates the summary values for these metrics. Visualize logged data in a workspace at [wandb.ai](https://wandb.ai), or locally on a [self-hosted instance](https://docs.wandb.ai/guides/hosting) of the W&B app, or export data to visualize and explore locally, such as in a Jupyter notebook, with the [Public API](https://docs.wandb.ai/guides/track/public-api-guide). Logged values don't have to be scalars. You can log any [W&B supported Data Type](https://docs.wandb.ai/ref/python/data-types/) such as images, audio, video, and more. For example, you can use `wandb.Table` to log structured data. See [Log tables, visualize and query data](https://docs.wandb.ai/guides/models/tables/tables-walkthrough) tutorial for more details. W&B organizes metrics with a forward slash (`/`) in their name into sections named using the text before the final slash. For example, the following results in two sections named "train" and "validate": ```python with wandb.init() as run: # Log metrics in the "train" section. run.log( { "train/accuracy": 0.9, "train/loss": 30, "validate/accuracy": 0.8, "validate/loss": 20, } ) ``` Only one level of nesting is supported; `run.log({"a/b/c": 1})` produces a section named "a". `run.log()` is not intended to be called more than a few times per second. For optimal performance, limit your logging to once every N iterations, or collect data over multiple iterations and log it in a single step. By default, each call to `log` creates a new "step". The step must always increase, and it is not possible to log to a previous step. You can use any metric as the X axis in charts. See [Custom log axes](https://docs.wandb.ai/guides/track/log/customize-logging-axes/) for more details. In many cases, it is better to treat the W&B step like you'd treat a timestamp rather than a training step. ```python with wandb.init() as run: # Example: log an "epoch" metric for use as an X axis. run.log({"epoch": 40, "train-loss": 0.5}) ``` It is possible to use multiple `wandb.Run.log()` invocations to log to the same step with the `step` and `commit` parameters. The following are all equivalent: ```python with wandb.init() as run: # Normal usage: run.log({"train-loss": 0.5, "accuracy": 0.8}) run.log({"train-loss": 0.4, "accuracy": 0.9}) # Implicit step without auto-incrementing: run.log({"train-loss": 0.5}, commit=False) run.log({"accuracy": 0.8}) run.log({"train-loss": 0.4}, commit=False) run.log({"accuracy": 0.9}) # Explicit step: run.log({"train-loss": 0.5}, step=current_step) run.log({"accuracy": 0.8}, step=current_step) current_step += 1 run.log({"train-loss": 0.4}, step=current_step) run.log({"accuracy": 0.9}, step=current_step, commit=True) ``` Args: data: A `dict` with `str` keys and values that are serializable Python objects including: `int`, `float` and `string`; any of the `wandb.data_types`; lists, tuples and NumPy arrays of serializable Python objects; other `dict`s of this structure. step: The step number to log. If `None`, then an implicit auto-incrementing step is used. See the notes in the description. commit: If true, finalize and upload the step. If false, then accumulate data for the step. See the notes in the description. If `step` is `None`, then the default is `commit=True`; otherwise, the default is `commit=False`. Examples: For more and more detailed examples, see [our guides to logging](https://docs.wandb.com/guides/track/log). Basic usage ```python import wandb with wandb.init() as run: run.log({"train-loss": 0.5, "accuracy": 0.9 ``` Incremental logging ```python import wandb with wandb.init() as run: run.log({"loss": 0.2}, commit=False) # Somewhere else when I'm ready to report this step: run.log({"accuracy": 0.8}) ``` Histogram ```python import numpy as np import wandb # sample gradients at random from normal distribution gradients = np.random.randn(100, 100) with wandb.init() as run: run.log({"gradients": wandb.Histogram(gradients)}) ``` Image from NumPy ```python import numpy as np import wandb with wandb.init() as run: examples = [] for i in range(3): pixels = np.random.randint(low=0, high=256, size=(100, 100, 3)) image = wandb.Image(pixels, caption=f"random field {i}") examples.append(image) run.log({"examples": examples}) ``` Image from PIL ```python import numpy as np from PIL import Image as PILImage import wandb with wandb.init() as run: examples = [] for i in range(3): pixels = np.random.randint( low=0, high=256, size=(100, 100, 3), dtype=np.uint8, ) pil_image = PILImage.fromarray(pixels, mode="RGB") image = wandb.Image(pil_image, caption=f"random field {i}") examples.append(image) run.log({"examples": examples}) ``` Video from NumPy ```python import numpy as np import wandb with wandb.init() as run: # axes are (time, channel, height, width) frames = np.random.randint( low=0, high=256, size=(10, 3, 100, 100), dtype=np.uint8, ) run.log({"video": wandb.Video(frames, fps=4)}) ``` Matplotlib plot ```python from matplotlib import pyplot as plt import numpy as np import wandb with wandb.init() as run: fig, ax = plt.subplots() x = np.linspace(0, 10) y = x * x ax.plot(x, y) # plot y = x^2 run.log({"chart": fig}) ``` PR Curve ```python import wandb with wandb.init() as run: run.log({"pr": wandb.plot.pr_curve(y_test, y_probas, labels)}) ``` 3D Object ```python import wandb with wandb.init() as run: run.log( { "generated_samples": [ wandb.Object3D(open("sample.obj")), wandb.Object3D(open("sample.gltf")), wandb.Object3D(open("sample.glb")), ] } ) ``` Raises: wandb.Error: If called before `wandb.init()`. ValueError: If invalid data is passed. NrTztIn shared mode, the use of `wandb.log` with the step argument is not supported and will be ignored. Please refer to z define-metricz! on how to customize your x-axis.Fr)rPrr\) rGrr set_step_logr_sharedrzrrr*r)rrPrr\rrfrfrglogs} zRun.logliveglob_strstr | os.PathLike base_pathstr | os.PathLike | Nonepolicyr&bool | list[str]cCst|tr |d}t|tr|drt|dgSt|}tt j |}|dur6t |}n| s@t d}n tjddd|jj}|d vrStd tt j |}||||S) a{Sync one or more files to W&B. Relative paths are relative to the current working directory. A Unix glob, such as "myfiles/*", is expanded at the time `save` is called regardless of the `policy`. In particular, new files are not picked up automatically. A `base_path` may be provided to control the directory structure of uploaded files. It should be a prefix of `glob_str`, and the directory structure beneath it is preserved. When given an absolute path or glob and no `base_path`, one directory level is preserved as in the example above. Files are automatically deduplicated: calling `save()` multiple times on the same file without modifications will not re-upload it. Args: glob_str: A relative or absolute path or Unix glob. base_path: A path to use to infer a directory structure; see examples. policy: One of `live`, `now`, or `end`. - live: upload the file as it changes, overwriting the previous version - now: upload the file once now - end: upload file when the run ends Returns: Paths to the symlinks created for the matched files. For historical reasons, this may return a boolean in legacy code. ```python import wandb run = wandb.init() run.save("these/are/myfiles/*") # => Saves files in a "these/are/myfiles/" folder in the run. run.save("these/are/myfiles/*", base_path="these") # => Saves files in an "are/myfiles/" folder in the run. run.save("/Users/username/Documents/run123/*.txt") # => Saves files in a "run123/" folder in the run. See note below. run.save("/Users/username/Documents/run123/*.txt", base_path="/Users") # => Saves files in a "username/Documents/run123/" folder in the run. run.save("files/*/saveme.txt") # => Saves each "saveme.txt" file in an appropriate subdirectory # of "files/". # Explicitly finish the run since a context manager is not used. run.finish() ``` zutf-8)zgs://zs3://z0 is a cloud storage url, can't save file to W&B.NrzSaving files without folders. If you want to preserve subdirectories pass base_path to wandb.save, i.e. wandb.save("/mnt/folder/file.h5", base_path="/mnt")Fr)rendrz>Only "live", "end" and "now" policies are currently supported.)rOr.decoderZrrzrpathlibPurePathrrrPath is_absoluterparentr_save)rrrr glob_pathresolved_glob_pathresolved_base_pathrfrfrgrs4 A    zRun.saverpathlib.PurePathc s t||||}tt|}tj|d }d|j_Wdn1s%wYt |j j t |}ddtt tt||D}t} g} t } |D]o} tj | jt|jd} | }| |tt'|r| |r| tt||f WdqTWdn1swY|jjdddt|t|j | ||| }| tt||fqTt|D]}|| vr| tt||fq| d| i}|jr|jjr|jj |fdd | D}d dt|DS) aMaterialize matched files into the run's files/ dir for syncing. Strategy: 1) If settings.symlink is True, try symlink. 2) Else (or if symlink fails), try hardlink (same-volume files). 3) Else copy and, if requested policy == "live", downgrade those files to "now". Args: glob_path: Absolute path glob pattern for files to save. base_path: Base path to determine relative directory structure. policy: Upload policy - "live", "now", or "end". Returns: List of absolute paths to files in the wandb run directory. Raises: ValueError: If glob_path is invalid relative to base_path. rTNcSsg|] }t|qSrf)rrabsoluterprfrfrg s zRun._save..)parentsexist_okr#csh|] \}}t|qSrf)rr)rg_pol files_rootrfrg szRun._save..cSsg|]}t|qSrf)rZrrfrfrgr)!r) relative_tor$rZrGrrrrrrrrglobsortedr%partsrr contextlibsuppressOSErrorrsamefileappendrmkdirr(r' emit_warningsr2rr)rrrr relative_globrelative_glob_strr preexisting src_pathsstatspublish_entriescreated_targetssrcreldsteffective_policyr files_dict abs_targetsrfrrgras^        z Run._saverun_pathreplace None | TextIOcCst||p|||p |jjSr)restorerrr)rrrrrrfrfrgrs    z Run.restore exit_codercCs(|durtjtddd|d||S)aYFinish a run and upload any remaining data. Marks the completion of a W&B run and ensures all data is synced to the server. The run's final state is determined by its exit conditions and sync status. Run States: - Running: Active run that is logging data and/or sending heartbeats. - Crashed: Run that stopped sending heartbeats unexpectedly. - Finished: Run completed successfully (`exit_code=0`) with all data synced. - Failed: Run completed with errors (`exit_code!=0`). - Killed: Run was forcibly stopped before it could finish. Args: exit_code: Integer indicating the run's exit status. Use 0 for success, any other value marks the run as failed. quiet: Deprecated. Configure logging verbosity using `wandb.Settings(quiet=...)`. NT)run__finish_quietzpThe `quiet` argument to `wandb.run.finish()` is deprecated, use `wandb.Settings(quiet=...)` to set this instead.rr!r)r=rr!_finish)rrrrfrfrgfinishs z Run.finishcCs$|jrdS|js Jtd|tj|d }d|j_Wdn1s)wY|j D] }|j t j kr=| q1d|_|j|z;|j|d|j D] }|j t jkr]| qQg|_ |jjrr|j}|j|jjdWtj|ur|ttdStj|urttw)Nzfinishing run rTr)r)rr4rLrMrrGrrrr1rr|r~rremove_active_run_atexit_cleanuprrrassert_service inform_finishrzrrB unset_globalsr end_session)rrrhookservicerfrfrgrs<            z Run._finishr$cCsl|jr|jjs tS|jj}|jdd}|jj}d}|jjr-t |jj|jj d}t|j |j |dS)zMGet sync info from the internal backend, about the current run's sync status.NrgeA)r&r'r()r2rr$deliver_request_run_statusrrrun_status_responser(secondsr fromtimestampnanosr&r')rhandle_run_statusr sync_datar(rfrfrgstatus s  z Run.status visualize_key panel_type panel_configrncCs"||d}|j|dd|fddS)N)r)r*rX visualizerr{)rr(r)r*rSrfrfrg _add_panel1 szRun._add_panelstdout_slave_fdstderr_slave_fdconsolec s|durjj}|dkrd}td||dvr.tjjjtj }j s.t t |d_ |dkrqtdtjdfd d j jgjjd kd }tjd fdd j jgjjd kd }tjdkrpd!fdd }td|n^|dkrtdtjdfdd j jgjjd kd }tjd fdd j jgjjd kd }n,|dkrtdtjdfdd gd}tjd fdd gd}n |dkrdStdz|||_|_tdWdSty}ztd|td WYd}~dSd}~ww)"Nwrapwrap_rawz redirect: %s>rFwrap_emuwbrFzRedirecting console.stdoutc d|SNr4rrPrrfrgrZ rzRun._redirect..online)rcbsflush_periodicallystderrcr5Nr<r7r8rrfrgrb rntrrcsBjrjjrjd}t|jdddddS)NzTensorflow detected. Stream redirection is not supported on Windows when tensorflow is imported. Falling back to wrapping stdout/err.r0)r/)r5 uninstallr6rzr _redirect)rrrfrg wrap_fallbacki s   z$Run._redirect..wrap_fallback tensorflowr2zWrapping output streams.cr5r6r7r8rrfrgr| rcr5r=r7r8rrfrgr rcr5r6rr8rrfrgr r)rr:cr5r=rCr8rrfrgr roffzunhandled consolezRedirects installed.zFailed to redirect: zFailed to redirect.r)rr/rLrMrrrrr> OUTPUT_FNAMEr9r? CRDedupedFilerrFRedirectwritemoderr3 StreamWrapperStreamRawWrapperrinstallr5r6rrzr exception) rr-r.r/output_log_path out_redir err_redirrArrfrrgr@: s                  z Run._redirectcCs8td|jr |j|jr|jtddS)Nrz restore done)rLrMr5r?r6rrfrfrg_restore s   z Run._restorecCs|jdur tddS|jrdSd|_|p|jr|jjpd}||_td||dkr=tj |j j r=t |j j z|Wn'tyUtjsTtdtyj|tdtdwtj|j|j|j|j|j |jddS)Nz)process exited without backend configuredTrzgot exitcode: z-Control-C detected -- Run data was not syncedzProblem finishing runsampled_history final_summarypoll_exit_responserrrC)r2rLrr:r;rr=rMrrrr resume_fnameremove _on_finishKeyboardInterruptrz wandb_agent _is_running termerrorr _console_stoprMr_footerr@rBrErGrQ)rrrfrfrgr s>          zRun._atexit_cleanupcCs&tdt|_||j|jdS)Nz atexit reg)rLrMrHr;r@rHrIrrfrfrg_console_start s zRun._console_startcCs&||jr|jd|_dSdSr)rQr9closerrfrfrgr] s   zRun._console_stopcCs||jjr|jjdur||jj|jjr3|jr3|jjr3ddlm }t d|jj ||jrV|jjrV|jj sV|jjsDJt|jj|jj|jd|_|j||dS)Nr working_setzBSaving list of pip packages installed into the current environment)rr)_headerr save_codecode_dirr%x_save_requirementsr2r wandb.utilrbrLdebugpublish_python_packagesrrrr>rr_ _on_ready)rrbrfrfrg _on_start s0    z Run._on_startcCsFtj|d }d|j_Wdn1swYd|_|dS)z4Event triggered when run is attached to another run.rTN)rGrrattachrLrj)rrrfrfrg _on_attach s   zRun._on_attachcCsHd dd}t}t||}|jjsdS|D] }t||jj|qdS) NrrrBrrrc Ssztj|d-}zt|dd}|durt|j|dWnty*YWddSwWddS1s6wYdS)NrrbT)rGrrrimports_finishAttributeError)rrBrrrfrfrg_telemetry_import_hook s  "zDRun._register_telemetry_import_hooks.._telemetry_import_hook)rrrBrrr)rGlist_telemetry_importsrpartialrrr*)rrpimport_telemetry_setimport_hook_fn module_namerfrfrg _register_telemetry_import_hooks s  z$Run._register_telemetry_import_hookscCs|jsJ|j||d|_|z|Wnty*tdYnw| |j j sDt j |j jrFt |j jdSdSdS)z/Event triggered when run is ready for the user.Tz"Problem applying launch job inputsN)r4add_active_runrvr,r_detect_and_apply_job_inputsrrLrMrrresumerrrrVrWrrfrfrgrj' s    z Run._on_readycCsddlm}||dS)z.) rgrbrr9type_ofrSas_dictto_jsonrR_as_dict)rrbinstalled_packages_listrsrtrfrfrg_make_job_source_reqsC s  zRun._make_job_source_reqs source_dictrnr patch_pathos.PathLike | Nonec Csddlm}ddlm}|||j}|r"tj|r"|t |d| d}| d |Wdn1s:wY| d}| t |Wd|S1sXwY|S)Nrr) job_builderz diff.patchzrequirements.frozen.txt zwandb-job.json)r rwandb.sdk.internalrJOB_ARTIFACT_TYPErrrrr,new_filerHrrdumps) rrrrrrr job_artifactfrfrfrg_construct_job_artifactL s      zRun._construct_job_artifactrsrtdocker_image_namer`list[str] | Nonec Csj|ptd}|s dStjd|}|dur|n|jj}dd||d|||jjd}||||} | S)N WANDB_DOCKERzjob-v0rl)rlr`)rorprqrsrtrv) rgetenvrzrrr_args_pythonr) rrsrtrrr`rs_args source_inforrfrfrg_create_image_job` s zRun._create_image_jobcCsL|\}}}|j|||||d}|sJ||}|s$td||S)N)r`rzJob Artifact log unsuccessful: )rr log_artifactrzError)rrr`packagesin_types out_typesrrirfrfrg_log_job_artifact_with_image} s z Run._log_job_artifact_with_imagec Csrtd|jdur|j||jr|jjsJ|jjr)|jj |j }n|jj }t j |jdd}t|dtt j||jjdWdn1sQwY|jj}|jdd}|jj|_|jj}|jdd}|jj|_|jj}|jj}|jdd}|jj|_|jdd}|jj|_ |jr|j!|jr|j"|jj#r|$|jj#dSdS)N on_finishedzFinishing up...) default_text)rdisplay_progressr)%rrr>rr]r2rrx_update_finish_state deliver_exitr=deliver_finish_without_exitrDprogress_printerrQrLrrrloop_printing_operation_statsdeliver_poll_exitrrrUrErrrGrdeliver_request_sampled_historysampled_history_responser@rrBcleanuprr"_unregister_telemetry_import_hooks)r exit_handlerpoll_exit_handlerinternal_messages_handlefinal_summary_handlesampled_history_handlerfrfrgrX sV                  zRun._on_finishrcCs t}|D]}t||qdSr)rGrqr+)rrsrurfrfrgr s z&Run._unregister_telemetry_import_hooks step_metric str | wandb_metric.Metric | None step_syncgoal overwritewandb_metric.Metricc Csb|rd|vrtjtddd|d|rd|vs|dur&tjtddd |d||||||||S) anCustomize metrics logged with `wandb.Run.log()`. Args: name: The name of the metric to customize. step_metric: The name of another metric to serve as the X-axis for this metric in automatically generated charts. step_sync: Automatically insert the last value of step_metric into `wandb.Run.log()` if it is not provided explicitly. Defaults to True if step_metric is specified. hidden: Hide this metric from automatic plots. summary: Specify aggregate metrics added to summary. Supported aggregations include "min", "max", "mean", "last", "first", "best", "copy" and "none". "none" prevents a summary from being generated. "best" is used together with the goal parameter, "best" is deprecated and should not be used, use "min" or "max" instead. "copy" is deprecated and should not be used. goal: Specify how to interpret the "best" summary type. Supported options are "minimize" and "maximize". "goal" is deprecated and should not be used, use "min" or "max" instead. overwrite: If false, then this call is merged with previous `define_metric` calls for the same metric by using their values for any unspecified parameters. If true, then unspecified parameters overwrite values specified by previous calls. Returns: An object that represents this call but can otherwise be discarded. rT)run__define_metric_copyz@define_metric(summary='copy') is deprecated and will be removed.rbestN)run__define_metric_best_goalzdefine_metric(summary='best', goal=...) is deprecated and will be removed. Use define_metric(summary='min') or define_metric(summary='max') instead.)r=rr!_define_metric)rrrrrUrRrrrfrfrg define_metric s* *zRun.define_metricc Cs|stdt|tjr|j}d|tfd|tfd|tfd|tfd|tfd|tfd|tffD]\}} } | durLt| | sLt| j } td |d | q.| d rX|dd n|} d | vrftd |d} |rdd| dD}g} hd}|D]}||vrtd|| |q|t j|d }d|j_Wdn1swYd}|dur|dd}ddh}||vrtd|t j|d }d|j_Wdn1swY|rt j|d }d|j_Wdn1swY|rt j|d }d|j_Wdn 1swYt j|d }d|j_Wdn 1s2wYtj|||| |||d}||j||S)Nz0define_metric() requires non-empty name argumentrrrrUrRrrzUnhandled define_metric() arg: z type: *rz:Unhandled define_metric() arg: name (glob suffixes only): cSsg|]}|qSrf)lower)rsrfrfrgr: rz&Run._define_metric..,>rminrrlastmeannonefirstz+Unhandled define_metric() arg: summary op: rTrrz%Unhandled define_metric() arg: goal: )rrrrRrUrr)rzrrOr7MetricrrZr+rwrbendswithrrrGrrmetric_summaryr metric_goal metric_hiddenmetric_step_syncmetricrhr_commit)rrrrrUrRrrarg_namearg_valexp_typearg_typestripped summary_ops summary_itemsvalidir goal_cleaned valid_goalrFrfrfrgr s          zRun._define_metric gradientsmodels+torch.nn.Module | Sequence[torch.nn.Module] criteriontorch.F | Noner0Literal['gradients', 'parameters', 'all'] | Nonelog_freqidx log_graphc Cstj|||||||dS)aHook into given PyTorch model to monitor gradients and the model's computational graph. This function can track parameters, gradients, or both during training. Args: models: A single model or a sequence of models to be monitored. criterion: The loss function being optimized (optional). log: Specifies whether to log "gradients", "parameters", or "all". Set to None to disable logging. (default="gradients"). log_freq: Frequency (in batches) to log gradients and parameters. (default=1000) idx: Index used when tracking multiple models with `wandb.watch`. (default=None) log_graph: Whether to log the model's computational graph. (default=False) Raises: ValueError: If `wandb.init()` has not been called or if any of the models are not instances of `torch.nn.Module`. N)rzsdk_watch)rrrrrrrrfrfrgwatchd sz Run.watch2torch.nn.Module | Sequence[torch.nn.Module] | NonecCstjj||ddS)zRemove pytorch model topology, gradient and parameter hooks. Args: models: Optional list of pytorch models that have had watch called on them. )rN)rzr_unwatch)rrrfrfrgunwatch s z Run.unwatchri target_pathaliasescCsfddlm}|r|s||}|jjrt||}| s+|j |j |j d}| ||S)uLink the artifact to a collection. The term “link” refers to pointers that connect where W&B stores the artifact and where the artifact is accessible in the registry. W&B does not duplicate artifacts when you link an artifact to a collection. View linked artifacts in the Registry UI for the specified collection. Args: artifact: The artifact object to link to the collection. target_path: The path of the collection. Path consists of the prefix "wandb-registry-" along with the registry name and the collection name `wandb-registry-{REGISTRY_NAME}/{COLLECTION_NAME}`. aliases: Add one or more aliases to the linked artifact. The "latest" alias is automatically applied to the most recent artifact you link. Returns: The linked artifact. r5) ArtifactPath)rar)artifacts._validatorsris_draft_is_draft_save_startedrrrNotImplementedErrorfrom_stris_registry_path with_defaultsrrlinkto_str)rrirrrrrfrfrg link_artifact s   zRun.link_artifactartifact_or_namestr | Artifactrwuse_asc Csddlm}ddlm}|jjrtd|j|jj|jj dd}| |jj |dur6t j tdd d d t|trr|}|} | j||d } |dur`|| jkr`td |d| jd| j|j| j|jj|jj | j| j dnJ|} |dur{g}nt|tr|g}t||r| r|durtd|j| |ddd| nt| |r| s|j| j| j| j dntd|jr|jjr|jj| | S)a(Declare an artifact as an input to a run. Call `download` or `file` on the returned object to get the contents locally. Args: artifact_or_name: The name of the artifact to use. May be prefixed with the name of the project the artifact was logged to ("entity" or "entity/project"). If no entity is specified in the name, the Run or API setting's entity is used. Valid names can be in the following forms - name:version - name:alias type: The type of artifact to use. aliases: Aliases to apply to this artifact use_as: This argument is deprecated and does nothing. Returns: An `Artifact` object. Examples: ```python import wandb run = wandb.init(project="") # Use an artifact by name and alias artifact_a = run.use_artifact(artifact_or_name=":") # Use an artifact by name and version artifact_b = run.use_artifact(artifact_or_name=":v") # Use an artifact by entity/project/name:alias artifact_c = run.use_artifact( artifact_or_name="//:" ) # Use an artifact by entity/project/name:version artifact_d = run.use_artifact( artifact_or_name="//:v" ) # Explicitly finish the run since a context manager is not used. run.finish() ``` r)internalrTz)Cannot use artifact when in offline mode.)rr)default_settingsNT)run__use_artifact_use_aszW`use_as` argument is deprecated and does not affect the behaviour of `run.use_artifact`r)rwrzSupplied type z does not match type z of artifact ) entity_namerartifact_entity_nameartifact_project_namez>Indicating use_as is not supported when using a draft artifact)ris_user_createduse_after_commit)rrzYou must pass an artifact name (e.g. "pedestrian-dataset:v1"), an instance of `wandb.Artifact`, or `wandb.Api().artifact()` to `use_artifact`) rorrprUrrrrPrrset_current_run_idrr=rr!rOrZrqrvrwrrrtr rrzrrrr2rpublish_use_artifact) rrrwrrrrUapirrxrirfrfrgrt sv 8    zRun.use_artifactartifact_or_pathArtifact | StrPathcCs|j|||||dS)aEDeclare an artifact as an output of a run. Args: artifact_or_path: (str or Artifact) A path to the contents of this artifact, can be in the following forms: - `/local/directory` - `/local/directory/file.txt` - `s3://bucket/path` You can also pass an Artifact object created by calling `wandb.Artifact`. name: (str, optional) An artifact name. Valid names can be in the following forms: - name:version - name:alias - digest This will default to the basename of the path prepended with the current run id if not specified. type: (str) The type of artifact to log, examples include `dataset`, `model` aliases: (list, optional) Aliases to apply to this artifact, defaults to `["latest"]` tags: (list, optional) Tags to apply to this artifact, if any. Returns: An `Artifact` object. )rrwrr[r)rrrrwrr[rfrfrgr@ s#zRun.log_artifactArtifact | strdistributed_idcCF|jjdur|durtd|dur|jjpd}|j|||||ddS)aDeclare (or append to) a non-finalized artifact as output of a run. Note that you must call run.finish_artifact() to finalize the artifact. This is useful when distributed jobs need to all contribute to the same artifact. Args: artifact_or_path: A path to the contents of this artifact, can be in the following forms: - `/local/directory` - `/local/directory/file.txt` - `s3://bucket/path` name: An artifact name. May be prefixed with "entity/project". Defaults to the basename of the path prepended with the current run ID if not specified. Valid names can be in the following forms: - name:version - name:alias - digest type: The type of artifact to log. Common examples include `dataset`, `model`. aliases: Aliases to apply to this artifact, defaults to `["latest"]`. distributed_id: Unique string that all distributed jobs share. If None, defaults to the run's group name. Returns: An `Artifact` object. NzMCannot upsert artifact unless run is in a group or distributed_id is providedrF)rrwrr finalizerrrrrrrrwrr rfrfrgupsert_artifactk s$ zRun.upsert_artifactcCr )aFinishes a non-finalized artifact as output of a run. Subsequent "upserts" with the same distributed ID will result in a new version. Args: artifact_or_path: A path to the contents of this artifact, can be in the following forms: - `/local/directory` - `/local/directory/file.txt` - `s3://bucket/path` You can also pass an Artifact object created by calling `wandb.Artifact`. name: An artifact name. May be prefixed with entity/project. Valid names can be in the following forms: - name:version - name:alias - digest This will default to the basename of the path prepended with the current run id if not specified. type: The type of artifact to log, examples include `dataset`, `model` aliases: Aliases to apply to this artifact, defaults to `["latest"]` distributed_id: Unique string that all distributed jobs share. If None, defaults to the run's group name. Returns: An `Artifact` object. NzMCannot finish artifact unless run is in a group or distributed_id is providedrT)r r r rrfrfrgfinish_artifact s' zRun.finish_artifactr rrc  Csddlm} m} |s|durtd|dur| |}|dur"| |}|||||\} }i| j| _|| _|| |jrp|jj rp|j j s`|jj j || |||j ||| d} | | |j| S|jj j|| ||||| d| S|jr|jj|| ||||| d| S)Nr5)validate_aliases validate_tagsz7Must provide distributed_id if artifact is not finalize)r rr)rrrr_prepare_artifactmetadatar _assert_can_log_artifactr2rrrdeliver_artifactr_set_save_handlerqrspublish_artifactr3)rrrrwrr[r r rrrrrirrfrfrgr s`     zRun._log_artifactrdict[str, str] | None PublicApicCsv|jdur|jSddlm}d|jji}|jjs.|jjpd|d<|jjp%d|d<|jj|d<|j ||jj d|_|jS) Nrrlrrrrrn)api_key) ryrormrrrrrrnrPr)rrrmrfrfrgrq s    zRun._public_apicCsddl}ddlm}|jjrdSz|}|jd}|jd}||||j|j }Wn |j j y6YdSw|durP|j |krPt d|jd|d|j d|rj|jrj||jkrjt d|jd |jd |d|r|jr||jkrt d|jd |jd |ddSdSdS) NrrTrrz Artifact z already exists with type 'z$'; cannot create another with type ''z is owned by entity 'z'; it can't be moved to 'z exists in project ')requestsrprUrrrqr_expected_typerrs exceptionsRequestExceptionrwr_source_entity_source_project)rrirrUrxrr expected_typerfrfrgr) sJ       zRun._assert_can_log_artifacttuple[Artifact, list[str]]cCsddlm}t|ttjfrS|pd|jjdtj |}|||p#d}tj |r3| t|n"tj |rA| t|ndt|vrO|t|ntd|}t||s^td||t|fS) NrrTzrun-r unspecifiedz://zIpath must be a file, directory or externalreference like s3://bucket/pathzPYou must pass an instance of wandb.Artifact or a valid file path to log_artifact)rprUrOrZrPathLikerrrbasenameisfilerisdiradd_dir add_referencerrr r2)rrrrwrrUrirfrfrgrL s,      zRun._prepare_artifactrr-cCs|j||d|ddS)aLogs a model artifact containing the contents inside the 'path' to a run and marks it as an output to this run. The name of model artifact can only contain alphanumeric characters, underscores, and hyphens. Args: path: (str) A path to the contents of this model, can be in the following forms: - `/local/directory` - `/local/directory/file.txt` - `s3://bucket/path` name: A name to assign to the model artifact that the file contents will be added to. This will default to the basename of the path prepended with the current run id if not specified. aliases: Aliases to apply to the created model artifact, defaults to `["latest"]` Raises: ValueError: If name has invalid special characters. Returns: None model)rrrwrNr)rrrrrfrfrg log_modelq s! z Run.log_modelr,cCsn|jjrtd|j|d}dt|jvrtd|}t |}t |dkr5t t j ||dS|S)a`Download the files logged in a model artifact 'name'. Args: name: A model artifact name. 'name' must match the name of an existing logged model artifact. May be prefixed with `entity/project/`. Valid names can be in the following forms - model_artifact_name:version - model_artifact_name:alias Returns: path (str): Path to downloaded model artifact file(s). Raises: AssertionError: If model artifact 'name' is of a type that does not contain the substring 'model'. z*`use_model` not supported in offline mode.)rr,You can only use this method for 'model' artifacts. For an artifact to be a 'model' artifact, its type property must contain the substring 'model'.r5r)rrrrtrZrwrAssertionErrordownloadrlistdirrr,rr)rrrirdir_listrfrfrg use_model s   z Run.use_modelregistered_model_namec Cs|d}t|dkrtdd}|jd|d|}|}z!|j|dd} dt| jvr7td|j ||| jd } Wnt t fyT|j ||dd } Ynw|j | ||d S) aLog a model artifact version and link it to a registered model in the model registry. Linked model versions are visible in the UI for the specified registered model. This method will: - Check if 'name' model artifact has been logged. If so, use the artifact version that matches the files located at 'path' or log a new version. Otherwise log files under 'path' as a new model artifact, 'name' of type 'model'. - Check if registered model with name 'registered_model_name' exists in the 'model-registry' project. If not, create a new registered model with name 'registered_model_name'. - Link version of model artifact 'name' to registered model, 'registered_model_name'. - Attach aliases from 'aliases' list to the newly linked model artifact version. Args: path: (str) A path to the contents of this model, can be in the following forms: - `/local/directory` - `/local/directory/file.txt` - `s3://bucket/path` registered_model_name: The name of the registered model that the model is to be linked to. A registered model is a collection of model versions linked to the model registry, typically representing a team's specific ML Task. The entity that this registered model belongs to will be derived from the run. name: The name of the model artifact that files in 'path' will be logged to. This will default to the basename of the path prepended with the current run id if not specified. aliases: Aliases that will only be applied on this linked artifact inside the registered model. The alias "latest" will always be applied to the latest version of an artifact that is linked. Raises: AssertionError: If registered_model_name is a path or if model artifact 'name' is of a type that does not contain the substring 'model'. ValueError: If name has invalid special characters. Returns: The linked artifact if linking was successful, otherwise `None`. rr5z_Please provide only the name of the registered model. Do not append the entity or project name.zmodel-registryz:latestr r,r.)rrrw)rirr) rrr/rrqrvrZrwrrrrr) rrr4rr name_partsrrrxrirfrfrg link_model s2 2   zRun.link_modeltitletextlevelstr | AlertLevel | None wait_durationint | float | timedelta | NonecCs|ptj}t|tr |jn|}|ddtDvrtd|p"tdd}t|ttfr0t|d}n tt |dds.z/level must be one of 'INFO', 'WARN', or 'ERROR'r5)minutes)r" total_secondsNz:wait_duration must be an int, float, or datetime.timedeltar)rMINFOrOrrrrrcallablerrr?r2r publish_alert)rr7r8r9r; level_strrfrfrgalerts  z Run.alertcCrrrfrrfrfrg __enter__3rz Run.__enter__exc_typetype[BaseException] | Noneexc_valBaseException | Noneexc_tbTracebackType | NonecCs8|du}|r t||||rdnd}|j|d| S)Nr5rr) tracebackprint_exceptionr)rrFrHrJexception_raisedrrfrfrg__exit__6s   z Run.__exit__cCs&|jr|jjr|jjdSdSdS)ztMark this run as preempting. Also tells the internal process to immediately report this to server. N)r2rpublish_preemptingrrfrfrgmark_preemptingCszRun.mark_preempting'dict[str, list[tuple[datetime, float]]]cCsddlm}d dd}|jr|jjsiS|jj}z|jd d }Wn ty-iYSwz|jj}|r:||WSiWSt yLt d iYSw)znReturns a dictionary of system metrics. Returns: A dictionary of system metrics. r)wandb_internal_pb2system_metrics_pb+wandb_internal_pb2.GetSystemMetricsResponserrRcSsli}|jD],\}}g}|jD]}tj|jjtjd}|j |jj dd}| ||j fq|||<q|S)N)tzr) microsecond) system_metricsrrecordrr# timestampr"r utcrr$rr)rTresrrecords measurementsrYdtrfrfrg pb_to_dictZs   z'Run._system_metrics..pb_to_dictr5rzError getting system metrics.N)rTrUrrR) wandb.protorSr2rdeliver_get_system_metricsrrrget_system_metrics_responserrLrM)rrSr`rrrrfrfrg_system_metricsNs"     zRun._system_metricscCs|||dSr)_header_wandb_version_info_header_sync_info_header_run_inforrfrfrgrcs z Run._headercCs,|jjs|jjr dS|jdtjdS)Nz Tracking run with wandb version )rrrrQrVrz __version__rrfrfrgreszRun._header_wandb_version_infocCsd|j|jj}|jjr1d|jdd|jdd|jdd}|j||gdS|g}|jjsGd |jd d }|||jj sW|jj sY|j|dSdSdS) NzRun data is saved locally in zW&B syncing is set to z `offline`z in this directory. Run z`wandb online`z or set zWANDB_MODE=onlinez to enable cloud syncing.zRun z`wandb offline`z to turn off syncing.) rQr#rsync_dirrr rV supports_htmlrrr)rsync_location_msgoffline_warningrdisable_sync_msgrfrfrgrfs"   zRun._header_sync_infocCs|j|j}}|js |jrdS|j}|j}|j}|js|jr dnd}|j }|s)dS|j rzddl }|j |syd|||d} d\} } |jsj|tdd} ||d } d | d | d } |rjd |||} ||d| d| | gn|r||d|||js||dd|||r||dd||||dd||dS)Nz Resuming runz Syncing runrzz )rrzdeveloper-guidedocszWeights & Biaseszto z ()z Sweep page: ristarz View project at broomz View sweep at rocketz View run at )rrQrrr,rr'r resume_fromrrj wandb.jupyterjupyterdisplay_if_magic_is_usedrrrr*rVremoji)rrrCr,rr' run_state_strrrzrun_line project_line sweep_linedoc_html project_htmlrfrfrgrgsV   zRun._header_run_inforSrTrUrrCcCsDtj||||dtj|||dtj||dtj|||ddS)N)historyrRrrC)rUrrC)rrC)rrrC)r_footer_history_summary_info_footer_sync_info_footer_log_dir_info_footer_internal_messagesrRrfrfrgr^s"  z Run._footerc Cs|jrdS|jr|js|d|d|jgdSg}|jr;|jr;|| dd| |jd| |j|j rO|| dd| |j |rr|j rrtd|j }|d |jd |jd |jd |jd ||dS)Nz.You can sync this run to the cloud by running:z wandb sync rrz View run z at: rpz View project at: zlogging synced fileszSynced z W&B file(s), z media file(s), z artifact file(s) and z other file(s))rrrrVr rirr,rrwrrr file_countsrLrM wandb_count media_countartifact_count other_count)rUrrCrMrrfrfrgrs< (  zRun._footer_sync_infocCsV|js|jrdS|jp |j}|r)tj|td}| d| |dSdS)NrzFind logs at: ) rrlog_user log_internalrrdirnamergetcwdrVr#)rrClog_dirrfrfrgr$s  zRun._footer_log_dir_infor~cCsp|js|jrdSg}|rt|||}r|||r*t|||}r*|||r6|||dSdSr)rrr_footer_historyr_footer_summaryrVpanel)r~rRrrCr history_grid summary_gridrfrfrgr4s   z Run._footer_history_summary_inforSc Cstdd|jDddd}g}|D]%}t||jkrntj|jp%|jd}| |}r7| |j |gq|sReturns the run history formatted for printing to the console.css |] }|jds|VqdSr"N)rrrrrfrfrgrVsz&Run._footer_history..cSrrrrrfrfrgrWz%Run._footer_history..r(N+,d...z Run history:) rrrmax_end_of_run_history_metricsrzr downsample values_float values_int sparklinesrrgrid) r~rCrsorted_history_items history_rowsrvalues sparkline remainingrfrfrgrNs*  zRun._footer_historyrQc CsNtdd|jDddd}g}d}|D]i}t||jkrn_zt|j}Wntjy?t d|j d|d 7}Yqwt |t r\|d d d t|d k}| |j |gqt |tjryt |trlt|d n|}| |j t |gq|d 7}q|sd St|t||krt|t||}| d|dd g||dS)z>Returns the run summary formatted for printing to the console.css&|]}|jds|js|VqdSr)rr nested_keyrrfrfrgrxs  z&Run._footer_summary..cSrrrrrfrfrgr}rz%Run._footer_summary..rrzError decoding summary[]r5Nrrrrz Run summary:)rrrmax_end_of_run_summary_metricsrrrJSONDecodeErrorrLrMrrOrZrnumbersNumberrroundr) rRrCrsorted_summary_items summary_rowsskippedrrrrfrfrgrps>     zRun._footer_summarycCs8|js|jrdS|s dS|jjD] }|j|ddqdS)Nwarn)r9)rrrrrV)rrrCr!rfrfrgrs  zRun._footer_internal_messages)NNN) rrXrSrNrTrNrUrNrrr)rrrrr)rr)rr)rrZrrrr)rrrr)rr)rrrr)rr)rrX)rrZ)rr)rr)rru)rrZrr)rrZrr)rr)r[rrr)rr)rr)rr+) rrurrurrrrrr)r rur-rur.rurr) r rur-rur.rurrZrr)r9r]rr)rJrrr)rSF)rTrrUr+rr+)rTrrUr+rrZNN)rbrcrdrcrrw)rrfrgrcrPrhrr)rrZrgrkrrU)rrZrgrrr)r}r;rr)rrr)rrrr)r$rZrrr)rPrrrrurrr)rPrrrrr)rPrrrr<r\rrr)rrZrPrZrr)Tr)rrZrr+rrZrr)rrNrr)rrVrr)rrWrr)rr0rr)rr rr)rrZrrZrrrr)Nr)rrrrrr&rr)rrrrrr&rr]NFN rrZrrurr+rrurrrr<rrrr)rr<rr)rr$)r(rZr)rZr*rnrr)r-r<r.r<r/rurr)rr}) rrZrrnrr]rrrrU) rsrrrtrrrr]rrur`rrr)rrZr`rrrU)rrZrr)NNNNNN)rrZrrrrrUrrRrurrurrrr)NrrNF)rrrrrrrrrr<rr+rr)rrrr)rirUrrZrrrrU) rrrwrurrrrurrU)NNNN) rrrrurwrurrr[rrrU) rr rrurwrurrr rurrU)NNNNNTFF)rrrrurwrurrr[rr rur r+rr+rr+rrU)rrrr) rrrrurwrurrrr$)rr-rrurrrr)rrZrr,) rr-r4rZrrurrrr) r7rZr8rZr9r:r;r<rr)rr)rFrGrHrIrJrKrr+)rrR)rSr?rTrArUrDrrFrrXrCrPrr)rUrDrrXrCrPrr)rrXrCrPrr) r~r?rRrArrXrCrPrr)r~rSrCrPrrXrru)rRrQrCrPrrXrru)rrFrrXrCrPrr)rbrcrdrrerrWrrrrrrrrrpropertyrrrrrrSrrsetterr#rr[r rrrrrrrrrrrrrrrr1r>exclude_wandb_fnr%r(r'r+r*rr4r8rArIrRrVr\rerirkr|rrrprrrrrrrrrrrrrrrrrrrrrrr'r,r@rQrr_r]rkrmrvrjrxrrrrrXrrrrrrrrtrrrrrqrrr-r3r6rDrErOrQrdrcrerfrgr^rrrrrr __classcell__rfrfrrgrs` + v           f        * # = &fU!. m +<CN 0{(07C&%"%N! 0<%!.rrrrurr+rrc Cs ddlm}tjduotjj}|rdntj}|dur&|dur"|j}ntd|dur1|dur1|j}|}||}|durBt }t j ||} t j | rW|durWt | S|r[dS||g} t| dkridS| djdkr}td|d|px|d | dj|d d S) a`Download the specified file from cloud storage. File is placed into the current directory or run directory. By default, will only download the file if it doesn't already exist. Args: name: The name of the file. run_path: Optional path to a run to pull files from, i.e. `username/project_name/run_id` if wandb.init has not been called, this is required. replace: Whether to download the file even if it already exists locally root: The directory to download the file to. Defaults to the current directory or the run directory if wandb.init was called. Returns: None if it can't find the file, otherwise a file object open for reading. Raises: CommError: If W&B can't connect to the W&B backend. ValueError: If the file is not found or can't find run_path. rrlNz>run_path required when calling wandb.restore before wandb.initF0zFile z not found in rT)rr)rormrzrrrrrrPrrrrrr#rmd5r0) rrrrrm is_disabledrrapi_runrr#rfrfrgrs4    rrr<rrrcCstjr tjj||ddSdS)aFinish a run and upload any remaining data. Marks the completion of a W&B run and ensures all data is synced to the server. The run's final state is determined by its exit conditions and sync status. Run States: - Running: Active run that is logging data and/or sending heartbeats. - Crashed: Run that stopped sending heartbeats unexpectedly. - Finished: Run completed successfully (`exit_code=0`) with all data synced. - Failed: Run completed with errors (`exit_code!=0`). Args: exit_code: Integer indicating the run's exit status. Use 0 for success, any other value marks the run as failed. quiet: Deprecated. Configure logging verbosity using `wandb.Settings(quiet=...)`. rrN)rzrrrrfrfrgrsr)rrrrrrrr) __future__rrrrrloggingrrrrerCrrrLcollections.abcrr dataclassesrrrrr enumr typesr typingr r rrtyping_extensionsrrrrrrz wandb.envrgrwandb.analyticsr wandb.errorsrrwandb.errors.linksrwandb.integration.torchr wandb.plotrrwandb.proto.wandb_internal_pb2rrrr wandb.proto.wandb_telemetry_pb2r! wandb.sdk.libr"wandb.sdk.lib.filesystemr#r$r%r&r'r(r)wandb.sdk.lib.import_hooksr*r+wandb.sdk.lib.pathsr,r-r.r/r0r1r2r3r4rr6r7r8data_types._dtypesr9interface.interfacer:interface.summary_recordr;libr<r=r>r?r@rArBrCrDrErFrGlib.exit_hooksrHmailboxrIrJrKrL wandb_alertsrM wandb_setuprNrOtorchwandb.apis.publicrPrrQrRrSartifacts.artifactrUbackend.backendrVinterface.interface_queuerWwandb_settingsrXrYrhrkrn getLoggerrL EXIT_TIMEOUTcompiler/r|rrrrrrrerr#r$rrrrorrfrfrfrgs        $ $   8           \    *q :