





from __future__ import annotations

from typing import Any






class  lowercase    :






					"""simple docstring"""



					def __init__(    self						:     Optional[Any] ,					a_						:     str ,					a_						:     List[Any] ,					a_						:     Tuple = 0							):

						"""simple docstring"""



						lowerCamelCase__							,							lowerCamelCase__										=			row, column
						lowerCamelCase__										=			[[default_value for c in range(UpperCamelCase__							)] for r in range(UpperCamelCase__							)]





					def __str__(    self						:     Optional[Any]							):

						"""simple docstring"""



						lowerCamelCase__										=			F'''Matrix consist of {self.row} rows and {self.column} columns\n'''

						# Make string identifier
						lowerCamelCase__										=			0
						for row_vector in self.array:
							for obj in row_vector:
								lowerCamelCase__										=			max(UpperCamelCase__ ,					len(str(UpperCamelCase__							)							)							)
						lowerCamelCase__										=			F'''%{max_element_length}s'''

						# Make string and return
						def single_line(a_						:     Optional[Any]							) -> str:
							nonlocal string_format_identifier
							lowerCamelCase__										=			"""["""
							line += ", ".join(string_format_identifier % (obj,) for obj in row_vector							)
							line += "]"
							return line

						s += "\n".join(single_line(UpperCamelCase__							) for row_vector in self.array							)
						return s





					def __repr__(    self						:     int							):

						"""simple docstring"""



						return str(self							)





					def       _UpperCamelCase       (    self						:     List[Any] ,					a_						:     List[str]							):

						"""simple docstring"""



						if not (isinstance(UpperCamelCase__ ,					(list, tuple)							) and len(UpperCamelCase__							) == 2):
							return False
						elif not (0 <= loc[0] < self.row and 0 <= loc[1] < self.column):
							return False
						else:
							return True





					def __getitem__(    self						:     int ,					a_						:     int							):

						"""simple docstring"""



						assert self.validate_indicies(UpperCamelCase__							)
						return self.array[loc[0]][loc[1]]





					def __setitem__(    self						:     int ,					a_						:     Tuple ,					a_						:     Any							):

						"""simple docstring"""



						assert self.validate_indicies(UpperCamelCase__							)
						lowerCamelCase__										=			value





					def __add__(    self						:     Optional[Any] ,					a_						:     Union[str, Any]							):

						"""simple docstring"""



						assert isinstance(UpperCamelCase__ ,					UpperCamelCase__							)
						assert self.row == another.row and self.column == another.column

						# Add
						lowerCamelCase__										=			Matrix(self.row ,					self.column							)
						for r in range(self.row							):
							for c in range(self.column							):
								lowerCamelCase__										=			self[r, c] + another[r, c]
						return result





					def __neg__(    self						:     Optional[int]							):

						"""simple docstring"""



						lowerCamelCase__										=			Matrix(self.row ,					self.column							)
						for r in range(self.row							):
							for c in range(self.column							):
								lowerCamelCase__										=			-self[r, c]
						return result





					def __sub__(    self						:     List[Any] ,					a_						:     Optional[int]							):

						"""simple docstring"""



						return self + (-another)





					def __mul__(    self						:     List[str] ,					a_						:     Union[str, Any]							):

						"""simple docstring"""



						if isinstance(UpperCamelCase__ ,					(int, float)							):  # Scalar multiplication
							lowerCamelCase__										=			Matrix(self.row ,					self.column							)
							for r in range(self.row							):
								for c in range(self.column							):
									lowerCamelCase__										=			self[r, c] * another
							return result
						elif isinstance(UpperCamelCase__ ,					UpperCamelCase__							):  # Matrix multiplication
							assert self.column == another.row
							lowerCamelCase__										=			Matrix(self.row ,					another.column							)
							for r in range(self.row							):
								for c in range(another.column							):
									for i in range(self.column							):
										result[r, c] += self[r, i] * another[i, c]
							return result
						else:
							lowerCamelCase__										=			F'''Unsupported type given for another ({type(UpperCamelCase__							)})'''
							raise TypeError(UpperCamelCase__							)





					def       _UpperCamelCase       (    self						:     Dict							):

						"""simple docstring"""



						lowerCamelCase__										=			Matrix(self.column ,					self.row							)
						for r in range(self.row							):
							for c in range(self.column							):
								lowerCamelCase__										=			self[r, c]
						return result





					def       _UpperCamelCase       (    self						:     Union[str, Any] ,					a_						:     str ,					a_						:     Union[str, Any]							):

						"""simple docstring"""



						assert isinstance(UpperCamelCase__ ,					UpperCamelCase__							) and isinstance(UpperCamelCase__ ,					UpperCamelCase__							)
						assert self.row == self.column == u.row == v.row  # u, v should be column vector
						assert u.column == v.column == 1  # u, v should be column vector

						# Calculate
						lowerCamelCase__										=			v.transpose()
						lowerCamelCase__										=			(v_t * self * u)[0, 0] + 1
						if numerator_factor == 0:
							return None  # It's not invertable
						return self - ((self * u) * (v_t * self) * (1.0 / numerator_factor))


