



import unittest

from transformers import SPIECE_UNDERLINE, ReformerTokenizer, ReformerTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, require_torch, slow
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin


__A							       =		get_tests_dir('''fixtures/test_sentencepiece.model''')






@require_sentencepiece
@require_tokenizers
class 						lowercase		(					UpperCamelCase__					,       unittest.TestCase):






	"""simple docstring"""


	a__ :   str						  =				ReformerTokenizer
	a__ :   Dict						  =				ReformerTokenizerFast
	a__ :   int						  =				True
	a__ :   Any						  =				False
	a__ :   Any						  =				True




	def     _SCREAMING_SNAKE_CASE						(      self      :		str	)     ->					Any:
							super().setUp()

							UpperCAmelCase_=  ReformerTokenizer(__UpperCAmelCase		,    keep_accents=__UpperCAmelCase	)
							tokenizer.save_pretrained(self.tmpdirname	)




	def     _SCREAMING_SNAKE_CASE						(      self      :		Union[str, Any]	)     ->					Optional[Any]:
							UpperCAmelCase_=  """<s>"""
							UpperCAmelCase_=  1

							self.assertEqual(self.get_tokenizer()._convert_token_to_id(__UpperCAmelCase	)		,    __UpperCAmelCase	)
							self.assertEqual(self.get_tokenizer()._convert_id_to_token(__UpperCAmelCase	)		,    __UpperCAmelCase	)




	def     _SCREAMING_SNAKE_CASE						(      self      :		Tuple	)     ->					Optional[int]:
							UpperCAmelCase_=  list(self.get_tokenizer().get_vocab().keys()	)

							self.assertEqual(vocab_keys[0]		,    """<unk>"""	)
							self.assertEqual(vocab_keys[1]		,    """<s>"""	)
							self.assertEqual(vocab_keys[-1]		,    """j"""	)
							self.assertEqual(len(__UpperCAmelCase	)		,    1_000	)




	def     _SCREAMING_SNAKE_CASE						(      self      :		Optional[Any]	)     ->					List[Any]:
							self.assertEqual(self.get_tokenizer().vocab_size		,    1_000	)




	def     _SCREAMING_SNAKE_CASE						(      self      :		Optional[Any]	)     ->					Tuple:
							if not self.test_rust_tokenizer:
													return

							UpperCAmelCase_=  self.get_tokenizer()
							UpperCAmelCase_=  self.get_rust_tokenizer()

							UpperCAmelCase_=  """I was born in 92000, and this is falsé."""

							UpperCAmelCase_=  tokenizer.tokenize(__UpperCAmelCase	)
							UpperCAmelCase_=  rust_tokenizer.tokenize(__UpperCAmelCase	)
							self.assertListEqual(__UpperCAmelCase		,    __UpperCAmelCase	)

							UpperCAmelCase_=  tokenizer.encode(__UpperCAmelCase		,    add_special_tokens=__UpperCAmelCase	)
							UpperCAmelCase_=  rust_tokenizer.encode(__UpperCAmelCase		,    add_special_tokens=__UpperCAmelCase	)
							self.assertListEqual(__UpperCAmelCase		,    __UpperCAmelCase	)

							UpperCAmelCase_=  self.get_rust_tokenizer()
							UpperCAmelCase_=  tokenizer.encode(__UpperCAmelCase	)
							UpperCAmelCase_=  rust_tokenizer.encode(__UpperCAmelCase	)
							self.assertListEqual(__UpperCAmelCase		,    __UpperCAmelCase	)




	def     _SCREAMING_SNAKE_CASE						(      self      :		Any		,    __UpperCAmelCase      :		Tuple=15	)     ->					Optional[int]:
							for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
													with self.subTest(F"""{tokenizer.__class__.__name__} ({pretrained_name})"""	):
																			UpperCAmelCase_=  self.rust_tokenizer_class.from_pretrained(__UpperCAmelCase		,    **__UpperCAmelCase	)

																			# Simple input
																			UpperCAmelCase_=  """This is a simple input"""
																			UpperCAmelCase_=  ["""This is a simple input 1""", """This is a simple input 2"""]
																			UpperCAmelCase_=  ("""This is a simple input""", """This is a pair""")
																			UpperCAmelCase_=  [
																			    ("""This is a simple input 1""", """This is a simple input 2"""),
																			    ("""This is a simple pair 1""", """This is a simple pair 2"""),
																			]

																			# Simple input tests
																			self.assertRaises(__UpperCAmelCase		,    tokenizer_r.encode		,    __UpperCAmelCase		,    max_length=__UpperCAmelCase		,    padding="""max_length"""	)

																			# Simple input
																			self.assertRaises(__UpperCAmelCase		,    tokenizer_r.encode_plus		,    __UpperCAmelCase		,    max_length=__UpperCAmelCase		,    padding="""max_length"""	)

																			# Simple input
																			self.assertRaises(
																			    __UpperCAmelCase		,    tokenizer_r.batch_encode_plus		,    __UpperCAmelCase		,    max_length=__UpperCAmelCase		,    padding="""max_length"""		,    )

																			# Pair input
																			self.assertRaises(__UpperCAmelCase		,    tokenizer_r.encode		,    __UpperCAmelCase		,    max_length=__UpperCAmelCase		,    padding="""max_length"""	)

																			# Pair input
																			self.assertRaises(__UpperCAmelCase		,    tokenizer_r.encode_plus		,    __UpperCAmelCase		,    max_length=__UpperCAmelCase		,    padding="""max_length"""	)

																			# Pair input
																			self.assertRaises(
																			    __UpperCAmelCase		,    tokenizer_r.batch_encode_plus		,    __UpperCAmelCase		,    max_length=__UpperCAmelCase		,    padding="""max_length"""		,    )




	def     _SCREAMING_SNAKE_CASE						(      self      :		Any	)     ->					List[Any]:
							pass




	def     _SCREAMING_SNAKE_CASE						(      self      :		str	)     ->					Optional[int]:
							UpperCAmelCase_=  ReformerTokenizer(__UpperCAmelCase		,    keep_accents=__UpperCAmelCase	)

							UpperCAmelCase_=  tokenizer.tokenize("""This is a test"""	)
							self.assertListEqual(__UpperCAmelCase		,    ["""▁This""", """▁is""", """▁a""", """▁t""", """est"""]	)

							self.assertListEqual(
							    tokenizer.convert_tokens_to_ids(__UpperCAmelCase	)		,    [285, 46, 10, 170, 382]		,    )

							UpperCAmelCase_=  tokenizer.tokenize("""I was born in 92000, and this is falsé."""	)
							self.assertListEqual(
							    __UpperCAmelCase		,    [
							        SPIECE_UNDERLINE + """I""",
							        SPIECE_UNDERLINE + """was""",
							        SPIECE_UNDERLINE + """b""",
							        """or""",
							        """n""",
							        SPIECE_UNDERLINE + """in""",
							        SPIECE_UNDERLINE + """""",
							        """9""",
							        """2""",
							        """0""",
							        """0""",
							        """0""",
							        """,""",
							        SPIECE_UNDERLINE + """and""",
							        SPIECE_UNDERLINE + """this""",
							        SPIECE_UNDERLINE + """is""",
							        SPIECE_UNDERLINE + """f""",
							        """al""",
							        """s""",
							        """é""",
							        """.""",
							    ]		,    )
							UpperCAmelCase_=  tokenizer.convert_tokens_to_ids(__UpperCAmelCase	)
							self.assertListEqual(
							    __UpperCAmelCase		,    [8, 21, 84, 55, 24, 19, 7, 0, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, 0, 4]		,    )

							UpperCAmelCase_=  tokenizer.convert_ids_to_tokens(__UpperCAmelCase	)
							self.assertListEqual(
							    __UpperCAmelCase		,    [
							        SPIECE_UNDERLINE + """I""",
							        SPIECE_UNDERLINE + """was""",
							        SPIECE_UNDERLINE + """b""",
							        """or""",
							        """n""",
							        SPIECE_UNDERLINE + """in""",
							        SPIECE_UNDERLINE + """""",
							        """<unk>""",
							        """2""",
							        """0""",
							        """0""",
							        """0""",
							        """,""",
							        SPIECE_UNDERLINE + """and""",
							        SPIECE_UNDERLINE + """this""",
							        SPIECE_UNDERLINE + """is""",
							        SPIECE_UNDERLINE + """f""",
							        """al""",
							        """s""",
							        """<unk>""",
							        """.""",
							    ]		,    )




	@cached_property
	def     _SCREAMING_SNAKE_CASE						(      self      :		List[Any]	)     ->					str:
							return ReformerTokenizer.from_pretrained("""google/reformer-crime-and-punishment"""	)




	@slow
	def     _SCREAMING_SNAKE_CASE						(      self      :		int	)     ->					Optional[Any]:
							UpperCAmelCase_=  """Hello World!"""
							UpperCAmelCase_=  [126, 32, 262, 152, 38, 72, 287]

							self.assertListEqual(__UpperCAmelCase		,    self.big_tokenizer.encode(__UpperCAmelCase	)	)




	@slow
	def     _SCREAMING_SNAKE_CASE						(      self      :		List[Any]	)     ->					int:
							UpperCAmelCase_=  (
							    """This is a very long text with a lot of weird characters, such as: . , ~ ? ( ) \" [ ] ! : - . Also we will"""
							    """ add words that should not exsist and be tokenized to <unk>, such as saoneuhaoesuth"""
							)
							UpperCAmelCase_=  [
							    108,
							    265,
							    24,
							    111,
							    4,
							    258,
							    156,
							    35,
							    28,
							    275,
							    3,
							    259,
							    297,
							    260,
							    84,
							    4,
							    35,
							    110,
							    44,
							    8,
							    259,
							    91,
							    268,
							    21,
							    11,
							    209,
							    274,
							    109,
							    266,
							    277,
							    117,
							    86,
							    93,
							    315,
							    258,
							    278,
							    258,
							    277,
							    258,
							    0,
							    258,
							    288,
							    258,
							    319,
							    258,
							    0,
							    258,
							    0,
							    258,
							    0,
							    258,
							    0,
							    258,
							    287,
							    258,
							    315,
							    258,
							    289,
							    258,
							    278,
							    99,
							    269,
							    266,
							    262,
							    8,
							    259,
							    241,
							    4,
							    217,
							    230,
							    268,
							    266,
							    55,
							    168,
							    106,
							    75,
							    193,
							    266,
							    223,
							    27,
							    49,
							    26,
							    282,
							    25,
							    264,
							    299,
							    19,
							    26,
							    0,
							    258,
							    277,
							    117,
							    86,
							    93,
							    176,
							    183,
							    270,
							    11,
							    262,
							    42,
							    61,
							    265,
							]

							self.assertListEqual(__UpperCAmelCase		,    self.big_tokenizer.encode(__UpperCAmelCase	)	)




	@require_torch
	@slow
	def     _SCREAMING_SNAKE_CASE						(      self      :		Union[str, Any]	)     ->					str:
							import torch

							from transformers import ReformerConfig, ReformerModel

							# Build sequence
							UpperCAmelCase_=  list(self.big_tokenizer.get_vocab().keys()	)[:10]
							UpperCAmelCase_=  """ """.join(__UpperCAmelCase	)
							UpperCAmelCase_=  self.big_tokenizer.encode_plus(__UpperCAmelCase		,    return_tensors="""pt"""	)
							UpperCAmelCase_=  self.big_tokenizer.batch_encode_plus([sequence, sequence]		,    return_tensors="""pt"""	)

							UpperCAmelCase_=  ReformerConfig()
							# The input gets padded during training so adjust the axial position encodings from the pretrained model value of (512, 1024)
							UpperCAmelCase_=  encoded_sequence["""input_ids"""].shape
							UpperCAmelCase_=  ReformerModel(__UpperCAmelCase	)

							# Reformer has config.vocab_size == tokenizer.vocab_size == len(tokenizer) - 1 = 320; len(tokenizer) is 321 (including a pad token with id 320)
							assert model.get_input_embeddings().weight.shape[0] >= self.big_tokenizer.vocab_size

							with torch.no_grad():
													model(**__UpperCAmelCase	)
													model(**__UpperCAmelCase	)




	@slow
	def     _SCREAMING_SNAKE_CASE						(      self      :		Optional[int]	)     ->					List[str]:
							# fmt: off
							UpperCAmelCase_=  {"""input_ids""": [[108, 265, 24, 111, 4, 258, 156, 7, 51, 279, 58, 7, 76, 25, 69, 278], [140, 243, 264, 134, 17, 267, 77, 263, 22, 262, 297, 258, 304, 177, 279, 266, 14, 89, 13, 35, 261, 299, 272, 137, 275, 278]], """attention_mask""": [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]}  # noqa: E501
							# fmt: on

							# This tokenizer does not know some characters like ")".
							# That is the reason why we use very simple texts here.
							# Also see https://github.com/huggingface/transformers/pull/11737#issuecomment-850769064
							UpperCAmelCase_=  [
							    """This is a very simple sentence.""",
							    """The quick brown fox jumps over the lazy dog.""",
							]

							self.tokenizer_integration_test_util(
							    expected_encoding=__UpperCAmelCase		,    model_name="""google/reformer-crime-and-punishment"""		,    revision="""0e6c3decb8211d49bf881013425dc8b0448b3f5a"""		,    padding=__UpperCAmelCase		,    sequences=__UpperCAmelCase		,    )






