def __init__(self,
vocab,
encoder: FeedForward,
mean_projection: FeedForward,
log_variance_projection: FeedForward,
decoder: FeedForward,
kld_clamp: Optional[float] = None,
z_dropout: float = 0.2) -> None:
super(LogisticNormal, self).__init__(vocab)
self.encoder = encoder
self.mean_projection = mean_projection
self.log_variance_projection = log_variance_projection
self._kld_clamp = kld_clamp
self._decoder = torch.nn.Linear(decoder.get_input_dim(), decoder.get_output_dim(),
bias=False)
self._decoder_rationale = torch.nn.Linear(decoder.get_input_dim(), decoder.get_output_dim(),
bias=False)
self._z_dropout = torch.nn.Dropout(z_dropout)
mem_params = AttrDict({
"sparse": False,
"k_dim": 128,
"heads": 4,
"knn": 32,
"n_keys": 512, # the memory will have (n_keys ** 2) values
"query_batchnorm": True,
"input_dropout": 0,
"query_dropout": 0,
"value_dropout": 0,
})
# self.memory = HashingMemory(encoder.get_output_dim(), decoder.get_input_dim(), mem_params)
self.latent_dim = mean_projection.get_output_dim()
def __init__(self, vocab: Vocabulary,
text_field_embedder: TextFieldEmbedder,
attend_feedforward: FeedForward,
similarity_function: SimilarityFunction,
compare_feedforward: FeedForward,
aggregate_feedforward: FeedForward,
premise_encoder: Optional[Seq2SeqEncoder] = None,
hypothesis_encoder: Optional[Seq2SeqEncoder] = None,
initializer: InitializerApplicator = InitializerApplicator(),
regularizer: Optional[RegularizerApplicator] = None) -> None:
super(DecomposableAttention, self).__init__(vocab, regularizer)
self._text_field_embedder = text_field_embedder
self._attend_feedforward = TimeDistributed(attend_feedforward)
self._matrix_attention = MatrixAttention(similarity_function)
self._compare_feedforward = TimeDistributed(compare_feedforward)
self._aggregate_feedforward = aggregate_feedforward
self._premise_encoder = premise_encoder
self._hypothesis_encoder = hypothesis_encoder or premise_encoder
self._num_labels = vocab.get_vocab_size(namespace="labels")
if text_field_embedder.get_output_dim() != attend_feedforward.get_input_dim():
raise ConfigurationError("Output dimension of the text_field_embedder (dim: {}), "
"must match the input_dim of the FeedForward layer "
"attend_feedforward, (dim: {}). ".format(text_field_embedder.get_output_dim(),
attend_feedforward.get_input_dim()))
if aggregate_feedforward.get_output_dim() != self._num_labels:
raise ConfigurationError("Final output dimension (%d) must equal num labels (%d)" %
(aggregate_feedforward.get_output_dim(), self._num_labels))
self._accuracy = CategoricalAccuracy()
self._loss = torch.nn.CrossEntropyLoss()
initializer(self)
def __init__(self, vocab: Vocabulary,
text_field_embedder: TextFieldEmbedder,
aggregate_feedforward: FeedForward,
premise_encoder: Optional[Seq2SeqEncoder] = None,
hypothesis_encoder: Optional[Seq2SeqEncoder] = None,
initializer: InitializerApplicator = InitializerApplicator(),
aggregate_premise: Optional[str] = "max",
aggregate_hypothesis: Optional[str] = "max",
embeddings_dropout_value: Optional[float] = 0.0,
share_encoders: Optional[bool] = False) -> None:
super(StackedNNAggregateCustom, self).__init__(vocab)
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._aggregate_feedforward = aggregate_feedforward
self._premise_encoder = premise_encoder
self._hypothesis_encoder = hypothesis_encoder
self._premise_aggregate = aggregate_premise
self._hypothesis_aggregate = aggregate_hypothesis
self._num_labels = vocab.get_vocab_size(namespace="labels")
premise_output_dim = self._text_field_embedder.get_output_dim()
if self._premise_encoder is not None:
premise_output_dim = self._premise_encoder.get_output_dim()
hypothesis_output_dim = self._text_field_embedder.get_output_dim()
if self._hypothesis_encoder is not None:
hypothesis_output_dim = self._hypothesis_encoder.get_output_dim()
if premise_output_dim != hypothesis_output_dim:
raise ConfigurationError("Output dimension of the premise_encoder (dim: {}), "
"plus hypothesis_encoder (dim: {})"
"must match! "
.format(premise_output_dim,
hypothesis_output_dim))
if premise_output_dim * 4 != \
aggregate_feedforward.get_input_dim():
raise ConfigurationError("The output of aggregate_feedforward input dim ({2}) "
"should be {3} = 4 x {0} ({1} = premise_output_dim == hypothesis_output_dim)!"
.format(premise_output_dim,
hypothesis_output_dim,
aggregate_feedforward.get_input_dim(),
4 * premise_output_dim))
if aggregate_feedforward.get_output_dim() != self._num_labels:
raise ConfigurationError("Final output dimension (%d) must equal num labels (%d)" %
(aggregate_feedforward.get_output_dim(), self._num_labels))
self._accuracy = CategoricalAccuracy()
self._loss = torch.nn.CrossEntropyLoss()
initializer(self)
def __init__(self,
vocab: Vocabulary,
text_field_embedder: TextFieldEmbedder,
classifier_feedforward: FeedForward,
span_extractor: Optional[SpanExtractor] = None,
seq2seq_encoder: Optional[Seq2SeqEncoder] = None,
regularizer: Optional[RegularizerApplicator] = None) -> None:
super(SentenceSpanClassificationModel,
self).__init__(vocab, regularizer)
self.text_field_embedder = text_field_embedder
self.num_classes = self.vocab.get_vocab_size("labels")
self.classifier_feedforward = classifier_feedforward
self.seq2seq_encoder = seq2seq_encoder
self.span_extractor = span_extractor
# Using an encoder that returns a vector for each token
if seq2seq_encoder:
check_dimensions_match(text_field_embedder.get_output_dim(),
seq2seq_encoder.get_input_dim(),
"text embedding dim",
"seq2seq_encoder input dim")
check_dimensions_match(seq2seq_encoder.get_output_dim(),
span_extractor.get_input_dim(),
"seq2seq_encoder output dim",
"span_extractor input dim")
check_dimensions_match(span_extractor.get_output_dim(),
classifier_feedforward.get_input_dim(),
"span_extractor",
"classifier_feedforward input dim")
# Using only an embedder, it will return a vector for each token, and it needs to go through a
# span extractor afterwards.
else:
check_dimensions_match(text_field_embedder.get_output_dim(),
span_extractor.get_input_dim(),
"text embedding dim",
"span_extractor input dim")
check_dimensions_match(span_extractor.get_output_dim(),
classifier_feedforward.get_input_dim(),
"span_extractor",
"classifier_feedforward input dim")
self.metrics = {"accuracy": CategoricalAccuracy()}
self.loss = torch.nn.CrossEntropyLoss()
InitializerApplicator()(self)
def __init__(self,
vocab: Vocabulary,
text_field_embedder: TextFieldEmbedder,
classifier_feedforward: FeedForward,
span_extractor: Optional[SpanExtractor] = None,
sentence_encoder: Optional[Seq2SeqEncoder] = None,
regularizer: Optional[RegularizerApplicator] = None) -> None:
super(SentenceWordClassificationModel,
self).__init__(vocab, regularizer)
self.text_field_embedder = text_field_embedder
self.num_classes = self.vocab.get_vocab_size("labels")
self.classifier_feedforward = classifier_feedforward
self.sentence_encoder = sentence_encoder
self.span_extractor = span_extractor
# biLSTM
if sentence_encoder:
check_dimensions_match(text_field_embedder.get_output_dim(),
sentence_encoder.get_input_dim(),
"text embedding dim",
"sentence_encoder input dim")
check_dimensions_match(
sentence_encoder.get_output_dim() +
text_field_embedder.get_output_dim(),
classifier_feedforward.get_input_dim(),
"sentence_encoder + text_field_embedder output dim",
"classifier_feedforward input dim")
# Attention
elif span_extractor:
check_dimensions_match(
text_field_embedder.get_output_dim() +
span_extractor.get_output_dim(),
classifier_feedforward.get_input_dim(),
"text embedding dim + span_extractor",
"classifier_feedforward input dim")
# Only embedder
else:
check_dimensions_match(2 * text_field_embedder.get_output_dim(),
classifier_feedforward.get_input_dim(),
"2 * text embedding dim",
"classifier_feedforward input dim")
self.metrics = {"accuracy": CategoricalAccuracy()}
self.loss = torch.nn.CrossEntropyLoss()
InitializerApplicator()(self)
def __init__(self,
encoder_output_dim: int,
action_embedding_dim: int,
input_attention: Attention,
num_start_types: int,
num_entity_types: int,
mixture_feedforward: FeedForward = None,
dropout: float = 0.0,
unlinked_terminal_indices: List[int] = None) -> None:
super(WikiTablesDecoderStep, self).__init__()
self._mixture_feedforward = mixture_feedforward
self._entity_type_embedding = Embedding(num_entity_types,
action_embedding_dim)
self._input_attention = input_attention
self._num_start_types = num_start_types
self._start_type_predictor = Linear(encoder_output_dim,
num_start_types)
# Decoder output dim needs to be the same as the encoder output dim since we initialize the
# hidden state of the decoder with the final hidden state of the encoder.
output_dim = encoder_output_dim
input_dim = output_dim
# Our decoder input will be the concatenation of the decoder hidden state and the previous
# action embedding, and we'll project that down to the decoder's `input_dim`, which we
# arbitrarily set to be the same as `output_dim`.
self._input_projection_layer = Linear(
output_dim + action_embedding_dim, input_dim)
# Before making a prediction, we'll compute an attention over the input given our updated
# hidden state. Then we concatenate those with the decoder state and project to
# `action_embedding_dim` to make a prediction.
self._output_projection_layer = Linear(output_dim + encoder_output_dim,
action_embedding_dim)
if unlinked_terminal_indices is not None:
# This means we are using coverage to train the parser.
# These factors are used to add the embeddings of yet to be produced actions to the
# predicted embedding, and to boost the action logits of yet to be produced linked
# actions, respectively.
self._unlinked_checklist_multiplier = Parameter(
torch.FloatTensor([1.0]))
self._linked_checklist_multiplier = Parameter(
torch.FloatTensor([1.0]))
self._unlinked_terminal_indices = unlinked_terminal_indices
# TODO(pradeep): Do not hardcode decoder cell type.
self._decoder_cell = LSTMCell(input_dim, output_dim)
if mixture_feedforward is not None:
check_dimensions_match(output_dim,
mixture_feedforward.get_input_dim(),
"hidden state embedding dim",
"mixture feedforward input dim")
check_dimensions_match(mixture_feedforward.get_output_dim(), 1,
"mixture feedforward output dim",
"dimension for scalar value")
if dropout > 0:
self._dropout = torch.nn.Dropout(p=dropout)
else:
self._dropout = lambda x: x
def __init__(self,
encoder_output_dim: int,
action_embedding_dim: int,
input_attention: Attention,
activation: Activation = Activation.by_name('relu')(),
predict_start_type_separately: bool = True,
num_start_types: int = None,
add_action_bias: bool = True,
mixture_feedforward: FeedForward = None,
dropout: float = 0.0) -> None:
super().__init__(encoder_output_dim=encoder_output_dim,
action_embedding_dim=action_embedding_dim,
input_attention=input_attention,
num_start_types=num_start_types,
activation=activation,
predict_start_type_separately=predict_start_type_separately,
add_action_bias=add_action_bias,
dropout=dropout)
self._linked_checklist_multiplier = Parameter(torch.FloatTensor([1.0]))
self._mixture_feedforward = mixture_feedforward
if mixture_feedforward is not None:
check_dimensions_match(encoder_output_dim, mixture_feedforward.get_input_dim(),
"hidden state embedding dim", "mixture feedforward input dim")
check_dimensions_match(mixture_feedforward.get_output_dim(), 1,
"mixture feedforward output dim", "dimension for scalar value")
def __init__(self,
vocab: Vocabulary,
text_field_embedder: TextFieldEmbedder,
attend_feedforward: FeedForward,
similarity_function: SimilarityFunction,
compare_feedforward: FeedForward,
classifier_feedforward: FeedForward,
context_encoder: Optional[Seq2SeqEncoder] = None,
response_encoder: Optional[Seq2SeqEncoder] = None,
initializer: InitializerApplicator = InitializerApplicator(),
regularizer: Optional[RegularizerApplicator] = None) -> None:
super(DialogueContextCoherenceAttentionClassifier, self).__init__(vocab, regularizer)
self.text_field_embedder = text_field_embedder
self.num_classes = vocab.get_vocab_size("labels")
self.context_encoder = context_encoder
self.response_encoder = response_encoder
self.attend_feedforward = TimeDistributed(attend_feedforward)
self.matrix_attention = MatrixAttention(similarity_function)
self.compare_feedforward = TimeDistributed(compare_feedforward)
self.classifier_feedforward = classifier_feedforward
labels = self.vocab.get_index_to_token_vocabulary('labels')
pos_label_index = list(labels.keys())[list(labels.values()).index('neg')]
check_dimensions_match(text_field_embedder.get_output_dim(), attend_feedforward.get_input_dim(),
"text field embedding dim", "attend feedforward input dim")
check_dimensions_match(classifier_feedforward.get_output_dim(), self.num_classes,
"final output dimension", "number of labels")
self.metrics = {
"accuracy": CategoricalAccuracy()
# "f1": F1Measure(positive_label=pos_label_index)
}
self.loss = torch.nn.CrossEntropyLoss()
initializer(self)
def __init__(self,
encoder_output_dim: int,
action_embedding_dim: int,
input_attention: Attention,
activation: Activation = Activation.by_name('relu')(),
predict_start_type_separately: bool = True,
num_start_types: int = None,
add_action_bias: bool = True,
mixture_feedforward: FeedForward = None,
dropout: float = 0.0) -> None:
super().__init__(encoder_output_dim=encoder_output_dim,
action_embedding_dim=action_embedding_dim,
input_attention=input_attention,
num_start_types=num_start_types,
activation=activation,
predict_start_type_separately=predict_start_type_separately,
add_action_bias=add_action_bias,
dropout=dropout)
self._linked_checklist_multiplier = Parameter(torch.FloatTensor([1.0]))
self._mixture_feedforward = mixture_feedforward
if mixture_feedforward is not None:
check_dimensions_match(encoder_output_dim, mixture_feedforward.get_input_dim(),
"hidden state embedding dim", "mixture feedforward input dim")
check_dimensions_match(mixture_feedforward.get_output_dim(), 1,
"mixture feedforward output dim", "dimension for scalar value")
def __init__(
self,
vocab: Vocabulary,
text_field_embedder: TextFieldEmbedder,
encoder: Seq2SeqEncoder,
matrix_attention: MatrixAttention,
projection_feedforward: FeedForward,
inference_encoder: Seq2SeqEncoder,
output_feedforward: FeedForward,
output_logit: FeedForward,
dropout: float = 0.5,
initializer: InitializerApplicator = InitializerApplicator(),
**kwargs,
) -> None:
super().__init__(vocab, **kwargs)
self._text_field_embedder = text_field_embedder
self._encoder = encoder
self._matrix_attention = matrix_attention
self._projection_feedforward = projection_feedforward
self._inference_encoder = inference_encoder
if dropout:
self.dropout = torch.nn.Dropout(dropout)
self.rnn_input_dropout = InputVariationalDropout(dropout)
else:
self.dropout = None
self.rnn_input_dropout = None
self._output_feedforward = output_feedforward
self._output_logit = output_logit
self._num_labels = vocab.get_vocab_size(namespace="labels")
check_dimensions_match(
text_field_embedder.get_output_dim(),
encoder.get_input_dim(),
"text field embedding dim",
"encoder input dim",
)
check_dimensions_match(
encoder.get_output_dim() * 4,
projection_feedforward.get_input_dim(),
"encoder output dim",
"projection feedforward input",
)
check_dimensions_match(
projection_feedforward.get_output_dim(),
inference_encoder.get_input_dim(),
"proj feedforward output dim",
"inference lstm input dim",
)
self._accuracy = CategoricalAccuracy()
self._loss = torch.nn.CrossEntropyLoss()
self._debug = 2
initializer(self)
def __init__(self,
vocab: Vocabulary,
bert: TextFieldEmbedder,
encoder: Seq2SeqEncoder,
classifier: FeedForward,
aggregation: str = 'cls+max',
dropout: float = 0.1,
initializer: InitializerApplicator = InitializerApplicator(),
regularizer: Optional[RegularizerApplicator] = None) -> None:
super().__init__(vocab, regularizer)
self._bert = bert
self._encoder = encoder
self._aggregation = aggregation
self._dropout = torch.nn.Dropout(dropout)
self._classifier = classifier
self._num_labels = vocab.get_vocab_size(namespace="labels")
self._pooler = FeedForward(input_dim=bert.get_output_dim(),
num_layers=1,
hidden_dims=bert.get_output_dim(),
activations=torch.tanh)
check_dimensions_match(bert.get_output_dim(), encoder.get_input_dim(),
"bert output dim", "encoder input dim")
check_dimensions_match(encoder.get_output_dim() * 2,
classifier.get_input_dim(),
"encoder output dim", "classifier input dim")
check_dimensions_match(classifier.get_output_dim(), self._num_labels,
"classifier output dim", "number of labels")
self._accuracy = CategoricalAccuracy()
self._loss = torch.nn.CrossEntropyLoss()
initializer(self)
def __init__(self,
vocab: Vocabulary,
bert: TextFieldEmbedder,
classifier: FeedForward,
dropout: float = 0.1,
initializer: InitializerApplicator = InitializerApplicator(),
regularizer: Optional[RegularizerApplicator] = None) -> None:
super().__init__(vocab, regularizer)
self._bert = bert
self._classifier = classifier
if dropout:
self.dropout = torch.nn.Dropout(dropout)
else:
self.dropout = None
self._pooler = FeedForward(input_dim=bert.get_output_dim(),
num_layers=1,
hidden_dims=bert.get_output_dim(),
activations=torch.tanh)
check_dimensions_match(bert.get_output_dim(),
classifier.get_input_dim(),
"bert embedding dim", "classifier input dim")
self._accuracy = CategoricalAccuracy()
self._loss = torch.nn.CrossEntropyLoss()
initializer(self)
def __init__(self, vocab: Vocabulary,
text_field_embedder: TextFieldEmbedder,
attend_feedforward: FeedForward,
similarity_function: SimilarityFunction,
compare_feedforward: FeedForward,
aggregate_feedforward: FeedForward,
premise_encoder: Optional[Seq2SeqEncoder] = None,
hypothesis_encoder: Optional[Seq2SeqEncoder] = None,
initializer: InitializerApplicator = InitializerApplicator(),
regularizer: Optional[RegularizerApplicator] = None) -> None:
super(DecomposableAttention, self).__init__(vocab, regularizer)
self._text_field_embedder = text_field_embedder
self._attend_feedforward = TimeDistributed(attend_feedforward)
self._matrix_attention = LegacyMatrixAttention(similarity_function)
self._compare_feedforward = TimeDistributed(compare_feedforward)
self._aggregate_feedforward = aggregate_feedforward
self._premise_encoder = premise_encoder
self._hypothesis_encoder = hypothesis_encoder or premise_encoder
self._num_labels = vocab.get_vocab_size(namespace="labels")
check_dimensions_match(text_field_embedder.get_output_dim(), attend_feedforward.get_input_dim(),
"text field embedding dim", "attend feedforward input dim")
check_dimensions_match(aggregate_feedforward.get_output_dim(), self._num_labels,
"final output dimension", "number of labels")
self._accuracy = CategoricalAccuracy()
self._loss = torch.nn.CrossEntropyLoss()
initializer(self)
def __init__(
self,
encoder_output_dim: int,
action_embedding_dim: int,
input_attention: Attention,
activation: Activation = Activation.by_name("relu")(),
add_action_bias: bool = True,
mixture_feedforward: FeedForward = None,
dropout: float = 0.0,
num_layers: int = 1,
) -> None:
super().__init__(
encoder_output_dim=encoder_output_dim,
action_embedding_dim=action_embedding_dim,
input_attention=input_attention,
activation=activation,
add_action_bias=add_action_bias,
dropout=dropout,
num_layers=num_layers,
)
self._mixture_feedforward = mixture_feedforward
if mixture_feedforward is not None:
check_dimensions_match(
encoder_output_dim,
mixture_feedforward.get_input_dim(),
"hidden state embedding dim",
"mixture feedforward input dim",
)
check_dimensions_match(
mixture_feedforward.get_output_dim(),
1,
"mixture feedforward output dim",
"dimension for scalar value",
)
def __init__(self,
vocab: Vocabulary,
bert: TextFieldEmbedder,
classifier: FeedForward,
dropout: float = 0.1,
num_labels: int = None,
initializer: InitializerApplicator = InitializerApplicator(),
regularizer: Optional[RegularizerApplicator] = None) -> None:
super().__init__(vocab, regularizer)
self._bert = bert
self._dropout = torch.nn.Dropout(dropout)
if dropout:
self.dropout = torch.nn.Dropout(dropout)
else:
self.dropout = None
self._classifier = classifier
if num_labels is None:
self._num_labels = vocab.get_vocab_size(namespace="labels")
else:
self._num_labels = num_labels
check_dimensions_match(bert.get_output_dim() * 2,
classifier.get_input_dim(), "bert output dim",
"classifier input dim")
check_dimensions_match(classifier.get_output_dim(), self._num_labels,
"classifier output dim", "number of labels")
self._accuracy = CategoricalAccuracy()
self._loss = torch.nn.CrossEntropyLoss()
initializer(self)
def __init__(self, vocab: Vocabulary,
text_field_embedder: TextFieldEmbedder,
attend_feedforward: FeedForward,
similarity_function: SimilarityFunction,
compare_feedforward: FeedForward,
aggregate_feedforward: FeedForward,
premise_encoder: Optional[Seq2SeqEncoder] = None,
hypothesis_encoder: Optional[Seq2SeqEncoder] = None,
initializer: InitializerApplicator = InitializerApplicator(),
regularizer: Optional[RegularizerApplicator] = None) -> None:
super(DecomposableAttention, self).__init__(vocab, regularizer)
self._text_field_embedder = text_field_embedder
self._attend_feedforward = TimeDistributed(attend_feedforward)
self._matrix_attention = LegacyMatrixAttention(similarity_function)
self._compare_feedforward = TimeDistributed(compare_feedforward)
self._aggregate_feedforward = aggregate_feedforward
self._premise_encoder = premise_encoder
self._hypothesis_encoder = hypothesis_encoder or premise_encoder
self._num_labels = vocab.get_vocab_size(namespace="labels")
check_dimensions_match(text_field_embedder.get_output_dim(), attend_feedforward.get_input_dim(),
"text field embedding dim", "attend feedforward input dim")
check_dimensions_match(aggregate_feedforward.get_output_dim(), self._num_labels,
"final output dimension", "number of labels")
self._accuracy = CategoricalAccuracy()
self._loss = torch.nn.CrossEntropyLoss()
initializer(self)
def __init__(
self,
vocab: Vocabulary = None,
antecedent_feedforward: FeedForward = None,
relation_cardinality: int = 2,
initializer: InitializerApplicator = InitializerApplicator(),
regularizer: Optional[RegularizerApplicator] = None,
) -> None:
super(RelationExtractor, self).__init__(vocab, regularizer)
self._antecedent_feedforward = TimeDistributed(antecedent_feedforward)
self._antecedent_scorer = TimeDistributed(
torch.nn.Linear(antecedent_feedforward.get_output_dim(), 1))
self._span_embedding_size = antecedent_feedforward.get_input_dim() // 4
self._bias_vectors = torch.nn.Parameter(
torch.zeros((1, 4, self._span_embedding_size)))
self._relation_cardinality = relation_cardinality
self._pos_weight_dict = {2: 1.0, 3: 1.0, 4: 3.3}
self._pos_weight = self._pos_weight_dict[relation_cardinality]
self._relation_type_map = {
tuple(e): i
for i, e in enumerate(
combinations(used_entities, self._relation_cardinality))
}
self._binary_scores = BinaryThresholdF1()
self._global_scores = NAryRelationMetrics()
initializer(self)
def __init__(
self,
vocab: Vocabulary,
text_field_embedder: TextFieldEmbedder,
span_extractor: SpanExtractor,
encoder: Seq2SeqEncoder,
feedforward: FeedForward = None,
pos_tag_embedding: Embedding = None,
initializer: InitializerApplicator = InitializerApplicator(),
regularizer: Optional[RegularizerApplicator] = None,
evalb_directory_path: str = DEFAULT_EVALB_DIR,
) -> None:
super().__init__(vocab, regularizer)
self.text_field_embedder = text_field_embedder
self.span_extractor = span_extractor
self.num_classes = self.vocab.get_vocab_size("labels")
self.encoder = encoder
self.feedforward_layer = TimeDistributed(
feedforward) if feedforward else None
self.pos_tag_embedding = pos_tag_embedding or None
if feedforward is not None:
output_dim = feedforward.get_output_dim()
else:
output_dim = span_extractor.get_output_dim()
self.tag_projection_layer = TimeDistributed(
Linear(output_dim, self.num_classes))
representation_dim = text_field_embedder.get_output_dim()
if pos_tag_embedding is not None:
representation_dim += pos_tag_embedding.get_output_dim()
check_dimensions_match(
representation_dim,
encoder.get_input_dim(),
"representation dim (tokens + optional POS tags)",
"encoder input dim",
)
check_dimensions_match(
encoder.get_output_dim(),
span_extractor.get_input_dim(),
"encoder input dim",
"span extractor input dim",
)
if feedforward is not None:
check_dimensions_match(
span_extractor.get_output_dim(),
feedforward.get_input_dim(),
"span extractor output dim",
"feedforward input dim",
)
self.tag_accuracy = CategoricalAccuracy()
if evalb_directory_path is not None:
self._evalb_score = EvalbBracketingScorer(evalb_directory_path)
else:
self._evalb_score = None
initializer(self)
def test_get_dimension_is_correct(self):
feedforward = FeedForward(input_dim=10,
num_layers=1,
hidden_dims=10,
activations="linear")
encoder = FeedForwardEncoder(feedforward)
assert encoder.get_input_dim() == feedforward.get_input_dim()
assert encoder.get_output_dim() == feedforward.get_output_dim()
def __init__(self,
encoder_output_dim: int,
action_embedding_dim: int,
attention_function: SimilarityFunction,
num_start_types: int,
num_entity_types: int,
mixture_feedforward: FeedForward = None,
dropout: float = 0.0,
unlinked_terminal_indices: List[int] = None) -> None:
super(WikiTablesDecoderStep, self).__init__()
self._mixture_feedforward = mixture_feedforward
self._entity_type_embedding = Embedding(num_entity_types,
action_embedding_dim)
self._input_attention = Attention(attention_function)
self._num_start_types = num_start_types
self._start_type_predictor = Linear(encoder_output_dim,
num_start_types)
# Decoder output dim needs to be the same as the encoder output dim since we initialize the
# hidden state of the decoder with the final hidden state of the encoder.
output_dim = encoder_output_dim
input_dim = output_dim
# Our decoder input will be the concatenation of the decoder hidden state and the previous
# action embedding, and we'll project that down to the decoder's `input_dim`, which we
# arbitrarily set to be the same as `output_dim`.
self._input_projection_layer = Linear(
output_dim + action_embedding_dim, input_dim)
# Before making a prediction, we'll compute an attention over the input given our updated
# hidden state, and optionally a difference between the current checklist vector and its
# target, if we are training to maximize coverage using a checklist. Then we concatenate
# those with the decoder state and project to `action_embedding_dim` to make a prediction.
if unlinked_terminal_indices is None:
self._output_projection_layer = Linear(
output_dim + encoder_output_dim, action_embedding_dim)
else:
unlinked_checklist_size = len(unlinked_terminal_indices)
self._output_projection_layer = Linear(
output_dim + encoder_output_dim + unlinked_checklist_size,
action_embedding_dim)
self._unlinked_terminal_indices = unlinked_terminal_indices
# TODO(pradeep): Do not hardcode decoder cell type.
self._decoder_cell = LSTMCell(input_dim, output_dim)
if mixture_feedforward is not None:
check_dimensions_match(output_dim,
mixture_feedforward.get_input_dim(),
"hidden state embedding dim",
"mixture feedforward input dim")
check_dimensions_match(mixture_feedforward.get_output_dim(), 1,
"mixture feedforward output dim",
"dimension for scalar value")
if dropout > 0:
self._dropout = torch.nn.Dropout(p=dropout)
else:
self._dropout = lambda x: x
def __init__(self,
vocab: Vocabulary,
text_field_embedder: TextFieldEmbedder,
encoder: Seq2SeqEncoder,
label_namespace: str = "labels",
constraint_type: str = None,
feedforward: FeedForward = None,
include_start_end_transitions: bool = True,
dropout: float = None,
verbose_metrics: bool = False,
initializer: InitializerApplicator = InitializerApplicator(),
regularizer: Optional[RegularizerApplicator] = None) -> None:
super().__init__(vocab, regularizer)
self.label_namespace = label_namespace
self.text_field_embedder = text_field_embedder
self.num_tags = self.vocab.get_vocab_size(label_namespace)
self.encoder = encoder
self._verbose_metrics = verbose_metrics
if dropout:
self.dropout = torch.nn.Dropout(dropout)
else:
self.dropout = None
self._feedforward = feedforward
if feedforward is not None:
output_dim = feedforward.get_output_dim()
else:
output_dim = self.encoder.get_output_dim()
self.tag_projection_layer = TimeDistributed(
Linear(output_dim, self.num_tags))
if constraint_type is not None:
labels = self.vocab.get_index_to_token_vocabulary(label_namespace)
constraints = allowed_transitions(constraint_type, labels)
else:
constraints = None
self.crf = ConditionalRandomField(
self.num_tags,
constraints,
include_start_end_transitions=include_start_end_transitions)
self.span_metric = SpanBasedF1Measure(vocab,
tag_namespace=label_namespace,
label_encoding=constraint_type
or "BIO")
check_dimensions_match(text_field_embedder.get_output_dim(),
encoder.get_input_dim(),
"text field embedding dim", "encoder input dim")
if feedforward is not None:
check_dimensions_match(encoder.get_output_dim(),
feedforward.get_input_dim(),
"encoder output dim",
"feedforward input dim")
initializer(self)
def __init__(self, vocab: Vocabulary,
text_field_embedder: TextFieldEmbedder,
encoder: Seq2SeqEncoder,
similarity_function: SimilarityFunction,
projection_feedforward: FeedForward,
inference_encoder: Seq2SeqEncoder,
output_feedforward: FeedForward,
output_logit: FeedForward,
parser_model_path: str,
parser_cuda_device: int,
freeze_parser: bool,
dropout: float = 0.5,
initializer: InitializerApplicator = InitializerApplicator(),
regularizer: Optional[RegularizerApplicator] = None) -> None:
super().__init__(vocab, regularizer)
self._text_field_embedder = text_field_embedder
self._encoder = encoder
self._matrix_attention = LegacyMatrixAttention(similarity_function)
self._projection_feedforward = projection_feedforward
self._inference_encoder = inference_encoder
if dropout:
self.dropout = torch.nn.Dropout(dropout)
self.rnn_input_dropout = InputVariationalDropout(dropout)
else:
self.dropout = None
self.rnn_input_dropout = None
self._output_feedforward = output_feedforward
self._output_logit = output_logit
self._num_labels = vocab.get_vocab_size(namespace="labels")
check_dimensions_match(text_field_embedder.get_output_dim(), encoder.get_input_dim(),
"text field embedding dim", "encoder input dim")
check_dimensions_match(encoder.get_output_dim() * 4, projection_feedforward.get_input_dim(),
"encoder output dim", "projection feedforward input")
check_dimensions_match(projection_feedforward.get_output_dim(), inference_encoder.get_input_dim(),
"proj feedforward output dim", "inference lstm input dim")
self._accuracy = CategoricalAccuracy()
self._loss = torch.nn.CrossEntropyLoss()
self._parser = load_archive(parser_model_path,
cuda_device=parser_cuda_device).model
self._parser._head_sentinel.requires_grad = False
for child in self._parser.children():
for param in child.parameters():
param.requires_grad = False
if not freeze_parser:
for param in self._parser.encoder.parameters():
param.requires_grad = True
initializer(self)
def __init__(self,vocab: Vocabulary,
mlp : FeedForward,
label_namespace : str,
regularizer: Optional[RegularizerApplicator] = None ):
super().__init__(vocab=vocab, regularizer=regularizer)
self.mlp = mlp
self._encoder_dim = mlp.get_input_dim()
self.output_layer = torch.nn.Linear(mlp.get_output_dim(),vocab.get_vocab_size(label_namespace))
def __init__(
self,
module: FeedForward,
pool_type: str = 'mean',
) -> None:
super().__init__()
self._input_dim = module.get_input_dim()
self._output_dim = module.get_output_dim()
self._module = TimeDistributed(module)
self.pool = (lambda tensor: tensor.mean(dim=1)) if pool_type == 'mean' \
else (lambda tensor: tensor.max(dim=1)[0])
def __init__(self, vocab: Vocabulary,
text_field_embedder: TextFieldEmbedder,
encoder: Seq2SeqEncoder,
label_namespace: str = "labels",
constraint_type: str = None,
feedforward: FeedForward = None,
include_start_end_transitions: bool = True,
dropout: float = None,
verbose_metrics: bool = False,
initializer: InitializerApplicator = InitializerApplicator(),
regularizer: Optional[RegularizerApplicator] = None) -> None:
super().__init__(vocab, regularizer)
self.label_namespace = label_namespace
self.text_field_embedder = text_field_embedder
self.num_tags = self.vocab.get_vocab_size(label_namespace)
self.encoder = encoder
self._verbose_metrics = verbose_metrics
if dropout:
self.dropout = torch.nn.Dropout(dropout)
else:
self.dropout = None
self._feedforward = feedforward
if feedforward is not None:
output_dim = feedforward.get_output_dim()
else:
output_dim = self.encoder.get_output_dim()
self.tag_projection_layer = TimeDistributed(Linear(output_dim,
self.num_tags))
if constraint_type is not None:
labels = self.vocab.get_index_to_token_vocabulary(label_namespace)
constraints = allowed_transitions(constraint_type, labels)
else:
constraints = None
self.crf = ConditionalRandomField(
self.num_tags, constraints,
include_start_end_transitions=include_start_end_transitions
)
self.span_metric = SpanBasedF1Measure(vocab,
tag_namespace=label_namespace,
label_encoding=constraint_type or "BIO")
check_dimensions_match(text_field_embedder.get_output_dim(), encoder.get_input_dim(),
"text field embedding dim", "encoder input dim")
if feedforward is not None:
check_dimensions_match(encoder.get_output_dim(), feedforward.get_input_dim(),
"encoder output dim", "feedforward input dim")
initializer(self)
def __init__(self, vocab: Vocabulary,
text_field_embedder: TextFieldEmbedder,
attend_feedforward: FeedForward,
similarity_function: SimilarityFunction,
compare_feedforward: FeedForward,
aggregate_feedforward: FeedForward,
premise_encoder: Optional[Seq2SeqEncoder] = None,
hypothesis_encoder: Optional[Seq2SeqEncoder] = None,
initializer: InitializerApplicator = InitializerApplicator(),
regularizer: Optional[RegularizerApplicator] = None,
preload_path: Optional[str] = None) -> None:
super(DecomposableAttention, self).__init__(vocab, regularizer)
self._text_field_embedder = text_field_embedder
self._attend_feedforward = TimeDistributed(attend_feedforward)
self._matrix_attention = MatrixAttention(similarity_function)
self._compare_feedforward = TimeDistributed(compare_feedforward)
self._aggregate_feedforward = aggregate_feedforward
self._premise_encoder = premise_encoder
self._hypothesis_encoder = hypothesis_encoder or premise_encoder
# self._num_labels = vocab.get_vocab_size(namespace="labels")
check_dimensions_match(text_field_embedder.get_output_dim(), attend_feedforward.get_input_dim(),
"text field embedding dim", "attend feedforward input dim")
# check_dimensions_match(aggregate_feedforward.get_output_dim(), self._num_labels,
# "final output dimension", "number of labels")
self._accuracy = CategoricalAccuracy()
self._loss = torch.nn.CrossEntropyLoss()
initializer(self)
# Do we want to initialize with the SNLI stuff? let's say yes.
# 'snli-decomposable-attention/weights.th'
if preload_path is not None:
logger.info("Preloading!")
preload = torch.load(preload_path)
own_state = self.state_dict()
for name, param in preload.items():
if name not in own_state:
logger.info("Unexpected key {} in state_dict with size {}".format(name, param.size()))
elif param.size() == own_state[name].size():
own_state[name].copy_(param)
else:
logger.info("Network has {} with size {}, ckpt has {}".format(name,
own_state[name].size(),
param.size()))
missing = set(own_state.keys()) - set(preload.keys())
if len(missing) > 0:
logger.info("We couldn't find {}".format(','.join(missing)))
def __init__(self,
rnn: Seq2SeqEncoder,
feed_forward: FeedForward,
dropout: float = 0.0) -> None:
super().__init__()
self.rnn = rnn
self.feed_forward = feed_forward
self.dropout = torch.nn.Dropout(dropout)
if rnn.get_output_dim() != feed_forward.get_input_dim():
raise ConfigurationError('The RNN and feed-forward layers have incompatible dimensions')
if feed_forward.get_output_dim() != 1:
raise ConfigurationError('The feed-foward network must have output size 1')
def __init__(self,
encoder_output_dim: int,
action_embedding_dim: int,
input_attention: Attention,
num_start_types: int,
num_entity_types: int,
mixture_feedforward: FeedForward = None,
dropout: float = 0.0,
unlinked_terminal_indices: List[int] = None) -> None:
super(WikiTablesDecoderStep, self).__init__()
self._mixture_feedforward = mixture_feedforward
self._entity_type_embedding = Embedding(num_entity_types, action_embedding_dim)
self._input_attention = input_attention
self._num_start_types = num_start_types
self._start_type_predictor = Linear(encoder_output_dim, num_start_types)
# Decoder output dim needs to be the same as the encoder output dim since we initialize the
# hidden state of the decoder with the final hidden state of the encoder.
output_dim = encoder_output_dim
input_dim = output_dim
# Our decoder input will be the concatenation of the decoder hidden state and the previous
# action embedding, and we'll project that down to the decoder's `input_dim`, which we
# arbitrarily set to be the same as `output_dim`.
self._input_projection_layer = Linear(output_dim + action_embedding_dim, input_dim)
# Before making a prediction, we'll compute an attention over the input given our updated
# hidden state. Then we concatenate those with the decoder state and project to
# `action_embedding_dim` to make a prediction.
self._output_projection_layer = Linear(output_dim + encoder_output_dim, action_embedding_dim)
if unlinked_terminal_indices is not None:
# This means we are using coverage to train the parser.
# These factors are used to add the embeddings of yet to be produced actions to the
# predicted embedding, and to boost the action logits of yet to be produced linked
# actions, respectively.
self._unlinked_checklist_multiplier = Parameter(torch.FloatTensor([1.0]))
self._linked_checklist_multiplier = Parameter(torch.FloatTensor([1.0]))
self._unlinked_terminal_indices = unlinked_terminal_indices
# TODO(pradeep): Do not hardcode decoder cell type.
self._decoder_cell = LSTMCell(input_dim, output_dim)
if mixture_feedforward is not None:
check_dimensions_match(output_dim, mixture_feedforward.get_input_dim(),
"hidden state embedding dim", "mixture feedforward input dim")
check_dimensions_match(mixture_feedforward.get_output_dim(), 1,
"mixture feedforward output dim", "dimension for scalar value")
if dropout > 0:
self._dropout = torch.nn.Dropout(p=dropout)
else:
self._dropout = lambda x: x
def __init__(self,
dim_reduce_layer: FeedForward = None,
separate: bool = False,
repr_layer: FeedForward = None,
pair: bool = True,
combine: str = 'concat',
dist_emb_size: int = None) -> None:
super(SpanPairPairedLayer, self).__init__()
self.inp_dim, self.out_dim = None, None
self.pair = pair
self.combine = combine
assert combine in {'concat',
'coref'} # 'coref' means using concat + dot + width
if combine == 'coref':
self.num_distance_buckets = 10
self.distance_embedding = Embedding(self.num_distance_buckets,
dist_emb_size)
self.dim_reduce_layer1 = self.dim_reduce_layer2 = dim_reduce_layer
if dim_reduce_layer is not None:
self.inp_dim = self.inp_dim or dim_reduce_layer.get_input_dim()
self.out_dim = dim_reduce_layer.get_output_dim()
self.dim_reduce_layer1 = TimeDistributed(dim_reduce_layer)
if separate:
self.dim_reduce_layer2 = copy.deepcopy(self.dim_reduce_layer1)
else:
self.dim_reduce_layer2 = self.dim_reduce_layer1
if pair:
self.out_dim *= 2
self.repr_layer = None
if repr_layer is not None:
if not pair:
raise Exception('MLP needs paired input')
self.inp_dim = self.inp_dim or repr_layer.get_input_dim()
self.out_dim = repr_layer.get_output_dim()
self.repr_layer = TimeDistributed(repr_layer)
def __init__(self,
dim_reduce_layer: FeedForward = None,
separate: bool = False,
repr_layer: FeedForward = None) -> None:
super(SpanPairLayer, self).__init__()
self.inp_dim, self.out_dim = None, None
self.dim_reduce_layer1 = self.dim_reduce_layer2 = dim_reduce_layer
if dim_reduce_layer is not None:
self.inp_dim = self.inp_dim or dim_reduce_layer.get_input_dim()
self.out_dim = dim_reduce_layer.get_output_dim()
self.dim_reduce_layer1 = TimeDistributed(dim_reduce_layer)
if separate:
self.dim_reduce_layer2 = copy.deepcopy(self.dim_reduce_layer1)
else:
self.dim_reduce_layer2 = self.dim_reduce_layer1
self.repr_layer = None
if repr_layer is not None:
self.inp_dim = self.inp_dim or repr_layer.get_input_dim()
self.out_dim = repr_layer.get_output_dim()
self.repr_layer = TimeDistributed(repr_layer)
def __init__(self,
vocab: Vocabulary,
text_field_embedder: TextFieldEmbedder,
encoder: Seq2SeqEncoder,
classifier_feedforward: FeedForward,
label_namespace: str = "labels",
dropout: Optional[float] = None,
calculate_f1: bool = None,
positive_label: int = 1,
initializer: InitializerApplicator = InitializerApplicator(),
regularizer: Optional[RegularizerApplicator] = None) -> None:
super(AttBiLSTM, self).__init__(vocab, regularizer)
self.label_namespace = label_namespace
self.num_tags = self.vocab.get_vocab_size(label_namespace)
self.text_field_embedder = text_field_embedder
self.num_classes = self.vocab.get_vocab_size("labels")
self.encoder = encoder
self.attention_scale = math.sqrt(encoder.get_output_dim())
if dropout:
self.dropout = torch.nn.Dropout(dropout)
else:
self.dropout = None
self.classifier_feedforward = classifier_feedforward
if classifier_feedforward is not None:
output_dim = classifier_feedforward.get_output_dim()
else:
output_dim = self.encoder.get_output_dim()
self.metrics = {"accuracy": CategoricalAccuracy()}
self.loss = torch.nn.CrossEntropyLoss()
self.positive_label = positive_label
self.calculate_f1 = calculate_f1
if calculate_f1:
self._f1_metric = F1Measure(positive_label)
# check_dimensions_match(text_field_embedder.get_output_dim(), encoder.get_input_dim(),
# "text field embedding dim", "encoder input dim")
if classifier_feedforward is not None:
check_dimensions_match(encoder.get_output_dim(),
classifier_feedforward.get_input_dim(),
"encoder output dim",
"feedforward input dim")
initializer(self)
def __init__(self,
vocab: Vocabulary,
text_field_embedder: TextFieldEmbedder,
encoder: Seq2SeqEncoder,
output_logit: FeedForward,
dropout: float = 0.1,
initializer: InitializerApplicator = InitializerApplicator(),
regularizer: Optional[RegularizerApplicator] = None) -> None:
super().__init__(vocab, regularizer)
self._text_field_embedder = text_field_embedder
self._output_logit = output_logit
self._encoder = encoder
if dropout:
self.dropout = torch.nn.Dropout(dropout)
else:
self.dropout = None
if encoder:
check_dimensions_match(text_field_embedder.get_output_dim(),
encoder.get_input_dim(),
"text field embedding dim",
"encoder input dim")
check_dimensions_match(encoder.get_output_dim(),
output_logit.get_input_dim(),
"encoder output dim",
"output_logit input dim")
else:
check_dimensions_match(text_field_embedder.get_output_dim(),
output_logit.get_input_dim(),
"text field embedding dim",
"output_logit input dim")
self._accuracy = CategoricalAccuracy()
self._loss = torch.nn.CrossEntropyLoss()
initializer(self)
def __init__(self,
vocab: Vocabulary,
text_field_embedder: TextFieldEmbedder,
encoder: Seq2SeqEncoder,
similarity_function: SimilarityFunction,
projection_feedforward: FeedForward,
inference_encoder: Seq2SeqEncoder,
output_feedforward: FeedForward,
output_logit: FeedForward,
dropout: float = 0.5,
initializer: InitializerApplicator = InitializerApplicator(),
regularizer: Optional[RegularizerApplicator] = None) -> None:
super().__init__(vocab, regularizer)
self._text_field_embedder = text_field_embedder
self._encoder = encoder
self._matrix_attention = LegacyMatrixAttention(similarity_function)
self._projection_feedforward = projection_feedforward
self._inference_encoder = inference_encoder
if dropout:
self.dropout = torch.nn.Dropout(dropout)
self.rnn_input_dropout = InputVariationalDropout(dropout)
else:
self.dropout = None
self.rnn_input_dropout = None
self._output_feedforward = output_feedforward
self._num_labels = 1
check_dimensions_match(text_field_embedder.get_output_dim(),
encoder.get_input_dim(),
"text field embedding dim", "encoder input dim")
check_dimensions_match(encoder.get_output_dim() * 4,
projection_feedforward.get_input_dim(),
"encoder output dim",
"projection feedforward input")
check_dimensions_match(projection_feedforward.get_output_dim(),
inference_encoder.get_input_dim(),
"proj feedforward output dim",
"inference lstm input dim")
self._metric = PearsonCorrelation()
self._loss = torch.nn.MSELoss()
initializer(self)
def __init__(self,
vocab: Vocabulary,
text_field_embedder: TextFieldEmbedder,
span_extractor: SpanExtractor,
encoder: Seq2SeqEncoder,
feedforward_layer: FeedForward = None,
pos_tag_embedding: Embedding = None,
initializer: InitializerApplicator = InitializerApplicator(),
regularizer: Optional[RegularizerApplicator] = None,
evalb_directory_path: str = None) -> None:
super(SpanConstituencyParser, self).__init__(vocab, regularizer)
self.text_field_embedder = text_field_embedder
self.span_extractor = span_extractor
self.num_classes = self.vocab.get_vocab_size("labels")
self.encoder = encoder
self.feedforward_layer = TimeDistributed(feedforward_layer) if feedforward_layer else None
self.pos_tag_embedding = pos_tag_embedding or None
if feedforward_layer is not None:
output_dim = feedforward_layer.get_output_dim()
else:
output_dim = span_extractor.get_output_dim()
self.tag_projection_layer = TimeDistributed(Linear(output_dim, self.num_classes))
representation_dim = text_field_embedder.get_output_dim()
if pos_tag_embedding is not None:
representation_dim += pos_tag_embedding.get_output_dim()
check_dimensions_match(representation_dim,
encoder.get_input_dim(),
"representation dim (tokens + optional POS tags)",
"encoder input dim")
check_dimensions_match(encoder.get_output_dim(),
span_extractor.get_input_dim(),
"encoder input dim",
"span extractor input dim")
if feedforward_layer is not None:
check_dimensions_match(span_extractor.get_output_dim(),
feedforward_layer.get_input_dim(),
"span extractor output dim",
"feedforward input dim")
self.tag_accuracy = CategoricalAccuracy()
if evalb_directory_path is not None:
self._evalb_score = EvalbBracketingScorer(evalb_directory_path)
else:
self._evalb_score = None
initializer(self)
def __init__(self, vocab: Vocabulary,
text_field_embedder: TextFieldEmbedder,
attend_feedforward: FeedForward,
similarity_function: SimilarityFunction,
compare_feedforward: FeedForward,
aggregate_feedforward: FeedForward,
parser_model_path: str,
parser_cuda_device: int,
freeze_parser: bool,
premise_encoder: Optional[Seq2SeqEncoder] = None,
hypothesis_encoder: Optional[Seq2SeqEncoder] = None,
initializer: InitializerApplicator = InitializerApplicator(),
regularizer: Optional[RegularizerApplicator] = None) -> None:
super(SyntacticEntailment, self).__init__(vocab, regularizer)
self._text_field_embedder = text_field_embedder
self._attend_feedforward = TimeDistributed(attend_feedforward)
self._attention = LegacyMatrixAttention(similarity_function)
self._compare_feedforward = TimeDistributed(compare_feedforward)
self._aggregate_feedforward = aggregate_feedforward
self._premise_encoder = premise_encoder
self._hypothesis_encoder = hypothesis_encoder or premise_encoder
self._num_labels = vocab.get_vocab_size(namespace="labels")
check_dimensions_match(text_field_embedder.get_output_dim(),
attend_feedforward.get_input_dim(),
"text field embedding dim",
"attend feedforward input dim")
check_dimensions_match(aggregate_feedforward.get_output_dim(),
self._num_labels,
"final output dimension",
"number of labels")
self._accuracy = CategoricalAccuracy()
self._loss = torch.nn.CrossEntropyLoss()
self._parser = load_archive(parser_model_path,
cuda_device=parser_cuda_device).model
self._parser._head_sentinel.requires_grad = False
for child in self._parser.children():
for param in child.parameters():
param.requires_grad = False
if not freeze_parser:
for param in self._parser.encoder.parameters():
param.requires_grad = True
initializer(self)
def __init__(self, vocab: Vocabulary,
text_field_embedder: TextFieldEmbedder,
encoder: Seq2SeqEncoder,
similarity_function: SimilarityFunction,
projection_feedforward: FeedForward,
inference_encoder: Seq2SeqEncoder,
output_feedforward: FeedForward,
output_logit: FeedForward,
dropout: float = 0.5,
initializer: InitializerApplicator = InitializerApplicator(),
regularizer: Optional[RegularizerApplicator] = None) -> None:
super().__init__(vocab, regularizer)
self._text_field_embedder = text_field_embedder
self._encoder = encoder
self._matrix_attention = LegacyMatrixAttention(similarity_function)
self._projection_feedforward = projection_feedforward
self._inference_encoder = inference_encoder
if dropout:
self.dropout = torch.nn.Dropout(dropout)
self.rnn_input_dropout = InputVariationalDropout(dropout)
else:
self.dropout = None
self.rnn_input_dropout = None
self._output_feedforward = output_feedforward
self._output_logit = output_logit
self._num_labels = vocab.get_vocab_size(namespace="labels")
check_dimensions_match(text_field_embedder.get_output_dim(), encoder.get_input_dim(),
"text field embedding dim", "encoder input dim")
check_dimensions_match(encoder.get_output_dim() * 4, projection_feedforward.get_input_dim(),
"encoder output dim", "projection feedforward input")
check_dimensions_match(projection_feedforward.get_output_dim(), inference_encoder.get_input_dim(),
"proj feedforward output dim", "inference lstm input dim")
self._accuracy = CategoricalAccuracy()
self._loss = torch.nn.CrossEntropyLoss()
initializer(self)
