def from_params(cls, vocab: Vocabulary, params: Params) -> 'ElmoTokenEmbedder': # type: ignore
# pylint: disable=arguments-differ
params.add_file_to_archive('options_file')
params.add_file_to_archive('weight_file')
options_file = params.pop('options_file')
weight_file = params.pop('weight_file')
requires_grad = params.pop('requires_grad', False)
do_layer_norm = params.pop_bool('do_layer_norm', False)
dropout = params.pop_float("dropout", 0.5)
namespace_to_cache = params.pop("namespace_to_cache", None)
if namespace_to_cache is not None:
vocab_to_cache = list(vocab.get_token_to_index_vocabulary(namespace_to_cache).keys())
else:
vocab_to_cache = None
projection_dim = params.pop_int("projection_dim", None)
scalar_mix_parameters = params.pop('scalar_mix_parameters', None)
params.assert_empty(cls.__name__)
return cls(options_file=options_file,
weight_file=weight_file,
do_layer_norm=do_layer_norm,
dropout=dropout,
requires_grad=requires_grad,
projection_dim=projection_dim,
vocab_to_cache=vocab_to_cache,
scalar_mix_parameters=scalar_mix_parameters)
def from_params(cls, params: Params) -> 'WordSplitter':
language = params.pop('language', 'en_core_web_sm')
pos_tags = params.pop_bool('pos_tags', False)
parse = params.pop_bool('parse', False)
ner = params.pop_bool('ner', False)
params.assert_empty(cls.__name__)
return cls(language, pos_tags, parse, ner)
def extend_from_instances(self,
params: Params,
instances: Iterable['adi.Instance'] = ()) -> None:
"""
Extends an already generated vocabulary using a collection of instances.
"""
min_count = params.pop("min_count", None)
max_vocab_size = pop_max_vocab_size(params)
non_padded_namespaces = params.pop("non_padded_namespaces", DEFAULT_NON_PADDED_NAMESPACES)
pretrained_files = params.pop("pretrained_files", {})
min_pretrained_embeddings = params.pop("min_pretrained_embeddings", None)
only_include_pretrained_words = params.pop_bool("only_include_pretrained_words", False)
tokens_to_add = params.pop("tokens_to_add", None)
params.assert_empty("Vocabulary - from dataset")
logger.info("Fitting token dictionary from dataset.")
namespace_token_counts: Dict[str, Dict[str, int]] = defaultdict(lambda: defaultdict(int))
for instance in Tqdm.tqdm(instances):
instance.count_vocab_items(namespace_token_counts)
self._extend(counter=namespace_token_counts,
min_count=min_count,
max_vocab_size=max_vocab_size,
non_padded_namespaces=non_padded_namespaces,
pretrained_files=pretrained_files,
only_include_pretrained_words=only_include_pretrained_words,
tokens_to_add=tokens_to_add,
min_pretrained_embeddings=min_pretrained_embeddings)
def from_params(cls, vocab: Vocabulary, params: Params) -> 'SpanConstituencyParser':
embedder_params = params.pop("text_field_embedder")
text_field_embedder = TextFieldEmbedder.from_params(vocab, embedder_params)
span_extractor = SpanExtractor.from_params(params.pop("span_extractor"))
encoder = Seq2SeqEncoder.from_params(params.pop("encoder"))
feed_forward_params = params.pop("feedforward", None)
if feed_forward_params is not None:
feedforward_layer = FeedForward.from_params(feed_forward_params)
else:
feedforward_layer = None
pos_tag_embedding_params = params.pop("pos_tag_embedding", None)
if pos_tag_embedding_params is not None:
pos_tag_embedding = Embedding.from_params(vocab, pos_tag_embedding_params)
else:
pos_tag_embedding = None
initializer = InitializerApplicator.from_params(params.pop('initializer', []))
regularizer = RegularizerApplicator.from_params(params.pop('regularizer', []))
evalb_directory_path = params.pop("evalb_directory_path", None)
params.assert_empty(cls.__name__)
return cls(vocab=vocab,
text_field_embedder=text_field_embedder,
span_extractor=span_extractor,
encoder=encoder,
feedforward_layer=feedforward_layer,
pos_tag_embedding=pos_tag_embedding,
initializer=initializer,
regularizer=regularizer,
evalb_directory_path=evalb_directory_path)
def from_params(cls, vocab: Vocabulary, params: Params) -> 'DecomposableAttention':
embedder_params = params.pop("text_field_embedder")
text_field_embedder = TextFieldEmbedder.from_params(vocab, embedder_params)
premise_encoder_params = params.pop("premise_encoder", None)
if premise_encoder_params is not None:
premise_encoder = Seq2SeqEncoder.from_params(premise_encoder_params)
else:
premise_encoder = None
hypothesis_encoder_params = params.pop("hypothesis_encoder", None)
if hypothesis_encoder_params is not None:
hypothesis_encoder = Seq2SeqEncoder.from_params(hypothesis_encoder_params)
else:
hypothesis_encoder = None
attend_feedforward = FeedForward.from_params(params.pop('attend_feedforward'))
similarity_function = SimilarityFunction.from_params(params.pop("similarity_function"))
compare_feedforward = FeedForward.from_params(params.pop('compare_feedforward'))
aggregate_feedforward = FeedForward.from_params(params.pop('aggregate_feedforward'))
initializer = InitializerApplicator.from_params(params.pop('initializer', []))
regularizer = RegularizerApplicator.from_params(params.pop('regularizer', []))
params.assert_empty(cls.__name__)
return cls(vocab=vocab,
text_field_embedder=text_field_embedder,
attend_feedforward=attend_feedforward,
similarity_function=similarity_function,
compare_feedforward=compare_feedforward,
aggregate_feedforward=aggregate_feedforward,
premise_encoder=premise_encoder,
hypothesis_encoder=hypothesis_encoder,
initializer=initializer,
regularizer=regularizer)
def from_params(cls, params: Params) -> 'PennTreeBankConstituencySpanDatasetReader':
token_indexers = TokenIndexer.dict_from_params(params.pop('token_indexers', {}))
use_pos_tags = params.pop('use_pos_tags', True)
lazy = params.pop('lazy', False)
params.assert_empty(cls.__name__)
return PennTreeBankConstituencySpanDatasetReader(token_indexers=token_indexers,
use_pos_tags=use_pos_tags,
lazy=lazy)
def from_params(cls, params: Params) -> 'BasicIterator':
batch_size = params.pop_int('batch_size', 32)
instances_per_epoch = params.pop_int('instances_per_epoch', None)
max_instances_in_memory = params.pop_int('max_instances_in_memory', None)
params.assert_empty(cls.__name__)
return cls(batch_size=batch_size,
instances_per_epoch=instances_per_epoch,
max_instances_in_memory=max_instances_in_memory)
def from_params(cls, vocab: Vocabulary, params: Params) -> 'BasicTextFieldEmbedder':
token_embedders = {}
keys = list(params.keys())
for key in keys:
embedder_params = params.pop(key)
token_embedders[key] = TokenEmbedder.from_params(vocab, embedder_params)
params.assert_empty(cls.__name__)
return cls(token_embedders)
def from_params(cls, params: Params) -> 'SnliReader':
tokenizer = Tokenizer.from_params(params.pop('tokenizer', {}))
token_indexers = TokenIndexer.dict_from_params(params.pop('token_indexers', {}))
lazy = params.pop('lazy', False)
params.assert_empty(cls.__name__)
return SnliReader(tokenizer=tokenizer,
token_indexers=token_indexers,
lazy=lazy)
def from_params(cls, params: Params) -> 'SrlReader':
token_indexers = TokenIndexer.dict_from_params(params.pop('token_indexers', {}))
domain_identifier = params.pop("domain_identifier", None)
lazy = params.pop('lazy', False)
params.assert_empty(cls.__name__)
return SrlReader(token_indexers=token_indexers,
domain_identifier=domain_identifier,
lazy=lazy)
def from_params(cls, params: Params) -> 'LinearSimilarity':
tensor_1_dim = params.pop_int("tensor_1_dim")
tensor_2_dim = params.pop_int("tensor_2_dim")
combination = params.pop("combination", "x,y")
activation = Activation.by_name(params.pop("activation", "linear"))()
params.assert_empty(cls.__name__)
return cls(tensor_1_dim=tensor_1_dim,
tensor_2_dim=tensor_2_dim,
combination=combination,
activation=activation)
def from_params(cls, params: Params) -> 'SequenceTaggingDatasetReader':
token_indexers = TokenIndexer.dict_from_params(params.pop('token_indexers', {}))
word_tag_delimiter = params.pop("word_tag_delimiter", DEFAULT_WORD_TAG_DELIMITER)
token_delimiter = params.pop("token_delimiter", None)
lazy = params.pop('lazy', False)
params.assert_empty(cls.__name__)
return SequenceTaggingDatasetReader(token_indexers=token_indexers,
word_tag_delimiter=word_tag_delimiter,
token_delimiter=token_delimiter,
lazy=lazy)
def from_params(cls, params: Params) -> 'CharacterTokenizer':
byte_encoding = params.pop('byte_encoding', None)
lowercase_characters = params.pop('lowercase_characters', False)
start_tokens = params.pop('start_tokens', None)
end_tokens = params.pop('end_tokens', None)
params.assert_empty(cls.__name__)
return cls(byte_encoding=byte_encoding,
lowercase_characters=lowercase_characters,
start_tokens=start_tokens,
end_tokens=end_tokens)
def from_params(cls, vocab: Vocabulary, params: Params) -> 'ElmoTokenEmbedder':
params.add_file_to_archive('options_file')
params.add_file_to_archive('weight_file')
options_file = params.pop('options_file')
weight_file = params.pop('weight_file')
requires_grad = params.pop('requires_grad', False)
do_layer_norm = params.pop_bool('do_layer_norm', False)
dropout = params.pop_float("dropout", 0.5)
params.assert_empty(cls.__name__)
return cls(options_file, weight_file, do_layer_norm, dropout, requires_grad=requires_grad)
def from_params(cls, params: Params) -> 'Conll2003DatasetReader':
token_indexers = TokenIndexer.dict_from_params(params.pop('token_indexers', {}))
tag_label = params.pop('tag_label', None)
feature_labels = params.pop('feature_labels', ())
lazy = params.pop('lazy', False)
params.assert_empty(cls.__name__)
return Conll2003DatasetReader(token_indexers=token_indexers,
tag_label=tag_label,
feature_labels=feature_labels,
lazy=lazy)
def from_params(cls, params: Params) -> 'LanguageModelingReader':
tokens_per_instance = params.pop_int('tokens_per_instance', None)
tokenizer = Tokenizer.from_params(params.pop('tokenizer', {}))
token_indexers = TokenIndexer.dict_from_params(params.pop('token_indexers', {}))
lazy = params.pop('lazy', False)
params.assert_empty(cls.__name__)
return LanguageModelingReader(tokens_per_instance=tokens_per_instance,
tokenizer=tokenizer,
token_indexers=token_indexers,
lazy=lazy)
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, params: Params) -> 'CnnEncoder':
embedding_dim = params.pop_int('embedding_dim')
output_dim = params.pop_int('output_dim', None)
num_filters = params.pop_int('num_filters')
conv_layer_activation = Activation.by_name(params.pop("conv_layer_activation", "relu"))()
ngram_filter_sizes = tuple(params.pop('ngram_filter_sizes', [2, 3, 4, 5]))
params.assert_empty(cls.__name__)
return cls(embedding_dim=embedding_dim,
num_filters=num_filters,
ngram_filter_sizes=ngram_filter_sizes,
conv_layer_activation=conv_layer_activation,
output_dim=output_dim)
def from_params(cls, params: Params) -> 'WordTokenizer':
word_splitter = WordSplitter.from_params(params.pop('word_splitter', {}))
word_filter = WordFilter.from_params(params.pop('word_filter', {}))
word_stemmer = WordStemmer.from_params(params.pop('word_stemmer', {}))
start_tokens = params.pop('start_tokens', None)
end_tokens = params.pop('end_tokens', None)
params.assert_empty(cls.__name__)
return cls(word_splitter=word_splitter,
word_filter=word_filter,
word_stemmer=word_stemmer,
start_tokens=start_tokens,
end_tokens=end_tokens)
def from_params(cls, vocab: Vocabulary, params: Params) -> 'TokenCharactersEncoder': # type: ignore
# pylint: disable=arguments-differ
embedding_params: Params = params.pop("embedding")
# Embedding.from_params() uses "tokens" as the default namespace, but we need to change
# that to be "token_characters" by default.
embedding_params.setdefault("vocab_namespace", "token_characters")
embedding = Embedding.from_params(vocab, embedding_params)
encoder_params: Params = params.pop("encoder")
encoder = Seq2VecEncoder.from_params(encoder_params)
dropout = params.pop_float("dropout", 0.0)
params.assert_empty(cls.__name__)
return cls(embedding, encoder, dropout)
def from_params(cls, vocab: Vocabulary, params: Params) -> 'SimpleTagger':
embedder_params = params.pop("text_field_embedder")
text_field_embedder = TextFieldEmbedder.from_params(vocab, embedder_params)
encoder = Seq2SeqEncoder.from_params(params.pop("encoder"))
initializer = InitializerApplicator.from_params(params.pop('initializer', []))
regularizer = RegularizerApplicator.from_params(params.pop('regularizer', []))
params.assert_empty(cls.__name__)
return cls(vocab=vocab,
text_field_embedder=text_field_embedder,
encoder=encoder,
initializer=initializer,
regularizer=regularizer)
def from_params(cls,
model: Model,
serialization_dir: str,
iterator: DataIterator,
train_data: Iterable[Instance],
validation_data: Optional[Iterable[Instance]],
params: Params,
validation_iterator: DataIterator = None) -> 'Trainer':
patience = params.pop_int("patience", None)
validation_metric = params.pop("validation_metric", "-loss")
num_epochs = params.pop_int("num_epochs", 20)
cuda_device = params.pop_int("cuda_device", -1)
grad_norm = params.pop_float("grad_norm", None)
grad_clipping = params.pop_float("grad_clipping", None)
lr_scheduler_params = params.pop("learning_rate_scheduler", None)
if cuda_device >= 0:
model = model.cuda(cuda_device)
parameters = [[n, p] for n, p in model.named_parameters() if p.requires_grad]
optimizer = Optimizer.from_params(parameters, params.pop("optimizer"))
if lr_scheduler_params:
scheduler = LearningRateScheduler.from_params(optimizer, lr_scheduler_params)
else:
scheduler = None
num_serialized_models_to_keep = params.pop_int("num_serialized_models_to_keep", 20)
keep_serialized_model_every_num_seconds = params.pop_int(
"keep_serialized_model_every_num_seconds", None)
model_save_interval = params.pop_float("model_save_interval", None)
summary_interval = params.pop_int("summary_interval", 100)
histogram_interval = params.pop_int("histogram_interval", None)
params.assert_empty(cls.__name__)
return Trainer(model, optimizer, iterator,
train_data, validation_data,
patience=patience,
validation_metric=validation_metric,
validation_iterator=validation_iterator,
num_epochs=num_epochs,
serialization_dir=serialization_dir,
cuda_device=cuda_device,
grad_norm=grad_norm,
grad_clipping=grad_clipping,
learning_rate_scheduler=scheduler,
num_serialized_models_to_keep=num_serialized_models_to_keep,
keep_serialized_model_every_num_seconds=keep_serialized_model_every_num_seconds,
model_save_interval=model_save_interval,
summary_interval=summary_interval,
histogram_interval=histogram_interval)
def from_params(cls, params: Params) -> 'MultiHeadedSimilarity':
num_heads = params.pop_int("num_heads")
tensor_1_dim = params.pop_int("tensor_1_dim")
tensor_1_projected_dim = params.pop_int("tensor_1_projected_dim", None)
tensor_2_dim = params.pop_int("tensor_2_dim", None)
tensor_2_projected_dim = params.pop_int("tensor_1_projected_dim", None)
internal_similarity = SimilarityFunction.from_params(params.pop("internal_similarity", {}))
params.assert_empty(cls.__name__)
return cls(num_heads=num_heads,
tensor_1_dim=tensor_1_dim,
tensor_1_projected_dim=tensor_1_projected_dim,
tensor_2_dim=tensor_2_dim,
tensor_2_projected_dim=tensor_2_projected_dim,
internal_similarity=internal_similarity)
def from_params(cls, params: Params) -> 'Elmo':
# Add files to archive
params.add_file_to_archive('options_file')
params.add_file_to_archive('weight_file')
options_file = params.pop('options_file')
weight_file = params.pop('weight_file')
requires_grad = params.pop('requires_grad', False)
num_output_representations = params.pop('num_output_representations')
do_layer_norm = params.pop_bool('do_layer_norm', False)
params.assert_empty(cls.__name__)
return cls(options_file, weight_file, num_output_representations,
requires_grad=requires_grad, do_layer_norm=do_layer_norm)
def from_params(cls, params: Params) -> 'IntraSentenceAttentionEncoder':
input_dim = params.pop_int('input_dim')
projection_dim = params.pop_int('projection_dim', None)
similarity_function = SimilarityFunction.from_params(params.pop('similarity_function', {}))
num_attention_heads = params.pop_int('num_attention_heads', 1)
combination = params.pop('combination', '1,2')
output_dim = params.pop_int('output_dim', None)
params.assert_empty(cls.__name__)
return cls(input_dim=input_dim,
projection_dim=projection_dim,
similarity_function=similarity_function,
num_attention_heads=num_attention_heads,
combination=combination,
output_dim=output_dim)
def from_params(cls, params: Params):
input_dim = params.pop_int('input_dim')
num_layers = params.pop_int('num_layers')
hidden_dims = params.pop('hidden_dims')
activations = params.pop('activations')
dropout = params.pop('dropout', 0.0)
if isinstance(activations, list):
activations = [Activation.by_name(name)() for name in activations]
else:
activations = Activation.by_name(activations)()
params.assert_empty(cls.__name__)
return cls(input_dim=input_dim,
num_layers=num_layers,
hidden_dims=hidden_dims,
activations=activations,
dropout=dropout)
def from_params(cls, vocab: Vocabulary, params: Params) -> 'CrfTagger':
embedder_params = params.pop("text_field_embedder")
text_field_embedder = TextFieldEmbedder.from_params(vocab, embedder_params)
encoder = Seq2SeqEncoder.from_params(params.pop("encoder"))
label_namespace = params.pop("label_namespace", "labels")
constraint_type = params.pop("constraint_type", None)
initializer = InitializerApplicator.from_params(params.pop('initializer', []))
regularizer = RegularizerApplicator.from_params(params.pop('regularizer', []))
params.assert_empty(cls.__name__)
return cls(vocab=vocab,
text_field_embedder=text_field_embedder,
encoder=encoder,
label_namespace=label_namespace,
constraint_type=constraint_type,
initializer=initializer,
regularizer=regularizer)
def from_params(cls, vocab: Vocabulary, params: Params) -> 'Embedding':
"""
We need the vocabulary here to know how many items we need to embed, and we look for a
``vocab_namespace`` key in the parameter dictionary to know which vocabulary to use. If
you know beforehand exactly how many embeddings you need, or aren't using a vocabulary
mapping for the things getting embedded here, then you can pass in the ``num_embeddings``
key directly, and the vocabulary will be ignored.
"""
num_embeddings = params.pop_int('num_embeddings', None)
vocab_namespace = params.pop("vocab_namespace", "tokens")
if num_embeddings is None:
num_embeddings = vocab.get_vocab_size(vocab_namespace)
embedding_dim = params.pop_int('embedding_dim')
pretrained_file = params.pop("pretrained_file", None)
projection_dim = params.pop_int("projection_dim", None)
trainable = params.pop_bool("trainable", True)
padding_index = params.pop_int('padding_index', None)
max_norm = params.pop_float('max_norm', None)
norm_type = params.pop_float('norm_type', 2.)
scale_grad_by_freq = params.pop_bool('scale_grad_by_freq', False)
sparse = params.pop_bool('sparse', False)
params.assert_empty(cls.__name__)
if pretrained_file:
# If we're loading a saved model, we don't want to actually read a pre-trained
# embedding file - the embeddings will just be in our saved weights, and we might not
# have the original embedding file anymore, anyway.
weight = _read_pretrained_embedding_file(pretrained_file,
embedding_dim,
vocab,
vocab_namespace)
else:
weight = None
return cls(num_embeddings=num_embeddings,
embedding_dim=embedding_dim,
projection_dim=projection_dim,
weight=weight,
padding_index=padding_index,
trainable=trainable,
max_norm=max_norm,
norm_type=norm_type,
scale_grad_by_freq=scale_grad_by_freq,
sparse=sparse)
def from_params(cls, params: Params):
input_dim = params.pop_int('input_dim')
hidden_dim = params.pop_int('hidden_dim')
projection_dim = params.pop_int('projection_dim', None)
feedforward_hidden_dim = params.pop_int("feedforward_hidden_dim")
num_layers = params.pop_int("num_layers", 2)
num_attention_heads = params.pop_int('num_attention_heads', 3)
use_positional_encoding = params.pop_bool('use_positional_encoding', True)
dropout_prob = params.pop_float("dropout_prob", 0.2)
params.assert_empty(cls.__name__)
return cls(input_dim=input_dim,
hidden_dim=hidden_dim,
feedforward_hidden_dim=feedforward_hidden_dim,
projection_dim=projection_dim,
num_layers=num_layers,
num_attention_heads=num_attention_heads,
use_positional_encoding=use_positional_encoding,
dropout_prob=dropout_prob)
def from_params(cls, params: Params) -> 'AdaptiveIterator':
adaptive_memory_usage_constant = params.pop_int('adaptive_memory_usage_constant')
padding_memory_scaling = params.pop('padding_memory_scaling')
maximum_batch_size = params.pop_int('maximum_batch_size', 10000)
biggest_batch_first = params.pop_bool('biggest_batch_first', False)
batch_size = params.pop_int('batch_size', None)
sorting_keys = params.pop('sorting_keys', None)
padding_noise = params.pop_float('sorting_noise', 0.2)
instances_per_epoch = params.pop_int('instances_per_epoch', None)
max_instances_in_memory = params.pop_int('max_instances_in_memory', None)
params.assert_empty(cls.__name__)
return cls(adaptive_memory_usage_constant=adaptive_memory_usage_constant,
padding_memory_scaling=padding_memory_scaling,
maximum_batch_size=maximum_batch_size,
biggest_batch_first=biggest_batch_first,
batch_size=batch_size,
sorting_keys=sorting_keys,
padding_noise=padding_noise,
instances_per_epoch=instances_per_epoch,
max_instances_in_memory=max_instances_in_memory)
def from_params(cls, params: Params) -> 'Elmo':
# Add files to archive
params.add_file_to_archive('options_file')
params.add_file_to_archive('weight_file')
options_file = params.pop('options_file')
weight_file = params.pop('weight_file')
requires_grad = params.pop('requires_grad', False)
num_output_representations = params.pop('num_output_representations')
do_layer_norm = params.pop_bool('do_layer_norm', False)
keep_sentence_boundaries = params.pop_bool('keep_sentence_boundaries',
False)
dropout = params.pop_float('dropout', 0.5)
scalar_mix_parameters = params.pop('scalar_mix_parameters', None)
params.assert_empty(cls.__name__)
return cls(options_file=options_file,
weight_file=weight_file,
num_output_representations=num_output_representations,
requires_grad=requires_grad,
do_layer_norm=do_layer_norm,
keep_sentence_boundaries=keep_sentence_boundaries,
dropout=dropout,
scalar_mix_parameters=scalar_mix_parameters)
def from_params(cls, params: Params) -> 'AdaptiveIterator':
adaptive_memory_usage_constant = params.pop_int(
'adaptive_memory_usage_constant')
padding_memory_scaling = params.pop('padding_memory_scaling')
maximum_batch_size = params.pop_int('maximum_batch_size', 10000)
biggest_batch_first = params.pop_bool('biggest_batch_first', False)
batch_size = params.pop_int('batch_size', None)
sorting_keys = params.pop('sorting_keys', None)
padding_noise = params.pop_float('sorting_noise', 0.2)
instances_per_epoch = params.pop_int('instances_per_epoch', None)
max_instances_in_memory = params.pop_int('max_instances_in_memory',
None)
params.assert_empty(cls.__name__)
return cls(
adaptive_memory_usage_constant=adaptive_memory_usage_constant,
padding_memory_scaling=padding_memory_scaling,
maximum_batch_size=maximum_batch_size,
biggest_batch_first=biggest_batch_first,
batch_size=batch_size,
sorting_keys=sorting_keys,
padding_noise=padding_noise,
instances_per_epoch=instances_per_epoch,
max_instances_in_memory=max_instances_in_memory)
def from_params(cls, params: Params) -> 'SequenceTaggingDatasetReader':
"""
Parameters
----------
token_indexers: ``Dict[Params]``, optional
"""
token_indexers = {}
token_indexer_params = params.pop('token_indexers', Params({}))
for name, indexer_params in token_indexer_params.items():
token_indexers[name] = TokenIndexer.from_params(indexer_params)
# The default parameters are contained within the class,
# so if no parameters are given we must pass None.
if token_indexers == {}:
token_indexers = None
word_tag_delimiter = params.pop("word_tag_delimiter",
DEFAULT_WORD_TAG_DELIMITER)
token_delimiter = params.pop("token_delimiter", None)
params.assert_empty(cls.__name__)
return SequenceTaggingDatasetReader(
token_indexers=token_indexers,
word_tag_delimiter=word_tag_delimiter,
token_delimiter=token_delimiter)
def from_params(cls, vocab: Vocabulary, params: Params) -> 'BIOLabeler':
embedder_params = params.pop("text_field_embedder")
text_field_embedder = TextFieldEmbedder.from_params(vocab, embedder_params)
stacked_encoder = Seq2SeqEncoder.from_params(params.pop("stacked_encoder"))
predicate_feature_dim = params.pop("predicate_feature_dim", 100)
dim_hidden = params.pop("hidden_dim", 100)
question_generator = QuestionGenerator.from_params(vocab, params.pop("question_generator"))
initializer = InitializerApplicator.from_params(params.pop('initializer', []))
regularizer = RegularizerApplicator.from_params(params.pop('regularizer', []))
params.assert_empty(cls.__name__)
return cls(vocab=vocab,
text_field_embedder=text_field_embedder,
stacked_encoder=stacked_encoder,
question_generator=question_generator,
predicate_feature_dim=predicate_feature_dim,
dim_hidden=dim_hidden,
initializer=initializer,
regularizer=regularizer)
def from_params(cls, vocab,
params: Params) -> 'NlvrCoverageSemanticParser':
sentence_embedder_params = params.pop("sentence_embedder")
sentence_embedder = TextFieldEmbedder.from_params(
vocab, sentence_embedder_params)
action_embedding_dim = params.pop_int('action_embedding_dim')
encoder = Seq2SeqEncoder.from_params(params.pop("encoder"))
dropout = params.pop_float('dropout', 0.0)
input_attention = Attention.from_params(params.pop("attention"))
beam_size = params.pop_int('beam_size')
max_num_finished_states = params.pop_int('max_num_finished_states',
None)
normalize_beam_score_by_length = params.pop_bool(
'normalize_beam_score_by_length', False)
max_decoding_steps = params.pop_int("max_decoding_steps")
checklist_cost_weight = params.pop_float("checklist_cost_weight", 0.6)
dynamic_cost_weight = params.pop("dynamic_cost_weight", None)
penalize_non_agenda_actions = params.pop_bool(
"penalize_non_agenda_actions", False)
initial_mml_model_file = params.pop("initial_mml_model_file", None)
params.assert_empty(cls.__name__)
return cls(
vocab,
sentence_embedder=sentence_embedder,
action_embedding_dim=action_embedding_dim,
encoder=encoder,
input_attention=input_attention,
beam_size=beam_size,
max_num_finished_states=max_num_finished_states,
dropout=dropout,
max_decoding_steps=max_decoding_steps,
normalize_beam_score_by_length=normalize_beam_score_by_length,
checklist_cost_weight=checklist_cost_weight,
dynamic_cost_weight=dynamic_cost_weight,
penalize_non_agenda_actions=penalize_non_agenda_actions,
initial_mml_model_file=initial_mml_model_file)
def from_params(cls, params: Params) -> 'SquadSentenceSelectionReader':
"""
Parameters
----------
negative_sentence_selection : ``str``, optional (default="paragraph")
tokenizer : ``Params``, optional
token_indexers: ``List[Params]``, optional
"""
negative_sentence_selection = params.pop('negative_sentence_selection',
'paragraph')
tokenizer = Tokenizer.from_params(params.pop('tokenizer', {}))
token_indexers = {}
token_indexer_params = params.pop('token_indexers', Params({}))
for name, indexer_params in token_indexer_params.items():
token_indexers[name] = TokenIndexer.from_params(indexer_params)
# The default parameters are contained within the class,
# so if no parameters are given we must pass None.
if token_indexers == {}:
token_indexers = None
params.assert_empty(cls.__name__)
return SquadSentenceSelectionReader(
negative_sentence_selection=negative_sentence_selection,
tokenizer=tokenizer,
token_indexers=token_indexers)
def from_params(cls, params: Params) -> "PnetOntoDatasetReader":
# token_indexers = TokenIndexer.dict_from_params(params.pop('token_indexers', {}))
token_indexers = {
"tokens": SingleIdTokenIndexer(lowercase_tokens=True),
"token_characters": TokenCharactersIndexer(),
"elmo": ELMoTokenCharactersIndexer(),
}
valid_class = params.pop("valid_class")
random_seed = params.pop("random_seed")
drop_empty = params.pop("drop_empty")
tag_label = params.pop("tag_label", None)
feature_labels = params.pop("feature_labels", ())
lazy = params.pop("lazy", False)
params.assert_empty(cls.__name__)
return PnetOntoDatasetReader(
token_indexers=token_indexers,
valid_class=valid_class,
random_seed=random_seed,
drop_empty=drop_empty,
tag_label=tag_label,
feature_labels=feature_labels,
lazy=lazy,
)
def from_params(cls, params: Params) -> 'NLPCC3PatternDatasetReader':
source_tokenizer_type = params.pop('source_tokenizer', None)
source_tokenizer = None if source_tokenizer_type is None else Tokenizer.from_params(source_tokenizer_type)
target_tokenizer_type = params.pop('target_tokenizer', None)
target_tokenizer = None if target_tokenizer_type is None else Tokenizer.from_params(target_tokenizer_type)
source_indexers_type = params.pop('source_token_indexers', None)
source_add_start_token = params.pop_bool('source_add_start_token', True)
if source_indexers_type is None:
source_token_indexers = None
else:
source_token_indexers = TokenIndexer.dict_from_params(source_indexers_type)
target_indexers_type = params.pop('target_token_indexers', None)
if target_indexers_type is None:
target_token_indexers = None
else:
target_token_indexers = TokenIndexer.dict_from_params(target_indexers_type)
lazy = params.pop('lazy', False)
make_vocab = params.pop_bool('make_vocab', False)
max_encoding_steps = params.pop('max_encoding_steps', 1000)
params.assert_empty(cls.__name__)
return NLPCC3PatternDatasetReader(source_tokenizer, target_tokenizer,
source_token_indexers, target_token_indexers,
source_add_start_token, lazy, make_vocab,
max_encoding_steps)
def from_params(cls, vocab: Vocabulary,
params: Params) -> 'SpanConstituencyParser':
embedder_params = params.pop("text_field_embedder")
text_field_embedder = TextFieldEmbedder.from_params(
vocab, embedder_params)
span_extractor = SpanExtractor.from_params(
params.pop("span_extractor"))
encoder = Seq2SeqEncoder.from_params(params.pop("encoder"))
feed_forward_params = params.pop("feedforward", None)
if feed_forward_params is not None:
feedforward_layer = FeedForward.from_params(feed_forward_params)
else:
feedforward_layer = None
pos_tag_embedding_params = params.pop("pos_tag_embedding", None)
if pos_tag_embedding_params is not None:
pos_tag_embedding = Embedding.from_params(
vocab, pos_tag_embedding_params)
else:
pos_tag_embedding = None
initializer = InitializerApplicator.from_params(
params.pop('initializer', []))
regularizer = RegularizerApplicator.from_params(
params.pop('regularizer', []))
evalb_directory_path = params.pop("evalb_directory_path", None)
params.assert_empty(cls.__name__)
return cls(vocab=vocab,
text_field_embedder=text_field_embedder,
span_extractor=span_extractor,
encoder=encoder,
feedforward_layer=feedforward_layer,
pos_tag_embedding=pos_tag_embedding,
initializer=initializer,
regularizer=regularizer,
evalb_directory_path=evalb_directory_path)
def from_params(
cls,
vocab: Vocabulary, # pylint: disable=unused-argument
params: Params
) -> 'VampireTokenEmbedder': # type: ignore
# pylint: disable=arguments-differ
params.add_file_to_archive('model_archive')
model_archive = params.pop('model_archive')
device = params.pop_int('device')
background_frequency = params.pop('background_frequency')
requires_grad = params.pop('requires_grad', False)
scalar_mix = params.pop("scalar_mix", None)
dropout = params.pop_float("dropout", None)
expand_dim = params.pop_float("expand_dim", False)
projection_dim = params.pop_int("projection_dim", None)
params.assert_empty(cls.__name__)
return cls(expand_dim=expand_dim,
scalar_mix=scalar_mix,
background_frequency=background_frequency,
device=device,
model_archive=model_archive,
dropout=dropout,
requires_grad=requires_grad,
projection_dim=projection_dim)
def from_params(cls, vocab: Vocabulary,
params: Params) -> 'ElmoTokenEmbedder':
params.add_file_to_archive('options_file')
params.add_file_to_archive('weight_file')
options_file = params.pop('options_file')
weight_file = params.pop('weight_file')
requires_grad = params.pop('requires_grad', False)
do_layer_norm = params.pop_bool('do_layer_norm', False)
dropout = params.pop_float("dropout", 0.5)
namespace_to_cache = params.pop("namespace_to_cache", None)
if namespace_to_cache is not None:
vocab_to_cache = list(
vocab.get_token_to_index_vocabulary(namespace_to_cache).keys())
else:
vocab_to_cache = None
projection_dim = params.pop_int("projection_dim", None)
params.assert_empty(cls.__name__)
return cls(options_file=options_file,
weight_file=weight_file,
do_layer_norm=do_layer_norm,
dropout=dropout,
requires_grad=requires_grad,
projection_dim=projection_dim,
vocab_to_cache=vocab_to_cache)
def from_params(cls, vocab: Vocabulary, params: Params) -> 'DecomposableAttention':
embedder_params = params.pop("text_field_embedder")
text_field_embedder = TextFieldEmbedder.from_params(vocab, embedder_params)
premise_encoder_params = params.pop("premise_encoder", None)
if premise_encoder_params is not None:
premise_encoder = Seq2SeqEncoder.from_params(premise_encoder_params)
else:
premise_encoder = None
hypothesis_encoder_params = params.pop("hypothesis_encoder", None)
if hypothesis_encoder_params is not None:
hypothesis_encoder = Seq2SeqEncoder.from_params(hypothesis_encoder_params)
else:
hypothesis_encoder = None
attend_feedforward = FeedForward.from_params(params.pop('attend_feedforward'))
similarity_function = SimilarityFunction.from_params(params.pop("similarity_function"))
compare_feedforward = FeedForward.from_params(params.pop('compare_feedforward'))
aggregate_feedforward = FeedForward.from_params(params.pop('aggregate_feedforward'))
initializer = InitializerApplicator.from_params(params.pop('initializer', []))
regularizer = RegularizerApplicator.from_params(params.pop('regularizer', []))
preload_path = params.pop('preload_path', None)
params.assert_empty(cls.__name__)
return cls(vocab=vocab,
text_field_embedder=text_field_embedder,
attend_feedforward=attend_feedforward,
similarity_function=similarity_function,
compare_feedforward=compare_feedforward,
aggregate_feedforward=aggregate_feedforward,
premise_encoder=premise_encoder,
hypothesis_encoder=hypothesis_encoder,
initializer=initializer,
regularizer=regularizer,
preload_path=preload_path)
def from_params(cls, params: Params) -> 'CustomConll':
token_indexers = TokenIndexer.dict_from_params(params.pop('token_indexers', {}))
columns_header = params.pop('columns_header', COLUMNS_HEADER)
use_header = params.pop('use_header', 'ner')
encoding = params.pop('encoding', 'latin-1')
ignore_tag = params.pop('ignore_tag', None)
input_scheme = params.pop('input_scheme', 'IOB1')
tag_scheme = params.pop('tag_scheme', 'IOB2')
field_sep = params.pop('field_sep', None)
lm_task = params.pop('lm_task', False)
max_characters_per_token = params.pop('max_characters_per_token', 50)
start_end = params.pop('start_end', False)
params.assert_empty(cls.__name__)
return CustomConll(token_indexers=token_indexers,
columns_header=columns_header,
use_header=use_header,
ignore_tag=ignore_tag,
input_scheme=input_scheme,
tag_scheme=tag_scheme,
field_sep=field_sep,
encoding=encoding,
lm_task=lm_task,
max_characters_per_token=max_characters_per_token,
start_end=start_end)
def from_params(cls,
vocab: Vocabulary,
params: Params,
constructor_to_call=None,
constructor_to_inspect=None) -> 'ProLocalModel':
embedder_params = params.pop("text_field_embedder")
token_params = embedder_params.pop("tokens")
embedding = Embedding.from_params(vocab=vocab, params=token_params)
text_field_embedder = BasicTextFieldEmbedder(
token_embedders={'tokens': embedding})
# text_field_embedder = TextFieldEmbedder.from_params(vocab, embedder_params)
seq2seq_encoder_params = params.pop("seq2seq_encoder")
seq2seq_encoder = Seq2SeqEncoder.from_params(seq2seq_encoder_params)
initializer = InitializerApplicator(
) #.from_params(params.pop("initializer", []))
params.assert_empty(cls.__name__)
# print(cls)
return cls(vocab=vocab,
text_field_embedder=text_field_embedder,
seq2seq_encoder=seq2seq_encoder,
initializer=initializer)
def from_params(cls, vocab,
params: Params) -> 'NlvrCoverageSemanticParser':
sentence_embedder_params = params.pop("sentence_embedder")
sentence_embedder = TextFieldEmbedder.from_params(
vocab, sentence_embedder_params)
action_embedding_dim = params.pop_int('action_embedding_dim')
encoder = Seq2SeqEncoder.from_params(params.pop("encoder"))
attention_function_type = params.pop("attention_function", None)
if attention_function_type is not None:
attention_function = SimilarityFunction.from_params(
attention_function_type)
else:
attention_function = None
beam_size = params.pop_int('beam_size')
normalize_beam_score_by_length = params.pop_bool(
'normalize_beam_score_by_length', False)
max_decoding_steps = params.pop_int("max_decoding_steps")
checklist_cost_weight = params.pop_float("checklist_cost_weight", 0.6)
dynamic_cost_weight = params.pop("dynamic_cost_weight", None)
penalize_non_agenda_actions = params.pop_bool(
"penalize_non_agenda_actions", False)
initial_mml_model_file = params.pop("initial_mml_model_file", None)
params.assert_empty(cls.__name__)
return cls(
vocab,
sentence_embedder=sentence_embedder,
action_embedding_dim=action_embedding_dim,
encoder=encoder,
attention_function=attention_function,
beam_size=beam_size,
max_decoding_steps=max_decoding_steps,
normalize_beam_score_by_length=normalize_beam_score_by_length,
checklist_cost_weight=checklist_cost_weight,
dynamic_cost_weight=dynamic_cost_weight,
penalize_non_agenda_actions=penalize_non_agenda_actions,
initial_mml_model_file=initial_mml_model_file)
def from_params(cls, params: Params) -> 'WordTokenizer':
"""
Parameters
----------
word_splitter : ``str``, default=``"simple"``
The string name of the ``WordSplitter`` of choice (see the options at the bottom of
``word_splitter.py``).
word_filter : ``str``, default=``"pass_through"``
The name of the ``WordFilter`` to use (see the options at the bottom of
``word_filter.py``).
word_stemmer : ``str``, default=``"pass_through"``
The name of the ``WordStemmer`` to use (see the options at the bottom of
``word_stemmer.py``).
"""
word_splitter = WordSplitter.from_params(
params.pop('word_splitter', {}))
word_filter = WordFilter.from_params(params.pop('word_filter', {}))
word_stemmer = WordStemmer.from_params(params.pop('word_stemmer', {}))
params.assert_empty(cls.__name__)
return cls(word_splitter=word_splitter,
word_filter=word_filter,
word_stemmer=word_stemmer)
def from_params(cls, vocab: Vocabulary, params: Params) -> 'BidirectionalAttentionFlow':
embedder_params = params.pop("text_field_embedder")
text_field_embedder = TextFieldEmbedder.from_params(vocab, embedder_params)
num_highway_layers = params.pop("num_highway_layers")
phrase_layer = Seq2SeqEncoder.from_params(params.pop("phrase_layer"))
similarity_function = SimilarityFunction.from_params(params.pop("similarity_function"))
modeling_layer = Seq2SeqEncoder.from_params(params.pop("modeling_layer"))
span_end_encoder = Seq2SeqEncoder.from_params(params.pop("span_end_encoder"))
initializer = InitializerApplicator.from_params(params.pop("initializer", []))
dropout = params.pop('dropout', 0.2)
evaluation_json_file = params.pop('evaluation_json_file', None)
mask_lstms = params.pop('mask_lstms', True)
params.assert_empty(cls.__name__)
return cls(vocab=vocab,
text_field_embedder=text_field_embedder,
num_highway_layers=num_highway_layers,
phrase_layer=phrase_layer,
attention_similarity_function=similarity_function,
modeling_layer=modeling_layer,
span_end_encoder=span_end_encoder,
initializer=initializer,
dropout=dropout,
mask_lstms=mask_lstms,
evaluation_json_file=evaluation_json_file)
def from_params(cls, vocab: Vocabulary, params: Params) -> 'HierarchicalCRF':
embedder_params = params.pop('text_field_embedder')
text_field_embedder = TextFieldEmbedder.from_params(vocab, embedder_params)
inner_encoder = Seq2VecEncoder.from_params(params.pop('inner_encoder'))
outer_encoder = Seq2SeqEncoder.from_params(params.pop('outer_encoder'))
label_namespace = params.pop('label_namespace', 'labels')
constraint_type = params.pop('constraint_type', None)
dropout = params.pop('dropout', None)
include_start_end_transitions = params.pop('include_start_end_transitions', True)
initializer = InitializerApplicator.from_params(params.pop('initializer', []))
regularizer = RegularizerApplicator.from_params(params.pop('regularizer', []))
params.assert_empty(cls.__name__)
return cls(vocab=vocab,
text_field_embedder=text_field_embedder,
inner_encoder=inner_encoder,
outer_encoder=outer_encoder,
label_namespace=label_namespace,
constraint_type=constraint_type,
dropout=dropout,
include_start_end_transitions=include_start_end_transitions,
initializer=initializer,
regularizer=regularizer)
def from_params(cls, model: Model, task_list: List[Task],
serialization_dir: str,
params: Params) -> "TransferMtlTrainer":
optimizer_params = params.pop("optimizer")
lr_scheduler_params = params.pop("scheduler")
patience = params.pop_int("patience", 2)
num_epochs = params.pop_int("num_epochs", 20)
cuda_device = params.pop_int("cuda_device", -1)
gradient_accumulation_steps = params.pop_int(
"gradient_accumulation_steps", 1)
grad_norm = params.pop_float("grad_norm", None)
grad_clipping = params.pop_float("grad_clipping", None)
min_lr = params.pop_float("min_lr", 0.00001)
no_tqdm = params.pop_bool("no_tqdm", False)
summary_interval = params.pop("summary_interval", 30)
histogram_interval = params.pop("histogram_interval", 30)
sampling_method = params.pop("sampling_method", "proportional")
params.assert_empty(cls.__name__)
return TransferMtlTrainer(
model=model,
task_list=task_list,
optimizer_params=optimizer_params,
lr_scheduler_params=lr_scheduler_params,
patience=patience,
num_epochs=num_epochs,
serialization_dir=serialization_dir,
cuda_device=cuda_device,
gradient_accumulation_steps=gradient_accumulation_steps,
grad_norm=grad_norm,
grad_clipping=grad_clipping,
min_lr=min_lr,
no_tqdm=no_tqdm,
summary_interval=summary_interval,
histogram_interval=histogram_interval,
sampling_method=sampling_method)
def from_params(cls, vocab: Vocabulary, params: Params) -> 'ProGlobal':
token_embedder_params = params.pop("text_field_embedder")
pos_embedder_params = params.pop("pos_field_embedder")
sent_pos_embedder_params = params.pop("sent_pos_field_embedder")
text_field_embedder = TextFieldEmbedder.from_params(
vocab, token_embedder_params)
pos_field_embedder = TextFieldEmbedder.from_params(
vocab, pos_embedder_params)
sent_pos_field_embedder = TextFieldEmbedder.from_params(
vocab, sent_pos_embedder_params)
modeling_layer = Seq2SeqEncoder.from_params(
params.pop("modeling_layer"))
span_end_encoder_before = Seq2SeqEncoder.from_params(
params.pop("span_end_encoder_bef"))
span_start_encoder_after = Seq2SeqEncoder.from_params(
params.pop("span_start_encoder_aft"))
span_end_encoder_after = Seq2SeqEncoder.from_params(
params.pop("span_end_encoder_aft"))
dropout = params.pop('dropout', 0.2)
init_params = params.pop('initializer', None)
initializer = (InitializerApplicator.from_params(init_params)
if init_params is not None else InitializerApplicator())
params.assert_empty(cls.__name__)
return cls(vocab=vocab,
text_field_embedder=text_field_embedder,
pos_field_embedder=pos_field_embedder,
sent_pos_field_embedder=sent_pos_field_embedder,
modeling_layer=modeling_layer,
span_start_encoder_after=span_start_encoder_after,
span_end_encoder_before=span_end_encoder_before,
span_end_encoder_after=span_end_encoder_after,
dropout=dropout,
initializer=initializer)
def from_params(cls, vocab: Vocabulary,
params: Params) -> 'BidirectionalAttentionFlow':
embedder_params = params.pop("text_field_embedder")
text_field_embedder = TextFieldEmbedder.from_params(
vocab, embedder_params)
num_highway_layers = params.pop("num_highway_layers")
phrase_layer = Seq2SeqEncoder.from_params(params.pop("phrase_layer"))
similarity_function = SimilarityFunction.from_params(
params.pop("similarity_function"))
modeling_layer = Seq2SeqEncoder.from_params(
params.pop("modeling_layer"))
span_end_encoder = Seq2SeqEncoder.from_params(
params.pop("span_end_encoder"))
initializer = InitializerApplicator.from_params(
params.pop("initializer", []))
dropout = params.pop('dropout', 0.2)
# TODO: Remove the following when fully deprecated
evaluation_json_file = params.pop('evaluation_json_file', None)
if evaluation_json_file is not None:
logger.warning(
"the 'evaluation_json_file' model parameter is deprecated, please remove"
)
mask_lstms = params.pop('mask_lstms', True)
params.assert_empty(cls.__name__)
return cls(vocab=vocab,
text_field_embedder=text_field_embedder,
num_highway_layers=num_highway_layers,
phrase_layer=phrase_layer,
attention_similarity_function=similarity_function,
modeling_layer=modeling_layer,
span_end_encoder=span_end_encoder,
initializer=initializer,
dropout=dropout,
mask_lstms=mask_lstms)
def from_params(cls, params: Params) -> 'SingleIdTokenIndexer':
namespace = params.pop('namespace', 'tokens')
lowercase_tokens = params.pop('lowercase_tokens', False)
params.assert_empty(cls.__name__)
return cls(namespace=namespace, lowercase_tokens=lowercase_tokens)
def from_params(cls, vocab: Vocabulary,
params: Params) -> 'ELMoTokenEmbedder':
options_file = params.pop('options_file')
weight_file = params.pop('weight_file')
params.assert_empty(cls.__name__)
return cls(options_file, weight_file)
def from_params(cls, params: Params,constructor_to_call=None, constructor_to_inspect=None) -> 'ProLocalDatasetReader':
# token_indexers = TokenIndexer()
# print(params.pop("token_indexer", {}))
token_indexers = {'tokens': SingleIdTokenIndexer()}
params.assert_empty(cls.__name__)
return ProLocalDatasetReader(token_indexers=token_indexers)
def from_params(cls, # type: ignore
model: Model,
serialization_dir: str,
iterator: DataIterator,
train_data: Iterable[Instance],
validation_data: Optional[Iterable[Instance]],
params: Params,
validation_iterator: DataIterator = None) -> 'Trainer':
# pylint: disable=arguments-differ
patience = params.pop_int("patience", None)
validation_metric = params.pop("validation_metric", "-loss")
shuffle = params.pop_bool("shuffle", True)
num_epochs = params.pop_int("num_epochs", 20)
cuda_device = parse_cuda_device(params.pop("cuda_device", -1))
grad_norm = params.pop_float("grad_norm", None)
grad_clipping = params.pop_float("grad_clipping", None)
lr_scheduler_params = params.pop("learning_rate_scheduler", None)
momentum_scheduler_params = params.pop("momentum_scheduler", None)
if isinstance(cuda_device, list):
model_device = cuda_device[0]
else:
model_device = cuda_device
if model_device >= 0:
# Moving model to GPU here so that the optimizer state gets constructed on
# the right device.
model = model.cuda(model_device)
parameters = [[n, p] for n, p in model.named_parameters() if p.requires_grad]
optimizer = Optimizer.from_params(parameters, params.pop("optimizer"))
if "moving_average" in params:
moving_average = MovingAverage.from_params(params.pop("moving_average"), parameters=parameters)
else:
moving_average = None
if lr_scheduler_params:
lr_scheduler = LearningRateScheduler.from_params(optimizer, lr_scheduler_params)
else:
lr_scheduler = None
if momentum_scheduler_params:
momentum_scheduler = MomentumScheduler.from_params(optimizer, momentum_scheduler_params)
else:
momentum_scheduler = None
if 'checkpointer' in params:
if 'keep_serialized_model_every_num_seconds' in params or \
'num_serialized_models_to_keep' in params:
raise ConfigurationError(
"Checkpointer may be initialized either from the 'checkpointer' key or from the "
"keys 'num_serialized_models_to_keep' and 'keep_serialized_model_every_num_seconds'"
" but the passed config uses both methods.")
checkpointer = Checkpointer.from_params(params.pop("checkpointer"))
else:
num_serialized_models_to_keep = params.pop_int("num_serialized_models_to_keep", 20)
keep_serialized_model_every_num_seconds = params.pop_int(
"keep_serialized_model_every_num_seconds", None)
checkpointer = Checkpointer(
serialization_dir=serialization_dir,
num_serialized_models_to_keep=num_serialized_models_to_keep,
keep_serialized_model_every_num_seconds=keep_serialized_model_every_num_seconds)
model_save_interval = params.pop_float("model_save_interval", None)
summary_interval = params.pop_int("summary_interval", 100)
histogram_interval = params.pop_int("histogram_interval", None)
should_log_parameter_statistics = params.pop_bool("should_log_parameter_statistics", True)
should_log_learning_rate = params.pop_bool("should_log_learning_rate", False)
log_batch_size_period = params.pop_int("log_batch_size_period", None)
params.assert_empty(cls.__name__)
return cls(model, optimizer, iterator,
train_data, validation_data,
patience=patience,
validation_metric=validation_metric,
validation_iterator=validation_iterator,
shuffle=shuffle,
num_epochs=num_epochs,
serialization_dir=serialization_dir,
cuda_device=cuda_device,
grad_norm=grad_norm,
grad_clipping=grad_clipping,
learning_rate_scheduler=lr_scheduler,
momentum_scheduler=momentum_scheduler,
checkpointer=checkpointer,
model_save_interval=model_save_interval,
summary_interval=summary_interval,
histogram_interval=histogram_interval,
should_log_parameter_statistics=should_log_parameter_statistics,
should_log_learning_rate=should_log_learning_rate,
log_batch_size_period=log_batch_size_period,
moving_average=moving_average)
def from_params(cls, params: Params,
**extras2) -> "E": # type: ignore
m = params.pop_int("m")
params.assert_empty(cls.__name__)
n = extras2["n"]
return cls(m=m, n=n)
def from_params(cls, params: Params, c: int,
**extras) -> "B": # type: ignore
b = params.pop_int("b")
params.assert_empty(cls.__name__)
return cls(c=c, b=b)
def from_params(cls, vocab: Vocabulary, params: Params) -> 'Embedding':
"""
We need the vocabulary here to know how many items we need to embed, and we look for a
``vocab_namespace`` key in the parameter dictionary to know which vocabulary to use. If
you know beforehand exactly how many embeddings you need, or aren't using a vocabulary
mapping for the things getting embedded here, then you can pass in the ``num_embeddings``
key directly, and the vocabulary will be ignored.
In the configuration file, a file containing pretrained embeddings can be specified
using the parameter ``"pretrained_file"``.
It can be the path to a local file or an URL of a (cached) remote file.
Two formats are supported:
* hdf5 file - containing an embedding matrix in the form of a torch.Tensor;
* text file - an utf-8 encoded text file with space separated fields::
[word] [dim 1] [dim 2] ...
The text file can eventually be compressed with gzip, bz2, lzma or zip.
You can even select a single file inside an archive containing multiple files
using the URI::
"(archive_uri)#file_path_inside_the_archive"
where ``archive_uri`` can be a file system path or a URL. For example::
"(http://nlp.stanford.edu/data/glove.twitter.27B.zip)#glove.twitter.27B.200d.txt"
"""
num_embeddings = params.pop_int('num_embeddings', None)
vocab_namespace = params.pop("vocab_namespace", "tokens")
if num_embeddings is None:
num_embeddings = vocab.get_vocab_size(vocab_namespace)
embedding_dim = params.pop_int('embedding_dim')
pretrained_file = params.pop("pretrained_file", None)
projection_dim = params.pop_int("projection_dim", None)
trainable = params.pop_bool("trainable", True)
padding_index = params.pop_int('padding_index', None)
max_norm = params.pop_float('max_norm', None)
norm_type = params.pop_float('norm_type', 2.)
scale_grad_by_freq = params.pop_bool('scale_grad_by_freq', False)
sparse = params.pop_bool('sparse', False)
params.assert_empty(cls.__name__)
if pretrained_file:
# If we're loading a saved model, we don't want to actually read a pre-trained
# embedding file - the embeddings will just be in our saved weights, and we might not
# have the original embedding file anymore, anyway.
weight = _read_pretrained_embeddings_file(pretrained_file,
embedding_dim, vocab,
vocab_namespace)
else:
weight = None
return cls(num_embeddings=num_embeddings,
embedding_dim=embedding_dim,
projection_dim=projection_dim,
weight=weight,
padding_index=padding_index,
trainable=trainable,
max_norm=max_norm,
norm_type=norm_type,
scale_grad_by_freq=scale_grad_by_freq,
sparse=sparse)
def train_model(params: Params,
serialization_dir: str,
file_friendly_logging: bool = False,
recover: bool = False) -> Model:
"""
Trains the model specified in the given :class:`Params` object, using the data and training
parameters also specified in that object, and saves the results in ``serialization_dir``.
Parameters
----------
params : ``Params``
A parameter object specifying an AllenNLP Experiment.
serialization_dir : ``str``
The directory in which to save results and logs.
file_friendly_logging : ``bool``, optional (default=False)
If ``True``, we add newlines to tqdm output, even on an interactive terminal, and we slow
down tqdm's output to only once every 10 seconds.
recover : ``bool``, optional (default=False)
If ``True``, we will try to recover a training run from an existing serialization
directory. This is only intended for use when something actually crashed during the middle
of a run. For continuing training a model on new data, see the ``fine-tune`` command.
Returns
-------
best_model: ``Model``
The model with the best epoch weights.
"""
prepare_environment(params)
create_serialization_dir(params, serialization_dir, recover)
prepare_global_logging(serialization_dir, file_friendly_logging)
check_for_gpu(params.params.get('trainer').get('cuda_device', -1))
serialization_params = deepcopy(params).as_dict(quiet=True)
with open(os.path.join(serialization_dir, CONFIG_NAME), "w") as param_file:
json.dump(serialization_params, param_file, indent=4)
all_datasets = datasets_from_params(params)
datasets_for_vocab_creation = set(
params.pop("datasets_for_vocab_creation", all_datasets))
for dataset in datasets_for_vocab_creation:
if dataset not in all_datasets:
raise ConfigurationError(
f"invalid 'dataset_for_vocab_creation' {dataset}")
logger.info("Creating a vocabulary using %s data.",
", ".join(datasets_for_vocab_creation))
vocab = Vocabulary.from_params(
params.pop("vocabulary", {}),
(instance for key, dataset in all_datasets.items()
for instance in dataset if key in datasets_for_vocab_creation))
vocab.save_to_files(os.path.join(serialization_dir, "vocabulary"))
model = Model.from_params(vocab=vocab, params=params.pop('model'))
iterator = DataIterator.from_params(params.pop("iterator"))
iterator.index_with(vocab)
validation_iterator_params = params.pop("validation_iterator", None)
if validation_iterator_params:
validation_iterator = DataIterator.from_params(
validation_iterator_params)
validation_iterator.index_with(vocab)
else:
validation_iterator = None
train_data = all_datasets['train']
validation_data = all_datasets.get('validation')
test_data = all_datasets.get('test')
trainer_params = params.pop("trainer")
no_grad_regexes = trainer_params.pop("no_grad", ())
for name, parameter in model.named_parameters():
if any(re.search(regex, name) for regex in no_grad_regexes):
parameter.requires_grad_(False)
frozen_parameter_names, tunable_parameter_names = \
get_frozen_and_tunable_parameter_names(model)
logger.info("Following parameters are Frozen (without gradient):")
for name in frozen_parameter_names:
logger.info(name)
logger.info("Following parameters are Tunable (with gradient):")
for name in tunable_parameter_names:
logger.info(name)
trainer = Trainer.from_params(model,
serialization_dir,
iterator,
train_data,
validation_data,
trainer_params,
validation_iterator=validation_iterator)
evaluate_on_test = params.pop_bool("evaluate_on_test", False)
params.assert_empty('base train command')
try:
metrics = trainer.train()
except KeyboardInterrupt:
# if we have completed an epoch, try to create a model archive.
if os.path.exists(os.path.join(serialization_dir, _DEFAULT_WEIGHTS)):
logging.info(
"Training interrupted by the user. Attempting to create "
"a model archive using the current best epoch weights.")
archive_model(serialization_dir,
files_to_archive=params.files_to_archive)
raise
# Now tar up results
archive_model(serialization_dir, files_to_archive=params.files_to_archive)
logger.info("Loading the best epoch weights.")
best_model_state_path = os.path.join(serialization_dir, 'best.th')
best_model_state = torch.load(best_model_state_path)
best_model = model
best_model.load_state_dict(best_model_state)
if test_data and evaluate_on_test:
logger.info(
"The model will be evaluated using the best epoch weights.")
test_metrics = evaluate(
best_model,
test_data,
validation_iterator or iterator,
cuda_device=trainer._cuda_devices[0] # pylint: disable=protected-access
)
for key, value in test_metrics.items():
metrics["test_" + key] = value
elif test_data:
logger.info(
"To evaluate on the test set after training, pass the "
"'evaluate_on_test' flag, or use the 'allennlp evaluate' command.")
metrics_json = json.dumps(metrics, indent=2)
with open(os.path.join(serialization_dir, "metrics.json"),
"w") as metrics_file:
metrics_file.write(metrics_json)
logger.info("Metrics: %s", metrics_json)
return best_model
def train_model(params: Params,
serialization_dir: str,
file_friendly_logging: bool = False,
recover: bool = False,
force: bool = False,
cache_directory: str = None,
cache_prefix: str = None) -> Model:
"""
Trains the model specified in the given :class:`Params` object, using the data and training
parameters also specified in that object, and saves the results in ``serialization_dir``.
Parameters
----------
params : ``Params``
A parameter object specifying an AllenNLP Experiment.
serialization_dir : ``str``
The directory in which to save results and logs.
file_friendly_logging : ``bool``, optional (default=False)
If ``True``, we add newlines to tqdm output, even on an interactive terminal, and we slow
down tqdm's output to only once every 10 seconds.
recover : ``bool``, optional (default=False)
If ``True``, we will try to recover a training run from an existing serialization
directory. This is only intended for use when something actually crashed during the middle
of a run. For continuing training a model on new data, see the ``fine-tune`` command.
force : ``bool``, optional (default=False)
If ``True``, we will overwrite the serialization directory if it already exists.
cache_directory : ``str``, optional
For caching data pre-processing. See :func:`allennlp.training.util.datasets_from_params`.
cache_prefix : ``str``, optional
For caching data pre-processing. See :func:`allennlp.training.util.datasets_from_params`.
Returns
-------
best_model: ``Model``
The model with the best epoch weights.
"""
create_serialization_dir(params, serialization_dir, recover, force)
stdout_handler = prepare_global_logging(serialization_dir,
file_friendly_logging)
prepare_environment(params)
cuda_device = params.params.get('trainer').get('cuda_device', -1)
check_for_gpu(cuda_device)
params.to_file(os.path.join(serialization_dir, CONFIG_NAME))
evaluate_on_test = params.pop_bool("evaluate_on_test", False)
trainer_type = params.get("trainer", {}).get("type", "default")
if trainer_type == "default":
# Special logic to instantiate backward-compatible trainer.
pieces = TrainerPieces.from_params(
params, # pylint: disable=no-member
serialization_dir,
recover,
cache_directory,
cache_prefix)
trainer = Trainer.from_params(
model=pieces.model,
serialization_dir=serialization_dir,
iterator=pieces.iterator,
train_data=pieces.train_dataset,
validation_data=pieces.validation_dataset,
params=pieces.params,
validation_iterator=pieces.validation_iterator)
evaluation_iterator = pieces.validation_iterator or pieces.iterator
evaluation_dataset = pieces.test_dataset
else:
if evaluate_on_test:
raise ValueError(
"--evaluate-on-test only works with the default Trainer. "
"If you're using the CallbackTrainer you can use a callback "
"to evaluate at Events.TRAINING_END; otherwise you'll have "
"to run allennlp evaluate separately.")
trainer = TrainerBase.from_params(params, serialization_dir, recover,
cache_directory, cache_prefix)
evaluation_dataset = None
params.assert_empty('base train command')
try:
metrics = trainer.train()
except KeyboardInterrupt:
# if we have completed an epoch, try to create a model archive.
if os.path.exists(os.path.join(serialization_dir, _DEFAULT_WEIGHTS)):
logging.info(
"Training interrupted by the user. Attempting to create "
"a model archive using the current best epoch weights.")
archive_model(serialization_dir,
files_to_archive=params.files_to_archive)
raise
# Evaluate
if evaluation_dataset and evaluate_on_test:
logger.info(
"The model will be evaluated using the best epoch weights.")
test_metrics = evaluate(
trainer.model,
evaluation_dataset,
evaluation_iterator,
cuda_device=trainer._cuda_devices[0], # pylint: disable=protected-access,
# TODO(brendanr): Pass in an arg following Joel's trainer refactor.
batch_weight_key="")
for key, value in test_metrics.items():
metrics["test_" + key] = value
elif evaluation_dataset:
logger.info(
"To evaluate on the test set after training, pass the "
"'evaluate_on_test' flag, or use the 'allennlp evaluate' command.")
cleanup_global_logging(stdout_handler)
# Now tar up results
archive_model(serialization_dir, files_to_archive=params.files_to_archive)
dump_metrics(os.path.join(serialization_dir, "metrics.json"),
metrics,
log=True)
# We count on the trainer to have the model with best weights
return trainer.model
