Skip to content

GitLab

"tests/models/bit/test_modeling_bit.py" did not exist on "0bae286de94f7131b4a2db3f85754b0961c4aaf5"
Unverified Commit e2bd7f80 authored by amyeroberts's avatar amyeroberts Committed by GitHub
Browse files

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: default avatarbofeng huang <bofenghuang7@gmail.com>
parent 354ea443
Hide whitespace changes
Inline Side-by-side
Showing with 643 additions and 655 deletions
tests/models/mobilenet_v2/test_image_processing_mobilenet_v2.py
View file @ e2bd7f80
...@@ -21,8 +21,7 @@ import numpy as np ...@@ -21,8 +21,7 @@ import numpy as np
from transformers.testing_utils import require_torch, require_vision from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available from transformers.utils import is_torch_available, is_vision_available
from ...test_feature_extraction_common import FeatureExtractionSavingTestMixin from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs
from ...test_image_processing_common import prepare_image_inputs
if is_torch_available(): if is_torch_available():
...@@ -31,10 +30,10 @@ if is_torch_available(): ...@@ -31,10 +30,10 @@ if is_torch_available():
if is_vision_available(): if is_vision_available():
from PIL import Image from PIL import Image
from transformers import MobileNetV2FeatureExtractor from transformers import MobileNetV2ImageProcessor
class MobileNetV2FeatureExtractionTester(unittest.TestCase): class MobileNetV2ImageProcessingTester(unittest.TestCase):
def __init__( def __init__(
self, self,
parent, parent,
...@@ -61,7 +60,7 @@ class MobileNetV2FeatureExtractionTester(unittest.TestCase): ...@@ -61,7 +60,7 @@ class MobileNetV2FeatureExtractionTester(unittest.TestCase):
self.do_center_crop = do_center_crop self.do_center_crop = do_center_crop
self.crop_size = crop_size self.crop_size = crop_size
def prepare_feat_extract_dict(self): def prepare_image_processor_dict(self):
return { return {
"do_resize": self.do_resize, "do_resize": self.do_resize,
"size": self.size, "size": self.size,
...@@ -72,128 +71,128 @@ class MobileNetV2FeatureExtractionTester(unittest.TestCase): ...@@ -72,128 +71,128 @@ class MobileNetV2FeatureExtractionTester(unittest.TestCase):
@require_torch @require_torch
@require_vision @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): def setUp(self):
self.feature_extract_tester = MobileNetV2FeatureExtractionTester(self) self.image_processor_tester = MobileNetV2ImageProcessingTester(self)
@property @property
def feat_extract_dict(self): def image_processor_dict(self):
return self.feature_extract_tester.prepare_feat_extract_dict() return self.image_processor_tester.prepare_image_processor_dict()
def test_feat_extract_properties(self): def test_image_processor_properties(self):
feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) image_processor = self.image_processing_class(**self.image_processor_dict)
self.assertTrue(hasattr(feature_extractor, "do_resize")) self.assertTrue(hasattr(image_processor, "do_resize"))
self.assertTrue(hasattr(feature_extractor, "size")) self.assertTrue(hasattr(image_processor, "size"))
self.assertTrue(hasattr(feature_extractor, "do_center_crop")) self.assertTrue(hasattr(image_processor, "do_center_crop"))
self.assertTrue(hasattr(feature_extractor, "crop_size")) self.assertTrue(hasattr(image_processor, "crop_size"))
def test_feat_extract_from_dict_with_kwargs(self): def test_image_processor_from_dict_with_kwargs(self):
feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict) image_processor = self.image_processing_class.from_dict(self.image_processor_dict)
self.assertEqual(feature_extractor.size, {"shortest_edge": 20}) self.assertEqual(image_processor.size, {"shortest_edge": 20})
self.assertEqual(feature_extractor.crop_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) image_processor = self.image_processing_class.from_dict(self.image_processor_dict, size=42, crop_size=84)
self.assertEqual(feature_extractor.size, {"shortest_edge": 42}) self.assertEqual(image_processor.size, {"shortest_edge": 42})
self.assertEqual(feature_extractor.crop_size, {"height": 84, "width": 84}) self.assertEqual(image_processor.crop_size, {"height": 84, "width": 84})
def test_batch_feature(self): def test_batch_feature(self):
pass pass
def test_call_pil(self): def test_call_pil(self):
# Initialize feature_extractor # Initialize image_processing
feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) image_processing = self.image_processing_class(**self.image_processor_dict)
# create random PIL images # 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: for image in image_inputs:
self.assertIsInstance(image, Image.Image) self.assertIsInstance(image, Image.Image)
# Test not batched input # 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( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
1, 1,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
self.feature_extract_tester.crop_size["height"], self.image_processor_tester.crop_size["height"],
self.feature_extract_tester.crop_size["width"], self.image_processor_tester.crop_size["width"],
), ),
) )
# Test batched # 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( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
self.feature_extract_tester.batch_size, self.image_processor_tester.batch_size,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
self.feature_extract_tester.crop_size["height"], self.image_processor_tester.crop_size["height"],
self.feature_extract_tester.crop_size["width"], self.image_processor_tester.crop_size["width"],
), ),
) )
def test_call_numpy(self): def test_call_numpy(self):
# Initialize feature_extractor # Initialize image_processing
feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) image_processing = self.image_processing_class(**self.image_processor_dict)
# create random numpy tensors # 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: for image in image_inputs:
self.assertIsInstance(image, np.ndarray) self.assertIsInstance(image, np.ndarray)
# Test not batched input # 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( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
1, 1,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
self.feature_extract_tester.crop_size["height"], self.image_processor_tester.crop_size["height"],
self.feature_extract_tester.crop_size["width"], self.image_processor_tester.crop_size["width"],
), ),
) )
# Test batched # 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( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
self.feature_extract_tester.batch_size, self.image_processor_tester.batch_size,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
self.feature_extract_tester.crop_size["height"], self.image_processor_tester.crop_size["height"],
self.feature_extract_tester.crop_size["width"], self.image_processor_tester.crop_size["width"],
), ),
) )
def test_call_pytorch(self): def test_call_pytorch(self):
# Initialize feature_extractor # Initialize image_processing
feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) image_processing = self.image_processing_class(**self.image_processor_dict)
# create random PyTorch tensors # 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: for image in image_inputs:
self.assertIsInstance(image, torch.Tensor) self.assertIsInstance(image, torch.Tensor)
# Test not batched input # 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( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
1, 1,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
self.feature_extract_tester.crop_size["height"], self.image_processor_tester.crop_size["height"],
self.feature_extract_tester.crop_size["width"], self.image_processor_tester.crop_size["width"],
), ),
) )
# Test batched # 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( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
self.feature_extract_tester.batch_size, self.image_processor_tester.batch_size,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
self.feature_extract_tester.crop_size["height"], self.image_processor_tester.crop_size["height"],
self.feature_extract_tester.crop_size["width"], self.image_processor_tester.crop_size["width"],
), ),
) )
tests/models/mobilevit/test_image_processing_mobilevit.py
View file @ e2bd7f80
...@@ -21,8 +21,7 @@ import numpy as np ...@@ -21,8 +21,7 @@ import numpy as np
from transformers.testing_utils import require_torch, require_vision from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available from transformers.utils import is_torch_available, is_vision_available
from ...test_feature_extraction_common import FeatureExtractionSavingTestMixin from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs
from ...test_image_processing_common import prepare_image_inputs
if is_torch_available(): if is_torch_available():
...@@ -31,10 +30,10 @@ if is_torch_available(): ...@@ -31,10 +30,10 @@ if is_torch_available():
if is_vision_available(): if is_vision_available():
from PIL import Image from PIL import Image
from transformers import MobileViTFeatureExtractor from transformers import MobileViTImageProcessor
class MobileViTFeatureExtractionTester(unittest.TestCase): class MobileViTImageProcessingTester(unittest.TestCase):
def __init__( def __init__(
self, self,
parent, parent,
...@@ -63,7 +62,7 @@ class MobileViTFeatureExtractionTester(unittest.TestCase): ...@@ -63,7 +62,7 @@ class MobileViTFeatureExtractionTester(unittest.TestCase):
self.crop_size = crop_size self.crop_size = crop_size
self.do_flip_channel_order = do_flip_channel_order self.do_flip_channel_order = do_flip_channel_order
def prepare_feat_extract_dict(self): def prepare_image_processor_dict(self):
return { return {
"do_resize": self.do_resize, "do_resize": self.do_resize,
"size": self.size, "size": self.size,
...@@ -75,129 +74,129 @@ class MobileViTFeatureExtractionTester(unittest.TestCase): ...@@ -75,129 +74,129 @@ class MobileViTFeatureExtractionTester(unittest.TestCase):
@require_torch @require_torch
@require_vision @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): def setUp(self):
self.feature_extract_tester = MobileViTFeatureExtractionTester(self) self.image_processor_tester = MobileViTImageProcessingTester(self)
@property @property
def feat_extract_dict(self): def image_processor_dict(self):
return self.feature_extract_tester.prepare_feat_extract_dict() return self.image_processor_tester.prepare_image_processor_dict()
def test_feat_extract_properties(self): def test_image_processor_properties(self):
feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) image_processing = self.image_processing_class(**self.image_processor_dict)
self.assertTrue(hasattr(feature_extractor, "do_resize")) self.assertTrue(hasattr(image_processing, "do_resize"))
self.assertTrue(hasattr(feature_extractor, "size")) self.assertTrue(hasattr(image_processing, "size"))
self.assertTrue(hasattr(feature_extractor, "do_center_crop")) self.assertTrue(hasattr(image_processing, "do_center_crop"))
self.assertTrue(hasattr(feature_extractor, "center_crop")) self.assertTrue(hasattr(image_processing, "center_crop"))
self.assertTrue(hasattr(feature_extractor, "do_flip_channel_order")) self.assertTrue(hasattr(image_processing, "do_flip_channel_order"))
def test_feat_extract_from_dict_with_kwargs(self): def test_image_processor_from_dict_with_kwargs(self):
feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict) image_processor = self.image_processing_class.from_dict(self.image_processor_dict)
self.assertEqual(feature_extractor.size, {"shortest_edge": 20}) self.assertEqual(image_processor.size, {"shortest_edge": 20})
self.assertEqual(feature_extractor.crop_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) image_processor = self.image_processing_class.from_dict(self.image_processor_dict, size=42, crop_size=84)
self.assertEqual(feature_extractor.size, {"shortest_edge": 42}) self.assertEqual(image_processor.size, {"shortest_edge": 42})
self.assertEqual(feature_extractor.crop_size, {"height": 84, "width": 84}) self.assertEqual(image_processor.crop_size, {"height": 84, "width": 84})
def test_batch_feature(self): def test_batch_feature(self):
pass pass
def test_call_pil(self): def test_call_pil(self):
# Initialize feature_extractor # Initialize image_processing
feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) image_processing = self.image_processing_class(**self.image_processor_dict)
# create random PIL images # 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: for image in image_inputs:
self.assertIsInstance(image, Image.Image) self.assertIsInstance(image, Image.Image)
# Test not batched input # 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( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
1, 1,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
self.feature_extract_tester.crop_size["height"], self.image_processor_tester.crop_size["height"],
self.feature_extract_tester.crop_size["width"], self.image_processor_tester.crop_size["width"],
), ),
) )
# Test batched # 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( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
self.feature_extract_tester.batch_size, self.image_processor_tester.batch_size,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
self.feature_extract_tester.crop_size["height"], self.image_processor_tester.crop_size["height"],
self.feature_extract_tester.crop_size["width"], self.image_processor_tester.crop_size["width"],
), ),
) )
def test_call_numpy(self): def test_call_numpy(self):
# Initialize feature_extractor # Initialize image_processing
feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) image_processing = self.image_processing_class(**self.image_processor_dict)
# create random numpy tensors # 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: for image in image_inputs:
self.assertIsInstance(image, np.ndarray) self.assertIsInstance(image, np.ndarray)
# Test not batched input # 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( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
1, 1,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
self.feature_extract_tester.crop_size["height"], self.image_processor_tester.crop_size["height"],
self.feature_extract_tester.crop_size["width"], self.image_processor_tester.crop_size["width"],
), ),
) )
# Test batched # 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( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
self.feature_extract_tester.batch_size, self.image_processor_tester.batch_size,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
self.feature_extract_tester.crop_size["height"], self.image_processor_tester.crop_size["height"],
self.feature_extract_tester.crop_size["width"], self.image_processor_tester.crop_size["width"],
), ),
) )
def test_call_pytorch(self): def test_call_pytorch(self):
# Initialize feature_extractor # Initialize image_processing
feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) image_processing = self.image_processing_class(**self.image_processor_dict)
# create random PyTorch tensors # 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: for image in image_inputs:
self.assertIsInstance(image, torch.Tensor) self.assertIsInstance(image, torch.Tensor)
# Test not batched input # 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( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
1, 1,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
self.feature_extract_tester.crop_size["height"], self.image_processor_tester.crop_size["height"],
self.feature_extract_tester.crop_size["width"], self.image_processor_tester.crop_size["width"],
), ),
) )
# Test batched # 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( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
self.feature_extract_tester.batch_size, self.image_processor_tester.batch_size,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
self.feature_extract_tester.crop_size["height"], self.image_processor_tester.crop_size["height"],
self.feature_extract_tester.crop_size["width"], self.image_processor_tester.crop_size["width"],
), ),
) )
tests/models/oneformer/test_image_processing_oneformer.py
View file @ e2bd7f80
...@@ -23,8 +23,7 @@ from huggingface_hub import hf_hub_download ...@@ -23,8 +23,7 @@ from huggingface_hub import hf_hub_download
from transformers.testing_utils import require_torch, require_vision from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available from transformers.utils import is_torch_available, is_vision_available
from ...test_feature_extraction_common import FeatureExtractionSavingTestMixin from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs
from ...test_image_processing_common import prepare_image_inputs
if is_torch_available(): if is_torch_available():
...@@ -100,7 +99,7 @@ class OneFormerImageProcessorTester(unittest.TestCase): ...@@ -100,7 +99,7 @@ class OneFormerImageProcessorTester(unittest.TestCase):
self.do_reduce_labels = do_reduce_labels self.do_reduce_labels = do_reduce_labels
self.ignore_index = ignore_index self.ignore_index = ignore_index
def prepare_feat_extract_dict(self): def prepare_image_processor_dict(self):
return { return {
"do_resize": self.do_resize, "do_resize": self.do_resize,
"size": self.size, "size": self.size,
...@@ -156,20 +155,20 @@ class OneFormerImageProcessorTester(unittest.TestCase): ...@@ -156,20 +155,20 @@ class OneFormerImageProcessorTester(unittest.TestCase):
@require_torch @require_torch
@require_vision @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 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 # only for test_image_processing_common.test_image_proc_to_json_string
feature_extraction_class = image_processing_class image_processing_class = image_processing_class
def setUp(self): def setUp(self):
self.image_processing_tester = OneFormerImageProcessorTester(self) self.image_processing_tester = OneFormerImageProcessorTester(self)
@property @property
def feat_extract_dict(self): def image_processor_dict(self):
return self.image_processing_tester.prepare_feat_extract_dict() return self.image_processing_tester.prepare_image_processor_dict()
def test_feat_extract_properties(self): def test_image_proc_properties(self):
image_processor = self.image_processing_class(**self.feat_extract_dict) image_processor = self.image_processing_class(**self.image_processor_dict)
self.assertTrue(hasattr(image_processor, "image_mean")) self.assertTrue(hasattr(image_processor, "image_mean"))
self.assertTrue(hasattr(image_processor, "image_std")) self.assertTrue(hasattr(image_processor, "image_std"))
self.assertTrue(hasattr(image_processor, "do_normalize")) self.assertTrue(hasattr(image_processor, "do_normalize"))
...@@ -187,7 +186,7 @@ class OneFormerImageProcessingTest(FeatureExtractionSavingTestMixin, unittest.Te ...@@ -187,7 +186,7 @@ class OneFormerImageProcessingTest(FeatureExtractionSavingTestMixin, unittest.Te
def test_call_pil(self): def test_call_pil(self):
# Initialize image_processor # 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 # create random PIL images
image_inputs = prepare_image_inputs(self.image_processing_tester, equal_resolution=False) image_inputs = prepare_image_inputs(self.image_processing_tester, equal_resolution=False)
for image in image_inputs: for image in image_inputs:
...@@ -221,7 +220,7 @@ class OneFormerImageProcessingTest(FeatureExtractionSavingTestMixin, unittest.Te ...@@ -221,7 +220,7 @@ class OneFormerImageProcessingTest(FeatureExtractionSavingTestMixin, unittest.Te
def test_call_numpy(self): def test_call_numpy(self):
# Initialize image_processor # 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 # create random numpy tensors
image_inputs = prepare_image_inputs(self.image_processing_tester, equal_resolution=False, numpify=True) image_inputs = prepare_image_inputs(self.image_processing_tester, equal_resolution=False, numpify=True)
for image in image_inputs: for image in image_inputs:
...@@ -255,7 +254,7 @@ class OneFormerImageProcessingTest(FeatureExtractionSavingTestMixin, unittest.Te ...@@ -255,7 +254,7 @@ class OneFormerImageProcessingTest(FeatureExtractionSavingTestMixin, unittest.Te
def test_call_pytorch(self): def test_call_pytorch(self):
# Initialize image_processor # 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 # create random PyTorch tensors
image_inputs = prepare_image_inputs(self.image_processing_tester, equal_resolution=False, torchify=True) image_inputs = prepare_image_inputs(self.image_processing_tester, equal_resolution=False, torchify=True)
for image in image_inputs: for image in image_inputs:
...@@ -289,7 +288,7 @@ class OneFormerImageProcessingTest(FeatureExtractionSavingTestMixin, unittest.Te ...@@ -289,7 +288,7 @@ class OneFormerImageProcessingTest(FeatureExtractionSavingTestMixin, unittest.Te
def test_equivalence_pad_and_create_pixel_mask(self): def test_equivalence_pad_and_create_pixel_mask(self):
# Initialize image_processors # 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( image_processor_2 = self.image_processing_class(
do_resize=False, do_resize=False,
do_normalize=False, do_normalize=False,
...@@ -320,7 +319,7 @@ class OneFormerImageProcessingTest(FeatureExtractionSavingTestMixin, unittest.Te ...@@ -320,7 +319,7 @@ class OneFormerImageProcessingTest(FeatureExtractionSavingTestMixin, unittest.Te
def comm_get_image_processor_inputs( def comm_get_image_processor_inputs(
self, with_segmentation_maps=False, is_instance_map=False, segmentation_type="np" 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 # prepare image and target
num_labels = self.image_processing_tester.num_labels num_labels = self.image_processing_tester.num_labels
annotations = None annotations = None
......
tests/models/owlvit/test_image_processing_owlvit.py
View file @ e2bd7f80
...@@ -21,8 +21,7 @@ import numpy as np ...@@ -21,8 +21,7 @@ import numpy as np
from transformers.testing_utils import require_torch, require_vision from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available from transformers.utils import is_torch_available, is_vision_available
from ...test_feature_extraction_common import FeatureExtractionSavingTestMixin from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs
from ...test_image_processing_common import prepare_image_inputs
if is_torch_available(): if is_torch_available():
...@@ -31,10 +30,10 @@ if is_torch_available(): ...@@ -31,10 +30,10 @@ if is_torch_available():
if is_vision_available(): if is_vision_available():
from PIL import Image from PIL import Image
from transformers import OwlViTFeatureExtractor from transformers import OwlViTImageProcessor
class OwlViTFeatureExtractionTester(unittest.TestCase): class OwlViTImageProcessingTester(unittest.TestCase):
def __init__( def __init__(
self, self,
parent, parent,
...@@ -67,7 +66,7 @@ class OwlViTFeatureExtractionTester(unittest.TestCase): ...@@ -67,7 +66,7 @@ class OwlViTFeatureExtractionTester(unittest.TestCase):
self.image_std = image_std self.image_std = image_std
self.do_convert_rgb = do_convert_rgb self.do_convert_rgb = do_convert_rgb
def prepare_feat_extract_dict(self): def prepare_image_processor_dict(self):
return { return {
"do_resize": self.do_resize, "do_resize": self.do_resize,
"size": self.size, "size": self.size,
...@@ -82,130 +81,130 @@ class OwlViTFeatureExtractionTester(unittest.TestCase): ...@@ -82,130 +81,130 @@ class OwlViTFeatureExtractionTester(unittest.TestCase):
@require_torch @require_torch
@require_vision @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): def setUp(self):
self.feature_extract_tester = OwlViTFeatureExtractionTester(self) self.image_processor_tester = OwlViTImageProcessingTester(self)
@property @property
def feat_extract_dict(self): def image_processor_dict(self):
return self.feature_extract_tester.prepare_feat_extract_dict() return self.image_processor_tester.prepare_image_processor_dict()
def test_feat_extract_properties(self): def test_image_processor_properties(self):
feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) image_processing = self.image_processing_class(**self.image_processor_dict)
self.assertTrue(hasattr(feature_extractor, "do_resize")) self.assertTrue(hasattr(image_processing, "do_resize"))
self.assertTrue(hasattr(feature_extractor, "size")) self.assertTrue(hasattr(image_processing, "size"))
self.assertTrue(hasattr(feature_extractor, "do_center_crop")) self.assertTrue(hasattr(image_processing, "do_center_crop"))
self.assertTrue(hasattr(feature_extractor, "center_crop")) self.assertTrue(hasattr(image_processing, "center_crop"))
self.assertTrue(hasattr(feature_extractor, "do_normalize")) self.assertTrue(hasattr(image_processing, "do_normalize"))
self.assertTrue(hasattr(feature_extractor, "image_mean")) self.assertTrue(hasattr(image_processing, "image_mean"))
self.assertTrue(hasattr(feature_extractor, "image_std")) self.assertTrue(hasattr(image_processing, "image_std"))
self.assertTrue(hasattr(feature_extractor, "do_convert_rgb")) self.assertTrue(hasattr(image_processing, "do_convert_rgb"))
def test_feat_extract_from_dict_with_kwargs(self): def test_image_processor_from_dict_with_kwargs(self):
feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict) image_processor = self.image_processing_class.from_dict(self.image_processor_dict)
self.assertEqual(feature_extractor.size, {"height": 18, "width": 18}) self.assertEqual(image_processor.size, {"height": 18, "width": 18})
self.assertEqual(feature_extractor.crop_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) image_processor = self.image_processing_class.from_dict(self.image_processor_dict, size=42, crop_size=84)
self.assertEqual(feature_extractor.size, {"height": 42, "width": 42}) self.assertEqual(image_processor.size, {"height": 42, "width": 42})
self.assertEqual(feature_extractor.crop_size, {"height": 84, "width": 84}) self.assertEqual(image_processor.crop_size, {"height": 84, "width": 84})
def test_call_pil(self): def test_call_pil(self):
# Initialize feature_extractor # Initialize image_processing
feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) image_processing = self.image_processing_class(**self.image_processor_dict)
# create random PIL images # 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: for image in image_inputs:
self.assertIsInstance(image, Image.Image) self.assertIsInstance(image, Image.Image)
# Test not batched input # 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( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
1, 1,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
self.feature_extract_tester.crop_size["height"], self.image_processor_tester.crop_size["height"],
self.feature_extract_tester.crop_size["width"], self.image_processor_tester.crop_size["width"],
), ),
) )
# Test batched # 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( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
self.feature_extract_tester.batch_size, self.image_processor_tester.batch_size,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
self.feature_extract_tester.crop_size["height"], self.image_processor_tester.crop_size["height"],
self.feature_extract_tester.crop_size["width"], self.image_processor_tester.crop_size["width"],
), ),
) )
def test_call_numpy(self): def test_call_numpy(self):
# Initialize feature_extractor # Initialize image_processing
feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) image_processing = self.image_processing_class(**self.image_processor_dict)
# create random numpy tensors # 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: for image in image_inputs:
self.assertIsInstance(image, np.ndarray) self.assertIsInstance(image, np.ndarray)
# Test not batched input # 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( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
1, 1,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
self.feature_extract_tester.crop_size["height"], self.image_processor_tester.crop_size["height"],
self.feature_extract_tester.crop_size["width"], self.image_processor_tester.crop_size["width"],
), ),
) )
# Test batched # 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( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
self.feature_extract_tester.batch_size, self.image_processor_tester.batch_size,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
self.feature_extract_tester.crop_size["height"], self.image_processor_tester.crop_size["height"],
self.feature_extract_tester.crop_size["width"], self.image_processor_tester.crop_size["width"],
), ),
) )
def test_call_pytorch(self): def test_call_pytorch(self):
# Initialize feature_extractor # Initialize image_processing
feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) image_processing = self.image_processing_class(**self.image_processor_dict)
# create random PyTorch tensors # 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: for image in image_inputs:
self.assertIsInstance(image, torch.Tensor) self.assertIsInstance(image, torch.Tensor)
# Test not batched input # 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( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
1, 1,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
self.feature_extract_tester.crop_size["height"], self.image_processor_tester.crop_size["height"],
self.feature_extract_tester.crop_size["width"], self.image_processor_tester.crop_size["width"],
), ),
) )
# Test batched # 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( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
self.feature_extract_tester.batch_size, self.image_processor_tester.batch_size,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
self.feature_extract_tester.crop_size["height"], self.image_processor_tester.crop_size["height"],
self.feature_extract_tester.crop_size["width"], self.image_processor_tester.crop_size["width"],
), ),
) )
tests/models/poolformer/test_image_processing_poolformer.py
View file @ e2bd7f80
...@@ -20,8 +20,7 @@ import numpy as np ...@@ -20,8 +20,7 @@ import numpy as np
from transformers.testing_utils import require_torch, require_vision from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available from transformers.utils import is_torch_available, is_vision_available
from ...test_feature_extraction_common import FeatureExtractionSavingTestMixin from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs
from ...test_image_processing_common import prepare_image_inputs
if is_torch_available(): if is_torch_available():
...@@ -30,10 +29,10 @@ if is_torch_available(): ...@@ -30,10 +29,10 @@ if is_torch_available():
if is_vision_available(): if is_vision_available():
from PIL import Image from PIL import Image
from transformers import PoolFormerFeatureExtractor from transformers import PoolFormerImageProcessor
class PoolFormerFeatureExtractionTester(unittest.TestCase): class PoolFormerImageProcessingTester(unittest.TestCase):
def __init__( def __init__(
self, self,
parent, parent,
...@@ -64,7 +63,7 @@ class PoolFormerFeatureExtractionTester(unittest.TestCase): ...@@ -64,7 +63,7 @@ class PoolFormerFeatureExtractionTester(unittest.TestCase):
self.image_mean = image_mean self.image_mean = image_mean
self.image_std = image_std self.image_std = image_std
def prepare_feat_extract_dict(self): def prepare_image_processor_dict(self):
return { return {
"size": self.size, "size": self.size,
"do_resize_and_center_crop": self.do_resize_and_center_crop, "do_resize_and_center_crop": self.do_resize_and_center_crop,
...@@ -78,131 +77,131 @@ class PoolFormerFeatureExtractionTester(unittest.TestCase): ...@@ -78,131 +77,131 @@ class PoolFormerFeatureExtractionTester(unittest.TestCase):
@require_torch @require_torch
@require_vision @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): def setUp(self):
self.feature_extract_tester = PoolFormerFeatureExtractionTester(self) self.image_processor_tester = PoolFormerImageProcessingTester(self)
@property @property
def feat_extract_dict(self): def image_processor_dict(self):
return self.feature_extract_tester.prepare_feat_extract_dict() return self.image_processor_tester.prepare_image_processor_dict()
def test_feat_extract_properties(self): def test_image_processor_properties(self):
feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) image_processing = self.image_processing_class(**self.image_processor_dict)
self.assertTrue(hasattr(feature_extractor, "do_resize_and_center_crop")) self.assertTrue(hasattr(image_processing, "do_resize_and_center_crop"))
self.assertTrue(hasattr(feature_extractor, "size")) self.assertTrue(hasattr(image_processing, "size"))
self.assertTrue(hasattr(feature_extractor, "crop_pct")) self.assertTrue(hasattr(image_processing, "crop_pct"))
self.assertTrue(hasattr(feature_extractor, "do_normalize")) self.assertTrue(hasattr(image_processing, "do_normalize"))
self.assertTrue(hasattr(feature_extractor, "image_mean")) self.assertTrue(hasattr(image_processing, "image_mean"))
self.assertTrue(hasattr(feature_extractor, "image_std")) self.assertTrue(hasattr(image_processing, "image_std"))
def test_feat_extract_from_dict_with_kwargs(self): def test_image_processor_from_dict_with_kwargs(self):
feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict) image_processor = self.image_processing_class.from_dict(self.image_processor_dict)
self.assertEqual(feature_extractor.size, {"shortest_edge": 30}) self.assertEqual(image_processor.size, {"shortest_edge": 30})
self.assertEqual(feature_extractor.crop_size, {"height": 30, "width": 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) image_processor = self.image_processing_class.from_dict(self.image_processor_dict, size=42, crop_size=84)
self.assertEqual(feature_extractor.size, {"shortest_edge": 42}) self.assertEqual(image_processor.size, {"shortest_edge": 42})
self.assertEqual(feature_extractor.crop_size, {"height": 84, "width": 84}) self.assertEqual(image_processor.crop_size, {"height": 84, "width": 84})
def test_batch_feature(self): def test_batch_feature(self):
pass pass
def test_call_pil(self): def test_call_pil(self):
# Initialize feature_extractor # Initialize image_processing
feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) image_processing = self.image_processing_class(**self.image_processor_dict)
# create random PIL images # 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: for image in image_inputs:
self.assertIsInstance(image, Image.Image) self.assertIsInstance(image, Image.Image)
# Test not batched input # 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( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
1, 1,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
self.feature_extract_tester.crop_size["height"], self.image_processor_tester.crop_size["height"],
self.feature_extract_tester.crop_size["width"], self.image_processor_tester.crop_size["width"],
), ),
) )
# Test batched # 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( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
self.feature_extract_tester.batch_size, self.image_processor_tester.batch_size,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
self.feature_extract_tester.crop_size["height"], self.image_processor_tester.crop_size["height"],
self.feature_extract_tester.crop_size["width"], self.image_processor_tester.crop_size["width"],
), ),
) )
def test_call_numpy(self): def test_call_numpy(self):
# Initialize feature_extractor # Initialize image_processing
feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) image_processing = self.image_processing_class(**self.image_processor_dict)
# create random numpy tensors # 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: for image in image_inputs:
self.assertIsInstance(image, np.ndarray) self.assertIsInstance(image, np.ndarray)
# Test not batched input # 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( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
1, 1,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
self.feature_extract_tester.crop_size["height"], self.image_processor_tester.crop_size["height"],
self.feature_extract_tester.crop_size["width"], self.image_processor_tester.crop_size["width"],
), ),
) )
# Test batched # 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( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
self.feature_extract_tester.batch_size, self.image_processor_tester.batch_size,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
self.feature_extract_tester.crop_size["height"], self.image_processor_tester.crop_size["height"],
self.feature_extract_tester.crop_size["width"], self.image_processor_tester.crop_size["width"],
), ),
) )
def test_call_pytorch(self): def test_call_pytorch(self):
# Initialize feature_extractor # Initialize image_processing
feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) image_processing = self.image_processing_class(**self.image_processor_dict)
# create random PyTorch tensors # 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: for image in image_inputs:
self.assertIsInstance(image, torch.Tensor) self.assertIsInstance(image, torch.Tensor)
# Test not batched input # 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( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
1, 1,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
self.feature_extract_tester.crop_size["height"], self.image_processor_tester.crop_size["height"],
self.feature_extract_tester.crop_size["width"], self.image_processor_tester.crop_size["width"],
), ),
) )
# Test batched # 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( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
self.feature_extract_tester.batch_size, self.image_processor_tester.batch_size,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
self.feature_extract_tester.crop_size["height"], self.image_processor_tester.crop_size["height"],
self.feature_extract_tester.crop_size["width"], self.image_processor_tester.crop_size["width"],
), ),
) )
tests/models/segformer/test_image_processing_segformer.py
View file @ e2bd7f80
...@@ -22,8 +22,7 @@ from datasets import load_dataset ...@@ -22,8 +22,7 @@ from datasets import load_dataset
from transformers.testing_utils import require_torch, require_vision from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available from transformers.utils import is_torch_available, is_vision_available
from ...test_feature_extraction_common import FeatureExtractionSavingTestMixin from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs
from ...test_image_processing_common import prepare_image_inputs
if is_torch_available(): if is_torch_available():
...@@ -32,10 +31,10 @@ if is_torch_available(): ...@@ -32,10 +31,10 @@ if is_torch_available():
if is_vision_available(): if is_vision_available():
from PIL import Image from PIL import Image
from transformers import SegformerFeatureExtractor from transformers import SegformerImageProcessor
class SegformerFeatureExtractionTester(unittest.TestCase): class SegformerImageProcessingTester(unittest.TestCase):
def __init__( def __init__(
self, self,
parent, parent,
...@@ -63,7 +62,7 @@ class SegformerFeatureExtractionTester(unittest.TestCase): ...@@ -63,7 +62,7 @@ class SegformerFeatureExtractionTester(unittest.TestCase):
self.image_std = image_std self.image_std = image_std
self.do_reduce_labels = do_reduce_labels self.do_reduce_labels = do_reduce_labels
def prepare_feat_extract_dict(self): def prepare_image_processor_dict(self):
return { return {
"do_resize": self.do_resize, "do_resize": self.do_resize,
"size": self.size, "size": self.size,
...@@ -96,163 +95,161 @@ def prepare_semantic_batch_inputs(): ...@@ -96,163 +95,161 @@ def prepare_semantic_batch_inputs():
@require_torch @require_torch
@require_vision @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): def setUp(self):
self.feature_extract_tester = SegformerFeatureExtractionTester(self) self.image_processor_tester = SegformerImageProcessingTester(self)
@property @property
def feat_extract_dict(self): def image_processor_dict(self):
return self.feature_extract_tester.prepare_feat_extract_dict() return self.image_processor_tester.prepare_image_processor_dict()
def test_feat_extract_properties(self): def test_image_processor_properties(self):
feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) image_processing = self.image_processing_class(**self.image_processor_dict)
self.assertTrue(hasattr(feature_extractor, "do_resize")) self.assertTrue(hasattr(image_processing, "do_resize"))
self.assertTrue(hasattr(feature_extractor, "size")) self.assertTrue(hasattr(image_processing, "size"))
self.assertTrue(hasattr(feature_extractor, "do_normalize")) self.assertTrue(hasattr(image_processing, "do_normalize"))
self.assertTrue(hasattr(feature_extractor, "image_mean")) self.assertTrue(hasattr(image_processing, "image_mean"))
self.assertTrue(hasattr(feature_extractor, "image_std")) self.assertTrue(hasattr(image_processing, "image_std"))
self.assertTrue(hasattr(feature_extractor, "do_reduce_labels")) self.assertTrue(hasattr(image_processing, "do_reduce_labels"))
def test_feat_extract_from_dict_with_kwargs(self): def test_image_processor_from_dict_with_kwargs(self):
feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict) image_processor = self.image_processing_class.from_dict(self.image_processor_dict)
self.assertEqual(feature_extractor.size, {"height": 30, "width": 30}) self.assertEqual(image_processor.size, {"height": 30, "width": 30})
self.assertEqual(feature_extractor.do_reduce_labels, False) self.assertEqual(image_processor.do_reduce_labels, False)
feature_extractor = self.feature_extraction_class.from_dict( image_processor = self.image_processing_class.from_dict(self.image_processor_dict, size=42, reduce_labels=True)
self.feat_extract_dict, size=42, reduce_labels=True self.assertEqual(image_processor.size, {"height": 42, "width": 42})
) self.assertEqual(image_processor.do_reduce_labels, True)
self.assertEqual(feature_extractor.size, {"height": 42, "width": 42})
self.assertEqual(feature_extractor.do_reduce_labels, True)
def test_batch_feature(self): def test_batch_feature(self):
pass pass
def test_call_pil(self): def test_call_pil(self):
# Initialize feature_extractor # Initialize image_processing
feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) image_processing = self.image_processing_class(**self.image_processor_dict)
# create random PIL images # 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: for image in image_inputs:
self.assertIsInstance(image, Image.Image) self.assertIsInstance(image, Image.Image)
# Test not batched input # 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( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
1, 1,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
self.feature_extract_tester.size["height"], self.image_processor_tester.size["height"],
self.feature_extract_tester.size["width"], self.image_processor_tester.size["width"],
), ),
) )
# Test batched # 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( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
self.feature_extract_tester.batch_size, self.image_processor_tester.batch_size,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
self.feature_extract_tester.size["height"], self.image_processor_tester.size["height"],
self.feature_extract_tester.size["width"], self.image_processor_tester.size["width"],
), ),
) )
def test_call_numpy(self): def test_call_numpy(self):
# Initialize feature_extractor # Initialize image_processing
feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) image_processing = self.image_processing_class(**self.image_processor_dict)
# create random numpy tensors # 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: for image in image_inputs:
self.assertIsInstance(image, np.ndarray) self.assertIsInstance(image, np.ndarray)
# Test not batched input # 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( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
1, 1,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
self.feature_extract_tester.size["height"], self.image_processor_tester.size["height"],
self.feature_extract_tester.size["width"], self.image_processor_tester.size["width"],
), ),
) )
# Test batched # 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( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
self.feature_extract_tester.batch_size, self.image_processor_tester.batch_size,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
self.feature_extract_tester.size["height"], self.image_processor_tester.size["height"],
self.feature_extract_tester.size["width"], self.image_processor_tester.size["width"],
), ),
) )
def test_call_pytorch(self): def test_call_pytorch(self):
# Initialize feature_extractor # Initialize image_processing
feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) image_processing = self.image_processing_class(**self.image_processor_dict)
# create random PyTorch tensors # 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: for image in image_inputs:
self.assertIsInstance(image, torch.Tensor) self.assertIsInstance(image, torch.Tensor)
# Test not batched input # 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( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
1, 1,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
self.feature_extract_tester.size["height"], self.image_processor_tester.size["height"],
self.feature_extract_tester.size["width"], self.image_processor_tester.size["width"],
), ),
) )
# Test batched # 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( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
self.feature_extract_tester.batch_size, self.image_processor_tester.batch_size,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
self.feature_extract_tester.size["height"], self.image_processor_tester.size["height"],
self.feature_extract_tester.size["width"], self.image_processor_tester.size["width"],
), ),
) )
def test_call_segmentation_maps(self): def test_call_segmentation_maps(self):
# Initialize feature_extractor # Initialize image_processing
feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) image_processing = self.image_processing_class(**self.image_processor_dict)
# create random PyTorch tensors # 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 = [] maps = []
for image in image_inputs: for image in image_inputs:
self.assertIsInstance(image, torch.Tensor) self.assertIsInstance(image, torch.Tensor)
maps.append(torch.zeros(image.shape[-2:]).long()) maps.append(torch.zeros(image.shape[-2:]).long())
# Test not batched input # 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( self.assertEqual(
encoding["pixel_values"].shape, encoding["pixel_values"].shape,
( (
1, 1,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
self.feature_extract_tester.size["height"], self.image_processor_tester.size["height"],
self.feature_extract_tester.size["width"], self.image_processor_tester.size["width"],
), ),
) )
self.assertEqual( self.assertEqual(
encoding["labels"].shape, encoding["labels"].shape,
( (
1, 1,
self.feature_extract_tester.size["height"], self.image_processor_tester.size["height"],
self.feature_extract_tester.size["width"], self.image_processor_tester.size["width"],
), ),
) )
self.assertEqual(encoding["labels"].dtype, torch.long) self.assertEqual(encoding["labels"].dtype, torch.long)
...@@ -260,22 +257,22 @@ class SegformerFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest. ...@@ -260,22 +257,22 @@ class SegformerFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.
self.assertTrue(encoding["labels"].max().item() <= 255) self.assertTrue(encoding["labels"].max().item() <= 255)
# Test batched # Test batched
encoding = feature_extractor(image_inputs, maps, return_tensors="pt") encoding = image_processing(image_inputs, maps, return_tensors="pt")
self.assertEqual( self.assertEqual(
encoding["pixel_values"].shape, encoding["pixel_values"].shape,
( (
self.feature_extract_tester.batch_size, self.image_processor_tester.batch_size,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
self.feature_extract_tester.size["height"], self.image_processor_tester.size["height"],
self.feature_extract_tester.size["width"], self.image_processor_tester.size["width"],
), ),
) )
self.assertEqual( self.assertEqual(
encoding["labels"].shape, encoding["labels"].shape,
( (
self.feature_extract_tester.batch_size, self.image_processor_tester.batch_size,
self.feature_extract_tester.size["height"], self.image_processor_tester.size["height"],
self.feature_extract_tester.size["width"], self.image_processor_tester.size["width"],
), ),
) )
self.assertEqual(encoding["labels"].dtype, torch.long) self.assertEqual(encoding["labels"].dtype, torch.long)
...@@ -285,22 +282,22 @@ class SegformerFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest. ...@@ -285,22 +282,22 @@ class SegformerFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.
# Test not batched input (PIL images) # Test not batched input (PIL images)
image, segmentation_map = prepare_semantic_single_inputs() 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( self.assertEqual(
encoding["pixel_values"].shape, encoding["pixel_values"].shape,
( (
1, 1,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
self.feature_extract_tester.size["height"], self.image_processor_tester.size["height"],
self.feature_extract_tester.size["width"], self.image_processor_tester.size["width"],
), ),
) )
self.assertEqual( self.assertEqual(
encoding["labels"].shape, encoding["labels"].shape,
( (
1, 1,
self.feature_extract_tester.size["height"], self.image_processor_tester.size["height"],
self.feature_extract_tester.size["width"], self.image_processor_tester.size["width"],
), ),
) )
self.assertEqual(encoding["labels"].dtype, torch.long) self.assertEqual(encoding["labels"].dtype, torch.long)
...@@ -310,22 +307,22 @@ class SegformerFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest. ...@@ -310,22 +307,22 @@ class SegformerFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.
# Test batched input (PIL images) # Test batched input (PIL images)
images, segmentation_maps = prepare_semantic_batch_inputs() 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( self.assertEqual(
encoding["pixel_values"].shape, encoding["pixel_values"].shape,
( (
2, 2,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
self.feature_extract_tester.size["height"], self.image_processor_tester.size["height"],
self.feature_extract_tester.size["width"], self.image_processor_tester.size["width"],
), ),
) )
self.assertEqual( self.assertEqual(
encoding["labels"].shape, encoding["labels"].shape,
( (
2, 2,
self.feature_extract_tester.size["height"], self.image_processor_tester.size["height"],
self.feature_extract_tester.size["width"], self.image_processor_tester.size["width"],
), ),
) )
self.assertEqual(encoding["labels"].dtype, torch.long) self.assertEqual(encoding["labels"].dtype, torch.long)
...@@ -333,16 +330,16 @@ class SegformerFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest. ...@@ -333,16 +330,16 @@ class SegformerFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.
self.assertTrue(encoding["labels"].max().item() <= 255) self.assertTrue(encoding["labels"].max().item() <= 255)
def test_reduce_labels(self): def test_reduce_labels(self):
# Initialize feature_extractor # Initialize image_processing
feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) 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 # ADE20k has 150 classes, and the background is included, so labels should be between 0 and 150
image, map = prepare_semantic_single_inputs() 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"].min().item() >= 0)
self.assertTrue(encoding["labels"].max().item() <= 150) self.assertTrue(encoding["labels"].max().item() <= 150)
feature_extractor.reduce_labels = True image_processing.reduce_labels = True
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"].min().item() >= 0)
self.assertTrue(encoding["labels"].max().item() <= 255) self.assertTrue(encoding["labels"].max().item() <= 255)
tests/models/swin2sr/test_image_processing_swin2sr.py
View file @ e2bd7f80
...@@ -21,7 +21,7 @@ import numpy as np ...@@ -21,7 +21,7 @@ import numpy as np
from transformers.testing_utils import require_torch, require_vision from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available 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(): if is_torch_available():
...@@ -59,7 +59,7 @@ class Swin2SRImageProcessingTester(unittest.TestCase): ...@@ -59,7 +59,7 @@ class Swin2SRImageProcessingTester(unittest.TestCase):
self.do_pad = do_pad self.do_pad = do_pad
self.pad_size = pad_size self.pad_size = pad_size
def prepare_feat_extract_dict(self): def prepare_image_processor_dict(self):
return { return {
"do_rescale": self.do_rescale, "do_rescale": self.do_rescale,
"rescale_factor": self.rescale_factor, "rescale_factor": self.rescale_factor,
...@@ -100,93 +100,93 @@ class Swin2SRImageProcessingTester(unittest.TestCase): ...@@ -100,93 +100,93 @@ class Swin2SRImageProcessingTester(unittest.TestCase):
@require_torch @require_torch
@require_vision @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): def setUp(self):
self.feature_extract_tester = Swin2SRImageProcessingTester(self) self.image_processor_tester = Swin2SRImageProcessingTester(self)
@property @property
def feat_extract_dict(self): def image_processor_dict(self):
return self.feature_extract_tester.prepare_feat_extract_dict() return self.image_processor_tester.prepare_image_processor_dict()
def test_feat_extract_properties(self): def test_image_processor_properties(self):
feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) image_processor = self.image_processing_class(**self.image_processor_dict)
self.assertTrue(hasattr(feature_extractor, "do_rescale")) self.assertTrue(hasattr(image_processor, "do_rescale"))
self.assertTrue(hasattr(feature_extractor, "rescale_factor")) self.assertTrue(hasattr(image_processor, "rescale_factor"))
self.assertTrue(hasattr(feature_extractor, "do_pad")) self.assertTrue(hasattr(image_processor, "do_pad"))
self.assertTrue(hasattr(feature_extractor, "pad_size")) self.assertTrue(hasattr(image_processor, "pad_size"))
def test_batch_feature(self): def test_batch_feature(self):
pass pass
def calculate_expected_size(self, image): def calculate_expected_size(self, image):
old_height, old_width = get_image_size(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_height = (old_height // size + 1) * size - old_height
pad_width = (old_width // size + 1) * size - old_width pad_width = (old_width // size + 1) * size - old_width
return old_height + pad_height, old_width + pad_width return old_height + pad_height, old_width + pad_width
def test_call_pil(self): def test_call_pil(self):
# Initialize feature_extractor # Initialize image_processor
feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) image_processor = self.image_processing_class(**self.image_processor_dict)
# create random PIL images # 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: for image in image_inputs:
self.assertIsInstance(image, Image.Image) self.assertIsInstance(image, Image.Image)
# Test not batched input # 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])) expected_height, expected_width = self.calculate_expected_size(np.array(image_inputs[0]))
self.assertEqual( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
1, 1,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
expected_height, expected_height,
expected_width, expected_width,
), ),
) )
def test_call_numpy(self): def test_call_numpy(self):
# Initialize feature_extractor # Initialize image_processor
feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) image_processor = self.image_processing_class(**self.image_processor_dict)
# create random numpy tensors # 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: for image in image_inputs:
self.assertIsInstance(image, np.ndarray) self.assertIsInstance(image, np.ndarray)
# Test not batched input # 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]) expected_height, expected_width = self.calculate_expected_size(image_inputs[0])
self.assertEqual( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
1, 1,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
expected_height, expected_height,
expected_width, expected_width,
), ),
) )
def test_call_pytorch(self): def test_call_pytorch(self):
# Initialize feature_extractor # Initialize image_processor
feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) image_processor = self.image_processing_class(**self.image_processor_dict)
# create random PyTorch tensors # 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: for image in image_inputs:
self.assertIsInstance(image, torch.Tensor) self.assertIsInstance(image, torch.Tensor)
# Test not batched input # 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]) expected_height, expected_width = self.calculate_expected_size(image_inputs[0])
self.assertEqual( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
1, 1,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
expected_height, expected_height,
expected_width, expected_width,
), ),
......
tests/models/videomae/test_image_processing_videomae.py
View file @ e2bd7f80
...@@ -21,8 +21,7 @@ import numpy as np ...@@ -21,8 +21,7 @@ import numpy as np
from transformers.testing_utils import require_torch, require_vision from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available from transformers.utils import is_torch_available, is_vision_available
from ...test_feature_extraction_common import FeatureExtractionSavingTestMixin from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_video_inputs
from ...test_image_processing_common import prepare_video_inputs
if is_torch_available(): if is_torch_available():
...@@ -31,10 +30,10 @@ if is_torch_available(): ...@@ -31,10 +30,10 @@ if is_torch_available():
if is_vision_available(): if is_vision_available():
from PIL import Image from PIL import Image
from transformers import VideoMAEFeatureExtractor from transformers import VideoMAEImageProcessor
class VideoMAEFeatureExtractionTester(unittest.TestCase): class VideoMAEImageProcessingTester(unittest.TestCase):
def __init__( def __init__(
self, self,
parent, parent,
...@@ -68,7 +67,7 @@ class VideoMAEFeatureExtractionTester(unittest.TestCase): ...@@ -68,7 +67,7 @@ class VideoMAEFeatureExtractionTester(unittest.TestCase):
self.image_std = image_std self.image_std = image_std
self.crop_size = crop_size self.crop_size = crop_size
def prepare_feat_extract_dict(self): def prepare_image_processor_dict(self):
return { return {
"image_mean": self.image_mean, "image_mean": self.image_mean,
"image_std": self.image_std, "image_std": self.image_std,
...@@ -81,139 +80,139 @@ class VideoMAEFeatureExtractionTester(unittest.TestCase): ...@@ -81,139 +80,139 @@ class VideoMAEFeatureExtractionTester(unittest.TestCase):
@require_torch @require_torch
@require_vision @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): def setUp(self):
self.feature_extract_tester = VideoMAEFeatureExtractionTester(self) self.image_processor_tester = VideoMAEImageProcessingTester(self)
@property @property
def feat_extract_dict(self): def image_processor_dict(self):
return self.feature_extract_tester.prepare_feat_extract_dict() return self.image_processor_tester.prepare_image_processor_dict()
def test_feat_extract_properties(self): def test_image_processor_properties(self):
feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) image_processing = self.image_processing_class(**self.image_processor_dict)
self.assertTrue(hasattr(feature_extractor, "image_mean")) self.assertTrue(hasattr(image_processing, "image_mean"))
self.assertTrue(hasattr(feature_extractor, "image_std")) self.assertTrue(hasattr(image_processing, "image_std"))
self.assertTrue(hasattr(feature_extractor, "do_normalize")) self.assertTrue(hasattr(image_processing, "do_normalize"))
self.assertTrue(hasattr(feature_extractor, "do_resize")) self.assertTrue(hasattr(image_processing, "do_resize"))
self.assertTrue(hasattr(feature_extractor, "do_center_crop")) self.assertTrue(hasattr(image_processing, "do_center_crop"))
self.assertTrue(hasattr(feature_extractor, "size")) self.assertTrue(hasattr(image_processing, "size"))
def test_feat_extract_from_dict_with_kwargs(self): def test_image_processor_from_dict_with_kwargs(self):
feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict) image_processor = self.image_processing_class.from_dict(self.image_processor_dict)
self.assertEqual(feature_extractor.size, {"shortest_edge": 18}) self.assertEqual(image_processor.size, {"shortest_edge": 18})
self.assertEqual(feature_extractor.crop_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) image_processor = self.image_processing_class.from_dict(self.image_processor_dict, size=42, crop_size=84)
self.assertEqual(feature_extractor.size, {"shortest_edge": 42}) self.assertEqual(image_processor.size, {"shortest_edge": 42})
self.assertEqual(feature_extractor.crop_size, {"height": 84, "width": 84}) self.assertEqual(image_processor.crop_size, {"height": 84, "width": 84})
def test_batch_feature(self): def test_batch_feature(self):
pass pass
def test_call_pil(self): def test_call_pil(self):
# Initialize feature_extractor # Initialize image_processing
feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) image_processing = self.image_processing_class(**self.image_processor_dict)
# create random PIL videos # 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: for video in video_inputs:
self.assertIsInstance(video, list) self.assertIsInstance(video, list)
self.assertIsInstance(video[0], Image.Image) self.assertIsInstance(video[0], Image.Image)
# Test not batched input # 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( self.assertEqual(
encoded_videos.shape, encoded_videos.shape,
( (
1, 1,
self.feature_extract_tester.num_frames, self.image_processor_tester.num_frames,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
self.feature_extract_tester.crop_size["height"], self.image_processor_tester.crop_size["height"],
self.feature_extract_tester.crop_size["width"], self.image_processor_tester.crop_size["width"],
), ),
) )
# Test batched # 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( self.assertEqual(
encoded_videos.shape, encoded_videos.shape,
( (
self.feature_extract_tester.batch_size, self.image_processor_tester.batch_size,
self.feature_extract_tester.num_frames, self.image_processor_tester.num_frames,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
self.feature_extract_tester.crop_size["height"], self.image_processor_tester.crop_size["height"],
self.feature_extract_tester.crop_size["width"], self.image_processor_tester.crop_size["width"],
), ),
) )
def test_call_numpy(self): def test_call_numpy(self):
# Initialize feature_extractor # Initialize image_processing
feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) image_processing = self.image_processing_class(**self.image_processor_dict)
# create random numpy tensors # 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: for video in video_inputs:
self.assertIsInstance(video, list) self.assertIsInstance(video, list)
self.assertIsInstance(video[0], np.ndarray) self.assertIsInstance(video[0], np.ndarray)
# Test not batched input # 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( self.assertEqual(
encoded_videos.shape, encoded_videos.shape,
( (
1, 1,
self.feature_extract_tester.num_frames, self.image_processor_tester.num_frames,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
self.feature_extract_tester.crop_size["height"], self.image_processor_tester.crop_size["height"],
self.feature_extract_tester.crop_size["width"], self.image_processor_tester.crop_size["width"],
), ),
) )
# Test batched # 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( self.assertEqual(
encoded_videos.shape, encoded_videos.shape,
( (
self.feature_extract_tester.batch_size, self.image_processor_tester.batch_size,
self.feature_extract_tester.num_frames, self.image_processor_tester.num_frames,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
self.feature_extract_tester.crop_size["height"], self.image_processor_tester.crop_size["height"],
self.feature_extract_tester.crop_size["width"], self.image_processor_tester.crop_size["width"],
), ),
) )
def test_call_pytorch(self): def test_call_pytorch(self):
# Initialize feature_extractor # Initialize image_processing
feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) image_processing = self.image_processing_class(**self.image_processor_dict)
# create random PyTorch tensors # 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: for video in video_inputs:
self.assertIsInstance(video, list) self.assertIsInstance(video, list)
self.assertIsInstance(video[0], torch.Tensor) self.assertIsInstance(video[0], torch.Tensor)
# Test not batched input # 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( self.assertEqual(
encoded_videos.shape, encoded_videos.shape,
( (
1, 1,
self.feature_extract_tester.num_frames, self.image_processor_tester.num_frames,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
self.feature_extract_tester.crop_size["height"], self.image_processor_tester.crop_size["height"],
self.feature_extract_tester.crop_size["width"], self.image_processor_tester.crop_size["width"],
), ),
) )
# Test batched # 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( self.assertEqual(
encoded_videos.shape, encoded_videos.shape,
( (
self.feature_extract_tester.batch_size, self.image_processor_tester.batch_size,
self.feature_extract_tester.num_frames, self.image_processor_tester.num_frames,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
self.feature_extract_tester.crop_size["height"], self.image_processor_tester.crop_size["height"],
self.feature_extract_tester.crop_size["width"], self.image_processor_tester.crop_size["width"],
), ),
) )
tests/models/vilt/test_image_processing_vilt.py
View file @ e2bd7f80
...@@ -21,8 +21,7 @@ import numpy as np ...@@ -21,8 +21,7 @@ import numpy as np
from transformers.testing_utils import require_torch, require_vision from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available from transformers.utils import is_torch_available, is_vision_available
from ...test_feature_extraction_common import FeatureExtractionSavingTestMixin from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs
from ...test_image_processing_common import prepare_image_inputs
if is_torch_available(): if is_torch_available():
...@@ -31,10 +30,10 @@ if is_torch_available(): ...@@ -31,10 +30,10 @@ if is_torch_available():
if is_vision_available(): if is_vision_available():
from PIL import Image from PIL import Image
from transformers import ViltFeatureExtractor from transformers import ViltImageProcessor
class ViltFeatureExtractionTester(unittest.TestCase): class ViltImageProcessingTester(unittest.TestCase):
def __init__( def __init__(
self, self,
parent, parent,
...@@ -64,7 +63,7 @@ class ViltFeatureExtractionTester(unittest.TestCase): ...@@ -64,7 +63,7 @@ class ViltFeatureExtractionTester(unittest.TestCase):
self.image_mean = image_mean self.image_mean = image_mean
self.image_std = image_std self.image_std = image_std
def prepare_feat_extract_dict(self): def prepare_image_processor_dict(self):
return { return {
"image_mean": self.image_mean, "image_mean": self.image_mean,
"image_std": self.image_std, "image_std": self.image_std,
...@@ -76,7 +75,7 @@ class ViltFeatureExtractionTester(unittest.TestCase): ...@@ -76,7 +75,7 @@ class ViltFeatureExtractionTester(unittest.TestCase):
def get_expected_values(self, image_inputs, batched=False): 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. assuming do_resize is set to True with a scalar size and size_divisor.
""" """
if not batched: if not batched:
...@@ -117,141 +116,141 @@ class ViltFeatureExtractionTester(unittest.TestCase): ...@@ -117,141 +116,141 @@ class ViltFeatureExtractionTester(unittest.TestCase):
@require_torch @require_torch
@require_vision @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): def setUp(self):
self.feature_extract_tester = ViltFeatureExtractionTester(self) self.image_processor_tester = ViltImageProcessingTester(self)
@property @property
def feat_extract_dict(self): def image_processor_dict(self):
return self.feature_extract_tester.prepare_feat_extract_dict() return self.image_processor_tester.prepare_image_processor_dict()
def test_feat_extract_properties(self): def test_image_processor_properties(self):
feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) image_processing = self.image_processing_class(**self.image_processor_dict)
self.assertTrue(hasattr(feature_extractor, "image_mean")) self.assertTrue(hasattr(image_processing, "image_mean"))
self.assertTrue(hasattr(feature_extractor, "image_std")) self.assertTrue(hasattr(image_processing, "image_std"))
self.assertTrue(hasattr(feature_extractor, "do_normalize")) self.assertTrue(hasattr(image_processing, "do_normalize"))
self.assertTrue(hasattr(feature_extractor, "do_resize")) self.assertTrue(hasattr(image_processing, "do_resize"))
self.assertTrue(hasattr(feature_extractor, "size")) self.assertTrue(hasattr(image_processing, "size"))
self.assertTrue(hasattr(feature_extractor, "size_divisor")) self.assertTrue(hasattr(image_processing, "size_divisor"))
def test_feat_extract_from_dict_with_kwargs(self): def test_image_processor_from_dict_with_kwargs(self):
feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict) image_processor = self.image_processing_class.from_dict(self.image_processor_dict)
self.assertEqual(feature_extractor.size, {"shortest_edge": 30}) self.assertEqual(image_processor.size, {"shortest_edge": 30})
feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict, size=42) image_processor = self.image_processing_class.from_dict(self.image_processor_dict, size=42)
self.assertEqual(feature_extractor.size, {"shortest_edge": 42}) self.assertEqual(image_processor.size, {"shortest_edge": 42})
def test_batch_feature(self): def test_batch_feature(self):
pass pass
def test_call_pil(self): def test_call_pil(self):
# Initialize feature_extractor # Initialize image_processing
feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) image_processing = self.image_processing_class(**self.image_processor_dict)
# create random PIL images # 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: for image in image_inputs:
self.assertIsInstance(image, Image.Image) self.assertIsInstance(image, Image.Image)
# Test not batched input # 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( self.assertEqual(
encoded_images.shape, 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 # 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( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
self.feature_extract_tester.batch_size, self.image_processor_tester.batch_size,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
expected_height, expected_height,
expected_width, expected_width,
), ),
) )
def test_call_numpy(self): def test_call_numpy(self):
# Initialize feature_extractor # Initialize image_processing
feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) image_processing = self.image_processing_class(**self.image_processor_dict)
# create random numpy tensors # 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: for image in image_inputs:
self.assertIsInstance(image, np.ndarray) self.assertIsInstance(image, np.ndarray)
# Test not batched input # 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( self.assertEqual(
encoded_images.shape, 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 # 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( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
self.feature_extract_tester.batch_size, self.image_processor_tester.batch_size,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
expected_height, expected_height,
expected_width, expected_width,
), ),
) )
def test_call_pytorch(self): def test_call_pytorch(self):
# Initialize feature_extractor # Initialize image_processing
feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) image_processing = self.image_processing_class(**self.image_processor_dict)
# create random PyTorch tensors # 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: for image in image_inputs:
self.assertIsInstance(image, torch.Tensor) self.assertIsInstance(image, torch.Tensor)
# Test not batched input # 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( self.assertEqual(
encoded_images.shape, 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 # 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( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
self.feature_extract_tester.batch_size, self.image_processor_tester.batch_size,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
expected_height, expected_height,
expected_width, expected_width,
), ),
) )
def test_equivalence_pad_and_create_pixel_mask(self): def test_equivalence_pad_and_create_pixel_mask(self):
# Initialize feature_extractors # Initialize image_processings
feature_extractor_1 = self.feature_extraction_class(**self.feat_extract_dict) image_processing_1 = self.image_processing_class(**self.image_processor_dict)
feature_extractor_2 = self.feature_extraction_class(do_resize=False, do_normalize=False, do_rescale=False) image_processing_2 = self.image_processing_class(do_resize=False, do_normalize=False, do_rescale=False)
# create random PyTorch tensors # 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: for image in image_inputs:
self.assertIsInstance(image, torch.Tensor) self.assertIsInstance(image, torch.Tensor)
# Test whether the method "pad_and_return_pixel_mask" and calling the feature extractor return the same tensors # Test whether the method "pad_and_return_pixel_mask" and calling the image processor return the same tensors
encoded_images_with_method = feature_extractor_1.pad_and_create_pixel_mask(image_inputs, return_tensors="pt") encoded_images_with_method = image_processing_1.pad_and_create_pixel_mask(image_inputs, return_tensors="pt")
encoded_images = feature_extractor_2(image_inputs, return_tensors="pt") encoded_images = image_processing_2(image_inputs, return_tensors="pt")
self.assertTrue( self.assertTrue(
torch.allclose(encoded_images_with_method["pixel_values"], encoded_images["pixel_values"], atol=1e-4) torch.allclose(encoded_images_with_method["pixel_values"], encoded_images["pixel_values"], atol=1e-4)
......
tests/models/vit/test_image_processing_vit.py
View file @ e2bd7f80
...@@ -21,8 +21,7 @@ import numpy as np ...@@ -21,8 +21,7 @@ import numpy as np
from transformers.testing_utils import require_torch, require_vision from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available from transformers.utils import is_torch_available, is_vision_available
from ...test_feature_extraction_common import FeatureExtractionSavingTestMixin from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs
from ...test_image_processing_common import prepare_image_inputs
if is_torch_available(): if is_torch_available():
...@@ -31,10 +30,10 @@ if is_torch_available(): ...@@ -31,10 +30,10 @@ if is_torch_available():
if is_vision_available(): if is_vision_available():
from PIL import Image from PIL import Image
from transformers import ViTFeatureExtractor from transformers import ViTImageProcessor
class ViTFeatureExtractionTester(unittest.TestCase): class ViTImageProcessingTester(unittest.TestCase):
def __init__( def __init__(
self, self,
parent, parent,
...@@ -62,7 +61,7 @@ class ViTFeatureExtractionTester(unittest.TestCase): ...@@ -62,7 +61,7 @@ class ViTFeatureExtractionTester(unittest.TestCase):
self.image_mean = image_mean self.image_mean = image_mean
self.image_std = image_std self.image_std = image_std
def prepare_feat_extract_dict(self): def prepare_image_processor_dict(self):
return { return {
"image_mean": self.image_mean, "image_mean": self.image_mean,
"image_std": self.image_std, "image_std": self.image_std,
...@@ -74,127 +73,127 @@ class ViTFeatureExtractionTester(unittest.TestCase): ...@@ -74,127 +73,127 @@ class ViTFeatureExtractionTester(unittest.TestCase):
@require_torch @require_torch
@require_vision @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): def setUp(self):
self.feature_extract_tester = ViTFeatureExtractionTester(self) self.image_processor_tester = ViTImageProcessingTester(self)
@property @property
def feat_extract_dict(self): def image_processor_dict(self):
return self.feature_extract_tester.prepare_feat_extract_dict() return self.image_processor_tester.prepare_image_processor_dict()
def test_feat_extract_properties(self): def test_image_processor_properties(self):
feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) image_processing = self.image_processing_class(**self.image_processor_dict)
self.assertTrue(hasattr(feature_extractor, "image_mean")) self.assertTrue(hasattr(image_processing, "image_mean"))
self.assertTrue(hasattr(feature_extractor, "image_std")) self.assertTrue(hasattr(image_processing, "image_std"))
self.assertTrue(hasattr(feature_extractor, "do_normalize")) self.assertTrue(hasattr(image_processing, "do_normalize"))
self.assertTrue(hasattr(feature_extractor, "do_resize")) self.assertTrue(hasattr(image_processing, "do_resize"))
self.assertTrue(hasattr(feature_extractor, "size")) self.assertTrue(hasattr(image_processing, "size"))
def test_feat_extract_from_dict_with_kwargs(self): def test_image_processor_from_dict_with_kwargs(self):
feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict) image_processor = self.image_processing_class.from_dict(self.image_processor_dict)
self.assertEqual(feature_extractor.size, {"height": 18, "width": 18}) self.assertEqual(image_processor.size, {"height": 18, "width": 18})
feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict, size=42) image_processor = self.image_processing_class.from_dict(self.image_processor_dict, size=42)
self.assertEqual(feature_extractor.size, {"height": 42, "width": 42}) self.assertEqual(image_processor.size, {"height": 42, "width": 42})
def test_batch_feature(self): def test_batch_feature(self):
pass pass
def test_call_pil(self): def test_call_pil(self):
# Initialize feature_extractor # Initialize image_processing
feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) image_processing = self.image_processing_class(**self.image_processor_dict)
# create random PIL images # 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: for image in image_inputs:
self.assertIsInstance(image, Image.Image) self.assertIsInstance(image, Image.Image)
# Test not batched input # 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( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
1, 1,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
self.feature_extract_tester.size["height"], self.image_processor_tester.size["height"],
self.feature_extract_tester.size["width"], self.image_processor_tester.size["width"],
), ),
) )
# Test batched # 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( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
self.feature_extract_tester.batch_size, self.image_processor_tester.batch_size,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
self.feature_extract_tester.size["height"], self.image_processor_tester.size["height"],
self.feature_extract_tester.size["width"], self.image_processor_tester.size["width"],
), ),
) )
def test_call_numpy(self): def test_call_numpy(self):
# Initialize feature_extractor # Initialize image_processing
feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) image_processing = self.image_processing_class(**self.image_processor_dict)
# create random numpy tensors # 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: for image in image_inputs:
self.assertIsInstance(image, np.ndarray) self.assertIsInstance(image, np.ndarray)
# Test not batched input # 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( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
1, 1,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
self.feature_extract_tester.size["height"], self.image_processor_tester.size["height"],
self.feature_extract_tester.size["width"], self.image_processor_tester.size["width"],
), ),
) )
# Test batched # 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( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
self.feature_extract_tester.batch_size, self.image_processor_tester.batch_size,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
self.feature_extract_tester.size["height"], self.image_processor_tester.size["height"],
self.feature_extract_tester.size["width"], self.image_processor_tester.size["width"],
), ),
) )
def test_call_pytorch(self): def test_call_pytorch(self):
# Initialize feature_extractor # Initialize image_processing
feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) image_processing = self.image_processing_class(**self.image_processor_dict)
# create random PyTorch tensors # 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: for image in image_inputs:
self.assertIsInstance(image, torch.Tensor) self.assertIsInstance(image, torch.Tensor)
# Test not batched input # 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( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
1, 1,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
self.feature_extract_tester.size["height"], self.image_processor_tester.size["height"],
self.feature_extract_tester.size["width"], self.image_processor_tester.size["width"],
), ),
) )
# Test batched # 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( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
self.feature_extract_tester.batch_size, self.image_processor_tester.batch_size,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
self.feature_extract_tester.size["height"], self.image_processor_tester.size["height"],
self.feature_extract_tester.size["width"], self.image_processor_tester.size["width"],
), ),
) )
tests/models/yolos/test_image_processing_yolos.py
View file @ e2bd7f80
...@@ -23,8 +23,7 @@ import numpy as np ...@@ -23,8 +23,7 @@ import numpy as np
from transformers.testing_utils import require_torch, require_vision, slow from transformers.testing_utils import require_torch, require_vision, slow
from transformers.utils import is_torch_available, is_vision_available from transformers.utils import is_torch_available, is_vision_available
from ...test_feature_extraction_common import FeatureExtractionSavingTestMixin from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs
from ...test_image_processing_common import prepare_image_inputs
if is_torch_available(): if is_torch_available():
...@@ -33,10 +32,10 @@ if is_torch_available(): ...@@ -33,10 +32,10 @@ if is_torch_available():
if is_vision_available(): if is_vision_available():
from PIL import Image from PIL import Image
from transformers import YolosFeatureExtractor from transformers import YolosImageProcessor
class YolosFeatureExtractionTester(unittest.TestCase): class YolosImageProcessingTester(unittest.TestCase):
def __init__( def __init__(
self, self,
parent, parent,
...@@ -69,7 +68,7 @@ class YolosFeatureExtractionTester(unittest.TestCase): ...@@ -69,7 +68,7 @@ class YolosFeatureExtractionTester(unittest.TestCase):
self.rescale_factor = rescale_factor self.rescale_factor = rescale_factor
self.do_pad = do_pad self.do_pad = do_pad
def prepare_feat_extract_dict(self): def prepare_image_processor_dict(self):
return { return {
"do_resize": self.do_resize, "do_resize": self.do_resize,
"size": self.size, "size": self.size,
...@@ -83,7 +82,7 @@ class YolosFeatureExtractionTester(unittest.TestCase): ...@@ -83,7 +82,7 @@ class YolosFeatureExtractionTester(unittest.TestCase):
def get_expected_values(self, image_inputs, batched=False): 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. assuming do_resize is set to True with a scalar size.
""" """
if not batched: if not batched:
...@@ -115,149 +114,149 @@ class YolosFeatureExtractionTester(unittest.TestCase): ...@@ -115,149 +114,149 @@ class YolosFeatureExtractionTester(unittest.TestCase):
@require_torch @require_torch
@require_vision @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): def setUp(self):
self.feature_extract_tester = YolosFeatureExtractionTester(self) self.image_processor_tester = YolosImageProcessingTester(self)
@property @property
def feat_extract_dict(self): def image_processor_dict(self):
return self.feature_extract_tester.prepare_feat_extract_dict() return self.image_processor_tester.prepare_image_processor_dict()
def test_feat_extract_properties(self): def test_image_processor_properties(self):
feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) image_processing = self.image_processing_class(**self.image_processor_dict)
self.assertTrue(hasattr(feature_extractor, "image_mean")) self.assertTrue(hasattr(image_processing, "image_mean"))
self.assertTrue(hasattr(feature_extractor, "image_std")) self.assertTrue(hasattr(image_processing, "image_std"))
self.assertTrue(hasattr(feature_extractor, "do_normalize")) self.assertTrue(hasattr(image_processing, "do_normalize"))
self.assertTrue(hasattr(feature_extractor, "do_resize")) self.assertTrue(hasattr(image_processing, "do_resize"))
self.assertTrue(hasattr(feature_extractor, "size")) self.assertTrue(hasattr(image_processing, "size"))
def test_feat_extract_from_dict_with_kwargs(self): def test_image_processor_from_dict_with_kwargs(self):
feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict) image_processor = self.image_processing_class.from_dict(self.image_processor_dict)
self.assertEqual(feature_extractor.size, {"shortest_edge": 18, "longest_edge": 1333}) self.assertEqual(image_processor.size, {"shortest_edge": 18, "longest_edge": 1333})
self.assertEqual(feature_extractor.do_pad, True) self.assertEqual(image_processor.do_pad, True)
feature_extractor = self.feature_extraction_class.from_dict( image_processor = self.image_processing_class.from_dict(
self.feat_extract_dict, size=42, max_size=84, pad_and_return_pixel_mask=False 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(image_processor.size, {"shortest_edge": 42, "longest_edge": 84})
self.assertEqual(feature_extractor.do_pad, False) self.assertEqual(image_processor.do_pad, False)
def test_batch_feature(self): def test_batch_feature(self):
pass pass
def test_call_pil(self): def test_call_pil(self):
# Initialize feature_extractor # Initialize image_processing
feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) image_processing = self.image_processing_class(**self.image_processor_dict)
# create random PIL images # 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: for image in image_inputs:
self.assertIsInstance(image, Image.Image) self.assertIsInstance(image, Image.Image)
# Test not batched input # 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( self.assertEqual(
encoded_images.shape, 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 # 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( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
self.feature_extract_tester.batch_size, self.image_processor_tester.batch_size,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
expected_height, expected_height,
expected_width, expected_width,
), ),
) )
def test_call_numpy(self): def test_call_numpy(self):
# Initialize feature_extractor # Initialize image_processing
feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) image_processing = self.image_processing_class(**self.image_processor_dict)
# create random numpy tensors # 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: for image in image_inputs:
self.assertIsInstance(image, np.ndarray) self.assertIsInstance(image, np.ndarray)
# Test not batched input # 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( self.assertEqual(
encoded_images.shape, 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 # 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( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
self.feature_extract_tester.batch_size, self.image_processor_tester.batch_size,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
expected_height, expected_height,
expected_width, expected_width,
), ),
) )
def test_call_pytorch(self): def test_call_pytorch(self):
# Initialize feature_extractor # Initialize image_processing
feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) image_processing = self.image_processing_class(**self.image_processor_dict)
# create random PyTorch tensors # 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: for image in image_inputs:
self.assertIsInstance(image, torch.Tensor) self.assertIsInstance(image, torch.Tensor)
# Test not batched input # 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( self.assertEqual(
encoded_images.shape, 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 # 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( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
self.feature_extract_tester.batch_size, self.image_processor_tester.batch_size,
self.feature_extract_tester.num_channels, self.image_processor_tester.num_channels,
expected_height, expected_height,
expected_width, expected_width,
), ),
) )
def test_equivalence_padding(self): def test_equivalence_padding(self):
# Initialize feature_extractors # Initialize image_processings
feature_extractor_1 = self.feature_extraction_class(**self.feat_extract_dict) image_processing_1 = self.image_processing_class(**self.image_processor_dict)
feature_extractor_2 = self.feature_extraction_class(do_resize=False, do_normalize=False, do_rescale=False) image_processing_2 = self.image_processing_class(do_resize=False, do_normalize=False, do_rescale=False)
# create random PyTorch tensors # 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: for image in image_inputs:
self.assertIsInstance(image, torch.Tensor) self.assertIsInstance(image, torch.Tensor)
# Test whether the method "pad" and calling the feature extractor return the same tensors # Test whether the method "pad" and calling the image processor return the same tensors
encoded_images_with_method = feature_extractor_1.pad(image_inputs, return_tensors="pt") encoded_images_with_method = image_processing_1.pad(image_inputs, return_tensors="pt")
encoded_images = feature_extractor_2(image_inputs, return_tensors="pt") encoded_images = image_processing_2(image_inputs, return_tensors="pt")
self.assertTrue( self.assertTrue(
torch.allclose(encoded_images_with_method["pixel_values"], encoded_images["pixel_values"], atol=1e-4) torch.allclose(encoded_images_with_method["pixel_values"], encoded_images["pixel_values"], atol=1e-4)
...@@ -273,8 +272,8 @@ class YolosFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.Test ...@@ -273,8 +272,8 @@ class YolosFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.Test
target = {"image_id": 39769, "annotations": target} target = {"image_id": 39769, "annotations": target}
# encode them # encode them
feature_extractor = YolosFeatureExtractor.from_pretrained("hustvl/yolos-small") image_processing = YolosImageProcessor.from_pretrained("hustvl/yolos-small")
encoding = feature_extractor(images=image, annotations=target, return_tensors="pt") encoding = image_processing(images=image, annotations=target, return_tensors="pt")
# verify pixel values # verify pixel values
expected_shape = torch.Size([1, 3, 800, 1066]) expected_shape = torch.Size([1, 3, 800, 1066])
...@@ -319,8 +318,8 @@ class YolosFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.Test ...@@ -319,8 +318,8 @@ class YolosFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.Test
masks_path = pathlib.Path("./tests/fixtures/tests_samples/COCO/coco_panoptic") masks_path = pathlib.Path("./tests/fixtures/tests_samples/COCO/coco_panoptic")
# encode them # encode them
feature_extractor = YolosFeatureExtractor(format="coco_panoptic") image_processing = YolosImageProcessor(format="coco_panoptic")
encoding = feature_extractor(images=image, annotations=target, masks_path=masks_path, return_tensors="pt") encoding = image_processing(images=image, annotations=target, masks_path=masks_path, return_tensors="pt")
# verify pixel values # verify pixel values
expected_shape = torch.Size([1, 3, 800, 1066]) expected_shape = torch.Size([1, 3, 800, 1066])
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment