



'''simple docstring'''





import warnings
from typing import List

import numpy as np

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding
from ...utils import is_flax_available, is_tf_available, is_torch_available






class __A     (    A		):



 '''simple docstring'''







 __lowerCamelCase       :			Dict		=			['image_processor', 'tokenizer']
 __lowerCamelCase       :			Union[str, Any]		=			'OwlViTImageProcessor'
 __lowerCamelCase       :			Optional[int]		=			('CLIPTokenizer', 'CLIPTokenizerFast')



 def __init__(self					,  A=None					,  A=None					,  **A			)       ->	str:


      """simple docstring"""



      _a           =    None
      if "feature_extractor" in kwargs:
           warnings.warn(
               '''The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`'''
               ''' instead.'''					,  A					,  )
           _a           =    kwargs.pop('''feature_extractor'''			)

      _a           =    image_processor if image_processor is not None else feature_extractor
      if image_processor is None:
           raise ValueError('''You need to specify an `image_processor`.'''			)
      if tokenizer is None:
           raise ValueError('''You need to specify a `tokenizer`.'''			)

      super().__init__(A					,  A			)



 def __call__(self					,  A=None					,  A=None					,  A=None					,  A="max_length"					,  A="np"					,  **A			)       ->	int:


      """simple docstring"""



      if text is None and query_images is None and images is None:
           raise ValueError(
               '''You have to specify at least one text or query image or image. All three cannot be none.'''			)

      if text is not None:
           if isinstance(A					,  A			) or (isinstance(A					,  A			) and not isinstance(text[0]					,  A			)):
                _a           =    [self.tokenizer(A					,  padding=A					,  return_tensors=A					,  **A			)]

           elif isinstance(A					,  A			) and isinstance(text[0]					,  A			):
                _a           =    []

                # Maximum number of queries across batch
                _a           =    max([len(A			) for t in text]			)

                # Pad all batch samples to max number of text queries
                for t in text:
                     if len(A			) != max_num_queries:
                          _a           =    t + [''' '''] * (max_num_queries - len(A			))

                     _a           =    self.tokenizer(A					,  padding=A					,  return_tensors=A					,  **A			)
                     encodings.append(A			)
           else:
                raise TypeError('''Input text should be a string, a list of strings or a nested list of strings'''			)

           if return_tensors == "np":
                _a           =    np.concatenate([encoding['''input_ids'''] for encoding in encodings]					,  axis=0			)
                _a           =    np.concatenate([encoding['''attention_mask'''] for encoding in encodings]					,  axis=0			)

           elif return_tensors == "jax" and is_flax_available():
                import jax.numpy as jnp

                _a           =    jnp.concatenate([encoding['''input_ids'''] for encoding in encodings]					,  axis=0			)
                _a           =    jnp.concatenate([encoding['''attention_mask'''] for encoding in encodings]					,  axis=0			)

           elif return_tensors == "pt" and is_torch_available():
                import torch

                _a           =    torch.cat([encoding['''input_ids'''] for encoding in encodings]					,  dim=0			)
                _a           =    torch.cat([encoding['''attention_mask'''] for encoding in encodings]					,  dim=0			)

           elif return_tensors == "tf" and is_tf_available():
                import tensorflow as tf

                _a           =    tf.stack([encoding['''input_ids'''] for encoding in encodings]					,  axis=0			)
                _a           =    tf.stack([encoding['''attention_mask'''] for encoding in encodings]					,  axis=0			)

           else:
                raise ValueError('''Target return tensor type could not be returned'''			)

           _a           =    BatchEncoding()
           _a           =    input_ids
           _a           =    attention_mask

      if query_images is not None:
           _a           =    BatchEncoding()
           _a           =    self.image_processor(
               A					,  return_tensors=A					,  **A			).pixel_values
           _a           =    query_pixel_values

      if images is not None:
           _a           =    self.image_processor(A					,  return_tensors=A					,  **A			)

      if text is not None and images is not None:
           _a           =    image_features.pixel_values
           return encoding
      elif query_images is not None and images is not None:
           _a           =    image_features.pixel_values
           return encoding
      elif text is not None or query_images is not None:
           return encoding
      else:
           return BatchEncoding(data=dict(**A			)					,  tensor_type=A			)



 def    a__    (self					,  *A					,  **A			)       ->	Any:


      """simple docstring"""



      return self.image_processor.post_process(*A					,  **A			)



 def    a__    (self					,  *A					,  **A			)       ->	Union[str, Any]:


      """simple docstring"""



      return self.image_processor.post_process_object_detection(*A					,  **A			)



 def    a__    (self					,  *A					,  **A			)       ->	Optional[Any]:


      """simple docstring"""



      return self.image_processor.post_process_image_guided_detection(*A					,  **A			)



 def    a__    (self					,  *A					,  **A			)       ->	Tuple:


      """simple docstring"""



      return self.tokenizer.batch_decode(*A					,  **A			)



 def    a__    (self					,  *A					,  **A			)       ->	str:


      """simple docstring"""



      return self.tokenizer.decode(*A					,  **A			)



 @property
 def    a__    (self			)       ->	Dict:


      """simple docstring"""



      warnings.warn(
          '''`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead.'''					,  A					,  )
      return self.image_processor_class



 @property
 def    a__    (self			)       ->	List[Any]:


      """simple docstring"""



      warnings.warn(
          '''`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead.'''					,  A					,  )
      return self.image_processor





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