



'''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:   Tuple					=		'ResNetConfig'

# Base docstring
lowerCAmelCase:   Optional[Any]					=		'microsoft/resnet-50'
lowerCAmelCase:   Dict					=		[1, 2_0_4_8, 7, 7]

# Image classification docstring
lowerCAmelCase:   Union[str, Any]					=		'microsoft/resnet-50'
lowerCAmelCase:   List[str]					=		'tiger cat'

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

class 				a__(   nn.Module      ):







    def __init__( self					:    Optional[Any]		,     __snake_case					:    int		,     __snake_case					:    int		,     __snake_case					:    int = 3		,     __snake_case					:    int = 1		,     __snake_case					:    str = "relu"      ):
      super().__init__()
      a		:   Any	  =	nn.Convad(
          __snake_case		,     __snake_case		,     kernel_size=__snake_case		,     stride=__snake_case		,     padding=kernel_size // 2		,     bias=__snake_case      )
      a		:   Any	  =	nn.BatchNormad(__snake_case      )
      a		:   List[Any]	  =	ACTaFN[activation] if activation is not None else nn.Identity()







    def      lowercase_			( self					:    Optional[Any]		,     __snake_case					:    Tensor      ):
      a		:   Any	  =	self.convolution(__snake_case      )
      a		:   Tuple	  =	self.normalization(__snake_case      )
      a		:   Dict	  =	self.activation(__snake_case      )
      return hidden_state

class 				a__(   nn.Module      ):







    def __init__( self					:    List[Any]		,     __snake_case					:    ResNetConfig      ):
      super().__init__()
      a		:   Union[str, Any]	  =	ResNetConvLayer(
          config.num_channels		,     config.embedding_size		,     kernel_size=7		,     stride=2		,     activation=config.hidden_act      )
      a		:   Dict	  =	nn.MaxPoolad(kernel_size=3		,     stride=2		,     padding=1      )
      a		:   List[Any]	  =	config.num_channels







    def      lowercase_			( self					:    Optional[Any]		,     __snake_case					:    Tensor      ):
      a		:   Tuple	  =	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		:   Any	  =	self.embedder(__snake_case      )
      a		:   List[Any]	  =	self.pooler(__snake_case      )
      return embedding

class 				a__(   nn.Module      ):







    def __init__( self					:    Tuple		,     __snake_case					:    int		,     __snake_case					:    int		,     __snake_case					:    int = 2      ):
      super().__init__()
      a		:   Tuple	  =	nn.Convad(__snake_case		,     __snake_case		,     kernel_size=1		,     stride=__snake_case		,     bias=__snake_case      )
      a		:   Tuple	  =	nn.BatchNormad(__snake_case      )







    def      lowercase_			( self					:    List[str]		,     __snake_case					:    Tensor      ):
      a		:   Optional[int]	  =	self.convolution(__snake_case      )
      a		:   str	  =	self.normalization(__snake_case      )
      return hidden_state

class 				a__(   nn.Module      ):







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







    def      lowercase_			( self					:    List[Any]		,     __snake_case					:    str      ):
      a		:   Tuple	  =	hidden_state
      a		:   Optional[int]	  =	self.layer(__snake_case      )
      a		:   List[str]	  =	self.shortcut(__snake_case      )
      hidden_state += residual
      a		:   Dict	  =	self.activation(__snake_case      )
      return hidden_state

class 				a__(   nn.Module      ):







    def __init__( self					:    List[str]		,     __snake_case					:    int		,     __snake_case					:    int		,     __snake_case					:    int = 1		,     __snake_case					:    str = "relu"		,     __snake_case					:    int = 4      ):
      super().__init__()
      a		:   Union[str, Any]	  =	in_channels != out_channels or stride != 1
      a		:   str	  =	out_channels // reduction
      a		:   Tuple	  =	(
          ResNetShortCut(__snake_case		,     __snake_case		,     stride=__snake_case      ) if should_apply_shortcut else nn.Identity()
      )
      a		:   str	  =	nn.Sequential(
          ResNetConvLayer(__snake_case		,     __snake_case		,     kernel_size=1      )		,     ResNetConvLayer(__snake_case		,     __snake_case		,     stride=__snake_case      )		,     ResNetConvLayer(__snake_case		,     __snake_case		,     kernel_size=1		,     activation=__snake_case      )		,     )
      a		:   List[str]	  =	ACTaFN[activation]







    def      lowercase_			( self					:    str		,     __snake_case					:    Tuple      ):
      a		:   List[str]	  =	hidden_state
      a		:   int	  =	self.layer(__snake_case      )
      a		:   List[str]	  =	self.shortcut(__snake_case      )
      hidden_state += residual
      a		:   Tuple	  =	self.activation(__snake_case      )
      return hidden_state

class 				a__(   nn.Module      ):







    def __init__( self					:    List[Any]		,     __snake_case					:    ResNetConfig		,     __snake_case					:    int		,     __snake_case					:    int		,     __snake_case					:    int = 2		,     __snake_case					:    int = 2		,     ):
      super().__init__()

      a		:   Any	  =	ResNetBottleNeckLayer if config.layer_type == 'bottleneck' else ResNetBasicLayer

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







    def      lowercase_			( self					:    Optional[Any]		,     __snake_case					:    Tensor      ):
      a		:   Optional[int]	  =	input
      for layer in self.layers:
        a		:   Optional[Any]	  =	layer(__snake_case      )
      return hidden_state

class 				a__(   nn.Module      ):







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







    def      lowercase_			( self					:    Dict		,     __snake_case					:    Tensor		,     __snake_case					:    bool = False		,     __snake_case					:    bool = True      ):
      a		:   int	  =	() if output_hidden_states else None

      for stage_module in self.stages:
        if output_hidden_states:
          a		:   List[str]	  =	hidden_states + (hidden_state,)

        a		:   List[str]	  =	stage_module(__snake_case      )

      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 BaseModelOutputWithNoAttention(
          last_hidden_state=__snake_case		,     hidden_states=__snake_case		,     )

class 				a__(   lowerCamelCase__      ):
    lowercase__					=       ResNetConfig
    lowercase__					=       """resnet"""
    lowercase__					=       """pixel_values"""
    lowercase__					=       True







    def      lowercase_			( self					:    Optional[int]		,     __snake_case					:    List[str]      ):
      if isinstance(__snake_case		,     nn.Convad      ):
        nn.init.kaiming_normal_(module.weight		,     mode='fan_out'		,     nonlinearity='relu'      )
      elif isinstance(__snake_case		,     (nn.BatchNormad, nn.GroupNorm)      ):
        nn.init.constant_(module.weight		,     1      )
        nn.init.constant_(module.bias		,     0      )







    def      lowercase_			( self					:    Union[str, Any]		,     __snake_case					:    Any		,     __snake_case					:    Optional[int]=False      ):
      if isinstance(__snake_case		,     __snake_case      ):
        a		:   List[str]	  =	value
lowerCAmelCase:   int					=		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:   Union[str, 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."""						,					lowerCamelCase__						,					)
class 				a__(   lowerCamelCase__      ):







    def __init__( self					:    Any		,     __snake_case					:    Optional[int]      ):
      super().__init__(__snake_case      )
      a		:   List[str]	  =	config
      a		:   str	  =	ResNetEmbeddings(__snake_case      )
      a		:   Dict	  =	ResNetEncoder(__snake_case      )
      a		:   int	  =	nn.AdaptiveAvgPoolad((1, 1)      )
      # Initialize weights and apply final processing
      self.post_init()







    @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      lowercase_			( self					:    Any		,     __snake_case					:    Tensor		,     __snake_case					:    Optional[bool] = None		,     __snake_case					:    Optional[bool] = None      ):
      a		:   List[str]	  =	(
          output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
      )
      a		:   List[Any]	  =	return_dict if return_dict is not None else self.config.use_return_dict

      a		:   str	  =	self.embedder(__snake_case      )

      a		:   Union[str, Any]	  =	self.encoder(
          __snake_case		,     output_hidden_states=__snake_case		,     return_dict=__snake_case      )

      a		:   str	  =	encoder_outputs[0]

      a		:   Any	  =	self.pooler(__snake_case      )

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

      return BaseModelOutputWithPoolingAndNoAttention(
          last_hidden_state=__snake_case		,     pooler_output=__snake_case		,     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.
    """						,					lowerCamelCase__						,					)
class 				a__(   lowerCamelCase__      ):







    def __init__( self					:    List[str]		,     __snake_case					:    List[Any]      ):
      super().__init__(__snake_case      )
      a		:   int	  =	config.num_labels
      a		:   Dict	  =	ResNetModel(__snake_case      )
      # classification head
      a		:   List[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(__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      lowercase_			( self					:    str		,     __snake_case					:    Optional[torch.FloatTensor] = None		,     __snake_case					:    Optional[torch.LongTensor] = None		,     __snake_case					:    Optional[bool] = None		,     __snake_case					:    Optional[bool] = None		,     ):
      a		:   Optional[int]	  =	return_dict if return_dict is not None else self.config.use_return_dict

      a		:   List[Any]	  =	self.resnet(__snake_case		,     output_hidden_states=__snake_case		,     return_dict=__snake_case      )

      a		:   List[str]	  =	outputs.pooler_output if return_dict else outputs[1]

      a		:   int	  =	self.classifier(__snake_case      )

      a		:   Dict	  =	None

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

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

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

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







    def __init__( self					:    Tuple		,     __snake_case					:    int      ):
      super().__init__(__snake_case      )
      super()._init_backbone(__snake_case      )

      a		:   Any	  =	[config.embedding_size] + config.hidden_sizes
      a		:   Union[str, Any]	  =	ResNetEmbeddings(__snake_case      )
      a		:   Any	  =	ResNetEncoder(__snake_case      )

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







    @add_start_docstrings_to_model_forward(__snake_case      )
    @replace_return_docstrings(output_type=__snake_case		,     config_class=_CONFIG_FOR_DOC      )
    def      lowercase_			( self					:    List[str]		,     __snake_case					:    Tensor		,     __snake_case					:    Optional[bool] = None		,     __snake_case					:    Optional[bool] = None      ):
      a		:   List[str]	  =	return_dict if return_dict is not None else self.config.use_return_dict
      a		:   Dict	  =	(
          output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
      )

      a		:   Optional[int]	  =	self.embedder(__snake_case      )

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

      a		:   Optional[Any]	  =	outputs.hidden_states

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

      if not return_dict:
        a		:   List[str]	  =	(feature_maps,)
        if output_hidden_states:
          output += (outputs.hidden_states,)
        return output

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




'''simple docstring'''






from __future__ import annotations
def  lowerCamelCase__			(		_A					,     _A					,     _A							):
  a		:   List[str]	  =	list(range(len(_A							)							)							)
  a		:   Union[str, Any]	  =	[v / w for v, w in zip(_A					,     _A							)]
  index.sort(key=lambda _A							: ratio[i]					,     reverse=_A							)

  a		:   float	  =	0
  a		:   list[float]	  =	[0] * len(_A							)
  for i in index:
    if weight[i] <= capacity:
      a		:   int	  =	1
      max_value += value[i]
      capacity -= weight[i]
    else:
      a		:   Optional[int]	  =	capacity / weight[i]
      max_value += value[i] * capacity / weight[i]
      break

  return max_value, fractions


if __name__ == "__main__":
     import doctest

     doctest.testmod()