


from __future__ import annotations

import unittest

from transformers import AutoTokenizer, MBartConfig, is_tf_available
from transformers.testing_utils import require_sentencepiece, require_tf, require_tokenizers, slow
from transformers.utils import cached_property

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
   import tensorflow as tf

   from transformers import TFAutoModelForSeqaSeqLM, TFMBartForConditionalGeneration, TFMBartModel
@require_tf
class 		__magic_name__						:





     '''simple docstring'''



     __lowercase				:							Optional[int]	   =       MBartConfig
     __lowercase				:							Tuple	   =       {}
     __lowercase				:							Optional[int]	   =       'gelu'

     def __init__(					self:Tuple     ,		_a:int     ,		_a:List[Any]=13     ,		_a:List[str]=7     ,		_a:Tuple=True     ,		_a:Union[str, Any]=False     ,		_a:Any=99     ,		_a:List[Any]=32     ,		_a:List[Any]=2     ,		_a:int=4     ,		_a:Dict=37     ,		_a:int=0.1     ,		_a:List[str]=0.1     ,		_a:Any=20     ,		_a:Any=2     ,		_a:List[str]=1     ,		_a:List[str]=0     ,		):
       snake_case__						= parent
       snake_case__						= batch_size
       snake_case__						= seq_length
       snake_case__						= is_training
       snake_case__						= use_labels
       snake_case__						= vocab_size
       snake_case__						= hidden_size
       snake_case__						= num_hidden_layers
       snake_case__						= num_attention_heads
       snake_case__						= intermediate_size
       snake_case__						= hidden_dropout_prob
       snake_case__						= attention_probs_dropout_prob
       snake_case__						= max_position_embeddings
       snake_case__						= eos_token_id
       snake_case__						= pad_token_id
       snake_case__						= bos_token_id

     def 	SCREAMING_SNAKE_CASE__						(					self:Any   ):
       snake_case__						= ids_tensor([self.batch_size, self.seq_length - 1]     ,		self.vocab_size   )
       snake_case__						= tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size   )     ,		1   )
       snake_case__						= tf.concat([input_ids, eos_tensor]     ,		axis=1   )

       snake_case__						= ids_tensor([self.batch_size, self.seq_length]     ,		self.vocab_size   )

       snake_case__						= self.config_cls(
           vocab_size=self.vocab_size     ,		d_model=self.hidden_size     ,		encoder_layers=self.num_hidden_layers     ,		decoder_layers=self.num_hidden_layers     ,		encoder_attention_heads=self.num_attention_heads     ,		decoder_attention_heads=self.num_attention_heads     ,		encoder_ffn_dim=self.intermediate_size     ,		decoder_ffn_dim=self.intermediate_size     ,		dropout=self.hidden_dropout_prob     ,		attention_dropout=self.attention_probs_dropout_prob     ,		max_position_embeddings=self.max_position_embeddings     ,		eos_token_ids=[2]     ,		bos_token_id=self.bos_token_id     ,		pad_token_id=self.pad_token_id     ,		decoder_start_token_id=self.pad_token_id     ,		**self.config_updates     ,		)
       snake_case__						= prepare_mbart_inputs_dict(_a     ,		_a     ,		_a   )
       return config, inputs_dict







     def 	SCREAMING_SNAKE_CASE__						(					self:List[Any]     ,		_a:Tuple     ,		_a:Any   ):
       snake_case__						= TFMBartModel(config=_a   ).get_decoder()
       snake_case__						= inputs_dict['''input_ids''']

       snake_case__						= input_ids[:1, :]
       snake_case__						= inputs_dict['''attention_mask'''][:1, :]
       snake_case__						= inputs_dict['''head_mask''']
       snake_case__						= 1

       # first forward pass
       snake_case__						= model(_a     ,		attention_mask=_a     ,		head_mask=_a     ,		use_cache=_a   )

       snake_case__				,				snake_case__						= outputs.to_tuple()
       snake_case__						= past_key_values[1]







