

import inspect
import unittest

from transformers import ResNetConfig
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_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
				import torch
				from torch import nn

				from transformers import ResNetBackbone, ResNetForImageClassification, ResNetModel
				from transformers.models.resnet.modeling_resnet import RESNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
				from PIL import Image

				from transformers import AutoImageProcessor

class   __UpperCamelCase      :




	def __init__(						self		:  Dict						,		lowerCAmelCase		:  Any						,		lowerCAmelCase		:  Any=3						,		lowerCAmelCase		:  Any=32						,		lowerCAmelCase		:  str=3						,		lowerCAmelCase		:  int=10						,		lowerCAmelCase		:  str=[10, 20, 30, 40]						,		lowerCAmelCase		:  Optional[Any]=[1, 1, 2, 1]						,		lowerCAmelCase		:  List[Any]=True						,		lowerCAmelCase		:  Tuple=True						,		lowerCAmelCase		:  str="relu"						,		lowerCAmelCase		:  Tuple=3						,		lowerCAmelCase		:  Tuple=None						,		lowerCAmelCase		:  Union[str, Any]=["stage2", "stage3", "stage4"]						,		lowerCAmelCase		:  str=[2, 3, 4]						,		):


		'''simple docstring'''







		UpperCAmelCase_    			=     parent
		UpperCAmelCase_    			=     batch_size
		UpperCAmelCase_    			=     image_size
		UpperCAmelCase_    			=     num_channels
		UpperCAmelCase_    			=     embeddings_size
		UpperCAmelCase_    			=     hidden_sizes
		UpperCAmelCase_    			=     depths
		UpperCAmelCase_    			=     is_training
		UpperCAmelCase_    			=     use_labels
		UpperCAmelCase_    			=     hidden_act
		UpperCAmelCase_    			=     num_labels
		UpperCAmelCase_    			=     scope
		UpperCAmelCase_    			=     len(lowerCAmelCase							)
		UpperCAmelCase_    			=     out_features
		UpperCAmelCase_    			=     out_indices




	def  __A   (						self		:  List[str]							):


		'''simple docstring'''







		UpperCAmelCase_    			=     floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

		UpperCAmelCase_    			=     None
		if self.use_labels:
			UpperCAmelCase_    			=     ids_tensor([self.batch_size]						,		self.num_labels							)

		UpperCAmelCase_    			=     self.get_config()

		return config, pixel_values, labels




	def  __A   (						self		:  Any							):


		'''simple docstring'''







		return ResNetConfig(
		    num_channels=self.num_channels						,		embeddings_size=self.embeddings_size						,		hidden_sizes=self.hidden_sizes						,		depths=self.depths						,		hidden_act=self.hidden_act						,		num_labels=self.num_labels						,		out_features=self.out_features						,		out_indices=self.out_indices						,		)




	def  __A   (						self		:  List[str]						,		lowerCAmelCase		:  Tuple						,		lowerCAmelCase		:  Any						,		lowerCAmelCase		:  List[Any]							):


		'''simple docstring'''







		UpperCAmelCase_    			=     ResNetModel(config=lowerCAmelCase							)
		model.to(lowerCAmelCase							)
		model.eval()
		UpperCAmelCase_    			=     model(lowerCAmelCase							)
		# expected last hidden states: B, C, H // 32, W // 32
		self.parent.assertEqual(
		    result.last_hidden_state.shape						,		(self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)						,		)




	def  __A   (						self		:  Dict						,		lowerCAmelCase		:  Any						,		lowerCAmelCase		:  Dict						,		lowerCAmelCase		:  List[Any]							):


		'''simple docstring'''







		UpperCAmelCase_    			=     self.num_labels
		UpperCAmelCase_    			=     ResNetForImageClassification(lowerCAmelCase							)
		model.to(lowerCAmelCase							)
		model.eval()
		UpperCAmelCase_    			=     model(lowerCAmelCase						,		labels=lowerCAmelCase							)
		self.parent.assertEqual(result.logits.shape						,		(self.batch_size, self.num_labels)							)




	def  __A   (						self		:  str						,		lowerCAmelCase		:  int						,		lowerCAmelCase		:  int						,		lowerCAmelCase		:  Tuple							):


		'''simple docstring'''







		UpperCAmelCase_    			=     ResNetBackbone(config=lowerCAmelCase							)
		model.to(lowerCAmelCase							)
		model.eval()
		UpperCAmelCase_    			=     model(lowerCAmelCase							)

		# verify feature maps
		self.parent.assertEqual(len(result.feature_maps							)						,		len(config.out_features							)							)
		self.parent.assertListEqual(list(result.feature_maps[0].shape							)						,		[self.batch_size, self.hidden_sizes[1], 4, 4]							)

		# verify channels
		self.parent.assertEqual(len(model.channels							)						,		len(config.out_features							)							)
		self.parent.assertListEqual(model.channels						,		config.hidden_sizes[1:]							)

		# verify backbone works with out_features=None
		UpperCAmelCase_    			=     None
		UpperCAmelCase_    			=     ResNetBackbone(config=lowerCAmelCase							)
		model.to(lowerCAmelCase							)
		model.eval()
		UpperCAmelCase_    			=     model(lowerCAmelCase							)

		# verify feature maps
		self.parent.assertEqual(len(result.feature_maps							)						,		1							)
		self.parent.assertListEqual(list(result.feature_maps[0].shape							)						,		[self.batch_size, self.hidden_sizes[-1], 1, 1]							)

		# verify channels
		self.parent.assertEqual(len(model.channels							)						,		1							)
		self.parent.assertListEqual(model.channels						,		[config.hidden_sizes[-1]]							)




	def  __A   (						self		:  str							):


		'''simple docstring'''







		UpperCAmelCase_    			=     self.prepare_config_and_inputs()
		UpperCAmelCase_			,				UpperCAmelCase_			,				UpperCAmelCase_    			=     config_and_inputs
		UpperCAmelCase_    			=     {"pixel_values": pixel_values}
		return config, inputs_dict


