





'''simple docstring'''




from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


__SCREAMING_SNAKE_CASE	:int	    =							logging.get_logger(__name__)

__SCREAMING_SNAKE_CASE	:Dict	    =							{
    'google/vit-base-patch16-224': 'https://huggingface.co/vit-base-patch16-224/resolve/main/config.json',
    # See all ViT models at https://huggingface.co/models?filter=vit
}







class     A_      (    _a     ):
 _lowerCamelCase    :					List[str]       			=				"""vit"""




 def __init__(   self			:       Optional[Any]      ,     snake_case_			:       List[Any]=7_6_8      ,     snake_case_			:       Any=1_2      ,     snake_case_			:       Optional[Any]=1_2      ,     snake_case_			:       Optional[Any]=3_0_7_2      ,     snake_case_			:       Any="gelu"      ,     snake_case_			:       int=0.0      ,     snake_case_			:       Any=0.0      ,     snake_case_			:       str=0.0_2      ,     snake_case_			:       Dict=1e-12      ,     snake_case_			:       Optional[int]=2_2_4      ,     snake_case_			:       Dict=1_6      ,     snake_case_			:       List[str]=3      ,     snake_case_			:       List[Any]=True      ,     snake_case_			:       int=1_6      ,     **snake_case_			:       Optional[Any]      ,     ):
      super().__init__(**snake_case_       )

      _UpperCAmelCase					=  hidden_size
      _UpperCAmelCase					=  num_hidden_layers
      _UpperCAmelCase					=  num_attention_heads
      _UpperCAmelCase					=  intermediate_size
      _UpperCAmelCase					=  hidden_act
      _UpperCAmelCase					=  hidden_dropout_prob
      _UpperCAmelCase					=  attention_probs_dropout_prob
      _UpperCAmelCase					=  initializer_range
      _UpperCAmelCase					=  layer_norm_eps
      _UpperCAmelCase					=  image_size
      _UpperCAmelCase					=  patch_size
      _UpperCAmelCase					=  num_channels
      _UpperCAmelCase					=  qkv_bias
      _UpperCAmelCase					=  encoder_stride







class     A_      (    _a     ):
 _lowerCamelCase    :					Dict       			=				version.parse("""1.11"""     )




 @property
 def 	lowercase      (   self			:       List[str]       ):
      return OrderedDict(
          [
              ("pixel_values", {0: "batch", 1: "num_channels", 2: "height", 3: "width"}),
          ]       )




 @property
 def 	lowercase      (   self			:       Dict       ):
      return 1e-4








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 PoolFormerImageProcessor






