Backout D64619891 for torchvision

Summary: Changes to torchvision weren't exported to GitHub properly, and that's now creating conflicts.

Reviewed By: vmoens

Differential Revision: D68022237

fbshipit-source-id: 2adb3b0e7f5c47619397d5e6ef41c7c0f5019025

Author: NicolasHug

references/depth/stereo/train.py

@@ -5,7 +5,6 @@
 from typing import List, Union
 
 import numpy as np
-import numpy.typing as npt
 import torch
 import torch.distributed as dist
 import torchvision.models.optical_flow
@@ -34,7 +33,7 @@ def make_stereo_flow(flow: Union[torch.Tensor, List[torch.Tensor]], model_out_ch
     return flow
 
 
-def make_lr_schedule(args: argparse.Namespace, optimizer: torch.optim.Optimizer) -> npt.NDArray:
+def make_lr_schedule(args: argparse.Namespace, optimizer: torch.optim.Optimizer) -> np.ndarray:
     """Helper function to return a learning rate scheduler for CRE-stereo"""
     if args.decay_after_steps < args.warmup_steps:
         raise ValueError(f"decay_after_steps: {args.function} must be greater than warmup_steps: {args.warmup_steps}")

references/depth/stereo/visualization.py

@@ -2,7 +2,6 @@
 from typing import List
 
 import numpy as np
-import numpy.typing as npt
 import torch
 from torch import Tensor
 from torchvision.utils import make_grid
@@ -65,7 +64,7 @@ def make_training_sample_grid(
     disparities: Tensor,
     masks: Tensor,
     predictions: List[Tensor],
-) -> npt.NDArray:
+) -> 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
@@ -85,7 +84,7 @@ def make_training_sample_grid(
 
 
 @torch.no_grad()
-def make_disparity_sequence_grid(predictions: List[Tensor], disparities: Tensor) -> npt.NDArray:
+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]))

test/datasets_utils.py

@@ -18,7 +18,6 @@
 from typing import Any, Callable, Dict, Iterator, List, Optional, Sequence, Tuple, Union
 
 import numpy as np
-import numpy.typing as npt
 
 import PIL
 import PIL.Image
@@ -826,8 +825,8 @@ def size(idx: int) -> Tuple[int, int, int]:
 def shape_test_for_stereo(
     left: PIL.Image.Image,
     right: PIL.Image.Image,
-    disparity: Optional[npt.NDArray] = None,
-    valid_mask: Optional[npt.NDArray] = None,
+    disparity: Optional[np.ndarray] = None,
+    valid_mask: Optional[np.ndarray] = None,
 ):
     left_dims = get_dimensions(left)
     right_dims = get_dimensions(right)

torchvision/datasets/_optical_flow.py

@@ -6,7 +6,6 @@
 from typing import Callable, List, Optional, Tuple, Union
 
 import numpy as np
-import numpy.typing as npt
 import torch
 from PIL import Image
 
@@ -165,7 +164,7 @@ def __getitem__(self, index: int) -> Union[T1, T2]:
         """
         return super().__getitem__(index)
 
-    def _read_flow(self, file_name: str) -> npt.NDArray:
+    def _read_flow(self, file_name: str) -> np.ndarray:
         return _read_flo(file_name)
 
 
@@ -226,7 +225,7 @@ def __getitem__(self, index: int) -> Union[T1, T2]:
         """
         return super().__getitem__(index)
 
-    def _read_flow(self, file_name: str) -> Tuple[npt.NDArray, npt.NDArray]:
+    def _read_flow(self, file_name: str) -> Tuple[np.ndarray, np.ndarray]:
         return _read_16bits_png_with_flow_and_valid_mask(file_name)
 
 
@@ -294,7 +293,7 @@ def __getitem__(self, index: int) -> Union[T1, T2]:
         """
         return super().__getitem__(index)
 
-    def _read_flow(self, file_name: str) -> npt.NDArray:
+    def _read_flow(self, file_name: str) -> np.ndarray:
         return _read_flo(file_name)
 
 
@@ -392,7 +391,7 @@ def __getitem__(self, index: int) -> Union[T1, T2]:
         """
         return super().__getitem__(index)
 
-    def _read_flow(self, file_name: str) -> npt.NDArray:
+    def _read_flow(self, file_name: str) -> np.ndarray:
         return _read_pfm(file_name)
 
 
