Remove relative imports.

Author: datumbox

torchvision/prototype/features/__init__.py

@@ -1,6 +1,15 @@
 from ._bounding_box import BoundingBox, BoundingBoxFormat
 from ._encoded import EncodedData, EncodedImage, EncodedVideo
-from ._feature import _Feature, is_simple_tensor
-from ._image import ColorSpace, Image
+from ._feature import _Feature, FillType, FillTypeJIT, InputType, InputTypeJIT, is_simple_tensor
+from ._image import (
+    ColorSpace,
+    Image,
+    ImageType,
+    ImageTypeJIT,
+    LegacyImageType,
+    LegacyImageTypeJIT,
+    TensorImageType,
+    TensorImageTypeJIT,
+)
 from ._label import Label, OneHotLabel
 from ._mask import Mask

torchvision/prototype/transforms/_augment.py

@@ -10,8 +10,6 @@
 from torchvision.prototype import features
 from torchvision.prototype.transforms import functional as F, InterpolationMode
 
-from ..features._image import ImageType, TensorImageType
-
 from ._transform import _RandomApplyTransform
 from ._utils import has_any, query_chw
 
@@ -94,7 +92,7 @@ def _get_params(self, sample: Any) -> Dict[str, Any]:
 
         return dict(i=i, j=j, h=h, w=w, v=v)
 
-    def _transform(self, inpt: ImageType, params: Dict[str, Any]) -> ImageType:
+    def _transform(self, inpt: features.ImageType, params: Dict[str, Any]) -> features.ImageType:
         if params["v"] is not None:
             inpt = F.erase(inpt, **params, inplace=self.inplace)
 
@@ -205,15 +203,15 @@ def __init__(
 
     def _copy_paste(
         self,
-        image: TensorImageType,
+        image: features.TensorImageType,
         target: Dict[str, Any],
-        paste_image: TensorImageType,
+        paste_image: features.TensorImageType,
         paste_target: Dict[str, Any],
         random_selection: torch.Tensor,
         blending: bool,
         resize_interpolation: F.InterpolationMode,
         antialias: Optional[bool],
-    ) -> Tuple[TensorImageType, Dict[str, Any]]:
+    ) -> Tuple[features.TensorImageType, Dict[str, Any]]:
 
         paste_masks = paste_target["masks"].new_like(paste_target["masks"], paste_target["masks"][random_selection])
         paste_boxes = paste_target["boxes"].new_like(paste_target["boxes"], paste_target["boxes"][random_selection])
