Skip to content

GitLab

"...lm-evaluation-harness.git" did not exist on "966b70eafc667412d43caf9215447d4e7d89a3cc"
Unverified Commit 41d56ea6 authored by amyeroberts's avatar amyeroberts Committed by GitHub
Browse files

Refactor image processor testers (#25450) 

* Refactor image processor test mixin

- Move test_call_numpy, test_call_pytorch, test_call_pil to mixin
- Rename mixin to reflect handling of logic more than saving
- Add prepare_image_inputs, expected_image_outputs for tests

* Fix for oneformer
parent 454957c9
Hide whitespace changes
Inline Side-by-side
Showing with 416 additions and 1647 deletions
tests/models/levit/test_image_processing_levit.py
View file @ 41d56ea6
...@@ -16,20 +16,13 @@ ...@@ -16,20 +16,13 @@
import unittest import unittest
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_vision_available
from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs
from ...test_image_processing_common import ImageProcessingTestMixin, prepare_image_inputs
if is_torch_available():
import torch
if is_vision_available(): if is_vision_available():
from PIL import Image
from transformers import LevitImageProcessor from transformers import LevitImageProcessor
...@@ -77,10 +70,24 @@ class LevitImageProcessingTester(unittest.TestCase): ...@@ -77,10 +70,24 @@ class LevitImageProcessingTester(unittest.TestCase):
"crop_size": self.crop_size, "crop_size": self.crop_size,
} }
def expected_output_image_shape(self, images):
return self.num_channels, self.crop_size["height"], self.crop_size["width"]
def prepare_image_inputs(self, equal_resolution=False, numpify=False, torchify=False):
return prepare_image_inputs(
batch_size=self.batch_size,
num_channels=self.num_channels,
min_resolution=self.min_resolution,
max_resolution=self.max_resolution,
equal_resolution=equal_resolution,
numpify=numpify,
torchify=torchify,
)
@require_torch @require_torch
@require_vision @require_vision
class LevitImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase): class LevitImageProcessingTest(ImageProcessingTestMixin, unittest.TestCase):
image_processing_class = LevitImageProcessor if is_vision_available() else None image_processing_class = LevitImageProcessor if is_vision_available() else None
def setUp(self): def setUp(self):
...@@ -107,102 +114,3 @@ class LevitImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase ...@@ -107,102 +114,3 @@ class LevitImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase
image_processor = self.image_processing_class.from_dict(self.image_processor_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(image_processor.size, {"shortest_edge": 42}) self.assertEqual(image_processor.size, {"shortest_edge": 42})
self.assertEqual(image_processor.crop_size, {"height": 84, "width": 84}) self.assertEqual(image_processor.crop_size, {"height": 84, "width": 84})
def test_batch_feature(self):
pass
def test_call_pil(self):
# Initialize image_processing
image_processing = self.image_processing_class(**self.image_processor_dict)
# create random PIL images
image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False)
for image in image_inputs:
self.assertIsInstance(image, Image.Image)
# Test not batched input
encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
1,
self.image_processor_tester.num_channels,
self.image_processor_tester.crop_size["height"],
self.image_processor_tester.crop_size["width"],
),
)
# Test batched
encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
self.image_processor_tester.batch_size,
self.image_processor_tester.num_channels,
self.image_processor_tester.crop_size["height"],
self.image_processor_tester.crop_size["width"],
),
)
def test_call_numpy(self):
# Initialize image_processing
image_processing = self.image_processing_class(**self.image_processor_dict)
# create random numpy tensors
image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, numpify=True)
for image in image_inputs:
self.assertIsInstance(image, np.ndarray)
# Test not batched input
encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
1,
self.image_processor_tester.num_channels,
self.image_processor_tester.crop_size["height"],
self.image_processor_tester.crop_size["width"],
),
)
# Test batched
encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
self.image_processor_tester.batch_size,
self.image_processor_tester.num_channels,
self.image_processor_tester.crop_size["height"],
self.image_processor_tester.crop_size["width"],
),
)
def test_call_pytorch(self):
# Initialize image_processing
image_processing = self.image_processing_class(**self.image_processor_dict)
# create random PyTorch tensors
image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, torchify=True)
for image in image_inputs:
self.assertIsInstance(image, torch.Tensor)
# Test not batched input
encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
1,
self.image_processor_tester.num_channels,
self.image_processor_tester.crop_size["height"],
self.image_processor_tester.crop_size["width"],
),
)
# Test batched
encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
self.image_processor_tester.batch_size,
self.image_processor_tester.num_channels,
self.image_processor_tester.crop_size["height"],
self.image_processor_tester.crop_size["width"],
),
)
tests/models/mask2former/test_image_processing_mask2former.py
View file @ 41d56ea6
...@@ -23,7 +23,7 @@ from huggingface_hub import hf_hub_download ...@@ -23,7 +23,7 @@ from huggingface_hub import hf_hub_download
from transformers.testing_utils import require_torch, require_vision from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available from transformers.utils import is_torch_available, is_vision_available
from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs from ...test_image_processing_common import ImageProcessingTestMixin, prepare_image_inputs
if is_torch_available(): if is_torch_available():
...@@ -127,10 +127,25 @@ class Mask2FormerImageProcessingTester(unittest.TestCase): ...@@ -127,10 +127,25 @@ class Mask2FormerImageProcessingTester(unittest.TestCase):
masks_queries_logits=torch.randn((self.batch_size, self.num_queries, self.height, self.width)), masks_queries_logits=torch.randn((self.batch_size, self.num_queries, self.height, self.width)),
) )
def expected_output_image_shape(self, images):
height, width = self.get_expected_values(images, batched=True)
return self.num_channels, height, width
def prepare_image_inputs(self, equal_resolution=False, numpify=False, torchify=False):
return prepare_image_inputs(
batch_size=self.batch_size,
num_channels=self.num_channels,
min_resolution=self.min_resolution,
max_resolution=self.max_resolution,
equal_resolution=equal_resolution,
numpify=numpify,
torchify=torchify,
)
@require_torch @require_torch
@require_vision @require_vision
class Mask2FormerImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase): class Mask2FormerImageProcessingTest(ImageProcessingTestMixin, unittest.TestCase):
image_processing_class = Mask2FormerImageProcessor if (is_vision_available() and is_torch_available()) else None image_processing_class = Mask2FormerImageProcessor if (is_vision_available() and is_torch_available()) else None
def setUp(self): def setUp(self):
...@@ -161,107 +176,6 @@ class Mask2FormerImageProcessingTest(ImageProcessingSavingTestMixin, unittest.Te ...@@ -161,107 +176,6 @@ class Mask2FormerImageProcessingTest(ImageProcessingSavingTestMixin, unittest.Te
self.assertEqual(image_processor.size, {"shortest_edge": 42, "longest_edge": 84}) self.assertEqual(image_processor.size, {"shortest_edge": 42, "longest_edge": 84})
self.assertEqual(image_processor.size_divisor, 8) self.assertEqual(image_processor.size_divisor, 8)
def test_batch_feature(self):
pass
def test_call_pil(self):
# Initialize image_processing
image_processing = self.image_processing_class(**self.image_processor_dict)
# create random PIL images
image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False)
for image in image_inputs:
self.assertIsInstance(image, Image.Image)
# Test not batched input
encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values
expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs)
self.assertEqual(
encoded_images.shape,
(1, self.image_processor_tester.num_channels, expected_height, expected_width),
)
# Test batched
expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs, batched=True)
encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
self.image_processor_tester.batch_size,
self.image_processor_tester.num_channels,
expected_height,
expected_width,
),
)
def test_call_numpy(self):
# Initialize image_processing
image_processing = self.image_processing_class(**self.image_processor_dict)
# create random numpy tensors
image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, numpify=True)
for image in image_inputs:
self.assertIsInstance(image, np.ndarray)
# Test not batched input
encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values
expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs)
self.assertEqual(
encoded_images.shape,
(1, self.image_processor_tester.num_channels, expected_height, expected_width),
)
# Test batched
encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values
expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs, batched=True)
self.assertEqual(
encoded_images.shape,
(
self.image_processor_tester.batch_size,
self.image_processor_tester.num_channels,
expected_height,
expected_width,
),
)
def test_call_pytorch(self):
# Initialize image_processing
image_processing = self.image_processing_class(**self.image_processor_dict)
# create random PyTorch tensors
image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, torchify=True)
for image in image_inputs:
self.assertIsInstance(image, torch.Tensor)
# Test not batched input
encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values
expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs)
self.assertEqual(
encoded_images.shape,
(1, self.image_processor_tester.num_channels, expected_height, expected_width),
)
# Test batched
encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values
expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs, batched=True)
self.assertEqual(
encoded_images.shape,
(
self.image_processor_tester.batch_size,
self.image_processor_tester.num_channels,
expected_height,
expected_width,
),
)
def comm_get_image_processing_inputs( def comm_get_image_processing_inputs(
self, with_segmentation_maps=False, is_instance_map=False, segmentation_type="np" self, with_segmentation_maps=False, is_instance_map=False, segmentation_type="np"
): ):
...@@ -270,7 +184,7 @@ class Mask2FormerImageProcessingTest(ImageProcessingSavingTestMixin, unittest.Te ...@@ -270,7 +184,7 @@ class Mask2FormerImageProcessingTest(ImageProcessingSavingTestMixin, unittest.Te
num_labels = self.image_processor_tester.num_labels num_labels = self.image_processor_tester.num_labels
annotations = None annotations = None
instance_id_to_semantic_id = None instance_id_to_semantic_id = None
image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False) image_inputs = self.image_processor_tester.prepare_image_inputs(equal_resolution=False)
if with_segmentation_maps: if with_segmentation_maps:
high = num_labels high = num_labels
if is_instance_map: if is_instance_map:
...@@ -292,9 +206,6 @@ class Mask2FormerImageProcessingTest(ImageProcessingSavingTestMixin, unittest.Te ...@@ -292,9 +206,6 @@ class Mask2FormerImageProcessingTest(ImageProcessingSavingTestMixin, unittest.Te
return inputs return inputs
def test_init_without_params(self):
pass
def test_with_size_divisor(self): def test_with_size_divisor(self):
size_divisors = [8, 16, 32] size_divisors = [8, 16, 32]
weird_input_sizes = [(407, 802), (582, 1094)] weird_input_sizes = [(407, 802), (582, 1094)]
......
tests/models/maskformer/test_image_processing_maskformer.py
View file @ 41d56ea6
...@@ -23,7 +23,7 @@ from huggingface_hub import hf_hub_download ...@@ -23,7 +23,7 @@ from huggingface_hub import hf_hub_download
from transformers.testing_utils import require_torch, require_vision from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available from transformers.utils import is_torch_available, is_vision_available
from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs from ...test_image_processing_common import ImageProcessingTestMixin, prepare_image_inputs
if is_torch_available(): if is_torch_available():
...@@ -127,10 +127,25 @@ class MaskFormerImageProcessingTester(unittest.TestCase): ...@@ -127,10 +127,25 @@ class MaskFormerImageProcessingTester(unittest.TestCase):
masks_queries_logits=torch.randn((self.batch_size, self.num_queries, self.height, self.width)), masks_queries_logits=torch.randn((self.batch_size, self.num_queries, self.height, self.width)),
) )
def expected_output_image_shape(self, images):
height, width = self.get_expected_values(images, batched=True)
return self.num_channels, height, width
def prepare_image_inputs(self, equal_resolution=False, numpify=False, torchify=False):
return prepare_image_inputs(
batch_size=self.batch_size,
num_channels=self.num_channels,
min_resolution=self.min_resolution,
max_resolution=self.max_resolution,
equal_resolution=equal_resolution,
numpify=numpify,
torchify=torchify,
)
@require_torch @require_torch
@require_vision @require_vision
class MaskFormerImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase): class MaskFormerImageProcessingTest(ImageProcessingTestMixin, unittest.TestCase):
image_processing_class = MaskFormerImageProcessor if (is_vision_available() and is_torch_available()) else None image_processing_class = MaskFormerImageProcessor if (is_vision_available() and is_torch_available()) else None
def setUp(self): def setUp(self):
...@@ -161,107 +176,6 @@ class MaskFormerImageProcessingTest(ImageProcessingSavingTestMixin, unittest.Tes ...@@ -161,107 +176,6 @@ class MaskFormerImageProcessingTest(ImageProcessingSavingTestMixin, unittest.Tes
self.assertEqual(image_processor.size, {"shortest_edge": 42, "longest_edge": 84}) self.assertEqual(image_processor.size, {"shortest_edge": 42, "longest_edge": 84})
self.assertEqual(image_processor.size_divisor, 8) self.assertEqual(image_processor.size_divisor, 8)
def test_batch_feature(self):
pass
def test_call_pil(self):
# Initialize image_processing
image_processing = self.image_processing_class(**self.image_processor_dict)
# create random PIL images
image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False)
for image in image_inputs:
self.assertIsInstance(image, Image.Image)
# Test not batched input
encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values
expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs)
self.assertEqual(
encoded_images.shape,
(1, self.image_processor_tester.num_channels, expected_height, expected_width),
)
# Test batched
expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs, batched=True)
encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
self.image_processor_tester.batch_size,
self.image_processor_tester.num_channels,
expected_height,
expected_width,
),
)
def test_call_numpy(self):
# Initialize image_processing
image_processing = self.image_processing_class(**self.image_processor_dict)
# create random numpy tensors
image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, numpify=True)
for image in image_inputs:
self.assertIsInstance(image, np.ndarray)
# Test not batched input
encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values
expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs)
self.assertEqual(
encoded_images.shape,
(1, self.image_processor_tester.num_channels, expected_height, expected_width),
)
# Test batched
encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values
expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs, batched=True)
self.assertEqual(
encoded_images.shape,
(
self.image_processor_tester.batch_size,
self.image_processor_tester.num_channels,
expected_height,
expected_width,
),
)
def test_call_pytorch(self):
# Initialize image_processing
image_processing = self.image_processing_class(**self.image_processor_dict)
# create random PyTorch tensors
image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, torchify=True)
for image in image_inputs:
self.assertIsInstance(image, torch.Tensor)
# Test not batched input
encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values
expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs)
self.assertEqual(
encoded_images.shape,
(1, self.image_processor_tester.num_channels, expected_height, expected_width),
)
# Test batched
encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values
expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs, batched=True)
self.assertEqual(
encoded_images.shape,
(
self.image_processor_tester.batch_size,
self.image_processor_tester.num_channels,
expected_height,
expected_width,
),
)
def comm_get_image_processing_inputs( def comm_get_image_processing_inputs(
self, with_segmentation_maps=False, is_instance_map=False, segmentation_type="np" self, with_segmentation_maps=False, is_instance_map=False, segmentation_type="np"
): ):
...@@ -270,7 +184,7 @@ class MaskFormerImageProcessingTest(ImageProcessingSavingTestMixin, unittest.Tes ...@@ -270,7 +184,7 @@ class MaskFormerImageProcessingTest(ImageProcessingSavingTestMixin, unittest.Tes
num_labels = self.image_processor_tester.num_labels num_labels = self.image_processor_tester.num_labels
annotations = None annotations = None
instance_id_to_semantic_id = None instance_id_to_semantic_id = None
image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False) image_inputs = self.image_processor_tester.prepare_image_inputs(equal_resolution=False)
if with_segmentation_maps: if with_segmentation_maps:
high = num_labels high = num_labels
if is_instance_map: if is_instance_map:
...@@ -292,9 +206,6 @@ class MaskFormerImageProcessingTest(ImageProcessingSavingTestMixin, unittest.Tes ...@@ -292,9 +206,6 @@ class MaskFormerImageProcessingTest(ImageProcessingSavingTestMixin, unittest.Tes
return inputs return inputs
def test_init_without_params(self):
pass
def test_with_size_divisor(self): def test_with_size_divisor(self):
size_divisors = [8, 16, 32] size_divisors = [8, 16, 32]
weird_input_sizes = [(407, 802), (582, 1094)] weird_input_sizes = [(407, 802), (582, 1094)]
......
tests/models/mgp_str/test_processor_mgp_str.py
View file @ 41d56ea6
...@@ -46,7 +46,7 @@ class MgpstrProcessorTest(unittest.TestCase): ...@@ -46,7 +46,7 @@ class MgpstrProcessorTest(unittest.TestCase):
@property @property
def image_processor_dict(self): def image_processor_dict(self):
return self.image_processor_tester.prepare_image_processor_dict() return self.prepare_image_processor_dict()
def setUp(self): def setUp(self):
self.image_size = (3, 32, 128) self.image_size = (3, 32, 128)
......
tests/models/mobilenet_v1/test_image_processing_mobilenet_v1.py
View file @ 41d56ea6
...@@ -16,20 +16,13 @@ ...@@ -16,20 +16,13 @@
import unittest import unittest
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_vision_available
from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs
from ...test_image_processing_common import ImageProcessingTestMixin, prepare_image_inputs
if is_torch_available():
import torch
if is_vision_available(): if is_vision_available():
from PIL import Image
from transformers import MobileNetV1ImageProcessor from transformers import MobileNetV1ImageProcessor
...@@ -68,10 +61,24 @@ class MobileNetV1ImageProcessingTester(unittest.TestCase): ...@@ -68,10 +61,24 @@ class MobileNetV1ImageProcessingTester(unittest.TestCase):
"crop_size": self.crop_size, "crop_size": self.crop_size,
} }
def expected_output_image_shape(self, images):
return self.num_channels, self.crop_size["height"], self.crop_size["width"]
def prepare_image_inputs(self, equal_resolution=False, numpify=False, torchify=False):
return prepare_image_inputs(
batch_size=self.batch_size,
num_channels=self.num_channels,
min_resolution=self.min_resolution,
max_resolution=self.max_resolution,
equal_resolution=equal_resolution,
numpify=numpify,
torchify=torchify,
)
@require_torch @require_torch
@require_vision @require_vision
class MobileNetV1ImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase): class MobileNetV1ImageProcessingTest(ImageProcessingTestMixin, unittest.TestCase):
image_processing_class = MobileNetV1ImageProcessor if is_vision_available() else None image_processing_class = MobileNetV1ImageProcessor if is_vision_available() else None
def setUp(self): def setUp(self):
...@@ -96,102 +103,3 @@ class MobileNetV1ImageProcessingTest(ImageProcessingSavingTestMixin, unittest.Te ...@@ -96,102 +103,3 @@ class MobileNetV1ImageProcessingTest(ImageProcessingSavingTestMixin, unittest.Te
image_processor = self.image_processing_class.from_dict(self.image_processor_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(image_processor.size, {"shortest_edge": 42}) self.assertEqual(image_processor.size, {"shortest_edge": 42})
self.assertEqual(image_processor.crop_size, {"height": 84, "width": 84}) self.assertEqual(image_processor.crop_size, {"height": 84, "width": 84})
def test_batch_feature(self):
pass
def test_call_pil(self):
# Initialize image_processing
image_processing = self.image_processing_class(**self.image_processor_dict)
# create random PIL images
image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False)
for image in image_inputs:
self.assertIsInstance(image, Image.Image)
# Test not batched input
encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
1,
self.image_processor_tester.num_channels,
self.image_processor_tester.crop_size["height"],
self.image_processor_tester.crop_size["width"],
),
)
# Test batched
encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
self.image_processor_tester.batch_size,
self.image_processor_tester.num_channels,
self.image_processor_tester.crop_size["height"],
self.image_processor_tester.crop_size["width"],
),
)
def test_call_numpy(self):
# Initialize image_processing
image_processing = self.image_processing_class(**self.image_processor_dict)
# create random numpy tensors
image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, numpify=True)
for image in image_inputs:
self.assertIsInstance(image, np.ndarray)
# Test not batched input
encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
1,
self.image_processor_tester.num_channels,
self.image_processor_tester.crop_size["height"],
self.image_processor_tester.crop_size["width"],
),
)
# Test batched
encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
self.image_processor_tester.batch_size,
self.image_processor_tester.num_channels,
self.image_processor_tester.crop_size["height"],
self.image_processor_tester.crop_size["width"],
),
)
def test_call_pytorch(self):
# Initialize image_processing
image_processing = self.image_processing_class(**self.image_processor_dict)
# create random PyTorch tensors
image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, torchify=True)
for image in image_inputs:
self.assertIsInstance(image, torch.Tensor)
# Test not batched input
encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
1,
self.image_processor_tester.num_channels,
self.image_processor_tester.crop_size["height"],
self.image_processor_tester.crop_size["width"],
),
)
# Test batched
encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
self.image_processor_tester.batch_size,
self.image_processor_tester.num_channels,
self.image_processor_tester.crop_size["height"],
self.image_processor_tester.crop_size["width"],
),
)
tests/models/mobilenet_v2/test_image_processing_mobilenet_v2.py
View file @ 41d56ea6
...@@ -16,20 +16,13 @@ ...@@ -16,20 +16,13 @@
import unittest import unittest
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_vision_available
from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs
from ...test_image_processing_common import ImageProcessingTestMixin, prepare_image_inputs
if is_torch_available():
import torch
if is_vision_available(): if is_vision_available():
from PIL import Image
from transformers import MobileNetV2ImageProcessor from transformers import MobileNetV2ImageProcessor
...@@ -68,10 +61,24 @@ class MobileNetV2ImageProcessingTester(unittest.TestCase): ...@@ -68,10 +61,24 @@ class MobileNetV2ImageProcessingTester(unittest.TestCase):
"crop_size": self.crop_size, "crop_size": self.crop_size,
} }
def expected_output_image_shape(self, images):
return self.num_channels, self.crop_size["height"], self.crop_size["width"]
def prepare_image_inputs(self, equal_resolution=False, numpify=False, torchify=False):
return prepare_image_inputs(
batch_size=self.batch_size,
num_channels=self.num_channels,
min_resolution=self.min_resolution,
max_resolution=self.max_resolution,
equal_resolution=equal_resolution,
numpify=numpify,
torchify=torchify,
)
@require_torch @require_torch
@require_vision @require_vision
class MobileNetV2ImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase): class MobileNetV2ImageProcessingTest(ImageProcessingTestMixin, unittest.TestCase):
image_processing_class = MobileNetV2ImageProcessor if is_vision_available() else None image_processing_class = MobileNetV2ImageProcessor if is_vision_available() else None
def setUp(self): def setUp(self):
...@@ -96,102 +103,3 @@ class MobileNetV2ImageProcessingTest(ImageProcessingSavingTestMixin, unittest.Te ...@@ -96,102 +103,3 @@ class MobileNetV2ImageProcessingTest(ImageProcessingSavingTestMixin, unittest.Te
image_processor = self.image_processing_class.from_dict(self.image_processor_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(image_processor.size, {"shortest_edge": 42}) self.assertEqual(image_processor.size, {"shortest_edge": 42})
self.assertEqual(image_processor.crop_size, {"height": 84, "width": 84}) self.assertEqual(image_processor.crop_size, {"height": 84, "width": 84})
def test_batch_feature(self):
pass
def test_call_pil(self):
# Initialize image_processing
image_processing = self.image_processing_class(**self.image_processor_dict)
# create random PIL images
image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False)
for image in image_inputs:
self.assertIsInstance(image, Image.Image)
# Test not batched input
encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
1,
self.image_processor_tester.num_channels,
self.image_processor_tester.crop_size["height"],
self.image_processor_tester.crop_size["width"],
),
)
# Test batched
encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
self.image_processor_tester.batch_size,
self.image_processor_tester.num_channels,
self.image_processor_tester.crop_size["height"],
self.image_processor_tester.crop_size["width"],
),
)
def test_call_numpy(self):
# Initialize image_processing
image_processing = self.image_processing_class(**self.image_processor_dict)
# create random numpy tensors
image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, numpify=True)
for image in image_inputs:
self.assertIsInstance(image, np.ndarray)
# Test not batched input
encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
1,
self.image_processor_tester.num_channels,
self.image_processor_tester.crop_size["height"],
self.image_processor_tester.crop_size["width"],
),
)
# Test batched
encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
self.image_processor_tester.batch_size,
self.image_processor_tester.num_channels,
self.image_processor_tester.crop_size["height"],
self.image_processor_tester.crop_size["width"],
),
)
def test_call_pytorch(self):
# Initialize image_processing
image_processing = self.image_processing_class(**self.image_processor_dict)
# create random PyTorch tensors
image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, torchify=True)
for image in image_inputs:
self.assertIsInstance(image, torch.Tensor)
# Test not batched input
encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
1,
self.image_processor_tester.num_channels,
self.image_processor_tester.crop_size["height"],
self.image_processor_tester.crop_size["width"],
),
)
# Test batched
encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
self.image_processor_tester.batch_size,
self.image_processor_tester.num_channels,
self.image_processor_tester.crop_size["height"],
self.image_processor_tester.crop_size["width"],
),
)
tests/models/mobilevit/test_image_processing_mobilevit.py
View file @ 41d56ea6
...@@ -16,20 +16,13 @@ ...@@ -16,20 +16,13 @@
import unittest import unittest
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_vision_available
from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs
from ...test_image_processing_common import ImageProcessingTestMixin, prepare_image_inputs
if is_torch_available():
import torch
if is_vision_available(): if is_vision_available():
from PIL import Image
from transformers import MobileViTImageProcessor from transformers import MobileViTImageProcessor
...@@ -71,10 +64,24 @@ class MobileViTImageProcessingTester(unittest.TestCase): ...@@ -71,10 +64,24 @@ class MobileViTImageProcessingTester(unittest.TestCase):
"do_flip_channel_order": self.do_flip_channel_order, "do_flip_channel_order": self.do_flip_channel_order,
} }
def expected_output_image_shape(self, images):
return self.num_channels, self.crop_size["height"], self.crop_size["width"]
def prepare_image_inputs(self, equal_resolution=False, numpify=False, torchify=False):
return prepare_image_inputs(
batch_size=self.batch_size,
num_channels=self.num_channels,
min_resolution=self.min_resolution,
max_resolution=self.max_resolution,
equal_resolution=equal_resolution,
numpify=numpify,
torchify=torchify,
)
@require_torch @require_torch
@require_vision @require_vision
class MobileViTImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase): class MobileViTImageProcessingTest(ImageProcessingTestMixin, unittest.TestCase):
image_processing_class = MobileViTImageProcessor if is_vision_available() else None image_processing_class = MobileViTImageProcessor if is_vision_available() else None
def setUp(self): def setUp(self):
...@@ -100,102 +107,3 @@ class MobileViTImageProcessingTest(ImageProcessingSavingTestMixin, unittest.Test ...@@ -100,102 +107,3 @@ class MobileViTImageProcessingTest(ImageProcessingSavingTestMixin, unittest.Test
image_processor = self.image_processing_class.from_dict(self.image_processor_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(image_processor.size, {"shortest_edge": 42}) self.assertEqual(image_processor.size, {"shortest_edge": 42})
self.assertEqual(image_processor.crop_size, {"height": 84, "width": 84}) self.assertEqual(image_processor.crop_size, {"height": 84, "width": 84})
def test_batch_feature(self):
pass
def test_call_pil(self):
# Initialize image_processing
image_processing = self.image_processing_class(**self.image_processor_dict)
# create random PIL images
image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False)
for image in image_inputs:
self.assertIsInstance(image, Image.Image)
# Test not batched input
encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
1,
self.image_processor_tester.num_channels,
self.image_processor_tester.crop_size["height"],
self.image_processor_tester.crop_size["width"],
),
)
# Test batched
encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
self.image_processor_tester.batch_size,
self.image_processor_tester.num_channels,
self.image_processor_tester.crop_size["height"],
self.image_processor_tester.crop_size["width"],
),
)
def test_call_numpy(self):
# Initialize image_processing
image_processing = self.image_processing_class(**self.image_processor_dict)
# create random numpy tensors
image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, numpify=True)
for image in image_inputs:
self.assertIsInstance(image, np.ndarray)
# Test not batched input
encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
1,
self.image_processor_tester.num_channels,
self.image_processor_tester.crop_size["height"],
self.image_processor_tester.crop_size["width"],
),
)
# Test batched
encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
self.image_processor_tester.batch_size,
self.image_processor_tester.num_channels,
self.image_processor_tester.crop_size["height"],
self.image_processor_tester.crop_size["width"],
),
)
def test_call_pytorch(self):
# Initialize image_processing
image_processing = self.image_processing_class(**self.image_processor_dict)
# create random PyTorch tensors
image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, torchify=True)
for image in image_inputs:
self.assertIsInstance(image, torch.Tensor)
# Test not batched input
encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
1,
self.image_processor_tester.num_channels,
self.image_processor_tester.crop_size["height"],
self.image_processor_tester.crop_size["width"],
),
)
# Test batched
encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
self.image_processor_tester.batch_size,
self.image_processor_tester.num_channels,
self.image_processor_tester.crop_size["height"],
self.image_processor_tester.crop_size["width"],
),
)
tests/models/oneformer/test_image_processing_oneformer.py
View file @ 41d56ea6
...@@ -23,7 +23,7 @@ from huggingface_hub import hf_hub_download ...@@ -23,7 +23,7 @@ from huggingface_hub import hf_hub_download
from transformers.testing_utils import require_torch, require_vision from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available from transformers.utils import is_torch_available, is_vision_available
from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs from ...test_image_processing_common import ImageProcessingTestMixin, prepare_image_inputs
if is_torch_available(): if is_torch_available():
...@@ -152,20 +152,35 @@ class OneFormerImageProcessorTester(unittest.TestCase): ...@@ -152,20 +152,35 @@ class OneFormerImageProcessorTester(unittest.TestCase):
masks_queries_logits=torch.randn((self.batch_size, self.num_queries, self.height, self.width)), masks_queries_logits=torch.randn((self.batch_size, self.num_queries, self.height, self.width)),
) )
def expected_output_image_shape(self, images):
height, width = self.get_expected_values(images, batched=True)
return self.num_channels, height, width
def prepare_image_inputs(self, equal_resolution=False, numpify=False, torchify=False):
return prepare_image_inputs(
batch_size=self.batch_size,
num_channels=self.num_channels,
min_resolution=self.min_resolution,
max_resolution=self.max_resolution,
equal_resolution=equal_resolution,
numpify=numpify,
torchify=torchify,
)
@require_torch @require_torch
@require_vision @require_vision
class OneFormerImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase): class OneFormerImageProcessingTest(ImageProcessingTestMixin, unittest.TestCase):
image_processing_class = OneFormerImageProcessor if (is_vision_available() and is_torch_available()) else None image_processing_class = OneFormerImageProcessor if (is_vision_available() and is_torch_available()) else None
# only for test_image_processing_common.test_image_proc_to_json_string # only for test_image_processing_common.test_image_proc_to_json_string
image_processing_class = image_processing_class image_processing_class = image_processing_class
def setUp(self): def setUp(self):
self.image_processing_tester = OneFormerImageProcessorTester(self) self.image_processor_tester = OneFormerImageProcessorTester(self)
@property @property
def image_processor_dict(self): def image_processor_dict(self):
return self.image_processing_tester.prepare_image_processor_dict() return self.image_processor_tester.prepare_image_processor_dict()
def test_image_proc_properties(self): def test_image_proc_properties(self):
image_processor = self.image_processing_class(**self.image_processor_dict) image_processor = self.image_processing_class(**self.image_processor_dict)
...@@ -181,120 +196,15 @@ class OneFormerImageProcessingTest(ImageProcessingSavingTestMixin, unittest.Test ...@@ -181,120 +196,15 @@ class OneFormerImageProcessingTest(ImageProcessingSavingTestMixin, unittest.Test
self.assertTrue(hasattr(image_processor, "metadata")) self.assertTrue(hasattr(image_processor, "metadata"))
self.assertTrue(hasattr(image_processor, "do_reduce_labels")) self.assertTrue(hasattr(image_processor, "do_reduce_labels"))
def test_batch_feature(self):
pass
def test_call_pil(self):
# Initialize image_processor
image_processor = self.image_processing_class(**self.image_processor_dict)
# create random PIL images
image_inputs = prepare_image_inputs(self.image_processing_tester, equal_resolution=False)
for image in image_inputs:
self.assertIsInstance(image, Image.Image)
# Test not batched input
encoded_images = image_processor(image_inputs[0], ["semantic"], return_tensors="pt").pixel_values
expected_height, expected_width = self.image_processing_tester.get_expected_values(image_inputs)
self.assertEqual(
encoded_images.shape,
(1, self.image_processing_tester.num_channels, expected_height, expected_width),
)
# Test batched
expected_height, expected_width = self.image_processing_tester.get_expected_values(image_inputs, batched=True)
encoded_images = image_processor(
image_inputs, ["semantic"] * len(image_inputs), return_tensors="pt"
).pixel_values
self.assertEqual(
encoded_images.shape,
(
self.image_processing_tester.batch_size,
self.image_processing_tester.num_channels,
expected_height,
expected_width,
),
)
def test_call_numpy(self):
# Initialize image_processor
image_processor = self.image_processing_class(**self.image_processor_dict)
# create random numpy tensors
image_inputs = prepare_image_inputs(self.image_processing_tester, equal_resolution=False, numpify=True)
for image in image_inputs:
self.assertIsInstance(image, np.ndarray)
# Test not batched input
encoded_images = image_processor(image_inputs[0], ["semantic"], return_tensors="pt").pixel_values
expected_height, expected_width = self.image_processing_tester.get_expected_values(image_inputs)
self.assertEqual(
encoded_images.shape,
(1, self.image_processing_tester.num_channels, expected_height, expected_width),
)
# Test batched
expected_height, expected_width = self.image_processing_tester.get_expected_values(image_inputs, batched=True)
encoded_images = image_processor(
image_inputs, ["semantic"] * len(image_inputs), return_tensors="pt"
).pixel_values
self.assertEqual(
encoded_images.shape,
(
self.image_processing_tester.batch_size,
self.image_processing_tester.num_channels,
expected_height,
expected_width,
),
)
def test_call_pytorch(self):
# Initialize image_processor
image_processor = self.image_processing_class(**self.image_processor_dict)
# create random PyTorch tensors
image_inputs = prepare_image_inputs(self.image_processing_tester, equal_resolution=False, torchify=True)
for image in image_inputs:
self.assertIsInstance(image, torch.Tensor)
# Test not batched input
encoded_images = image_processor(image_inputs[0], ["semantic"], return_tensors="pt").pixel_values
expected_height, expected_width = self.image_processing_tester.get_expected_values(image_inputs)
self.assertEqual(
encoded_images.shape,
(1, self.image_processing_tester.num_channels, expected_height, expected_width),
)
# Test batched
expected_height, expected_width = self.image_processing_tester.get_expected_values(image_inputs, batched=True)
encoded_images = image_processor(
image_inputs, ["semantic"] * len(image_inputs), return_tensors="pt"
).pixel_values
self.assertEqual(
encoded_images.shape,
(
self.image_processing_tester.batch_size,
self.image_processing_tester.num_channels,
expected_height,
expected_width,
),
)
def comm_get_image_processor_inputs( def comm_get_image_processor_inputs(
self, with_segmentation_maps=False, is_instance_map=False, segmentation_type="np" self, with_segmentation_maps=False, is_instance_map=False, segmentation_type="np"
): ):
image_processor = self.image_processing_class(**self.image_processor_dict) image_processor = self.image_processing_class(**self.image_processor_dict)
# prepare image and target # prepare image and target
num_labels = self.image_processing_tester.num_labels num_labels = self.image_processor_tester.num_labels
annotations = None annotations = None
instance_id_to_semantic_id = None instance_id_to_semantic_id = None
image_inputs = prepare_image_inputs(self.image_processing_tester, equal_resolution=False) image_inputs = self.image_processor_tester.prepare_image_inputs(equal_resolution=False)
if with_segmentation_maps: if with_segmentation_maps:
high = num_labels high = num_labels
if is_instance_map: if is_instance_map:
...@@ -336,7 +246,7 @@ class OneFormerImageProcessingTest(ImageProcessingSavingTestMixin, unittest.Test ...@@ -336,7 +246,7 @@ class OneFormerImageProcessingTest(ImageProcessingSavingTestMixin, unittest.Test
self.assertEqual(mask_label.shape[0], class_label.shape[0]) self.assertEqual(mask_label.shape[0], class_label.shape[0])
# this ensure padding has happened # this ensure padding has happened
self.assertEqual(mask_label.shape[1:], pixel_values.shape[2:]) self.assertEqual(mask_label.shape[1:], pixel_values.shape[2:])
self.assertEqual(len(text_input), self.image_processing_tester.num_text) self.assertEqual(len(text_input), self.image_processor_tester.num_text)
common() common()
common(is_instance_map=True) common(is_instance_map=True)
...@@ -356,69 +266,69 @@ class OneFormerImageProcessingTest(ImageProcessingSavingTestMixin, unittest.Test ...@@ -356,69 +266,69 @@ class OneFormerImageProcessingTest(ImageProcessingSavingTestMixin, unittest.Test
def test_post_process_semantic_segmentation(self): def test_post_process_semantic_segmentation(self):
fature_extractor = self.image_processing_class( fature_extractor = self.image_processing_class(
num_labels=self.image_processing_tester.num_classes, num_labels=self.image_processor_tester.num_classes,
max_seq_length=77, max_seq_length=77,
task_seq_length=77, task_seq_length=77,
class_info_file="ade20k_panoptic.json", class_info_file="ade20k_panoptic.json",
num_text=self.image_processing_tester.num_text, num_text=self.image_processor_tester.num_text,
repo_path="shi-labs/oneformer_demo", repo_path="shi-labs/oneformer_demo",
) )
outputs = self.image_processing_tester.get_fake_oneformer_outputs() outputs = self.image_processor_tester.get_fake_oneformer_outputs()
segmentation = fature_extractor.post_process_semantic_segmentation(outputs) segmentation = fature_extractor.post_process_semantic_segmentation(outputs)
self.assertEqual(len(segmentation), self.image_processing_tester.batch_size) self.assertEqual(len(segmentation), self.image_processor_tester.batch_size)
self.assertEqual( self.assertEqual(
segmentation[0].shape, segmentation[0].shape,
( (
self.image_processing_tester.height, self.image_processor_tester.height,
self.image_processing_tester.width, self.image_processor_tester.width,
), ),
) )
target_sizes = [(1, 4) for i in range(self.image_processing_tester.batch_size)] target_sizes = [(1, 4) for i in range(self.image_processor_tester.batch_size)]
segmentation = fature_extractor.post_process_semantic_segmentation(outputs, target_sizes=target_sizes) segmentation = fature_extractor.post_process_semantic_segmentation(outputs, target_sizes=target_sizes)
self.assertEqual(segmentation[0].shape, target_sizes[0]) self.assertEqual(segmentation[0].shape, target_sizes[0])
def test_post_process_instance_segmentation(self): def test_post_process_instance_segmentation(self):
image_processor = self.image_processing_class( image_processor = self.image_processing_class(
num_labels=self.image_processing_tester.num_classes, num_labels=self.image_processor_tester.num_classes,
max_seq_length=77, max_seq_length=77,
task_seq_length=77, task_seq_length=77,
class_info_file="ade20k_panoptic.json", class_info_file="ade20k_panoptic.json",
num_text=self.image_processing_tester.num_text, num_text=self.image_processor_tester.num_text,
repo_path="shi-labs/oneformer_demo", repo_path="shi-labs/oneformer_demo",
) )
outputs = self.image_processing_tester.get_fake_oneformer_outputs() outputs = self.image_processor_tester.get_fake_oneformer_outputs()
segmentation = image_processor.post_process_instance_segmentation(outputs, threshold=0) segmentation = image_processor.post_process_instance_segmentation(outputs, threshold=0)
self.assertTrue(len(segmentation) == self.image_processing_tester.batch_size) self.assertTrue(len(segmentation) == self.image_processor_tester.batch_size)
for el in segmentation: for el in segmentation:
self.assertTrue("segmentation" in el) self.assertTrue("segmentation" in el)
self.assertTrue("segments_info" in el) self.assertTrue("segments_info" in el)
self.assertEqual(type(el["segments_info"]), list) self.assertEqual(type(el["segments_info"]), list)
self.assertEqual( self.assertEqual(
el["segmentation"].shape, (self.image_processing_tester.height, self.image_processing_tester.width) el["segmentation"].shape, (self.image_processor_tester.height, self.image_processor_tester.width)
) )
def test_post_process_panoptic_segmentation(self): def test_post_process_panoptic_segmentation(self):
image_processor = self.image_processing_class( image_processor = self.image_processing_class(
num_labels=self.image_processing_tester.num_classes, num_labels=self.image_processor_tester.num_classes,
max_seq_length=77, max_seq_length=77,
task_seq_length=77, task_seq_length=77,
class_info_file="ade20k_panoptic.json", class_info_file="ade20k_panoptic.json",
num_text=self.image_processing_tester.num_text, num_text=self.image_processor_tester.num_text,
repo_path="shi-labs/oneformer_demo", repo_path="shi-labs/oneformer_demo",
) )
outputs = self.image_processing_tester.get_fake_oneformer_outputs() outputs = self.image_processor_tester.get_fake_oneformer_outputs()
segmentation = image_processor.post_process_panoptic_segmentation(outputs, threshold=0) segmentation = image_processor.post_process_panoptic_segmentation(outputs, threshold=0)
self.assertTrue(len(segmentation) == self.image_processing_tester.batch_size) self.assertTrue(len(segmentation) == self.image_processor_tester.batch_size)
for el in segmentation: for el in segmentation:
self.assertTrue("segmentation" in el) self.assertTrue("segmentation" in el)
self.assertTrue("segments_info" in el) self.assertTrue("segments_info" in el)
self.assertEqual(type(el["segments_info"]), list) self.assertEqual(type(el["segments_info"]), list)
self.assertEqual( self.assertEqual(
el["segmentation"].shape, (self.image_processing_tester.height, self.image_processing_tester.width) el["segmentation"].shape, (self.image_processor_tester.height, self.image_processor_tester.width)
) )
tests/models/oneformer/test_processor_oneformer.py
View file @ 41d56ea6
...@@ -174,6 +174,17 @@ class OneFormerProcessorTester(unittest.TestCase): ...@@ -174,6 +174,17 @@ class OneFormerProcessorTester(unittest.TestCase):
masks_queries_logits=torch.randn((self.batch_size, self.num_queries, self.height, self.width)), masks_queries_logits=torch.randn((self.batch_size, self.num_queries, self.height, self.width)),
) )
def prepare_image_inputs(self, equal_resolution=False, numpify=False, torchify=False):
return prepare_image_inputs(
batch_size=self.batch_size,
num_channels=self.num_channels,
min_resolution=self.min_resolution,
max_resolution=self.max_resolution,
equal_resolution=equal_resolution,
numpify=numpify,
torchify=torchify,
)
@require_torch @require_torch
@require_vision @require_vision
...@@ -203,7 +214,7 @@ class OneFormerProcessingTest(unittest.TestCase): ...@@ -203,7 +214,7 @@ class OneFormerProcessingTest(unittest.TestCase):
# Initialize processor # Initialize processor
processor = self.processing_class(**self.processor_dict) processor = self.processing_class(**self.processor_dict)
# create random PIL images # create random PIL images
image_inputs = prepare_image_inputs(self.processing_tester, equal_resolution=False) image_inputs = self.processing_tester.prepare_image_inputs(equal_resolution=False)
for image in image_inputs: for image in image_inputs:
self.assertIsInstance(image, Image.Image) self.assertIsInstance(image, Image.Image)
...@@ -255,7 +266,7 @@ class OneFormerProcessingTest(unittest.TestCase): ...@@ -255,7 +266,7 @@ class OneFormerProcessingTest(unittest.TestCase):
# Initialize processor # Initialize processor
processor = self.processing_class(**self.processor_dict) processor = self.processing_class(**self.processor_dict)
# create random numpy tensors # create random numpy tensors
image_inputs = prepare_image_inputs(self.processing_tester, equal_resolution=False, numpify=True) image_inputs = self.processing_tester.prepare_image_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)
...@@ -307,7 +318,7 @@ class OneFormerProcessingTest(unittest.TestCase): ...@@ -307,7 +318,7 @@ class OneFormerProcessingTest(unittest.TestCase):
# Initialize processor # Initialize processor
processor = self.processing_class(**self.processor_dict) processor = self.processing_class(**self.processor_dict)
# create random PyTorch tensors # create random PyTorch tensors
image_inputs = prepare_image_inputs(self.processing_tester, equal_resolution=False, torchify=True) image_inputs = self.processing_tester.prepare_image_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)
...@@ -361,7 +372,7 @@ class OneFormerProcessingTest(unittest.TestCase): ...@@ -361,7 +372,7 @@ class OneFormerProcessingTest(unittest.TestCase):
num_labels = self.processing_tester.num_labels num_labels = self.processing_tester.num_labels
annotations = None annotations = None
instance_id_to_semantic_id = None instance_id_to_semantic_id = None
image_inputs = prepare_image_inputs(self.processing_tester, equal_resolution=False) image_inputs = self.processing_tester.prepare_image_inputs(equal_resolution=False)
if with_segmentation_maps: if with_segmentation_maps:
high = num_labels high = num_labels
if is_instance_map: if is_instance_map:
......
tests/models/owlvit/test_image_processing_owlvit.py
View file @ 41d56ea6
...@@ -16,20 +16,13 @@ ...@@ -16,20 +16,13 @@
import unittest import unittest
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_vision_available
from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs
from ...test_image_processing_common import ImageProcessingTestMixin, prepare_image_inputs
if is_torch_available():
import torch
if is_vision_available(): if is_vision_available():
from PIL import Image
from transformers import OwlViTImageProcessor from transformers import OwlViTImageProcessor
...@@ -78,10 +71,24 @@ class OwlViTImageProcessingTester(unittest.TestCase): ...@@ -78,10 +71,24 @@ class OwlViTImageProcessingTester(unittest.TestCase):
"do_convert_rgb": self.do_convert_rgb, "do_convert_rgb": self.do_convert_rgb,
} }
def expected_output_image_shape(self, images):
return self.num_channels, self.crop_size["height"], self.crop_size["width"]
def prepare_image_inputs(self, equal_resolution=False, numpify=False, torchify=False):
return prepare_image_inputs(
batch_size=self.batch_size,
num_channels=self.num_channels,
min_resolution=self.min_resolution,
max_resolution=self.max_resolution,
equal_resolution=equal_resolution,
numpify=numpify,
torchify=torchify,
)
@require_torch @require_torch
@require_vision @require_vision
class OwlViTImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase): class OwlViTImageProcessingTest(ImageProcessingTestMixin, unittest.TestCase):
image_processing_class = OwlViTImageProcessor if is_vision_available() else None image_processing_class = OwlViTImageProcessor if is_vision_available() else None
def setUp(self): def setUp(self):
...@@ -110,100 +117,3 @@ class OwlViTImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCas ...@@ -110,100 +117,3 @@ class OwlViTImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCas
image_processor = self.image_processing_class.from_dict(self.image_processor_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(image_processor.size, {"height": 42, "width": 42}) self.assertEqual(image_processor.size, {"height": 42, "width": 42})
self.assertEqual(image_processor.crop_size, {"height": 84, "width": 84}) self.assertEqual(image_processor.crop_size, {"height": 84, "width": 84})
def test_call_pil(self):
# Initialize image_processing
image_processing = self.image_processing_class(**self.image_processor_dict)
# create random PIL images
image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False)
for image in image_inputs:
self.assertIsInstance(image, Image.Image)
# Test not batched input
encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
1,
self.image_processor_tester.num_channels,
self.image_processor_tester.crop_size["height"],
self.image_processor_tester.crop_size["width"],
),
)
# Test batched
encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
self.image_processor_tester.batch_size,
self.image_processor_tester.num_channels,
self.image_processor_tester.crop_size["height"],
self.image_processor_tester.crop_size["width"],
),
)
def test_call_numpy(self):
# Initialize image_processing
image_processing = self.image_processing_class(**self.image_processor_dict)
# create random numpy tensors
image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, numpify=True)
for image in image_inputs:
self.assertIsInstance(image, np.ndarray)
# Test not batched input
encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
1,
self.image_processor_tester.num_channels,
self.image_processor_tester.crop_size["height"],
self.image_processor_tester.crop_size["width"],
),
)
# Test batched
encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
self.image_processor_tester.batch_size,
self.image_processor_tester.num_channels,
self.image_processor_tester.crop_size["height"],
self.image_processor_tester.crop_size["width"],
),
)
def test_call_pytorch(self):
# Initialize image_processing
image_processing = self.image_processing_class(**self.image_processor_dict)
# create random PyTorch tensors
image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, torchify=True)
for image in image_inputs:
self.assertIsInstance(image, torch.Tensor)
# Test not batched input
encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
1,
self.image_processor_tester.num_channels,
self.image_processor_tester.crop_size["height"],
self.image_processor_tester.crop_size["width"],
),
)
# Test batched
encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
self.image_processor_tester.batch_size,
self.image_processor_tester.num_channels,
self.image_processor_tester.crop_size["height"],
self.image_processor_tester.crop_size["width"],
),
)
tests/models/pix2struct/test_image_processing_pix2struct.py
View file @ 41d56ea6
...@@ -22,7 +22,7 @@ import requests ...@@ -22,7 +22,7 @@ import requests
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_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs from ...test_image_processing_common import ImageProcessingTestMixin, prepare_image_inputs
if is_torch_available(): if is_torch_available():
...@@ -73,6 +73,17 @@ class Pix2StructImageProcessingTester(unittest.TestCase): ...@@ -73,6 +73,17 @@ class Pix2StructImageProcessingTester(unittest.TestCase):
raw_image = Image.open(requests.get(img_url, stream=True).raw).convert("RGB") raw_image = Image.open(requests.get(img_url, stream=True).raw).convert("RGB")
return raw_image return raw_image
def prepare_image_inputs(self, equal_resolution=False, numpify=False, torchify=False):
return prepare_image_inputs(
batch_size=self.batch_size,
num_channels=self.num_channels,
min_resolution=self.min_resolution,
max_resolution=self.max_resolution,
equal_resolution=equal_resolution,
numpify=numpify,
torchify=torchify,
)
@unittest.skipIf( @unittest.skipIf(
not is_torch_greater_or_equal_than_1_11, not is_torch_greater_or_equal_than_1_11,
...@@ -80,7 +91,7 @@ class Pix2StructImageProcessingTester(unittest.TestCase): ...@@ -80,7 +91,7 @@ class Pix2StructImageProcessingTester(unittest.TestCase):
) )
@require_torch @require_torch
@require_vision @require_vision
class Pix2StructImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase): class Pix2StructImageProcessingTest(ImageProcessingTestMixin, unittest.TestCase):
image_processing_class = Pix2StructImageProcessor if is_vision_available() else None image_processing_class = Pix2StructImageProcessor if is_vision_available() else None
def setUp(self): def setUp(self):
...@@ -108,7 +119,7 @@ class Pix2StructImageProcessingTest(ImageProcessingSavingTestMixin, unittest.Tes ...@@ -108,7 +119,7 @@ class Pix2StructImageProcessingTest(ImageProcessingSavingTestMixin, unittest.Tes
# Initialize image_processor # Initialize image_processor
image_processor = self.image_processing_class(**self.image_processor_dict) image_processor = self.image_processing_class(**self.image_processor_dict)
# create random PIL images # create random PIL images
image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False) image_inputs = self.image_processor_tester.prepare_image_inputs(equal_resolution=False)
for image in image_inputs: for image in image_inputs:
self.assertIsInstance(image, Image.Image) self.assertIsInstance(image, Image.Image)
...@@ -141,7 +152,7 @@ class Pix2StructImageProcessingTest(ImageProcessingSavingTestMixin, unittest.Tes ...@@ -141,7 +152,7 @@ class Pix2StructImageProcessingTest(ImageProcessingSavingTestMixin, unittest.Tes
# Initialize image_processor # Initialize image_processor
image_processor = self.image_processing_class(**self.image_processor_dict) image_processor = self.image_processing_class(**self.image_processor_dict)
# create random PIL images # create random PIL images
image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False) image_inputs = self.image_processor_tester.prepare_image_inputs(equal_resolution=False)
for image in image_inputs: for image in image_inputs:
self.assertIsInstance(image, Image.Image) self.assertIsInstance(image, Image.Image)
...@@ -183,7 +194,7 @@ class Pix2StructImageProcessingTest(ImageProcessingSavingTestMixin, unittest.Tes ...@@ -183,7 +194,7 @@ class Pix2StructImageProcessingTest(ImageProcessingSavingTestMixin, unittest.Tes
# Initialize image_processor # Initialize image_processor
image_processor = self.image_processing_class(**self.image_processor_dict) image_processor = self.image_processing_class(**self.image_processor_dict)
# create random numpy tensors # create random numpy tensors
image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, numpify=True) image_inputs = self.image_processor_tester.prepare_image_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)
...@@ -215,7 +226,7 @@ class Pix2StructImageProcessingTest(ImageProcessingSavingTestMixin, unittest.Tes ...@@ -215,7 +226,7 @@ class Pix2StructImageProcessingTest(ImageProcessingSavingTestMixin, unittest.Tes
# Initialize image_processor # Initialize image_processor
image_processor = self.image_processing_class(**self.image_processor_dict) image_processor = self.image_processing_class(**self.image_processor_dict)
# create random PyTorch tensors # create random PyTorch tensors
image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, torchify=True) image_inputs = self.image_processor_tester.prepare_image_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)
...@@ -251,7 +262,7 @@ class Pix2StructImageProcessingTest(ImageProcessingSavingTestMixin, unittest.Tes ...@@ -251,7 +262,7 @@ class Pix2StructImageProcessingTest(ImageProcessingSavingTestMixin, unittest.Tes
) )
@require_torch @require_torch
@require_vision @require_vision
class Pix2StructImageProcessingTestFourChannels(ImageProcessingSavingTestMixin, unittest.TestCase): class Pix2StructImageProcessingTestFourChannels(ImageProcessingTestMixin, unittest.TestCase):
image_processing_class = Pix2StructImageProcessor if is_vision_available() else None image_processing_class = Pix2StructImageProcessor if is_vision_available() else None
def setUp(self): def setUp(self):
...@@ -267,11 +278,11 @@ class Pix2StructImageProcessingTestFourChannels(ImageProcessingSavingTestMixin, ...@@ -267,11 +278,11 @@ class Pix2StructImageProcessingTestFourChannels(ImageProcessingSavingTestMixin,
self.assertTrue(hasattr(image_processor, "do_normalize")) self.assertTrue(hasattr(image_processor, "do_normalize"))
self.assertTrue(hasattr(image_processor, "do_convert_rgb")) self.assertTrue(hasattr(image_processor, "do_convert_rgb"))
def test_call_pil_four_channels(self): def test_call_pil(self):
# Initialize image_processor # Initialize image_processor
image_processor = self.image_processing_class(**self.image_processor_dict) image_processor = self.image_processing_class(**self.image_processor_dict)
# create random PIL images # create random PIL images
image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False) image_inputs = self.image_processor_tester.prepare_image_inputs(equal_resolution=False)
for image in image_inputs: for image in image_inputs:
self.assertIsInstance(image, Image.Image) self.assertIsInstance(image, Image.Image)
...@@ -299,3 +310,11 @@ class Pix2StructImageProcessingTestFourChannels(ImageProcessingSavingTestMixin, ...@@ -299,3 +310,11 @@ class Pix2StructImageProcessingTestFourChannels(ImageProcessingSavingTestMixin,
encoded_images.shape, encoded_images.shape,
(self.image_processor_tester.batch_size, max_patch, expected_hidden_dim), (self.image_processor_tester.batch_size, max_patch, expected_hidden_dim),
) )
@unittest.skip("Pix2StructImageProcessor does not support 4 channels yet") # FIXME Amy
def test_call_numpy(self):
return super().test_call_numpy()
@unittest.skip("Pix2StructImageProcessor does not support 4 channels yet") # FIXME Amy
def test_call_pytorch(self):
return super().test_call_torch()
tests/models/poolformer/test_image_processing_poolformer.py
View file @ 41d56ea6
...@@ -15,20 +15,13 @@ ...@@ -15,20 +15,13 @@
import unittest import unittest
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_vision_available
from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs
from ...test_image_processing_common import ImageProcessingTestMixin, prepare_image_inputs
if is_torch_available():
import torch
if is_vision_available(): if is_vision_available():
from PIL import Image
from transformers import PoolFormerImageProcessor from transformers import PoolFormerImageProcessor
...@@ -74,10 +67,24 @@ class PoolFormerImageProcessingTester(unittest.TestCase): ...@@ -74,10 +67,24 @@ class PoolFormerImageProcessingTester(unittest.TestCase):
"image_std": self.image_std, "image_std": self.image_std,
} }
def expected_output_image_shape(self, images):
return self.num_channels, self.crop_size["height"], self.crop_size["width"]
def prepare_image_inputs(self, equal_resolution=False, numpify=False, torchify=False):
return prepare_image_inputs(
batch_size=self.batch_size,
num_channels=self.num_channels,
min_resolution=self.min_resolution,
max_resolution=self.max_resolution,
equal_resolution=equal_resolution,
numpify=numpify,
torchify=torchify,
)
@require_torch @require_torch
@require_vision @require_vision
class PoolFormerImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase): class PoolFormerImageProcessingTest(ImageProcessingTestMixin, unittest.TestCase):
image_processing_class = PoolFormerImageProcessor if is_vision_available() else None image_processing_class = PoolFormerImageProcessor if is_vision_available() else None
def setUp(self): def setUp(self):
...@@ -104,103 +111,3 @@ class PoolFormerImageProcessingTest(ImageProcessingSavingTestMixin, unittest.Tes ...@@ -104,103 +111,3 @@ class PoolFormerImageProcessingTest(ImageProcessingSavingTestMixin, unittest.Tes
image_processor = self.image_processing_class.from_dict(self.image_processor_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(image_processor.size, {"shortest_edge": 42}) self.assertEqual(image_processor.size, {"shortest_edge": 42})
self.assertEqual(image_processor.crop_size, {"height": 84, "width": 84}) self.assertEqual(image_processor.crop_size, {"height": 84, "width": 84})
def test_batch_feature(self):
pass
def test_call_pil(self):
# Initialize image_processing
image_processing = self.image_processing_class(**self.image_processor_dict)
# create random PIL images
image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False)
for image in image_inputs:
self.assertIsInstance(image, Image.Image)
# Test not batched input
encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
1,
self.image_processor_tester.num_channels,
self.image_processor_tester.crop_size["height"],
self.image_processor_tester.crop_size["width"],
),
)
# Test batched
encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
self.image_processor_tester.batch_size,
self.image_processor_tester.num_channels,
self.image_processor_tester.crop_size["height"],
self.image_processor_tester.crop_size["width"],
),
)
def test_call_numpy(self):
# Initialize image_processing
image_processing = self.image_processing_class(**self.image_processor_dict)
# create random numpy tensors
image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, numpify=True)
for image in image_inputs:
self.assertIsInstance(image, np.ndarray)
# Test not batched input
encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
1,
self.image_processor_tester.num_channels,
self.image_processor_tester.crop_size["height"],
self.image_processor_tester.crop_size["width"],
),
)
# Test batched
encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
self.image_processor_tester.batch_size,
self.image_processor_tester.num_channels,
self.image_processor_tester.crop_size["height"],
self.image_processor_tester.crop_size["width"],
),
)
def test_call_pytorch(self):
# Initialize image_processing
image_processing = self.image_processing_class(**self.image_processor_dict)
# create random PyTorch tensors
image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, torchify=True)
for image in image_inputs:
self.assertIsInstance(image, torch.Tensor)
# Test not batched input
encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
1,
self.image_processor_tester.num_channels,
self.image_processor_tester.crop_size["height"],
self.image_processor_tester.crop_size["width"],
),
)
# Test batched
encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
self.image_processor_tester.batch_size,
self.image_processor_tester.num_channels,
self.image_processor_tester.crop_size["height"],
self.image_processor_tester.crop_size["width"],
),
)
tests/models/pvt/test_image_processing_pvt.py
View file @ 41d56ea6
...@@ -16,20 +16,13 @@ ...@@ -16,20 +16,13 @@
import unittest import unittest
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_vision_available
from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs
from ...test_image_processing_common import ImageProcessingTestMixin, prepare_image_inputs
if is_torch_available():
import torch
if is_vision_available(): if is_vision_available():
from PIL import Image
from transformers import PvtImageProcessor from transformers import PvtImageProcessor
...@@ -70,10 +63,24 @@ class PvtImageProcessingTester(unittest.TestCase): ...@@ -70,10 +63,24 @@ class PvtImageProcessingTester(unittest.TestCase):
"size": self.size, "size": self.size,
} }
def expected_output_image_shape(self, images):
return self.num_channels, self.size["height"], self.size["width"]
def prepare_image_inputs(self, equal_resolution=False, numpify=False, torchify=False):
return prepare_image_inputs(
batch_size=self.batch_size,
num_channels=self.num_channels,
min_resolution=self.min_resolution,
max_resolution=self.max_resolution,
equal_resolution=equal_resolution,
numpify=numpify,
torchify=torchify,
)
@require_torch @require_torch
@require_vision @require_vision
class PvtImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase): class PvtImageProcessingTest(ImageProcessingTestMixin, unittest.TestCase):
image_processing_class = PvtImageProcessor if is_vision_available() else None image_processing_class = PvtImageProcessor if is_vision_available() else None
def setUp(self): def setUp(self):
...@@ -97,102 +104,3 @@ class PvtImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase): ...@@ -97,102 +104,3 @@ class PvtImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase):
image_processor = self.image_processing_class.from_dict(self.image_processor_dict, size=42) image_processor = self.image_processing_class.from_dict(self.image_processor_dict, size=42)
self.assertEqual(image_processor.size, {"height": 42, "width": 42}) self.assertEqual(image_processor.size, {"height": 42, "width": 42})
def test_batch_feature(self):
pass
def test_call_pil(self):
# Initialize image_processing
image_processing = self.image_processing_class(**self.image_processor_dict)
# create random PIL images
image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False)
for image in image_inputs:
self.assertIsInstance(image, Image.Image)
# Test not batched input
encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
1,
self.image_processor_tester.num_channels,
self.image_processor_tester.size["height"],
self.image_processor_tester.size["width"],
),
)
# Test batched
encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
self.image_processor_tester.batch_size,
self.image_processor_tester.num_channels,
self.image_processor_tester.size["height"],
self.image_processor_tester.size["width"],
),
)
def test_call_numpy(self):
# Initialize image_processing
image_processing = self.image_processing_class(**self.image_processor_dict)
# create random numpy tensors
image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, numpify=True)
for image in image_inputs:
self.assertIsInstance(image, np.ndarray)
# Test not batched input
encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
1,
self.image_processor_tester.num_channels,
self.image_processor_tester.size["height"],
self.image_processor_tester.size["width"],
),
)
# Test batched
encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
self.image_processor_tester.batch_size,
self.image_processor_tester.num_channels,
self.image_processor_tester.size["height"],
self.image_processor_tester.size["width"],
),
)
def test_call_pytorch(self):
# Initialize image_processing
image_processing = self.image_processing_class(**self.image_processor_dict)
# create random PyTorch tensors
image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, torchify=True)
for image in image_inputs:
self.assertIsInstance(image, torch.Tensor)
# Test not batched input
encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
1,
self.image_processor_tester.num_channels,
self.image_processor_tester.size["height"],
self.image_processor_tester.size["width"],
),
)
# Test batched
encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
self.image_processor_tester.batch_size,
self.image_processor_tester.num_channels,
self.image_processor_tester.size["height"],
self.image_processor_tester.size["width"],
),
)
tests/models/segformer/test_image_processing_segformer.py
View file @ 41d56ea6
...@@ -16,13 +16,12 @@ ...@@ -16,13 +16,12 @@
import unittest import unittest
import numpy as np
from datasets import load_dataset 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_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs from ...test_image_processing_common import ImageProcessingTestMixin, prepare_image_inputs
if is_torch_available(): if is_torch_available():
...@@ -72,6 +71,20 @@ class SegformerImageProcessingTester(unittest.TestCase): ...@@ -72,6 +71,20 @@ class SegformerImageProcessingTester(unittest.TestCase):
"do_reduce_labels": self.do_reduce_labels, "do_reduce_labels": self.do_reduce_labels,
} }
def expected_output_image_shape(self, images):
return self.num_channels, self.size["height"], self.size["width"]
def prepare_image_inputs(self, equal_resolution=False, numpify=False, torchify=False):
return prepare_image_inputs(
batch_size=self.batch_size,
num_channels=self.num_channels,
min_resolution=self.min_resolution,
max_resolution=self.max_resolution,
equal_resolution=equal_resolution,
numpify=numpify,
torchify=torchify,
)
def prepare_semantic_single_inputs(): def prepare_semantic_single_inputs():
dataset = load_dataset("hf-internal-testing/fixtures_ade20k", split="test") dataset = load_dataset("hf-internal-testing/fixtures_ade20k", split="test")
...@@ -95,7 +108,7 @@ def prepare_semantic_batch_inputs(): ...@@ -95,7 +108,7 @@ def prepare_semantic_batch_inputs():
@require_torch @require_torch
@require_vision @require_vision
class SegformerImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase): class SegformerImageProcessingTest(ImageProcessingTestMixin, unittest.TestCase):
image_processing_class = SegformerImageProcessor if is_vision_available() else None image_processing_class = SegformerImageProcessor if is_vision_available() else None
def setUp(self): def setUp(self):
...@@ -123,110 +136,11 @@ class SegformerImageProcessingTest(ImageProcessingSavingTestMixin, unittest.Test ...@@ -123,110 +136,11 @@ class SegformerImageProcessingTest(ImageProcessingSavingTestMixin, unittest.Test
self.assertEqual(image_processor.size, {"height": 42, "width": 42}) self.assertEqual(image_processor.size, {"height": 42, "width": 42})
self.assertEqual(image_processor.do_reduce_labels, True) self.assertEqual(image_processor.do_reduce_labels, True)
def test_batch_feature(self):
pass
def test_call_pil(self):
# Initialize image_processing
image_processing = self.image_processing_class(**self.image_processor_dict)
# create random PIL images
image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False)
for image in image_inputs:
self.assertIsInstance(image, Image.Image)
# Test not batched input
encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
1,
self.image_processor_tester.num_channels,
self.image_processor_tester.size["height"],
self.image_processor_tester.size["width"],
),
)
# Test batched
encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
self.image_processor_tester.batch_size,
self.image_processor_tester.num_channels,
self.image_processor_tester.size["height"],
self.image_processor_tester.size["width"],
),
)
def test_call_numpy(self):
# Initialize image_processing
image_processing = self.image_processing_class(**self.image_processor_dict)
# create random numpy tensors
image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, numpify=True)
for image in image_inputs:
self.assertIsInstance(image, np.ndarray)
# Test not batched input
encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
1,
self.image_processor_tester.num_channels,
self.image_processor_tester.size["height"],
self.image_processor_tester.size["width"],
),
)
# Test batched
encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
self.image_processor_tester.batch_size,
self.image_processor_tester.num_channels,
self.image_processor_tester.size["height"],
self.image_processor_tester.size["width"],
),
)
def test_call_pytorch(self):
# Initialize image_processing
image_processing = self.image_processing_class(**self.image_processor_dict)
# create random PyTorch tensors
image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, torchify=True)
for image in image_inputs:
self.assertIsInstance(image, torch.Tensor)
# Test not batched input
encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
1,
self.image_processor_tester.num_channels,
self.image_processor_tester.size["height"],
self.image_processor_tester.size["width"],
),
)
# Test batched
encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
self.image_processor_tester.batch_size,
self.image_processor_tester.num_channels,
self.image_processor_tester.size["height"],
self.image_processor_tester.size["width"],
),
)
def test_call_segmentation_maps(self): def test_call_segmentation_maps(self):
# Initialize image_processing # Initialize image_processing
image_processing = self.image_processing_class(**self.image_processor_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.image_processor_tester, equal_resolution=False, torchify=True) image_inputs = self.image_processor_tester.prepare_image_inputs(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)
......
tests/models/swin2sr/test_image_processing_swin2sr.py
View file @ 41d56ea6
...@@ -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_image_processing_common import ImageProcessingSavingTestMixin from ...test_image_processing_common import ImageProcessingTestMixin, prepare_image_inputs
if is_torch_available(): if is_torch_available():
...@@ -67,40 +67,34 @@ class Swin2SRImageProcessingTester(unittest.TestCase): ...@@ -67,40 +67,34 @@ class Swin2SRImageProcessingTester(unittest.TestCase):
"pad_size": self.pad_size, "pad_size": self.pad_size,
} }
def prepare_inputs(self, equal_resolution=False, numpify=False, torchify=False): def expected_output_image_shape(self, images):
"""This function prepares a list of PIL images, or a list of numpy arrays if one specifies numpify=True, img = images[0]
or a list of PyTorch tensors if one specifies torchify=True.
"""
assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"
if equal_resolution:
image_inputs = []
for i in range(self.batch_size):
image_inputs.append(
np.random.randint(
255, size=(self.num_channels, self.max_resolution, self.max_resolution), dtype=np.uint8
)
)
else:
image_inputs = []
for i in range(self.batch_size):
width, height = np.random.choice(np.arange(self.min_resolution, self.max_resolution), 2)
image_inputs.append(np.random.randint(255, size=(self.num_channels, width, height), dtype=np.uint8))
if not numpify and not torchify:
# PIL expects the channel dimension as last dimension
image_inputs = [Image.fromarray(np.moveaxis(x, 0, -1)) for x in image_inputs]
if torchify: if isinstance(img, Image.Image):
image_inputs = [torch.from_numpy(x) for x in image_inputs] input_width, input_height = img.size
else:
return image_inputs input_height, input_width = img.shape[-2:]
pad_height = (input_height // self.pad_size + 1) * self.pad_size - input_height
pad_width = (input_width // self.pad_size + 1) * self.pad_size - input_width
return self.num_channels, input_height + pad_height, input_width + pad_width
def prepare_image_inputs(self, equal_resolution=False, numpify=False, torchify=False):
return prepare_image_inputs(
batch_size=self.batch_size,
num_channels=self.num_channels,
min_resolution=self.min_resolution,
max_resolution=self.max_resolution,
equal_resolution=equal_resolution,
numpify=numpify,
torchify=torchify,
)
@require_torch @require_torch
@require_vision @require_vision
class Swin2SRImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase): class Swin2SRImageProcessingTest(ImageProcessingTestMixin, unittest.TestCase):
image_processing_class = Swin2SRImageProcessor if is_vision_available() else None image_processing_class = Swin2SRImageProcessor if is_vision_available() else None
def setUp(self): def setUp(self):
...@@ -117,9 +111,6 @@ class Swin2SRImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCa ...@@ -117,9 +111,6 @@ class Swin2SRImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCa
self.assertTrue(hasattr(image_processor, "do_pad")) self.assertTrue(hasattr(image_processor, "do_pad"))
self.assertTrue(hasattr(image_processor, "pad_size")) self.assertTrue(hasattr(image_processor, "pad_size"))
def test_batch_feature(self):
pass
def calculate_expected_size(self, image): def calculate_expected_size(self, image):
old_height, old_width = get_image_size(image) old_height, old_width = get_image_size(image)
size = self.image_processor_tester.pad_size size = self.image_processor_tester.pad_size
...@@ -128,65 +119,45 @@ class Swin2SRImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCa ...@@ -128,65 +119,45 @@ class Swin2SRImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCa
pad_width = (old_width // size + 1) * size - old_width pad_width = (old_width // size + 1) * size - old_width
return old_height + pad_height, old_width + pad_width return old_height + pad_height, old_width + pad_width
# Swin2SRImageProcessor does not support batched input
def test_call_pil(self): def test_call_pil(self):
# Initialize image_processor # Initialize image_processing
image_processor = self.image_processing_class(**self.image_processor_dict) image_processing = self.image_processing_class(**self.image_processor_dict)
# create random PIL images # create random PIL images
image_inputs = self.image_processor_tester.prepare_inputs(equal_resolution=False) image_inputs = self.image_processor_tester.prepare_image_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 = image_processor(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.calculate_expected_size(np.array(image_inputs[0])) expected_output_image_shape = self.image_processor_tester.expected_output_image_shape([image_inputs[0]])
self.assertEqual( self.assertEqual(tuple(encoded_images.shape), (1, *expected_output_image_shape))
encoded_images.shape,
(
1,
self.image_processor_tester.num_channels,
expected_height,
expected_width,
),
)
# Swin2SRImageProcessor does not support batched input
def test_call_numpy(self): def test_call_numpy(self):
# Initialize image_processor # Initialize image_processing
image_processor = self.image_processing_class(**self.image_processor_dict) image_processing = self.image_processing_class(**self.image_processor_dict)
# create random numpy tensors # create random numpy tensors
image_inputs = self.image_processor_tester.prepare_inputs(equal_resolution=False, numpify=True) image_inputs = self.image_processor_tester.prepare_image_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 = image_processor(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.calculate_expected_size(image_inputs[0]) expected_output_image_shape = self.image_processor_tester.expected_output_image_shape([image_inputs[0]])
self.assertEqual( self.assertEqual(tuple(encoded_images.shape), (1, *expected_output_image_shape))
encoded_images.shape,
(
1,
self.image_processor_tester.num_channels,
expected_height,
expected_width,
),
)
# Swin2SRImageProcessor does not support batched input
def test_call_pytorch(self): def test_call_pytorch(self):
# Initialize image_processor # Initialize image_processing
image_processor = self.image_processing_class(**self.image_processor_dict) image_processing = self.image_processing_class(**self.image_processor_dict)
# create random PyTorch tensors # create random PyTorch tensors
image_inputs = self.image_processor_tester.prepare_inputs(equal_resolution=False, torchify=True) image_inputs = self.image_processor_tester.prepare_image_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 = image_processor(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.calculate_expected_size(image_inputs[0]) expected_output_image_shape = self.image_processor_tester.expected_output_image_shape([image_inputs[0]])
self.assertEqual( self.assertEqual(tuple(encoded_images.shape), (1, *expected_output_image_shape))
encoded_images.shape,
(
1,
self.image_processor_tester.num_channels,
expected_height,
expected_width,
),
)
tests/models/tvlt/test_image_processor_tvlt.py
View file @ 41d56ea6
...@@ -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_image_processing_common import ImageProcessingSavingTestMixin from ...test_image_processing_common import ImageProcessingTestMixin
if is_torch_available(): if is_torch_available():
...@@ -128,7 +128,7 @@ class TvltImageProcessorTester(unittest.TestCase): ...@@ -128,7 +128,7 @@ class TvltImageProcessorTester(unittest.TestCase):
@require_torch @require_torch
@require_vision @require_vision
class TvltImageProcessorTest(ImageProcessingSavingTestMixin, unittest.TestCase): class TvltImageProcessorTest(ImageProcessingTestMixin, unittest.TestCase):
image_processing_class = TvltImageProcessor if is_vision_available() else None image_processing_class = TvltImageProcessor if is_vision_available() else None
def setUp(self): def setUp(self):
......
tests/models/videomae/test_image_processing_videomae.py
View file @ 41d56ea6
...@@ -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_image_processing_common import ImageProcessingSavingTestMixin, prepare_video_inputs from ...test_image_processing_common import ImageProcessingTestMixin, prepare_video_inputs
if is_torch_available(): if is_torch_available():
...@@ -77,10 +77,25 @@ class VideoMAEImageProcessingTester(unittest.TestCase): ...@@ -77,10 +77,25 @@ class VideoMAEImageProcessingTester(unittest.TestCase):
"crop_size": self.crop_size, "crop_size": self.crop_size,
} }
def expected_output_image_shape(self, images):
return self.num_frames, self.num_channels, self.crop_size["height"], self.crop_size["width"]
def prepare_video_inputs(self, equal_resolution=False, numpify=False, torchify=False):
return prepare_video_inputs(
batch_size=self.batch_size,
num_frames=self.num_frames,
num_channels=self.num_channels,
min_resolution=self.min_resolution,
max_resolution=self.max_resolution,
equal_resolution=equal_resolution,
numpify=numpify,
torchify=torchify,
)
@require_torch @require_torch
@require_vision @require_vision
class VideoMAEImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase): class VideoMAEImageProcessingTest(ImageProcessingTestMixin, unittest.TestCase):
image_processing_class = VideoMAEImageProcessor if is_vision_available() else None image_processing_class = VideoMAEImageProcessor if is_vision_available() else None
def setUp(self): def setUp(self):
...@@ -108,110 +123,65 @@ class VideoMAEImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestC ...@@ -108,110 +123,65 @@ class VideoMAEImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestC
self.assertEqual(image_processor.size, {"shortest_edge": 42}) self.assertEqual(image_processor.size, {"shortest_edge": 42})
self.assertEqual(image_processor.crop_size, {"height": 84, "width": 84}) self.assertEqual(image_processor.crop_size, {"height": 84, "width": 84})
def test_batch_feature(self):
pass
def test_call_pil(self): def test_call_pil(self):
# Initialize image_processing # Initialize image_processing
image_processing = self.image_processing_class(**self.image_processor_dict) image_processing = self.image_processing_class(**self.image_processor_dict)
# create random PIL videos # create random PIL videos
video_inputs = prepare_video_inputs(self.image_processor_tester, equal_resolution=False) video_inputs = self.image_processor_tester.prepare_video_inputs(equal_resolution=False)
for video in video_inputs: for video in video_inputs:
self.assertIsInstance(video, list) self.assertIsInstance(video, list)
self.assertIsInstance(video[0], Image.Image) self.assertIsInstance(video[0], Image.Image)
# Test not batched input # Test not batched input
encoded_videos = image_processing(video_inputs[0], return_tensors="pt").pixel_values encoded_videos = image_processing(video_inputs[0], return_tensors="pt").pixel_values
self.assertEqual( expected_output_video_shape = self.image_processor_tester.expected_output_image_shape([encoded_videos[0]])
encoded_videos.shape, self.assertEqual(tuple(encoded_videos.shape), (1, *expected_output_video_shape))
(
1,
self.image_processor_tester.num_frames,
self.image_processor_tester.num_channels,
self.image_processor_tester.crop_size["height"],
self.image_processor_tester.crop_size["width"],
),
)
# Test batched # Test batched
encoded_videos = image_processing(video_inputs, return_tensors="pt").pixel_values encoded_videos = image_processing(video_inputs, return_tensors="pt").pixel_values
expected_output_video_shape = self.image_processor_tester.expected_output_image_shape(encoded_videos)
self.assertEqual( self.assertEqual(
encoded_videos.shape, tuple(encoded_videos.shape), (self.image_processor_tester.batch_size, *expected_output_video_shape)
(
self.image_processor_tester.batch_size,
self.image_processor_tester.num_frames,
self.image_processor_tester.num_channels,
self.image_processor_tester.crop_size["height"],
self.image_processor_tester.crop_size["width"],
),
) )
def test_call_numpy(self): def test_call_numpy(self):
# Initialize image_processing # Initialize image_processing
image_processing = self.image_processing_class(**self.image_processor_dict) image_processing = self.image_processing_class(**self.image_processor_dict)
# create random numpy tensors # create random numpy tensors
video_inputs = prepare_video_inputs(self.image_processor_tester, equal_resolution=False, numpify=True) video_inputs = self.image_processor_tester.prepare_video_inputs(equal_resolution=False, numpify=True)
for video in video_inputs: for video in video_inputs:
self.assertIsInstance(video, list) self.assertIsInstance(video, list)
self.assertIsInstance(video[0], np.ndarray) self.assertIsInstance(video[0], np.ndarray)
# Test not batched input # Test not batched input
encoded_videos = image_processing(video_inputs[0], return_tensors="pt").pixel_values encoded_videos = image_processing(video_inputs[0], return_tensors="pt").pixel_values
self.assertEqual( expected_output_video_shape = self.image_processor_tester.expected_output_image_shape([encoded_videos[0]])
encoded_videos.shape, self.assertEqual(tuple(encoded_videos.shape), (1, *expected_output_video_shape))
(
1,
self.image_processor_tester.num_frames,
self.image_processor_tester.num_channels,
self.image_processor_tester.crop_size["height"],
self.image_processor_tester.crop_size["width"],
),
)
# Test batched # Test batched
encoded_videos = image_processing(video_inputs, return_tensors="pt").pixel_values encoded_videos = image_processing(video_inputs, return_tensors="pt").pixel_values
expected_output_video_shape = self.image_processor_tester.expected_output_image_shape(encoded_videos)
self.assertEqual( self.assertEqual(
encoded_videos.shape, tuple(encoded_videos.shape), (self.image_processor_tester.batch_size, *expected_output_video_shape)
(
self.image_processor_tester.batch_size,
self.image_processor_tester.num_frames,
self.image_processor_tester.num_channels,
self.image_processor_tester.crop_size["height"],
self.image_processor_tester.crop_size["width"],
),
) )
def test_call_pytorch(self): def test_call_pytorch(self):
# Initialize image_processing # Initialize image_processing
image_processing = self.image_processing_class(**self.image_processor_dict) image_processing = self.image_processing_class(**self.image_processor_dict)
# create random PyTorch tensors # create random PyTorch tensors
video_inputs = prepare_video_inputs(self.image_processor_tester, equal_resolution=False, torchify=True) video_inputs = self.image_processor_tester.prepare_video_inputs(equal_resolution=False, torchify=True)
for video in video_inputs: for video in video_inputs:
self.assertIsInstance(video, list) self.assertIsInstance(video, list)
self.assertIsInstance(video[0], torch.Tensor) self.assertIsInstance(video[0], torch.Tensor)
# Test not batched input # Test not batched input
encoded_videos = image_processing(video_inputs[0], return_tensors="pt").pixel_values encoded_videos = image_processing(video_inputs[0], return_tensors="pt").pixel_values
self.assertEqual( expected_output_video_shape = self.image_processor_tester.expected_output_image_shape([encoded_videos[0]])
encoded_videos.shape, self.assertEqual(tuple(encoded_videos.shape), (1, *expected_output_video_shape))
(
1,
self.image_processor_tester.num_frames,
self.image_processor_tester.num_channels,
self.image_processor_tester.crop_size["height"],
self.image_processor_tester.crop_size["width"],
),
)
# Test batched # Test batched
encoded_videos = image_processing(video_inputs, return_tensors="pt").pixel_values encoded_videos = image_processing(video_inputs, return_tensors="pt").pixel_values
expected_output_video_shape = self.image_processor_tester.expected_output_image_shape(encoded_videos)
self.assertEqual( self.assertEqual(
encoded_videos.shape, tuple(encoded_videos.shape), (self.image_processor_tester.batch_size, *expected_output_video_shape)
(
self.image_processor_tester.batch_size,
self.image_processor_tester.num_frames,
self.image_processor_tester.num_channels,
self.image_processor_tester.crop_size["height"],
self.image_processor_tester.crop_size["width"],
),
) )
tests/models/vilt/test_image_processing_vilt.py
View file @ 41d56ea6
...@@ -16,16 +16,11 @@ ...@@ -16,16 +16,11 @@
import unittest import unittest
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_vision_available
from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs
from ...test_image_processing_common import ImageProcessingTestMixin, prepare_image_inputs
if is_torch_available():
import torch
if is_vision_available(): if is_vision_available():
from PIL import Image from PIL import Image
...@@ -113,10 +108,25 @@ class ViltImageProcessingTester(unittest.TestCase): ...@@ -113,10 +108,25 @@ class ViltImageProcessingTester(unittest.TestCase):
return expected_height, expected_width return expected_height, expected_width
def expected_output_image_shape(self, images):
height, width = self.get_expected_values(images, batched=True)
return (self.num_channels, height, width)
def prepare_image_inputs(self, equal_resolution=False, numpify=False, torchify=False):
return prepare_image_inputs(
batch_size=self.batch_size,
num_channels=self.num_channels,
min_resolution=self.min_resolution,
max_resolution=self.max_resolution,
equal_resolution=equal_resolution,
numpify=numpify,
torchify=torchify,
)
@require_torch @require_torch
@require_vision @require_vision
class ViltImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase): class ViltImageProcessingTest(ImageProcessingTestMixin, unittest.TestCase):
image_processing_class = ViltImageProcessor if is_vision_available() else None image_processing_class = ViltImageProcessor if is_vision_available() else None
def setUp(self): def setUp(self):
...@@ -141,99 +151,3 @@ class ViltImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase) ...@@ -141,99 +151,3 @@ class ViltImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase)
image_processor = self.image_processing_class.from_dict(self.image_processor_dict, size=42) image_processor = self.image_processing_class.from_dict(self.image_processor_dict, size=42)
self.assertEqual(image_processor.size, {"shortest_edge": 42}) self.assertEqual(image_processor.size, {"shortest_edge": 42})
def test_batch_feature(self):
pass
def test_call_pil(self):
# Initialize image_processing
image_processing = self.image_processing_class(**self.image_processor_dict)
# create random PIL images
image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False)
for image in image_inputs:
self.assertIsInstance(image, Image.Image)
# Test not batched input
encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values
expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs)
self.assertEqual(
encoded_images.shape,
(1, self.image_processor_tester.num_channels, expected_height, expected_width),
)
# Test batched
encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values
expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs, batched=True)
self.assertEqual(
encoded_images.shape,
(
self.image_processor_tester.batch_size,
self.image_processor_tester.num_channels,
expected_height,
expected_width,
),
)
def test_call_numpy(self):
# Initialize image_processing
image_processing = self.image_processing_class(**self.image_processor_dict)
# create random numpy tensors
image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, numpify=True)
for image in image_inputs:
self.assertIsInstance(image, np.ndarray)
# Test not batched input
encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values
expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs)
self.assertEqual(
encoded_images.shape,
(1, self.image_processor_tester.num_channels, expected_height, expected_width),
)
# Test batched
encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values
expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs, batched=True)
self.assertEqual(
encoded_images.shape,
(
self.image_processor_tester.batch_size,
self.image_processor_tester.num_channels,
expected_height,
expected_width,
),
)
def test_call_pytorch(self):
# Initialize image_processing
image_processing = self.image_processing_class(**self.image_processor_dict)
# create random PyTorch tensors
image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, torchify=True)
for image in image_inputs:
self.assertIsInstance(image, torch.Tensor)
# Test not batched input
encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values
expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs)
self.assertEqual(
encoded_images.shape,
(1, self.image_processor_tester.num_channels, expected_height, expected_width),
)
# Test batched
encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values
expected_height, expected_width = self.image_processor_tester.get_expected_values(image_inputs, batched=True)
self.assertEqual(
encoded_images.shape,
(
self.image_processor_tester.batch_size,
self.image_processor_tester.num_channels,
expected_height,
expected_width,
),
)
tests/models/vit/test_image_processing_vit.py
View file @ 41d56ea6
...@@ -16,20 +16,13 @@ ...@@ -16,20 +16,13 @@
import unittest import unittest
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_vision_available
from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs
from ...test_image_processing_common import ImageProcessingTestMixin, prepare_image_inputs
if is_torch_available():
import torch
if is_vision_available(): if is_vision_available():
from PIL import Image
from transformers import ViTImageProcessor from transformers import ViTImageProcessor
...@@ -70,10 +63,24 @@ class ViTImageProcessingTester(unittest.TestCase): ...@@ -70,10 +63,24 @@ class ViTImageProcessingTester(unittest.TestCase):
"size": self.size, "size": self.size,
} }
def expected_output_image_shape(self, images):
return self.num_channels, self.size["height"], self.size["width"]
def prepare_image_inputs(self, equal_resolution=False, numpify=False, torchify=False):
return prepare_image_inputs(
batch_size=self.batch_size,
num_channels=self.num_channels,
min_resolution=self.min_resolution,
max_resolution=self.max_resolution,
equal_resolution=equal_resolution,
numpify=numpify,
torchify=torchify,
)
@require_torch @require_torch
@require_vision @require_vision
class ViTImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase): class ViTImageProcessingTest(ImageProcessingTestMixin, unittest.TestCase):
image_processing_class = ViTImageProcessor if is_vision_available() else None image_processing_class = ViTImageProcessor if is_vision_available() else None
def setUp(self): def setUp(self):
...@@ -97,102 +104,3 @@ class ViTImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase): ...@@ -97,102 +104,3 @@ class ViTImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase):
image_processor = self.image_processing_class.from_dict(self.image_processor_dict, size=42) image_processor = self.image_processing_class.from_dict(self.image_processor_dict, size=42)
self.assertEqual(image_processor.size, {"height": 42, "width": 42}) self.assertEqual(image_processor.size, {"height": 42, "width": 42})
def test_batch_feature(self):
pass
def test_call_pil(self):
# Initialize image_processing
image_processing = self.image_processing_class(**self.image_processor_dict)
# create random PIL images
image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False)
for image in image_inputs:
self.assertIsInstance(image, Image.Image)
# Test not batched input
encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
1,
self.image_processor_tester.num_channels,
self.image_processor_tester.size["height"],
self.image_processor_tester.size["width"],
),
)
# Test batched
encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
self.image_processor_tester.batch_size,
self.image_processor_tester.num_channels,
self.image_processor_tester.size["height"],
self.image_processor_tester.size["width"],
),
)
def test_call_numpy(self):
# Initialize image_processing
image_processing = self.image_processing_class(**self.image_processor_dict)
# create random numpy tensors
image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, numpify=True)
for image in image_inputs:
self.assertIsInstance(image, np.ndarray)
# Test not batched input
encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
1,
self.image_processor_tester.num_channels,
self.image_processor_tester.size["height"],
self.image_processor_tester.size["width"],
),
)
# Test batched
encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
self.image_processor_tester.batch_size,
self.image_processor_tester.num_channels,
self.image_processor_tester.size["height"],
self.image_processor_tester.size["width"],
),
)
def test_call_pytorch(self):
# Initialize image_processing
image_processing = self.image_processing_class(**self.image_processor_dict)
# create random PyTorch tensors
image_inputs = prepare_image_inputs(self.image_processor_tester, equal_resolution=False, torchify=True)
for image in image_inputs:
self.assertIsInstance(image, torch.Tensor)
# Test not batched input
encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
1,
self.image_processor_tester.num_channels,
self.image_processor_tester.size["height"],
self.image_processor_tester.size["width"],
),
)
# Test batched
encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values
self.assertEqual(
encoded_images.shape,
(
self.image_processor_tester.batch_size,
self.image_processor_tester.num_channels,
self.image_processor_tester.size["height"],
self.image_processor_tester.size["width"],
),
)
tests/models/vivit/test_image_processing_vivit.py
View file @ 41d56ea6
...@@ -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_image_processing_common import ImageProcessingSavingTestMixin, prepare_video_inputs from ...test_image_processing_common import ImageProcessingTestMixin, prepare_video_inputs
if is_torch_available(): if is_torch_available():
...@@ -77,10 +77,25 @@ class VivitImageProcessingTester(unittest.TestCase): ...@@ -77,10 +77,25 @@ class VivitImageProcessingTester(unittest.TestCase):
"crop_size": self.crop_size, "crop_size": self.crop_size,
} }
def expected_output_image_shape(self, images):
return self.num_frames, self.num_channels, self.crop_size["height"], self.crop_size["width"]
def prepare_video_inputs(self, equal_resolution=False, numpify=False, torchify=False):
return prepare_video_inputs(
batch_size=self.batch_size,
num_channels=self.num_channels,
num_frames=self.num_frames,
min_resolution=self.min_resolution,
max_resolution=self.max_resolution,
equal_resolution=equal_resolution,
numpify=numpify,
torchify=torchify,
)
@require_torch @require_torch
@require_vision @require_vision
class VivitImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase): class VivitImageProcessingTest(ImageProcessingTestMixin, unittest.TestCase):
image_processing_class = VivitImageProcessor if is_vision_available() else None image_processing_class = VivitImageProcessor if is_vision_available() else None
def setUp(self): def setUp(self):
...@@ -108,121 +123,79 @@ class VivitImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase ...@@ -108,121 +123,79 @@ class VivitImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase
self.assertEqual(image_processor.size, {"shortest_edge": 42}) self.assertEqual(image_processor.size, {"shortest_edge": 42})
self.assertEqual(image_processor.crop_size, {"height": 84, "width": 84}) self.assertEqual(image_processor.crop_size, {"height": 84, "width": 84})
def test_rescale(self):
# ViVit optionally rescales between -1 and 1 instead of the usual 0 and 1
image = np.arange(0, 256, 1, dtype=np.uint8).reshape(1, 8, 32)
image_processor = self.image_processing_class(**self.image_processor_dict)
rescaled_image = image_processor.rescale(image, scale=1 / 127.5)
expected_image = (image * (1 / 127.5)).astype(np.float32) - 1
self.assertTrue(np.allclose(rescaled_image, expected_image))
rescaled_image = image_processor.rescale(image, scale=1 / 255, offset=False)
expected_image = (image / 255.0).astype(np.float32)
self.assertTrue(np.allclose(rescaled_image, expected_image))
def test_call_pil(self): def test_call_pil(self):
# Initialize image_processing # Initialize image_processing
image_processing = self.image_processing_class(**self.image_processor_dict) image_processing = self.image_processing_class(**self.image_processor_dict)
# create random PIL videos # create random PIL videos
video_inputs = prepare_video_inputs(self.image_processor_tester, equal_resolution=False) video_inputs = self.image_processor_tester.prepare_video_inputs(equal_resolution=False)
for video in video_inputs: for video in video_inputs:
self.assertIsInstance(video, list) self.assertIsInstance(video, list)
self.assertIsInstance(video[0], Image.Image) self.assertIsInstance(video[0], Image.Image)
# Test not batched input # Test not batched input
encoded_videos = image_processing(video_inputs[0], return_tensors="pt").pixel_values encoded_videos = image_processing(video_inputs[0], return_tensors="pt").pixel_values
self.assertEqual( expected_output_video_shape = self.image_processor_tester.expected_output_image_shape([encoded_videos[0]])
encoded_videos.shape, self.assertEqual(tuple(encoded_videos.shape), (1, *expected_output_video_shape))
(
1,
self.image_processor_tester.num_frames,
self.image_processor_tester.num_channels,
self.image_processor_tester.crop_size["height"],
self.image_processor_tester.crop_size["width"],
),
)
# Test batched # Test batched
encoded_videos = image_processing(video_inputs, return_tensors="pt").pixel_values encoded_videos = image_processing(video_inputs, return_tensors="pt").pixel_values
expected_output_video_shape = self.image_processor_tester.expected_output_image_shape(encoded_videos)
self.assertEqual( self.assertEqual(
encoded_videos.shape, tuple(encoded_videos.shape), (self.image_processor_tester.batch_size, *expected_output_video_shape)
(
self.image_processor_tester.batch_size,
self.image_processor_tester.num_frames,
self.image_processor_tester.num_channels,
self.image_processor_tester.crop_size["height"],
self.image_processor_tester.crop_size["width"],
),
) )
def test_call_numpy(self): def test_call_numpy(self):
# Initialize image_processing # Initialize image_processing
image_processing = self.image_processing_class(**self.image_processor_dict) image_processing = self.image_processing_class(**self.image_processor_dict)
# create random numpy tensors # create random numpy tensors
video_inputs = prepare_video_inputs(self.image_processor_tester, equal_resolution=False, numpify=True) video_inputs = self.image_processor_tester.prepare_video_inputs(equal_resolution=False, numpify=True)
for video in video_inputs: for video in video_inputs:
self.assertIsInstance(video, list) self.assertIsInstance(video, list)
self.assertIsInstance(video[0], np.ndarray) self.assertIsInstance(video[0], np.ndarray)
# Test not batched input # Test not batched input
encoded_videos = image_processing(video_inputs[0], return_tensors="pt").pixel_values encoded_videos = image_processing(video_inputs[0], return_tensors="pt").pixel_values
self.assertEqual( expected_output_video_shape = self.image_processor_tester.expected_output_image_shape([encoded_videos[0]])
encoded_videos.shape, self.assertEqual(tuple(encoded_videos.shape), (1, *expected_output_video_shape))
(
1,
self.image_processor_tester.num_frames,
self.image_processor_tester.num_channels,
self.image_processor_tester.crop_size["height"],
self.image_processor_tester.crop_size["width"],
),
)
# Test batched # Test batched
encoded_videos = image_processing(video_inputs, return_tensors="pt").pixel_values encoded_videos = image_processing(video_inputs, return_tensors="pt").pixel_values
expected_output_video_shape = self.image_processor_tester.expected_output_image_shape(encoded_videos)
self.assertEqual( self.assertEqual(
encoded_videos.shape, tuple(encoded_videos.shape), (self.image_processor_tester.batch_size, *expected_output_video_shape)
(
self.image_processor_tester.batch_size,
self.image_processor_tester.num_frames,
self.image_processor_tester.num_channels,
self.image_processor_tester.crop_size["height"],
self.image_processor_tester.crop_size["width"],
),
) )
def test_call_pytorch(self): def test_call_pytorch(self):
# Initialize image_processing # Initialize image_processing
image_processing = self.image_processing_class(**self.image_processor_dict) image_processing = self.image_processing_class(**self.image_processor_dict)
# create random PyTorch tensors # create random PyTorch tensors
video_inputs = prepare_video_inputs(self.image_processor_tester, equal_resolution=False, torchify=True) video_inputs = self.image_processor_tester.prepare_video_inputs(equal_resolution=False, torchify=True)
for video in video_inputs: for video in video_inputs:
self.assertIsInstance(video, list) self.assertIsInstance(video, list)
self.assertIsInstance(video[0], torch.Tensor) self.assertIsInstance(video[0], torch.Tensor)
# Test not batched input # Test not batched input
encoded_videos = image_processing(video_inputs[0], return_tensors="pt").pixel_values encoded_videos = image_processing(video_inputs[0], return_tensors="pt").pixel_values
self.assertEqual( expected_output_video_shape = self.image_processor_tester.expected_output_image_shape([encoded_videos[0]])
encoded_videos.shape, self.assertEqual(tuple(encoded_videos.shape), (1, *expected_output_video_shape))
(
1,
self.image_processor_tester.num_frames,
self.image_processor_tester.num_channels,
self.image_processor_tester.crop_size["height"],
self.image_processor_tester.crop_size["width"],
),
)
# Test batched # Test batched
encoded_videos = image_processing(video_inputs, return_tensors="pt").pixel_values encoded_videos = image_processing(video_inputs, return_tensors="pt").pixel_values
expected_output_video_shape = self.image_processor_tester.expected_output_image_shape(encoded_videos)
self.assertEqual( self.assertEqual(
encoded_videos.shape, tuple(encoded_videos.shape), (self.image_processor_tester.batch_size, *expected_output_video_shape)
(
self.image_processor_tester.batch_size,
self.image_processor_tester.num_frames,
self.image_processor_tester.num_channels,
self.image_processor_tester.crop_size["height"],
self.image_processor_tester.crop_size["width"],
),
) )
def test_rescale(self):
# ViVit optionally rescales between -1 and 1 instead of the usual 0 and 1
image = np.arange(0, 256, 1, dtype=np.uint8).reshape(1, 8, 32)
image_processor = self.image_processing_class(**self.image_processor_dict)
rescaled_image = image_processor.rescale(image, scale=1 / 127.5)
expected_image = (image * (1 / 127.5)).astype(np.float32) - 1
self.assertTrue(np.allclose(rescaled_image, expected_image))
rescaled_image = image_processor.rescale(image, scale=1 / 255, offset=False)
expected_image = (image / 255.0).astype(np.float32)
self.assertTrue(np.allclose(rescaled_image, expected_image))
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