Skip to content

GitLab

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
Show whitespace changes
Inline Side-by-side
Showing with 1390 additions and 1406 deletions
tests/models/beit/test_image_processing_beit.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 BeitFeatureExtractor from transformers import BeitImageProcessor
class BeitFeatureExtractionTester(unittest.TestCase): class BeitImageProcessingTester(unittest.TestCase):
def __init__( def __init__(
self, self,
parent, parent,
...@@ -70,7 +69,7 @@ class BeitFeatureExtractionTester(unittest.TestCase): ...@@ -70,7 +69,7 @@ class BeitFeatureExtractionTester(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,
...@@ -105,166 +104,166 @@ def prepare_semantic_batch_inputs(): ...@@ -105,166 +104,166 @@ def prepare_semantic_batch_inputs():
@require_torch @require_torch
@require_vision @require_vision
class BeitFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestCase): class BeitImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase):
feature_extraction_class = BeitFeatureExtractor if is_vision_available() else None image_processing_class = BeitImageProcessor if is_vision_available() else None
def setUp(self): def setUp(self):
self.feature_extract_tester = BeitFeatureExtractionTester(self) self.image_processor_tester = BeitImageProcessingTester(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"))
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": 20, "width": 20}) self.assertEqual(image_processor.size, {"height": 20, "width": 20})
self.assertEqual(feature_extractor.crop_size, {"height": 18, "width": 18}) self.assertEqual(image_processor.crop_size, {"height": 18, "width": 18})
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.feat_extract_dict, size=42, crop_size=84, reduce_labels=True self.image_processor_dict, size=42, crop_size=84, reduce_labels=True
) )
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})
self.assertEqual(feature_extractor.do_reduce_labels, True) self.assertEqual(image_processor.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.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"],
), ),
) )
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.crop_size["height"], self.image_processor_tester.crop_size["height"],
self.feature_extract_tester.crop_size["width"], self.image_processor_tester.crop_size["width"],
), ),
) )
self.assertEqual( self.assertEqual(
encoding["labels"].shape, encoding["labels"].shape,
( (
1, 1,
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"],
), ),
) )
self.assertEqual(encoding["labels"].dtype, torch.long) self.assertEqual(encoding["labels"].dtype, torch.long)
...@@ -272,22 +271,22 @@ class BeitFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestC ...@@ -272,22 +271,22 @@ class BeitFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestC
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.crop_size["height"], self.image_processor_tester.crop_size["height"],
self.feature_extract_tester.crop_size["width"], self.image_processor_tester.crop_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.crop_size["height"], self.image_processor_tester.crop_size["height"],
self.feature_extract_tester.crop_size["width"], self.image_processor_tester.crop_size["width"],
), ),
) )
self.assertEqual(encoding["labels"].dtype, torch.long) self.assertEqual(encoding["labels"].dtype, torch.long)
...@@ -297,22 +296,22 @@ class BeitFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestC ...@@ -297,22 +296,22 @@ class BeitFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestC
# 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.crop_size["height"], self.image_processor_tester.crop_size["height"],
self.feature_extract_tester.crop_size["width"], self.image_processor_tester.crop_size["width"],
), ),
) )
self.assertEqual( self.assertEqual(
encoding["labels"].shape, encoding["labels"].shape,
( (
1, 1,
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"],
), ),
) )
self.assertEqual(encoding["labels"].dtype, torch.long) self.assertEqual(encoding["labels"].dtype, torch.long)
...@@ -322,22 +321,22 @@ class BeitFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestC ...@@ -322,22 +321,22 @@ class BeitFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestC
# 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.crop_size["height"], self.image_processor_tester.crop_size["height"],
self.feature_extract_tester.crop_size["width"], self.image_processor_tester.crop_size["width"],
), ),
) )
self.assertEqual( self.assertEqual(
encoding["labels"].shape, encoding["labels"].shape,
( (
2, 2,
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"],
), ),
) )
self.assertEqual(encoding["labels"].dtype, torch.long) self.assertEqual(encoding["labels"].dtype, torch.long)
...@@ -345,16 +344,16 @@ class BeitFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestC ...@@ -345,16 +344,16 @@ class BeitFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestC
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/blip/test_image_processing_blip.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():
...@@ -65,7 +65,7 @@ class BlipImageProcessingTester(unittest.TestCase): ...@@ -65,7 +65,7 @@ class BlipImageProcessingTester(unittest.TestCase):
self.do_pad = do_pad self.do_pad = do_pad
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,
...@@ -109,180 +109,180 @@ class BlipImageProcessingTester(unittest.TestCase): ...@@ -109,180 +109,180 @@ class BlipImageProcessingTester(unittest.TestCase):
@require_torch @require_torch
@require_vision @require_vision
class BlipImageProcessingTest(FeatureExtractionSavingTestMixin, unittest.TestCase): class BlipImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase):
feature_extraction_class = BlipImageProcessor if is_vision_available() else None image_processing_class = BlipImageProcessor if is_vision_available() else None
def setUp(self): def setUp(self):
self.feature_extract_tester = BlipImageProcessingTester(self) self.image_processor_tester = BlipImageProcessingTester(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_normalize")) self.assertTrue(hasattr(image_processor, "do_normalize"))
self.assertTrue(hasattr(feature_extractor, "image_mean")) self.assertTrue(hasattr(image_processor, "image_mean"))
self.assertTrue(hasattr(feature_extractor, "image_std")) self.assertTrue(hasattr(image_processor, "image_std"))
self.assertTrue(hasattr(feature_extractor, "do_convert_rgb")) self.assertTrue(hasattr(image_processor, "do_convert_rgb"))
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_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
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_processor(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_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
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_processor(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_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
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_processor(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"],
), ),
) )
@require_torch @require_torch
@require_vision @require_vision
class BlipImageProcessingTestFourChannels(FeatureExtractionSavingTestMixin, unittest.TestCase): class BlipImageProcessingTestFourChannels(ImageProcessingSavingTestMixin, unittest.TestCase):
feature_extraction_class = BlipImageProcessor if is_vision_available() else None image_processing_class = BlipImageProcessor if is_vision_available() else None
def setUp(self): def setUp(self):
self.feature_extract_tester = BlipImageProcessingTester(self, num_channels=4) self.image_processor_tester = BlipImageProcessingTester(self, num_channels=4)
self.expected_encoded_image_num_channels = 3 self.expected_encoded_image_num_channels = 3
@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_normalize")) self.assertTrue(hasattr(image_processor, "do_normalize"))
self.assertTrue(hasattr(feature_extractor, "image_mean")) self.assertTrue(hasattr(image_processor, "image_mean"))
self.assertTrue(hasattr(feature_extractor, "image_std")) self.assertTrue(hasattr(image_processor, "image_std"))
self.assertTrue(hasattr(feature_extractor, "do_convert_rgb")) self.assertTrue(hasattr(image_processor, "do_convert_rgb"))
def test_batch_feature(self): def test_batch_feature(self):
pass pass
def test_call_pil_four_channels(self): def test_call_pil_four_channels(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
self.assertEqual( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
1, 1,
self.expected_encoded_image_num_channels, self.expected_encoded_image_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_processor(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.expected_encoded_image_num_channels, self.expected_encoded_image_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/chinese_clip/test_image_processing_chinese_clip.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():
...@@ -30,10 +30,10 @@ if is_torch_available(): ...@@ -30,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 ChineseCLIPFeatureExtractor from transformers import ChineseCLIPImageProcessor
class ChineseCLIPFeatureExtractionTester(unittest.TestCase): class ChineseCLIPImageProcessingTester(unittest.TestCase):
def __init__( def __init__(
self, self,
parent, parent,
...@@ -68,7 +68,7 @@ class ChineseCLIPFeatureExtractionTester(unittest.TestCase): ...@@ -68,7 +68,7 @@ class ChineseCLIPFeatureExtractionTester(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,
...@@ -113,193 +113,193 @@ class ChineseCLIPFeatureExtractionTester(unittest.TestCase): ...@@ -113,193 +113,193 @@ class ChineseCLIPFeatureExtractionTester(unittest.TestCase):
@require_torch @require_torch
@require_vision @require_vision
class ChineseCLIPFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestCase): class ChineseCLIPImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase):
feature_extraction_class = ChineseCLIPFeatureExtractor if is_vision_available() else None image_processing_class = ChineseCLIPImageProcessor if is_vision_available() else None
def setUp(self): def setUp(self):
self.feature_extract_tester = ChineseCLIPFeatureExtractionTester(self, do_center_crop=True) self.image_processor_tester = ChineseCLIPImageProcessingTester(self, do_center_crop=True)
@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": 224, "width": 224}) self.assertEqual(image_processor.size, {"height": 224, "width": 224})
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 = 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_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 = 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_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 = 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_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"],
), ),
) )
@require_torch @require_torch
@require_vision @require_vision
class ChineseCLIPFeatureExtractionTestFourChannels(FeatureExtractionSavingTestMixin, unittest.TestCase): class ChineseCLIPImageProcessingTestFourChannels(ImageProcessingSavingTestMixin, unittest.TestCase):
feature_extraction_class = ChineseCLIPFeatureExtractor if is_vision_available() else None image_processing_class = ChineseCLIPImageProcessor if is_vision_available() else None
def setUp(self): def setUp(self):
self.feature_extract_tester = ChineseCLIPFeatureExtractionTester(self, num_channels=4, do_center_crop=True) self.image_processor_tester = ChineseCLIPImageProcessingTester(self, num_channels=4, do_center_crop=True)
self.expected_encoded_image_num_channels = 3 self.expected_encoded_image_num_channels = 3
@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_batch_feature(self): def test_batch_feature(self):
pass pass
def test_call_pil_four_channels(self): def test_call_pil_four_channels(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 = 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_processing(image_inputs[0], return_tensors="pt").pixel_values
self.assertEqual( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
1, 1,
self.expected_encoded_image_num_channels, self.expected_encoded_image_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.expected_encoded_image_num_channels, self.expected_encoded_image_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/clip/test_image_processing_clip.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():
...@@ -30,10 +30,10 @@ if is_torch_available(): ...@@ -30,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 CLIPFeatureExtractor from transformers import CLIPImageProcessor
class CLIPFeatureExtractionTester(unittest.TestCase): class CLIPImageProcessingTester(unittest.TestCase):
def __init__( def __init__(
self, self,
parent, parent,
...@@ -68,7 +68,7 @@ class CLIPFeatureExtractionTester(unittest.TestCase): ...@@ -68,7 +68,7 @@ class CLIPFeatureExtractionTester(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,
...@@ -113,193 +113,193 @@ class CLIPFeatureExtractionTester(unittest.TestCase): ...@@ -113,193 +113,193 @@ class CLIPFeatureExtractionTester(unittest.TestCase):
@require_torch @require_torch
@require_vision @require_vision
class CLIPFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestCase): class CLIPImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase):
feature_extraction_class = CLIPFeatureExtractor if is_vision_available() else None image_processing_class = CLIPImageProcessor if is_vision_available() else None
def setUp(self): def setUp(self):
self.feature_extract_tester = CLIPFeatureExtractionTester(self) self.image_processor_tester = CLIPImageProcessingTester(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, {"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 = 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_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 = 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_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 = 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_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"],
), ),
) )
@require_torch @require_torch
@require_vision @require_vision
class CLIPFeatureExtractionTestFourChannels(FeatureExtractionSavingTestMixin, unittest.TestCase): class CLIPImageProcessingTestFourChannels(ImageProcessingSavingTestMixin, unittest.TestCase):
feature_extraction_class = CLIPFeatureExtractor if is_vision_available() else None image_processing_class = CLIPImageProcessor if is_vision_available() else None
def setUp(self): def setUp(self):
self.feature_extract_tester = CLIPFeatureExtractionTester(self, num_channels=4) self.image_processor_tester = CLIPImageProcessingTester(self, num_channels=4)
self.expected_encoded_image_num_channels = 3 self.expected_encoded_image_num_channels = 3
@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_batch_feature(self): def test_batch_feature(self):
pass pass
def test_call_pil_four_channels(self): def test_call_pil_four_channels(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 = 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_processing(image_inputs[0], return_tensors="pt").pixel_values
self.assertEqual( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
1, 1,
self.expected_encoded_image_num_channels, self.expected_encoded_image_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.expected_encoded_image_num_channels, self.expected_encoded_image_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/conditional_detr/test_image_processing_conditional_detr.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 ConditionalDetrFeatureExtractor from transformers import ConditionalDetrImageProcessor
class ConditionalDetrFeatureExtractionTester(unittest.TestCase): class ConditionalDetrImageProcessingTester(unittest.TestCase):
def __init__( def __init__(
self, self,
parent, parent,
...@@ -69,7 +68,7 @@ class ConditionalDetrFeatureExtractionTester(unittest.TestCase): ...@@ -69,7 +68,7 @@ class ConditionalDetrFeatureExtractionTester(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 ConditionalDetrFeatureExtractionTester(unittest.TestCase): ...@@ -83,7 +82,7 @@ class ConditionalDetrFeatureExtractionTester(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 ConditionalDetrFeatureExtractor, This function computes the expected height and width when providing images to ConditionalDetrImageProcessor,
assuming do_resize is set to True with a scalar size. assuming do_resize is set to True with a scalar size.
""" """
if not batched: if not batched:
...@@ -115,149 +114,149 @@ class ConditionalDetrFeatureExtractionTester(unittest.TestCase): ...@@ -115,149 +114,149 @@ class ConditionalDetrFeatureExtractionTester(unittest.TestCase):
@require_torch @require_torch
@require_vision @require_vision
class ConditionalDetrFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestCase): class ConditionalDetrImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase):
feature_extraction_class = ConditionalDetrFeatureExtractor if is_vision_available() else None image_processing_class = ConditionalDetrImageProcessor if is_vision_available() else None
def setUp(self): def setUp(self):
self.feature_extract_tester = ConditionalDetrFeatureExtractionTester(self) self.image_processor_tester = ConditionalDetrImageProcessingTester(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_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)
...@@ -276,8 +275,8 @@ class ConditionalDetrFeatureExtractionTest(FeatureExtractionSavingTestMixin, uni ...@@ -276,8 +275,8 @@ class ConditionalDetrFeatureExtractionTest(FeatureExtractionSavingTestMixin, uni
target = {"image_id": 39769, "annotations": target} target = {"image_id": 39769, "annotations": target}
# encode them # encode them
feature_extractor = ConditionalDetrFeatureExtractor.from_pretrained("microsoft/conditional-detr-resnet-50") image_processing = ConditionalDetrImageProcessor.from_pretrained("microsoft/conditional-detr-resnet-50")
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])
...@@ -322,8 +321,8 @@ class ConditionalDetrFeatureExtractionTest(FeatureExtractionSavingTestMixin, uni ...@@ -322,8 +321,8 @@ class ConditionalDetrFeatureExtractionTest(FeatureExtractionSavingTestMixin, uni
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 = ConditionalDetrFeatureExtractor(format="coco_panoptic") image_processing = ConditionalDetrImageProcessor(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])
......
tests/models/convnext/test_image_processing_convnext.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 ConvNextFeatureExtractor from transformers import ConvNextImageProcessor
class ConvNextFeatureExtractionTester(unittest.TestCase): class ConvNextImageProcessingTester(unittest.TestCase):
def __init__( def __init__(
self, self,
parent, parent,
...@@ -64,7 +63,7 @@ class ConvNextFeatureExtractionTester(unittest.TestCase): ...@@ -64,7 +63,7 @@ class ConvNextFeatureExtractionTester(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,
...@@ -77,128 +76,128 @@ class ConvNextFeatureExtractionTester(unittest.TestCase): ...@@ -77,128 +76,128 @@ class ConvNextFeatureExtractionTester(unittest.TestCase):
@require_torch @require_torch
@require_vision @require_vision
class ConvNextFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestCase): class ConvNextImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase):
feature_extraction_class = ConvNextFeatureExtractor if is_vision_available() else None image_processing_class = ConvNextImageProcessor if is_vision_available() else None
def setUp(self): def setUp(self):
self.feature_extract_tester = ConvNextFeatureExtractionTester(self) self.image_processor_tester = ConvNextImageProcessingTester(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, "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": 20}) self.assertEqual(image_processor.size, {"shortest_edge": 20})
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
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["shortest_edge"], self.image_processor_tester.size["shortest_edge"],
self.feature_extract_tester.size["shortest_edge"], self.image_processor_tester.size["shortest_edge"],
), ),
) )
# 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["shortest_edge"], self.image_processor_tester.size["shortest_edge"],
self.feature_extract_tester.size["shortest_edge"], self.image_processor_tester.size["shortest_edge"],
), ),
) )
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["shortest_edge"], self.image_processor_tester.size["shortest_edge"],
self.feature_extract_tester.size["shortest_edge"], self.image_processor_tester.size["shortest_edge"],
), ),
) )
# 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["shortest_edge"], self.image_processor_tester.size["shortest_edge"],
self.feature_extract_tester.size["shortest_edge"], self.image_processor_tester.size["shortest_edge"],
), ),
) )
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["shortest_edge"], self.image_processor_tester.size["shortest_edge"],
self.feature_extract_tester.size["shortest_edge"], self.image_processor_tester.size["shortest_edge"],
), ),
) )
# 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["shortest_edge"], self.image_processor_tester.size["shortest_edge"],
self.feature_extract_tester.size["shortest_edge"], self.image_processor_tester.size["shortest_edge"],
), ),
) )
tests/models/deformable_detr/test_image_processing_deformable_detr.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 DeformableDetrFeatureExtractor from transformers import DeformableDetrImageProcessor
class DeformableDetrFeatureExtractionTester(unittest.TestCase): class DeformableDetrImageProcessingTester(unittest.TestCase):
def __init__( def __init__(
self, self,
parent, parent,
...@@ -69,7 +68,7 @@ class DeformableDetrFeatureExtractionTester(unittest.TestCase): ...@@ -69,7 +68,7 @@ class DeformableDetrFeatureExtractionTester(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 DeformableDetrFeatureExtractionTester(unittest.TestCase): ...@@ -83,7 +82,7 @@ class DeformableDetrFeatureExtractionTester(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 DeformableDetrFeatureExtractor, This function computes the expected height and width when providing images to DeformableDetrImageProcessor,
assuming do_resize is set to True with a scalar size. assuming do_resize is set to True with a scalar size.
""" """
if not batched: if not batched:
...@@ -115,152 +114,152 @@ class DeformableDetrFeatureExtractionTester(unittest.TestCase): ...@@ -115,152 +114,152 @@ class DeformableDetrFeatureExtractionTester(unittest.TestCase):
@require_torch @require_torch
@require_vision @require_vision
class DeformableDetrFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestCase): class DeformableDetrImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase):
feature_extraction_class = DeformableDetrFeatureExtractor if is_vision_available() else None image_processing_class = DeformableDetrImageProcessor if is_vision_available() else None
def setUp(self): def setUp(self):
self.feature_extract_tester = DeformableDetrFeatureExtractionTester(self) self.image_processor_tester = DeformableDetrImageProcessingTester(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_rescale")) self.assertTrue(hasattr(image_processing, "do_rescale"))
self.assertTrue(hasattr(feature_extractor, "do_pad")) self.assertTrue(hasattr(image_processing, "do_pad"))
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_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)
...@@ -279,8 +278,8 @@ class DeformableDetrFeatureExtractionTest(FeatureExtractionSavingTestMixin, unit ...@@ -279,8 +278,8 @@ class DeformableDetrFeatureExtractionTest(FeatureExtractionSavingTestMixin, unit
target = {"image_id": 39769, "annotations": target} target = {"image_id": 39769, "annotations": target}
# encode them # encode them
feature_extractor = DeformableDetrFeatureExtractor() image_processing = DeformableDetrImageProcessor()
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])
...@@ -325,8 +324,8 @@ class DeformableDetrFeatureExtractionTest(FeatureExtractionSavingTestMixin, unit ...@@ -325,8 +324,8 @@ class DeformableDetrFeatureExtractionTest(FeatureExtractionSavingTestMixin, unit
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 = DeformableDetrFeatureExtractor(format="coco_panoptic") image_processing = DeformableDetrImageProcessor(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])
......
tests/models/deit/test_image_processing_deit.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 DeiTFeatureExtractor from transformers import DeiTImageProcessor
class DeiTFeatureExtractionTester(unittest.TestCase): class DeiTImageProcessingTester(unittest.TestCase):
def __init__( def __init__(
self, self,
parent, parent,
...@@ -68,7 +67,7 @@ class DeiTFeatureExtractionTester(unittest.TestCase): ...@@ -68,7 +67,7 @@ class DeiTFeatureExtractionTester(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 {
"do_resize": self.do_resize, "do_resize": self.do_resize,
"size": self.size, "size": self.size,
...@@ -82,132 +81,132 @@ class DeiTFeatureExtractionTester(unittest.TestCase): ...@@ -82,132 +81,132 @@ class DeiTFeatureExtractionTester(unittest.TestCase):
@require_torch @require_torch
@require_vision @require_vision
class DeiTFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestCase): class DeiTImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase):
feature_extraction_class = DeiTFeatureExtractor if is_vision_available() else None image_processing_class = DeiTImageProcessor if is_vision_available() else None
test_cast_dtype = True test_cast_dtype = True
def setUp(self): def setUp(self):
self.feature_extract_tester = DeiTFeatureExtractionTester(self) self.image_processor_tester = DeiTImageProcessingTester(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"))
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": 20, "width": 20}) self.assertEqual(image_processor.size, {"height": 20, "width": 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, {"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_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/detr/test_image_processing_detr.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 DetrFeatureExtractor from transformers import DetrImageProcessor
class DetrFeatureExtractionTester(unittest.TestCase): class DetrImageProcessingTester(unittest.TestCase):
def __init__( def __init__(
self, self,
parent, parent,
...@@ -69,7 +68,7 @@ class DetrFeatureExtractionTester(unittest.TestCase): ...@@ -69,7 +68,7 @@ class DetrFeatureExtractionTester(unittest.TestCase):
self.image_std = image_std self.image_std = image_std
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 DetrFeatureExtractionTester(unittest.TestCase): ...@@ -83,7 +82,7 @@ class DetrFeatureExtractionTester(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 DetrFeatureExtractor, This function computes the expected height and width when providing images to DetrImageProcessor,
assuming do_resize is set to True with a scalar size. assuming do_resize is set to True with a scalar size.
""" """
if not batched: if not batched:
...@@ -115,152 +114,152 @@ class DetrFeatureExtractionTester(unittest.TestCase): ...@@ -115,152 +114,152 @@ class DetrFeatureExtractionTester(unittest.TestCase):
@require_torch @require_torch
@require_vision @require_vision
class DetrFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestCase): class DetrImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase):
feature_extraction_class = DetrFeatureExtractor if is_vision_available() else None image_processing_class = DetrImageProcessor if is_vision_available() else None
def setUp(self): def setUp(self):
self.feature_extract_tester = DetrFeatureExtractionTester(self) self.image_processor_tester = DetrImageProcessingTester(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_rescale")) self.assertTrue(hasattr(image_processing, "do_rescale"))
self.assertTrue(hasattr(feature_extractor, "rescale_factor")) self.assertTrue(hasattr(image_processing, "rescale_factor"))
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_pad")) self.assertTrue(hasattr(image_processing, "do_pad"))
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_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)
...@@ -279,8 +278,8 @@ class DetrFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestC ...@@ -279,8 +278,8 @@ class DetrFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestC
target = {"image_id": 39769, "annotations": target} target = {"image_id": 39769, "annotations": target}
# encode them # encode them
feature_extractor = DetrFeatureExtractor.from_pretrained("facebook/detr-resnet-50") image_processing = DetrImageProcessor.from_pretrained("facebook/detr-resnet-50")
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])
...@@ -325,8 +324,8 @@ class DetrFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestC ...@@ -325,8 +324,8 @@ class DetrFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestC
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 = DetrFeatureExtractor.from_pretrained("facebook/detr-resnet-50-panoptic") image_processing = DetrImageProcessor.from_pretrained("facebook/detr-resnet-50-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])
......
tests/models/donut/test_image_processing_donut.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 is_flaky, require_torch, require_vision from transformers.testing_utils import is_flaky, 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 DonutFeatureExtractor from transformers import DonutImageProcessor
class DonutFeatureExtractionTester(unittest.TestCase): class DonutImageProcessingTester(unittest.TestCase):
def __init__( def __init__(
self, self,
parent, parent,
...@@ -67,7 +66,7 @@ class DonutFeatureExtractionTester(unittest.TestCase): ...@@ -67,7 +66,7 @@ class DonutFeatureExtractionTester(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 {
"do_resize": self.do_resize, "do_resize": self.do_resize,
"size": self.size, "size": self.size,
...@@ -82,137 +81,137 @@ class DonutFeatureExtractionTester(unittest.TestCase): ...@@ -82,137 +81,137 @@ class DonutFeatureExtractionTester(unittest.TestCase):
@require_torch @require_torch
@require_vision @require_vision
class DonutFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestCase): class DonutImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase):
feature_extraction_class = DonutFeatureExtractor if is_vision_available() else None image_processing_class = DonutImageProcessor if is_vision_available() else None
def setUp(self): def setUp(self):
self.feature_extract_tester = DonutFeatureExtractionTester(self) self.image_processor_tester = DonutImageProcessingTester(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_thumbnail")) self.assertTrue(hasattr(image_processing, "do_thumbnail"))
self.assertTrue(hasattr(feature_extractor, "do_align_long_axis")) self.assertTrue(hasattr(image_processing, "do_align_long_axis"))
self.assertTrue(hasattr(feature_extractor, "do_pad")) self.assertTrue(hasattr(image_processing, "do_pad"))
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, {"height": 18, "width": 20}) self.assertEqual(image_processor.size, {"height": 18, "width": 20})
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})
# Previous config had dimensions in (width, height) order # Previous config had dimensions in (width, height) order
feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict, size=(42, 84)) image_processor = self.image_processing_class.from_dict(self.image_processor_dict, size=(42, 84))
self.assertEqual(feature_extractor.size, {"height": 84, "width": 42}) self.assertEqual(image_processor.size, {"height": 84, "width": 42})
def test_batch_feature(self): def test_batch_feature(self):
pass pass
@is_flaky() @is_flaky()
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"],
), ),
) )
@is_flaky() @is_flaky()
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"],
), ),
) )
@is_flaky() @is_flaky()
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/dpt/test_image_processing_dpt.py
View file @ e2bd7f80
...@@ -21,8 +21,7 @@ import numpy as np ...@@ -21,8 +21,7 @@ import numpy as np
from transformers.file_utils import is_torch_available, is_vision_available from transformers.file_utils import is_torch_available, is_vision_available
from transformers.testing_utils import require_torch, require_vision from transformers.testing_utils import require_torch, require_vision
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 DPTFeatureExtractor from transformers import DPTImageProcessor
class DPTFeatureExtractionTester(unittest.TestCase): class DPTImageProcessingTester(unittest.TestCase):
def __init__( def __init__(
self, self,
parent, parent,
...@@ -62,7 +61,7 @@ class DPTFeatureExtractionTester(unittest.TestCase): ...@@ -62,7 +61,7 @@ class DPTFeatureExtractionTester(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,124 +73,124 @@ class DPTFeatureExtractionTester(unittest.TestCase): ...@@ -74,124 +73,124 @@ class DPTFeatureExtractionTester(unittest.TestCase):
@require_torch @require_torch
@require_vision @require_vision
class DPTFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestCase): class DPTImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase):
feature_extraction_class = DPTFeatureExtractor if is_vision_available() else None image_processing_class = DPTImageProcessor if is_vision_available() else None
def setUp(self): def setUp(self):
self.feature_extract_tester = DPTFeatureExtractionTester(self) self.image_processor_tester = DPTImageProcessingTester(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_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/efficientformer/test_image_processing_efficientformer.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,7 +30,7 @@ if is_torch_available(): ...@@ -31,7 +30,7 @@ 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 EfficientFormerImageProcessorTester(unittest.TestCase): class EfficientFormerImageProcessorTester(unittest.TestCase):
...@@ -62,7 +61,7 @@ class EfficientFormerImageProcessorTester(unittest.TestCase): ...@@ -62,7 +61,7 @@ class EfficientFormerImageProcessorTester(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,120 +73,120 @@ class EfficientFormerImageProcessorTester(unittest.TestCase): ...@@ -74,120 +73,120 @@ class EfficientFormerImageProcessorTester(unittest.TestCase):
@require_torch @require_torch
@require_vision @require_vision
class EfficientFormerImageProcessorTest(FeatureExtractionSavingTestMixin, unittest.TestCase): class EfficientFormerImageProcessorTest(ImageProcessingSavingTestMixin, unittest.TestCase):
feature_extraction_class = ViTFeatureExtractor if is_vision_available() else None image_processing_class = ViTImageProcessor if is_vision_available() else None
def setUp(self): def setUp(self):
self.feature_extract_tester = EfficientFormerImageProcessorTester(self) self.image_proc_tester = EfficientFormerImageProcessorTester(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_proc_tester.prepare_image_processor_dict()
def test_feat_extract_properties(self): def test_image_proc_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, "image_mean")) self.assertTrue(hasattr(image_processor, "image_mean"))
self.assertTrue(hasattr(feature_extractor, "image_std")) self.assertTrue(hasattr(image_processor, "image_std"))
self.assertTrue(hasattr(feature_extractor, "do_normalize")) self.assertTrue(hasattr(image_processor, "do_normalize"))
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"))
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_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 = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False) image_inputs = prepare_image_inputs(self.image_proc_tester, equal_resolution=False)
for image in image_inputs: 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
self.assertEqual( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
1, 1,
self.feature_extract_tester.num_channels, self.image_proc_tester.num_channels,
self.feature_extract_tester.size["height"], self.image_proc_tester.size["height"],
self.feature_extract_tester.size["width"], self.image_proc_tester.size["width"],
), ),
) )
# Test batched # Test batched
encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values encoded_images = image_processor(image_inputs, return_tensors="pt").pixel_values
self.assertEqual( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
self.feature_extract_tester.batch_size, self.image_proc_tester.batch_size,
self.feature_extract_tester.num_channels, self.image_proc_tester.num_channels,
self.feature_extract_tester.size["height"], self.image_proc_tester.size["height"],
self.feature_extract_tester.size["width"], self.image_proc_tester.size["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 = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, numpify=True) image_inputs = prepare_image_inputs(self.image_proc_tester, equal_resolution=False, numpify=True)
for image in image_inputs: 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
self.assertEqual( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
1, 1,
self.feature_extract_tester.num_channels, self.image_proc_tester.num_channels,
self.feature_extract_tester.size["height"], self.image_proc_tester.size["height"],
self.feature_extract_tester.size["width"], self.image_proc_tester.size["width"],
), ),
) )
# Test batched # Test batched
encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values encoded_images = image_processor(image_inputs, return_tensors="pt").pixel_values
self.assertEqual( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
self.feature_extract_tester.batch_size, self.image_proc_tester.batch_size,
self.feature_extract_tester.num_channels, self.image_proc_tester.num_channels,
self.feature_extract_tester.size["height"], self.image_proc_tester.size["height"],
self.feature_extract_tester.size["width"], self.image_proc_tester.size["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 = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, torchify=True) image_inputs = prepare_image_inputs(self.image_proc_tester, equal_resolution=False, torchify=True)
for image in image_inputs: 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
self.assertEqual( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
1, 1,
self.feature_extract_tester.num_channels, self.image_proc_tester.num_channels,
self.feature_extract_tester.size["height"], self.image_proc_tester.size["height"],
self.feature_extract_tester.size["width"], self.image_proc_tester.size["width"],
), ),
) )
# Test batched # Test batched
encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values encoded_images = image_processor(image_inputs, return_tensors="pt").pixel_values
self.assertEqual( self.assertEqual(
encoded_images.shape, encoded_images.shape,
( (
self.feature_extract_tester.batch_size, self.image_proc_tester.batch_size,
self.feature_extract_tester.num_channels, self.image_proc_tester.num_channels,
self.feature_extract_tester.size["height"], self.image_proc_tester.size["height"],
self.feature_extract_tester.size["width"], self.image_proc_tester.size["width"],
), ),
) )
tests/models/flava/test_image_processing_flava.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,7 +30,7 @@ if is_torch_available(): ...@@ -31,7 +30,7 @@ if is_torch_available():
if is_vision_available(): if is_vision_available():
import PIL import PIL
from transformers import FlavaFeatureExtractor from transformers import FlavaImageProcessor
from transformers.image_utils import PILImageResampling from transformers.image_utils import PILImageResampling
from transformers.models.flava.image_processing_flava import ( from transformers.models.flava.image_processing_flava import (
FLAVA_CODEBOOK_MEAN, FLAVA_CODEBOOK_MEAN,
...@@ -43,7 +42,7 @@ else: ...@@ -43,7 +42,7 @@ else:
FLAVA_IMAGE_MEAN = FLAVA_IMAGE_STD = FLAVA_CODEBOOK_MEAN = FLAVA_CODEBOOK_STD = None FLAVA_IMAGE_MEAN = FLAVA_IMAGE_STD = FLAVA_CODEBOOK_MEAN = FLAVA_CODEBOOK_STD = None
class FlavaFeatureExtractionTester(unittest.TestCase): class FlavaImageProcessingTester(unittest.TestCase):
def __init__( def __init__(
self, self,
parent, parent,
...@@ -115,7 +114,7 @@ class FlavaFeatureExtractionTester(unittest.TestCase): ...@@ -115,7 +114,7 @@ class FlavaFeatureExtractionTester(unittest.TestCase):
self.codebook_image_mean = codebook_image_mean self.codebook_image_mean = codebook_image_mean
self.codebook_image_std = codebook_image_std self.codebook_image_std = codebook_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,
...@@ -160,82 +159,82 @@ class FlavaFeatureExtractionTester(unittest.TestCase): ...@@ -160,82 +159,82 @@ class FlavaFeatureExtractionTester(unittest.TestCase):
@require_torch @require_torch
@require_vision @require_vision
class FlavaFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestCase): class FlavaImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase):
feature_extraction_class = FlavaFeatureExtractor if is_vision_available() else None image_processing_class = FlavaImageProcessor if is_vision_available() else None
maxDiff = None maxDiff = None
def setUp(self): def setUp(self):
self.feature_extract_tester = FlavaFeatureExtractionTester(self) self.image_processor_tester = FlavaImageProcessingTester(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, "resample")) self.assertTrue(hasattr(image_processing, "resample"))
self.assertTrue(hasattr(feature_extractor, "crop_size")) self.assertTrue(hasattr(image_processing, "crop_size"))
self.assertTrue(hasattr(feature_extractor, "do_center_crop")) self.assertTrue(hasattr(image_processing, "do_center_crop"))
self.assertTrue(hasattr(feature_extractor, "do_rescale")) self.assertTrue(hasattr(image_processing, "do_rescale"))
self.assertTrue(hasattr(feature_extractor, "rescale_factor")) self.assertTrue(hasattr(image_processing, "rescale_factor"))
self.assertTrue(hasattr(feature_extractor, "masking_generator")) self.assertTrue(hasattr(image_processing, "masking_generator"))
self.assertTrue(hasattr(feature_extractor, "codebook_do_resize")) self.assertTrue(hasattr(image_processing, "codebook_do_resize"))
self.assertTrue(hasattr(feature_extractor, "codebook_size")) self.assertTrue(hasattr(image_processing, "codebook_size"))
self.assertTrue(hasattr(feature_extractor, "codebook_resample")) self.assertTrue(hasattr(image_processing, "codebook_resample"))
self.assertTrue(hasattr(feature_extractor, "codebook_do_center_crop")) self.assertTrue(hasattr(image_processing, "codebook_do_center_crop"))
self.assertTrue(hasattr(feature_extractor, "codebook_crop_size")) self.assertTrue(hasattr(image_processing, "codebook_crop_size"))
self.assertTrue(hasattr(feature_extractor, "codebook_do_map_pixels")) self.assertTrue(hasattr(image_processing, "codebook_do_map_pixels"))
self.assertTrue(hasattr(feature_extractor, "codebook_do_normalize")) self.assertTrue(hasattr(image_processing, "codebook_do_normalize"))
self.assertTrue(hasattr(feature_extractor, "codebook_image_mean")) self.assertTrue(hasattr(image_processing, "codebook_image_mean"))
self.assertTrue(hasattr(feature_extractor, "codebook_image_std")) self.assertTrue(hasattr(image_processing, "codebook_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, {"height": 224, "width": 224}) self.assertEqual(image_processor.size, {"height": 224, "width": 224})
self.assertEqual(feature_extractor.crop_size, {"height": 224, "width": 224}) self.assertEqual(image_processor.crop_size, {"height": 224, "width": 224})
self.assertEqual(feature_extractor.codebook_size, {"height": 112, "width": 112}) self.assertEqual(image_processor.codebook_size, {"height": 112, "width": 112})
self.assertEqual(feature_extractor.codebook_crop_size, {"height": 112, "width": 112}) self.assertEqual(image_processor.codebook_crop_size, {"height": 112, "width": 112})
feature_extractor = self.feature_extraction_class.from_dict( image_processor = self.image_processing_class.from_dict(
self.feat_extract_dict, size=42, crop_size=84, codebook_size=33, codebook_crop_size=66 self.image_processor_dict, size=42, crop_size=84, codebook_size=33, codebook_crop_size=66
) )
self.assertEqual(feature_extractor.size, {"height": 42, "width": 42}) self.assertEqual(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})
self.assertEqual(feature_extractor.codebook_size, {"height": 33, "width": 33}) self.assertEqual(image_processor.codebook_size, {"height": 33, "width": 33})
self.assertEqual(feature_extractor.codebook_crop_size, {"height": 66, "width": 66}) self.assertEqual(image_processor.codebook_crop_size, {"height": 66, "width": 66})
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, PIL.Image.Image) self.assertIsInstance(image, PIL.Image.Image)
# Test not batched input # Test not batched input
encoded_images = feature_extractor(image_inputs[0], return_tensors="pt") encoded_images = image_processing(image_inputs[0], return_tensors="pt")
# Test no bool masked pos # Test no bool masked pos
self.assertFalse("bool_masked_pos" in encoded_images) self.assertFalse("bool_masked_pos" in encoded_images)
expected_height, expected_width = self.feature_extract_tester.get_expected_image_size() expected_height, expected_width = self.image_processor_tester.get_expected_image_size()
self.assertEqual( self.assertEqual(
encoded_images.pixel_values.shape, encoded_images.pixel_values.shape,
(1, self.feature_extract_tester.num_channels, expected_height, expected_width), (1, self.image_processor_tester.num_channels, expected_height, expected_width),
) )
# Test batched # Test batched
encoded_images = feature_extractor(image_inputs, return_tensors="pt") encoded_images = image_processing(image_inputs, return_tensors="pt")
expected_height, expected_width = self.feature_extract_tester.get_expected_image_size() expected_height, expected_width = self.image_processor_tester.get_expected_image_size()
# Test no bool masked pos # Test no bool masked pos
self.assertFalse("bool_masked_pos" in encoded_images) self.assertFalse("bool_masked_pos" in encoded_images)
...@@ -243,86 +242,86 @@ class FlavaFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.Test ...@@ -243,86 +242,86 @@ class FlavaFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.Test
self.assertEqual( self.assertEqual(
encoded_images.pixel_values.shape, encoded_images.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,
expected_height, expected_height,
expected_width, expected_width,
), ),
) )
def _test_call_framework(self, instance_class, prepare_kwargs): def _test_call_framework(self, instance_class, prepare_kwargs):
# 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 tensors # create random tensors
image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, **prepare_kwargs) image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, **prepare_kwargs)
for image in image_inputs: for image in image_inputs:
self.assertIsInstance(image, instance_class) self.assertIsInstance(image, instance_class)
# Test not batched input # Test not batched input
encoded_images = feature_extractor(image_inputs[0], return_tensors="pt") encoded_images = image_processing(image_inputs[0], return_tensors="pt")
expected_height, expected_width = self.feature_extract_tester.get_expected_image_size() expected_height, expected_width = self.image_processor_tester.get_expected_image_size()
self.assertEqual( self.assertEqual(
encoded_images.pixel_values.shape, encoded_images.pixel_values.shape,
(1, self.feature_extract_tester.num_channels, expected_height, expected_width), (1, self.image_processor_tester.num_channels, expected_height, expected_width),
) )
encoded_images = feature_extractor(image_inputs, return_image_mask=True, return_tensors="pt") encoded_images = image_processing(image_inputs, return_image_mask=True, return_tensors="pt")
expected_height, expected_width = self.feature_extract_tester.get_expected_image_size() expected_height, expected_width = self.image_processor_tester.get_expected_image_size()
self.assertEqual( self.assertEqual(
encoded_images.pixel_values.shape, encoded_images.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,
expected_height, expected_height,
expected_width, expected_width,
), ),
) )
expected_height, expected_width = self.feature_extract_tester.get_expected_mask_size() expected_height, expected_width = self.image_processor_tester.get_expected_mask_size()
self.assertEqual( self.assertEqual(
encoded_images.bool_masked_pos.shape, encoded_images.bool_masked_pos.shape,
( (
self.feature_extract_tester.batch_size, self.image_processor_tester.batch_size,
expected_height, expected_height,
expected_width, 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_image_size() expected_height, expected_width = self.image_processor_tester.get_expected_image_size()
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,
), ),
) )
# Test masking # Test masking
encoded_images = feature_extractor(image_inputs, return_image_mask=True, return_tensors="pt") encoded_images = image_processing(image_inputs, return_image_mask=True, return_tensors="pt")
expected_height, expected_width = self.feature_extract_tester.get_expected_image_size() expected_height, expected_width = self.image_processor_tester.get_expected_image_size()
self.assertEqual( self.assertEqual(
encoded_images.pixel_values.shape, encoded_images.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,
expected_height, expected_height,
expected_width, expected_width,
), ),
) )
expected_height, expected_width = self.feature_extract_tester.get_expected_mask_size() expected_height, expected_width = self.image_processor_tester.get_expected_mask_size()
self.assertEqual( self.assertEqual(
encoded_images.bool_masked_pos.shape, encoded_images.bool_masked_pos.shape,
( (
self.feature_extract_tester.batch_size, self.image_processor_tester.batch_size,
expected_height, expected_height,
expected_width, expected_width,
), ),
...@@ -335,39 +334,39 @@ class FlavaFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.Test ...@@ -335,39 +334,39 @@ class FlavaFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.Test
self._test_call_framework(torch.Tensor, prepare_kwargs={"torchify": True}) self._test_call_framework(torch.Tensor, prepare_kwargs={"torchify": True})
def test_masking(self): def test_masking(self):
# Initialize feature_extractor # Initialize image_processing
random.seed(1234) random.seed(1234)
feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) image_processing = self.image_processing_class(**self.image_processor_dict)
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)
# Test not batched input # Test not batched input
encoded_images = feature_extractor(image_inputs[0], return_image_mask=True, return_tensors="pt") encoded_images = image_processing(image_inputs[0], return_image_mask=True, return_tensors="pt")
self.assertEqual(encoded_images.bool_masked_pos.sum().item(), 75) self.assertEqual(encoded_images.bool_masked_pos.sum().item(), 75)
def test_codebook_pixels(self): def test_codebook_pixels(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, PIL.Image.Image) self.assertIsInstance(image, PIL.Image.Image)
# Test not batched input # Test not batched input
encoded_images = feature_extractor(image_inputs[0], return_codebook_pixels=True, return_tensors="pt") encoded_images = image_processing(image_inputs[0], return_codebook_pixels=True, return_tensors="pt")
expected_height, expected_width = self.feature_extract_tester.get_expected_codebook_image_size() expected_height, expected_width = self.image_processor_tester.get_expected_codebook_image_size()
self.assertEqual( self.assertEqual(
encoded_images.codebook_pixel_values.shape, encoded_images.codebook_pixel_values.shape,
(1, self.feature_extract_tester.num_channels, expected_height, expected_width), (1, self.image_processor_tester.num_channels, expected_height, expected_width),
) )
# Test batched # Test batched
encoded_images = feature_extractor(image_inputs, return_codebook_pixels=True, return_tensors="pt") encoded_images = image_processing(image_inputs, return_codebook_pixels=True, return_tensors="pt")
expected_height, expected_width = self.feature_extract_tester.get_expected_codebook_image_size() expected_height, expected_width = self.image_processor_tester.get_expected_codebook_image_size()
self.assertEqual( self.assertEqual(
encoded_images.codebook_pixel_values.shape, encoded_images.codebook_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,
expected_height, expected_height,
expected_width, expected_width,
), ),
......
tests/models/glpn/test_image_processing_glpn.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 GLPNFeatureExtractor from transformers import GLPNImageProcessor
class GLPNFeatureExtractionTester(unittest.TestCase): class GLPNImageProcessingTester(unittest.TestCase):
def __init__( def __init__(
self, self,
parent, parent,
...@@ -57,7 +56,7 @@ class GLPNFeatureExtractionTester(unittest.TestCase): ...@@ -57,7 +56,7 @@ class GLPNFeatureExtractionTester(unittest.TestCase):
self.size_divisor = size_divisor self.size_divisor = size_divisor
self.do_rescale = do_rescale self.do_rescale = do_rescale
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_divisor": self.size_divisor, "size_divisor": self.size_divisor,
...@@ -67,62 +66,62 @@ class GLPNFeatureExtractionTester(unittest.TestCase): ...@@ -67,62 +66,62 @@ class GLPNFeatureExtractionTester(unittest.TestCase):
@require_torch @require_torch
@require_vision @require_vision
class GLPNFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestCase): class GLPNImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase):
feature_extraction_class = GLPNFeatureExtractor if is_vision_available() else None image_processing_class = GLPNImageProcessor if is_vision_available() else None
def setUp(self): def setUp(self):
self.feature_extract_tester = GLPNFeatureExtractionTester(self) self.image_processor_tester = GLPNImageProcessingTester(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_divisor")) self.assertTrue(hasattr(image_processing, "size_divisor"))
self.assertTrue(hasattr(feature_extractor, "resample")) self.assertTrue(hasattr(image_processing, "resample"))
self.assertTrue(hasattr(feature_extractor, "do_rescale")) self.assertTrue(hasattr(image_processing, "do_rescale"))
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 (GLPNFeatureExtractor doesn't support batching) # Test not batched input (GLPNImageProcessor doesn't support batching)
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.assertTrue(encoded_images.shape[-1] % self.feature_extract_tester.size_divisor == 0) self.assertTrue(encoded_images.shape[-1] % self.image_processor_tester.size_divisor == 0)
self.assertTrue(encoded_images.shape[-2] % self.feature_extract_tester.size_divisor == 0) self.assertTrue(encoded_images.shape[-2] % self.image_processor_tester.size_divisor == 0)
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 (GLPNFeatureExtractor doesn't support batching) # Test not batched input (GLPNImageProcessor doesn't support batching)
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.assertTrue(encoded_images.shape[-1] % self.feature_extract_tester.size_divisor == 0) self.assertTrue(encoded_images.shape[-1] % self.image_processor_tester.size_divisor == 0)
self.assertTrue(encoded_images.shape[-2] % self.feature_extract_tester.size_divisor == 0) self.assertTrue(encoded_images.shape[-2] % self.image_processor_tester.size_divisor == 0)
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 (GLPNFeatureExtractor doesn't support batching) # Test not batched input (GLPNImageProcessor doesn't support batching)
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.assertTrue(encoded_images.shape[-1] % self.feature_extract_tester.size_divisor == 0) self.assertTrue(encoded_images.shape[-1] % self.image_processor_tester.size_divisor == 0)
self.assertTrue(encoded_images.shape[-2] % self.feature_extract_tester.size_divisor == 0) self.assertTrue(encoded_images.shape[-2] % self.image_processor_tester.size_divisor == 0)
tests/models/imagegpt/test_image_processing_imagegpt.py
View file @ e2bd7f80
...@@ -25,7 +25,7 @@ from datasets import load_dataset ...@@ -25,7 +25,7 @@ from datasets import load_dataset
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
if is_torch_available(): if is_torch_available():
...@@ -34,10 +34,10 @@ if is_torch_available(): ...@@ -34,10 +34,10 @@ if is_torch_available():
if is_vision_available(): if is_vision_available():
from PIL import Image from PIL import Image
from transformers import ImageGPTFeatureExtractor from transformers import ImageGPTImageProcessor
class ImageGPTFeatureExtractionTester(unittest.TestCase): class ImageGPTImageProcessingTester(unittest.TestCase):
def __init__( def __init__(
self, self,
parent, parent,
...@@ -61,7 +61,7 @@ class ImageGPTFeatureExtractionTester(unittest.TestCase): ...@@ -61,7 +61,7 @@ class ImageGPTFeatureExtractionTester(unittest.TestCase):
self.size = size self.size = size
self.do_normalize = do_normalize self.do_normalize = do_normalize
def prepare_feat_extract_dict(self): def prepare_image_processor_dict(self):
return { return {
# here we create 2 clusters for the sake of simplicity # here we create 2 clusters for the sake of simplicity
"clusters": np.asarray( "clusters": np.asarray(
...@@ -78,68 +78,68 @@ class ImageGPTFeatureExtractionTester(unittest.TestCase): ...@@ -78,68 +78,68 @@ class ImageGPTFeatureExtractionTester(unittest.TestCase):
@require_torch @require_torch
@require_vision @require_vision
class ImageGPTFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestCase): class ImageGPTImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase):
feature_extraction_class = ImageGPTFeatureExtractor if is_vision_available() else None image_processing_class = ImageGPTImageProcessor if is_vision_available() else None
def setUp(self): def setUp(self):
self.feature_extract_tester = ImageGPTFeatureExtractionTester(self) self.image_processor_tester = ImageGPTImageProcessingTester(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, "clusters")) self.assertTrue(hasattr(image_processing, "clusters"))
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"))
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_feat_extract_to_json_string(self): def test_image_processor_to_json_string(self):
feat_extract = self.feature_extraction_class(**self.feat_extract_dict) image_processor = self.image_processing_class(**self.image_processor_dict)
obj = json.loads(feat_extract.to_json_string()) obj = json.loads(image_processor.to_json_string())
for key, value in self.feat_extract_dict.items(): for key, value in self.image_processor_dict.items():
if key == "clusters": if key == "clusters":
self.assertTrue(np.array_equal(value, obj[key])) self.assertTrue(np.array_equal(value, obj[key]))
else: else:
self.assertEqual(obj[key], value) self.assertEqual(obj[key], value)
def test_feat_extract_to_json_file(self): def test_image_processor_to_json_file(self):
feat_extract_first = self.feature_extraction_class(**self.feat_extract_dict) image_processor_first = self.image_processing_class(**self.image_processor_dict)
with tempfile.TemporaryDirectory() as tmpdirname: with tempfile.TemporaryDirectory() as tmpdirname:
json_file_path = os.path.join(tmpdirname, "feat_extract.json") json_file_path = os.path.join(tmpdirname, "image_processor.json")
feat_extract_first.to_json_file(json_file_path) image_processor_first.to_json_file(json_file_path)
feat_extract_second = self.feature_extraction_class.from_json_file(json_file_path).to_dict() image_processor_second = self.image_processing_class.from_json_file(json_file_path).to_dict()
feat_extract_first = feat_extract_first.to_dict() image_processor_first = image_processor_first.to_dict()
for key, value in feat_extract_first.items(): for key, value in image_processor_first.items():
if key == "clusters": if key == "clusters":
self.assertTrue(np.array_equal(value, feat_extract_second[key])) self.assertTrue(np.array_equal(value, image_processor_second[key]))
else: else:
self.assertEqual(feat_extract_first[key], value) self.assertEqual(image_processor_first[key], value)
def test_feat_extract_from_and_save_pretrained(self): def test_image_processor_from_and_save_pretrained(self):
feat_extract_first = self.feature_extraction_class(**self.feat_extract_dict) image_processor_first = self.image_processing_class(**self.image_processor_dict)
with tempfile.TemporaryDirectory() as tmpdirname: with tempfile.TemporaryDirectory() as tmpdirname:
feat_extract_first.save_pretrained(tmpdirname) image_processor_first.save_pretrained(tmpdirname)
feat_extract_second = self.feature_extraction_class.from_pretrained(tmpdirname).to_dict() image_processor_second = self.image_processing_class.from_pretrained(tmpdirname).to_dict()
feat_extract_first = feat_extract_first.to_dict() image_processor_first = image_processor_first.to_dict()
for key, value in feat_extract_first.items(): for key, value in image_processor_first.items():
if key == "clusters": if key == "clusters":
self.assertTrue(np.array_equal(value, feat_extract_second[key])) self.assertTrue(np.array_equal(value, image_processor_second[key]))
else: else:
self.assertEqual(feat_extract_first[key], value) self.assertEqual(image_processor_first[key], value)
@unittest.skip("ImageGPT requires clusters at initialization") @unittest.skip("ImageGPT requires clusters at initialization")
def test_init_without_params(self): def test_init_without_params(self):
...@@ -159,15 +159,15 @@ def prepare_images(): ...@@ -159,15 +159,15 @@ def prepare_images():
@require_vision @require_vision
@require_torch @require_torch
class ImageGPTFeatureExtractorIntegrationTest(unittest.TestCase): class ImageGPTImageProcessorIntegrationTest(unittest.TestCase):
@slow @slow
def test_image(self): def test_image(self):
feature_extractor = ImageGPTFeatureExtractor.from_pretrained("openai/imagegpt-small") image_processing = ImageGPTImageProcessor.from_pretrained("openai/imagegpt-small")
images = prepare_images() images = prepare_images()
# test non-batched # test non-batched
encoding = feature_extractor(images[0], return_tensors="pt") encoding = image_processing(images[0], return_tensors="pt")
self.assertIsInstance(encoding.input_ids, torch.LongTensor) self.assertIsInstance(encoding.input_ids, torch.LongTensor)
self.assertEqual(encoding.input_ids.shape, (1, 1024)) self.assertEqual(encoding.input_ids.shape, (1, 1024))
...@@ -176,7 +176,7 @@ class ImageGPTFeatureExtractorIntegrationTest(unittest.TestCase): ...@@ -176,7 +176,7 @@ class ImageGPTFeatureExtractorIntegrationTest(unittest.TestCase):
self.assertEqual(encoding.input_ids[0, :3].tolist(), expected_slice) self.assertEqual(encoding.input_ids[0, :3].tolist(), expected_slice)
# test batched # test batched
encoding = feature_extractor(images, return_tensors="pt") encoding = image_processing(images, return_tensors="pt")
self.assertIsInstance(encoding.input_ids, torch.LongTensor) self.assertIsInstance(encoding.input_ids, torch.LongTensor)
self.assertEqual(encoding.input_ids.shape, (2, 1024)) self.assertEqual(encoding.input_ids.shape, (2, 1024))
......
tests/models/layoutlmv2/test_image_processing_layoutlmv2.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_pytesseract, require_torch from transformers.testing_utils import require_pytesseract, require_torch
from transformers.utils import is_pytesseract_available, is_torch_available from transformers.utils import is_pytesseract_available, is_torch_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_pytesseract_available(): if is_pytesseract_available():
from PIL import Image from PIL import Image
from transformers import LayoutLMv2FeatureExtractor from transformers import LayoutLMv2ImageProcessor
class LayoutLMv2FeatureExtractionTester(unittest.TestCase): class LayoutLMv2ImageProcessingTester(unittest.TestCase):
def __init__( def __init__(
self, self,
parent, parent,
...@@ -58,56 +57,56 @@ class LayoutLMv2FeatureExtractionTester(unittest.TestCase): ...@@ -58,56 +57,56 @@ class LayoutLMv2FeatureExtractionTester(unittest.TestCase):
self.size = size self.size = size
self.apply_ocr = apply_ocr self.apply_ocr = apply_ocr
def prepare_feat_extract_dict(self): def prepare_image_processor_dict(self):
return {"do_resize": self.do_resize, "size": self.size, "apply_ocr": self.apply_ocr} return {"do_resize": self.do_resize, "size": self.size, "apply_ocr": self.apply_ocr}
@require_torch @require_torch
@require_pytesseract @require_pytesseract
class LayoutLMv2FeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestCase): class LayoutLMv2ImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase):
feature_extraction_class = LayoutLMv2FeatureExtractor if is_pytesseract_available() else None image_processing_class = LayoutLMv2ImageProcessor if is_pytesseract_available() else None
def setUp(self): def setUp(self):
self.feature_extract_tester = LayoutLMv2FeatureExtractionTester(self) self.image_processor_tester = LayoutLMv2ImageProcessingTester(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, "apply_ocr")) self.assertTrue(hasattr(image_processing, "apply_ocr"))
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
encoding = feature_extractor(image_inputs[0], return_tensors="pt") encoding = image_processing(image_inputs[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"],
), ),
) )
...@@ -115,84 +114,84 @@ class LayoutLMv2FeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest ...@@ -115,84 +114,84 @@ class LayoutLMv2FeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest
self.assertIsInstance(encoding.boxes, list) self.assertIsInstance(encoding.boxes, list)
# 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_layoutlmv2_integration_test(self): def test_layoutlmv2_integration_test(self):
# with apply_OCR = True # with apply_OCR = True
feature_extractor = LayoutLMv2FeatureExtractor() image_processing = LayoutLMv2ImageProcessor()
from datasets import load_dataset from datasets import load_dataset
...@@ -200,7 +199,7 @@ class LayoutLMv2FeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest ...@@ -200,7 +199,7 @@ class LayoutLMv2FeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest
image = Image.open(ds[0]["file"]).convert("RGB") image = Image.open(ds[0]["file"]).convert("RGB")
encoding = feature_extractor(image, return_tensors="pt") encoding = image_processing(image, return_tensors="pt")
self.assertEqual(encoding.pixel_values.shape, (1, 3, 224, 224)) self.assertEqual(encoding.pixel_values.shape, (1, 3, 224, 224))
self.assertEqual(len(encoding.words), len(encoding.boxes)) self.assertEqual(len(encoding.words), len(encoding.boxes))
...@@ -215,8 +214,8 @@ class LayoutLMv2FeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest ...@@ -215,8 +214,8 @@ class LayoutLMv2FeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest
self.assertListEqual(encoding.boxes, expected_boxes) self.assertListEqual(encoding.boxes, expected_boxes)
# with apply_OCR = False # with apply_OCR = False
feature_extractor = LayoutLMv2FeatureExtractor(apply_ocr=False) image_processing = LayoutLMv2ImageProcessor(apply_ocr=False)
encoding = feature_extractor(image, return_tensors="pt") encoding = image_processing(image, return_tensors="pt")
self.assertEqual(encoding.pixel_values.shape, (1, 3, 224, 224)) self.assertEqual(encoding.pixel_values.shape, (1, 3, 224, 224))
tests/models/layoutlmv3/test_image_processing_layoutlmv3.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_pytesseract, require_torch from transformers.testing_utils import require_pytesseract, require_torch
from transformers.utils import is_pytesseract_available, is_torch_available from transformers.utils import is_pytesseract_available, is_torch_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_pytesseract_available(): if is_pytesseract_available():
from PIL import Image from PIL import Image
from transformers import LayoutLMv3FeatureExtractor from transformers import LayoutLMv3ImageProcessor
class LayoutLMv3FeatureExtractionTester(unittest.TestCase): class LayoutLMv3ImageProcessingTester(unittest.TestCase):
def __init__( def __init__(
self, self,
parent, parent,
...@@ -58,56 +57,56 @@ class LayoutLMv3FeatureExtractionTester(unittest.TestCase): ...@@ -58,56 +57,56 @@ class LayoutLMv3FeatureExtractionTester(unittest.TestCase):
self.size = size self.size = size
self.apply_ocr = apply_ocr self.apply_ocr = apply_ocr
def prepare_feat_extract_dict(self): def prepare_image_processor_dict(self):
return {"do_resize": self.do_resize, "size": self.size, "apply_ocr": self.apply_ocr} return {"do_resize": self.do_resize, "size": self.size, "apply_ocr": self.apply_ocr}
@require_torch @require_torch
@require_pytesseract @require_pytesseract
class LayoutLMv3FeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestCase): class LayoutLMv3ImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase):
feature_extraction_class = LayoutLMv3FeatureExtractor if is_pytesseract_available() else None image_processing_class = LayoutLMv3ImageProcessor if is_pytesseract_available() else None
def setUp(self): def setUp(self):
self.feature_extract_tester = LayoutLMv3FeatureExtractionTester(self) self.image_processor_tester = LayoutLMv3ImageProcessingTester(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, "apply_ocr")) self.assertTrue(hasattr(image_processing, "apply_ocr"))
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
encoding = feature_extractor(image_inputs[0], return_tensors="pt") encoding = image_processing(image_inputs[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"],
), ),
) )
...@@ -115,84 +114,84 @@ class LayoutLMv3FeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest ...@@ -115,84 +114,84 @@ class LayoutLMv3FeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest
self.assertIsInstance(encoding.boxes, list) self.assertIsInstance(encoding.boxes, list)
# 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_LayoutLMv3_integration_test(self): def test_LayoutLMv3_integration_test(self):
# with apply_OCR = True # with apply_OCR = True
feature_extractor = LayoutLMv3FeatureExtractor() image_processing = LayoutLMv3ImageProcessor()
from datasets import load_dataset from datasets import load_dataset
...@@ -200,7 +199,7 @@ class LayoutLMv3FeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest ...@@ -200,7 +199,7 @@ class LayoutLMv3FeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest
image = Image.open(ds[0]["file"]).convert("RGB") image = Image.open(ds[0]["file"]).convert("RGB")
encoding = feature_extractor(image, return_tensors="pt") encoding = image_processing(image, return_tensors="pt")
self.assertEqual(encoding.pixel_values.shape, (1, 3, 224, 224)) self.assertEqual(encoding.pixel_values.shape, (1, 3, 224, 224))
self.assertEqual(len(encoding.words), len(encoding.boxes)) self.assertEqual(len(encoding.words), len(encoding.boxes))
...@@ -215,8 +214,8 @@ class LayoutLMv3FeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest ...@@ -215,8 +214,8 @@ class LayoutLMv3FeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest
self.assertListEqual(encoding.boxes, expected_boxes) self.assertListEqual(encoding.boxes, expected_boxes)
# with apply_OCR = False # with apply_OCR = False
feature_extractor = LayoutLMv3FeatureExtractor(apply_ocr=False) image_processing = LayoutLMv3ImageProcessor(apply_ocr=False)
encoding = feature_extractor(image, return_tensors="pt") encoding = image_processing(image, return_tensors="pt")
self.assertEqual(encoding.pixel_values.shape, (1, 3, 224, 224)) self.assertEqual(encoding.pixel_values.shape, (1, 3, 224, 224))
tests/models/levit/test_image_processing_levit.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 LevitFeatureExtractor from transformers import LevitImageProcessor
class LevitFeatureExtractionTester(unittest.TestCase): class LevitImageProcessingTester(unittest.TestCase):
def __init__( def __init__(
self, self,
parent, parent,
...@@ -67,7 +66,7 @@ class LevitFeatureExtractionTester(unittest.TestCase): ...@@ -67,7 +66,7 @@ class LevitFeatureExtractionTester(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,
...@@ -81,130 +80,130 @@ class LevitFeatureExtractionTester(unittest.TestCase): ...@@ -81,130 +80,130 @@ class LevitFeatureExtractionTester(unittest.TestCase):
@require_torch @require_torch
@require_vision @require_vision
class LevitFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestCase): class LevitImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase):
feature_extraction_class = LevitFeatureExtractor if is_vision_available() else None image_processing_class = LevitImageProcessor if is_vision_available() else None
def setUp(self): def setUp(self):
self.feature_extract_tester = LevitFeatureExtractionTester(self) self.image_processor_tester = LevitImageProcessingTester(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 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/maskformer/test_image_processing_maskformer.py
View file @ e2bd7f80
...@@ -23,15 +23,14 @@ from huggingface_hub import hf_hub_download ...@@ -23,15 +23,14 @@ 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():
import torch import torch
if is_vision_available(): if is_vision_available():
from transformers import MaskFormerFeatureExtractor from transformers import MaskFormerImageProcessor
from transformers.models.maskformer.image_processing_maskformer import binary_mask_to_rle from transformers.models.maskformer.image_processing_maskformer import binary_mask_to_rle
from transformers.models.maskformer.modeling_maskformer import MaskFormerForInstanceSegmentationOutput from transformers.models.maskformer.modeling_maskformer import MaskFormerForInstanceSegmentationOutput
...@@ -39,7 +38,7 @@ if is_vision_available(): ...@@ -39,7 +38,7 @@ if is_vision_available():
from PIL import Image from PIL import Image
class MaskFormerFeatureExtractionTester(unittest.TestCase): class MaskFormerImageProcessingTester(unittest.TestCase):
def __init__( def __init__(
self, self,
parent, parent,
...@@ -77,7 +76,7 @@ class MaskFormerFeatureExtractionTester(unittest.TestCase): ...@@ -77,7 +76,7 @@ class MaskFormerFeatureExtractionTester(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,
...@@ -92,7 +91,7 @@ class MaskFormerFeatureExtractionTester(unittest.TestCase): ...@@ -92,7 +91,7 @@ class MaskFormerFeatureExtractionTester(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 MaskFormerFeatureExtractor, This function computes the expected height and width when providing images to MaskFormerImageProcessor,
assuming do_resize is set to True with a scalar size. assuming do_resize is set to True with a scalar size.
""" """
if not batched: if not batched:
...@@ -131,154 +130,154 @@ class MaskFormerFeatureExtractionTester(unittest.TestCase): ...@@ -131,154 +130,154 @@ class MaskFormerFeatureExtractionTester(unittest.TestCase):
@require_torch @require_torch
@require_vision @require_vision
class MaskFormerFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestCase): class MaskFormerImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase):
feature_extraction_class = MaskFormerFeatureExtractor if (is_vision_available() and is_torch_available()) else None image_processing_class = MaskFormerImageProcessor if (is_vision_available() and is_torch_available()) else None
def setUp(self): def setUp(self):
self.feature_extract_tester = MaskFormerFeatureExtractionTester(self) self.image_processor_tester = MaskFormerImageProcessingTester(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, "max_size")) self.assertTrue(hasattr(image_processing, "max_size"))
self.assertTrue(hasattr(feature_extractor, "ignore_index")) self.assertTrue(hasattr(image_processing, "ignore_index"))
self.assertTrue(hasattr(feature_extractor, "num_labels")) self.assertTrue(hasattr(image_processing, "num_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, {"shortest_edge": 32, "longest_edge": 1333}) self.assertEqual(image_processor.size, {"shortest_edge": 32, "longest_edge": 1333})
self.assertEqual(feature_extractor.size_divisor, 0) self.assertEqual(image_processor.size_divisor, 0)
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, size_divisibility=8 self.image_processor_dict, size=42, max_size=84, size_divisibility=8
) )
self.assertEqual(feature_extractor.size, {"shortest_edge": 42, "longest_edge": 84}) self.assertEqual(image_processor.size, {"shortest_edge": 42, "longest_edge": 84})
self.assertEqual(feature_extractor.size_divisor, 8) self.assertEqual(image_processor.size_divisor, 8)
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_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( image_processing_2 = self.image_processing_class(
do_resize=False, do_normalize=False, do_rescale=False, num_labels=self.feature_extract_tester.num_classes do_resize=False, do_normalize=False, do_rescale=False, num_labels=self.image_processor_tester.num_classes
) )
# 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.encode_inputs(image_inputs, return_tensors="pt") encoded_images_with_method = image_processing_1.encode_inputs(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)
...@@ -287,15 +286,15 @@ class MaskFormerFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest ...@@ -287,15 +286,15 @@ class MaskFormerFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest
torch.allclose(encoded_images_with_method["pixel_mask"], encoded_images["pixel_mask"], atol=1e-4) torch.allclose(encoded_images_with_method["pixel_mask"], encoded_images["pixel_mask"], atol=1e-4)
) )
def comm_get_feature_extractor_inputs( def comm_get_image_processing_inputs(
self, with_segmentation_maps=False, is_instance_map=False, segmentation_type="np" self, with_segmentation_maps=False, is_instance_map=False, segmentation_type="np"
): ):
feature_extractor = self.feature_extraction_class(**self.feat_extract_dict) image_processing = self.image_processing_class(**self.image_processor_dict)
# prepare image and target # prepare image and target
num_labels = self.feature_extract_tester.num_labels num_labels = self.image_processor_tester.num_labels
annotations = None annotations = None
instance_id_to_semantic_id = None instance_id_to_semantic_id = None
image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False) image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False)
if with_segmentation_maps: if with_segmentation_maps:
high = num_labels high = num_labels
if is_instance_map: if is_instance_map:
...@@ -309,7 +308,7 @@ class MaskFormerFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest ...@@ -309,7 +308,7 @@ class MaskFormerFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest
if segmentation_type == "pil": if segmentation_type == "pil":
annotations = [Image.fromarray(annotation) for annotation in annotations] annotations = [Image.fromarray(annotation) for annotation in annotations]
inputs = feature_extractor( inputs = image_processing(
image_inputs, image_inputs,
annotations, annotations,
return_tensors="pt", return_tensors="pt",
...@@ -326,10 +325,10 @@ class MaskFormerFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest ...@@ -326,10 +325,10 @@ class MaskFormerFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest
size_divisors = [8, 16, 32] size_divisors = [8, 16, 32]
weird_input_sizes = [(407, 802), (582, 1094)] weird_input_sizes = [(407, 802), (582, 1094)]
for size_divisor in size_divisors: for size_divisor in size_divisors:
feat_extract_dict = {**self.feat_extract_dict, **{"size_divisor": size_divisor}} image_processor_dict = {**self.image_processor_dict, **{"size_divisor": size_divisor}}
feature_extractor = self.feature_extraction_class(**feat_extract_dict) image_processing = self.image_processing_class(**image_processor_dict)
for weird_input_size in weird_input_sizes: for weird_input_size in weird_input_sizes:
inputs = feature_extractor([np.ones((3, *weird_input_size))], return_tensors="pt") inputs = image_processing([np.ones((3, *weird_input_size))], return_tensors="pt")
pixel_values = inputs["pixel_values"] pixel_values = inputs["pixel_values"]
# check if divisible # check if divisible
self.assertTrue((pixel_values.shape[-1] % size_divisor) == 0) self.assertTrue((pixel_values.shape[-1] % size_divisor) == 0)
...@@ -337,7 +336,7 @@ class MaskFormerFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest ...@@ -337,7 +336,7 @@ class MaskFormerFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest
def test_call_with_segmentation_maps(self): def test_call_with_segmentation_maps(self):
def common(is_instance_map=False, segmentation_type=None): def common(is_instance_map=False, segmentation_type=None):
inputs = self.comm_get_feature_extractor_inputs( inputs = self.comm_get_image_processing_inputs(
with_segmentation_maps=True, is_instance_map=is_instance_map, segmentation_type=segmentation_type with_segmentation_maps=True, is_instance_map=is_instance_map, segmentation_type=segmentation_type
) )
...@@ -389,11 +388,11 @@ class MaskFormerFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest ...@@ -389,11 +388,11 @@ class MaskFormerFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest
instance_seg1, inst2class1 = get_instance_segmentation_and_mapping(annotation1) instance_seg1, inst2class1 = get_instance_segmentation_and_mapping(annotation1)
instance_seg2, inst2class2 = get_instance_segmentation_and_mapping(annotation2) instance_seg2, inst2class2 = get_instance_segmentation_and_mapping(annotation2)
# create a feature extractor # create a image processor
feature_extractor = MaskFormerFeatureExtractor(reduce_labels=True, ignore_index=255, size=(512, 512)) image_processing = MaskFormerImageProcessor(reduce_labels=True, ignore_index=255, size=(512, 512))
# prepare the images and annotations # prepare the images and annotations
inputs = feature_extractor( inputs = image_processing(
[image1, image2], [image1, image2],
[instance_seg1, instance_seg2], [instance_seg1, instance_seg2],
instance_id_to_semantic_id=[inst2class1, inst2class2], instance_id_to_semantic_id=[inst2class1, inst2class2],
...@@ -432,11 +431,11 @@ class MaskFormerFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest ...@@ -432,11 +431,11 @@ class MaskFormerFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest
hf_hub_download(repo_id=repo_id, filename="semantic_segmentation_annotation_2.png", repo_type="dataset") hf_hub_download(repo_id=repo_id, filename="semantic_segmentation_annotation_2.png", repo_type="dataset")
) )
# create a feature extractor # create a image processor
feature_extractor = MaskFormerFeatureExtractor(reduce_labels=True, ignore_index=255, size=(512, 512)) image_processing = MaskFormerImageProcessor(reduce_labels=True, ignore_index=255, size=(512, 512))
# prepare the images and annotations # prepare the images and annotations
inputs = feature_extractor( inputs = image_processing(
[image1, image2], [image1, image2],
[annotation1, annotation2], [annotation1, annotation2],
return_tensors="pt", return_tensors="pt",
...@@ -489,12 +488,12 @@ class MaskFormerFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest ...@@ -489,12 +488,12 @@ class MaskFormerFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest
panoptic_map1, inst2class1 = create_panoptic_map(annotation1, segments_info1) panoptic_map1, inst2class1 = create_panoptic_map(annotation1, segments_info1)
panoptic_map2, inst2class2 = create_panoptic_map(annotation2, segments_info2) panoptic_map2, inst2class2 = create_panoptic_map(annotation2, segments_info2)
# create a feature extractor # create a image processor
feature_extractor = MaskFormerFeatureExtractor(ignore_index=0, do_resize=False) image_processing = MaskFormerImageProcessor(ignore_index=0, do_resize=False)
# prepare the images and annotations # prepare the images and annotations
pixel_values_list = [np.moveaxis(np.array(image1), -1, 0), np.moveaxis(np.array(image2), -1, 0)] pixel_values_list = [np.moveaxis(np.array(image1), -1, 0), np.moveaxis(np.array(image2), -1, 0)]
inputs = feature_extractor.encode_inputs( inputs = image_processing.encode_inputs(
pixel_values_list, pixel_values_list,
[panoptic_map1, panoptic_map2], [panoptic_map1, panoptic_map2],
instance_id_to_semantic_id=[inst2class1, inst2class2], instance_id_to_semantic_id=[inst2class1, inst2class2],
...@@ -535,17 +534,17 @@ class MaskFormerFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest ...@@ -535,17 +534,17 @@ class MaskFormerFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest
self.assertEqual(rle[1], 45) self.assertEqual(rle[1], 45)
def test_post_process_segmentation(self): def test_post_process_segmentation(self):
fature_extractor = self.feature_extraction_class(num_labels=self.feature_extract_tester.num_classes) fature_extractor = self.image_processing_class(num_labels=self.image_processor_tester.num_classes)
outputs = self.feature_extract_tester.get_fake_maskformer_outputs() outputs = self.image_processor_tester.get_fake_maskformer_outputs()
segmentation = fature_extractor.post_process_segmentation(outputs) segmentation = fature_extractor.post_process_segmentation(outputs)
self.assertEqual( self.assertEqual(
segmentation.shape, segmentation.shape,
( (
self.feature_extract_tester.batch_size, self.image_processor_tester.batch_size,
self.feature_extract_tester.num_classes, self.image_processor_tester.num_classes,
self.feature_extract_tester.height, self.image_processor_tester.height,
self.feature_extract_tester.width, self.image_processor_tester.width,
), ),
) )
...@@ -554,53 +553,53 @@ class MaskFormerFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest ...@@ -554,53 +553,53 @@ class MaskFormerFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest
self.assertEqual( self.assertEqual(
segmentation.shape, segmentation.shape,
(self.feature_extract_tester.batch_size, self.feature_extract_tester.num_classes, *target_size), (self.image_processor_tester.batch_size, self.image_processor_tester.num_classes, *target_size),
) )
def test_post_process_semantic_segmentation(self): def test_post_process_semantic_segmentation(self):
fature_extractor = self.feature_extraction_class(num_labels=self.feature_extract_tester.num_classes) fature_extractor = self.image_processing_class(num_labels=self.image_processor_tester.num_classes)
outputs = self.feature_extract_tester.get_fake_maskformer_outputs() outputs = self.image_processor_tester.get_fake_maskformer_outputs()
segmentation = fature_extractor.post_process_semantic_segmentation(outputs) segmentation = fature_extractor.post_process_semantic_segmentation(outputs)
self.assertEqual(len(segmentation), self.feature_extract_tester.batch_size) self.assertEqual(len(segmentation), self.image_processor_tester.batch_size)
self.assertEqual( self.assertEqual(
segmentation[0].shape, segmentation[0].shape,
( (
self.feature_extract_tester.height, self.image_processor_tester.height,
self.feature_extract_tester.width, self.image_processor_tester.width,
), ),
) )
target_sizes = [(1, 4) for i in range(self.feature_extract_tester.batch_size)] target_sizes = [(1, 4) for i in range(self.image_processor_tester.batch_size)]
segmentation = fature_extractor.post_process_semantic_segmentation(outputs, target_sizes=target_sizes) segmentation = fature_extractor.post_process_semantic_segmentation(outputs, target_sizes=target_sizes)
self.assertEqual(segmentation[0].shape, target_sizes[0]) self.assertEqual(segmentation[0].shape, target_sizes[0])
def test_post_process_panoptic_segmentation(self): def test_post_process_panoptic_segmentation(self):
feature_extractor = self.feature_extraction_class(num_labels=self.feature_extract_tester.num_classes) image_processing = self.image_processing_class(num_labels=self.image_processor_tester.num_classes)
outputs = self.feature_extract_tester.get_fake_maskformer_outputs() outputs = self.image_processor_tester.get_fake_maskformer_outputs()
segmentation = feature_extractor.post_process_panoptic_segmentation(outputs, threshold=0) segmentation = image_processing.post_process_panoptic_segmentation(outputs, threshold=0)
self.assertTrue(len(segmentation) == self.feature_extract_tester.batch_size) self.assertTrue(len(segmentation) == self.image_processor_tester.batch_size)
for el in segmentation: for el in segmentation:
self.assertTrue("segmentation" in el) self.assertTrue("segmentation" in el)
self.assertTrue("segments_info" in el) self.assertTrue("segments_info" in el)
self.assertEqual(type(el["segments_info"]), list) self.assertEqual(type(el["segments_info"]), list)
self.assertEqual( self.assertEqual(
el["segmentation"].shape, (self.feature_extract_tester.height, self.feature_extract_tester.width) el["segmentation"].shape, (self.image_processor_tester.height, self.image_processor_tester.width)
) )
def test_post_process_label_fusing(self): def test_post_process_label_fusing(self):
feature_extractor = self.feature_extraction_class(num_labels=self.feature_extract_tester.num_classes) image_processor = self.image_processing_class(num_labels=self.image_processor_tester.num_classes)
outputs = self.feature_extract_tester.get_fake_maskformer_outputs() outputs = self.image_processor_tester.get_fake_maskformer_outputs()
segmentation = feature_extractor.post_process_panoptic_segmentation( segmentation = image_processor.post_process_panoptic_segmentation(
outputs, threshold=0, mask_threshold=0, overlap_mask_area_threshold=0 outputs, threshold=0, mask_threshold=0, overlap_mask_area_threshold=0
) )
unfused_segments = [el["segments_info"] for el in segmentation] unfused_segments = [el["segments_info"] for el in segmentation]
fused_segmentation = feature_extractor.post_process_panoptic_segmentation( fused_segmentation = image_processor.post_process_panoptic_segmentation(
outputs, threshold=0, mask_threshold=0, overlap_mask_area_threshold=0, label_ids_to_fuse={1} outputs, threshold=0, mask_threshold=0, overlap_mask_area_threshold=0, label_ids_to_fuse={1}
) )
fused_segments = [el["segments_info"] for el in fused_segmentation] fused_segments = [el["segments_info"] for el in fused_segmentation]
......
tests/models/mobilenet_v1/test_image_processing_mobilenet_v1.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 MobileNetV1FeatureExtractor from transformers import MobileNetV1ImageProcessor
class MobileNetV1FeatureExtractionTester(unittest.TestCase): class MobileNetV1ImageProcessingTester(unittest.TestCase):
def __init__( def __init__(
self, self,
parent, parent,
...@@ -61,7 +60,7 @@ class MobileNetV1FeatureExtractionTester(unittest.TestCase): ...@@ -61,7 +60,7 @@ class MobileNetV1FeatureExtractionTester(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 MobileNetV1FeatureExtractionTester(unittest.TestCase): ...@@ -72,128 +71,128 @@ class MobileNetV1FeatureExtractionTester(unittest.TestCase):
@require_torch @require_torch
@require_vision @require_vision
class MobileNetV1FeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestCase): class MobileNetV1ImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase):
feature_extraction_class = MobileNetV1FeatureExtractor if is_vision_available() else None image_processing_class = MobileNetV1ImageProcessor if is_vision_available() else None
def setUp(self): def setUp(self):
self.feature_extract_tester = MobileNetV1FeatureExtractionTester(self) self.image_processor_tester = MobileNetV1ImageProcessingTester(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"))
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"],
), ),
) )
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