def add_subclass_to_registry(subclass: Type[T]):
if name in registry:
message = "Cannot register {} as {}, since name already in user for {}".format(
name, cls.__name__, registry[name].__name__s)
raise ConfigurationError(message)
registry[name] = subclass
return subclass
def step(self, metrics, epoch=None):
if not metrics:
raise ConfigurationError(
"The reduce_on_plateau learning rate scheduler requires "
"a validation metric to compute the schedule and therefore "
"must be used with a validation dataset.")
self.lr_scheduler.step(metrics, epoch)
def pop_choice(self,
key: str,
choices: List[Any],
default_to_first_choice: bool = False) -> Any:
"""
Gets the value of ``key`` in the ``params`` dictionary, ensuring that the value is one of
the given choices. Note that this `pops` the key from params, modifying the dictionary,
consistent with how parameters are processed in this codebase.
Parameters
----------
key: str
Key to get the value from in the param dictionary
choices: List[Any]
A list of valid options for values corresponding to ``key``. For example, if you're
specifying the type of encoder to use for some part of your model, the choices might be
the list of encoder classes we know about and can instantiate. If the value we find in
the param dictionary is not in ``choices``, we raise a ``ConfigurationError``, because
the user specified an invalid value in their parameter file.
default_to_first_choice: bool, optional (default=False)
If this is ``True``, we allow the ``key`` to not be present in the parameter
dictionary. If the key is not present, we will use the return as the value the first
choice in the ``choices`` list. If this is ``False``, we raise a
``ConfigurationError``, because specifying the ``key`` is required (e.g., you `have` to
specify your model class when running an experiment, but you can feel free to use
default settings for encoders if you want).
"""
default = choices[0] if default_to_first_choice else self.DEFAULT
value = self.pop(key, default)
if value not in choices:
key_str = self.history + key
message = '%s not in acceptable choices for %s: %s' % (
value, key_str, str(choices))
raise ConfigurationError(message)
return value
def assert_empty(self, class_name: str):
"""
Raises a ``ConfigurationError`` if ``self.params`` is not empty. We take ``class_name`` as
an argument so that the error message gives some idea of where an error happened, if there
was one. ``class_name`` should be the name of the `calling` class, the one that got extra
parameters (if there are any).
"""
if self.params:
raise ConfigurationError(
"Extra parameters passed to {}: {}".format(
class_name, self.params))
def get(self, key: str, default: Any = DEFAULT):
"""
Performs the functionality associated with dict.get(key) but also checks for returned
dicts and returns a Params object in their place with an updated history.
"""
if default is self.DEFAULT:
try:
value = self.params.get(key)
except KeyError:
raise ConfigurationError(
"key \"{}\" is required at location \"{}\"".format(
key, self.history))
else:
value = self.params.get(key, default)
return self._check_is_dict(key, value)
def pop(self, key: str, default: Any = DEFAULT) -> Any:
"""
Performs the functionality associated with dict.pop(key), along with checking for
returned dictionaries, replacing them with Param objects with an updated history.
If ``key`` is not present in the dictionary, and no default was specified, we raise a
``ConfigurationError``, instead of the typical ``KeyError``.
"""
if default is self.DEFAULT:
try:
value = self.params.pop(key)
except KeyError:
raise ConfigurationError(
"key \"{}\" is required at location \"{}\"".format(
key, self.history))
else:
value = self.params.pop(key, default)
if not isinstance(value, dict):
logger.info(self.history + key + " = " +
str(value)) # type: ignore
return self._check_is_dict(key, value)
def by_name(cls: Type[T], name: str) -> Type[T]:
if name not in Registrable._registry[cls]:
raise ConfigurationError(
"{} is not a registered name for {}".format(
name, cls.__name__))
return Registrable._registry.get(name)