





import unittest

from transformers import MraConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask


if is_torch_available():
     import torch

     from transformers import (
         MraForMaskedLM,
         MraForMultipleChoice,
         MraForQuestionAnswering,
         MraForSequenceClassification,
         MraForTokenClassification,
         MraModel,
     )
     from transformers.models.mra.modeling_mra import MRA_PRETRAINED_MODEL_ARCHIVE_LIST
class      UpperCamelCase_						:




     def __init__(						self			,  lowerCAmelCase_			,  lowerCAmelCase_=2			,  lowerCAmelCase_=8			,  lowerCAmelCase_=True			,  lowerCAmelCase_=True			,  lowerCAmelCase_=True			,  lowerCAmelCase_=True			,  lowerCAmelCase_=99			,  lowerCAmelCase_=16			,  lowerCAmelCase_=5			,  lowerCAmelCase_=2			,  lowerCAmelCase_=36			,  lowerCAmelCase_="gelu"			,  lowerCAmelCase_=0.0			,  lowerCAmelCase_=0.0			,  lowerCAmelCase_=512			,  lowerCAmelCase_=16			,  lowerCAmelCase_=2			,  lowerCAmelCase_=0.02			,  lowerCAmelCase_=3			,  lowerCAmelCase_=4			,  lowerCAmelCase_=None			,  )						->							Optional[Any]:
          _snake_case													=			parent
          _snake_case													=			batch_size
          _snake_case													=			seq_length
          _snake_case													=			is_training
          _snake_case													=			use_input_mask
          _snake_case													=			use_token_type_ids
          _snake_case													=			use_labels
          _snake_case													=			vocab_size
          _snake_case													=			hidden_size
          _snake_case													=			num_hidden_layers
          _snake_case													=			num_attention_heads
          _snake_case													=			intermediate_size
          _snake_case													=			hidden_act
          _snake_case													=			hidden_dropout_prob
          _snake_case													=			attention_probs_dropout_prob
          _snake_case													=			max_position_embeddings
          _snake_case													=			type_vocab_size
          _snake_case													=			type_sequence_label_size
          _snake_case													=			initializer_range
          _snake_case													=			num_labels
          _snake_case													=			num_choices
          _snake_case													=			scope




     def 		lowerCAmelCase     (						self					)						->							Optional[int]:
          _snake_case													=			ids_tensor([self.batch_size, self.seq_length]			,  self.vocab_size					)

          _snake_case													=			None
          if self.use_input_mask:
               _snake_case													=			random_attention_mask([self.batch_size, self.seq_length]					)

          _snake_case													=			None
          if self.use_token_type_ids:
               _snake_case													=			ids_tensor([self.batch_size, self.seq_length]			,  self.type_vocab_size					)

          _snake_case													=			None
          _snake_case													=			None
          _snake_case													=			None
          if self.use_labels:
               _snake_case													=			ids_tensor([self.batch_size]			,  self.type_sequence_label_size					)
               _snake_case													=			ids_tensor([self.batch_size, self.seq_length]			,  self.num_labels					)
               _snake_case													=			ids_tensor([self.batch_size]			,  self.num_choices					)

          _snake_case													=			self.get_config()

          return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels




     def 		lowerCAmelCase     (						self					)						->							str:
          return MraConfig(
              vocab_size=self.vocab_size			,  hidden_size=self.hidden_size			,  num_hidden_layers=self.num_hidden_layers			,  num_attention_heads=self.num_attention_heads			,  intermediate_size=self.intermediate_size			,  hidden_act=self.hidden_act			,  hidden_dropout_prob=self.hidden_dropout_prob			,  attention_probs_dropout_prob=self.attention_probs_dropout_prob			,  max_position_embeddings=self.max_position_embeddings			,  type_vocab_size=self.type_vocab_size			,  is_decoder=_lowerCamelCase			,  initializer_range=self.initializer_range			,  )




     def 		lowerCAmelCase     (						self					)						->							Optional[int]:
          _snake_case													=			self.get_config()
          _snake_case													=			300
          return config




     def 		lowerCAmelCase     (						self					)						->							Any:
          (
              _snake_case
          )													=			self.prepare_config_and_inputs()

          _snake_case													=			True
          _snake_case													=			floats_tensor([self.batch_size, self.seq_length, self.hidden_size]					)
          _snake_case													=			ids_tensor([self.batch_size, self.seq_length]			,  vocab_size=2					)

          return (
              config,
              input_ids,
              token_type_ids,
              input_mask,
              sequence_labels,
              token_labels,
              choice_labels,
              encoder_hidden_states,
              encoder_attention_mask,
          )




     def 		lowerCAmelCase     (						self			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_					)						->							Optional[int]:
          _snake_case													=			MraModel(config=_lowerCamelCase					)
          model.to(_lowerCamelCase					)
          model.eval()
          _snake_case													=			model(_lowerCamelCase			,  attention_mask=_lowerCamelCase			,  token_type_ids=_lowerCamelCase					)
          _snake_case													=			model(_lowerCamelCase			,  token_type_ids=_lowerCamelCase					)
          _snake_case													=			model(_lowerCamelCase					)
          self.parent.assertEqual(result.last_hidden_state.shape			,  (self.batch_size, self.seq_length, self.hidden_size)					)




     def 		lowerCAmelCase     (						self			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  )						->							str:
          _snake_case													=			True
          _snake_case													=			MraModel(_lowerCamelCase					)
          model.to(_lowerCamelCase					)
          model.eval()
          _snake_case													=			model(
              _lowerCamelCase			,  attention_mask=_lowerCamelCase			,  token_type_ids=_lowerCamelCase			,  encoder_hidden_states=_lowerCamelCase			,  encoder_attention_mask=_lowerCamelCase			,  )
          _snake_case													=			model(
              _lowerCamelCase			,  attention_mask=_lowerCamelCase			,  token_type_ids=_lowerCamelCase			,  encoder_hidden_states=_lowerCamelCase			,  )
          _snake_case													=			model(_lowerCamelCase			,  attention_mask=_lowerCamelCase			,  token_type_ids=_lowerCamelCase					)
          self.parent.assertEqual(result.last_hidden_state.shape			,  (self.batch_size, self.seq_length, self.hidden_size)					)




     def 		lowerCAmelCase     (						self			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_					)						->							List[str]:
          _snake_case													=			MraForMaskedLM(config=_lowerCamelCase					)
          model.to(_lowerCamelCase					)
          model.eval()
          _snake_case													=			model(_lowerCamelCase			,  attention_mask=_lowerCamelCase			,  token_type_ids=_lowerCamelCase			,  labels=_lowerCamelCase					)
          self.parent.assertEqual(result.logits.shape			,  (self.batch_size, self.seq_length, self.vocab_size)					)




     def 		lowerCAmelCase     (						self			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_					)						->							Any:
          _snake_case													=			MraForQuestionAnswering(config=_lowerCamelCase					)
          model.to(_lowerCamelCase					)
          model.eval()
          _snake_case													=			model(
              _lowerCamelCase			,  attention_mask=_lowerCamelCase			,  token_type_ids=_lowerCamelCase			,  start_positions=_lowerCamelCase			,  end_positions=_lowerCamelCase			,  )
          self.parent.assertEqual(result.start_logits.shape			,  (self.batch_size, self.seq_length)					)
          self.parent.assertEqual(result.end_logits.shape			,  (self.batch_size, self.seq_length)					)




     def 		lowerCAmelCase     (						self			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_					)						->							Optional[int]:
          _snake_case													=			self.num_labels
          _snake_case													=			MraForSequenceClassification(_lowerCamelCase					)
          model.to(_lowerCamelCase					)
          model.eval()
          _snake_case													=			model(_lowerCamelCase			,  attention_mask=_lowerCamelCase			,  token_type_ids=_lowerCamelCase			,  labels=_lowerCamelCase					)
          self.parent.assertEqual(result.logits.shape			,  (self.batch_size, self.num_labels)					)




     def 		lowerCAmelCase     (						self			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_					)						->							Union[str, Any]:
          _snake_case													=			self.num_labels
          _snake_case													=			MraForTokenClassification(config=_lowerCamelCase					)
          model.to(_lowerCamelCase					)
          model.eval()
          _snake_case													=			model(_lowerCamelCase			,  attention_mask=_lowerCamelCase			,  token_type_ids=_lowerCamelCase			,  labels=_lowerCamelCase					)
          self.parent.assertEqual(result.logits.shape			,  (self.batch_size, self.seq_length, self.num_labels)					)




     def 		lowerCAmelCase     (						self			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_					)						->							Tuple:
          _snake_case													=			self.num_choices
          _snake_case													=			MraForMultipleChoice(config=_lowerCamelCase					)
          model.to(_lowerCamelCase					)
          model.eval()
          _snake_case													=			input_ids.unsqueeze(1					).expand(-1			,  self.num_choices			,  -1					).contiguous()
          _snake_case													=			token_type_ids.unsqueeze(1					).expand(-1			,  self.num_choices			,  -1					).contiguous()
          _snake_case													=			input_mask.unsqueeze(1					).expand(-1			,  self.num_choices			,  -1					).contiguous()
          _snake_case													=			model(
              _lowerCamelCase			,  attention_mask=_lowerCamelCase			,  token_type_ids=_lowerCamelCase			,  labels=_lowerCamelCase			,  )
          self.parent.assertEqual(result.logits.shape			,  (self.batch_size, self.num_choices)					)






     def 		lowerCAmelCase     (						self					)						->							str:
          _snake_case													=			self.prepare_config_and_inputs()
          (
              _snake_case
          )													=			config_and_inputs
          _snake_case													=			{'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
          return config, inputs_dict





@require_torch
class      UpperCamelCase_						(					a__							,					unittest.TestCase   ):
     lowerCAmelCase_							=		(
         (
             MraModel,
             MraForMaskedLM,
             MraForMultipleChoice,
             MraForQuestionAnswering,
             MraForSequenceClassification,
             MraForTokenClassification,
         )
         if is_torch_available()
         else ()
     )
     lowerCAmelCase_							=		False
     lowerCAmelCase_							=		False
     lowerCAmelCase_							=		False
     lowerCAmelCase_							=		False

     lowerCAmelCase_							=		()




     def 		lowerCAmelCase     (						self					)						->							List[Any]:
          _snake_case													=			MraModelTester(self					)
          _snake_case													=			ConfigTester(self			,  config_class=_lowerCamelCase			,  hidden_size=37					)




     def 		lowerCAmelCase     (						self					)						->							Optional[int]:
          self.config_tester.run_common_tests()




     def 		lowerCAmelCase     (						self					)						->							int:
          _snake_case													=			self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*_lowerCamelCase					)




     def 		lowerCAmelCase     (						self					)						->							int:
          _snake_case													=			self.model_tester.prepare_config_and_inputs()
          for type in ["absolute", "relative_key", "relative_key_query"]:
               _snake_case													=			type
               self.model_tester.create_and_check_model(*_lowerCamelCase					)




     def 		lowerCAmelCase     (						self					)						->							str:
          _snake_case													=			self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_masked_lm(*_lowerCamelCase					)




     def 		lowerCAmelCase     (						self					)						->							str:
          _snake_case													=			self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_multiple_choice(*_lowerCamelCase					)




     def 		lowerCAmelCase     (						self					)						->							Tuple:
          _snake_case													=			self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_question_answering(*_lowerCamelCase					)




     def 		lowerCAmelCase     (						self					)						->							Union[str, Any]:
          _snake_case													=			self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_sequence_classification(*_lowerCamelCase					)




     def 		lowerCAmelCase     (						self					)						->							int:
          _snake_case													=			self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_token_classification(*_lowerCamelCase					)




     @slow
     def 		lowerCAmelCase     (						self					)						->							Optional[Any]:







          for model_name in MRA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               _snake_case													=			MraModel.from_pretrained(_lowerCamelCase					)
               self.assertIsNotNone(_lowerCamelCase					)






     @unittest.skip(reason='MRA does not output attentions'					)
     def 		lowerCAmelCase     (						self					)						->							List[Any]:
          return





