def forward(self, y_logits: torch.Tensor, y_target: torch.Tensor) -> torch.Tensor: """ logsoftmax+nll :param y_logits: NCHW logits :param y_target: NCHW one-hot encoded label :return: cross_entropy loss """ return F.cross_entropy(y_logits, y_target.argmax(1), reduction=self.reduction, weight=self.weight)
def _obtain_labels_( self, score_arc: torch.Tensor, score_rel: torch.Tensor ) -> Tuple[List[List[int]], List[List[str]]]: arc_prediction: torch.Tensor = score_arc.argmax(-1) relation_prediction: torch.Tensor = score_rel.argmax(-1) relation_prediction = relation_prediction.gather(-1, arc_prediction.unsqueeze(-1)).squeeze(-1) decoded_arc_prediction = [ [arc + 1 if token_index != arc else 0 for token_index, arc in enumerate(batch)] for batch in arc_prediction ] decoded_relation_prediction = [ [self.relations_dictionary.get_item_for_index(rel_tag_idx) for rel_tag_idx in batch] for batch in relation_prediction ] return decoded_arc_prediction, decoded_relation_prediction
def log_prob(self, scores: torch.Tensor, action: torch.Tensor) -> torch.Tensor: greedy_indices = self._get_greedy_indices(scores) # pyre-fixme[16]: `Tensor` has no attribute `argmax`. match = greedy_indices == action.argmax(-1) lp = torch.zeros(scores.shape[0]).float() lp[match] = -float("inf") return lp
def compute_guessed(logits: Tensor, targets: Tensor, to_device='cpu') -> Tensor: assert logits.ndim == 2 assert targets.ndim == 1 assert len(logits) == len(targets) return (logits.argmax(dim=1) == targets).float().detach().to(to_device)
def log_prob(self, scores: torch.Tensor, action: torch.Tensor) -> torch.Tensor: max_index = self.sample_action(scores).argmax(-1) opt = max_index == action.argmax(-1) n = len(scores) lp = torch.ones(n) * self.epsilon / n lp[opt] = 1 - self.epsilon + self.epsilon / n return lp
def accuracy_rate(predictions: torch.Tensor, labels: torch.Tensor) -> float: """Return the accuracy rate based on dense predictions and sparse labels.""" assert len(predictions) == len(labels), "Predictions and labels must have the same length." assert len(labels.shape) == 1, "Labels must be a column vector." return ( # type: ignore float((predictions.argmax(1) == labels.to(torch.long)).sum()) / predictions.shape[0] )
def loss(self, cls_logits: torch.Tensor, gt_labels: torch.Tensor): losses = dict() cls_logits = cls_logits.view(-1, self.class_num) batch_size = cls_logits.size(0) cls_preds = cls_logits.argmax(dim=1) losses['loss_cls'] = F.cross_entropy(cls_logits, gt_labels.view(-1)) losses['accuracy'] = (cls_preds.eq(gt_labels.view(-1))).float().sum() / batch_size return losses
def probs2class(probs: Tensor) -> Tensor: b, _, *img_shape = probs.shape assert simplex(probs) res = probs.argmax(dim=1) assert res.shape == (b, *img_shape) return res
def forward(self, pred: T, y: T): if self.multiclass: assert len(pred.shape) == 2 pred = pred.argmax(dim=1) else: assert len(pred.shape) == 1 pred = pred > 0 return self.metric(pred.long(), y.long())
def error_rate(predictions: torch.Tensor, labels: torch.Tensor) -> float: """Return the error rate based on dense predictions and dense labels.""" check.equal_lengths(predictions, labels) check.len_eq(labels.shape, 1, "Labels must be a column vector") return ( # type: ignore 1.0 - float((predictions.argmax(1) == labels.to(torch.long)).sum()) / predictions.shape[0])
def forward(self, x: torch.Tensor) -> torch.Tensor: indexes = x.argmax(dim=self.index_dim) indexes = indexes.type(torch.int64).view(-1, 1) n_dims = self.n_dims # if self.n_dims is not None else int(torch.max(indexes)) + 1 one_hots = torch.zeros(indexes.size()[0], n_dims).scatter_(1, indexes, 1) one_hots = one_hots.view(*indexes.shape, -1) return one_hots
def compute(self, prediction: Tensor, target: Tensor): prediction = prediction.argmax(1) correct = (prediction == target).prod(axis=1) total = correct.shape[0] correct = correct.sum() return correct, total
def log_prob(self, scores: torch.Tensor, action: torch.Tensor) -> torch.Tensor: max_index = self.sample_action(scores).argmax(-1) # pyre-fixme[16]: `Tensor` has no attribute `argmax`. opt = max_index == action.argmax(-1) n = len(scores) lp = torch.ones(n) * self.epsilon / n lp[opt] = 1 - self.epsilon + self.epsilon / n return lp
def probs2class(probs: Tensor) -> Tensor: b, _, w, h = probs.shape # type: Tuple[int, int, int, int] assert simplex(probs) res = probs.argmax(dim=1) assert res.shape == (b, w, h) return res
def losses(self, pred_scores: torch.Tensor, pred_deltas: torch.Tensor, proposals: List[Instances]) -> Dict[torch.Tensor, torch.Tensor]: gt_boxes = Boxes.cat([p.gt_boxes for p in proposals]) gt_classes = torch.cat([p.gt_classes for p in proposals], dim=0) proposal_boxes = Boxes.cat([p.proposal_boxes for p in proposals]) num_instances = gt_classes.numel() valid_idxs = gt_classes >= 0 foreground_idxs = torch.nonzero( (gt_classes >= 0) & (gt_classes != self.num_classes), as_tuple=True)[0] pred_classes = pred_scores.argmax(dim=1) fg_gt_classes = gt_classes[foreground_idxs] fg_pred_classes = pred_classes[foreground_idxs] num_foreground = foreground_idxs.numel() num_false_negative = ( fg_pred_classes == self.num_classes).nonzero().numel() num_accurate = (pred_classes == gt_classes).nonzero().numel() fg_num_accurate = (fg_pred_classes == fg_gt_classes).nonzero().numel() storage = get_event_storage() if num_instances > 0: storage.put_scalar("roi_head/cls_accuracy", num_accurate / num_instances) if num_foreground > 0: storage.put_scalar("roi_head/fg_cls_accuracy", fg_num_accurate / num_foreground) storage.put_scalar("roi_head/false_negative", num_false_negative / num_foreground) if len(proposals) == 0: loss_cls = 0.0 * pred_scores.sum() loss_loc = 0.0 * pred_deltas.sum() else: loss_cls = F.cross_entropy(pred_scores, gt_classes, reduction="mean") gt_proposal_deltas = self.box2box_transform.get_deltas( proposal_boxes.tensor, gt_boxes.tensor) box_dim = gt_boxes.tensor.size(1) fg_gt_classes = gt_classes[foreground_idxs] gt_class_cols = box_dim * fg_gt_classes[:, None] + torch.arange( box_dim, device=pred_deltas.device) loss_loc = smooth_l1_loss( pred_deltas[foreground_idxs[:, None], gt_class_cols], gt_proposal_deltas[foreground_idxs], self.smooth_l1_beta, reduction="sum", ) / gt_classes.numel() loss_cls *= self.loss_weight.get('loss_cls', 1.0) loss_loc *= self.loss_weight.get('loss_loc', 1.0) return {"loss_cls": loss_cls, "loss_loc": loss_loc}
def Test_is_equal_label(label_OneHot, output: t.Tensor, backdoor_idx): """根据output 检查label是否已经发生了改变""" label_backdoor_OneHot = np.where(label_OneHot[backdoor_idx])[0][0] target_label = output.argmax().item() # print("后门label为{},目标label为{}".format(label_backdoor_OneHot, target_label)) if label_backdoor_OneHot == target_label: return True else: return False
def __call__(self, output: torch.Tensor, target: torch.Tensor): output = output.view(-1, output.shape[-1]) target = target.view(-1) pred = output.argmax(dim=-1) mask = target == self.ignore_index pred.masked_fill_(mask, self.ignore_index) n_masked = mask.sum().item() self.data.correct += pred.eq(target).sum().item() - n_masked self.data.samples += len(target) - n_masked
def score_per_class(outputs: torch.Tensor, target, n_classes) -> torch.Tensor: pred = outputs.argmax(dim=2).t() correct = pred.eq(target.view(1, -1).expand_as(pred)).t() scores = [torch.zeros(outputs.size()[1], device=correct.device)] * n_classes for corr, expected in zip(correct, target): # if all values are true we point no one if not corr.all().data.item(): scores[expected] = scores[expected] + corr.float() return torch.stack(scores, dim=1, out=None)
def score_per_model(outputs: torch.Tensor, target) -> torch.Tensor: pred = outputs.argmax(dim=2).t() correct = pred.eq(target.view(1, -1).expand_as(pred)).t() scores = [torch.zeros(outputs.size()[1], device=correct.device)] for row in correct: # if all values are true we point no one if not row.all().data.item(): scores.append(row.float()) return torch.vstack(scores, out=None).sum(dim=0)
def forward(self, input: torch.Tensor, target: torch.Tensor): """ :param input: [B, T, V] :param target: [B, T] :return: """ input = input.softmax(-1) categorical_input = input.argmax(-1) return super().forward(categorical_input, target)
def compute(self, prediction: Tensor, target: Tensor): prediction = prediction.argmax(1) pred_seq_len = (prediction != self._pad).sum(axis=1) target_seq_len = (target != self._pad).sum(axis=1) matches = torch.eq(pred_seq_len, target_seq_len) correct = matches.int().sum() total = matches.shape[0] return correct, total
def trim_attention_matrices( attention_matrices: List[torch.Tensor], stop_tokens: torch.Tensor, ) -> List[List[torch.Tensor]]: stop_indexes = stop_tokens.argmax(dim=1) result = [] for i, stop_index in enumerate(stop_indexes): result.append([matrix[i, :stop_index, :] for matrix in attention_matrices]) return result
def get_accuracy(outputs: torch.Tensor, labels: torch.Tensor) -> float: """ Method to calculate accuracy of predicted outputs vs ground truth labels. :param outputs: torch.Tensor, predicted outputs classes :param labels: torch.Tensor, ground truth labels classes :return: float, accuracy of the predicted outputs vs the ground truth labels """ return (outputs.argmax(dim=1) == labels).sum().item() / labels.shape[0]
def loss(self, y_hat: torch.Tensor, y: torch.Tensor) -> torch.Tensor: try: loss = self.loss_fn(y_hat, y.argmax(dim=1)) except BaseException as e: print(f'_SoftmaxHead: y_hat: {y_hat}, y: {y}') raise e if self.loss_reducer_fn is not None: loss = self.loss_reducer_fn(loss) return loss
def draw_segmentation_masks( image: torch.Tensor, masks: torch.Tensor, alpha: float = 0.2, colors: Optional[List[Union[str, Tuple[int, int, int]]]] = None, ) -> torch.Tensor: """ Draws segmentation masks on given RGB image. The values of the input image should be uint8 between 0 and 255. Args: image (Tensor): Tensor of shape (3 x H x W) and dtype uint8. masks (Tensor): Tensor of shape (num_masks, H, W). Each containing probability of predicted class. alpha (float): Float number between 0 and 1 denoting factor of transpaerency of masks. colors (List[Union[str, Tuple[int, int, int]]]): List containing the colors of masks. The colors can be represented as `str` or `Tuple[int, int, int]`. """ if not isinstance(image, torch.Tensor): raise TypeError(f"Tensor expected, got {type(image)}") elif image.dtype != torch.uint8: raise ValueError(f"Tensor uint8 expected, got {image.dtype}") elif image.dim() != 3: raise ValueError("Pass individual images, not batches") elif image.size()[0] != 3: raise ValueError( "Pass an RGB image. Other Image formats are not supported") num_masks = masks.size()[0] masks = masks.argmax(0) if colors is None: palette = torch.tensor([2**25 - 1, 2**15 - 1, 2**21 - 1]) colors_t = torch.as_tensor([i for i in range(num_masks) ])[:, None] * palette color_arr = (colors_t % 255).numpy().astype("uint8") else: color_list = [] for color in colors: if isinstance(color, str): # This will automatically raise Error if rgb cannot be parsed. fill_color = ImageColor.getrgb(color) color_list.append(fill_color) elif isinstance(color, tuple): color_list.append(color) color_arr = np.array(color_list).astype("uint8") _, h, w = image.size() img_to_draw = Image.fromarray(masks.byte().cpu().numpy()).resize((w, h)) img_to_draw.putpalette(color_arr) img_to_draw = torch.from_numpy(np.array(img_to_draw.convert('RGB'))) img_to_draw = img_to_draw.permute((2, 0, 1)) return (image.float() * alpha + img_to_draw.float() * (1.0 - alpha)).to(dtype=torch.uint8)
def accuracy(y_true: torch.Tensor, y_pred: torch.Tensor) -> float: """Calculates categorical accuracy. # Arguments: y_true: Ground truth categories. Must have shape [batch_size,] y_pred: Prediction probabilities or logits of shape [batch_size, num_categories] """ return torch.eq(y_pred.argmax(dim=-1), y_true).sum().item() / y_pred.shape[0]
def decode_actions( node_logits: torch.Tensor, parent_label_logits: torch.Tensor, new_label_logits: torch.Tensor, label_vocab: List[Label], ) -> List[Any]: """ Decode the most likely actions from action logits for the attach-juxtapose transition system """ batch_size = node_logits.size(0) node_idx = node_logits.argmax(dim=-1) parent_label_idx = parent_label_logits.argmax(dim=-1) new_label_idx = new_label_logits.argmax(dim=-1) if node_logits.dim() == 2: # decode actions for only the current time step return [ Action( "attach" if label_vocab[new_label] == DUMMY_LABEL else "juxtapose", target_node, label_vocab[parent_label], label_vocab[new_label], ) for target_node, parent_label, new_label in zip( node_idx.tolist(), parent_label_idx.tolist(), new_label_idx.tolist()) ] else: # decode actions for all time steps max_len = node_idx.size(1) return [ [ Action( "attach" if label_vocab[new_label_idx[i, j].item()] == DUMMY_LABEL # type: ignore else "juxtapose", target_node=node_idx[i, j].item(), # type: ignore parent_label=label_vocab[parent_label_idx[ i, j]], # type: ignore new_label=label_vocab[new_label_idx[i, j]], # type: ignore ) for j in range(max_len) ] for i in range(batch_size) ]
def _decode_deprels( logits_deprel: torch.Tensor, trees: torch.Tensor, root: int = 0 ) -> torch.Tensor: steps = torch.arange(trees.size(1)) logits_deprel = [logits_deprel[i, steps, heads] for i, heads in enumerate(trees)] logits_deprel = torch.stack(logits_deprel, dim=0) logits_deprel[:, :, root] = -float("inf") deprels = logits_deprel.argmax(dim=2).detach().cpu() deprels.masked_fill_(trees == 0, root) return deprels
def _extremity_game_target_function( context: torch.Tensor, function_selectors: torch.Tensor) -> torch.Tensor: func_idxs = function_selectors.argmax(dim=1) func_min_or_max = func_idxs % 2 param_idxs = func_idxs // 2 min_obj_per_param = context.argmin(dim=1) max_obj_per_param = context.argmax(dim=1) targets = [] for batch in range(context.shape[0]): if func_min_or_max[batch] == 0: targets.append( context[batch, min_obj_per_param[batch][param_idxs[batch]]]) else: targets.append( context[batch, max_obj_per_param[batch][param_idxs[batch]]]) return torch.stack(targets)
def get_accuracy_with_logits(y_true: torch.Tensor, y_pred: torch.Tensor) -> float: """ Calculate accuracy with logits :param y_true: torch.Tensor of ints containing true labels. shape = (N,) :param y_pred: torch.Tensor of predicted logits. shape = (N, N_classes) :return acc: float which equals to accuracy score """ return (y_true == y_pred.argmax(dim=1)).float().mean().item()