riaz.somc/transformers
1
0
Fork 0
mirror of https://github.com/huggingface/transformers.git synced 2025-07-31 02:02:21 +06:00
Code Issues Actions 33 Packages Projects Releases Wiki Activity

Fast image processor for VitMatte added and bug in slow version fixed (#37616)

Browse Source 
* added fast image processor for VitMatte including updated and new tests, fixed a bug in the slow image processor that processed images incorrectly for input format ChannelDimension.FIRST in which case the trimaps were not added in the correct dimension, this bug was also reflected in the tests through incorretly shaped trimaps being passed

* final edits for fast vitmatte image processor and tests

* final edits for fast vitmatte image processor and tests

---------

Co-authored-by: Yoni Gozlan <74535834+yonigozlan@users.noreply.github.com>
This commit is contained in:
Henrik Matthiesen 2025-04-28 20:51:50 +02:00 committed by GitHub
parent 65e940208c
commit a847d4aa6b
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
6 changed files with 413 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
docs/source/en/model_doc/vitmatte.md
View File

@ -53,6 +53,11 @@ The model expects both the image and trimap (concatenated) as input. Use [`ViTMa
[[autodoc]] VitMatteImageProcessor
- preprocess
## VitMatteImageProcessorFast
[[autodoc]] VitMatteImageProcessorFast
- preprocess
## VitMatteForImageMatting
[[autodoc]] VitMatteForImageMatting

2
src/transformers/models/auto/image_processing_auto.py
View File

@ -167,7 +167,7 @@ else:
("vit_hybrid", ("ViTHybridImageProcessor",)),
("vit_mae", ("ViTImageProcessor", "ViTImageProcessorFast")),
("vit_msn", ("ViTImageProcessor", "ViTImageProcessorFast")),
("vitmatte", ("VitMatteImageProcessor",)),
("vitmatte", ("VitMatteImageProcessor", "VitMatteImageProcessorFast")),
("xclip", ("CLIPImageProcessor", "CLIPImageProcessorFast")),
("yolos", ("YolosImageProcessor", "YolosImageProcessorFast")),
("zoedepth", ("ZoeDepthImageProcessor",)),

1
src/transformers/models/vitmatte/__init__.py
View File

@ -20,6 +20,7 @@ from ...utils.import_utils import define_import_structure
if TYPE_CHECKING:
from .configuration_vitmatte import *
from .image_processing_vitmatte import *
from .image_processing_vitmatte_fast import *
from .modeling_vitmatte import *
else:
import sys

4
src/transformers/models/vitmatte/image_processing_vitmatte.py
View File

@ -250,8 +250,10 @@ class VitMatteImageProcessor(BaseImageProcessor):
]
# concatenate images and trimaps
axis = -1 if input_data_format == ChannelDimension.LAST else 0
images = [
np.concatenate([image, np.expand_dims(trimap, axis=-1)], axis=-1) for image, trimap in zip(images, trimaps)
np.concatenate([image, np.expand_dims(trimap, axis=axis)], axis=axis)
for image, trimap in zip(images, trimaps)
]
if do_pad:

240
src/transformers/models/vitmatte/image_processing_vitmatte_fast.py Normal file
View File

@ -0,0 +1,240 @@
# coding=utf-8
# Copyright 2025 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Fast Image processor class for ViTMatte."""
from functools import partial
from typing import Optional, Union
from ...image_processing_utils import BatchFeature
from ...image_processing_utils_fast import (
BASE_IMAGE_PROCESSOR_FAST_DOCSTRING,
BASE_IMAGE_PROCESSOR_FAST_DOCSTRING_PREPROCESS,
BaseImageProcessorFast,
DefaultFastImageProcessorKwargs,
group_images_by_shape,
reorder_images,
)
from ...image_utils import (
IMAGENET_STANDARD_MEAN,
IMAGENET_STANDARD_STD,
ChannelDimension,
ImageInput,
get_image_size,
make_list_of_images,
validate_kwargs,
)
from ...processing_utils import Unpack
from ...utils import (
TensorType,
add_start_docstrings,
filter_out_non_signature_kwargs,
is_torch_available,
is_torchvision_available,
is_torchvision_v2_available,
logging,
)
if is_torch_available():
import torch
if is_torchvision_available():
if is_torchvision_v2_available():
from torchvision.transforms.v2 import functional as F
else:
from torchvision.transforms import functional as F
logger = logging.get_logger(__name__)
class VitMatteFastImageProcessorKwargs(DefaultFastImageProcessorKwargs):
do_pad: Optional[bool]
size_divisibility: int
@add_start_docstrings(
"Constructs a fast VitMatte image processor.",
BASE_IMAGE_PROCESSOR_FAST_DOCSTRING,
"""
do_pad (`bool`, *optional*, defaults to `True`):
Whether to pad the image to make the width and height divisible by `size_divisibility`. Can be overridden
by the `do_pad` parameter in the `preprocess` method.
size_divisibility (`int`, *optional*, defaults to 32):
The width and height of the image will be padded to be divisible by this number.
""",
)
class VitMatteImageProcessorFast(BaseImageProcessorFast):
do_rescale: bool = True
rescale_factor: Union[int, float] = 1 / 255
do_normalize: bool = True
image_mean: Optional[Union[float, list[float]]] = IMAGENET_STANDARD_MEAN
image_std: Optional[Union[float, list[float]]] = IMAGENET_STANDARD_STD
do_pad: bool = True
size_divisibility: int = 32
valid_kwargs = VitMatteFastImageProcessorKwargs
def __init__(self, **kwargs: Unpack[VitMatteFastImageProcessorKwargs]) -> None:
super().__init__(**kwargs)
@add_start_docstrings(
BASE_IMAGE_PROCESSOR_FAST_DOCSTRING_PREPROCESS,
"""
do_pad (`bool`, *optional*, defaults to `True`):
Whether to pad the image to make the width and height divisible by `size_divisibility`. Can be overridden
by the `do_pad` parameter in the `preprocess` method.
size_divisibility (`int`, *optional*, defaults to 32):
The width and height of the image will be padded to be divisible by this number.
""",
)
def preprocess(
self,
images: list["torch.Tensor"],
trimaps: list["torch.Tensor"],
**kwargs: Unpack[VitMatteFastImageProcessorKwargs],
) -> BatchFeature:
validate_kwargs(captured_kwargs=kwargs.keys(), valid_processor_keys=self.valid_kwargs.__annotations__.keys())
# Set default kwargs from self. This ensures that if a kwarg is not provided
# by the user, it gets its default value from the instance, or is set to None.
for kwarg_name in self.valid_kwargs.__annotations__:
kwargs.setdefault(kwarg_name, getattr(self, kwarg_name, None))
# Extract parameters that are only used for preparing the input images
do_convert_rgb = kwargs.pop("do_convert_rgb")
input_data_format = kwargs.pop("input_data_format")
device = kwargs.pop("device")
# Prepare input images
images = self._prepare_input_images(
images=images, do_convert_rgb=do_convert_rgb, input_data_format=input_data_format, device=device
)
# Prepare input trimaps
trimaps = self._prepare_input_trimaps(trimaps=trimaps, device=device)
# Update kwargs that need further processing before being validated
kwargs = self._further_process_kwargs(**kwargs)
# Validate kwargs
self._validate_preprocess_kwargs(**kwargs)
# Pop kwargs that are not needed in _preprocess
kwargs.pop("resample")
kwargs.pop("default_to_square")
kwargs.pop("data_format")
kwargs.pop("do_resize")
kwargs.pop("do_center_crop")
kwargs.pop("size")
kwargs.pop("crop_size")
return self._preprocess(images=images, trimaps=trimaps, **kwargs)
def _prepare_input_trimaps(
self, trimaps: ImageInput, device: Optional["torch.device"] = None
) -> list["torch.Tensor"]:
"""
Prepare input trimaps for processing,m this can not yet deal with nested list
Args:
trimaps ('ImageInout):
The input trimaps to be process, should not be nested
device('Optional['torch.device'] defaults to 'self.device'):
The device to process the trimaps on
Returns:
list['torch.Tensor']:
Input trimaps converted to a list of tensors
"""
# from batch or single image to list, and insert channel dimension
trimaps = make_list_of_images(trimaps, expected_ndims=2)
# passing ChannelDimension.First achieves correct functionality on grayscale/single channel
process_image_fn = partial(
self._process_image,
input_data_format=ChannelDimension.FIRST,
device=device,
)
processed_trimaps = []
for trimap in trimaps:
processed_trimaps.append(torch.unsqueeze(process_image_fn(trimap), dim=0))
return processed_trimaps
def _pad_image(
self,
images: "torch.tensor",
size_divisibility: int = 32,
) -> "torch.tensor":
"""
Pads an image or batched images constantly so that width and height are divisible by size_divisibility
Args:
image (`torch,tensor`):
Image to pad.
size_divisibility (`int`, *optional*, defaults to 32):
The width and height of the image will be padded to be divisible by this number.
"""
height, width = get_image_size(images, channel_dim=ChannelDimension.FIRST)
pad_height = 0 if height % size_divisibility == 0 else size_divisibility - height % size_divisibility
pad_width = 0 if width % size_divisibility == 0 else size_divisibility - width % size_divisibility
if pad_width + pad_height > 0:
padding = (0, 0, pad_width, pad_height)
images = F.pad(images, padding)
return images
@filter_out_non_signature_kwargs()
def _preprocess(
self,
images: list["torch.Tensor"],
trimaps: list["torch.Tensor"],
do_rescale: Optional[bool] = None,
rescale_factor: Optional[float] = None,
do_normalize: Optional[bool] = None,
image_mean: Optional[Union[float, list[float]]] = None,
image_std: Optional[Union[float, list[float]]] = None,
do_pad: Optional[bool] = None,
size_divisibility: Optional[int] = None,
return_tensors: Optional[Union[str, TensorType]] = None,
) -> BatchFeature:
grouped_images, grouped_images_index = group_images_by_shape(images)
grouped_trimaps, grouped_trimaps_index = group_images_by_shape(trimaps)
processed_images_grouped = {}
for shape in grouped_images:
stacked_images = grouped_images[shape]
stacked_trimaps = grouped_trimaps[shape]
# Fused rescale and normalize
stacked_images = self.rescale_and_normalize(
stacked_images, do_rescale, rescale_factor, do_normalize, image_mean, image_std
)
stacked_trimaps = self.rescale_and_normalize(
stacked_trimaps, do_rescale, rescale_factor, False, image_mean, image_std
)
stacked_images = torch.cat([stacked_images, stacked_trimaps], dim=1)
if do_pad:
stacked_images = self._pad_image(stacked_images, self.size_divisibility)
processed_images_grouped[shape] = stacked_images
processed_images = reorder_images(processed_images_grouped, grouped_images_index)
processed_images = torch.stack(processed_images, dim=0) if return_tensors else processed_images
return BatchFeature(data={"pixel_values": processed_images}, tensor_type=return_tensors)
__all__ = ["VitMatteImageProcessorFast"]

206
tests/models/vitmatte/test_image_processing_vitmatte.py
View File

@ -13,13 +13,15 @@
# limitations under the License.
import time
import unittest
import warnings
import numpy as np
import requests
from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available
from transformers.testing_utils import is_flaky, require_torch, require_vision
from transformers.utils import is_torch_available, is_torchvision_available, is_vision_available
from ...test_image_processing_common import ImageProcessingTestMixin, prepare_image_inputs
@ -33,6 +35,9 @@ if is_vision_available():
from transformers import VitMatteImageProcessor
if is_torchvision_available():
from transformers import VitMatteImageProcessorFast
class VitMatteImageProcessingTester:
def __init__(
@ -92,6 +97,7 @@ class VitMatteImageProcessingTester:
@require_vision
class VitMatteImageProcessingTest(ImageProcessingTestMixin, unittest.TestCase):
image_processing_class = VitMatteImageProcessor if is_vision_available() else None
fast_image_processing_class = VitMatteImageProcessorFast if is_torchvision_available() else None
def setUp(self):
super().setUp()
@ -102,18 +108,17 @@ class VitMatteImageProcessingTest(ImageProcessingTestMixin, unittest.TestCase):
return self.image_processor_tester.prepare_image_processor_dict()
def test_image_processor_properties(self):
image_processing = self.image_processing_class(**self.image_processor_dict)
self.assertTrue(hasattr(image_processing, "image_mean"))
self.assertTrue(hasattr(image_processing, "image_std"))
self.assertTrue(hasattr(image_processing, "do_normalize"))
self.assertTrue(hasattr(image_processing, "do_rescale"))
self.assertTrue(hasattr(image_processing, "rescale_factor"))
self.assertTrue(hasattr(image_processing, "do_pad"))
self.assertTrue(hasattr(image_processing, "size_divisibility"))
for image_processing_class in self.image_processor_list:
image_processing = image_processing_class(**self.image_processor_dict)
self.assertTrue(hasattr(image_processing, "image_mean"))
self.assertTrue(hasattr(image_processing, "image_std"))
self.assertTrue(hasattr(image_processing, "do_normalize"))
self.assertTrue(hasattr(image_processing, "do_rescale"))
self.assertTrue(hasattr(image_processing, "rescale_factor"))
self.assertTrue(hasattr(image_processing, "do_pad"))
self.assertTrue(hasattr(image_processing, "size_divisibility"))
def test_call_numpy(self):
# Initialize image_processing
image_processing = self.image_processing_class(**self.image_processor_dict)
# create random numpy tensors
image_inputs = self.image_processor_tester.prepare_image_inputs(equal_resolution=False, numpify=True)
for image in image_inputs:
@ -122,15 +127,16 @@ class VitMatteImageProcessingTest(ImageProcessingTestMixin, unittest.TestCase):
# Test not batched input (image processor does not support batched inputs)
image = image_inputs[0]
trimap = np.random.randint(0, 3, size=image.shape[:2])
encoded_images = image_processing(images=image, trimaps=trimap, return_tensors="pt").pixel_values
for image_processing_class in self.image_processor_list:
image_processing = image_processing_class(**self.image_processor_dict)
encoded_images = image_processing(images=image, trimaps=trimap, return_tensors="pt").pixel_values
# Verify that width and height can be divided by size_divisibility
self.assertTrue(encoded_images.shape[-1] % self.image_processor_tester.size_divisibility == 0)
self.assertTrue(encoded_images.shape[-2] % self.image_processor_tester.size_divisibility == 0)
# Verify that width and height can be divided by size_divisibility and that correct dimensions got merged
self.assertTrue(encoded_images.shape[-1] % self.image_processor_tester.size_divisibility == 0)
self.assertTrue(encoded_images.shape[-2] % self.image_processor_tester.size_divisibility == 0)
self.assertTrue(encoded_images.shape[-3] == 4)
def test_call_pytorch(self):
# Initialize image_processing
image_processing = self.image_processing_class(**self.image_processor_dict)
# create random PyTorch tensors
image_inputs = self.image_processor_tester.prepare_image_inputs(equal_resolution=False, torchify=True)
@ -139,16 +145,37 @@ class VitMatteImageProcessingTest(ImageProcessingTestMixin, unittest.TestCase):
# Test not batched input (image processor does not support batched inputs)
image = image_inputs[0]
trimap = np.random.randint(0, 3, size=image.shape[:2])
encoded_images = image_processing(images=image, trimaps=trimap, return_tensors="pt").pixel_values
trimap = np.random.randint(0, 3, size=image.shape[1:])
for image_processing_class in self.image_processor_list:
image_processing = image_processing_class(**self.image_processor_dict)
encoded_images = image_processing(images=image, trimaps=trimap, return_tensors="pt").pixel_values
# Verify that width and height can be divided by size_divisibility
self.assertTrue(encoded_images.shape[-1] % self.image_processor_tester.size_divisibility == 0)
self.assertTrue(encoded_images.shape[-2] % self.image_processor_tester.size_divisibility == 0)
# Verify that width and height can be divided by size_divisibility and that correct dimensions got merged
self.assertTrue(encoded_images.shape[-1] % self.image_processor_tester.size_divisibility == 0)
self.assertTrue(encoded_images.shape[-2] % self.image_processor_tester.size_divisibility == 0)
self.assertTrue(encoded_images.shape[-3] == 4)
# create batched tensors
image_inputs = self.image_processor_tester.prepare_image_inputs(equal_resolution=True, torchify=True)
image_input = torch.stack(image_inputs, dim=0)
self.assertIsInstance(image_input, torch.Tensor)
self.assertTrue(image_input.shape[1] == 3)
trimap_shape = [image_input.shape[0]] + [1] + list(image_input.shape)[2:]
trimap_input = torch.randint(0, 3, trimap_shape, dtype=torch.uint8)
self.assertIsInstance(trimap_input, torch.Tensor)
self.assertTrue(trimap_input.shape[1] == 1)
for image_processing_class in self.image_processor_list:
image_processing = image_processing_class(**self.image_processor_dict)
encoded_images = image_processing(images=image, trimaps=trimap, return_tensors="pt").pixel_values
# Verify that width and height can be divided by size_divisibility and that correct dimensions got merged
self.assertTrue(encoded_images.shape[-1] % self.image_processor_tester.size_divisibility == 0)
self.assertTrue(encoded_images.shape[-2] % self.image_processor_tester.size_divisibility == 0)
self.assertTrue(encoded_images.shape[-3] == 4)
def test_call_pil(self):
# Initialize image_processing
image_processing = self.image_processing_class(**self.image_processor_dict)
# create random PIL images
image_inputs = self.image_processor_tester.prepare_image_inputs(equal_resolution=False)
for image in image_inputs:
@ -157,16 +184,17 @@ class VitMatteImageProcessingTest(ImageProcessingTestMixin, unittest.TestCase):
# Test not batched input (image processor does not support batched inputs)
image = image_inputs[0]
trimap = np.random.randint(0, 3, size=image.size[::-1])
encoded_images = image_processing(images=image, trimaps=trimap, return_tensors="pt").pixel_values
for image_processing_class in self.image_processor_list:
image_processing = image_processing_class(**self.image_processor_dict)
encoded_images = image_processing(images=image, trimaps=trimap, return_tensors="pt").pixel_values
# Verify that width and height can be divided by size_divisibility
self.assertTrue(encoded_images.shape[-1] % self.image_processor_tester.size_divisibility == 0)
self.assertTrue(encoded_images.shape[-2] % self.image_processor_tester.size_divisibility == 0)
# Verify that width and height can be divided by size_divisibility and that correct dimensions got merged
self.assertTrue(encoded_images.shape[-1] % self.image_processor_tester.size_divisibility == 0)
self.assertTrue(encoded_images.shape[-2] % self.image_processor_tester.size_divisibility == 0)
self.assertTrue(encoded_images.shape[-3] == 4)
def test_call_numpy_4_channels(self):
# Test that can process images which have an arbitrary number of channels
# Initialize image_processing
image_processor = self.image_processing_class(**self.image_processor_dict)
# create random numpy tensors
self.image_processor_tester.num_channels = 4
@ -175,20 +203,23 @@ class VitMatteImageProcessingTest(ImageProcessingTestMixin, unittest.TestCase):
# Test not batched input (image processor does not support batched inputs)
image = image_inputs[0]
trimap = np.random.randint(0, 3, size=image.shape[:2])
encoded_images = image_processor(
images=image,
trimaps=trimap,
input_data_format="channels_first",
image_mean=0,
image_std=1,
return_tensors="pt",
).pixel_values
for image_processing_class in self.image_processor_list:
image_processor = image_processing_class(**self.image_processor_dict)
encoded_images = image_processor(
images=image,
trimaps=trimap,
input_data_format="channels_last",
image_mean=0,
image_std=1,
return_tensors="pt",
).pixel_values
# Verify that width and height can be divided by size_divisibility
self.assertTrue(encoded_images.shape[-1] % self.image_processor_tester.size_divisibility == 0)
self.assertTrue(encoded_images.shape[-2] % self.image_processor_tester.size_divisibility == 0)
# Verify that width and height can be divided by size_divisibility and that correct dimensions got merged
self.assertTrue(encoded_images.shape[-1] % self.image_processor_tester.size_divisibility == 0)
self.assertTrue(encoded_images.shape[-2] % self.image_processor_tester.size_divisibility == 0)
self.assertTrue(encoded_images.shape[-3] == 5)
def test_padding(self):
def test_padding_slow(self):
image_processing = self.image_processing_class(**self.image_processor_dict)
image = np.random.randn(3, 249, 491)
images = image_processing.pad_image(image)
@ -198,6 +229,17 @@ class VitMatteImageProcessingTest(ImageProcessingTestMixin, unittest.TestCase):
images = image_processing.pad_image(image)
assert images.shape == (3, 256, 512)
def test_padding_fast(self):
# extra test because name is different for fast image processor
image_processing = self.fast_image_processing_class(**self.image_processor_dict)
image = torch.rand(3, 249, 491)
images = image_processing._pad_image(image)
assert images.shape == (3, 256, 512)
image = torch.rand(3, 249, 512)
images = image_processing._pad_image(image)
assert images.shape == (3, 256, 512)
def test_image_processor_preprocess_arguments(self):
# vitmatte require additional trimap input for image_processor
# that is why we override original common test
@ -214,3 +256,81 @@ class VitMatteImageProcessingTest(ImageProcessingTestMixin, unittest.TestCase):
messages = " ".join([str(w.message) for w in raised_warnings])
self.assertGreaterEqual(len(raised_warnings), 1)
self.assertIn("extra_argument", messages)
@is_flaky()
def test_fast_is_faster_than_slow(self):
if not self.test_slow_image_processor or not self.test_fast_image_processor:
self.skipTest(reason="Skipping speed test")
if self.image_processing_class is None or self.fast_image_processing_class is None:
self.skipTest(reason="Skipping speed test as one of the image processors is not defined")
def measure_time(image_processor, images, trimaps):
# Warmup
for _ in range(5):
_ = image_processor(images, trimaps=trimaps, return_tensors="pt")
all_times = []
for _ in range(10):
start = time.time()
_ = image_processor(images, trimaps=trimaps, return_tensors="pt")
all_times.append(time.time() - start)
# Take the average of the fastest 3 runs
avg_time = sum(sorted(all_times[:3])) / 3.0
return avg_time
dummy_images = torch.randint(0, 255, (4, 3, 400, 800), dtype=torch.uint8)
dummy_trimaps = torch.randint(0, 3, (4, 400, 800), dtype=torch.uint8)
image_processor_slow = self.image_processing_class(**self.image_processor_dict)
image_processor_fast = self.fast_image_processing_class(**self.image_processor_dict)
fast_time = measure_time(image_processor_fast, dummy_images, dummy_trimaps)
slow_time = measure_time(image_processor_slow, dummy_images, dummy_trimaps)
self.assertLessEqual(fast_time, slow_time)
def test_slow_fast_equivalence(self):
if not self.test_slow_image_processor or not self.test_fast_image_processor:
self.skipTest(reason="Skipping slow/fast equivalence test")
if self.image_processing_class is None or self.fast_image_processing_class is None:
self.skipTest(reason="Skipping slow/fast equivalence test as one of the image processors is not defined")
dummy_image = Image.open(
requests.get("http://images.cocodataset.org/val2017/000000039769.jpg", stream=True).raw
)
dummy_trimap = np.random.randint(0, 3, size=dummy_image.size[::-1])
image_processor_slow = self.image_processing_class(**self.image_processor_dict)
image_processor_fast = self.fast_image_processing_class(**self.image_processor_dict)
encoding_slow = image_processor_slow(dummy_image, trimaps=dummy_trimap, return_tensors="pt")
encoding_fast = image_processor_fast(dummy_image, trimaps=dummy_trimap, return_tensors="pt")
self.assertTrue(torch.allclose(encoding_slow.pixel_values, encoding_fast.pixel_values, atol=1e-1))
self.assertLessEqual(
torch.mean(torch.abs(encoding_slow.pixel_values - encoding_fast.pixel_values)).item(), 1e-3
)
def test_slow_fast_equivalence_batched(self):
# this only checks on equal resolution, since the slow processor doesn't work otherwise
if not self.test_slow_image_processor or not self.test_fast_image_processor:
self.skipTest(reason="Skipping slow/fast equivalence test")
if self.image_processing_class is None or self.fast_image_processing_class is None:
self.skipTest(reason="Skipping slow/fast equivalence test as one of the image processors is not defined")
if hasattr(self.image_processor_tester, "do_center_crop") and self.image_processor_tester.do_center_crop:
self.skipTest(
reason="Skipping as do_center_crop is True and center_crop functions are not equivalent for fast and slow processors"
)
dummy_images = self.image_processor_tester.prepare_image_inputs(equal_resolution=True, torchify=True)
dummy_trimaps = [np.random.randint(0, 3, size=image.shape[1:]) for image in dummy_images]
image_processor_slow = self.image_processing_class(**self.image_processor_dict)
image_processor_fast = self.fast_image_processing_class(**self.image_processor_dict)
encoding_slow = image_processor_slow(dummy_images, trimaps=dummy_trimaps, return_tensors="pt")
encoding_fast = image_processor_fast(dummy_images, trimaps=dummy_trimaps, return_tensors="pt")
self.assertTrue(torch.allclose(encoding_slow.pixel_values, encoding_fast.pixel_values, atol=1e-1))
self.assertLessEqual(
torch.mean(torch.abs(encoding_slow.pixel_values - encoding_fast.pixel_values)).item(), 1e-3
)