





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:	str = logging.get_logger(__name__)

# General docstring
__UpperCamelCase:	List[Any] = """RegNetConfig"""

# Base docstring
__UpperCamelCase:	Any = """facebook/regnet-y-040"""
__UpperCamelCase:	List[Any] = [1, 1_0_8_8, 7, 7]

# Image classification docstring
__UpperCamelCase:	int = """facebook/regnet-y-040"""
__UpperCamelCase:	str = """tabby, tabby cat"""

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


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


	'''simple docstring'''





	def __init__(						self:						Optional[Any],					lowerCamelCase_:						int,					lowerCamelCase_:						int = 3,					lowerCamelCase_:						int = 1,					lowerCamelCase_:						int = 1,					lowerCamelCase_:						Optional[str] = "relu",					**lowerCamelCase_:						int,					):
			super().__init__(**lowerCamelCase_			)
			# 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__					:      Union[str, Any]      =		tf.keras.layers.ConvaD(
			    filters=lowerCamelCase_,					kernel_size=lowerCamelCase_,					strides=lowerCamelCase_,					padding='VALID',					groups=lowerCamelCase_,					use_bias=lowerCamelCase_,					name='convolution',					)
			lowercase__					:      Any      =		tf.keras.layers.BatchNormalization(epsilon=1E-5,					momentum=0.9,					name='normalization'			)
			lowercase__					:      str      =		ACTaFN[activation] if activation is not None else tf.identity





	def    snake_case__(						self:						Optional[int],					lowerCamelCase_:						List[str]			):
			lowercase__					:      Union[str, Any]      =		self.convolution(self.padding(lowerCamelCase_			)			)
			lowercase__					:      List[str]      =		self.normalization(lowerCamelCase_			)
			lowercase__					:      Optional[int]      =		self.activation(lowerCamelCase_			)
			return hidden_state


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


	'''simple docstring'''





	def __init__(						self:						str,					lowerCamelCase_:						RegNetConfig,					**lowerCamelCase_:						List[Any]			):
			super().__init__(**lowerCamelCase_			)
			lowercase__					:      Tuple      =		config.num_channels
			lowercase__					:      Tuple      =		TFRegNetConvLayer(
			    out_channels=config.embedding_size,					kernel_size=3,					stride=2,					activation=config.hidden_act,					name='embedder',					)





	def    snake_case__(						self:						Union[str, Any],					lowerCamelCase_:						Any			):
			lowercase__					:      Optional[int]      =		shape_list(lowerCamelCase_			)[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__					:      Dict      =		tf.transpose(lowerCamelCase_,					perm=(0, 2, 3, 1)			)
			lowercase__					:      str      =		self.embedder(lowerCamelCase_			)
			return hidden_state


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


	'''simple docstring'''





	def __init__(						self:						List[str],					lowerCamelCase_:						int,					lowerCamelCase_:						int = 2,					**lowerCamelCase_:						Tuple			):
			super().__init__(**lowerCamelCase_			)
			lowercase__					:      int      =		tf.keras.layers.ConvaD(
			    filters=lowerCamelCase_,					kernel_size=1,					strides=lowerCamelCase_,					use_bias=lowerCamelCase_,					name='convolution'			)
			lowercase__					:      Optional[int]      =		tf.keras.layers.BatchNormalization(epsilon=1E-5,					momentum=0.9,					name='normalization'			)





	def    snake_case__(						self:						Optional[int],					lowerCamelCase_:						tf.Tensor,					lowerCamelCase_:						bool = False			):
			return self.normalization(self.convolution(lowerCamelCase_			),					training=lowerCamelCase_			)


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


	'''simple docstring'''





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





	def    snake_case__(						self:						Optional[int],					lowerCamelCase_:						Optional[Any]			):
			# [batch_size, h, w, num_channels] -> [batch_size, 1, 1, num_channels]
			lowercase__					:      int      =		self.pooler(lowerCamelCase_			)
			for layer_module in self.attention:
					lowercase__					:      List[str]      =		layer_module(lowerCamelCase_			)
			lowercase__					:      int      =		hidden_state * pooled
			return hidden_state


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


	'''simple docstring'''





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





	def    snake_case__(						self:						Optional[Any],					lowerCamelCase_:						Optional[Any]			):
			lowercase__					:      Any      =		hidden_state
			for layer_module in self.layers:
					lowercase__					:      List[Any]      =		layer_module(lowerCamelCase_			)
			lowercase__					:      Optional[Any]      =		self.shortcut(lowerCamelCase_			)
			hidden_state += residual
			lowercase__					:      str      =		self.activation(lowerCamelCase_			)
			return hidden_state


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


	'''simple docstring'''





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





	def    snake_case__(						self:						str,					lowerCamelCase_:						Union[str, Any]			):
			lowercase__					:      List[Any]      =		hidden_state
			for layer_module in self.layers:
					lowercase__					:      List[Any]      =		layer_module(lowerCamelCase_			)
			lowercase__					:      List[Any]      =		self.shortcut(lowerCamelCase_			)
			hidden_state += residual
			lowercase__					:      Dict      =		self.activation(lowerCamelCase_			)
			return hidden_state


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


	'''simple docstring'''





	def __init__(						self:						int,					lowerCamelCase_:						RegNetConfig,					lowerCamelCase_:						int,					lowerCamelCase_:						int,					lowerCamelCase_:						int = 2,					lowerCamelCase_:						int = 2,					**lowerCamelCase_:						Tuple			):
			super().__init__(**lowerCamelCase_			)

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





	def    snake_case__(						self:						int,					lowerCamelCase_:						Union[str, Any]			):
			for layer_module in self.layers:
					lowercase__					:      Tuple      =		layer_module(lowerCamelCase_			)
			return hidden_state


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


	'''simple docstring'''





	def __init__(						self:						Any,					lowerCamelCase_:						RegNetConfig,					**lowerCamelCase_:						List[str]			):
			super().__init__(**lowerCamelCase_			)
			lowercase__					:      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(
			        lowerCamelCase_,					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__					:      List[Any]      =		zip(config.hidden_sizes,					config.hidden_sizes[1:]			)
			for i, ((in_channels, out_channels), depth) in enumerate(zip(lowerCamelCase_,					config.depths[1:]			)			):
					self.stages.append(TFRegNetStage(lowerCamelCase_,					lowerCamelCase_,					lowerCamelCase_,					depth=lowerCamelCase_,					name=F"""stages.{i+1}"""			)			)





	def    snake_case__(						self:						Dict,					lowerCamelCase_:						tf.Tensor,					lowerCamelCase_:						bool = False,					lowerCamelCase_:						bool = True			):
			lowercase__					:      Dict      =		() if output_hidden_states else None

			for stage_module in self.stages:
					if output_hidden_states:
							lowercase__					:      Union[str, Any]      =		hidden_states + (hidden_state,)

					lowercase__					:      Optional[Any]      =		stage_module(lowerCamelCase_			)

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


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


	'''simple docstring'''





	_A													=				RegNetConfig

	def __init__(						self:						Dict,					lowerCamelCase_:						Dict,					**lowerCamelCase_:						Any			):
			super().__init__(**lowerCamelCase_			)
			lowercase__					:      str      =		config
			lowercase__					:      List[Any]      =		TFRegNetEmbeddings(lowerCamelCase_,					name='embedder'			)
			lowercase__					:      Tuple      =		TFRegNetEncoder(lowerCamelCase_,					name='encoder'			)
			lowercase__					:      Any      =		tf.keras.layers.GlobalAveragePoolingaD(keepdims=lowerCamelCase_,					name='pooler'			)





	@unpack_inputs
	def    snake_case__(						self:						Any,					lowerCamelCase_:						tf.Tensor,					lowerCamelCase_:						Optional[bool] = None,					lowerCamelCase_:						Optional[bool] = None,					lowerCamelCase_:						bool = False,					):
			lowercase__					:      Optional[int]      =		(
			    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
			)
			lowercase__					:      Tuple      =		return_dict if return_dict is not None else self.config.use_return_dict

			lowercase__					:      Tuple      =		self.embedder(lowerCamelCase_,					training=lowerCamelCase_			)

			lowercase__					:      Any      =		self.encoder(
			    lowerCamelCase_,					output_hidden_states=lowerCamelCase_,					return_dict=lowerCamelCase_,					training=lowerCamelCase_			)

			lowercase__					:      str      =		encoder_outputs[0]
			lowercase__					:      Union[str, Any]      =		self.pooler(lowerCamelCase_			)

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

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


class       __lowerCAmelCase					(       _UpperCamelCase      ):


	'''simple docstring'''





	_A													=				RegNetConfig
	_A													=				"regnet"
	_A													=				"pixel_values"

	@property
	def    snake_case__(						self:						Tuple			):
			return {"pixel_values": tf.TensorSpec(shape=(None, self.config.num_channels, 224, 224),					dtype=tf.floataa			)}
__UpperCamelCase:	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.
"""

__UpperCamelCase:	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."   ,    _UpperCamelCase   ,    )
class       __lowerCAmelCase					(       _UpperCamelCase      ):


	'''simple docstring'''





	def __init__(						self:						str,					lowerCamelCase_:						RegNetConfig,					*lowerCamelCase_:						List[str],					**lowerCamelCase_:						Union[str, Any]			):
			super().__init__(lowerCamelCase_,					*lowerCamelCase_,					**lowerCamelCase_			)
			lowercase__					:      List[Any]      =		TFRegNetMainLayer(lowerCamelCase_,					name='regnet'			)





	@unpack_inputs
	@add_start_docstrings_to_model_forward(lowerCamelCase_			)
	@add_code_sample_docstrings(
	    checkpoint=_CHECKPOINT_FOR_DOC,					output_type=lowerCamelCase_,					config_class=_CONFIG_FOR_DOC,					modality='vision',					expected_output=_EXPECTED_OUTPUT_SHAPE,					)
	def    snake_case__(						self:						List[Any],					lowerCamelCase_:						tf.Tensor,					lowerCamelCase_:						Optional[bool] = None,					lowerCamelCase_:						Optional[bool] = None,					lowerCamelCase_:						Any=False,					):
			lowercase__					:      Union[str, Any]      =		(
			    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
			)
			lowercase__					:      Optional[int]      =		return_dict if return_dict is not None else self.config.use_return_dict

			lowercase__					:      List[str]      =		self.regnet(
			    pixel_values=lowerCamelCase_,					output_hidden_states=lowerCamelCase_,					return_dict=lowerCamelCase_,					training=lowerCamelCase_,					)
			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       __lowerCAmelCase					(       _UpperCamelCase   ,    _UpperCamelCase      ):


	'''simple docstring'''





	def __init__(						self:						Union[str, Any],					lowerCamelCase_:						RegNetConfig,					*lowerCamelCase_:						int,					**lowerCamelCase_:						Any			):
			super().__init__(lowerCamelCase_,					*lowerCamelCase_,					**lowerCamelCase_			)
			lowercase__					:      Union[str, Any]      =		config.num_labels
			lowercase__					:      List[str]      =		TFRegNetMainLayer(lowerCamelCase_,					name='regnet'			)
			# classification head
			lowercase__					:      Dict      =		[
			    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(lowerCamelCase_			)
	@add_code_sample_docstrings(
	    checkpoint=_IMAGE_CLASS_CHECKPOINT,					output_type=lowerCamelCase_,					config_class=_CONFIG_FOR_DOC,					expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT,					)
	def    snake_case__(						self:						int,					lowerCamelCase_:						tf.Tensor = None,					lowerCamelCase_:						tf.Tensor = None,					lowerCamelCase_:						bool = None,					lowerCamelCase_:						bool = None,					lowerCamelCase_:						Tuple=False,					):
			lowercase__					:      Optional[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__					:      Union[str, Any]      =		self.regnet(
			    lowerCamelCase_,					output_hidden_states=lowerCamelCase_,					return_dict=lowerCamelCase_,					training=lowerCamelCase_			)

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

			lowercase__					:      str      =		self.classifier[0](lowerCamelCase_			)
			lowercase__					:      Optional[int]      =		self.classifier[1](lowerCamelCase_			)

			lowercase__					:      str      =		None if labels is None else self.hf_compute_loss(labels=lowerCamelCase_,					logits=lowerCamelCase_			)

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

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









import numpy as np
from sklearn.datasets import fetch_california_housing
from sklearn.metrics import mean_absolute_error, mean_squared_error
from sklearn.model_selection import train_test_split
from xgboost import XGBRegressor


def       SCREAMING_SNAKE_CASE__  (       _lowercase     : dict			)   ->							tuple:




		'''simple docstring'''
		return (data["data"], data["target"])


def       SCREAMING_SNAKE_CASE__  (       _lowercase     : np.ndarray   ,    _lowercase     : np.ndarray   ,    _lowercase     : np.ndarray			)   ->							np.ndarray:




		'''simple docstring'''
		lowercase__					:      List[str]      =		XGBRegressor(verbosity=0   ,    random_state=42			)
		xgb.fit(_lowercase   ,    _lowercase			)
		# Predict target for test data
		lowercase__					:      Union[str, Any]      =		xgb.predict(_lowercase			)
		lowercase__					:      Tuple      =		predictions.reshape(len(_lowercase			)   ,    1			)
		return predictions


def       SCREAMING_SNAKE_CASE__  (       )   ->							None:




		'''simple docstring'''
		lowercase__					:      List[str]      =		fetch_california_housing()
		lowercase__   ,				lowercase__					:      Optional[int]      =		data_handling(_lowercase			)
		lowercase__   ,				lowercase__   ,				lowercase__   ,				lowercase__					:      Optional[Any]      =		train_test_split(
		    _lowercase   ,    _lowercase   ,    test_size=0.25   ,    random_state=1			)
		lowercase__					:      Any      =		xgboost(_lowercase   ,    _lowercase   ,    _lowercase			)
		# Error printing
		print(f"""Mean Absolute Error : {mean_absolute_error(_lowercase   ,    _lowercase			)}"""			)
		print(f"""Mean Square Error  : {mean_squared_error(_lowercase   ,    _lowercase			)}"""			)


if __name__ == "__main__":
			import doctest

			doctest.testmod(verbose=True)
			main()