@require_torch
class      UpperCamelCase_						(					unittest.TestCase   ):




     @slow
     def 		lowerCAmelCase     (						self					)						->							List[str]:
          _snake_case													=			MraModel.from_pretrained('uw-madison/mra-base-512-4'					)
          _snake_case													=			torch.arange(256					).unsqueeze(0					)

          with torch.no_grad():
               _snake_case													=			model(_lowerCamelCase					)[0]

          _snake_case													=			torch.Size((1, 256, 768)					)
          self.assertEqual(output.shape			,  _lowerCamelCase					)

          _snake_case													=			torch.tensor(
              [[[-0.01_40, 0.08_30, -0.03_81], [0.15_46, 0.14_02, 0.02_20], [0.11_62, 0.08_51, 0.01_65]]]					)

          self.assertTrue(torch.allclose(output[:, :3, :3]			,  _lowerCamelCase			,  atol=1E-4					)					)




     @slow
     def 		lowerCAmelCase     (						self					)						->							Optional[Any]:
          _snake_case													=			MraForMaskedLM.from_pretrained('uw-madison/mra-base-512-4'					)
          _snake_case													=			torch.arange(256					).unsqueeze(0					)

          with torch.no_grad():
               _snake_case													=			model(_lowerCamelCase					)[0]

          _snake_case													=			5_0265

          _snake_case													=			torch.Size((1, 256, vocab_size)					)
          self.assertEqual(output.shape			,  _lowerCamelCase					)

          _snake_case													=			torch.tensor(
              [[[9.25_95, -3.60_38, 11.88_19], [9.38_69, -3.26_93, 11.09_56], [11.85_24, -3.49_38, 13.12_10]]]					)

          self.assertTrue(torch.allclose(output[:, :3, :3]			,  _lowerCamelCase			,  atol=1E-4					)					)






     @slow
     def 		lowerCAmelCase     (						self					)						->							Tuple:
          _snake_case													=			MraForMaskedLM.from_pretrained('uw-madison/mra-base-4096-8-d3'					)
          _snake_case													=			torch.arange(4096					).unsqueeze(0					)

          with torch.no_grad():
               _snake_case													=			model(_lowerCamelCase					)[0]

          _snake_case													=			5_0265

          _snake_case													=			torch.Size((1, 4096, vocab_size)					)
          self.assertEqual(output.shape			,  _lowerCamelCase					)

          _snake_case													=			torch.tensor(
              [[[5.47_89, -2.35_64, 7.50_64], [7.90_67, -1.33_69, 9.96_68], [9.07_12, -1.81_06, 7.03_80]]]					)

          self.assertTrue(torch.allclose(output[:, :3, :3]			,  _lowerCamelCase			,  atol=1E-4					)					)










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


