Removing prototype related things from release/0.14 branch (#6687)

* Remove test related to prototype

* Remove torchvision/prototype dir

* Remove references/depth/stereo because it depend on prototype

* Remove prototype related entries on mypy.ini

* Remove things related to prototype in pytest.ini

* clean setup.py from prototype

* Clean CI from prototype

* Remove unused expect file

references/depth/stereo/utils/metrics.py

-from typing import Dict, List, Optional, Tuple
-
-from torch import Tensor
-
-AVAILABLE_METRICS = ["mae", "rmse", "epe", "bad1", "bad2", "epe", "1px", "3px", "5px", "fl-all", "relepe"]
-
-
-def compute_metrics(
-    flow_pred: Tensor, flow_gt: Tensor, valid_flow_mask: Optional[Tensor], metrics: List[str]
-) -> Tuple[Dict[str, float], int]:
-    for m in metrics:
-        if m not in AVAILABLE_METRICS:
-            raise ValueError(f"Invalid metric: {m}. Valid metrics are: {AVAILABLE_METRICS}")
-
-    metrics_dict = {}
-
-    pixels_diffs = (flow_pred - flow_gt).abs()
-    # there is no Y flow in Stereo Matching, therefor flow.abs() = flow.pow(2).sum(dim=1).sqrt()
-    flow_norm = flow_gt.abs()
-
-    if valid_flow_mask is not None:
-        valid_flow_mask = valid_flow_mask.unsqueeze(1)
-        pixels_diffs = pixels_diffs[valid_flow_mask]
-        flow_norm = flow_norm[valid_flow_mask]
-
-    num_pixels = pixels_diffs.numel()
-    if "bad1" in metrics:
-        metrics_dict["bad1"] = (pixels_diffs > 1).float().mean().item()
-    if "bad2" in metrics:
-        metrics_dict["bad2"] = (pixels_diffs > 2).float().mean().item()
-
-    if "mae" in metrics:
-        metrics_dict["mae"] = pixels_diffs.mean().item()
-    if "rmse" in metrics:
-        metrics_dict["rmse"] = pixels_diffs.pow(2).mean().sqrt().item()
-    if "epe" in metrics:
-        metrics_dict["epe"] = pixels_diffs.mean().item()
-    if "1px" in metrics:
-        metrics_dict["1px"] = (pixels_diffs < 1).float().mean().item()
-    if "3px" in metrics:
-        metrics_dict["3px"] = (pixels_diffs < 3).float().mean().item()
-    if "5px" in metrics:
-        metrics_dict["5px"] = (pixels_diffs < 5).float().mean().item()
-    if "fl-all" in metrics:
-        metrics_dict["fl-all"] = ((pixels_diffs < 3) & ((pixels_diffs / flow_norm) < 0.05)).float().mean().item() * 100
-    if "relepe" in metrics:
-        metrics_dict["relepe"] = (pixels_diffs / flow_norm).mean().item()
-
-    return metrics_dict, num_pixels

references/depth/stereo/utils/norm.py

-import torch
-
-
-def freeze_batch_norm(model):
-    for m in model.modules():
-        if isinstance(m, torch.nn.BatchNorm2d):
-            m.eval()
-
-
-def unfreeze_batch_norm(model):
-    for m in model.modules():
-        if isinstance(m, torch.nn.BatchNorm2d):
-            m.train()

references/depth/stereo/utils/padder.py

-import torch.nn.functional as F
-
-
-class InputPadder:
-    """Pads images such that dimensions are divisible by 8"""
-
-    # TODO: Ideally, this should be part of the eval transforms preset, instead
-    # of being part of the validation code. It's not obvious what a good
-    # solution would be, because we need to unpad the predicted flows according
-    # to the input images' size, and in some datasets (Kitti) images can have
-    # variable sizes.
-
-    def __init__(self, dims, mode="sintel"):
-        self.ht, self.wd = dims[-2:]
-        pad_ht = (((self.ht // 8) + 1) * 8 - self.ht) % 8
-        pad_wd = (((self.wd // 8) + 1) * 8 - self.wd) % 8
-        if mode == "sintel":
-            self._pad = [pad_wd // 2, pad_wd - pad_wd // 2, pad_ht // 2, pad_ht - pad_ht // 2]
-        else:
-            self._pad = [pad_wd // 2, pad_wd - pad_wd // 2, 0, pad_ht]
-
-    def pad(self, *inputs):
-        return [F.pad(x, self._pad, mode="replicate") for x in inputs]
-
-    def unpad(self, x):
-        ht, wd = x.shape[-2:]
-        c = [self._pad[2], ht - self._pad[3], self._pad[0], wd - self._pad[1]]
-        return x[..., c[0] : c[1], c[2] : c[3]]

references/depth/stereo/vizualization.py

-import os
-from typing import List
-
-import numpy as np
-import torch
-from torch import Tensor
-from torchvision.utils import make_grid
-
-
-@torch.no_grad()
-def make_disparity_image(disparity: Tensor):
-    # normalize image to [0, 1]
-    disparity = disparity.detach().cpu()
-    disparity = (disparity - disparity.min()) / (disparity.max() - disparity.min())
-    return disparity
-
-
-@torch.no_grad()
-def make_disparity_image_pairs(disparity: Tensor, image: Tensor):
-    disparity = make_disparity_image(disparity)
-    # image is in [-1, 1], bring it to [0, 1]
-    image = image.detach().cpu()
-    image = image * 0.5 + 0.5
-    return disparity, image
-
-
-@torch.no_grad()
-def make_disparity_sequence(disparities: List[Tensor]):
-    # convert each disparity to [0, 1]
-    for idx, disparity_batch in enumerate(disparities):
-        disparities[idx] = torch.stack(list(map(make_disparity_image, disparity_batch)))
-    # make the list into a batch
-    disparity_sequences = torch.stack(disparities)
-    return disparity_sequences
-
-
-@torch.no_grad()
-def make_pair_grid(*inputs, orientation="horizontal"):
-    # make a grid of images with the outputs and references side by side
-    if orientation == "horizontal":
-        # interleave the outputs and references
-        canvas = torch.zeros_like(inputs[0])
-        canvas = torch.cat([canvas] * len(inputs), dim=0)
-        size = len(inputs)
-        for idx, inp in enumerate(inputs):
-            canvas[idx::size, ...] = inp
-        grid = make_grid(canvas, nrow=len(inputs), padding=16, normalize=True, scale_each=True)
-    elif orientation == "vertical":
-        # interleave the outputs and references
-        canvas = torch.cat(inputs, dim=0)
-        size = len(inputs)
-        for idx, inp in enumerate(inputs):
-            canvas[idx::size, ...] = inp
-        grid = make_grid(canvas, nrow=len(inputs[0]), padding=16, normalize=True, scale_each=True)
-    else:
-        raise ValueError("Unknown orientation: {}".format(orientation))
-    return grid
-
-
-@torch.no_grad()
-def make_training_sample_grid(
-    left_images: Tensor,
-    right_images: Tensor,
-    disparities: Tensor,
-    masks: Tensor,
-    predictions: List[Tensor],
-) -> np.ndarray:
-    # detach images and renormalize to [0, 1]
-    images_left = left_images.detach().cpu() * 0.5 + 0.5
-    images_right = right_images.detach().cpu() * 0.5 + 0.5
-    # detach the disparties and predictions
-    disparities = disparities.detach().cpu()
-    predictions = predictions[-1].detach().cpu()
-    # keep only the first channel of pixels, and repeat it 3 times
-    disparities = disparities[:, :1, ...].repeat(1, 3, 1, 1)
-    predictions = predictions[:, :1, ...].repeat(1, 3, 1, 1)
-    # unsqueeze and repeat the masks
-    masks = masks.detach().cpu().unsqueeze(1).repeat(1, 3, 1, 1)
-    # make a grid that will self normalize across the batch
-    pred_grid = make_pair_grid(images_left, images_right, masks, disparities, predictions, orientation="horizontal")
-    pred_grid = pred_grid.permute(1, 2, 0).numpy()
-    pred_grid = (pred_grid * 255).astype(np.uint8)
-    return pred_grid
-
-
-@torch.no_grad()
-def make_disparity_sequence_grid(predictions: List[Tensor], disparities: Tensor) -> np.ndarray:
-    # right most we will be adding the ground truth
-    seq_len = len(predictions) + 1
-    predictions = list(map(lambda x: x[:, :1, :, :].detach().cpu(), predictions + [disparities]))
-    sequence = make_disparity_sequence(predictions)
-    # swap axes to have the in the correct order for each batch sample
-    sequence = torch.swapaxes(sequence, 0, 1).contiguous().reshape(-1, 1, disparities.shape[-2], disparities.shape[-1])
-    sequence = make_grid(sequence, nrow=seq_len, padding=16, normalize=True, scale_each=True)
-    sequence = sequence.permute(1, 2, 0).numpy()
-    sequence = (sequence * 255).astype(np.uint8)
-    return sequence
-
-
-@torch.no_grad()
-def make_prediction_image_side_to_side(
-    predictions: Tensor, disparities: Tensor, valid_mask: Tensor, save_path: str, prefix: str
-) -> None:
-    import matplotlib.pyplot as plt
-
-    # normalize the predictions and disparities in [0, 1]
-    predictions = (predictions - predictions.min()) / (predictions.max() - predictions.min())
-    disparities = (disparities - disparities.min()) / (disparities.max() - disparities.min())
-    predictions = predictions * valid_mask
-    disparities = disparities * valid_mask
-
-    predictions = predictions.detach().cpu()
-    disparities = disparities.detach().cpu()
-
-    for idx, (pred, gt) in enumerate(zip(predictions, disparities)):
-        pred = pred.permute(1, 2, 0).numpy()
-        gt = gt.permute(1, 2, 0).numpy()
-        # plot pred and gt side by side
-        fig, ax = plt.subplots(1, 2, figsize=(10, 5))
-        ax[0].imshow(pred)
-        ax[0].set_title("Prediction")
-        ax[1].imshow(gt)
-        ax[1].set_title("Ground Truth")
-        save_name = os.path.join(save_path, "{}_{}.png".format(prefix, idx))
-        plt.savefig(save_name)
-        plt.close()

setup.py

@@ -539,7 +539,7 @@ if __name__ == "__main__":
         license="BSD",
         # Package info
         packages=find_packages(exclude=("test",)),
-        package_data={package_name: ["*.dll", "*.dylib", "*.so", "prototype/datasets/_builtin/*.categories"]},
+        package_data={package_name: ["*.dll", "*.dylib", "*.so"]},
         zip_safe=False,
         install_requires=requirements,
         extras_require={

test/test_prototype_features.py

-import pytest
-import torch
-from torchvision.prototype import features
-
-
-def test_isinstance():
-    assert isinstance(
-        features.Label([0, 1, 0], categories=["foo", "bar"]),
-        torch.Tensor,
-    )
-
-
-def test_wrapping_no_copy():
-    tensor = torch.tensor([0, 1, 0], dtype=torch.int64)
-    label = features.Label(tensor, categories=["foo", "bar"])
-
-    assert label.data_ptr() == tensor.data_ptr()
-
-
-def test_to_wrapping():
-    tensor = torch.tensor([0, 1, 0], dtype=torch.int64)
-    label = features.Label(tensor, categories=["foo", "bar"])
-
-    label_to = label.to(torch.int32)
-
-    assert type(label_to) is features.Label
-    assert label_to.dtype is torch.int32
-    assert label_to.categories is label.categories
-
-
-def test_to_feature_reference():
-    tensor = torch.tensor([0, 1, 0], dtype=torch.int64)
-    label = features.Label(tensor, categories=["foo", "bar"]).to(torch.int32)
-
-    tensor_to = tensor.to(label)
-
-    assert type(tensor_to) is torch.Tensor
-    assert tensor_to.dtype is torch.int32
-
-
-def test_clone_wrapping():
-    tensor = torch.tensor([0, 1, 0], dtype=torch.int64)
-    label = features.Label(tensor, categories=["foo", "bar"])
-
-    label_clone = label.clone()
-
-    assert type(label_clone) is features.Label
-    assert label_clone.data_ptr() != label.data_ptr()
-    assert label_clone.categories is label.categories
-
-
-def test_requires_grad__wrapping():
-    tensor = torch.tensor([0, 1, 0], dtype=torch.float32)
-    label = features.Label(tensor, categories=["foo", "bar"])
-
-    assert not label.requires_grad
-
-    label_requires_grad = label.requires_grad_(True)
-
-    assert type(label_requires_grad) is features.Label
-    assert label.requires_grad
-    assert label_requires_grad.requires_grad
-
-
-def test_other_op_no_wrapping():
-    tensor = torch.tensor([0, 1, 0], dtype=torch.int64)
-    label = features.Label(tensor, categories=["foo", "bar"])
-
-    # any operation besides .to() and .clone() will do here
-    output = label * 2
-
-    assert type(output) is torch.Tensor
-
-
-@pytest.mark.parametrize(
-    "op",
-    [
-        lambda t: t.numpy(),
-        lambda t: t.tolist(),
-        lambda t: t.max(dim=-1),
-    ],
-)
-def test_no_tensor_output_op_no_wrapping(op):
-    tensor = torch.tensor([0, 1, 0], dtype=torch.int64)
-    label = features.Label(tensor, categories=["foo", "bar"])
-
-    output = op(label)
-
-    assert type(output) is not features.Label
-
-
-def test_inplace_op_no_wrapping():
-    tensor = torch.tensor([0, 1, 0], dtype=torch.int64)
-    label = features.Label(tensor, categories=["foo", "bar"])
-
-    output = label.add_(0)
-
-    assert type(output) is torch.Tensor
-    assert type(label) is features.Label
-
-
-def test_new_like():
-    tensor = torch.tensor([0, 1, 0], dtype=torch.int64)
-    label = features.Label(tensor, categories=["foo", "bar"])
-
-    # any operation besides .to() and .clone() will do here
-    output = label * 2
-
-    label_new = features.Label.new_like(label, output)
-
-    assert type(label_new) is features.Label
-    assert label_new.data_ptr() == output.data_ptr()
-    assert label_new.categories is label.categories