def hinge(y_true: Tensor, y_pred: Tensor) -> Tensor: """Calculate the hinge loss between two tensors. This method can be used with TensorFlow tensors: ```python true = tf.constant([[-1,1,1,-1], [1,1,1,1], [-1,-1,1,-1], [1,-1,-1,-1]]) pred = tf.constant([[0.1,0.9,0.05,0.05], [0.1,-0.2,0.0,-0.7], [0.0,0.15,0.8,0.05], [1.0,-1.0,-1.0,-1.0]]) b = fe.backend.hinge(y_pred=pred, y_true=true) # [0.8 1.2 0.85 0. ] ``` This method can be used with PyTorch tensors: ```python true = torch.tensor([[-1,1,1,-1], [1,1,1,1], [-1,-1,1,-1], [1,-1,-1,-1]]) pred = torch.tensor([[0.1,0.9,0.05,0.05], [0.1,-0.2,0.0,-0.7], [0.0,0.15,0.8,0.05], [1.0,-1.0,-1.0,-1.0]]) b = fe.backend.hinge(y_pred=pred, y_true=true) # [0.8 1.2 0.85 0. ] ``` Args: y_true: Ground truth class labels which should take values of 1 or -1. y_pred: Prediction score for each class, with a shape like y_true. dtype: float32 or float16. Returns: The hinge loss between `y_true` and `y_pred` Raises: ValueError: If `y_pred` is an unacceptable data type. """ y_true = cast(y_true, 'float32') return reduce_mean(clip_by_value(1.0 - y_true * y_pred, min_value=0), axis=-1)
def forward(self, data: List[Tensor], state: Dict[str, Any]) -> Tensor: data, loss = data grad = get_gradient(target=loss, sources=data, tape=state['tape'], retain_graph=self.retain_graph) adverse_data = clip_by_value(data + self.epsilon * sign(grad), min_value=self.clip_low or reduce_min(data), max_value=self.clip_high or reduce_max(data)) return adverse_data
def _convert_for_visualization(tensor: Tensor, tile: int = 99) -> np.ndarray: """Modify the range of data in a given input `tensor` to be appropriate for visualization. Args: tensor: Input masks, whose channel values are to be reduced by absolute value summation. tile: The percentile [0-100] used to set the max value of the image. Returns: A (batch X width X height) image after visualization clipping is applied. """ if isinstance(tensor, torch.Tensor): channel_axis = 1 else: channel_axis = -1 flattened_mask = reduce_sum(abs(tensor), axis=channel_axis, keepdims=True) non_batch_axes = list(range(len(flattened_mask.shape)))[1:] vmax = percentile(flattened_mask, tile, axis=non_batch_axes, keepdims=True) vmin = reduce_min(flattened_mask, axis=non_batch_axes, keepdims=True) return clip_by_value((flattened_mask - vmin) / (vmax - vmin), 0, 1)
def _get_patch_coordinates( tensor: Tensor, x: Tensor, y: Tensor, lam: Tensor ) -> Tuple[Tensor, Tensor, Tensor, Tensor, Tensor, Tensor]: """Randomly cut the patches from input images. If patches are going to be pasted in other image, combination ratio between two images is defined by `lam`. Cropping region indicates where to drop out from the image and `cut_x` & `cut_y` are used to calculate cropping region whose aspect ratio is proportional to the original image. Args: tensor: The input value. lam: Combination ratio between two images. Larger the lambda value is smaller the patch would be. A scalar tensor containing value between 0 and 1. x: X-coordinate in image from which patch needs to be cropped. A scalar tensor containing value between 0 and 1 which in turn is transformed in the range of image width. y: Y-coordinate in image from which patch needs to be cropped. A scalar tensor containing value between 0 and 1 which in turn is transformed in the range of image height. Returns: The X and Y coordinates of the cropped patch along with width and height. """ _, img_height, img_width = get_image_dims(tensor) cut_x = img_width * x cut_y = img_height * y cut_w = img_width * tensor_sqrt(1 - lam) cut_h = img_height * tensor_sqrt(1 - lam) bbox_x1 = cast( tensor_round(clip_by_value(cut_x - cut_w / 2, min_value=0)), "int32") bbox_x2 = cast( tensor_round(clip_by_value(cut_x + cut_w / 2, max_value=img_width)), "int32") bbox_y1 = cast( tensor_round(clip_by_value(cut_y - cut_h / 2, min_value=0)), "int32") bbox_y2 = cast( tensor_round(clip_by_value(cut_y + cut_h / 2, max_value=img_height)), "int32") return bbox_x1, bbox_x2, bbox_y1, bbox_y2, img_width, img_height