

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

# General docstring
a__				=		'RegNetConfig'

# Base docstring
a__				=		'facebook/regnet-y-040'
a__				=		[1, 1088, 7, 7]

# Image classification docstring
a__				=		'facebook/regnet-y-040'
a__				=		'tabby, tabby cat'

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




							def 				__lowercase				(			self       ,							_a       )    ->    Optional[int]:
												_a	:    List[str]         =		self.convolution(self.padding(_a       )       )
												_a	:    Dict         =		self.normalization(_a       )
												_a	:    Union[str, Any]         =		self.activation(_a       )
												return hidden_state



class 				UpperCAmelCase_		(			tf.keras.layers.Layer   ):
							"""simple docstring"""







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




							def 				__lowercase				(			self       ,							_a       )    ->    Optional[Any]:
												_a	:    int         =		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)
												_a	:    List[str]         =		tf.transpose(_a       ,							perm=(0, 2, 3, 1)       )
												_a	:    List[str]         =		self.embedder(_a       )
												return hidden_state



class 				UpperCAmelCase_		(			tf.keras.layers.Layer   ):
							"""simple docstring"""







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




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



class 				UpperCAmelCase_		(			tf.keras.layers.Layer   ):
							"""simple docstring"""







							def __init__(			self       ,							_a       ,							_a       ,							**_a       )    ->    List[str]:
												super().__init__(**_a       )
												_a	:    Dict         =		tf.keras.layers.GlobalAveragePoolingaD(keepdims=_a       ,							name='''pooler'''       )
												_a	:    Tuple         =		[
												    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 				__lowercase				(			self       ,							_a       )    ->    Tuple:
												# [batch_size, h, w, num_channels] -> [batch_size, 1, 1, num_channels]
												_a	:    Optional[int]         =		self.pooler(_a       )
												for layer_module in self.attention:
																	_a	:    str         =		layer_module(_a       )
												_a	:    Union[str, Any]         =		hidden_state * pooled
												return hidden_state



class 				UpperCAmelCase_		(			tf.keras.layers.Layer   ):
							"""simple docstring"""







							def __init__(			self       ,							_a       ,							_a       ,							_a       ,							_a = 1       ,							**_a       )    ->    List[Any]:
												super().__init__(**_a       )
												_a	:    Union[str, Any]         =		in_channels != out_channels or stride != 1
												_a	:    Union[str, Any]         =		max(1       ,							out_channels // config.groups_width       )
												_a	:    Any         =		(
												    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.
												_a	:    Tuple         =		[
												    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'''       ),
												]
												_a	:    List[Any]         =		ACTaFN[config.hidden_act]




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



class 				UpperCAmelCase_		(			tf.keras.layers.Layer   ):
							"""simple docstring"""







							def __init__(			self       ,							_a       ,							_a       ,							_a       ,							_a = 1       ,							**_a       )    ->    int:
												super().__init__(**_a       )
												_a	:    Dict         =		in_channels != out_channels or stride != 1
												_a	:    Any         =		max(1       ,							out_channels // config.groups_width       )
												_a	:    Optional[int]         =		(
												    TFRegNetShortCut(_a       ,							stride=_a       ,							name='''shortcut'''       )
												    if should_apply_shortcut
												    else tf.keras.layers.Activation('''linear'''       ,							name='''shortcut'''       )
												)
												_a	:    List[Any]         =		[
												    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'''       ),
												]
												_a	:    str         =		ACTaFN[config.hidden_act]




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



class 				UpperCAmelCase_		(			tf.keras.layers.Layer   ):
							"""simple docstring"""







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

												_a	:    Optional[int]         =		TFRegNetXLayer if config.layer_type == "x" else TFRegNetYLayer
												_a	:    Optional[Any]         =		[
												    # 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 				__lowercase				(			self       ,							_a       )    ->    Dict:
												for layer_module in self.layers:
																	_a	:    str         =		layer_module(_a       )
												return hidden_state



class 				UpperCAmelCase_		(			tf.keras.layers.Layer   ):
							"""simple docstring"""







							def __init__(			self       ,							_a       ,							**_a       )    ->    List[str]:
												super().__init__(**_a       )
												_a	:    Optional[Any]         =		[]
												# 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'''       ,							)       )
												_a	:    Optional[Any]         =		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 				__lowercase				(			self       ,							_a       ,							_a = False       ,							_a = True       )    ->    TFBaseModelOutputWithNoAttention:
												_a	:    Dict         =		() if output_hidden_states else None

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

																	_a	:    Tuple         =		stage_module(_a       )

												if output_hidden_states:
																	_a	:    Union[str, 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=_a       ,							hidden_states=_a       )



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







							UpperCAmelCase__       :						List[str]	    =    RegNetConfig


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




							@unpack_inputs
							def 				__lowercase				(			self       ,							_a       ,							_a = None       ,							_a = None       ,							_a = False       ,							)    ->    TFBaseModelOutputWithPoolingAndNoAttention:
												_a	:    int         =		(
												    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
												)
												_a	:    Tuple         =		return_dict if return_dict is not None else self.config.use_return_dict

												_a	:    Tuple         =		self.embedder(_a       ,							training=_a       )

												_a	:    int         =		self.encoder(
												    _a       ,							output_hidden_states=_a       ,							return_dict=_a       ,							training=_a       )

												_a	:    Tuple         =		encoder_outputs[0]
												_a	:    Tuple         =		self.pooler(_a       )

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

												# Change the other hidden state outputs to NCHW as well
												if output_hidden_states:
																	_a	:    Optional[int]         =		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 				UpperCAmelCase_		(			__lowercase   ):
							"""simple docstring"""







							UpperCAmelCase__       :						List[Any]	    =    RegNetConfig
							UpperCAmelCase__       :						Dict	    =    "regnet"
							UpperCAmelCase__       :						Tuple	    =    "pixel_values"


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



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

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

@add_start_docstrings(
    "The bare RegNet model outputting raw features without any specific head on top."				,       __lowercase				,       )
class 				UpperCAmelCase_		(			__lowercase   ):
							"""simple docstring"""







							def __init__(			self       ,							_a       ,							*_a       ,							**_a       )    ->    Dict:
												super().__init__(_a       ,							*_a       ,							**_a       )
												_a	:    int         =		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 				__lowercase				(			self       ,							_a       ,							_a = None       ,							_a = None       ,							_a=False       ,							)    ->    Union[TFBaseModelOutputWithPoolingAndNoAttention, Tuple[tf.Tensor]]:
												_a	:    Optional[Any]         =		(
												    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
												)
												_a	:    str         =		return_dict if return_dict is not None else self.config.use_return_dict

												_a	:    List[str]         =		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(
    "\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    "				,       __lowercase				,       )
class 				UpperCAmelCase_		(			__lowercase				,       __lowercase   ):
							"""simple docstring"""







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

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

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

												_a	:    str         =		self.classifier[0](_a       )
												_a	:    int         =		self.classifier[1](_a       )

												_a	:    Any         =		None if labels is None else self.hf_compute_loss(labels=_a       ,							logits=_a       )

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

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





from PIL import Image




def 	_SCREAMING_SNAKE_CASE					(		_lowerCamelCase :			Image						,  _lowerCamelCase :			int)					->    Image:






							'''simple docstring'''





							__UpperCamelCase	:   str			   =					(259 * (level + 255)) / (255 * (259 - level))

							def contrast(_lowerCamelCase :			int) -> int:
														return int(128 + factor * (c - 128))

							return img.point(_lowerCamelCase)


if __name__ == "__main__":
		# Load image
		with Image.open('image_data/lena.jpg') as img:
				# Change contrast to 170
				lowercase  :					Tuple													=       change_contrast(img, 170)
				cont_img.save('image_data/lena_high_contrast.png', format='png')