@@ -444,7 +443,7 @@ def __init__(self, root: Union[str, Path], split: str = "train", transforms: Opt
                 "Could not find the HD1K images. Please make sure the directory structure is correct."
             )
 
-    def _read_flow(self, file_name: str) -> Tuple[npt.NDArray, npt.NDArray]:
+    def _read_flow(self, file_name: str) -> Tuple[np.ndarray, np.ndarray]:
         return _read_16bits_png_with_flow_and_valid_mask(file_name)
 
     def __getitem__(self, index: int) -> Union[T1, T2]:
@@ -463,7 +462,7 @@ def __getitem__(self, index: int) -> Union[T1, T2]:
         return super().__getitem__(index)
 
 
-def _read_flo(file_name: str) -> npt.NDArray:
+def _read_flo(file_name: str) -> np.ndarray:
     """Read .flo file in Middlebury format"""
     # Code adapted from:
     # http://stackoverflow.com/questions/28013200/reading-middlebury-flow-files-with-python-bytes-array-numpy
@@ -480,7 +479,7 @@ def _read_flo(file_name: str) -> npt.NDArray:
         return data.reshape(h, w, 2).transpose(2, 0, 1)
 
 
-def _read_16bits_png_with_flow_and_valid_mask(file_name: str) -> Tuple[npt.NDArray, npt.NDArray]:
+def _read_16bits_png_with_flow_and_valid_mask(file_name: str) -> Tuple[np.ndarray, np.ndarray]:
 
     flow_and_valid = decode_png(read_file(file_name)).to(torch.float32)
     flow, valid_flow_mask = flow_and_valid[:2, :, :], flow_and_valid[2, :, :]

torchvision/datasets/_stereo_matching.py

@@ -9,7 +9,6 @@
 from typing import Callable, cast, List, Optional, Tuple, Union
 
 import numpy as np
-import numpy.typing as npt
 from PIL import Image
 
 from .utils import _read_pfm, download_and_extract_archive, verify_str_arg