def SCREAMING_SNAKE_CASE	(			__lowerCAmelCase							,   __lowerCAmelCase							,   __lowerCAmelCase							,   __lowerCAmelCase=None							,   __lowerCAmelCase=None							,   __lowerCAmelCase=None							,   __lowerCAmelCase=None							,   __lowerCAmelCase=None							,   )    ->				List[str]:
  if attention_mask is None:
    snake_case__						= tf.cast(tf.math.not_equal(__lowerCAmelCase							,   config.pad_token_id				)							,   tf.inta				)
  if decoder_attention_mask is None:
    snake_case__						= tf.concat(
        [
            tf.ones(decoder_input_ids[:, :1].shape							,   dtype=tf.inta				),
            tf.cast(tf.math.not_equal(decoder_input_ids[:, 1:]							,   config.pad_token_id				)							,   tf.inta				),
        ]							,   axis=-1							,   )
  if head_mask is None:
    snake_case__						= tf.ones((config.encoder_layers, config.encoder_attention_heads)				)
  if decoder_head_mask is None:
    snake_case__						= tf.ones((config.decoder_layers, config.decoder_attention_heads)				)
  if cross_attn_head_mask is None:
    snake_case__						= tf.ones((config.decoder_layers, config.decoder_attention_heads)				)
  return {
      "input_ids": input_ids,
      "decoder_input_ids": decoder_input_ids,
      "attention_mask": attention_mask,
      "decoder_attention_mask": decoder_attention_mask,
      "head_mask": head_mask,
      "decoder_head_mask": decoder_head_mask,
      "cross_attn_head_mask": cross_attn_head_mask,
  }
@require_tf
class 		__magic_name__						(snake_case_   ,snake_case_   ,unittest.TestCase				):





     '''simple docstring'''



     __lowercase				:							str	   =       (TFMBartForConditionalGeneration, TFMBartModel) if is_tf_available() else ()
     __lowercase				:							Dict	   =       (TFMBartForConditionalGeneration,) if is_tf_available() else ()
     __lowercase				:							Optional[int]	   =       (
         {
             'conversational': TFMBartForConditionalGeneration,
             'feature-extraction': TFMBartModel,
             'summarization': TFMBartForConditionalGeneration,
             'text2text-generation': TFMBartForConditionalGeneration,
             'translation': TFMBartForConditionalGeneration,
         }
         if is_tf_available()
         else {}
     )
     __lowercase				:							Optional[int]	   =       True
     __lowercase				:							Tuple	   =       False
     __lowercase				:							List[str]	   =       False

     def 	SCREAMING_SNAKE_CASE__						(					self:Dict     ,		_a:str     ,		_a:Optional[int]     ,		_a:Optional[int]     ,		_a:List[Any]     ,		_a:int   ):
       if pipeline_test_casse_name != "FeatureExtractionPipelineTests":
         # Exception encountered when calling layer '...'
         return True

       return False

     def 	SCREAMING_SNAKE_CASE__						(					self:str   ):
       snake_case__						= TFMBartModelTester(self   )
       snake_case__						= ConfigTester(self     ,		config_class=_a   )

     def 	SCREAMING_SNAKE_CASE__						(					self:List[Any]   ):
       self.config_tester.run_common_tests()







     def 	SCREAMING_SNAKE_CASE__						(					self:Union[str, Any]   ):
       snake_case__						= self.model_tester.prepare_config_and_inputs_for_common()
       self.model_tester.check_decoder_model_past_large_inputs(*_a   )




