





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


lowercase_					= logging.get_logger(__name__)

# General docstring
lowercase_					= """RegNetConfig"""

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

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

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


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

    '''simple docstring'''


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





    def 			snake_case_(		self ,		A       )		->   str:
        _SCREAMING_SNAKE_CASE									=			self.convolution(self.padding(A       )       )
        _SCREAMING_SNAKE_CASE									=			self.normalization(A       )
        _SCREAMING_SNAKE_CASE									=			self.activation(A       )
        return hidden_state




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

    '''simple docstring'''


    def __init__(		self ,		A ,		**A       )		->   Optional[int]:
        super().__init__(**A       )
        _SCREAMING_SNAKE_CASE									=			config.num_channels
        _SCREAMING_SNAKE_CASE									=			TFRegNetConvLayer(
            out_channels=config.embedding_size ,		kernel_size=3 ,		stride=2 ,		activation=config.hidden_act ,		name="""embedder""" ,		)





    def 			snake_case_(		self ,		A       )		->   Union[str, Any]:
        _SCREAMING_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)
        _SCREAMING_SNAKE_CASE									=			tf.transpose(A ,		perm=(0, 2, 3, 1)       )
        _SCREAMING_SNAKE_CASE									=			self.embedder(A       )
        return hidden_state




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

    '''simple docstring'''


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





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




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

    '''simple docstring'''


    def __init__(		self ,		A ,		A ,		**A       )		->   str:
        super().__init__(**A       )
        _SCREAMING_SNAKE_CASE									=			tf.keras.layers.GlobalAveragePoolingaD(keepdims=A ,		name="""pooler"""       )
        _SCREAMING_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 			snake_case_(		self ,		A       )		->   Dict:
        # [batch_size, h, w, num_channels] -> [batch_size, 1, 1, num_channels]
        _SCREAMING_SNAKE_CASE									=			self.pooler(A       )
        for layer_module in self.attention:
            _SCREAMING_SNAKE_CASE									=			layer_module(A       )
        _SCREAMING_SNAKE_CASE									=			hidden_state * pooled
        return hidden_state




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

    '''simple docstring'''


    def __init__(		self ,		A ,		A ,		A ,		A = 1 ,		**A       )		->   int:
        super().__init__(**A       )
        _SCREAMING_SNAKE_CASE									=			in_channels != out_channels or stride != 1
        _SCREAMING_SNAKE_CASE									=			max(1 ,		out_channels // config.groups_width       )
        _SCREAMING_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.
        _SCREAMING_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"""       ),
        ]
        _SCREAMING_SNAKE_CASE									=			ACTaFN[config.hidden_act]





    def 			snake_case_(		self ,		A       )		->   Union[str, Any]:
        _SCREAMING_SNAKE_CASE									=			hidden_state
        for layer_module in self.layers:
            _SCREAMING_SNAKE_CASE									=			layer_module(A       )
        _SCREAMING_SNAKE_CASE									=			self.shortcut(A       )
        hidden_state += residual
        _SCREAMING_SNAKE_CASE									=			self.activation(A       )
        return hidden_state




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

    '''simple docstring'''


    def __init__(		self ,		A ,		A ,		A ,		A = 1 ,		**A       )		->   Tuple:
        super().__init__(**A       )
        _SCREAMING_SNAKE_CASE									=			in_channels != out_channels or stride != 1
        _SCREAMING_SNAKE_CASE									=			max(1 ,		out_channels // config.groups_width       )
        _SCREAMING_SNAKE_CASE									=			(
            TFRegNetShortCut(A ,		stride=A ,		name="""shortcut"""       )
            if should_apply_shortcut
            else tf.keras.layers.Activation("""linear""" ,		name="""shortcut"""       )
        )
        _SCREAMING_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"""       ),
        ]
        _SCREAMING_SNAKE_CASE									=			ACTaFN[config.hidden_act]





    def 			snake_case_(		self ,		A       )		->   Optional[int]:
        _SCREAMING_SNAKE_CASE									=			hidden_state
        for layer_module in self.layers:
            _SCREAMING_SNAKE_CASE									=			layer_module(A       )
        _SCREAMING_SNAKE_CASE									=			self.shortcut(A       )
        hidden_state += residual
        _SCREAMING_SNAKE_CASE									=			self.activation(A       )
        return hidden_state




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

    '''simple docstring'''


    def __init__(		self ,		A ,		A ,		A ,		A = 2 ,		A = 2 ,		**A       )		->   int:
        super().__init__(**A       )

        _SCREAMING_SNAKE_CASE									=			TFRegNetXLayer if config.layer_type == """x""" else TFRegNetYLayer
        _SCREAMING_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 			snake_case_(		self ,		A       )		->   Optional[Any]:
        for layer_module in self.layers:
            _SCREAMING_SNAKE_CASE									=			layer_module(A       )
        return hidden_state




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

    '''simple docstring'''


    def __init__(		self ,		A ,		**A       )		->   Tuple:
        super().__init__(**A       )
        _SCREAMING_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""" ,		)       )
        _SCREAMING_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 			snake_case_(		self ,		A ,		A = False ,		A = True       )		->   TFBaseModelOutputWithNoAttention:
        _SCREAMING_SNAKE_CASE									=			() if output_hidden_states else None

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

            _SCREAMING_SNAKE_CASE									=			stage_module(A       )

        if output_hidden_states:
            _SCREAMING_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 					a_     (				tf.keras.layers.Layer       ):

    '''simple docstring'''
    UpperCamelCase     = RegNetConfig


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





    @unpack_inputs
    def 			snake_case_(		self ,		A ,		A = None ,		A = None ,		A = False ,		)		->   TFBaseModelOutputWithPoolingAndNoAttention:
        _SCREAMING_SNAKE_CASE									=			(
            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
        )
        _SCREAMING_SNAKE_CASE									=			return_dict if return_dict is not None else self.config.use_return_dict

        _SCREAMING_SNAKE_CASE									=			self.embedder(A ,		training=A       )

        _SCREAMING_SNAKE_CASE									=			self.encoder(
            A ,		output_hidden_states=A ,		return_dict=A ,		training=A       )

        _SCREAMING_SNAKE_CASE									=			encoder_outputs[0]
        _SCREAMING_SNAKE_CASE									=			self.pooler(A       )

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

        # Change the other hidden state outputs to NCHW as well
        if output_hidden_states:
            _SCREAMING_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 					a_     (				snake_case_       ):

    '''simple docstring'''
    UpperCamelCase     = RegNetConfig
    UpperCamelCase     = '''regnet'''
    UpperCamelCase     = '''pixel_values'''


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




lowercase_					= 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.
"""

