






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


_UpperCamelCase    :   Optional[Any]   			=						logging.get_logger(__name__)

# General docstring
_UpperCamelCase    :   List[Any]   			=						'''ResNetConfig'''

# Base docstring
_UpperCamelCase    :   int   			=						'''microsoft/resnet-50'''
_UpperCamelCase    :   List[Any]   			=						[1, 2048, 7, 7]

# Image classification docstring
_UpperCamelCase    :   int   			=						'''microsoft/resnet-50'''
_UpperCamelCase    :   Optional[Any]   			=						'''tiger cat'''

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






class 						snake_case  (  nn.Module	):





    def __init__(							self     : Tuple    ,		A     : int    ,		A     : int    ,		A     : int = 3    ,		A     : int = 1    ,		A     : str = "relu"      ):


      '''simple docstring'''




      super().__init__()
      a					:      int    =       nn.Convad(
          __lowerCamelCase    ,		__lowerCamelCase    ,		kernel_size=__lowerCamelCase    ,		stride=__lowerCamelCase    ,		padding=kernel_size // 2    ,		bias=__lowerCamelCase      )
      a					:      int    =       nn.BatchNormad(__lowerCamelCase      )
      a					:      Optional[Any]    =       ACTaFN[activation] if activation is not None else nn.Identity()





    def     lowerCamelCase__				(							self     : Tuple    ,		A     : Tensor      ):


      '''simple docstring'''




      a					:      Tuple    =       self.convolution(__lowerCamelCase      )
      a					:      Dict    =       self.normalization(__lowerCamelCase      )
      a					:      str    =       self.activation(__lowerCamelCase      )
      return hidden_state






class 						snake_case  (  nn.Module	):





    def __init__(							self     : Tuple    ,		A     : ResNetConfig      ):


      '''simple docstring'''




      super().__init__()
      a					:      Optional[Any]    =       ResNetConvLayer(
          config.num_channels    ,		config.embedding_size    ,		kernel_size=7    ,		stride=2    ,		activation=config.hidden_act      )
      a					:      Optional[int]    =       nn.MaxPoolad(kernel_size=3    ,		stride=2    ,		padding=1      )
      a					:      str    =       config.num_channels





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


      '''simple docstring'''




      a					:      Dict    =       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.'      )
      a					:      int    =       self.embedder(__lowerCamelCase      )
      a					:      Tuple    =       self.pooler(__lowerCamelCase      )
      return embedding






class 						snake_case  (  nn.Module	):





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


      '''simple docstring'''




      super().__init__()
      a					:      Optional[Any]    =       nn.Convad(__lowerCamelCase    ,		__lowerCamelCase    ,		kernel_size=1    ,		stride=__lowerCamelCase    ,		bias=__lowerCamelCase      )
      a					:      Dict    =       nn.BatchNormad(__lowerCamelCase      )





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


      '''simple docstring'''




      a					:      str    =       self.convolution(__lowerCamelCase      )
      a					:      Dict    =       self.normalization(__lowerCamelCase      )
      return hidden_state






class 						snake_case  (  nn.Module	):





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


      '''simple docstring'''




      super().__init__()
      a					:      List[str]    =       in_channels != out_channels or stride != 1
      a					:      Union[str, Any]    =       (
          ResNetShortCut(__lowerCamelCase    ,		__lowerCamelCase    ,		stride=__lowerCamelCase      ) if should_apply_shortcut else nn.Identity()
      )
      a					:      Optional[int]    =       nn.Sequential(
          ResNetConvLayer(__lowerCamelCase    ,		__lowerCamelCase    ,		stride=__lowerCamelCase      )    ,		ResNetConvLayer(__lowerCamelCase    ,		__lowerCamelCase    ,		activation=__lowerCamelCase      )    ,		)
      a					:      Optional[int]    =       ACTaFN[activation]





    def     lowerCamelCase__				(							self     : Optional[int]    ,		A     : Union[str, Any]      ):


      '''simple docstring'''




      a					:      Tuple    =       hidden_state
      a					:      List[Any]    =       self.layer(__lowerCamelCase      )
      a					:      Optional[int]    =       self.shortcut(__lowerCamelCase      )
      hidden_state += residual
      a					:      int    =       self.activation(__lowerCamelCase      )
      return hidden_state






class 						snake_case  (  nn.Module	):





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


      '''simple docstring'''




      super().__init__()
      a					:      str    =       in_channels != out_channels or stride != 1
      a					:      List[Any]    =       out_channels // reduction
      a					:      List[Any]    =       (
          ResNetShortCut(__lowerCamelCase    ,		__lowerCamelCase    ,		stride=__lowerCamelCase      ) if should_apply_shortcut else nn.Identity()
      )
      a					:      Optional[Any]    =       nn.Sequential(
          ResNetConvLayer(__lowerCamelCase    ,		__lowerCamelCase    ,		kernel_size=1      )    ,		ResNetConvLayer(__lowerCamelCase    ,		__lowerCamelCase    ,		stride=__lowerCamelCase      )    ,		ResNetConvLayer(__lowerCamelCase    ,		__lowerCamelCase    ,		kernel_size=1    ,		activation=__lowerCamelCase      )    ,		)
      a					:      str    =       ACTaFN[activation]





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


      '''simple docstring'''




      a					:      Union[str, Any]    =       hidden_state
      a					:      str    =       self.layer(__lowerCamelCase      )
      a					:      Tuple    =       self.shortcut(__lowerCamelCase      )
      hidden_state += residual
      a					:      Union[str, Any]    =       self.activation(__lowerCamelCase      )
      return hidden_state






class 						snake_case  (  nn.Module	):





    def __init__(							self     : Tuple    ,		A     : ResNetConfig    ,		A     : int    ,		A     : int    ,		A     : int = 2    ,		A     : int = 2    ,		):


      '''simple docstring'''




      super().__init__()

      a					:      Dict    =       ResNetBottleNeckLayer if config.layer_type == """bottleneck""" else ResNetBasicLayer

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





    def     lowerCamelCase__				(							self     : str    ,		A     : Tensor      ):


      '''simple docstring'''




      a					:      Dict    =       input
      for layer in self.layers:
        a					:      Optional[int]    =       layer(__lowerCamelCase      )
      return hidden_state






class 						snake_case  (  nn.Module	):





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


      '''simple docstring'''




      super().__init__()
      a					:      List[str]    =       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(
              __lowerCamelCase    ,		config.embedding_size    ,		config.hidden_sizes[0]    ,		stride=2 if config.downsample_in_first_stage else 1    ,		depth=config.depths[0]    ,		)      )
      a					:      Optional[int]    =       zip(config.hidden_sizes    ,		config.hidden_sizes[1:]      )
      for (in_channels, out_channels), depth in zip(__lowerCamelCase    ,		config.depths[1:]      ):
        self.stages.append(ResNetStage(__lowerCamelCase    ,		__lowerCamelCase    ,		__lowerCamelCase    ,		depth=__lowerCamelCase      )      )





    def     lowerCamelCase__				(							self     : Dict    ,		A     : Tensor    ,		A     : bool = False    ,		A     : bool = True      ):


      '''simple docstring'''




      a					:      Dict    =       () if output_hidden_states else None

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

        a					:      Dict    =       stage_module(__lowerCamelCase      )

      if output_hidden_states:
        a					:      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 BaseModelOutputWithNoAttention(
          last_hidden_state=__lowerCamelCase    ,		hidden_states=__lowerCamelCase    ,		)