@require_sentencepiece
@require_tokenizers
@require_tf
class 		__magic_name__						(unittest.TestCase				):





     '''simple docstring'''



     __lowercase				:							str	   =       [
         ' UN Chief Says There Is No Military Solution in Syria',
     ]
     __lowercase				:							Union[str, Any]	   =       [
         'Şeful ONU declară că nu există o soluţie militară în Siria',
     ]
     __lowercase				:							Any	   =       'facebook/mbart-large-en-ro'

     @cached_property
     def 	SCREAMING_SNAKE_CASE__						(					self:Any   ):
       return AutoTokenizer.from_pretrained(self.model_name   )

     @cached_property
     def 	SCREAMING_SNAKE_CASE__						(					self:Dict   ):
       snake_case__						= TFAutoModelForSeqaSeqLM.from_pretrained(self.model_name   )
       return model

     def 	SCREAMING_SNAKE_CASE__						(					self:List[Any]     ,		**_a:Optional[Any]   ):
       snake_case__						= self.translate_src_text(**_a   )
       self.assertListEqual(self.expected_text     ,		_a   )

     def 	SCREAMING_SNAKE_CASE__						(					self:Dict     ,		**_a:Optional[int]   ):
       snake_case__						= self.tokenizer(self.src_text     ,		**_a     ,		return_tensors='''tf'''   )
       snake_case__						= self.model.generate(
           model_inputs.input_ids     ,		attention_mask=model_inputs.attention_mask     ,		num_beams=2   )
       snake_case__						= self.tokenizer.batch_decode(_a     ,		skip_special_tokens=_a   )
       return generated_words







     @slow
     def 	SCREAMING_SNAKE_CASE__						(					self:int   ):
       self._assert_generated_batch_equal_expected()








import collections.abc
from typing import Optional, Tuple, Union

import torch
import torch.utils.checkpoint
from torch import nn
from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss

from ...activations import ACTaFN
from ...modeling_outputs import BaseModelOutputWithNoAttention, ImageClassifierOutputWithNoAttention
from ...modeling_utils import PreTrainedModel
from ...utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward, logging
from .configuration_poolformer import PoolFormerConfig


_lowerCamelCase 					=      logging.get_logger(__name__)

# General docstring
_lowerCamelCase 					=      'PoolFormerConfig'

# Base docstring
_lowerCamelCase 					=      'sail/poolformer_s12'
_lowerCamelCase 					=      [1, 512, 7, 7]

# Image classification docstring
_lowerCamelCase 					=      'sail/poolformer_s12'
_lowerCamelCase 					=      'tabby, tabby cat'

_lowerCamelCase 					=      [
    'sail/poolformer_s12',
    # See all PoolFormer models at https://huggingface.co/models?filter=poolformer
]






def 					SCREAMING_SNAKE_CASE__				(							UpperCamelCase__:				Optional[Any]       , UpperCamelCase__:				float = 0.0       , UpperCamelCase__:				bool = False     ):
		if drop_prob == 0.0 or not training:
				return input
		SCREAMING_SNAKE_CASE__								=   1 - drop_prob
		SCREAMING_SNAKE_CASE__								=   (input.shape[0],) + (1,) * (input.ndim - 1)  # work with diff dim tensors, not just 2D ConvNets
		SCREAMING_SNAKE_CASE__								=   keep_prob + torch.rand(UpperCamelCase__       , dtype=input.dtype       , device=input.device     )
		random_tensor.floor_()  # binarize
		SCREAMING_SNAKE_CASE__								=   input.div(UpperCamelCase__     ) * random_tensor
		return output




class 	UpperCamelCase_							(  nn.Module     ):


							def __init__(				self     :Optional[Any]				,					__A     :Optional[float] = None		) -> None:



									"""simple docstring"""



									super().__init__()
									SCREAMING_SNAKE_CASE__								=   drop_prob


							def   _snake_case	(				self     :Any				,					__A     :torch.Tensor		) -> torch.Tensor:



									"""simple docstring"""



									return drop_path(__A				,					self.drop_prob				,					self.training		)


							def   _snake_case	(				self     :Dict		) -> str:



									"""simple docstring"""



									return "p={}".format(self.drop_prob		)