'''simple docstring'''
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


lowercase__											=logging.get_logger(__name__)

# General docstring
lowercase__											='PoolFormerConfig'

# Base docstring
lowercase__											='sail/poolformer_s12'
lowercase__											=[1, 5_12, 7, 7]

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

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






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







class   a_ (      nn.Module					):




			def __init__(       self					,   UpperCAmelCase = None	):
				super().__init__()
				a_      				=						drop_prob




			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase	):
				return drop_path(UpperCAmelCase					,   self.drop_prob					,   self.training	)






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







class   a_ (      nn.Module					):




			def __init__(       self					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase=None	):
				super().__init__()
				a_      				=						patch_size if isinstance(UpperCAmelCase					,   collections.abc.Iterable	) else (patch_size, patch_size)
				a_      				=						stride if isinstance(UpperCAmelCase					,   collections.abc.Iterable	) else (stride, stride)
				a_      				=						padding if isinstance(UpperCAmelCase					,   collections.abc.Iterable	) else (padding, padding)

				a_      				=						nn.Convad(UpperCAmelCase					,   UpperCAmelCase					,   kernel_size=UpperCAmelCase					,   stride=UpperCAmelCase					,   padding=UpperCAmelCase	)
				a_      				=						norm_layer(UpperCAmelCase	) if norm_layer else nn.Identity()






			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase	):
				a_      				=						self.projection(UpperCAmelCase	)
				a_      				=						self.norm(UpperCAmelCase	)
				return embeddings







