


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     UpperCAmelCase__       (					nn.Module		):



    """simple docstring"""






    def __init__(			self					,   A_					,   A_					,   A_ = 3					,   A_ = 1					,   A_ = "relu"    )  ->       Optional[Any]:
         super().__init__()
         __UpperCamelCase    							=nn.Convad(
             A_					,   A_					,   kernel_size=A_					,   stride=A_					,   padding=kernel_size // 2					,   bias=A_    )
         __UpperCamelCase    							=nn.BatchNormad(A_    )
         __UpperCamelCase    							=ACTaFN[activation] if activation is not None else nn.Identity()






    def _a					(			self					,   A_    )  ->       Tensor:
         __UpperCamelCase    							=self.convolution(A_    )
         __UpperCamelCase    							=self.normalization(A_    )
         __UpperCamelCase    							=self.activation(A_    )
         return hidden_state






class     UpperCAmelCase__       (					nn.Module		):



    """simple docstring"""






    def __init__(			self					,   A_    )  ->       int:
         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					,   A_    )  ->       Tensor:
         __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(A_    )
         __UpperCamelCase    							=self.pooler(A_    )
         return embedding






class     UpperCAmelCase__       (					nn.Module		):



    """simple docstring"""






    def __init__(			self					,   A_					,   A_					,   A_ = 2    )  ->       Optional[int]:
         super().__init__()
         __UpperCamelCase    							=nn.Convad(A_					,   A_					,   kernel_size=1					,   stride=A_					,   bias=A_    )
         __UpperCamelCase    							=nn.BatchNormad(A_    )






    def _a					(			self					,   A_    )  ->       Tensor:
         __UpperCamelCase    							=self.convolution(A_    )
         __UpperCamelCase    							=self.normalization(A_    )
         return hidden_state






class     UpperCAmelCase__       (					nn.Module		):



    """simple docstring"""






    def __init__(			self					,   A_					,   A_					,   A_ = 1					,   A_ = "relu"    )  ->       Tuple:
         super().__init__()
         __UpperCamelCase    							=in_channels != out_channels or stride != 1
         __UpperCamelCase    							=(
             ResNetShortCut(A_					,   A_					,   stride=A_    ) if should_apply_shortcut else nn.Identity()
         )
         __UpperCamelCase    							=nn.Sequential(
             ResNetConvLayer(A_					,   A_					,   stride=A_    )					,   ResNetConvLayer(A_					,   A_					,   activation=A_    )					,   )
         __UpperCamelCase    							=ACTaFN[activation]






    def _a					(			self					,   A_    )  ->       List[Any]:
         __UpperCamelCase    							=hidden_state
         __UpperCamelCase    							=self.layer(A_    )
         __UpperCamelCase    							=self.shortcut(A_    )
         hidden_state += residual
         __UpperCamelCase    							=self.activation(A_    )
         return hidden_state






class     UpperCAmelCase__       (					nn.Module		):



    """simple docstring"""






    def __init__(			self					,   A_					,   A_					,   A_ = 1					,   A_ = "relu"					,   A_ = 4    )  ->       Tuple:
         super().__init__()
         __UpperCamelCase    							=in_channels != out_channels or stride != 1
         __UpperCamelCase    							=out_channels // reduction
         __UpperCamelCase    							=(
             ResNetShortCut(A_					,   A_					,   stride=A_    ) if should_apply_shortcut else nn.Identity()
         )
         __UpperCamelCase    							=nn.Sequential(
             ResNetConvLayer(A_					,   A_					,   kernel_size=1    )					,   ResNetConvLayer(A_					,   A_					,   stride=A_    )					,   ResNetConvLayer(A_					,   A_					,   kernel_size=1					,   activation=A_    )					,   )
         __UpperCamelCase    							=ACTaFN[activation]






    def _a					(			self					,   A_    )  ->       int:
         __UpperCamelCase    							=hidden_state
         __UpperCamelCase    							=self.layer(A_    )
         __UpperCamelCase    							=self.shortcut(A_    )
         hidden_state += residual
         __UpperCamelCase    							=self.activation(A_    )
         return hidden_state






class     UpperCAmelCase__       (					nn.Module		):



    """simple docstring"""






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






    def _a					(			self					,   A_    )  ->       Tensor:
         __UpperCamelCase    							=input
         for layer in self.layers:
              __UpperCamelCase    							=layer(A_    )
         return hidden_state






class     UpperCAmelCase__       (					nn.Module		):



    """simple docstring"""






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






    def _a					(			self					,   A_					,   A_ = False					,   A_ = True    )  ->       BaseModelOutputWithNoAttention:
         __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(A_    )

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