# Testing
if __name__ == "__main__":

					def     snake_case							():




						'''simple docstring'''







						lowerCamelCase__										=			Matrix(3			,    3			,    0							)
						for i in range(3							):
							lowerCamelCase__										=			1
						print(f'''a^(-1) is {ainv}'''							)
						# u, v
						lowerCamelCase__										=			Matrix(3			,    1			,    0							)
						lowerCamelCase__							,							lowerCamelCase__							,							lowerCamelCase__										=			1, 2, -3
						lowerCamelCase__										=			Matrix(3			,    1			,    0							)
						lowerCamelCase__							,							lowerCamelCase__							,							lowerCamelCase__										=			4, -2, 5
						print(f'''u is {u}'''							)
						print(f'''v is {v}'''							)
						print(f'''uv^T is {u * v.transpose()}'''							)
						# Sherman Morrison
						print(f'''(a + uv^T)^(-1) is {ainv.sherman_morrison(lowercase_			,    lowercase_							)}'''							)

					def     snake_case							():




						'''simple docstring'''







						import doctest

						doctest.testmod()


					testa()








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


__lowerCAmelCase        =							logging.get_logger(__name__)

# General docstring
__lowerCAmelCase        =							"PoolFormerConfig"

# Base docstring
__lowerCAmelCase        =							"sail/poolformer_s12"
__lowerCAmelCase        =							[1, 5_12, 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       __UpperCamelCase					(      lowercase_       :  List[Any]   ,       lowercase_       :  float = 0.0   ,       lowercase_       :  bool = False   ):
       """simple docstring"""




       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(lowercase_   ,       dtype=input.dtype   ,       device=input.device   )
       random_tensor.floor_()  # binarize
       a_						     =			input.div(lowercase_   ) * random_tensor
       return output




class   __SCREAMING_SNAKE_CASE       (nn.Module       ):


  """simple docstring"""


  def __init__(			self   ,	UpperCamelCase__ = None	):






         """simple docstring"""


         super().__init__()
         a_						     =			drop_prob







  def    _a       (			self   ,	UpperCamelCase__	):






         """simple docstring"""


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







  def    _a       (			self	):






         """simple docstring"""


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





class   __SCREAMING_SNAKE_CASE       (nn.Module       ):


  """simple docstring"""


  def __init__(			self   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__=None	):






         """simple docstring"""


         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    _a       (			self   ,	UpperCamelCase__	):






         """simple docstring"""


         a_						     =			self.projection(UpperCamelCase__	)
         a_						     =			self.norm(UpperCamelCase__	)
         return embeddings





class   __SCREAMING_SNAKE_CASE       (nn.GroupNorm       ):


  """simple docstring"""


  def __init__(			self   ,	UpperCamelCase__   ,	**UpperCamelCase__	):






         """simple docstring"""


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





class   __SCREAMING_SNAKE_CASE       (nn.Module       ):


  """simple docstring"""


  def __init__(			self   ,	UpperCamelCase__	):






         """simple docstring"""


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







  def    _a       (			self   ,	UpperCamelCase__	):






         """simple docstring"""


         return self.pool(UpperCamelCase__	) - hidden_states





class   __SCREAMING_SNAKE_CASE       (nn.Module       ):


  """simple docstring"""


  def __init__(			self   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__	):






         """simple docstring"""


         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    _a       (			self   ,	UpperCamelCase__	):






         """simple docstring"""


         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   __SCREAMING_SNAKE_CASE       (nn.Module       ):


  """simple docstring"""


  def __init__(			self   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__	):






         """simple docstring"""


         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    _a       (			self   ,	UpperCamelCase__	):






         """simple docstring"""


         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   __SCREAMING_SNAKE_CASE       (nn.Module       ):


  """simple docstring"""


  def __init__(			self   ,	UpperCamelCase__	):






         """simple docstring"""


         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    _a       (			self   ,	UpperCamelCase__   ,	UpperCamelCase__=False   ,	UpperCamelCase__=True	):






         """simple docstring"""


         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   __SCREAMING_SNAKE_CASE       (__A       ):


  """simple docstring"""


  _a  : int      			=     PoolFormerConfig
  _a  : Optional[Any]      			=     '''poolformer'''
  _a  : Union[str, Any]      			=     '''pixel_values'''
  _a  : Optional[int]      			=     True







  def    _a       (			self   ,	UpperCamelCase__	):






         """simple docstring"""


         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    _a       (			self   ,	UpperCamelCase__   ,	UpperCamelCase__=False	):






         """simple docstring"""


         if isinstance(UpperCamelCase__   ,	UpperCamelCase__	):
                a_						     =			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.'''							,       __A							,       )
class   __SCREAMING_SNAKE_CASE       (__A       ):


  """simple docstring"""


  def __init__(			self   ,	UpperCamelCase__	):






         """simple docstring"""


         super().__init__(UpperCamelCase__	)
         a_						     =			config

         a_						     =			PoolFormerEncoder(UpperCamelCase__	)

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







  def    _a       (			self	):






         """simple docstring"""


         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    _a       (			self   ,	UpperCamelCase__ = None   ,	UpperCamelCase__ = None   ,	UpperCamelCase__ = None   ,	):






         """simple docstring"""


         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   __SCREAMING_SNAKE_CASE       (nn.Module       ):


  """simple docstring"""


  def __init__(			self   ,	UpperCamelCase__	):






         """simple docstring"""


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







  def    _a       (			self   ,	UpperCamelCase__	):






         """simple docstring"""


         a_						     =			self.dense(UpperCamelCase__	)
         return output





@add_start_docstrings(
    '''
    PoolFormer Model transformer with an image classification head on top
    '''							,       __A							,       )
class   __SCREAMING_SNAKE_CASE       (__A       ):


  """simple docstring"""


  def __init__(			self   ,	UpperCamelCase__	):






         """simple docstring"""


         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    _a       (			self   ,	UpperCamelCase__ = None   ,	UpperCamelCase__ = None   ,	UpperCamelCase__ = None   ,	UpperCamelCase__ = None   ,	):






         """simple docstring"""


         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	)