class 						snake_case  (  _a	):
    __magic_name__   					=					ResNetConfig
    __magic_name__   					=					"""resnet"""
    __magic_name__   					=					"""pixel_values"""
    __magic_name__   					=					True





    def     lowerCamelCase__				(							self     : Any    ,		A     : str      ):


      '''simple docstring'''




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





    def     lowerCamelCase__				(							self     : Union[str, Any]    ,		A     : Optional[Any]    ,		A     : Optional[int]=False      ):


      '''simple docstring'''




      if isinstance(__lowerCamelCase    ,		__lowerCamelCase      ):
        a					:      Union[str, Any]    =       value




_UpperCamelCase    :   Optional[Any]   			=						R'''
    This model is a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass. Use it
    as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage and
    behavior.

    Parameters:
        config ([`ResNetConfig`]): Model configuration class with all the parameters of the model.
            Initializing with a config file does not load the weights associated with the model, only the
            configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights.
'''

_UpperCamelCase    :   Any   			=						R'''
    Args:
        pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`):
            Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See
            [`ConvNextImageProcessor.__call__`] for details.

        output_hidden_states (`bool`, *optional*):
            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for
            more detail.
        return_dict (`bool`, *optional*):
            Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
'''






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





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


      '''simple docstring'''




      super().__init__(__lowerCamelCase      )
      a					:      Tuple    =       config
      a					:      str    =       ResNetEmbeddings(__lowerCamelCase      )
      a					:      Dict    =       ResNetEncoder(__lowerCamelCase      )
      a					:      Dict    =       nn.AdaptiveAvgPoolad((1, 1)      )
      # Initialize weights and apply final processing
      self.post_init()





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


      '''simple docstring'''




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

      a					:      Optional[Any]    =       self.embedder(__lowerCamelCase      )

      a					:      Tuple    =       self.encoder(
          __lowerCamelCase    ,		output_hidden_states=__lowerCamelCase    ,		return_dict=__lowerCamelCase      )

      a					:      Dict    =       encoder_outputs[0]

      a					:      Optional[Any]    =       self.pooler(__lowerCamelCase      )

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

      return BaseModelOutputWithPoolingAndNoAttention(
          last_hidden_state=__lowerCamelCase    ,		pooler_output=__lowerCamelCase    ,		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 						snake_case  (  _a	):





    def __init__(							self     : Dict    ,		A     : Optional[int]      ):


      '''simple docstring'''




      super().__init__(__lowerCamelCase      )
      a					:      Optional[Any]    =       config.num_labels
      a					:      int    =       ResNetModel(__lowerCamelCase      )
      # classification head
      a					:      Optional[Any]    =       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(__lowerCamelCase      )
    @add_code_sample_docstrings(
        checkpoint=_IMAGE_CLASS_CHECKPOINT    ,		output_type=__lowerCamelCase    ,		config_class=_CONFIG_FOR_DOC    ,		expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT    ,		)
    def     lowerCamelCase__				(							self     : Optional[Any]    ,		A     : Optional[torch.FloatTensor] = None    ,		A     : Optional[torch.LongTensor] = None    ,		A     : Optional[bool] = None    ,		A     : Optional[bool] = None    ,		):


      '''simple docstring'''




      a					:      str    =       return_dict if return_dict is not None else self.config.use_return_dict

      a					:      Optional[int]    =       self.resnet(__lowerCamelCase    ,		output_hidden_states=__lowerCamelCase    ,		return_dict=__lowerCamelCase      )

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

      a					:      Tuple    =       self.classifier(__lowerCamelCase      )

      a					:      List[Any]    =       None

      if labels is not None:
        if self.config.problem_type is None:
          if self.num_labels == 1:
            a					:      List[str]    =       """regression"""
          elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
            a					:      List[str]    =       """single_label_classification"""
          else:
            a					:      Tuple    =       """multi_label_classification"""
        if self.config.problem_type == "regression":
          a					:      Optional[Any]    =       MSELoss()
          if self.num_labels == 1:
            a					:      Dict    =       loss_fct(logits.squeeze()    ,		labels.squeeze()      )
          else:
            a					:      Optional[int]    =       loss_fct(__lowerCamelCase    ,		__lowerCamelCase      )
        elif self.config.problem_type == "single_label_classification":
          a					:      Any    =       CrossEntropyLoss()
          a					:      List[str]    =       loss_fct(logits.view(-1    ,		self.num_labels      )    ,		labels.view(-1      )      )
        elif self.config.problem_type == "multi_label_classification":
          a					:      Dict    =       BCEWithLogitsLoss()
          a					:      Any    =       loss_fct(__lowerCamelCase    ,		__lowerCamelCase      )

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

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






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





    def __init__(							self     : str    ,		A     : Tuple      ):


      '''simple docstring'''




      super().__init__(__lowerCamelCase      )
      super()._init_backbone(__lowerCamelCase      )

      a					:      int    =       [config.embedding_size] + config.hidden_sizes
      a					:      Any    =       ResNetEmbeddings(__lowerCamelCase      )
      a					:      Dict    =       ResNetEncoder(__lowerCamelCase      )

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





    @add_start_docstrings_to_model_forward(__lowerCamelCase      )
    @replace_return_docstrings(output_type=__lowerCamelCase    ,		config_class=_CONFIG_FOR_DOC      )
    def     lowerCamelCase__				(							self     : List[str]    ,		A     : Tensor    ,		A     : Optional[bool] = None    ,		A     : Optional[bool] = None      ):


      '''simple docstring'''




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

      a					:      str    =       self.embedder(__lowerCamelCase      )

      a					:      List[str]    =       self.encoder(__lowerCamelCase    ,		output_hidden_states=__lowerCamelCase    ,		return_dict=__lowerCamelCase      )

      a					:      List[str]    =       outputs.hidden_states

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

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

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












"""simple docstring"""


def       snake_case  (A_				:list[int]     ,      A_				:str				):







  '''simple docstring'''

  a					:      Optional[int]    =       int(A_				)

  # Initialize Result
  a					:      int    =       []

  # Traverse through all denomination
  for denomination in reversed(A_				):
    # Find denominations
    while int(A_				) >= int(A_				):
      total_value -= int(A_				)
      answer.append(A_				)  # Append the "answers" array

  return answer


# Driver Code
if __name__ == "__main__":
   _UpperCamelCase    :   Dict   			=						[]
   _UpperCamelCase    :   str   			=						'0'

   if (
       input('Do you want to enter your denominations ? (yY/n): ').strip().lower()
       == "y"
   ):
      _UpperCamelCase    :   Dict   			=						int(input('Enter the number of denominations you want to add: ').strip())

      for i in range(0, n):
         denominations.append(int(input(f'''Denomination {i}: ''').strip()))
      _UpperCamelCase    :   Optional[int]   			=						input('Enter the change you want to make in Indian Currency: ').strip()
   else:
      # All denominations of Indian Currency if user does not enter
      _UpperCamelCase    :   Union[str, Any]   			=						[1, 2, 5, 10, 20, 50, 100, 500, 2000]
      _UpperCamelCase    :   Dict   			=						input('Enter the change you want to make: ').strip()

   if int(value) == 0 or int(value) < 0:
      print('The total value cannot be zero or negative.')

   else:
      print(f'''Following is minimal change for {value}: ''')
      _UpperCamelCase    :   Tuple   			=						find_minimum_change(denominations, value)
      # Print result
      for i in range(len(answer)):
         print(answer[i], end=' ')




