



'''simple docstring'''


from typing import Optional

import torch
import torch.utils.checkpoint
from torch import Tensor, nn
from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss

from ...activations import ACTaFN
from ...modeling_outputs import (
    BackboneOutput,
    BaseModelOutputWithNoAttention,
    BaseModelOutputWithPoolingAndNoAttention,
    ImageClassifierOutputWithNoAttention,
)
from ...modeling_utils import PreTrainedModel
from ...utils import (
    add_code_sample_docstrings,
    add_start_docstrings,
    add_start_docstrings_to_model_forward,
    logging,
    replace_return_docstrings,
)
from ...utils.backbone_utils import BackboneMixin
from .configuration_resnet import ResNetConfig


_lowerCamelCase	:       Dict      	=	logging.get_logger(__name__)

# General docstring
_lowerCamelCase	:       List[str]      	=	"ResNetConfig"

# Base docstring
_lowerCamelCase	:       Tuple      	=	"microsoft/resnet-50"
_lowerCamelCase	:       Union[str, Any]      	=	[1, 2048, 7, 7]

# Image classification docstring
_lowerCamelCase	:       Dict      	=	"microsoft/resnet-50"
_lowerCamelCase	:       Optional[int]      	=	"tiger cat"

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

class  SCREAMING_SNAKE_CASE (  nn.Module		):






    """simple docstring"""





    def __init__(  self      :					Dict  ,						UpperCamelCase__      :					int  ,						UpperCamelCase__      :					int  ,						UpperCamelCase__      :					int = 3  ,						UpperCamelCase__      :					int = 1  ,						UpperCamelCase__      :					str = "relu" ):


       """simple docstring"""







       super().__init__()
       UpperCamelCase					=  nn.Convad(
           UpperCamelCase__  ,						UpperCamelCase__  ,						kernel_size=UpperCamelCase__  ,						stride=UpperCamelCase__  ,						padding=kernel_size // 2  ,						bias=UpperCamelCase__ )
       UpperCamelCase					=  nn.BatchNormad(UpperCamelCase__ )
       UpperCamelCase					=  ACTaFN[activation] if activation is not None else nn.Identity()






    def  A       (  self      :					Dict  ,						UpperCamelCase__      :					Tensor ):


       """simple docstring"""







       UpperCamelCase					=  self.convolution(UpperCamelCase__ )
       UpperCamelCase					=  self.normalization(UpperCamelCase__ )
       UpperCamelCase					=  self.activation(UpperCamelCase__ )
       return hidden_state

class  SCREAMING_SNAKE_CASE (  nn.Module		):






    """simple docstring"""





    def __init__(  self      :					Any  ,						UpperCamelCase__      :					ResNetConfig ):


       """simple docstring"""







       super().__init__()
       UpperCamelCase					=  ResNetConvLayer(
           config.num_channels  ,						config.embedding_size  ,						kernel_size=7  ,						stride=2  ,						activation=config.hidden_act )
       UpperCamelCase					=  nn.MaxPoolad(kernel_size=3  ,						stride=2  ,						padding=1 )
       UpperCamelCase					=  config.num_channels






    def  A       (  self      :					Union[str, Any]  ,						UpperCamelCase__      :					Tensor ):


       """simple docstring"""







       UpperCamelCase					=  pixel_values.shape[1]
       if 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.' )
       UpperCamelCase					=  self.embedder(UpperCamelCase__ )
       UpperCamelCase					=  self.pooler(UpperCamelCase__ )
       return embedding

class  SCREAMING_SNAKE_CASE (  nn.Module		):






    """simple docstring"""





    def __init__(  self      :					Union[str, Any]  ,						UpperCamelCase__      :					int  ,						UpperCamelCase__      :					int  ,						UpperCamelCase__      :					int = 2 ):


       """simple docstring"""







       super().__init__()
       UpperCamelCase					=  nn.Convad(UpperCamelCase__  ,						UpperCamelCase__  ,						kernel_size=1  ,						stride=UpperCamelCase__  ,						bias=UpperCamelCase__ )
       UpperCamelCase					=  nn.BatchNormad(UpperCamelCase__ )






    def  A       (  self      :					Any  ,						UpperCamelCase__      :					Tensor ):


       """simple docstring"""







       UpperCamelCase					=  self.convolution(UpperCamelCase__ )
       UpperCamelCase					=  self.normalization(UpperCamelCase__ )
       return hidden_state

class  SCREAMING_SNAKE_CASE (  nn.Module		):






    """simple docstring"""





    def __init__(  self      :					Optional[int]  ,						UpperCamelCase__      :					int  ,						UpperCamelCase__      :					int  ,						UpperCamelCase__      :					int = 1  ,						UpperCamelCase__      :					str = "relu" ):


       """simple docstring"""







       super().__init__()
       UpperCamelCase					=  in_channels != out_channels or stride != 1
       UpperCamelCase					=  (
           ResNetShortCut(UpperCamelCase__  ,						UpperCamelCase__  ,						stride=UpperCamelCase__ ) if should_apply_shortcut else nn.Identity()
       )
       UpperCamelCase					=  nn.Sequential(
           ResNetConvLayer(UpperCamelCase__  ,						UpperCamelCase__  ,						stride=UpperCamelCase__ )  ,						ResNetConvLayer(UpperCamelCase__  ,						UpperCamelCase__  ,						activation=UpperCamelCase__ )  ,						)
       UpperCamelCase					=  ACTaFN[activation]






    def  A       (  self      :					str  ,						UpperCamelCase__      :					Union[str, Any] ):


       """simple docstring"""







       UpperCamelCase					=  hidden_state
       UpperCamelCase					=  self.layer(UpperCamelCase__ )
       UpperCamelCase					=  self.shortcut(UpperCamelCase__ )
       hidden_state += residual
       UpperCamelCase					=  self.activation(UpperCamelCase__ )
       return hidden_state

class  SCREAMING_SNAKE_CASE (  nn.Module		):






    """simple docstring"""





    def __init__(  self      :					Optional[Any]  ,						UpperCamelCase__      :					int  ,						UpperCamelCase__      :					int  ,						UpperCamelCase__      :					int = 1  ,						UpperCamelCase__      :					str = "relu"  ,						UpperCamelCase__      :					int = 4 ):


       """simple docstring"""







       super().__init__()
       UpperCamelCase					=  in_channels != out_channels or stride != 1
       UpperCamelCase					=  out_channels // reduction
       UpperCamelCase					=  (
           ResNetShortCut(UpperCamelCase__  ,						UpperCamelCase__  ,						stride=UpperCamelCase__ ) if should_apply_shortcut else nn.Identity()
       )
       UpperCamelCase					=  nn.Sequential(
           ResNetConvLayer(UpperCamelCase__  ,						UpperCamelCase__  ,						kernel_size=1 )  ,						ResNetConvLayer(UpperCamelCase__  ,						UpperCamelCase__  ,						stride=UpperCamelCase__ )  ,						ResNetConvLayer(UpperCamelCase__  ,						UpperCamelCase__  ,						kernel_size=1  ,						activation=UpperCamelCase__ )  ,						)
       UpperCamelCase					=  ACTaFN[activation]






    def  A       (  self      :					Dict  ,						UpperCamelCase__      :					Optional[Any] ):


       """simple docstring"""







       UpperCamelCase					=  hidden_state
       UpperCamelCase					=  self.layer(UpperCamelCase__ )
       UpperCamelCase					=  self.shortcut(UpperCamelCase__ )
       hidden_state += residual
       UpperCamelCase					=  self.activation(UpperCamelCase__ )
       return hidden_state

class  SCREAMING_SNAKE_CASE (  nn.Module		):






    """simple docstring"""





    def __init__(  self      :					List[str]  ,						UpperCamelCase__      :					ResNetConfig  ,						UpperCamelCase__      :					int  ,						UpperCamelCase__      :					int  ,						UpperCamelCase__      :					int = 2  ,						UpperCamelCase__      :					int = 2  ,						):


       """simple docstring"""







       super().__init__()

       UpperCamelCase					=  ResNetBottleNeckLayer if config.layer_type == 'bottleneck' else ResNetBasicLayer

       UpperCamelCase					=  nn.Sequential(
           # downsampling is done in the first layer with stride of 2
           layer(UpperCamelCase__  ,						UpperCamelCase__  ,						stride=UpperCamelCase__  ,						activation=config.hidden_act )  ,						*[layer(UpperCamelCase__  ,						UpperCamelCase__  ,						activation=config.hidden_act ) for _ in range(depth - 1 )]  ,						)






    def  A       (  self      :					Dict  ,						UpperCamelCase__      :					Tensor ):


       """simple docstring"""







       UpperCamelCase					=  input
       for layer in self.layers:
          UpperCamelCase					=  layer(UpperCamelCase__ )
       return hidden_state

class  SCREAMING_SNAKE_CASE (  nn.Module		):






    """simple docstring"""





    def __init__(  self      :					Dict  ,						UpperCamelCase__      :					ResNetConfig ):


       """simple docstring"""







       super().__init__()
       UpperCamelCase					=  nn.ModuleList([] )
       # based on `downsample_in_first_stage` the first layer of the first stage may or may not downsample the input
       self.stages.append(
           ResNetStage(
               UpperCamelCase__  ,						config.embedding_size  ,						config.hidden_sizes[0]  ,						stride=2 if config.downsample_in_first_stage else 1  ,						depth=config.depths[0]  ,						) )
       UpperCamelCase					=  zip(config.hidden_sizes  ,						config.hidden_sizes[1:] )
       for (in_channels, out_channels), depth in zip(UpperCamelCase__  ,						config.depths[1:] ):
          self.stages.append(ResNetStage(UpperCamelCase__  ,						UpperCamelCase__  ,						UpperCamelCase__  ,						depth=UpperCamelCase__ ) )






    def  A       (  self      :					Tuple  ,						UpperCamelCase__      :					Tensor  ,						UpperCamelCase__      :					bool = False  ,						UpperCamelCase__      :					bool = True ):


       """simple docstring"""







       UpperCamelCase					=  () if output_hidden_states else None

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

          UpperCamelCase					=  stage_module(UpperCamelCase__ )

       if output_hidden_states:
          UpperCamelCase					=  hidden_states + (hidden_state,)

       if not return_dict:
          return tuple(v for v in [hidden_state, hidden_states] if v is not None )

       return BaseModelOutputWithNoAttention(
           last_hidden_state=UpperCamelCase__  ,						hidden_states=UpperCamelCase__  ,						)

class  SCREAMING_SNAKE_CASE (  _a		):






    """simple docstring"""





    _SCREAMING_SNAKE_CASE	  =  ResNetConfig
    _SCREAMING_SNAKE_CASE	  =  """resnet"""
    _SCREAMING_SNAKE_CASE	  =  """pixel_values"""
    _SCREAMING_SNAKE_CASE	  =  True






    def  A       (  self      :					List[str]  ,						UpperCamelCase__      :					Dict ):


       """simple docstring"""







       if isinstance(UpperCamelCase__  ,						nn.Convad ):
          nn.init.kaiming_normal_(module.weight  ,						mode='fan_out'  ,						nonlinearity='relu' )
       elif isinstance(UpperCamelCase__  ,						(nn.BatchNormad, nn.GroupNorm) ):
          nn.init.constant_(module.weight  ,						1 )
          nn.init.constant_(module.bias  ,						0 )






    def  A       (  self      :					Dict  ,						UpperCamelCase__      :					Union[str, Any]  ,						UpperCamelCase__      :					str=False ):


       """simple docstring"""







       if isinstance(UpperCamelCase__  ,						UpperCamelCase__ ):
          UpperCamelCase					=  value

_lowerCamelCase	:       Union[str, Any]      	=	R"\n    This model is a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass. Use it\n    as a regular PyTorch Module and refer to the PyTorch 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 [`~PreTrainedModel.from_pretrained`] method to load the model weights.\n"

_lowerCamelCase	:       Any      	=	R"\n    Args:\n        pixel_values (`torch.FloatTensor` 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"

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






    """simple docstring"""





    def __init__(  self      :					str  ,						UpperCamelCase__      :					Any ):


       """simple docstring"""







       super().__init__(UpperCamelCase__ )
       UpperCamelCase					=  config
       UpperCamelCase					=  ResNetEmbeddings(UpperCamelCase__ )
       UpperCamelCase					=  ResNetEncoder(UpperCamelCase__ )
       UpperCamelCase					=  nn.AdaptiveAvgPoolad((1, 1) )
       # Initialize weights and apply final processing
       self.post_init()






    @add_start_docstrings_to_model_forward(UpperCamelCase__ )
    @add_code_sample_docstrings(
        checkpoint=_CHECKPOINT_FOR_DOC  ,						output_type=UpperCamelCase__  ,						config_class=_CONFIG_FOR_DOC  ,						modality='vision'  ,						expected_output=_EXPECTED_OUTPUT_SHAPE  ,						)
    def  A       (  self      :					str  ,						UpperCamelCase__      :					Tensor  ,						UpperCamelCase__      :					Optional[bool] = None  ,						UpperCamelCase__      :					Optional[bool] = None ):


       """simple docstring"""







       UpperCamelCase					=  (
           output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
       )
       UpperCamelCase					=  return_dict if return_dict is not None else self.config.use_return_dict

       UpperCamelCase					=  self.embedder(UpperCamelCase__ )

       UpperCamelCase					=  self.encoder(
           UpperCamelCase__  ,						output_hidden_states=UpperCamelCase__  ,						return_dict=UpperCamelCase__ )

       UpperCamelCase					=  encoder_outputs[0]

       UpperCamelCase					=  self.pooler(UpperCamelCase__ )

       if not return_dict:
          return (last_hidden_state, pooled_output) + encoder_outputs[1:]

       return BaseModelOutputWithPoolingAndNoAttention(
           last_hidden_state=UpperCamelCase__  ,						pooler_output=UpperCamelCase__  ,						hidden_states=encoder_outputs.hidden_states  ,						)

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






    """simple docstring"""





    def __init__(  self      :					int  ,						UpperCamelCase__      :					Dict ):


       """simple docstring"""







       super().__init__(UpperCamelCase__ )
       UpperCamelCase					=  config.num_labels
       UpperCamelCase					=  ResNetModel(UpperCamelCase__ )
       # classification head
       UpperCamelCase					=  nn.Sequential(
           nn.Flatten()  ,						nn.Linear(config.hidden_sizes[-1]  ,						config.num_labels ) if config.num_labels > 0 else nn.Identity()  ,						)
       # initialize weights and apply final processing
       self.post_init()






    @add_start_docstrings_to_model_forward(UpperCamelCase__ )
    @add_code_sample_docstrings(
        checkpoint=_IMAGE_CLASS_CHECKPOINT  ,						output_type=UpperCamelCase__  ,						config_class=_CONFIG_FOR_DOC  ,						expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT  ,						)
    def  A       (  self      :					List[Any]  ,						UpperCamelCase__      :					Optional[torch.FloatTensor] = None  ,						UpperCamelCase__      :					Optional[torch.LongTensor] = None  ,						UpperCamelCase__      :					Optional[bool] = None  ,						UpperCamelCase__      :					Optional[bool] = None  ,						):


       """simple docstring"""







       UpperCamelCase					=  return_dict if return_dict is not None else self.config.use_return_dict

       UpperCamelCase					=  self.resnet(UpperCamelCase__  ,						output_hidden_states=UpperCamelCase__  ,						return_dict=UpperCamelCase__ )

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

       UpperCamelCase					=  self.classifier(UpperCamelCase__ )

       UpperCamelCase					=  None

       if labels is not None:
          if self.config.problem_type is None:
             if self.num_labels == 1:
                UpperCamelCase					=  'regression'
             elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
                UpperCamelCase					=  'single_label_classification'
             else:
                UpperCamelCase					=  'multi_label_classification'
          if self.config.problem_type == "regression":
             UpperCamelCase					=  MSELoss()
             if self.num_labels == 1:
                UpperCamelCase					=  loss_fct(logits.squeeze()  ,						labels.squeeze() )
             else:
                UpperCamelCase					=  loss_fct(UpperCamelCase__  ,						UpperCamelCase__ )
          elif self.config.problem_type == "single_label_classification":
             UpperCamelCase					=  CrossEntropyLoss()
             UpperCamelCase					=  loss_fct(logits.view(-1  ,						self.num_labels )  ,						labels.view(-1 ) )
          elif self.config.problem_type == "multi_label_classification":
             UpperCamelCase					=  BCEWithLogitsLoss()
             UpperCamelCase					=  loss_fct(UpperCamelCase__  ,						UpperCamelCase__ )

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

       return ImageClassifierOutputWithNoAttention(loss=UpperCamelCase__  ,						logits=UpperCamelCase__  ,						hidden_states=outputs.hidden_states )

@add_start_docstrings(
    """
    ResNet backbone, to be used with frameworks like DETR and MaskFormer.
    """   ,						_a   ,						)
class  SCREAMING_SNAKE_CASE (  _a   ,						_a		):






    """simple docstring"""





    def __init__(  self      :					Dict  ,						UpperCamelCase__      :					Tuple ):


       """simple docstring"""







       super().__init__(UpperCamelCase__ )
       super()._init_backbone(UpperCamelCase__ )

       UpperCamelCase					=  [config.embedding_size] + config.hidden_sizes
       UpperCamelCase					=  ResNetEmbeddings(UpperCamelCase__ )
       UpperCamelCase					=  ResNetEncoder(UpperCamelCase__ )

       # initialize weights and apply final processing
       self.post_init()






    @add_start_docstrings_to_model_forward(UpperCamelCase__ )
    @replace_return_docstrings(output_type=UpperCamelCase__  ,						config_class=_CONFIG_FOR_DOC )
    def  A       (  self      :					Any  ,						UpperCamelCase__      :					Tensor  ,						UpperCamelCase__      :					Optional[bool] = None  ,						UpperCamelCase__      :					Optional[bool] = None ):


       """simple docstring"""







       UpperCamelCase					=  return_dict if return_dict is not None else self.config.use_return_dict
       UpperCamelCase					=  (
           output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
       )

       UpperCamelCase					=  self.embedder(UpperCamelCase__ )

       UpperCamelCase					=  self.encoder(UpperCamelCase__  ,						output_hidden_states=UpperCamelCase__  ,						return_dict=UpperCamelCase__ )

       UpperCamelCase					=  outputs.hidden_states

       UpperCamelCase					=  ()
       for idx, stage in enumerate(self.stage_names ):
          if stage in self.out_features:
             feature_maps += (hidden_states[idx],)

       if not return_dict:
          UpperCamelCase					=  (feature_maps,)
          if output_hidden_states:
             output += (outputs.hidden_states,)
          return output

       return BackboneOutput(
           feature_maps=UpperCamelCase__  ,						hidden_states=outputs.hidden_states if output_hidden_states else None  ,						attentions=UpperCamelCase__  ,						)






"""simple docstring"""






from itertools import zip_longest

import requests
from bsa import BeautifulSoup
from pandas import DataFrame


def 			_lowercase				(  __snake_case = "laptop"	)						->   DataFrame:
			__lowerCAmelCase      :  str												=       F"""https://www.amazon.in/laptop/s?k={product}"""
			__lowerCAmelCase      :  Union[str, Any]												=       {
			    "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36\n        (KHTML, like Gecko)Chrome/44.0.2403.157 Safari/537.36",
			    "Accept-Language": "en-US, en;q=0.5",
			}
			__lowerCAmelCase      :  List[str]												=       BeautifulSoup(requests.get(__snake_case					,headers=__snake_case	).text	)
			# Initialize a Pandas dataframe with the column titles
			__lowerCAmelCase      :  Dict												=       DataFrame(
			    columns=[
			        "Product Title",
			        "Product Link",
			        "Current Price of the product",
			        "Product Rating",
			        "MRP of the product",
			        "Discount",
			    ]	)
			# Loop through each entry and store them in the dataframe
			for item, _ in zip_longest(
			    soup.find_all(
			        "div"					,attrs={"class": "s-result-item", "data-component-type": "s-search-result"}					,)					,soup.find_all("div"					,attrs={"class": "a-row a-size-base a-color-base"}	)					,):
						try:
									__lowerCAmelCase      :  Any												=       item.ha.text
									__lowerCAmelCase      :  Union[str, Any]												=       "https://www.amazon.in/" + item.ha.a["href"]
									__lowerCAmelCase      :  Any												=       item.find("span"					,attrs={"class": "a-offscreen"}	).text
									try:
												__lowerCAmelCase      :  Union[str, Any]												=       item.find("span"					,attrs={"class": "a-icon-alt"}	).text
									except AttributeError:
												__lowerCAmelCase      :  Optional[Any]												=       "Not available"
									try:
												__lowerCAmelCase      :  Union[str, Any]												=       (
												    "₹"
												    + item.find(
												        "span"					,attrs={"class": "a-price a-text-price"}	).text.split("₹"	)[1]
												)
									except AttributeError:
												__lowerCAmelCase      :  Dict												=       ""
									try:
												__lowerCAmelCase      :  str												=       float(
												    (
												        (
												            float(product_mrp.strip("₹"	).replace(","					,""	)	)
												            - float(product_price.strip("₹"	).replace(","					,""	)	)
												        )
												        / float(product_mrp.strip("₹"	).replace(","					,""	)	)
												    )
												    * 100	)
									except ValueError:
												__lowerCAmelCase      :  List[str]												=       float("nan"	)
						except AttributeError:
									pass
						__lowerCAmelCase      :  int												=       [
						    product_title,
						    product_link,
						    product_price,
						    product_rating,
						    product_mrp,
						    discount,
						]
			__lowerCAmelCase      :  Union[str, Any]												=       " "
			__lowerCAmelCase      :  Union[str, Any]												=       " "
			data_frame.index += 1
			return data_frame


if __name__ == "__main__":
	__snake_case							:   Any      =    'headphones'
	get_amazon_product_data(product).to_csv(F"""Amazon Product Data for {product}.csv""")