UpperCAmelCase_ 							=       logging.get_logger(__name__)

# General docstring
UpperCAmelCase_ 							=       """ResNetConfig"""

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

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

UpperCAmelCase_ 							=       [
    """microsoft/resnet-50""",
    # See all resnet models at https://huggingface.co/models?filter=resnet
]
class      UpperCamelCase_						(					nn.Module   ):




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






					def 		lowerCAmelCase     (						self			,  lowerCAmelCase_					)						->							Tensor:
										_snake_case													=			self.convolution(lowerCAmelCase_					)
										_snake_case													=			self.normalization(lowerCAmelCase_					)
										_snake_case													=			self.activation(lowerCAmelCase_					)
										return hidden_state





class      UpperCamelCase_						(					nn.Module   ):




					def __init__(						self			,  lowerCAmelCase_					)						->							Dict:
										super().__init__()
										_snake_case													=			ResNetConvLayer(
										    config.num_channels			,  config.embedding_size			,  kernel_size=7			,  stride=2			,  activation=config.hidden_act					)
										_snake_case													=			nn.MaxPoolad(kernel_size=3			,  stride=2			,  padding=1					)
										_snake_case													=			config.num_channels






					def 		lowerCAmelCase     (						self			,  lowerCAmelCase_					)						->							Tensor:
										_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(lowerCAmelCase_					)
										_snake_case													=			self.pooler(lowerCAmelCase_					)
										return embedding





