

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  :      Optional[int]			 =logging.get_logger(__name__)

# General docstring
_lowerCAmelCase  :      Union[str, Any]			 ="""PoolFormerConfig"""

# Base docstring
_lowerCAmelCase  :      List[str]			 ="""sail/poolformer_s12"""
_lowerCAmelCase  :      int			 =[1, 5_12, 7, 7]

# Image classification docstring
_lowerCAmelCase  :      Dict			 ="""sail/poolformer_s12"""
_lowerCAmelCase  :      Dict			 ="""tabby, tabby cat"""

_lowerCAmelCase  :      Optional[Any]			 =[
    """sail/poolformer_s12""",
    # See all PoolFormer models at https://huggingface.co/models?filter=poolformer
]



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

class __UpperCamelCase     (				nn.Module		):






					'''simple docstring'''



					def __init__(				self				,      lowerCamelCase__ = None						):
						super().__init__()
						UpperCAmelCase__:	int									= drop_prob





					def    _UpperCAmelCase    (				self				,      lowerCamelCase__						):
						return drop_path(snake_case_				,      self.drop_prob				,      self.training						)





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

class __UpperCamelCase     (				nn.Module		):






					'''simple docstring'''



					def __init__(				self				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__=None						):
						super().__init__()
						UpperCAmelCase__:	int									= patch_size if isinstance(snake_case_				,      collections.abc.Iterable						) else (patch_size, patch_size)
						UpperCAmelCase__:	str									= stride if isinstance(snake_case_				,      collections.abc.Iterable						) else (stride, stride)
						UpperCAmelCase__:	Optional[int]									= padding if isinstance(snake_case_				,      collections.abc.Iterable						) else (padding, padding)

						UpperCAmelCase__:	List[Any]									= nn.Convad(snake_case_				,      snake_case_				,      kernel_size=snake_case_				,      stride=snake_case_				,      padding=snake_case_						)
						UpperCAmelCase__:	Optional[Any]									= norm_layer(snake_case_						) if norm_layer else nn.Identity()





					def    _UpperCAmelCase    (				self				,      lowerCamelCase__						):
						UpperCAmelCase__:	Union[str, Any]									= self.projection(snake_case_						)
						UpperCAmelCase__:	List[Any]									= self.norm(snake_case_						)
						return embeddings

class __UpperCamelCase     (				nn.GroupNorm		):






					'''simple docstring'''



					def __init__(				self				,      lowerCamelCase__				,      **lowerCamelCase__						):
						super().__init__(1				,      snake_case_				,      **snake_case_						)

