



'''simple docstring'''





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


SCREAMING_SNAKE_CASE__      					=     logging.get_logger(__name__)

# General docstring
SCREAMING_SNAKE_CASE__      					=     "RegNetConfig"

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

# Image classification docstring
SCREAMING_SNAKE_CASE__      					=     "facebook/regnet-y-040"
SCREAMING_SNAKE_CASE__      					=     "tabby, tabby cat"

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


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



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







       def 							_a      (				self     ,UpperCAmelCase_      )  ->							Optional[Any]:
           lowercase__		       =						self.convolution(self.padding(UpperCAmelCase_      )      )
           lowercase__		       =						self.normalization(UpperCAmelCase_      )
           lowercase__		       =						self.activation(UpperCAmelCase_      )
           return hidden_state





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



       def __init__(				self     ,UpperCAmelCase_     ,**UpperCAmelCase_      )  ->							List[Any]:
           super().__init__(**UpperCAmelCase_      )
           lowercase__		       =						config.num_channels
           lowercase__		       =						TFRegNetConvLayer(
               out_channels=config.embedding_size     ,kernel_size=3     ,stride=2     ,activation=config.hidden_act     ,name="embedder"     ,)







       def 							_a      (				self     ,UpperCAmelCase_      )  ->							List[str]:
           lowercase__		       =						shape_list(UpperCAmelCase_      )[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)
           lowercase__		       =						tf.transpose(UpperCAmelCase_     ,perm=(0, 2, 3, 1)      )
           lowercase__		       =						self.embedder(UpperCAmelCase_      )
           return hidden_state





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



       def __init__(				self     ,UpperCAmelCase_     ,UpperCAmelCase_ = 2     ,**UpperCAmelCase_      )  ->							List[Any]:
           super().__init__(**UpperCAmelCase_      )
           lowercase__		       =						tf.keras.layers.ConvaD(
               filters=UpperCAmelCase_     ,kernel_size=1     ,strides=UpperCAmelCase_     ,use_bias=UpperCAmelCase_     ,name="convolution"      )
           lowercase__		       =						tf.keras.layers.BatchNormalization(epsilon=1E-5     ,momentum=0.9     ,name="normalization"      )







       def 							_a      (				self     ,UpperCAmelCase_     ,UpperCAmelCase_ = False      )  ->							tf.Tensor:
           return self.normalization(self.convolution(UpperCAmelCase_      )     ,training=UpperCAmelCase_      )





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



       def __init__(				self     ,UpperCAmelCase_     ,UpperCAmelCase_     ,**UpperCAmelCase_      )  ->							Any:
           super().__init__(**UpperCAmelCase_      )
           lowercase__		       =						tf.keras.layers.GlobalAveragePoolingaD(keepdims=UpperCAmelCase_     ,name="pooler"      )
           lowercase__		       =						[
               tf.keras.layers.ConvaD(filters=UpperCAmelCase_     ,kernel_size=1     ,activation="relu"     ,name="attention.0"      ),
               tf.keras.layers.ConvaD(filters=UpperCAmelCase_     ,kernel_size=1     ,activation="sigmoid"     ,name="attention.2"      ),
           ]







       def 							_a      (				self     ,UpperCAmelCase_      )  ->							int:
           # [batch_size, h, w, num_channels] -> [batch_size, 1, 1, num_channels]
           lowercase__		       =						self.pooler(UpperCAmelCase_      )
           for layer_module in self.attention:
               lowercase__		       =						layer_module(UpperCAmelCase_      )
           lowercase__		       =						hidden_state * pooled
           return hidden_state





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



       def __init__(				self     ,UpperCAmelCase_     ,UpperCAmelCase_     ,UpperCAmelCase_     ,UpperCAmelCase_ = 1     ,**UpperCAmelCase_      )  ->							Dict:
           super().__init__(**UpperCAmelCase_      )
           lowercase__		       =						in_channels != out_channels or stride != 1
           lowercase__		       =						max(1     ,out_channels // config.groups_width      )
           lowercase__		       =						(
               TFRegNetShortCut(UpperCAmelCase_     ,stride=UpperCAmelCase_     ,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.
           lowercase__		       =						[
               TFRegNetConvLayer(UpperCAmelCase_     ,kernel_size=1     ,activation=config.hidden_act     ,name="layer.0"      ),
               TFRegNetConvLayer(
                   UpperCAmelCase_     ,stride=UpperCAmelCase_     ,groups=UpperCAmelCase_     ,activation=config.hidden_act     ,name="layer.1"      ),
               TFRegNetConvLayer(UpperCAmelCase_     ,kernel_size=1     ,activation=UpperCAmelCase_     ,name="layer.2"      ),
           ]
           lowercase__		       =						ACTaFN[config.hidden_act]







       def 							_a      (				self     ,UpperCAmelCase_      )  ->							List[str]:
           lowercase__		       =						hidden_state
           for layer_module in self.layers:
               lowercase__		       =						layer_module(UpperCAmelCase_      )
           lowercase__		       =						self.shortcut(UpperCAmelCase_      )
           hidden_state += residual
           lowercase__		       =						self.activation(UpperCAmelCase_      )
           return hidden_state





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



       def __init__(				self     ,UpperCAmelCase_     ,UpperCAmelCase_     ,UpperCAmelCase_     ,UpperCAmelCase_ = 1     ,**UpperCAmelCase_      )  ->							Dict:
           super().__init__(**UpperCAmelCase_      )
           lowercase__		       =						in_channels != out_channels or stride != 1
           lowercase__		       =						max(1     ,out_channels // config.groups_width      )
           lowercase__		       =						(
               TFRegNetShortCut(UpperCAmelCase_     ,stride=UpperCAmelCase_     ,name="shortcut"      )
               if should_apply_shortcut
               else tf.keras.layers.Activation("linear"     ,name="shortcut"      )
           )
           lowercase__		       =						[
               TFRegNetConvLayer(UpperCAmelCase_     ,kernel_size=1     ,activation=config.hidden_act     ,name="layer.0"      ),
               TFRegNetConvLayer(
                   UpperCAmelCase_     ,stride=UpperCAmelCase_     ,groups=UpperCAmelCase_     ,activation=config.hidden_act     ,name="layer.1"      ),
               TFRegNetSELayer(UpperCAmelCase_     ,reduced_channels=int(round(in_channels / 4      )      )     ,name="layer.2"      ),
               TFRegNetConvLayer(UpperCAmelCase_     ,kernel_size=1     ,activation=UpperCAmelCase_     ,name="layer.3"      ),
           ]
           lowercase__		       =						ACTaFN[config.hidden_act]







       def 							_a      (				self     ,UpperCAmelCase_      )  ->							Optional[Any]:
           lowercase__		       =						hidden_state
           for layer_module in self.layers:
               lowercase__		       =						layer_module(UpperCAmelCase_      )
           lowercase__		       =						self.shortcut(UpperCAmelCase_      )
           hidden_state += residual
           lowercase__		       =						self.activation(UpperCAmelCase_      )
           return hidden_state





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



       def __init__(				self     ,UpperCAmelCase_     ,UpperCAmelCase_     ,UpperCAmelCase_     ,UpperCAmelCase_ = 2     ,UpperCAmelCase_ = 2     ,**UpperCAmelCase_      )  ->							List[str]:
           super().__init__(**UpperCAmelCase_      )

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







       def 							_a      (				self     ,UpperCAmelCase_      )  ->							Union[str, Any]:
           for layer_module in self.layers:
               lowercase__		       =						layer_module(UpperCAmelCase_      )
           return hidden_state





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



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







       def 							_a      (				self     ,UpperCAmelCase_     ,UpperCAmelCase_ = False     ,UpperCAmelCase_ = True      )  ->							TFBaseModelOutputWithNoAttention:
           lowercase__		       =						() if output_hidden_states else None

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

               lowercase__		       =						stage_module(UpperCAmelCase_      )

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





@keras_serializable
class 				snake_case (tf.keras.layers.Layer   ):
       lowerCAmelCase__  :Optional[Any]						   =					RegNetConfig



       def __init__(				self     ,UpperCAmelCase_     ,**UpperCAmelCase_      )  ->							Any:
           super().__init__(**UpperCAmelCase_      )
           lowercase__		       =						config
           lowercase__		       =						TFRegNetEmbeddings(UpperCAmelCase_     ,name="embedder"      )
           lowercase__		       =						TFRegNetEncoder(UpperCAmelCase_     ,name="encoder"      )
           lowercase__		       =						tf.keras.layers.GlobalAveragePoolingaD(keepdims=UpperCAmelCase_     ,name="pooler"      )







       @unpack_inputs
       def 							_a      (				self     ,UpperCAmelCase_     ,UpperCAmelCase_ = None     ,UpperCAmelCase_ = None     ,UpperCAmelCase_ = False     ,)  ->							TFBaseModelOutputWithPoolingAndNoAttention:
           lowercase__		       =						(
               output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
           )
           lowercase__		       =						return_dict if return_dict is not None else self.config.use_return_dict

           lowercase__		       =						self.embedder(UpperCAmelCase_     ,training=UpperCAmelCase_      )

           lowercase__		       =						self.encoder(
               UpperCAmelCase_     ,output_hidden_states=UpperCAmelCase_     ,return_dict=UpperCAmelCase_     ,training=UpperCAmelCase_      )

           lowercase__		       =						encoder_outputs[0]
           lowercase__		       =						self.pooler(UpperCAmelCase_      )

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

           # Change the other hidden state outputs to NCHW as well
           if output_hidden_states:
               lowercase__		       =						tuple([tf.transpose(UpperCAmelCase_     ,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=UpperCAmelCase_     ,pooler_output=UpperCAmelCase_     ,hidden_states=hidden_states if output_hidden_states else encoder_outputs.hidden_states     ,)





class 				snake_case (UpperCamelCase   ):
       lowerCAmelCase__  :List[Any]						   =					RegNetConfig
       lowerCAmelCase__  :Any						   =					"regnet"
       lowerCAmelCase__  :List[str]						   =					"pixel_values"



       @property
       def 							_a      (				self      )  ->							List[str]:
           return {"pixel_values": tf.TensorSpec(shape=(None, self.config.num_channels, 224, 224)     ,dtype=tf.floataa      )}





SCREAMING_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"

SCREAMING_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 				snake_case (UpperCamelCase   ):



       def __init__(				self     ,UpperCAmelCase_     ,*UpperCAmelCase_     ,**UpperCAmelCase_      )  ->							Optional[int]:
           super().__init__(UpperCAmelCase_     ,*UpperCAmelCase_     ,**UpperCAmelCase_      )
           lowercase__		       =						TFRegNetMainLayer(UpperCAmelCase_     ,name="regnet"      )







       @unpack_inputs
       @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_     ,UpperCAmelCase_ = None     ,UpperCAmelCase_ = None     ,UpperCAmelCase_=False     ,)  ->							Union[TFBaseModelOutputWithPoolingAndNoAttention, Tuple[tf.Tensor]]:
           lowercase__		       =						(
               output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
           )
           lowercase__		       =						return_dict if return_dict is not None else self.config.use_return_dict

           lowercase__		       =						self.regnet(
               pixel_values=UpperCAmelCase_     ,output_hidden_states=UpperCAmelCase_     ,return_dict=UpperCAmelCase_     ,training=UpperCAmelCase_     ,)
           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 				snake_case (UpperCamelCase		,      UpperCamelCase   ):



       def __init__(				self     ,UpperCAmelCase_     ,*UpperCAmelCase_     ,**UpperCAmelCase_      )  ->							List[str]:
           super().__init__(UpperCAmelCase_     ,*UpperCAmelCase_     ,**UpperCAmelCase_      )
           lowercase__		       =						config.num_labels
           lowercase__		       =						TFRegNetMainLayer(UpperCAmelCase_     ,name="regnet"      )
           # classification head
           lowercase__		       =						[
               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(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     ,UpperCAmelCase_=False     ,)  ->							Union[TFSequenceClassifierOutput, Tuple[tf.Tensor]]:
           lowercase__		       =						(
               output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
           )
           lowercase__		       =						return_dict if return_dict is not None else self.config.use_return_dict

           lowercase__		       =						self.regnet(
               UpperCAmelCase_     ,output_hidden_states=UpperCAmelCase_     ,return_dict=UpperCAmelCase_     ,training=UpperCAmelCase_      )

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

           lowercase__		       =						self.classifier[0](UpperCAmelCase_      )
           lowercase__		       =						self.classifier[1](UpperCAmelCase_      )

           lowercase__		       =						None if labels is None else self.hf_compute_loss(labels=UpperCAmelCase_     ,logits=UpperCAmelCase_      )

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

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









'''simple docstring'''





import os
from typing import Dict, List, Union

import tensorflow as tf
from keras_nlp.tokenizers import BytePairTokenizer
from tensorflow_text import pad_model_inputs

from .tokenization_gpta import GPTaTokenizer


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



       def __init__(				self     ,UpperCAmelCase_     ,UpperCAmelCase_     ,UpperCAmelCase_ = None     ,UpperCAmelCase_ = None      )  ->							List[Any]:
           super().__init__()
           lowercase__		       =						pad_token_id
           lowercase__		       =						max_length
           lowercase__		       =						vocab
           lowercase__		       =						merges
           lowercase__		       =						BytePairTokenizer(UpperCAmelCase_     ,UpperCAmelCase_     ,sequence_length=UpperCAmelCase_      )



       @classmethod
       def 							_a      (				cls     ,UpperCAmelCase_     ,*UpperCAmelCase_     ,**UpperCAmelCase_      )  ->							List[str]:
           lowercase__		       =						[" ".join(UpperCAmelCase_      ) for m in tokenizer.bpe_ranks.keys()]
           lowercase__		       =						tokenizer.get_vocab()
           return cls(UpperCAmelCase_     ,UpperCAmelCase_     ,*UpperCAmelCase_     ,**UpperCAmelCase_      )



       @classmethod
       def 							_a      (				cls     ,UpperCAmelCase_     ,*UpperCAmelCase_     ,**UpperCAmelCase_      )  ->							Optional[Any]:
           lowercase__		       =						GPTaTokenizer.from_pretrained(UpperCAmelCase_     ,*UpperCAmelCase_     ,**UpperCAmelCase_      )
           return cls.from_tokenizer(UpperCAmelCase_     ,*UpperCAmelCase_     ,**UpperCAmelCase_      )



       @classmethod
       def 							_a      (				cls     ,UpperCAmelCase_      )  ->							Optional[Any]:
           return cls(**UpperCAmelCase_      )



       def 							_a      (				self      )  ->							Tuple:
           return {
               "vocab": self.vocab,
               "merges": self.merges,
               "max_length": self.max_length,
               "pad_token_id": self.pad_token_id,
           }







       def 							_a      (				self     ,UpperCAmelCase_     ,UpperCAmelCase_ = None      )  ->							Tuple:
           lowercase__		       =						self.tf_tokenizer(UpperCAmelCase_      )
           lowercase__		       =						tf.ones_like(UpperCAmelCase_      )

           if self.pad_token_id is not None:
               # pad the tokens up to max length
               lowercase__		       =						max_length if max_length is not None else self.max_length

               if max_length is not None:
                   lowercase__       ,       lowercase__		       =						pad_model_inputs(
                       UpperCAmelCase_     ,max_seq_length=UpperCAmelCase_     ,pad_value=self.pad_token_id      )

           return {"attention_mask": attention_mask, "input_ids": input_ids}




