






"""simple docstring"""


from typing import Optional, Tuple, Union

import tensorflow as tf

from ...activations_tf import ACTaFN
from ...modeling_tf_outputs import (
    TFBaseModelOutputWithNoAttention,
    TFBaseModelOutputWithPoolingAndNoAttention,
    TFImageClassifierOutputWithNoAttention,
)
from ...modeling_tf_utils import TFPreTrainedModel, TFSequenceClassificationLoss, keras_serializable, unpack_inputs
from ...tf_utils import shape_list
from ...utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward, logging
from .configuration_resnet import ResNetConfig


lowercase_								=	logging.get_logger(__name__)

# General docstring
lowercase_								=	'ResNetConfig'

# Base docstring
lowercase_								=	'microsoft/resnet-50'
lowercase_								=	[1, 2048, 7, 7]

# Image classification docstring
lowercase_								=	'microsoft/resnet-50'
lowercase_								=	'tiger cat'

lowercase_								=	[
    'microsoft/resnet-50',
    # See all resnet models at https://huggingface.co/models?filter=resnet
]


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


   '''simple docstring'''

   def __init__(      self					:	Optional[int],			_lowerCamelCase					:	int,			_lowerCamelCase					:	int = 3,			_lowerCamelCase					:	int = 1,			_lowerCamelCase					:	str = "relu",			**_lowerCamelCase					:	List[Any]    ):

     '''simple docstring'''
     super().__init__(**_lowerCamelCase    )
     __A		     =					kernel_size // 2
     __A		     =					tf.keras.layers.ConvaD(
         _lowerCamelCase,			kernel_size=_lowerCamelCase,			strides=_lowerCamelCase,			padding='''valid''',			use_bias=_lowerCamelCase,			name='''convolution'''    )
     # Use same default momentum and epsilon as PyTorch equivalent
     __A		     =					tf.keras.layers.BatchNormalization(epsilon=1e-5,			momentum=0.9,			name='''normalization'''    )
     __A		     =					ACTaFN[activation] if activation is not None else tf.keras.layers.Activation('''linear'''    )


   def 							_SCREAMING_SNAKE_CASE							(      self					:	Optional[int],			_lowerCamelCase					:	tf.Tensor    ):

     '''simple docstring'''
     # Pad to match that done in the PyTorch Conv2D model
     __A		     =					__A		     =					(self.pad_value, self.pad_value)
     __A		     =					tf.pad(_lowerCamelCase,			[(0, 0), height_pad, width_pad, (0, 0)]    )
     __A		     =					self.conv(_lowerCamelCase    )
     return hidden_state






   def 							_SCREAMING_SNAKE_CASE							(      self					:	Dict,			_lowerCamelCase					:	tf.Tensor,			_lowerCamelCase					:	bool = False    ):

     '''simple docstring'''
     __A		     =					self.convolution(_lowerCamelCase    )
     __A		     =					self.normalization(_lowerCamelCase,			training=_lowerCamelCase    )
     __A		     =					self.activation(_lowerCamelCase    )
     return hidden_state





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


   '''simple docstring'''

   def __init__(      self					:	Union[str, Any],			_lowerCamelCase					:	ResNetConfig,			**_lowerCamelCase					:	str    ):

     '''simple docstring'''
     super().__init__(**_lowerCamelCase    )
     __A		     =					TFResNetConvLayer(
         config.embedding_size,			kernel_size=7,			stride=2,			activation=config.hidden_act,			name='''embedder''',			)
     __A		     =					tf.keras.layers.MaxPoolaD(pool_size=3,			strides=2,			padding='''valid''',			name='''pooler'''    )
     __A		     =					config.num_channels






   def 							_SCREAMING_SNAKE_CASE							(      self					:	int,			_lowerCamelCase					:	tf.Tensor,			_lowerCamelCase					:	bool = False    ):

     '''simple docstring'''
     __A     ,       __A     ,       __A     ,       __A		     =					shape_list(_lowerCamelCase    )
     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.'''    )
     __A		     =					pixel_values
     __A		     =					self.embedder(_lowerCamelCase    )
     __A		     =					tf.pad(_lowerCamelCase,			[[0, 0], [1, 1], [1, 1], [0, 0]]    )
     __A		     =					self.pooler(_lowerCamelCase    )
     return hidden_state





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


   '''simple docstring'''

   def __init__(      self					:	Tuple,			_lowerCamelCase					:	int,			_lowerCamelCase					:	int = 2,			**_lowerCamelCase					:	Dict    ):

     '''simple docstring'''
     super().__init__(**_lowerCamelCase    )
     __A		     =					tf.keras.layers.ConvaD(
         _lowerCamelCase,			kernel_size=1,			strides=_lowerCamelCase,			use_bias=_lowerCamelCase,			name='''convolution'''    )
     # Use same default momentum and epsilon as PyTorch equivalent
     __A		     =					tf.keras.layers.BatchNormalization(epsilon=1e-5,			momentum=0.9,			name='''normalization'''    )






   def 							_SCREAMING_SNAKE_CASE							(      self					:	List[Any],			_lowerCamelCase					:	tf.Tensor,			_lowerCamelCase					:	bool = False    ):

     '''simple docstring'''
     __A		     =					x
     __A		     =					self.convolution(_lowerCamelCase    )
     __A		     =					self.normalization(_lowerCamelCase,			training=_lowerCamelCase    )
     return hidden_state





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


   '''simple docstring'''

   def __init__(      self					:	int,			_lowerCamelCase					:	int,			_lowerCamelCase					:	int,			_lowerCamelCase					:	int = 1,			_lowerCamelCase					:	str = "relu",			**_lowerCamelCase					:	Tuple    ):

     '''simple docstring'''
     super().__init__(**_lowerCamelCase    )
     __A		     =					in_channels != out_channels or stride != 1
     __A		     =					TFResNetConvLayer(_lowerCamelCase,			stride=_lowerCamelCase,			name='''layer.0'''    )
     __A		     =					TFResNetConvLayer(_lowerCamelCase,			activation=_lowerCamelCase,			name='''layer.1'''    )
     __A		     =					(
         TFResNetShortCut(_lowerCamelCase,			stride=_lowerCamelCase,			name='''shortcut'''    )
         if should_apply_shortcut
         else tf.keras.layers.Activation('''linear''',			name='''shortcut'''    )
     )
     __A		     =					ACTaFN[activation]






   def 							_SCREAMING_SNAKE_CASE							(      self					:	List[str],			_lowerCamelCase					:	tf.Tensor,			_lowerCamelCase					:	bool = False    ):

     '''simple docstring'''
     __A		     =					hidden_state
     __A		     =					self.conva(_lowerCamelCase,			training=_lowerCamelCase    )
     __A		     =					self.conva(_lowerCamelCase,			training=_lowerCamelCase    )
     __A		     =					self.shortcut(_lowerCamelCase,			training=_lowerCamelCase    )
     hidden_state += residual
     __A		     =					self.activation(_lowerCamelCase    )
     return hidden_state





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


   '''simple docstring'''

   def __init__(      self					:	List[str],			_lowerCamelCase					:	int,			_lowerCamelCase					:	int,			_lowerCamelCase					:	int = 1,			_lowerCamelCase					:	str = "relu",			_lowerCamelCase					:	int = 4,			**_lowerCamelCase					:	List[Any],			):

     '''simple docstring'''
     super().__init__(**_lowerCamelCase    )
     __A		     =					in_channels != out_channels or stride != 1
     __A		     =					out_channels // reduction
     __A		     =					TFResNetConvLayer(_lowerCamelCase,			kernel_size=1,			name='''layer.0'''    )
     __A		     =					TFResNetConvLayer(_lowerCamelCase,			stride=_lowerCamelCase,			name='''layer.1'''    )
     __A		     =					TFResNetConvLayer(_lowerCamelCase,			kernel_size=1,			activation=_lowerCamelCase,			name='''layer.2'''    )
     __A		     =					(
         TFResNetShortCut(_lowerCamelCase,			stride=_lowerCamelCase,			name='''shortcut'''    )
         if should_apply_shortcut
         else tf.keras.layers.Activation('''linear''',			name='''shortcut'''    )
     )
     __A		     =					ACTaFN[activation]






   def 							_SCREAMING_SNAKE_CASE							(      self					:	Any,			_lowerCamelCase					:	tf.Tensor,			_lowerCamelCase					:	bool = False    ):

     '''simple docstring'''
     __A		     =					hidden_state
     __A		     =					self.conva(_lowerCamelCase,			training=_lowerCamelCase    )
     __A		     =					self.conva(_lowerCamelCase,			training=_lowerCamelCase    )
     __A		     =					self.conva(_lowerCamelCase,			training=_lowerCamelCase    )
     __A		     =					self.shortcut(_lowerCamelCase,			training=_lowerCamelCase    )
     hidden_state += residual
     __A		     =					self.activation(_lowerCamelCase    )
     return hidden_state





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


   '''simple docstring'''

   def __init__(      self					:	List[str],			_lowerCamelCase					:	ResNetConfig,			_lowerCamelCase					:	int,			_lowerCamelCase					:	int,			_lowerCamelCase					:	int = 2,			_lowerCamelCase					:	int = 2,			**_lowerCamelCase					:	Tuple    ):

     '''simple docstring'''
     super().__init__(**_lowerCamelCase    )

     __A		     =					TFResNetBottleNeckLayer if config.layer_type == '''bottleneck''' else TFResNetBasicLayer

     __A		     =					[layer(_lowerCamelCase,			_lowerCamelCase,			stride=_lowerCamelCase,			activation=config.hidden_act,			name='''layers.0'''    )]
     layers += [
         layer(_lowerCamelCase,			_lowerCamelCase,			activation=config.hidden_act,			name=f'layers.{i + 1}'    )
         for i in range(depth - 1    )
     ]
     __A		     =					layers






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

     '''simple docstring'''
     for layer in self.stage_layers:
       __A		     =					layer(_lowerCamelCase,			training=_lowerCamelCase    )
     return hidden_state





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


   '''simple docstring'''

   def __init__(      self					:	List[Any],			_lowerCamelCase					:	ResNetConfig,			**_lowerCamelCase					:	Tuple    ):

     '''simple docstring'''
     super().__init__(**_lowerCamelCase    )
     # based on `downsample_in_first_stage` the first layer of the first stage may or may not downsample the input
     __A		     =					[
         TFResNetStage(
             _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''',			)
     ]
     for i, (in_channels, out_channels, depth) in enumerate(
         zip(config.hidden_sizes,			config.hidden_sizes[1:],			config.depths[1:]    )    ):
       self.stages.append(TFResNetStage(_lowerCamelCase,			_lowerCamelCase,			_lowerCamelCase,			depth=_lowerCamelCase,			name=f'stages.{i + 1}'    )    )






   def 							_SCREAMING_SNAKE_CASE							(      self					:	str,			_lowerCamelCase					:	tf.Tensor,			_lowerCamelCase					:	bool = False,			_lowerCamelCase					:	bool = True,			_lowerCamelCase					:	bool = False,			):

     '''simple docstring'''
     __A		     =					() if output_hidden_states else None

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

       __A		     =					stage_module(_lowerCamelCase,			training=_lowerCamelCase    )

     if output_hidden_states:
       __A		     =					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    )





