Merge branch 'main' into vanilla-tensor-image

Author: datumbox

.circleci/config.yml

@@ -84,9 +84,10 @@ def workflow_pair(btype, os_type, python_version, cu_version, unicode, prefix=""
 
     if upload:
         w.append(generate_upload_workflow(base_workflow_name, os_type, btype, cu_version, filter_branch=filter_branch))
-        if filter_branch == "nightly" and os_type in ["linux", "win"]:
-            pydistro = "pip" if btype == "wheel" else "conda"
-            w.append(generate_smoketest_workflow(pydistro, base_workflow_name, filter_branch, python_version, os_type))
+        # disable smoke tests, they are broken and needs to be fixed
+        # if filter_branch == "nightly" and os_type in ["linux", "win"]:
+        #     pydistro = "pip" if btype == "wheel" else "conda"
+        #     w.append(generate_smoketest_workflow(pydistro, base_workflow_name, filter_branch, python_version, os_type))
 
     return w
 

.circleci/regenerate.py

@@ -179,7 +179,7 @@ to::
     import torch
     from torchvision import datasets, transforms as T
 
-    transform = T.Compose([T.Resize(256), T.CenterCrop(224), T.ToTensor()])
+    transform = T.Compose([T.Resize(256), T.CenterCrop(224), T.PILToTensor(), T.ConvertImageDtype(torch.float)])
     dataset = datasets.ImageNet(".", split="train", transform=transform)
 
     means = []

docs/source/models.rst

@@ -41,7 +41,12 @@ def __call__(self, img, target):
 
 class DetectionPresetEval:
     def __init__(self):
-        self.transforms = T.ToTensor()
+        self.transforms = T.Compose(
+            [
+                T.PILToTensor(),
+                T.ConvertImageDtype(torch.float),
+            ]
+        )
 
     def __call__(self, img, target):
         return self.transforms(img, target)

references/detection/presets.py

@@ -45,15 +45,6 @@ def forward(
         return image, target
 
 
-class ToTensor(nn.Module):
-    def forward(
-        self, image: Tensor, target: Optional[Dict[str, Tensor]] = None
-    ) -> Tuple[Tensor, Optional[Dict[str, Tensor]]]:
-        image = F.pil_to_tensor(image)
-        image = F.convert_image_dtype(image)
-        return image, target
-
-
 class PILToTensor(nn.Module):
     def forward(
         self, image: Tensor, target: Optional[Dict[str, Tensor]] = None

references/detection/transforms.py

@@ -1,6 +1,7 @@
 import unittest
 from collections import defaultdict
 
+import torch
 import torchvision.transforms as transforms
 from sampler import PKSampler
 from torch.utils.data import DataLoader
@@ -17,7 +18,13 @@ def test_pksampler(self):
         self.assertRaises(AssertionError, PKSampler, targets, p, k)
 
         # Ensure p, k constraints on batch
-        dataset = FakeData(size=1000, num_classes=100, image_size=(3, 1, 1), transform=transforms.ToTensor())
+        trans = transforms.Compose(
+            [
+                transforms.PILToTensor(),
+                transforms.ConvertImageDtype(torch.float),
+            ]
+        )
+        dataset = FakeData(size=1000, num_classes=100, image_size=(3, 1, 1), transform=trans)
         targets = [target.item() for _, target in dataset]
         sampler = PKSampler(targets, p, k)
         loader = DataLoader(dataset, batch_size=p * k, sampler=sampler)

references/similarity/test.py

@@ -102,7 +102,12 @@ def main(args):
     optimizer = Adam(model.parameters(), lr=args.lr)
 
     transform = transforms.Compose(
-        [transforms.Lambda(lambda image: image.convert("RGB")), transforms.Resize((224, 224)), transforms.ToTensor()]
+        [
+            transforms.Lambda(lambda image: image.convert("RGB")),
+            transforms.Resize((224, 224)),
+            transforms.PILToTensor(),
+            transforms.ConvertImageDtype(torch.float),
+        ]
     )
 
     # Using FMNIST to demonstrate embedding learning using triplet loss. This dataset can

references/similarity/train.py

@@ -878,6 +878,34 @@ def celeba(info, root, config):
     return CelebAMockData.generate(root)[config.split]
 
 
+@register_mock
+def country211(info, root, config):
+    split_name_mapper = {
+        "train": "train",
+        "val": "valid",
+        "test": "test",
+    }
+    split_folder = pathlib.Path(root, "country211", split_name_mapper[config["split"]])
+    split_folder.mkdir(parents=True, exist_ok=True)
+
+    num_examples = {
+        "train": 3,
+        "val": 4,
+        "test": 5,
+    }[config["split"]]
+
+    classes = ("AD", "BS", "GR")
+    for cls in classes:
+        create_image_folder(
+            split_folder,
+            name=cls,
+            file_name_fn=lambda idx: f"{idx}.jpg",
+            num_examples=num_examples,
+        )
+    make_tar(root, f"{split_folder.parent.name}.tgz", split_folder.parent, compression="gz")
+    return num_examples * len(classes)
+
+
 @register_mock
 def dtd(info, root, config):
     data_folder = root / "dtd"
@@ -1299,6 +1327,24 @@ def cub200(info, root, config):
     return num_samples_map[config.split]
 
 
+@register_mock
+def eurosat(info, root, config):
+    data_folder = pathlib.Path(root, "eurosat", "2750")
+    data_folder.mkdir(parents=True)
+
+    num_examples_per_class = 3
+    classes = ("AnnualCrop", "Forest")
+    for cls in classes:
+        create_image_folder(
+            root=data_folder,
+            name=cls,
+            file_name_fn=lambda idx: f"{cls}_{idx}.jpg",
+            num_examples=num_examples_per_class,
+        )
+    make_zip(root, "EuroSAT.zip", data_folder)
+    return len(classes) * num_examples_per_class
+
+
 @register_mock
 def svhn(info, root, config):
     import scipy.io as sio

test/builtin_dataset_mocks.py

@@ -33,7 +33,8 @@
         [
             transforms.RandomSizedCrop(224),
             transforms.RandomHorizontalFlip(),
-            transforms.ToTensor(),
+            transforms.PILToTensor(),
+            transforms.ConvertImageDtype(torch.float),
             transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
         ]
     )

test/preprocess-bench.py

@@ -30,7 +30,8 @@ def read_image1():
     )
     image = Image.open(image_path)
     image = image.resize((224, 224))
-    x = F.to_tensor(image)
+    x = F.pil_to_tensor(image)
+    x = F.convert_image_dtype(x)
     return x.view(1, 3, 224, 224)
 
 
@@ -40,7 +41,8 @@ def read_image2():
     )
     image = Image.open(image_path)
     image = image.resize((299, 299))
-    x = F.to_tensor(image)
+    x = F.pil_to_tensor(image)
+    x = F.convert_image_dtype(x)
     x = x.view(1, 3, 299, 299)
     return torch.cat([x, x], 0)
 

test/sanity_checks.ipynb

@@ -413,13 +413,13 @@ def get_image(self, rel_path: str, size: Tuple[int, int]) -> torch.Tensor:
         import os
 
         from PIL import Image
-        from torchvision import transforms
+        from torchvision.transforms import functional as F
 
         data_dir = os.path.join(os.path.dirname(__file__), "assets")
         path = os.path.join(data_dir, *rel_path.split("/"))
         image = Image.open(path).convert("RGB").resize(size, Image.BILINEAR)
 
-        return transforms.ToTensor()(image)
+        return F.convert_image_dtype(F.pil_to_tensor(image))
 
     def get_test_images(self) -> Tuple[List[torch.Tensor], List[torch.Tensor]]:
         return (