





import inspect
import unittest
from typing import List

import numpy as np

from transformers import EfficientFormerConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
					import tensorflow as tf

					from transformers import (
					    TFEfficientFormerForImageClassification,
					    TFEfficientFormerForImageClassificationWithTeacher,
					    TFEfficientFormerModel,
					)
					from transformers.models.efficientformer.modeling_tf_efficientformer import (
					    TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
					)


if is_vision_available():
					from PIL import Image

					from transformers import EfficientFormerImageProcessor
class      UpperCamelCase_						:




					def __init__(						self			,  lowerCAmelCase_			,  lowerCAmelCase_ = 13			,  lowerCAmelCase_ = 64			,  lowerCAmelCase_ = 2			,  lowerCAmelCase_ = 3			,  lowerCAmelCase_ = 3			,  lowerCAmelCase_ = True			,  lowerCAmelCase_ = True			,  lowerCAmelCase_ = 128			,  lowerCAmelCase_=[16, 32, 64, 128]			,  lowerCAmelCase_ = 7			,  lowerCAmelCase_ = 4			,  lowerCAmelCase_ = 37			,  lowerCAmelCase_ = "gelu"			,  lowerCAmelCase_ = 0.1			,  lowerCAmelCase_ = 0.1			,  lowerCAmelCase_ = 10			,  lowerCAmelCase_ = 0.02			,  lowerCAmelCase_ = 2			,  lowerCAmelCase_ = 1			,  lowerCAmelCase_ = 128			,  lowerCAmelCase_ = [2, 2, 2, 2]			,  lowerCAmelCase_ = 2			,  lowerCAmelCase_ = 2			,  )						->							Dict:
										_snake_case													=			parent
										_snake_case													=			batch_size
										_snake_case													=			image_size
										_snake_case													=			patch_size
										_snake_case													=			num_channels
										_snake_case													=			is_training
										_snake_case													=			use_labels
										_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													=			type_sequence_label_size
										_snake_case													=			initializer_range
										_snake_case													=			encoder_stride
										_snake_case													=			num_attention_outputs
										_snake_case													=			embed_dim
										_snake_case													=			embed_dim + 1
										_snake_case													=			resolution
										_snake_case													=			depths
										_snake_case													=			hidden_sizes
										_snake_case													=			dim
										_snake_case													=			mlp_expansion_ratio




					def 		lowerCAmelCase     (						self					)						->							Optional[Any]:
										_snake_case													=			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)

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

										_snake_case													=			self.get_config()

										return config, pixel_values, labels




					def 		lowerCAmelCase     (						self					)						->							Tuple:
										return EfficientFormerConfig(
										    image_size=self.image_size			,  patch_size=self.patch_size			,  num_channels=self.num_channels			,  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			,  is_decoder=lowerCAmelCase_			,  initializer_range=self.initializer_range			,  encoder_stride=self.encoder_stride			,  resolution=self.resolution			,  depths=self.depths			,  hidden_sizes=self.hidden_sizes			,  dim=self.dim			,  mlp_expansion_ratio=self.mlp_expansion_ratio			,  )




					def 		lowerCAmelCase     (						self			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_					)						->							List[Any]:
										_snake_case													=			TFEfficientFormerModel(config=lowerCAmelCase_					)
										_snake_case													=			model(lowerCAmelCase_			,  training=lowerCAmelCase_					)
										self.parent.assertEqual(result.last_hidden_state.shape			,  (self.batch_size, self.seq_length, self.hidden_size)					)




					def 		lowerCAmelCase     (						self			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_					)						->							Any:
										_snake_case													=			self.type_sequence_label_size
										_snake_case													=			TFEfficientFormerForImageClassification(lowerCAmelCase_					)
										_snake_case													=			model(lowerCAmelCase_			,  labels=lowerCAmelCase_			,  training=lowerCAmelCase_					)
										self.parent.assertEqual(result.logits.shape			,  (self.batch_size, self.type_sequence_label_size)					)

										# test greyscale images
										_snake_case													=			1
										_snake_case													=			TFEfficientFormerForImageClassification(lowerCAmelCase_					)

										_snake_case													=			floats_tensor([self.batch_size, 1, self.image_size, self.image_size]					)
										_snake_case													=			model(lowerCAmelCase_			,  labels=lowerCAmelCase_					)
										self.parent.assertEqual(result.logits.shape			,  (self.batch_size, self.type_sequence_label_size)					)






					def 		lowerCAmelCase     (						self					)						->							List[str]:
										_snake_case													=			self.prepare_config_and_inputs()
										_snake_case							,       _snake_case							,       _snake_case													=			config_and_inputs
										_snake_case													=			{'pixel_values': pixel_values}
										return config, inputs_dict