class    snake_case						(				_lowerCAmelCase		):


   '''simple docstring'''

   A_		:      Dict							=					ResNetConfig
   A_		:      Dict							=					"resnet"
   A_		:      Tuple							=					"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    )}





lowercase_								=	R'\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\n    Parameters:\n        config ([`ResNetConfig`]): 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'


lowercase_								=	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            [`ConvNextImageProcessor.__call__`] for details.\n\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'


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


   '''simple docstring'''

   A_		:      Tuple							=					ResNetConfig


   def __init__(      self					:	str,			_lowerCamelCase					:	ResNetConfig,			**_lowerCamelCase					:	Dict    ):

     '''simple docstring'''
     super().__init__(**_lowerCamelCase    )
     __A		     =					config
     __A		     =					TFResNetEmbeddings(_lowerCamelCase,			name='''embedder'''    )
     __A		     =					TFResNetEncoder(_lowerCamelCase,			name='''encoder'''    )
     __A		     =					tf.keras.layers.GlobalAveragePoolingaD(keepdims=_lowerCamelCase    )






   @unpack_inputs
   def 							_SCREAMING_SNAKE_CASE							(      self					:	Union[str, Any],			_lowerCamelCase					:	tf.Tensor,			_lowerCamelCase					:	Optional[bool] = None,			_lowerCamelCase					:	Optional[bool] = None,			_lowerCamelCase					:	bool = False,			):

     '''simple docstring'''
     __A		     =					(
         output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
     )
     __A		     =					return_dict if return_dict is not None else self.config.use_return_dict

     # TF 2.0 image layers can't use NCHW format when running on CPU.
     # We transpose to NHWC format and then transpose back after the full forward pass.
     # (batch_size, num_channels, height, width) -> (batch_size, height, width, num_channels)
     __A		     =					tf.transpose(_lowerCamelCase,			perm=[0, 2, 3, 1]    )
     __A		     =					self.embedder(_lowerCamelCase,			training=_lowerCamelCase    )

     __A		     =					self.encoder(
         _lowerCamelCase,			output_hidden_states=_lowerCamelCase,			return_dict=_lowerCamelCase,			training=_lowerCamelCase    )

     __A		     =					encoder_outputs[0]

     __A		     =					self.pooler(_lowerCamelCase    )

     # Transpose all the outputs to the NCHW format
     # (batch_size, height, width, num_channels) -> (batch_size, num_channels, height, width)
     __A		     =					tf.transpose(_lowerCamelCase,			(0, 3, 1, 2)    )
     __A		     =					tf.transpose(_lowerCamelCase,			(0, 3, 1, 2)    )
     __A		     =					()
     for hidden_state in encoder_outputs[1:]:
       __A		     =					hidden_states + tuple(tf.transpose(_lowerCamelCase,			(0, 3, 1, 2)    ) for h in hidden_state    )

     if not return_dict:
       return (last_hidden_state, pooled_output) + hidden_states

     __A		     =					hidden_states if output_hidden_states else None

     return TFBaseModelOutputWithPoolingAndNoAttention(
         last_hidden_state=_lowerCamelCase,			pooler_output=_lowerCamelCase,			hidden_states=_lowerCamelCase,			)