class 	UpperCamelCase_							(  nn.Module     ):


							def __init__(				self     :Dict				,					__A     :Optional[Any]				,					__A     :Dict				,					__A     :List[str]				,					__A     :Optional[Any]				,					__A     :Tuple				,					__A     :Optional[Any]=None		) -> Union[str, Any]:



									"""simple docstring"""



									super().__init__()
									SCREAMING_SNAKE_CASE__								=   patch_size if isinstance(__A				,					collections.abc.Iterable		) else (patch_size, patch_size)
									SCREAMING_SNAKE_CASE__								=   stride if isinstance(__A				,					collections.abc.Iterable		) else (stride, stride)
									SCREAMING_SNAKE_CASE__								=   padding if isinstance(__A				,					collections.abc.Iterable		) else (padding, padding)

									SCREAMING_SNAKE_CASE__								=   nn.Convad(__A				,					__A				,					kernel_size=__A				,					stride=__A				,					padding=__A		)
									SCREAMING_SNAKE_CASE__								=   norm_layer(__A		) if norm_layer else nn.Identity()


							def   _snake_case	(				self     :Dict				,					__A     :Union[str, Any]		) -> Optional[Any]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   self.projection(__A		)
									SCREAMING_SNAKE_CASE__								=   self.norm(__A		)
									return embeddings




class 	UpperCamelCase_							(  nn.GroupNorm     ):


							def __init__(				self     :Dict				,					__A     :Tuple				,					**__A     :Union[str, Any]		) -> Dict:



									"""simple docstring"""



									super().__init__(1				,					__A				,					**__A		)