class __UpperCamelCase     (				nn.Module		):






					'''simple docstring'''



					def __init__(				self				,      lowerCamelCase__						):
						super().__init__()
						UpperCAmelCase__:	List[str]									= nn.AvgPoolad(snake_case_				,      stride=1				,      padding=pool_size // 2				,      count_include_pad=snake_case_						)





					def    _UpperCAmelCase    (				self				,      lowerCamelCase__						):
						return self.pool(snake_case_						) - hidden_states

class __UpperCamelCase     (				nn.Module		):






					'''simple docstring'''



					def __init__(				self				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__						):
						super().__init__()
						UpperCAmelCase__:	Union[str, Any]									= nn.Convad(snake_case_				,      snake_case_				,      1						)
						UpperCAmelCase__:	Optional[Any]									= nn.Convad(snake_case_				,      snake_case_				,      1						)
						UpperCAmelCase__:	List[Any]									= PoolFormerDropPath(snake_case_						)
						if isinstance(config.hidden_act				,      snake_case_						):
							UpperCAmelCase__:	int									= ACTaFN[config.hidden_act]
						else:
							UpperCAmelCase__:	str									= config.hidden_act





					def    _UpperCAmelCase    (				self				,      lowerCamelCase__						):
						UpperCAmelCase__:	Optional[int]									= self.conva(snake_case_						)
						UpperCAmelCase__:	Optional[int]									= self.act_fn(snake_case_						)
						UpperCAmelCase__:	Any									= self.drop(snake_case_						)
						UpperCAmelCase__:	Optional[int]									= self.conva(snake_case_						)
						UpperCAmelCase__:	List[Any]									= self.drop(snake_case_						)

						return hidden_states

class __UpperCamelCase     (				nn.Module		):






					'''simple docstring'''



					def __init__(				self				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__						):
						super().__init__()
						UpperCAmelCase__:	Tuple									= PoolFormerPooling(snake_case_						)
						UpperCAmelCase__:	Dict									= PoolFormerOutput(snake_case_				,      snake_case_				,      snake_case_				,      snake_case_						)
						UpperCAmelCase__:	Any									= PoolFormerGroupNorm(snake_case_						)
						UpperCAmelCase__:	List[str]									= PoolFormerGroupNorm(snake_case_						)

						# Useful for training neural nets
						UpperCAmelCase__:	List[Any]									= PoolFormerDropPath(snake_case_						) if drop_path > 0.0 else nn.Identity()
						UpperCAmelCase__:	Union[str, Any]									= config.use_layer_scale
						if config.use_layer_scale:
							UpperCAmelCase__:	Union[str, Any]									= nn.Parameter(
							    config.layer_scale_init_value * torch.ones((snake_case_)						)				,      requires_grad=snake_case_						)
							UpperCAmelCase__:	Union[str, Any]									= nn.Parameter(
							    config.layer_scale_init_value * torch.ones((snake_case_)						)				,      requires_grad=snake_case_						)





					def    _UpperCAmelCase    (				self				,      lowerCamelCase__						):
						if self.use_layer_scale:
							UpperCAmelCase__:	int									= self.pooling(self.before_norm(snake_case_						)						)
							UpperCAmelCase__:	List[str]									= self.layer_scale_a.unsqueeze(-1						).unsqueeze(-1						) * pooling_output
							# First residual connection
							UpperCAmelCase__:	Optional[Any]									= hidden_states + self.drop_path(snake_case_						)
							UpperCAmelCase__:	List[str]									= ()

							UpperCAmelCase__:	Any									= self.output(self.after_norm(snake_case_						)						)
							UpperCAmelCase__:	Union[str, Any]									= self.layer_scale_a.unsqueeze(-1						).unsqueeze(-1						) * layer_output
							# Second residual connection
							UpperCAmelCase__:	Union[str, Any]									= hidden_states + self.drop_path(snake_case_						)

							UpperCAmelCase__:	Optional[Any]									= (output,) + outputs
							return outputs

						else:
							UpperCAmelCase__:	int									= self.drop_path(self.pooling(self.before_norm(snake_case_						)						)						)
							# First residual connection
							UpperCAmelCase__:	Optional[int]									= pooling_output + hidden_states
							UpperCAmelCase__:	Tuple									= ()

							# Second residual connection inside the PoolFormerOutput block
							UpperCAmelCase__:	Optional[Any]									= self.drop_path(self.output(self.after_norm(snake_case_						)						)						)
							UpperCAmelCase__:	Optional[Any]									= hidden_states + layer_output

							UpperCAmelCase__:	Tuple									= (output,) + outputs
							return outputs

class __UpperCamelCase     (				nn.Module		):






					'''simple docstring'''



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

						# patch embeddings
						UpperCAmelCase__:	Any									= []
						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]				,      )						)
						UpperCAmelCase__:	Optional[Any]									= nn.ModuleList(snake_case_						)

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

						UpperCAmelCase__:	int									= nn.ModuleList(snake_case_						)





					def    _UpperCAmelCase    (				self				,      lowerCamelCase__				,      lowerCamelCase__=False				,      lowerCamelCase__=True						):
						UpperCAmelCase__:	Union[str, Any]									= () if output_hidden_states else None

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

							if output_hidden_states:
								UpperCAmelCase__:	Any									= 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=snake_case_				,      hidden_states=snake_case_						)

class __UpperCamelCase     (				A__		):






					'''simple docstring'''



					__magic_name__        =   PoolFormerConfig
					__magic_name__        =   "poolformer"
					__magic_name__        =   "pixel_values"
					__magic_name__        =   True





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





					def    _UpperCAmelCase    (				self				,      lowerCamelCase__				,      lowerCamelCase__=False						):
						if isinstance(snake_case_				,      snake_case_						):
							UpperCAmelCase__:	str									= value
