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