@require_tf
class      UpperCamelCase_						(					_lowerCamelCase							,					_lowerCamelCase							,					unittest.TestCase   ):
					lowerCAmelCase_							=		(
					    (
					        TFEfficientFormerModel,
					        TFEfficientFormerForImageClassificationWithTeacher,
					        TFEfficientFormerForImageClassification,
					    )
					    if is_tf_available()
					    else ()
					)
					lowerCAmelCase_							=		(
					    {
					        '''feature-extraction''': TFEfficientFormerModel,
					        '''image-classification''': (
					            TFEfficientFormerForImageClassification,
					            TFEfficientFormerForImageClassificationWithTeacher,
					        ),
					    }
					    if is_tf_available()
					    else {}
					)

					lowerCAmelCase_							=		False

					lowerCAmelCase_							=		False
					lowerCAmelCase_							=		False
					lowerCAmelCase_							=		False
					lowerCAmelCase_							=		False




					def 		lowerCAmelCase     (						self					)						->							str:
										_snake_case													=			TFEfficientFormerModelTester(self					)
										_snake_case													=			ConfigTester(
										    self			,  config_class=lowerCAmelCase_			,  has_text_modality=lowerCAmelCase_			,  hidden_size=37					)




					def 		lowerCAmelCase     (						self					)						->							str:
										self.config_tester.run_common_tests()




					@unittest.skip(reason='EfficientFormer does not use inputs_embeds'					)
					def 		lowerCAmelCase     (						self					)						->							int:
										pass




					@unittest.skip(reason='EfficientFormer does not support input and output embeddings'					)
					def 		lowerCAmelCase     (						self					)						->							Optional[Any]:
										pass




					def 		lowerCAmelCase     (						self					)						->							str:
										_snake_case							,       _snake_case													=			self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
															_snake_case													=			model_class(lowerCAmelCase_					)
															_snake_case													=			inspect.signature(model.call					)
															# signature.parameters is an OrderedDict => so arg_names order is deterministic
															_snake_case													=			[*signature.parameters.keys()]

															_snake_case													=			['pixel_values']
															self.assertListEqual(arg_names[:1]			,  lowerCAmelCase_					)




					def 		lowerCAmelCase     (						self					)						->							Optional[Any]:
										def check_hidden_states_output(lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_					):
															_snake_case													=			model_class(lowerCAmelCase_					)

															_snake_case													=			model(**self._prepare_for_class(lowerCAmelCase_			,  lowerCAmelCase_					)			,  training=lowerCAmelCase_					)
															_snake_case													=			outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

															_snake_case													=			getattr(
															    self.model_tester			,  'expected_num_hidden_layers'			,  self.model_tester.num_hidden_layers + 1					)
															self.assertEqual(len(lowerCAmelCase_					)			,  lowerCAmelCase_					)

															if hasattr(self.model_tester			,  'encoder_seq_length'					):
																				_snake_case													=			self.model_tester.encoder_seq_length
																				if hasattr(self.model_tester			,  'chunk_length'					) and self.model_tester.chunk_length > 1:
																									_snake_case													=			seq_length * self.model_tester.chunk_length
															else:
																				_snake_case													=			self.model_tester.seq_length

															self.assertListEqual(
															    list(hidden_states[-1].shape[-2:]					)			,  [seq_length, self.model_tester.hidden_size]			,  )

															if config.is_encoder_decoder:
																				_snake_case													=			outputs.decoder_hidden_states

																				self.asseretIsInstance(lowerCAmelCase_			,  (list, tuple)					)
																				self.assertEqual(len(lowerCAmelCase_					)			,  lowerCAmelCase_					)
																				_snake_case													=			getattr(self.model_tester			,  'seq_length'			,  lowerCAmelCase_					)
																				_snake_case													=			getattr(self.model_tester			,  'decoder_seq_length'			,  lowerCAmelCase_					)

																				self.assertListEqual(
																				    list(hidden_states[-1].shape[-2:]					)			,  [decoder_seq_length, self.model_tester.hidden_size]			,  )

										_snake_case							,       _snake_case													=			self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
															_snake_case													=			True
															check_hidden_states_output(lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_					)

															# check that output_hidden_states also work using config
															del inputs_dict["output_hidden_states"]
															_snake_case													=			True

															check_hidden_states_output(lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_					)




					def 		lowerCAmelCase     (						self			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_=False					)						->							List[Any]:
										_snake_case													=			super()._prepare_for_class(lowerCAmelCase_			,  lowerCAmelCase_			,  return_labels=lowerCAmelCase_					)

										if return_labels:
															if model_class.__name__ == "TFEfficientFormerForImageClassificationWithTeacher":
																				del inputs_dict["labels"]

										return inputs_dict




					def 		lowerCAmelCase     (						self					)						->							Dict:
										_snake_case													=			self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*lowerCAmelCase_					)




					@unittest.skip(reason='EfficientFormer does not implement masked image modeling yet'					)
					def 		lowerCAmelCase     (						self					)						->							Dict:
										_snake_case													=			self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_masked_image_modeling(*lowerCAmelCase_					)




					def 		lowerCAmelCase     (						self					)						->							List[Any]:
										_snake_case													=			self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase_					)




					@slow
					def 		lowerCAmelCase     (						self					)						->							str:
										for model_name in TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
															_snake_case													=			TFEfficientFormerModel.from_pretrained(lowerCAmelCase_					)
															self.assertIsNotNone(lowerCAmelCase_					)




					def 		lowerCAmelCase     (						self					)						->							List[str]:
										_snake_case							,       _snake_case													=			self.model_tester.prepare_config_and_inputs_for_common()
										_snake_case													=			True

										_snake_case													=			getattr(self.model_tester			,  'seq_length'			,  lowerCAmelCase_					)
										_snake_case													=			getattr(self.model_tester			,  'encoder_seq_length'			,  lowerCAmelCase_					)
										_snake_case													=			getattr(self.model_tester			,  'key_length'			,  lowerCAmelCase_					)
										_snake_case													=			getattr(self.model_tester			,  'chunk_length'			,  lowerCAmelCase_					)

										if chunk_length is not None and hasattr(self.model_tester			,  'num_hashes'					):
															_snake_case													=			encoder_seq_length * self.model_tester.num_hashes

										for model_class in self.all_model_classes:
															_snake_case													=			True
															_snake_case													=			False
															_snake_case													=			True
															_snake_case													=			model_class(lowerCAmelCase_					)

															_snake_case													=			model(**self._prepare_for_class(lowerCAmelCase_			,  lowerCAmelCase_					)			,  training=lowerCAmelCase_					)
															_snake_case													=			outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
															self.assertEqual(len(lowerCAmelCase_					)			,  self.model_tester.num_attention_outputs					)

															# check that output_attentions also work using config
															del inputs_dict["output_attentions"]
															_snake_case													=			True
															_snake_case													=			model_class(lowerCAmelCase_					)
															_snake_case													=			model(**self._prepare_for_class(lowerCAmelCase_			,  lowerCAmelCase_					)			,  training=lowerCAmelCase_					)

															_snake_case													=			outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
															self.assertEqual(len(lowerCAmelCase_					)			,  self.model_tester.num_attention_outputs					)

															if chunk_length is not None:
																				self.assertListEqual(
																				    list(attentions[0].shape[-4:]					)			,  [self.model_tester.num_attention_heads, encoder_seq_length, chunk_length, encoder_key_length]			,  )
															else:
																				self.assertListEqual(
																				    list(attentions[0].shape[-3:]					)			,  [self.model_tester.num_attention_heads, encoder_seq_length, encoder_key_length]			,  )






					def 		lowerCAmelCase     (						self					)						->							Dict:
										# We use a simplified version of this test for EfficientFormer because it requires training=False
										# and Keras refuses to let us force that during functional construction
										_snake_case							,       _snake_case													=			self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
															# Prepare our model
															_snake_case													=			model_class(lowerCAmelCase_					)
															# These are maximally general inputs for the model, with multiple None dimensions
															# Hopefully this will catch any conditionals that fail for flexible shapes
															_snake_case													=			{
															    key: tf.keras.Input(shape=val.shape[1:]			,  dtype=val.dtype			,  name=lowerCAmelCase_					)
															    for key, val in model.input_signature.items()
															    if key in model.dummy_inputs
															}
															_snake_case													=			model(lowerCAmelCase_					)
															self.assertTrue(outputs_dict is not None					)





