




'''simple docstring'''







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      lowerCamelCase_							(       UpperCAmelCase_							):




					'''simple docstring'''






					def 				__SCREAMING_SNAKE_CASE	(    self ):
							_snake_case	       =       self.config_class(**self.inputs_dict )
							self.parent.assertTrue(hasattr(__UpperCamelCase,  "hidden_sizes" ) )
							self.parent.assertTrue(hasattr(__UpperCamelCase,  "num_encoder_blocks" ) )





class      lowerCamelCase_							:




					'''simple docstring'''






					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, 128],  __UpperCamelCase=[1, 4, 8, 16],  __UpperCamelCase=False,  __UpperCamelCase=True,  __UpperCamelCase="gelu",  __UpperCamelCase=0.1,  __UpperCamelCase=0.02,  __UpperCamelCase=3,  __UpperCamelCase=None,  ):
							_snake_case	       =       parent
							_snake_case	       =       batch_size
							_snake_case	       =       image_size
							_snake_case	       =       num_channels
							_snake_case	       =       num_encoder_blocks
							_snake_case	       =       sr_ratios
							_snake_case	       =       depths
							_snake_case	       =       hidden_sizes
							_snake_case	       =       downsampling_rates
							_snake_case	       =       is_training
							_snake_case	       =       use_labels
							_snake_case	       =       hidden_act
							_snake_case	       =       hidden_dropout_prob
							_snake_case	       =       initializer_range
							_snake_case	       =       num_labels
							_snake_case	       =       scope






					def 				__SCREAMING_SNAKE_CASE	(    self ):
							_snake_case	       =       floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

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

							_snake_case	       =       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 				__SCREAMING_SNAKE_CASE	(    self,  __UpperCamelCase,  __UpperCamelCase,  __UpperCamelCase ):
							_snake_case	       =       PoolFormerModel(config=__UpperCamelCase )
							model.to(__UpperCamelCase )
							model.eval()
							_snake_case	       =       model(__UpperCamelCase )
							_snake_case	       =       _snake_case	       =       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 				__SCREAMING_SNAKE_CASE	(    self ):
							_snake_case	       =       self.prepare_config_and_inputs()
							_snake_case       ,    _snake_case       ,    _snake_case	       =       config_and_inputs
							_snake_case	       =       {"pixel_values": pixel_values}
							return config, inputs_dict





@require_torch
class      lowerCamelCase_							(       UpperCAmelCase_,       UpperCAmelCase_,       unittest.TestCase							):




					'''simple docstring'''






					lowercase__    = (PoolFormerModel, PoolFormerForImageClassification) if is_torch_available() else ()
					lowercase__    = (
					    {"""feature-extraction""": PoolFormerModel, """image-classification""": PoolFormerForImageClassification}
					    if is_torch_available()
					    else {}
					)

					lowercase__    = False
					lowercase__    = False
					lowercase__    = False
					lowercase__    = False
					lowercase__    = False






					def 				__SCREAMING_SNAKE_CASE	(    self ):
							_snake_case	       =       PoolFormerModelTester(self )
							_snake_case	       =       PoolFormerConfigTester(self,  config_class=__UpperCamelCase )






					def 				__SCREAMING_SNAKE_CASE	(    self ):
							self.config_tester.run_common_tests()






					def 				__SCREAMING_SNAKE_CASE	(    self ):
							_snake_case	       =       self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*__UpperCamelCase )






					@unittest.skip("PoolFormer does not use inputs_embeds" )
					def 				__SCREAMING_SNAKE_CASE	(    self ):
							pass






					@unittest.skip("PoolFormer does not have get_input_embeddings method and get_output_embeddings methods" )
					def 				__SCREAMING_SNAKE_CASE	(    self ):
							pass






					def 				__SCREAMING_SNAKE_CASE	(    self ):
							def check_hidden_states_output(__UpperCamelCase,  __UpperCamelCase,  __UpperCamelCase ):
									_snake_case	       =       model_class(__UpperCamelCase )
									model.to(__UpperCamelCase )
									model.eval()

									with torch.no_grad():
											_snake_case	       =       model(**self._prepare_for_class(__UpperCamelCase,  __UpperCamelCase ) )

									_snake_case	       =       outputs.hidden_states

									_snake_case	       =       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,
									    ],  )

							_snake_case       ,    _snake_case	       =       self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
									_snake_case	       =       True
									check_hidden_states_output(__UpperCamelCase,  __UpperCamelCase,  __UpperCamelCase )

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

									check_hidden_states_output(__UpperCamelCase,  __UpperCamelCase,  __UpperCamelCase )






					def 				__SCREAMING_SNAKE_CASE	(    self ):
							if not self.model_tester.is_training:
									return

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

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






					def 				__SCREAMING_SNAKE_CASE	(    self ):
							_snake_case       ,    _snake_case	       =       self.model_tester.prepare_config_and_inputs_for_common()

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

									_snake_case	       =       ["pixel_values"]
									self.assertListEqual(arg_names[:1],  __UpperCamelCase )






					@slow
					def 				__SCREAMING_SNAKE_CASE	(    self ):
							for model_name in POOLFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									_snake_case	       =       PoolFormerModel.from_pretrained(__UpperCamelCase )
									self.assertIsNotNone(__UpperCamelCase )






def 		_lowercase		(	):



		'''simple docstring'''







		_snake_case	       =       Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"  )
		return image





@require_torch
class      lowerCamelCase_							(       unittest.TestCase							):




					'''simple docstring'''






					@slow
					def 				__SCREAMING_SNAKE_CASE	(    self ):
							_snake_case	       =       PoolFormerImageProcessor()
							_snake_case	       =       PoolFormerForImageClassification.from_pretrained("sail/poolformer_s12" ).to(__UpperCamelCase )

							_snake_case	       =       image_processor(images=prepare_img(),  return_tensors="pt" ).to(__UpperCamelCase )

							# forward pass
							with torch.no_grad():
									_snake_case	       =       model(**__UpperCamelCase )

							# verify the logits
							_snake_case	       =       torch.Size((1, 1_000) )
							self.assertEqual(outputs.logits.shape,  __UpperCamelCase )

							_snake_case	       =       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 ) )








"""simple docstring"""




def    __SCREAMING_SNAKE_CASE						(						lowercase__ = 1_000      ):
					"""simple docstring"""
					return sum(i for i in range(lowercase__      ) if i % 3 == 0 or i % 5 == 0      )


if __name__ == "__main__":
	print(f"""{solution() = }""")