@@ -280,7 +278,9 @@ def _copy_paste(
 
         return image, out_target
 
-    def _extract_image_targets(self, flat_sample: List[Any]) -> Tuple[List[TensorImageType], List[Dict[str, Any]]]:
+    def _extract_image_targets(
+        self, flat_sample: List[Any]
+    ) -> Tuple[List[features.TensorImageType], List[Dict[str, Any]]]:
         # fetch all images, bboxes, masks and labels from unstructured input
         # with List[image], List[BoundingBox], List[Mask], List[Label]
         images, bboxes, masks, labels = [], [], [], []
@@ -309,7 +309,10 @@ def _extract_image_targets(self, flat_sample: List[Any]) -> Tuple[List[TensorIma
         return images, targets
 
     def _insert_outputs(
-        self, flat_sample: List[Any], output_images: List[TensorImageType], output_targets: List[Dict[str, Any]]
+        self,
+        flat_sample: List[Any],
+        output_images: List[features.TensorImageType],
+        output_targets: List[Dict[str, Any]],
     ) -> None:
         c0, c1, c2, c3 = 0, 0, 0, 0
         for i, obj in enumerate(flat_sample):

torchvision/prototype/transforms/_auto_augment.py

@@ -9,9 +9,6 @@
 from torchvision.prototype.transforms import AutoAugmentPolicy, functional as F, InterpolationMode, Transform
 from torchvision.prototype.transforms.functional._meta import get_chw
 
-from ..features._feature import FillType
-from ..features._image import ImageType
-
 from ._utils import _isinstance, _setup_fill_arg
 
 K = TypeVar("K")
@@ -23,7 +20,7 @@ def __init__(
         self,
         *,
         interpolation: InterpolationMode = InterpolationMode.NEAREST,
-        fill: Union[FillType, Dict[Type, FillType]] = None,
+        fill: Union[features.FillType, Dict[Type, features.FillType]] = None,
     ) -> None:
         super().__init__()
         self.interpolation = interpolation
@@ -38,7 +35,7 @@ def _extract_image(
         self,
         sample: Any,
         unsupported_types: Tuple[Type, ...] = (features.BoundingBox, features.Mask),
-    ) -> Tuple[int, ImageType]:
+    ) -> Tuple[int, features.ImageType]:
         sample_flat, _ = tree_flatten(sample)
         images = []
         for id, inpt in enumerate(sample_flat):
@@ -62,12 +59,12 @@ def _put_into_sample(self, sample: Any, id: int, item: Any) -> Any:
 
     def _apply_image_transform(
         self,
-        image: ImageType,
+        image: features.ImageType,
         transform_id: str,
         magnitude: float,
         interpolation: InterpolationMode,
-        fill: Dict[Type, FillType],
-    ) -> ImageType:
+        fill: Dict[Type, features.FillType],
+    ) -> features.ImageType:
         fill_ = fill[type(image)]
         fill_ = F._geometry._convert_fill_arg(fill_)
 
@@ -180,7 +177,7 @@ def __init__(
         self,
         policy: AutoAugmentPolicy = AutoAugmentPolicy.IMAGENET,
         interpolation: InterpolationMode = InterpolationMode.NEAREST,
-        fill: Union[FillType, Dict[Type, FillType]] = None,
+        fill: Union[features.FillType, Dict[Type, features.FillType]] = None,
     ) -> None:
         super().__init__(interpolation=interpolation, fill=fill)
         self.policy = policy
@@ -340,7 +337,7 @@ def __init__(
         magnitude: int = 9,
         num_magnitude_bins: int = 31,
         interpolation: InterpolationMode = InterpolationMode.NEAREST,
-        fill: Union[FillType, Dict[Type, FillType]] = None,
+        fill: Union[features.FillType, Dict[Type, features.FillType]] = None,
     ) -> None:
         super().__init__(interpolation=interpolation, fill=fill)
         self.num_ops = num_ops
@@ -396,7 +393,7 @@ def __init__(
         self,
         num_magnitude_bins: int = 31,
         interpolation: InterpolationMode = InterpolationMode.NEAREST,
-        fill: Union[FillType, Dict[Type, FillType]] = None,
+        fill: Union[features.FillType, Dict[Type, features.FillType]] = None,
     ):
         super().__init__(interpolation=interpolation, fill=fill)
         self.num_magnitude_bins = num_magnitude_bins
@@ -456,7 +453,7 @@ def __init__(
         alpha: float = 1.0,
         all_ops: bool = True,
         interpolation: InterpolationMode = InterpolationMode.BILINEAR,
-        fill: Union[FillType, Dict[Type, FillType]] = None,
+        fill: Union[features.FillType, Dict[Type, features.FillType]] = None,
     ) -> None:
         super().__init__(interpolation=interpolation, fill=fill)
         self._PARAMETER_MAX = 10

torchvision/prototype/transforms/_color.py

@@ -6,8 +6,6 @@
 from torchvision.prototype import features
 from torchvision.prototype.transforms import functional as F, Transform
 
-from ..features._image import ImageType
-
 from ._transform import _RandomApplyTransform
 from ._utils import query_chw
 
@@ -112,7 +110,7 @@ def _get_params(self, sample: Any) -> Dict[str, Any]:
             channel_permutation=torch.randperm(num_channels) if torch.rand(()) < self.p else None,
         )
 
-    def _permute_channels(self, inpt: ImageType, permutation: torch.Tensor) -> ImageType:
+    def _permute_channels(self, inpt: features.ImageType, permutation: torch.Tensor) -> features.ImageType:
         if isinstance(inpt, PIL.Image.Image):
             inpt = F.pil_to_tensor(inpt)
 
@@ -125,7 +123,7 @@ def _permute_channels(self, inpt: ImageType, permutation: torch.Tensor) -> Image
 
         return output
 
