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)