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, 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 test_get_entity_action_logits(self):
decoder_step = WikiTablesDecoderStep(1, 5, SimilarityFunction.from_params(Params({})), 5, 3)
actions_to_link = [[1, 2], [3, 4, 5], [6]]
# (group_size, num_question_tokens) = (3, 3)
attention_weights = Variable(torch.Tensor([[.2, .8, 0],
[.7, .1, .2],
[.3, .3, .4]]))
action_logits, mask, type_embeddings = decoder_step._get_entity_action_logits(self.state,
actions_to_link,
attention_weights)
assert_almost_equal(mask.data.cpu().numpy(), [[1, 1, 0], [1, 1, 1], [1, 0, 0]])
assert tuple(action_logits.size()) == (3, 3)
assert_almost_equal(action_logits[0, 0].data.cpu().numpy(), .4 * .2 + .5 * .8 + .6 * 0)
assert_almost_equal(action_logits[0, 1].data.cpu().numpy(), .7 * .2 + .8 * .8 + .9 * 0)
assert_almost_equal(action_logits[1, 0].data.cpu().numpy(), -.4 * .7 + -.5 * .1 + -.6 * .2)
assert_almost_equal(action_logits[1, 1].data.cpu().numpy(), -.7 * .7 + -.8 * .1 + -.9 * .2)
assert_almost_equal(action_logits[1, 2].data.cpu().numpy(), -1.0 * .7 + -1.1 * .1 + -1.2 * .2)
assert_almost_equal(action_logits[2, 0].data.cpu().numpy(), 1.0 * .3 + 1.1 * .3 + 1.2 * .4)
embedding_matrix = decoder_step._entity_type_embedding.weight.data.cpu().numpy()
assert_almost_equal(type_embeddings[0, 0].data.cpu().numpy(), embedding_matrix[2])
assert_almost_equal(type_embeddings[0, 1].data.cpu().numpy(), embedding_matrix[1])
assert_almost_equal(type_embeddings[1, 0].data.cpu().numpy(), embedding_matrix[0])
assert_almost_equal(type_embeddings[1, 1].data.cpu().numpy(), embedding_matrix[1])
assert_almost_equal(type_embeddings[1, 2].data.cpu().numpy(), embedding_matrix[2])
assert_almost_equal(type_embeddings[2, 0].data.cpu().numpy(), embedding_matrix[0])
def from_params(cls, vocab: Vocabulary, params: Params) -> 'DialogueContextCoherenceAttentionClassifier':
embedder_params = params.pop("text_field_embedder")
text_field_embedder = TextFieldEmbedder.from_params(vocab, embedder_params)
context_encoder_params = params.pop("context_encoder", None)
if context_encoder_params is not None:
context_encoder = Seq2SeqEncoder.from_params(context_encoder_params)
else:
context_encoder = None
response_encoder_params = params.pop("response_encoder", None)
if response_encoder_params is not None:
response_encoder = Seq2SeqEncoder.from_params(response_encoder_params)
else:
response_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'))
classifier_feedforward = FeedForward.from_params(params.pop("classifier_feedforward"))
initializer = InitializerApplicator.from_params(params.pop("initializer", []))
regularizer = RegularizerApplicator.from_params(params.pop("regularizer", []))
return cls(vocab=vocab,
text_field_embedder=text_field_embedder,
attend_feedforward=attend_feedforward,
similarity_function=similarity_function,
compare_feedforward=compare_feedforward,
classifier_feedforward=classifier_feedforward,
context_encoder=context_encoder,
response_encoder=response_encoder,
initializer=initializer,
regularizer=regularizer)
def test_get_entity_action_logits(self):
decoder_step = WikiTablesDecoderStep(1, 5, SimilarityFunction.from_params(Params({})), 5, 3)
actions_to_link = [[1, 2], [3, 4, 5], [6]]
# (group_size, num_question_tokens) = (3, 3)
attention_weights = torch.Tensor([[.2, .8, 0],
[.7, .1, .2],
[.3, .3, .4]])
action_logits, mask, type_embeddings = decoder_step._get_entity_action_logits(self.state,
actions_to_link,
attention_weights)
assert_almost_equal(mask.detach().cpu().numpy(), [[1, 1, 0], [1, 1, 1], [1, 0, 0]])
assert tuple(action_logits.size()) == (3, 3)
assert_almost_equal(action_logits[0, 0].detach().cpu().numpy(), .4 * .2 + .5 * .8 + .6 * 0)
assert_almost_equal(action_logits[0, 1].detach().cpu().numpy(), .7 * .2 + .8 * .8 + .9 * 0)
assert_almost_equal(action_logits[1, 0].detach().cpu().numpy(), -.4 * .7 + -.5 * .1 + -.6 * .2)
assert_almost_equal(action_logits[1, 1].detach().cpu().numpy(), -.7 * .7 + -.8 * .1 + -.9 * .2)
assert_almost_equal(action_logits[1, 2].detach().cpu().numpy(), -1.0 * .7 + -1.1 * .1 + -1.2 * .2)
assert_almost_equal(action_logits[2, 0].detach().cpu().numpy(), 1.0 * .3 + 1.1 * .3 + 1.2 * .4)
embedding_matrix = decoder_step._entity_type_embedding.weight.detach().cpu().numpy()
assert_almost_equal(type_embeddings[0, 0].detach().cpu().numpy(), embedding_matrix[2])
assert_almost_equal(type_embeddings[0, 1].detach().cpu().numpy(), embedding_matrix[1])
assert_almost_equal(type_embeddings[1, 0].detach().cpu().numpy(), embedding_matrix[0])
assert_almost_equal(type_embeddings[1, 1].detach().cpu().numpy(), embedding_matrix[1])
assert_almost_equal(type_embeddings[1, 2].detach().cpu().numpy(), embedding_matrix[2])
assert_almost_equal(type_embeddings[2, 0].detach().cpu().numpy(), embedding_matrix[0])
def from_params(cls, vocab: Vocabulary, params: Params) -> 'ESIM':
embedder_params = params.pop("text_field_embedder")
text_field_embedder = TextFieldEmbedder.from_params(
vocab, embedder_params)
encoder = Seq2SeqEncoder.from_params(params.pop("encoder"))
similarity_function = SimilarityFunction.from_params(
params.pop("similarity_function"))
projection_feedforward = FeedForward.from_params(
params.pop('projection_feedforward'))
inference_encoder = Seq2SeqEncoder.from_params(
params.pop("inference_encoder"))
output_feedforward = FeedForward.from_params(
params.pop('output_feedforward'))
output_logit = FeedForward.from_params(params.pop('output_logit'))
initializer = InitializerApplicator.from_params(
params.pop('initializer', []))
regularizer = RegularizerApplicator.from_params(
params.pop('regularizer', []))
dropout = params.pop("dropout", 0)
params.assert_empty(cls.__name__)
return cls(vocab=vocab,
text_field_embedder=text_field_embedder,
encoder=encoder,
similarity_function=similarity_function,
projection_feedforward=projection_feedforward,
inference_encoder=inference_encoder,
output_feedforward=output_feedforward,
output_logit=output_logit,
initializer=initializer,
dropout=dropout,
regularizer=regularizer)
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', []))
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, 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_int("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"))
dropout = params.pop_float('dropout', 0.2)
initializer = InitializerApplicator.from_params(params.pop('initializer', []))
regularizer = RegularizerApplicator.from_params(params.pop('regularizer', []))
mask_lstms = params.pop_bool('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,
dropout=dropout,
mask_lstms=mask_lstms,
initializer=initializer,
regularizer=regularizer)
def from_params(cls, vocab, params):
''' Initialize from a Params object '''
similarity_function = SimilarityFunction.from_params(params.pop("similarity_function"))
modeling_layer = Seq2SeqEncoder.from_params(params.pop("modeling_layer"))
dropout = params.pop('dropout', 0.2)
initializer = InitializerApplicator.from_params(params.pop('initializer', []))
mask_lstms = params.pop('mask_lstms', True)
params.assert_empty(cls.__name__)
return cls(vocab=vocab, attention_similarity_function=similarity_function,
modeling_layer=modeling_layer, dropout=dropout,
mask_lstms=mask_lstms, initializer=initializer)
def from_params(cls, vocab: Vocabulary,
params: Params) -> 'QAMultiChoiceMaxAttention':
embedder_params = params.pop("text_field_embedder")
text_field_embedder = TextFieldEmbedder.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 from_params(cls, params: Params) -> 'ESIMAttention':
similarity_function = SimilarityFunction.from_params(
params.pop("similarity_function"))
response_projection_feedforward = FeedForward.from_params(
params.pop("response_projection_feedforward"))
response_inference_encoder = Seq2SeqEncoder.from_params(
params.pop("response_inference_encoder"))
source_projection_feedforward_params = params.pop(
"source_projection_feedforward", None)
source_projection_feedforward = None
if source_projection_feedforward_params is not None:
source_projection_feedforward = FeedForward.from_params(
source_projection_feedforward_params)
response_input_feedforward_params = params.pop(
"response_input_feedforward", None)
response_input_feedforward = None
if response_input_feedforward_params is not None:
response_input_feedforward = FeedForward.from_params(
response_input_feedforward_params)
source_input_feedforward_params = params.pop(
"source_input_feedforward", None)
source_input_feedforward = None
if source_input_feedforward_params is not None:
source_input_feedforward = FeedForward.from_params(
source_input_feedforward_params)
source_inference_encoder_params = params.pop(
"source_inference_encoder", None)
if source_inference_encoder_params is not None:
source_inference_encoder = Seq2SeqEncoder.from_params(
source_inference_encoder_params)
else:
source_inference_encoder = None
dropout = params.pop("dropout", 0.5)
return cls(similarity_function, response_projection_feedforward,
response_inference_encoder, response_input_feedforward,
source_input_feedforward, source_projection_feedforward,
source_inference_encoder, dropout)
def from_params(cls, vocab, params):
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"))
dropout = params.pop('dropout', 0.2)
initializer = InitializerApplicator.from_params(params.pop('initializer', []))
regularizer = RegularizerApplicator.from_params(params.pop('regularizer', []))
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,
dropout=dropout, mask_lstms=mask_lstms,
initializer=initializer, regularizer=regularizer)
def from_params(cls, vocab, params):
""" Initialize from a Params object """
similarity_function = SimilarityFunction.from_params(
params.pop("similarity_function"))
modeling_layer = Seq2SeqEncoder.from_params(
params.pop("modeling_layer"))
dropout = params.pop("dropout", 0.2)
initializer = InitializerApplicator.from_params(
params.pop("initializer", []))
mask_lstms = params.pop("mask_lstms", True)
params.assert_empty(cls.__name__)
return cls(
vocab=vocab,
modeling_layer=modeling_layer,
dropout=dropout,
mask_lstms=mask_lstms,
initializer=initializer,
)
def from_params(cls, vocab: Vocabulary, params: Params) -> 'DecAccSRL':
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
srl_model_archive = params.pop('srl_model_archive', None)
if srl_model_archive is not None:
logger.info("Loaded pretrained SRL model from {}".format(srl_model_archive))
archive = load_archive(srl_model_archive)
srl_model = archive.model
else:
srl_model = 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", []))
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,
initializer=initializer,
srl_model=srl_model,
premise_encoder=premise_encoder,
hypothesis_encoder=hypothesis_encoder)
def from_params(cls, vocab: Vocabulary,
params: Params) -> 'SWAGExampleModel':
text_field_embedder = TextFieldEmbedder.from_params(
vocab, params.pop('text_field_embedder'))
startphrase_encoder = Seq2VecEncoder.from_params(
params.pop('startphrase_encoder'))
ending_encoder = Seq2VecEncoder.from_params(
params.pop('ending_encoder'))
similarity = SimilarityFunction.from_params(params.pop('similarity'))
initializer = InitializerApplicator.from_params(
params.pop('initializer', []))
regularizer = RegularizerApplicator.from_params(
params.pop('regularizer', []))
return cls(vocab=vocab,
text_field_embedder=text_field_embedder,
startphrase_encoder=startphrase_encoder,
ending_encoder=ending_encoder,
similarity=similarity,
initializer=initializer,
regularizer=regularizer)
def from_params(cls, vocab: Vocabulary, params: Params) -> 'ModelMSMARCO':
embedder_params = params.pop("text_field_embedder")
text_field_embedder = TextFieldEmbedder.from_params(
vocab, embedder_params)
#num_highway_layers = params.pop_int("num_highway_layers")
phrase_layer = Seq2SeqEncoder.from_params(params.pop("phrase_layer"))
similarity_function = SimilarityFunction.from_params(
params.pop("similarity_function"))
residual_encoder = Seq2SeqEncoder.from_params(
params.pop("residual_encoder"))
span_start_encoder = Seq2SeqEncoder.from_params(
params.pop("span_start_encoder"))
span_end_encoder = Seq2SeqEncoder.from_params(
params.pop("span_end_encoder"))
#feed_forward = FeedForward.from_params(params.pop("feed_forward"))
dropout = params.pop_float('dropout', 0.2)
initializer = InitializerApplicator.from_params(
params.pop('initializer', []))
regularizer = RegularizerApplicator.from_params(
params.pop('regularizer', []))
mask_lstms = params.pop_bool('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,
residual_encoder=residual_encoder,
span_start_encoder=span_start_encoder,
span_end_encoder=span_end_encoder,
dropout=dropout,
mask_lstms=mask_lstms,
initializer=initializer,
regularizer=regularizer)
def __init__(self,
vocab: Vocabulary,
text_field_embedder: TextFieldEmbedder,
question_encoder: Optional[Seq2SeqEncoder] = None,
choice_encoder: Optional[Seq2SeqEncoder] = None,
use_knowledge: Optional[bool] = True,
facts_encoder: Optional[Seq2SeqEncoder] = None,
know_aggregate_feedforward: FeedForward = None,
initializer: InitializerApplicator = InitializerApplicator(),
aggregate_question: Optional[str] = "max",
aggregate_choice: Optional[str] = "max",
aggregate_facts: Optional[str] = "max",
embeddings_dropout_value: Optional[float] = 0.0,
share_encoders: Optional[bool] = False,
choices_init_from_question_states: Optional[bool] = False,
facts_init_from_question_states: Optional[bool] = False,
use_ctx2facts_retrieval_map_as_mask: Optional[bool] = False,
params=Params) -> None:
super(QAMultiChoiceKnowReader_v1, self).__init__(vocab)
# TO DO: AllenNLP does not support statefull RNNS yet..
init_is_supported = False
if not init_is_supported and (choices_init_from_question_states
or facts_init_from_question_states):
raise ValueError(
"choices_init_from_question_states=True or facts_init_from_question_states=True are not supported yet!"
)
else:
self._choices_init_from_question_states = choices_init_from_question_states
self._facts_init_from_question_states = facts_init_from_question_states
self._return_question_to_choices_att = False
self._return_question_to_facts_att = False
self._return_choice_to_facts_att = False
self._params = params
self._text_field_embedder = text_field_embedder
if embeddings_dropout_value > 0.0:
self._embeddings_dropout = torch.nn.Dropout(
p=embeddings_dropout_value)
else:
self._embeddings_dropout = lambda x: x
self._question_encoder = question_encoder
# choices encoding
self._choice_encoder = choice_encoder
# facts encoding
self._use_knowledge = use_knowledge
self._facts_encoder = facts_encoder
self._use_ctx2facts_retrieval_map_as_mask = use_ctx2facts_retrieval_map_as_mask
self._know_aggregate_feedforward = know_aggregate_feedforward
self._question_aggregate = aggregate_question
self._choice_aggregate = aggregate_choice
self._facts_aggregate = aggregate_facts
self._num_labels = vocab.get_vocab_size(namespace="labels")
question_output_dim = self._text_field_embedder.get_output_dim()
if self._question_encoder is not None:
question_output_dim = self._question_encoder.get_output_dim()
choice_output_dim = self._text_field_embedder.get_output_dim()
if self._choice_encoder is not None:
choice_output_dim = self._choice_encoder.get_output_dim()
facts_output_dim = self._text_field_embedder.get_output_dim()
if self._facts_encoder is not None:
facts_output_dim = self._facts_encoder.get_output_dim()
if question_output_dim != choice_output_dim:
raise ConfigurationError(
"Output dimension of the question_encoder (dim: {}), "
"plus choice_encoder (dim: {})"
"must match! ".format(question_output_dim, choice_output_dim))
# question to choice attention
att_question_to_choice_params = params.get("att_question_to_choice")
if "tensor_1_dim" in att_question_to_choice_params:
att_question_to_choice_params = update_params(
att_question_to_choice_params, {
"tensor_1_dim": question_output_dim,
"tensor_2_dim": choice_output_dim
})
self._matrix_attention_question_to_choice = LegacyMatrixAttention(
SimilarityFunction.from_params(att_question_to_choice_params))
# text to knowlegde attention
share_att_question_to_choice_and_att_text_to_facts = params.get(
"share_att_question_to_choice_and_att_text_to_facts", False)
if share_att_question_to_choice_and_att_text_to_facts:
self._matrix_attention_text_to_facts = self._matrix_attention_question_to_choice
else:
att_text_to_facts_params = params.get("att_text_to_facts")
if "tensor_1_dim" in att_text_to_facts_params:
att_text_to_facts_params = update_params(
att_text_to_facts_params, {
"tensor_1_dim": question_output_dim,
"tensor_2_dim": facts_output_dim
})
self._matrix_attention_text_to_facts = LegacyMatrixAttention(
SimilarityFunction.from_params(att_text_to_facts_params))
text_plus_knowledge_repr_params = params.get(
"text_plus_knowledge_repr")
self._text_plus_knowledge_repr_funciton = SimilarityFunction.from_params(
text_plus_knowledge_repr_params)
self._know_interactions = params.get("know_interactions").get(
"interactions", [["ctx", "ctx"], ["ctx+kn", "ctx"],
["ctx", "ctx+kn"], ["ctx+kn", "ctx+kn"]])
self._accuracy = CategoricalAccuracy()
self._loss = torch.nn.CrossEntropyLoss()
initializer(self)
def from_params(cls, vocab: Vocabulary,
params: Params) -> 'DecomposableAttention':
"""
With an empty ``params`` argument, this will instantiate a decomposable attention model
with the same configuration as published in the original paper, as long as you've set
``allennlp.common.constants.GLOVE_PATH`` to the location of your gzipped 300-dimensional
glove vectors.
If you want to change parameters, the keys in the ``params`` object must match the
constructor arguments above.
"""
default_embedder_params = {
'tokens': {
'type': 'embedding',
'projection_dim': 200,
'pretrained_file': constants.GLOVE_PATH,
'trainable': False
}
}
embedder_params = params.pop("text_field_embedder",
default_embedder_params)
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
default_attend_params = {
'input_dim': 200,
'num_layers': 2,
'hidden_dims': 200,
'activations': 'relu'
}
attend_params = params.pop('attend_feedforward', default_attend_params)
attend_feedforward = FeedForward.from_params(attend_params)
default_similarity_function_params = {'type': 'dot_product'}
similarity_function_params = params.pop(
"similarity_function", default_similarity_function_params)
similarity_function = SimilarityFunction.from_params(
similarity_function_params)
default_compare_params = {
'input_dim': 400,
'num_layers': 2,
'hidden_dims': 200,
'activations': 'relu'
}
compare_params = params.pop('compare_feedforward',
default_compare_params)
compare_feedforward = FeedForward.from_params(compare_params)
default_aggregate_params = {
'input_dim': 400,
'num_layers': 2,
'hidden_dims': [200, 3],
'activations': ['relu', 'linear']
}
aggregate_params = params.pop('aggregate_feedforward',
default_aggregate_params)
aggregate_feedforward = FeedForward.from_params(aggregate_params)
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)
def from_params(cls, vocab: Vocabulary,
params: Params) -> 'QAMultiChoiceMaxAttention':
embedder_params = params.pop("text_field_embedder")
text_field_embedder = TextFieldEmbedder.from_params(
vocab, embedder_params)
embeddings_dropout_value = params.pop("embeddings_dropout", 0.0)
encoder_dropout_value = params.pop("encoder_dropout", 0.0)
# question encoder
question_encoder_params = params.pop("question_encoder", None)
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
else:
# choice encoder
choice_encoder_params = params.pop("choice_encoder", None)
if choice_encoder_params is not None:
choice_encoder = Seq2SeqEncoder.from_params(
choice_encoder_params)
else:
choice_encoder = None
init_params = params.pop('initializer', None)
initializer = (InitializerApplicator.from_params(init_params)
if init_params is not None else InitializerApplicator())
similarity_function = SimilarityFunction.from_params(
params.pop("similarity_function"))
projection_feedforward = FeedForward.from_params(
params.pop('projection_feedforward'))
inference_encoder = Seq2SeqEncoder.from_params(
params.pop("inference_encoder"))
output_feedforward = FeedForward.from_params(
params.pop('output_feedforward'))
output_logit = FeedForward.from_params(params.pop('output_logit'))
initializer = InitializerApplicator.from_params(
params.pop('initializer', []))
regularizer = RegularizerApplicator.from_params(
params.pop('regularizer', []))
return cls(vocab=vocab,
text_field_embedder=text_field_embedder,
question_encoder=question_encoder,
choice_encoder=choice_encoder,
embeddings_dropout_value=embeddings_dropout_value,
encoder_dropout_value=encoder_dropout_value,
similarity_function=similarity_function,
projection_feedforward=projection_feedforward,
inference_encoder=inference_encoder,
output_feedforward=output_feedforward,
output_logit=output_logit,
initializer=initializer,
regularizer=regularizer)
def from_params(cls,
vocab: Vocabulary,
params: Params,
vocab_weight=None) -> 'ESIM':
embedder_params = params.pop("text_field_embedder")
if vocab_weight is None:
text_field_embedder = TextFieldEmbedder.from_params(
vocab, embedder_params)
else:
token_embedders = {}
keys = list(embedder_params.keys())
for key in keys:
e_params = embedder_params.pop(key)
if e_params['type'] == 'embedding':
token_embedders[key] = Embedding(
vocab_weight.size(0),
vocab_weight.size(1),
e_params.pop('projection_dim'),
vocab_weight,
trainable=False)
else:
token_embedders[key] = TokenEmbedder.from_params(
vocab, e_params)
text_field_embedder = BasicTextFieldEmbedder(token_embedders)
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'))
premise_composer_params = params.pop("premise_composer", None)
if premise_composer_params is not None:
premise_composer = Seq2SeqEncoder.from_params(
premise_composer_params)
else:
premise_composer = None
hypothesis_composer_params = params.pop("hypothesis_composer", None)
if hypothesis_composer_params is not None:
hypothesis_composer = Seq2SeqEncoder.from_params(
hypothesis_composer_params)
else:
hypothesis_composer = None
combine_feedforward_params = params.pop("combine_feedforward", None)
combine_feedforward = None
if combine_feedforward_params is not None:
combine_feedforward = FeedForward.from_params(
combine_feedforward_params)
aggregate_feedforward_params = params.pop("aggregate_feedforward",
None)
aggregate_feedforward = None
if aggregate_feedforward_params is not None:
aggregate_feedforward = FeedForward.from_params(
aggregate_feedforward_params)
num_wrapping_dims = params.pop("num_wrapping_dims", 0)
initializer = InitializerApplicator.from_params(
params.pop('initializer', []))
params.assert_empty(cls.__name__)
return cls(text_field_embedder=text_field_embedder,
attend_feedforward=attend_feedforward,
similarity_function=similarity_function,
compare_feedforward=compare_feedforward,
premise_encoder=premise_encoder,
hypothesis_encoder=hypothesis_encoder,
premise_composer=premise_composer,
hypothesis_composer=hypothesis_composer,
combine_feedforward=combine_feedforward,
aggregate_feedforward=aggregate_feedforward,
initializer=initializer,
num_wrapping_dims=num_wrapping_dims,
vocab=vocab)
def __init__(self,
vocab: Vocabulary,
text_field_embedder: TextFieldEmbedder,
question_encoder: Optional[Seq2SeqEncoder] = None,
choice_encoder: Optional[Seq2SeqEncoder] = None,
initializer: InitializerApplicator = InitializerApplicator(),
aggregate_question: Optional[str] = "max",
aggregate_choice: Optional[str] = "max",
embeddings_dropout_value: Optional[float] = 0.0,
share_encoders: Optional[bool] = False,
choices_init_from_question_states: Optional[bool] = False,
use_choice_sum_instead_of_question: Optional[bool] = False,
params=Params) -> None:
super(QAMultiChoice_OneVsRest_Choices_v1, self).__init__(vocab)
# TO DO: AllenNLP does not support statefull RNNS yet..
init_is_supported = False
if not init_is_supported and (choices_init_from_question_states):
raise ValueError(
"choices_init_from_question_states=True or facts_init_from_question_states=True are not supported yet!"
)
else:
self._choices_init_from_question_states = choices_init_from_question_states
self._use_cuda = (torch.cuda.is_available()
and torch.cuda.current_device() >= 0)
self._return_question_to_choices_att = False
self._use_choice_sum_instead_of_question = use_choice_sum_instead_of_question
self._params = params
self._text_field_embedder = text_field_embedder
if embeddings_dropout_value > 0.0:
self._embeddings_dropout = torch.nn.Dropout(
p=embeddings_dropout_value)
else:
self._embeddings_dropout = lambda x: x
self._question_encoder = question_encoder
# choices encoding
self._choice_encoder = choice_encoder
self._question_aggregate = aggregate_question
self._choice_aggregate = aggregate_choice
self._num_labels = vocab.get_vocab_size(namespace="labels")
question_output_dim = self._text_field_embedder.get_output_dim()
if self._question_encoder is not None:
question_output_dim = self._question_encoder.get_output_dim()
choice_output_dim = self._text_field_embedder.get_output_dim()
if self._choice_encoder is not None:
choice_output_dim = self._choice_encoder.get_output_dim()
if question_output_dim != choice_output_dim:
raise ConfigurationError(
"Output dimension of the question_encoder (dim: {}), "
"plus choice_encoder (dim: {})"
"must match! ".format(question_output_dim, choice_output_dim))
# question to choice attention
att_question_to_choice_params = params.get("att_question_to_choice")
if "tensor_1_dim" in att_question_to_choice_params:
att_question_to_choice_params = update_params(
att_question_to_choice_params, {
"tensor_1_dim": question_output_dim,
"tensor_2_dim": choice_output_dim
})
self._matrix_attention_question_to_choice = LegacyMatrixAttention(
SimilarityFunction.from_params(att_question_to_choice_params))
self._accuracy = CategoricalAccuracy()
self._loss = torch.nn.CrossEntropyLoss()
initializer(self)
