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) -> 'SpanConstituencyParser': embedder_params = params.pop("text_field_embedder") text_field_embedder = TextFieldEmbedder.from_params(vocab, embedder_params) span_extractor = SpanExtractor.from_params(params.pop("span_extractor")) encoder = Seq2SeqEncoder.from_params(params.pop("encoder")) feed_forward_params = params.pop("feedforward", None) if feed_forward_params is not None: feedforward_layer = FeedForward.from_params(feed_forward_params) else: feedforward_layer = None pos_tag_embedding_params = params.pop("pos_tag_embedding", None) if pos_tag_embedding_params is not None: pos_tag_embedding = Embedding.from_params(vocab, pos_tag_embedding_params) else: pos_tag_embedding = None initializer = InitializerApplicator.from_params(params.pop('initializer', [])) regularizer = RegularizerApplicator.from_params(params.pop('regularizer', [])) evalb_directory_path = params.pop("evalb_directory_path", None) params.assert_empty(cls.__name__) return cls(vocab=vocab, text_field_embedder=text_field_embedder, span_extractor=span_extractor, encoder=encoder, feedforward_layer=feedforward_layer, pos_tag_embedding=pos_tag_embedding, initializer=initializer, regularizer=regularizer, evalb_directory_path=evalb_directory_path)
def test_from_params_requires_batch_first(self): params = Params({ "type": "lstm", "batch_first": False, }) with pytest.raises(ConfigurationError): # pylint: disable=unused-variable encoder = Seq2SeqEncoder.from_params(params)
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) -> 'SimpleTagger': embedder_params = params.pop("text_field_embedder") text_field_embedder = TextFieldEmbedder.from_params( vocab, embedder_params) stacked_encoder = Seq2SeqEncoder.from_params( params.pop("stacked_encoder")) return cls(vocab=vocab, text_field_embedder=text_field_embedder, stacked_encoder=stacked_encoder)
def from_params( # type: ignore cls, vocab: Vocabulary, params: Params ) -> "BiattentiveClassificationNetwork": embedder_params = params.pop("text_field_embedder") text_field_embedder = TextFieldEmbedder.from_params(vocab=vocab, params=embedder_params) embedding_dropout = params.pop("embedding_dropout") pre_encode_feedforward = FeedForward.from_params(params.pop("pre_encode_feedforward")) encoder = Seq2SeqEncoder.from_params(params.pop("encoder")) integrator = Seq2SeqEncoder.from_params(params.pop("integrator")) integrator_dropout = params.pop("integrator_dropout") output_layer_params = params.pop("output_layer") if "activations" in output_layer_params: output_layer = FeedForward.from_params(output_layer_params) else: output_layer = Maxout.from_params(output_layer_params) elmo = params.pop("elmo", None) if elmo is not None: elmo = Elmo.from_params(elmo) use_input_elmo = params.pop_bool("use_input_elmo", False) use_integrator_output_elmo = params.pop_bool("use_integrator_output_elmo", False) 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, embedding_dropout=embedding_dropout, pre_encode_feedforward=pre_encode_feedforward, encoder=encoder, integrator=integrator, integrator_dropout=integrator_dropout, output_layer=output_layer, elmo=elmo, use_input_elmo=use_input_elmo, use_integrator_output_elmo=use_integrator_output_elmo, initializer=initializer, regularizer=regularizer, )
def from_params(cls, vocab: Vocabulary, params: Params) -> 'EvidenceExtraction': embedder_params = params.pop("text_field_embedder") embedder = TextFieldEmbedder.from_params(vocab, embedder_params) question_encoder = Seq2SeqEncoder.from_params(params.pop("question_encoder")) passage_encoder = Seq2SeqEncoder.from_params(params.pop("passage_encoder")) dropout = params.pop_float('dropout', 0.1) r = params.pop_float('r', 0.8) initializer = InitializerApplicator.from_params(params.pop('initializer', [])) regularizer = RegularizerApplicator.from_params(params.pop('regularizer', [])) return cls(vocab=vocab, embedder=embedder, question_encoder=question_encoder, passage_encoder=passage_encoder, r=r, dropout=dropout, initializer=initializer, regularizer=regularizer)
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: 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")) 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" ) init_params = params.pop('initializer', None) reg_params = params.pop('regularizer', None) initializer = (InitializerApplicator.from_params(init_params) if init_params is not None else InitializerApplicator()) regularizer = RegularizerApplicator.from_params( reg_params) if reg_params is not None else None mask_lstms = params.pop('mask_lstms', True) params.assert_empty(cls.__name__) return cls(vocab=vocab, text_field_embedder=text_field_embedder, num_highway_layers=num_highway_layers, phrase_layer=phrase_layer, attention_similarity_function=similarity_function, modeling_layer=modeling_layer, span_end_encoder=span_end_encoder, dropout=dropout, mask_lstms=mask_lstms, initializer=initializer, regularizer=regularizer)
def from_params(cls, vocab: Vocabulary, params: Params) -> 'HierAttnNetworkClassifier': """Constructs class from ``Params`` and ``Vocabulary`` """ embedder_params = params.pop("text_field_embedder") text_field_embedder = TextFieldEmbedder.from_params( vocab, embedder_params) encoder_word = Seq2SeqEncoder.from_params(params.pop("encoder_word")) encoder_sent = Seq2SeqEncoder.from_params(params.pop("encoder_sent")) attention_word_params = params.pop("attention_word") attention_type = attention_word_params.pop("type") attn_word = getattr(attention_module, attention_type).from_params(attention_word_params) attention_sent_params = params.pop("attention_sent") attention_type = attention_sent_params.pop("type") attn_sent = getattr(attention_module, attention_type).from_params(attention_sent_params) label_namespace = params.pop("label_namespace", "labels") dropout = params.pop("dropout", None) threshold = params.pop("threshold", 0.5) initializer = InitializerApplicator.from_params( params.pop('initializer', [])) regularizer = RegularizerApplicator.from_params( params.pop('regularizer', [])) label_indexer = params.pop("label_indexer", "LabelIndicesBiMap") params.assert_empty(cls.__name__) return cls(vocab=vocab, text_field_embedder=text_field_embedder, encoder_word=encoder_word, attn_word=attn_word, attn_sent=attn_sent, encoder_sent=encoder_sent, thresh=threshold, label_namespace=label_namespace, dropout=dropout, initializer=initializer, regularizer=regularizer, label_indexer=label_indexer)
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 from_params(cls, vocab, params: Params) -> 'WikiTablesErmSemanticParser': question_embedder = TextFieldEmbedder.from_params( vocab, params.pop("question_embedder")) action_embedding_dim = params.pop_int("action_embedding_dim") encoder = Seq2SeqEncoder.from_params(params.pop("encoder")) entity_encoder = Seq2VecEncoder.from_params( params.pop('entity_encoder')) mixture_feedforward_type = params.pop('mixture_feedforward', None) if mixture_feedforward_type is not None: mixture_feedforward = FeedForward.from_params( mixture_feedforward_type) else: mixture_feedforward = None # If no attention function is specified, we should not use attention, not attention with # default similarity function. attention_function_type = params.pop("attention_function", None) if attention_function_type is not None: attention_function = SimilarityFunction.from_params( attention_function_type) else: attention_function = None decoder_beam_size = params.pop_int("decoder_beam_size") max_decoding_steps = params.pop_int("max_decoding_steps") normalize_beam_score_by_length = params.pop( "normalize_beam_score_by_length", False) use_neighbor_similarity_for_linking = params.pop_bool( "use_neighbor_similarity_for_linking", False) dropout = params.pop_float('dropout', 0.0) num_linking_features = params.pop_int('num_linking_features', 10) tables_directory = params.pop('tables_directory', '/wikitables/') rule_namespace = params.pop('rule_namespace', 'rule_labels') checklist_cost_weight = params.pop_float("checklist_cost_weight", 0.6) mml_model_file = params.pop('mml_model_file', None) params.assert_empty(cls.__name__) return cls( vocab, question_embedder=question_embedder, action_embedding_dim=action_embedding_dim, encoder=encoder, entity_encoder=entity_encoder, mixture_feedforward=mixture_feedforward, attention_function=attention_function, decoder_beam_size=decoder_beam_size, max_decoding_steps=max_decoding_steps, normalize_beam_score_by_length=normalize_beam_score_by_length, checklist_cost_weight=checklist_cost_weight, use_neighbor_similarity_for_linking= use_neighbor_similarity_for_linking, dropout=dropout, num_linking_features=num_linking_features, tables_directory=tables_directory, rule_namespace=rule_namespace, initial_mml_model_file=mml_model_file)
def from_params(cls, vocab: Vocabulary, params: Params) -> "CoreferenceResolver": embedder_params = params.pop("text_field_embedder") text_field_embedder = TextFieldEmbedder.from_params( vocab, embedder_params) context_layer = Seq2SeqEncoder.from_params(params.pop("context_layer")) context_layer_back = params.pop("context_layer_back", None) if context_layer_back is not None: context_layer_back = Seq2SeqEncoder.from_params(context_layer_back) mention_feedforward = FeedForward.from_params( params.pop("mention_feedforward")) antecedent_feedforward = FeedForward.from_params( params.pop("antecedent_feedforward")) feature_size = params.pop_int("feature_size") max_span_width = params.pop_int("max_span_width") spans_per_word = params.pop_float("spans_per_word") max_antecedents = params.pop_int("max_antecedents") lexical_dropout = params.pop_float("lexical_dropout", 0.2) init_params = params.pop("initializer", None) reg_params = params.pop("regularizer", None) initializer = (InitializerApplicator.from_params(init_params) if init_params is not None else InitializerApplicator()) regularizer = RegularizerApplicator.from_params( reg_params) if reg_params is not None else None params.assert_empty(cls.__name__) return cls(vocab=vocab, text_field_embedder=text_field_embedder, context_layer=context_layer, context_layer_back=context_layer_back, mention_feedforward=mention_feedforward, antecedent_feedforward=antecedent_feedforward, feature_size=feature_size, max_span_width=max_span_width, spans_per_word=spans_per_word, max_antecedents=max_antecedents, lexical_dropout=lexical_dropout, initializer=initializer, regularizer=regularizer)
def from_params(cls, vocab: Vocabulary, params: Params) -> 'Tagger': token_representation_dim = params.pop_int("token_representation_dim") encoder = params.pop("encoder", None) if encoder is not None: encoder = Seq2SeqEncoder.from_params(encoder) decoder = params.pop("decoder", None) if decoder is not None and not isinstance(decoder, str): decoder = FeedForward.from_params(decoder) use_crf = params.pop_bool("use_crf", False) constrain_crf_decoding = params.pop_bool("constrain_crf_decoding", False) include_start_end_transitions = params.pop_bool("include_start_end_transitions", True) contextualizer = params.pop('contextualizer', None) if contextualizer: contextualizer = Contextualizer.from_params(contextualizer) calculate_per_label_f1 = params.pop_bool("calculate_per_label_f1", False) calculate_span_f1 = params.pop_bool("calculate_span_f1", False) calculate_perplexity = params.pop_bool("calculate_perplexity", False) loss_average = params.pop("loss_average", "batch") label_encoding = params.pop_choice("label_encoding", [None, "BIO", "BIOUL", "IOB1"], default_to_first_choice=True) pretrained_file = params.pop("pretrained_file", None) transfer_contextualizer_from_pretrained_file = params.pop_bool( "transfer_contextualizer_from_pretrained_file", False) transfer_encoder_from_pretrained_file = params.pop_bool( "transfer_encoder_from_pretrained_file", False) freeze_encoder = params.pop_bool("freeze_encoder", False) initializer = InitializerApplicator.from_params(params.pop('initializer', [])) regularizer = RegularizerApplicator.from_params(params.pop('regularizer', [])) params.assert_empty(cls.__name__) return cls(vocab=vocab, token_representation_dim=token_representation_dim, encoder=encoder, decoder=decoder, use_crf=use_crf, constrain_crf_decoding=constrain_crf_decoding, include_start_end_transitions=include_start_end_transitions, label_encoding=label_encoding, contextualizer=contextualizer, calculate_per_label_f1=calculate_per_label_f1, calculate_span_f1=calculate_span_f1, calculate_perplexity=calculate_perplexity, loss_average=loss_average, pretrained_file=pretrained_file, transfer_contextualizer_from_pretrained_file=transfer_contextualizer_from_pretrained_file, transfer_encoder_from_pretrained_file=transfer_encoder_from_pretrained_file, freeze_encoder=freeze_encoder, initializer=initializer, regularizer=regularizer)
def from_params(cls, vocab: Vocabulary, params: Params) -> 'AnswerSynthesis': embedder_params = params.pop("text_field_embedder") embedder = TextFieldEmbedder.from_params(vocab, embedder_params) question_encoder = Seq2SeqEncoder.from_params(params.pop("question_encoder")) passage_encoder = Seq2SeqEncoder.from_params(params.pop("passage_encoder")) feed_forward = FeedForward.from_params(params.pop("feed_forward")) dropout = params.pop_float('dropout', 0.1) num_decoding_steps = params.pop_int("num_decoding_steps", 40) initializer = InitializerApplicator.from_params(params.pop('initializer', [])) regularizer = RegularizerApplicator.from_params(params.pop('regularizer', [])) return cls(vocab=vocab, embedder=embedder, question_encoder=question_encoder, passage_encoder=passage_encoder, feed_forward=feed_forward, dropout=dropout, num_decoding_steps=num_decoding_steps, 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) -> 'SemanticRoleLabeler': embedder_params = params.pop("text_field_embedder") text_field_embedder = TextFieldEmbedder.from_params(vocab, embedder_params) stacked_encoder = Seq2SeqEncoder.from_params(params.pop("stacked_encoder")) binary_feature_dim = params.pop("binary_feature_dim") initializer = InitializerApplicator.from_params(params.pop("initializer", [])) return cls(vocab=vocab, text_field_embedder=text_field_embedder, stacked_encoder=stacked_encoder, binary_feature_dim=binary_feature_dim, initializer=initializer)
def from_params( cls, vocab: Vocabulary, params: Params) -> 'SemEvalClassifierAttention': # type: ignore # pylint: disable=arguments-differ embedder_params = params.pop("text_field_embedder") text_field_embedder = TextFieldEmbedder.from_params( vocab=vocab, params=embedder_params) embedding_dropout = params.pop("embedding_dropout") encoder = Seq2SeqEncoder.from_params(params.pop("encoder")) integrator = Seq2SeqEncoder.from_params(params.pop("integrator")) integrator_dropout = params.pop("integrator_dropout") output_layer_params = params.pop("output_layer") if "activations" in output_layer_params: output_layer = FeedForward.from_params(output_layer_params) else: output_layer = Maxout.from_params(output_layer_params) elmo = params.pop("elmo", None) if elmo is not None: elmo = Elmo.from_params(elmo) use_input_elmo = params.pop_bool("use_input_elmo", False) use_integrator_output_elmo = params.pop_bool( "use_integrator_output_elmo", False) 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, embedding_dropout=embedding_dropout, encoder=encoder, integrator=integrator, integrator_dropout=integrator_dropout, output_layer=output_layer, initializer=initializer, regularizer=regularizer)
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) -> 'EtdBCN': embedder_params = params.pop("text_field_embedder") text_field_embedder = TextFieldEmbedder.from_params( vocab=vocab, params=embedder_params) title_text_encoder = Seq2SeqEncoder.from_params( params.pop("title_text_encoder")) abstract_text_encoder = Seq2SeqEncoder.from_params( params.pop("abstract_text_encoder")) title_text_projection = FeedForward.from_params( params.pop("title_text_projection")) abstract_text_projection = FeedForward.from_params( params.pop("abstract_text_projection")) bi_attention_encoder = BiAttentionEncoder.from_params( params.pop("attention_encoder")) classifier_feedforward = params.pop("classifier_feedforward") if classifier_feedforward.pop('type') == 'feedforward': classifier_feedforward = FeedForward.from_params( classifier_feedforward) else: classifier_feedforward = Maxout.from_params(classifier_feedforward) use_positional_encoding = params.pop("use_positional_encoding", False) bce_pos_weight = params.pop_int("bce_pos_weight", 10) initializer = InitializerApplicator.from_params( params.pop('initializer', [])) regularizer = RegularizerApplicator.from_params( params.pop('regularizer', [])) return cls(vocab=vocab, text_field_embedder=text_field_embedder, title_text_encoder=title_text_encoder, abstract_text_encoder=abstract_text_encoder, title_text_projection=title_text_projection, abstract_text_projection=abstract_text_projection, bi_attention_encoder=bi_attention_encoder, classifier_feedforward=classifier_feedforward, bce_pos_weight=bce_pos_weight, use_positional_encoding=use_positional_encoding, initializer=initializer, regularizer=regularizer)
def from_params(cls, vocab: Vocabulary, params: Params) -> 'BiattentiveClassificationNetwork': # type: ignore # pylint: disable=arguments-differ embedder_params = params.pop("text_field_embedder") text_field_embedder = TextFieldEmbedder.from_params(vocab=vocab, params=embedder_params) embedding_dropout = params.pop("embedding_dropout") pre_encode_feedforward = FeedForward.from_params(params.pop("pre_encode_feedforward")) encoder = Seq2SeqEncoder.from_params(params.pop("encoder")) integrator = Seq2SeqEncoder.from_params(params.pop("integrator")) integrator_dropout = params.pop("integrator_dropout") output_layer_params = params.pop("output_layer") if "activations" in output_layer_params: output_layer = FeedForward.from_params(output_layer_params) else: output_layer = Maxout.from_params(output_layer_params) elmo = params.pop("elmo", None) if elmo is not None: elmo = Elmo.from_params(elmo) use_input_elmo = params.pop_bool("use_input_elmo", False) use_integrator_output_elmo = params.pop_bool("use_integrator_output_elmo", False) 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, embedding_dropout=embedding_dropout, pre_encode_feedforward=pre_encode_feedforward, encoder=encoder, integrator=integrator, integrator_dropout=integrator_dropout, output_layer=output_layer, elmo=elmo, use_input_elmo=use_input_elmo, use_integrator_output_elmo=use_integrator_output_elmo, initializer=initializer, regularizer=regularizer)
def from_params(cls, vocab: Vocabulary, params: Params) -> 'SimpleTagger': embedder_params = params.pop("text_field_embedder") text_field_embedder = TextFieldEmbedder.from_params(vocab, embedder_params) encoder = Seq2SeqEncoder.from_params(params.pop("encoder")) initializer = InitializerApplicator.from_params(params.pop('initializer', [])) regularizer = RegularizerApplicator.from_params(params.pop('regularizer', [])) params.assert_empty(cls.__name__) return cls(vocab=vocab, text_field_embedder=text_field_embedder, encoder=encoder, initializer=initializer, regularizer=regularizer)
def from_params(cls, vocab: Vocabulary, params: Params) -> 'SimpleTagger': embedder_params = params.pop("text_field_embedder") text_field_embedder = TextFieldEmbedder.from_params(vocab, embedder_params) stacked_encoder = Seq2SeqEncoder.from_params(params.pop("stacked_encoder")) initializer = InitializerApplicator.from_params(params.pop('initializer', [])) regularizer = RegularizerApplicator.from_params(params.pop('regularizer', [])) return cls(vocab=vocab, text_field_embedder=text_field_embedder, stacked_encoder=stacked_encoder, initializer=initializer, regularizer=regularizer)
def from_params(cls, vocab , params ) : # type: ignore # pylint: disable=arguments-differ embedder_params = params.pop(u"text_field_embedder") text_field_embedder = TextFieldEmbedder.from_params(vocab=vocab, params=embedder_params) embedding_dropout = params.pop(u"embedding_dropout") pre_encode_feedforward = FeedForward.from_params(params.pop(u"pre_encode_feedforward")) encoder = Seq2SeqEncoder.from_params(params.pop(u"encoder")) integrator = Seq2SeqEncoder.from_params(params.pop(u"integrator")) integrator_dropout = params.pop(u"integrator_dropout") output_layer_params = params.pop(u"output_layer") if u"activations" in output_layer_params: output_layer = FeedForward.from_params(output_layer_params) else: output_layer = Maxout.from_params(output_layer_params) elmo = params.pop(u"elmo", None) if elmo is not None: elmo = Elmo.from_params(elmo) use_input_elmo = params.pop_bool(u"use_input_elmo", False) use_integrator_output_elmo = params.pop_bool(u"use_integrator_output_elmo", False) initializer = InitializerApplicator.from_params(params.pop(u'initializer', [])) regularizer = RegularizerApplicator.from_params(params.pop(u'regularizer', [])) params.assert_empty(cls.__name__) return cls(vocab=vocab, text_field_embedder=text_field_embedder, embedding_dropout=embedding_dropout, pre_encode_feedforward=pre_encode_feedforward, encoder=encoder, integrator=integrator, integrator_dropout=integrator_dropout, output_layer=output_layer, elmo=elmo, use_input_elmo=use_input_elmo, use_integrator_output_elmo=use_integrator_output_elmo, initializer=initializer, regularizer=regularizer)
def s2s_test(nsteps): params = Params(params={"type": "gru", "input_size": 4, "hidden_size": 20, "num_layers": 3, "bidirectional": True}) gru_net = Seq2SeqEncoder.from_params(params=params) gru_net.cuda(device=0) with Profile("s2s"): for i in range(nsteps): s2s_func(max_length=450, seq_length=350, gru_net=gru_net) print(Profile.to_string())
def from_params(cls, vocab: Vocabulary, params: Params) -> 'SemanticRoleLabeler': """ With an empty ``params`` argument, this will instantiate a SRL model with the same configuration as published in the "Deep Semantic Role Labeling - What works and what's next" paper, as long as you've set ``allennlp.common.constants.GLOVE_PATH`` to the location of your gzipped 100-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', 'pretrained_file': GLOVE_PATH, 'trainable': True } } embedder_params = params.pop("text_field_embedder", default_embedder_params) text_field_embedder = TextFieldEmbedder.from_params( vocab, embedder_params) default_lstm_params = { 'type': 'alternating_lstm', 'input_size': 101, # Because of the verb_indicator feature. 'hidden_size': 300, 'num_layers': 8, 'recurrent_dropout_probability': 0.1, 'use_highway': True } encoder_params = params.pop("stacked_encoder", default_lstm_params) stacked_encoder = Seq2SeqEncoder.from_params(encoder_params) default_initializer_params = { 'bias': { 'type': 'normal', 'std': 0.1 }, 'default': 'orthogonal' } initializer_params = params.pop('initializer', default_initializer_params) initializer = InitializerApplicator.from_params(initializer_params) return cls(vocab=vocab, text_field_embedder=text_field_embedder, stacked_encoder=stacked_encoder, initializer=initializer)
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 from_params(cls, vocab, params: Params) -> 'WikiTablesMmlSemanticParser': question_embedder = TextFieldEmbedder.from_params( vocab, params.pop("question_embedder")) action_embedding_dim = params.pop_int("action_embedding_dim") encoder = Seq2SeqEncoder.from_params(params.pop("encoder")) entity_encoder = Seq2VecEncoder.from_params( params.pop('entity_encoder')) max_decoding_steps = params.pop_int("max_decoding_steps") mixture_feedforward_type = params.pop('mixture_feedforward', None) if mixture_feedforward_type is not None: mixture_feedforward = FeedForward.from_params( mixture_feedforward_type) else: mixture_feedforward = None decoder_beam_search = BeamSearch.from_params( params.pop("decoder_beam_search")) # If no attention function is specified, we should not use attention, not attention with # default similarity function. attention_function_type = params.pop("attention_function", None) if attention_function_type is not None: attention_function = SimilarityFunction.from_params( attention_function_type) else: attention_function = None training_beam_size = params.pop_int('training_beam_size', None) use_neighbor_similarity_for_linking = params.pop_bool( 'use_neighbor_similarity_for_linking', False) dropout = params.pop_float('dropout', 0.0) num_linking_features = params.pop_int('num_linking_features', 10) tables_directory = params.pop('tables_directory', '/wikitables/') rule_namespace = params.pop('rule_namespace', 'rule_labels') params.assert_empty(cls.__name__) return cls(vocab, question_embedder=question_embedder, action_embedding_dim=action_embedding_dim, encoder=encoder, entity_encoder=entity_encoder, mixture_feedforward=mixture_feedforward, decoder_beam_search=decoder_beam_search, max_decoding_steps=max_decoding_steps, attention_function=attention_function, training_beam_size=training_beam_size, use_neighbor_similarity_for_linking= use_neighbor_similarity_for_linking, dropout=dropout, num_linking_features=num_linking_features, tables_directory=tables_directory, rule_namespace=rule_namespace)
def from_params(cls, vocab: Vocabulary, params: Params) -> 'MetaphoreClassifier': embedder_params = params.pop("model_sentence_field_embedder") model_sentence_field_embedder = MetaphoreFieldEmbedder.from_params(embedder_params, vocab=vocab) input_encoder_dropout = Dropout(params.pop("input_encoder_dropout")) internal_sentence_encoder = Seq2SeqEncoder.from_params(params.pop("internal_sentence_encoder")) linear_attention_feedforward = FeedForward.from_params(params.pop("linear_attention_feedforward")) input_classifier_dropout = Dropout(params.pop("input_classifier_dropout")) linear_classifier_feedforward = FeedForward.from_params(params.pop("linear_classifier_feedforward")) return cls(vocab=vocab, model_sentence_field_embedder=model_sentence_field_embedder, input_encoder_dropout = input_encoder_dropout, internal_sentence_encoder=internal_sentence_encoder, linear_attention_feedforward = linear_attention_feedforward, input_classifier_dropout = input_classifier_dropout, linear_classifier_feedforward=linear_classifier_feedforward,)
def from_params(cls, vocab, params): """ Initialize from a Params object """ 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) -> 'ProLocalModel': embedder_params = params.pop("text_field_embedder") text_field_embedder = TextFieldEmbedder.from_params(vocab, embedder_params) seq2seq_encoder_params = params.pop("seq2seq_encoder") seq2seq_encoder = Seq2SeqEncoder.from_params(seq2seq_encoder_params) initializer = InitializerApplicator.from_params(params.pop("initializer", [])) params.assert_empty(cls.__name__) return cls(vocab=vocab, text_field_embedder=text_field_embedder, seq2seq_encoder=seq2seq_encoder, initializer=initializer)
def from_params(cls, vocab: Vocabulary, params: Params) -> 'ProGlobal': token_embedder_params = params.pop("text_field_embedder") pos_embedder_params = params.pop("pos_field_embedder") sent_pos_embedder_params = params.pop("sent_pos_field_embedder") text_field_embedder = TextFieldEmbedder.from_params( vocab, token_embedder_params) pos_field_embedder = TextFieldEmbedder.from_params( vocab, pos_embedder_params) sent_pos_field_embedder = TextFieldEmbedder.from_params( vocab, sent_pos_embedder_params) modeling_layer = Seq2SeqEncoder.from_params( params.pop("modeling_layer")) span_end_encoder_before = Seq2SeqEncoder.from_params( params.pop("span_end_encoder_bef")) span_start_encoder_after = Seq2SeqEncoder.from_params( params.pop("span_start_encoder_aft")) span_end_encoder_after = Seq2SeqEncoder.from_params( params.pop("span_end_encoder_aft")) dropout = params.pop('dropout', 0.2) init_params = params.pop('initializer', None) initializer = (InitializerApplicator.from_params(init_params) if init_params is not None else InitializerApplicator()) params.assert_empty(cls.__name__) return cls(vocab=vocab, text_field_embedder=text_field_embedder, pos_field_embedder=pos_field_embedder, sent_pos_field_embedder=sent_pos_field_embedder, modeling_layer=modeling_layer, span_start_encoder_after=span_start_encoder_after, span_end_encoder_before=span_end_encoder_before, span_end_encoder_after=span_end_encoder_after, dropout=dropout, initializer=initializer)
def from_params(cls, vocab: Vocabulary, params: Params) -> 'DialogueContextHierarchicalCoherenceAttentionClassifier': embedder_params = params.pop("text_field_embedder") text_field_embedder = TextFieldEmbedder.from_params(vocab, embedder_params) utterance_encoder = Seq2VecEncoder.from_params(params.pop("utterance_encoder")) context_encoder = Seq2SeqEncoder.from_params(params.pop("context_encoder")) 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")) final_classifier_feedforward = FeedForward.from_params(params.pop("final_classifier_feedforward")) initializer = InitializerApplicator.from_params(params.pop("initializer", [])) regularizer = RegularizerApplicator.from_params(params.pop("regularizer", [])) matrix_attention = MatrixAttention().from_params(params.pop("similarity_function")) return cls(vocab=vocab, text_field_embedder=text_field_embedder, attend_feedforward=attend_feedforward, matrix_attention=matrix_attention, compare_feedforward=compare_feedforward, classifier_feedforward=classifier_feedforward, final_classifier_feedforward=final_classifier_feedforward, utterance_encoder=utterance_encoder, context_encoder=context_encoder, response_encoder=response_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) evaluation_json_file = params.pop('evaluation_json_file', None) mask_lstms = params.pop('mask_lstms', True) params.assert_empty(cls.__name__) return cls(vocab=vocab, text_field_embedder=text_field_embedder, num_highway_layers=num_highway_layers, phrase_layer=phrase_layer, attention_similarity_function=similarity_function, modeling_layer=modeling_layer, span_end_encoder=span_end_encoder, initializer=initializer, dropout=dropout, mask_lstms=mask_lstms, evaluation_json_file=evaluation_json_file)
def make_model2(params, vocab, glove_path): # parameters for original model are specified here: # https://github.com/allenai/allennlp/blob/master/training_config/semantic_role_labeler.jsonnet # do not change - these values are used in original model glove_size = 100 binary_feature_dim = 100 max_grad_norm = 1.0 # encoder encoder_params = AllenParams( {'type': 'alternating_lstm', 'input_size': glove_size + binary_feature_dim, 'hidden_size': params.hidden_size, 'num_layers': params.num_layers, 'use_highway': True, 'recurrent_dropout_probability': 0.1}) encoder = Seq2SeqEncoder.from_params(encoder_params) # embedder embedder_params = AllenParams({ "token_embedders": { "tokens": { "type": "embedding", "embedding_dim": glove_size, # must match glove dimension "pretrained_file": str(glove_path), "trainable": True } } }) text_field_embedder = TextFieldEmbedder.from_params(embedder_params, vocab=vocab) # initializer initializer_params = [ ("tag_projection_layer.*weight", AllenParams({"type": "orthogonal"})) ] initializer = InitializerApplicator.from_params(initializer_params) # model model = Model2(vocab=vocab, text_field_embedder=text_field_embedder, encoder=encoder, initializer=initializer, binary_feature_dim=binary_feature_dim) model.cuda() model.max_grad_norm = max_grad_norm return model
def from_params(cls, vocab: Vocabulary, params: Params) -> 'AttentionClassifier': """Constructs class from ``Params`` and ``Vocabulary`` """ embedder_params = params.pop("text_field_embedder") embedder_type = embedder_params.get("type", None) if embedder_type is None: text_field_embedder = TextFieldEmbedder.from_params( vocab, embedder_params) else: embedder_type = embedder_params.pop("type") text_field_embedder = getattr(text_field_embedder_modules, embedder_type).from_params( vocab, embedder_params) encoder = Seq2SeqEncoder.from_params(params.pop("encoder")) attention_params = params.pop("attention_module") attention_type = attention_params.pop("type") key_dim = attention_params.get("key_emb_size") attention_module = getattr( attention_modules, attention_type).from_params(attention_params) label_namespace = params.pop("label_namespace", "labels") dropout = params.pop("dropout", None) entropy_scalar = params.pop("entropy_scalar", 0.) coverage_scalar = params.pop("coverage_scalar", 0.) threshold = params.pop("threshold", 0.5) initializer = InitializerApplicator.from_params( params.pop('initializer', [])) regularizer = RegularizerApplicator.from_params( params.pop('regularizer', [])) label_indexer = params.pop("label_indexer", "LabelIndicesBiMap") params.assert_empty(cls.__name__) return cls(vocab=vocab, text_field_embedder=text_field_embedder, encoder=encoder, attention_module=attention_module, key_dim=key_dim, entropy_scalar=entropy_scalar, coverage_scalar=coverage_scalar, label_namespace=label_namespace, dropout=dropout, thresh=threshold, initializer=initializer, regularizer=regularizer, label_indexer=label_indexer)
def from_params(cls, vocab: Vocabulary, params: Params) -> 'CrfTagger': embedder_params = params.pop("text_field_embedder") text_field_embedder = TextFieldEmbedder.from_params(vocab, embedder_params) encoder = Seq2SeqEncoder.from_params(params.pop("encoder")) label_namespace = params.pop("label_namespace", "labels") constraint_type = params.pop("constraint_type", None) initializer = InitializerApplicator.from_params(params.pop('initializer', [])) regularizer = RegularizerApplicator.from_params(params.pop('regularizer', [])) params.assert_empty(cls.__name__) return cls(vocab=vocab, text_field_embedder=text_field_embedder, encoder=encoder, label_namespace=label_namespace, constraint_type=constraint_type, initializer=initializer, regularizer=regularizer)
def test_from_params_builders_encoder_correctly(self): # We're just making sure parameters get passed through correctly here, and that the basic # API works. params = Params({ "type": "lstm", "bidirectional": True, "num_layers": 3, "input_size": 5, "hidden_size": 7 }) encoder = Seq2SeqEncoder.from_params(params) # pylint: disable=protected-access assert encoder.__class__.__name__ == 'PytorchSeq2SeqWrapper' assert encoder._module.__class__.__name__ == 'LSTM' assert encoder._module.num_layers == 3 assert encoder._module.input_size == 5 assert encoder._module.hidden_size == 7 assert encoder._module.bidirectional is True assert encoder._module.batch_first is True
def from_params(cls, vocab, params: Params) -> 'SimpleSeq2Seq': source_embedder_params = params.pop("source_embedder") source_embedder = TextFieldEmbedder.from_params(vocab, source_embedder_params) encoder = Seq2SeqEncoder.from_params(params.pop("encoder")) max_decoding_steps = params.pop("max_decoding_steps") target_namespace = params.pop("target_namespace", "tokens") # If no attention function is specified, we should not use attention, not attention with # default similarity function. attention_function_type = params.pop("attention_function", None) if attention_function_type is not None: attention_function = SimilarityFunction.from_params(attention_function_type) else: attention_function = None scheduled_sampling_ratio = params.pop_float("scheduled_sampling_ratio", 0.0) params.assert_empty(cls.__name__) return cls(vocab, source_embedder=source_embedder, encoder=encoder, max_decoding_steps=max_decoding_steps, target_namespace=target_namespace, attention_function=attention_function, scheduled_sampling_ratio=scheduled_sampling_ratio)