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 __init__(
      self,
      *,
      uuid: str,
      name: Optional[str],
      python_file: Optional[str],
      comment: Optional[str],
      writers: Set[str],
      ignore_callers: Set[str],
      tags: Optional[Set[str]],
      distributed_rank: int,
      distributed_world_size: int,
      distributed_main_rank: int,
      is_evaluate: bool,
  ):
      if is_ipynb():
          lab_singleton().set_path(os.getcwd())
          if python_file is None:
              python_file = "notebook.ipynb"
          if name is None:
              name = "Notebook Experiment"
      else:
          if python_file is None:
              python_file = get_caller_file(ignore_callers)
  
          lab_singleton().set_path(python_file)
  
          if name is None:
              file_path = pathlib.PurePath(python_file)
              name = file_path.stem
  
      if comment is None:
          comment = ""
      if global_params_singleton().comment is not None:
          comment = global_params_singleton().comment
  
      self.experiment_path = lab_singleton().experiments / name
  
      self.check_repo_dirty = lab_singleton().check_repo_dirty
  
      self.configs_processor = None
  
      if tags is None:
          tags = set(name.split("_"))
  
      self.run = Run.create(
          uuid=uuid,
          experiment_path=self.experiment_path,
          python_file=python_file,
          trial_time=time.localtime(),
          name=name,
          comment=comment,
          tags=list(tags),
          distributed_rank=distributed_rank,
          distributed_world_size=distributed_world_size,
          distributed_main_rank=distributed_main_rank,
      )
  
      info, status = get_git_status()
  
      if status is None:
          pass
      if status == "no_git":
          labml_notice(
              [
                  "Not a valid git repository: ",
                  (str(lab_singleton().path), Text.value),
              ]
          )
      elif status == "no_gitpython":
          labml_notice(
              [
                  "Install gitpython to record git commit: ",
                  ("pip install gitpython", Text.value),
              ]
          )
      elif status == "no_git_google_colab":
          pass
  
      self.run.repo_remotes = info["remotes"]
      self.run.commit = info["commit"]
      self.run.commit_message = info["commit_message"]
      self.run.is_dirty = info["is_dirty"]
      self.run.diff = info["diff"]
  
      self.is_evaluate = is_evaluate
      self.app_experiment = None
      self.writers = writers
      self.is_started = False
      self.is_worker = False
  
      # TODO: option
      if self.run.distributed_rank != self.run.distributed_main_rank:
          monitor().silent()
  
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 1 to create a new Experiment object  with example: obj = Experiment()