class   a_ (      nn.GroupNorm					):




			def __init__(       self					,   UpperCAmelCase					,   **UpperCAmelCase	):
				super().__init__(1					,   UpperCAmelCase					,   **UpperCAmelCase	)







class   a_ (      nn.Module					):




			def __init__(       self					,   UpperCAmelCase	):
				super().__init__()
				a_      				=						nn.AvgPoolad(UpperCAmelCase					,   stride=1					,   padding=pool_size // 2					,   count_include_pad=UpperCAmelCase	)






			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase	):
				return self.pool(UpperCAmelCase	) - hidden_states







class   a_ (      nn.Module					):




			def __init__(       self					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase	):
				super().__init__()
				a_      				=						nn.Convad(UpperCAmelCase					,   UpperCAmelCase					,   1	)
				a_      				=						nn.Convad(UpperCAmelCase					,   UpperCAmelCase					,   1	)
				a_      				=						PoolFormerDropPath(UpperCAmelCase	)
				if isinstance(config.hidden_act					,   UpperCAmelCase	):
					a_      				=						ACTaFN[config.hidden_act]
				else:
					a_      				=						config.hidden_act






			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase	):
				a_      				=						self.conva(UpperCAmelCase	)
				a_      				=						self.act_fn(UpperCAmelCase	)
				a_      				=						self.drop(UpperCAmelCase	)
				a_      				=						self.conva(UpperCAmelCase	)
				a_      				=						self.drop(UpperCAmelCase	)

				return hidden_states







