Add owlv2 fast processor (#39041)

* add owlv2 fast image processor

* add Owlv2ImageProcessorFast to Owlv2Processor image_processor_class

* add Owlv2ImageProcessorFast to Owlv2Processor image_processor_class

* change references to owlVit to owlv2 in docstrings for post process methods

* change type hints from List, Dict, Tuple to list, dict, tuple

* remove unused typing imports

* add disable grouping argument to group images by shape

* run make quality and repo-consistency

* use modular

* fix auto_docstring

---------

Co-authored-by: Lewis Marshall <lewism@elderda.co.uk>
Co-authored-by: yonigozlan <yoni.gozlan@huggingface.co>

tests/models/owlv2/test_image_processing_owlv2.py

@@ -16,7 +16,7 @@
 import unittest
 
 from transformers.testing_utils import require_torch, require_vision, slow
-from transformers.utils import is_torch_available, is_vision_available
+from transformers.utils import is_torch_available, is_torchvision_available, is_vision_available
 
 from ...test_image_processing_common import ImageProcessingTestMixin, prepare_image_inputs
 
@@ -29,6 +29,8 @@ if is_vision_available():
 if is_torch_available():
     import torch
 
+    from transformers import Owlv2ImageProcessorFast
+
 
 class Owlv2ImageProcessingTester:
     def __init__(
@@ -87,6 +89,7 @@ class Owlv2ImageProcessingTester:
 @require_vision
 class Owlv2ImageProcessingTest(ImageProcessingTestMixin, unittest.TestCase):
     image_processing_class = Owlv2ImageProcessor if is_vision_available() else None
+    fast_image_processing_class = Owlv2ImageProcessorFast if is_torchvision_available() else None
 
     def setUp(self):
         super().setUp()
@@ -97,76 +100,74 @@ class Owlv2ImageProcessingTest(ImageProcessingTestMixin, unittest.TestCase):
         return self.image_processor_tester.prepare_image_processor_dict()
 
     def test_image_processor_properties(self):
-        image_processing = self.image_processing_class(**self.image_processor_dict)
-        self.assertTrue(hasattr(image_processing, "do_resize"))
-        self.assertTrue(hasattr(image_processing, "size"))
-        self.assertTrue(hasattr(image_processing, "do_normalize"))
-        self.assertTrue(hasattr(image_processing, "image_mean"))
-        self.assertTrue(hasattr(image_processing, "image_std"))
+        for image_processing_class in self.image_processor_list:
+            image_processing = image_processing_class(**self.image_processor_dict)
+            self.assertTrue(hasattr(image_processing, "do_resize"))
+            self.assertTrue(hasattr(image_processing, "size"))
+            self.assertTrue(hasattr(image_processing, "do_normalize"))
+            self.assertTrue(hasattr(image_processing, "image_mean"))
+            self.assertTrue(hasattr(image_processing, "image_std"))
 
     def test_image_processor_from_dict_with_kwargs(self):
-        image_processor = self.image_processing_class.from_dict(self.image_processor_dict)
-        self.assertEqual(image_processor.size, {"height": 18, "width": 18})
+        for image_processing_class in self.image_processor_list:
+            image_processor = image_processing_class.from_dict(self.image_processor_dict)
+            self.assertEqual(image_processor.size, {"height": 18, "width": 18})
 
-        image_processor = self.image_processing_class.from_dict(
-            self.image_processor_dict, size={"height": 42, "width": 42}
-        )
-        self.assertEqual(image_processor.size, {"height": 42, "width": 42})
+            image_processor = image_processing_class.from_dict(
+                self.image_processor_dict, size={"height": 42, "width": 42}
+            )
+            self.assertEqual(image_processor.size, {"height": 42, "width": 42})
 
     @slow
     def test_image_processor_integration_test(self):
-        processor = Owlv2ImageProcessor()
+        for image_processing_class in self.image_processor_list:
+            processor = image_processing_class()
 
-        image = Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png")
-        pixel_values = processor(image, return_tensors="pt").pixel_values
+            image = Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png")
+            pixel_values = processor(image, return_tensors="pt").pixel_values
 
-        mean_value = round(pixel_values.mean().item(), 4)
-        self.assertEqual(mean_value, 0.2353)
+            mean_value = round(pixel_values.mean().item(), 4)
+            self.assertEqual(mean_value, 0.2353)
 
     @slow
     def test_image_processor_integration_test_resize(self):
-        checkpoint = "google/owlv2-base-patch16-ensemble"
-        processor = AutoProcessor.from_pretrained(checkpoint)
-        model = Owlv2ForObjectDetection.from_pretrained(checkpoint)
+        for use_fast in [False, True]:
+            checkpoint = "google/owlv2-base-patch16-ensemble"
+            processor = AutoProcessor.from_pretrained(checkpoint, use_fast=use_fast)
+            model = Owlv2ForObjectDetection.from_pretrained(checkpoint)
 
-        image = Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png")
-        text = ["cat"]
-        target_size = image.size[::-1]
-        expected_boxes = torch.tensor(
-            [
-                [341.66656494140625, 23.38756561279297, 642.321044921875, 371.3482971191406],
-                [6.753320693969727, 51.96149826049805, 326.61810302734375, 473.12982177734375],
-            ]
-        )
-
-        # single image
-        inputs = processor(text=[text], images=[image], return_tensors="pt")
-        with torch.no_grad():
-            outputs = model(**inputs)
-
-        results = processor.post_process_object_detection(outputs, threshold=0.2, target_sizes=[target_size])[0]
-
-        boxes = results["boxes"]
-        self.assertTrue(
-            torch.allclose(boxes, expected_boxes, atol=1e-2),
-            f"Single image bounding boxes fail. Expected {expected_boxes}, got {boxes}",
-        )
-
-        # batch of images
-        inputs = processor(text=[text, text], images=[image, image], return_tensors="pt")
-        with torch.no_grad():
-            outputs = model(**inputs)
-        results = processor.post_process_object_detection(
-            outputs, threshold=0.2, target_sizes=[target_size, target_size]
-        )
-
-        for result in results:
-            boxes = result["boxes"]
-            self.assertTrue(
-                torch.allclose(boxes, expected_boxes, atol=1e-2),
-                f"Batch image bounding boxes fail. Expected {expected_boxes}, got {boxes}",
+            image = Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png")
+            text = ["cat"]
+            target_size = image.size[::-1]
+            expected_boxes = torch.tensor(
+                [
+                    [341.66656494140625, 23.38756561279297, 642.321044921875, 371.3482971191406],
+                    [6.753320693969727, 51.96149826049805, 326.61810302734375, 473.12982177734375],
+                ]
             )
 
+            # single image
+            inputs = processor(text=[text], images=[image], return_tensors="pt")
+            with torch.no_grad():
+                outputs = model(**inputs)
+
+            results = processor.post_process_object_detection(outputs, threshold=0.2, target_sizes=[target_size])[0]
+
+            boxes = results["boxes"]
+            torch.testing.assert_close(boxes, expected_boxes, atol=1e-1, rtol=1e-1)
+
+            # batch of images
+            inputs = processor(text=[text, text], images=[image, image], return_tensors="pt")
+            with torch.no_grad():
+                outputs = model(**inputs)
+            results = processor.post_process_object_detection(
+                outputs, threshold=0.2, target_sizes=[target_size, target_size]
+            )
+
+            for result in results:
+                boxes = result["boxes"]
+                torch.testing.assert_close(boxes, expected_boxes, atol=1e-1, rtol=1e-1)
+
     @unittest.skip(reason="OWLv2 doesn't treat 4 channel PIL and numpy consistently yet")  # FIXME Amy
     def test_call_numpy_4_channels(self):
         pass