class      UpperCamelCase_						(					nn.Module   ):




					def __init__(						self			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_ = 2					)						->							List[Any]:
										super().__init__()
										_snake_case													=			nn.Convad(lowerCAmelCase_			,  lowerCAmelCase_			,  kernel_size=1			,  stride=lowerCAmelCase_			,  bias=lowerCAmelCase_					)
										_snake_case													=			nn.BatchNormad(lowerCAmelCase_					)






					def 		lowerCAmelCase     (						self			,  lowerCAmelCase_					)						->							Tensor:
										_snake_case													=			self.convolution(lowerCAmelCase_					)
										_snake_case													=			self.normalization(lowerCAmelCase_					)
										return hidden_state





class      UpperCamelCase_						(					nn.Module   ):




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






					def 		lowerCAmelCase     (						self			,  lowerCAmelCase_					)						->							str:
										_snake_case													=			hidden_state
										_snake_case													=			self.layer(lowerCAmelCase_					)
										_snake_case													=			self.shortcut(lowerCAmelCase_					)
										hidden_state += residual
										_snake_case													=			self.activation(lowerCAmelCase_					)
										return hidden_state





class      UpperCamelCase_						(					nn.Module   ):




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






					def 		lowerCAmelCase     (						self			,  lowerCAmelCase_					)						->							Optional[Any]:
										_snake_case													=			hidden_state
										_snake_case													=			self.layer(lowerCAmelCase_					)
										_snake_case													=			self.shortcut(lowerCAmelCase_					)
										hidden_state += residual
										_snake_case													=			self.activation(lowerCAmelCase_					)
										return hidden_state





