From e2bd7f80d023b27bf3b93fa3d3f5ca941ff66572 Mon Sep 17 00:00:00 2001 From: amyeroberts <22614925+amyeroberts@users.noreply.github.com> Date: Mon, 23 Jan 2023 17:25:41 +0000 Subject: [PATCH] Update tests: replace feature extractor tests with image processor (#20768) * Update imports and test fetcher * Revert but keep test fetcher update * Fix imports * Fix all imports * Replace fe with ip names * Add generate kwargs to `AutomaticSpeechRecognitionPipeline` (#20952) * Add generate kwargs to AutomaticSpeechRecognitionPipeline * Add test for generation kwargs * Update image processor parameters if creating with kwargs (#20866) * Update parameters if creating with kwargs * Shallow copy to prevent mutating input * Pass all args in constructor dict - warnings in init * Fix typo * Rename tester class * Rebase and tidy up * Fixup * Use ImageProcessingSavingTestMixin * Update property ref in tests * Update property ref in tests * Update recently merged in models * Small fix Co-authored-by: bofeng huang --- .../models/beit/test_image_processing_beit.py | 197 ++++++++-------- .../models/blip/test_image_processing_blip.py | 148 ++++++------ .../test_image_processing_chinese_clip.py | 174 +++++++------- .../models/clip/test_image_processing_clip.py | 174 +++++++------- .../test_image_processing_conditional_detr.py | 133 ++++++----- .../test_image_processing_convnext.py | 117 +++++----- .../test_image_processing_deformable_detr.py | 137 ++++++----- .../models/deit/test_image_processing_deit.py | 123 +++++----- .../models/detr/test_image_processing_detr.py | 139 ++++++------ .../donut/test_image_processing_donut.py | 125 +++++----- tests/models/dpt/test_image_processing_dpt.py | 115 +++++----- .../test_image_processing_efficientformer.py | 103 +++++---- .../flava/test_image_processing_flava.py | 177 ++++++++------- .../models/glpn/test_image_processing_glpn.py | 73 +++--- .../test_image_processing_imagegpt.py | 90 ++++---- .../test_image_processing_layoutlmv2.py | 119 +++++----- .../test_image_processing_layoutlmv3.py | 119 +++++----- .../levit/test_image_processing_levit.py | 121 +++++----- .../test_image_processing_maskformer.py | 213 +++++++++--------- .../test_image_processing_mobilenet_v1.py | 117 +++++----- .../test_image_processing_mobilenet_v2.py | 117 +++++----- .../test_image_processing_mobilevit.py | 119 +++++----- .../test_image_processing_oneformer.py | 29 ++- .../owlvit/test_image_processing_owlvit.py | 125 +++++----- .../test_image_processing_poolformer.py | 121 +++++----- .../test_image_processing_segformer.py | 191 ++++++++-------- .../swin2sr/test_image_processing_swin2sr.py | 58 ++--- .../test_image_processing_videomae.py | 133 ++++++----- .../models/vilt/test_image_processing_vilt.py | 121 +++++----- tests/models/vit/test_image_processing_vit.py | 115 +++++----- .../yolos/test_image_processing_yolos.py | 133 ++++++----- 31 files changed, 1974 insertions(+), 2002 deletions(-) diff --git a/tests/models/beit/test_image_processing_beit.py b/tests/models/beit/test_image_processing_beit.py index b499f00845..95348bfe63 100644 --- a/tests/models/beit/test_image_processing_beit.py +++ b/tests/models/beit/test_image_processing_beit.py @@ -22,8 +22,7 @@ from datasets import load_dataset from transformers.testing_utils import require_torch, require_vision from transformers.utils import is_torch_available, is_vision_available -from ...test_feature_extraction_common import FeatureExtractionSavingTestMixin -from ...test_image_processing_common import prepare_image_inputs +from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs if is_torch_available(): @@ -32,10 +31,10 @@ if is_torch_available(): if is_vision_available(): from PIL import Image - from transformers import BeitFeatureExtractor + from transformers import BeitImageProcessor -class BeitFeatureExtractionTester(unittest.TestCase): +class BeitImageProcessingTester(unittest.TestCase): def __init__( self, parent, @@ -70,7 +69,7 @@ class BeitFeatureExtractionTester(unittest.TestCase): self.image_std = image_std self.do_reduce_labels = do_reduce_labels - def prepare_feat_extract_dict(self): + def prepare_image_processor_dict(self): return { "do_resize": self.do_resize, "size": self.size, @@ -105,166 +104,166 @@ def prepare_semantic_batch_inputs(): @require_torch @require_vision -class BeitFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestCase): +class BeitImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase): - feature_extraction_class = BeitFeatureExtractor if is_vision_available() else None + image_processing_class = BeitImageProcessor if is_vision_available() else None def setUp(self): - self.feature_extract_tester = BeitFeatureExtractionTester(self) + self.image_processor_tester = BeitImageProcessingTester(self) @property - def feat_extract_dict(self): - return self.feature_extract_tester.prepare_feat_extract_dict() + def image_processor_dict(self): + return self.image_processor_tester.prepare_image_processor_dict() - def test_feat_extract_properties(self): - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) - self.assertTrue(hasattr(feature_extractor, "do_resize")) - self.assertTrue(hasattr(feature_extractor, "size")) - self.assertTrue(hasattr(feature_extractor, "do_center_crop")) - self.assertTrue(hasattr(feature_extractor, "center_crop")) - self.assertTrue(hasattr(feature_extractor, "do_normalize")) - self.assertTrue(hasattr(feature_extractor, "image_mean")) - self.assertTrue(hasattr(feature_extractor, "image_std")) + 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_center_crop")) + self.assertTrue(hasattr(image_processing, "center_crop")) + self.assertTrue(hasattr(image_processing, "do_normalize")) + self.assertTrue(hasattr(image_processing, "image_mean")) + self.assertTrue(hasattr(image_processing, "image_std")) - def test_feat_extract_from_dict_with_kwargs(self): - feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict) - self.assertEqual(feature_extractor.size, {"height": 20, "width": 20}) - self.assertEqual(feature_extractor.crop_size, {"height": 18, "width": 18}) - self.assertEqual(feature_extractor.do_reduce_labels, False) + 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": 20, "width": 20}) + self.assertEqual(image_processor.crop_size, {"height": 18, "width": 18}) + self.assertEqual(image_processor.do_reduce_labels, False) - feature_extractor = self.feature_extraction_class.from_dict( - self.feat_extract_dict, size=42, crop_size=84, reduce_labels=True + image_processor = self.image_processing_class.from_dict( + self.image_processor_dict, size=42, crop_size=84, reduce_labels=True ) - self.assertEqual(feature_extractor.size, {"height": 42, "width": 42}) - self.assertEqual(feature_extractor.crop_size, {"height": 84, "width": 84}) - self.assertEqual(feature_extractor.do_reduce_labels, True) + self.assertEqual(image_processor.size, {"height": 42, "width": 42}) + self.assertEqual(image_processor.crop_size, {"height": 84, "width": 84}) + self.assertEqual(image_processor.do_reduce_labels, True) def test_batch_feature(self): pass def test_call_pil(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PIL images - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False) for image in image_inputs: self.assertIsInstance(image, Image.Image) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) def test_call_numpy(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random numpy tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, numpify=True) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, numpify=True) for image in image_inputs: self.assertIsInstance(image, np.ndarray) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) def test_call_pytorch(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PyTorch tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, torchify=True) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, torchify=True) for image in image_inputs: self.assertIsInstance(image, torch.Tensor) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) def test_call_segmentation_maps(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PyTorch tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, torchify=True) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, torchify=True) maps = [] for image in image_inputs: self.assertIsInstance(image, torch.Tensor) maps.append(torch.zeros(image.shape[-2:]).long()) # Test not batched input - encoding = feature_extractor(image_inputs[0], maps[0], return_tensors="pt") + encoding = image_processing(image_inputs[0], maps[0], return_tensors="pt") self.assertEqual( encoding["pixel_values"].shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) self.assertEqual( encoding["labels"].shape, ( 1, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) self.assertEqual(encoding["labels"].dtype, torch.long) @@ -272,22 +271,22 @@ class BeitFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestC self.assertTrue(encoding["labels"].max().item() <= 255) # Test batched - encoding = feature_extractor(image_inputs, maps, return_tensors="pt") + encoding = image_processing(image_inputs, maps, return_tensors="pt") self.assertEqual( encoding["pixel_values"].shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) self.assertEqual( encoding["labels"].shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) self.assertEqual(encoding["labels"].dtype, torch.long) @@ -297,22 +296,22 @@ class BeitFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestC # Test not batched input (PIL images) image, segmentation_map = prepare_semantic_single_inputs() - encoding = feature_extractor(image, segmentation_map, return_tensors="pt") + encoding = image_processing(image, segmentation_map, return_tensors="pt") self.assertEqual( encoding["pixel_values"].shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) self.assertEqual( encoding["labels"].shape, ( 1, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) self.assertEqual(encoding["labels"].dtype, torch.long) @@ -322,22 +321,22 @@ class BeitFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestC # Test batched input (PIL images) images, segmentation_maps = prepare_semantic_batch_inputs() - encoding = feature_extractor(images, segmentation_maps, return_tensors="pt") + encoding = image_processing(images, segmentation_maps, return_tensors="pt") self.assertEqual( encoding["pixel_values"].shape, ( 2, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) self.assertEqual( encoding["labels"].shape, ( 2, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) self.assertEqual(encoding["labels"].dtype, torch.long) @@ -345,16 +344,16 @@ class BeitFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestC self.assertTrue(encoding["labels"].max().item() <= 255) def test_reduce_labels(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # ADE20k has 150 classes, and the background is included, so labels should be between 0 and 150 image, map = prepare_semantic_single_inputs() - encoding = feature_extractor(image, map, return_tensors="pt") + encoding = image_processing(image, map, return_tensors="pt") self.assertTrue(encoding["labels"].min().item() >= 0) self.assertTrue(encoding["labels"].max().item() <= 150) - feature_extractor.reduce_labels = True - encoding = feature_extractor(image, map, return_tensors="pt") + image_processing.reduce_labels = True + encoding = image_processing(image, map, return_tensors="pt") self.assertTrue(encoding["labels"].min().item() >= 0) self.assertTrue(encoding["labels"].max().item() <= 255) diff --git a/tests/models/blip/test_image_processing_blip.py b/tests/models/blip/test_image_processing_blip.py index ea31038b14..f3f2ab21df 100644 --- a/tests/models/blip/test_image_processing_blip.py +++ b/tests/models/blip/test_image_processing_blip.py @@ -21,7 +21,7 @@ import numpy as np from transformers.testing_utils import require_torch, require_vision from transformers.utils import is_torch_available, is_vision_available -from ...test_feature_extraction_common import FeatureExtractionSavingTestMixin +from ...test_image_processing_common import ImageProcessingSavingTestMixin if is_torch_available(): @@ -65,7 +65,7 @@ class BlipImageProcessingTester(unittest.TestCase): self.do_pad = do_pad self.do_convert_rgb = do_convert_rgb - def prepare_feat_extract_dict(self): + def prepare_image_processor_dict(self): return { "do_resize": self.do_resize, "size": self.size, @@ -109,180 +109,180 @@ class BlipImageProcessingTester(unittest.TestCase): @require_torch @require_vision -class BlipImageProcessingTest(FeatureExtractionSavingTestMixin, unittest.TestCase): +class BlipImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase): - feature_extraction_class = BlipImageProcessor if is_vision_available() else None + image_processing_class = BlipImageProcessor if is_vision_available() else None def setUp(self): - self.feature_extract_tester = BlipImageProcessingTester(self) + self.image_processor_tester = BlipImageProcessingTester(self) @property - def feat_extract_dict(self): - return self.feature_extract_tester.prepare_feat_extract_dict() + def image_processor_dict(self): + return self.image_processor_tester.prepare_image_processor_dict() - def test_feat_extract_properties(self): - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) - self.assertTrue(hasattr(feature_extractor, "do_resize")) - self.assertTrue(hasattr(feature_extractor, "size")) - self.assertTrue(hasattr(feature_extractor, "do_normalize")) - self.assertTrue(hasattr(feature_extractor, "image_mean")) - self.assertTrue(hasattr(feature_extractor, "image_std")) - self.assertTrue(hasattr(feature_extractor, "do_convert_rgb")) + def test_image_processor_properties(self): + image_processor = self.image_processing_class(**self.image_processor_dict) + self.assertTrue(hasattr(image_processor, "do_resize")) + self.assertTrue(hasattr(image_processor, "size")) + self.assertTrue(hasattr(image_processor, "do_normalize")) + self.assertTrue(hasattr(image_processor, "image_mean")) + self.assertTrue(hasattr(image_processor, "image_std")) + self.assertTrue(hasattr(image_processor, "do_convert_rgb")) def test_batch_feature(self): pass def test_call_pil(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processor + image_processor = self.image_processing_class(**self.image_processor_dict) # create random PIL images - image_inputs = self.feature_extract_tester.prepare_inputs(equal_resolution=False) + image_inputs = self.image_processor_tester.prepare_inputs(equal_resolution=False) for image in image_inputs: self.assertIsInstance(image, Image.Image) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processor(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.size["height"], + self.image_processor_tester.size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processor(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.size["height"], + self.image_processor_tester.size["width"], ), ) def test_call_numpy(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processor + image_processor = self.image_processing_class(**self.image_processor_dict) # create random numpy tensors - image_inputs = self.feature_extract_tester.prepare_inputs(equal_resolution=False, numpify=True) + image_inputs = self.image_processor_tester.prepare_inputs(equal_resolution=False, numpify=True) for image in image_inputs: self.assertIsInstance(image, np.ndarray) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processor(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.size["height"], + self.image_processor_tester.size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processor(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.size["height"], + self.image_processor_tester.size["width"], ), ) def test_call_pytorch(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processor + image_processor = self.image_processing_class(**self.image_processor_dict) # create random PyTorch tensors - image_inputs = self.feature_extract_tester.prepare_inputs(equal_resolution=False, torchify=True) + image_inputs = self.image_processor_tester.prepare_inputs(equal_resolution=False, torchify=True) for image in image_inputs: self.assertIsInstance(image, torch.Tensor) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processor(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.size["height"], + self.image_processor_tester.size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processor(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.size["height"], + self.image_processor_tester.size["width"], ), ) @require_torch @require_vision -class BlipImageProcessingTestFourChannels(FeatureExtractionSavingTestMixin, unittest.TestCase): +class BlipImageProcessingTestFourChannels(ImageProcessingSavingTestMixin, unittest.TestCase): - feature_extraction_class = BlipImageProcessor if is_vision_available() else None + image_processing_class = BlipImageProcessor if is_vision_available() else None def setUp(self): - self.feature_extract_tester = BlipImageProcessingTester(self, num_channels=4) + self.image_processor_tester = BlipImageProcessingTester(self, num_channels=4) self.expected_encoded_image_num_channels = 3 @property - def feat_extract_dict(self): - return self.feature_extract_tester.prepare_feat_extract_dict() + def image_processor_dict(self): + return self.image_processor_tester.prepare_image_processor_dict() - def test_feat_extract_properties(self): - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) - self.assertTrue(hasattr(feature_extractor, "do_resize")) - self.assertTrue(hasattr(feature_extractor, "size")) - self.assertTrue(hasattr(feature_extractor, "do_normalize")) - self.assertTrue(hasattr(feature_extractor, "image_mean")) - self.assertTrue(hasattr(feature_extractor, "image_std")) - self.assertTrue(hasattr(feature_extractor, "do_convert_rgb")) + def test_image_processor_properties(self): + image_processor = self.image_processing_class(**self.image_processor_dict) + self.assertTrue(hasattr(image_processor, "do_resize")) + self.assertTrue(hasattr(image_processor, "size")) + self.assertTrue(hasattr(image_processor, "do_normalize")) + self.assertTrue(hasattr(image_processor, "image_mean")) + self.assertTrue(hasattr(image_processor, "image_std")) + self.assertTrue(hasattr(image_processor, "do_convert_rgb")) def test_batch_feature(self): pass def test_call_pil_four_channels(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processor + image_processor = self.image_processing_class(**self.image_processor_dict) # create random PIL images - image_inputs = self.feature_extract_tester.prepare_inputs(equal_resolution=False) + image_inputs = self.image_processor_tester.prepare_inputs(equal_resolution=False) for image in image_inputs: self.assertIsInstance(image, Image.Image) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processor(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, self.expected_encoded_image_num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_processor_tester.size["height"], + self.image_processor_tester.size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processor(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, + self.image_processor_tester.batch_size, self.expected_encoded_image_num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_processor_tester.size["height"], + self.image_processor_tester.size["width"], ), ) diff --git a/tests/models/chinese_clip/test_image_processing_chinese_clip.py b/tests/models/chinese_clip/test_image_processing_chinese_clip.py index 616dfa3ffc..b7b3135071 100644 --- a/tests/models/chinese_clip/test_image_processing_chinese_clip.py +++ b/tests/models/chinese_clip/test_image_processing_chinese_clip.py @@ -21,7 +21,7 @@ import numpy as np from transformers.testing_utils import require_torch, require_vision from transformers.utils import is_torch_available, is_vision_available -from ...test_feature_extraction_common import FeatureExtractionSavingTestMixin +from ...test_image_processing_common import ImageProcessingSavingTestMixin if is_torch_available(): @@ -30,10 +30,10 @@ if is_torch_available(): if is_vision_available(): from PIL import Image - from transformers import ChineseCLIPFeatureExtractor + from transformers import ChineseCLIPImageProcessor -class ChineseCLIPFeatureExtractionTester(unittest.TestCase): +class ChineseCLIPImageProcessingTester(unittest.TestCase): def __init__( self, parent, @@ -68,7 +68,7 @@ class ChineseCLIPFeatureExtractionTester(unittest.TestCase): self.image_std = image_std self.do_convert_rgb = do_convert_rgb - def prepare_feat_extract_dict(self): + def prepare_image_processor_dict(self): return { "do_resize": self.do_resize, "size": self.size, @@ -113,193 +113,193 @@ class ChineseCLIPFeatureExtractionTester(unittest.TestCase): @require_torch @require_vision -class ChineseCLIPFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestCase): +class ChineseCLIPImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase): - feature_extraction_class = ChineseCLIPFeatureExtractor if is_vision_available() else None + image_processing_class = ChineseCLIPImageProcessor if is_vision_available() else None def setUp(self): - self.feature_extract_tester = ChineseCLIPFeatureExtractionTester(self, do_center_crop=True) + self.image_processor_tester = ChineseCLIPImageProcessingTester(self, do_center_crop=True) @property - def feat_extract_dict(self): - return self.feature_extract_tester.prepare_feat_extract_dict() + def image_processor_dict(self): + return self.image_processor_tester.prepare_image_processor_dict() - def test_feat_extract_properties(self): - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) - self.assertTrue(hasattr(feature_extractor, "do_resize")) - self.assertTrue(hasattr(feature_extractor, "size")) - self.assertTrue(hasattr(feature_extractor, "do_center_crop")) - self.assertTrue(hasattr(feature_extractor, "center_crop")) - self.assertTrue(hasattr(feature_extractor, "do_normalize")) - self.assertTrue(hasattr(feature_extractor, "image_mean")) - self.assertTrue(hasattr(feature_extractor, "image_std")) - self.assertTrue(hasattr(feature_extractor, "do_convert_rgb")) + 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_center_crop")) + self.assertTrue(hasattr(image_processing, "center_crop")) + self.assertTrue(hasattr(image_processing, "do_normalize")) + self.assertTrue(hasattr(image_processing, "image_mean")) + self.assertTrue(hasattr(image_processing, "image_std")) + self.assertTrue(hasattr(image_processing, "do_convert_rgb")) - def test_feat_extract_from_dict_with_kwargs(self): - feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict) - self.assertEqual(feature_extractor.size, {"height": 224, "width": 224}) - self.assertEqual(feature_extractor.crop_size, {"height": 18, "width": 18}) + 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": 224, "width": 224}) + self.assertEqual(image_processor.crop_size, {"height": 18, "width": 18}) - feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict, size=42, crop_size=84) - self.assertEqual(feature_extractor.size, {"shortest_edge": 42}) - self.assertEqual(feature_extractor.crop_size, {"height": 84, "width": 84}) + image_processor = self.image_processing_class.from_dict(self.image_processor_dict, size=42, crop_size=84) + self.assertEqual(image_processor.size, {"shortest_edge": 42}) + self.assertEqual(image_processor.crop_size, {"height": 84, "width": 84}) def test_batch_feature(self): pass def test_call_pil(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PIL images - image_inputs = self.feature_extract_tester.prepare_inputs(equal_resolution=False) + image_inputs = self.image_processor_tester.prepare_inputs(equal_resolution=False) for image in image_inputs: self.assertIsInstance(image, Image.Image) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) def test_call_numpy(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random numpy tensors - image_inputs = self.feature_extract_tester.prepare_inputs(equal_resolution=False, numpify=True) + image_inputs = self.image_processor_tester.prepare_inputs(equal_resolution=False, numpify=True) for image in image_inputs: self.assertIsInstance(image, np.ndarray) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) def test_call_pytorch(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PyTorch tensors - image_inputs = self.feature_extract_tester.prepare_inputs(equal_resolution=False, torchify=True) + image_inputs = self.image_processor_tester.prepare_inputs(equal_resolution=False, torchify=True) for image in image_inputs: self.assertIsInstance(image, torch.Tensor) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) @require_torch @require_vision -class ChineseCLIPFeatureExtractionTestFourChannels(FeatureExtractionSavingTestMixin, unittest.TestCase): +class ChineseCLIPImageProcessingTestFourChannels(ImageProcessingSavingTestMixin, unittest.TestCase): - feature_extraction_class = ChineseCLIPFeatureExtractor if is_vision_available() else None + image_processing_class = ChineseCLIPImageProcessor if is_vision_available() else None def setUp(self): - self.feature_extract_tester = ChineseCLIPFeatureExtractionTester(self, num_channels=4, do_center_crop=True) + self.image_processor_tester = ChineseCLIPImageProcessingTester(self, num_channels=4, do_center_crop=True) self.expected_encoded_image_num_channels = 3 @property - def feat_extract_dict(self): - return self.feature_extract_tester.prepare_feat_extract_dict() + def image_processor_dict(self): + return self.image_processor_tester.prepare_image_processor_dict() - def test_feat_extract_properties(self): - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) - self.assertTrue(hasattr(feature_extractor, "do_resize")) - self.assertTrue(hasattr(feature_extractor, "size")) - self.assertTrue(hasattr(feature_extractor, "do_center_crop")) - self.assertTrue(hasattr(feature_extractor, "center_crop")) - self.assertTrue(hasattr(feature_extractor, "do_normalize")) - self.assertTrue(hasattr(feature_extractor, "image_mean")) - self.assertTrue(hasattr(feature_extractor, "image_std")) - self.assertTrue(hasattr(feature_extractor, "do_convert_rgb")) + 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_center_crop")) + self.assertTrue(hasattr(image_processing, "center_crop")) + self.assertTrue(hasattr(image_processing, "do_normalize")) + self.assertTrue(hasattr(image_processing, "image_mean")) + self.assertTrue(hasattr(image_processing, "image_std")) + self.assertTrue(hasattr(image_processing, "do_convert_rgb")) def test_batch_feature(self): pass def test_call_pil_four_channels(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PIL images - image_inputs = self.feature_extract_tester.prepare_inputs(equal_resolution=False) + image_inputs = self.image_processor_tester.prepare_inputs(equal_resolution=False) for image in image_inputs: self.assertIsInstance(image, Image.Image) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, self.expected_encoded_image_num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, + self.image_processor_tester.batch_size, self.expected_encoded_image_num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) diff --git a/tests/models/clip/test_image_processing_clip.py b/tests/models/clip/test_image_processing_clip.py index 8f29b63bbb..7ffaceb54c 100644 --- a/tests/models/clip/test_image_processing_clip.py +++ b/tests/models/clip/test_image_processing_clip.py @@ -21,7 +21,7 @@ import numpy as np from transformers.testing_utils import require_torch, require_vision from transformers.utils import is_torch_available, is_vision_available -from ...test_feature_extraction_common import FeatureExtractionSavingTestMixin +from ...test_image_processing_common import ImageProcessingSavingTestMixin if is_torch_available(): @@ -30,10 +30,10 @@ if is_torch_available(): if is_vision_available(): from PIL import Image - from transformers import CLIPFeatureExtractor + from transformers import CLIPImageProcessor -class CLIPFeatureExtractionTester(unittest.TestCase): +class CLIPImageProcessingTester(unittest.TestCase): def __init__( self, parent, @@ -68,7 +68,7 @@ class CLIPFeatureExtractionTester(unittest.TestCase): self.image_std = image_std self.do_convert_rgb = do_convert_rgb - def prepare_feat_extract_dict(self): + def prepare_image_processor_dict(self): return { "do_resize": self.do_resize, "size": self.size, @@ -113,193 +113,193 @@ class CLIPFeatureExtractionTester(unittest.TestCase): @require_torch @require_vision -class CLIPFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestCase): +class CLIPImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase): - feature_extraction_class = CLIPFeatureExtractor if is_vision_available() else None + image_processing_class = CLIPImageProcessor if is_vision_available() else None def setUp(self): - self.feature_extract_tester = CLIPFeatureExtractionTester(self) + self.image_processor_tester = CLIPImageProcessingTester(self) @property - def feat_extract_dict(self): - return self.feature_extract_tester.prepare_feat_extract_dict() + def image_processor_dict(self): + return self.image_processor_tester.prepare_image_processor_dict() - def test_feat_extract_properties(self): - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) - self.assertTrue(hasattr(feature_extractor, "do_resize")) - self.assertTrue(hasattr(feature_extractor, "size")) - self.assertTrue(hasattr(feature_extractor, "do_center_crop")) - self.assertTrue(hasattr(feature_extractor, "center_crop")) - self.assertTrue(hasattr(feature_extractor, "do_normalize")) - self.assertTrue(hasattr(feature_extractor, "image_mean")) - self.assertTrue(hasattr(feature_extractor, "image_std")) - self.assertTrue(hasattr(feature_extractor, "do_convert_rgb")) + 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_center_crop")) + self.assertTrue(hasattr(image_processing, "center_crop")) + self.assertTrue(hasattr(image_processing, "do_normalize")) + self.assertTrue(hasattr(image_processing, "image_mean")) + self.assertTrue(hasattr(image_processing, "image_std")) + self.assertTrue(hasattr(image_processing, "do_convert_rgb")) - def test_feat_extract_from_dict_with_kwargs(self): - feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict) - self.assertEqual(feature_extractor.size, {"shortest_edge": 20}) - self.assertEqual(feature_extractor.crop_size, {"height": 18, "width": 18}) + 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, {"shortest_edge": 20}) + self.assertEqual(image_processor.crop_size, {"height": 18, "width": 18}) - feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict, size=42, crop_size=84) - self.assertEqual(feature_extractor.size, {"shortest_edge": 42}) - self.assertEqual(feature_extractor.crop_size, {"height": 84, "width": 84}) + image_processor = self.image_processing_class.from_dict(self.image_processor_dict, size=42, crop_size=84) + self.assertEqual(image_processor.size, {"shortest_edge": 42}) + self.assertEqual(image_processor.crop_size, {"height": 84, "width": 84}) def test_batch_feature(self): pass def test_call_pil(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PIL images - image_inputs = self.feature_extract_tester.prepare_inputs(equal_resolution=False) + image_inputs = self.image_processor_tester.prepare_inputs(equal_resolution=False) for image in image_inputs: self.assertIsInstance(image, Image.Image) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) def test_call_numpy(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random numpy tensors - image_inputs = self.feature_extract_tester.prepare_inputs(equal_resolution=False, numpify=True) + image_inputs = self.image_processor_tester.prepare_inputs(equal_resolution=False, numpify=True) for image in image_inputs: self.assertIsInstance(image, np.ndarray) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) def test_call_pytorch(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PyTorch tensors - image_inputs = self.feature_extract_tester.prepare_inputs(equal_resolution=False, torchify=True) + image_inputs = self.image_processor_tester.prepare_inputs(equal_resolution=False, torchify=True) for image in image_inputs: self.assertIsInstance(image, torch.Tensor) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) @require_torch @require_vision -class CLIPFeatureExtractionTestFourChannels(FeatureExtractionSavingTestMixin, unittest.TestCase): +class CLIPImageProcessingTestFourChannels(ImageProcessingSavingTestMixin, unittest.TestCase): - feature_extraction_class = CLIPFeatureExtractor if is_vision_available() else None + image_processing_class = CLIPImageProcessor if is_vision_available() else None def setUp(self): - self.feature_extract_tester = CLIPFeatureExtractionTester(self, num_channels=4) + self.image_processor_tester = CLIPImageProcessingTester(self, num_channels=4) self.expected_encoded_image_num_channels = 3 @property - def feat_extract_dict(self): - return self.feature_extract_tester.prepare_feat_extract_dict() + def image_processor_dict(self): + return self.image_processor_tester.prepare_image_processor_dict() - def test_feat_extract_properties(self): - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) - self.assertTrue(hasattr(feature_extractor, "do_resize")) - self.assertTrue(hasattr(feature_extractor, "size")) - self.assertTrue(hasattr(feature_extractor, "do_center_crop")) - self.assertTrue(hasattr(feature_extractor, "center_crop")) - self.assertTrue(hasattr(feature_extractor, "do_normalize")) - self.assertTrue(hasattr(feature_extractor, "image_mean")) - self.assertTrue(hasattr(feature_extractor, "image_std")) - self.assertTrue(hasattr(feature_extractor, "do_convert_rgb")) + 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_center_crop")) + self.assertTrue(hasattr(image_processing, "center_crop")) + self.assertTrue(hasattr(image_processing, "do_normalize")) + self.assertTrue(hasattr(image_processing, "image_mean")) + self.assertTrue(hasattr(image_processing, "image_std")) + self.assertTrue(hasattr(image_processing, "do_convert_rgb")) def test_batch_feature(self): pass def test_call_pil_four_channels(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PIL images - image_inputs = self.feature_extract_tester.prepare_inputs(equal_resolution=False) + image_inputs = self.image_processor_tester.prepare_inputs(equal_resolution=False) for image in image_inputs: self.assertIsInstance(image, Image.Image) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, self.expected_encoded_image_num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, + self.image_processor_tester.batch_size, self.expected_encoded_image_num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) diff --git a/tests/models/conditional_detr/test_image_processing_conditional_detr.py b/tests/models/conditional_detr/test_image_processing_conditional_detr.py index b4e6f46d3e..f93d3cabbf 100644 --- a/tests/models/conditional_detr/test_image_processing_conditional_detr.py +++ b/tests/models/conditional_detr/test_image_processing_conditional_detr.py @@ -23,8 +23,7 @@ import numpy as np from transformers.testing_utils import require_torch, require_vision, slow from transformers.utils import is_torch_available, is_vision_available -from ...test_feature_extraction_common import FeatureExtractionSavingTestMixin -from ...test_image_processing_common import prepare_image_inputs +from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs if is_torch_available(): @@ -33,10 +32,10 @@ if is_torch_available(): if is_vision_available(): from PIL import Image - from transformers import ConditionalDetrFeatureExtractor + from transformers import ConditionalDetrImageProcessor -class ConditionalDetrFeatureExtractionTester(unittest.TestCase): +class ConditionalDetrImageProcessingTester(unittest.TestCase): def __init__( self, parent, @@ -69,7 +68,7 @@ class ConditionalDetrFeatureExtractionTester(unittest.TestCase): self.rescale_factor = rescale_factor self.do_pad = do_pad - def prepare_feat_extract_dict(self): + def prepare_image_processor_dict(self): return { "do_resize": self.do_resize, "size": self.size, @@ -83,7 +82,7 @@ class ConditionalDetrFeatureExtractionTester(unittest.TestCase): def get_expected_values(self, image_inputs, batched=False): """ - This function computes the expected height and width when providing images to ConditionalDetrFeatureExtractor, + This function computes the expected height and width when providing images to ConditionalDetrImageProcessor, assuming do_resize is set to True with a scalar size. """ if not batched: @@ -115,149 +114,149 @@ class ConditionalDetrFeatureExtractionTester(unittest.TestCase): @require_torch @require_vision -class ConditionalDetrFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestCase): +class ConditionalDetrImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase): - feature_extraction_class = ConditionalDetrFeatureExtractor if is_vision_available() else None + image_processing_class = ConditionalDetrImageProcessor if is_vision_available() else None def setUp(self): - self.feature_extract_tester = ConditionalDetrFeatureExtractionTester(self) + self.image_processor_tester = ConditionalDetrImageProcessingTester(self) @property - def feat_extract_dict(self): - return self.feature_extract_tester.prepare_feat_extract_dict() + def image_processor_dict(self): + return self.image_processor_tester.prepare_image_processor_dict() - def test_feat_extract_properties(self): - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) - self.assertTrue(hasattr(feature_extractor, "image_mean")) - self.assertTrue(hasattr(feature_extractor, "image_std")) - self.assertTrue(hasattr(feature_extractor, "do_normalize")) - self.assertTrue(hasattr(feature_extractor, "do_resize")) - self.assertTrue(hasattr(feature_extractor, "size")) + def test_image_processor_properties(self): + image_processing = self.image_processing_class(**self.image_processor_dict) + self.assertTrue(hasattr(image_processing, "image_mean")) + self.assertTrue(hasattr(image_processing, "image_std")) + self.assertTrue(hasattr(image_processing, "do_normalize")) + self.assertTrue(hasattr(image_processing, "do_resize")) + self.assertTrue(hasattr(image_processing, "size")) - def test_feat_extract_from_dict_with_kwargs(self): - feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict) - self.assertEqual(feature_extractor.size, {"shortest_edge": 18, "longest_edge": 1333}) - self.assertEqual(feature_extractor.do_pad, True) + 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, {"shortest_edge": 18, "longest_edge": 1333}) + self.assertEqual(image_processor.do_pad, True) - feature_extractor = self.feature_extraction_class.from_dict( - self.feat_extract_dict, size=42, max_size=84, pad_and_return_pixel_mask=False + image_processor = self.image_processing_class.from_dict( + self.image_processor_dict, size=42, max_size=84, pad_and_return_pixel_mask=False ) - self.assertEqual(feature_extractor.size, {"shortest_edge": 42, "longest_edge": 84}) - self.assertEqual(feature_extractor.do_pad, False) + self.assertEqual(image_processor.size, {"shortest_edge": 42, "longest_edge": 84}) + self.assertEqual(image_processor.do_pad, False) def test_batch_feature(self): pass def test_call_pil(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PIL images - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False) for image in image_inputs: self.assertIsInstance(image, Image.Image) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values - expected_height, expected_width = self.feature_extract_tester.get_expected_values(image_inputs) + expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs) self.assertEqual( encoded_images.shape, - (1, self.feature_extract_tester.num_channels, expected_height, expected_width), + (1, self.image_processor_tester.num_channels, expected_height, expected_width), ) # Test batched - expected_height, expected_width = self.feature_extract_tester.get_expected_values(image_inputs, batched=True) + expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs, batched=True) - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, expected_height, expected_width, ), ) def test_call_numpy(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random numpy tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, numpify=True) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, numpify=True) for image in image_inputs: self.assertIsInstance(image, np.ndarray) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values - expected_height, expected_width = self.feature_extract_tester.get_expected_values(image_inputs) + expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs) self.assertEqual( encoded_images.shape, - (1, self.feature_extract_tester.num_channels, expected_height, expected_width), + (1, self.image_processor_tester.num_channels, expected_height, expected_width), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values - expected_height, expected_width = self.feature_extract_tester.get_expected_values(image_inputs, batched=True) + expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs, batched=True) self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, expected_height, expected_width, ), ) def test_call_pytorch(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PyTorch tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, torchify=True) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, torchify=True) for image in image_inputs: self.assertIsInstance(image, torch.Tensor) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values - expected_height, expected_width = self.feature_extract_tester.get_expected_values(image_inputs) + expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs) self.assertEqual( encoded_images.shape, - (1, self.feature_extract_tester.num_channels, expected_height, expected_width), + (1, self.image_processor_tester.num_channels, expected_height, expected_width), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values - expected_height, expected_width = self.feature_extract_tester.get_expected_values(image_inputs, batched=True) + expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs, batched=True) self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, expected_height, expected_width, ), ) def test_equivalence_pad_and_create_pixel_mask(self): - # Initialize feature_extractors - feature_extractor_1 = self.feature_extraction_class(**self.feat_extract_dict) - feature_extractor_2 = self.feature_extraction_class(do_resize=False, do_normalize=False, do_rescale=False) + # Initialize image_processings + image_processing_1 = self.image_processing_class(**self.image_processor_dict) + image_processing_2 = self.image_processing_class(do_resize=False, do_normalize=False, do_rescale=False) # create random PyTorch tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, torchify=True) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, torchify=True) for image in image_inputs: self.assertIsInstance(image, torch.Tensor) - # Test whether the method "pad_and_return_pixel_mask" and calling the feature extractor return the same tensors - encoded_images_with_method = feature_extractor_1.pad_and_create_pixel_mask(image_inputs, return_tensors="pt") - encoded_images = feature_extractor_2(image_inputs, return_tensors="pt") + # Test whether the method "pad_and_return_pixel_mask" and calling the image processor return the same tensors + encoded_images_with_method = image_processing_1.pad_and_create_pixel_mask(image_inputs, return_tensors="pt") + encoded_images = image_processing_2(image_inputs, return_tensors="pt") self.assertTrue( torch.allclose(encoded_images_with_method["pixel_values"], encoded_images["pixel_values"], atol=1e-4) @@ -276,8 +275,8 @@ class ConditionalDetrFeatureExtractionTest(FeatureExtractionSavingTestMixin, uni target = {"image_id": 39769, "annotations": target} # encode them - feature_extractor = ConditionalDetrFeatureExtractor.from_pretrained("microsoft/conditional-detr-resnet-50") - encoding = feature_extractor(images=image, annotations=target, return_tensors="pt") + image_processing = ConditionalDetrImageProcessor.from_pretrained("microsoft/conditional-detr-resnet-50") + encoding = image_processing(images=image, annotations=target, return_tensors="pt") # verify pixel values expected_shape = torch.Size([1, 3, 800, 1066]) @@ -322,8 +321,8 @@ class ConditionalDetrFeatureExtractionTest(FeatureExtractionSavingTestMixin, uni masks_path = pathlib.Path("./tests/fixtures/tests_samples/COCO/coco_panoptic") # encode them - feature_extractor = ConditionalDetrFeatureExtractor(format="coco_panoptic") - encoding = feature_extractor(images=image, annotations=target, masks_path=masks_path, return_tensors="pt") + image_processing = ConditionalDetrImageProcessor(format="coco_panoptic") + encoding = image_processing(images=image, annotations=target, masks_path=masks_path, return_tensors="pt") # verify pixel values expected_shape = torch.Size([1, 3, 800, 1066]) diff --git a/tests/models/convnext/test_image_processing_convnext.py b/tests/models/convnext/test_image_processing_convnext.py index 4fd62fc51d..da7d28e64d 100644 --- a/tests/models/convnext/test_image_processing_convnext.py +++ b/tests/models/convnext/test_image_processing_convnext.py @@ -21,8 +21,7 @@ import numpy as np from transformers.testing_utils import require_torch, require_vision from transformers.utils import is_torch_available, is_vision_available -from ...test_feature_extraction_common import FeatureExtractionSavingTestMixin -from ...test_image_processing_common import prepare_image_inputs +from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs if is_torch_available(): @@ -31,10 +30,10 @@ if is_torch_available(): if is_vision_available(): from PIL import Image - from transformers import ConvNextFeatureExtractor + from transformers import ConvNextImageProcessor -class ConvNextFeatureExtractionTester(unittest.TestCase): +class ConvNextImageProcessingTester(unittest.TestCase): def __init__( self, parent, @@ -64,7 +63,7 @@ class ConvNextFeatureExtractionTester(unittest.TestCase): self.image_mean = image_mean self.image_std = image_std - def prepare_feat_extract_dict(self): + def prepare_image_processor_dict(self): return { "image_mean": self.image_mean, "image_std": self.image_std, @@ -77,128 +76,128 @@ class ConvNextFeatureExtractionTester(unittest.TestCase): @require_torch @require_vision -class ConvNextFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestCase): +class ConvNextImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase): - feature_extraction_class = ConvNextFeatureExtractor if is_vision_available() else None + image_processing_class = ConvNextImageProcessor if is_vision_available() else None def setUp(self): - self.feature_extract_tester = ConvNextFeatureExtractionTester(self) + self.image_processor_tester = ConvNextImageProcessingTester(self) @property - def feat_extract_dict(self): - return self.feature_extract_tester.prepare_feat_extract_dict() + def image_processor_dict(self): + return self.image_processor_tester.prepare_image_processor_dict() - def test_feat_extract_properties(self): - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) - self.assertTrue(hasattr(feature_extractor, "do_resize")) - self.assertTrue(hasattr(feature_extractor, "size")) - self.assertTrue(hasattr(feature_extractor, "crop_pct")) - self.assertTrue(hasattr(feature_extractor, "do_normalize")) - self.assertTrue(hasattr(feature_extractor, "image_mean")) - self.assertTrue(hasattr(feature_extractor, "image_std")) + 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, "crop_pct")) + self.assertTrue(hasattr(image_processing, "do_normalize")) + self.assertTrue(hasattr(image_processing, "image_mean")) + self.assertTrue(hasattr(image_processing, "image_std")) - def test_feat_extract_from_dict_with_kwargs(self): - feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict) - self.assertEqual(feature_extractor.size, {"shortest_edge": 20}) + 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, {"shortest_edge": 20}) - feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict, size=42) - self.assertEqual(feature_extractor.size, {"shortest_edge": 42}) + image_processor = self.image_processing_class.from_dict(self.image_processor_dict, size=42) + self.assertEqual(image_processor.size, {"shortest_edge": 42}) def test_batch_feature(self): pass def test_call_pil(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PIL images - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False) for image in image_inputs: self.assertIsInstance(image, Image.Image) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["shortest_edge"], - self.feature_extract_tester.size["shortest_edge"], + self.image_processor_tester.num_channels, + self.image_processor_tester.size["shortest_edge"], + self.image_processor_tester.size["shortest_edge"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["shortest_edge"], - self.feature_extract_tester.size["shortest_edge"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.size["shortest_edge"], + self.image_processor_tester.size["shortest_edge"], ), ) def test_call_numpy(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random numpy tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, numpify=True) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, numpify=True) for image in image_inputs: self.assertIsInstance(image, np.ndarray) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["shortest_edge"], - self.feature_extract_tester.size["shortest_edge"], + self.image_processor_tester.num_channels, + self.image_processor_tester.size["shortest_edge"], + self.image_processor_tester.size["shortest_edge"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["shortest_edge"], - self.feature_extract_tester.size["shortest_edge"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.size["shortest_edge"], + self.image_processor_tester.size["shortest_edge"], ), ) def test_call_pytorch(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PyTorch tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, torchify=True) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, torchify=True) for image in image_inputs: self.assertIsInstance(image, torch.Tensor) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["shortest_edge"], - self.feature_extract_tester.size["shortest_edge"], + self.image_processor_tester.num_channels, + self.image_processor_tester.size["shortest_edge"], + self.image_processor_tester.size["shortest_edge"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["shortest_edge"], - self.feature_extract_tester.size["shortest_edge"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.size["shortest_edge"], + self.image_processor_tester.size["shortest_edge"], ), ) diff --git a/tests/models/deformable_detr/test_image_processing_deformable_detr.py b/tests/models/deformable_detr/test_image_processing_deformable_detr.py index bc63689539..98ebac4bbb 100644 --- a/tests/models/deformable_detr/test_image_processing_deformable_detr.py +++ b/tests/models/deformable_detr/test_image_processing_deformable_detr.py @@ -23,8 +23,7 @@ import numpy as np from transformers.testing_utils import require_torch, require_vision, slow from transformers.utils import is_torch_available, is_vision_available -from ...test_feature_extraction_common import FeatureExtractionSavingTestMixin -from ...test_image_processing_common import prepare_image_inputs +from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs if is_torch_available(): @@ -33,10 +32,10 @@ if is_torch_available(): if is_vision_available(): from PIL import Image - from transformers import DeformableDetrFeatureExtractor + from transformers import DeformableDetrImageProcessor -class DeformableDetrFeatureExtractionTester(unittest.TestCase): +class DeformableDetrImageProcessingTester(unittest.TestCase): def __init__( self, parent, @@ -69,7 +68,7 @@ class DeformableDetrFeatureExtractionTester(unittest.TestCase): self.rescale_factor = rescale_factor self.do_pad = do_pad - def prepare_feat_extract_dict(self): + def prepare_image_processor_dict(self): return { "do_resize": self.do_resize, "size": self.size, @@ -83,7 +82,7 @@ class DeformableDetrFeatureExtractionTester(unittest.TestCase): def get_expected_values(self, image_inputs, batched=False): """ - This function computes the expected height and width when providing images to DeformableDetrFeatureExtractor, + This function computes the expected height and width when providing images to DeformableDetrImageProcessor, assuming do_resize is set to True with a scalar size. """ if not batched: @@ -115,152 +114,152 @@ class DeformableDetrFeatureExtractionTester(unittest.TestCase): @require_torch @require_vision -class DeformableDetrFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestCase): +class DeformableDetrImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase): - feature_extraction_class = DeformableDetrFeatureExtractor if is_vision_available() else None + image_processing_class = DeformableDetrImageProcessor if is_vision_available() else None def setUp(self): - self.feature_extract_tester = DeformableDetrFeatureExtractionTester(self) + self.image_processor_tester = DeformableDetrImageProcessingTester(self) @property - def feat_extract_dict(self): - return self.feature_extract_tester.prepare_feat_extract_dict() + def image_processor_dict(self): + return self.image_processor_tester.prepare_image_processor_dict() - def test_feat_extract_properties(self): - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) - self.assertTrue(hasattr(feature_extractor, "image_mean")) - self.assertTrue(hasattr(feature_extractor, "image_std")) - self.assertTrue(hasattr(feature_extractor, "do_normalize")) - self.assertTrue(hasattr(feature_extractor, "do_resize")) - self.assertTrue(hasattr(feature_extractor, "do_rescale")) - self.assertTrue(hasattr(feature_extractor, "do_pad")) - self.assertTrue(hasattr(feature_extractor, "size")) + def test_image_processor_properties(self): + image_processing = self.image_processing_class(**self.image_processor_dict) + self.assertTrue(hasattr(image_processing, "image_mean")) + self.assertTrue(hasattr(image_processing, "image_std")) + self.assertTrue(hasattr(image_processing, "do_normalize")) + self.assertTrue(hasattr(image_processing, "do_resize")) + self.assertTrue(hasattr(image_processing, "do_rescale")) + self.assertTrue(hasattr(image_processing, "do_pad")) + self.assertTrue(hasattr(image_processing, "size")) - def test_feat_extract_from_dict_with_kwargs(self): - feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict) - self.assertEqual(feature_extractor.size, {"shortest_edge": 18, "longest_edge": 1333}) - self.assertEqual(feature_extractor.do_pad, True) + 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, {"shortest_edge": 18, "longest_edge": 1333}) + self.assertEqual(image_processor.do_pad, True) - feature_extractor = self.feature_extraction_class.from_dict( - self.feat_extract_dict, size=42, max_size=84, pad_and_return_pixel_mask=False + image_processor = self.image_processing_class.from_dict( + self.image_processor_dict, size=42, max_size=84, pad_and_return_pixel_mask=False ) - self.assertEqual(feature_extractor.size, {"shortest_edge": 42, "longest_edge": 84}) - self.assertEqual(feature_extractor.do_pad, False) + self.assertEqual(image_processor.size, {"shortest_edge": 42, "longest_edge": 84}) + self.assertEqual(image_processor.do_pad, False) def test_batch_feature(self): pass def test_call_pil(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PIL images - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False) for image in image_inputs: self.assertIsInstance(image, Image.Image) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values - expected_height, expected_width = self.feature_extract_tester.get_expected_values(image_inputs) + expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs) self.assertEqual( encoded_images.shape, - (1, self.feature_extract_tester.num_channels, expected_height, expected_width), + (1, self.image_processor_tester.num_channels, expected_height, expected_width), ) # Test batched - expected_height, expected_width = self.feature_extract_tester.get_expected_values(image_inputs, batched=True) + expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs, batched=True) - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, expected_height, expected_width, ), ) def test_call_numpy(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random numpy tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, numpify=True) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, numpify=True) for image in image_inputs: self.assertIsInstance(image, np.ndarray) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values - expected_height, expected_width = self.feature_extract_tester.get_expected_values(image_inputs) + expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs) self.assertEqual( encoded_images.shape, - (1, self.feature_extract_tester.num_channels, expected_height, expected_width), + (1, self.image_processor_tester.num_channels, expected_height, expected_width), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values - expected_height, expected_width = self.feature_extract_tester.get_expected_values(image_inputs, batched=True) + expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs, batched=True) self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, expected_height, expected_width, ), ) def test_call_pytorch(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PyTorch tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, torchify=True) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, torchify=True) for image in image_inputs: self.assertIsInstance(image, torch.Tensor) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values - expected_height, expected_width = self.feature_extract_tester.get_expected_values(image_inputs) + expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs) self.assertEqual( encoded_images.shape, - (1, self.feature_extract_tester.num_channels, expected_height, expected_width), + (1, self.image_processor_tester.num_channels, expected_height, expected_width), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values - expected_height, expected_width = self.feature_extract_tester.get_expected_values(image_inputs, batched=True) + expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs, batched=True) self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, expected_height, expected_width, ), ) def test_equivalence_pad_and_create_pixel_mask(self): - # Initialize feature_extractors - feature_extractor_1 = self.feature_extraction_class(**self.feat_extract_dict) - feature_extractor_2 = self.feature_extraction_class(do_resize=False, do_normalize=False, do_rescale=False) + # Initialize image_processings + image_processing_1 = self.image_processing_class(**self.image_processor_dict) + image_processing_2 = self.image_processing_class(do_resize=False, do_normalize=False, do_rescale=False) # create random PyTorch tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, torchify=True) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, torchify=True) for image in image_inputs: self.assertIsInstance(image, torch.Tensor) - # Test whether the method "pad_and_return_pixel_mask" and calling the feature extractor return the same tensors - encoded_images_with_method = feature_extractor_1.pad_and_create_pixel_mask(image_inputs, return_tensors="pt") - encoded_images = feature_extractor_2(image_inputs, return_tensors="pt") + # Test whether the method "pad_and_return_pixel_mask" and calling the image processor return the same tensors + encoded_images_with_method = image_processing_1.pad_and_create_pixel_mask(image_inputs, return_tensors="pt") + encoded_images = image_processing_2(image_inputs, return_tensors="pt") self.assertTrue( torch.allclose(encoded_images_with_method["pixel_values"], encoded_images["pixel_values"], atol=1e-4) @@ -279,8 +278,8 @@ class DeformableDetrFeatureExtractionTest(FeatureExtractionSavingTestMixin, unit target = {"image_id": 39769, "annotations": target} # encode them - feature_extractor = DeformableDetrFeatureExtractor() - encoding = feature_extractor(images=image, annotations=target, return_tensors="pt") + image_processing = DeformableDetrImageProcessor() + encoding = image_processing(images=image, annotations=target, return_tensors="pt") # verify pixel values expected_shape = torch.Size([1, 3, 800, 1066]) @@ -325,8 +324,8 @@ class DeformableDetrFeatureExtractionTest(FeatureExtractionSavingTestMixin, unit masks_path = pathlib.Path("./tests/fixtures/tests_samples/COCO/coco_panoptic") # encode them - feature_extractor = DeformableDetrFeatureExtractor(format="coco_panoptic") - encoding = feature_extractor(images=image, annotations=target, masks_path=masks_path, return_tensors="pt") + image_processing = DeformableDetrImageProcessor(format="coco_panoptic") + encoding = image_processing(images=image, annotations=target, masks_path=masks_path, return_tensors="pt") # verify pixel values expected_shape = torch.Size([1, 3, 800, 1066]) diff --git a/tests/models/deit/test_image_processing_deit.py b/tests/models/deit/test_image_processing_deit.py index db1e42f771..d2919ccc2a 100644 --- a/tests/models/deit/test_image_processing_deit.py +++ b/tests/models/deit/test_image_processing_deit.py @@ -21,8 +21,7 @@ import numpy as np from transformers.testing_utils import require_torch, require_vision from transformers.utils import is_torch_available, is_vision_available -from ...test_feature_extraction_common import FeatureExtractionSavingTestMixin -from ...test_image_processing_common import prepare_image_inputs +from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs if is_torch_available(): @@ -31,10 +30,10 @@ if is_torch_available(): if is_vision_available(): from PIL import Image - from transformers import DeiTFeatureExtractor + from transformers import DeiTImageProcessor -class DeiTFeatureExtractionTester(unittest.TestCase): +class DeiTImageProcessingTester(unittest.TestCase): def __init__( self, parent, @@ -68,7 +67,7 @@ class DeiTFeatureExtractionTester(unittest.TestCase): self.image_mean = image_mean self.image_std = image_std - def prepare_feat_extract_dict(self): + def prepare_image_processor_dict(self): return { "do_resize": self.do_resize, "size": self.size, @@ -82,132 +81,132 @@ class DeiTFeatureExtractionTester(unittest.TestCase): @require_torch @require_vision -class DeiTFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestCase): +class DeiTImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase): - feature_extraction_class = DeiTFeatureExtractor if is_vision_available() else None + image_processing_class = DeiTImageProcessor if is_vision_available() else None test_cast_dtype = True def setUp(self): - self.feature_extract_tester = DeiTFeatureExtractionTester(self) + self.image_processor_tester = DeiTImageProcessingTester(self) @property - def feat_extract_dict(self): - return self.feature_extract_tester.prepare_feat_extract_dict() + def image_processor_dict(self): + return self.image_processor_tester.prepare_image_processor_dict() - def test_feat_extract_properties(self): - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) - self.assertTrue(hasattr(feature_extractor, "do_resize")) - self.assertTrue(hasattr(feature_extractor, "size")) - self.assertTrue(hasattr(feature_extractor, "do_center_crop")) - self.assertTrue(hasattr(feature_extractor, "center_crop")) - self.assertTrue(hasattr(feature_extractor, "do_normalize")) - self.assertTrue(hasattr(feature_extractor, "image_mean")) - self.assertTrue(hasattr(feature_extractor, "image_std")) + 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_center_crop")) + self.assertTrue(hasattr(image_processing, "center_crop")) + self.assertTrue(hasattr(image_processing, "do_normalize")) + self.assertTrue(hasattr(image_processing, "image_mean")) + self.assertTrue(hasattr(image_processing, "image_std")) - def test_feat_extract_from_dict_with_kwargs(self): - feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict) - self.assertEqual(feature_extractor.size, {"height": 20, "width": 20}) - self.assertEqual(feature_extractor.crop_size, {"height": 18, "width": 18}) + 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": 20, "width": 20}) + self.assertEqual(image_processor.crop_size, {"height": 18, "width": 18}) - feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict, size=42, crop_size=84) - self.assertEqual(feature_extractor.size, {"height": 42, "width": 42}) - self.assertEqual(feature_extractor.crop_size, {"height": 84, "width": 84}) + image_processor = self.image_processing_class.from_dict(self.image_processor_dict, size=42, crop_size=84) + self.assertEqual(image_processor.size, {"height": 42, "width": 42}) + self.assertEqual(image_processor.crop_size, {"height": 84, "width": 84}) def test_batch_feature(self): pass def test_call_pil(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PIL images - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False) for image in image_inputs: self.assertIsInstance(image, Image.Image) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) def test_call_numpy(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random numpy tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, numpify=True) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, numpify=True) for image in image_inputs: self.assertIsInstance(image, np.ndarray) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) def test_call_pytorch(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PyTorch tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, torchify=True) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, torchify=True) for image in image_inputs: self.assertIsInstance(image, torch.Tensor) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) diff --git a/tests/models/detr/test_image_processing_detr.py b/tests/models/detr/test_image_processing_detr.py index 253ffb7c29..1638cb6794 100644 --- a/tests/models/detr/test_image_processing_detr.py +++ b/tests/models/detr/test_image_processing_detr.py @@ -23,8 +23,7 @@ import numpy as np from transformers.testing_utils import require_torch, require_vision, slow from transformers.utils import is_torch_available, is_vision_available -from ...test_feature_extraction_common import FeatureExtractionSavingTestMixin -from ...test_image_processing_common import prepare_image_inputs +from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs if is_torch_available(): @@ -33,10 +32,10 @@ if is_torch_available(): if is_vision_available(): from PIL import Image - from transformers import DetrFeatureExtractor + from transformers import DetrImageProcessor -class DetrFeatureExtractionTester(unittest.TestCase): +class DetrImageProcessingTester(unittest.TestCase): def __init__( self, parent, @@ -69,7 +68,7 @@ class DetrFeatureExtractionTester(unittest.TestCase): self.image_std = image_std self.do_pad = do_pad - def prepare_feat_extract_dict(self): + def prepare_image_processor_dict(self): return { "do_resize": self.do_resize, "size": self.size, @@ -83,7 +82,7 @@ class DetrFeatureExtractionTester(unittest.TestCase): def get_expected_values(self, image_inputs, batched=False): """ - This function computes the expected height and width when providing images to DetrFeatureExtractor, + This function computes the expected height and width when providing images to DetrImageProcessor, assuming do_resize is set to True with a scalar size. """ if not batched: @@ -115,152 +114,152 @@ class DetrFeatureExtractionTester(unittest.TestCase): @require_torch @require_vision -class DetrFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestCase): +class DetrImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase): - feature_extraction_class = DetrFeatureExtractor if is_vision_available() else None + image_processing_class = DetrImageProcessor if is_vision_available() else None def setUp(self): - self.feature_extract_tester = DetrFeatureExtractionTester(self) + self.image_processor_tester = DetrImageProcessingTester(self) @property - def feat_extract_dict(self): - return self.feature_extract_tester.prepare_feat_extract_dict() + def image_processor_dict(self): + return self.image_processor_tester.prepare_image_processor_dict() - def test_feat_extract_properties(self): - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) - self.assertTrue(hasattr(feature_extractor, "image_mean")) - self.assertTrue(hasattr(feature_extractor, "image_std")) - self.assertTrue(hasattr(feature_extractor, "do_normalize")) - self.assertTrue(hasattr(feature_extractor, "do_rescale")) - self.assertTrue(hasattr(feature_extractor, "rescale_factor")) - self.assertTrue(hasattr(feature_extractor, "do_resize")) - self.assertTrue(hasattr(feature_extractor, "size")) - self.assertTrue(hasattr(feature_extractor, "do_pad")) + def test_image_processor_properties(self): + image_processing = self.image_processing_class(**self.image_processor_dict) + self.assertTrue(hasattr(image_processing, "image_mean")) + self.assertTrue(hasattr(image_processing, "image_std")) + self.assertTrue(hasattr(image_processing, "do_normalize")) + self.assertTrue(hasattr(image_processing, "do_rescale")) + self.assertTrue(hasattr(image_processing, "rescale_factor")) + self.assertTrue(hasattr(image_processing, "do_resize")) + self.assertTrue(hasattr(image_processing, "size")) + self.assertTrue(hasattr(image_processing, "do_pad")) - def test_feat_extract_from_dict_with_kwargs(self): - feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict) - self.assertEqual(feature_extractor.size, {"shortest_edge": 18, "longest_edge": 1333}) - self.assertEqual(feature_extractor.do_pad, True) + 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, {"shortest_edge": 18, "longest_edge": 1333}) + self.assertEqual(image_processor.do_pad, True) - feature_extractor = self.feature_extraction_class.from_dict( - self.feat_extract_dict, size=42, max_size=84, pad_and_return_pixel_mask=False + image_processor = self.image_processing_class.from_dict( + self.image_processor_dict, size=42, max_size=84, pad_and_return_pixel_mask=False ) - self.assertEqual(feature_extractor.size, {"shortest_edge": 42, "longest_edge": 84}) - self.assertEqual(feature_extractor.do_pad, False) + self.assertEqual(image_processor.size, {"shortest_edge": 42, "longest_edge": 84}) + self.assertEqual(image_processor.do_pad, False) def test_batch_feature(self): pass def test_call_pil(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PIL images - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False) for image in image_inputs: self.assertIsInstance(image, Image.Image) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values - expected_height, expected_width = self.feature_extract_tester.get_expected_values(image_inputs) + expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs) self.assertEqual( encoded_images.shape, - (1, self.feature_extract_tester.num_channels, expected_height, expected_width), + (1, self.image_processor_tester.num_channels, expected_height, expected_width), ) # Test batched - expected_height, expected_width = self.feature_extract_tester.get_expected_values(image_inputs, batched=True) + expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs, batched=True) - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, expected_height, expected_width, ), ) def test_call_numpy(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random numpy tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, numpify=True) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, numpify=True) for image in image_inputs: self.assertIsInstance(image, np.ndarray) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values - expected_height, expected_width = self.feature_extract_tester.get_expected_values(image_inputs) + expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs) self.assertEqual( encoded_images.shape, - (1, self.feature_extract_tester.num_channels, expected_height, expected_width), + (1, self.image_processor_tester.num_channels, expected_height, expected_width), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values - expected_height, expected_width = self.feature_extract_tester.get_expected_values(image_inputs, batched=True) + expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs, batched=True) self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, expected_height, expected_width, ), ) def test_call_pytorch(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PyTorch tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, torchify=True) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, torchify=True) for image in image_inputs: self.assertIsInstance(image, torch.Tensor) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values - expected_height, expected_width = self.feature_extract_tester.get_expected_values(image_inputs) + expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs) self.assertEqual( encoded_images.shape, - (1, self.feature_extract_tester.num_channels, expected_height, expected_width), + (1, self.image_processor_tester.num_channels, expected_height, expected_width), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values - expected_height, expected_width = self.feature_extract_tester.get_expected_values(image_inputs, batched=True) + expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs, batched=True) self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, expected_height, expected_width, ), ) def test_equivalence_pad_and_create_pixel_mask(self): - # Initialize feature_extractors - feature_extractor_1 = self.feature_extraction_class(**self.feat_extract_dict) - feature_extractor_2 = self.feature_extraction_class(do_resize=False, do_normalize=False, do_rescale=False) + # Initialize image_processings + image_processing_1 = self.image_processing_class(**self.image_processor_dict) + image_processing_2 = self.image_processing_class(do_resize=False, do_normalize=False, do_rescale=False) # create random PyTorch tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, torchify=True) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, torchify=True) for image in image_inputs: self.assertIsInstance(image, torch.Tensor) - # Test whether the method "pad_and_return_pixel_mask" and calling the feature extractor return the same tensors - encoded_images_with_method = feature_extractor_1.pad_and_create_pixel_mask(image_inputs, return_tensors="pt") - encoded_images = feature_extractor_2(image_inputs, return_tensors="pt") + # Test whether the method "pad_and_return_pixel_mask" and calling the image processor return the same tensors + encoded_images_with_method = image_processing_1.pad_and_create_pixel_mask(image_inputs, return_tensors="pt") + encoded_images = image_processing_2(image_inputs, return_tensors="pt") self.assertTrue( torch.allclose(encoded_images_with_method["pixel_values"], encoded_images["pixel_values"], atol=1e-4) @@ -279,8 +278,8 @@ class DetrFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestC target = {"image_id": 39769, "annotations": target} # encode them - feature_extractor = DetrFeatureExtractor.from_pretrained("facebook/detr-resnet-50") - encoding = feature_extractor(images=image, annotations=target, return_tensors="pt") + image_processing = DetrImageProcessor.from_pretrained("facebook/detr-resnet-50") + encoding = image_processing(images=image, annotations=target, return_tensors="pt") # verify pixel values expected_shape = torch.Size([1, 3, 800, 1066]) @@ -325,8 +324,8 @@ class DetrFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestC masks_path = pathlib.Path("./tests/fixtures/tests_samples/COCO/coco_panoptic") # encode them - feature_extractor = DetrFeatureExtractor.from_pretrained("facebook/detr-resnet-50-panoptic") - encoding = feature_extractor(images=image, annotations=target, masks_path=masks_path, return_tensors="pt") + image_processing = DetrImageProcessor.from_pretrained("facebook/detr-resnet-50-panoptic") + encoding = image_processing(images=image, annotations=target, masks_path=masks_path, return_tensors="pt") # verify pixel values expected_shape = torch.Size([1, 3, 800, 1066]) diff --git a/tests/models/donut/test_image_processing_donut.py b/tests/models/donut/test_image_processing_donut.py index 550d166e46..5ac4d1fc3d 100644 --- a/tests/models/donut/test_image_processing_donut.py +++ b/tests/models/donut/test_image_processing_donut.py @@ -21,8 +21,7 @@ import numpy as np from transformers.testing_utils import is_flaky, require_torch, require_vision from transformers.utils import is_torch_available, is_vision_available -from ...test_feature_extraction_common import FeatureExtractionSavingTestMixin -from ...test_image_processing_common import prepare_image_inputs +from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs if is_torch_available(): @@ -31,10 +30,10 @@ if is_torch_available(): if is_vision_available(): from PIL import Image - from transformers import DonutFeatureExtractor + from transformers import DonutImageProcessor -class DonutFeatureExtractionTester(unittest.TestCase): +class DonutImageProcessingTester(unittest.TestCase): def __init__( self, parent, @@ -67,7 +66,7 @@ class DonutFeatureExtractionTester(unittest.TestCase): self.image_mean = image_mean self.image_std = image_std - def prepare_feat_extract_dict(self): + def prepare_image_processor_dict(self): return { "do_resize": self.do_resize, "size": self.size, @@ -82,137 +81,137 @@ class DonutFeatureExtractionTester(unittest.TestCase): @require_torch @require_vision -class DonutFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestCase): +class DonutImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase): - feature_extraction_class = DonutFeatureExtractor if is_vision_available() else None + image_processing_class = DonutImageProcessor if is_vision_available() else None def setUp(self): - self.feature_extract_tester = DonutFeatureExtractionTester(self) + self.image_processor_tester = DonutImageProcessingTester(self) @property - def feat_extract_dict(self): - return self.feature_extract_tester.prepare_feat_extract_dict() + def image_processor_dict(self): + return self.image_processor_tester.prepare_image_processor_dict() - def test_feat_extract_properties(self): - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) - self.assertTrue(hasattr(feature_extractor, "do_resize")) - self.assertTrue(hasattr(feature_extractor, "size")) - self.assertTrue(hasattr(feature_extractor, "do_thumbnail")) - self.assertTrue(hasattr(feature_extractor, "do_align_long_axis")) - self.assertTrue(hasattr(feature_extractor, "do_pad")) - self.assertTrue(hasattr(feature_extractor, "do_normalize")) - self.assertTrue(hasattr(feature_extractor, "image_mean")) - self.assertTrue(hasattr(feature_extractor, "image_std")) + 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_thumbnail")) + self.assertTrue(hasattr(image_processing, "do_align_long_axis")) + self.assertTrue(hasattr(image_processing, "do_pad")) + self.assertTrue(hasattr(image_processing, "do_normalize")) + self.assertTrue(hasattr(image_processing, "image_mean")) + self.assertTrue(hasattr(image_processing, "image_std")) - def test_feat_extract_from_dict_with_kwargs(self): - feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict) - self.assertEqual(feature_extractor.size, {"height": 18, "width": 20}) + 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": 20}) - feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict, size=42) - self.assertEqual(feature_extractor.size, {"height": 42, "width": 42}) + image_processor = self.image_processing_class.from_dict(self.image_processor_dict, size=42) + self.assertEqual(image_processor.size, {"height": 42, "width": 42}) # Previous config had dimensions in (width, height) order - feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict, size=(42, 84)) - self.assertEqual(feature_extractor.size, {"height": 84, "width": 42}) + image_processor = self.image_processing_class.from_dict(self.image_processor_dict, size=(42, 84)) + self.assertEqual(image_processor.size, {"height": 84, "width": 42}) def test_batch_feature(self): pass @is_flaky() def test_call_pil(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PIL images - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False) for image in image_inputs: self.assertIsInstance(image, Image.Image) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.size["height"], + self.image_processor_tester.size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.size["height"], + self.image_processor_tester.size["width"], ), ) @is_flaky() def test_call_numpy(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random numpy tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, numpify=True) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, numpify=True) for image in image_inputs: self.assertIsInstance(image, np.ndarray) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.size["height"], + self.image_processor_tester.size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.size["height"], + self.image_processor_tester.size["width"], ), ) @is_flaky() def test_call_pytorch(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PyTorch tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, torchify=True) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, torchify=True) for image in image_inputs: self.assertIsInstance(image, torch.Tensor) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.size["height"], + self.image_processor_tester.size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.size["height"], + self.image_processor_tester.size["width"], ), ) diff --git a/tests/models/dpt/test_image_processing_dpt.py b/tests/models/dpt/test_image_processing_dpt.py index 0bbeb173e5..4ed6faadb6 100644 --- a/tests/models/dpt/test_image_processing_dpt.py +++ b/tests/models/dpt/test_image_processing_dpt.py @@ -21,8 +21,7 @@ import numpy as np from transformers.file_utils import is_torch_available, is_vision_available from transformers.testing_utils import require_torch, require_vision -from ...test_feature_extraction_common import FeatureExtractionSavingTestMixin -from ...test_image_processing_common import prepare_image_inputs +from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs if is_torch_available(): @@ -31,10 +30,10 @@ if is_torch_available(): if is_vision_available(): from PIL import Image - from transformers import DPTFeatureExtractor + from transformers import DPTImageProcessor -class DPTFeatureExtractionTester(unittest.TestCase): +class DPTImageProcessingTester(unittest.TestCase): def __init__( self, parent, @@ -62,7 +61,7 @@ class DPTFeatureExtractionTester(unittest.TestCase): self.image_mean = image_mean self.image_std = image_std - def prepare_feat_extract_dict(self): + def prepare_image_processor_dict(self): return { "image_mean": self.image_mean, "image_std": self.image_std, @@ -74,124 +73,124 @@ class DPTFeatureExtractionTester(unittest.TestCase): @require_torch @require_vision -class DPTFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestCase): +class DPTImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase): - feature_extraction_class = DPTFeatureExtractor if is_vision_available() else None + image_processing_class = DPTImageProcessor if is_vision_available() else None def setUp(self): - self.feature_extract_tester = DPTFeatureExtractionTester(self) + self.image_processor_tester = DPTImageProcessingTester(self) @property - def feat_extract_dict(self): - return self.feature_extract_tester.prepare_feat_extract_dict() + def image_processor_dict(self): + return self.image_processor_tester.prepare_image_processor_dict() - def test_feat_extract_properties(self): - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) - self.assertTrue(hasattr(feature_extractor, "image_mean")) - self.assertTrue(hasattr(feature_extractor, "image_std")) - self.assertTrue(hasattr(feature_extractor, "do_normalize")) - self.assertTrue(hasattr(feature_extractor, "do_resize")) - self.assertTrue(hasattr(feature_extractor, "size")) + def test_image_processor_properties(self): + image_processing = self.image_processing_class(**self.image_processor_dict) + self.assertTrue(hasattr(image_processing, "image_mean")) + self.assertTrue(hasattr(image_processing, "image_std")) + self.assertTrue(hasattr(image_processing, "do_normalize")) + self.assertTrue(hasattr(image_processing, "do_resize")) + self.assertTrue(hasattr(image_processing, "size")) - def test_feat_extract_from_dict_with_kwargs(self): - feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict) - self.assertEqual(feature_extractor.size, {"height": 18, "width": 18}) + 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}) - feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict, size=42) - self.assertEqual(feature_extractor.size, {"height": 42, "width": 42}) + image_processor = self.image_processing_class.from_dict(self.image_processor_dict, size=42) + self.assertEqual(image_processor.size, {"height": 42, "width": 42}) def test_call_pil(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PIL images - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False) for image in image_inputs: self.assertIsInstance(image, Image.Image) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.size["height"], + self.image_processor_tester.size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.size["height"], + self.image_processor_tester.size["width"], ), ) def test_call_numpy(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random numpy tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, numpify=True) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, numpify=True) for image in image_inputs: self.assertIsInstance(image, np.ndarray) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.size["height"], + self.image_processor_tester.size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.size["height"], + self.image_processor_tester.size["width"], ), ) def test_call_pytorch(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PyTorch tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, torchify=True) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, torchify=True) for image in image_inputs: self.assertIsInstance(image, torch.Tensor) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.size["height"], + self.image_processor_tester.size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.size["height"], + self.image_processor_tester.size["width"], ), ) diff --git a/tests/models/efficientformer/test_image_processing_efficientformer.py b/tests/models/efficientformer/test_image_processing_efficientformer.py index 0a52550564..6a17783f61 100644 --- a/tests/models/efficientformer/test_image_processing_efficientformer.py +++ b/tests/models/efficientformer/test_image_processing_efficientformer.py @@ -21,8 +21,7 @@ import numpy as np from transformers.testing_utils import require_torch, require_vision from transformers.utils import is_torch_available, is_vision_available -from ...test_feature_extraction_common import FeatureExtractionSavingTestMixin -from ...test_image_processing_common import prepare_image_inputs +from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs if is_torch_available(): @@ -31,7 +30,7 @@ if is_torch_available(): if is_vision_available(): from PIL import Image - from transformers import ViTFeatureExtractor + from transformers import ViTImageProcessor class EfficientFormerImageProcessorTester(unittest.TestCase): @@ -62,7 +61,7 @@ class EfficientFormerImageProcessorTester(unittest.TestCase): self.image_mean = image_mean self.image_std = image_std - def prepare_feat_extract_dict(self): + def prepare_image_processor_dict(self): return { "image_mean": self.image_mean, "image_std": self.image_std, @@ -74,120 +73,120 @@ class EfficientFormerImageProcessorTester(unittest.TestCase): @require_torch @require_vision -class EfficientFormerImageProcessorTest(FeatureExtractionSavingTestMixin, unittest.TestCase): +class EfficientFormerImageProcessorTest(ImageProcessingSavingTestMixin, unittest.TestCase): - feature_extraction_class = ViTFeatureExtractor if is_vision_available() else None + image_processing_class = ViTImageProcessor if is_vision_available() else None def setUp(self): - self.feature_extract_tester = EfficientFormerImageProcessorTester(self) + self.image_proc_tester = EfficientFormerImageProcessorTester(self) @property - def feat_extract_dict(self): - return self.feature_extract_tester.prepare_feat_extract_dict() + def image_processor_dict(self): + return self.image_proc_tester.prepare_image_processor_dict() - def test_feat_extract_properties(self): - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) - self.assertTrue(hasattr(feature_extractor, "image_mean")) - self.assertTrue(hasattr(feature_extractor, "image_std")) - self.assertTrue(hasattr(feature_extractor, "do_normalize")) - self.assertTrue(hasattr(feature_extractor, "do_resize")) - self.assertTrue(hasattr(feature_extractor, "size")) + def test_image_proc_properties(self): + image_processor = self.image_processing_class(**self.image_processor_dict) + self.assertTrue(hasattr(image_processor, "image_mean")) + self.assertTrue(hasattr(image_processor, "image_std")) + self.assertTrue(hasattr(image_processor, "do_normalize")) + self.assertTrue(hasattr(image_processor, "do_resize")) + self.assertTrue(hasattr(image_processor, "size")) def test_batch_feature(self): pass def test_call_pil(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processor + image_processor = self.image_processing_class(**self.image_processor_dict) # create random PIL images - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False) + image_inputs = prepare_image_inputs(self.image_proc_tester, equal_resolution=False) for image in image_inputs: self.assertIsInstance(image, Image.Image) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processor(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_proc_tester.num_channels, + self.image_proc_tester.size["height"], + self.image_proc_tester.size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processor(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_proc_tester.batch_size, + self.image_proc_tester.num_channels, + self.image_proc_tester.size["height"], + self.image_proc_tester.size["width"], ), ) def test_call_numpy(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processor + image_processor = self.image_processing_class(**self.image_processor_dict) # create random numpy tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, numpify=True) + image_inputs = prepare_image_inputs(self.image_proc_tester, equal_resolution=False, numpify=True) for image in image_inputs: self.assertIsInstance(image, np.ndarray) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processor(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_proc_tester.num_channels, + self.image_proc_tester.size["height"], + self.image_proc_tester.size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processor(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_proc_tester.batch_size, + self.image_proc_tester.num_channels, + self.image_proc_tester.size["height"], + self.image_proc_tester.size["width"], ), ) def test_call_pytorch(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processor + image_processor = self.image_processing_class(**self.image_processor_dict) # create random PyTorch tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, torchify=True) + image_inputs = prepare_image_inputs(self.image_proc_tester, equal_resolution=False, torchify=True) for image in image_inputs: self.assertIsInstance(image, torch.Tensor) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processor(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_proc_tester.num_channels, + self.image_proc_tester.size["height"], + self.image_proc_tester.size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processor(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_proc_tester.batch_size, + self.image_proc_tester.num_channels, + self.image_proc_tester.size["height"], + self.image_proc_tester.size["width"], ), ) diff --git a/tests/models/flava/test_image_processing_flava.py b/tests/models/flava/test_image_processing_flava.py index 2871874820..129343b998 100644 --- a/tests/models/flava/test_image_processing_flava.py +++ b/tests/models/flava/test_image_processing_flava.py @@ -21,8 +21,7 @@ import numpy as np from transformers.testing_utils import require_torch, require_vision from transformers.utils import is_torch_available, is_vision_available -from ...test_feature_extraction_common import FeatureExtractionSavingTestMixin -from ...test_image_processing_common import prepare_image_inputs +from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs if is_torch_available(): @@ -31,7 +30,7 @@ if is_torch_available(): if is_vision_available(): import PIL - from transformers import FlavaFeatureExtractor + from transformers import FlavaImageProcessor from transformers.image_utils import PILImageResampling from transformers.models.flava.image_processing_flava import ( FLAVA_CODEBOOK_MEAN, @@ -43,7 +42,7 @@ else: FLAVA_IMAGE_MEAN = FLAVA_IMAGE_STD = FLAVA_CODEBOOK_MEAN = FLAVA_CODEBOOK_STD = None -class FlavaFeatureExtractionTester(unittest.TestCase): +class FlavaImageProcessingTester(unittest.TestCase): def __init__( self, parent, @@ -115,7 +114,7 @@ class FlavaFeatureExtractionTester(unittest.TestCase): self.codebook_image_mean = codebook_image_mean self.codebook_image_std = codebook_image_std - def prepare_feat_extract_dict(self): + def prepare_image_processor_dict(self): return { "image_mean": self.image_mean, "image_std": self.image_std, @@ -160,82 +159,82 @@ class FlavaFeatureExtractionTester(unittest.TestCase): @require_torch @require_vision -class FlavaFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestCase): +class FlavaImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase): - feature_extraction_class = FlavaFeatureExtractor if is_vision_available() else None + image_processing_class = FlavaImageProcessor if is_vision_available() else None maxDiff = None def setUp(self): - self.feature_extract_tester = FlavaFeatureExtractionTester(self) + self.image_processor_tester = FlavaImageProcessingTester(self) @property - def feat_extract_dict(self): - return self.feature_extract_tester.prepare_feat_extract_dict() + def image_processor_dict(self): + return self.image_processor_tester.prepare_image_processor_dict() - def test_feat_extract_properties(self): - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) - self.assertTrue(hasattr(feature_extractor, "image_mean")) - self.assertTrue(hasattr(feature_extractor, "image_std")) - self.assertTrue(hasattr(feature_extractor, "do_normalize")) - self.assertTrue(hasattr(feature_extractor, "do_resize")) - self.assertTrue(hasattr(feature_extractor, "resample")) - self.assertTrue(hasattr(feature_extractor, "crop_size")) - self.assertTrue(hasattr(feature_extractor, "do_center_crop")) - self.assertTrue(hasattr(feature_extractor, "do_rescale")) - self.assertTrue(hasattr(feature_extractor, "rescale_factor")) - self.assertTrue(hasattr(feature_extractor, "masking_generator")) - self.assertTrue(hasattr(feature_extractor, "codebook_do_resize")) - self.assertTrue(hasattr(feature_extractor, "codebook_size")) - self.assertTrue(hasattr(feature_extractor, "codebook_resample")) - self.assertTrue(hasattr(feature_extractor, "codebook_do_center_crop")) - self.assertTrue(hasattr(feature_extractor, "codebook_crop_size")) - self.assertTrue(hasattr(feature_extractor, "codebook_do_map_pixels")) - self.assertTrue(hasattr(feature_extractor, "codebook_do_normalize")) - self.assertTrue(hasattr(feature_extractor, "codebook_image_mean")) - self.assertTrue(hasattr(feature_extractor, "codebook_image_std")) + def test_image_processor_properties(self): + image_processing = self.image_processing_class(**self.image_processor_dict) + self.assertTrue(hasattr(image_processing, "image_mean")) + self.assertTrue(hasattr(image_processing, "image_std")) + self.assertTrue(hasattr(image_processing, "do_normalize")) + self.assertTrue(hasattr(image_processing, "do_resize")) + self.assertTrue(hasattr(image_processing, "resample")) + self.assertTrue(hasattr(image_processing, "crop_size")) + self.assertTrue(hasattr(image_processing, "do_center_crop")) + self.assertTrue(hasattr(image_processing, "do_rescale")) + self.assertTrue(hasattr(image_processing, "rescale_factor")) + self.assertTrue(hasattr(image_processing, "masking_generator")) + self.assertTrue(hasattr(image_processing, "codebook_do_resize")) + self.assertTrue(hasattr(image_processing, "codebook_size")) + self.assertTrue(hasattr(image_processing, "codebook_resample")) + self.assertTrue(hasattr(image_processing, "codebook_do_center_crop")) + self.assertTrue(hasattr(image_processing, "codebook_crop_size")) + self.assertTrue(hasattr(image_processing, "codebook_do_map_pixels")) + self.assertTrue(hasattr(image_processing, "codebook_do_normalize")) + self.assertTrue(hasattr(image_processing, "codebook_image_mean")) + self.assertTrue(hasattr(image_processing, "codebook_image_std")) - def test_feat_extract_from_dict_with_kwargs(self): - feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict) - self.assertEqual(feature_extractor.size, {"height": 224, "width": 224}) - self.assertEqual(feature_extractor.crop_size, {"height": 224, "width": 224}) - self.assertEqual(feature_extractor.codebook_size, {"height": 112, "width": 112}) - self.assertEqual(feature_extractor.codebook_crop_size, {"height": 112, "width": 112}) + 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": 224, "width": 224}) + self.assertEqual(image_processor.crop_size, {"height": 224, "width": 224}) + self.assertEqual(image_processor.codebook_size, {"height": 112, "width": 112}) + self.assertEqual(image_processor.codebook_crop_size, {"height": 112, "width": 112}) - feature_extractor = self.feature_extraction_class.from_dict( - self.feat_extract_dict, size=42, crop_size=84, codebook_size=33, codebook_crop_size=66 + image_processor = self.image_processing_class.from_dict( + self.image_processor_dict, size=42, crop_size=84, codebook_size=33, codebook_crop_size=66 ) - self.assertEqual(feature_extractor.size, {"height": 42, "width": 42}) - self.assertEqual(feature_extractor.crop_size, {"height": 84, "width": 84}) - self.assertEqual(feature_extractor.codebook_size, {"height": 33, "width": 33}) - self.assertEqual(feature_extractor.codebook_crop_size, {"height": 66, "width": 66}) + self.assertEqual(image_processor.size, {"height": 42, "width": 42}) + self.assertEqual(image_processor.crop_size, {"height": 84, "width": 84}) + self.assertEqual(image_processor.codebook_size, {"height": 33, "width": 33}) + self.assertEqual(image_processor.codebook_crop_size, {"height": 66, "width": 66}) def test_batch_feature(self): pass def test_call_pil(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PIL images - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False) for image in image_inputs: self.assertIsInstance(image, PIL.Image.Image) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt") + encoded_images = image_processing(image_inputs[0], return_tensors="pt") # Test no bool masked pos self.assertFalse("bool_masked_pos" in encoded_images) - expected_height, expected_width = self.feature_extract_tester.get_expected_image_size() + expected_height, expected_width = self.image_processor_tester.get_expected_image_size() self.assertEqual( encoded_images.pixel_values.shape, - (1, self.feature_extract_tester.num_channels, expected_height, expected_width), + (1, self.image_processor_tester.num_channels, expected_height, expected_width), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt") - expected_height, expected_width = self.feature_extract_tester.get_expected_image_size() + encoded_images = image_processing(image_inputs, return_tensors="pt") + expected_height, expected_width = self.image_processor_tester.get_expected_image_size() # Test no bool masked pos self.assertFalse("bool_masked_pos" in encoded_images) @@ -243,86 +242,86 @@ class FlavaFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.Test self.assertEqual( encoded_images.pixel_values.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, expected_height, expected_width, ), ) def _test_call_framework(self, instance_class, prepare_kwargs): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, **prepare_kwargs) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, **prepare_kwargs) for image in image_inputs: self.assertIsInstance(image, instance_class) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt") + encoded_images = image_processing(image_inputs[0], return_tensors="pt") - expected_height, expected_width = self.feature_extract_tester.get_expected_image_size() + expected_height, expected_width = self.image_processor_tester.get_expected_image_size() self.assertEqual( encoded_images.pixel_values.shape, - (1, self.feature_extract_tester.num_channels, expected_height, expected_width), + (1, self.image_processor_tester.num_channels, expected_height, expected_width), ) - encoded_images = feature_extractor(image_inputs, return_image_mask=True, return_tensors="pt") + encoded_images = image_processing(image_inputs, return_image_mask=True, return_tensors="pt") - expected_height, expected_width = self.feature_extract_tester.get_expected_image_size() + expected_height, expected_width = self.image_processor_tester.get_expected_image_size() self.assertEqual( encoded_images.pixel_values.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, expected_height, expected_width, ), ) - expected_height, expected_width = self.feature_extract_tester.get_expected_mask_size() + expected_height, expected_width = self.image_processor_tester.get_expected_mask_size() self.assertEqual( encoded_images.bool_masked_pos.shape, ( - self.feature_extract_tester.batch_size, + self.image_processor_tester.batch_size, expected_height, expected_width, ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values - expected_height, expected_width = self.feature_extract_tester.get_expected_image_size() + expected_height, expected_width = self.image_processor_tester.get_expected_image_size() self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, expected_height, expected_width, ), ) # Test masking - encoded_images = feature_extractor(image_inputs, return_image_mask=True, return_tensors="pt") + encoded_images = image_processing(image_inputs, return_image_mask=True, return_tensors="pt") - expected_height, expected_width = self.feature_extract_tester.get_expected_image_size() + expected_height, expected_width = self.image_processor_tester.get_expected_image_size() self.assertEqual( encoded_images.pixel_values.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, expected_height, expected_width, ), ) - expected_height, expected_width = self.feature_extract_tester.get_expected_mask_size() + expected_height, expected_width = self.image_processor_tester.get_expected_mask_size() self.assertEqual( encoded_images.bool_masked_pos.shape, ( - self.feature_extract_tester.batch_size, + self.image_processor_tester.batch_size, expected_height, expected_width, ), @@ -335,39 +334,39 @@ class FlavaFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.Test self._test_call_framework(torch.Tensor, prepare_kwargs={"torchify": True}) def test_masking(self): - # Initialize feature_extractor + # Initialize image_processing random.seed(1234) - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, torchify=True) + image_processing = self.image_processing_class(**self.image_processor_dict) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, torchify=True) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_image_mask=True, return_tensors="pt") + encoded_images = image_processing(image_inputs[0], return_image_mask=True, return_tensors="pt") self.assertEqual(encoded_images.bool_masked_pos.sum().item(), 75) def test_codebook_pixels(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PIL images - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False) for image in image_inputs: self.assertIsInstance(image, PIL.Image.Image) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_codebook_pixels=True, return_tensors="pt") - expected_height, expected_width = self.feature_extract_tester.get_expected_codebook_image_size() + encoded_images = image_processing(image_inputs[0], return_codebook_pixels=True, return_tensors="pt") + expected_height, expected_width = self.image_processor_tester.get_expected_codebook_image_size() self.assertEqual( encoded_images.codebook_pixel_values.shape, - (1, self.feature_extract_tester.num_channels, expected_height, expected_width), + (1, self.image_processor_tester.num_channels, expected_height, expected_width), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_codebook_pixels=True, return_tensors="pt") - expected_height, expected_width = self.feature_extract_tester.get_expected_codebook_image_size() + encoded_images = image_processing(image_inputs, return_codebook_pixels=True, return_tensors="pt") + expected_height, expected_width = self.image_processor_tester.get_expected_codebook_image_size() self.assertEqual( encoded_images.codebook_pixel_values.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, expected_height, expected_width, ), diff --git a/tests/models/glpn/test_image_processing_glpn.py b/tests/models/glpn/test_image_processing_glpn.py index 31e5277617..cddc80d9ae 100644 --- a/tests/models/glpn/test_image_processing_glpn.py +++ b/tests/models/glpn/test_image_processing_glpn.py @@ -21,8 +21,7 @@ import numpy as np from transformers.testing_utils import require_torch, require_vision from transformers.utils import is_torch_available, is_vision_available -from ...test_feature_extraction_common import FeatureExtractionSavingTestMixin -from ...test_image_processing_common import prepare_image_inputs +from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs if is_torch_available(): @@ -31,10 +30,10 @@ if is_torch_available(): if is_vision_available(): from PIL import Image - from transformers import GLPNFeatureExtractor + from transformers import GLPNImageProcessor -class GLPNFeatureExtractionTester(unittest.TestCase): +class GLPNImageProcessingTester(unittest.TestCase): def __init__( self, parent, @@ -57,7 +56,7 @@ class GLPNFeatureExtractionTester(unittest.TestCase): self.size_divisor = size_divisor self.do_rescale = do_rescale - def prepare_feat_extract_dict(self): + def prepare_image_processor_dict(self): return { "do_resize": self.do_resize, "size_divisor": self.size_divisor, @@ -67,62 +66,62 @@ class GLPNFeatureExtractionTester(unittest.TestCase): @require_torch @require_vision -class GLPNFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestCase): +class GLPNImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase): - feature_extraction_class = GLPNFeatureExtractor if is_vision_available() else None + image_processing_class = GLPNImageProcessor if is_vision_available() else None def setUp(self): - self.feature_extract_tester = GLPNFeatureExtractionTester(self) + self.image_processor_tester = GLPNImageProcessingTester(self) @property - def feat_extract_dict(self): - return self.feature_extract_tester.prepare_feat_extract_dict() + def image_processor_dict(self): + return self.image_processor_tester.prepare_image_processor_dict() - def test_feat_extract_properties(self): - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) - self.assertTrue(hasattr(feature_extractor, "do_resize")) - self.assertTrue(hasattr(feature_extractor, "size_divisor")) - self.assertTrue(hasattr(feature_extractor, "resample")) - self.assertTrue(hasattr(feature_extractor, "do_rescale")) + 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_divisor")) + self.assertTrue(hasattr(image_processing, "resample")) + self.assertTrue(hasattr(image_processing, "do_rescale")) def test_batch_feature(self): pass def test_call_pil(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PIL images - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False) for image in image_inputs: self.assertIsInstance(image, Image.Image) - # Test not batched input (GLPNFeatureExtractor doesn't support batching) - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values - self.assertTrue(encoded_images.shape[-1] % self.feature_extract_tester.size_divisor == 0) - self.assertTrue(encoded_images.shape[-2] % self.feature_extract_tester.size_divisor == 0) + # Test not batched input (GLPNImageProcessor doesn't support batching) + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values + self.assertTrue(encoded_images.shape[-1] % self.image_processor_tester.size_divisor == 0) + self.assertTrue(encoded_images.shape[-2] % self.image_processor_tester.size_divisor == 0) def test_call_numpy(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random numpy tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, numpify=True) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, numpify=True) for image in image_inputs: self.assertIsInstance(image, np.ndarray) - # Test not batched input (GLPNFeatureExtractor doesn't support batching) - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values - self.assertTrue(encoded_images.shape[-1] % self.feature_extract_tester.size_divisor == 0) - self.assertTrue(encoded_images.shape[-2] % self.feature_extract_tester.size_divisor == 0) + # Test not batched input (GLPNImageProcessor doesn't support batching) + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values + self.assertTrue(encoded_images.shape[-1] % self.image_processor_tester.size_divisor == 0) + self.assertTrue(encoded_images.shape[-2] % self.image_processor_tester.size_divisor == 0) def test_call_pytorch(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PyTorch tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, torchify=True) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, torchify=True) for image in image_inputs: self.assertIsInstance(image, torch.Tensor) - # Test not batched input (GLPNFeatureExtractor doesn't support batching) - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values - self.assertTrue(encoded_images.shape[-1] % self.feature_extract_tester.size_divisor == 0) - self.assertTrue(encoded_images.shape[-2] % self.feature_extract_tester.size_divisor == 0) + # Test not batched input (GLPNImageProcessor doesn't support batching) + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values + self.assertTrue(encoded_images.shape[-1] % self.image_processor_tester.size_divisor == 0) + self.assertTrue(encoded_images.shape[-2] % self.image_processor_tester.size_divisor == 0) diff --git a/tests/models/imagegpt/test_image_processing_imagegpt.py b/tests/models/imagegpt/test_image_processing_imagegpt.py index 465a6015a3..efc456e998 100644 --- a/tests/models/imagegpt/test_image_processing_imagegpt.py +++ b/tests/models/imagegpt/test_image_processing_imagegpt.py @@ -25,7 +25,7 @@ from datasets import load_dataset from transformers.testing_utils import require_torch, require_vision, slow from transformers.utils import is_torch_available, is_vision_available -from ...test_feature_extraction_common import FeatureExtractionSavingTestMixin +from ...test_image_processing_common import ImageProcessingSavingTestMixin if is_torch_available(): @@ -34,10 +34,10 @@ if is_torch_available(): if is_vision_available(): from PIL import Image - from transformers import ImageGPTFeatureExtractor + from transformers import ImageGPTImageProcessor -class ImageGPTFeatureExtractionTester(unittest.TestCase): +class ImageGPTImageProcessingTester(unittest.TestCase): def __init__( self, parent, @@ -61,7 +61,7 @@ class ImageGPTFeatureExtractionTester(unittest.TestCase): self.size = size self.do_normalize = do_normalize - def prepare_feat_extract_dict(self): + def prepare_image_processor_dict(self): return { # here we create 2 clusters for the sake of simplicity "clusters": np.asarray( @@ -78,68 +78,68 @@ class ImageGPTFeatureExtractionTester(unittest.TestCase): @require_torch @require_vision -class ImageGPTFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestCase): +class ImageGPTImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase): - feature_extraction_class = ImageGPTFeatureExtractor if is_vision_available() else None + image_processing_class = ImageGPTImageProcessor if is_vision_available() else None def setUp(self): - self.feature_extract_tester = ImageGPTFeatureExtractionTester(self) + self.image_processor_tester = ImageGPTImageProcessingTester(self) @property - def feat_extract_dict(self): - return self.feature_extract_tester.prepare_feat_extract_dict() + def image_processor_dict(self): + return self.image_processor_tester.prepare_image_processor_dict() - def test_feat_extract_properties(self): - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) - self.assertTrue(hasattr(feature_extractor, "clusters")) - self.assertTrue(hasattr(feature_extractor, "do_resize")) - self.assertTrue(hasattr(feature_extractor, "size")) - self.assertTrue(hasattr(feature_extractor, "do_normalize")) + def test_image_processor_properties(self): + image_processing = self.image_processing_class(**self.image_processor_dict) + self.assertTrue(hasattr(image_processing, "clusters")) + self.assertTrue(hasattr(image_processing, "do_resize")) + self.assertTrue(hasattr(image_processing, "size")) + self.assertTrue(hasattr(image_processing, "do_normalize")) - def test_feat_extract_from_dict_with_kwargs(self): - feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict) - self.assertEqual(feature_extractor.size, {"height": 18, "width": 18}) + 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}) - feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict, size=42) - self.assertEqual(feature_extractor.size, {"height": 42, "width": 42}) + image_processor = self.image_processing_class.from_dict(self.image_processor_dict, size=42) + self.assertEqual(image_processor.size, {"height": 42, "width": 42}) - def test_feat_extract_to_json_string(self): - feat_extract = self.feature_extraction_class(**self.feat_extract_dict) - obj = json.loads(feat_extract.to_json_string()) - for key, value in self.feat_extract_dict.items(): + def test_image_processor_to_json_string(self): + image_processor = self.image_processing_class(**self.image_processor_dict) + obj = json.loads(image_processor.to_json_string()) + for key, value in self.image_processor_dict.items(): if key == "clusters": self.assertTrue(np.array_equal(value, obj[key])) else: self.assertEqual(obj[key], value) - def test_feat_extract_to_json_file(self): - feat_extract_first = self.feature_extraction_class(**self.feat_extract_dict) + def test_image_processor_to_json_file(self): + image_processor_first = self.image_processing_class(**self.image_processor_dict) with tempfile.TemporaryDirectory() as tmpdirname: - json_file_path = os.path.join(tmpdirname, "feat_extract.json") - feat_extract_first.to_json_file(json_file_path) - feat_extract_second = self.feature_extraction_class.from_json_file(json_file_path).to_dict() + json_file_path = os.path.join(tmpdirname, "image_processor.json") + image_processor_first.to_json_file(json_file_path) + image_processor_second = self.image_processing_class.from_json_file(json_file_path).to_dict() - feat_extract_first = feat_extract_first.to_dict() - for key, value in feat_extract_first.items(): + image_processor_first = image_processor_first.to_dict() + for key, value in image_processor_first.items(): if key == "clusters": - self.assertTrue(np.array_equal(value, feat_extract_second[key])) + self.assertTrue(np.array_equal(value, image_processor_second[key])) else: - self.assertEqual(feat_extract_first[key], value) + self.assertEqual(image_processor_first[key], value) - def test_feat_extract_from_and_save_pretrained(self): - feat_extract_first = self.feature_extraction_class(**self.feat_extract_dict) + def test_image_processor_from_and_save_pretrained(self): + image_processor_first = self.image_processing_class(**self.image_processor_dict) with tempfile.TemporaryDirectory() as tmpdirname: - feat_extract_first.save_pretrained(tmpdirname) - feat_extract_second = self.feature_extraction_class.from_pretrained(tmpdirname).to_dict() + image_processor_first.save_pretrained(tmpdirname) + image_processor_second = self.image_processing_class.from_pretrained(tmpdirname).to_dict() - feat_extract_first = feat_extract_first.to_dict() - for key, value in feat_extract_first.items(): + image_processor_first = image_processor_first.to_dict() + for key, value in image_processor_first.items(): if key == "clusters": - self.assertTrue(np.array_equal(value, feat_extract_second[key])) + self.assertTrue(np.array_equal(value, image_processor_second[key])) else: - self.assertEqual(feat_extract_first[key], value) + self.assertEqual(image_processor_first[key], value) @unittest.skip("ImageGPT requires clusters at initialization") def test_init_without_params(self): @@ -159,15 +159,15 @@ def prepare_images(): @require_vision @require_torch -class ImageGPTFeatureExtractorIntegrationTest(unittest.TestCase): +class ImageGPTImageProcessorIntegrationTest(unittest.TestCase): @slow def test_image(self): - feature_extractor = ImageGPTFeatureExtractor.from_pretrained("openai/imagegpt-small") + image_processing = ImageGPTImageProcessor.from_pretrained("openai/imagegpt-small") images = prepare_images() # test non-batched - encoding = feature_extractor(images[0], return_tensors="pt") + encoding = image_processing(images[0], return_tensors="pt") self.assertIsInstance(encoding.input_ids, torch.LongTensor) self.assertEqual(encoding.input_ids.shape, (1, 1024)) @@ -176,7 +176,7 @@ class ImageGPTFeatureExtractorIntegrationTest(unittest.TestCase): self.assertEqual(encoding.input_ids[0, :3].tolist(), expected_slice) # test batched - encoding = feature_extractor(images, return_tensors="pt") + encoding = image_processing(images, return_tensors="pt") self.assertIsInstance(encoding.input_ids, torch.LongTensor) self.assertEqual(encoding.input_ids.shape, (2, 1024)) diff --git a/tests/models/layoutlmv2/test_image_processing_layoutlmv2.py b/tests/models/layoutlmv2/test_image_processing_layoutlmv2.py index 4423d33376..d2eae1d8df 100644 --- a/tests/models/layoutlmv2/test_image_processing_layoutlmv2.py +++ b/tests/models/layoutlmv2/test_image_processing_layoutlmv2.py @@ -21,8 +21,7 @@ import numpy as np from transformers.testing_utils import require_pytesseract, require_torch from transformers.utils import is_pytesseract_available, is_torch_available -from ...test_feature_extraction_common import FeatureExtractionSavingTestMixin -from ...test_image_processing_common import prepare_image_inputs +from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs if is_torch_available(): @@ -31,10 +30,10 @@ if is_torch_available(): if is_pytesseract_available(): from PIL import Image - from transformers import LayoutLMv2FeatureExtractor + from transformers import LayoutLMv2ImageProcessor -class LayoutLMv2FeatureExtractionTester(unittest.TestCase): +class LayoutLMv2ImageProcessingTester(unittest.TestCase): def __init__( self, parent, @@ -58,56 +57,56 @@ class LayoutLMv2FeatureExtractionTester(unittest.TestCase): self.size = size self.apply_ocr = apply_ocr - def prepare_feat_extract_dict(self): + def prepare_image_processor_dict(self): return {"do_resize": self.do_resize, "size": self.size, "apply_ocr": self.apply_ocr} @require_torch @require_pytesseract -class LayoutLMv2FeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestCase): +class LayoutLMv2ImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase): - feature_extraction_class = LayoutLMv2FeatureExtractor if is_pytesseract_available() else None + image_processing_class = LayoutLMv2ImageProcessor if is_pytesseract_available() else None def setUp(self): - self.feature_extract_tester = LayoutLMv2FeatureExtractionTester(self) + self.image_processor_tester = LayoutLMv2ImageProcessingTester(self) @property - def feat_extract_dict(self): - return self.feature_extract_tester.prepare_feat_extract_dict() + def image_processor_dict(self): + return self.image_processor_tester.prepare_image_processor_dict() - def test_feat_extract_properties(self): - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) - self.assertTrue(hasattr(feature_extractor, "do_resize")) - self.assertTrue(hasattr(feature_extractor, "size")) - self.assertTrue(hasattr(feature_extractor, "apply_ocr")) + 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, "apply_ocr")) - def test_feat_extract_from_dict_with_kwargs(self): - feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict) - self.assertEqual(feature_extractor.size, {"height": 18, "width": 18}) + 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}) - feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict, size=42) - self.assertEqual(feature_extractor.size, {"height": 42, "width": 42}) + image_processor = self.image_processing_class.from_dict(self.image_processor_dict, size=42) + self.assertEqual(image_processor.size, {"height": 42, "width": 42}) def test_batch_feature(self): pass def test_call_pil(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PIL images - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False) for image in image_inputs: self.assertIsInstance(image, Image.Image) # Test not batched input - encoding = feature_extractor(image_inputs[0], return_tensors="pt") + encoding = image_processing(image_inputs[0], return_tensors="pt") self.assertEqual( encoding.pixel_values.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.size["height"], + self.image_processor_tester.size["width"], ), ) @@ -115,84 +114,84 @@ class LayoutLMv2FeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest self.assertIsInstance(encoding.boxes, list) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.size["height"], + self.image_processor_tester.size["width"], ), ) def test_call_numpy(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random numpy tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, numpify=True) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, numpify=True) for image in image_inputs: self.assertIsInstance(image, np.ndarray) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.size["height"], + self.image_processor_tester.size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.size["height"], + self.image_processor_tester.size["width"], ), ) def test_call_pytorch(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PyTorch tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, torchify=True) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, torchify=True) for image in image_inputs: self.assertIsInstance(image, torch.Tensor) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.size["height"], + self.image_processor_tester.size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.size["height"], + self.image_processor_tester.size["width"], ), ) def test_layoutlmv2_integration_test(self): # with apply_OCR = True - feature_extractor = LayoutLMv2FeatureExtractor() + image_processing = LayoutLMv2ImageProcessor() from datasets import load_dataset @@ -200,7 +199,7 @@ class LayoutLMv2FeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest image = Image.open(ds[0]["file"]).convert("RGB") - encoding = feature_extractor(image, return_tensors="pt") + encoding = image_processing(image, return_tensors="pt") self.assertEqual(encoding.pixel_values.shape, (1, 3, 224, 224)) self.assertEqual(len(encoding.words), len(encoding.boxes)) @@ -215,8 +214,8 @@ class LayoutLMv2FeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest self.assertListEqual(encoding.boxes, expected_boxes) # with apply_OCR = False - feature_extractor = LayoutLMv2FeatureExtractor(apply_ocr=False) + image_processing = LayoutLMv2ImageProcessor(apply_ocr=False) - encoding = feature_extractor(image, return_tensors="pt") + encoding = image_processing(image, return_tensors="pt") self.assertEqual(encoding.pixel_values.shape, (1, 3, 224, 224)) diff --git a/tests/models/layoutlmv3/test_image_processing_layoutlmv3.py b/tests/models/layoutlmv3/test_image_processing_layoutlmv3.py index 829fc8d79d..c61d52b65a 100644 --- a/tests/models/layoutlmv3/test_image_processing_layoutlmv3.py +++ b/tests/models/layoutlmv3/test_image_processing_layoutlmv3.py @@ -21,8 +21,7 @@ import numpy as np from transformers.testing_utils import require_pytesseract, require_torch from transformers.utils import is_pytesseract_available, is_torch_available -from ...test_feature_extraction_common import FeatureExtractionSavingTestMixin -from ...test_image_processing_common import prepare_image_inputs +from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs if is_torch_available(): @@ -31,10 +30,10 @@ if is_torch_available(): if is_pytesseract_available(): from PIL import Image - from transformers import LayoutLMv3FeatureExtractor + from transformers import LayoutLMv3ImageProcessor -class LayoutLMv3FeatureExtractionTester(unittest.TestCase): +class LayoutLMv3ImageProcessingTester(unittest.TestCase): def __init__( self, parent, @@ -58,56 +57,56 @@ class LayoutLMv3FeatureExtractionTester(unittest.TestCase): self.size = size self.apply_ocr = apply_ocr - def prepare_feat_extract_dict(self): + def prepare_image_processor_dict(self): return {"do_resize": self.do_resize, "size": self.size, "apply_ocr": self.apply_ocr} @require_torch @require_pytesseract -class LayoutLMv3FeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestCase): +class LayoutLMv3ImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase): - feature_extraction_class = LayoutLMv3FeatureExtractor if is_pytesseract_available() else None + image_processing_class = LayoutLMv3ImageProcessor if is_pytesseract_available() else None def setUp(self): - self.feature_extract_tester = LayoutLMv3FeatureExtractionTester(self) + self.image_processor_tester = LayoutLMv3ImageProcessingTester(self) @property - def feat_extract_dict(self): - return self.feature_extract_tester.prepare_feat_extract_dict() + def image_processor_dict(self): + return self.image_processor_tester.prepare_image_processor_dict() - def test_feat_extract_properties(self): - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) - self.assertTrue(hasattr(feature_extractor, "do_resize")) - self.assertTrue(hasattr(feature_extractor, "size")) - self.assertTrue(hasattr(feature_extractor, "apply_ocr")) + 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, "apply_ocr")) - def test_feat_extract_from_dict_with_kwargs(self): - feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict) - self.assertEqual(feature_extractor.size, {"height": 18, "width": 18}) + 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}) - feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict, size=42) - self.assertEqual(feature_extractor.size, {"height": 42, "width": 42}) + image_processor = self.image_processing_class.from_dict(self.image_processor_dict, size=42) + self.assertEqual(image_processor.size, {"height": 42, "width": 42}) def test_batch_feature(self): pass def test_call_pil(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PIL images - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False) for image in image_inputs: self.assertIsInstance(image, Image.Image) # Test not batched input - encoding = feature_extractor(image_inputs[0], return_tensors="pt") + encoding = image_processing(image_inputs[0], return_tensors="pt") self.assertEqual( encoding.pixel_values.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.size["height"], + self.image_processor_tester.size["width"], ), ) @@ -115,84 +114,84 @@ class LayoutLMv3FeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest self.assertIsInstance(encoding.boxes, list) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.size["height"], + self.image_processor_tester.size["width"], ), ) def test_call_numpy(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random numpy tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, numpify=True) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, numpify=True) for image in image_inputs: self.assertIsInstance(image, np.ndarray) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.size["height"], + self.image_processor_tester.size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.size["height"], + self.image_processor_tester.size["width"], ), ) def test_call_pytorch(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PyTorch tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, torchify=True) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, torchify=True) for image in image_inputs: self.assertIsInstance(image, torch.Tensor) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.size["height"], + self.image_processor_tester.size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.size["height"], + self.image_processor_tester.size["width"], ), ) def test_LayoutLMv3_integration_test(self): # with apply_OCR = True - feature_extractor = LayoutLMv3FeatureExtractor() + image_processing = LayoutLMv3ImageProcessor() from datasets import load_dataset @@ -200,7 +199,7 @@ class LayoutLMv3FeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest image = Image.open(ds[0]["file"]).convert("RGB") - encoding = feature_extractor(image, return_tensors="pt") + encoding = image_processing(image, return_tensors="pt") self.assertEqual(encoding.pixel_values.shape, (1, 3, 224, 224)) self.assertEqual(len(encoding.words), len(encoding.boxes)) @@ -215,8 +214,8 @@ class LayoutLMv3FeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest self.assertListEqual(encoding.boxes, expected_boxes) # with apply_OCR = False - feature_extractor = LayoutLMv3FeatureExtractor(apply_ocr=False) + image_processing = LayoutLMv3ImageProcessor(apply_ocr=False) - encoding = feature_extractor(image, return_tensors="pt") + encoding = image_processing(image, return_tensors="pt") self.assertEqual(encoding.pixel_values.shape, (1, 3, 224, 224)) diff --git a/tests/models/levit/test_image_processing_levit.py b/tests/models/levit/test_image_processing_levit.py index 76f3c66e1a..8fba9a5d03 100644 --- a/tests/models/levit/test_image_processing_levit.py +++ b/tests/models/levit/test_image_processing_levit.py @@ -21,8 +21,7 @@ import numpy as np from transformers.testing_utils import require_torch, require_vision from transformers.utils import is_torch_available, is_vision_available -from ...test_feature_extraction_common import FeatureExtractionSavingTestMixin -from ...test_image_processing_common import prepare_image_inputs +from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs if is_torch_available(): @@ -31,10 +30,10 @@ if is_torch_available(): if is_vision_available(): from PIL import Image - from transformers import LevitFeatureExtractor + from transformers import LevitImageProcessor -class LevitFeatureExtractionTester(unittest.TestCase): +class LevitImageProcessingTester(unittest.TestCase): def __init__( self, parent, @@ -67,7 +66,7 @@ class LevitFeatureExtractionTester(unittest.TestCase): self.image_mean = image_mean self.image_std = image_std - def prepare_feat_extract_dict(self): + def prepare_image_processor_dict(self): return { "image_mean": self.image_mean, "image_std": self.image_std, @@ -81,130 +80,130 @@ class LevitFeatureExtractionTester(unittest.TestCase): @require_torch @require_vision -class LevitFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestCase): +class LevitImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase): - feature_extraction_class = LevitFeatureExtractor if is_vision_available() else None + image_processing_class = LevitImageProcessor if is_vision_available() else None def setUp(self): - self.feature_extract_tester = LevitFeatureExtractionTester(self) + self.image_processor_tester = LevitImageProcessingTester(self) @property - def feat_extract_dict(self): - return self.feature_extract_tester.prepare_feat_extract_dict() + def image_processor_dict(self): + return self.image_processor_tester.prepare_image_processor_dict() - def test_feat_extract_properties(self): - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) - self.assertTrue(hasattr(feature_extractor, "image_mean")) - self.assertTrue(hasattr(feature_extractor, "image_std")) - self.assertTrue(hasattr(feature_extractor, "do_normalize")) - self.assertTrue(hasattr(feature_extractor, "do_resize")) - self.assertTrue(hasattr(feature_extractor, "do_center_crop")) - self.assertTrue(hasattr(feature_extractor, "size")) + def test_image_processor_properties(self): + image_processing = self.image_processing_class(**self.image_processor_dict) + self.assertTrue(hasattr(image_processing, "image_mean")) + self.assertTrue(hasattr(image_processing, "image_std")) + self.assertTrue(hasattr(image_processing, "do_normalize")) + self.assertTrue(hasattr(image_processing, "do_resize")) + self.assertTrue(hasattr(image_processing, "do_center_crop")) + self.assertTrue(hasattr(image_processing, "size")) - def test_feat_extract_from_dict_with_kwargs(self): - feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict) - self.assertEqual(feature_extractor.size, {"shortest_edge": 18}) - self.assertEqual(feature_extractor.crop_size, {"height": 18, "width": 18}) + 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, {"shortest_edge": 18}) + self.assertEqual(image_processor.crop_size, {"height": 18, "width": 18}) - feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict, size=42, crop_size=84) - self.assertEqual(feature_extractor.size, {"shortest_edge": 42}) - self.assertEqual(feature_extractor.crop_size, {"height": 84, "width": 84}) + image_processor = self.image_processing_class.from_dict(self.image_processor_dict, size=42, crop_size=84) + self.assertEqual(image_processor.size, {"shortest_edge": 42}) + self.assertEqual(image_processor.crop_size, {"height": 84, "width": 84}) def test_batch_feature(self): pass def test_call_pil(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PIL images - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False) for image in image_inputs: self.assertIsInstance(image, Image.Image) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) def test_call_numpy(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random numpy tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, numpify=True) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, numpify=True) for image in image_inputs: self.assertIsInstance(image, np.ndarray) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) def test_call_pytorch(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PyTorch tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, torchify=True) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, torchify=True) for image in image_inputs: self.assertIsInstance(image, torch.Tensor) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) diff --git a/tests/models/maskformer/test_image_processing_maskformer.py b/tests/models/maskformer/test_image_processing_maskformer.py index cb4f448268..2df4b8df92 100644 --- a/tests/models/maskformer/test_image_processing_maskformer.py +++ b/tests/models/maskformer/test_image_processing_maskformer.py @@ -23,15 +23,14 @@ from huggingface_hub import hf_hub_download from transformers.testing_utils import require_torch, require_vision from transformers.utils import is_torch_available, is_vision_available -from ...test_feature_extraction_common import FeatureExtractionSavingTestMixin -from ...test_image_processing_common import prepare_image_inputs +from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs if is_torch_available(): import torch if is_vision_available(): - from transformers import MaskFormerFeatureExtractor + from transformers import MaskFormerImageProcessor from transformers.models.maskformer.image_processing_maskformer import binary_mask_to_rle from transformers.models.maskformer.modeling_maskformer import MaskFormerForInstanceSegmentationOutput @@ -39,7 +38,7 @@ if is_vision_available(): from PIL import Image -class MaskFormerFeatureExtractionTester(unittest.TestCase): +class MaskFormerImageProcessingTester(unittest.TestCase): def __init__( self, parent, @@ -77,7 +76,7 @@ class MaskFormerFeatureExtractionTester(unittest.TestCase): self.do_reduce_labels = do_reduce_labels self.ignore_index = ignore_index - def prepare_feat_extract_dict(self): + def prepare_image_processor_dict(self): return { "do_resize": self.do_resize, "size": self.size, @@ -92,7 +91,7 @@ class MaskFormerFeatureExtractionTester(unittest.TestCase): def get_expected_values(self, image_inputs, batched=False): """ - This function computes the expected height and width when providing images to MaskFormerFeatureExtractor, + This function computes the expected height and width when providing images to MaskFormerImageProcessor, assuming do_resize is set to True with a scalar size. """ if not batched: @@ -131,154 +130,154 @@ class MaskFormerFeatureExtractionTester(unittest.TestCase): @require_torch @require_vision -class MaskFormerFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestCase): +class MaskFormerImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase): - feature_extraction_class = MaskFormerFeatureExtractor if (is_vision_available() and is_torch_available()) else None + image_processing_class = MaskFormerImageProcessor if (is_vision_available() and is_torch_available()) else None def setUp(self): - self.feature_extract_tester = MaskFormerFeatureExtractionTester(self) + self.image_processor_tester = MaskFormerImageProcessingTester(self) @property - def feat_extract_dict(self): - return self.feature_extract_tester.prepare_feat_extract_dict() + def image_processor_dict(self): + return self.image_processor_tester.prepare_image_processor_dict() - def test_feat_extract_properties(self): - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) - self.assertTrue(hasattr(feature_extractor, "image_mean")) - self.assertTrue(hasattr(feature_extractor, "image_std")) - self.assertTrue(hasattr(feature_extractor, "do_normalize")) - self.assertTrue(hasattr(feature_extractor, "do_resize")) - self.assertTrue(hasattr(feature_extractor, "size")) - self.assertTrue(hasattr(feature_extractor, "max_size")) - self.assertTrue(hasattr(feature_extractor, "ignore_index")) - self.assertTrue(hasattr(feature_extractor, "num_labels")) + def test_image_processor_properties(self): + image_processing = self.image_processing_class(**self.image_processor_dict) + self.assertTrue(hasattr(image_processing, "image_mean")) + self.assertTrue(hasattr(image_processing, "image_std")) + self.assertTrue(hasattr(image_processing, "do_normalize")) + self.assertTrue(hasattr(image_processing, "do_resize")) + self.assertTrue(hasattr(image_processing, "size")) + self.assertTrue(hasattr(image_processing, "max_size")) + self.assertTrue(hasattr(image_processing, "ignore_index")) + self.assertTrue(hasattr(image_processing, "num_labels")) - def test_feat_extract_from_dict_with_kwargs(self): - feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict) - self.assertEqual(feature_extractor.size, {"shortest_edge": 32, "longest_edge": 1333}) - self.assertEqual(feature_extractor.size_divisor, 0) + 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, {"shortest_edge": 32, "longest_edge": 1333}) + self.assertEqual(image_processor.size_divisor, 0) - feature_extractor = self.feature_extraction_class.from_dict( - self.feat_extract_dict, size=42, max_size=84, size_divisibility=8 + image_processor = self.image_processing_class.from_dict( + self.image_processor_dict, size=42, max_size=84, size_divisibility=8 ) - self.assertEqual(feature_extractor.size, {"shortest_edge": 42, "longest_edge": 84}) - self.assertEqual(feature_extractor.size_divisor, 8) + self.assertEqual(image_processor.size, {"shortest_edge": 42, "longest_edge": 84}) + self.assertEqual(image_processor.size_divisor, 8) def test_batch_feature(self): pass def test_call_pil(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PIL images - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False) for image in image_inputs: self.assertIsInstance(image, Image.Image) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values - expected_height, expected_width = self.feature_extract_tester.get_expected_values(image_inputs) + expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs) self.assertEqual( encoded_images.shape, - (1, self.feature_extract_tester.num_channels, expected_height, expected_width), + (1, self.image_processor_tester.num_channels, expected_height, expected_width), ) # Test batched - expected_height, expected_width = self.feature_extract_tester.get_expected_values(image_inputs, batched=True) + expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs, batched=True) - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, expected_height, expected_width, ), ) def test_call_numpy(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random numpy tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, numpify=True) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, numpify=True) for image in image_inputs: self.assertIsInstance(image, np.ndarray) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values - expected_height, expected_width = self.feature_extract_tester.get_expected_values(image_inputs) + expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs) self.assertEqual( encoded_images.shape, - (1, self.feature_extract_tester.num_channels, expected_height, expected_width), + (1, self.image_processor_tester.num_channels, expected_height, expected_width), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values - expected_height, expected_width = self.feature_extract_tester.get_expected_values(image_inputs, batched=True) + expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs, batched=True) self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, expected_height, expected_width, ), ) def test_call_pytorch(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PyTorch tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, torchify=True) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, torchify=True) for image in image_inputs: self.assertIsInstance(image, torch.Tensor) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values - expected_height, expected_width = self.feature_extract_tester.get_expected_values(image_inputs) + expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs) self.assertEqual( encoded_images.shape, - (1, self.feature_extract_tester.num_channels, expected_height, expected_width), + (1, self.image_processor_tester.num_channels, expected_height, expected_width), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values - expected_height, expected_width = self.feature_extract_tester.get_expected_values(image_inputs, batched=True) + expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs, batched=True) self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, expected_height, expected_width, ), ) def test_equivalence_pad_and_create_pixel_mask(self): - # Initialize feature_extractors - feature_extractor_1 = self.feature_extraction_class(**self.feat_extract_dict) - feature_extractor_2 = self.feature_extraction_class( - do_resize=False, do_normalize=False, do_rescale=False, num_labels=self.feature_extract_tester.num_classes + # Initialize image_processings + image_processing_1 = self.image_processing_class(**self.image_processor_dict) + image_processing_2 = self.image_processing_class( + do_resize=False, do_normalize=False, do_rescale=False, num_labels=self.image_processor_tester.num_classes ) # create random PyTorch tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, torchify=True) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, torchify=True) for image in image_inputs: self.assertIsInstance(image, torch.Tensor) - # Test whether the method "pad_and_return_pixel_mask" and calling the feature extractor return the same tensors - encoded_images_with_method = feature_extractor_1.encode_inputs(image_inputs, return_tensors="pt") - encoded_images = feature_extractor_2(image_inputs, return_tensors="pt") + # Test whether the method "pad_and_return_pixel_mask" and calling the image processor return the same tensors + encoded_images_with_method = image_processing_1.encode_inputs(image_inputs, return_tensors="pt") + encoded_images = image_processing_2(image_inputs, return_tensors="pt") self.assertTrue( torch.allclose(encoded_images_with_method["pixel_values"], encoded_images["pixel_values"], atol=1e-4) @@ -287,15 +286,15 @@ class MaskFormerFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest torch.allclose(encoded_images_with_method["pixel_mask"], encoded_images["pixel_mask"], atol=1e-4) ) - def comm_get_feature_extractor_inputs( + def comm_get_image_processing_inputs( self, with_segmentation_maps=False, is_instance_map=False, segmentation_type="np" ): - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + image_processing = self.image_processing_class(**self.image_processor_dict) # prepare image and target - num_labels = self.feature_extract_tester.num_labels + num_labels = self.image_processor_tester.num_labels annotations = None instance_id_to_semantic_id = None - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False) if with_segmentation_maps: high = num_labels if is_instance_map: @@ -309,7 +308,7 @@ class MaskFormerFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest if segmentation_type == "pil": annotations = [Image.fromarray(annotation) for annotation in annotations] - inputs = feature_extractor( + inputs = image_processing( image_inputs, annotations, return_tensors="pt", @@ -326,10 +325,10 @@ class MaskFormerFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest size_divisors = [8, 16, 32] weird_input_sizes = [(407, 802), (582, 1094)] for size_divisor in size_divisors: - feat_extract_dict = {**self.feat_extract_dict, **{"size_divisor": size_divisor}} - feature_extractor = self.feature_extraction_class(**feat_extract_dict) + image_processor_dict = {**self.image_processor_dict, **{"size_divisor": size_divisor}} + image_processing = self.image_processing_class(**image_processor_dict) for weird_input_size in weird_input_sizes: - inputs = feature_extractor([np.ones((3, *weird_input_size))], return_tensors="pt") + inputs = image_processing([np.ones((3, *weird_input_size))], return_tensors="pt") pixel_values = inputs["pixel_values"] # check if divisible self.assertTrue((pixel_values.shape[-1] % size_divisor) == 0) @@ -337,7 +336,7 @@ class MaskFormerFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest def test_call_with_segmentation_maps(self): def common(is_instance_map=False, segmentation_type=None): - inputs = self.comm_get_feature_extractor_inputs( + inputs = self.comm_get_image_processing_inputs( with_segmentation_maps=True, is_instance_map=is_instance_map, segmentation_type=segmentation_type ) @@ -389,11 +388,11 @@ class MaskFormerFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest instance_seg1, inst2class1 = get_instance_segmentation_and_mapping(annotation1) instance_seg2, inst2class2 = get_instance_segmentation_and_mapping(annotation2) - # create a feature extractor - feature_extractor = MaskFormerFeatureExtractor(reduce_labels=True, ignore_index=255, size=(512, 512)) + # create a image processor + image_processing = MaskFormerImageProcessor(reduce_labels=True, ignore_index=255, size=(512, 512)) # prepare the images and annotations - inputs = feature_extractor( + inputs = image_processing( [image1, image2], [instance_seg1, instance_seg2], instance_id_to_semantic_id=[inst2class1, inst2class2], @@ -432,11 +431,11 @@ class MaskFormerFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest hf_hub_download(repo_id=repo_id, filename="semantic_segmentation_annotation_2.png", repo_type="dataset") ) - # create a feature extractor - feature_extractor = MaskFormerFeatureExtractor(reduce_labels=True, ignore_index=255, size=(512, 512)) + # create a image processor + image_processing = MaskFormerImageProcessor(reduce_labels=True, ignore_index=255, size=(512, 512)) # prepare the images and annotations - inputs = feature_extractor( + inputs = image_processing( [image1, image2], [annotation1, annotation2], return_tensors="pt", @@ -489,12 +488,12 @@ class MaskFormerFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest panoptic_map1, inst2class1 = create_panoptic_map(annotation1, segments_info1) panoptic_map2, inst2class2 = create_panoptic_map(annotation2, segments_info2) - # create a feature extractor - feature_extractor = MaskFormerFeatureExtractor(ignore_index=0, do_resize=False) + # create a image processor + image_processing = MaskFormerImageProcessor(ignore_index=0, do_resize=False) # prepare the images and annotations pixel_values_list = [np.moveaxis(np.array(image1), -1, 0), np.moveaxis(np.array(image2), -1, 0)] - inputs = feature_extractor.encode_inputs( + inputs = image_processing.encode_inputs( pixel_values_list, [panoptic_map1, panoptic_map2], instance_id_to_semantic_id=[inst2class1, inst2class2], @@ -535,17 +534,17 @@ class MaskFormerFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest self.assertEqual(rle[1], 45) def test_post_process_segmentation(self): - fature_extractor = self.feature_extraction_class(num_labels=self.feature_extract_tester.num_classes) - outputs = self.feature_extract_tester.get_fake_maskformer_outputs() + fature_extractor = self.image_processing_class(num_labels=self.image_processor_tester.num_classes) + outputs = self.image_processor_tester.get_fake_maskformer_outputs() segmentation = fature_extractor.post_process_segmentation(outputs) self.assertEqual( segmentation.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_classes, - self.feature_extract_tester.height, - self.feature_extract_tester.width, + self.image_processor_tester.batch_size, + self.image_processor_tester.num_classes, + self.image_processor_tester.height, + self.image_processor_tester.width, ), ) @@ -554,53 +553,53 @@ class MaskFormerFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest self.assertEqual( segmentation.shape, - (self.feature_extract_tester.batch_size, self.feature_extract_tester.num_classes, *target_size), + (self.image_processor_tester.batch_size, self.image_processor_tester.num_classes, *target_size), ) def test_post_process_semantic_segmentation(self): - fature_extractor = self.feature_extraction_class(num_labels=self.feature_extract_tester.num_classes) - outputs = self.feature_extract_tester.get_fake_maskformer_outputs() + fature_extractor = self.image_processing_class(num_labels=self.image_processor_tester.num_classes) + outputs = self.image_processor_tester.get_fake_maskformer_outputs() segmentation = fature_extractor.post_process_semantic_segmentation(outputs) - self.assertEqual(len(segmentation), self.feature_extract_tester.batch_size) + self.assertEqual(len(segmentation), self.image_processor_tester.batch_size) self.assertEqual( segmentation[0].shape, ( - self.feature_extract_tester.height, - self.feature_extract_tester.width, + self.image_processor_tester.height, + self.image_processor_tester.width, ), ) - target_sizes = [(1, 4) for i in range(self.feature_extract_tester.batch_size)] + target_sizes = [(1, 4) for i in range(self.image_processor_tester.batch_size)] segmentation = fature_extractor.post_process_semantic_segmentation(outputs, target_sizes=target_sizes) self.assertEqual(segmentation[0].shape, target_sizes[0]) def test_post_process_panoptic_segmentation(self): - feature_extractor = self.feature_extraction_class(num_labels=self.feature_extract_tester.num_classes) - outputs = self.feature_extract_tester.get_fake_maskformer_outputs() - segmentation = feature_extractor.post_process_panoptic_segmentation(outputs, threshold=0) + image_processing = self.image_processing_class(num_labels=self.image_processor_tester.num_classes) + outputs = self.image_processor_tester.get_fake_maskformer_outputs() + segmentation = image_processing.post_process_panoptic_segmentation(outputs, threshold=0) - self.assertTrue(len(segmentation) == self.feature_extract_tester.batch_size) + self.assertTrue(len(segmentation) == self.image_processor_tester.batch_size) for el in segmentation: self.assertTrue("segmentation" in el) self.assertTrue("segments_info" in el) self.assertEqual(type(el["segments_info"]), list) self.assertEqual( - el["segmentation"].shape, (self.feature_extract_tester.height, self.feature_extract_tester.width) + el["segmentation"].shape, (self.image_processor_tester.height, self.image_processor_tester.width) ) def test_post_process_label_fusing(self): - feature_extractor = self.feature_extraction_class(num_labels=self.feature_extract_tester.num_classes) - outputs = self.feature_extract_tester.get_fake_maskformer_outputs() + image_processor = self.image_processing_class(num_labels=self.image_processor_tester.num_classes) + outputs = self.image_processor_tester.get_fake_maskformer_outputs() - segmentation = feature_extractor.post_process_panoptic_segmentation( + segmentation = image_processor.post_process_panoptic_segmentation( outputs, threshold=0, mask_threshold=0, overlap_mask_area_threshold=0 ) unfused_segments = [el["segments_info"] for el in segmentation] - fused_segmentation = feature_extractor.post_process_panoptic_segmentation( + fused_segmentation = image_processor.post_process_panoptic_segmentation( outputs, threshold=0, mask_threshold=0, overlap_mask_area_threshold=0, label_ids_to_fuse={1} ) fused_segments = [el["segments_info"] for el in fused_segmentation] diff --git a/tests/models/mobilenet_v1/test_image_processing_mobilenet_v1.py b/tests/models/mobilenet_v1/test_image_processing_mobilenet_v1.py index 383f91c554..34096ff1f9 100644 --- a/tests/models/mobilenet_v1/test_image_processing_mobilenet_v1.py +++ b/tests/models/mobilenet_v1/test_image_processing_mobilenet_v1.py @@ -21,8 +21,7 @@ import numpy as np from transformers.testing_utils import require_torch, require_vision from transformers.utils import is_torch_available, is_vision_available -from ...test_feature_extraction_common import FeatureExtractionSavingTestMixin -from ...test_image_processing_common import prepare_image_inputs +from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs if is_torch_available(): @@ -31,10 +30,10 @@ if is_torch_available(): if is_vision_available(): from PIL import Image - from transformers import MobileNetV1FeatureExtractor + from transformers import MobileNetV1ImageProcessor -class MobileNetV1FeatureExtractionTester(unittest.TestCase): +class MobileNetV1ImageProcessingTester(unittest.TestCase): def __init__( self, parent, @@ -61,7 +60,7 @@ class MobileNetV1FeatureExtractionTester(unittest.TestCase): self.do_center_crop = do_center_crop self.crop_size = crop_size - def prepare_feat_extract_dict(self): + def prepare_image_processor_dict(self): return { "do_resize": self.do_resize, "size": self.size, @@ -72,128 +71,128 @@ class MobileNetV1FeatureExtractionTester(unittest.TestCase): @require_torch @require_vision -class MobileNetV1FeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestCase): +class MobileNetV1ImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase): - feature_extraction_class = MobileNetV1FeatureExtractor if is_vision_available() else None + image_processing_class = MobileNetV1ImageProcessor if is_vision_available() else None def setUp(self): - self.feature_extract_tester = MobileNetV1FeatureExtractionTester(self) + self.image_processor_tester = MobileNetV1ImageProcessingTester(self) @property - def feat_extract_dict(self): - return self.feature_extract_tester.prepare_feat_extract_dict() + def image_processor_dict(self): + return self.image_processor_tester.prepare_image_processor_dict() - def test_feat_extract_properties(self): - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) - self.assertTrue(hasattr(feature_extractor, "do_resize")) - self.assertTrue(hasattr(feature_extractor, "size")) - self.assertTrue(hasattr(feature_extractor, "do_center_crop")) - self.assertTrue(hasattr(feature_extractor, "center_crop")) + 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_center_crop")) + self.assertTrue(hasattr(image_processing, "center_crop")) - def test_feat_extract_from_dict_with_kwargs(self): - feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict) - self.assertEqual(feature_extractor.size, {"shortest_edge": 20}) - self.assertEqual(feature_extractor.crop_size, {"height": 18, "width": 18}) + 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, {"shortest_edge": 20}) + self.assertEqual(image_processor.crop_size, {"height": 18, "width": 18}) - feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict, size=42, crop_size=84) - self.assertEqual(feature_extractor.size, {"shortest_edge": 42}) - self.assertEqual(feature_extractor.crop_size, {"height": 84, "width": 84}) + image_processor = self.image_processing_class.from_dict(self.image_processor_dict, size=42, crop_size=84) + self.assertEqual(image_processor.size, {"shortest_edge": 42}) + self.assertEqual(image_processor.crop_size, {"height": 84, "width": 84}) def test_batch_feature(self): pass def test_call_pil(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PIL images - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False) for image in image_inputs: self.assertIsInstance(image, Image.Image) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) def test_call_numpy(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random numpy tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, numpify=True) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, numpify=True) for image in image_inputs: self.assertIsInstance(image, np.ndarray) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) def test_call_pytorch(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PyTorch tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, torchify=True) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, torchify=True) for image in image_inputs: self.assertIsInstance(image, torch.Tensor) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) diff --git a/tests/models/mobilenet_v2/test_image_processing_mobilenet_v2.py b/tests/models/mobilenet_v2/test_image_processing_mobilenet_v2.py index e207932e38..472280753e 100644 --- a/tests/models/mobilenet_v2/test_image_processing_mobilenet_v2.py +++ b/tests/models/mobilenet_v2/test_image_processing_mobilenet_v2.py @@ -21,8 +21,7 @@ import numpy as np from transformers.testing_utils import require_torch, require_vision from transformers.utils import is_torch_available, is_vision_available -from ...test_feature_extraction_common import FeatureExtractionSavingTestMixin -from ...test_image_processing_common import prepare_image_inputs +from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs if is_torch_available(): @@ -31,10 +30,10 @@ if is_torch_available(): if is_vision_available(): from PIL import Image - from transformers import MobileNetV2FeatureExtractor + from transformers import MobileNetV2ImageProcessor -class MobileNetV2FeatureExtractionTester(unittest.TestCase): +class MobileNetV2ImageProcessingTester(unittest.TestCase): def __init__( self, parent, @@ -61,7 +60,7 @@ class MobileNetV2FeatureExtractionTester(unittest.TestCase): self.do_center_crop = do_center_crop self.crop_size = crop_size - def prepare_feat_extract_dict(self): + def prepare_image_processor_dict(self): return { "do_resize": self.do_resize, "size": self.size, @@ -72,128 +71,128 @@ class MobileNetV2FeatureExtractionTester(unittest.TestCase): @require_torch @require_vision -class MobileNetV2FeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestCase): +class MobileNetV2ImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase): - feature_extraction_class = MobileNetV2FeatureExtractor if is_vision_available() else None + image_processing_class = MobileNetV2ImageProcessor if is_vision_available() else None def setUp(self): - self.feature_extract_tester = MobileNetV2FeatureExtractionTester(self) + self.image_processor_tester = MobileNetV2ImageProcessingTester(self) @property - def feat_extract_dict(self): - return self.feature_extract_tester.prepare_feat_extract_dict() + def image_processor_dict(self): + return self.image_processor_tester.prepare_image_processor_dict() - def test_feat_extract_properties(self): - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) - self.assertTrue(hasattr(feature_extractor, "do_resize")) - self.assertTrue(hasattr(feature_extractor, "size")) - self.assertTrue(hasattr(feature_extractor, "do_center_crop")) - self.assertTrue(hasattr(feature_extractor, "crop_size")) + def test_image_processor_properties(self): + image_processor = self.image_processing_class(**self.image_processor_dict) + self.assertTrue(hasattr(image_processor, "do_resize")) + self.assertTrue(hasattr(image_processor, "size")) + self.assertTrue(hasattr(image_processor, "do_center_crop")) + self.assertTrue(hasattr(image_processor, "crop_size")) - def test_feat_extract_from_dict_with_kwargs(self): - feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict) - self.assertEqual(feature_extractor.size, {"shortest_edge": 20}) - self.assertEqual(feature_extractor.crop_size, {"height": 18, "width": 18}) + 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, {"shortest_edge": 20}) + self.assertEqual(image_processor.crop_size, {"height": 18, "width": 18}) - feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict, size=42, crop_size=84) - self.assertEqual(feature_extractor.size, {"shortest_edge": 42}) - self.assertEqual(feature_extractor.crop_size, {"height": 84, "width": 84}) + image_processor = self.image_processing_class.from_dict(self.image_processor_dict, size=42, crop_size=84) + self.assertEqual(image_processor.size, {"shortest_edge": 42}) + self.assertEqual(image_processor.crop_size, {"height": 84, "width": 84}) def test_batch_feature(self): pass def test_call_pil(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PIL images - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False) for image in image_inputs: self.assertIsInstance(image, Image.Image) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) def test_call_numpy(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random numpy tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, numpify=True) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, numpify=True) for image in image_inputs: self.assertIsInstance(image, np.ndarray) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) def test_call_pytorch(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PyTorch tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, torchify=True) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, torchify=True) for image in image_inputs: self.assertIsInstance(image, torch.Tensor) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) diff --git a/tests/models/mobilevit/test_image_processing_mobilevit.py b/tests/models/mobilevit/test_image_processing_mobilevit.py index a22fc2c1d5..d14a405715 100644 --- a/tests/models/mobilevit/test_image_processing_mobilevit.py +++ b/tests/models/mobilevit/test_image_processing_mobilevit.py @@ -21,8 +21,7 @@ import numpy as np from transformers.testing_utils import require_torch, require_vision from transformers.utils import is_torch_available, is_vision_available -from ...test_feature_extraction_common import FeatureExtractionSavingTestMixin -from ...test_image_processing_common import prepare_image_inputs +from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs if is_torch_available(): @@ -31,10 +30,10 @@ if is_torch_available(): if is_vision_available(): from PIL import Image - from transformers import MobileViTFeatureExtractor + from transformers import MobileViTImageProcessor -class MobileViTFeatureExtractionTester(unittest.TestCase): +class MobileViTImageProcessingTester(unittest.TestCase): def __init__( self, parent, @@ -63,7 +62,7 @@ class MobileViTFeatureExtractionTester(unittest.TestCase): self.crop_size = crop_size self.do_flip_channel_order = do_flip_channel_order - def prepare_feat_extract_dict(self): + def prepare_image_processor_dict(self): return { "do_resize": self.do_resize, "size": self.size, @@ -75,129 +74,129 @@ class MobileViTFeatureExtractionTester(unittest.TestCase): @require_torch @require_vision -class MobileViTFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestCase): +class MobileViTImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase): - feature_extraction_class = MobileViTFeatureExtractor if is_vision_available() else None + image_processing_class = MobileViTImageProcessor if is_vision_available() else None def setUp(self): - self.feature_extract_tester = MobileViTFeatureExtractionTester(self) + self.image_processor_tester = MobileViTImageProcessingTester(self) @property - def feat_extract_dict(self): - return self.feature_extract_tester.prepare_feat_extract_dict() + def image_processor_dict(self): + return self.image_processor_tester.prepare_image_processor_dict() - def test_feat_extract_properties(self): - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) - self.assertTrue(hasattr(feature_extractor, "do_resize")) - self.assertTrue(hasattr(feature_extractor, "size")) - self.assertTrue(hasattr(feature_extractor, "do_center_crop")) - self.assertTrue(hasattr(feature_extractor, "center_crop")) - self.assertTrue(hasattr(feature_extractor, "do_flip_channel_order")) + 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_center_crop")) + self.assertTrue(hasattr(image_processing, "center_crop")) + self.assertTrue(hasattr(image_processing, "do_flip_channel_order")) - def test_feat_extract_from_dict_with_kwargs(self): - feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict) - self.assertEqual(feature_extractor.size, {"shortest_edge": 20}) - self.assertEqual(feature_extractor.crop_size, {"height": 18, "width": 18}) + 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, {"shortest_edge": 20}) + self.assertEqual(image_processor.crop_size, {"height": 18, "width": 18}) - feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict, size=42, crop_size=84) - self.assertEqual(feature_extractor.size, {"shortest_edge": 42}) - self.assertEqual(feature_extractor.crop_size, {"height": 84, "width": 84}) + image_processor = self.image_processing_class.from_dict(self.image_processor_dict, size=42, crop_size=84) + self.assertEqual(image_processor.size, {"shortest_edge": 42}) + self.assertEqual(image_processor.crop_size, {"height": 84, "width": 84}) def test_batch_feature(self): pass def test_call_pil(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PIL images - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False) for image in image_inputs: self.assertIsInstance(image, Image.Image) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) def test_call_numpy(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random numpy tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, numpify=True) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, numpify=True) for image in image_inputs: self.assertIsInstance(image, np.ndarray) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) def test_call_pytorch(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PyTorch tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, torchify=True) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, torchify=True) for image in image_inputs: self.assertIsInstance(image, torch.Tensor) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) diff --git a/tests/models/oneformer/test_image_processing_oneformer.py b/tests/models/oneformer/test_image_processing_oneformer.py index c94089d115..ac12447a36 100644 --- a/tests/models/oneformer/test_image_processing_oneformer.py +++ b/tests/models/oneformer/test_image_processing_oneformer.py @@ -23,8 +23,7 @@ from huggingface_hub import hf_hub_download from transformers.testing_utils import require_torch, require_vision from transformers.utils import is_torch_available, is_vision_available -from ...test_feature_extraction_common import FeatureExtractionSavingTestMixin -from ...test_image_processing_common import prepare_image_inputs +from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs if is_torch_available(): @@ -100,7 +99,7 @@ class OneFormerImageProcessorTester(unittest.TestCase): self.do_reduce_labels = do_reduce_labels self.ignore_index = ignore_index - def prepare_feat_extract_dict(self): + def prepare_image_processor_dict(self): return { "do_resize": self.do_resize, "size": self.size, @@ -156,20 +155,20 @@ class OneFormerImageProcessorTester(unittest.TestCase): @require_torch @require_vision -class OneFormerImageProcessingTest(FeatureExtractionSavingTestMixin, unittest.TestCase): +class OneFormerImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase): image_processing_class = OneFormerImageProcessor if (is_vision_available() and is_torch_available()) else None - # only for test_feat_extracttion_common.test_feat_extract_to_json_string - feature_extraction_class = image_processing_class + # only for test_image_processing_common.test_image_proc_to_json_string + image_processing_class = image_processing_class def setUp(self): self.image_processing_tester = OneFormerImageProcessorTester(self) @property - def feat_extract_dict(self): - return self.image_processing_tester.prepare_feat_extract_dict() + def image_processor_dict(self): + return self.image_processing_tester.prepare_image_processor_dict() - def test_feat_extract_properties(self): - image_processor = self.image_processing_class(**self.feat_extract_dict) + def test_image_proc_properties(self): + image_processor = self.image_processing_class(**self.image_processor_dict) self.assertTrue(hasattr(image_processor, "image_mean")) self.assertTrue(hasattr(image_processor, "image_std")) self.assertTrue(hasattr(image_processor, "do_normalize")) @@ -187,7 +186,7 @@ class OneFormerImageProcessingTest(FeatureExtractionSavingTestMixin, unittest.Te def test_call_pil(self): # Initialize image_processor - image_processor = self.image_processing_class(**self.feat_extract_dict) + image_processor = self.image_processing_class(**self.image_processor_dict) # create random PIL images image_inputs = prepare_image_inputs(self.image_processing_tester, equal_resolution=False) for image in image_inputs: @@ -221,7 +220,7 @@ class OneFormerImageProcessingTest(FeatureExtractionSavingTestMixin, unittest.Te def test_call_numpy(self): # Initialize image_processor - image_processor = self.image_processing_class(**self.feat_extract_dict) + image_processor = self.image_processing_class(**self.image_processor_dict) # create random numpy tensors image_inputs = prepare_image_inputs(self.image_processing_tester, equal_resolution=False, numpify=True) for image in image_inputs: @@ -255,7 +254,7 @@ class OneFormerImageProcessingTest(FeatureExtractionSavingTestMixin, unittest.Te def test_call_pytorch(self): # Initialize image_processor - image_processor = self.image_processing_class(**self.feat_extract_dict) + image_processor = self.image_processing_class(**self.image_processor_dict) # create random PyTorch tensors image_inputs = prepare_image_inputs(self.image_processing_tester, equal_resolution=False, torchify=True) for image in image_inputs: @@ -289,7 +288,7 @@ class OneFormerImageProcessingTest(FeatureExtractionSavingTestMixin, unittest.Te def test_equivalence_pad_and_create_pixel_mask(self): # Initialize image_processors - image_processor_1 = self.image_processing_class(**self.feat_extract_dict) + image_processor_1 = self.image_processing_class(**self.image_processor_dict) image_processor_2 = self.image_processing_class( do_resize=False, do_normalize=False, @@ -320,7 +319,7 @@ class OneFormerImageProcessingTest(FeatureExtractionSavingTestMixin, unittest.Te def comm_get_image_processor_inputs( self, with_segmentation_maps=False, is_instance_map=False, segmentation_type="np" ): - image_processor = self.image_processing_class(**self.feat_extract_dict) + image_processor = self.image_processing_class(**self.image_processor_dict) # prepare image and target num_labels = self.image_processing_tester.num_labels annotations = None diff --git a/tests/models/owlvit/test_image_processing_owlvit.py b/tests/models/owlvit/test_image_processing_owlvit.py index bf2cd8d666..b94120f563 100644 --- a/tests/models/owlvit/test_image_processing_owlvit.py +++ b/tests/models/owlvit/test_image_processing_owlvit.py @@ -21,8 +21,7 @@ import numpy as np from transformers.testing_utils import require_torch, require_vision from transformers.utils import is_torch_available, is_vision_available -from ...test_feature_extraction_common import FeatureExtractionSavingTestMixin -from ...test_image_processing_common import prepare_image_inputs +from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs if is_torch_available(): @@ -31,10 +30,10 @@ if is_torch_available(): if is_vision_available(): from PIL import Image - from transformers import OwlViTFeatureExtractor + from transformers import OwlViTImageProcessor -class OwlViTFeatureExtractionTester(unittest.TestCase): +class OwlViTImageProcessingTester(unittest.TestCase): def __init__( self, parent, @@ -67,7 +66,7 @@ class OwlViTFeatureExtractionTester(unittest.TestCase): self.image_std = image_std self.do_convert_rgb = do_convert_rgb - def prepare_feat_extract_dict(self): + def prepare_image_processor_dict(self): return { "do_resize": self.do_resize, "size": self.size, @@ -82,130 +81,130 @@ class OwlViTFeatureExtractionTester(unittest.TestCase): @require_torch @require_vision -class OwlViTFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestCase): +class OwlViTImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase): - feature_extraction_class = OwlViTFeatureExtractor if is_vision_available() else None + image_processing_class = OwlViTImageProcessor if is_vision_available() else None def setUp(self): - self.feature_extract_tester = OwlViTFeatureExtractionTester(self) + self.image_processor_tester = OwlViTImageProcessingTester(self) @property - def feat_extract_dict(self): - return self.feature_extract_tester.prepare_feat_extract_dict() + def image_processor_dict(self): + return self.image_processor_tester.prepare_image_processor_dict() - def test_feat_extract_properties(self): - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) - self.assertTrue(hasattr(feature_extractor, "do_resize")) - self.assertTrue(hasattr(feature_extractor, "size")) - self.assertTrue(hasattr(feature_extractor, "do_center_crop")) - self.assertTrue(hasattr(feature_extractor, "center_crop")) - self.assertTrue(hasattr(feature_extractor, "do_normalize")) - self.assertTrue(hasattr(feature_extractor, "image_mean")) - self.assertTrue(hasattr(feature_extractor, "image_std")) - self.assertTrue(hasattr(feature_extractor, "do_convert_rgb")) + 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_center_crop")) + self.assertTrue(hasattr(image_processing, "center_crop")) + self.assertTrue(hasattr(image_processing, "do_normalize")) + self.assertTrue(hasattr(image_processing, "image_mean")) + self.assertTrue(hasattr(image_processing, "image_std")) + self.assertTrue(hasattr(image_processing, "do_convert_rgb")) - def test_feat_extract_from_dict_with_kwargs(self): - feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict) - self.assertEqual(feature_extractor.size, {"height": 18, "width": 18}) - self.assertEqual(feature_extractor.crop_size, {"height": 18, "width": 18}) + 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}) + self.assertEqual(image_processor.crop_size, {"height": 18, "width": 18}) - feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict, size=42, crop_size=84) - self.assertEqual(feature_extractor.size, {"height": 42, "width": 42}) - self.assertEqual(feature_extractor.crop_size, {"height": 84, "width": 84}) + image_processor = self.image_processing_class.from_dict(self.image_processor_dict, size=42, crop_size=84) + self.assertEqual(image_processor.size, {"height": 42, "width": 42}) + self.assertEqual(image_processor.crop_size, {"height": 84, "width": 84}) def test_call_pil(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PIL images - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False) for image in image_inputs: self.assertIsInstance(image, Image.Image) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) def test_call_numpy(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random numpy tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, numpify=True) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, numpify=True) for image in image_inputs: self.assertIsInstance(image, np.ndarray) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) def test_call_pytorch(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PyTorch tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, torchify=True) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, torchify=True) for image in image_inputs: self.assertIsInstance(image, torch.Tensor) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) diff --git a/tests/models/poolformer/test_image_processing_poolformer.py b/tests/models/poolformer/test_image_processing_poolformer.py index 47e583a321..d5596a55a9 100644 --- a/tests/models/poolformer/test_image_processing_poolformer.py +++ b/tests/models/poolformer/test_image_processing_poolformer.py @@ -20,8 +20,7 @@ import numpy as np from transformers.testing_utils import require_torch, require_vision from transformers.utils import is_torch_available, is_vision_available -from ...test_feature_extraction_common import FeatureExtractionSavingTestMixin -from ...test_image_processing_common import prepare_image_inputs +from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs if is_torch_available(): @@ -30,10 +29,10 @@ if is_torch_available(): if is_vision_available(): from PIL import Image - from transformers import PoolFormerFeatureExtractor + from transformers import PoolFormerImageProcessor -class PoolFormerFeatureExtractionTester(unittest.TestCase): +class PoolFormerImageProcessingTester(unittest.TestCase): def __init__( self, parent, @@ -64,7 +63,7 @@ class PoolFormerFeatureExtractionTester(unittest.TestCase): self.image_mean = image_mean self.image_std = image_std - def prepare_feat_extract_dict(self): + def prepare_image_processor_dict(self): return { "size": self.size, "do_resize_and_center_crop": self.do_resize_and_center_crop, @@ -78,131 +77,131 @@ class PoolFormerFeatureExtractionTester(unittest.TestCase): @require_torch @require_vision -class PoolFormerFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestCase): +class PoolFormerImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase): - feature_extraction_class = PoolFormerFeatureExtractor if is_vision_available() else None + image_processing_class = PoolFormerImageProcessor if is_vision_available() else None def setUp(self): - self.feature_extract_tester = PoolFormerFeatureExtractionTester(self) + self.image_processor_tester = PoolFormerImageProcessingTester(self) @property - def feat_extract_dict(self): - return self.feature_extract_tester.prepare_feat_extract_dict() + def image_processor_dict(self): + return self.image_processor_tester.prepare_image_processor_dict() - def test_feat_extract_properties(self): - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) - self.assertTrue(hasattr(feature_extractor, "do_resize_and_center_crop")) - self.assertTrue(hasattr(feature_extractor, "size")) - self.assertTrue(hasattr(feature_extractor, "crop_pct")) - self.assertTrue(hasattr(feature_extractor, "do_normalize")) - self.assertTrue(hasattr(feature_extractor, "image_mean")) - self.assertTrue(hasattr(feature_extractor, "image_std")) + def test_image_processor_properties(self): + image_processing = self.image_processing_class(**self.image_processor_dict) + self.assertTrue(hasattr(image_processing, "do_resize_and_center_crop")) + self.assertTrue(hasattr(image_processing, "size")) + self.assertTrue(hasattr(image_processing, "crop_pct")) + self.assertTrue(hasattr(image_processing, "do_normalize")) + self.assertTrue(hasattr(image_processing, "image_mean")) + self.assertTrue(hasattr(image_processing, "image_std")) - def test_feat_extract_from_dict_with_kwargs(self): - feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict) - self.assertEqual(feature_extractor.size, {"shortest_edge": 30}) - self.assertEqual(feature_extractor.crop_size, {"height": 30, "width": 30}) + 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, {"shortest_edge": 30}) + self.assertEqual(image_processor.crop_size, {"height": 30, "width": 30}) - feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict, size=42, crop_size=84) - self.assertEqual(feature_extractor.size, {"shortest_edge": 42}) - self.assertEqual(feature_extractor.crop_size, {"height": 84, "width": 84}) + image_processor = self.image_processing_class.from_dict(self.image_processor_dict, size=42, crop_size=84) + self.assertEqual(image_processor.size, {"shortest_edge": 42}) + self.assertEqual(image_processor.crop_size, {"height": 84, "width": 84}) def test_batch_feature(self): pass def test_call_pil(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PIL images - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False) for image in image_inputs: self.assertIsInstance(image, Image.Image) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) def test_call_numpy(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random numpy tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, numpify=True) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, numpify=True) for image in image_inputs: self.assertIsInstance(image, np.ndarray) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) def test_call_pytorch(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PyTorch tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, torchify=True) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, torchify=True) for image in image_inputs: self.assertIsInstance(image, torch.Tensor) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) diff --git a/tests/models/segformer/test_image_processing_segformer.py b/tests/models/segformer/test_image_processing_segformer.py index a104fc2f48..a05b3349e8 100644 --- a/tests/models/segformer/test_image_processing_segformer.py +++ b/tests/models/segformer/test_image_processing_segformer.py @@ -22,8 +22,7 @@ from datasets import load_dataset from transformers.testing_utils import require_torch, require_vision from transformers.utils import is_torch_available, is_vision_available -from ...test_feature_extraction_common import FeatureExtractionSavingTestMixin -from ...test_image_processing_common import prepare_image_inputs +from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs if is_torch_available(): @@ -32,10 +31,10 @@ if is_torch_available(): if is_vision_available(): from PIL import Image - from transformers import SegformerFeatureExtractor + from transformers import SegformerImageProcessor -class SegformerFeatureExtractionTester(unittest.TestCase): +class SegformerImageProcessingTester(unittest.TestCase): def __init__( self, parent, @@ -63,7 +62,7 @@ class SegformerFeatureExtractionTester(unittest.TestCase): self.image_std = image_std self.do_reduce_labels = do_reduce_labels - def prepare_feat_extract_dict(self): + def prepare_image_processor_dict(self): return { "do_resize": self.do_resize, "size": self.size, @@ -96,163 +95,161 @@ def prepare_semantic_batch_inputs(): @require_torch @require_vision -class SegformerFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestCase): +class SegformerImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase): - feature_extraction_class = SegformerFeatureExtractor if is_vision_available() else None + image_processing_class = SegformerImageProcessor if is_vision_available() else None def setUp(self): - self.feature_extract_tester = SegformerFeatureExtractionTester(self) + self.image_processor_tester = SegformerImageProcessingTester(self) @property - def feat_extract_dict(self): - return self.feature_extract_tester.prepare_feat_extract_dict() + def image_processor_dict(self): + return self.image_processor_tester.prepare_image_processor_dict() - def test_feat_extract_properties(self): - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) - self.assertTrue(hasattr(feature_extractor, "do_resize")) - self.assertTrue(hasattr(feature_extractor, "size")) - self.assertTrue(hasattr(feature_extractor, "do_normalize")) - self.assertTrue(hasattr(feature_extractor, "image_mean")) - self.assertTrue(hasattr(feature_extractor, "image_std")) - self.assertTrue(hasattr(feature_extractor, "do_reduce_labels")) + 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")) + self.assertTrue(hasattr(image_processing, "do_reduce_labels")) - def test_feat_extract_from_dict_with_kwargs(self): - feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict) - self.assertEqual(feature_extractor.size, {"height": 30, "width": 30}) - self.assertEqual(feature_extractor.do_reduce_labels, False) + 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": 30, "width": 30}) + self.assertEqual(image_processor.do_reduce_labels, False) - feature_extractor = self.feature_extraction_class.from_dict( - self.feat_extract_dict, size=42, reduce_labels=True - ) - self.assertEqual(feature_extractor.size, {"height": 42, "width": 42}) - self.assertEqual(feature_extractor.do_reduce_labels, True) + image_processor = self.image_processing_class.from_dict(self.image_processor_dict, size=42, reduce_labels=True) + self.assertEqual(image_processor.size, {"height": 42, "width": 42}) + self.assertEqual(image_processor.do_reduce_labels, True) def test_batch_feature(self): pass def test_call_pil(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PIL images - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False) for image in image_inputs: self.assertIsInstance(image, Image.Image) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.size["height"], + self.image_processor_tester.size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.size["height"], + self.image_processor_tester.size["width"], ), ) def test_call_numpy(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random numpy tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, numpify=True) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, numpify=True) for image in image_inputs: self.assertIsInstance(image, np.ndarray) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.size["height"], + self.image_processor_tester.size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.size["height"], + self.image_processor_tester.size["width"], ), ) def test_call_pytorch(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PyTorch tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, torchify=True) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, torchify=True) for image in image_inputs: self.assertIsInstance(image, torch.Tensor) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.size["height"], + self.image_processor_tester.size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.size["height"], + self.image_processor_tester.size["width"], ), ) def test_call_segmentation_maps(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PyTorch tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, torchify=True) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, torchify=True) maps = [] for image in image_inputs: self.assertIsInstance(image, torch.Tensor) maps.append(torch.zeros(image.shape[-2:]).long()) # Test not batched input - encoding = feature_extractor(image_inputs[0], maps[0], return_tensors="pt") + encoding = image_processing(image_inputs[0], maps[0], return_tensors="pt") self.assertEqual( encoding["pixel_values"].shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.size["height"], + self.image_processor_tester.size["width"], ), ) self.assertEqual( encoding["labels"].shape, ( 1, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_processor_tester.size["height"], + self.image_processor_tester.size["width"], ), ) self.assertEqual(encoding["labels"].dtype, torch.long) @@ -260,22 +257,22 @@ class SegformerFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest. self.assertTrue(encoding["labels"].max().item() <= 255) # Test batched - encoding = feature_extractor(image_inputs, maps, return_tensors="pt") + encoding = image_processing(image_inputs, maps, return_tensors="pt") self.assertEqual( encoding["pixel_values"].shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.size["height"], + self.image_processor_tester.size["width"], ), ) self.assertEqual( encoding["labels"].shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.size["height"], + self.image_processor_tester.size["width"], ), ) self.assertEqual(encoding["labels"].dtype, torch.long) @@ -285,22 +282,22 @@ class SegformerFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest. # Test not batched input (PIL images) image, segmentation_map = prepare_semantic_single_inputs() - encoding = feature_extractor(image, segmentation_map, return_tensors="pt") + encoding = image_processing(image, segmentation_map, return_tensors="pt") self.assertEqual( encoding["pixel_values"].shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.size["height"], + self.image_processor_tester.size["width"], ), ) self.assertEqual( encoding["labels"].shape, ( 1, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_processor_tester.size["height"], + self.image_processor_tester.size["width"], ), ) self.assertEqual(encoding["labels"].dtype, torch.long) @@ -310,22 +307,22 @@ class SegformerFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest. # Test batched input (PIL images) images, segmentation_maps = prepare_semantic_batch_inputs() - encoding = feature_extractor(images, segmentation_maps, return_tensors="pt") + encoding = image_processing(images, segmentation_maps, return_tensors="pt") self.assertEqual( encoding["pixel_values"].shape, ( 2, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.size["height"], + self.image_processor_tester.size["width"], ), ) self.assertEqual( encoding["labels"].shape, ( 2, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_processor_tester.size["height"], + self.image_processor_tester.size["width"], ), ) self.assertEqual(encoding["labels"].dtype, torch.long) @@ -333,16 +330,16 @@ class SegformerFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest. self.assertTrue(encoding["labels"].max().item() <= 255) def test_reduce_labels(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # ADE20k has 150 classes, and the background is included, so labels should be between 0 and 150 image, map = prepare_semantic_single_inputs() - encoding = feature_extractor(image, map, return_tensors="pt") + encoding = image_processing(image, map, return_tensors="pt") self.assertTrue(encoding["labels"].min().item() >= 0) self.assertTrue(encoding["labels"].max().item() <= 150) - feature_extractor.reduce_labels = True - encoding = feature_extractor(image, map, return_tensors="pt") + image_processing.reduce_labels = True + encoding = image_processing(image, map, return_tensors="pt") self.assertTrue(encoding["labels"].min().item() >= 0) self.assertTrue(encoding["labels"].max().item() <= 255) diff --git a/tests/models/swin2sr/test_image_processing_swin2sr.py b/tests/models/swin2sr/test_image_processing_swin2sr.py index 393a44ecfa..06e9539693 100644 --- a/tests/models/swin2sr/test_image_processing_swin2sr.py +++ b/tests/models/swin2sr/test_image_processing_swin2sr.py @@ -21,7 +21,7 @@ import numpy as np from transformers.testing_utils import require_torch, require_vision from transformers.utils import is_torch_available, is_vision_available -from ...test_feature_extraction_common import FeatureExtractionSavingTestMixin +from ...test_image_processing_common import ImageProcessingSavingTestMixin if is_torch_available(): @@ -59,7 +59,7 @@ class Swin2SRImageProcessingTester(unittest.TestCase): self.do_pad = do_pad self.pad_size = pad_size - def prepare_feat_extract_dict(self): + def prepare_image_processor_dict(self): return { "do_rescale": self.do_rescale, "rescale_factor": self.rescale_factor, @@ -100,93 +100,93 @@ class Swin2SRImageProcessingTester(unittest.TestCase): @require_torch @require_vision -class Swin2SRImageProcessingTest(FeatureExtractionSavingTestMixin, unittest.TestCase): +class Swin2SRImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase): - feature_extraction_class = Swin2SRImageProcessor if is_vision_available() else None + image_processing_class = Swin2SRImageProcessor if is_vision_available() else None def setUp(self): - self.feature_extract_tester = Swin2SRImageProcessingTester(self) + self.image_processor_tester = Swin2SRImageProcessingTester(self) @property - def feat_extract_dict(self): - return self.feature_extract_tester.prepare_feat_extract_dict() + def image_processor_dict(self): + return self.image_processor_tester.prepare_image_processor_dict() - def test_feat_extract_properties(self): - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) - self.assertTrue(hasattr(feature_extractor, "do_rescale")) - self.assertTrue(hasattr(feature_extractor, "rescale_factor")) - self.assertTrue(hasattr(feature_extractor, "do_pad")) - self.assertTrue(hasattr(feature_extractor, "pad_size")) + def test_image_processor_properties(self): + image_processor = self.image_processing_class(**self.image_processor_dict) + self.assertTrue(hasattr(image_processor, "do_rescale")) + self.assertTrue(hasattr(image_processor, "rescale_factor")) + self.assertTrue(hasattr(image_processor, "do_pad")) + self.assertTrue(hasattr(image_processor, "pad_size")) def test_batch_feature(self): pass def calculate_expected_size(self, image): old_height, old_width = get_image_size(image) - size = self.feature_extract_tester.pad_size + size = self.image_processor_tester.pad_size pad_height = (old_height // size + 1) * size - old_height pad_width = (old_width // size + 1) * size - old_width return old_height + pad_height, old_width + pad_width def test_call_pil(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processor + image_processor = self.image_processing_class(**self.image_processor_dict) # create random PIL images - image_inputs = self.feature_extract_tester.prepare_inputs(equal_resolution=False) + image_inputs = self.image_processor_tester.prepare_inputs(equal_resolution=False) for image in image_inputs: self.assertIsInstance(image, Image.Image) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processor(image_inputs[0], return_tensors="pt").pixel_values expected_height, expected_width = self.calculate_expected_size(np.array(image_inputs[0])) self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, + self.image_processor_tester.num_channels, expected_height, expected_width, ), ) def test_call_numpy(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processor + image_processor = self.image_processing_class(**self.image_processor_dict) # create random numpy tensors - image_inputs = self.feature_extract_tester.prepare_inputs(equal_resolution=False, numpify=True) + image_inputs = self.image_processor_tester.prepare_inputs(equal_resolution=False, numpify=True) for image in image_inputs: self.assertIsInstance(image, np.ndarray) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processor(image_inputs[0], return_tensors="pt").pixel_values expected_height, expected_width = self.calculate_expected_size(image_inputs[0]) self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, + self.image_processor_tester.num_channels, expected_height, expected_width, ), ) def test_call_pytorch(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processor + image_processor = self.image_processing_class(**self.image_processor_dict) # create random PyTorch tensors - image_inputs = self.feature_extract_tester.prepare_inputs(equal_resolution=False, torchify=True) + image_inputs = self.image_processor_tester.prepare_inputs(equal_resolution=False, torchify=True) for image in image_inputs: self.assertIsInstance(image, torch.Tensor) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processor(image_inputs[0], return_tensors="pt").pixel_values expected_height, expected_width = self.calculate_expected_size(image_inputs[0]) self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, + self.image_processor_tester.num_channels, expected_height, expected_width, ), diff --git a/tests/models/videomae/test_image_processing_videomae.py b/tests/models/videomae/test_image_processing_videomae.py index 025c39ef97..5367632845 100644 --- a/tests/models/videomae/test_image_processing_videomae.py +++ b/tests/models/videomae/test_image_processing_videomae.py @@ -21,8 +21,7 @@ import numpy as np from transformers.testing_utils import require_torch, require_vision from transformers.utils import is_torch_available, is_vision_available -from ...test_feature_extraction_common import FeatureExtractionSavingTestMixin -from ...test_image_processing_common import prepare_video_inputs +from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_video_inputs if is_torch_available(): @@ -31,10 +30,10 @@ if is_torch_available(): if is_vision_available(): from PIL import Image - from transformers import VideoMAEFeatureExtractor + from transformers import VideoMAEImageProcessor -class VideoMAEFeatureExtractionTester(unittest.TestCase): +class VideoMAEImageProcessingTester(unittest.TestCase): def __init__( self, parent, @@ -68,7 +67,7 @@ class VideoMAEFeatureExtractionTester(unittest.TestCase): self.image_std = image_std self.crop_size = crop_size - def prepare_feat_extract_dict(self): + def prepare_image_processor_dict(self): return { "image_mean": self.image_mean, "image_std": self.image_std, @@ -81,139 +80,139 @@ class VideoMAEFeatureExtractionTester(unittest.TestCase): @require_torch @require_vision -class VideoMAEFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestCase): +class VideoMAEImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase): - feature_extraction_class = VideoMAEFeatureExtractor if is_vision_available() else None + image_processing_class = VideoMAEImageProcessor if is_vision_available() else None def setUp(self): - self.feature_extract_tester = VideoMAEFeatureExtractionTester(self) + self.image_processor_tester = VideoMAEImageProcessingTester(self) @property - def feat_extract_dict(self): - return self.feature_extract_tester.prepare_feat_extract_dict() + def image_processor_dict(self): + return self.image_processor_tester.prepare_image_processor_dict() - def test_feat_extract_properties(self): - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) - self.assertTrue(hasattr(feature_extractor, "image_mean")) - self.assertTrue(hasattr(feature_extractor, "image_std")) - self.assertTrue(hasattr(feature_extractor, "do_normalize")) - self.assertTrue(hasattr(feature_extractor, "do_resize")) - self.assertTrue(hasattr(feature_extractor, "do_center_crop")) - self.assertTrue(hasattr(feature_extractor, "size")) + def test_image_processor_properties(self): + image_processing = self.image_processing_class(**self.image_processor_dict) + self.assertTrue(hasattr(image_processing, "image_mean")) + self.assertTrue(hasattr(image_processing, "image_std")) + self.assertTrue(hasattr(image_processing, "do_normalize")) + self.assertTrue(hasattr(image_processing, "do_resize")) + self.assertTrue(hasattr(image_processing, "do_center_crop")) + self.assertTrue(hasattr(image_processing, "size")) - def test_feat_extract_from_dict_with_kwargs(self): - feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict) - self.assertEqual(feature_extractor.size, {"shortest_edge": 18}) - self.assertEqual(feature_extractor.crop_size, {"height": 18, "width": 18}) + 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, {"shortest_edge": 18}) + self.assertEqual(image_processor.crop_size, {"height": 18, "width": 18}) - feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict, size=42, crop_size=84) - self.assertEqual(feature_extractor.size, {"shortest_edge": 42}) - self.assertEqual(feature_extractor.crop_size, {"height": 84, "width": 84}) + image_processor = self.image_processing_class.from_dict(self.image_processor_dict, size=42, crop_size=84) + self.assertEqual(image_processor.size, {"shortest_edge": 42}) + self.assertEqual(image_processor.crop_size, {"height": 84, "width": 84}) def test_batch_feature(self): pass def test_call_pil(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PIL videos - video_inputs = prepare_video_inputs(self.feature_extract_tester, equal_resolution=False) + video_inputs = prepare_video_inputs(self.image_processor_tester, equal_resolution=False) for video in video_inputs: self.assertIsInstance(video, list) self.assertIsInstance(video[0], Image.Image) # Test not batched input - encoded_videos = feature_extractor(video_inputs[0], return_tensors="pt").pixel_values + encoded_videos = image_processing(video_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_videos.shape, ( 1, - self.feature_extract_tester.num_frames, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.num_frames, + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) # Test batched - encoded_videos = feature_extractor(video_inputs, return_tensors="pt").pixel_values + encoded_videos = image_processing(video_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_videos.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_frames, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_frames, + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) def test_call_numpy(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random numpy tensors - video_inputs = prepare_video_inputs(self.feature_extract_tester, equal_resolution=False, numpify=True) + video_inputs = prepare_video_inputs(self.image_processor_tester, equal_resolution=False, numpify=True) for video in video_inputs: self.assertIsInstance(video, list) self.assertIsInstance(video[0], np.ndarray) # Test not batched input - encoded_videos = feature_extractor(video_inputs[0], return_tensors="pt").pixel_values + encoded_videos = image_processing(video_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_videos.shape, ( 1, - self.feature_extract_tester.num_frames, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.num_frames, + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) # Test batched - encoded_videos = feature_extractor(video_inputs, return_tensors="pt").pixel_values + encoded_videos = image_processing(video_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_videos.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_frames, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_frames, + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) def test_call_pytorch(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PyTorch tensors - video_inputs = prepare_video_inputs(self.feature_extract_tester, equal_resolution=False, torchify=True) + video_inputs = prepare_video_inputs(self.image_processor_tester, equal_resolution=False, torchify=True) for video in video_inputs: self.assertIsInstance(video, list) self.assertIsInstance(video[0], torch.Tensor) # Test not batched input - encoded_videos = feature_extractor(video_inputs[0], return_tensors="pt").pixel_values + encoded_videos = image_processing(video_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_videos.shape, ( 1, - self.feature_extract_tester.num_frames, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.num_frames, + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) # Test batched - encoded_videos = feature_extractor(video_inputs, return_tensors="pt").pixel_values + encoded_videos = image_processing(video_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_videos.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_frames, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.crop_size["height"], - self.feature_extract_tester.crop_size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_frames, + self.image_processor_tester.num_channels, + self.image_processor_tester.crop_size["height"], + self.image_processor_tester.crop_size["width"], ), ) diff --git a/tests/models/vilt/test_image_processing_vilt.py b/tests/models/vilt/test_image_processing_vilt.py index 5d7be90a74..a89fd9b854 100644 --- a/tests/models/vilt/test_image_processing_vilt.py +++ b/tests/models/vilt/test_image_processing_vilt.py @@ -21,8 +21,7 @@ import numpy as np from transformers.testing_utils import require_torch, require_vision from transformers.utils import is_torch_available, is_vision_available -from ...test_feature_extraction_common import FeatureExtractionSavingTestMixin -from ...test_image_processing_common import prepare_image_inputs +from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs if is_torch_available(): @@ -31,10 +30,10 @@ if is_torch_available(): if is_vision_available(): from PIL import Image - from transformers import ViltFeatureExtractor + from transformers import ViltImageProcessor -class ViltFeatureExtractionTester(unittest.TestCase): +class ViltImageProcessingTester(unittest.TestCase): def __init__( self, parent, @@ -64,7 +63,7 @@ class ViltFeatureExtractionTester(unittest.TestCase): self.image_mean = image_mean self.image_std = image_std - def prepare_feat_extract_dict(self): + def prepare_image_processor_dict(self): return { "image_mean": self.image_mean, "image_std": self.image_std, @@ -76,7 +75,7 @@ class ViltFeatureExtractionTester(unittest.TestCase): def get_expected_values(self, image_inputs, batched=False): """ - This function computes the expected height and width when providing images to ViltFeatureExtractor, + This function computes the expected height and width when providing images to ViltImageProcessor, assuming do_resize is set to True with a scalar size and size_divisor. """ if not batched: @@ -117,141 +116,141 @@ class ViltFeatureExtractionTester(unittest.TestCase): @require_torch @require_vision -class ViltFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestCase): +class ViltImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase): - feature_extraction_class = ViltFeatureExtractor if is_vision_available() else None + image_processing_class = ViltImageProcessor if is_vision_available() else None def setUp(self): - self.feature_extract_tester = ViltFeatureExtractionTester(self) + self.image_processor_tester = ViltImageProcessingTester(self) @property - def feat_extract_dict(self): - return self.feature_extract_tester.prepare_feat_extract_dict() + def image_processor_dict(self): + return self.image_processor_tester.prepare_image_processor_dict() - def test_feat_extract_properties(self): - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) - self.assertTrue(hasattr(feature_extractor, "image_mean")) - self.assertTrue(hasattr(feature_extractor, "image_std")) - self.assertTrue(hasattr(feature_extractor, "do_normalize")) - self.assertTrue(hasattr(feature_extractor, "do_resize")) - self.assertTrue(hasattr(feature_extractor, "size")) - self.assertTrue(hasattr(feature_extractor, "size_divisor")) + def test_image_processor_properties(self): + image_processing = self.image_processing_class(**self.image_processor_dict) + self.assertTrue(hasattr(image_processing, "image_mean")) + self.assertTrue(hasattr(image_processing, "image_std")) + self.assertTrue(hasattr(image_processing, "do_normalize")) + self.assertTrue(hasattr(image_processing, "do_resize")) + self.assertTrue(hasattr(image_processing, "size")) + self.assertTrue(hasattr(image_processing, "size_divisor")) - def test_feat_extract_from_dict_with_kwargs(self): - feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict) - self.assertEqual(feature_extractor.size, {"shortest_edge": 30}) + 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, {"shortest_edge": 30}) - feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict, size=42) - self.assertEqual(feature_extractor.size, {"shortest_edge": 42}) + image_processor = self.image_processing_class.from_dict(self.image_processor_dict, size=42) + self.assertEqual(image_processor.size, {"shortest_edge": 42}) def test_batch_feature(self): pass def test_call_pil(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PIL images - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False) for image in image_inputs: self.assertIsInstance(image, Image.Image) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values - expected_height, expected_width = self.feature_extract_tester.get_expected_values(image_inputs) + expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs) self.assertEqual( encoded_images.shape, - (1, self.feature_extract_tester.num_channels, expected_height, expected_width), + (1, self.image_processor_tester.num_channels, expected_height, expected_width), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values - expected_height, expected_width = self.feature_extract_tester.get_expected_values(image_inputs, batched=True) + expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs, batched=True) self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, expected_height, expected_width, ), ) def test_call_numpy(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random numpy tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, numpify=True) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, numpify=True) for image in image_inputs: self.assertIsInstance(image, np.ndarray) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values - expected_height, expected_width = self.feature_extract_tester.get_expected_values(image_inputs) + expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs) self.assertEqual( encoded_images.shape, - (1, self.feature_extract_tester.num_channels, expected_height, expected_width), + (1, self.image_processor_tester.num_channels, expected_height, expected_width), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values - expected_height, expected_width = self.feature_extract_tester.get_expected_values(image_inputs, batched=True) + expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs, batched=True) self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, expected_height, expected_width, ), ) def test_call_pytorch(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PyTorch tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, torchify=True) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, torchify=True) for image in image_inputs: self.assertIsInstance(image, torch.Tensor) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values - expected_height, expected_width = self.feature_extract_tester.get_expected_values(image_inputs) + expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs) self.assertEqual( encoded_images.shape, - (1, self.feature_extract_tester.num_channels, expected_height, expected_width), + (1, self.image_processor_tester.num_channels, expected_height, expected_width), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values - expected_height, expected_width = self.feature_extract_tester.get_expected_values(image_inputs, batched=True) + expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs, batched=True) self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, expected_height, expected_width, ), ) def test_equivalence_pad_and_create_pixel_mask(self): - # Initialize feature_extractors - feature_extractor_1 = self.feature_extraction_class(**self.feat_extract_dict) - feature_extractor_2 = self.feature_extraction_class(do_resize=False, do_normalize=False, do_rescale=False) + # Initialize image_processings + image_processing_1 = self.image_processing_class(**self.image_processor_dict) + image_processing_2 = self.image_processing_class(do_resize=False, do_normalize=False, do_rescale=False) # create random PyTorch tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, torchify=True) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, torchify=True) for image in image_inputs: self.assertIsInstance(image, torch.Tensor) - # Test whether the method "pad_and_return_pixel_mask" and calling the feature extractor return the same tensors - encoded_images_with_method = feature_extractor_1.pad_and_create_pixel_mask(image_inputs, return_tensors="pt") - encoded_images = feature_extractor_2(image_inputs, return_tensors="pt") + # Test whether the method "pad_and_return_pixel_mask" and calling the image processor return the same tensors + encoded_images_with_method = image_processing_1.pad_and_create_pixel_mask(image_inputs, return_tensors="pt") + encoded_images = image_processing_2(image_inputs, return_tensors="pt") self.assertTrue( torch.allclose(encoded_images_with_method["pixel_values"], encoded_images["pixel_values"], atol=1e-4) diff --git a/tests/models/vit/test_image_processing_vit.py b/tests/models/vit/test_image_processing_vit.py index a0db60887e..ce0cc5610a 100644 --- a/tests/models/vit/test_image_processing_vit.py +++ b/tests/models/vit/test_image_processing_vit.py @@ -21,8 +21,7 @@ import numpy as np from transformers.testing_utils import require_torch, require_vision from transformers.utils import is_torch_available, is_vision_available -from ...test_feature_extraction_common import FeatureExtractionSavingTestMixin -from ...test_image_processing_common import prepare_image_inputs +from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs if is_torch_available(): @@ -31,10 +30,10 @@ if is_torch_available(): if is_vision_available(): from PIL import Image - from transformers import ViTFeatureExtractor + from transformers import ViTImageProcessor -class ViTFeatureExtractionTester(unittest.TestCase): +class ViTImageProcessingTester(unittest.TestCase): def __init__( self, parent, @@ -62,7 +61,7 @@ class ViTFeatureExtractionTester(unittest.TestCase): self.image_mean = image_mean self.image_std = image_std - def prepare_feat_extract_dict(self): + def prepare_image_processor_dict(self): return { "image_mean": self.image_mean, "image_std": self.image_std, @@ -74,127 +73,127 @@ class ViTFeatureExtractionTester(unittest.TestCase): @require_torch @require_vision -class ViTFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestCase): +class ViTImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase): - feature_extraction_class = ViTFeatureExtractor if is_vision_available() else None + image_processing_class = ViTImageProcessor if is_vision_available() else None def setUp(self): - self.feature_extract_tester = ViTFeatureExtractionTester(self) + self.image_processor_tester = ViTImageProcessingTester(self) @property - def feat_extract_dict(self): - return self.feature_extract_tester.prepare_feat_extract_dict() + def image_processor_dict(self): + return self.image_processor_tester.prepare_image_processor_dict() - def test_feat_extract_properties(self): - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) - self.assertTrue(hasattr(feature_extractor, "image_mean")) - self.assertTrue(hasattr(feature_extractor, "image_std")) - self.assertTrue(hasattr(feature_extractor, "do_normalize")) - self.assertTrue(hasattr(feature_extractor, "do_resize")) - self.assertTrue(hasattr(feature_extractor, "size")) + def test_image_processor_properties(self): + image_processing = self.image_processing_class(**self.image_processor_dict) + self.assertTrue(hasattr(image_processing, "image_mean")) + self.assertTrue(hasattr(image_processing, "image_std")) + self.assertTrue(hasattr(image_processing, "do_normalize")) + self.assertTrue(hasattr(image_processing, "do_resize")) + self.assertTrue(hasattr(image_processing, "size")) - def test_feat_extract_from_dict_with_kwargs(self): - feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict) - self.assertEqual(feature_extractor.size, {"height": 18, "width": 18}) + 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}) - feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict, size=42) - self.assertEqual(feature_extractor.size, {"height": 42, "width": 42}) + image_processor = self.image_processing_class.from_dict(self.image_processor_dict, size=42) + self.assertEqual(image_processor.size, {"height": 42, "width": 42}) def test_batch_feature(self): pass def test_call_pil(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PIL images - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False) for image in image_inputs: self.assertIsInstance(image, Image.Image) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.size["height"], + self.image_processor_tester.size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.size["height"], + self.image_processor_tester.size["width"], ), ) def test_call_numpy(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random numpy tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, numpify=True) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, numpify=True) for image in image_inputs: self.assertIsInstance(image, np.ndarray) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.size["height"], + self.image_processor_tester.size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.size["height"], + self.image_processor_tester.size["width"], ), ) def test_call_pytorch(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PyTorch tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, torchify=True) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, torchify=True) for image in image_inputs: self.assertIsInstance(image, torch.Tensor) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( 1, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_processor_tester.num_channels, + self.image_processor_tester.size["height"], + self.image_processor_tester.size["width"], ), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, - self.feature_extract_tester.size["height"], - self.feature_extract_tester.size["width"], + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, + self.image_processor_tester.size["height"], + self.image_processor_tester.size["width"], ), ) diff --git a/tests/models/yolos/test_image_processing_yolos.py b/tests/models/yolos/test_image_processing_yolos.py index 4e22baa4d6..b262a654a5 100644 --- a/tests/models/yolos/test_image_processing_yolos.py +++ b/tests/models/yolos/test_image_processing_yolos.py @@ -23,8 +23,7 @@ import numpy as np from transformers.testing_utils import require_torch, require_vision, slow from transformers.utils import is_torch_available, is_vision_available -from ...test_feature_extraction_common import FeatureExtractionSavingTestMixin -from ...test_image_processing_common import prepare_image_inputs +from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs if is_torch_available(): @@ -33,10 +32,10 @@ if is_torch_available(): if is_vision_available(): from PIL import Image - from transformers import YolosFeatureExtractor + from transformers import YolosImageProcessor -class YolosFeatureExtractionTester(unittest.TestCase): +class YolosImageProcessingTester(unittest.TestCase): def __init__( self, parent, @@ -69,7 +68,7 @@ class YolosFeatureExtractionTester(unittest.TestCase): self.rescale_factor = rescale_factor self.do_pad = do_pad - def prepare_feat_extract_dict(self): + def prepare_image_processor_dict(self): return { "do_resize": self.do_resize, "size": self.size, @@ -83,7 +82,7 @@ class YolosFeatureExtractionTester(unittest.TestCase): def get_expected_values(self, image_inputs, batched=False): """ - This function computes the expected height and width when providing images to YolosFeatureExtractor, + This function computes the expected height and width when providing images to YolosImageProcessor, assuming do_resize is set to True with a scalar size. """ if not batched: @@ -115,149 +114,149 @@ class YolosFeatureExtractionTester(unittest.TestCase): @require_torch @require_vision -class YolosFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestCase): +class YolosImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase): - feature_extraction_class = YolosFeatureExtractor if is_vision_available() else None + image_processing_class = YolosImageProcessor if is_vision_available() else None def setUp(self): - self.feature_extract_tester = YolosFeatureExtractionTester(self) + self.image_processor_tester = YolosImageProcessingTester(self) @property - def feat_extract_dict(self): - return self.feature_extract_tester.prepare_feat_extract_dict() + def image_processor_dict(self): + return self.image_processor_tester.prepare_image_processor_dict() - def test_feat_extract_properties(self): - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) - self.assertTrue(hasattr(feature_extractor, "image_mean")) - self.assertTrue(hasattr(feature_extractor, "image_std")) - self.assertTrue(hasattr(feature_extractor, "do_normalize")) - self.assertTrue(hasattr(feature_extractor, "do_resize")) - self.assertTrue(hasattr(feature_extractor, "size")) + def test_image_processor_properties(self): + image_processing = self.image_processing_class(**self.image_processor_dict) + self.assertTrue(hasattr(image_processing, "image_mean")) + self.assertTrue(hasattr(image_processing, "image_std")) + self.assertTrue(hasattr(image_processing, "do_normalize")) + self.assertTrue(hasattr(image_processing, "do_resize")) + self.assertTrue(hasattr(image_processing, "size")) - def test_feat_extract_from_dict_with_kwargs(self): - feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict) - self.assertEqual(feature_extractor.size, {"shortest_edge": 18, "longest_edge": 1333}) - self.assertEqual(feature_extractor.do_pad, True) + 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, {"shortest_edge": 18, "longest_edge": 1333}) + self.assertEqual(image_processor.do_pad, True) - feature_extractor = self.feature_extraction_class.from_dict( - self.feat_extract_dict, size=42, max_size=84, pad_and_return_pixel_mask=False + image_processor = self.image_processing_class.from_dict( + self.image_processor_dict, size=42, max_size=84, pad_and_return_pixel_mask=False ) - self.assertEqual(feature_extractor.size, {"shortest_edge": 42, "longest_edge": 84}) - self.assertEqual(feature_extractor.do_pad, False) + self.assertEqual(image_processor.size, {"shortest_edge": 42, "longest_edge": 84}) + self.assertEqual(image_processor.do_pad, False) def test_batch_feature(self): pass def test_call_pil(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PIL images - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False) for image in image_inputs: self.assertIsInstance(image, Image.Image) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values - expected_height, expected_width = self.feature_extract_tester.get_expected_values(image_inputs) + expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs) self.assertEqual( encoded_images.shape, - (1, self.feature_extract_tester.num_channels, expected_height, expected_width), + (1, self.image_processor_tester.num_channels, expected_height, expected_width), ) # Test batched - expected_height, expected_width = self.feature_extract_tester.get_expected_values(image_inputs, batched=True) + expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs, batched=True) - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, expected_height, expected_width, ), ) def test_call_numpy(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random numpy tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, numpify=True) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, numpify=True) for image in image_inputs: self.assertIsInstance(image, np.ndarray) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values - expected_height, expected_width = self.feature_extract_tester.get_expected_values(image_inputs) + expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs) self.assertEqual( encoded_images.shape, - (1, self.feature_extract_tester.num_channels, expected_height, expected_width), + (1, self.image_processor_tester.num_channels, expected_height, expected_width), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values - expected_height, expected_width = self.feature_extract_tester.get_expected_values(image_inputs, batched=True) + expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs, batched=True) self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, expected_height, expected_width, ), ) def test_call_pytorch(self): - # Initialize feature_extractor - feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) + # Initialize image_processing + image_processing = self.image_processing_class(**self.image_processor_dict) # create random PyTorch tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, torchify=True) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, torchify=True) for image in image_inputs: self.assertIsInstance(image, torch.Tensor) # Test not batched input - encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values - expected_height, expected_width = self.feature_extract_tester.get_expected_values(image_inputs) + expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs) self.assertEqual( encoded_images.shape, - (1, self.feature_extract_tester.num_channels, expected_height, expected_width), + (1, self.image_processor_tester.num_channels, expected_height, expected_width), ) # Test batched - encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values + encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values - expected_height, expected_width = self.feature_extract_tester.get_expected_values(image_inputs, batched=True) + expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs, batched=True) self.assertEqual( encoded_images.shape, ( - self.feature_extract_tester.batch_size, - self.feature_extract_tester.num_channels, + self.image_processor_tester.batch_size, + self.image_processor_tester.num_channels, expected_height, expected_width, ), ) def test_equivalence_padding(self): - # Initialize feature_extractors - feature_extractor_1 = self.feature_extraction_class(**self.feat_extract_dict) - feature_extractor_2 = self.feature_extraction_class(do_resize=False, do_normalize=False, do_rescale=False) + # Initialize image_processings + image_processing_1 = self.image_processing_class(**self.image_processor_dict) + image_processing_2 = self.image_processing_class(do_resize=False, do_normalize=False, do_rescale=False) # create random PyTorch tensors - image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, torchify=True) + image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, torchify=True) for image in image_inputs: self.assertIsInstance(image, torch.Tensor) - # Test whether the method "pad" and calling the feature extractor return the same tensors - encoded_images_with_method = feature_extractor_1.pad(image_inputs, return_tensors="pt") - encoded_images = feature_extractor_2(image_inputs, return_tensors="pt") + # Test whether the method "pad" and calling the image processor return the same tensors + encoded_images_with_method = image_processing_1.pad(image_inputs, return_tensors="pt") + encoded_images = image_processing_2(image_inputs, return_tensors="pt") self.assertTrue( torch.allclose(encoded_images_with_method["pixel_values"], encoded_images["pixel_values"], atol=1e-4) @@ -273,8 +272,8 @@ class YolosFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.Test target = {"image_id": 39769, "annotations": target} # encode them - feature_extractor = YolosFeatureExtractor.from_pretrained("hustvl/yolos-small") - encoding = feature_extractor(images=image, annotations=target, return_tensors="pt") + image_processing = YolosImageProcessor.from_pretrained("hustvl/yolos-small") + encoding = image_processing(images=image, annotations=target, return_tensors="pt") # verify pixel values expected_shape = torch.Size([1, 3, 800, 1066]) @@ -319,8 +318,8 @@ class YolosFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.Test masks_path = pathlib.Path("./tests/fixtures/tests_samples/COCO/coco_panoptic") # encode them - feature_extractor = YolosFeatureExtractor(format="coco_panoptic") - encoding = feature_extractor(images=image, annotations=target, masks_path=masks_path, return_tensors="pt") + image_processing = YolosImageProcessor(format="coco_panoptic") + encoding = image_processing(images=image, annotations=target, masks_path=masks_path, return_tensors="pt") # verify pixel values expected_shape = torch.Size([1, 3, 800, 1066])