@add_start_docstrings(
    "The bare ResNet model outputting raw features without any specific head on top."  ,      _lowerCAmelCase  ,      )
class    snake_case						(				_lowerCAmelCase		):


   '''simple docstring'''

   def __init__(      self					:	Any,			_lowerCamelCase					:	ResNetConfig,			**_lowerCamelCase					:	int    ):

     '''simple docstring'''
     super().__init__(_lowerCamelCase,			**_lowerCamelCase    )
     __A		     =					TFResNetMainLayer(config=_lowerCamelCase,			name='''resnet'''    )






   @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,			)
   @unpack_inputs
   def 							_SCREAMING_SNAKE_CASE							(      self					:	List[Any],			_lowerCamelCase					:	tf.Tensor,			_lowerCamelCase					:	Optional[bool] = None,			_lowerCamelCase					:	Optional[bool] = None,			_lowerCamelCase					:	bool = False,			):

     '''simple docstring'''
     __A		     =					(
         output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
     )
     __A		     =					return_dict if return_dict is not None else self.config.use_return_dict

     __A		     =					self.resnet(
         pixel_values=_lowerCamelCase,			output_hidden_states=_lowerCamelCase,			return_dict=_lowerCamelCase,			training=_lowerCamelCase,			)
     return resnet_outputs