class      UpperCamelCase(	unittest.TestCase ):


					def __init__(    self						:		Tuple  ,     SCREAMING_SNAKE_CASE						:		List[Any]  ,     SCREAMING_SNAKE_CASE						:		Optional[Any]=7  ,     SCREAMING_SNAKE_CASE						:		Dict=3  ,     SCREAMING_SNAKE_CASE						:		Any=3_0  ,     SCREAMING_SNAKE_CASE						:		List[str]=4_0_0  ,     SCREAMING_SNAKE_CASE						:		Any=True  ,     SCREAMING_SNAKE_CASE						:		List[Any]=None  ,     SCREAMING_SNAKE_CASE						:		int=0.9  ,     SCREAMING_SNAKE_CASE						:		Tuple=None  ,     SCREAMING_SNAKE_CASE						:		int=True  ,     SCREAMING_SNAKE_CASE						:		Union[str, Any]=[0.5, 0.5, 0.5]  ,     SCREAMING_SNAKE_CASE						:		Optional[Any]=[0.5, 0.5, 0.5]  ,     )      ->						Union[str, Any]:




											'''simple docstring'''

											__snake_case				=		size if size is not None else {"shortest_edge": 3_0}
											__snake_case				=		crop_size if crop_size is not None else {"height": 3_0, "width": 3_0}
											__snake_case				=		parent
											__snake_case				=		batch_size
											__snake_case				=		num_channels
											__snake_case				=		min_resolution
											__snake_case				=		max_resolution
											__snake_case				=		do_resize_and_center_crop
											__snake_case				=		size
											__snake_case				=		crop_pct
											__snake_case				=		crop_size
											__snake_case				=		do_normalize
											__snake_case				=		image_mean
											__snake_case				=		image_std






					def 				SCREAMING_SNAKE_CASE_	(    self						:		str    )      ->						Any:




											'''simple docstring'''

											return {
											    "size": self.size,
											    "do_resize_and_center_crop": self.do_resize_and_center_crop,
											    "crop_pct": self.crop_pct,
											    "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(	_a  ,				unittest.TestCase ):
					snake_case_		:					List[str]    					=						PoolFormerImageProcessor if is_vision_available() else None


					def 				SCREAMING_SNAKE_CASE_	(    self						:		Union[str, Any]    )      ->						str:




											'''simple docstring'''

											__snake_case				=		PoolFormerImageProcessingTester(self    )


					@property
					def 				SCREAMING_SNAKE_CASE_	(    self						:		int    )      ->						Dict:




											'''simple docstring'''

											return self.image_processor_tester.prepare_image_processor_dict()


					def 				SCREAMING_SNAKE_CASE_	(    self						:		Dict    )      ->						List[str]:




											'''simple docstring'''

											__snake_case				=		self.image_processing_class(**self.image_processor_dict    )
											self.assertTrue(hasattr(SCREAMING_SNAKE_CASE  ,     "do_resize_and_center_crop"    )    )
											self.assertTrue(hasattr(SCREAMING_SNAKE_CASE  ,     "size"    )    )
											self.assertTrue(hasattr(SCREAMING_SNAKE_CASE  ,     "crop_pct"    )    )
											self.assertTrue(hasattr(SCREAMING_SNAKE_CASE  ,     "do_normalize"    )    )
											self.assertTrue(hasattr(SCREAMING_SNAKE_CASE  ,     "image_mean"    )    )
											self.assertTrue(hasattr(SCREAMING_SNAKE_CASE  ,     "image_std"    )    )


					def 				SCREAMING_SNAKE_CASE_	(    self						:		Union[str, Any]    )      ->						Any:




											'''simple docstring'''

											__snake_case				=		self.image_processing_class.from_dict(self.image_processor_dict    )
											self.assertEqual(image_processor.size  ,     {"shortest_edge": 3_0}    )
											self.assertEqual(image_processor.crop_size  ,     {"height": 3_0, "width": 3_0}    )

											__snake_case				=		self.image_processing_class.from_dict(self.image_processor_dict  ,     size=4_2  ,     crop_size=8_4    )
											self.assertEqual(image_processor.size  ,     {"shortest_edge": 4_2}    )
											self.assertEqual(image_processor.crop_size  ,     {"height": 8_4, "width": 8_4}    )


					def 				SCREAMING_SNAKE_CASE_	(    self						:		Optional[int]    )      ->						List[Any]:




											'''simple docstring'''

											pass


					def 				SCREAMING_SNAKE_CASE_	(    self						:		Optional[Any]    )      ->						Dict:




											'''simple docstring'''

											__snake_case				=		self.image_processing_class(**self.image_processor_dict    )
											# create random PIL images
											__snake_case				=		prepare_image_inputs(self.image_processor_tester  ,     equal_resolution=SCREAMING_SNAKE_CASE    )
											for image in image_inputs:
																	self.assertIsInstance(SCREAMING_SNAKE_CASE  ,     Image.Image    )

											# Test not batched input
											__snake_case				=		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
											__snake_case				=		image_processing(SCREAMING_SNAKE_CASE  ,     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 				SCREAMING_SNAKE_CASE_	(    self						:		Optional[Any]    )      ->						Optional[int]:




											'''simple docstring'''

											__snake_case				=		self.image_processing_class(**self.image_processor_dict    )
											# create random numpy tensors
											__snake_case				=		prepare_image_inputs(self.image_processor_tester  ,     equal_resolution=SCREAMING_SNAKE_CASE  ,     numpify=SCREAMING_SNAKE_CASE    )
											for image in image_inputs:
																	self.assertIsInstance(SCREAMING_SNAKE_CASE  ,     np.ndarray    )

											# Test not batched input
											__snake_case				=		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
											__snake_case				=		image_processing(SCREAMING_SNAKE_CASE  ,     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 				SCREAMING_SNAKE_CASE_	(    self						:		Optional[int]    )      ->						Union[str, Any]:




											'''simple docstring'''

											__snake_case				=		self.image_processing_class(**self.image_processor_dict    )
											# create random PyTorch tensors
											__snake_case				=		prepare_image_inputs(self.image_processor_tester  ,     equal_resolution=SCREAMING_SNAKE_CASE  ,     torchify=SCREAMING_SNAKE_CASE    )
											for image in image_inputs:
																	self.assertIsInstance(SCREAMING_SNAKE_CASE  ,     torch.Tensor    )

											# Test not batched input
											__snake_case				=		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
											__snake_case				=		image_processing(SCREAMING_SNAKE_CASE  ,     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"],
											    )  ,     )