-    def _transform(self, inpt: ImageType, params: Dict[str, Any]) -> ImageType:
+    def _transform(self, inpt: features.ImageType, params: Dict[str, Any]) -> features.ImageType:
         if params["brightness"]:
             inpt = F.adjust_brightness(
                 inpt, brightness_factor=ColorJitter._generate_value(self.brightness[0], self.brightness[1])

torchvision/prototype/transforms/_deprecated.py

@@ -10,8 +10,6 @@
 from torchvision.transforms import functional as _F
 from typing_extensions import Literal
 
-from ..features._image import ImageType
-
 from ._transform import _RandomApplyTransform
 from ._utils import query_chw
 
@@ -54,7 +52,7 @@ def __init__(self, num_output_channels: Literal[1, 3] = 1) -> None:
         super().__init__()
         self.num_output_channels = num_output_channels
 
-    def _transform(self, inpt: ImageType, params: Dict[str, Any]) -> ImageType:
+    def _transform(self, inpt: features.ImageType, params: Dict[str, Any]) -> features.ImageType:
         output = _F.rgb_to_grayscale(inpt, num_output_channels=self.num_output_channels)
         if isinstance(inpt, features.Image):
             output = features.Image.new_like(inpt, output, color_space=features.ColorSpace.GRAY)
@@ -83,7 +81,7 @@ def _get_params(self, sample: Any) -> Dict[str, Any]:
         num_input_channels, _, _ = query_chw(sample)
         return dict(num_input_channels=num_input_channels)
 
-    def _transform(self, inpt: ImageType, params: Dict[str, Any]) -> ImageType:
+    def _transform(self, inpt: features.ImageType, params: Dict[str, Any]) -> features.ImageType:
         output = _F.rgb_to_grayscale(inpt, num_output_channels=params["num_input_channels"])
         if isinstance(inpt, features.Image):
             output = features.Image.new_like(inpt, output, color_space=features.ColorSpace.GRAY)

torchvision/prototype/transforms/_geometry.py

@@ -12,9 +12,6 @@
 
 from typing_extensions import Literal
 
-from ..features._feature import FillType
-from ..features._image import ImageType
-
 from ._transform import _RandomApplyTransform
 from ._utils import (
     _check_padding_arg,
@@ -181,8 +178,8 @@ def __init__(self, size: Union[int, Sequence[int]]) -> None:
         self.size = _setup_size(size, error_msg="Please provide only two dimensions (h, w) for size.")
 
     def _transform(
-        self, inpt: ImageType, params: Dict[str, Any]
-    ) -> Tuple[ImageType, ImageType, ImageType, ImageType, ImageType]:
+        self, inpt: features.ImageType, params: Dict[str, Any]
+    ) -> Tuple[features.ImageType, features.ImageType, features.ImageType, features.ImageType, features.ImageType]:
         return F.five_crop(inpt, self.size)
 
     def forward(self, *inputs: Any) -> Any:
@@ -203,7 +200,7 @@ def __init__(self, size: Union[int, Sequence[int]], vertical_flip: bool = False)
         self.size = _setup_size(size, error_msg="Please provide only two dimensions (h, w) for size.")
         self.vertical_flip = vertical_flip
 
-    def _transform(self, inpt: ImageType, params: Dict[str, Any]) -> List[ImageType]:
+    def _transform(self, inpt: features.ImageType, params: Dict[str, Any]) -> List[features.ImageType]:
         return F.ten_crop(inpt, self.size, vertical_flip=self.vertical_flip)
 
     def forward(self, *inputs: Any) -> Any:
@@ -216,7 +213,7 @@ class Pad(Transform):
     def __init__(
         self,
         padding: Union[int, Sequence[int]],
-        fill: Union[FillType, Dict[Type, FillType]] = 0,
+        fill: Union[features.FillType, Dict[Type, features.FillType]] = 0,
         padding_mode: Literal["constant", "edge", "reflect", "symmetric"] = "constant",
     ) -> None:
         super().__init__()
@@ -243,7 +240,7 @@ def _transform(self, inpt: Any, params: Dict[str, Any]) -> Any:
 class RandomZoomOut(_RandomApplyTransform):
     def __init__(
         self,
-        fill: Union[FillType, Dict[Type, FillType]] = 0,
+        fill: Union[features.FillType, Dict[Type, features.FillType]] = 0,
         side_range: Sequence[float] = (1.0, 4.0),
         p: float = 0.5,
     ) -> None:
@@ -285,7 +282,7 @@ def __init__(
         degrees: Union[numbers.Number, Sequence],
         interpolation: InterpolationMode = InterpolationMode.NEAREST,
         expand: bool = False,
-        fill: Union[FillType, Dict[Type, FillType]] = 0,
+        fill: Union[features.FillType, Dict[Type, features.FillType]] = 0,
         center: Optional[List[float]] = None,
     ) -> None:
         super().__init__()
@@ -325,7 +322,7 @@ def __init__(
         scale: Optional[Sequence[float]] = None,
         shear: Optional[Union[float, Sequence[float]]] = None,
         interpolation: InterpolationMode = InterpolationMode.NEAREST,
-        fill: Union[FillType, Dict[Type, FillType]] = 0,
+        fill: Union[features.FillType, Dict[Type, features.FillType]] = 0,
         center: Optional[List[float]] = None,
     ) -> None:
         super().__init__()
@@ -404,7 +401,7 @@ def __init__(
         size: Union[int, Sequence[int]],
         padding: Optional[Union[int, Sequence[int]]] = None,
         pad_if_needed: bool = False,
-        fill: Union[FillType, Dict[Type, FillType]] = 0,
+        fill: Union[features.FillType, Dict[Type, features.FillType]] = 0,
         padding_mode: Literal["constant", "edge", "reflect", "symmetric"] = "constant",
     ) -> None:
         super().__init__()
@@ -494,7 +491,7 @@ class RandomPerspective(_RandomApplyTransform):
     def __init__(
         self,
         distortion_scale: float = 0.5,
-        fill: Union[FillType, Dict[Type, FillType]] = 0,
+        fill: Union[features.FillType, Dict[Type, features.FillType]] = 0,
         interpolation: InterpolationMode = InterpolationMode.BILINEAR,
         p: float = 0.5,
     ) -> None:
@@ -570,7 +567,7 @@ def __init__(
         self,
         alpha: Union[float, Sequence[float]] = 50.0,
         sigma: Union[float, Sequence[float]] = 5.0,
-        fill: Union[FillType, Dict[Type, FillType]] = 0,
+        fill: Union[features.FillType, Dict[Type, features.FillType]] = 0,
         interpolation: InterpolationMode = InterpolationMode.BILINEAR,
     ) -> None:
         super().__init__()
@@ -783,7 +780,7 @@ class FixedSizeCrop(Transform):
     def __init__(
         self,
         size: Union[int, Sequence[int]],
-        fill: Union[FillType, Dict[Type, FillType]] = 0,
+        fill: Union[features.FillType, Dict[Type, features.FillType]] = 0,
         padding_mode: str = "constant",
     ) -> None:
         super().__init__()

torchvision/prototype/transforms/_meta.py

@@ -6,8 +6,6 @@
 from torchvision.prototype import features
 from torchvision.prototype.transforms import functional as F, Transform
 
-from ..features._image import ImageType, TensorImageType
-
 
 class ConvertBoundingBoxFormat(Transform):
     _transformed_types = (features.BoundingBox,)
@@ -30,7 +28,7 @@ def __init__(self, dtype: torch.dtype = torch.float32) -> None:
         super().__init__()
         self.dtype = dtype
 
-    def _transform(self, inpt: TensorImageType, params: Dict[str, Any]) -> TensorImageType:
+    def _transform(self, inpt: features.TensorImageType, params: Dict[str, Any]) -> features.TensorImageType:
         output = F.convert_image_dtype(inpt, dtype=self.dtype)
         return output if features.is_simple_tensor(inpt) else features.Image.new_like(inpt, output, dtype=self.dtype)  # type: ignore[arg-type]
 
@@ -56,7 +54,7 @@ def __init__(
 
         self.copy = copy
 
-    def _transform(self, inpt: ImageType, params: Dict[str, Any]) -> ImageType:
+    def _transform(self, inpt: features.ImageType, params: Dict[str, Any]) -> features.ImageType:
         return F.convert_color_space(
             inpt, color_space=self.color_space, old_color_space=self.old_color_space, copy=self.copy
         )

torchvision/prototype/transforms/_misc.py

@@ -8,8 +8,6 @@
 from torchvision.prototype import features
 from torchvision.prototype.transforms import functional as F, Transform
 
-from ..features._image import TensorImageType
-
 from ._utils import _setup_size, has_any, query_bounding_box
 
 
@@ -70,7 +68,7 @@ def forward(self, *inputs: Any) -> Any:
 
         return super().forward(*inputs)
 
-    def _transform(self, inpt: TensorImageType, params: Dict[str, Any]) -> torch.Tensor:
+    def _transform(self, inpt: features.TensorImageType, params: Dict[str, Any]) -> torch.Tensor:
         # Image instance after linear transformation is not Image anymore due to unknown data range
         # Thus we will return Tensor for input Image
 
@@ -103,7 +101,7 @@ def __init__(self, mean: Sequence[float], std: Sequence[float], inplace: bool =
         self.std = list(std)
         self.inplace = inplace
 
-    def _transform(self, inpt: TensorImageType, params: Dict[str, Any]) -> torch.Tensor:
+    def _transform(self, inpt: features.TensorImageType, params: Dict[str, Any]) -> torch.Tensor:
         return F.normalize(inpt, mean=self.mean, std=self.std, inplace=self.inplace)
 
     def forward(self, *inpts: Any) -> Any:

torchvision/prototype/transforms/functional/_augment.py

@@ -5,8 +5,6 @@
 from torchvision.transforms import functional_tensor as _FT
 from torchvision.transforms.functional import pil_to_tensor, to_pil_image
 
-from ...features._image import ImageTypeJIT
-
 erase_image_tensor = _FT.erase
 
 
@@ -20,14 +18,14 @@ def erase_image_pil(
 
 
 def erase(
-    inpt: ImageTypeJIT,
+    inpt: features.ImageTypeJIT,
     i: int,
     j: int,
     h: int,
     w: int,
     v: torch.Tensor,
     inplace: bool = False,
-) -> ImageTypeJIT:
+) -> features.ImageTypeJIT:
     if isinstance(inpt, torch.Tensor):
         output = erase_image_tensor(inpt, i=i, j=j, h=h, w=w, v=v, inplace=inplace)
         if not torch.jit.is_scripting() and isinstance(inpt, features.Image):