def   lowerCamelCase__       (       )     ->	List[str]:



					'''simple docstring'''




					_snake_case													=			Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'  )
					return image




@require_tf
@require_vision
class      UpperCamelCase_						(					unittest.TestCase   ):




					@cached_property
					def 		lowerCAmelCase     (						self					)						->							Dict:
										return (
										    EfficientFormerImageProcessor.from_pretrained('snap-research/efficientformer-l1-300'					)
										    if is_vision_available()
										    else None
										)




					@slow
					def 		lowerCAmelCase     (						self					)						->							Union[str, Any]:
										_snake_case													=			TFEfficientFormerForImageClassification.from_pretrained('snap-research/efficientformer-l1-300'					)
										_snake_case													=			self.default_image_processor
										_snake_case													=			prepare_img()
										_snake_case													=			image_processor(images=lowerCAmelCase_			,  return_tensors='tf'					)
										# forward pass
										_snake_case													=			model(**lowerCAmelCase_			,  training=lowerCAmelCase_					)
										# verify the logits
										_snake_case													=			tf.TensorShape((1, 1000)					)
										self.assertEqual(outputs.logits.shape			,  lowerCAmelCase_					)
										_snake_case													=			tf.constant([-0.05_55, 0.48_25, -0.08_52]					)
										self.assertTrue(np.allclose(outputs.logits[0, :3]			,  lowerCAmelCase_			,  atol=1E-4					)					)






					@slow
					def 		lowerCAmelCase     (						self					)						->							str:
										_snake_case													=			TFEfficientFormerForImageClassificationWithTeacher.from_pretrained(
										    'snap-research/efficientformer-l1-300'					)
										_snake_case													=			self.default_image_processor
										_snake_case													=			prepare_img()
										_snake_case													=			image_processor(images=lowerCAmelCase_			,  return_tensors='tf'					)
										# forward pass
										_snake_case													=			model(**lowerCAmelCase_			,  training=lowerCAmelCase_					)
										# verify the logits
										_snake_case													=			tf.TensorShape((1, 1000)					)
										self.assertEqual(outputs.logits.shape			,  lowerCAmelCase_					)
										_snake_case													=			tf.constant([-0.13_12, 0.43_53, -1.04_99]					)
										self.assertTrue(np.allclose(outputs.logits[0, :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_			,  )



