


'''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 ...file_utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward
from ...modeling_outputs import (
    BaseModelOutputWithNoAttention,
    BaseModelOutputWithPoolingAndNoAttention,
    ImageClassifierOutputWithNoAttention,
)
from ...modeling_utils import PreTrainedModel
from ...utils import logging
from .configuration_regnet import RegNetConfig


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

# General docstring
_a   :   Optional[Any]												=   "RegNetConfig"

# Base docstring
_a   :   int												=   "facebook/regnet-y-040"
_a   :   Tuple												=   [1, 1_088, 7, 7]

# Image classification docstring
_a   :   List[str]												=   "facebook/regnet-y-040"
_a   :   Any												=   "tabby, tabby cat"

_a   :   Tuple												=   [
    "facebook/regnet-y-040",
    # See all regnet models at https://huggingface.co/models?filter=regnet
]




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





   def a  (						self       :      int       ,   SCREAMING_SNAKE_CASE_       :      Dict      ) ->							Dict:
        __snake_case           =						self.convolution(SCREAMING_SNAKE_CASE_      )
        __snake_case           =						self.normalization(SCREAMING_SNAKE_CASE_      )
        __snake_case           =						self.activation(SCREAMING_SNAKE_CASE_      )
        return hidden_state




class 			_lowercase (	nn.Module							):
   def __init__(						self       :      Tuple       ,   SCREAMING_SNAKE_CASE_       :      RegNetConfig      ) ->							Dict:
        super().__init__()
        __snake_case           =						RegNetConvLayer(
            config.num_channels       ,   config.embedding_size       ,   kernel_size=3       ,   stride=2       ,   activation=config.hidden_act      )
        __snake_case           =						config.num_channels





   def a  (						self       :      int       ,   SCREAMING_SNAKE_CASE_       :      Optional[Any]      ) ->							Dict:
        __snake_case           =						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.'      )
        __snake_case           =						self.embedder(SCREAMING_SNAKE_CASE_      )
        return hidden_state




class 			_lowercase (	nn.Module							):
   def __init__(						self       :      Tuple       ,   SCREAMING_SNAKE_CASE_       :      int       ,   SCREAMING_SNAKE_CASE_       :      int       ,   SCREAMING_SNAKE_CASE_       :      int = 2      ) ->							List[str]:
        super().__init__()
        __snake_case           =						nn.Convad(SCREAMING_SNAKE_CASE_       ,   SCREAMING_SNAKE_CASE_       ,   kernel_size=1       ,   stride=SCREAMING_SNAKE_CASE_       ,   bias=SCREAMING_SNAKE_CASE_      )
        __snake_case           =						nn.BatchNormad(SCREAMING_SNAKE_CASE_      )





   def a  (						self       :      List[Any]       ,   SCREAMING_SNAKE_CASE_       :      Tensor      ) ->							Tensor:
        __snake_case           =						self.convolution(SCREAMING_SNAKE_CASE_      )
        __snake_case           =						self.normalization(SCREAMING_SNAKE_CASE_      )
        return hidden_state




class 			_lowercase (	nn.Module							):
   def __init__(						self       :      Dict       ,   SCREAMING_SNAKE_CASE_       :      int       ,   SCREAMING_SNAKE_CASE_       :      int      ) ->							int:
        super().__init__()

        __snake_case           =						nn.AdaptiveAvgPoolad((1, 1)      )
        __snake_case           =						nn.Sequential(
            nn.Convad(SCREAMING_SNAKE_CASE_       ,   SCREAMING_SNAKE_CASE_       ,   kernel_size=1      )       ,   nn.ReLU()       ,   nn.Convad(SCREAMING_SNAKE_CASE_       ,   SCREAMING_SNAKE_CASE_       ,   kernel_size=1      )       ,   nn.Sigmoid()       ,   )





   def a  (						self       :      Optional[Any]       ,   SCREAMING_SNAKE_CASE_       :      Union[str, Any]      ) ->							List[Any]:
        # b c h w -> b c 1 1
        __snake_case           =						self.pooler(SCREAMING_SNAKE_CASE_      )
        __snake_case           =						self.attention(SCREAMING_SNAKE_CASE_      )
        __snake_case           =						hidden_state * attention
        return hidden_state




class 			_lowercase (	nn.Module							):
   def __init__(						self       :      List[Any]       ,   SCREAMING_SNAKE_CASE_       :      RegNetConfig       ,   SCREAMING_SNAKE_CASE_       :      int       ,   SCREAMING_SNAKE_CASE_       :      int       ,   SCREAMING_SNAKE_CASE_       :      int = 1      ) ->							Tuple:
        super().__init__()
        __snake_case           =						in_channels != out_channels or stride != 1
        __snake_case           =						max(1       ,   out_channels // config.groups_width      )
        __snake_case           =						(
            RegNetShortCut(SCREAMING_SNAKE_CASE_       ,   SCREAMING_SNAKE_CASE_       ,   stride=SCREAMING_SNAKE_CASE_      ) if should_apply_shortcut else nn.Identity()
        )
        __snake_case           =						nn.Sequential(
            RegNetConvLayer(SCREAMING_SNAKE_CASE_       ,   SCREAMING_SNAKE_CASE_       ,   kernel_size=1       ,   activation=config.hidden_act      )       ,   RegNetConvLayer(SCREAMING_SNAKE_CASE_       ,   SCREAMING_SNAKE_CASE_       ,   stride=SCREAMING_SNAKE_CASE_       ,   groups=SCREAMING_SNAKE_CASE_       ,   activation=config.hidden_act      )       ,   RegNetConvLayer(SCREAMING_SNAKE_CASE_       ,   SCREAMING_SNAKE_CASE_       ,   kernel_size=1       ,   activation=SCREAMING_SNAKE_CASE_      )       ,   )
        __snake_case           =						ACTaFN[config.hidden_act]





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




class 			_lowercase (	nn.Module							):
   def __init__(						self       :      Any       ,   SCREAMING_SNAKE_CASE_       :      RegNetConfig       ,   SCREAMING_SNAKE_CASE_       :      int       ,   SCREAMING_SNAKE_CASE_       :      int       ,   SCREAMING_SNAKE_CASE_       :      int = 1      ) ->							Optional[Any]:
        super().__init__()
        __snake_case           =						in_channels != out_channels or stride != 1
        __snake_case           =						max(1       ,   out_channels // config.groups_width      )
        __snake_case           =						(
            RegNetShortCut(SCREAMING_SNAKE_CASE_       ,   SCREAMING_SNAKE_CASE_       ,   stride=SCREAMING_SNAKE_CASE_      ) if should_apply_shortcut else nn.Identity()
        )
        __snake_case           =						nn.Sequential(
            RegNetConvLayer(SCREAMING_SNAKE_CASE_       ,   SCREAMING_SNAKE_CASE_       ,   kernel_size=1       ,   activation=config.hidden_act      )       ,   RegNetConvLayer(SCREAMING_SNAKE_CASE_       ,   SCREAMING_SNAKE_CASE_       ,   stride=SCREAMING_SNAKE_CASE_       ,   groups=SCREAMING_SNAKE_CASE_       ,   activation=config.hidden_act      )       ,   RegNetSELayer(SCREAMING_SNAKE_CASE_       ,   reduced_channels=int(round(in_channels / 4      )      )      )       ,   RegNetConvLayer(SCREAMING_SNAKE_CASE_       ,   SCREAMING_SNAKE_CASE_       ,   kernel_size=1       ,   activation=SCREAMING_SNAKE_CASE_      )       ,   )
        __snake_case           =						ACTaFN[config.hidden_act]





   def a  (						self       :      Optional[int]       ,   SCREAMING_SNAKE_CASE_       :      int      ) ->							Tuple:
        __snake_case           =						hidden_state
        __snake_case           =						self.layer(SCREAMING_SNAKE_CASE_      )
        __snake_case           =						self.shortcut(SCREAMING_SNAKE_CASE_      )
        hidden_state += residual
        __snake_case           =						self.activation(SCREAMING_SNAKE_CASE_      )
        return hidden_state




class 			_lowercase (	nn.Module							):
   def __init__(						self       :      Optional[int]       ,   SCREAMING_SNAKE_CASE_       :      RegNetConfig       ,   SCREAMING_SNAKE_CASE_       :      int       ,   SCREAMING_SNAKE_CASE_       :      int       ,   SCREAMING_SNAKE_CASE_       :      int = 2       ,   SCREAMING_SNAKE_CASE_       :      int = 2       ,   ) ->							Any:
        super().__init__()

        __snake_case           =						RegNetXLayer if config.layer_type == 'x' else RegNetYLayer

        __snake_case           =						nn.Sequential(
            # downsampling is done in the first layer with stride of 2
            layer(
                SCREAMING_SNAKE_CASE_       ,   SCREAMING_SNAKE_CASE_       ,   SCREAMING_SNAKE_CASE_       ,   stride=SCREAMING_SNAKE_CASE_       ,   )       ,   *[layer(SCREAMING_SNAKE_CASE_       ,   SCREAMING_SNAKE_CASE_       ,   SCREAMING_SNAKE_CASE_      ) for _ in range(depth - 1      )]       ,   )





   def a  (						self       :      List[Any]       ,   SCREAMING_SNAKE_CASE_       :      str      ) ->							Any:
        __snake_case           =						self.layers(SCREAMING_SNAKE_CASE_      )
        return hidden_state




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





   def a  (						self       :      Union[str, Any]       ,   SCREAMING_SNAKE_CASE_       :      Tensor       ,   SCREAMING_SNAKE_CASE_       :      bool = False       ,   SCREAMING_SNAKE_CASE_       :      bool = True      ) ->							BaseModelOutputWithNoAttention:
        __snake_case           =						() if output_hidden_states else None

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

             __snake_case           =						stage_module(SCREAMING_SNAKE_CASE_      )

        if output_hidden_states:
             __snake_case           =						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=SCREAMING_SNAKE_CASE_       ,   hidden_states=SCREAMING_SNAKE_CASE_      )




class 			_lowercase (	__lowercase							):
   _SCREAMING_SNAKE_CASE  :  Optional[Any]          =	RegNetConfig
   _SCREAMING_SNAKE_CASE  :  Optional[int]          =	"regnet"
   _SCREAMING_SNAKE_CASE  :  int          =	"pixel_values"
   _SCREAMING_SNAKE_CASE  :  Optional[int]          =	True
   def a  (						self       :      Union[str, Any]       ,   SCREAMING_SNAKE_CASE_       :      Any      ) ->							Optional[Any]:
        if isinstance(SCREAMING_SNAKE_CASE_       ,   nn.Convad      ):
             nn.init.kaiming_normal_(module.weight       ,   mode='fan_out'       ,   nonlinearity='relu'      )
        elif isinstance(SCREAMING_SNAKE_CASE_       ,   (nn.BatchNormad, nn.GroupNorm)      ):
             nn.init.constant_(module.weight       ,   1      )
             nn.init.constant_(module.bias       ,   0      )





   def a  (						self       :      int       ,   SCREAMING_SNAKE_CASE_       :      Tuple       ,   SCREAMING_SNAKE_CASE_       :      Tuple=False      ) ->							Tuple:
        if isinstance(SCREAMING_SNAKE_CASE_       ,   SCREAMING_SNAKE_CASE_      ):
             __snake_case           =						value




_a   :   Union[str, Any]												=   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 ([`RegNetConfig`]): 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   :   Dict												=   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 [`~file_utils.ModelOutput`] instead of a plain tuple.\n"




@add_start_docstrings(
    "The bare RegNet model outputting raw features without any specific head on top."						,					__lowercase						,					)
# Copied from transformers.models.resnet.modeling_resnet.ResNetModel with RESNET->REGNET,ResNet->RegNet
class 			_lowercase (	__lowercase							):
   def __init__(						self       :      Optional[Any]       ,   SCREAMING_SNAKE_CASE_       :      List[Any]      ) ->							Tuple:
        super().__init__(SCREAMING_SNAKE_CASE_      )
        __snake_case           =						config
        __snake_case           =						RegNetEmbeddings(SCREAMING_SNAKE_CASE_      )
        __snake_case           =						RegNetEncoder(SCREAMING_SNAKE_CASE_      )
        __snake_case           =						nn.AdaptiveAvgPoolad((1, 1)      )
        # Initialize weights and apply final processing
        self.post_init()





   @add_start_docstrings_to_model_forward(SCREAMING_SNAKE_CASE_      )
   @add_code_sample_docstrings(
       checkpoint=_CHECKPOINT_FOR_DOC       ,   output_type=SCREAMING_SNAKE_CASE_       ,   config_class=_CONFIG_FOR_DOC       ,   modality='vision'       ,   expected_output=_EXPECTED_OUTPUT_SHAPE       ,   )
   def a  (						self       :      List[Any]       ,   SCREAMING_SNAKE_CASE_       :      Tensor       ,   SCREAMING_SNAKE_CASE_       :      Optional[bool] = None       ,   SCREAMING_SNAKE_CASE_       :      Optional[bool] = None      ) ->							BaseModelOutputWithPoolingAndNoAttention:
        __snake_case           =						(
            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
        )
        __snake_case           =						return_dict if return_dict is not None else self.config.use_return_dict

        __snake_case           =						self.embedder(SCREAMING_SNAKE_CASE_      )

        __snake_case           =						self.encoder(
            SCREAMING_SNAKE_CASE_       ,   output_hidden_states=SCREAMING_SNAKE_CASE_       ,   return_dict=SCREAMING_SNAKE_CASE_      )

        __snake_case           =						encoder_outputs[0]

        __snake_case           =						self.pooler(SCREAMING_SNAKE_CASE_      )

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

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




@add_start_docstrings(
    "\n    RegNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for\n    ImageNet.\n    "						,					__lowercase						,					)
# Copied from transformers.models.resnet.modeling_resnet.ResNetForImageClassification with RESNET->REGNET,ResNet->RegNet,resnet->regnet
class 			_lowercase (	__lowercase							):
   def __init__(						self       :      Union[str, Any]       ,   SCREAMING_SNAKE_CASE_       :      Tuple      ) ->							Any:
        super().__init__(SCREAMING_SNAKE_CASE_      )
        __snake_case           =						config.num_labels
        __snake_case           =						RegNetModel(SCREAMING_SNAKE_CASE_      )
        # classification head
        __snake_case           =						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(SCREAMING_SNAKE_CASE_      )
   @add_code_sample_docstrings(
       checkpoint=_IMAGE_CLASS_CHECKPOINT       ,   output_type=SCREAMING_SNAKE_CASE_       ,   config_class=_CONFIG_FOR_DOC       ,   expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT       ,   )
   def a  (						self       :      int       ,   SCREAMING_SNAKE_CASE_       :      Optional[torch.FloatTensor] = None       ,   SCREAMING_SNAKE_CASE_       :      Optional[torch.LongTensor] = None       ,   SCREAMING_SNAKE_CASE_       :      Optional[bool] = None       ,   SCREAMING_SNAKE_CASE_       :      Optional[bool] = None       ,   ) ->							ImageClassifierOutputWithNoAttention:
        __snake_case           =						return_dict if return_dict is not None else self.config.use_return_dict

        __snake_case           =						self.regnet(SCREAMING_SNAKE_CASE_       ,   output_hidden_states=SCREAMING_SNAKE_CASE_       ,   return_dict=SCREAMING_SNAKE_CASE_      )

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

        __snake_case           =						self.classifier(SCREAMING_SNAKE_CASE_      )

        __snake_case           =						None

        if labels is not None:
             if self.config.problem_type is None:
                  if self.num_labels == 1:
                       __snake_case           =						'regression'
                  elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
                       __snake_case           =						'single_label_classification'
                  else:
                       __snake_case           =						'multi_label_classification'
             if self.config.problem_type == "regression":
                  __snake_case           =						MSELoss()
                  if self.num_labels == 1:
                       __snake_case           =						loss_fct(logits.squeeze()       ,   labels.squeeze()      )
                  else:
                       __snake_case           =						loss_fct(SCREAMING_SNAKE_CASE_       ,   SCREAMING_SNAKE_CASE_      )
             elif self.config.problem_type == "single_label_classification":
                  __snake_case           =						CrossEntropyLoss()
                  __snake_case           =						loss_fct(logits.view(-1       ,   self.num_labels      )       ,   labels.view(-1      )      )
             elif self.config.problem_type == "multi_label_classification":
                  __snake_case           =						BCEWithLogitsLoss()
                  __snake_case           =						loss_fct(SCREAMING_SNAKE_CASE_       ,   SCREAMING_SNAKE_CASE_      )

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

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







from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_sentencepiece_available,
    is_tokenizers_available,
    is_torch_available,
)


a_      =     {'configuration_plbart': ['PLBART_PRETRAINED_CONFIG_ARCHIVE_MAP', 'PLBartConfig']}

try:
			if not is_sentencepiece_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			a_      =     ['PLBartTokenizer']

try:
			if not is_torch_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			a_      =     [
			    'PLBART_PRETRAINED_MODEL_ARCHIVE_LIST',
			    'PLBartForCausalLM',
			    'PLBartForConditionalGeneration',
			    'PLBartForSequenceClassification',
			    'PLBartModel',
			    'PLBartPreTrainedModel',
			]


if TYPE_CHECKING:
			from .configuration_plbart import PLBART_PRETRAINED_CONFIG_ARCHIVE_MAP, PLBartConfig

			try:
						if not is_sentencepiece_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .tokenization_plbart import PLBartTokenizer

			try:
						if not is_torch_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_plbart import (
						    PLBART_PRETRAINED_MODEL_ARCHIVE_LIST,
						    PLBartForCausalLM,
						    PLBartForConditionalGeneration,
						    PLBartForSequenceClassification,
						    PLBartModel,
						    PLBartPreTrainedModel,
						)


else:
			import sys

			a_      =     _LazyModule(__name__, globals()['__file__'], _import_structure)