code: def create_builtin_class_instance(
      builtin_name: str,
      input_class_args: dict,
      algo_type: Literal["tuners", "assessors"],
  ) -> Any:
      """Create instance of builtin algorithms
  
      Parameters
      ----------
      builtin_name: str
          builtin name.
      input_class_args: dict
          kwargs for builtin class constructor
      algo_type: str
          can be one of 'tuners', 'assessors'
  
      Returns: object
      -------
          Returns builtin class instance.
      """
      assert algo_type in ALGO_TYPES
      builtin_name = builtin_name.lower()
      if builtin_name not in _get_all_builtin_names(algo_type):
          raise RuntimeError(
              "Builtin name is not found: {}".format(builtin_name)
          )
  
      def parse_algo_meta(algo_meta, input_class_args):
          """
          1. parse class_name field in meta data into module name and class name,
          for example:
              parse class_name 'nni.hyperopt_tuner.hyperopt_tuner.HyperoptTuner' in meta data into:
              module name: nni.hyperopt_tuner.hyperopt_tuner
              class name: HyperoptTuner
          2. merge user specified class args together with builtin class args.
          """
          assert algo_meta
          module_name, class_name = parse_full_class_name(
              algo_meta["className"]
          )
  
          class_args = {}
          if "classArgs" in algo_meta:
              class_args = algo_meta["classArgs"]
          if input_class_args is not None:
              class_args.update(input_class_args)
  
          return module_name, class_name, class_args
  
      algo_meta = _get_registered_algo_meta(builtin_name)
      module_name, class_name, class_args = parse_algo_meta(
          algo_meta, input_class_args
      )
      assert module_name is not None
  
      if importlib.util.find_spec(module_name) is None:  # type: ignore
          raise RuntimeError(
              "Builtin module can not be loaded: {}".format(module_name)
          )
  
      class_module = importlib.import_module(module_name)
      class_constructor = getattr(class_module, class_name)  # type: ignore
  
      instance = class_constructor(**class_args)
  
      return instance
  
file_path: nni/nni/tools/package_utils/tuner_factory.py
imports: from __future__ import annotations
  import importlib
  import os
  import sys
  from typing import Any
  from typing_extensions import Literal
  from .None import config_manager
label_desc: Use image node_id 6 for calling a global function with example usage: create_builtin_class_instance(builtin_name, input_class_args, algo_type) and returns: instance, module_name,  class_name,  class_args