@require_torch
class   __UpperCamelCase      (   lowercase       ,       lowercase       ,       unittest.TestCase  ):
	SCREAMING_SNAKE_CASE__      			=       (
	    (
	        ResNetModel,
	        ResNetForImageClassification,
	        ResNetBackbone,
	    )
	    if is_torch_available()
	    else ()
	)
	SCREAMING_SNAKE_CASE__      			=       (
	    {'feature-extraction': ResNetModel, 'image-classification': ResNetForImageClassification}
	    if is_torch_available()
	    else {}
	)

	SCREAMING_SNAKE_CASE__      			=       True
	SCREAMING_SNAKE_CASE__      			=       False
	SCREAMING_SNAKE_CASE__      			=       False
	SCREAMING_SNAKE_CASE__      			=       False
	SCREAMING_SNAKE_CASE__      			=       False




	def  __A   (						self		:  List[str]							):


		'''simple docstring'''







		UpperCAmelCase_    			=     ResNetModelTester(self							)
		UpperCAmelCase_    			=     ConfigTester(self						,		config_class=lowerCAmelCase						,		has_text_modality=lowerCAmelCase							)




	def  __A   (						self		:  Dict							):


		'''simple docstring'''







		self.create_and_test_config_common_properties()
		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  __A   (						self		:  Tuple							):


		'''simple docstring'''







		return




	@unittest.skip(reason="ResNet does not use inputs_embeds"							)
	def  __A   (						self		:  List[Any]							):


		'''simple docstring'''







		pass




	@unittest.skip(reason="ResNet does not support input and output embeddings"							)
	def  __A   (						self		:  Union[str, Any]							):


		'''simple docstring'''







		pass




	def  __A   (						self		:  List[str]							):


		'''simple docstring'''







		UpperCAmelCase_			,				UpperCAmelCase_    			=     self.model_tester.prepare_config_and_inputs_for_common()

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

			UpperCAmelCase_    			=     ["pixel_values"]
			self.assertListEqual(arg_names[:1]						,		lowerCAmelCase							)




	def  __A   (						self		:  List[str]							):


		'''simple docstring'''







		UpperCAmelCase_    			=     self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_model(*lowerCAmelCase							)




	def  __A   (						self		:  Tuple							):


		'''simple docstring'''







		UpperCAmelCase_    			=     self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_backbone(*lowerCAmelCase							)




	def  __A   (						self		:  Tuple							):


		'''simple docstring'''







		UpperCAmelCase_			,				UpperCAmelCase_    			=     self.model_tester.prepare_config_and_inputs_for_common()

		for model_class in self.all_model_classes:
			UpperCAmelCase_    			=     model_class(config=lowerCAmelCase							)
			for name, module in model.named_modules():
				if isinstance(lowerCAmelCase						,		(nn.BatchNormad, nn.GroupNorm)							):
					self.assertTrue(
					    torch.all(module.weight == 1							)						,		msg=F"Parameter {name} of model {model_class} seems not properly initialized"						,		)
					self.assertTrue(
					    torch.all(module.bias == 0							)						,		msg=F"Parameter {name} of model {model_class} seems not properly initialized"						,		)




	def  __A   (						self		:  List[Any]							):


		'''simple docstring'''







		def check_hidden_states_output(lowerCAmelCase		:  Optional[Any]						,		lowerCAmelCase		:  Union[str, Any]						,		lowerCAmelCase		:  Tuple							):
			UpperCAmelCase_    			=     model_class(lowerCAmelCase							)
			model.to(lowerCAmelCase							)
			model.eval()

			with torch.no_grad():
				UpperCAmelCase_    			=     model(**self._prepare_for_class(lowerCAmelCase						,		lowerCAmelCase							)							)

			UpperCAmelCase_    			=     outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

			UpperCAmelCase_    			=     self.model_tester.num_stages
			self.assertEqual(len(lowerCAmelCase							)						,		expected_num_stages + 1							)

			# ResNet's feature maps are of shape (batch_size, num_channels, height, width)
			self.assertListEqual(
			    list(hidden_states[0].shape[-2:]							)						,		[self.model_tester.image_size // 4, self.model_tester.image_size // 4]						,		)

		UpperCAmelCase_			,				UpperCAmelCase_    			=     self.model_tester.prepare_config_and_inputs_for_common()
		UpperCAmelCase_    			=     ["basic", "bottleneck"]
		for model_class in self.all_model_classes:
			for layer_type in layers_type:
				UpperCAmelCase_    			=     layer_type
				UpperCAmelCase_    			=     True
				check_hidden_states_output(lowerCAmelCase						,		lowerCAmelCase						,		lowerCAmelCase							)

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

				check_hidden_states_output(lowerCAmelCase						,		lowerCAmelCase						,		lowerCAmelCase							)




	@unittest.skip(reason="ResNet does not use feedforward chunking"							)
	def  __A   (						self		:  Any							):


		'''simple docstring'''







		pass




	def  __A   (						self		:  List[str]							):


		'''simple docstring'''







		UpperCAmelCase_    			=     self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase							)




	@slow
	def  __A   (						self		:  Dict							):


		'''simple docstring'''







		for model_name in RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
			UpperCAmelCase_    			=     ResNetModel.from_pretrained(lowerCAmelCase							)
			self.assertIsNotNone(lowerCAmelCase							)



def  __lowerCAmelCase (  ):
	UpperCAmelCase_    			=     Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"      )
	return image

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




	@cached_property
	def  __A   (						self		:  int							):


		'''simple docstring'''







		return (
		    AutoImageProcessor.from_pretrained(RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]							)
		    if is_vision_available()
		    else None
		)




	@slow
	def  __A   (						self		:  List[Any]							):


		'''simple docstring'''







		UpperCAmelCase_    			=     ResNetForImageClassification.from_pretrained(RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]							).to(lowerCAmelCase							)

		UpperCAmelCase_    			=     self.default_image_processor
		UpperCAmelCase_    			=     prepare_img()
		UpperCAmelCase_    			=     image_processor(images=lowerCAmelCase						,		return_tensors="pt"							).to(lowerCAmelCase							)

		# forward pass
		with torch.no_grad():
			UpperCAmelCase_    			=     model(**lowerCAmelCase							)

		# verify the logits
		UpperCAmelCase_    			=     torch.Size((1, 1_000)							)
		self.assertEqual(outputs.logits.shape						,		lowerCAmelCase							)

		UpperCAmelCase_    			=     torch.tensor([-11.1_069, -9.7_877, -8.3_777]							).to(lowerCAmelCase							)

		self.assertTrue(torch.allclose(outputs.logits[0, :3]						,		lowerCAmelCase						,		atol=1e-4							)							)


