





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


A   : Dict             =			logging.get_logger(__name__)

# General docstring
A   : Any             =			'RegNetConfig'

# Base docstring
A   : List[Any]             =			'facebook/regnet-y-040'
A   : Tuple             =			[1, 1_088, 7, 7]

# Image classification docstring
A   : int             =			'facebook/regnet-y-040'
A   : Optional[Any]             =			'tabby, tabby cat'

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







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


					def __init__(					self	:  str       ,     __snake_case	:  int       ,     __snake_case	:  int = 3       ,     __snake_case	:  int = 1       ,     __snake_case	:  int = 1       ,     __snake_case	:  Optional[str] = "relu"       ,     **__snake_case	:  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
											_snake_case:   List[Any]  					=		tf.keras.layers.ZeroPaddingaD(padding=kernel_size // 2       )
											_snake_case:   Optional[int]  					=		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'       ,     )
											_snake_case:   str  					=		tf.keras.layers.BatchNormalization(epsilon=1e-5       ,     momentum=0.9       ,     name='normalization'       )
											_snake_case:   int  					=		ACTaFN[activation] if activation is not None else tf.identity




					def    SCREAMING_SNAKE_CASE_		(					self	:  Optional[Any]       ,     __snake_case	:  Union[str, Any]       ):





											'''simple docstring'''





											_snake_case:   List[str]  					=		self.convolution(self.padding(__snake_case       )       )
											_snake_case:   Any  					=		self.normalization(__snake_case       )
											_snake_case:   Tuple  					=		self.activation(__snake_case       )
											return hidden_state







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


					def __init__(					self	:  Union[str, Any]       ,     __snake_case	:  RegNetConfig       ,     **__snake_case	:  int       ):





											'''simple docstring'''





											super().__init__(**__snake_case       )
											_snake_case:   Optional[int]  					=		config.num_channels
											_snake_case:   Optional[int]  					=		TFRegNetConvLayer(
											    out_channels=config.embedding_size       ,     kernel_size=3       ,     stride=2       ,     activation=config.hidden_act       ,     name='embedder'       ,     )




					def    SCREAMING_SNAKE_CASE_		(					self	:  List[Any]       ,     __snake_case	:  Optional[Any]       ):





											'''simple docstring'''





											_snake_case:   Dict  					=		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)
											_snake_case:   Any  					=		tf.transpose(__snake_case       ,     perm=(0, 2, 3, 1)       )
											_snake_case:   Dict  					=		self.embedder(__snake_case       )
											return hidden_state







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


					def __init__(					self	:  List[str]       ,     __snake_case	:  int       ,     __snake_case	:  int = 2       ,     **__snake_case	:  List[str]       ):





											'''simple docstring'''





											super().__init__(**__snake_case       )
											_snake_case:   int  					=		tf.keras.layers.ConvaD(
											    filters=__snake_case       ,     kernel_size=1       ,     strides=__snake_case       ,     use_bias=__snake_case       ,     name='convolution'       )
											_snake_case:   List[str]  					=		tf.keras.layers.BatchNormalization(epsilon=1e-5       ,     momentum=0.9       ,     name='normalization'       )




					def    SCREAMING_SNAKE_CASE_		(					self	:  Optional[int]       ,     __snake_case	:  tf.Tensor       ,     __snake_case	:  bool = False       ):





											'''simple docstring'''





											return self.normalization(self.convolution(__snake_case       )       ,     training=__snake_case       )







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


					def __init__(					self	:  Dict       ,     __snake_case	:  int       ,     __snake_case	:  int       ,     **__snake_case	:  Union[str, Any]       ):





											'''simple docstring'''





											super().__init__(**__snake_case       )
											_snake_case:   Union[str, Any]  					=		tf.keras.layers.GlobalAveragePoolingaD(keepdims=__snake_case       ,     name='pooler'       )
											_snake_case:   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    SCREAMING_SNAKE_CASE_		(					self	:  int       ,     __snake_case	:  Tuple       ):





											'''simple docstring'''





											_snake_case:   Tuple  					=		self.pooler(__snake_case       )
											for layer_module in self.attention:
																	_snake_case:   Any  					=		layer_module(__snake_case       )
											_snake_case:   List[Any]  					=		hidden_state * pooled
											return hidden_state







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


					def __init__(					self	:  List[Any]       ,     __snake_case	:  RegNetConfig       ,     __snake_case	:  int       ,     __snake_case	:  int       ,     __snake_case	:  int = 1       ,     **__snake_case	:  Tuple       ):





											'''simple docstring'''





											super().__init__(**__snake_case       )
											_snake_case:   Tuple  					=		in_channels != out_channels or stride != 1
											_snake_case:   str  					=		max(1       ,     out_channels // config.groups_width       )
											_snake_case:   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.
											_snake_case:   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'       ),
											    TFRegNetConvLayer(__snake_case       ,     kernel_size=1       ,     activation=__snake_case       ,     name='layer.2'       ),
											]
											_snake_case:   Optional[int]  					=		ACTaFN[config.hidden_act]




					def    SCREAMING_SNAKE_CASE_		(					self	:  Dict       ,     __snake_case	:  Optional[Any]       ):





											'''simple docstring'''





											_snake_case:   Union[str, Any]  					=		hidden_state
											for layer_module in self.layers:
																	_snake_case:   Tuple  					=		layer_module(__snake_case       )
											_snake_case:   Any  					=		self.shortcut(__snake_case       )
											hidden_state += residual
											_snake_case:   str  					=		self.activation(__snake_case       )
											return hidden_state







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


					def __init__(					self	:  Tuple       ,     __snake_case	:  RegNetConfig       ,     __snake_case	:  int       ,     __snake_case	:  int       ,     __snake_case	:  int = 1       ,     **__snake_case	:  Dict       ):





											'''simple docstring'''





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




					def    SCREAMING_SNAKE_CASE_		(					self	:  Dict       ,     __snake_case	:  Tuple       ):





											'''simple docstring'''





											_snake_case:   Union[str, Any]  					=		hidden_state
											for layer_module in self.layers:
																	_snake_case:   Optional[int]  					=		layer_module(__snake_case       )
											_snake_case:   Optional[int]  					=		self.shortcut(__snake_case       )
											hidden_state += residual
											_snake_case:   List[Any]  					=		self.activation(__snake_case       )
											return hidden_state







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


					def __init__(					self	:  Any       ,     __snake_case	:  RegNetConfig       ,     __snake_case	:  int       ,     __snake_case	:  int       ,     __snake_case	:  int = 2       ,     __snake_case	:  int = 2       ,     **__snake_case	:  Dict       ):





											'''simple docstring'''





											super().__init__(**__snake_case       )

											_snake_case:   Optional[int]  					=		TFRegNetXLayer if config.layer_type == 'x' else TFRegNetYLayer
											_snake_case:   str  					=		[
											    # 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    SCREAMING_SNAKE_CASE_		(					self	:  Tuple       ,     __snake_case	:  int       ):





											'''simple docstring'''





											for layer_module in self.layers:
																	_snake_case:   Tuple  					=		layer_module(__snake_case       )
											return hidden_state







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


					def __init__(					self	:  Any       ,     __snake_case	:  RegNetConfig       ,     **__snake_case	:  List[Any]       ):





											'''simple docstring'''





											super().__init__(**__snake_case       )
											_snake_case:   List[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'       ,     )       )
											_snake_case:   str  					=		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    SCREAMING_SNAKE_CASE_		(					self	:  str       ,     __snake_case	:  tf.Tensor       ,     __snake_case	:  bool = False       ,     __snake_case	:  bool = True       ):





											'''simple docstring'''





											_snake_case:   Union[str, Any]  					=		() if output_hidden_states else None

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

																	_snake_case:   Union[str, Any]  					=		stage_module(__snake_case       )

											if output_hidden_states:
																	_snake_case:   int  					=		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 			lowerCamelCase					(						tf.keras.layers.Layer  ):
					_SCREAMING_SNAKE_CASE							   =    RegNetConfig


					def __init__(					self	:  List[Any]       ,     __snake_case	:  Any       ,     **__snake_case	:  Union[str, Any]       ):





											'''simple docstring'''





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




					@unpack_inputs
					def    SCREAMING_SNAKE_CASE_		(					self	:  Optional[Any]       ,     __snake_case	:  tf.Tensor       ,     __snake_case	:  Optional[bool] = None       ,     __snake_case	:  Optional[bool] = None       ,     __snake_case	:  bool = False       ,     ):





											'''simple docstring'''





											_snake_case:   int  					=		(
											    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
											)
											_snake_case:   Dict  					=		return_dict if return_dict is not None else self.config.use_return_dict

											_snake_case:   List[Any]  					=		self.embedder(__snake_case       ,     training=__snake_case       )

											_snake_case:   str  					=		self.encoder(
											    __snake_case       ,     output_hidden_states=__snake_case       ,     return_dict=__snake_case       ,     training=__snake_case       )

											_snake_case:   Optional[Any]  					=		encoder_outputs[0]
											_snake_case:   Union[str, Any]  					=		self.pooler(__snake_case       )

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

											# Change the other hidden state outputs to NCHW as well
											if output_hidden_states:
																	_snake_case:   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 			lowerCamelCase					(						__UpperCAmelCase  ):
					_SCREAMING_SNAKE_CASE							   =    RegNetConfig
					_SCREAMING_SNAKE_CASE							   =    "regnet"
					_SCREAMING_SNAKE_CASE							   =    "pixel_values"


					@property
					def    SCREAMING_SNAKE_CASE_		(					self	:  Union[str, Any]       ):





											'''simple docstring'''





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





A   : List[Any]             =			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   : Union[str, Any]             =			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."     ,							__UpperCAmelCase     ,							)
class 			lowerCamelCase					(						__UpperCAmelCase  ):


					def __init__(					self	:  Any       ,     __snake_case	:  RegNetConfig       ,     *__snake_case	:  Any       ,     **__snake_case	:  List[str]       ):





											'''simple docstring'''





											super().__init__(__snake_case       ,     *__snake_case       ,     **__snake_case       )
											_snake_case:   Optional[Any]  					=		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    SCREAMING_SNAKE_CASE_		(					self	:  int       ,     __snake_case	:  tf.Tensor       ,     __snake_case	:  Optional[bool] = None       ,     __snake_case	:  Optional[bool] = None       ,     __snake_case	:  Tuple=False       ,     ):





											'''simple docstring'''





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

											_snake_case:   int  					=		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    "     ,							__UpperCAmelCase     ,							)
class 			lowerCamelCase					(						__UpperCAmelCase     ,							__UpperCAmelCase  ):


					def __init__(					self	:  List[str]       ,     __snake_case	:  RegNetConfig       ,     *__snake_case	:  str       ,     **__snake_case	:  List[str]       ):





											'''simple docstring'''





											super().__init__(__snake_case       ,     *__snake_case       ,     **__snake_case       )
											_snake_case:   str  					=		config.num_labels
											_snake_case:   Any  					=		TFRegNetMainLayer(__snake_case       ,     name='regnet'       )
											# classification head
											_snake_case:   List[str]  					=		[
											    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    SCREAMING_SNAKE_CASE_		(					self	:  List[Any]       ,     __snake_case	:  tf.Tensor = None       ,     __snake_case	:  tf.Tensor = None       ,     __snake_case	:  bool = None       ,     __snake_case	:  bool = None       ,     __snake_case	:  Optional[Any]=False       ,     ):





											'''simple docstring'''





											_snake_case:   List[str]  					=		(
											    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
											)
											_snake_case:   Dict  					=		return_dict if return_dict is not None else self.config.use_return_dict

											_snake_case:   int  					=		self.regnet(
											    __snake_case       ,     output_hidden_states=__snake_case       ,     return_dict=__snake_case       ,     training=__snake_case       )

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

											_snake_case:   Optional[Any]  					=		self.classifier[0](__snake_case       )
											_snake_case:   List[Any]  					=		self.classifier[1](__snake_case       )

											_snake_case:   Union[str, Any]  					=		None if labels is None else self.hf_compute_loss(labels=__snake_case       ,     logits=__snake_case       )

											if not return_dict:
																	_snake_case:   Dict  					=		(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       )












'''simple docstring'''






import sys
import webbrowser

import requests
from bsa import BeautifulSoup
from fake_useragent import UserAgent

if __name__ == "__main__":
		print('Googling.....')
		A   : Optional[int]             =			'https://www.google.com/search?q=' + ' '.join(sys.argv[1:])
		A   : Dict             =			requests.get(url, headers={'UserAgent': UserAgent().random})
		# res.raise_for_status()
		with open('project1a.html', 'wb') as out_file:  # only for knowing the class
				for data in res.iter_content(10_000):
						out_file.write(data)
		A   : List[Any]             =			BeautifulSoup(res.text, 'html.parser')
		A   : List[Any]             =			list(soup.select('.eZt8xd'))[:5]

		print(len(links))
		for link in links:
				if link.text == "Maps":
						webbrowser.open(link.get('href'))
				else:
						webbrowser.open(F'https://google.com{link.get("href")}')