_lowerCAmelCase  :      str			 =r"""
    This model is a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) sub-class. Use
    it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage and
    behavior.

    Parameters:
        config ([`PoolFormerConfig`]): Model configuration class with all the parameters of the model.
            Initializing with a config file does not load the weights associated with the model, only the
            configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights.
"""

_lowerCAmelCase  :      List[Any]			 =r"""
    Args:
        pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`):
            Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See
            [`PoolFormerImageProcessor.__call__`] for details.
"""

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






					'''simple docstring'''



					def __init__(				self				,      lowerCamelCase__						):
						super().__init__(snake_case_						)
						UpperCAmelCase__:	List[Any]									= config

						UpperCAmelCase__:	Any									= PoolFormerEncoder(snake_case_						)

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





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





					@add_start_docstrings_to_model_forward(snake_case_						)
					@add_code_sample_docstrings(
					    checkpoint=_CHECKPOINT_FOR_DOC				,      output_type=snake_case_				,      config_class=_CONFIG_FOR_DOC				,      modality="vision"				,      expected_output=_EXPECTED_OUTPUT_SHAPE				,      )
					def    _UpperCAmelCase    (				self				,      lowerCamelCase__ = None				,      lowerCamelCase__ = None				,      lowerCamelCase__ = None				,      ):
						UpperCAmelCase__:	Union[str, Any]									= (
						    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
						)
						UpperCAmelCase__:	Dict									= 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"						)

						UpperCAmelCase__:	List[Any]									= self.encoder(
						    snake_case_				,      output_hidden_states=snake_case_				,      return_dict=snake_case_				,      )
						UpperCAmelCase__:	Any									= encoder_outputs[0]

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

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

