


import copy
from dataclasses import dataclass, field
from typing import ClassVar, Dict

from ..features import ClassLabel, Features, Image
from .base import TaskTemplate
@dataclass(frozen=SCREAMING_SNAKE_CASE_	)
class 	UpperCamelCase__					( SCREAMING_SNAKE_CASE_	):



     """simple docstring"""






     __magic_name__    			=    field(default="image-classification"    ,					metadata={"include_in_asdict_even_if_is_default": True}	)
     __magic_name__    			=    Features({"image": Image()}	)
     __magic_name__    			=    Features({"labels": ClassLabel}	)
     __magic_name__    			=    "image"
     __magic_name__    			=    "labels"







     def a	( self      ,	snake_case__   ):

            '''simple docstring'''

            if self.label_column not in features:
                   raise ValueError(F'Column {self.label_column} is not present in features.'   )
            if not isinstance(features[self.label_column]      ,	snake_case__   ):
                   raise ValueError(F'Column {self.label_column} is not a ClassLabel.'   )
            _lowerCAmelCase    :							Tuple   			=       copy.deepcopy(self   )
            _lowerCAmelCase    :							Dict   			=       self.label_schema.copy()
            _lowerCAmelCase    :							Union[str, Any]   			=       features[self.label_column]
            _lowerCAmelCase    :							List[Any]   			=       label_schema
            return task_template







     @property
     def a	( self   ):

            '''simple docstring'''

            return {
                self.image_column: "image",
                self.label_column: "labels",
            }





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


lowerCAmelCase    :     str					=						logging.get_logger(__name__)

# General docstring
lowerCAmelCase    :     Optional[Any]					=						"""RegNetConfig"""

# Base docstring
lowerCAmelCase    :     int					=						"""facebook/regnet-y-040"""
lowerCAmelCase    :     Optional[Any]					=						[1, 10_88, 7, 7]

# Image classification docstring
lowerCAmelCase    :     Any					=						"""facebook/regnet-y-040"""
lowerCAmelCase    :     Optional[Any]					=						"""tabby, tabby cat"""

