





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 				__lowerCamelCase		(						lowerCAmelCase__     ,  lowerCAmelCase__ = 0.0     ,  lowerCAmelCase__ = False     ):
       if drop_prob == 0.0 or not training:
              return input
       lowerCAmelCase__					     = 1 - drop_prob
       lowerCAmelCase__					     = (input.shape[0],) + (1,) * (input.ndim - 1)  # work with diff dim tensors, not just 2D ConvNets
       lowerCAmelCase__					     = keep_prob + torch.rand(lowerCAmelCase__     ,  dtype=input.dtype     ,  device=input.device     )
       random_tensor.floor_()  # binarize
       lowerCAmelCase__					     = input.div(lowerCAmelCase__     ) * random_tensor
       return output
class     a_			(						nn.Module						):






 '''simple docstring'''






 def __init__(      self :  Optional[int]      ,   lowercase__ :  Optional[float] = None):







        '''simple docstring'''



        super().__init__()
        lowerCAmelCase__					     = drop_prob




 def 		__snake_case						(      self :  List[Any]      ,   lowercase__ :  torch.Tensor):







        '''simple docstring'''



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




 def 		__snake_case						(      self :  str):







        '''simple docstring'''



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






class     a_			(						nn.Module						):






 '''simple docstring'''






 def __init__(      self :  int      ,   lowercase__ :  Optional[int]      ,   lowercase__ :  Optional[int]      ,   lowercase__ :  Union[str, Any]      ,   lowercase__ :  int      ,   lowercase__ :  Tuple      ,   lowercase__ :  Union[str, Any]=None):







        '''simple docstring'''



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

        lowerCAmelCase__					     = nn.Convad(lowercase__      ,   lowercase__      ,   kernel_size=lowercase__      ,   stride=lowercase__      ,   padding=lowercase__)
        lowerCAmelCase__					     = norm_layer(lowercase__) if norm_layer else nn.Identity()




 def 		__snake_case						(      self :  Tuple      ,   lowercase__ :  List[str]):







        '''simple docstring'''



        lowerCAmelCase__					     = self.projection(lowercase__)
        lowerCAmelCase__					     = self.norm(lowercase__)
        return embeddings






class     a_			(						nn.GroupNorm						):






 '''simple docstring'''






 def __init__(      self :  Optional[Any]      ,   lowercase__ :  Union[str, Any]      ,   **lowercase__ :  List[str]):







        '''simple docstring'''



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






class     a_			(						nn.Module						):






 '''simple docstring'''






 def __init__(      self :  Any      ,   lowercase__ :  Union[str, Any]):







        '''simple docstring'''



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




 def 		__snake_case						(      self :  Optional[Any]      ,   lowercase__ :  List[str]):







        '''simple docstring'''



        return self.pool(lowercase__) - hidden_states






class     a_			(						nn.Module						):






 '''simple docstring'''






 def __init__(      self :  Dict      ,   lowercase__ :  int      ,   lowercase__ :  str      ,   lowercase__ :  Optional[Any]      ,   lowercase__ :  int):







        '''simple docstring'''



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




 def 		__snake_case						(      self :  List[str]      ,   lowercase__ :  Tuple):







        '''simple docstring'''



        lowerCAmelCase__					     = self.conva(lowercase__)
        lowerCAmelCase__					     = self.act_fn(lowercase__)
        lowerCAmelCase__					     = self.drop(lowercase__)
        lowerCAmelCase__					     = self.conva(lowercase__)
        lowerCAmelCase__					     = self.drop(lowercase__)

        return hidden_states






class     a_			(						nn.Module						):






 '''simple docstring'''






 def __init__(      self :  Any      ,   lowercase__ :  List[Any]      ,   lowercase__ :  List[Any]      ,   lowercase__ :  int      ,   lowercase__ :  Tuple      ,   lowercase__ :  Optional[Any]      ,   lowercase__ :  Tuple):







        '''simple docstring'''



        super().__init__()
        lowerCAmelCase__					     = PoolFormerPooling(lowercase__)
        lowerCAmelCase__					     = PoolFormerOutput(lowercase__      ,   lowercase__      ,   lowercase__      ,   lowercase__)
        lowerCAmelCase__					     = PoolFormerGroupNorm(lowercase__)
        lowerCAmelCase__					     = PoolFormerGroupNorm(lowercase__)

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




 def 		__snake_case						(      self :  str      ,   lowercase__ :  List[str]):







        '''simple docstring'''



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

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

               lowerCAmelCase__					     = (output,) + outputs
               return outputs

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

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

               lowerCAmelCase__					     = (output,) + outputs
               return outputs






class     a_			(						nn.Module						):






 '''simple docstring'''






 def __init__(      self :  Dict      ,   lowercase__ :  Tuple):







        '''simple docstring'''



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

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

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

        lowerCAmelCase__					     = nn.ModuleList(lowercase__)




 def 		__snake_case						(      self :  Optional[Any]      ,   lowercase__ :  str      ,   lowercase__ :  Any=False      ,   lowercase__ :  Union[str, Any]=True):







        '''simple docstring'''



        lowerCAmelCase__					     = () if output_hidden_states else None

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

               if output_hidden_states:
                      lowerCAmelCase__					     = 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=lowercase__      ,   hidden_states=lowercase__)