@@ -93,7 +92,7 @@ def _scan_pairs(
         return paths
 
     @abstractmethod
-    def _read_disparity(self, file_path: str) -> Tuple[Optional[npt.NDArray], Optional[npt.NDArray]]:
+    def _read_disparity(self, file_path: str) -> Tuple[Optional[np.ndarray], Optional[np.ndarray]]:
         # function that returns a disparity map and an occlusion map
         pass
 
@@ -179,7 +178,7 @@ def __init__(self, root: Union[str, Path], transforms: Optional[Callable] = None
         disparities = self._scan_pairs(left_disparity_pattern, right_disparity_pattern)
         self._disparities = disparities
 
-    def _read_disparity(self, file_path: str) -> Tuple[npt.NDArray, None]:
+    def _read_disparity(self, file_path: str) -> Tuple[np.ndarray, None]:
         disparity_map = _read_pfm_file(file_path)
         disparity_map = np.abs(disparity_map)  # ensure that the disparity is positive
         valid_mask = None
@@ -258,7 +257,7 @@ def __init__(self, root: Union[str, Path], split: str = "train", transforms: Opt
         else:
             self._disparities = list((None, None) for _ in self._images)
 
-    def _read_disparity(self, file_path: str) -> Tuple[Optional[npt.NDArray], None]:
+    def _read_disparity(self, file_path: str) -> Tuple[Optional[np.ndarray], None]:
         # test split has no disparity maps
         if file_path is None:
             return None, None
@@ -346,7 +345,7 @@ def __init__(self, root: Union[str, Path], split: str = "train", transforms: Opt
         else:
             self._disparities = list((None, None) for _ in self._images)
 
-    def _read_disparity(self, file_path: str) -> Tuple[Optional[npt.NDArray], None]:
+    def _read_disparity(self, file_path: str) -> Tuple[Optional[np.ndarray], None]:
         # test split has no disparity maps
         if file_path is None:
             return None, None
@@ -566,7 +565,7 @@ def _read_img(self, file_path: Union[str, Path]) -> Image.Image:
             file_path = random.choice(ambient_file_paths)  # type: ignore
         return super()._read_img(file_path)
 
-    def _read_disparity(self, file_path: str) -> Union[Tuple[None, None], Tuple[npt.NDArray, npt.NDArray]]:
+    def _read_disparity(self, file_path: str) -> Union[Tuple[None, None], Tuple[np.ndarray, np.ndarray]]:
         # test split has not disparity maps
         if file_path is None:
             return None, None
@@ -696,7 +695,7 @@ def __init__(
             disparities = self._scan_pairs(left_disparity_pattern, right_disparity_pattern)
             self._disparities += disparities
 
-    def _read_disparity(self, file_path: str) -> Tuple[npt.NDArray, None]:
+    def _read_disparity(self, file_path: str) -> Tuple[np.ndarray, None]:
         disparity_map = np.asarray(Image.open(file_path), dtype=np.float32)
         # unsqueeze the disparity map into (C, H, W) format
         disparity_map = disparity_map[None, :, :] / 32.0
@@ -790,7 +789,7 @@ def __init__(self, root: Union[str, Path], variant: str = "single", transforms:
             right_disparity_pattern = str(root / s / split_prefix[s] / "*.right.depth.png")
             self._disparities += self._scan_pairs(left_disparity_pattern, right_disparity_pattern)
 
-    def _read_disparity(self, file_path: str) -> Tuple[npt.NDArray, None]:
+    def _read_disparity(self, file_path: str) -> Tuple[np.ndarray, None]:
         # (H, W) image
         depth = np.asarray(Image.open(file_path))
         # as per https://research.nvidia.com/sites/default/files/pubs/2018-06_Falling-Things/readme_0.txt
@@ -913,7 +912,7 @@ def __init__(
             right_disparity_pattern = str(root / "disparity" / prefix_directories[variant] / "right" / "*.pfm")
             self._disparities += self._scan_pairs(left_disparity_pattern, right_disparity_pattern)
 
-    def _read_disparity(self, file_path: str) -> Tuple[npt.NDArray, None]:
+    def _read_disparity(self, file_path: str) -> Tuple[np.ndarray, None]:
         disparity_map = _read_pfm_file(file_path)
         disparity_map = np.abs(disparity_map)  # ensure that the disparity is positive
         valid_mask = None
@@ -1022,7 +1021,7 @@ def _get_occlussion_mask_paths(self, file_path: str) -> Tuple[str, str]:
 
         return occlusion_path, outofframe_path
 
-    def _read_disparity(self, file_path: str) -> Union[Tuple[None, None], Tuple[npt.NDArray, npt.NDArray]]:
+    def _read_disparity(self, file_path: str) -> Union[Tuple[None, None], Tuple[np.ndarray, np.ndarray]]:
         if file_path is None:
             return None, None
 
@@ -1103,7 +1102,7 @@ def __init__(self, root: Union[str, Path], split: str = "train", transforms: Opt
         right_disparity_pattern = str(root / "*" / "right_disp.png")
         self._disparities = self._scan_pairs(left_disparity_pattern, right_disparity_pattern)
 
-    def _read_disparity(self, file_path: str) -> Tuple[npt.NDArray, None]:
+    def _read_disparity(self, file_path: str) -> Tuple[np.ndarray, None]:
         disparity_map = np.asarray(Image.open(file_path), dtype=np.float32)
         # unsqueeze disparity to (C, H, W)
         disparity_map = disparity_map[None, :, :] / 1024.0
@@ -1197,7 +1196,7 @@ def __init__(self, root: Union[str, Path], split: str = "train", transforms: Opt
             disparity_pattern = str(root / anot_dir / "*" / "disp0GT.pfm")
             self._disparities = self._scan_pairs(disparity_pattern, None)
 
-    def _read_disparity(self, file_path: str) -> Union[Tuple[None, None], Tuple[npt.NDArray, npt.NDArray]]:
+    def _read_disparity(self, file_path: str) -> Union[Tuple[None, None], Tuple[np.ndarray, np.ndarray]]:
         # test split has no disparity maps
         if file_path is None:
             return None, None

torchvision/datasets/phototour.py

@@ -3,7 +3,6 @@
 from typing import Any, Callable, List, Optional, Tuple, Union
 
 import numpy as np
-import numpy.typing as npt
 import torch
 from PIL import Image
 
@@ -188,7 +187,7 @@ def extra_repr(self) -> str:
 def read_image_file(data_dir: str, image_ext: str, n: int) -> torch.Tensor:
     """Return a Tensor containing the patches"""
 
-    def PIL2array(_img: Image.Image) -> npt.NDArray:
+    def PIL2array(_img: Image.Image) -> np.ndarray:
         """Convert PIL image type to numpy 2D array"""
         return np.array(_img.getdata(), dtype=np.uint8).reshape(64, 64)
 

torchvision/datasets/sbd.py

@@ -4,7 +4,6 @@
 from typing import Any, Callable, Optional, Tuple, Union
 
 import numpy as np
-import numpy.typing as npt
 from PIL import Image
 
 from .utils import download_and_extract_archive, download_url, verify_str_arg
@@ -103,7 +102,7 @@ def _get_segmentation_target(self, filepath: str) -> Image.Image:
         mat = self._loadmat(filepath)
         return Image.fromarray(mat["GTcls"][0]["Segmentation"][0])
 
-    def _get_boundaries_target(self, filepath: str) -> npt.NDArray:
+    def _get_boundaries_target(self, filepath: str) -> np.ndarray:
         mat = self._loadmat(filepath)
         return np.concatenate(
             [np.expand_dims(mat["GTcls"][0]["Boundaries"][0][i][0].toarray(), axis=0) for i in range(self.num_classes)],

torchvision/datasets/stl10.py

@@ -3,7 +3,6 @@
 from typing import Any, Callable, cast, Optional, Tuple, Union
 
 import numpy as np
-import numpy.typing as npt
 from PIL import Image
 
 from .utils import check_integrity, download_and_extract_archive, verify_str_arg
@@ -64,7 +63,7 @@ def __init__(
             raise RuntimeError("Dataset not found or corrupted. You can use download=True to download it")
 
         # now load the picked numpy arrays
-        self.labels: Optional[npt.NDArray]
+        self.labels: Optional[np.ndarray]
         if self.split == "train":
             self.data, self.labels = self.__loadfile(self.train_list[0][0], self.train_list[1][0])
             self.labels = cast(np.ndarray, self.labels)
@@ -130,7 +129,7 @@ def __getitem__(self, index: int) -> Tuple[Any, Any]:
     def __len__(self) -> int:
         return self.data.shape[0]
 
-    def __loadfile(self, data_file: str, labels_file: Optional[str] = None) -> Tuple[npt.NDArray, Optional[npt.NDArray]]:
+    def __loadfile(self, data_file: str, labels_file: Optional[str] = None) -> Tuple[np.ndarray, Optional[np.ndarray]]:
         labels = None
         if labels_file:
             path_to_labels = os.path.join(self.root, self.base_folder, labels_file)

torchvision/datasets/utils.py

@@ -16,7 +16,6 @@
 from urllib.parse import urlparse
 
 import numpy as np
-import numpy.typing as npt
 import torch
 from torch.utils.model_zoo import tqdm
 
@@ -435,7 +434,7 @@ def verify_str_arg(
     return value
 
 
-def _read_pfm(file_name: Union[str, pathlib.Path], slice_channels: int = 2) -> npt.NDArray:
+def _read_pfm(file_name: Union[str, pathlib.Path], slice_channels: int = 2) -> np.ndarray:
     """Read file in .pfm format. Might contain either 1 or 3 channels of data.
 
     Args:

torchvision/prototype/datasets/_builtin/cifar.py

@@ -5,7 +5,6 @@
 from typing import Any, BinaryIO, cast, Dict, Iterator, List, Optional, Tuple, Union
 
 import numpy as np
-import numpy.typing as npt
 from torchdata.datapipes.iter import Filter, IterDataPipe, Mapper
 from torchvision.prototype.datasets.utils import Dataset, HttpResource, OnlineResource
 from torchvision.prototype.datasets.utils._internal import (
@@ -25,7 +24,7 @@ def __init__(self, datapipe: IterDataPipe[Dict[str, Any]], *, labels_key: str) -
         self.datapipe = datapipe
         self.labels_key = labels_key
 
-    def __iter__(self) -> Iterator[Tuple[npt.NDArray, int]]:
+    def __iter__(self) -> Iterator[Tuple[np.ndarray, int]]:
         for mapping in self.datapipe:
             image_arrays = mapping["data"].reshape((-1, 3, 32, 32))
             category_idcs = mapping[self.labels_key]
@@ -68,7 +67,7 @@ def _unpickle(self, data: Tuple[str, io.BytesIO]) -> Dict[str, Any]:
         file.close()
         return content
 
-    def _prepare_sample(self, data: Tuple[npt.NDArray, int]) -> Dict[str, Any]:
+    def _prepare_sample(self, data: Tuple[np.ndarray, int]) -> Dict[str, Any]:
         image_array, category_idx = data
         return dict(
             image=Image(image_array),