if span_start_logits.dim() != 2 or span_end_logits.dim() != 2:
raise ValueError(
u"Input shapes must be (batch_size, passage_length)")
batch_size, passage_length = span_start_logits.size()
max_span_log_prob = [-1e20] * batch_size
span_start_argmax = [0] * batch_size
best_word_span = span_start_logits.new_zeros((batch_size, 2),
dtype=torch.long)
span_start_logits = span_start_logits.detach().cpu().numpy()
span_end_logits = span_end_logits.detach().cpu().numpy()
for b in range(batch_size): # pylint: disable=invalid-name
for j in range(passage_length):
val1 = span_start_logits[b, span_start_argmax[b]]
if val1 < span_start_logits[b, j]:
span_start_argmax[b] = j
val1 = span_start_logits[b, j]
val2 = span_end_logits[b, j]
if val1 + val2 > max_span_log_prob[b]:
best_word_span[b, 0] = span_start_argmax[b]
best_word_span[b, 1] = j
max_span_log_prob[b] = val1 + val2
return best_word_span
BidirectionalAttentionFlow = Model.register(u"bidaf")(
BidirectionalAttentionFlow)
action_strings, add_var_function=False)
self._has_logical_form(1.0)
except ParsingError:
self._has_logical_form(0.0)
logical_form = u'Error producing logical form'
if example_lisp_string:
self._denotation_accuracy(logical_form,
example_lisp_string[i])
outputs[u'best_action_sequence'].append(action_strings)
outputs[u'logical_form'].append(logical_form)
outputs[u'debug_info'].append(
best_final_states[i][0].debug_info[0]) # type: ignore
outputs[u'entities'].append(world[i].table_graph.entities)
else:
outputs[u'logical_form'].append(u'')
self._has_logical_form(0.0)
if example_lisp_string:
self._denotation_accuracy(None, example_lisp_string[i])
if metadata is not None:
outputs[u"question_tokens"] = [
x[u"question_tokens"] for x in metadata
]
outputs[u"original_table"] = [
x[u"original_table"] for x in metadata
]
return outputs
WikiTablesMmlSemanticParser = Model.register(u"wikitables_mml_parser")(
WikiTablesMmlSemanticParser)
if metadata is not None:
output[u"words"] = [x[u"words"] for x in metadata]
return output
#overrides
def decode(self, output_dict):
u"""
Converts the tag ids to the actual tags.
``output_dict["tags"]`` is a list of lists of tag_ids,
so we use an ugly nested list comprehension.
"""
output_dict[u"tags"] = [[
self.vocab.get_token_from_index(tag,
namespace=self.label_namespace)
for tag in instance_tags
] for instance_tags in output_dict[u"tags"]]
return output_dict
#overrides
def get_metrics(self, reset=False):
metric_dict = self.span_metric.get_metric(reset=reset)
if self._verbose_metrics:
return metric_dict
else:
return dict((x, y) for x, y in list(metric_dict.items())
if u"overall" in x)
CrfTagger = Model.register(u"crf_tagger")(CrfTagger)
torch.cat(matching_vector_premise, dim=2))
matching_vector_cat_hypothesis = self.dropout(
torch.cat(matching_vector_hypothesis, dim=2))
# aggregate the matching vectors
aggregated_premise = self.dropout(
self.aggregator(matching_vector_cat_premise, mask_premise))
aggregated_hypothesis = self.dropout(
self.aggregator(matching_vector_cat_hypothesis, mask_hypothesis))
# the final forward layer
logits = self.classifier_feedforward(
torch.cat([aggregated_premise, aggregated_hypothesis], dim=-1))
output_dict = {u'logits': logits}
if label is not None:
loss = self.loss(logits, label)
for metric in list(self.metrics.values()):
metric(logits, label)
output_dict[u"loss"] = loss
return output_dict
#overrides
def get_metrics(self, reset=False):
return dict((metric_name, metric.get_metric(reset))
for metric_name, metric in list(self.metrics.items()))
BiMpm = Model.register(u"bimpm")(BiMpm)
u"""
Dependency evaluation excludes words are punctuation.
Here, we create a new mask to exclude word indices which
have a "punctuation-like" part of speech tag.
Parameters
----------
mask : ``torch.LongTensor``, required.
The original mask.
pos_tags : ``torch.LongTensor``, required.
The pos tags for the sequence.
Returns
-------
A new mask, where any indices equal to labels
we should be ignoring are masked.
"""
new_mask = mask.detach()
for label in self._pos_to_ignore:
label_mask = pos_tags.eq(label).long()
new_mask = new_mask * (1 - label_mask)
return new_mask
#overrides
def get_metrics(self, reset=False):
return self._attachment_scores.get_metric(reset)
BiaffineDependencyParser = Model.register(u"biaffine_parser")(
BiaffineDependencyParser)
# The logic here requires a custom from_params.
@classmethod
def from_params(cls, vocab, params): # type: ignore
# pylint: disable=arguments-differ
if vocab:
raise ConfigurationError(u"vocab should be None")
submodels = []
paths = params.pop(u"submodels")
for path in paths:
submodels.append(load_archive(path).model)
return cls(submodels=submodels)
BidafEnsemble = Model.register(u"bidaf-ensemble")(BidafEnsemble)
def ensemble(subresults):
u"""
Identifies the best prediction given the results from the submodels.
Parameters
----------
index : int
The index within this index to ensemble
subresults : List[Dict[str, torch.Tensor]]
Returns
-------
output_dict = {
u"label_logits": label_logits,
u"label_probs": label_probs,
u"h2p_attention": h2p_attention,
u"p2h_attention": p2h_attention
}
if label is not None:
loss = self._loss(label_logits, label.long().view(-1))
self._accuracy(label_logits, label)
output_dict[u"loss"] = loss
if metadata is not None:
output_dict[u"premise_tokens"] = [
x[u"premise_tokens"] for x in metadata
]
output_dict[u"hypothesis_tokens"] = [
x[u"hypothesis_tokens"] for x in metadata
]
return output_dict
def get_metrics(self, reset=False):
return {
u'accuracy': self._accuracy.get_metric(reset),
}
DecomposableAttention = Model.register(u"decomposable_attention")(
DecomposableAttention)
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)
BiattentiveClassificationNetwork = Model.register(u"bcn")(BiattentiveClassificationNetwork)
checklist_cost = self._checklist_cost_weight * checklist_cost
action_history = state.action_history[0]
batch_index = state.batch_indices[0]
action_strings = [
state.possible_actions[batch_index][i][0] for i in action_history
]
logical_form = state.world[batch_index].get_logical_form(
action_strings)
lisp_string = state.example_lisp_string[batch_index]
if self._denotation_accuracy.evaluate_logical_form(
logical_form, lisp_string):
cost = checklist_cost
else:
cost = checklist_cost + (
1 - self._checklist_cost_weight) * denotation_cost
return cost
#overrides
def get_metrics(self, reset=False):
u"""
The base class returns a dict with dpd accuracy, denotation accuracy, and logical form
percentage metrics. We add the agenda coverage metric here.
"""
metrics = super(WikiTablesErmSemanticParser, self).get_metrics(reset)
metrics[u"agenda_coverage"] = self._agenda_coverage.get_metric(reset)
return metrics
WikiTablesErmSemanticParser = Model.register(u"wikitables_erm_parser")(
WikiTablesErmSemanticParser)
is learning. It may be inefficient to call it while training the model on real data.
"""
if len(state.batch_indices) == 1 and state.is_finished():
costs = [float(self._get_state_cost(state).detach().cpu().numpy())]
else:
costs = []
model_scores = [float(score.detach().cpu().numpy()) for score in state.score]
all_actions = state.possible_actions[0]
action_sequences = [[self._get_action_string(all_actions[action]) for action in history]
for history in state.action_history]
agenda_sequences = []
all_agenda_indices = []
for agenda, checklist_target in izip(state.terminal_actions, state.checklist_target):
agenda_indices = []
for action, is_wanted in izip(agenda, checklist_target):
action_int = int(action.detach().cpu().numpy())
is_wanted_int = int(is_wanted.detach().cpu().numpy())
if is_wanted_int != 0:
agenda_indices.append(action_int)
agenda_sequences.append([self._get_action_string(all_actions[action])
for action in agenda_indices])
all_agenda_indices.append(agenda_indices)
return {u"agenda": agenda_sequences,
u"agenda_indices": all_agenda_indices,
u"history": action_sequences,
u"history_indices": state.action_history,
u"costs": costs,
u"scores": model_scores}
NlvrCoverageSemanticParser = Model.register(u"nlvr_coverage_parser")(NlvrCoverageSemanticParser)
(batch_size, num_spans_to_keep, max_antecedents).
antecedent_mention_scores: ``torch.FloatTensor``, required.
Mention scores for every antecedent. Has shape
(batch_size, num_spans_to_keep, max_antecedents).
antecedent_log_mask: ``torch.FloatTensor``, required.
The log of the mask for valid antecedents.
Returns
-------
coreference_scores: ``torch.FloatTensor``
A tensor of shape (batch_size, num_spans_to_keep, max_antecedents + 1),
representing the unormalised score for each (span, antecedent) pair
we considered.
"""
# Shape: (batch_size, num_spans_to_keep, max_antecedents)
antecedent_scores = self._antecedent_scorer(
self._antecedent_feedforward(pairwise_embeddings)).squeeze(-1)
antecedent_scores += top_span_mention_scores + antecedent_mention_scores
antecedent_scores += antecedent_log_mask
# Shape: (batch_size, num_spans_to_keep, 1)
shape = [antecedent_scores.size(0), antecedent_scores.size(1), 1]
dummy_scores = antecedent_scores.new_zeros(*shape)
# Shape: (batch_size, num_spans_to_keep, max_antecedents + 1)
coreference_scores = torch.cat([dummy_scores, antecedent_scores], -1)
return coreference_scores
CoreferenceResolver = Model.register(u"coref")(CoreferenceResolver)
"""
all_labels = self.vocab.get_index_to_token_vocabulary(u"labels")
num_labels = len(all_labels)
transition_matrix = torch.zeros([num_labels, num_labels])
for i, previous_label in list(all_labels.items()):
for j, label in list(all_labels.items()):
# I labels can only be preceded by themselves or
# their corresponding B tag.
if i != j and label[
0] == u'I' and not previous_label == u'B' + label[1:]:
transition_matrix[i, j] = float(u"-inf")
return transition_matrix
SemanticRoleLabeler = Model.register(u"srl")(SemanticRoleLabeler)
def write_to_conll_eval_file(prediction_file, gold_file, verb_index, sentence,
prediction, gold_labels):
u"""
Prints predicate argument predictions and gold labels for a single verbal
predicate in a sentence to two provided file references.
Parameters
----------
prediction_file : TextIO, required.
A file reference to print predictions to.
gold_file : TextIO, required.
A file reference to print gold labels to.
verb_index : Optional[int], required.
from allennlp.training import Trainer
from allennlp.models.model import Model
from allennlp.common.params import Params
from allennlp.commands import fine_tune
from mtl.models.ABSASharedNetwork import ABSASharedNetwork
from mtl.dataset_readers.ABSADatasetReader import ABSADatasetReader
from mtl.dataset_readers.ACSADatasetReader import ACSADatasetReader
config = Params.from_file(os.path.join('checkpoint5', 'config.json'))
# print(config.get('model'))
# config.loading_from_archive = True
weights_path = os.path.join('checkpoint5', 'best.th')
Model.register('absa')
model = ABSASharedNetwork._load(config.duplicate(),
weights_file=weights_path,
serialization_dir='checkpoint5',
cuda_device=0)
def fine_tune(args):
source_model = model.to(args.device)
discriminator = nn.Sequential(nn.Linear(200, 50), nn.ReLU(),
nn.Linear(50, 1)).to(args.device)
source_reader = ACSADatasetReader(max_sequence_len=args.max_seq_len)
target_reader = ABSADatasetReader(max_sequence_len=args.max_seq_len)
u"""
Does a simple position-wise argmax over each token, converts indices to string labels, and
adds a ``"tags"`` key to the dictionary with the result.
"""
all_predictions = output_dict[u'class_probabilities']
all_predictions = all_predictions.cpu().data.numpy()
if all_predictions.ndim == 3:
predictions_list = [
all_predictions[i] for i in range(all_predictions.shape[0])
]
else:
predictions_list = [all_predictions]
all_tags = []
for predictions in predictions_list:
argmax_indices = numpy.argmax(predictions, axis=-1)
tags = [
self.vocab.get_token_from_index(x, namespace=u"labels")
for x in argmax_indices
]
all_tags.append(tags)
output_dict[u'tags'] = all_tags
return output_dict
#overrides
def get_metrics(self, reset=False):
return dict((metric_name, metric.get_metric(reset))
for metric_name, metric in list(self.metrics.items()))
SimpleTagger = Model.register(u"simple_tagger")(SimpleTagger)
# the left hand side is a constituent.
for split in range(end - 1, start, -1):
if (start, split) in spans_to_labels:
argmax_split = split
break
left_trees = assemble_subtree(start, argmax_split)
right_trees = assemble_subtree(argmax_split, end)
children = left_trees + right_trees
if labels is not None:
while labels:
children = [Tree(labels.pop(), children)]
return children
tree = assemble_subtree(0, len(sentence))
return tree[0]
#overrides
def get_metrics(self, reset=False):
all_metrics = {}
all_metrics[u"tag_accuracy"] = self.tag_accuracy.get_metric(
reset=reset)
if self._evalb_score is not None:
evalb_metrics = self._evalb_score.get_metric(reset=reset)
all_metrics.update(evalb_metrics)
return all_metrics
SpanConstituencyParser = Model.register(u"constituency_parser")(
SpanConstituencyParser)
#overrides
def decode(self, output_dict):
u"""
This method overrides ``Model.decode``, which gets called after ``Model.forward``, at test
time, to finalize predictions. The logic for the decoder part of the encoder-decoder lives
within the ``forward`` method.
This method trims the output predictions to the first end symbol, replaces indices with
corresponding tokens, and adds a field called ``predicted_tokens`` to the ``output_dict``.
"""
predicted_indices = output_dict[u"predictions"]
if not isinstance(predicted_indices, numpy.ndarray):
predicted_indices = predicted_indices.detach().cpu().numpy()
all_predicted_tokens = []
for indices in predicted_indices:
indices = list(indices)
# Collect indices till the first end_symbol
if self._end_index in indices:
indices = indices[:indices.index(self._end_index)]
predicted_tokens = [
self.vocab.get_token_from_index(
x, namespace=self._target_namespace) for x in indices
]
all_predicted_tokens.append(predicted_tokens)
output_dict[u"predicted_tokens"] = all_predicted_tokens
return output_dict
SimpleSeq2Seq = Model.register(u"simple_seq2seq")(SimpleSeq2Seq)
classes = []
for prediction in predictions_list:
label_idx = prediction.argmax(dim=-1).item()
label_str = self.vocab.get_index_to_token_vocabulary(
self._label_namespace).get(label_idx, str(label_idx))
classes.append(label_str)
output_dict["label"] = classes
tokens = []
for instance_tokens in output_dict["token_ids"]:
tokens.append([
self.vocab.get_token_from_index(token_id.item(),
namespace=self._namespace)
for token_id in instance_tokens
])
output_dict["tokens"] = tokens
return output_dict
def load_state_dict(self,
state_dict: Union[Dict[str, torch.Tensor],
Dict[str, torch.Tensor]],
strict: bool = False):
return super().load_state_dict(state_dict, strict=strict)
default_predictor = "glue-numeric"
Model.register("arp_classifier",
constructor="from_partial_objects")(ArpClassifier)
Model.register("warp_classifier",
constructor="from_partial_objects")(ArpClassifier)
def _update_metrics(self, action_strings, worlds, label_strings):
# TODO(pradeep): Move this to the base class.
# TODO(pradeep): Using only the best decoded sequence. Define metrics for top-k sequences?
batch_size = len(worlds)
for i in range(batch_size):
instance_action_strings = action_strings[i]
sequence_is_correct = [False]
if instance_action_strings:
instance_label_strings = label_strings[i]
instance_worlds = worlds[i]
# Taking only the best sequence.
sequence_is_correct = self._check_denotation(
instance_action_strings[0], instance_label_strings,
instance_worlds)
for correct_in_world in sequence_is_correct:
self._denotation_accuracy(1 if correct_in_world else 0)
self._consistency(1 if all(sequence_is_correct) else 0)
#overrides
def get_metrics(self, reset=False):
return {
u'denotation_accuracy':
self._denotation_accuracy.get_metric(reset),
u'consistency': self._consistency.get_metric(reset)
}
NlvrDirectSemanticParser = Model.register(u"nlvr_direct_parser")(
NlvrDirectSemanticParser)