class __UpperCamelCase     (				nn.Module		):






					'''simple docstring'''



					def __init__(				self				,      lowerCamelCase__						):
						super().__init__()
						UpperCAmelCase__:	Optional[Any]									= nn.Linear(config.hidden_size				,      config.hidden_size						)





					def    _UpperCAmelCase    (				self				,      lowerCamelCase__						):
						UpperCAmelCase__:	str									= self.dense(snake_case_						)
						return output

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






					'''simple docstring'''



					def __init__(				self				,      lowerCamelCase__						):
						super().__init__(snake_case_						)
						UpperCAmelCase__:	Optional[Any]									= config.num_labels
						UpperCAmelCase__:	Optional[int]									= PoolFormerModel(snake_case_						)

						# Final norm
						UpperCAmelCase__:	Union[str, Any]									= PoolFormerGroupNorm(config.hidden_sizes[-1]						)
						# Classifier head
						UpperCAmelCase__:	Tuple									= (
						    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(snake_case_						)
					@add_code_sample_docstrings(
					    checkpoint=_IMAGE_CLASS_CHECKPOINT				,      output_type=snake_case_				,      config_class=_CONFIG_FOR_DOC				,      expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT				,      )
					def    _UpperCAmelCase    (				self				,      lowerCamelCase__ = None				,      lowerCamelCase__ = None				,      lowerCamelCase__ = None				,      lowerCamelCase__ = None				,      ):
						UpperCAmelCase__:	List[str]									= return_dict if return_dict is not None else self.config.use_return_dict

						UpperCAmelCase__:	Any									= self.poolformer(
						    snake_case_				,      output_hidden_states=snake_case_				,      return_dict=snake_case_				,      )

						UpperCAmelCase__:	Dict									= outputs[0]

						UpperCAmelCase__:	Dict									= self.classifier(self.norm(snake_case_						).mean([-2, -1]						)						)

						UpperCAmelCase__:	Union[str, Any]									= None
						if labels is not None:
							if self.config.problem_type is None:
								if self.num_labels == 1:
									UpperCAmelCase__:	Optional[Any]									= "regression"
								elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
									UpperCAmelCase__:	str									= "single_label_classification"
								else:
									UpperCAmelCase__:	Union[str, Any]									= "multi_label_classification"

							if self.config.problem_type == "regression":
								UpperCAmelCase__:	Union[str, Any]									= MSELoss()
								if self.num_labels == 1:
									UpperCAmelCase__:	List[Any]									= loss_fct(logits.squeeze()				,      labels.squeeze()						)
								else:
									UpperCAmelCase__:	List[Any]									= loss_fct(snake_case_				,      snake_case_						)
							elif self.config.problem_type == "single_label_classification":
								UpperCAmelCase__:	Tuple									= CrossEntropyLoss()
								UpperCAmelCase__:	str									= loss_fct(logits.view(-1				,      self.num_labels						)				,      labels.view(-1						)						)
							elif self.config.problem_type == "multi_label_classification":
								UpperCAmelCase__:	Tuple									= BCEWithLogitsLoss()
								UpperCAmelCase__:	Union[str, Any]									= loss_fct(snake_case_				,      snake_case_						)

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

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

"""simple docstring"""
from typing import List

from ...configuration_utils import PretrainedConfig
from ...utils import logging


SCREAMING_SNAKE_CASE_					     =	logging.get_logger(__name__)

SCREAMING_SNAKE_CASE_					     =	{
    '''snap-research/efficientformer-l1-300''': (
        '''https://huggingface.co/snap-research/efficientformer-l1-300/resolve/main/config.json'''
    ),
}
class       lowerCAmelCase_		(				A__ ):



							'''simple docstring'''





							_snake_case						      =		'''efficientformer'''




							def __init__( self    ,				snake_case_ = [3, 2, 6, 4]    ,				snake_case_ = [48, 96, 224, 448]    ,				snake_case_ = [True, True, True, True]    ,				snake_case_ = 448    ,				snake_case_ = 32    ,				snake_case_ = 4    ,				snake_case_ = 7    ,				snake_case_ = 5    ,				snake_case_ = 8    ,				snake_case_ = 4    ,				snake_case_ = 0.0    ,				snake_case_ = 16    ,				snake_case_ = 3    ,				snake_case_ = 3    ,				snake_case_ = 3    ,				snake_case_ = 2    ,				snake_case_ = 1    ,				snake_case_ = 0.0    ,				snake_case_ = 1    ,				snake_case_ = True    ,				snake_case_ = True    ,				snake_case_ = 1e-5    ,				snake_case_ = "gelu"    ,				snake_case_ = 0.02    ,				snake_case_ = 1e-1_2    ,				snake_case_ = 224    ,				snake_case_ = 1e-0_5    ,				**snake_case_    ,				)       ->  None:
													super().__init__(**snake_case_				)

													__lowerCAmelCase     =  hidden_act
													__lowerCAmelCase     =  hidden_dropout_prob
													__lowerCAmelCase     =  hidden_sizes
													__lowerCAmelCase     =  num_hidden_layers
													__lowerCAmelCase     =  num_attention_heads
													__lowerCAmelCase     =  initializer_range
													__lowerCAmelCase     =  layer_norm_eps
													__lowerCAmelCase     =  patch_size
													__lowerCAmelCase     =  num_channels
													__lowerCAmelCase     =  depths
													__lowerCAmelCase     =  mlp_expansion_ratio
													__lowerCAmelCase     =  downsamples
													__lowerCAmelCase     =  dim
													__lowerCAmelCase     =  key_dim
													__lowerCAmelCase     =  attention_ratio
													__lowerCAmelCase     =  resolution
													__lowerCAmelCase     =  pool_size
													__lowerCAmelCase     =  downsample_patch_size
													__lowerCAmelCase     =  downsample_stride
													__lowerCAmelCase     =  downsample_pad
													__lowerCAmelCase     =  drop_path_rate
													__lowerCAmelCase     =  num_metaad_blocks
													__lowerCAmelCase     =  distillation
													__lowerCAmelCase     =  use_layer_scale
													__lowerCAmelCase     =  layer_scale_init_value
													__lowerCAmelCase     =  image_size
													__lowerCAmelCase     =  batch_norm_eps
