
"""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[int]					=							logging.get_logger(__name__)

# General docstring
_a      :			Any					=							'RegNetConfig'

# Base docstring
_a      :			Any					=							'facebook/regnet-y-040'
_a      :			str					=							[1, 1_088, 7, 7]

# Image classification docstring
_a      :			Optional[int]					=							'facebook/regnet-y-040'
_a      :			Any					=							'tabby, tabby cat'

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






class      _UpperCAmelCase				(					nn.Module):
    def __init__(    self						,    snake_case_						,    snake_case_						,    snake_case_ = 3						,    snake_case_ = 1						,    snake_case_ = 1						,    snake_case_ = "relu"						,    ):
      super().__init__()
      _snake_case     :						str						=   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     :						Any						=   nn.BatchNormad(_SCREAMING_SNAKE_CASE     )
      _snake_case     :						Tuple						=   ACTaFN[activation] if activation is not None else nn.Identity()


    def 					lowerCamelCase__	(    self						,    snake_case_     ):
      _snake_case     :						List[str]						=   self.convolution(_SCREAMING_SNAKE_CASE     )
      _snake_case     :						List[str]						=   self.normalization(_SCREAMING_SNAKE_CASE     )
      _snake_case     :						Dict						=   self.activation(_SCREAMING_SNAKE_CASE     )
      return hidden_state






class      _UpperCAmelCase				(					nn.Module):
    def __init__(    self						,    snake_case_     ):
      super().__init__()
      _snake_case     :						str						=   RegNetConvLayer(
          config.num_channels						,    config.embedding_size						,    kernel_size=3						,    stride=2						,    activation=config.hidden_act     )
      _snake_case     :						int						=   config.num_channels


    def 					lowerCamelCase__	(    self						,    snake_case_     ):
      _snake_case     :						List[str]						=   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     :						int						=   self.embedder(_SCREAMING_SNAKE_CASE     )
      return hidden_state






class      _UpperCAmelCase				(					nn.Module):
    def __init__(    self						,    snake_case_						,    snake_case_						,    snake_case_ = 2     ):
      super().__init__()
      _snake_case     :						int						=   nn.Convad(_SCREAMING_SNAKE_CASE						,    _SCREAMING_SNAKE_CASE						,    kernel_size=1						,    stride=_SCREAMING_SNAKE_CASE						,    bias=_SCREAMING_SNAKE_CASE     )
      _snake_case     :						Union[str, Any]						=   nn.BatchNormad(_SCREAMING_SNAKE_CASE     )


    def 					lowerCamelCase__	(    self						,    snake_case_     ):
      _snake_case     :						List[Any]						=   self.convolution(_SCREAMING_SNAKE_CASE     )
      _snake_case     :						str						=   self.normalization(_SCREAMING_SNAKE_CASE     )
      return hidden_state






class      _UpperCAmelCase				(					nn.Module):
    def __init__(    self						,    snake_case_						,    snake_case_     ):
      super().__init__()

      _snake_case     :						Any						=   nn.AdaptiveAvgPoolad((1, 1)     )
      _snake_case     :						List[Any]						=   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 					lowerCamelCase__	(    self						,    snake_case_     ):
      # b c h w -> b c 1 1
      _snake_case     :						str						=   self.pooler(_SCREAMING_SNAKE_CASE     )
      _snake_case     :						Any						=   self.attention(_SCREAMING_SNAKE_CASE     )
      _snake_case     :						Union[str, Any]						=   hidden_state * attention
      return hidden_state






class      _UpperCAmelCase				(					nn.Module):
    def __init__(    self						,    snake_case_						,    snake_case_						,    snake_case_						,    snake_case_ = 1     ):
      super().__init__()
      _snake_case     :						List[Any]						=   in_channels != out_channels or stride != 1
      _snake_case     :						Dict						=   max(1						,    out_channels // config.groups_width     )
      _snake_case     :						Any						=   (
          RegNetShortCut(_SCREAMING_SNAKE_CASE						,    _SCREAMING_SNAKE_CASE						,    stride=_SCREAMING_SNAKE_CASE     ) if should_apply_shortcut else nn.Identity()
      )
      _snake_case     :						int						=   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     :						List[str]						=   ACTaFN[config.hidden_act]


    def 					lowerCamelCase__	(    self						,    snake_case_     ):
      _snake_case     :						Any						=   hidden_state
      _snake_case     :						Dict						=   self.layer(_SCREAMING_SNAKE_CASE     )
      _snake_case     :						Union[str, Any]						=   self.shortcut(_SCREAMING_SNAKE_CASE     )
      hidden_state += residual
      _snake_case     :						List[str]						=   self.activation(_SCREAMING_SNAKE_CASE     )
      return hidden_state






class      _UpperCAmelCase				(					nn.Module):
    def __init__(    self						,    snake_case_						,    snake_case_						,    snake_case_						,    snake_case_ = 1     ):
      super().__init__()
      _snake_case     :						List[Any]						=   in_channels != out_channels or stride != 1
      _snake_case     :						Union[str, Any]						=   max(1						,    out_channels // config.groups_width     )
      _snake_case     :						Union[str, Any]						=   (
          RegNetShortCut(_SCREAMING_SNAKE_CASE						,    _SCREAMING_SNAKE_CASE						,    stride=_SCREAMING_SNAKE_CASE     ) if should_apply_shortcut else nn.Identity()
      )
      _snake_case     :						Any						=   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     :						Tuple						=   ACTaFN[config.hidden_act]


    def 					lowerCamelCase__	(    self						,    snake_case_     ):
      _snake_case     :						str						=   hidden_state
      _snake_case     :						Optional[Any]						=   self.layer(_SCREAMING_SNAKE_CASE     )
      _snake_case     :						Optional[Any]						=   self.shortcut(_SCREAMING_SNAKE_CASE     )
      hidden_state += residual
      _snake_case     :						List[str]						=   self.activation(_SCREAMING_SNAKE_CASE     )
      return hidden_state






class      _UpperCAmelCase				(					nn.Module):
    def __init__(    self						,    snake_case_						,    snake_case_						,    snake_case_						,    snake_case_ = 2						,    snake_case_ = 2						,    ):
      super().__init__()

      _snake_case     :						List[Any]						=   RegNetXLayer if config.layer_type == "x" else RegNetYLayer

      _snake_case     :						Optional[Any]						=   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 					lowerCamelCase__	(    self						,    snake_case_     ):
      _snake_case     :						Any						=   self.layers(_SCREAMING_SNAKE_CASE     )
      return hidden_state






class      _UpperCAmelCase				(					nn.Module):
    def __init__(    self						,    snake_case_     ):
      super().__init__()
      _snake_case     :						List[Any]						=   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     :						str						=   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 					lowerCamelCase__	(    self						,    snake_case_						,    snake_case_ = False						,    snake_case_ = True     ):
      _snake_case     :						Union[str, Any]						=   () if output_hidden_states else None

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

        _snake_case     :						List[str]						=   stage_module(_SCREAMING_SNAKE_CASE     )

      if output_hidden_states:
        _snake_case     :						str						=   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      _UpperCAmelCase				(					lowerCAmelCase__):
    __lowercase							: Any  =					RegNetConfig
    __lowercase							: List[str]  =					"regnet"
    __lowercase							: Optional[int]  =					"pixel_values"
    __lowercase							: Tuple  =					True
    def 					lowerCamelCase__	(    self						,    snake_case_     ):
      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 					lowerCamelCase__	(    self						,    snake_case_						,    snake_case_=False     ):
      if isinstance(_SCREAMING_SNAKE_CASE						,    _SCREAMING_SNAKE_CASE     ):
        _snake_case     :						Dict						=   value


_a      :			List[str]					=							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      :			Optional[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 [`~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."""		,					lowerCAmelCase__		,					)
# Copied from transformers.models.resnet.modeling_resnet.ResNetModel with RESNET->REGNET,ResNet->RegNet
class      _UpperCAmelCase				(					lowerCAmelCase__):
    def __init__(    self						,    snake_case_     ):
      super().__init__(_SCREAMING_SNAKE_CASE     )
      _snake_case     :						Any						=   config
      _snake_case     :						Dict						=   RegNetEmbeddings(_SCREAMING_SNAKE_CASE     )
      _snake_case     :						Dict						=   RegNetEncoder(_SCREAMING_SNAKE_CASE     )
      _snake_case     :						Any						=   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 					lowerCamelCase__	(    self						,    snake_case_						,    snake_case_ = None						,    snake_case_ = None     ):
      _snake_case     :						List[Any]						=   (
          output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
      )
      _snake_case     :						Dict						=   return_dict if return_dict is not None else self.config.use_return_dict

      _snake_case     :						List[Any]						=   self.embedder(_SCREAMING_SNAKE_CASE     )

      _snake_case     :						Tuple						=   self.encoder(
          _SCREAMING_SNAKE_CASE						,    output_hidden_states=_SCREAMING_SNAKE_CASE						,    return_dict=_SCREAMING_SNAKE_CASE     )

      _snake_case     :						int						=   encoder_outputs[0]

      _snake_case     :						int						=   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    """		,					lowerCAmelCase__		,					)
# Copied from transformers.models.resnet.modeling_resnet.ResNetForImageClassification with RESNET->REGNET,ResNet->RegNet,resnet->regnet
class      _UpperCAmelCase				(					lowerCAmelCase__):
    def __init__(    self						,    snake_case_     ):
      super().__init__(_SCREAMING_SNAKE_CASE     )
      _snake_case     :						Dict						=   config.num_labels
      _snake_case     :						List[Any]						=   RegNetModel(_SCREAMING_SNAKE_CASE     )
      # classification head
      _snake_case     :						Dict						=   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 					lowerCamelCase__	(    self						,    snake_case_ = None						,    snake_case_ = None						,    snake_case_ = None						,    snake_case_ = None						,    ):
      _snake_case     :						int						=   return_dict if return_dict is not None else self.config.use_return_dict

      _snake_case     :						Optional[Any]						=   self.regnet(_SCREAMING_SNAKE_CASE						,    output_hidden_states=_SCREAMING_SNAKE_CASE						,    return_dict=_SCREAMING_SNAKE_CASE     )

      _snake_case     :						Dict						=   outputs.pooler_output if return_dict else outputs[1]

      _snake_case     :						List[Any]						=   self.classifier(_SCREAMING_SNAKE_CASE     )

      _snake_case     :						Any						=   None

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

      if not return_dict:
        _snake_case     :						Optional[int]						=   (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     )



"""simple docstring"""
from ...configuration_utils import PretrainedConfig
from ...utils import logging


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

_a      :			str					=							{"""openai-gpt""": """https://huggingface.co/openai-gpt/resolve/main/config.json"""}






