def from_params(cls,
params: Params,
instances: Iterable['adi.Instance'] = None):
choice = params.pop_choice('type',
cls.list_available(),
default_to_first_choice=True)
return cls.by_name(choice).from_params(params, instances)
def from_params(cls, model_parameters: List[torch.nn.Parameter], params: Params):
if isinstance(params, str):
optimizer = params
params = Params({})
else:
optimizer = params.pop_choice("type", Optimizer.list_available())
return Optimizer.by_name(optimizer)(model_parameters, **params.as_dict()) # type: ignore
def from_params(cls, params: Params) -> 'WordSplitter':
choice = params.pop_choice('type',
cls.list_available(),
default_to_first_choice=True)
# None of the word splitters take parameters, so we just make sure the parameters are empty
# here.
params.assert_empty('WordSplitter')
return cls.by_name(choice)()
def from_params(cls, params: Params):
from allennlp.experiments.registry import Registry
# TODO(Mark): The adaptive iterator will need a bit of work here,
# to retrieve the scaling function etc.
iterator_type = params.pop_choice("type",
Registry.list_data_iterators())
return Registry.get_data_iterator(iterator_type)(
**params.as_dict()) # type: ignore
def from_params(
cls, model: Model, task_list: List[Task], serialization_dir: str, params: Params
) -> "MultiTaskTrainer":
"""
Static method that constructs the multi task trainer described by ``params``.
"""
choice = params.pop_choice("type", cls.list_available())
return cls.by_name(choice).from_params(
model=model, task_list=task_list, serialization_dir=serialization_dir, params=params
)
def from_params(cls, params: Params) -> 'StanfordSentimentTreeBankDatasetReader':
token_indexers = TokenIndexer.dict_from_params(params.pop('token_indexers', {}))
use_subtrees = params.pop('use_subtrees', False)
granularity = params.pop_choice('granularity', ["5-class", "3-class", "2-class"], True)
lazy = params.pop('lazy', False)
params.assert_empty(cls.__name__)
return StanfordSentimentTreeBankDatasetReader(
token_indexers=token_indexers,
use_subtrees=use_subtrees,
granularity=granularity,
lazy=lazy)
def from_params(cls, vocab: Vocabulary, params: Params) -> 'Tagger':
token_representation_dim = params.pop_int("token_representation_dim")
encoder = params.pop("encoder", None)
if encoder is not None:
encoder = Seq2SeqEncoder.from_params(encoder)
decoder = params.pop("decoder", None)
if decoder is not None and not isinstance(decoder, str):
decoder = FeedForward.from_params(decoder)
use_crf = params.pop_bool("use_crf", False)
constrain_crf_decoding = params.pop_bool("constrain_crf_decoding", False)
include_start_end_transitions = params.pop_bool("include_start_end_transitions", True)
contextualizer = params.pop('contextualizer', None)
if contextualizer:
contextualizer = Contextualizer.from_params(contextualizer)
calculate_per_label_f1 = params.pop_bool("calculate_per_label_f1", False)
calculate_span_f1 = params.pop_bool("calculate_span_f1", False)
calculate_perplexity = params.pop_bool("calculate_perplexity", False)
loss_average = params.pop("loss_average", "batch")
label_encoding = params.pop_choice("label_encoding", [None, "BIO", "BIOUL", "IOB1"],
default_to_first_choice=True)
pretrained_file = params.pop("pretrained_file", None)
transfer_contextualizer_from_pretrained_file = params.pop_bool(
"transfer_contextualizer_from_pretrained_file", False)
transfer_encoder_from_pretrained_file = params.pop_bool(
"transfer_encoder_from_pretrained_file", False)
freeze_encoder = params.pop_bool("freeze_encoder", False)
initializer = InitializerApplicator.from_params(params.pop('initializer', []))
regularizer = RegularizerApplicator.from_params(params.pop('regularizer', []))
params.assert_empty(cls.__name__)
return cls(vocab=vocab,
token_representation_dim=token_representation_dim,
encoder=encoder,
decoder=decoder,
use_crf=use_crf,
constrain_crf_decoding=constrain_crf_decoding,
include_start_end_transitions=include_start_end_transitions,
label_encoding=label_encoding,
contextualizer=contextualizer,
calculate_per_label_f1=calculate_per_label_f1,
calculate_span_f1=calculate_span_f1,
calculate_perplexity=calculate_perplexity,
loss_average=loss_average,
pretrained_file=pretrained_file,
transfer_contextualizer_from_pretrained_file=transfer_contextualizer_from_pretrained_file,
transfer_encoder_from_pretrained_file=transfer_encoder_from_pretrained_file,
freeze_encoder=freeze_encoder,
initializer=initializer,
regularizer=regularizer)
def from_params(cls, params: Params) -> 'UniversalDatasetReader':
token_indexers = TokenIndexer.dict_from_params(
params.pop('token_indexers', {}))
use_subtrees = params.pop('use_subtrees', False)
granularity = params.pop_choice('granularity',
["5-class", "3-class", "2-class"],
True)
lazy = params.pop('lazy', False)
params.assert_empty(cls.__name__)
return UniversalDatasetReader(token_indexers=token_indexers,
use_subtrees=use_subtrees,
granularity=granularity,
lazy=lazy)
def from_params(cls, params: Params) -> 'MultiCorpusReader':
token_indexers_params = params.pop('token_indexers', {})
token_indexers = TokenIndexer.dict_from_params(token_indexers_params)
corpus_langmap = params.pop('corpus_langmap', None)
logger.info('corpus langmap %s', corpus_langmap)
shuffle_corpus = params.pop('shuffle_corpus', True)
corpus_readers_params: Dict = params.pop('corpus_readers', {})
corpus_readers = defaultdict()
for name, params in corpus_readers_params.items():
params['token_indexers'] = token_indexers_params
choice = params.pop_choice('type', DatasetReader.list_available())
corpus_readers[name] = DatasetReader.by_name(choice).from_params(
params)
# corpus_readers[name] = DatasetReader.from_params(**params)
lazy = params.pop('lazy', True)
params.assert_empty(cls.__name__)
return MultiCorpusReader(token_indexers=token_indexers,
corpus_readers=corpus_readers,
corpus_langmap=corpus_langmap,
shuffle_corpus=shuffle_corpus,
lazy=lazy)
def from_params(params: Params) -> 'WordSplitter':
choice = params.pop_choice('type', list(word_splitters.keys()), default_to_first_choice=True)
params.assert_empty('WordSplitter')
return word_splitters[choice]()
def from_params(cls, vocab: Vocabulary, params: Params) -> 'QuestionGenerator':
choice = params.pop_choice('type', cls.list_available())
return cls.by_name(choice).from_params(vocab, params)
def from_params(cls, params: Params) -> 'Attention':
clazz = cls.by_name(params.pop_choice("type", cls.list_available()))
return clazz.from_params(params)
def from_params(cls, params: Params) -> 'Seq2VecEncoder':
choice = params.pop_choice('type', cls.list_available())
return cls.by_name(choice).from_params(params)
def from_params(cls, vocab: Vocabulary, params: Params) -> 'TextFieldEmbedder':
choice = params.pop_choice('type', cls.list_available(), default_to_first_choice=True)
return cls.by_name(choice).from_params(vocab, params)
def from_params(cls, model_parameters: List, params: Params): # type: ignore
# pylint: disable=arguments-differ
if isinstance(params, str):
optimizer = params
params = Params({})
else:
optimizer = params.pop_choice("type", Optimizer.list_available())
# make the parameter groups if need
groups = params.pop("parameter_groups", None)
if groups:
# The input to the optimizer is list of dict.
# Each dict contains a "parameter group" and groups specific options,
# e.g., {'params': [list of parameters], 'lr': 1e-3, ...}
# Any config option not specified in the additional options (e.g.
# for the default group) is inherited from the top level config.
# see: http://pytorch.org/docs/0.3.0/optim.html?#per-parameter-options
#
# groups contains something like:
#"parameter_groups": [
# [["regex1", "regex2"], {"lr": 1e-3}],
# [["regex3"], {"lr": 1e-4}]
#]
#(note that the allennlp config files require double quotes ", and will
# fail (sometimes silently) with single quotes ').
# This is typed as as Any since the dict values other then
# the params key are passed to the Optimizer constructor and
# can be any type it accepts.
# In addition to any parameters that match group specific regex,
# we also need a group for the remaining "default" group.
# Those will be included in the last entry of parameter_groups.
parameter_groups: Any = [{'params': []} for _ in range(len(groups) + 1)]
# add the group specific kwargs
for k in range(len(groups)): # pylint: disable=consider-using-enumerate
parameter_groups[k].update(groups[k][1].as_dict())
regex_use_counts: Dict[str, int] = {}
parameter_group_names: List[set] = [set() for _ in range(len(groups) + 1)]
for name, param in model_parameters:
# Determine the group for this parameter.
group_index = None
for k, group_regexes in enumerate(groups):
for regex in group_regexes[0]:
if regex not in regex_use_counts:
regex_use_counts[regex] = 0
if re.search(regex, name):
if group_index is not None and group_index != k:
raise ValueError("{} was specified in two separate parameter groups".format(name))
group_index = k
regex_use_counts[regex] += 1
if group_index is not None:
parameter_groups[group_index]['params'].append(param)
parameter_group_names[group_index].add(name)
else:
# the default group
parameter_groups[-1]['params'].append(param)
parameter_group_names[-1].add(name)
# log the parameter groups
logger.info("Done constructing parameter groups.")
for k in range(len(groups) + 1):
group_options = {key: val for key, val in parameter_groups[k].items()
if key != 'params'}
logger.info("Group %s: %s, %s", k,
list(parameter_group_names[k]),
group_options)
# check for unused regex
for regex, count in regex_use_counts.items():
if count == 0:
logger.warning("When constructing parameter groups, "
" %s not match any parameter name", regex)
else:
parameter_groups = [param for name, param in model_parameters]
# Log the number of parameters to optimize
num_parameters = 0
for parameter_group in parameter_groups:
if isinstance(parameter_group, dict):
num_parameters += sum(parameter.numel() for parameter in parameter_group["params"])
else:
num_parameters += parameter_group.numel()
logger.info("Number of trainable parameters: %s", num_parameters)
# By default we cast things that e.g. look like floats to floats before handing them
# to the Optimizer constructor, but if you want to disable that behavior you could add a
# "infer_type_and_cast": false
# key to your "trainer.optimizer" config.
infer_type_and_cast = params.pop_bool("infer_type_and_cast", True)
params_as_dict = params.as_dict(infer_type_and_cast=infer_type_and_cast)
return Optimizer.by_name(optimizer)(parameter_groups, **params_as_dict) # type: ignore
def from_params(cls, params: Params) -> 'HCNEntityTracker':
"""
Static method that constructs the dataset reader described by ``params``.
"""
choice = params.pop_choice('type', cls.list_available())
return cls.by_name(choice).from_params(params)
def from_params(cls, model_parameters , params ): # type: ignore
# pylint: disable=arguments-differ
if isinstance(params, unicode):
optimizer = params
params = Params({})
else:
optimizer = params.pop_choice(u"type", Optimizer.list_available())
# make the parameter groups if need
groups = params.pop(u"parameter_groups", None)
if groups:
# The input to the optimizer is list of dict.
# Each dict contains a "parameter group" and groups specific options,
# e.g., {'params': [list of parameters], 'lr': 1e-3, ...}
# Any config option not specified in the additional options (e.g.
# for the default group) is inherited from the top level config.
# see: http://pytorch.org/docs/0.3.0/optim.html?#per-parameter-options
#
# groups contains something like:
#"parameter_groups": [
# [["regex1", "regex2"], {"lr": 1e-3},
# ["regex3"], {"lr": 1e-4}]
#]
#(note that the allennlp config files require double quotes ", and will
# fail (sometimes silently) with single quotes ').
# This is typed as as Any since the dict values other then
# the params key are passed to the Optimizer constructor and
# can be any type it accepts.
# In addition to any parameters that match group specific regex,
# we also need a group for the remaining "default" group.
# Those will be included in the last entry of parameter_groups.
parameter_groups = [{u'params': []} for _ in range(len(groups) + 1)]
# add the group specific kwargs
for k in range(len(groups)): # pylint: disable=consider-using-enumerate
parameter_groups[k].update(groups[k][1].as_dict())
regex_use_counts = {}
parameter_group_names = [set() for _ in range(len(groups) + 1)]
for name, param in model_parameters:
# Determine the group for this parameter.
group_index = None
for k, group_regexes in enumerate(groups):
for regex in group_regexes[0]:
if regex not in regex_use_counts:
regex_use_counts[regex] = 0
if re.search(regex, name):
if group_index is not None and group_index != k:
raise ValueError(u"{} was specified in two separate parameter groups".format(name))
group_index = k
regex_use_counts[regex] += 1
if group_index is not None:
parameter_groups[group_index][u'params'].append(param)
parameter_group_names[group_index].add(name)
else:
# the default group
parameter_groups[-1][u'params'].append(param)
parameter_group_names[-1].add(name)
# log the parameter groups
logger.info(u"Done constructing parameter groups.")
for k in range(len(groups) + 1):
group_options = dict((key, val) for key, val in list(parameter_groups[k].items())
if key != u'params')
logger.info(u"Group %s: %s, %s", k,
list(parameter_group_names[k]),
group_options)
# check for unused regex
for regex, count in list(regex_use_counts.items()):
if count == 0:
logger.warning(u"When constructing parameter groups, "
u" %s not match any parameter name", regex)
else:
parameter_groups = [param for name, param in model_parameters]
# Log the number of parameters to optimize
num_parameters = 0
for parameter_group in parameter_groups:
if isinstance(parameter_group, dict):
num_parameters += sum(parameter.numel() for parameter in parameter_group[u"params"])
else:
num_parameters += parameter_group.numel()
logger.info(u"Number of trainable parameters: %s", num_parameters)
return Optimizer.by_name(optimizer)(parameter_groups, **params.as_dict()) # type: ignore
def from_params(cls, params: Params) -> 'DatasetReader':
"""
Static method that constructs the dataset reader described by ``params``.
"""
choice = params.pop_choice('type', cls.list_available())
return cls.by_name(choice).from_params(params)
def from_params(cls, params: Params) -> 'WordFilter':
choice = params.pop_choice('type', cls.list_available(), default_to_first_choice=True)
params.assert_empty('WordFilter')
return cls.by_name(choice)()
def from_params(cls, params: Params) -> 'SimilarityFunction':
choice = params.pop_choice('type', cls.list_available(), default_to_first_choice=True)
return cls.by_name(choice).from_params(params)
def from_params(cls, params: Params) -> 'TokenIndexer': # type: ignore
choice = params.pop_choice('type', cls.list_available(), default_to_first_choice=True)
return cls.by_name(choice).from_params(params)
def from_params(cls, params: Params) -> 'DataIterator':
# TODO(Mark): The adaptive iterator will need a bit of work here,
# to retrieve the scaling function etc.
iterator_type = params.pop_choice("type", cls.list_available())
return cls.by_name(iterator_type).from_params(params)
def from_params(
cls: Type["Step"],
params: Params,
constructor_to_call: Callable[..., "Step"] = None,
constructor_to_inspect: Union[Callable[..., "Step"],
Callable[["Step"], None]] = None,
existing_steps: Optional[Dict[str, "Step"]] = None,
step_name: Optional[str] = None,
**extras,
) -> "Step":
# Why do we need a custom from_params? Step classes have a run() method that takes all the
# parameters necessary to perform the step. The __init__() method of the step takes those
# same parameters, but each of them could be wrapped in another Step instead of being
# supplied directly. from_params() doesn't know anything about these shenanigans, so
# we have to supply the necessary logic here.
if constructor_to_call is not None:
raise ConfigurationError(
f"{cls.__name__}.from_params cannot be called with a constructor_to_call."
)
if constructor_to_inspect is not None:
raise ConfigurationError(
f"{cls.__name__}.from_params cannot be called with a constructor_to_inspect."
)
if existing_steps is None:
existing_steps = {}
if isinstance(params, str):
params = Params({"type": params})
if not isinstance(params, Params):
raise ConfigurationError(
"from_params was passed a `params` object that was not a `Params`. This probably "
"indicates malformed parameters in a configuration file, where something that "
"should have been a dictionary was actually a list, or something else. "
f"This happened when constructing an object of type {cls}.")
as_registrable = cast(Type[Registrable], cls)
choice = params.pop_choice("type",
choices=as_registrable.list_available(),
default_to_first_choice=True)
subclass, constructor_name = as_registrable.resolve_class_name(choice)
if not issubclass(subclass, Step):
# This can happen if `choice` is a fully qualified name.
raise ConfigurationError(
f"Tried to make a Step of type {choice}, but ended up with a {subclass}."
)
parameters = infer_method_params(subclass, subclass.run)
del parameters["self"]
init_parameters = infer_constructor_params(subclass)
del init_parameters["self"]
del init_parameters["kwargs"]
parameter_overlap = parameters.keys() & init_parameters.keys()
assert len(parameter_overlap) <= 0, (
f"If this assert fails it means that you wrote a Step with a run() method that takes one of the "
f"reserved parameters ({', '.join(init_parameters.keys())})")
parameters.update(init_parameters)
kwargs: Dict[str, Any] = {}
accepts_kwargs = False
for param_name, param in parameters.items():
if param.kind == param.VAR_KEYWORD:
# When a class takes **kwargs we store the fact that the method allows extra keys; if
# we get extra parameters, instead of crashing, we'll just pass them as-is to the
# constructor, and hope that you know what you're doing.
accepts_kwargs = True
continue
explicitly_set = param_name in params
constructed_arg = pop_and_construct_arg(
subclass.__name__,
param_name,
param.annotation,
param.default,
params,
existing_steps=existing_steps,
**extras,
)
# If the param wasn't explicitly set in `params` and we just ended up constructing
# the default value for the parameter, we can just omit it.
# Leaving it in can cause issues with **kwargs in some corner cases, where you might end up
# with multiple values for a single parameter (e.g., the default value gives you lazy=False
# for a dataset reader inside **kwargs, but a particular dataset reader actually hard-codes
# lazy=True - the superclass sees both lazy=True and lazy=False in its constructor).
if explicitly_set or constructed_arg is not param.default:
kwargs[param_name] = constructed_arg
if accepts_kwargs:
kwargs.update(params)
else:
params.assert_empty(subclass.__name__)
return subclass(step_name=step_name, **kwargs)
def from_params(cls, vocab: Vocabulary, params: Params) -> 'TextFieldEmbedder':
choice = params.pop_choice('type', cls.list_available(), default_to_first_choice=True)
return cls.by_name(choice).from_params(vocab, params)
def from_params(cls, params: Params):
from allennlp.experiments.registry import Registry
choice = params.pop_choice('type', Registry.list_dataset_readers())
return Registry.get_dataset_reader(choice).from_params(params)
def from_params(cls, params: Params) -> 'DataIterator':
iterator_type = params.pop_choice("type", cls.list_available())
return cls.by_name(iterator_type).from_params(params)
def from_params(cls, model_parameters: List, params: Params): # type: ignore
# pylint: disable=arguments-differ
if isinstance(params, str):
optimizer = params
params = Params({})
else:
optimizer = params.pop_choice("type", Optimizer.list_available())
# make the parameter groups if need
groups = params.pop("parameter_groups", None)
if groups:
# The input to the optimizer is list of dict.
# Each dict contains a "parameter group" and groups specific options,
# e.g., {'params': [list of parameters], 'lr': 1e-3, ...}
# Any config option not specified in the additional options (e.g.
# for the default group) is inherited from the top level config.
# see: https://pytorch.org/docs/0.3.0/optim.html?#per-parameter-options
#
# groups contains something like:
#"parameter_groups": [
# [["regex1", "regex2"], {"lr": 1e-3}],
# [["regex3"], {"lr": 1e-4}]
#]
#(note that the allennlp config files require double quotes ", and will
# fail (sometimes silently) with single quotes ').
# This is typed as as Any since the dict values other then
# the params key are passed to the Optimizer constructor and
# can be any type it accepts.
# In addition to any parameters that match group specific regex,
# we also need a group for the remaining "default" group.
# Those will be included in the last entry of parameter_groups.
parameter_groups: Any = [{'params': []} for _ in range(len(groups) + 1)]
# add the group specific kwargs
for k in range(len(groups)): # pylint: disable=consider-using-enumerate
parameter_groups[k].update(groups[k][1].as_dict())
regex_use_counts: Dict[str, int] = {}
parameter_group_names: List[set] = [set() for _ in range(len(groups) + 1)]
for name, param in model_parameters:
# Determine the group for this parameter.
group_index = None
for k, group_regexes in enumerate(groups):
for regex in group_regexes[0]:
if regex not in regex_use_counts:
regex_use_counts[regex] = 0
if re.search(regex, name):
if group_index is not None and group_index != k:
raise ValueError("{} was specified in two separate parameter groups".format(name))
group_index = k
regex_use_counts[regex] += 1
if group_index is not None:
parameter_groups[group_index]['params'].append(param)
parameter_group_names[group_index].add(name)
else:
# the default group
parameter_groups[-1]['params'].append(param)
parameter_group_names[-1].add(name)
# log the parameter groups
logger.info("Done constructing parameter groups.")
for k in range(len(groups) + 1):
group_options = {key: val for key, val in parameter_groups[k].items()
if key != 'params'}
logger.info("Group %s: %s, %s", k,
list(parameter_group_names[k]),
group_options)
# check for unused regex
for regex, count in regex_use_counts.items():
if count == 0:
logger.warning("When constructing parameter groups, "
" %s not match any parameter name", regex)
else:
parameter_groups = [param for name, param in model_parameters]
# Log the number of parameters to optimize
num_parameters = 0
for parameter_group in parameter_groups:
if isinstance(parameter_group, dict):
num_parameters += sum(parameter.numel() for parameter in parameter_group["params"])
else:
num_parameters += parameter_group.numel()
logger.info("Number of trainable parameters: %s", num_parameters)
# By default we cast things that e.g. look like floats to floats before handing them
# to the Optimizer constructor, but if you want to disable that behavior you could add a
# "infer_type_and_cast": false
# key to your "trainer.optimizer" config.
infer_type_and_cast = params.pop_bool("infer_type_and_cast", True)
params_as_dict = params.as_dict(infer_type_and_cast=infer_type_and_cast)
subclass = Optimizer.by_name(optimizer)
# If the optimizer subclass has a from_params, use it.
if hasattr(subclass, 'from_params'):
return subclass.from_params(parameter_groups, params=params)
else:
return subclass(parameter_groups, **params_as_dict) # type: ignore
def from_params(cls, params: Params) -> 'WordStemmer':
choice = params.pop_choice('type', cls.list_available(), default_to_first_choice=True)
params.assert_empty('WordStemmer')
return cls.by_name(choice)()
def from_params(cls, vocab: Vocabulary, params: Params):
from allennlp.experiments.registry import Registry
choice = params.pop_choice('type', Registry.list_token_embedders())
return Registry.get_token_embedder(choice).from_params(vocab, params)
def from_params(cls, params: Params): # type: ignore
from allennlp.experiments.registry import Registry
choice = params.pop_choice('type',
Registry.list_token_indexers(),
default_to_first_choice=True)
return Registry.get_token_indexer(choice).from_params(params)
def from_params(cls, vocab: Vocabulary, params: Params):
from allennlp.experiments.registry import Registry
choice = params.pop_choice('type', Registry.list_text_field_embedders(), default_to_first_choice=True)
return Registry.get_text_field_embedder(choice).from_params(vocab, params)
def from_params(cls, params: Params) -> 'Tokenizer':
choice = params.pop_choice('type',
cls.list_available(),
default_to_first_choice=True)
return cls.by_name(choice).from_params(params)
def from_params(cls, params: Params) -> 'SimilarityFunction':
choice = params.pop_choice('type', cls.list_available())
return cls.by_name(choice).from_params(params)
def from_params(cls, vocab: Vocabulary, params: Params) -> 'TokenEmbedder':
choice = params.pop_choice('type', cls.list_available())
return cls.by_name(choice).from_params(vocab, params)
def from_params(cls, model_parameters: List, params: Params):
if isinstance(params, str):
optimizer = params
params = Params({})
else:
optimizer = params.pop_choice("type", Optimizer.list_available())
# make the parameter groups if need
groups = params.pop("parameter_groups", None)
if groups:
# input to optimizer is list of dict
# each dict contains {'params': [list of parameters], 'lr': 1e-3, ...}
# Any config option not specified in the additional options (e.g.
# for the default group) is inherited from the top level config.
# see: http://pytorch.org/docs/0.3.0/optim.html?#per-parameter-options
#
# groups contains something like:
#"parameter_groups": [
# [['regex1', 'regex2'], {'lr': 1e-3},
# ['regex3'], {'lr': 1e-4}]
#]
#
# The last entry of this list is for the parameters not in any regex.
#
# This is typed as as Any since the dict values other then
# the params key are passed to the Optimizer constructor and
# can be any type it accepts.
parameter_groups: Any = [{
'params': []
} for _ in range(len(groups) + 1)]
# add the group specific kwargs
for k in range(len(groups)): # pylint: disable=consider-using-enumerate
parameter_groups[k].update(groups[k][1].as_dict())
regex_use_counts: Dict[str, int] = {}
parameter_group_names: List[set] = [
set() for _ in range(len(groups) + 1)
]
for name, param in model_parameters:
# Determine the group for this parameter.
group_index = None
for k, group_regexes in enumerate(groups):
for regex in group_regexes[0]:
if regex not in regex_use_counts:
regex_use_counts[regex] = 0
if re.search(regex, name):
if group_index is not None and group_index != k:
raise ValueError(
"{} was specified in two separate parameter groups"
.format(name))
group_index = k
regex_use_counts[regex] += 1
if group_index is not None:
parameter_groups[group_index]['params'].append(param)
parameter_group_names[group_index].add(name)
else:
# the default group
parameter_groups[-1]['params'].append(param)
parameter_group_names[-1].add(name)
# log the parameter groups
logger.info("Done constructing parameter groups.")
for k in range(len(groups) + 1):
group_options = {
key: val
for key, val in parameter_groups[k].items()
if key != 'params'
}
print("Group {0}: {1}, {2}".format(
k, list(parameter_group_names[k]), group_options))
# check for unused regex
for regex, count in regex_use_counts.items():
if count == 0:
logger.warning(
"When constructing parameter groups, "
" %s not match any parameter name", regex)
else:
parameter_groups = [param for name, param in model_parameters]
return Optimizer.by_name(optimizer)(parameter_groups,
**params.as_dict()) # type: ignore
def from_params(cls, params: Params) -> 'WordSplitter':
choice = params.pop_choice('type', cls.list_available(), default_to_first_choice=True)
return cls.by_name(choice).from_params(params)
def from_params(cls, params: Params) -> 'Seq2SeqEncoder':
choice = params.pop_choice('type', cls.list_available())
return cls.by_name(choice).from_params(params)