class      UpperCamelCase_						(					nn.Module   ):




					def __init__(						self			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_ = 2			,  lowerCAmelCase_ = 2			,  )						->							Tuple:
										super().__init__()

										_snake_case													=			ResNetBottleNeckLayer if config.layer_type == 'bottleneck' else ResNetBasicLayer

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






					def 		lowerCAmelCase     (						self			,  lowerCAmelCase_					)						->							Tensor:
										_snake_case													=			input
										for layer in self.layers:
															_snake_case													=			layer(lowerCAmelCase_					)
										return hidden_state





class      UpperCamelCase_						(					nn.Module   ):




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






					def 		lowerCAmelCase     (						self			,  lowerCAmelCase_			,  lowerCAmelCase_ = False			,  lowerCAmelCase_ = 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(lowerCAmelCase_					)

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





class      UpperCamelCase_						(					_lowerCamelCase   ):
					lowerCAmelCase_							=		ResNetConfig
					lowerCAmelCase_							=		'''resnet'''
					lowerCAmelCase_							=		'''pixel_values'''
					lowerCAmelCase_							=		True




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






					def 		lowerCAmelCase     (						self			,  lowerCAmelCase_			,  lowerCAmelCase_=False					)						->							List[Any]:
										if isinstance(lowerCAmelCase_			,  lowerCAmelCase_					):
															_snake_case													=			value





UpperCAmelCase_ 							=       R"""
    This model is a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass. Use it
    as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage and
    behavior.

    Parameters:
        config ([`ResNetConfig`]): Model configuration class with all the parameters of the model.
            Initializing with a config file does not load the weights associated with the model, only the
            configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights.
"""

UpperCAmelCase_ 							=       R"""
    Args:
        pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`):
            Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See
            [`ConvNextImageProcessor.__call__`] for details.

        output_hidden_states (`bool`, *optional*):
            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for
            more detail.
        return_dict (`bool`, *optional*):
            Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
"""
@add_start_docstrings(
    '''The bare ResNet model outputting raw features without any specific head on top.'''							,					_lowerCamelCase							,					)
class      UpperCamelCase_						(					_lowerCamelCase   ):




					def __init__(						self			,  lowerCAmelCase_					)						->							int:
										super().__init__(lowerCAmelCase_					)
										_snake_case													=			config
										_snake_case													=			ResNetEmbeddings(lowerCAmelCase_					)
										_snake_case													=			ResNetEncoder(lowerCAmelCase_					)
										_snake_case													=			nn.AdaptiveAvgPoolad((1, 1)					)
										# Initialize weights and apply final processing
										self.post_init()






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

										_snake_case													=			self.encoder(
										    lowerCAmelCase_			,  output_hidden_states=lowerCAmelCase_			,  return_dict=lowerCAmelCase_					)

										_snake_case													=			encoder_outputs[0]

										_snake_case													=			self.pooler(lowerCAmelCase_					)

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

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





@add_start_docstrings(
    '''
    ResNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for
    ImageNet.
    '''							,					_lowerCamelCase							,					)
class      UpperCamelCase_						(					_lowerCamelCase   ):




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

										_snake_case													=			self.resnet(lowerCAmelCase_			,  output_hidden_states=lowerCAmelCase_			,  return_dict=lowerCAmelCase_					)

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

										_snake_case													=			self.classifier(lowerCAmelCase_					)

										_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(lowerCAmelCase_			,  lowerCAmelCase_					)
															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(lowerCAmelCase_			,  lowerCAmelCase_					)

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

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





@add_start_docstrings(
    '''
    ResNet backbone, to be used with frameworks like DETR and MaskFormer.
    '''							,					_lowerCamelCase							,					)
class      UpperCamelCase_						(					_lowerCamelCase							,					_lowerCamelCase   ):




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

										_snake_case													=			[config.embedding_size] + config.hidden_sizes
										_snake_case													=			ResNetEmbeddings(lowerCAmelCase_					)
										_snake_case													=			ResNetEncoder(lowerCAmelCase_					)

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






					@add_start_docstrings_to_model_forward(lowerCAmelCase_					)
					@replace_return_docstrings(output_type=lowerCAmelCase_			,  config_class=_CONFIG_FOR_DOC					)
					def 		lowerCAmelCase     (						self			,  lowerCAmelCase_			,  lowerCAmelCase_ = None			,  lowerCAmelCase_ = None					)						->							BackboneOutput:
										_snake_case													=			return_dict if return_dict is not None else self.config.use_return_dict
										_snake_case													=			(
										    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
										)

										_snake_case													=			self.embedder(lowerCAmelCase_					)

										_snake_case													=			self.encoder(lowerCAmelCase_			,  output_hidden_states=lowerCAmelCase_			,  return_dict=lowerCAmelCase_					)

										_snake_case													=			outputs.hidden_states

										_snake_case													=			()
										for idx, stage in enumerate(self.stage_names					):
															if stage in self.out_features:
																				feature_maps += (hidden_states[idx],)

										if not return_dict:
															_snake_case													=			(feature_maps,)
															if output_hidden_states:
																				output += (outputs.hidden_states,)
															return output

										return BackboneOutput(
										    feature_maps=lowerCAmelCase_			,  hidden_states=outputs.hidden_states if output_hidden_states else None			,  attentions=lowerCAmelCase_			,  )