class   a_ (      nn.Module					):




			def __init__(       self					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase	):
				super().__init__()
				a_      				=						PoolFormerPooling(UpperCAmelCase	)
				a_      				=						PoolFormerOutput(UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase	)
				a_      				=						PoolFormerGroupNorm(UpperCAmelCase	)
				a_      				=						PoolFormerGroupNorm(UpperCAmelCase	)

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






			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase	):
				if self.use_layer_scale:
					a_      				=						self.pooling(self.before_norm(UpperCAmelCase	)	)
					a_      				=						self.layer_scale_a.unsqueeze(-1	).unsqueeze(-1	) * pooling_output
					# First residual connection
					a_      				=						hidden_states + self.drop_path(UpperCAmelCase	)
					a_      				=						()

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

					a_      				=						(output,) + outputs
					return outputs

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

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

					a_      				=						(output,) + outputs
					return outputs







class   a_ (      nn.Module					):




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

				# patch embeddings
				a_      				=						[]
				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]					,   )	)
				a_      				=						nn.ModuleList(UpperCAmelCase	)

				# Transformer blocks
				a_      				=						[]
				a_      				=						0
				for i in range(config.num_encoder_blocks	):
					# each block consists of layers
					a_      				=						[]
					if i != 0:
						cur += config.depths[i - 1]
					for j in range(config.depths[i]	):
						layers.append(
						    PoolFormerLayer(
						        UpperCAmelCase					,   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(UpperCAmelCase	)	)

				a_      				=						nn.ModuleList(UpperCAmelCase	)






			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase					,   UpperCAmelCase=False					,   UpperCAmelCase=True	):
				a_      				=						() if output_hidden_states else None

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

					if output_hidden_states:
						a_      				=						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=UpperCAmelCase					,   hidden_states=UpperCAmelCase	)