lowercase_					= 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.'''      ,    snake_case_      ,    )
class 					a_     (				snake_case_       ):

    '''simple docstring'''


    def __init__(		self ,		A ,		*A ,		**A       )		->   Any:
        super().__init__(A ,		*A ,		**A       )
        _SCREAMING_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 			snake_case_(		self ,		A ,		A = None ,		A = None ,		A=False ,		)		->   Union[TFBaseModelOutputWithPoolingAndNoAttention, Tuple[tf.Tensor]]:
        _SCREAMING_SNAKE_CASE									=			(
            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
        )
        _SCREAMING_SNAKE_CASE									=			return_dict if return_dict is not None else self.config.use_return_dict

        _SCREAMING_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(
    '''
    RegNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for
    ImageNet.
    '''      ,    snake_case_      ,    )
class 					a_     (				snake_case_      ,    snake_case_       ):

    '''simple docstring'''


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

        _SCREAMING_SNAKE_CASE									=			self.regnet(
            A ,		output_hidden_states=A ,		return_dict=A ,		training=A       )

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

        _SCREAMING_SNAKE_CASE									=			self.classifier[0](A       )
        _SCREAMING_SNAKE_CASE									=			self.classifier[1](A       )

        _SCREAMING_SNAKE_CASE									=			None if labels is None else self.hf_compute_loss(labels=A ,		logits=A       )

        if not return_dict:
            _SCREAMING_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       )










'''simple docstring'''

from typing import List

from .keymap import KEYMAP, get_character





def lowerCamelCase						(     __lowerCamelCase :    str    )						->Optional[int]:

    def decorator(__lowerCamelCase :    int    ):
        _SCREAMING_SNAKE_CASE									=			getattr(__lowerCamelCase					,       """handle_key"""					,       []    )
        handle += [key]
        setattr(__lowerCamelCase					,       """handle_key"""					,       __lowerCamelCase    )
        return func

    return decorator





def lowerCamelCase						(     *__lowerCamelCase :    List[str]    )						->Dict:

    def decorator(__lowerCamelCase :    int    ):
        _SCREAMING_SNAKE_CASE									=			getattr(__lowerCamelCase					,       """handle_key"""					,       []    )
        handle += keys
        setattr(__lowerCamelCase					,       """handle_key"""					,       __lowerCamelCase    )
        return func

    return decorator


class 					a_     (				snake_case_       ):

    '''simple docstring'''


    def __new__(		cls ,		A ,		A ,		A       )		->   int:
        _SCREAMING_SNAKE_CASE									=			super().__new__(cls ,		A ,		A ,		A       )
        if not hasattr(A ,		"""key_handler"""       ):
            setattr(A ,		"""key_handler""" ,		{}       )
        setattr(A ,		"""handle_input""" ,		KeyHandler.handle_input       )

        for value in attrs.values():
            _SCREAMING_SNAKE_CASE									=			getattr(A ,		"""handle_key""" ,		[]       )
            for key in handled_keys:
                _SCREAMING_SNAKE_CASE									=			value
        return new_cls





    @staticmethod
    def 			snake_case_(		cls       )		->   str:
        _SCREAMING_SNAKE_CASE									=			get_character()
        if char != KEYMAP["undefined"]:
            _SCREAMING_SNAKE_CASE									=			ord(A       )
        _SCREAMING_SNAKE_CASE									=			cls.key_handler.get(A       )
        if handler:
            _SCREAMING_SNAKE_CASE									=			char
            return handler(cls       )
        else:
            return None





def lowerCamelCase						(     cls :    Any    )						->Dict:
    return KeyHandler(cls.__name__					,       cls.__bases__					,       cls.__dict__.copy()    )



