





from typing import Optional, Tuple, Union

import tensorflow as tf

from ...activations_tf import ACTaFN
from ...file_utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward
from ...modeling_tf_outputs import (
    TFBaseModelOutputWithNoAttention,
    TFBaseModelOutputWithPoolingAndNoAttention,
    TFSequenceClassifierOutput,
)
from ...modeling_tf_utils import TFPreTrainedModel, TFSequenceClassificationLoss, keras_serializable, unpack_inputs
from ...tf_utils import shape_list
from ...utils import logging
from .configuration_regnet import RegNetConfig


snake_case_				=			logging.get_logger(__name__)

# General docstring
snake_case_				=			'RegNetConfig'

# Base docstring
snake_case_				=			'facebook/regnet-y-040'
snake_case_				=			[1, 1088, 7, 7]

# Image classification docstring
snake_case_				=			'facebook/regnet-y-040'
snake_case_				=			'tabby, tabby cat'

snake_case_				=			[
    'facebook/regnet-y-040',
    # See all regnet models at https://huggingface.co/models?filter=regnet
]

class 		SCREAMING_SNAKE_CASE__				(       tf.keras.layers.Layer  ):


      def __init__(self       :      Any				,			a__       :      int				,			a__       :      int = 3				,			a__       :      int = 1				,			a__       :      int = 1				,			a__       :      Optional[str] = "relu"				,			**a__       :      Tuple				,			):





         """simple docstring"""



         super().__init__(**a__      )
         # The padding and conv has been verified in
         # https://colab.research.google.com/gist/sayakpaul/854bc10eeaf21c9ee2119e0b9f3841a7/scratchpad.ipynb
         __snake_case							       =   tf.keras.layers.ZeroPaddingaD(padding=kernel_size // 2      )
         __snake_case							       =   tf.keras.layers.ConvaD(
             filters=a__				,			kernel_size=a__				,			strides=a__				,			padding='''VALID'''				,			groups=a__				,			use_bias=a__				,			name='''convolution'''				,			)
         __snake_case							       =   tf.keras.layers.BatchNormalization(epsilon=1E-5				,			momentum=0.9				,			name='''normalization'''      )
         __snake_case							       =   ACTaFN[activation] if activation is not None else tf.identity


      def    a (self       :      Tuple				,			a__       :      Any      ):





         """simple docstring"""



         __snake_case							       =   self.convolution(self.padding(a__      )      )
         __snake_case							       =   self.normalization(a__      )
         __snake_case							       =   self.activation(a__      )
         return hidden_state






class 		SCREAMING_SNAKE_CASE__				(       tf.keras.layers.Layer  ):


      def __init__(self       :      Tuple				,			a__       :      RegNetConfig				,			**a__       :      Tuple      ):





         """simple docstring"""



         super().__init__(**a__      )
         __snake_case							       =   config.num_channels
         __snake_case							       =   TFRegNetConvLayer(
             out_channels=config.embedding_size				,			kernel_size=3				,			stride=2				,			activation=config.hidden_act				,			name='''embedder'''				,			)


      def    a (self       :      Optional[int]				,			a__       :      Any      ):





         """simple docstring"""



         __snake_case							       =   shape_list(a__      )[1]
         if tf.executing_eagerly() and num_channels != self.num_channels:
            raise ValueError(
                '''Make sure that the channel dimension of the pixel values match with the one set in the configuration.'''      )

         # When running on CPU, `tf.keras.layers.Conv2D` doesn't support `NCHW` format.
         # So change the input format from `NCHW` to `NHWC`.
         # shape = (batch_size, in_height, in_width, in_channels=num_channels)
         __snake_case							       =   tf.transpose(a__				,			perm=(0, 2, 3, 1)      )
         __snake_case							       =   self.embedder(a__      )
         return hidden_state






class 		SCREAMING_SNAKE_CASE__				(       tf.keras.layers.Layer  ):


      def __init__(self       :      Dict				,			a__       :      int				,			a__       :      int = 2				,			**a__       :      str      ):





         """simple docstring"""



         super().__init__(**a__      )
         __snake_case							       =   tf.keras.layers.ConvaD(
             filters=a__				,			kernel_size=1				,			strides=a__				,			use_bias=a__				,			name='''convolution'''      )
         __snake_case							       =   tf.keras.layers.BatchNormalization(epsilon=1E-5				,			momentum=0.9				,			name='''normalization'''      )


      def    a (self       :      str				,			a__       :      tf.Tensor				,			a__       :      bool = False      ):





         """simple docstring"""



         return self.normalization(self.convolution(a__      )				,			training=a__      )






class 		SCREAMING_SNAKE_CASE__				(       tf.keras.layers.Layer  ):


      def __init__(self       :      Optional[Any]				,			a__       :      int				,			a__       :      int				,			**a__       :      int      ):





         """simple docstring"""



         super().__init__(**a__      )
         __snake_case							       =   tf.keras.layers.GlobalAveragePoolingaD(keepdims=a__				,			name='''pooler'''      )
         __snake_case							       =   [
             tf.keras.layers.ConvaD(filters=a__				,			kernel_size=1				,			activation='''relu'''				,			name='''attention.0'''      ),
             tf.keras.layers.ConvaD(filters=a__				,			kernel_size=1				,			activation='''sigmoid'''				,			name='''attention.2'''      ),
         ]


      def    a (self       :      Tuple				,			a__       :      Union[str, Any]      ):





         """simple docstring"""



         __snake_case							       =   self.pooler(a__      )
         for layer_module in self.attention:
            __snake_case							       =   layer_module(a__      )
         __snake_case							       =   hidden_state * pooled
         return hidden_state






class 		SCREAMING_SNAKE_CASE__				(       tf.keras.layers.Layer  ):


      def __init__(self       :      int				,			a__       :      RegNetConfig				,			a__       :      int				,			a__       :      int				,			a__       :      int = 1				,			**a__       :      Any      ):





         """simple docstring"""



         super().__init__(**a__      )
         __snake_case							       =   in_channels != out_channels or stride != 1
         __snake_case							       =   max(1				,			out_channels // config.groups_width      )
         __snake_case							       =   (
             TFRegNetShortCut(a__				,			stride=a__				,			name='''shortcut'''      )
             if should_apply_shortcut
             else tf.keras.layers.Activation('''linear'''				,			name='''shortcut'''      )
         )
         # `self.layers` instead of `self.layer` because that is a reserved argument.
         __snake_case							       =   [
             TFRegNetConvLayer(a__				,			kernel_size=1				,			activation=config.hidden_act				,			name='''layer.0'''      ),
             TFRegNetConvLayer(
                 a__				,			stride=a__				,			groups=a__				,			activation=config.hidden_act				,			name='''layer.1'''      ),
             TFRegNetConvLayer(a__				,			kernel_size=1				,			activation=a__				,			name='''layer.2'''      ),
         ]
         __snake_case							       =   ACTaFN[config.hidden_act]


      def    a (self       :      Tuple				,			a__       :      str      ):





         """simple docstring"""



         __snake_case							       =   hidden_state
         for layer_module in self.layers:
            __snake_case							       =   layer_module(a__      )
         __snake_case							       =   self.shortcut(a__      )
         hidden_state += residual
         __snake_case							       =   self.activation(a__      )
         return hidden_state






class 		SCREAMING_SNAKE_CASE__				(       tf.keras.layers.Layer  ):


      def __init__(self       :      List[Any]				,			a__       :      RegNetConfig				,			a__       :      int				,			a__       :      int				,			a__       :      int = 1				,			**a__       :      Union[str, Any]      ):





         """simple docstring"""



         super().__init__(**a__      )
         __snake_case							       =   in_channels != out_channels or stride != 1
         __snake_case							       =   max(1				,			out_channels // config.groups_width      )
         __snake_case							       =   (
             TFRegNetShortCut(a__				,			stride=a__				,			name='''shortcut'''      )
             if should_apply_shortcut
             else tf.keras.layers.Activation('''linear'''				,			name='''shortcut'''      )
         )
         __snake_case							       =   [
             TFRegNetConvLayer(a__				,			kernel_size=1				,			activation=config.hidden_act				,			name='''layer.0'''      ),
             TFRegNetConvLayer(
                 a__				,			stride=a__				,			groups=a__				,			activation=config.hidden_act				,			name='''layer.1'''      ),
             TFRegNetSELayer(a__				,			reduced_channels=int(round(in_channels / 4      )      )				,			name='''layer.2'''      ),
             TFRegNetConvLayer(a__				,			kernel_size=1				,			activation=a__				,			name='''layer.3'''      ),
         ]
         __snake_case							       =   ACTaFN[config.hidden_act]


      def    a (self       :      Tuple				,			a__       :      int      ):





         """simple docstring"""



         __snake_case							       =   hidden_state
         for layer_module in self.layers:
            __snake_case							       =   layer_module(a__      )
         __snake_case							       =   self.shortcut(a__      )
         hidden_state += residual
         __snake_case							       =   self.activation(a__      )
         return hidden_state






class 		SCREAMING_SNAKE_CASE__				(       tf.keras.layers.Layer  ):


      def __init__(self       :      List[str]				,			a__       :      RegNetConfig				,			a__       :      int				,			a__       :      int				,			a__       :      int = 2				,			a__       :      int = 2				,			**a__       :      Optional[int]      ):





         """simple docstring"""



         super().__init__(**a__      )

         __snake_case							       =   TFRegNetXLayer if config.layer_type == '''x''' else TFRegNetYLayer
         __snake_case							       =   [
             # downsampling is done in the first layer with stride of 2
             layer(a__				,			a__				,			a__				,			stride=a__				,			name='''layers.0'''      ),
             *[layer(a__				,			a__				,			a__				,			name=f"""layers.{i+1}"""      ) for i in range(depth - 1      )],
         ]


      def    a (self       :      Any				,			a__       :      Optional[int]      ):





         """simple docstring"""



         for layer_module in self.layers:
            __snake_case							       =   layer_module(a__      )
         return hidden_state






class 		SCREAMING_SNAKE_CASE__				(       tf.keras.layers.Layer  ):


      def __init__(self       :      Optional[int]				,			a__       :      RegNetConfig				,			**a__       :      Union[str, Any]      ):





         """simple docstring"""



         super().__init__(**a__      )
         __snake_case							       =   []
         # based on `downsample_in_first_stage`, the first layer of the first stage may or may not downsample the input
         self.stages.append(
             TFRegNetStage(
                 a__				,			config.embedding_size				,			config.hidden_sizes[0]				,			stride=2 if config.downsample_in_first_stage else 1				,			depth=config.depths[0]				,			name='''stages.0'''				,			)      )
         __snake_case							       =   zip(config.hidden_sizes				,			config.hidden_sizes[1:]      )
         for i, ((in_channels, out_channels), depth) in enumerate(zip(a__				,			config.depths[1:]      )      ):
            self.stages.append(TFRegNetStage(a__				,			a__				,			a__				,			depth=a__				,			name=f"""stages.{i+1}"""      )      )


      def    a (self       :      Union[str, Any]				,			a__       :      tf.Tensor				,			a__       :      bool = False				,			a__       :      bool = True      ):





         """simple docstring"""



         __snake_case							       =   () if output_hidden_states else None

         for stage_module in self.stages:
            if output_hidden_states:
               __snake_case							       =   hidden_states + (hidden_state,)

            __snake_case							       =   stage_module(a__      )

         if output_hidden_states:
            __snake_case							       =   hidden_states + (hidden_state,)

         if not return_dict:
            return tuple(v for v in [hidden_state, hidden_states] if v is not None      )

         return TFBaseModelOutputWithNoAttention(last_hidden_state=a__				,			hidden_states=a__      )






@keras_serializable
class 		SCREAMING_SNAKE_CASE__				(       tf.keras.layers.Layer  ):
      A_						:				Tuple							=    RegNetConfig


      def __init__(self       :      Optional[int]				,			a__       :      Optional[Any]				,			**a__       :      List[Any]      ):





         """simple docstring"""



         super().__init__(**a__      )
         __snake_case							       =   config
         __snake_case							       =   TFRegNetEmbeddings(a__				,			name='''embedder'''      )
         __snake_case							       =   TFRegNetEncoder(a__				,			name='''encoder'''      )
         __snake_case							       =   tf.keras.layers.GlobalAveragePoolingaD(keepdims=a__				,			name='''pooler'''      )


      @unpack_inputs
      def    a (self       :      Optional[int]				,			a__       :      tf.Tensor				,			a__       :      Optional[bool] = None				,			a__       :      Optional[bool] = None				,			a__       :      bool = False				,			):





         """simple docstring"""



         __snake_case							       =   (
             output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
         )
         __snake_case							       =   return_dict if return_dict is not None else self.config.use_return_dict

         __snake_case							       =   self.embedder(a__				,			training=a__      )

         __snake_case							       =   self.encoder(
             a__				,			output_hidden_states=a__				,			return_dict=a__				,			training=a__      )

         __snake_case							       =   encoder_outputs[0]
         __snake_case							       =   self.pooler(a__      )

         # Change to NCHW output format have uniformity in the modules
         __snake_case							       =   tf.transpose(a__				,			perm=(0, 3, 1, 2)      )
         __snake_case							       =   tf.transpose(a__				,			perm=(0, 3, 1, 2)      )

         # Change the other hidden state outputs to NCHW as well
         if output_hidden_states:
            __snake_case							       =   tuple([tf.transpose(a__				,			perm=(0, 3, 1, 2)      ) for h in encoder_outputs[1]]      )

         if not return_dict:
            return (last_hidden_state, pooled_output) + encoder_outputs[1:]

         return TFBaseModelOutputWithPoolingAndNoAttention(
             last_hidden_state=a__				,			pooler_output=a__				,			hidden_states=hidden_states if output_hidden_states else encoder_outputs.hidden_states				,			)






class 		SCREAMING_SNAKE_CASE__				(       _UpperCAmelCase  ):
      A_						:				Union[str, Any]							=    RegNetConfig
      A_						:				int							=    'regnet'
      A_						:				str							=    'pixel_values'


      @property
      def    a (self       :      List[str]      ):





         """simple docstring"""



         return {"pixel_values": tf.TensorSpec(shape=(None, self.config.num_channels, 224, 224)				,			dtype=tf.floataa      )}






snake_case_				=			R'\n    Parameters:\n    This model is a Tensorflow\n    [tf.keras.layers.Layer](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Layer) sub-class. Use it as a\n    regular Tensorflow Module and refer to the Tensorflow documentation for all matter related to general usage and\n    behavior.\n        config ([`RegNetConfig`]): 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 [`~TFPreTrainedModel.from_pretrained`] method to load the model weights.\n'

snake_case_				=			R'\n    Args:\n        pixel_values (`tf.Tensor` of shape `(batch_size, num_channels, height, width)`):\n            Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See\n            [`ConveNextImageProcessor.__call__`] for details.\n        output_hidden_states (`bool`, *optional*):\n            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for\n            more detail.\n        return_dict (`bool`, *optional*):\n            Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.\n'

@add_start_docstrings(
    'The bare RegNet model outputting raw features without any specific head on top.'						,      _UpperCAmelCase						,      )
class 		SCREAMING_SNAKE_CASE__				(       _UpperCAmelCase  ):


      def __init__(self       :      List[Any]				,			a__       :      RegNetConfig				,			*a__       :      int				,			**a__       :      Union[str, Any]      ):





         """simple docstring"""



         super().__init__(a__				,			*a__				,			**a__      )
         __snake_case							       =   TFRegNetMainLayer(a__				,			name='''regnet'''      )


      @unpack_inputs
      @add_start_docstrings_to_model_forward(a__      )
      @add_code_sample_docstrings(
          checkpoint=_CHECKPOINT_FOR_DOC				,			output_type=a__				,			config_class=_CONFIG_FOR_DOC				,			modality='''vision'''				,			expected_output=_EXPECTED_OUTPUT_SHAPE				,			)
      def    a (self       :      List[str]				,			a__       :      tf.Tensor				,			a__       :      Optional[bool] = None				,			a__       :      Optional[bool] = None				,			a__       :      Any=False				,			):





         """simple docstring"""



         __snake_case							       =   (
             output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
         )
         __snake_case							       =   return_dict if return_dict is not None else self.config.use_return_dict

         __snake_case							       =   self.regnet(
             pixel_values=a__				,			output_hidden_states=a__				,			return_dict=a__				,			training=a__				,			)
         if not return_dict:
            return (outputs[0],) + outputs[1:]

         return TFBaseModelOutputWithPoolingAndNoAttention(
             last_hidden_state=outputs.last_hidden_state				,			pooler_output=outputs.pooler_output				,			hidden_states=outputs.hidden_states				,			)






@add_start_docstrings(
    '\n    RegNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for\n    ImageNet.\n    '						,      _UpperCAmelCase						,      )
class 		SCREAMING_SNAKE_CASE__				(       _UpperCAmelCase						,      _UpperCAmelCase  ):


      def __init__(self       :      int				,			a__       :      RegNetConfig				,			*a__       :      List[str]				,			**a__       :      Any      ):





         """simple docstring"""



         super().__init__(a__				,			*a__				,			**a__      )
         __snake_case							       =   config.num_labels
         __snake_case							       =   TFRegNetMainLayer(a__				,			name='''regnet'''      )
         # classification head
         __snake_case							       =   [
             tf.keras.layers.Flatten(),
             tf.keras.layers.Dense(config.num_labels				,			name='''classifier.1'''      ) if config.num_labels > 0 else tf.identity,
         ]


      @unpack_inputs
      @add_start_docstrings_to_model_forward(a__      )
      @add_code_sample_docstrings(
          checkpoint=_IMAGE_CLASS_CHECKPOINT				,			output_type=a__				,			config_class=_CONFIG_FOR_DOC				,			expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT				,			)
      def    a (self       :      List[str]				,			a__       :      tf.Tensor = None				,			a__       :      tf.Tensor = None				,			a__       :      bool = None				,			a__       :      bool = None				,			a__       :      Dict=False				,			):





         """simple docstring"""



         __snake_case							       =   (
             output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
         )
         __snake_case							       =   return_dict if return_dict is not None else self.config.use_return_dict

         __snake_case							       =   self.regnet(
             a__				,			output_hidden_states=a__				,			return_dict=a__				,			training=a__      )

         __snake_case							       =   outputs.pooler_output if return_dict else outputs[1]

         __snake_case							       =   self.classifier[0](a__      )
         __snake_case							       =   self.classifier[1](a__      )

         __snake_case							       =   None if labels is None else self.hf_compute_loss(labels=a__				,			logits=a__      )

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

         return TFSequenceClassifierOutput(loss=a__				,			logits=a__				,			hidden_states=outputs.hidden_states      )








import os
import unittest

from transformers.models.bartpho.tokenization_bartpho import VOCAB_FILES_NAMES, BartphoTokenizer
from transformers.testing_utils import get_tests_dir

from ...test_tokenization_common import TokenizerTesterMixin


snake_case_				=			get_tests_dir('fixtures/test_sentencepiece_bpe.model')

class 		SCREAMING_SNAKE_CASE__				(       _UpperCAmelCase						,      unittest.TestCase  ):
      A_						:				List[Any]							=    BartphoTokenizer
      A_						:				List[str]							=    False
      A_						:				Optional[Any]							=    True


      def    a (self       :      Tuple      ):





         """simple docstring"""



         super().setUp()

         __snake_case							       =   ['''▁This''', '''▁is''', '''▁a''', '''▁t''', '''est''']
         __snake_case							       =   dict(zip(a__				,			range(len(a__      )      )      )      )
         __snake_case							       =   {'''unk_token''': '''<unk>'''}

         __snake_case							       =   os.path.join(self.tmpdirname				,			VOCAB_FILES_NAMES['''monolingual_vocab_file''']      )
         with open(self.monolingual_vocab_file				,			'''w'''				,			encoding='''utf-8'''      ) as fp:
            for token in vocab_tokens:
               fp.write(f"""{token} {vocab_tokens[token]}\n"""      )

         __snake_case							       =   BartphoTokenizer(a__				,			self.monolingual_vocab_file				,			**self.special_tokens_map      )
         tokenizer.save_pretrained(self.tmpdirname      )


      def    a (self       :      str				,			**a__       :      str      ):





         """simple docstring"""



         kwargs.update(self.special_tokens_map      )
         return BartphoTokenizer.from_pretrained(self.tmpdirname				,			**a__      )


      def    a (self       :      str				,			a__       :      Any      ):





         """simple docstring"""



         __snake_case							       =   '''This is a là test'''
         __snake_case							       =   '''This is a<unk><unk> test'''
         return input_text, output_text


      def    a (self       :      Dict      ):





         """simple docstring"""



         __snake_case							       =   BartphoTokenizer(a__				,			self.monolingual_vocab_file				,			**self.special_tokens_map      )
         __snake_case							       =   '''This is a là test'''
         __snake_case							       =   '''▁This ▁is ▁a ▁l à ▁t est'''.split()
         __snake_case							       =   tokenizer.tokenize(a__      )
         self.assertListEqual(a__				,			a__      )

         __snake_case							       =   tokens + [tokenizer.unk_token]
         __snake_case							       =   [4, 5, 6, 3, 3, 7, 8, 3]
         self.assertListEqual(tokenizer.convert_tokens_to_ids(a__      )				,			a__      )

