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
Expand all Hide 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"],
), ),
) )
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