code: def from_params(
      params: Dict, mode: str = "infer", **kwargs
  ) -> Union[Component, FunctionType]:
      """Builds and returns the Component from corresponding dictionary of parameters."""
      # what is passed in json:
      config_params = {k: resolve(v) for k, v in params.items()}
  
      # get component by reference (if any)
      if "ref" in config_params:
          try:
              return _refs[config_params["ref"]]
          except KeyError:
              e = ConfigError(
                  'Component with id "{id}" was referenced but not initialized'.format(
                      id=config_params["ref"]
                  )
              )
              log.exception(e)
              raise e
  
      elif "config_path" in config_params:
          from deeppavlov.core.commands.infer import build_model
  
          refs = _refs.copy()
          _refs.clear()
          config = parse_config(
              expand_path(config_params["config_path"]),
              config_params.get("overwrite"),
          )
          model = build_model(config)
          _refs.clear()
          _refs.update(refs)
          try:
              _refs[config_params["id"]] = model
          except KeyError:
              pass
          return model
  
      cls_name = config_params.pop("class_name", None)
      if not cls_name:
          e = ConfigError(
              "Component config has no `class_name` nor `ref` fields"
          )
          log.exception(e)
          raise e
      obj = get_model(cls_name)
  
      if inspect.isclass(obj):
          # find the submodels params recursively
          config_params = {
              k: _init_param(v, mode) for k, v in config_params.items()
          }
          try:
              spec = inspect.getfullargspec(obj)
              if (
                  "mode" in spec.args + spec.kwonlyargs
                  or spec.varkw is not None
              ):
                  kwargs["mode"] = mode
  
              component = obj(**dict(config_params, **kwargs))
              try:
                  _refs[config_params["id"]] = component
              except KeyError:
                  pass
          except Exception:
              log.exception("Exception in {}".format(obj))
              raise
      else:
          component = obj
  
      return component
  
file_path: DeepPavlov/deeppavlov/core/common/params.py
imports: import inspect
  from logging import getLogger
  from types import FunctionType
  from typing import Any, Dict, Union
  from deeppavlov.core.commands.utils import expand_path, parse_config
  from deeppavlov.core.common.errors import ConfigError
  from deeppavlov.core.common.registry import get_model
  from deeppavlov.core.models.component import Component
label_desc: Use image node_id 3 for calling a global function with example usage: from_params(params, mode) and returns: component, _refs, model