






from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    convert_to_rgb,
    get_resize_output_image_size,
    normalize,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    OPENAI_CLIP_MEAN,
    OPENAI_CLIP_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


__snake_case			:			str			   =   logging.get_logger(__name__)


if is_vision_available():
					import PIL


class 			__SCREAMING_SNAKE_CASE    (      __lowercase):
						_SCREAMING_SNAKE_CASE		:				List[str]            =    ['''pixel_values''']






						def __init__(		self   ,  _UpperCamelCase = True   ,  _UpperCamelCase = None   ,  _UpperCamelCase = PILImageResampling.BICUBIC   ,  _UpperCamelCase = True   ,  _UpperCamelCase = None   ,  _UpperCamelCase = True   ,  _UpperCamelCase = 1 / 2_55   ,  _UpperCamelCase = True   ,  _UpperCamelCase = None   ,  _UpperCamelCase = None   ,  _UpperCamelCase = True   ,  **_UpperCamelCase   ,  ):






												"""simple docstring"""
												super().__init__(**_UpperCamelCase      )
												lowerCAmelCase__			  =  size if size is not None else {'shortest_edge': 2_24}
												lowerCAmelCase__			  =  get_size_dict(_UpperCamelCase   ,  default_to_square=_UpperCamelCase      )
												lowerCAmelCase__			  =  crop_size if crop_size is not None else {'height': 2_24, 'width': 2_24}
												lowerCAmelCase__			  =  get_size_dict(_UpperCamelCase      )

												lowerCAmelCase__			  =  do_resize
												lowerCAmelCase__			  =  size
												lowerCAmelCase__			  =  resample
												lowerCAmelCase__			  =  do_center_crop
												lowerCAmelCase__			  =  crop_size
												lowerCAmelCase__			  =  do_rescale
												lowerCAmelCase__			  =  rescale_factor
												lowerCAmelCase__			  =  do_normalize
												lowerCAmelCase__			  =  image_mean if image_mean is not None else OPENAI_CLIP_MEAN
												lowerCAmelCase__			  =  image_std if image_std is not None else OPENAI_CLIP_STD
												lowerCAmelCase__			  =  do_convert_rgb






						def 					UpperCamelCase__					(		self   ,  _UpperCamelCase   ,  _UpperCamelCase   ,  _UpperCamelCase = PILImageResampling.BICUBIC   ,  _UpperCamelCase = None   ,  **_UpperCamelCase   ,  ):






												"""simple docstring"""
												lowerCAmelCase__			  =  get_size_dict(_UpperCamelCase   ,  default_to_square=_UpperCamelCase      )
												lowerCAmelCase__			  =  get_resize_output_image_size(
												    _UpperCamelCase   ,  size=(size['height'], size['width'])   ,  default_to_square=_UpperCamelCase      )
												return resize(_UpperCamelCase   ,  size=_UpperCamelCase   ,  resample=_UpperCamelCase   ,  data_format=_UpperCamelCase   ,  **_UpperCamelCase      )






						def 					UpperCamelCase__					(		self   ,  _UpperCamelCase   ,  _UpperCamelCase   ,  _UpperCamelCase = None   ,  **_UpperCamelCase   ,  ):






												"""simple docstring"""
												lowerCAmelCase__			  =  get_size_dict(_UpperCamelCase      )
												return center_crop(_UpperCamelCase   ,  size=(size['height'], size['width'])   ,  data_format=_UpperCamelCase   ,  **_UpperCamelCase      )






						def 					UpperCamelCase__					(		self   ,  _UpperCamelCase   ,  _UpperCamelCase   ,  _UpperCamelCase = None   ,  **_UpperCamelCase   ,  ):






												"""simple docstring"""
												return rescale(_UpperCamelCase   ,  scale=_UpperCamelCase   ,  data_format=_UpperCamelCase   ,  **_UpperCamelCase      )






						def 					UpperCamelCase__					(		self   ,  _UpperCamelCase   ,  _UpperCamelCase   ,  _UpperCamelCase   ,  _UpperCamelCase = None   ,  **_UpperCamelCase   ,  ):






												"""simple docstring"""
												return normalize(_UpperCamelCase   ,  mean=_UpperCamelCase   ,  std=_UpperCamelCase   ,  data_format=_UpperCamelCase   ,  **_UpperCamelCase      )







						def 					UpperCamelCase__					(		self   ,  _UpperCamelCase   ,  _UpperCamelCase = None   ,  _UpperCamelCase = None   ,  _UpperCamelCase = None   ,  _UpperCamelCase = None   ,  _UpperCamelCase = None   ,  _UpperCamelCase = None   ,  _UpperCamelCase = None   ,  _UpperCamelCase = None   ,  _UpperCamelCase = None   ,  _UpperCamelCase = None   ,  _UpperCamelCase = None   ,  _UpperCamelCase = None   ,  _UpperCamelCase = ChannelDimension.FIRST   ,  **_UpperCamelCase   ,  ):






												"""simple docstring"""
												lowerCAmelCase__			  =  do_resize if do_resize is not None else self.do_resize
												lowerCAmelCase__			  =  size if size is not None else self.size
												lowerCAmelCase__			  =  get_size_dict(_UpperCamelCase   ,  default_to_square=_UpperCamelCase      )
												lowerCAmelCase__			  =  resample if resample is not None else self.resample
												lowerCAmelCase__			  =  do_center_crop if do_center_crop is not None else self.do_center_crop
												lowerCAmelCase__			  =  crop_size if crop_size is not None else self.crop_size
												lowerCAmelCase__			  =  get_size_dict(_UpperCamelCase      )
												lowerCAmelCase__			  =  do_rescale if do_rescale is not None else self.do_rescale
												lowerCAmelCase__			  =  rescale_factor if rescale_factor is not None else self.rescale_factor
												lowerCAmelCase__			  =  do_normalize if do_normalize is not None else self.do_normalize
												lowerCAmelCase__			  =  image_mean if image_mean is not None else self.image_mean
												lowerCAmelCase__			  =  image_std if image_std is not None else self.image_std
												lowerCAmelCase__			  =  do_convert_rgb if do_convert_rgb is not None else self.do_convert_rgb

												lowerCAmelCase__			  =  make_list_of_images(_UpperCamelCase      )

												if not valid_images(_UpperCamelCase      ):
																		raise ValueError(
																		    'Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, '
																		    'torch.Tensor, tf.Tensor or jax.ndarray.'      )

												if do_resize and size is None:
																		raise ValueError('Size must be specified if do_resize is True.'      )

												if do_center_crop and crop_size is None:
																		raise ValueError('Crop size must be specified if do_center_crop is True.'      )

												if do_rescale and rescale_factor is None:
																		raise ValueError('Rescale factor must be specified if do_rescale is True.'      )

												if do_normalize and (image_mean is None or image_std is None):
																		raise ValueError('Image mean and std must be specified if do_normalize is True.'      )

												# PIL RGBA images are converted to RGB
												if do_convert_rgb:
																		lowerCAmelCase__			  =  [convert_to_rgb(_UpperCamelCase      ) for image in images]

												# All transformations expect numpy arrays.
												lowerCAmelCase__			  =  [to_numpy_array(_UpperCamelCase      ) for image in images]

												if do_resize:
																		lowerCAmelCase__			  =  [self.resize(image=_UpperCamelCase   ,  size=_UpperCamelCase   ,  resample=_UpperCamelCase      ) for image in images]

												if do_center_crop:
																		lowerCAmelCase__			  =  [self.center_crop(image=_UpperCamelCase   ,  size=_UpperCamelCase      ) for image in images]

												if do_rescale:
																		lowerCAmelCase__			  =  [self.rescale(image=_UpperCamelCase   ,  scale=_UpperCamelCase      ) for image in images]

												if do_normalize:
																		lowerCAmelCase__			  =  [self.normalize(image=_UpperCamelCase   ,  mean=_UpperCamelCase   ,  std=_UpperCamelCase      ) for image in images]

												lowerCAmelCase__			  =  [to_channel_dimension_format(_UpperCamelCase   ,  _UpperCamelCase      ) for image in images]

												lowerCAmelCase__			  =  {'pixel_values': images}
												return BatchFeature(data=_UpperCamelCase   ,  tensor_type=_UpperCamelCase      )













