# Copyright 2024 HuggingFace Inc. # # 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. import unittest from dataclasses import dataclass import numpy as np from transformers.testing_utils import require_torch, require_vision from transformers.utils import is_torch_available from ...test_image_processing_common import ImageProcessingTester, ImageProcessingTestMixin, prepare_image_inputs if is_torch_available(): import torch @dataclass class ZoeDepthDepthOutputProxy: predicted_depth: torch.FloatTensor = None class ZoeDepthImageProcessingTester(ImageProcessingTester): def __init__(self, **kwargs): # Image processor init kwargs kwargs.setdefault("size", {"height": 18, "width": 18}) kwargs.setdefault("ensure_multiple_of", 32) kwargs.setdefault("keep_aspect_ratio", False) super().__init__(**kwargs) def expected_output_image_shape(self, images): return self.num_channels, self.ensure_multiple_of, self.ensure_multiple_of def prepare_depth_outputs(self): depth_tensors = prepare_image_inputs( batch_size=self.batch_size, num_channels=1, min_resolution=self.min_resolution, max_resolution=self.max_resolution, equal_resolution=True, torchify=True, ) depth_tensors = [depth_tensor.squeeze(0) for depth_tensor in depth_tensors] stacked_depth_tensors = torch.stack(depth_tensors, dim=0) return ZoeDepthDepthOutputProxy(predicted_depth=stacked_depth_tensors) @require_torch @require_vision class ZoeDepthImageProcessingTest(ImageProcessingTestMixin, unittest.TestCase): image_processor_tester_class = ZoeDepthImageProcessingTester def test_ensure_multiple_of(self): # Test variable by turning off all other variables which affect the size, size which is not multiple of 32 image = np.zeros((489, 640, 3)) size = {"height": 380, "width": 513} multiple = 32 for image_processor_class in self.image_processing_classes.values(): image_processor = image_processor_class( do_pad=False, ensure_multiple_of=multiple, size=size, keep_aspect_ratio=False ) pixel_values = image_processor(image, return_tensors="pt").pixel_values self.assertEqual(list(pixel_values.shape), [1, 3, 384, 512]) self.assertTrue(pixel_values.shape[2] % multiple == 0) self.assertTrue(pixel_values.shape[3] % multiple == 0) # Test variable by turning off all other variables which affect the size, size which is already multiple of 32 image = np.zeros((511, 511, 3)) height, width = 512, 512 size = {"height": height, "width": width} multiple = 32 for image_processing_class in self.image_processing_classes.values(): image_processor = image_processing_class( do_pad=False, ensure_multiple_of=multiple, size=size, keep_aspect_ratio=False ) pixel_values = image_processor(image, return_tensors="pt").pixel_values self.assertEqual(list(pixel_values.shape), [1, 3, height, width]) self.assertTrue(pixel_values.shape[2] % multiple == 0) self.assertTrue(pixel_values.shape[3] % multiple == 0) def test_keep_aspect_ratio(self): # Test `keep_aspect_ratio=True` by turning off all other variables which affect the size height, width = 489, 640 image = np.zeros((height, width, 3)) size = {"height": 512, "width": 512} for image_processing_class in self.image_processing_classes.values(): image_processor = image_processing_class( do_pad=False, keep_aspect_ratio=True, size=size, ensure_multiple_of=1 ) pixel_values = image_processor(image, return_tensors="pt").pixel_values # As can be seen, the image is resized to the maximum size that fits in the specified size self.assertEqual(list(pixel_values.shape), [1, 3, 512, 670]) # Test `keep_aspect_ratio=False` by turning off all other variables which affect the size for image_processing_class in self.image_processing_classes.values(): image_processor = image_processing_class( do_pad=False, keep_aspect_ratio=False, size=size, ensure_multiple_of=1 ) pixel_values = image_processor(image, return_tensors="pt").pixel_values # As can be seen, the size is respected self.assertEqual(list(pixel_values.shape), [1, 3, size["height"], size["width"]]) # Test `keep_aspect_ratio=True` with `ensure_multiple_of` set image = np.zeros((489, 640, 3)) size = {"height": 511, "width": 511} multiple = 32 for image_processing_class in self.image_processing_classes.values(): image_processor = image_processing_class(size=size, keep_aspect_ratio=True, ensure_multiple_of=multiple) pixel_values = image_processor(image, return_tensors="pt").pixel_values self.assertEqual(list(pixel_values.shape), [1, 3, 512, 672]) self.assertTrue(pixel_values.shape[2] % multiple == 0) self.assertTrue(pixel_values.shape[3] % multiple == 0) # extend this test to check if removal of padding works fine! def test_post_processing_equivalence(self): if len(self.image_processing_classes) < 2: self.skipTest(reason="Skipping post-processing equivalence test as there are less than 2 backends") outputs = self.image_processor_tester.prepare_depth_outputs() list(self.image_processing_classes.keys()) image_processor_torchvision = self.image_processing_classes["torchvision"](**self.image_processor_dict) image_processor_pil = self.image_processing_classes["pil"](**self.image_processor_dict) source_sizes = [outputs.predicted_depth.shape[1:]] * self.image_processor_tester.batch_size target_sizes = [ torch.Size([outputs.predicted_depth.shape[1] // 2, *(outputs.predicted_depth.shape[2:])]) ] * self.image_processor_tester.batch_size processed_torchvision = image_processor_torchvision.post_process_depth_estimation( outputs, source_sizes=source_sizes, target_sizes=target_sizes, ) processed_pil = image_processor_pil.post_process_depth_estimation( outputs, source_sizes=source_sizes, target_sizes=target_sizes, ) for pred_torchvision, pred_pil in zip(processed_torchvision, processed_pil): depth_torchvision = pred_torchvision["predicted_depth"] depth_pil = pred_pil["predicted_depth"] torch.testing.assert_close(depth_torchvision, depth_pil, atol=1e-1, rtol=1e-3) self.assertLessEqual(torch.mean(torch.abs(depth_torchvision.float() - depth_pil.float())).item(), 5e-3)