class      _UpperCAmelCase				(					_snake_case):
    __lowercase							: Optional[Any]  =					"""openai-gpt"""
    __lowercase							: Dict  =					{
        """max_position_embeddings""": """n_positions""",
        """hidden_size""": """n_embd""",
        """num_attention_heads""": """n_head""",
        """num_hidden_layers""": """n_layer""",
    }
    def __init__(    self						,    snake_case_=4_04_78						,    snake_case_=5_12						,    snake_case_=7_68						,    snake_case_=12						,    snake_case_=12						,    snake_case_="gelu"						,    snake_case_=0.1						,    snake_case_=0.1						,    snake_case_=0.1						,    snake_case_=1E-5						,    snake_case_=0.02						,    snake_case_="cls_index"						,    snake_case_=True						,    snake_case_=None						,    snake_case_=True						,    snake_case_=0.1						,    **snake_case_						,    ):
      _snake_case     :						Tuple						=   vocab_size
      _snake_case     :						Dict						=   n_positions
      _snake_case     :						Any						=   n_embd
      _snake_case     :						Any						=   n_layer
      _snake_case     :						Optional[int]						=   n_head
      _snake_case     :						Union[str, Any]						=   afn
      _snake_case     :						Dict						=   resid_pdrop
      _snake_case     :						str						=   embd_pdrop
      _snake_case     :						Union[str, Any]						=   attn_pdrop
      _snake_case     :						str						=   layer_norm_epsilon
      _snake_case     :						Union[str, Any]						=   initializer_range
      _snake_case     :						Any						=   summary_type
      _snake_case     :						List[str]						=   summary_use_proj
      _snake_case     :						Optional[int]						=   summary_activation
      _snake_case     :						Union[str, Any]						=   summary_first_dropout
      _snake_case     :						Optional[int]						=   summary_proj_to_labels
      super().__init__(**snake_case_     )

