





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


a_			=      logging.get_logger(__name__)

# General docstring
a_			=      """ResNetConfig"""

# Base docstring
a_			=      """microsoft/resnet-50"""
a_			=      [1, 2048, 7, 7]

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

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






class 		__snake_case (		nn.Module					):





 """simple docstring"""


 def __init__(   self ,						__lowerCamelCase ,						__lowerCamelCase ,						__lowerCamelCase = 3 ,						__lowerCamelCase = 1 ,						__lowerCamelCase = "relu"  ):



     '''simple docstring'''




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







 def  UpperCamelCase__(   self ,						__lowerCamelCase  ):



     '''simple docstring'''




     __A   :						Union[str, Any]									=					self.convolution(__lowerCamelCase  )
     __A   :						int									=					self.normalization(__lowerCamelCase  )
     __A   :						List[Any]									=					self.activation(__lowerCamelCase  )
     return hidden_state






class 		__snake_case (		nn.Module					):





 """simple docstring"""


 def __init__(   self ,						__lowerCamelCase  ):



     '''simple docstring'''




     super().__init__()
     __A   :						List[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   :						Tuple									=					config.num_channels







 def  UpperCamelCase__(   self ,						__lowerCamelCase  ):



     '''simple docstring'''




     __A   :						List[Any]									=					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   :						List[Any]									=					self.embedder(__lowerCamelCase  )
     __A   :						Dict									=					self.pooler(__lowerCamelCase  )
     return embedding






class 		__snake_case (		nn.Module					):





 """simple docstring"""


 def __init__(   self ,						__lowerCamelCase ,						__lowerCamelCase ,						__lowerCamelCase = 2  ):



     '''simple docstring'''




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







 def  UpperCamelCase__(   self ,						__lowerCamelCase  ):



     '''simple docstring'''




     __A   :						Tuple									=					self.convolution(__lowerCamelCase  )
     __A   :						Union[str, Any]									=					self.normalization(__lowerCamelCase  )
     return hidden_state






class 		__snake_case (		nn.Module					):





 """simple docstring"""


 def __init__(   self ,						__lowerCamelCase ,						__lowerCamelCase ,						__lowerCamelCase = 1 ,						__lowerCamelCase = "relu"  ):



     '''simple docstring'''




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







 def  UpperCamelCase__(   self ,						__lowerCamelCase  ):



     '''simple docstring'''




     __A   :						List[str]									=					hidden_state
     __A   :						str									=					self.layer(__lowerCamelCase  )
     __A   :						List[Any]									=					self.shortcut(__lowerCamelCase  )
     hidden_state += residual
     __A   :						Optional[Any]									=					self.activation(__lowerCamelCase  )
     return hidden_state






class 		__snake_case (		nn.Module					):





 """simple docstring"""


 def __init__(   self ,						__lowerCamelCase ,						__lowerCamelCase ,						__lowerCamelCase = 1 ,						__lowerCamelCase = "relu" ,						__lowerCamelCase = 4  ):



     '''simple docstring'''




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







 def  UpperCamelCase__(   self ,						__lowerCamelCase  ):



     '''simple docstring'''




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






class 		__snake_case (		nn.Module					):





 """simple docstring"""


 def __init__(   self ,						__lowerCamelCase ,						__lowerCamelCase ,						__lowerCamelCase ,						__lowerCamelCase = 2 ,						__lowerCamelCase = 2 ,						):



     '''simple docstring'''




     super().__init__()

     __A   :						List[str]									=					ResNetBottleNeckLayer if config.layer_type == '''bottleneck''' else ResNetBasicLayer

     __A   :						int									=					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  UpperCamelCase__(   self ,						__lowerCamelCase  ):



     '''simple docstring'''




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






class 		__snake_case (		nn.Module					):





 """simple docstring"""


 def __init__(   self ,						__lowerCamelCase  ):



     '''simple docstring'''




     super().__init__()
     __A   :						Tuple									=					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[Any]									=					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  UpperCamelCase__(   self ,						__lowerCamelCase ,						__lowerCamelCase = False ,						__lowerCamelCase = True  ):



     '''simple docstring'''




     __A   :						int									=					() if output_hidden_states else None

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

         __A   :						Any									=					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 (		SCREAMING_SNAKE_CASE__					):





 """simple docstring"""


 _lowerCamelCase				=					ResNetConfig
 _lowerCamelCase				=					"""resnet"""
 _lowerCamelCase				=					"""pixel_values"""
 _lowerCamelCase				=					True

 def  UpperCamelCase__(   self ,						__lowerCamelCase  ):



     '''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  UpperCamelCase__(   self ,						__lowerCamelCase ,						__lowerCamelCase=False  ):



     '''simple docstring'''




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






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

a_			=      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."""							,							SCREAMING_SNAKE_CASE__							,							)
class 		__snake_case (		SCREAMING_SNAKE_CASE__					):





 """simple docstring"""


 def __init__(   self ,						__lowerCamelCase  ):



     '''simple docstring'''




     super().__init__(__lowerCamelCase  )
     __A   :						List[str]									=					config
     __A   :						Dict									=					ResNetEmbeddings(__lowerCamelCase  )
     __A   :						List[Any]									=					ResNetEncoder(__lowerCamelCase  )
     __A   :						Optional[Any]									=					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  UpperCamelCase__(   self ,						__lowerCamelCase ,						__lowerCamelCase = None ,						__lowerCamelCase = None  ):



     '''simple docstring'''




     __A   :						Optional[Any]									=					(
         output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
     )
     __A   :						str									=					return_dict if return_dict is not None else self.config.use_return_dict

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

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

     __A   :						Tuple									=					encoder_outputs[0]

     __A   :						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.
    """							,							SCREAMING_SNAKE_CASE__							,							)
class 		__snake_case (		SCREAMING_SNAKE_CASE__					):





 """simple docstring"""


 def __init__(   self ,						__lowerCamelCase  ):



     '''simple docstring'''




     super().__init__(__lowerCamelCase  )
     __A   :						Union[str, Any]									=					config.num_labels
     __A   :						Tuple									=					ResNetModel(__lowerCamelCase  )
     # classification head
     __A   :						int									=					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  UpperCamelCase__(   self ,						__lowerCamelCase = None ,						__lowerCamelCase = None ,						__lowerCamelCase = None ,						__lowerCamelCase = None ,						):



     '''simple docstring'''




     __A   :						Optional[int]									=					return_dict if return_dict is not None else self.config.use_return_dict

     __A   :						int									=					self.resnet(__lowerCamelCase ,						output_hidden_states=__lowerCamelCase ,						return_dict=__lowerCamelCase  )

     __A   :						Union[str, Any]									=					outputs.pooler_output if return_dict else outputs[1]

     __A   :						List[str]									=					self.classifier(__lowerCamelCase  )

     __A   :						Any									=					None

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

     if not return_dict:
         __A   :						Optional[Any]									=					(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.
    """							,							SCREAMING_SNAKE_CASE__							,							)
class 		__snake_case (		SCREAMING_SNAKE_CASE__							,							SCREAMING_SNAKE_CASE__					):





 """simple docstring"""


 def __init__(   self ,						__lowerCamelCase  ):



     '''simple docstring'''




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

     __A   :						Any									=					[config.embedding_size] + config.hidden_sizes
     __A   :						Optional[Any]									=					ResNetEmbeddings(__lowerCamelCase  )
     __A   :						Optional[int]									=					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  UpperCamelCase__(   self ,						__lowerCamelCase ,						__lowerCamelCase = None ,						__lowerCamelCase = None  ):



     '''simple docstring'''




     __A   :						List[str]									=					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   :						Union[str, Any]									=					self.embedder(__lowerCamelCase  )

     __A   :						List[Any]									=					self.encoder(__lowerCamelCase ,						output_hidden_states=__lowerCamelCase ,						return_dict=__lowerCamelCase  )

     __A   :						Tuple									=					outputs.hidden_states

     __A   :						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   :						str									=					(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"""



from typing import TYPE_CHECKING

from ..utils import _LazyModule


a_			=      {
    """config""": [
        """EXTERNAL_DATA_FORMAT_SIZE_LIMIT""",
        """OnnxConfig""",
        """OnnxConfigWithPast""",
        """OnnxSeq2SeqConfigWithPast""",
        """PatchingSpec""",
    ],
    """convert""": ["""export""", """validate_model_outputs"""],
    """features""": ["""FeaturesManager"""],
    """utils""": ["""ParameterFormat""", """compute_serialized_parameters_size"""],
}


if TYPE_CHECKING:
       from .config import (
           EXTERNAL_DATA_FORMAT_SIZE_LIMIT,
           OnnxConfig,
           OnnxConfigWithPast,
           OnnxSeqaSeqConfigWithPast,
           PatchingSpec,
       )
       from .convert import export, validate_model_outputs
       from .features import FeaturesManager
       from .utils import ParameterFormat, compute_serialized_parameters_size

else:
       import sys

       a_			=      _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)




