Revert D36324783 for torchvision

Reviewed By: datumbox

Differential Revision: D36413353

fbshipit-source-id: 57a1e27fa08eb7699695feb999ef9e6843524586

Author: NicolasHug

references/optical_flow/utils.py

@@ -158,7 +158,7 @@ def log_every(self, iterable, print_freq=5, header=None):
 def compute_metrics(flow_pred, flow_gt, valid_flow_mask=None):
 
     epe = ((flow_pred - flow_gt) ** 2).sum(dim=1).sqrt()
-    flow_norm = (flow_gt**2).sum(dim=1).sqrt()
+    flow_norm = (flow_gt ** 2).sum(dim=1).sqrt()
 
     if valid_flow_mask is not None:
         epe = epe[valid_flow_mask]
@@ -183,7 +183,7 @@ def sequence_loss(flow_preds, flow_gt, valid_flow_mask, gamma=0.8, max_flow=400)
         raise ValueError(f"Gamma should be < 1, got {gamma}.")
 
     # exlude invalid pixels and extremely large diplacements
-    flow_norm = torch.sum(flow_gt**2, dim=1).sqrt()
+    flow_norm = torch.sum(flow_gt ** 2, dim=1).sqrt()
     valid_flow_mask = valid_flow_mask & (flow_norm < max_flow)
 
     valid_flow_mask = valid_flow_mask[:, None, :, :]

references/segmentation/utils.py

@@ -75,7 +75,7 @@ def update(self, a, b):
         with torch.inference_mode():
             k = (a >= 0) & (a < n)
             inds = n * a[k].to(torch.int64) + b[k]
-            self.mat += torch.bincount(inds, minlength=n**2).reshape(n, n)
+            self.mat += torch.bincount(inds, minlength=n ** 2).reshape(n, n)
 
     def reset(self):
         self.mat.zero_()

test/test_image.py

@@ -168,7 +168,7 @@ def test_decode_png(img_path, pil_mode, mode):
         img_lpng = _read_png_16(img_path, mode=mode)
         assert img_lpng.dtype == torch.int32
         # PIL converts 16 bits pngs in uint8
-        img_lpng = torch.round(img_lpng / (2**16 - 1) * 255).to(torch.uint8)
+        img_lpng = torch.round(img_lpng / (2 ** 16 - 1) * 255).to(torch.uint8)
     else:
         data = read_file(img_path)
         img_lpng = decode_image(data, mode=mode)

test/test_models_detection_negative_samples.py

@@ -60,7 +60,7 @@ def test_assign_targets_to_proposals(self):
 
         resolution = box_roi_pool.output_size[0]
         representation_size = 1024
-        box_head = TwoMLPHead(4 * resolution**2, representation_size)
+        box_head = TwoMLPHead(4 * resolution ** 2, representation_size)
 
         representation_size = 1024
         box_predictor = FastRCNNPredictor(representation_size, 2)

test/test_onnx.py

@@ -265,7 +265,7 @@ def _init_test_roi_heads_faster_rcnn(self):
 
         resolution = box_roi_pool.output_size[0]
         representation_size = 1024
-        box_head = TwoMLPHead(out_channels * resolution**2, representation_size)
+        box_head = TwoMLPHead(out_channels * resolution ** 2, representation_size)
 
         representation_size = 1024
         box_predictor = FastRCNNPredictor(representation_size, num_classes)

test/test_ops.py