lowerCAmelCase    :     Tuple					=						[
    """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      ,	snake_case__      ,	snake_case__ = 3      ,	snake_case__ = 1      ,	snake_case__ = 1      ,	snake_case__ = "relu"      ,	**snake_case__      ,	):

            '''simple docstring'''

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







     def a	( self      ,	snake_case__   ):

            '''simple docstring'''

            _lowerCAmelCase    :							Any   			=       self.convolution(self.padding(snake_case__   )   )
            _lowerCAmelCase    :							Union[str, Any]   			=       self.normalization(snake_case__   )
            _lowerCAmelCase    :							int   			=       self.activation(snake_case__   )
            return hidden_state
class 	UpperCamelCase__					( tf.keras.layers.Layer	):



     """simple docstring"""






     def __init__( self      ,	snake_case__      ,	**snake_case__   ):

            '''simple docstring'''

            super().__init__(**snake_case__   )
            _lowerCAmelCase    :							str   			=       config.num_channels
            _lowerCAmelCase    :							List[Any]   			=       TFRegNetConvLayer(
                out_channels=config.embedding_size      ,	kernel_size=3      ,	stride=2      ,	activation=config.hidden_act      ,	name='embedder'      ,	)







     def a	( self      ,	snake_case__   ):

            '''simple docstring'''

            _lowerCAmelCase    :							Optional[Any]   			=       shape_list(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(snake_case__      ,	perm=(0, 2, 3, 1)   )
            _lowerCAmelCase    :							Tuple   			=       self.embedder(snake_case__   )
            return hidden_state
class 	UpperCamelCase__					( tf.keras.layers.Layer	):



     """simple docstring"""






     def __init__( self      ,	snake_case__      ,	snake_case__ = 2      ,	**snake_case__   ):

            '''simple docstring'''

            super().__init__(**snake_case__   )
            _lowerCAmelCase    :							Union[str, Any]   			=       tf.keras.layers.ConvaD(
                filters=snake_case__      ,	kernel_size=1      ,	strides=snake_case__      ,	use_bias=snake_case__      ,	name='convolution'   )
            _lowerCAmelCase    :							Tuple   			=       tf.keras.layers.BatchNormalization(epsilon=1E-5      ,	momentum=0.9      ,	name='normalization'   )







     def a	( self      ,	snake_case__      ,	snake_case__ = False   ):

            '''simple docstring'''

            return self.normalization(self.convolution(snake_case__   )      ,	training=snake_case__   )
class 	UpperCamelCase__					( tf.keras.layers.Layer	):



     """simple docstring"""






     def __init__( self      ,	snake_case__      ,	snake_case__      ,	**snake_case__   ):

            '''simple docstring'''

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







     def a	( self      ,	snake_case__   ):

            '''simple docstring'''

            _lowerCAmelCase    :							Any   			=       self.pooler(snake_case__   )
            for layer_module in self.attention:
                   _lowerCAmelCase    :							Tuple   			=       layer_module(snake_case__   )
            _lowerCAmelCase    :							Optional[Any]   			=       hidden_state * pooled
            return hidden_state
class 	UpperCamelCase__					( tf.keras.layers.Layer	):



     """simple docstring"""






     def __init__( self      ,	snake_case__      ,	snake_case__      ,	snake_case__      ,	snake_case__ = 1      ,	**snake_case__   ):

            '''simple docstring'''

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







     def a	( self      ,	snake_case__   ):

            '''simple docstring'''

            _lowerCAmelCase    :							Optional[Any]   			=       hidden_state
            for layer_module in self.layers:
                   _lowerCAmelCase    :							int   			=       layer_module(snake_case__   )
            _lowerCAmelCase    :							int   			=       self.shortcut(snake_case__   )
            hidden_state += residual
            _lowerCAmelCase    :							Tuple   			=       self.activation(snake_case__   )
            return hidden_state
class 	UpperCamelCase__					( tf.keras.layers.Layer	):



     """simple docstring"""






     def __init__( self      ,	snake_case__      ,	snake_case__      ,	snake_case__      ,	snake_case__ = 1      ,	**snake_case__   ):

            '''simple docstring'''

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







     def a	( self      ,	snake_case__   ):

            '''simple docstring'''

            _lowerCAmelCase    :							Dict   			=       hidden_state
            for layer_module in self.layers:
                   _lowerCAmelCase    :							List[Any]   			=       layer_module(snake_case__   )
            _lowerCAmelCase    :							Tuple   			=       self.shortcut(snake_case__   )
            hidden_state += residual
            _lowerCAmelCase    :							str   			=       self.activation(snake_case__   )
            return hidden_state
class 	UpperCamelCase__					( tf.keras.layers.Layer	):



     """simple docstring"""






     def __init__( self      ,	snake_case__      ,	snake_case__      ,	snake_case__      ,	snake_case__ = 2      ,	snake_case__ = 2      ,	**snake_case__   ):

            '''simple docstring'''

            super().__init__(**snake_case__   )

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







     def a	( self      ,	snake_case__   ):

            '''simple docstring'''

            for layer_module in self.layers:
                   _lowerCAmelCase    :							int   			=       layer_module(snake_case__   )
            return hidden_state
class 	UpperCamelCase__					( tf.keras.layers.Layer	):



     """simple docstring"""






     def __init__( self      ,	snake_case__      ,	**snake_case__   ):

            '''simple docstring'''

            super().__init__(**snake_case__   )
            _lowerCAmelCase    :							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(
                    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    :							Union[str, Any]   			=       zip(config.hidden_sizes      ,	config.hidden_sizes[1:]   )
            for i, ((in_channels, out_channels), depth) in enumerate(zip(snake_case__      ,	config.depths[1:]   )   ):
                   self.stages.append(TFRegNetStage(snake_case__      ,	snake_case__      ,	snake_case__      ,	depth=snake_case__      ,	name=F'stages.{i+1}'   )   )







     def a	( self      ,	snake_case__      ,	snake_case__ = False      ,	snake_case__ = True   ):

            '''simple docstring'''

            _lowerCAmelCase    :							List[Any]   			=       () if output_hidden_states else None

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

                   _lowerCAmelCase    :							List[str]   			=       stage_module(snake_case__   )

            if output_hidden_states:
                   _lowerCAmelCase    :							Dict   			=       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=snake_case__      ,	hidden_states=snake_case__   )
@keras_serializable
class 	UpperCamelCase__					( tf.keras.layers.Layer	):



     """simple docstring"""






     __magic_name__    			=    RegNetConfig







     def __init__( self      ,	snake_case__      ,	**snake_case__   ):

            '''simple docstring'''

            super().__init__(**snake_case__   )
            _lowerCAmelCase    :							Union[str, Any]   			=       config
            _lowerCAmelCase    :							Union[str, Any]   			=       TFRegNetEmbeddings(snake_case__      ,	name='embedder'   )
            _lowerCAmelCase    :							Optional[int]   			=       TFRegNetEncoder(snake_case__      ,	name='encoder'   )
            _lowerCAmelCase    :							Dict   			=       tf.keras.layers.GlobalAveragePoolingaD(keepdims=snake_case__      ,	name='pooler'   )







     @unpack_inputs
     def a	( self      ,	snake_case__      ,	snake_case__ = None      ,	snake_case__ = None      ,	snake_case__ = False      ,	):

            '''simple docstring'''

            _lowerCAmelCase    :							Tuple   			=       (
                output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
            )
            _lowerCAmelCase    :							Optional[Any]   			=       return_dict if return_dict is not None else self.config.use_return_dict

            _lowerCAmelCase    :							int   			=       self.embedder(snake_case__      ,	training=snake_case__   )

            _lowerCAmelCase    :							List[str]   			=       self.encoder(
                snake_case__      ,	output_hidden_states=snake_case__      ,	return_dict=snake_case__      ,	training=snake_case__   )

            _lowerCAmelCase    :							List[Any]   			=       encoder_outputs[0]
            _lowerCAmelCase    :							Tuple   			=       self.pooler(snake_case__   )

            # Change to NCHW output format have uniformity in the modules
            _lowerCAmelCase    :							Optional[int]   			=       tf.transpose(snake_case__      ,	perm=(0, 3, 1, 2)   )
            _lowerCAmelCase    :							Optional[Any]   			=       tf.transpose(snake_case__      ,	perm=(0, 3, 1, 2)   )

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



     """simple docstring"""






     __magic_name__    			=    RegNetConfig
     __magic_name__    			=    "regnet"
     __magic_name__    			=    "pixel_values"







     @property
     def a	( self   ):

            '''simple docstring'''

            return {"pixel_values": tf.TensorSpec(shape=(None, self.config.num_channels, 224, 224)      ,	dtype=tf.floataa   )}
lowerCAmelCase    :     List[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.
"""

lowerCAmelCase    :     Dict					=						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."    ,					SCREAMING_SNAKE_CASE_    ,					)
class 	UpperCamelCase__					( SCREAMING_SNAKE_CASE_	):



     """simple docstring"""






     def __init__( self      ,	snake_case__      ,	*snake_case__      ,	**snake_case__   ):

            '''simple docstring'''

            super().__init__(snake_case__      ,	*snake_case__      ,	**snake_case__   )
            _lowerCAmelCase    :							List[str]   			=       TFRegNetMainLayer(snake_case__      ,	name='regnet'   )







     @unpack_inputs
     @add_start_docstrings_to_model_forward(snake_case__   )
     @add_code_sample_docstrings(
         checkpoint=_CHECKPOINT_FOR_DOC      ,	output_type=snake_case__      ,	config_class=_CONFIG_FOR_DOC      ,	modality='vision'      ,	expected_output=_EXPECTED_OUTPUT_SHAPE      ,	)
     def a	( self      ,	snake_case__      ,	snake_case__ = None      ,	snake_case__ = None      ,	snake_case__=False      ,	):

            '''simple docstring'''

            _lowerCAmelCase    :							Optional[Any]   			=       (
                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    :							str   			=       self.regnet(
                pixel_values=snake_case__      ,	output_hidden_states=snake_case__      ,	return_dict=snake_case__      ,	training=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    "    ,					SCREAMING_SNAKE_CASE_    ,					)
class 	UpperCamelCase__					( SCREAMING_SNAKE_CASE_    ,					SCREAMING_SNAKE_CASE_	):



     """simple docstring"""






     def __init__( self      ,	snake_case__      ,	*snake_case__      ,	**snake_case__   ):

            '''simple docstring'''

            super().__init__(snake_case__      ,	*snake_case__      ,	**snake_case__   )
            _lowerCAmelCase    :							Optional[Any]   			=       config.num_labels
            _lowerCAmelCase    :							Optional[Any]   			=       TFRegNetMainLayer(snake_case__      ,	name='regnet'   )
            # classification head
            _lowerCAmelCase    :							Optional[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(snake_case__   )
     @add_code_sample_docstrings(
         checkpoint=_IMAGE_CLASS_CHECKPOINT      ,	output_type=snake_case__      ,	config_class=_CONFIG_FOR_DOC      ,	expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT      ,	)
     def a	( self      ,	snake_case__ = None      ,	snake_case__ = None      ,	snake_case__ = None      ,	snake_case__ = None      ,	snake_case__=False      ,	):

            '''simple docstring'''

            _lowerCAmelCase    :							int   			=       (
                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    :							Dict   			=       self.regnet(
                snake_case__      ,	output_hidden_states=snake_case__      ,	return_dict=snake_case__      ,	training=snake_case__   )

            _lowerCAmelCase    :							Optional[Any]   			=       outputs.pooler_output if return_dict else outputs[1]

            _lowerCAmelCase    :							List[Any]   			=       self.classifier[0](snake_case__   )
            _lowerCAmelCase    :							Tuple   			=       self.classifier[1](snake_case__   )

            _lowerCAmelCase    :							int   			=       None if labels is None else self.hf_compute_loss(labels=snake_case__      ,	logits=snake_case__   )

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

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

