code: 
  
  
  
  
  
  
  import unittest
  
  import numpy as np
  
  from transformers.testing_utils import require_torch, require_vision
  from transformers.utils import is_torch_available, is_vision_available
  
  from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs
  
  
  if is_torch_available():
        import torch
  
  if is_vision_available():
        from PIL import Image
  
        from transformers import DeiTImageProcessor
  
  
  
  
  
  
  
  class 							UpperCAmelCase_     (		unittest.TestCase		):
  
  
  
  
       def __init__(							self  ,	_lowerCAmelCase  ,	_lowerCAmelCase=7  ,	_lowerCAmelCase=3  ,	_lowerCAmelCase=18  ,	_lowerCAmelCase=30  ,	_lowerCAmelCase=400  ,	_lowerCAmelCase=True  ,	_lowerCAmelCase=None  ,	_lowerCAmelCase=True  ,	_lowerCAmelCase=None  ,	_lowerCAmelCase=True  ,	_lowerCAmelCase=[0.5, 0.5, 0.5]  ,	_lowerCAmelCase=[0.5, 0.5, 0.5]  ,	):
            UpperCAmelCase__			:     Optional[Any]										= size if size is not None else {"""height""": 20, """width""": 20}
            UpperCAmelCase__			:     Optional[Any]										= crop_size if crop_size is not None else {"""height""": 18, """width""": 18}
  
            UpperCAmelCase__			:     str										= parent
            UpperCAmelCase__			:     Union[str, Any]										= batch_size
            UpperCAmelCase__			:     Any										= num_channels
            UpperCAmelCase__			:     List[Any]										= image_size
            UpperCAmelCase__			:     Union[str, Any]										= min_resolution
            UpperCAmelCase__			:     Union[str, Any]										= max_resolution
            UpperCAmelCase__			:     Optional[int]										= do_resize
            UpperCAmelCase__			:     int										= size
            UpperCAmelCase__			:     List[Any]										= do_center_crop
            UpperCAmelCase__			:     Any										= crop_size
            UpperCAmelCase__			:     List[Any]										= do_normalize
            UpperCAmelCase__			:     Dict										= image_mean
            UpperCAmelCase__			:     str										= image_std
  
  
  
  
       def      __UpperCAmelCase     (							self		):
            return {
                "do_resize": self.do_resize,
                "size": self.size,
                "do_center_crop": self.do_center_crop,
                "crop_size": self.crop_size,
                "do_normalize": self.do_normalize,
                "image_mean": self.image_mean,
                "image_std": self.image_std,
            }
  
  
  
  
  
  
  
  @require_torch
  @require_vision
  class 							UpperCAmelCase_     (		__lowerCamelCase       ,			unittest.TestCase		):
       __lowerCamelCase										=     DeiTImageProcessor if is_vision_available() else None
       __lowerCamelCase										=     True
  
  
  
  
       def      __UpperCAmelCase     (							self		):
            UpperCAmelCase__			:     Union[str, Any]										= DeiTImageProcessingTester(self		)
  
  
  
  
       @property
       def      __UpperCAmelCase     (							self		):
            return self.image_processor_tester.prepare_image_processor_dict()
  
  
  
  
       def      __UpperCAmelCase     (							self		):
            UpperCAmelCase__			:     str										= self.image_processing_class(**self.image_processor_dict		)
            self.assertTrue(hasattr(_lowerCAmelCase  ,	"""do_resize"""		)		)
            self.assertTrue(hasattr(_lowerCAmelCase  ,	"""size"""		)		)
            self.assertTrue(hasattr(_lowerCAmelCase  ,	"""do_center_crop"""		)		)
            self.assertTrue(hasattr(_lowerCAmelCase  ,	"""center_crop"""		)		)
            self.assertTrue(hasattr(_lowerCAmelCase  ,	"""do_normalize"""		)		)
            self.assertTrue(hasattr(_lowerCAmelCase  ,	"""image_mean"""		)		)
            self.assertTrue(hasattr(_lowerCAmelCase  ,	"""image_std"""		)		)
  
  
  
  
       def      __UpperCAmelCase     (							self		):
            UpperCAmelCase__			:     Optional[int]										= self.image_processing_class.from_dict(self.image_processor_dict		)
            self.assertEqual(image_processor.size  ,	{"""height""": 20, """width""": 20}		)
            self.assertEqual(image_processor.crop_size  ,	{"""height""": 18, """width""": 18}		)
  
            UpperCAmelCase__			:     Tuple										= 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.crop_size  ,	{"""height""": 84, """width""": 84}		)
  
  
  
  
       def      __UpperCAmelCase     (							self		):
            pass
  
  
  
  
       def      __UpperCAmelCase     (							self		):
            # Initialize image_processing
            UpperCAmelCase__			:     Tuple										= self.image_processing_class(**self.image_processor_dict		)
            # create random PIL images
            UpperCAmelCase__			:     Optional[Any]										= prepare_image_inputs(self.image_processor_tester  ,	equal_resolution=_lowerCAmelCase		)
            for image in image_inputs:
                 self.assertIsInstance(_lowerCAmelCase  ,	Image.Image		)
  
            # Test not batched input
            UpperCAmelCase__			:     Union[str, Any]										= 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
            UpperCAmelCase__			:     List[Any]										= image_processing(_lowerCAmelCase  ,	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      __UpperCAmelCase     (							self		):
            # Initialize image_processing
            UpperCAmelCase__			:     Dict										= self.image_processing_class(**self.image_processor_dict		)
            # create random numpy tensors
            UpperCAmelCase__			:     Dict										= prepare_image_inputs(self.image_processor_tester  ,	equal_resolution=_lowerCAmelCase  ,	numpify=_lowerCAmelCase		)
            for image in image_inputs:
                 self.assertIsInstance(_lowerCAmelCase  ,	np.ndarray		)
  
            # Test not batched input
            UpperCAmelCase__			:     List[str]										= 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
            UpperCAmelCase__			:     Optional[Any]										= image_processing(_lowerCAmelCase  ,	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      __UpperCAmelCase     (							self		):
            # Initialize image_processing
            UpperCAmelCase__			:     Optional[int]										= self.image_processing_class(**self.image_processor_dict		)
            # create random PyTorch tensors
            UpperCAmelCase__			:     Optional[int]										= prepare_image_inputs(self.image_processor_tester  ,	equal_resolution=_lowerCAmelCase  ,	torchify=_lowerCAmelCase		)
            for image in image_inputs:
                 self.assertIsInstance(_lowerCAmelCase  ,	torch.Tensor		)
  
            # Test not batched input
            UpperCAmelCase__			:     str										= 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
            UpperCAmelCase__			:     Dict										= image_processing(_lowerCAmelCase  ,	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"""],
                )  ,	)
  
  
  
  
  
  
  
style_context: 
  
  
  
  
  
  
  import math
  import os
  
  import cva
  import numpy as np
  
  SCREAMING_SNAKE_CASE__		:       Optional[Any]   							=							255.0
  
  
  
  
  
  def    _lowerCamelCase	(	__lowerCamelCase   ,       __lowerCamelCase					)   -> float:
  
       '''simple docstring'''
       UpperCAmelCase__			:     List[Any]										= np.mean((original - contrast) ** 2					)
       if mse == 0:
            return 100
  
       return 20 * math.logaa(PIXEL_MAX / math.sqrt(__lowerCamelCase					)					)
  
  
  
  
  
  def    _lowerCamelCase	(	)   -> None:
  
       '''simple docstring'''
       UpperCAmelCase__			:     Union[str, Any]										= os.path.dirname(os.path.realpath(__lowerCamelCase					)					)
       # Loading images (original image and compressed image)
       UpperCAmelCase__			:     List[Any]										= cva.imread(os.path.join(__lowerCamelCase   ,       """image_data/original_image.png"""					)					)
       UpperCAmelCase__			:     Dict										= cva.imread(os.path.join(__lowerCamelCase   ,       """image_data/compressed_image.png"""					)   ,       1					)
  
       UpperCAmelCase__			:     Tuple										= cva.imread(os.path.join(__lowerCamelCase   ,       """image_data/PSNR-example-base.png"""					)					)
       UpperCAmelCase__			:     int										= cva.imread(
           os.path.join(__lowerCamelCase   ,       """image_data/PSNR-example-comp-10.jpg"""					)   ,       1					)
  
       # Value expected: 29.73dB
       print("""-- First Test --"""					)
       print(F"PSNR value is {peak_signal_to_noise_ratio(__lowerCamelCase   ,       __lowerCamelCase					)} dB"					)
  
       # # Value expected: 31.53dB (Wikipedia Example)
       print("""\n-- Second Test --"""					)
       print(F"PSNR value is {peak_signal_to_noise_ratio(__lowerCamelCase   ,       __lowerCamelCase					)} dB"					)
  
  
  if __name__ == "__main__":
        main()
  
  
  
  
  
  
  