@@ -79,7 +79,7 @@ def test_forward(self, device, contiguous, x_dtype=None, rois_dtype=None, **kwar
         rois_dtype = self.dtype if rois_dtype is None else rois_dtype
         pool_size = 5
         # n_channels % (pool_size ** 2) == 0 required for PS opeartions.
-        n_channels = 2 * (pool_size**2)
+        n_channels = 2 * (pool_size ** 2)
         x = torch.rand(2, n_channels, 10, 10, dtype=x_dtype, device=device)
         if not contiguous:
             x = x.permute(0, 1, 3, 2)
@@ -115,7 +115,7 @@ def test_is_leaf_node(self, device):
     def test_backward(self, seed, device, contiguous):
         torch.random.manual_seed(seed)
         pool_size = 2
-        x = torch.rand(1, 2 * (pool_size**2), 5, 5, dtype=self.dtype, device=device, requires_grad=True)
+        x = torch.rand(1, 2 * (pool_size ** 2), 5, 5, dtype=self.dtype, device=device, requires_grad=True)
         if not contiguous:
             x = x.permute(0, 1, 3, 2)
         rois = torch.tensor(

test/test_utils.py

@@ -45,8 +45,8 @@ def test_normalize_in_make_grid():
 
     # Rounding the result to one decimal for comparison
     n_digits = 1
-    rounded_grid_max = torch.round(grid_max * 10**n_digits) / (10**n_digits)
-    rounded_grid_min = torch.round(grid_min * 10**n_digits) / (10**n_digits)
+    rounded_grid_max = torch.round(grid_max * 10 ** n_digits) / (10 ** n_digits)
+    rounded_grid_min = torch.round(grid_min * 10 ** n_digits) / (10 ** n_digits)
 
     assert_equal(norm_max, rounded_grid_max, msg="Normalized max is not equal to 1")
     assert_equal(norm_min, rounded_grid_min, msg="Normalized min is not equal to 0")

torchvision/datasets/_optical_flow.py

@@ -467,7 +467,7 @@ def _read_16bits_png_with_flow_and_valid_mask(file_name):
 
     flow_and_valid = _read_png_16(file_name).to(torch.float32)
     flow, valid_flow_mask = flow_and_valid[:2, :, :], flow_and_valid[2, :, :]
-    flow = (flow - 2**15) / 64  # This conversion is explained somewhere on the kitti archive
+    flow = (flow - 2 ** 15) / 64  # This conversion is explained somewhere on the kitti archive
     valid_flow_mask = valid_flow_mask.bool()
 
     # For consistency with other datasets, we convert to numpy

torchvision/extension.py

@@ -23,6 +23,7 @@ def _has_ops():
     def _has_ops():  # noqa: F811
         return True
 
+
 except (ImportError, OSError):
     pass
 

torchvision/io/video.py

@@ -176,9 +176,9 @@ def _read_from_stream(
             # can't use regex directly because of some weird characters sometimes...
             pos = extradata.find(b"DivX")
             d = extradata[pos:]
-            o = re.search(rb"DivX(\d+)Build(\d+)(\w)", d)
+            o = re.search(br"DivX(\d+)Build(\d+)(\w)", d)
             if o is None:
-                o = re.search(rb"DivX(\d+)b(\d+)(\w)", d)
+                o = re.search(br"DivX(\d+)b(\d+)(\w)", d)
             if o is not None:
                 should_buffer = o.group(3) == b"p"
     seek_offset = start_offset

torchvision/io/video_reader.py

@@ -17,6 +17,7 @@
     def _has_video_opt() -> bool:
         return True
 
+
 else:
 
     def _has_video_opt() -> bool:

torchvision/models/detection/faster_rcnn.py

@@ -250,7 +250,7 @@ def __init__(
         if box_head is None:
             resolution = box_roi_pool.output_size[0]
             representation_size = 1024
-            box_head = TwoMLPHead(out_channels * resolution**2, representation_size)
+            box_head = TwoMLPHead(out_channels * resolution ** 2, representation_size)
 
         if box_predictor is None:
             representation_size = 1024

torchvision/models/detection/rpn.py

@@ -322,12 +322,15 @@ def compute_loss(
         labels = torch.cat(labels, dim=0)
         regression_targets = torch.cat(regression_targets, dim=0)
 
-        box_loss = F.smooth_l1_loss(
-            pred_bbox_deltas[sampled_pos_inds],
-            regression_targets[sampled_pos_inds],
-            beta=1 / 9,
-            reduction="sum",
-        ) / (sampled_inds.numel())
+        box_loss = (
+            F.smooth_l1_loss(
+                pred_bbox_deltas[sampled_pos_inds],
+                regression_targets[sampled_pos_inds],
+                beta=1 / 9,
+                reduction="sum",
+            )
+            / (sampled_inds.numel())
+        )
 
         objectness_loss = F.binary_cross_entropy_with_logits(objectness[sampled_inds], labels[sampled_inds])
 

torchvision/models/swin_transformer.py

@@ -326,7 +326,7 @@ def __init__(
         # build SwinTransformer blocks
         for i_stage in range(len(depths)):
             stage: List[nn.Module] = []
-            dim = embed_dim * 2**i_stage
+            dim = embed_dim * 2 ** i_stage
             for i_layer in range(depths[i_stage]):
                 # adjust stochastic depth probability based on the depth of the stage block
                 sd_prob = stochastic_depth_prob * float(stage_block_id) / (total_stage_blocks - 1)

torchvision/ops/boxes.py

@@ -353,7 +353,7 @@ def complete_box_iou(boxes1: Tensor, boxes2: Tensor, eps: float = 1e-7) -> Tenso
     w_gt = boxes2[:, 2] - boxes2[:, 0]
     h_gt = boxes2[:, 3] - boxes2[:, 1]
 
-    v = (4 / (torch.pi**2)) * torch.pow((torch.atan(w_gt / h_gt) - torch.atan(w_pred / h_pred)), 2)
+    v = (4 / (torch.pi ** 2)) * torch.pow((torch.atan(w_gt / h_gt) - torch.atan(w_pred / h_pred)), 2)
     with torch.no_grad():
         alpha = v / (1 - iou + v + eps)
     return iou - (centers_distance_squared / diagonal_distance_squared) - alpha * v

torchvision/ops/ciou_loss.py

@@ -79,7 +79,7 @@ def complete_box_iou_loss(
     h_pred = y2 - y1
     w_gt = x2g - x1g
     h_gt = y2g - y1g
-    v = (4 / (torch.pi**2)) * torch.pow((torch.atan(w_gt / h_gt) - torch.atan(w_pred / h_pred)), 2)
+    v = (4 / (torch.pi ** 2)) * torch.pow((torch.atan(w_gt / h_gt) - torch.atan(w_pred / h_pred)), 2)
     with torch.no_grad():
         alpha = v / (1 - iou + v + eps)
 

torchvision/ops/drop_block.py

@@ -37,7 +37,7 @@ def drop_block2d(
     N, C, H, W = input.size()
     block_size = min(block_size, W, H)
     # compute the gamma of Bernoulli distribution
-    gamma = (p * H * W) / ((block_size**2) * ((H - block_size + 1) * (W - block_size + 1)))
+    gamma = (p * H * W) / ((block_size ** 2) * ((H - block_size + 1) * (W - block_size + 1)))
     noise = torch.empty((N, C, H - block_size + 1, W - block_size + 1), dtype=input.dtype, device=input.device)
     noise.bernoulli_(gamma)
 
@@ -83,7 +83,7 @@ def drop_block3d(
     N, C, D, H, W = input.size()
     block_size = min(block_size, D, H, W)
     # compute the gamma of Bernoulli distribution
-    gamma = (p * D * H * W) / ((block_size**3) * ((D - block_size + 1) * (H - block_size + 1) * (W - block_size + 1)))
+    gamma = (p * D * H * W) / ((block_size ** 3) * ((D - block_size + 1) * (H - block_size + 1) * (W - block_size + 1)))
     noise = torch.empty(
         (N, C, D - block_size + 1, H - block_size + 1, W - block_size + 1), dtype=input.dtype, device=input.device
     )

torchvision/prototype/datasets/_builtin/coco.py

@@ -151,7 +151,7 @@ def _decode_captions_ann(self, anns: List[Dict[str, Any]], image_meta: Dict[str,
     )
 
     _META_FILE_PATTERN = re.compile(
-        rf"(?P<annotations>({'|'.join(_ANN_DECODERS.keys())}))_(?P<split>[a-zA-Z]+)(?P<year>\d+)[.]json"
+        fr"(?P<annotations>({'|'.join(_ANN_DECODERS.keys())}))_(?P<split>[a-zA-Z]+)(?P<year>\d+)[.]json"
     )
 
     def _filter_meta_files(self, data: Tuple[str, Any]) -> bool:

torchvision/transforms/functional_tensor.py

@@ -247,7 +247,7 @@ def adjust_gamma(img: Tensor, gamma: float, gain: float = 1) -> Tensor:
     if not torch.is_floating_point(img):
         result = convert_image_dtype(result, torch.float32)
 
-    result = (gain * result**gamma).clamp(0, 1)
+    result = (gain * result ** gamma).clamp(0, 1)
 
     result = convert_image_dtype(result, dtype)
     return result

torchvision/utils.py

@@ -430,7 +430,7 @@ def flow_to_image(flow: torch.Tensor) -> torch.Tensor:
     if flow.ndim != 4 or flow.shape[1] != 2:
         raise ValueError(f"Input flow should have shape (2, H, W) or (N, 2, H, W), got {orig_shape}.")
 
-    max_norm = torch.sum(flow**2, dim=1).sqrt().max()
+    max_norm = torch.sum(flow ** 2, dim=1).sqrt().max()
     epsilon = torch.finfo((flow).dtype).eps
     normalized_flow = flow / (max_norm + epsilon)
     img = _normalized_flow_to_image(normalized_flow)
@@ -457,7 +457,7 @@ def _normalized_flow_to_image(normalized_flow: torch.Tensor) -> torch.Tensor:
     flow_image = torch.zeros((N, 3, H, W), dtype=torch.uint8, device=device)
     colorwheel = _make_colorwheel().to(device)  # shape [55x3]
     num_cols = colorwheel.shape[0]
-    norm = torch.sum(normalized_flow**2, dim=1).sqrt()
+    norm = torch.sum(normalized_flow ** 2, dim=1).sqrt()
     a = torch.atan2(-normalized_flow[:, 1, :, :], -normalized_flow[:, 0, :, :]) / torch.pi
     fk = (a + 1) / 2 * (num_cols - 1)
     k0 = torch.floor(fk).to(torch.long)
@@ -523,7 +523,7 @@ def _make_colorwheel() -> torch.Tensor:
 
 
 def _generate_color_palette(num_objects: int):
-    palette = torch.tensor([2**25 - 1, 2**15 - 1, 2**21 - 1])
+    palette = torch.tensor([2 ** 25 - 1, 2 ** 15 - 1, 2 ** 21 - 1])
     return [tuple((i * palette) % 255) for i in range(num_objects)]