o niR@s4UdZddlmZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl m Z m Z mZmZejdkrAddl mZnddlmZddlZddlZddlmZddlmZmZmZdd lmZdd lmZdd lmZdd l m!Z!dd l"m#Z#ddl$m%Z%ddl&m'Z'm(Z(ddl)m*Z*ddl+m,Z,m-Z-m.Z.m/Z/m0Z0ddl1m2Z2m3Z3ddl4m5Z5m6Z6ddl7m8Z8ddl9m:Z:m;Z;mZ>e rddl?m@ZAdaBdeCd<d[dd ZDd\d"d#ZEd]d'd(ZFd^d,d-ZGGd.d/d/ZH  d_dd0d`d5d6ZI                         dadbdYdZZJdS)caDefines wandb.init() and associated classes and methods. `wandb.init()` indicates the beginning of a new run. In an ML training pipeline, you could add `wandb.init()` to the beginning of your training script as well as your evaluation script, and each step would be tracked as a run in W&B. For more on using `wandb.init()`, including code snippets, check out our [guide and FAQs](https://docs.wandb.ai/guides/track/launch). ) annotationsN) TYPE_CHECKINGAnyLiteralSequence) )Self)trigger) CommErrorError UsageError) url_registry)ProtobufErrorHandler) sagemaker)runid)StrPath)_is_artifact_representation) wandb_login wandb_setup)Backend)SummaryDisabled filesystemmoduleprinter telemetry) Deprecated deprecate)MailboxMailboxProgress) parse_config)Run TeardownHook TeardownStage)Settings)wandb_internal_pb2zlogging.Logger | Nonelogger log_objectlogging.LoggerreturnNonecCs|adS)zConfigure module logger.N)r')r(r,R/home/ubuntu/SoloSpeech/.venv/lib/python3.10/site-packages/wandb/sdk/wandb_init.py _set_logger6sr. str | NonecCs.dtjvrtjd}t|drt|jSdS)N transformers __version__)sysmoduleswandbutil get_modulehasattrstrr1)transr,r,r-_huggingface_version<s    r:backendrboolcCsHt|jdd}|r|duS|j}|jdkrdS|jdr"dSdS)Nparent_process MainProcessFzProcess-T)getattr_multiprocessingcurrent_processname startswith)r;r=processr,r,r-_maybe_mp_processDs    rEsettingsr%dict[str, Any]c CsHi}|js|Stjddur.z ttjdd}W|Sttfy-t dY|Sw|j r_tj |j r_t |j }t|}Wdn1sOwY|did}|Sd}g} d|}|tjvr{|tj||d 7}nnqdt|dkrd |}zt|}W|Sttfyt dY|Sw|S) N WANDB_CONFIGz{}z-Malformed WANDB_CONFIG, using original config overrides run_configrT WANDB_CONFIG_r)launchosenvirongetjsonloads ValueError SyntaxErrorr4termwarnlaunch_config_pathpathexistsopenreadappendlenjoin)rFlaunch_run_configfp launch_configichunkskey config_stringr,r,r-_handle_launch_configRsH         rec@seZdZUded<dBddZdBddZ dCdDddZdBddZdEddZdFdGd!d"Z #dHdId)d*Z dJd.d/Z dJd0d1Z dBd2d3Z dKd5d6ZdKd7d8ZdLd:d;ZdMd>d?ZdLd@dAZd S)N _WandbInitztelemetry.TelemetryRecord_init_telemetry_objr*r+cCs\d|_d|_i|_i|_i|_d|_d|_g|_d|_d|_ t |_ t |_t|_dSN)kwargsrF sweep_configr`configrunr;_teardown_hooks_wlnotebookr new_printerrTelemetryRecordrgdictdeprecated_features_usedselfr,r,r-__init__vs   z_WandbInit.__init__cstjj}|dur dSddhfdd|jD}fddtjD}t|t|ks>t| t| krVd|j t dd d }|j j|d d dSdS) zWarn if environment variables change after wandb singleton is initialized. Any settings from environment variables set after the singleton is initialized (via login/setup/etc.) will be ignored. N WANDB_SERVICEWANDB_KUBEFLOW_URLc(i|]\}}|dr|vr||qSWANDB_rC.0kvexclude_env_varsr,r- z?_WandbInit.warn_env_vars_change_after_setup..cryrzr|r}rr,r-rrzChanges to your `wandb` environment variables will be ignored because your `wandb` session has already started. For more information on how to modify your settings with `wandb.init()` arguments, please refer to z wandb-initz the W&B docs.warn)level)r _WandbSetup _instance_environitemsrNrOsetkeysvaluesrlinkrurldisplay)ru singleton singleton_envos_envliner,rr- warn_env_vars_change_after_setups*   z+_WandbInit.warn_env_vars_change_after_setupN init_settingsr%rkdict | str | Noneconfig_exclude_keyslist[str] | Noneconfig_include_keysallow_val_change bool | None monitor_gymcCsf|i}|jdkr|j|d<|jr|j|d<|r"tjdi|nd}tj|d|_|jdus2Jt|j |jj } | j rJ| j |_ | | jrU| j|_|| || jr`tnt} | r| dd} t\} } | r| rz| | d<| | tj| d| | tj|jd }d |j_Wdn1swYtj|jd+}|durd |j_| jdurd |j_| j durd |j_!| j"durd |j_#Wdn1swY|rd |j$d <|rd |j$d <t%|pt||d}t|_&|jj'pt}t|_(t|_)| |jj*|fD]}|sq|+||j(q|r,|+||j&|r>t,tj-ddkr>tj./tj-dr`tj|jd }d |j_0Wdn 1s[wY| j1rt,tj-ddkrstj23tj|jd }d |j_4Wdn 1swY| j5s| j6st7j8| j9| j:d | j;p| j<| j=dt}|dusJdd|j j9|j j>|j j?|j j:|j j@dAD}|r| || B| jC}| j5s| j6s|jD}|dur| ||durd| _C| jEdur tjFG| jH| _EtII| _J| j6s |K| | jLr |M| tN| }|r.|+||jO| |_ dS)zComplete setup for `wandb.init()`. This includes parsing all arguments, applying them with settings and enabling logging. disabledmodex_disable_serviceNrF wandb_api_key WANDB_API_KEY)objTzPUse `config=wandb.helper.parse_config(config_object, exclude=('key',))` instead.rzPUse `config=wandb.helper.parse_config(config_object, include=('key',))` instead.r)includeexcludegymr tensorboard) anonymousforce_disable_warning_silent_entitycSsi|] \}}|dur||qSrhr,r}r,r,r-r,s z$_WandbInit.setup..)rapi_keybase_urlr login_timeoutFr,)Prrrr4r%rsetuprnr. _get_loggerrFcopysweep_idhandle_sweep_logicrMhandle_launch_logicupdate_from_settingssagemaker_disablerrrparse_sm_configrPparse_sm_resourcesupdate_from_env_varsupdate_from_dictrcontextrgfeatureset_init_configrun_name set_init_namerun_id set_init_idrun_tags set_init_tagsrsr!rj _sweep_configrkinit_artifact_config_config_split_artifacts_from_configr\patchedrmonitortensorboard_patchsync_tensorboardrpatchtensorboard_sync_offline_noopr_loginrrquietsilententityrrrrhandle_resume_logic save_code_load_user_settingsprojectr5auto_project_nameprogramtime x_start_time _log_setup_jupyter_jupyter_setuprer`)rurrkrrrrsetup_settings_dictsetup_settingsrFsagemaker_configsagemaker_api_key sagemaker_run sagemaker_envtelrj config_datawllogin_settingssave_code_pre_user_settings user_settingsr`r,r,r-rs                                 z_WandbInit.setupcCs*tsJtd|jD]}|q dS)Nztearing down wandb.init)r'informcall)ruhookr,r,r-teardown^s    z_WandbInit.teardown config_sourcerr config_targetcCs6|D]\}}t|r||j|<q|||qdSrh)rrr setdefault)rurrrrr,r,r-rfs  z'_WandbInit._split_artifacts_from_config log_fnamer8rr/cst|tjGfdddtj}rtd}ntd}|r0|tdus6Jdt_ t ttj |j tfddtjdS) zEnable logging to the global debug log. This adds a run_id to the log, in case of multiple processes on the same machine. Currently, there is no way to disable logging after it's enabled. cseZdZdfdd ZdS) z,_WandbInit._enable_logging..WBFilterrecordlogging.LogRecordr*r<cs |_dS)NTr)rurrr,r-filterysz3_WandbInit._enable_logging..WBFilter.filterN)rrr*r<)__name__ __module__ __qualname__rr,rr,r-WBFilterxsrzy%(asctime)s %(levelname)-7s %(threadName)-10s:%(process)d [%(run_id)s:%(filename)s:%(funcName)s():%(lineno)s] %(message)szn%(asctime)s %(levelname)-7s %(threadName)-10s:%(process)d [%(filename)s:%(funcName)s():%(lineno)s] %(message)sNFcstfSrh)closer' removeHandlerr,)handlerr,r-sz,_WandbInit._enable_logging..)logging FileHandlersetLevelINFOFilter Formatter setFormatter addFilterr' propagate addHandlerDEBUGrmr[r#r$LATE)rurrr formatterr,)rrr-_enable_loggingos.        z_WandbInit._enable_loggingFbasetargetrBdeleter<cCsttdsdSt}tj||d|}|r/z ttj||Wn ty.Ynwtj||}zt||t |tj||WdStyTYdSw)Nsymlinkr) r7rNgetpidrWr]removeOSErrorrelpathrrename)rurrrBrpidtmp_namer,r,r- _safe_symlinks"    z_WandbInit._safe_symlinkargsrricOsj|jdurdS|jr |jdusJ|jjdd}td||jjdur3td|jjdSdS)Nrootzsaved code: %szpausing backend) r;ro save_ipynbrllog_coder'r interface publish_pause)rurriresr,r,r-_pause_backends     z_WandbInit._pause_backendcOs8|jdur|jjdurtd|jjdSdSdS)Nzresuming backend)r;r!r'rpublish_resumerurrir,r,r-_resume_backends z_WandbInit._resume_backendcCs|jsJ|jj}|j|jr'|jdusJ|jjdd}td|td|jj dD]}d|j vr@|j d|q2|jj dD]}d|j vrU|j d|qG|j j |j _|j ` dS) z.publishrhr*r+)r4jupyterNotebookror*r7r/r'rr1r0r,registerr'r$rmr[r#r3r$EARLY)rurFr1r,r8r-rs     z_WandbInit._jupyter_setupcCs:ttj|jttj|jttj|jt|jt|j |j rm|j tj|j tj|jtj |j dd|j tj|j|jtj |jdd|j tj|j|jtj |jddttd||j|jsJtsJ|jttd|jtd|jdS)zSet up logging from settings.T)rr4zLogging user logs to zLogging internal logs to N)rmkdir_exists_okrNrWdirnamelog_user log_internal sync_file files_dir _tmp_code_dirrrsync_symlink_latestbasenamelog_symlink_userlog_symlink_internalr.r getLoggerrrnr'_early_logger_flushr)rurFr,r,r-rs>            z_WandbInit._log_setupr"c s6t}ttdt|tddd|ddd dtjj _ j |j j |jt_fdd_d d_j_d d_d d_d D] }t|d dqOGdddGfddd}|_t_d_d_d_d_tjjjjjj jjj!j"j#d S)aReturns a Run-like object where all methods are no-ops. This method is used when wandb.init(mode="disabled") is called or WANDB_MODE=disabled is set. It creates a Run object that mimics the behavior of a normal Run but doesn't communicate with the W&B servers. The returned Run object has all expected attributes and methods, but they are no-op versions that don't perform any actual logging or communication. rNzdummy-dummy) r x_files_dirrr run_notes run_grouprrrrcs j|Srh)summaryupdate)r5___)drunr,r-r1s z/_WandbInit._make_run_disabled..c_stSrh)r unset_globalsrQrRr,r,r-r2sc_stjjdS)NrK)r4sdk wandb_metricMetricrUr,r,r-r4sc_sdS)NFr,rUr,r,r-r5)alertfinish_artifactget_project_url get_sweep_urlget_url link_artifact link_model use_artifactr  log_model use_modelmark_preemptingrestorestatuswatchunwatchupsert_artifact_finishc_dSrhr,rUr,r,r-rJrYc@s$eZdZdZd ddZdd d Zd S)z5_WandbInit._make_run_disabled.._ChainableNoOpzEAn object that allows chaining arbitrary attributes and method calls.rQr8r*r cS|Srhr,)rurQr,r,r- __getattr__OzA_WandbInit._make_run_disabled.._ChainableNoOp.__getattr__rrRc_rlrhr,)rurQrRr,r,r-__call__Rrnz>_WandbInit._make_run_disabled.._ChainableNoOp.__call__N)rQr8r*r )rQrrRrr*r )rrr__doc__rmror,r,r,r-_ChainableNoOpLs rqcs<eZdZdddZddd Zdfd d Zdfdd ZdS)z:_WandbInit._make_run_disabled.._ChainableNoOpFieldr*r+cSs d|_dSrh_valuertr,r,r-rvX zC_WandbInit._make_run_disabled.._ChainableNoOpField.__init__instancervaluecSs ||_dSrhrr)rururvr,r,r-__set__[rtzB_WandbInit._make_run_disabled.._ChainableNoOpField.__set__ownertypecs|jdurS|jSrhrr)rururxrqr,r-__get__^szB_WandbInit._make_run_disabled.._ChainableNoOpField.__get__rrirqcsSrhr,r&rzr,r-roaszC_WandbInit._make_run_disabled.._ChainableNoOpField.__call__Nr9)rurrvrr*r+)rurrxryr*r)rrrirr*rq)rrrrvrwr{ror,rzr,r-_ChainableNoOpFieldUs   r|r) rlrklogrOsavera log_artifact define_metricrZrgrh)$r generate_idr"r%tempfile gettempdirtupler4rV wandb_configConfigrrPrjrkrrOr}finishr]rr~setattrrr _start_time_starting_step_step _attach_id_backendr set_globalrarZrgrh)rursymbolr|r,)rqrSr-_make_run_disableds^       z_WandbInit._make_run_disabledhandler cCsd}|j}|jj||ddS)NzWaiting for wandb.init()... ) percent_done)rrprogress_update)rurrrr,r,r-_on_progress_init|sz_WandbInit._on_progress_initcCstdurtdtdtd|jdusJ|jdus Jtd|jd|j|jj r5| S|jj sC|jj rl|jj durlt |jjdkrlt |jjdkrXtd |jjd }td |j|n6ttjtr|jj}|rttjjkrtd t}d |j_WdtjS1swYtjStd|jj}|rtd|j|j|jj dt!}t"|j||d}|#tdt|j|j|j|j$d}tj||j%d}tj&|_'t()|_)t(*dt(+,|_(t-}|r||_.|jj rd |j/_0|jj1rd |j/_2|jj3r#d |j/_4|jj5r,d |j/_6|jj7r5d |j/_8|jj9r>d |j_9tj:d dD] }t;|j<|d qDd} |jj=dkr]|jj=} n t>|j?ddd} | dkrqd |j/_@n| dkr{d |j/_An| dkrd |j/_Bn | dkrd |j/_CtjDEdrd |j/_F|jjGrd |j/_HtjDEtj/jIrd |j_J|rd |j_|jjKrd |j_L|jjMrd |j_N|jjOsd |j_P|jjQrtdd |j_RtS||j/_TWdn 1swY|jjUs |jVr|W|jVn|X|jYZD]\} } d | d!| } t[t>t\d"| | |d#qtd$|]|j|^||_|j`|a||jbsIJ|c|jbd|jjes`|jjfs`|gd} |jjhrtj|d% }d |j_iWdn 1s}wY|jjjrtd&|jkd'd}|jjl}td(|d)|jbm|}|jn||jod d*}|r|jp} | durd+|d,}tq|}|rn | sd-rttu| jv}|durtvd.||s|w|x|| dusJ| sd/styd0| jjzr'td1tj|d%}| jjz|j_zWdn 1s"wY|{| j||td2|rL|jj s@J|j}|j|jj d|jbsRJ|jb~|}|jnd3d4}|durg||jdusoJ|jj|||_||jj9r|jjrtj|jjr||jj|jZD]\}}|jj||id d5q|jEtjj}|r||||_|td6|S)7NzLogger not initializedzcalling init triggerson_initz%wandb.init called with sweep_config: z config: FrrzLaunching multiple wandb runs using Python's threading module is not well-supported. Please use multiprocessing instead. Finishing previous run before initializing another.zfound existing run on stack: z.wandb.init() called when a run is still activeTzstarting backendzsending inform_init request)rFrrFservicemailboxzbackend started and connected)rkrFrjr`)rlr-) only_importedthreadget_start_methodcSrkrhr,r,r,r,r-rrYz!_WandbInit.init..spawnfork forkserverPEXz}The `_shared` feature is experimental and may change. Please contact support@wandb.com for guidance and to report any issues.`z` is deprecated. init__) field_namewarning_messagerlzupdated telemetryrlz_`resume` will be ignored since W&B syncing is set to `offline`. Starting a new run with run id rz"communicating run to backend with z second timeout)timeout on_progresscancelz'Run initialization has timed out after z sec. Please try increasing the timeout with the `init_timeout` setting: `wandb.init(settings=wandb.Settings(init_timeout=120))`.errorzencountered error: rlzIt appears that something have gone wrong during the program execution as an unexpected missing field was encountered. (run_result is missing the 'run' field)z run resumedzstarting run threads in backendr)rz.run started, returning control to user process)r' RuntimeErrorrr rrFrnrjrkrrreinitrr\_global_run_stackr4rU_run_idr isinstancerlr"rrNr _init_pidrrrinit_return_run inform_initto_protorrrensure_launchedr`rgr1 cli_versionplatformpython_versionsystemmachinelowerr:huggingface_versionenvr:_ipythonr2_colabcolab_kagglekaggle_windowswindowsrMlist_telemetry_importsr imports_init start_methodr?r@ start_spawn start_forkstart_forkserver start_threadrOrPpex _aws_lambda aws_lambda_DISABLE_SERVICEservice_disabledx_flow_control_disabledflow_control_disabledx_flow_control_customflow_control_customx_require_legacy_servicecore_shared shared_moderEmaybe_mp label_disablero_label_probe_notebook_label_probe_mainrsrrr _set_library _set_backend_set_teardown_hooksrm _hack_set_runr!enable_keepalivepublish_header disable_gitx_disable_machine_info_populate_git_inforofflineresumeid init_timeout deliver_runwaitr run_resultr _cancelHasFieldr to_exceptionrcleanuprr resumed _set_run_obj_on_init inform_startdeliver_run_startabandonr[!_handle_launch_artifact_overridesrVrWrXr~rrP_launch_artifact_mappingr5LAUNCH_JOB_ARTIFACT_SLOT_NAMErar; _on_start)ru latest_runrrrr;rl hf_version module_nameactive_start_methoddeprecated_featuremsgrrrrrun_init_handleresult error_messagerun_start_handlerun_start_resultrr job_artifactr,r,r-inits                                   D                             z_WandbInit.initr9)NNNNN)rr%rkrrrrrrrrrr*r+)rrrrrrr*r+rh)rr8rr/r*r+)F) rr8rr8rBr8rr<r*r+)rrrirr*r+)rFr%r*r+)r*r")rr r*r+)rrr__annotations__rvrrrrrrr$r'r3rrrrrr,r,r,r-rfss0   %  5  )     & irfr attach_idrrl Run | Nonec Cs|p|}|du|duAstd|p|r|jnd}|dur!tdtt}|s-Jt|tdur;td|j }|sHtd|dz|j |d}Wnt yd}ztd||d}~wwt |j }|||jj|jjdt}t|||d } | td |durt|d }n|j|d |||| | || jsJ|| j|} | jd d } | s| td| j j!} | j"r| j"j#rtd| j"j#|$| j%|&|S)a3Attach to a run currently executing in another process/thread. Args: attach_id: (str, optional) The id of the run or an attach identifier that maps to a run. run_id: (str, optional) The id of the run to attach to. run: (Run, optional) The run instance to attach Nz;Either (`attach_id` or `run_id`) or `run` must be specifiedzPEither `attach_id` or `run_id` must be specified or `run` must have `_attach_id`zlogger is not initializedzUnable to attach to run z (no service process))r )rrrrz$attach backend started and connectedrrrzTimeout attaching to runzFailed to attach to run: )'r rr4_assert_is_user_processr_setupr.rr'r inform_attach Exceptionr _settingsrrrvrrrrrr"_initrrrr!rdeliver_attachrrresponseattach_responsermessagerrl _on_attach) r rrlrnrattach_settingserFrr; attach_handle attach_resultrr,r,r-_attachsj             rrrdirStrPath | NonerrBnotestagsSequence[str] | Nonerkdict[str, Any] | str | Nonerrrrrgroupjob_typer/Literal['online', 'offline', 'disabled'] | Nonerr(Literal['never', 'allow', 'must'] | Nonerr7bool | Literal['allow', 'never', 'must', 'auto'] | None resume_from fork_fromrrrr Settings | dict[str, Any] | Noner"c Cstt}t|trtdi|}nt|tr|}| dur"| |_|dur)||_|dur0||_|dur7||_|dur>||_ |durGt ||_ | durN| |_ |durU||_ |dur\||_|durc||_| durj| |_|durq||_|durx||_|dur||_|dur||_|dur||_|dur||_|dur||_|dur||_zt}|j|||| | |d|WSty}z tdurtjd|dd}~wty}ztdurtjd|dtj !|t"d}~ww)uc2Start a new run to track and log to W&B. In an ML training pipeline, you could add `wandb.init()` to the beginning of your training script as well as your evaluation script, and each piece would be tracked as a run in W&B. `wandb.init()` spawns a new background process to log data to a run, and it also syncs data to https://wandb.ai by default, so you can see your results in real-time. Call `wandb.init()` to start a run before logging data with `wandb.log()`. When you're done logging data, call `wandb.finish()` to end the run. If you don't call `wandb.finish()`, the run will end when your script exits. For more on using `wandb.init()`, including detailed examples, check out our [guide and FAQs](https://docs.wandb.ai/guides/track/launch). Examples: ### Explicitly set the entity and project and choose a name for the run: ```python import wandb run = wandb.init( entity="geoff", project="capsules", name="experiment-2021-10-31", ) # ... your training code here ... run.finish() ``` ### Add metadata about the run using the `config` argument: ```python import wandb config = {"lr": 0.01, "batch_size": 32} with wandb.init(config=config) as run: run.config.update({"architecture": "resnet", "depth": 34}) # ... your training code here ... ``` Note that you can use `wandb.init()` as a context manager to automatically call `wandb.finish()` at the end of the block. Args: entity: The username or team name under which the runs will be logged. The entity must already exist, so ensure you’ve created your account or team in the UI before starting to log runs. If not specified, the run will default your defualt entity. To change the default entity, go to [your settings](https://wandb.ai/settings) and update the "Default location to create new projects" under "Default team". project: The name of the project under which this run will be logged. If not specified, we use a heuristic to infer the project name based on the system, such as checking the git root or the current program file. If we can't infer the project name, the project will default to `"uncategorized"`. dir: An absolute path to the directory where metadata and downloaded files will be stored. When calling `download()` on an artifact, files will be saved to this directory. If not specified, this defaults to the `./wandb` directory. id: A unique identifier for this run, used for resuming. It must be unique within the project and cannot be reused once a run is deleted. The identifier must not contain any of the following special characters: `/ \ # ? % :`. For a short descriptive name, use the `name` field, or for saving hyperparameters to compare across runs, use `config`. name: A short display name for this run, which appears in the UI to help you identify it. By default, we generate a random two-word name allowing easy cross-reference runs from table to charts. Keeping these run names brief enhances readability in chart legends and tables. For saving hyperparameters, we recommend using the `config` field. notes: A detailed description of the run, similar to a commit message in Git. Use this argument to capture any context or details that may help you recall the purpose or setup of this run in the future. tags: A list of tags to label this run in the UI. Tags are helpful for organizing runs or adding temporary identifiers like "baseline" or "production." You can easily add, remove tags, or filter by tags in the UI. If resuming a run, the tags provided here will replace any existing tags. To add tags to a resumed run without overwriting the current tags, use `run.tags += ["new_tag"]` after calling `run = wandb.init()`. config: Sets `wandb.config`, a dictionary-like object for storing input parameters to your run, such as model hyperparameters or data preprocessing settings. The config appears in the UI in an overview page, allowing you to group, filter, and sort runs based on these parameters. Keys should not contain periods (`.`), and values should be smaller than 10 MB. If a dictionary, `argparse.Namespace`, or `absl.flags.FLAGS` is provided, the key-value pairs will be loaded directly into `wandb.config`. If a string is provided, it is interpreted as a path to a YAML file, from which configuration values will be loaded into `wandb.config`. config_exclude_keys: A list of specific keys to exclude from `wandb.config`. config_include_keys: A list of specific keys to include in `wandb.config`. allow_val_change: Controls whether config values can be modified after their initial set. By default, an exception is raised if a config value is overwritten. For tracking variables that change during training, such as a learning rate, consider using `wandb.log()` instead. By default, this is `False` in scripts and `True` in Notebook environments. group: Specify a group name to organize individual runs as part of a larger experiment. This is useful for cases like cross-validation or running multiple jobs that train and evaluate a model on different test sets. Grouping allows you to manage related runs collectively in the UI, making it easy to toggle and review results as a unified experiment. For more information, refer to our [guide to grouping runs](https://docs.wandb.com/guides/runs/grouping). job_type: Specify the type of run, especially helpful when organizing runs within a group as part of a larger experiment. For example, in a group, you might label runs with job types such as "train" and "eval". Defining job types enables you to easily filter and group similar runs in the UI, facilitating direct comparisons. mode: Specifies how run data is managed, with the following options: - `"online"` (default): Enables live syncing with W&B when a network connection is available, with real-time updates to visualizations. - `"offline"`: Suitable for air-gapped or offline environments; data is saved locally and can be synced later. Ensure the run folder is preserved to enable future syncing. - `"disabled"`: Disables all W&B functionality, making the run’s methods no-ops. Typically used in testing to bypass W&B operations. force: Determines if a W&B login is required to run the script. If `True`, the user must be logged in to W&B; otherwise, the script will not proceed. If `False` (default), the script can proceed without a login, switching to offline mode if the user is not logged in. anonymous: Specifies the level of control over anonymous data logging. Available options are: - `"never"` (default): Requires you to link your W&B account before tracking the run. This prevents unintentional creation of anonymous runs by ensuring each run is associated with an account. - `"allow"`: Enables a logged-in user to track runs with their account, but also allows someone running the script without a W&B account to view the charts and data in the UI. - `"must"`: Forces the run to be logged to an anonymous account, even if the user is logged in. reinit: Determines if multiple `wandb.init()` calls can start new runs within the same process. By default (`False`), if an active run exists, calling `wandb.init()` returns the existing run instead of creating a new one. When `reinit=True`, the active run is finished before a new run is initialized. In notebook environments, runs are reinitialized by default unless `reinit` is explicitly set to `False`. resume: Controls the behavior when resuming a run with the specified `id`. Available options are: - `"allow"`: If a run with the specified `id` exists, it will resume from the last step; otherwise, a new run will be created. - `"never"`: If a run with the specified `id` exists, an error will be raised. If no such run is found, a new run will be created. - `"must"`: If a run with the specified `id` exists, it will resume from the last step. If no run is found, an error will be raised. - `"auto"`: Automatically resumes the previous run if it crashed on this machine; otherwise, starts a new run. - `True`: Deprecated. Use `"auto"` instead. - `False`: Deprecated. Use the default behavior (leaving `resume` unset) to always start a new run. Note: If `resume` is set, `fork_from` and `resume_from` cannot be used. When `resume` is unset, the system will always start a new run. For more details, see our [guide to resuming runs](https://docs.wandb.com/guides/runs/resuming). resume_from: Specifies a moment in a previous run to resume a run from, using the format `{run_id}?_step={step}`. This allows users to truncate the history logged to a run at an intermediate step and resume logging from that step. The target run must be in the same project. If an `id` argument is also provided, the `resume_from` argument will take precedence. `resume`, `resume_from` and `fork_from` cannot be used together, only one of them can be used at a time. Note: This feature is in beta and may change in the future. fork_from: Specifies a point in a previous run from which to fork a new run, using the format `{id}?_step={step}`. This creates a new run that resumes logging from the specified step in the target run’s history. The target run must be part of the current project. If an `id` argument is also provided, it must be different from the `fork_from` argument, an error will be raised if they are the same. `resume`, `resume_from` and `fork_from` cannot be used together, only one of them can be used at a time. Note: This feature is in beta and may change in the future. save_code: Enables saving the main script or notebook to W&B, aiding in experiment reproducibility and allowing code comparisons across runs in the UI. By default, this is disabled, but you can change the default to enable on your [settings page](https://wandb.ai/settings). tensorboard: Deprecated. Use `sync_tensorboard` instead. sync_tensorboard: Enables automatic syncing of W&B logs from TensorBoard or TensorBoardX, saving relevant event files for viewing in the W&B UI. saving relevant event files for viewing in the W&B UI. (Default: `False`) monitor_gym: Enables automatic logging of videos of the environment when using OpenAI Gym. For additional details, see our [guide for gym integration](https://docs.wandb.com/guides/integrations/openai-gym). settings: Specifies a dictionary or `wandb.Settings` object with advanced settings for the run. Returns: A `Run` object, which is a handle to the current run. Use this object to perform operations like logging data, saving files, and finishing the run. See the [Run API](https://docs.wandb.ai/ref/python/run) for more details. Raises: Error: If some unknown or internal error happened during the run initialization. AuthenticationError: If the user failed to provide valid credentials. CommError: If there was a problem communicating with the W&B server. UsageError: If the user provided invalid arguments to the function. KeyboardInterrupt: If the user interrupts the run initialization process. If the user interrupts the run initialization process. N)rrkrrrr interrupted)exc_infozerror in wandb.init()r,)#r4r r%rrr run_job_typeroot_dirrrrrrrNrrMrrrrrrrr(r'rfrrKeyboardInterruptr'warningr exception_sentryreraiseAssertionError)rrrrrBrrrkrrrr"r#rrrrrr'r(rrrrrFrwirr,r,r-rsl     r)r(r)r*r+)r*r/)r;rr*r<)rFr%r*rG)NN)r r/rr/rlr r*r )NNNNNNNNNNNNNNNNNNNNNNNNN)4rr/rr/rrrr/rBr/rr/rr rkr!rrrrrrr"r/r#r/rr$rrrr%rrrr&r'r/r(r/rrrrrrrrrFr)r*r")Krp __future__rrrQrrNrr2rrtypingrrrr version_infor typing_extensionsr4 wandb.envr wandb.errorsr r r wandb.errors.linksrwandb.errors.utilrwandb.integrationr wandb.sdk.librwandb.sdk.lib.pathsr wandb.utilrrLrrbackend.backendrlibrrrrr lib.deprecaterr lib.mailboxrr wandb_helperr! wandb_runr"r#r$wandb_settingsr% wandb.protor&pbr'r r.r:rErerfrrr,r,r,r-s                   !,U