docs: def check_regularizers(regularizers, keys):
    """Checks the given regularizers.
  
    This checks that `regularizers` is a dictionary that only contains keys in
    `keys`, and furthermore the entries in `regularizers` are functions or
    further dictionaries (the latter used, for example, in passing regularizers
    to modules inside modules) that must satisfy the same constraints.
  
    Args:
      regularizers: Dictionary of regularizers (allowing nested dictionaries) or
        None.
      keys: Iterable of valid keys for `regularizers`.
  
    Returns:
      Copy of checked dictionary of regularizers. If `regularizers=None`, an empty
      dictionary will be returned.
  
    Raises:
      KeyError: If an regularizers is provided for a key not in `keys`.
      TypeError: If a provided regularizer is not a callable function, or
        `regularizers` is not a Mapping.
    """
    if regularizers is None:
      return {}
    _assert_is_dictlike(regularizers, valid_keys=keys)
  
    keys = set(keys)
  
    if not set(regularizers) <= keys:
      extra_keys = set(regularizers) - keys
      raise KeyError(
          "Invalid regularizer keys {}, regularizers can only "
          "be provided for {}".format(
              ", ".join("'{}'".format(key) for key in extra_keys),
              ", ".join("'{}'".format(key) for key in keys)))
  
    _check_nested_callables(regularizers, "Regularizer")
  
    return dict(regularizers)