import inspect
import unittest

from transformers import is_torch_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
					import torch

					from transformers import MODEL_MAPPING, PoolFormerConfig, PoolFormerForImageClassification, PoolFormerModel
					from transformers.models.poolformer.modeling_poolformer import POOLFORMER_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
					from PIL import Image

					from transformers import PoolFormerImageProcessor


class 			__SCREAMING_SNAKE_CASE    (      __lowercase):






						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												lowerCAmelCase__			  =  self.config_class(**self.inputs_dict      )
												self.parent.assertTrue(hasattr(_UpperCamelCase   ,  'hidden_sizes'      )      )
												self.parent.assertTrue(hasattr(_UpperCamelCase   ,  'num_encoder_blocks'      )      )




class 			__SCREAMING_SNAKE_CASE    :






						def __init__(		self   ,  _UpperCamelCase   ,  _UpperCamelCase=13   ,  _UpperCamelCase=64   ,  _UpperCamelCase=3   ,  _UpperCamelCase=4   ,  _UpperCamelCase=[2, 2, 2, 2]   ,  _UpperCamelCase=[8, 4, 2, 1]   ,  _UpperCamelCase=[16, 32, 64, 1_28]   ,  _UpperCamelCase=[1, 4, 8, 16]   ,  _UpperCamelCase=False   ,  _UpperCamelCase=True   ,  _UpperCamelCase="gelu"   ,  _UpperCamelCase=0.1   ,  _UpperCamelCase=0.02   ,  _UpperCamelCase=3   ,  _UpperCamelCase=None   ,  ):






												"""simple docstring"""
												lowerCAmelCase__			  =  parent
												lowerCAmelCase__			  =  batch_size
												lowerCAmelCase__			  =  image_size
												lowerCAmelCase__			  =  num_channels
												lowerCAmelCase__			  =  num_encoder_blocks
												lowerCAmelCase__			  =  sr_ratios
												lowerCAmelCase__			  =  depths
												lowerCAmelCase__			  =  hidden_sizes
												lowerCAmelCase__			  =  downsampling_rates
												lowerCAmelCase__			  =  is_training
												lowerCAmelCase__			  =  use_labels
												lowerCAmelCase__			  =  hidden_act
												lowerCAmelCase__			  =  hidden_dropout_prob
												lowerCAmelCase__			  =  initializer_range
												lowerCAmelCase__			  =  num_labels
												lowerCAmelCase__			  =  scope






						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												lowerCAmelCase__			  =  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]      )

												lowerCAmelCase__			  =  None
												if self.use_labels:
																		lowerCAmelCase__			  =  ids_tensor([self.batch_size, self.image_size, self.image_size]   ,  self.num_labels      )

												lowerCAmelCase__			  =  PoolFormerConfig(
												    image_size=self.image_size   ,  num_channels=self.num_channels   ,  num_encoder_blocks=self.num_encoder_blocks   ,  depths=self.depths   ,  hidden_sizes=self.hidden_sizes   ,  hidden_act=self.hidden_act   ,  hidden_dropout_prob=self.hidden_dropout_prob   ,  initializer_range=self.initializer_range   ,  )

												return config, pixel_values, labels






						def 					UpperCamelCase__					(		self   ,  _UpperCamelCase   ,  _UpperCamelCase   ,  _UpperCamelCase      ):






												"""simple docstring"""
												lowerCAmelCase__			  =  PoolFormerModel(config=_UpperCamelCase      )
												model.to(_UpperCamelCase      )
												model.eval()
												lowerCAmelCase__			  =  model(_UpperCamelCase      )
												lowerCAmelCase__			  =  lowerCAmelCase__			  =  self.image_size // 32.0
												self.parent.assertEqual(
												    result.last_hidden_state.shape   ,  (self.batch_size, self.hidden_sizes[-1], expected_height, expected_width)      )







						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												lowerCAmelCase__			  =  self.prepare_config_and_inputs()
												lowerCAmelCase__  ,				lowerCAmelCase__  ,				lowerCAmelCase__			  =  config_and_inputs
												lowerCAmelCase__			  =  {'pixel_values': pixel_values}
												return config, inputs_dict