class     a_			(						SCREAMING_SNAKE_CASE						):






 '''simple docstring'''






 UpperCAmelCase_     			= PoolFormerConfig
 UpperCAmelCase_     			= 'poolformer'
 UpperCAmelCase_     			= 'pixel_values'
 UpperCAmelCase_     			= True




 def 		__snake_case						(      self :  Any      ,   lowercase__ :  Tuple):







        '''simple docstring'''



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




 def 		__snake_case						(      self :  List[str]      ,   lowercase__ :  Optional[int]      ,   lowercase__ :  List[Any]=False):







        '''simple docstring'''



        if isinstance(lowercase__      ,   lowercase__):
               lowerCAmelCase__					     = 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.'	,					SCREAMING_SNAKE_CASE	,					)
class     a_			(						SCREAMING_SNAKE_CASE						):






 '''simple docstring'''






 def __init__(      self :  Tuple      ,   lowercase__ :  Any):







        '''simple docstring'''



        super().__init__(lowercase__)
        lowerCAmelCase__					     = config

        lowerCAmelCase__					     = PoolFormerEncoder(lowercase__)

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




 def 		__snake_case						(      self :  Any):







        '''simple docstring'''



        return self.embeddings.patch_embeddings




 @add_start_docstrings_to_model_forward(lowercase__)
 @add_code_sample_docstrings(
     checkpoint=_CHECKPOINT_FOR_DOC      ,   output_type=lowercase__      ,   config_class=_CONFIG_FOR_DOC      ,   modality='vision'      ,   expected_output=_EXPECTED_OUTPUT_SHAPE      ,   )
 def 		__snake_case						(      self :  Optional[Any]      ,   lowercase__ :  Optional[torch.FloatTensor] = None      ,   lowercase__ :  Optional[bool] = None      ,   lowercase__ :  Optional[bool] = None      ,   ):







        '''simple docstring'''



        lowerCAmelCase__					     = (
            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
        )
        lowerCAmelCase__					     = 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')

        lowerCAmelCase__					     = self.encoder(
            lowercase__      ,   output_hidden_states=lowercase__      ,   return_dict=lowercase__      ,   )
        lowerCAmelCase__					     = encoder_outputs[0]

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

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






class     a_			(						nn.Module						):






 '''simple docstring'''






 def __init__(      self :  Dict      ,   lowercase__ :  Tuple):







        '''simple docstring'''



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




 def 		__snake_case						(      self :  Tuple      ,   lowercase__ :  Optional[Any]):







        '''simple docstring'''



        lowerCAmelCase__					     = self.dense(lowercase__)
        return output






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






 '''simple docstring'''






 def __init__(      self :  str      ,   lowercase__ :  Dict):







        '''simple docstring'''



        super().__init__(lowercase__)
        lowerCAmelCase__					     = config.num_labels
        lowerCAmelCase__					     = PoolFormerModel(lowercase__)

        # Final norm
        lowerCAmelCase__					     = PoolFormerGroupNorm(config.hidden_sizes[-1])
        # Classifier head
        lowerCAmelCase__					     = (
            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(lowercase__)
 @add_code_sample_docstrings(
     checkpoint=_IMAGE_CLASS_CHECKPOINT      ,   output_type=lowercase__      ,   config_class=_CONFIG_FOR_DOC      ,   expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT      ,   )
 def 		__snake_case						(      self :  Tuple      ,   lowercase__ :  Optional[torch.FloatTensor] = None      ,   lowercase__ :  Optional[torch.LongTensor] = None      ,   lowercase__ :  Optional[bool] = None      ,   lowercase__ :  Optional[bool] = None      ,   ):







        '''simple docstring'''



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

        lowerCAmelCase__					     = self.poolformer(
            lowercase__      ,   output_hidden_states=lowercase__      ,   return_dict=lowercase__      ,   )

        lowerCAmelCase__					     = outputs[0]

        lowerCAmelCase__					     = self.classifier(self.norm(lowercase__).mean([-2, -1]))

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

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

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

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

from typing import Optional

import pyspark

from .. import Features, NamedSplit
from ..download import DownloadMode
from ..packaged_modules.spark.spark import Spark
from .abc import AbstractDatasetReader
class     a_			(						SCREAMING_SNAKE_CASE						):






 '''simple docstring'''






 def __init__(      self :  str      ,   lowercase__ :  pyspark.sql.DataFrame      ,   lowercase__ :  Optional[NamedSplit] = None      ,   lowercase__ :  Optional[Features] = None      ,   lowercase__ :  bool = True      ,   lowercase__ :  str = None      ,   lowercase__ :  bool = False      ,   lowercase__ :  str = None      ,   lowercase__ :  bool = True      ,   lowercase__ :  str = "arrow"      ,   **lowercase__ :  Any      ,   ):







        '''simple docstring'''



        super().__init__(
            split=lowercase__      ,   features=lowercase__      ,   cache_dir=lowercase__      ,   keep_in_memory=lowercase__      ,   streaming=lowercase__      ,   **lowercase__      ,   )
        lowerCAmelCase__					     = load_from_cache_file
        lowerCAmelCase__					     = file_format
        lowerCAmelCase__					     = Spark(
            df=lowercase__      ,   features=lowercase__      ,   cache_dir=lowercase__      ,   working_dir=lowercase__      ,   **lowercase__      ,   )




 def 		__snake_case						(      self :  Tuple):







        '''simple docstring'''



        if self.streaming:
               return self.builder.as_streaming_dataset(split=self.split)
        lowerCAmelCase__					     = None if self._load_from_cache_file else DownloadMode.FORCE_REDOWNLOAD
        self.builder.download_and_prepare(
            download_mode=lowercase__      ,   file_format=self._file_format      ,   )
        return self.builder.as_dataset(split=self.split)