class     UpperCAmelCase__       (					A_		):



    """simple docstring"""






    UpperCAmelCase__						:		List[Any]      =  ResNetConfig
    UpperCAmelCase__						:		Any      =  "resnet"
    UpperCAmelCase__						:		Optional[int]      =  "pixel_values"
    UpperCAmelCase__						:		List[str]      =  True






    def _a					(			self					,   A_    )  ->       str:
         if isinstance(A_					,   nn.Convad    ):
              nn.init.kaiming_normal_(module.weight					,   mode='fan_out'					,   nonlinearity='relu'    )
         elif isinstance(A_					,   (nn.BatchNormad, nn.GroupNorm)    ):
              nn.init.constant_(module.weight					,   1    )
              nn.init.constant_(module.bias					,   0    )






    def _a					(			self					,   A_					,   A_=False    )  ->       str:
         if isinstance(A_					,   A_    ):
              __UpperCamelCase    							=value
_A		       =						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'

_A		       =						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     UpperCAmelCase__       (					A_		):



    """simple docstring"""






    def __init__(			self					,   A_    )  ->       List[Any]:
         super().__init__(A_    )
         __UpperCamelCase    							=config
         __UpperCamelCase    							=ResNetEmbeddings(A_    )
         __UpperCamelCase    							=ResNetEncoder(A_    )
         __UpperCamelCase    							=nn.AdaptiveAvgPoolad((1, 1)    )
         # Initialize weights and apply final processing
         self.post_init()






    @add_start_docstrings_to_model_forward(A_    )
    @add_code_sample_docstrings(
        checkpoint=_CHECKPOINT_FOR_DOC					,   output_type=A_					,   config_class=_CONFIG_FOR_DOC					,   modality='vision'					,   expected_output=_EXPECTED_OUTPUT_SHAPE					,   )
    def _a					(			self					,   A_					,   A_ = None					,   A_ = None    )  ->       BaseModelOutputWithPoolingAndNoAttention:
         __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(A_    )

         __UpperCamelCase    							=self.encoder(
             A_					,   output_hidden_states=A_					,   return_dict=A_    )

         __UpperCamelCase    							=encoder_outputs[0]

         __UpperCamelCase    							=self.pooler(A_    )

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

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






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



    """simple docstring"""






    def __init__(			self					,   A_    )  ->       List[Any]:
         super().__init__(A_    )
         __UpperCamelCase    							=config.num_labels
         __UpperCamelCase    							=ResNetModel(A_    )
         # 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(A_    )
    @add_code_sample_docstrings(
        checkpoint=_IMAGE_CLASS_CHECKPOINT					,   output_type=A_					,   config_class=_CONFIG_FOR_DOC					,   expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT					,   )
    def _a					(			self					,   A_ = None					,   A_ = None					,   A_ = None					,   A_ = None					,   )  ->       ImageClassifierOutputWithNoAttention:
         __UpperCamelCase    							=return_dict if return_dict is not None else self.config.use_return_dict

         __UpperCamelCase    							=self.resnet(A_					,   output_hidden_states=A_					,   return_dict=A_    )

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

         __UpperCamelCase    							=self.classifier(A_    )

         __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(A_					,   A_    )
              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(A_					,   A_    )

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

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






@add_start_docstrings(
    "\n    ResNet backbone, to be used with frameworks like DETR and MaskFormer.\n    "   ,  A_   ,  )
class     UpperCAmelCase__       (					A_   ,  A_		):



    """simple docstring"""






    def __init__(			self					,   A_    )  ->       List[Any]:
         super().__init__(A_    )
         super()._init_backbone(A_    )

         __UpperCamelCase    							=[config.embedding_size] + config.hidden_sizes
         __UpperCamelCase    							=ResNetEmbeddings(A_    )
         __UpperCamelCase    							=ResNetEncoder(A_    )

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






    @add_start_docstrings_to_model_forward(A_    )
    @replace_return_docstrings(output_type=A_					,   config_class=_CONFIG_FOR_DOC    )
    def _a					(			self					,   A_					,   A_ = None					,   A_ = None    )  ->       BackboneOutput:
         __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(A_    )

         __UpperCamelCase    							=self.encoder(A_					,   output_hidden_states=A_					,   return_dict=A_    )

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









from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


_A		       =						{
    'configuration_jukebox': [
        'JUKEBOX_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'JukeboxConfig',
        'JukeboxPriorConfig',
        'JukeboxVQVAEConfig',
    ],
    'tokenization_jukebox': ['JukeboxTokenizer'],
}

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   _A		       =						[
       'JUKEBOX_PRETRAINED_MODEL_ARCHIVE_LIST',
       'JukeboxModel',
       'JukeboxPreTrainedModel',
       'JukeboxVQVAE',
       'JukeboxPrior',
   ]

if TYPE_CHECKING:
   from .configuration_jukebox import (
       JUKEBOX_PRETRAINED_CONFIG_ARCHIVE_MAP,
       JukeboxConfig,
       JukeboxPriorConfig,
       JukeboxVQVAEConfig,
   )
   from .tokenization_jukebox import JukeboxTokenizer

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_jukebox import (
          JUKEBOX_PRETRAINED_MODEL_ARCHIVE_LIST,
          JukeboxModel,
          JukeboxPreTrainedModel,
          JukeboxPrior,
          JukeboxVQVAE,
      )

else:
   import sys

   _A		       =						_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)





