



'''simple docstring'''






import collections
import inspect
import unittest

from transformers import SwinvaConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
     import torch
     from torch import nn

     from transformers import SwinvaForImageClassification, SwinvaForMaskedImageModeling, SwinvaModel
     from transformers.models.swinva.modeling_swinva import SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
     from PIL import Image

     from transformers import AutoImageProcessor

class 							a__:







    def __init__(				self			:  Union[str, Any]						,      __snake_case			:  List[Any]						,      __snake_case			:  List[str]=13						,      __snake_case			:  Optional[Any]=32						,      __snake_case			:  Tuple=2						,      __snake_case			:  Optional[int]=3						,      __snake_case			:  Optional[Any]=16						,      __snake_case			:  Optional[Any]=[1, 2, 1]						,      __snake_case			:  Union[str, Any]=[2, 2, 4]						,      __snake_case			:  Optional[Any]=2						,      __snake_case			:  Dict=2.0						,      __snake_case			:  str=True						,      __snake_case			:  Dict=0.0						,      __snake_case			:  Any=0.0						,      __snake_case			:  Any=0.1						,      __snake_case			:  List[str]="gelu"						,      __snake_case			:  List[Any]=False						,      __snake_case			:  str=True						,      __snake_case			:  Union[str, Any]=0.02						,      __snake_case			:  Union[str, Any]=1e-5						,      __snake_case			:  int=True						,      __snake_case			:  Tuple=None						,      __snake_case			:  Any=True						,      __snake_case			:  int=10						,      __snake_case			:  Tuple=8						,      ):
      a						: Optional[Any]					       =					parent
      a						: Dict					       =					batch_size
      a						: List[Any]					       =					image_size
      a						: int					       =					patch_size
      a						: List[Any]					       =					num_channels
      a						: str					       =					embed_dim
      a						: Optional[Any]					       =					depths
      a						: List[Any]					       =					num_heads
      a						: Dict					       =					window_size
      a						: int					       =					mlp_ratio
      a						: str					       =					qkv_bias
      a						: Dict					       =					hidden_dropout_prob
      a						: List[str]					       =					attention_probs_dropout_prob
      a						: Optional[int]					       =					drop_path_rate
      a						: int					       =					hidden_act
      a						: Dict					       =					use_absolute_embeddings
      a						: Optional[Any]					       =					patch_norm
      a						: Any					       =					layer_norm_eps
      a						: Optional[int]					       =					initializer_range
      a						: List[Any]					       =					is_training
      a						: List[str]					       =					scope
      a						: Optional[int]					       =					use_labels
      a						: Optional[Any]					       =					type_sequence_label_size
      a						: str					       =					encoder_stride







    def       lowercase_	(				self			:  Tuple     ):
      a						: Dict					       =					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]     )

      a						: List[Any]					       =					None
      if self.use_labels:
        a						: str					       =					ids_tensor([self.batch_size]						,      self.type_sequence_label_size     )

      a						: Dict					       =					self.get_config()

      return config, pixel_values, labels







    def       lowercase_	(				self			:  Optional[Any]     ):
      return SwinvaConfig(
          image_size=self.image_size						,      patch_size=self.patch_size						,      num_channels=self.num_channels						,      embed_dim=self.embed_dim						,      depths=self.depths						,      num_heads=self.num_heads						,      window_size=self.window_size						,      mlp_ratio=self.mlp_ratio						,      qkv_bias=self.qkv_bias						,      hidden_dropout_prob=self.hidden_dropout_prob						,      attention_probs_dropout_prob=self.attention_probs_dropout_prob						,      drop_path_rate=self.drop_path_rate						,      hidden_act=self.hidden_act						,      use_absolute_embeddings=self.use_absolute_embeddings						,      path_norm=self.patch_norm						,      layer_norm_eps=self.layer_norm_eps						,      initializer_range=self.initializer_range						,      encoder_stride=self.encoder_stride						,      )







    def       lowercase_	(				self			:  List[str]						,      __snake_case			:  Tuple						,      __snake_case			:  List[Any]						,      __snake_case			:  List[str]     ):
      a						: Any					       =					SwinvaModel(config=_lowerCamelCase     )
      model.to(_lowerCamelCase     )
      model.eval()
      a						: int					       =					model(_lowerCamelCase     )

      a						: Optional[Any]					       =					((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths     ) - 1))
      a						: Tuple					       =					int(config.embed_dim * 2 ** (len(config.depths     ) - 1)     )

      self.parent.assertEqual(result.last_hidden_state.shape						,      (self.batch_size, expected_seq_len, expected_dim)     )







    def       lowercase_	(				self			:  Any						,      __snake_case			:  Optional[int]						,      __snake_case			:  Optional[int]						,      __snake_case			:  int     ):
      a						: Tuple					       =					SwinvaForMaskedImageModeling(config=_lowerCamelCase     )
      model.to(_lowerCamelCase     )
      model.eval()
      a						: Tuple					       =					model(_lowerCamelCase     )
      self.parent.assertEqual(
          result.logits.shape						,      (self.batch_size, self.num_channels, self.image_size, self.image_size)     )

      # test greyscale images
      a						: str					       =					1
      a						: Any					       =					SwinvaForMaskedImageModeling(_lowerCamelCase     )
      model.to(_lowerCamelCase     )
      model.eval()

      a						: int					       =					floats_tensor([self.batch_size, 1, self.image_size, self.image_size]     )
      a						: Optional[Any]					       =					model(_lowerCamelCase     )
      self.parent.assertEqual(result.logits.shape						,      (self.batch_size, 1, self.image_size, self.image_size)     )







    def       lowercase_	(				self			:  Optional[Any]						,      __snake_case			:  Any						,      __snake_case			:  Tuple						,      __snake_case			:  Optional[Any]     ):
      a						: List[str]					       =					self.type_sequence_label_size
      a						: Dict					       =					SwinvaForImageClassification(_lowerCamelCase     )
      model.to(_lowerCamelCase     )
      model.eval()
      a						: str					       =					model(_lowerCamelCase						,      labels=_lowerCamelCase     )
      self.parent.assertEqual(result.logits.shape						,      (self.batch_size, self.type_sequence_label_size)     )







    def       lowercase_	(				self			:  Optional[int]     ):
      a						: List[Any]					       =					self.prepare_config_and_inputs()
      a       ,     a       ,     a						: Any					       =					config_and_inputs
      a						: Tuple					       =					{'pixel_values': pixel_values}
      return config, inputs_dict





