def test_forward_runs_with_non_bijective_mapping_with_dict(self):
elmo_fixtures_path = self.FIXTURES_ROOT / 'elmo'
options_file = str(elmo_fixtures_path / 'options.json')
weight_file = str(elmo_fixtures_path / 'lm_weights.hdf5')
params = Params({
"token_embedders": {
"words": {
"type": "embedding",
"num_embeddings": 20,
"embedding_dim": 2,
},
"elmo": {
"type": "elmo_token_embedder",
"options_file": options_file,
"weight_file": weight_file
},
},
"embedder_to_indexer_map": {
# pass arguments to `ElmoTokenEmbedder.forward` by dict
"elmo": {
"inputs": "elmo",
"word_inputs": "words"
},
"words": ["words"]
}
})
token_embedder = BasicTextFieldEmbedder.from_params(self.vocab, params)
inputs = {
'words': (torch.rand(3, 6) * 20).long(),
'elmo': (torch.rand(3, 6, 50) * 15).long(),
}
token_embedder(inputs)
def setUp(self):
super(TestBasicTextFieldEmbedder, self).setUp()
self.vocab = Vocabulary()
self.vocab.add_token_to_namespace("1")
self.vocab.add_token_to_namespace("2")
self.vocab.add_token_to_namespace("3")
self.vocab.add_token_to_namespace("4")
params = Params({
"token_embedders": {
"words1": {
"type": "embedding",
"embedding_dim": 2
},
"words2": {
"type": "embedding",
"embedding_dim": 5
},
"words3": {
"type": "embedding",
"embedding_dim": 3
}
}
})
self.token_embedder = BasicTextFieldEmbedder.from_params(
vocab=self.vocab, params=params)
self.inputs = {
"words1": torch.LongTensor([[0, 2, 3, 5]]),
"words2": torch.LongTensor([[1, 4, 3, 2]]),
"words3": torch.LongTensor([[1, 5, 1, 2]])
}
def test_forward_works_on_higher_order_input(self):
params = Params({
"words": {
"type": "embedding",
"num_embeddings": 20,
"embedding_dim": 2,
},
"characters": {
"type": "character_encoding",
"embedding": {
"embedding_dim": 4,
"num_embeddings": 15,
},
"encoder": {
"type": "cnn",
"embedding_dim": 4,
"num_filters": 10,
"ngram_filter_sizes": [3],
},
}
})
token_embedder = BasicTextFieldEmbedder.from_params(self.vocab, params)
inputs = {
'words': Variable(torch.rand(3, 4, 5, 6) * 20).long(),
'characters': Variable(torch.rand(3, 4, 5, 6, 7) * 15).long(),
}
assert token_embedder(inputs, num_wrapping_dims=2).size() == (3, 4, 5, 6, 12)
def setUp(self):
super(TestBasicTextFieldEmbedder, self).setUp()
self.vocab = Vocabulary()
self.vocab.add_token_to_namespace("1")
self.vocab.add_token_to_namespace("2")
self.vocab.add_token_to_namespace("3")
self.vocab.add_token_to_namespace("4")
params = Params({
"words1": {
"type": "embedding",
"embedding_dim": 2
},
"words2": {
"type": "embedding",
"embedding_dim": 5
},
"words3": {
"type": "embedding",
"embedding_dim": 3
}
})
self.token_embedder = BasicTextFieldEmbedder.from_params(self.vocab, params)
self.inputs = {
"words1": Variable(torch.LongTensor([[0, 2, 3, 5]])),
"words2": Variable(torch.LongTensor([[1, 4, 3, 2]])),
"words3": Variable(torch.LongTensor([[1, 5, 1, 2]]))
}
def test_end_to_end(self, train_parameters: bool, last_layer_only: bool):
tokenizer = PretrainedTransformerTokenizer(
model_name="bert-base-uncased")
token_indexer = PretrainedTransformerIndexer(
model_name="bert-base-uncased")
sentence1 = "A, AllenNLP sentence."
tokens1 = tokenizer.tokenize(sentence1)
expected_tokens1 = [
"[CLS]", "a", ",", "allen", "##nl", "##p", "sentence", ".", "[SEP]"
]
assert [t.text for t in tokens1] == expected_tokens1
sentence2 = "AllenNLP is great"
tokens2 = tokenizer.tokenize(sentence2)
expected_tokens2 = [
"[CLS]", "allen", "##nl", "##p", "is", "great", "[SEP]"
]
assert [t.text for t in tokens2] == expected_tokens2
vocab = Vocabulary()
params = Params({
"token_embedders": {
"bert": {
"type": "pretrained_transformer",
"model_name": "bert-base-uncased",
"train_parameters": train_parameters,
"last_layer_only": last_layer_only,
}
}
})
token_embedder = BasicTextFieldEmbedder.from_params(vocab=vocab,
params=params)
instance1 = Instance(
{"tokens": TextField(tokens1, {"bert": token_indexer})})
instance2 = Instance(
{"tokens": TextField(tokens2, {"bert": token_indexer})})
batch = Batch([instance1, instance2])
batch.index_instances(vocab)
padding_lengths = batch.get_padding_lengths()
tensor_dict = batch.as_tensor_dict(padding_lengths)
tokens = tensor_dict["tokens"]
max_length = max(len(tokens1), len(tokens2))
assert tokens["bert"]["token_ids"].shape == (2, max_length)
assert tokens["bert"]["mask"].tolist() == [
[True, True, True, True, True, True, True, True, True],
[True, True, True, True, True, True, True, False, False],
]
# Attention mask
bert_vectors = token_embedder(tokens)
assert bert_vectors.size() == (2, 9, 768)
assert bert_vectors.requires_grad == (train_parameters
or not last_layer_only)
def test_forward_runs_with_non_bijective_mapping_with_dict(self):
elmo_fixtures_path = self.FIXTURES_ROOT / "elmo"
options_file = str(elmo_fixtures_path / "options.json")
weight_file = str(elmo_fixtures_path / "lm_weights.hdf5")
params = Params({
"token_embedders": {
"words": {
"type": "embedding",
"num_embeddings": 20,
"embedding_dim": 2
},
"elmo": {
"type": "elmo_token_embedder",
"options_file": options_file,
"weight_file": weight_file,
},
}
})
token_embedder = BasicTextFieldEmbedder.from_params(vocab=self.vocab,
params=params)
inputs = {
"words": {
"tokens": (torch.rand(3, 6) * 20).long()
},
"elmo": {
"tokens": (torch.rand(3, 6, 50) * 15).long()
},
}
token_embedder(inputs)
def test_forward_works_on_higher_order_input(self):
params = Params({
"token_embedders": {
"words": {
"type": "embedding",
"num_embeddings": 20,
"embedding_dim": 2,
},
"characters": {
"type": "character_encoding",
"embedding": {
"embedding_dim": 4,
"num_embeddings": 15,
},
"encoder": {
"type": "cnn",
"embedding_dim": 4,
"num_filters": 10,
"ngram_filter_sizes": [3],
},
}
}
})
token_embedder = BasicTextFieldEmbedder.from_params(vocab=self.vocab,
params=params)
inputs = {
'words': (torch.rand(3, 4, 5, 6) * 20).long(),
'characters': (torch.rand(3, 4, 5, 6, 7) * 15).long(),
}
assert token_embedder(inputs,
num_wrapping_dims=2).size() == (3, 4, 5, 6, 12)
def test_forward_runs_with_bijective_and_non_bijective_mapping(self):
params = Params({
"token_embedders": {
"bert": {
"type": "pretrained_transformer",
"model_name": "bert-base-uncased"
},
"token_characters": {
"type": "character_encoding",
"embedding": {
"embedding_dim": 5
},
"encoder": {
"type": "cnn",
"embedding_dim": 5,
"num_filters": 5,
"ngram_filter_sizes": [5],
},
},
}
})
token_embedder = BasicTextFieldEmbedder.from_params(vocab=self.vocab,
params=params)
inputs = {
"bert": {
"token_ids": (torch.rand(3, 5) * 10).long(),
"mask": (torch.rand(3, 5) * 1).long(),
},
"token_characters": {
"token_characters": (torch.rand(3, 5, 5) * 1).long()
},
}
token_embedder(inputs)
def test_forward_runs_with_non_bijective_mapping(self):
elmo_fixtures_path = self.FIXTURES_ROOT / u'elmo'
options_file = unicode(elmo_fixtures_path / u'options.json')
weight_file = unicode(elmo_fixtures_path / u'lm_weights.hdf5')
params = Params({
u"words": {
u"type": u"embedding",
u"num_embeddings": 20,
u"embedding_dim": 2,
},
u"elmo": {
u"type": u"elmo_token_embedder",
u"options_file": options_file,
u"weight_file": weight_file
},
u"embedder_to_indexer_map": {
u"words": [u"words"],
u"elmo": [u"elmo", u"words"]
}
})
token_embedder = BasicTextFieldEmbedder.from_params(self.vocab, params)
inputs = {
u'words': (torch.rand(3, 6) * 20).long(),
u'elmo': (torch.rand(3, 6, 50) * 15).long(),
}
token_embedder(inputs)
def test_forward_runs_with_non_bijective_mapping(self):
elmo_fixtures_path = self.FIXTURES_ROOT / 'elmo'
options_file = str(elmo_fixtures_path / 'options.json')
weight_file = str(elmo_fixtures_path / 'lm_weights.hdf5')
params = Params({
"token_embedders": {
"words": {
"type": "embedding",
"num_embeddings": 20,
"embedding_dim": 2,
},
"elmo": {
"type": "elmo_token_embedder",
"options_file": options_file,
"weight_file": weight_file
},
},
"embedder_to_indexer_map": {"words": ["words"], "elmo": ["elmo", "words"]}
})
token_embedder = BasicTextFieldEmbedder.from_params(self.vocab, params)
inputs = {
'words': (torch.rand(3, 6) * 20).long(),
'elmo': (torch.rand(3, 6, 50) * 15).long(),
}
token_embedder(inputs)
def __init__(self,
vocab: Vocabulary,
params: Params,
regularizer: RegularizerApplicator = None):
super(LayerNer, self).__init__(vocab = vocab, regularizer = regularizer)
# Base Text Field Embedder
text_field_embedder_params = params.pop("text_field_embedder")
text_field_embedder = BasicTextFieldEmbedder.from_params(vocab=vocab,
params=text_field_embedder_params)
self._text_field_embedder = text_field_embedder
############
# NER Stuffs
############
ner_params = params.pop("ner")
# Encoder
encoder_ner_params = ner_params.pop("encoder")
encoder_ner = Seq2SeqEncoder.from_params(encoder_ner_params)
self._encoder_ner = encoder_ner
# Tagger NER - CRF Tagger
tagger_ner_params = ner_params.pop("tagger")
tagger_ner = CrfTagger(vocab = vocab,
text_field_embedder = self._text_field_embedder,
encoder = self._encoder_ner,
label_namespace = tagger_ner_params.pop("label_namespace", "labels"),
constraint_type = tagger_ner_params.pop("constraint_type", None),
dropout = tagger_ner_params.pop("dropout", None),
regularizer = regularizer)
self._tagger_ner = tagger_ner
logger.info("Multi-Task Learning Model has been instantiated.")
def test_end_to_end_t5(
self,
train_parameters: bool,
last_layer_only: bool,
gradient_checkpointing: bool,
):
tokenizer = PretrainedTransformerTokenizer(model_name="patrickvonplaten/t5-tiny-random")
token_indexer = PretrainedTransformerIndexer(model_name="patrickvonplaten/t5-tiny-random")
sentence1 = "A, AllenNLP sentence."
tokens1 = tokenizer.tokenize(sentence1)
expected_tokens1 = ["▁A", ",", "▁Allen", "N", "LP", "▁sentence", ".", "</s>"]
assert [t.text for t in tokens1] == expected_tokens1
sentence2 = "AllenNLP is great"
tokens2 = tokenizer.tokenize(sentence2)
expected_tokens2 = ["▁Allen", "N", "LP", "▁is", "▁great", "</s>"]
assert [t.text for t in tokens2] == expected_tokens2
vocab = Vocabulary()
params = Params(
{
"token_embedders": {
"bert": {
"type": "pretrained_transformer",
"model_name": "patrickvonplaten/t5-tiny-random",
"train_parameters": train_parameters,
"last_layer_only": last_layer_only,
"gradient_checkpointing": gradient_checkpointing,
"sub_module": "encoder",
}
}
}
)
token_embedder = BasicTextFieldEmbedder.from_params(vocab=vocab, params=params)
instance1 = Instance({"tokens": TextField(tokens1, {"bert": token_indexer})})
instance2 = Instance({"tokens": TextField(tokens2, {"bert": token_indexer})})
batch = Batch([instance1, instance2])
batch.index_instances(vocab)
padding_lengths = batch.get_padding_lengths()
tensor_dict = batch.as_tensor_dict(padding_lengths)
tokens = tensor_dict["tokens"]
max_length = max(len(tokens1), len(tokens2))
assert tokens["bert"]["token_ids"].shape == (2, max_length)
assert tokens["bert"]["mask"].tolist() == [
[True, True, True, True, True, True, True, True],
[True, True, True, True, True, True, False, False],
]
# Attention mask
bert_vectors = token_embedder(tokens)
assert bert_vectors.size() == (2, 8, 64)
assert bert_vectors.requires_grad == (train_parameters or not last_layer_only)
def test_end_to_end(self):
tokenizer = PretrainedTransformerTokenizer(
model_name="bert-base-uncased")
token_indexer = PretrainedTransformerIndexer(
model_name="bert-base-uncased")
sentence1 = "A, AllenNLP sentence."
tokens1 = tokenizer.tokenize(sentence1)
expected_tokens1 = [
"[CLS]", "a", ",", "allen", "##nl", "##p", "sentence", ".", "[SEP]"
]
assert [t.text for t in tokens1] == expected_tokens1
sentence2 = "AllenNLP is great"
tokens2 = tokenizer.tokenize(sentence2)
expected_tokens2 = [
"[CLS]", "allen", "##nl", "##p", "is", "great", "[SEP]"
]
assert [t.text for t in tokens2] == expected_tokens2
vocab = Vocabulary()
params = Params({
"token_embedders": {
"bert": {
"type": "pretrained_transformer",
"model_name": "bert-base-uncased"
}
},
"embedder_to_indexer_map": {
"bert": ["bert", "mask"]
},
"allow_unmatched_keys": True,
})
token_embedder = BasicTextFieldEmbedder.from_params(vocab=vocab,
params=params)
instance1 = Instance(
{"tokens": TextField(tokens1, {"bert": token_indexer})})
instance2 = Instance(
{"tokens": TextField(tokens2, {"bert": token_indexer})})
batch = Batch([instance1, instance2])
batch.index_instances(vocab)
padding_lengths = batch.get_padding_lengths()
tensor_dict = batch.as_tensor_dict(padding_lengths)
tokens = tensor_dict["tokens"]
max_length = max(len(tokens1), len(tokens2))
assert tokens["bert"].shape == (2, max_length)
assert tokens["mask"].tolist() == [[1, 1, 1, 1, 1, 1, 1, 1, 1],
[1, 1, 1, 1, 1, 1, 1, 0, 0]]
# Attention mask
bert_vectors = token_embedder(tokens)
assert bert_vectors.size() == (2, 9, 768)
def test_long_sequence_splitting_end_to_end(self):
# Mostly the same as the end_to_end test (except for adding max_length=4),
# because we don't want this splitting behavior to change input/output format.
tokenizer = PretrainedTransformerTokenizer(
model_name="bert-base-uncased")
token_indexer = PretrainedTransformerIndexer(
model_name="bert-base-uncased", max_length=4)
sentence1 = "A, AllenNLP sentence."
tokens1 = tokenizer.tokenize(sentence1)
sentence2 = "AllenNLP is great"
tokens2 = tokenizer.tokenize(sentence2)
vocab = Vocabulary()
params = Params({
"token_embedders": {
"bert": {
"type": "pretrained_transformer",
"model_name": "bert-base-uncased",
"max_length": 4,
}
}
})
token_embedder = BasicTextFieldEmbedder.from_params(vocab=vocab,
params=params)
instance1 = Instance(
{"tokens": TextField(tokens1, {"bert": token_indexer})})
instance2 = Instance(
{"tokens": TextField(tokens2, {"bert": token_indexer})})
batch = Batch([instance1, instance2])
batch.index_instances(vocab)
padding_lengths = batch.get_padding_lengths()
tensor_dict = batch.as_tensor_dict(padding_lengths)
tokens = tensor_dict["tokens"]
max_length = max(len(tokens1), len(tokens2))
# Adds n_segments * 2 special tokens
segment_concat_length = int(math.ceil(max_length / 4)) * 2 + max_length
assert tokens["bert"]["token_ids"].shape == (2, segment_concat_length)
assert tokens["bert"]["mask"].tolist() == [
[1, 1, 1, 1, 1, 1, 1, 1, 1],
[1, 1, 1, 1, 1, 1, 1, 0, 0],
]
assert tokens["bert"]["segment_concat_mask"].tolist() == [
[1] * segment_concat_length,
[1] * (segment_concat_length - 4) +
[0] * 4, # 4 is hard-coded length difference
]
# Attention mask
bert_vectors = token_embedder(tokens)
assert bert_vectors.size() == (2, 9, 768)
def test_old_from_params_new_from_params(self):
old_params = Params({
"words1": {
"type": "embedding",
"embedding_dim": 2
},
"words2": {
"type": "embedding",
"embedding_dim": 5
},
"words3": {
"type": "embedding",
"embedding_dim": 3
}
})
# Allow loading the parameters in the old format
with pytest.warns(DeprecationWarning):
old_embedder = BasicTextFieldEmbedder.from_params(
params=old_params, vocab=self.vocab)
new_params = Params({
"token_embedders": {
"words1": {
"type": "embedding",
"embedding_dim": 2
},
"words2": {
"type": "embedding",
"embedding_dim": 5
},
"words3": {
"type": "embedding",
"embedding_dim": 3
}
}
})
# But also allow loading the parameters in the new format
new_embedder = BasicTextFieldEmbedder.from_params(params=new_params,
vocab=self.vocab)
assert old_embedder._token_embedders.keys(
) == new_embedder._token_embedders.keys()
assert new_embedder(self.inputs).size() == (1, 4, 10)
def setUp(self):
super().setUp()
token_indexers = {"tokens": SingleIdTokenIndexer(namespace="tokens")}
tokenizer = WordTokenizer()
list_of_sentences = [
["words1 words2 words3", "words1 words2"],
["words1", "words1 words2"]
]
paragraphs = [
["words1 words2 words3 words1 words2"],
["words1 words1 words2"]
]
instances = []
for sentences, paragraph in zip(list_of_sentences, paragraphs):
sentences_tokens = [tokenizer.tokenize(sentence) for sentence in sentences]
sentences_text_fields = [TextField(sentence_tokens, token_indexers)
for sentence_tokens in sentences_tokens]
sentences_field = ListField(sentences_text_fields)
fields: Dict[str, Field] = {}
fields['sentences'] = sentences_field
paragraph_tokens = [token for sentence_tokens in sentences_tokens for token in sentence_tokens]
paragraph_text_field = TextField(paragraph_tokens, token_indexers)
fields['paragraph'] = paragraph_text_field
instances.append(Instance(fields))
vocab = Vocabulary.from_instances(instances)
batch = Batch(instances)
batch.index_instances(vocab)
tensor_dict = batch.as_tensor_dict()
sentences = tensor_dict["sentences"]
paragraph = tensor_dict["paragraph"]
text_field_embedder_params = Params({
"token_embedders": {
"tokens": {
"type": "embedding",
"embedding_dim": 3
},
}
})
text_field_embedder = BasicTextFieldEmbedder.from_params(vocab=vocab,
params=text_field_embedder_params)
self.embedded_sentences = text_field_embedder(sentences, num_wrapping_dims=1)
self.sentences_mask = get_text_field_mask(sentences, num_wrapping_dims=1).float()
self.sentences_lengths = self.sentences_mask.sum(dim=-1)
self.embedded_paragraph = text_field_embedder(paragraph)
self.paragraph_mask = get_text_field_mask(paragraph).float()
def test_old_from_params_new_from_params(self):
old_params = Params({
"words1": {
"type": "embedding",
"embedding_dim": 2
},
"words2": {
"type": "embedding",
"embedding_dim": 5
},
"words3": {
"type": "embedding",
"embedding_dim": 3
}
})
# Allow loading the parameters in the old format
with pytest.warns(DeprecationWarning):
old_embedder = BasicTextFieldEmbedder.from_params(params=old_params, vocab=self.vocab)
new_params = Params({
"token_embedders": {
"words1": {
"type": "embedding",
"embedding_dim": 2
},
"words2": {
"type": "embedding",
"embedding_dim": 5
},
"words3": {
"type": "embedding",
"embedding_dim": 3
}
}
})
# But also allow loading the parameters in the new format
new_embedder = BasicTextFieldEmbedder.from_params(params=new_params, vocab=self.vocab)
assert old_embedder._token_embedders.keys() == new_embedder._token_embedders.keys() #pylint: disable=protected-access
assert new_embedder(self.inputs).size() == (1, 4, 10)
def __init__(self,
vocab: Vocabulary,
params: Params,
regularizer: RegularizerApplicator = None):
super(LayerCoref, self).__init__(vocab=vocab, regularizer=regularizer)
# Base text Field Embedder
text_field_embedder_params = params.pop("text_field_embedder")
text_field_embedder = BasicTextFieldEmbedder.from_params(
vocab=vocab, params=text_field_embedder_params)
self._text_field_embedder = text_field_embedder
##############
# Coref Stuffs
##############
coref_params = params.pop("coref")
# Encoder
encoder_coref_params = coref_params.pop("encoder")
encoder_coref = Seq2SeqEncoder.from_params(encoder_coref_params)
self._encoder_coref = encoder_coref
# Tagger: Coreference
tagger_coref_params = coref_params.pop("tagger")
eval_on_gold_mentions = tagger_coref_params.pop_bool(
"eval_on_gold_mentions", False)
init_params = tagger_coref_params.pop("initializer", None)
initializer = (InitializerApplicator.from_params(init_params)
if init_params is not None else InitializerApplicator())
tagger_coref = CoreferenceCustom(
vocab=vocab,
text_field_embedder=self._text_field_embedder,
context_layer=self._encoder_coref,
mention_feedforward=FeedForward.from_params(
tagger_coref_params.pop("mention_feedforward")),
antecedent_feedforward=FeedForward.from_params(
tagger_coref_params.pop("antecedent_feedforward")),
feature_size=tagger_coref_params.pop_int("feature_size"),
max_span_width=tagger_coref_params.pop_int("max_span_width"),
spans_per_word=tagger_coref_params.pop_float("spans_per_word"),
max_antecedents=tagger_coref_params.pop_int("max_antecedents"),
lexical_dropout=tagger_coref_params.pop_float(
"lexical_dropout", 0.2),
initializer=initializer,
regularizer=regularizer,
eval_on_gold_mentions=eval_on_gold_mentions,
)
self._tagger_coref = tagger_coref
if eval_on_gold_mentions:
self._tagger_coref._eval_on_gold_mentions = True
logger.info("Multi-Task Learning Model has been instantiated.")
def test_old_from_params_new_from_params(self):
old_params = Params({
u"words1": {
u"type": u"embedding",
u"embedding_dim": 2
},
u"words2": {
u"type": u"embedding",
u"embedding_dim": 5
},
u"words3": {
u"type": u"embedding",
u"embedding_dim": 3
}
})
with pytest.warns(DeprecationWarning):
BasicTextFieldEmbedder.from_params(params=old_params,
vocab=self.vocab)
new_params = Params({
u"token_embedders": {
u"words1": {
u"type": u"embedding",
u"embedding_dim": 2
},
u"words2": {
u"type": u"embedding",
u"embedding_dim": 5
},
u"words3": {
u"type": u"embedding",
u"embedding_dim": 3
}
}
})
token_embedder = BasicTextFieldEmbedder.from_params(params=new_params,
vocab=self.vocab)
assert token_embedder(self.inputs).size() == (1, 4, 10)
def from_params(cls, vocab: Vocabulary,
params: Params) -> 'QAMultiChoiceMaxAttention':
embedder_params = params.pop("text_field_embedder")
text_field_embedder = BasicTextFieldEmbedder.from_params(
vocab, embedder_params)
embeddings_dropout_value = params.pop("embeddings_dropout", 0.0)
# question encoder
question_encoder_params = params.pop("question_encoder", None)
question_enc_aggregate = params.pop("question_encoder_aggregate",
"max")
share_encoders = params.pop("share_encoders", False)
if question_encoder_params is not None:
question_encoder = Seq2SeqEncoder.from_params(
question_encoder_params)
else:
question_encoder = None
if share_encoders:
choice_encoder = question_encoder
choice_enc_aggregate = question_enc_aggregate
else:
# choice encoder
choice_encoder_params = params.pop("choice_encoder", None)
choice_enc_aggregate = params.pop("choice_encoder_aggregate",
"max")
if choice_encoder_params is not None:
choice_encoder = Seq2SeqEncoder.from_params(
choice_encoder_params)
else:
choice_encoder = None
# question to choice attention
att_question_to_choice_params = params.get("att_question_to_choice")
att_question_to_choice = SimilarityFunction.from_params(
att_question_to_choice_params)
init_params = params.pop('initializer', None)
initializer = (InitializerApplicator.from_params(init_params)
if init_params is not None else InitializerApplicator())
return cls(vocab=vocab,
text_field_embedder=text_field_embedder,
question_encoder=question_encoder,
choice_encoder=choice_encoder,
initializer=initializer,
aggregate_choice=choice_enc_aggregate,
aggregate_question=question_enc_aggregate,
embeddings_dropout_value=embeddings_dropout_value,
att_question_to_choice=att_question_to_choice)
def test_end_to_end_for_first_sub_token_embedding(self,
sub_token_mode: str):
token_indexer = PretrainedTransformerMismatchedIndexer(
"bert-base-uncased")
sentence1 = ["A", ",", "AllenNLP", "sentence", "."]
sentence2 = ["AllenNLP", "is", "open", "source", "NLP", "library"]
tokens1 = [Token(word) for word in sentence1]
tokens2 = [Token(word) for word in sentence2]
vocab = Vocabulary()
params = Params({
"token_embedders": {
"bert": {
"type": "pretrained_transformer_mismatched",
"model_name": "bert-base-uncased",
"sub_token_mode": sub_token_mode,
}
}
})
token_embedder = BasicTextFieldEmbedder.from_params(vocab=vocab,
params=params)
instance1 = Instance(
{"tokens": TextField(tokens1, {"bert": token_indexer})})
instance2 = Instance(
{"tokens": TextField(tokens2, {"bert": token_indexer})})
batch = Batch([instance1, instance2])
batch.index_instances(vocab)
padding_lengths = batch.get_padding_lengths()
tensor_dict = batch.as_tensor_dict(padding_lengths)
tokens = tensor_dict["tokens"]
assert tokens["bert"]["mask"].tolist() == [
[True, True, True, True, True, False],
[True, True, True, True, True, True],
]
assert tokens["bert"]["offsets"].tolist() == [
[[1, 1], [2, 2], [3, 5], [6, 6], [7, 7], [0, 0]],
[[1, 3], [4, 4], [5, 5], [6, 6], [7, 8], [9, 9]],
]
# Attention mask
bert_vectors = token_embedder(tokens)
assert bert_vectors.size() == (2, max(len(sentence1),
len(sentence2)), 768)
assert not torch.isnan(bert_vectors).any()
def test_old_from_params_new_from_params(self):
old_params = Params({
"words1": {
"type": "embedding",
"embedding_dim": 2
},
"words2": {
"type": "embedding",
"embedding_dim": 5
},
"words3": {
"type": "embedding",
"embedding_dim": 3
}
})
with pytest.warns(DeprecationWarning):
BasicTextFieldEmbedder.from_params(params=old_params, vocab=self.vocab)
new_params = Params({
"token_embedders": {
"words1": {
"type": "embedding",
"embedding_dim": 2
},
"words2": {
"type": "embedding",
"embedding_dim": 5
},
"words3": {
"type": "embedding",
"embedding_dim": 3
}
}
})
token_embedder = BasicTextFieldEmbedder.from_params(params=new_params, vocab=self.vocab)
assert token_embedder(self.inputs).size() == (1, 4, 10)
def from_params(cls, vocab: Vocabulary,
params: Params) -> 'StackedNNAggregateCustom':
embedder_params = params.pop("text_field_embedder")
text_field_embedder = BasicTextFieldEmbedder.from_params(
vocab, embedder_params)
embeddings_dropout_value = params.pop("embeddings_dropout", 0.0)
share_encoders = params.pop("share_encoders", False)
# premise encoder
premise_encoder_params = params.pop("premise_encoder", None)
premise_enc_aggregate = params.pop("premise_encoder_aggregate", "max")
if premise_encoder_params is not None:
premise_encoder = Seq2SeqEncoder.from_params(
premise_encoder_params)
else:
premise_encoder = None
# hypothesis encoder
if share_encoders:
hypothesis_enc_aggregate = premise_enc_aggregate
hypothesis_encoder = premise_encoder
else:
hypothesis_encoder_params = params.pop("hypothesis_encoder", None)
hypothesis_enc_aggregate = params.pop(
"hypothesis_encoder_aggregate", "max")
if hypothesis_encoder_params is not None:
hypothesis_encoder = Seq2SeqEncoder.from_params(
hypothesis_encoder_params)
else:
hypothesis_encoder = None
aggregate_feedforward = FeedForward.from_params(
params.pop('aggregate_feedforward'))
init_params = params.pop('initializer', None)
initializer = (InitializerApplicator.from_params(init_params)
if init_params is not None else InitializerApplicator())
return cls(vocab=vocab,
text_field_embedder=text_field_embedder,
aggregate_feedforward=aggregate_feedforward,
premise_encoder=premise_encoder,
hypothesis_encoder=hypothesis_encoder,
initializer=initializer,
aggregate_hypothesis=hypothesis_enc_aggregate,
aggregate_premise=premise_enc_aggregate,
embeddings_dropout_value=embeddings_dropout_value,
share_encoders=share_encoders)
def from_params(cls, vocab: Vocabulary, params: Params) -> 'QAMultiChoice_OneVsRest_Choices_v1':
embedder_params = params.pop("text_field_embedder")
text_field_embedder = BasicTextFieldEmbedder.from_params(vocab, embedder_params)
embeddings_dropout_value = params.pop("embeddings_dropout", 0.0)
# question encoder
question_encoder_params = params.pop("question_encoder", None)
question_enc_aggregate = params.pop("question_encoder_aggregate", "max")
share_encoders = params.pop("share_encoders", False)
# condition the choices or facts encoding on quesiton output states
choices_init_from_question_states = params.pop("choices_init_from_question_states", False)
if question_encoder_params is not None:
question_encoder = Seq2SeqEncoder.from_params(question_encoder_params)
else:
question_encoder = None
if share_encoders:
choice_encoder = question_encoder
choice_enc_aggregate = question_enc_aggregate
else:
# choice encoder
choice_encoder_params = params.pop("choice_encoder", None)
choice_enc_aggregate = params.pop("choice_encoder_aggregate", "max")
if choice_encoder_params is not None:
choice_encoder = Seq2SeqEncoder.from_params(choice_encoder_params)
else:
choice_encoder = None
use_choice_sum_instead_of_question = params.get("use_choice_sum_instead_of_question", False)
init_params = params.pop('initializer', None)
initializer = (InitializerApplicator.from_params(init_params)
if init_params is not None
else InitializerApplicator())
return cls(vocab=vocab,
text_field_embedder=text_field_embedder,
question_encoder=question_encoder,
choice_encoder=choice_encoder,
initializer=initializer,
aggregate_choice=choice_enc_aggregate,
aggregate_question=question_enc_aggregate,
embeddings_dropout_value=embeddings_dropout_value,
share_encoders=share_encoders,
choices_init_from_question_states=choices_init_from_question_states,
use_choice_sum_instead_of_question=use_choice_sum_instead_of_question,
params=params)
def from_params(cls, vocab: Vocabulary, params: Params) -> 'LstmSwag':
embedder_params = params.pop("text_field_embedder")
text_field_embedder = BasicTextFieldEmbedder.from_params(
vocab=vocab, params=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 test_token_without_wordpieces(self):
token_indexer = PretrainedTransformerMismatchedIndexer(
"bert-base-uncased")
sentence1 = ["A", "", "AllenNLP", "sentence", "."]
sentence2 = ["AllenNLP", "", "great"]
tokens1 = [Token(word) for word in sentence1]
tokens2 = [Token(word) for word in sentence2]
vocab = Vocabulary()
params = Params({
"token_embedders": {
"bert": {
"type": "pretrained_transformer_mismatched",
"model_name": "bert-base-uncased",
}
}
})
token_embedder = BasicTextFieldEmbedder.from_params(vocab=vocab,
params=params)
instance1 = Instance(
{"tokens": TextField(tokens1, {"bert": token_indexer})})
instance2 = Instance(
{"tokens": TextField(tokens2, {"bert": token_indexer})})
batch = Batch([instance1, instance2])
batch.index_instances(vocab)
padding_lengths = batch.get_padding_lengths()
tensor_dict = batch.as_tensor_dict(padding_lengths)
tokens = tensor_dict["tokens"]
assert tokens["bert"]["offsets"].tolist() == [
[[1, 1], [-1, -1], [2, 4], [5, 5], [6, 6]],
[[1, 3], [-1, -1], [4, 4], [0, 0], [0, 0]],
]
bert_vectors = token_embedder(tokens)
assert bert_vectors.size() == (2, max(len(sentence1),
len(sentence2)), 768)
assert not torch.isnan(bert_vectors).any()
assert all(bert_vectors[0, 1] == 0)
assert all(bert_vectors[1, 1] == 0)
def test_forward_runs_with_non_bijective_mapping_with_null(self):
elmo_fixtures_path = self.FIXTURES_ROOT / "elmo"
options_file = str(elmo_fixtures_path / "options.json")
weight_file = str(elmo_fixtures_path / "lm_weights.hdf5")
params = Params({
"token_embedders": {
"elmo": {
"type": "elmo_token_embedder",
"options_file": options_file,
"weight_file": weight_file,
}
},
"embedder_to_indexer_map": {
# ignore `word_inputs` in `ElmoTokenEmbedder.forward`
"elmo": ["elmo", None]
},
})
token_embedder = BasicTextFieldEmbedder.from_params(self.vocab, params)
inputs = {"elmo": (torch.rand(3, 6, 50) * 15).long()}
token_embedder(inputs)
def test_forward_runs_with_forward_params(self):
elmo_fixtures_path = self.FIXTURES_ROOT / "elmo_multilingual" / "es"
options_file = str(elmo_fixtures_path / "options.json")
weight_file = str(elmo_fixtures_path / "weights.hdf5")
params = Params({
"token_embedders": {
"elmo": {
"type": "elmo_token_embedder_multilang",
"options_files": {
"es": options_file
},
"weight_files": {
"es": weight_file
},
}
}
})
token_embedder = BasicTextFieldEmbedder.from_params(self.vocab, params)
inputs = {"elmo": (torch.rand(3, 6, 50) * 15).long()}
kwargs = {"lang": "es"}
token_embedder(inputs, **kwargs)
def test_throws_error_on_incorrect_sub_token_mode(self,
sub_token_mode: str):
token_indexer = PretrainedTransformerMismatchedIndexer(
"bert-base-uncased")
sentence1 = ["A", ",", "AllenNLP", "sentence", "."]
sentence2 = ["AllenNLP", "is", "open", "source", "NLP", "library"]
tokens1 = [Token(word) for word in sentence1]
tokens2 = [Token(word) for word in sentence2]
vocab = Vocabulary()
params = Params({
"token_embedders": {
"bert": {
"type": "pretrained_transformer_mismatched",
"model_name": "bert-base-uncased",
"sub_token_mode": sub_token_mode,
}
}
})
token_embedder = BasicTextFieldEmbedder.from_params(vocab=vocab,
params=params)
instance1 = Instance(
{"tokens": TextField(tokens1, {"bert": token_indexer})})
instance2 = Instance(
{"tokens": TextField(tokens2, {"bert": token_indexer})})
batch = Batch([instance1, instance2])
batch.index_instances(vocab)
padding_lengths = batch.get_padding_lengths()
tensor_dict = batch.as_tensor_dict(padding_lengths)
tokens = tensor_dict["tokens"]
with pytest.raises(ConfigurationError):
token_embedder(tokens)
def __init__(self,
vocab: Vocabulary,
params: Params,
regularizer: RegularizerApplicator = None):
super(LayerRelation, self).__init__(vocab=vocab,
regularizer=regularizer)
# Base text Field Embedder
text_field_embedder_params = params.pop("text_field_embedder")
text_field_embedder = BasicTextFieldEmbedder.from_params(
vocab=vocab, params=text_field_embedder_params)
self._text_field_embedder = text_field_embedder
############################
# Relation Extraction Stuffs
############################
relation_params = params.pop("relation")
# Encoder
encoder_relation_params = relation_params.pop("encoder")
encoder_relation = Seq2SeqEncoder.from_params(encoder_relation_params)
self._encoder_relation = encoder_relation
# Tagger: Relation
tagger_relation_params = relation_params.pop("tagger")
tagger_relation = RelationExtractor(
vocab=vocab,
text_field_embedder=self._text_field_embedder,
context_layer=self._encoder_relation,
d=tagger_relation_params.pop_int("d"),
l=tagger_relation_params.pop_int("l"),
n_classes=tagger_relation_params.pop("n_classes"),
activation=tagger_relation_params.pop("activation"),
)
self._tagger_relation = tagger_relation
logger.info("Multi-Task Learning Model has been instantiated.")
def __init__(self,
vocab: Vocabulary,
params: Params,
regularizer: RegularizerApplicator = None):
super(LayerNerEmdCoref, self).__init__(vocab=vocab,
regularizer=regularizer)
# Base text Field Embedder
text_field_embedder_params = params.pop("text_field_embedder")
text_field_embedder = BasicTextFieldEmbedder.from_params(
vocab=vocab, params=text_field_embedder_params)
self._text_field_embedder = text_field_embedder
############
# NER Stuffs
############
ner_params = params.pop("ner")
# Encoder
encoder_ner_params = ner_params.pop("encoder")
encoder_ner = Seq2SeqEncoder.from_params(encoder_ner_params)
self._encoder_ner = encoder_ner
# Tagger NER - CRF Tagger
tagger_ner_params = ner_params.pop("tagger")
tagger_ner = CrfTagger(
vocab=vocab,
text_field_embedder=self._text_field_embedder,
encoder=self._encoder_ner,
label_namespace=tagger_ner_params.pop("label_namespace", "labels"),
constraint_type=tagger_ner_params.pop("constraint_type", None),
dropout=tagger_ner_params.pop("dropout", None),
regularizer=regularizer)
self._tagger_ner = tagger_ner
############
# EMD Stuffs
############
emd_params = params.pop("emd")
# Encoder
encoder_emd_params = emd_params.pop("encoder")
encoder_emd = Seq2SeqEncoder.from_params(encoder_emd_params)
self._encoder_emd = encoder_emd
shortcut_text_field_embedder = ShortcutConnectTextFieldEmbedder(
base_text_field_embedder=self._text_field_embedder,
previous_encoders=[self._encoder_ner])
self._shortcut_text_field_embedder = shortcut_text_field_embedder
# Tagger: EMD - CRF Tagger
tagger_emd_params = emd_params.pop("tagger")
tagger_emd = CrfTagger(
vocab=vocab,
text_field_embedder=self._shortcut_text_field_embedder,
encoder=self._encoder_emd,
label_namespace=tagger_emd_params.pop("label_namespace", "labels"),
constraint_type=tagger_emd_params.pop("constraint_type", None),
dropout=tagger_ner_params.pop("dropout", None),
regularizer=regularizer)
self._tagger_emd = tagger_emd
##############
# Coref Stuffs
##############
coref_params = params.pop("coref")
# Encoder
encoder_coref_params = coref_params.pop("encoder")
encoder_coref = Seq2SeqEncoder.from_params(encoder_coref_params)
self._encoder_coref = encoder_coref
shortcut_text_field_embedder_coref = ShortcutConnectTextFieldEmbedder(
base_text_field_embedder=self._text_field_embedder,
previous_encoders=[self._encoder_ner, self._encoder_emd])
self._shortcut_text_field_embedder_coref = shortcut_text_field_embedder_coref
# Tagger: Coreference
tagger_coref_params = coref_params.pop("tagger")
eval_on_gold_mentions = tagger_coref_params.pop_bool(
"eval_on_gold_mentions", False)
init_params = tagger_coref_params.pop("initializer", None)
initializer = (InitializerApplicator.from_params(init_params)
if init_params is not None else InitializerApplicator())
tagger_coref = CoreferenceCustom(
vocab=vocab,
text_field_embedder=self._shortcut_text_field_embedder_coref,
context_layer=self._encoder_coref,
mention_feedforward=FeedForward.from_params(
tagger_coref_params.pop("mention_feedforward")),
antecedent_feedforward=FeedForward.from_params(
tagger_coref_params.pop("antecedent_feedforward")),
feature_size=tagger_coref_params.pop_int("feature_size"),
max_span_width=tagger_coref_params.pop_int("max_span_width"),
spans_per_word=tagger_coref_params.pop_float("spans_per_word"),
max_antecedents=tagger_coref_params.pop_int("max_antecedents"),
lexical_dropout=tagger_coref_params.pop_float(
"lexical_dropout", 0.2),
initializer=initializer,
regularizer=regularizer,
eval_on_gold_mentions=eval_on_gold_mentions)
self._tagger_coref = tagger_coref
if eval_on_gold_mentions:
self._tagger_coref._eval_on_gold_mentions = True
logger.info("Multi-Task Learning Model has been instantiated.")
def __init__(self,
vocab: Vocabulary,
params: Params,
regularizer: RegularizerApplicator = None):
super(JointBiaffine, self).__init__(vocab=vocab,
regularizer=regularizer)
# Base text Field Embedder
text_field_embedder_params = params.pop("text_field_embedder")
text_field_embedder = BasicTextFieldEmbedder.from_params(
vocab=vocab, params=text_field_embedder_params)
self._text_field_embedder = text_field_embedder
# Encoder
encoder_params = params.pop("encoder")
encoder = Seq2SeqEncoder.from_params(encoder_params)
self._encoder = encoder
self._group_shared_matrix = torch.FloatTensor()
self._tag_representation_dim = params.pop('tag_representation_dim')
self._arc_representation_dim = params.pop('arc_representation_dim')
self._dropout = params.pop('dropout')
self._input_dropout = params.pop('input_dropout')
############
# DSP Stuffs
############
dsp_params = params.pop("dsp")
init_params = dsp_params.pop("initializer", None)
self._initializer = (InitializerApplicator.from_params(init_params)
if init_params is not None else
InitializerApplicator())
pos_params = dsp_params.pop("pos_tag_embedding")
self._pos_tag_embedding = Embedding.from_params(vocab, pos_params)
# Tagger DSP - Biaffine Tagger
tagger_dsp = BiaffineParser(
vocab=vocab,
task_type='dsp',
text_field_embedder=self._text_field_embedder,
encoder=self._encoder,
tag_representation_dim=self._tag_representation_dim,
arc_representation_dim=self._arc_representation_dim,
pos_tag_embedding=self._pos_tag_embedding,
dropout=self._dropout,
input_dropout=self._input_dropout,
initializer=self._initializer)
self._tagger_dsp = tagger_dsp
# arc shared
self._arc_attention = tagger_dsp.arc_attention
self._head_arc_feedforward = tagger_dsp.head_arc_feedforward
self._child_arc_feedforward = tagger_dsp.child_arc_feedforward
############
# SRL Stuffs
############
srl_params = params.pop("srl")
init_params = srl_params.pop("initializer", None)
self._initializer = (InitializerApplicator.from_params(init_params)
if init_params is not None else
InitializerApplicator())
pos_params = srl_params.pop("pos_tag_embedding")
self._pos_tag_embedding = Embedding.from_params(vocab, pos_params)
# Tagger: EMD - CRF Tagger
tagger_srl = BiaffineParser(
vocab=vocab,
task_type='srl',
text_field_embedder=self._text_field_embedder,
encoder=self._encoder,
tag_representation_dim=self._tag_representation_dim,
arc_representation_dim=self._arc_representation_dim,
pos_tag_embedding=self._pos_tag_embedding,
dropout=self._dropout,
input_dropout=self._input_dropout,
initializer=self._initializer)
tagger_srl.arc_attention = self._arc_attention
tagger_srl.head_arc_feedforward = self._head_arc_feedforward
tagger_srl.child_arc_feedforward = self._child_arc_feedforward
self._tagger_srl = tagger_srl
logger.info("Multi-Task Learning Model has been instantiated.")
def __init__(self,
vocab: Vocabulary,
params: Params,
regularizer: Optional[RegularizerApplicator] = None):
super(LayerPOSChunkDeppar, self).__init__(vocab=vocab,
regularizer=regularizer)
# Base text Field Embedder
text_field_embedder_params = params.pop("text_field_embedder")
text_field_embedder = BasicTextFieldEmbedder.from_params(
vocab=vocab, params=text_field_embedder_params)
self._text_field_embedder = text_field_embedder
############
# POS Stuffs
############
pos_params = params.pop("pos")
# Encoder
encoder_pos_params = pos_params.pop("encoder")
encoder_pos = Seq2SeqEncoder.from_params(encoder_pos_params)
self._encoder_pos = encoder_pos
# Tagger POS - Simple Tagger
tagger_pos_params = pos_params.pop("tagger")
# Can be updated to the pos model that is created
tagger_pos = PosSimpleTagger(
vocab=vocab,
text_field_embedder=self._text_field_embedder,
encoder=self._encoder_pos,
label_namespace=tagger_pos_params.pop("label_namespace", "labels"),
regularizer=regularizer,
)
self._tagger_pos = tagger_pos
############
# Chunk Stuffs
############
chunk_params = params.pop("chunk")
# Encoder
encoder_chunk_params = chunk_params.pop("encoder")
encoder_chunk = Seq2SeqEncoder.from_params(encoder_chunk_params)
self._encoder_chunk = encoder_chunk
shortcut_text_field_embedder = ShortcutConnectTextFieldEmbedder(
base_text_field_embedder=self._text_field_embedder,
previous_encoders=[self._encoder_pos])
self._shortcut_text_field_embedder = shortcut_text_field_embedder
# Tagger: Chunk - CRF Tagger
tagger_chunk_params = chunk_params.pop("tagger")
tagger_chunk = ChunkSimpleTagger(
vocab=vocab,
text_field_embedder=self._shortcut_text_field_embedder,
encoder=self._encoder_chunk,
label_namespace=tagger_chunk_params.pop("label_namespace",
"labels"),
label_encoding=tagger_chunk_params.pop("label_encoding", None),
regularizer=regularizer,
)
self._tagger_chunk = tagger_chunk
###########
# Dependency Parsing Stuffs
###########
deppar_params = params.pop("deppar")
# Encoder
encoder_deppar_params = deppar_params.pop("encoder")
encoder_deppar = Seq2SeqEncoder.from_params(encoder_deppar_params)
self._encoder_deppar = encoder_deppar
shortcut_text_field_embedder_deppar = ShortcutConnectTextFieldEmbedder(
base_text_field_embedder=self._text_field_embedder,
previous_encoders=[self._encoder_pos, self._encoder_chunk])
self._shortcut_text_field_embedder_deppar = shortcut_text_field_embedder_deppar
# Parser: Dependency Parser - Biaffine Parser
parser_deppar_params = deppar_params.pop("parser")
embedding_deppar_params = deppar_params.pop("pos_tag_embedding")
embedding = Embedding(
num_embeddings=vocab.get_vocab_size('tokens'),
embedding_dim=embedding_deppar_params.pop_int("embedding_dim"),
vocab_namespace=embedding_deppar_params.pop("vocab_namespace"))
init_params = parser_deppar_params.pop("initializer", None)
initializer = (InitializerApplicator.from_params(init_params)
if init_params is not None else InitializerApplicator())
tagger_deppar = BiaffineDependencyParser(
vocab=vocab,
text_field_embedder=self._shortcut_text_field_embedder_deppar,
encoder=self._encoder_deppar,
tag_representation_dim=parser_deppar_params.pop_int(
"tag_representation_dim"),
arc_representation_dim=parser_deppar_params.pop_int(
"arc_representation_dim"),
pos_tag_embedding=embedding,
use_mst_decoding_for_validation=parser_deppar_params.pop(
"use_mst_decoding_for_validation"),
dropout=parser_deppar_params.pop_float("dropout"),
input_dropout=parser_deppar_params.pop_float("input_dropout"),
initializer=initializer,
regularizer=regularizer)
self._tagger_deppar = tagger_deppar
logger.info("Multi-Task Learning Model has been instantiated.")
def from_params(cls, vocab: Vocabulary,
params: Params) -> 'QAMultiChoiceKnowReader_v1':
embedder_params = params.pop("text_field_embedder")
text_field_embedder = BasicTextFieldEmbedder.from_params(
vocab, embedder_params)
embeddings_dropout_value = params.pop("embeddings_dropout", 0.0)
# whether we want to use knowledge
use_knowledge = params.pop("use_knowledge", True)
use_ctx2facts_retrieval_map_as_mask = params.pop(
"use_ctx2facts_retrieval_map_as_mask", False)
# question encoder
question_encoder_params = params.pop("question_encoder", None)
question_enc_aggregate = params.pop("question_encoder_aggregate",
"max")
share_encoders = params.pop("share_encoders", False)
# condition the choices or facts encoding on quesiton output states
choices_init_from_question_states = params.pop(
"choices_init_from_question_states", False)
facts_init_from_question_states = params.pop(
"facts_init_from_question_states", False)
if question_encoder_params is not None:
question_encoder = Seq2SeqEncoder.from_params(
question_encoder_params)
else:
question_encoder = None
knowledge_encoder = None
knowledge_enc_aggregate = "max"
if share_encoders:
choice_encoder = question_encoder
choice_enc_aggregate = question_enc_aggregate
if use_knowledge:
knowledge_encoder = question_encoder
knowledge_enc_aggregate = question_enc_aggregate
else:
# choice encoder
choice_encoder_params = params.pop("choice_encoder", None)
choice_enc_aggregate = params.pop("choice_encoder_aggregate",
"max")
if choice_encoder_params is not None:
choice_encoder = Seq2SeqEncoder.from_params(
choice_encoder_params)
else:
choice_encoder = None
if use_knowledge:
knowledge_encoder_params = params.pop("knowledge_encoder",
None)
knowledge_enc_aggregate = params.pop(
"knowledge_encoder_aggregate", "max")
if knowledge_encoder_params is not None:
knowledge_encoder = Seq2SeqEncoder.from_params(
knowledge_encoder_params)
else:
knowledge_encoder = None
know_interactions_params = params.get("know_interactions")
know_interactions_aggregate_ffw_params = know_interactions_params.get(
'aggregate_feedforward')
# aggregate knowledge input state is inferred automatically
update_params(know_interactions_aggregate_ffw_params, {
"input_dim":
len(know_interactions_params.get("interactions", []))
})
know_aggregate_feedforward = FeedForward.from_params(
params.get("know_interactions").get('aggregate_feedforward'))
init_params = params.pop('initializer', None)
initializer = (InitializerApplicator.from_params(init_params)
if init_params is not None else InitializerApplicator())
return cls(
vocab=vocab,
text_field_embedder=text_field_embedder,
question_encoder=question_encoder,
choice_encoder=choice_encoder,
use_knowledge=use_knowledge,
facts_encoder=knowledge_encoder,
know_aggregate_feedforward=know_aggregate_feedforward,
initializer=initializer,
aggregate_choice=choice_enc_aggregate,
aggregate_question=question_enc_aggregate,
aggregate_facts=knowledge_enc_aggregate,
embeddings_dropout_value=embeddings_dropout_value,
share_encoders=share_encoders,
choices_init_from_question_states=choices_init_from_question_states,
facts_init_from_question_states=facts_init_from_question_states,
use_ctx2facts_retrieval_map_as_mask=
use_ctx2facts_retrieval_map_as_mask,
params=params)
def __init__(self,
vocab: Vocabulary,
params: Params,
regularizer: RegularizerApplicator = None):
super(LayerEmdRelation, self).__init__(vocab=vocab,
regularizer=regularizer)
# Base text Field Embedder
text_field_embedder_params = params.pop("text_field_embedder")
text_field_embedder = BasicTextFieldEmbedder.from_params(
vocab=vocab, params=text_field_embedder_params)
self._text_field_embedder = text_field_embedder
############
# EMD Stuffs
############
emd_params = params.pop("emd")
# Encoder
encoder_emd_params = emd_params.pop("encoder")
encoder_emd = Seq2SeqEncoder.from_params(encoder_emd_params)
self._encoder_emd = encoder_emd
# Tagger EMD - CRF Tagger
tagger_emd_params = emd_params.pop("tagger")
tagger_emd = CrfTagger(
vocab=vocab,
text_field_embedder=self._text_field_embedder,
encoder=self._encoder_emd,
label_namespace=tagger_emd_params.pop("label_namespace", "labels"),
label_encoding=tagger_emd_params.pop("label_encoding", None),
dropout=tagger_emd_params.pop("dropout", None),
regularizer=regularizer,
)
self._tagger_emd = tagger_emd
############################
# Relation Extraction Stuffs
############################
relation_params = params.pop("relation")
# Encoder
encoder_relation_params = relation_params.pop("encoder")
encoder_relation = Seq2SeqEncoder.from_params(encoder_relation_params)
self._encoder_relation = encoder_relation
shortcut_text_field_embedder_relation = ShortcutConnectTextFieldEmbedder(
base_text_field_embedder=self._text_field_embedder,
previous_encoders=[self._encoder_emd])
self._shortcut_text_field_embedder_relation = shortcut_text_field_embedder_relation
# Tagger: Relation
tagger_relation_params = relation_params.pop("tagger")
tagger_relation = RelationExtractor(
vocab=vocab,
text_field_embedder=self._shortcut_text_field_embedder_relation,
context_layer=self._encoder_relation,
d=tagger_relation_params.pop_int("d"),
l=tagger_relation_params.pop_int("l"),
n_classes=tagger_relation_params.pop("n_classes"),
activation=tagger_relation_params.pop("activation"),
)
self._tagger_relation = tagger_relation
logger.info("Multi-Task Learning Model has been instantiated.")