@require_torch
class 			__SCREAMING_SNAKE_CASE    (      __lowercase						,    __lowercase						,    unittest.TestCase):
						_SCREAMING_SNAKE_CASE		:				List[Any]            =    (PoolFormerModel, PoolFormerForImageClassification) if is_torch_available() else ()
						_SCREAMING_SNAKE_CASE		:				Optional[int]            =    (
						    {'''feature-extraction''': PoolFormerModel, '''image-classification''': PoolFormerForImageClassification}
						    if is_torch_available()
						    else {}
						)

						_SCREAMING_SNAKE_CASE		:				List[str]            =    False
						_SCREAMING_SNAKE_CASE		:				Optional[int]            =    False
						_SCREAMING_SNAKE_CASE		:				Optional[Any]            =    False
						_SCREAMING_SNAKE_CASE		:				str            =    False
						_SCREAMING_SNAKE_CASE		:				List[Any]            =    False






						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												lowerCAmelCase__			  =  PoolFormerModelTester(self      )
												lowerCAmelCase__			  =  PoolFormerConfigTester(self   ,  config_class=_UpperCamelCase      )






						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												self.config_tester.run_common_tests()






						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												lowerCAmelCase__			  =  self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_model(*_UpperCamelCase      )






						@unittest.skip('PoolFormer does not use inputs_embeds'      )
						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												pass






						@unittest.skip('PoolFormer does not have get_input_embeddings method and get_output_embeddings methods'      )
						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												pass






						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												def check_hidden_states_output(_UpperCamelCase   ,  _UpperCamelCase   ,  _UpperCamelCase      ):
																		lowerCAmelCase__			  =  model_class(_UpperCamelCase      )
																		model.to(_UpperCamelCase      )
																		model.eval()

																		with torch.no_grad():
																								lowerCAmelCase__			  =  model(**self._prepare_for_class(_UpperCamelCase   ,  _UpperCamelCase      )      )

																		lowerCAmelCase__			  =  outputs.hidden_states

																		lowerCAmelCase__			  =  self.model_tester.num_encoder_blocks
																		self.assertEqual(len(_UpperCamelCase      )   ,  _UpperCamelCase      )

																		# verify the first hidden states (first block)
																		self.assertListEqual(
																		    list(hidden_states[0].shape[-3:]      )   ,  [
																		        self.model_tester.hidden_sizes[0],
																		        self.model_tester.image_size // 4,
																		        self.model_tester.image_size // 4,
																		    ]   ,  )

												lowerCAmelCase__  ,				lowerCAmelCase__			  =  self.model_tester.prepare_config_and_inputs_for_common()

												for model_class in self.all_model_classes:
																		lowerCAmelCase__			  =  True
																		check_hidden_states_output(_UpperCamelCase   ,  _UpperCamelCase   ,  _UpperCamelCase      )

																		# check that output_hidden_states also work using config
																		del inputs_dict["output_hidden_states"]
																		lowerCAmelCase__			  =  True

																		check_hidden_states_output(_UpperCamelCase   ,  _UpperCamelCase   ,  _UpperCamelCase      )






						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												if not self.model_tester.is_training:
																		return

												lowerCAmelCase__  ,				lowerCAmelCase__			  =  self.model_tester.prepare_config_and_inputs_for_common()
												lowerCAmelCase__			  =  True

												for model_class in self.all_model_classes:
																		if model_class in get_values(_UpperCamelCase      ):
																								continue
																		lowerCAmelCase__			  =  model_class(_UpperCamelCase      )
																		model.to(_UpperCamelCase      )
																		model.train()
																		lowerCAmelCase__			  =  self._prepare_for_class(_UpperCamelCase   ,  _UpperCamelCase   ,  return_labels=_UpperCamelCase      )
																		lowerCAmelCase__			  =  model(**_UpperCamelCase      ).loss
																		loss.backward()






						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												lowerCAmelCase__  ,				lowerCAmelCase__			  =  self.model_tester.prepare_config_and_inputs_for_common()

												for model_class in self.all_model_classes:
																		lowerCAmelCase__			  =  model_class(_UpperCamelCase      )
																		lowerCAmelCase__			  =  inspect.signature(model.forward      )
																		# signature.parameters is an OrderedDict => so arg_names order is deterministic
																		lowerCAmelCase__			  =  [*signature.parameters.keys()]

																		lowerCAmelCase__			  =  ['pixel_values']
																		self.assertListEqual(arg_names[:1]   ,  _UpperCamelCase      )







						@slow
						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												for model_name in POOLFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																		lowerCAmelCase__			  =  PoolFormerModel.from_pretrained(_UpperCamelCase      )
																		self.assertIsNotNone(_UpperCamelCase      )







def 		_UpperCamelCase      (			)     ->      Optional[int]:

						"""simple docstring"""



						lowerCAmelCase__			  =  Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'						)
						return image


@require_torch
class 			__SCREAMING_SNAKE_CASE    (      unittest.TestCase):






						@slow
						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												lowerCAmelCase__			  =  PoolFormerImageProcessor()
												lowerCAmelCase__			  =  PoolFormerForImageClassification.from_pretrained('sail/poolformer_s12'      ).to(_UpperCamelCase      )

												lowerCAmelCase__			  =  image_processor(images=prepare_img()   ,  return_tensors='pt'      ).to(_UpperCamelCase      )

												# forward pass
												with torch.no_grad():
																		lowerCAmelCase__			  =  model(**_UpperCamelCase      )

												# verify the logits
												lowerCAmelCase__			  =  torch.Size((1, 10_00)      )
												self.assertEqual(outputs.logits.shape   ,  _UpperCamelCase      )

												lowerCAmelCase__			  =  torch.tensor([-0.61_13, 0.16_85, -0.04_92]      ).to(_UpperCamelCase      )
												self.assertTrue(torch.allclose(outputs.logits[0, :3]   ,  _UpperCamelCase   ,  atol=1E-4      )      )