class 	UpperCamelCase_							(  nn.Module     ):


							def __init__(				self     :List[str]				,					__A     :Optional[int]		) -> Any:



									"""simple docstring"""



									super().__init__()
									SCREAMING_SNAKE_CASE__								=   nn.AvgPoolad(__A				,					stride=1				,					padding=pool_size // 2				,					count_include_pad=__A		)


							def   _snake_case	(				self     :Any				,					__A     :Optional[Any]		) -> Optional[Any]:



									"""simple docstring"""



									return self.pool(__A		) - hidden_states




class 	UpperCamelCase_							(  nn.Module     ):


							def __init__(				self     :Optional[Any]				,					__A     :Tuple				,					__A     :Dict				,					__A     :int				,					__A     :Any		) -> str:



									"""simple docstring"""



									super().__init__()
									SCREAMING_SNAKE_CASE__								=   nn.Convad(__A				,					__A				,					1		)
									SCREAMING_SNAKE_CASE__								=   nn.Convad(__A				,					__A				,					1		)
									SCREAMING_SNAKE_CASE__								=   PoolFormerDropPath(__A		)
									if isinstance(config.hidden_act				,					__A		):
											SCREAMING_SNAKE_CASE__								=   ACTaFN[config.hidden_act]
									else:
											SCREAMING_SNAKE_CASE__								=   config.hidden_act


							def   _snake_case	(				self     :Union[str, Any]				,					__A     :Optional[int]		) -> Dict:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   self.conva(__A		)
									SCREAMING_SNAKE_CASE__								=   self.act_fn(__A		)
									SCREAMING_SNAKE_CASE__								=   self.drop(__A		)
									SCREAMING_SNAKE_CASE__								=   self.conva(__A		)
									SCREAMING_SNAKE_CASE__								=   self.drop(__A		)

									return hidden_states




class 	UpperCamelCase_							(  nn.Module     ):


							def __init__(				self     :Any				,					__A     :str				,					__A     :List[str]				,					__A     :Tuple				,					__A     :Dict				,					__A     :Union[str, Any]				,					__A     :int		) -> Optional[int]:



									"""simple docstring"""



									super().__init__()
									SCREAMING_SNAKE_CASE__								=   PoolFormerPooling(__A		)
									SCREAMING_SNAKE_CASE__								=   PoolFormerOutput(__A				,					__A				,					__A				,					__A		)
									SCREAMING_SNAKE_CASE__								=   PoolFormerGroupNorm(__A		)
									SCREAMING_SNAKE_CASE__								=   PoolFormerGroupNorm(__A		)

									# Useful for training neural nets
									SCREAMING_SNAKE_CASE__								=   PoolFormerDropPath(__A		) if drop_path > 0.0 else nn.Identity()
									SCREAMING_SNAKE_CASE__								=   config.use_layer_scale
									if config.use_layer_scale:
											SCREAMING_SNAKE_CASE__								=   nn.Parameter(
											    config.layer_scale_init_value * torch.ones((__A)		)				,					requires_grad=__A		)
											SCREAMING_SNAKE_CASE__								=   nn.Parameter(
											    config.layer_scale_init_value * torch.ones((__A)		)				,					requires_grad=__A		)


							def   _snake_case	(				self     :Optional[Any]				,					__A     :Optional[int]		) -> str:



									"""simple docstring"""



									if self.use_layer_scale:
											SCREAMING_SNAKE_CASE__								=   self.pooling(self.before_norm(__A		)		)
											SCREAMING_SNAKE_CASE__								=   self.layer_scale_a.unsqueeze(-1		).unsqueeze(-1		) * pooling_output
											# First residual connection
											SCREAMING_SNAKE_CASE__								=   hidden_states + self.drop_path(__A		)
											SCREAMING_SNAKE_CASE__								=   ()

											SCREAMING_SNAKE_CASE__								=   self.output(self.after_norm(__A		)		)
											SCREAMING_SNAKE_CASE__								=   self.layer_scale_a.unsqueeze(-1		).unsqueeze(-1		) * layer_output
											# Second residual connection
											SCREAMING_SNAKE_CASE__								=   hidden_states + self.drop_path(__A		)

											SCREAMING_SNAKE_CASE__								=   (output,) + outputs
											return outputs

									else:
											SCREAMING_SNAKE_CASE__								=   self.drop_path(self.pooling(self.before_norm(__A		)		)		)
											# First residual connection
											SCREAMING_SNAKE_CASE__								=   pooling_output + hidden_states
											SCREAMING_SNAKE_CASE__								=   ()

											# Second residual connection inside the PoolFormerOutput block
											SCREAMING_SNAKE_CASE__								=   self.drop_path(self.output(self.after_norm(__A		)		)		)
											SCREAMING_SNAKE_CASE__								=   hidden_states + layer_output

											SCREAMING_SNAKE_CASE__								=   (output,) + outputs
											return outputs




class 	UpperCamelCase_							(  nn.Module     ):


							def __init__(				self     :Union[str, Any]				,					__A     :List[Any]		) -> Union[str, Any]:



									"""simple docstring"""



									super().__init__()
									SCREAMING_SNAKE_CASE__								=   config
									# stochastic depth decay rule
									SCREAMING_SNAKE_CASE__								=   [x.item() for x in torch.linspace(0				,					config.drop_path_rate				,					sum(config.depths		)		)]

									# patch embeddings
									SCREAMING_SNAKE_CASE__								=   []
									for i in range(config.num_encoder_blocks		):
											embeddings.append(
											    PoolFormerEmbeddings(
											        patch_size=config.patch_sizes[i]				,					stride=config.strides[i]				,					padding=config.padding[i]				,					num_channels=config.num_channels if i == 0 else config.hidden_sizes[i - 1]				,					hidden_size=config.hidden_sizes[i]				,					)		)
									SCREAMING_SNAKE_CASE__								=   nn.ModuleList(__A		)

									# Transformer blocks
									SCREAMING_SNAKE_CASE__								=   []
									SCREAMING_SNAKE_CASE__								=   0
									for i in range(config.num_encoder_blocks		):
											# each block consists of layers
											SCREAMING_SNAKE_CASE__								=   []
											if i != 0:
													cur += config.depths[i - 1]
											for j in range(config.depths[i]		):
													layers.append(
													    PoolFormerLayer(
													        __A				,					num_channels=config.hidden_sizes[i]				,					pool_size=config.pool_size				,					hidden_size=config.hidden_sizes[i]				,					intermediate_size=int(config.hidden_sizes[i] * config.mlp_ratio		)				,					drop_path=dpr[cur + j]				,					)		)
											blocks.append(nn.ModuleList(__A		)		)

									SCREAMING_SNAKE_CASE__								=   nn.ModuleList(__A		)


							def   _snake_case	(				self     :str				,					__A     :Tuple				,					__A     :Dict=False				,					__A     :Tuple=True		) -> Optional[int]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   () if output_hidden_states else None

									SCREAMING_SNAKE_CASE__								=   pixel_values
									for idx, layers in enumerate(zip(self.patch_embeddings				,					self.block		)		):
											SCREAMING_SNAKE_CASE__						,    SCREAMING_SNAKE_CASE__								=   layers
											# Get patch embeddings from hidden_states
											SCREAMING_SNAKE_CASE__								=   embedding_layer(__A		)
											# Send the embeddings through the blocks
											for _, blk in enumerate(__A		):
													SCREAMING_SNAKE_CASE__								=   blk(__A		)
													SCREAMING_SNAKE_CASE__								=   layer_outputs[0]

											if output_hidden_states:
													SCREAMING_SNAKE_CASE__								=   all_hidden_states + (hidden_states,)

									if not return_dict:
											return tuple(v for v in [hidden_states, all_hidden_states] if v is not None		)

									return BaseModelOutputWithNoAttention(last_hidden_state=__A				,					hidden_states=__A		)




class 	UpperCamelCase_							(  UpperCamelCase__     ):
							lowerCamelCase_							     =       PoolFormerConfig
							lowerCamelCase_							     =       "poolformer"
							lowerCamelCase_							     =       "pixel_values"
							lowerCamelCase_							     =       True


							def   _snake_case	(				self     :Optional[Any]				,					__A     :Tuple		) -> Dict:



									"""simple docstring"""



									if isinstance(__A				,					(nn.Linear, nn.Convad)		):
											module.weight.data.normal_(mean=0.0				,					std=self.config.initializer_range		)
											if module.bias is not None:
													module.bias.data.zero_()
									elif isinstance(__A				,					nn.LayerNorm		):
											module.bias.data.zero_()
											module.weight.data.fill_(1.0		)


							def   _snake_case	(				self     :str				,					__A     :Optional[Any]				,					__A     :Union[str, Any]=False		) -> Any:



									"""simple docstring"""



									if isinstance(__A				,					__A		):
											SCREAMING_SNAKE_CASE__								=   value



_lowerCamelCase 					=      R'\n    This model is a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) sub-class. Use\n    it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage and\n    behavior.\n\n    Parameters:\n        config ([`PoolFormerConfig`]): Model configuration class with all the parameters of the model.\n            Initializing with a config file does not load the weights associated with the model, only the\n            configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights.\n'

_lowerCamelCase 					=      R'\n    Args:\n        pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`):\n            Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See\n            [`PoolFormerImageProcessor.__call__`] for details.\n'




@add_start_docstrings(
    "The bare PoolFormer Model transformer outputting raw hidden-states without any specific head on top."					,	UpperCamelCase__					,	)
class 	UpperCamelCase_							(  UpperCamelCase__     ):


							def __init__(				self     :Union[str, Any]				,					__A     :Any		) -> int:



									"""simple docstring"""



									super().__init__(__A		)
									SCREAMING_SNAKE_CASE__								=   config

									SCREAMING_SNAKE_CASE__								=   PoolFormerEncoder(__A		)

									# Initialize weights and apply final processing
									self.post_init()


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



									"""simple docstring"""



									return self.embeddings.patch_embeddings


							@add_start_docstrings_to_model_forward(__A		)
							@add_code_sample_docstrings(
							    checkpoint=_CHECKPOINT_FOR_DOC				,					output_type=__A				,					config_class=_CONFIG_FOR_DOC				,					modality="""vision"""				,					expected_output=_EXPECTED_OUTPUT_SHAPE				,					)
							def   _snake_case	(				self     :Dict				,					__A     :Optional[torch.FloatTensor] = None				,					__A     :Optional[bool] = None				,					__A     :Optional[bool] = None				,					) -> Union[Tuple, BaseModelOutputWithNoAttention]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   (
									    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
									)
									SCREAMING_SNAKE_CASE__								=   return_dict if return_dict is not None else self.config.use_return_dict

									if pixel_values is None:
											raise ValueError("""You have to specify pixel_values"""		)

									SCREAMING_SNAKE_CASE__								=   self.encoder(
									    __A				,					output_hidden_states=__A				,					return_dict=__A				,					)
									SCREAMING_SNAKE_CASE__								=   encoder_outputs[0]

									if not return_dict:
											return (sequence_output, None) + encoder_outputs[1:]

									return BaseModelOutputWithNoAttention(
									    last_hidden_state=__A				,					hidden_states=encoder_outputs.hidden_states				,					)




class 	UpperCamelCase_							(  nn.Module     ):


							def __init__(				self     :int				,					__A     :Optional[int]		) -> Tuple:



									"""simple docstring"""



									super().__init__()
									SCREAMING_SNAKE_CASE__								=   nn.Linear(config.hidden_size				,					config.hidden_size		)


							def   _snake_case	(				self     :List[Any]				,					__A     :Dict		) -> int:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   self.dense(__A		)
									return output




@add_start_docstrings(
    "\n    PoolFormer Model transformer with an image classification head on top\n    "					,	UpperCamelCase__					,	)
class 	UpperCamelCase_							(  UpperCamelCase__     ):


							def __init__(				self     :str				,					__A     :Union[str, Any]		) -> int:



									"""simple docstring"""



									super().__init__(__A		)
									SCREAMING_SNAKE_CASE__								=   config.num_labels
									SCREAMING_SNAKE_CASE__								=   PoolFormerModel(__A		)

									# Final norm
									SCREAMING_SNAKE_CASE__								=   PoolFormerGroupNorm(config.hidden_sizes[-1]		)
									# Classifier head
									SCREAMING_SNAKE_CASE__								=   (
									    nn.Linear(config.hidden_sizes[-1]				,					config.num_labels		) if config.num_labels > 0 else nn.Identity()
									)

									# Initialize weights and apply final processing
									self.post_init()


							@add_start_docstrings_to_model_forward(__A		)
							@add_code_sample_docstrings(
							    checkpoint=_IMAGE_CLASS_CHECKPOINT				,					output_type=__A				,					config_class=_CONFIG_FOR_DOC				,					expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT				,					)
							def   _snake_case	(				self     :int				,					__A     :Optional[torch.FloatTensor] = None				,					__A     :Optional[torch.LongTensor] = None				,					__A     :Optional[bool] = None				,					__A     :Optional[bool] = None				,					) -> Union[Tuple, ImageClassifierOutputWithNoAttention]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   return_dict if return_dict is not None else self.config.use_return_dict

									SCREAMING_SNAKE_CASE__								=   self.poolformer(
									    __A				,					output_hidden_states=__A				,					return_dict=__A				,					)

									SCREAMING_SNAKE_CASE__								=   outputs[0]

									SCREAMING_SNAKE_CASE__								=   self.classifier(self.norm(__A		).mean([-2, -1]		)		)

									SCREAMING_SNAKE_CASE__								=   None
									if labels is not None:
											if self.config.problem_type is None:
													if self.num_labels == 1:
															SCREAMING_SNAKE_CASE__								=   """regression"""
													elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
															SCREAMING_SNAKE_CASE__								=   """single_label_classification"""
													else:
															SCREAMING_SNAKE_CASE__								=   """multi_label_classification"""

											if self.config.problem_type == "regression":
													SCREAMING_SNAKE_CASE__								=   MSELoss()
													if self.num_labels == 1:
															SCREAMING_SNAKE_CASE__								=   loss_fct(logits.squeeze()				,					labels.squeeze()		)
													else:
															SCREAMING_SNAKE_CASE__								=   loss_fct(__A				,					__A		)
											elif self.config.problem_type == "single_label_classification":
													SCREAMING_SNAKE_CASE__								=   CrossEntropyLoss()
													SCREAMING_SNAKE_CASE__								=   loss_fct(logits.view(-1				,					self.num_labels		)				,					labels.view(-1		)		)
											elif self.config.problem_type == "multi_label_classification":
													SCREAMING_SNAKE_CASE__								=   BCEWithLogitsLoss()
													SCREAMING_SNAKE_CASE__								=   loss_fct(__A				,					__A		)

									if not return_dict:
											SCREAMING_SNAKE_CASE__								=   (logits,) + outputs[2:]
											return ((loss,) + output) if loss is not None else output

									return ImageClassifierOutputWithNoAttention(loss=__A				,					logits=__A				,					hidden_states=outputs.hidden_states		)