@add_start_docstrings(
    "\n    ResNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for\n    ImageNet.\n    "  ,      _lowerCAmelCase  ,      )
class    snake_case						(				_lowerCAmelCase  ,      _lowerCAmelCase		):


   '''simple docstring'''

   def __init__(      self					:	str,			_lowerCamelCase					:	ResNetConfig,			**_lowerCamelCase					:	Any    ):

     '''simple docstring'''
     super().__init__(_lowerCamelCase,			**_lowerCamelCase    )
     __A		     =					config.num_labels
     __A		     =					TFResNetMainLayer(_lowerCamelCase,			name='''resnet'''    )
     # classification head
     __A		     =					(
         tf.keras.layers.Dense(config.num_labels,			name='''classifier.1'''    )
         if config.num_labels > 0
         else tf.keras.layers.Activation('''linear''',			name='''classifier.1'''    )
     )


   def 							_SCREAMING_SNAKE_CASE							(      self					:	Optional[int],			_lowerCamelCase					:	tf.Tensor    ):

     '''simple docstring'''
     __A		     =					tf.keras.layers.Flatten()(_lowerCamelCase    )
     __A		     =					self.classifier_layer(_lowerCamelCase    )
     return logits






   @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,			)
   @unpack_inputs
   def 							_SCREAMING_SNAKE_CASE							(      self					:	str,			_lowerCamelCase					:	tf.Tensor = None,			_lowerCamelCase					:	tf.Tensor = None,			_lowerCamelCase					:	bool = None,			_lowerCamelCase					:	bool = None,			_lowerCamelCase					:	bool = False,			):

     '''simple docstring'''
     __A		     =					return_dict if return_dict is not None else self.config.use_return_dict

     __A		     =					self.resnet(
         _lowerCamelCase,			output_hidden_states=_lowerCamelCase,			return_dict=_lowerCamelCase,			training=_lowerCamelCase    )

     __A		     =					outputs.pooler_output if return_dict else outputs[1]

     __A		     =					self.classifier(_lowerCamelCase    )

     __A		     =					None if labels is None else self.hf_compute_loss(_lowerCamelCase,			_lowerCamelCase    )

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

     return TFImageClassifierOutputWithNoAttention(loss=_lowerCamelCase,			logits=_lowerCamelCase,			hidden_states=outputs.hidden_states    )









