code: def _retrieve_class_or_fn(
      name,
      registered_name,
      module,
      obj_type,
      full_config,
      custom_objects=None,
  ):
      # If there is a custom object registered via
      # `register_keras_serializable()`, that takes precedence.
      if obj_type == "function":
          custom_obj = object_registration.get_registered_object(
              name, custom_objects=custom_objects
          )
      else:
          custom_obj = object_registration.get_registered_object(
              registered_name, custom_objects=custom_objects
          )
      if custom_obj is not None:
          return custom_obj
  
      if module:
          # If it's a Keras built-in object,
          # we cannot always use direct import, because the exported
          # module name might not match the package structure
          # (e.g. experimental symbols).
          if module == "keras" or module.startswith("keras."):
              api_name = module + "." + name
  
              obj = api_export.get_symbol_from_name(api_name)
              if obj is not None:
                  return obj
  
          # Configs of Keras built-in functions do not contain identifying
          # information other than their name (e.g. 'acc' or 'tanh'). This special
          # case searches the Keras modules that contain built-ins to retrieve
          # the corresponding function from the identifying string.
          if obj_type == "function" and module == "builtins":
              for mod in BUILTIN_MODULES:
                  obj = api_export.get_symbol_from_name(
                      "keras." + mod + "." + name
                  )
                  if obj is not None:
                      return obj
  
              # Retrieval of registered custom function in a package
              filtered_dict = {
                  k: v
                  for k, v in custom_objects.items()
                  if k.endswith(full_config["config"])
              }
              if filtered_dict:
                  return next(iter(filtered_dict.values()))
  
          # Otherwise, attempt to retrieve the class object given the `module`
          # and `class_name`. Import the module, find the class.
          try:
              mod = importlib.import_module(module)
          except ModuleNotFoundError:
              raise TypeError(
                  f"Could not deserialize {obj_type} '{name}' because "
                  f"its parent module {module} cannot be imported. "
                  f"Full object config: {full_config}"
              )
          obj = vars(mod).get(name, None)
  
          # Special case for keras.metrics.metrics
          if obj is None and registered_name is not None:
              obj = vars(mod).get(registered_name, None)
  
          if obj is not None:
              return obj
  
      raise TypeError(
          f"Could not locate {obj_type} '{name}'. "
          "Make sure custom classes are decorated with "
          "`@keras.saving.register_keras_serializable()`. "
          f"Full object config: {full_config}"
      )
  
imports: import importlib
  import inspect
  import types
  import warnings
  import numpy
  from keras import api_export
  from keras import backend
  from keras.api_export import keras_export
  from keras.backend.common import global_state
  from keras.saving import object_registration
  from keras.utils import python_utils
  from keras.utils.module_utils import tensorflow
label_desc: Use image node_id 13 for calling a global function with example usage: _retrieve_class_or_fn(name, registered_name, module, obj_type, full_config, custom_objects) and returns: custom_obj, obj, obj, next, obj