





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


UpperCAmelCase_							=				logging.get_logger(__name__)

# General docstring
UpperCAmelCase_							=				"""RegNetConfig"""

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

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

UpperCAmelCase_							=				[
    """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__,   )       -> Optional[int]:






									"""simple docstring"""
									super().__init__(**snake_case__  )
									# The padding and conv has been verified in
									# https://colab.research.google.com/gist/sayakpaul/854bc10eeaf21c9ee2119e0b9f3841a7/scratchpad.ipynb
									lowercase_	:   Tuple  				=     tf.keras.layers.ZeroPaddingaD(padding=kernel_size // 2  )
									lowercase_	:   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""",   )
									lowercase_	:   Optional[Any]  				=     tf.keras.layers.BatchNormalization(epsilon=1E-5,   momentum=0.9,   name="""normalization"""  )
									lowercase_	:   Dict  				=     ACTaFN[activation] if activation is not None else tf.identity






		def 						snake_case__				(							self,   snake_case__  )       -> int:






									"""simple docstring"""
									lowercase_	:   Any  				=     self.convolution(self.padding(snake_case__  )  )
									lowercase_	:   str  				=     self.normalization(snake_case__  )
									lowercase_	:   int  				=     self.activation(snake_case__  )
									return hidden_state




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






		'''simple docstring'''






		def __init__(							self,   snake_case__,   **snake_case__  )       -> Any:






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






		def 						snake_case__				(							self,   snake_case__  )       -> int:






									"""simple docstring"""
									lowercase_	:   Tuple  				=     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)
									lowercase_	:   List[Any]  				=     tf.transpose(snake_case__,   perm=(0, 2, 3, 1)  )
									lowercase_	:   Optional[int]  				=     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__  )       -> int:






									"""simple docstring"""
									super().__init__(**snake_case__  )
									lowercase_	:   List[Any]  				=     tf.keras.layers.ConvaD(
									    filters=snake_case__,   kernel_size=1,   strides=snake_case__,   use_bias=snake_case__,   name="""convolution"""  )
									lowercase_	:   Optional[Any]  				=     tf.keras.layers.BatchNormalization(epsilon=1E-5,   momentum=0.9,   name="""normalization"""  )






		def 						snake_case__				(							self,   snake_case__,   snake_case__ = False  )       -> tf.Tensor:






									"""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__  )       -> str:






									"""simple docstring"""
									super().__init__(**snake_case__  )
									lowercase_	:   int  				=     tf.keras.layers.GlobalAveragePoolingaD(keepdims=snake_case__,   name="""pooler"""  )
									lowercase_	:   List[Any]  				=     [
									    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 						snake_case__				(							self,   snake_case__  )       -> int:






									"""simple docstring"""
									# [batch_size, h, w, num_channels] -> [batch_size, 1, 1, num_channels]
									lowercase_	:   str  				=     self.pooler(snake_case__  )
									for layer_module in self.attention:
																lowercase_	:   Optional[int]  				=     layer_module(snake_case__  )
									lowercase_	:   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__  )       -> Optional[int]:






									"""simple docstring"""
									super().__init__(**snake_case__  )
									lowercase_	:   List[Any]  				=     in_channels != out_channels or stride != 1
									lowercase_	:   Union[str, Any]  				=     max(1,   out_channels // config.groups_width  )
									lowercase_	:   Optional[int]  				=     (
									    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.
									lowercase_	:   int  				=     [
									    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"""  ),
									]
									lowercase_	:   List[Any]  				=     ACTaFN[config.hidden_act]






		def 						snake_case__				(							self,   snake_case__  )       -> Dict:






									"""simple docstring"""
									lowercase_	:   Tuple  				=     hidden_state
									for layer_module in self.layers:
																lowercase_	:   str  				=     layer_module(snake_case__  )
									lowercase_	:   Optional[Any]  				=     self.shortcut(snake_case__  )
									hidden_state += residual
									lowercase_	:   Optional[int]  				=     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__  )       -> List[str]:






									"""simple docstring"""
									super().__init__(**snake_case__  )
									lowercase_	:   Union[str, Any]  				=     in_channels != out_channels or stride != 1
									lowercase_	:   Optional[Any]  				=     max(1,   out_channels // config.groups_width  )
									lowercase_	:   Optional[Any]  				=     (
									    TFRegNetShortCut(snake_case__,   stride=snake_case__,   name="""shortcut"""  )
									    if should_apply_shortcut
									    else tf.keras.layers.Activation("""linear""",   name="""shortcut"""  )
									)
									lowercase_	:   List[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"""  ),
									    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"""  ),
									]
									lowercase_	:   str  				=     ACTaFN[config.hidden_act]






		def 						snake_case__				(							self,   snake_case__  )       -> str:






									"""simple docstring"""
									lowercase_	:   Any  				=     hidden_state
									for layer_module in self.layers:
																lowercase_	:   int  				=     layer_module(snake_case__  )
									lowercase_	:   Any  				=     self.shortcut(snake_case__  )
									hidden_state += residual
									lowercase_	:   Optional[Any]  				=     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__  )       -> Tuple:






									"""simple docstring"""
									super().__init__(**snake_case__  )

									lowercase_	:   List[Any]  				=     TFRegNetXLayer if config.layer_type == """x""" else TFRegNetYLayer
									lowercase_	:   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 						snake_case__				(							self,   snake_case__  )       -> Union[str, Any]:






									"""simple docstring"""
									for layer_module in self.layers:
																lowercase_	:   Tuple  				=     layer_module(snake_case__  )
									return hidden_state




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






		'''simple docstring'''






		def __init__(							self,   snake_case__,   **snake_case__  )       -> Any:






									"""simple docstring"""
									super().__init__(**snake_case__  )
									lowercase_	:   Optional[int]  				=     []
									# 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""",   )  )
									lowercase_	:   Tuple  				=     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 						snake_case__				(							self,   snake_case__,   snake_case__ = False,   snake_case__ = True  )       -> TFBaseModelOutputWithNoAttention:






									"""simple docstring"""
									lowercase_	:   Union[str, Any]  				=     () if output_hidden_states else None

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

																lowercase_	:   str  				=     stage_module(snake_case__  )

									if output_hidden_states:
																lowercase_	:   Optional[Any]  				=     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'''






		__a       :       Optional[int]       =	RegNetConfig






		def __init__(							self,   snake_case__,   **snake_case__  )       -> List[str]:






									"""simple docstring"""
									super().__init__(**snake_case__  )
									lowercase_	:   Optional[Any]  				=     config
									lowercase_	:   Dict  				=     TFRegNetEmbeddings(snake_case__,   name="""embedder"""  )
									lowercase_	:   List[str]  				=     TFRegNetEncoder(snake_case__,   name="""encoder"""  )
									lowercase_	:   Any  				=     tf.keras.layers.GlobalAveragePoolingaD(keepdims=snake_case__,   name="""pooler"""  )






		@unpack_inputs
		def 						snake_case__				(							self,   snake_case__,   snake_case__ = None,   snake_case__ = None,   snake_case__ = False,   )       -> TFBaseModelOutputWithPoolingAndNoAttention:






									"""simple docstring"""
									lowercase_	:   Union[str, Any]  				=     (
									    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
									)
									lowercase_	:   List[str]  				=     return_dict if return_dict is not None else self.config.use_return_dict

									lowercase_	:   str  				=     self.embedder(snake_case__,   training=snake_case__  )

									lowercase_	:   Optional[Any]  				=     self.encoder(
									    snake_case__,   output_hidden_states=snake_case__,   return_dict=snake_case__,   training=snake_case__  )

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

									# Change to NCHW output format have uniformity in the modules
									lowercase_	:   str  				=     tf.transpose(snake_case__,   perm=(0, 3, 1, 2)  )
									lowercase_	:   str  				=     tf.transpose(snake_case__,   perm=(0, 3, 1, 2)  )

									# Change the other hidden state outputs to NCHW as well
									if output_hidden_states:
																lowercase_	:   List[str]  				=     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__					(     lowerCamelCase__				):






		'''simple docstring'''






		__a       :       List[str]       =	RegNetConfig
		__a       :       Optional[Any]       =	"""regnet"""
		__a       :       str       =	"""pixel_values"""






		@property
		def 						snake_case__				(							self  )       -> str:






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




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

UpperCAmelCase_							=				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."""				, lowerCamelCase__				, )
class     UpperCamelCase__					(     lowerCamelCase__				):






		'''simple docstring'''






		def __init__(							self,   snake_case__,   *snake_case__,   **snake_case__  )       -> Union[str, Any]:






									"""simple docstring"""
									super().__init__(snake_case__,   *snake_case__,   **snake_case__  )
									lowercase_	:   int  				=     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 						snake_case__				(							self,   snake_case__,   snake_case__ = None,   snake_case__ = None,   snake_case__=False,   )       -> Union[TFBaseModelOutputWithPoolingAndNoAttention, Tuple[tf.Tensor]]:






									"""simple docstring"""
									lowercase_	:   Optional[int]  				=     (
									    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
									)
									lowercase_	:   Dict  				=     return_dict if return_dict is not None else self.config.use_return_dict

									lowercase_	:   List[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(
    """
    RegNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for
    ImageNet.
    """				, lowerCamelCase__				, )
class     UpperCamelCase__					(     lowerCamelCase__				, lowerCamelCase__				):






		'''simple docstring'''






		def __init__(							self,   snake_case__,   *snake_case__,   **snake_case__  )       -> int:






									"""simple docstring"""
									super().__init__(snake_case__,   *snake_case__,   **snake_case__  )
									lowercase_	:   Union[str, Any]  				=     config.num_labels
									lowercase_	:   int  				=     TFRegNetMainLayer(snake_case__,   name="""regnet"""  )
									# classification head
									lowercase_	:   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 						snake_case__				(							self,   snake_case__ = None,   snake_case__ = None,   snake_case__ = None,   snake_case__ = None,   snake_case__=False,   )       -> Union[TFSequenceClassifierOutput, Tuple[tf.Tensor]]:






									"""simple docstring"""
									lowercase_	:   Optional[Any]  				=     (
									    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
									)
									lowercase_	:   str  				=     return_dict if return_dict is not None else self.config.use_return_dict

									lowercase_	:   str  				=     self.regnet(
									    snake_case__,   output_hidden_states=snake_case__,   return_dict=snake_case__,   training=snake_case__  )

									lowercase_	:   str  				=     outputs.pooler_output if return_dict else outputs[1]

									lowercase_	:   Optional[Any]  				=     self.classifier[0](snake_case__  )
									lowercase_	:   str  				=     self.classifier[1](snake_case__  )

									lowercase_	:   Dict  				=     None if labels is None else self.hf_compute_loss(labels=snake_case__,   logits=snake_case__  )

									if not return_dict:
																lowercase_	:   List[Any]  				=     (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  )






import pytest
import requests

from datasets.utils.file_utils import http_head

from .utils import OfflineSimulationMode, RequestWouldHangIndefinitelyError, offline





@pytest.mark.integration
def  __magic_name__  (				)				-> Union[str, Any]:

							"""simple docstring"""



							with offline(OfflineSimulationMode.CONNECTION_TIMES_OUT				):
														with pytest.raises(lowercase				):
																					requests.request("""GET"""				,       """https://huggingface.co"""				)
														with pytest.raises(requests.exceptions.ConnectTimeout				):
																					requests.request("""GET"""				,       """https://huggingface.co"""				,       timeout=1.0				)





@pytest.mark.integration
def  __magic_name__  (				)				-> Union[str, Any]:

							"""simple docstring"""



							with offline(OfflineSimulationMode.CONNECTION_FAILS				):
														with pytest.raises(requests.exceptions.ConnectionError				):
																					requests.request("""GET"""				,       """https://huggingface.co"""				)





def  __magic_name__  (				)				-> Dict:

							"""simple docstring"""



							with offline(OfflineSimulationMode.HF_DATASETS_OFFLINE_SET_TO_1				):
														with pytest.raises(lowercase				):
																					http_head("""https://huggingface.co"""				)