


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


A__		:					str												=  logging.get_logger(__name__)

# General docstring
A__		:					int												=  """RegNetConfig"""

# Base docstring
A__		:					Optional[Any]												=  """facebook/regnet-y-040"""
A__		:					List[str]												=  [1, 1088, 7, 7]

# Image classification docstring
A__		:					Any												=  """facebook/regnet-y-040"""
A__		:					Tuple												=  """tabby, tabby cat"""

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





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





    """simple docstring"""






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







    def       lowercase_				(							self			,     SCREAMING_SNAKE_CASE_	)				->     Optional[Any]:
         __lowerCamelCase   :	Any								=		self.convolution(self.padding(SCREAMING_SNAKE_CASE_	)	)
         __lowerCamelCase   :	Any								=		self.normalization(SCREAMING_SNAKE_CASE_	)
         __lowerCamelCase   :	str								=		self.activation(SCREAMING_SNAKE_CASE_	)
         return hidden_state







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





    """simple docstring"""






    def __init__(							self			,     SCREAMING_SNAKE_CASE_			,     **SCREAMING_SNAKE_CASE_	)				->     Any:
         super().__init__(**SCREAMING_SNAKE_CASE_	)
         __lowerCamelCase   :	Optional[Any]								=		config.num_channels
         __lowerCamelCase   :	Dict								=		TFRegNetConvLayer(
             out_channels=config.embedding_size			,     kernel_size=3			,     stride=2			,     activation=config.hidden_act			,     name='embedder'			,     )







    def       lowercase_				(							self			,     SCREAMING_SNAKE_CASE_	)				->     int:
         __lowerCamelCase   :	Union[str, Any]								=		shape_list(SCREAMING_SNAKE_CASE_	)[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)
         __lowerCamelCase   :	List[Any]								=		tf.transpose(SCREAMING_SNAKE_CASE_			,     perm=(0, 2, 3, 1)	)
         __lowerCamelCase   :	Tuple								=		self.embedder(SCREAMING_SNAKE_CASE_	)
         return hidden_state







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





    """simple docstring"""






    def __init__(							self			,     SCREAMING_SNAKE_CASE_			,     SCREAMING_SNAKE_CASE_ = 2			,     **SCREAMING_SNAKE_CASE_	)				->     Optional[Any]:
         super().__init__(**SCREAMING_SNAKE_CASE_	)
         __lowerCamelCase   :	Optional[int]								=		tf.keras.layers.ConvaD(
             filters=SCREAMING_SNAKE_CASE_			,     kernel_size=1			,     strides=SCREAMING_SNAKE_CASE_			,     use_bias=SCREAMING_SNAKE_CASE_			,     name='convolution'	)
         __lowerCamelCase   :	Dict								=		tf.keras.layers.BatchNormalization(epsilon=1E-5			,     momentum=0.9			,     name='normalization'	)







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







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





    """simple docstring"""






    def __init__(							self			,     SCREAMING_SNAKE_CASE_			,     SCREAMING_SNAKE_CASE_			,     **SCREAMING_SNAKE_CASE_	)				->     List[str]:
         super().__init__(**SCREAMING_SNAKE_CASE_	)
         __lowerCamelCase   :	Dict								=		tf.keras.layers.GlobalAveragePoolingaD(keepdims=SCREAMING_SNAKE_CASE_			,     name='pooler'	)
         __lowerCamelCase   :	List[Any]								=		[
             tf.keras.layers.ConvaD(filters=SCREAMING_SNAKE_CASE_			,     kernel_size=1			,     activation='relu'			,     name='attention.0'	),
             tf.keras.layers.ConvaD(filters=SCREAMING_SNAKE_CASE_			,     kernel_size=1			,     activation='sigmoid'			,     name='attention.2'	),
         ]







    def       lowercase_				(							self			,     SCREAMING_SNAKE_CASE_	)				->     Tuple:
         # [batch_size, h, w, num_channels] -> [batch_size, 1, 1, num_channels]
         __lowerCamelCase   :	int								=		self.pooler(SCREAMING_SNAKE_CASE_	)
         for layer_module in self.attention:
              __lowerCamelCase   :	Optional[Any]								=		layer_module(SCREAMING_SNAKE_CASE_	)
         __lowerCamelCase   :	Tuple								=		hidden_state * pooled
         return hidden_state







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





    """simple docstring"""






    def __init__(							self			,     SCREAMING_SNAKE_CASE_			,     SCREAMING_SNAKE_CASE_			,     SCREAMING_SNAKE_CASE_			,     SCREAMING_SNAKE_CASE_ = 1			,     **SCREAMING_SNAKE_CASE_	)				->     int:
         super().__init__(**SCREAMING_SNAKE_CASE_	)
         __lowerCamelCase   :	Any								=		in_channels != out_channels or stride != 1
         __lowerCamelCase   :	Union[str, Any]								=		max(1			,     out_channels // config.groups_width	)
         __lowerCamelCase   :	List[str]								=		(
             TFRegNetShortCut(SCREAMING_SNAKE_CASE_			,     stride=SCREAMING_SNAKE_CASE_			,     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.
         __lowerCamelCase   :	List[str]								=		[
             TFRegNetConvLayer(SCREAMING_SNAKE_CASE_			,     kernel_size=1			,     activation=config.hidden_act			,     name='layer.0'	),
             TFRegNetConvLayer(
                 SCREAMING_SNAKE_CASE_			,     stride=SCREAMING_SNAKE_CASE_			,     groups=SCREAMING_SNAKE_CASE_			,     activation=config.hidden_act			,     name='layer.1'	),
             TFRegNetConvLayer(SCREAMING_SNAKE_CASE_			,     kernel_size=1			,     activation=SCREAMING_SNAKE_CASE_			,     name='layer.2'	),
         ]
         __lowerCamelCase   :	Tuple								=		ACTaFN[config.hidden_act]







    def       lowercase_				(							self			,     SCREAMING_SNAKE_CASE_	)				->     List[Any]:
         __lowerCamelCase   :	List[str]								=		hidden_state
         for layer_module in self.layers:
              __lowerCamelCase   :	int								=		layer_module(SCREAMING_SNAKE_CASE_	)
         __lowerCamelCase   :	Optional[int]								=		self.shortcut(SCREAMING_SNAKE_CASE_	)
         hidden_state += residual
         __lowerCamelCase   :	Union[str, Any]								=		self.activation(SCREAMING_SNAKE_CASE_	)
         return hidden_state







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





    """simple docstring"""






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







    def       lowercase_				(							self			,     SCREAMING_SNAKE_CASE_	)				->     Any:
         __lowerCamelCase   :	Optional[Any]								=		hidden_state
         for layer_module in self.layers:
              __lowerCamelCase   :	List[str]								=		layer_module(SCREAMING_SNAKE_CASE_	)
         __lowerCamelCase   :	Optional[int]								=		self.shortcut(SCREAMING_SNAKE_CASE_	)
         hidden_state += residual
         __lowerCamelCase   :	List[Any]								=		self.activation(SCREAMING_SNAKE_CASE_	)
         return hidden_state







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





    """simple docstring"""






    def __init__(							self			,     SCREAMING_SNAKE_CASE_			,     SCREAMING_SNAKE_CASE_			,     SCREAMING_SNAKE_CASE_			,     SCREAMING_SNAKE_CASE_ = 2			,     SCREAMING_SNAKE_CASE_ = 2			,     **SCREAMING_SNAKE_CASE_	)				->     Optional[Any]:
         super().__init__(**SCREAMING_SNAKE_CASE_	)

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







    def       lowercase_				(							self			,     SCREAMING_SNAKE_CASE_	)				->     List[str]:
         for layer_module in self.layers:
              __lowerCamelCase   :	List[Any]								=		layer_module(SCREAMING_SNAKE_CASE_	)
         return hidden_state







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





    """simple docstring"""






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







    def       lowercase_				(							self			,     SCREAMING_SNAKE_CASE_			,     SCREAMING_SNAKE_CASE_ = False			,     SCREAMING_SNAKE_CASE_ = True	)				->     TFBaseModelOutputWithNoAttention:
         __lowerCamelCase   :	int								=		() if output_hidden_states else None

         for stage_module in self.stages:
              if output_hidden_states:
                   __lowerCamelCase   :	List[Any]								=		hidden_states + (hidden_state,)

              __lowerCamelCase   :	Union[str, Any]								=		stage_module(SCREAMING_SNAKE_CASE_	)

         if output_hidden_states:
              __lowerCamelCase   :	str								=		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=SCREAMING_SNAKE_CASE_			,     hidden_states=SCREAMING_SNAKE_CASE_	)







@keras_serializable
class    UpperCAmelCase_  (tf.keras.layers.Layer  ):





    """simple docstring"""






    lowerCamelCase  :					Union[str, Any]							     =			RegNetConfig







    def __init__(							self			,     SCREAMING_SNAKE_CASE_			,     **SCREAMING_SNAKE_CASE_	)				->     Dict:
         super().__init__(**SCREAMING_SNAKE_CASE_	)
         __lowerCamelCase   :	str								=		config
         __lowerCamelCase   :	List[Any]								=		TFRegNetEmbeddings(SCREAMING_SNAKE_CASE_			,     name='embedder'	)
         __lowerCamelCase   :	List[str]								=		TFRegNetEncoder(SCREAMING_SNAKE_CASE_			,     name='encoder'	)
         __lowerCamelCase   :	Optional[Any]								=		tf.keras.layers.GlobalAveragePoolingaD(keepdims=SCREAMING_SNAKE_CASE_			,     name='pooler'	)







    @unpack_inputs
    def       lowercase_				(							self			,     SCREAMING_SNAKE_CASE_			,     SCREAMING_SNAKE_CASE_ = None			,     SCREAMING_SNAKE_CASE_ = None			,     SCREAMING_SNAKE_CASE_ = False			,     )				->     TFBaseModelOutputWithPoolingAndNoAttention:
         __lowerCamelCase   :	List[str]								=		(
             output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
         )
         __lowerCamelCase   :	Any								=		return_dict if return_dict is not None else self.config.use_return_dict

         __lowerCamelCase   :	Optional[Any]								=		self.embedder(SCREAMING_SNAKE_CASE_			,     training=SCREAMING_SNAKE_CASE_	)

         __lowerCamelCase   :	List[str]								=		self.encoder(
             SCREAMING_SNAKE_CASE_			,     output_hidden_states=SCREAMING_SNAKE_CASE_			,     return_dict=SCREAMING_SNAKE_CASE_			,     training=SCREAMING_SNAKE_CASE_	)

         __lowerCamelCase   :	Optional[Any]								=		encoder_outputs[0]
         __lowerCamelCase   :	Optional[int]								=		self.pooler(SCREAMING_SNAKE_CASE_	)

         # Change to NCHW output format have uniformity in the modules
         __lowerCamelCase   :	Any								=		tf.transpose(SCREAMING_SNAKE_CASE_			,     perm=(0, 3, 1, 2)	)
         __lowerCamelCase   :	Tuple								=		tf.transpose(SCREAMING_SNAKE_CASE_			,     perm=(0, 3, 1, 2)	)

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







class    UpperCAmelCase_  (_UpperCAmelCase  ):





    """simple docstring"""






    lowerCamelCase  :					Optional[int]							     =			RegNetConfig
    lowerCamelCase  :					Any							     =			'regnet'
    lowerCamelCase  :					Union[str, Any]							     =			'pixel_values'







    @property
    def       lowercase_				(							self	)				->     str:
         return {"pixel_values": tf.TensorSpec(shape=(None, self.config.num_channels, 2_24, 2_24)			,     dtype=tf.floataa	)}







A__		:					Any												=  R"""
    Parameters:
    This model is a Tensorflow
    [tf.keras.layers.Layer](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Layer) sub-class. Use it as a
    regular Tensorflow Module and refer to the Tensorflow documentation for all matter related to general usage and
    behavior.
        config ([`RegNetConfig`]): Model configuration class with all the parameters of the model.
            Initializing with a config file does not load the weights associated with the model, only the
            configuration. Check out the [`~TFPreTrainedModel.from_pretrained`] method to load the model weights.
"""

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





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





    """simple docstring"""






    def __init__(							self			,     SCREAMING_SNAKE_CASE_			,     *SCREAMING_SNAKE_CASE_			,     **SCREAMING_SNAKE_CASE_	)				->     Optional[int]:
         super().__init__(SCREAMING_SNAKE_CASE_			,     *SCREAMING_SNAKE_CASE_			,     **SCREAMING_SNAKE_CASE_	)
         __lowerCamelCase   :	str								=		TFRegNetMainLayer(SCREAMING_SNAKE_CASE_			,     name='regnet'	)







    @unpack_inputs
    @add_start_docstrings_to_model_forward(SCREAMING_SNAKE_CASE_	)
    @add_code_sample_docstrings(
        checkpoint=_CHECKPOINT_FOR_DOC			,     output_type=SCREAMING_SNAKE_CASE_			,     config_class=_CONFIG_FOR_DOC			,     modality='vision'			,     expected_output=_EXPECTED_OUTPUT_SHAPE			,     )
    def       lowercase_				(							self			,     SCREAMING_SNAKE_CASE_			,     SCREAMING_SNAKE_CASE_ = None			,     SCREAMING_SNAKE_CASE_ = None			,     SCREAMING_SNAKE_CASE_=False			,     )				->     Union[TFBaseModelOutputWithPoolingAndNoAttention, Tuple[tf.Tensor]]:
         __lowerCamelCase   :	List[str]								=		(
             output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
         )
         __lowerCamelCase   :	List[str]								=		return_dict if return_dict is not None else self.config.use_return_dict

         __lowerCamelCase   :	str								=		self.regnet(
             pixel_values=SCREAMING_SNAKE_CASE_			,     output_hidden_states=SCREAMING_SNAKE_CASE_			,     return_dict=SCREAMING_SNAKE_CASE_			,     training=SCREAMING_SNAKE_CASE_			,     )
         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    UpperCAmelCase_  (_UpperCAmelCase					,		_UpperCAmelCase  ):





    """simple docstring"""






    def __init__(							self			,     SCREAMING_SNAKE_CASE_			,     *SCREAMING_SNAKE_CASE_			,     **SCREAMING_SNAKE_CASE_	)				->     Union[str, Any]:
         super().__init__(SCREAMING_SNAKE_CASE_			,     *SCREAMING_SNAKE_CASE_			,     **SCREAMING_SNAKE_CASE_	)
         __lowerCamelCase   :	int								=		config.num_labels
         __lowerCamelCase   :	str								=		TFRegNetMainLayer(SCREAMING_SNAKE_CASE_			,     name='regnet'	)
         # classification head
         __lowerCamelCase   :	int								=		[
             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(SCREAMING_SNAKE_CASE_	)
    @add_code_sample_docstrings(
        checkpoint=_IMAGE_CLASS_CHECKPOINT			,     output_type=SCREAMING_SNAKE_CASE_			,     config_class=_CONFIG_FOR_DOC			,     expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT			,     )
    def       lowercase_				(							self			,     SCREAMING_SNAKE_CASE_ = None			,     SCREAMING_SNAKE_CASE_ = None			,     SCREAMING_SNAKE_CASE_ = None			,     SCREAMING_SNAKE_CASE_ = None			,     SCREAMING_SNAKE_CASE_=False			,     )				->     Union[TFSequenceClassifierOutput, Tuple[tf.Tensor]]:
         __lowerCamelCase   :	Dict								=		(
             output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
         )
         __lowerCamelCase   :	str								=		return_dict if return_dict is not None else self.config.use_return_dict

         __lowerCamelCase   :	Tuple								=		self.regnet(
             SCREAMING_SNAKE_CASE_			,     output_hidden_states=SCREAMING_SNAKE_CASE_			,     return_dict=SCREAMING_SNAKE_CASE_			,     training=SCREAMING_SNAKE_CASE_	)

         __lowerCamelCase   :	Optional[int]								=		outputs.pooler_output if return_dict else outputs[1]

         __lowerCamelCase   :	str								=		self.classifier[0](SCREAMING_SNAKE_CASE_	)
         __lowerCamelCase   :	Union[str, Any]								=		self.classifier[1](SCREAMING_SNAKE_CASE_	)

         __lowerCamelCase   :	Union[str, Any]								=		None if labels is None else self.hf_compute_loss(labels=SCREAMING_SNAKE_CASE_			,     logits=SCREAMING_SNAKE_CASE_	)

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

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










'''simple docstring'''



from numpy import exp, pi, sqrt



def 			UpperCAmelCase__					(	UpperCAmelCase_    :				Optional[int]      ,    UpperCAmelCase_    :				float = 0.0      ,    UpperCAmelCase_    :				float = 1.0							)     ->		int:
     return 1 / sqrt(2 * pi * sigma**2							) * exp(-((x - mu) ** 2) / (2 * sigma**2)							)


if __name__ == "__main__":
      import doctest

      doctest.testmod()