'''simple docstring'''

import bsa
import requests







def     __UpperCamelCase					(				_lowercase       )			->      dict[str, str]:
	return {
	    "name": soup.ha.a.text,
	    "genre": soup.find('span',					class_='genre'       ).text.strip(),
	    "rating": soup.strong.text,
	    "page_link": f'''https://www.imdb.com{soup.a.get("href"       )}''',
	}







def     __UpperCamelCase					(				_lowercase = 5       )			->      tuple:
	_lowercase       :							List[Any]  	=		int(float(_lowercase       )       )
	if num_movies < 1:
		return ()
	_lowercase       :							Any  	=		(
	    'https://www.imdb.com/search/title?title_type='
	    f'''feature&sort=num_votes,desc&count={num_movies}'''
	)
	_lowercase       :							Tuple  	=		bsa.BeautifulSoup(requests.get(_lowercase       ).content,					'html.parser'       )
	return tuple(
	    get_movie_data_from_soup(_lowercase       )
	    for movie in source.find_all('div',					class_='lister-item mode-advanced'       )       )


if __name__ == "__main__":
		import json

		_A					:     Optional[int]      =int(input('''How many movies would you like to see? '''))
		print(
		    ''', '''.join(
		        json.dumps(movie, indent=4) for movie in get_imdb_top_movies(num_movies)
		    )
		)
