






'''simple docstring'''







import unittest

from transformers.testing_utils import require_bsa
from transformers.utils import is_bsa_available

from ...test_feature_extraction_common import FeatureExtractionSavingTestMixin


if is_bsa_available():
  from transformers import MarkupLMFeatureExtractor




class   __SCREAMING_SNAKE_CASE       (unittest.TestCase       ):


  """simple docstring"""


  def __init__(			self   ,	UpperCamelCase__	):






         """simple docstring"""


         a_						     =			parent







  def    _a       (			self	):






         """simple docstring"""


         return {}





def       __UpperCamelCase					(      ):
       """simple docstring"""




       a_						     =			'<HTML>\n\n    <HEAD>\n    <TITLE>sample document</TITLE>\n    </HEAD>\n\n    <BODY BGCOLOR="FFFFFF">\n    <HR>\n    <a href="http://google.com">Goog</a>\n    <H1>This is one header</H1>\n    <H2>This is a another Header</H2>\n    <P>Travel from\n        <P>\n        <B>SFO to JFK</B>\n        <BR>\n        <B><I>on May 2, 2015 at 2:00 pm. For details go to confirm.com </I></B>\n        <HR>\n        <div style="color:#0000FF">\n            <h3>Traveler <b> name </b> is\n            <p> John Doe </p>\n        </div>'

       a_						     =			'\n    <!DOCTYPE html>\n    <html>\n    <body>\n\n    <h1>My First Heading</h1>\n    <p>My first paragraph.</p>\n\n    </body>\n    </html>\n    '

       return [html_string_a, html_string_a]




@require_bsa
class   __SCREAMING_SNAKE_CASE       (__A							,       unittest.TestCase       ):


  """simple docstring"""


  _a  : List[Any]      			=     MarkupLMFeatureExtractor if is_bsa_available() else None







  def    _a       (			self	):






         """simple docstring"""


         a_						     =			MarkupLMFeatureExtractionTester(self	)







  @property
  def    _a       (			self	):






         """simple docstring"""


         return self.feature_extract_tester.prepare_feat_extract_dict()







  def    _a       (			self	):






         """simple docstring"""


         a_						     =			self.feature_extraction_class()

         # Test not batched input
         a_						     =			get_html_strings()[0]
         a_						     =			feature_extractor(UpperCamelCase__	)

         # fmt: off
         a_						     =			[['sample document', 'Goog', 'This is one header', 'This is a another Header', 'Travel from', 'SFO to JFK', 'on May 2, 2015 at 2:00 pm. For details go to confirm.com', 'Traveler', 'name', 'is', 'John Doe']]
         a_						     =			[['/html/head/title', '/html/body/a', '/html/body/h1', '/html/body/h2', '/html/body/p', '/html/body/p/p/b[1]', '/html/body/p/p/b[2]/i', '/html/body/p/p/div/h3', '/html/body/p/p/div/h3/b', '/html/body/p/p/div/h3', '/html/body/p/p/div/h3/p']]
         # fmt: on

         self.assertEqual(encoding.nodes   ,	UpperCamelCase__	)
         self.assertEqual(encoding.xpaths   ,	UpperCamelCase__	)

         # Test batched
         a_						     =			get_html_strings()
         a_						     =			feature_extractor(UpperCamelCase__	)

         # fmt: off
         a_						     =			expected_nodes + [['My First Heading', 'My first paragraph.']]
         a_						     =			expected_xpaths + [['/html/body/h1', '/html/body/p']]

         self.assertEqual(len(encoding.nodes	)   ,	2	)
         self.assertEqual(len(encoding.xpaths	)   ,	2	)

         self.assertEqual(encoding.nodes   ,	UpperCamelCase__	)
         self.assertEqual(encoding.xpaths   ,	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


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