@require_torch
class   __UpperCamelCase      (   lowercase       ,       unittest.TestCase  ):
	SCREAMING_SNAKE_CASE__      			=       (ResNetBackbone,) if is_torch_available() else ()
	SCREAMING_SNAKE_CASE__      			=       False
	SCREAMING_SNAKE_CASE__      			=       ResNetConfig




	def  __A   (						self		:  Union[str, Any]							):


		'''simple docstring'''







		UpperCAmelCase_    			=     ResNetModelTester(self							)


from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_torch_available,
    is_vision_available,
)


_a:      Tuple								=     {
    """configuration_segformer""": ["""SEGFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP""", """SegformerConfig""", """SegformerOnnxConfig"""]
}

try:
				if not is_vision_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				_a:      List[str]								=     ["""SegformerFeatureExtractor"""]
				_a:      Union[str, Any]								=     ["""SegformerImageProcessor"""]

try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				_a:      Any								=     [
				    """SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST""",
				    """SegformerDecodeHead""",
				    """SegformerForImageClassification""",
				    """SegformerForSemanticSegmentation""",
				    """SegformerLayer""",
				    """SegformerModel""",
				    """SegformerPreTrainedModel""",
				]

try:
				if not is_tf_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				_a:      Optional[Any]								=     [
				    """TF_SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST""",
				    """TFSegformerDecodeHead""",
				    """TFSegformerForImageClassification""",
				    """TFSegformerForSemanticSegmentation""",
				    """TFSegformerModel""",
				    """TFSegformerPreTrainedModel""",
				]


if TYPE_CHECKING:
				from .configuration_segformer import SEGFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, SegformerConfig, SegformerOnnxConfig

				try:
								if not is_vision_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .feature_extraction_segformer import SegformerFeatureExtractor
								from .image_processing_segformer import SegformerImageProcessor

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_segformer import (
								    SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
								    SegformerDecodeHead,
								    SegformerForImageClassification,
								    SegformerForSemanticSegmentation,
								    SegformerLayer,
								    SegformerModel,
								    SegformerPreTrainedModel,
								)
				try:
								if not is_tf_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_tf_segformer import (
								    TF_SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
								    TFSegformerDecodeHead,
								    TFSegformerForImageClassification,
								    TFSegformerForSemanticSegmentation,
								    TFSegformerModel,
								    TFSegformerPreTrainedModel,
								)

else:
				import sys

				_a:      Optional[int]								=     _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)