class   a_ (      UpperCamelCase__					):
			lowerCamelCase__	:			Union[str, Any]       =    PoolFormerConfig
			lowerCamelCase__	:			Optional[Any]       =    'poolformer'
			lowerCamelCase__	:			List[Any]       =    'pixel_values'
			lowerCamelCase__	:			int       =    True




			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase	):
				if isinstance(UpperCAmelCase					,   (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(UpperCAmelCase					,   nn.LayerNorm	):
					module.bias.data.zero_()
					module.weight.data.fill_(1.0	)






			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase					,   UpperCAmelCase=False	):
				if isinstance(UpperCAmelCase					,   UpperCAmelCase	):
					a_      				=						value







lowercase__											=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'

lowercase__											=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   a_ (      UpperCamelCase__					):




			def __init__(       self					,   UpperCAmelCase	):
				super().__init__(UpperCAmelCase	)
				a_      				=						config

				a_      				=						PoolFormerEncoder(UpperCAmelCase	)

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




			def 					lowerCAmelCase__					(       self	):
				return self.embeddings.patch_embeddings






			@add_start_docstrings_to_model_forward(UpperCAmelCase	)
			@add_code_sample_docstrings(
			    checkpoint=_CHECKPOINT_FOR_DOC					,   output_type=UpperCAmelCase					,   config_class=_CONFIG_FOR_DOC					,   modality="""vision"""					,   expected_output=_EXPECTED_OUTPUT_SHAPE					,   )
			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase = None					,   UpperCAmelCase = None					,   UpperCAmelCase = None					,   ):
				a_      				=						(
				    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
				)
				a_      				=						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"""	)

				a_      				=						self.encoder(
				    UpperCAmelCase					,   output_hidden_states=UpperCAmelCase					,   return_dict=UpperCAmelCase					,   )
				a_      				=						encoder_outputs[0]

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

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







class   a_ (      nn.Module					):




			def __init__(       self					,   UpperCAmelCase	):
				super().__init__()
				a_      				=						nn.Linear(config.hidden_size					,   config.hidden_size	)






			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase	):
				a_      				=						self.dense(UpperCAmelCase	)
				return output







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




			def __init__(       self					,   UpperCAmelCase	):
				super().__init__(UpperCAmelCase	)
				a_      				=						config.num_labels
				a_      				=						PoolFormerModel(UpperCAmelCase	)

				# Final norm
				a_      				=						PoolFormerGroupNorm(config.hidden_sizes[-1]	)
				# Classifier head
				a_      				=						(
				    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(UpperCAmelCase	)
			@add_code_sample_docstrings(
			    checkpoint=_IMAGE_CLASS_CHECKPOINT					,   output_type=UpperCAmelCase					,   config_class=_CONFIG_FOR_DOC					,   expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT					,   )
			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase = None					,   UpperCAmelCase = None					,   UpperCAmelCase = None					,   UpperCAmelCase = None					,   ):
				a_      				=						return_dict if return_dict is not None else self.config.use_return_dict

				a_      				=						self.poolformer(
				    UpperCAmelCase					,   output_hidden_states=UpperCAmelCase					,   return_dict=UpperCAmelCase					,   )

				a_      				=						outputs[0]

				a_      				=						self.classifier(self.norm(UpperCAmelCase	).mean([-2, -1]	)	)

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

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

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

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