def sequence_tagging(self, tokens: torch.LongTensor, head: str):
tokens = tokens[:-1].view(-1, 1)
src_lengths = torch.LongTensor([tokens.numel()]).view(-1, 1)
r = self.models[0].decode(tokens,
tagging_head_name=head,
src_lengths=src_lengths)
return r
def _build_sample(self, src_tokens: torch.LongTensor):
assert torch.is_tensor(src_tokens)
dataset = self.task.build_dataset_for_inference([src_tokens],
[src_tokens.numel()])
sample = dataset.collater([dataset[0]])
sample = utils.apply_to_sample(lambda tensor: tensor.to(self.device),
sample)
return sample
def compute_parse_stats(
lmask: Tensor,
mapped_target_labels: LongTensor,
target_spans: LongTensor,
ntargets: LongTensor,
ignore_idxs: List[int] = [0, 1],
):
# assumes target_spans are (nseqs, 2, nspans) and leaf_idx is shifted
pad_val = -1
npred, ngold = 0, 0
ncorrect_lbls, ncorrect_spans = 0, 0
for seq_idx in range(ntargets.numel()):
seq_ntargets = ntargets[seq_idx]
seq_targets = mapped_target_labels[seq_idx, :seq_ntargets]
seq_tgt_ii = target_spans[seq_idx, 0, :seq_ntargets]
seq_tgt_jj = target_spans[seq_idx, 1, :seq_ntargets]
nrows, ncols = seq_tgt_ii.max() + 1, seq_tgt_jj.max() + 1
tgt_chart = seq_targets.new_full((nrows, ncols),
fill_value=pad_val,
dtype=torch.long)
tgt_chart[seq_tgt_ii, seq_tgt_jj] = seq_targets
lchart = lmask[seq_idx, :nrows, :ncols, :].max(dim=-1)[1]
tgt_mask = tgt_chart.ne(pad_val)
pred_mask = lmask[seq_idx, :nrows, :ncols, :].any(dim=-1).bool()
for ignore_idx in ignore_idxs or []:
tgt_mask *= tgt_chart.ne(ignore_idx)
pred_mask *= lchart.ne(ignore_idx)
# equivalent to: (is_target and is_predicted and is_same_label)
ncorrect_lbls += ((lchart == tgt_chart) * tgt_mask * pred_mask).sum()
npred += pred_mask.sum()
ngold += tgt_mask.sum()
ncorrect_spans += (tgt_mask * pred_mask).sum()
return ParseStats(
ncorrect=ncorrect_lbls.item(),
ncorrect_spans=ncorrect_spans.item(),
npred=npred.item(),
ngold=ngold.item(),
)
def forward(self, ids: torch.LongTensor) -> torch.Tensor:
"""
Receives the indices of a set of samples, and returns the precomputed predictions of those samples
:param ids: Index of samples in the dataset
:return: Predictions of the classifier for those indices
"""
metadata = read_pickle(self.path)
time_batch_128 = metadata['metrics']['time']
if self.split == Split.TRAIN:
precomputed_pred = metadata['train']['logits']
elif self.split == Split.TEST:
precomputed_pred = metadata['test']['logits']
else:
precomputed_pred = metadata['val']['logits']
precomputed_pred = torch.from_numpy(precomputed_pred)
self.update_processing_time(ids.numel() * time_batch_128 / 128.0)
self.predictions = precomputed_pred[ids].to(ids.device)
return self.predictions
def forward(self,
indices: torch.LongTensor,
offsets: Optional[torch.LongTensor] = None,
per_index_weights: Optional[torch.Tensor] = None):
"""
Forward process to the embedding bag layer.
:param indices: Tensor containing bags of indices into the embedding matrix.
:param offsets: Only used when indices is 1D. offsets determines the starting index position of each bag
(sequence)in input.
:param per_index_weights: a tensor of float / double weights, or None to indicate all weights should be taken to
be 1. If specified, per_sample_weights must have exactly the same shape as input and is treated as having the
same offsets, if those are not None.
:return: an #bag x embedding_dim Tensor.
"""
# always move indices to cpu, as we need to get its corresponding minhash values from table in memory
indices = indices.cpu()
# Check input validation.
if per_index_weights is not None and indices.size() != per_index_weights.size():
raise ValueError("embedding_bag: If per_index_weights ({}) is not None, "
"then it must have the same shape as the indices ({})"
.format(per_index_weights.shape, indices.shape))
if indices.dim() == 2:
if offsets is not None:
raise ValueError("if input is 2D, then offsets has to be None"
", as input is treated is a mini-batch of"
" fixed length sequences. However, found "
"offsets of type {}".format(type(offsets)))
offsets = torch.arange(0, indices.numel(), indices.size(1), dtype=torch.long, device=indices.device)
indices = indices.reshape(-1)
if per_index_weights is not None:
per_sample_weights = per_index_weights.reshape(-1)
elif indices.dim() == 1:
if offsets is None:
raise ValueError("offsets has to be a 1D Tensor but got None")
if offsets.dim() != 1:
raise ValueError("offsets has to be a 1D Tensor")
else:
ValueError("input has to be 1D or 2D Tensor,"
" but got Tensor of dimension {}".format(input.dim()))
num_bags = offsets.size(0)
# get the min-hash for each category value, note that lsh_weight_index is in cpu memory
lsh_weight_index = self._minhash_table[indices]
# print("In forward: ", lsh_weight_index, indices, self._minhash_table[indices], self.lsh_weight_size)
# move the min-hash values to target device
lsh_weight_index = lsh_weight_index.to(self.hashed_weight.device)
lsh_weight_index %= self.lsh_weight_size
# indices_embedding_vector is a |indices| x |embedding_dim| tensor.
indices_embedding_vectors = self.hashed_weight[lsh_weight_index]
# print('indices_embedding_vectors: ', lsh_weight_index, indices_embedding_vectors)
# multiply embedding vectors by weights
if per_index_weights is not None:
per_index_weights = per_index_weights.to(indices_embedding_vectors.device)
indices_embedding_vectors *= per_index_weights[:, None]
# print("per_index_weights",per_index_weights)
offsets2bag = make_offset2bag(offsets, indices)
# print("offsets2bag: ", offsets2bag)
if self._mode == "sum" or self._mode == "mean":
result = \
torch.zeros(num_bags, self.embedding_dim, dtype=indices_embedding_vectors.dtype,
device=self.hashed_weight.device)
result.index_add_(0, offsets2bag, indices_embedding_vectors)
if self._mode == "sum":
return result
# self._mode == "mean":
bag_size = make_bag_size(offsets, indices).to(result.device)
result /= bag_size[:, None]
return result
