class_docstr: Each experiment has different configurations or algorithms.
  An experiment can have multiple runs.
  
  Keyword Arguments:
      name (str, optional): name of the experiment
      python_file (str, optional): path of the Python file that
          created the experiment
      comment (str, optional): a short description of the experiment
      writers (Set[str], optional): list of writers to write stat to
      ignore_callers: (Set[str], optional): list of files to ignore when
          automatically determining ``python_file``
      tags (Set[str], optional): Set of tags for experiment
code: def start(self, *, global_step: int = 0):
      self.run.start_step = global_step
  
      self._start_tracker()
      tracker().set_start_global_step(global_step)
  
      if self.run.distributed_rank == self.run.distributed_main_rank:
          self.__print_info()
          if self.check_repo_dirty and self.run.is_dirty:
              logger.log(
                  [
                      ("[FAIL]", Text.danger),
                      " Cannot trial an experiment with uncommitted changes.",
                  ]
              )
              exit(1)
  
      if not self.is_evaluate:
          if (
              self.run.distributed_rank
              == self.run.distributed_main_rank
          ):
              from labml.internal.computer.configs import (
                  computer_singleton,
              )
  
              computer_singleton().add_project(lab_singleton().path)
  
          self.run.save_info()
  
          if (
              self.run.distributed_rank
              == self.run.distributed_main_rank
          ):
              if self.configs_processor is not None:
                  self.configs_processor.add_saver(
                      FileConfigsSaver(self.run.configs_path)
                  )
  
          if self.app_experiment is not None:
              self.app_experiment.start(self.run)
              if self.configs_processor is not None:
                  self.configs_processor.add_saver(
                      self.app_experiment.get_configs_saver()
                  )
                  self.app_experiment.set_dynamic_handler(
                      ExperimentDynamicUpdateHandler(
                          self.configs_processor
                      )
                  )
  
          if (
              self.run.distributed_rank
              == self.run.distributed_main_rank
          ):
              tracker().save_indicators(self.run.indicators_path)
  
      self.is_started = True
      return ExperimentWatcher(self)
  
imports: import json
  import os
  import pathlib
  import time
  from typing import Optional, Set, Dict, Union, TYPE_CHECKING
  from labml import logger
  from labml.logger import Text
  from labml.utils import get_caller_file
  from labml.utils.git_info import get_git_status
  from labml.utils.notice import labml_notice
  from ..app.dynamic import DynamicUpdateHandler
  from ..configs.base import Configs
  from ..configs.dynamic_hyperparam import DynamicHyperParam
  from ..configs.processor import ConfigProcessor, FileConfigsSaver
  from ..experiment.experiment_run import Run
  from ..experiment.watcher import ExperimentWatcher
  from ..lab import lab_singleton
  from ..monitor import monitor_singleton
  from ..tracker import tracker_singleton
  from ..util import is_ipynb
label_desc: Use image node_id 6 for calling the Experiment obj's underlying member method code with example usage: obj.start() and returns: ExperimentWatcher