


'''simple docstring'''






from typing import Mapping

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


__UpperCAmelCase    				=							logging.get_logger(__name__)

__UpperCAmelCase    				=							{
    """google/long-t5-local-base""": """https://huggingface.co/google/long-t5-local-base/blob/main/config.json""",
    """google/long-t5-local-large""": """https://huggingface.co/google/long-t5-local-large/blob/main/config.json""",
    """google/long-t5-tglobal-base""": """https://huggingface.co/google/long-t5-tglobal-base/blob/main/config.json""",
    """google/long-t5-tglobal-large""": """https://huggingface.co/google/long-t5-tglobal-large/blob/main/config.json""",
}




class 		a__				(							__lowercase  ):





							'''simple docstring'''






							lowercase__			:   Dict							=      '''longt5'''
							lowercase__			:   Tuple							=      ['''past_key_values''']
							lowercase__			:   Optional[Any]							=      {'''hidden_size''': '''d_model''', '''num_attention_heads''': '''num_heads''', '''num_hidden_layers''': '''num_layers'''}







							def __init__(		self					,    lowerCamelCase_=3_21_28					,    lowerCamelCase_=5_12					,    lowerCamelCase_=64					,    lowerCamelCase_=20_48					,    lowerCamelCase_=6					,    lowerCamelCase_=None					,    lowerCamelCase_=8					,    lowerCamelCase_=1_27					,    lowerCamelCase_=16					,    lowerCamelCase_=32					,    lowerCamelCase_=1_28					,    lowerCamelCase_=0.1					,    lowerCamelCase_=1e-6					,    lowerCamelCase_=1.0					,    lowerCamelCase_="relu"					,    lowerCamelCase_=True					,    lowerCamelCase_="local"					,    lowerCamelCase_=True					,    lowerCamelCase_=0					,    lowerCamelCase_=1					,    **lowerCamelCase_					,    )       ->							Optional[int]:
														lowerCAmelCase__          =	vocab_size
														lowerCAmelCase__          =	d_model
														lowerCAmelCase__          =	d_kv
														lowerCAmelCase__          =	d_ff
														lowerCAmelCase__          =	num_layers
														# default = symmetry
														lowerCAmelCase__          =	num_decoder_layers if num_decoder_layers is not None else self.num_layers
														lowerCAmelCase__          =	num_heads
														lowerCAmelCase__          =	local_radius
														lowerCAmelCase__          =	global_block_size
														lowerCAmelCase__          =	relative_attention_num_buckets
														lowerCAmelCase__          =	relative_attention_max_distance
														lowerCAmelCase__          =	dropout_rate
														lowerCAmelCase__          =	layer_norm_epsilon
														lowerCAmelCase__          =	initializer_factor
														lowerCAmelCase__          =	feed_forward_proj
														lowerCAmelCase__          =	encoder_attention_type
														lowerCAmelCase__          =	use_cache

														lowerCAmelCase__          =	self.feed_forward_proj.split('''-'''   )
														lowerCAmelCase__          =	act_info[-1]
														lowerCAmelCase__          =	act_info[0] == '''gated'''

														if len(_UpperCamelCase   ) > 1 and act_info[0] != "gated" or len(_UpperCamelCase   ) > 2:
																					raise ValueError(
																					    F"""`feed_forward_proj`: {feed_forward_proj} is not a valid activation function of the dense layer."""
																					    '''Please make sure `feed_forward_proj` is of the format `gated-{ACT_FN}` or `{ACT_FN}`, e.g. '''
																					    '''\'gated-gelu\' or \'relu\''''   )

														# for backwards compatibility
														if feed_forward_proj == "gated-gelu":
																					lowerCAmelCase__          =	'''gelu_new'''

														super().__init__(
														    pad_token_id=_UpperCamelCase					,    eos_token_id=_UpperCamelCase					,    is_encoder_decoder=_UpperCamelCase					,    **_UpperCamelCase					,    )




class 		a__				(							__lowercase  ):





							'''simple docstring'''






							@property
							def   __SCREAMING_SNAKE_CASE							(		self   )       ->							Dict:
														lowerCAmelCase__          =	{
														    '''input_ids''': {0: '''batch''', 1: '''encoder_sequence'''},
														    '''attention_mask''': {0: '''batch''', 1: '''encoder_sequence'''},
														}
														if self.use_past:
																					lowerCAmelCase__          =	'''past_encoder_sequence + sequence'''
																					lowerCAmelCase__          =	{0: '''batch'''}
																					lowerCAmelCase__          =	{0: '''batch''', 1: '''past_decoder_sequence + sequence'''}
														else:
																					lowerCAmelCase__          =	{0: '''batch''', 1: '''decoder_sequence'''}
																					lowerCAmelCase__          =	{0: '''batch''', 1: '''decoder_sequence'''}

														if self.use_past:
																					self.fill_with_past_key_values_(_UpperCamelCase					,    direction='''inputs'''   )

														return common_inputs







							@property
							def   __SCREAMING_SNAKE_CASE							(		self   )       ->							Union[str, Any]:
														return 13







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