@require_torch
class 							a__( A_		,			A_		,			unittest.TestCase     ):
    lowercase__			=   (
        (SwinvaModel, SwinvaForImageClassification, SwinvaForMaskedImageModeling) if is_torch_available() else ()
    )
    lowercase__			=   (
        {"""feature-extraction""": SwinvaModel, """image-classification""": SwinvaForImageClassification}
        if is_torch_available()
        else {}
    )

    lowercase__			=   False
    lowercase__			=   False
    lowercase__			=   False
    lowercase__			=   False







    def       lowercase_	(				self			:  Any     ):
      a						: Union[str, Any]					       =					SwinvaModelTester(self     )
      a						: int					       =					ConfigTester(self						,      config_class=_lowerCamelCase						,      embed_dim=37     )







    def       lowercase_	(				self			:  List[Any]     ):
      self.config_tester.create_and_test_config_to_json_string()
      self.config_tester.create_and_test_config_to_json_file()
      self.config_tester.create_and_test_config_from_and_save_pretrained()
      self.config_tester.create_and_test_config_with_num_labels()
      self.config_tester.check_config_can_be_init_without_params()
      self.config_tester.check_config_arguments_init()







    def       lowercase_	(				self			:  int     ):
      a						: Any					       =					self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*_lowerCamelCase     )







    @unittest.skip(reason='Got `CUDA error: misaligned address` with PyTorch 2.0.0.'     )
    def       lowercase_	(				self			:  Optional[Any]     ):
      pass







    @unittest.skip(reason='Swinv2 does not use inputs_embeds'     )
    def       lowercase_	(				self			:  Optional[Any]     ):
      pass







    def       lowercase_	(				self			:  Dict     ):
      a       ,     a						: Optional[int]					       =					self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
        a						: str					       =					model_class(_lowerCamelCase     )
        self.assertIsInstance(model.get_input_embeddings()						,      (nn.Module)     )
        a						: Tuple					       =					model.get_output_embeddings()
        self.assertTrue(x is None or isinstance(_lowerCamelCase						,      nn.Linear     )     )







    def       lowercase_	(				self			:  List[Any]     ):
      a       ,     a						: Tuple					       =					self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
        a						: Tuple					       =					model_class(_lowerCamelCase     )
        a						: Optional[int]					       =					inspect.signature(model.forward     )
        # signature.parameters is an OrderedDict => so arg_names order is deterministic
        a						: str					       =					[*signature.parameters.keys()]

        a						: Any					       =					['pixel_values']
        self.assertListEqual(arg_names[:1]						,      _lowerCamelCase     )







    def       lowercase_	(				self			:  Union[str, Any]     ):
      a       ,     a						: Any					       =					self.model_tester.prepare_config_and_inputs_for_common()
      a						: Union[str, Any]					       =					True

      for model_class in self.all_model_classes:
        a						: List[str]					       =					True
        a						: List[Any]					       =					False
        a						: Union[str, Any]					       =					True
        a						: List[Any]					       =					model_class(_lowerCamelCase     )
        model.to(_lowerCamelCase     )
        model.eval()
        with torch.no_grad():
          a						: Optional[int]					       =					model(**self._prepare_for_class(_lowerCamelCase						,      _lowerCamelCase     )     )
        a						: Tuple					       =					outputs.attentions
        a						: List[Any]					       =					len(self.model_tester.depths     )
        self.assertEqual(len(_lowerCamelCase     )						,      _lowerCamelCase     )

        # check that output_attentions also work using config
        del inputs_dict["output_attentions"]
        a						: str					       =					True
        a						: int					       =					config.window_size**2
        a						: List[str]					       =					model_class(_lowerCamelCase     )
        model.to(_lowerCamelCase     )
        model.eval()
        with torch.no_grad():
          a						: Optional[int]					       =					model(**self._prepare_for_class(_lowerCamelCase						,      _lowerCamelCase     )     )
        a						: int					       =					outputs.attentions
        self.assertEqual(len(_lowerCamelCase     )						,      _lowerCamelCase     )

        self.assertListEqual(
            list(attentions[0].shape[-3:]     )						,      [self.model_tester.num_heads[0], window_size_squared, window_size_squared]						,      )
        a						: Tuple					       =					len(_lowerCamelCase     )

        # Check attention is always last and order is fine
        a						: Dict					       =					True
        a						: int					       =					True
        a						: List[str]					       =					model_class(_lowerCamelCase     )
        model.to(_lowerCamelCase     )
        model.eval()
        with torch.no_grad():
          a						: Optional[Any]					       =					model(**self._prepare_for_class(_lowerCamelCase						,      _lowerCamelCase     )     )

        if hasattr(self.model_tester						,      'num_hidden_states_types'     ):
          a						: List[Any]					       =					self.model_tester.num_hidden_states_types
        else:
          # also another +1 for reshaped_hidden_states
          a						: Tuple					       =					2
        self.assertEqual(out_len + added_hidden_states						,      len(_lowerCamelCase     )     )

        a						: str					       =					outputs.attentions

        self.assertEqual(len(_lowerCamelCase     )						,      _lowerCamelCase     )

        self.assertListEqual(
            list(self_attentions[0].shape[-3:]     )						,      [self.model_tester.num_heads[0], window_size_squared, window_size_squared]						,      )







    def       lowercase_	(				self			:  Optional[int]						,      __snake_case			:  Optional[Any]						,      __snake_case			:  Any						,      __snake_case			:  Tuple						,      __snake_case			:  Tuple     ):
      a						: Optional[int]					       =					model_class(_lowerCamelCase     )
      model.to(_lowerCamelCase     )
      model.eval()

      with torch.no_grad():
        a						: Union[str, Any]					       =					model(**self._prepare_for_class(_lowerCamelCase						,      _lowerCamelCase     )     )

      a						: Any					       =					outputs.hidden_states

      a						: Optional[int]					       =					getattr(
          self.model_tester						,      'expected_num_hidden_layers'						,      len(self.model_tester.depths     ) + 1     )
      self.assertEqual(len(_lowerCamelCase     )						,      _lowerCamelCase     )

      # Swinv2 has a different seq_length
      a						: str					       =					(
          config.patch_size
          if isinstance(config.patch_size						,      collections.abc.Iterable     )
          else (config.patch_size, config.patch_size)
      )

      a						: Any					       =					(image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

      self.assertListEqual(
          list(hidden_states[0].shape[-2:]     )						,      [num_patches, self.model_tester.embed_dim]						,      )

      a						: Optional[Any]					       =					outputs.reshaped_hidden_states
      self.assertEqual(len(_lowerCamelCase     )						,      _lowerCamelCase     )

      a       ,     a       ,     a       ,     a						: Optional[Any]					       =					reshaped_hidden_states[0].shape
      a						: List[Any]					       =					(
          reshaped_hidden_states[0].view(_lowerCamelCase						,      _lowerCamelCase						,      height * width     ).permute(0						,      2						,      1     )
      )
      self.assertListEqual(
          list(reshaped_hidden_states.shape[-2:]     )						,      [num_patches, self.model_tester.embed_dim]						,      )







    def       lowercase_	(				self			:  List[Any]     ):
      a       ,     a						: Tuple					       =					self.model_tester.prepare_config_and_inputs_for_common()

      a						: List[Any]					       =					(
          self.model_tester.image_size
          if isinstance(self.model_tester.image_size						,      collections.abc.Iterable     )
          else (self.model_tester.image_size, self.model_tester.image_size)
      )

      for model_class in self.all_model_classes:
        a						: Any					       =					True
        self.check_hidden_states_output(_lowerCamelCase						,      _lowerCamelCase						,      _lowerCamelCase						,      _lowerCamelCase     )

        # check that output_hidden_states also work using config
        del inputs_dict["output_hidden_states"]
        a						: Tuple					       =					True

        self.check_hidden_states_output(_lowerCamelCase						,      _lowerCamelCase						,      _lowerCamelCase						,      _lowerCamelCase     )







    def       lowercase_	(				self			:  Any     ):
      a       ,     a						: Tuple					       =					self.model_tester.prepare_config_and_inputs_for_common()
      a						: List[str]					       =					3

      a						: Optional[int]					       =					(
          self.model_tester.image_size
          if isinstance(self.model_tester.image_size						,      collections.abc.Iterable     )
          else (self.model_tester.image_size, self.model_tester.image_size)
      )
      a						: Optional[Any]					       =					(
          config.patch_size
          if isinstance(config.patch_size						,      collections.abc.Iterable     )
          else (config.patch_size, config.patch_size)
      )

      a						: Dict					       =					image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
      a						: Tuple					       =					image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

      for model_class in self.all_model_classes:
        a						: Optional[Any]					       =					True
        self.check_hidden_states_output(_lowerCamelCase						,      _lowerCamelCase						,      _lowerCamelCase						,      (padded_height, padded_width)     )

        # check that output_hidden_states also work using config
        del inputs_dict["output_hidden_states"]
        a						: Optional[int]					       =					True
        self.check_hidden_states_output(_lowerCamelCase						,      _lowerCamelCase						,      _lowerCamelCase						,      (padded_height, padded_width)     )







    def       lowercase_	(				self			:  Dict     ):
      a						: Tuple					       =					self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_masked_image_modeling(*_lowerCamelCase     )







    def       lowercase_	(				self			:  List[Any]     ):
      a						: Optional[int]					       =					self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_image_classification(*_lowerCamelCase     )







    @slow
    def       lowercase_	(				self			:  int     ):
      for model_name in SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
        a						: Optional[Any]					       =					SwinvaModel.from_pretrained(_lowerCamelCase     )
        self.assertIsNotNone(_lowerCamelCase     )







    def       lowercase_	(				self			:  str     ):
      a       ,     a						: Dict					       =					self.model_tester.prepare_config_and_inputs_for_common()

      a						: List[str]					       =					_config_zero_init(_lowerCamelCase     )
      for model_class in self.all_model_classes:
        a						: Optional[Any]					       =					model_class(config=_lowerCamelCase     )
        for name, param in model.named_parameters():
          if "embeddings" not in name and "logit_scale" not in name and param.requires_grad:
            self.assertIn(
                ((param.data.mean() * 1e9).round() / 1e9).item()						,      [0.0, 1.0]						,      msg=F"""Parameter {name} of model {model_class} seems not properly initialized"""						,      )





@require_vision
@require_torch
class 							a__( unittest.TestCase     ):







    @cached_property
    def       lowercase_	(				self			:  List[Any]     ):
      return (
          AutoImageProcessor.from_pretrained('microsoft/swinv2-tiny-patch4-window8-256'     )
          if is_vision_available()
          else None
      )







    @slow
    def       lowercase_	(				self			:  Optional[Any]     ):
      a						: str					       =					SwinvaForImageClassification.from_pretrained('microsoft/swinv2-tiny-patch4-window8-256'     ).to(
          _lowerCamelCase     )
      a						: Dict					       =					self.default_image_processor

      a						: Union[str, Any]					       =					Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'     )
      a						: Optional[int]					       =					image_processor(images=_lowerCamelCase						,      return_tensors='pt'     ).to(_lowerCamelCase     )

      # forward pass
      with torch.no_grad():
        a						: Optional[Any]					       =					model(**_lowerCamelCase     )

      # verify the logits
      a						: Tuple					       =					torch.Size((1, 10_00)     )
      self.assertEqual(outputs.logits.shape						,      _lowerCamelCase     )
      a						: Union[str, Any]					       =					torch.tensor([-0.3947, -0.4306, 0.0026]     ).to(_lowerCamelCase     )
      self.assertTrue(torch.allclose(outputs.logits[0, :3]						,      _lowerCamelCase						,      atol=1e-4     )     )




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


lowerCAmelCase: List[Any]							=						logging.get_logger(__name__)

# General docstring
lowerCAmelCase: Optional[int]							=						'RegNetConfig'

# Base docstring
lowerCAmelCase: Tuple							=						'facebook/regnet-y-040'
lowerCAmelCase: str							=						[1, 1_0_8_8, 7, 7]

# Image classification docstring
lowerCAmelCase: Any							=						'facebook/regnet-y-040'
lowerCAmelCase: List[Any]							=						'tabby, tabby cat'

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

class 							a__( nn.Module     ):







    def __init__(				self			:  str						,      __snake_case			:  int						,      __snake_case			:  int						,      __snake_case			:  int = 3						,      __snake_case			:  int = 1						,      __snake_case			:  int = 1						,      __snake_case			:  Optional[str] = "relu"						,      ):
      super().__init__()
      a						: Tuple					       =					nn.Convad(
          __snake_case						,      __snake_case						,      kernel_size=__snake_case						,      stride=__snake_case						,      padding=kernel_size // 2						,      groups=__snake_case						,      bias=__snake_case						,      )
      a						: Dict					       =					nn.BatchNormad(__snake_case     )
      a						: Tuple					       =					ACTaFN[activation] if activation is not None else nn.Identity()







    def       lowercase_	(				self			:  Dict						,      __snake_case			:  int     ):
      a						: int					       =					self.convolution(__snake_case     )
      a						: int					       =					self.normalization(__snake_case     )
      a						: Any					       =					self.activation(__snake_case     )
      return hidden_state

class 							a__( nn.Module     ):







    def __init__(				self			:  List[str]						,      __snake_case			:  RegNetConfig     ):
      super().__init__()
      a						: Optional[int]					       =					RegNetConvLayer(
          config.num_channels						,      config.embedding_size						,      kernel_size=3						,      stride=2						,      activation=config.hidden_act     )
      a						: Optional[int]					       =					config.num_channels







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

class 							a__( nn.Module     ):







    def __init__(				self			:  Tuple						,      __snake_case			:  int						,      __snake_case			:  int						,      __snake_case			:  int = 2     ):
      super().__init__()
      a						: Optional[int]					       =					nn.Convad(__snake_case						,      __snake_case						,      kernel_size=1						,      stride=__snake_case						,      bias=__snake_case     )
      a						: Optional[Any]					       =					nn.BatchNormad(__snake_case     )







    def       lowercase_	(				self			:  Union[str, Any]						,      __snake_case			:  Tensor     ):
      a						: Any					       =					self.convolution(__snake_case     )
      a						: Dict					       =					self.normalization(__snake_case     )
      return hidden_state

class 							a__( nn.Module     ):







    def __init__(				self			:  Union[str, Any]						,      __snake_case			:  int						,      __snake_case			:  int     ):
      super().__init__()

      a						: Any					       =					nn.AdaptiveAvgPoolad((1, 1)     )
      a						: Dict					       =					nn.Sequential(
          nn.Convad(__snake_case						,      __snake_case						,      kernel_size=1     )						,      nn.ReLU()						,      nn.Convad(__snake_case						,      __snake_case						,      kernel_size=1     )						,      nn.Sigmoid()						,      )







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

class 							a__( nn.Module     ):







    def __init__(				self			:  List[str]						,      __snake_case			:  RegNetConfig						,      __snake_case			:  int						,      __snake_case			:  int						,      __snake_case			:  int = 1     ):
      super().__init__()
      a						: Union[str, Any]					       =					in_channels != out_channels or stride != 1
      a						: Dict					       =					max(1						,      out_channels // config.groups_width     )
      a						: List[str]					       =					(
          RegNetShortCut(__snake_case						,      __snake_case						,      stride=__snake_case     ) if should_apply_shortcut else nn.Identity()
      )
      a						: int					       =					nn.Sequential(
          RegNetConvLayer(__snake_case						,      __snake_case						,      kernel_size=1						,      activation=config.hidden_act     )						,      RegNetConvLayer(__snake_case						,      __snake_case						,      stride=__snake_case						,      groups=__snake_case						,      activation=config.hidden_act     )						,      RegNetConvLayer(__snake_case						,      __snake_case						,      kernel_size=1						,      activation=__snake_case     )						,      )
      a						: int					       =					ACTaFN[config.hidden_act]







    def       lowercase_	(				self			:  Union[str, Any]						,      __snake_case			:  Tuple     ):
      a						: List[str]					       =					hidden_state
      a						: Dict					       =					self.layer(__snake_case     )
      a						: Tuple					       =					self.shortcut(__snake_case     )
      hidden_state += residual
      a						: Optional[int]					       =					self.activation(__snake_case     )
      return hidden_state

class 							a__( nn.Module     ):







    def __init__(				self			:  List[str]						,      __snake_case			:  RegNetConfig						,      __snake_case			:  int						,      __snake_case			:  int						,      __snake_case			:  int = 1     ):
      super().__init__()
      a						: Union[str, Any]					       =					in_channels != out_channels or stride != 1
      a						: Dict					       =					max(1						,      out_channels // config.groups_width     )
      a						: Dict					       =					(
          RegNetShortCut(__snake_case						,      __snake_case						,      stride=__snake_case     ) if should_apply_shortcut else nn.Identity()
      )
      a						: List[str]					       =					nn.Sequential(
          RegNetConvLayer(__snake_case						,      __snake_case						,      kernel_size=1						,      activation=config.hidden_act     )						,      RegNetConvLayer(__snake_case						,      __snake_case						,      stride=__snake_case						,      groups=__snake_case						,      activation=config.hidden_act     )						,      RegNetSELayer(__snake_case						,      reduced_channels=int(round(in_channels / 4     )     )     )						,      RegNetConvLayer(__snake_case						,      __snake_case						,      kernel_size=1						,      activation=__snake_case     )						,      )
      a						: Union[str, Any]					       =					ACTaFN[config.hidden_act]







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

class 							a__( nn.Module     ):







    def __init__(				self			:  int						,      __snake_case			:  RegNetConfig						,      __snake_case			:  int						,      __snake_case			:  int						,      __snake_case			:  int = 2						,      __snake_case			:  int = 2						,      ):
      super().__init__()

      a						: int					       =					RegNetXLayer if config.layer_type == 'x' else RegNetYLayer

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







    def       lowercase_	(				self			:  Optional[Any]						,      __snake_case			:  str     ):
      a						: Dict					       =					self.layers(__snake_case     )
      return hidden_state

class 							a__( nn.Module     ):







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







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

      for stage_module in self.stages:
        if output_hidden_states:
          a						: List[str]					       =					hidden_states + (hidden_state,)

        a						: int					       =					stage_module(__snake_case     )

      if output_hidden_states:
        a						: Union[str, 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=__snake_case						,      hidden_states=__snake_case     )

class 							a__( lowerCamelCase__     ):
    lowercase__			=   RegNetConfig
    lowercase__			=   """regnet"""
    lowercase__			=   """pixel_values"""
    lowercase__			=   True







    def       lowercase_	(				self			:  Optional[Any]						,      __snake_case			:  Optional[int]     ):
      if isinstance(__snake_case						,      nn.Convad     ):
        nn.init.kaiming_normal_(module.weight						,      mode='fan_out'						,      nonlinearity='relu'     )
      elif isinstance(__snake_case						,      (nn.BatchNormad, nn.GroupNorm)     ):
        nn.init.constant_(module.weight						,      1     )
        nn.init.constant_(module.bias						,      0     )







    def       lowercase_	(				self			:  Dict						,      __snake_case			:  List[str]						,      __snake_case			:  Dict=False     ):
      if isinstance(__snake_case						,      __snake_case     ):
        a						: Optional[Any]					       =					value
lowerCAmelCase: 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'

lowerCAmelCase: int							=						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 							a__( lowerCamelCase__     ):







    def __init__(				self			:  Dict						,      __snake_case			:  Dict     ):
      super().__init__(__snake_case     )
      a						: str					       =					config
      a						: str					       =					RegNetEmbeddings(__snake_case     )
      a						: Dict					       =					RegNetEncoder(__snake_case     )
      a						: int					       =					nn.AdaptiveAvgPoolad((1, 1)     )
      # Initialize weights and apply final processing
      self.post_init()







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

      a						: int					       =					self.embedder(__snake_case     )

      a						: Optional[int]					       =					self.encoder(
          __snake_case						,      output_hidden_states=__snake_case						,      return_dict=__snake_case     )

      a						: List[Any]					       =					encoder_outputs[0]

      a						: Any					       =					self.pooler(__snake_case     )

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

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

@add_start_docstrings(
    """
    RegNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for
    ImageNet.
    """		,			lowerCamelCase__		,			)
# Copied from transformers.models.resnet.modeling_resnet.ResNetForImageClassification with RESNET->REGNET,ResNet->RegNet,resnet->regnet
class 							a__( lowerCamelCase__     ):







    def __init__(				self			:  int						,      __snake_case			:  Optional[int]     ):
      super().__init__(__snake_case     )
      a						: Optional[Any]					       =					config.num_labels
      a						: Tuple					       =					RegNetModel(__snake_case     )
      # classification head
      a						: List[Any]					       =					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(__snake_case     )
    @add_code_sample_docstrings(
        checkpoint=_IMAGE_CLASS_CHECKPOINT						,      output_type=__snake_case						,      config_class=_CONFIG_FOR_DOC						,      expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT						,      )
    def       lowercase_	(				self			:  Optional[Any]						,      __snake_case			:  Optional[torch.FloatTensor] = None						,      __snake_case			:  Optional[torch.LongTensor] = None						,      __snake_case			:  Optional[bool] = None						,      __snake_case			:  Optional[bool] = None						,      ):
      a						: str					       =					return_dict if return_dict is not None else self.config.use_return_dict

      a						: Optional[Any]					       =					self.regnet(__snake_case						,      output_hidden_states=__snake_case						,      return_dict=__snake_case     )

      a						: Any					       =					outputs.pooler_output if return_dict else outputs[1]

      a						: str					       =					self.classifier(__snake_case     )

      a						: Optional[int]					       =					None

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

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

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