Config & Registry

Function registry and configuration system

Config class

This class holds the model and training configuration and can load and save the INI-style configuration format from/to a string, file or bytes. The Config class is a subclass of dict and uses Python’s ConfigParser under the hood.

Config.__init__ method

Initialize a new Config object with optional data.

Examplefrom thinc.api import Config

config = Config({"training": {"patience": 10, "dropout": 0.2}})

Config.from_str method

Load the config from a string.

Examplefrom thinc.api import Config

config_str = """
[training]
patience = 10
dropout = 0.2
"""
config = Config().from_str(config_str)
print(config["training"])  # {'patience': 10, 'dropout': 0.2}}

Config.to_str method

Write the config to a string.

Examplefrom thinc.api import Config

config = Config({"training": {"patience": 10, "dropout": 0.2}})
print(config.to_str()) # '[training]\npatience = 10\n\ndropout = 0.2'

Config.to_bytes method

Serialize the config to a byte string.

Examplefrom thinc.api import Config

config = Config({"training": {"patience": 10, "dropout": 0.2}})
config_bytes = config.to_bytes()
print(config_bytes)  # b'[training]\npatience = 10\n\ndropout = 0.2'

Config.from_bytes method

Load the config from a byte string.

Examplefrom thinc.api import Config

config = Config({"training": {"patience": 10, "dropout": 0.2}})
config_bytes = config.to_bytes()
new_config = Config().from_bytes(config_bytes)

Config.to_disk method

Serialize the config to a file.

Examplefrom thinc.api import Config

config = Config({"training": {"patience": 10, "dropout": 0.2}})
config.to_disk("./config.cfg")

Config.from_disk method

Load the config from a file.

Examplefrom thinc.api import Config

config = Config({"training": {"patience": 10, "dropout": 0.2}})
config.to_disk("./config.cfg")
new_config = Config().from_disk("./config.cfg")

Config.copy method

Deep-copy the config.

Config.interpolate method

Interpolate variables like ${section.value} or ${section.subsection} and return a copy of the config with interpolated values. Can be used if a config is loaded with interpolate=False, e.g. via Config.from_str.

Examplefrom thinc.api import Config

config_str = """
[hyper_params]
dropout = 0.2

[training]
dropout = ${hyper_params.dropout}
"""
config = Config().from_str(config_str, interpolate=False)
print(config["training"])  # {'dropout': '${hyper_params.dropout}'}}
config = config.interpolate()
print(config["training"])  # {'dropout': 0.2}}

Config.merge method

Deep-merge two config objects, using the current config as the default. Only merges sections and dictionaries and not other values like lists. Values that are provided in the updates are overwritten in the base config, and any new values or sections are added. If a config value is a variable like ${section.key} (e.g. if the config was loaded with interpolate=False), the variable is preferred, even if the updates provide a different value. This ensures that variable references aren’t destroyed by a merge.

Examplefrom thinc.api import Config

base_config_str = """
[training]
patience = 10
dropout = 0.2
"""
update_config_str = """
[training]
dropout = 0.1
max_epochs = 2000
"""

base_config = Config().from_str(base_config_str)
update_config = Config().from_str(update_config_str)
merged = Config(base_config).merge(update_config)
print(merged["training"])  # {'patience': 10, 'dropout': 1.0, 'max_epochs': 2000}

Config Attributes

Registry class

Thinc’s registry system lets you map string keys to functions. You can register functions to create optimizers, schedules, layers and more, and then refer to them and set their arguments in your config file. Python type hints are used to validate the inputs.

Exampleimport thinc

@thinc.registry.optimizers.register("my_cool_optimizer.v1")
def make_my_optimizer(learn_rate: float, gamma: float):
    return MyCoolOptimizer(learn_rate, gamma)

Valid Config[optimizer]
@optimizers = "my_cool_optimizer.v1"
learn_rate = 0.001
gamma = 1e-8

Invalid Config[optimizer]
@optimizers = "my_cool_optimizer.v1"
learn_rate = 1  # not a float
schedules = null  # unknown argument

Attributes

registry.get classmethod

Get a registered function from a given registry using string names. Will raise an error if the registry or function doesn’t exist. All individual registries also have a get method to get a registered function.

Exampleimport thinc

registered_func = thinc.registry.get("optimizers", "my_cool_optimizer.v1")
# The above is the same as:
registered_func = thinc.registry.optimizers.get("my_cool_optimizer.v1")

registry.create classmethod

Create a new function registry that will become available as an attribute to registry. Will raise an error if a registry of the name already exists. Under the hood, this calls into catalogue.create using the "thinc" namespace.

Exampleimport thinc

thinc.registry.create("visualizers")

@thinc.registry.visualizers("my_cool_visualizer.v1")
def my_cool_visualizer(format: str = "jpg") -> "MyCoolVisualizer":
    return MyCoolVisualizer(format)

registry.fill classmethod

Unpack a config dictionary, but leave all references to registry functions intact and don’t resolve them. Only use the type annotations and optional base schema to fill in all arguments and their default values. This method is especially useful for getting an existing config up to date with changes in the schema and/or function arguments. If the config is incomplete and contains missing values for required arguments, you can set validate=False to skip validation and only update it. The updated schema should then pass validation.

If the provided Config still includes references to variables, e.g. if it was loaded with interpolate=False using a method like Config.from_str, a copy of the config is interpolated so it can be filled, and a filled version with the variables intact is returned. This means you can auto-fill partial config, without destroying the variables.

Examplefrom thinc.api import Config, registry

cfg = Config().from_disk("./my_config.cfg")
filled_cfg = registry.fill(cfg)

registry.resolve classmethod

Unpack a config dictionary, creating objects from the registry recursively. If a section contains a key beginning with @, the rest of that key will be interpreted as the name of the registry. For instance, "@optimizers": "my_cool_optimizer.v1" will load the function from the optimizers registry and pass in the specified arguments. For more details and examples, see the docs on Thinc’s config system.

Examplefrom thinc.api import Config, registry

cfg = Config().from_disk("./my_config.cfg")
resolved = registry.resolve(cfg)