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


_SCREAMING_SNAKE_CASE 		=      logging.get_logger(__name__)

# General docstring
_SCREAMING_SNAKE_CASE 		=      """ResNetConfig"""

# Base docstring
_SCREAMING_SNAKE_CASE 		=      """microsoft/resnet-50"""
_SCREAMING_SNAKE_CASE 		=      [1, 2_0_4_8, 7, 7]

# Image classification docstring
_SCREAMING_SNAKE_CASE 		=      """microsoft/resnet-50"""
_SCREAMING_SNAKE_CASE 		=      """tiger cat"""

_SCREAMING_SNAKE_CASE 		=      [
    """microsoft/resnet-50""",
    # See all resnet models at https://huggingface.co/models?filter=resnet
]
class SCREAMING_SNAKE_CASE_		(      nn.Module		):







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





    """simple docstring"""


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







   def 						lowerCamelCase_	(     self						:						Any   ,   lowerCamelCase_						:						Tensor				):





    """simple docstring"""


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





class SCREAMING_SNAKE_CASE_		(      nn.Module		):







   def __init__(     self						:						str   ,   lowerCamelCase_						:						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 						lowerCamelCase_	(     self						:						Dict   ,   lowerCamelCase_						:						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(lowerCamelCase_				)
    UpperCamelCase			  =      self.pooler(lowerCamelCase_				)
    return embedding





class SCREAMING_SNAKE_CASE_		(      nn.Module		):







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





    """simple docstring"""


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







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





    """simple docstring"""


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





class SCREAMING_SNAKE_CASE_		(      nn.Module		):







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





    """simple docstring"""


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







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





    """simple docstring"""


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





class SCREAMING_SNAKE_CASE_		(      nn.Module		):







   def __init__(     self						:						Tuple   ,   lowerCamelCase_						:						int   ,   lowerCamelCase_						:						int   ,   lowerCamelCase_						:						int = 1   ,   lowerCamelCase_						:						str = "relu"   ,   lowerCamelCase_						:						int = 4				):





    """simple docstring"""


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







   def 						lowerCamelCase_	(     self						:						Dict   ,   lowerCamelCase_						:						List[Any]				):





    """simple docstring"""


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





class SCREAMING_SNAKE_CASE_		(      nn.Module		):







   def __init__(     self						:						Union[str, Any]   ,   lowerCamelCase_						:						ResNetConfig   ,   lowerCamelCase_						:						int   ,   lowerCamelCase_						:						int   ,   lowerCamelCase_						:						int = 2   ,   lowerCamelCase_						:						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(lowerCamelCase_   ,   lowerCamelCase_   ,   stride=lowerCamelCase_   ,   activation=config.hidden_act				)   ,   *[layer(lowerCamelCase_   ,   lowerCamelCase_   ,   activation=config.hidden_act				) for _ in range(depth - 1				)]   ,   )







   def 						lowerCamelCase_	(     self						:						List[str]   ,   lowerCamelCase_						:						Tensor				):





    """simple docstring"""


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





class SCREAMING_SNAKE_CASE_		(      nn.Module		):







   def __init__(     self						:						str   ,   lowerCamelCase_						:						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(
            lowerCamelCase_   ,   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(lowerCamelCase_   ,   config.depths[1:]				):
     self.stages.append(ResNetStage(lowerCamelCase_   ,   lowerCamelCase_   ,   lowerCamelCase_   ,   depth=lowerCamelCase_				)				)







   def 						lowerCamelCase_	(     self						:						List[str]   ,   lowerCamelCase_						:						Tensor   ,   lowerCamelCase_						:						bool = False   ,   lowerCamelCase_						:						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(lowerCamelCase_				)

    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=lowerCamelCase_   ,   hidden_states=lowerCamelCase_   ,   )





class SCREAMING_SNAKE_CASE_		(      __lowerCAmelCase		):
   __lowerCAmelCase           =				ResNetConfig
   __lowerCAmelCase           =				"""resnet"""
   __lowerCAmelCase           =				"""pixel_values"""
   __lowerCAmelCase           =				True







   def 						lowerCamelCase_	(     self						:						Tuple   ,   lowerCamelCase_						:						List[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]   ,   lowerCamelCase_						:						int   ,   lowerCamelCase_						:						str=False				):





    """simple docstring"""


    if isinstance(lowerCamelCase_   ,   lowerCamelCase_				):
     UpperCamelCase			  =      value





_SCREAMING_SNAKE_CASE 		=      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.
"""

_SCREAMING_SNAKE_CASE 		=      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."""  ,     __lowerCAmelCase  ,     )
class SCREAMING_SNAKE_CASE_		(      __lowerCAmelCase		):







   def __init__(     self						:						str   ,   lowerCamelCase_						:						List[str]				):





    """simple docstring"""


    super().__init__(lowerCamelCase_				)
    UpperCamelCase			  =      config
    UpperCamelCase			  =      ResNetEmbeddings(lowerCamelCase_				)
    UpperCamelCase			  =      ResNetEncoder(lowerCamelCase_				)
    UpperCamelCase			  =      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						:						Optional[int]   ,   lowerCamelCase_						:						Tensor   ,   lowerCamelCase_						:						Optional[bool] = None   ,   lowerCamelCase_						:						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(lowerCamelCase_				)

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

    UpperCamelCase			  =      encoder_outputs[0]

    UpperCamelCase			  =      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.
    """  ,     __lowerCAmelCase  ,     )
class SCREAMING_SNAKE_CASE_		(      __lowerCAmelCase		):







   def __init__(     self						:						Union[str, Any]   ,   lowerCamelCase_						:						Optional[Any]				):





    """simple docstring"""


    super().__init__(lowerCamelCase_				)
    UpperCamelCase			  =      config.num_labels
    UpperCamelCase			  =      ResNetModel(lowerCamelCase_				)
    # 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(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						:						Tuple   ,   lowerCamelCase_						:						Optional[torch.FloatTensor] = None   ,   lowerCamelCase_						:						Optional[torch.LongTensor] = None   ,   lowerCamelCase_						:						Optional[bool] = None   ,   lowerCamelCase_						:						Optional[bool] = None   ,   ):





    """simple docstring"""


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

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

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

    UpperCamelCase			  =      self.classifier(lowerCamelCase_				)

    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(lowerCamelCase_   ,   lowerCamelCase_				)
     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(lowerCamelCase_   ,   lowerCamelCase_				)

    if not return_dict:
     UpperCamelCase			  =      (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.
    """  ,     __lowerCAmelCase  ,     )
class SCREAMING_SNAKE_CASE_		(      __lowerCAmelCase  ,     __lowerCAmelCase		):







   def __init__(     self						:						Tuple   ,   lowerCamelCase_						:						int				):





    """simple docstring"""


    super().__init__(lowerCamelCase_				)
    super()._init_backbone(lowerCamelCase_				)

    UpperCamelCase			  =      [config.embedding_size] + config.hidden_sizes
    UpperCamelCase			  =      ResNetEmbeddings(lowerCamelCase_				)
    UpperCamelCase			  =      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]   ,   lowerCamelCase_						:						Tensor   ,   lowerCamelCase_						:						Optional[bool] = None   ,   lowerCamelCase_						:						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(lowerCamelCase_				)

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

    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=lowerCamelCase_   ,   hidden_states=outputs.hidden_states if output_hidden_states else None   ,   attentions=lowerCamelCase_   ,   )

def 			lowercase(	UpperCamelCase_							,					UpperCamelCase_							,					UpperCamelCase_       )		->	list:







 '''simple docstring'''
 UpperCamelCase			  =      len(UpperCamelCase_       )
 UpperCamelCase			  =      [[0] * n for i in range(UpperCamelCase_       )]
 for i in range(UpperCamelCase_       ):
  UpperCamelCase			  =      y_points[i]

 for i in range(2							,					UpperCamelCase_       ):
  for j in range(UpperCamelCase_							,					UpperCamelCase_       ):
   UpperCamelCase			  =      (
       (xa - x_points[j - i + 1]) * q[j][i - 1]
       - (xa - x_points[j]) * q[j - 1][i - 1]
   ) / (x_points[j] - x_points[j - i + 1])

 return [q[n - 1][n - 1], q]


if __name__ == "__main__":
     import doctest

     doctest.testmod()
