


from __future__ import annotations

import inspect
import unittest

import numpy as np

from transformers import ResNetConfig
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 TFResNetForImageClassification, TFResNetModel
				from transformers.models.resnet.modeling_tf_resnet import TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
				from PIL import Image

				from transformers import AutoImageProcessor




class 							lowerCamelCase   :


	def __init__(    self				,     lowercase__				,     lowercase__=3				,     lowercase__=3_2				,     lowercase__=3				,     lowercase__=1_0				,     lowercase__=[1_0, 2_0, 3_0, 4_0]				,     lowercase__=[1, 1, 2, 1]				,     lowercase__=True				,     lowercase__=True				,     lowercase__="relu"				,     lowercase__=3				,     lowercase__=None				,     ):
							__UpperCAmelCase			:							Dict	    =	parent
							__UpperCAmelCase			:							Optional[int]	    =	batch_size
							__UpperCAmelCase			:							Any	    =	image_size
							__UpperCAmelCase			:							Tuple	    =	num_channels
							__UpperCAmelCase			:							Optional[Any]	    =	embeddings_size
							__UpperCAmelCase			:							int	    =	hidden_sizes
							__UpperCAmelCase			:							str	    =	depths
							__UpperCAmelCase			:							Any	    =	is_training
							__UpperCAmelCase			:							Optional[Any]	    =	use_labels
							__UpperCAmelCase			:							Tuple	    =	hidden_act
							__UpperCAmelCase			:							List[Any]	    =	num_labels
							__UpperCAmelCase			:							Any	    =	scope
							__UpperCAmelCase			:							List[Any]	    =	len(lowercase__)


	def  A(    self):
							__UpperCAmelCase			:							str	    =	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

							__UpperCAmelCase			:							List[Any]	    =	None
							if self.use_labels:
													__UpperCAmelCase			:							Optional[int]	    =	ids_tensor([self.batch_size]				,     self.num_labels)

							__UpperCAmelCase			:							Optional[Any]	    =	self.get_config()

							return config, pixel_values, labels


	def  A(    self):
							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				,     image_size=self.image_size				,     )


	def  A(    self				,     lowercase__				,     lowercase__				,     lowercase__):
							__UpperCAmelCase			:							Dict	    =	TFResNetModel(config=lowercase__)
							__UpperCAmelCase			:							Dict	    =	model(lowercase__)
							# 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 // 3_2, self.image_size // 3_2)				,     )


	def  A(    self				,     lowercase__				,     lowercase__				,     lowercase__):
							__UpperCAmelCase			:							Any	    =	self.num_labels
							__UpperCAmelCase			:							Any	    =	TFResNetForImageClassification(lowercase__)
							__UpperCAmelCase			:							List[Any]	    =	model(lowercase__				,     labels=lowercase__)
							self.parent.assertEqual(result.logits.shape				,     (self.batch_size, self.num_labels))


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






@require_tf
class 							lowerCamelCase   (  _UpperCamelCase							,						_UpperCamelCase							,						unittest.TestCase ):
	_lowerCAmelCase     :		Optional[Any]										=						(TFResNetModel, TFResNetForImageClassification) if is_tf_available() else ()
	_lowerCAmelCase     :		List[Any]										=						(
	    {'''feature-extraction''': TFResNetModel, '''image-classification''': TFResNetForImageClassification}
	    if is_tf_available()
	    else {}
	)

	_lowerCAmelCase     :		List[str]										=						False
	_lowerCAmelCase     :		Any										=						False
	_lowerCAmelCase     :		Tuple										=						False
	_lowerCAmelCase     :		str										=						False
	_lowerCAmelCase     :		Any										=						False


	def  A(    self):
							__UpperCAmelCase			:							int	    =	TFResNetModelTester(self)
							__UpperCAmelCase			:							int	    =	ConfigTester(self				,     config_class=lowercase__				,     has_text_modality=lowercase__)


	def  A(    self):
							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):
							return


	@unittest.skip(reason='''ResNet does not use inputs_embeds''')
	def  A(    self):
							pass


	@unittest.skip(reason='''ResNet does not support input and output embeddings''')
	def  A(    self):
							pass


	def  A(    self):
							__UpperCAmelCase    ,      __UpperCAmelCase			:							Any	    =	self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
													__UpperCAmelCase			:							List[str]	    =	model_class(lowercase__)
													__UpperCAmelCase			:							Any	    =	inspect.signature(model.call)
													# signature.parameters is an OrderedDict => so arg_names order is deterministic
													__UpperCAmelCase			:							Optional[Any]	    =	[*signature.parameters.keys()]

													__UpperCAmelCase			:							Optional[Any]	    =	['''pixel_values''']
													self.assertListEqual(arg_names[:1]				,     lowercase__)


	def  A(    self):
							__UpperCAmelCase			:							List[Any]	    =	self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*lowercase__)


	def  A(    self):
							def check_hidden_states_output(lowercase__				,     lowercase__				,     lowercase__):
													__UpperCAmelCase			:							str	    =	model_class(lowercase__)
													__UpperCAmelCase			:							Optional[Any]	    =	model(**self._prepare_for_class(lowercase__				,     lowercase__))

													__UpperCAmelCase			:							str	    =	outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

													__UpperCAmelCase			:							Tuple	    =	self.model_tester.num_stages
													self.assertEqual(len(lowercase__)				,     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			:							int	    =	self.model_tester.prepare_config_and_inputs_for_common()
							__UpperCAmelCase			:							Any	    =	['''basic''', '''bottleneck''']
							for model_class in self.all_model_classes:
													for layer_type in layers_type:
																			__UpperCAmelCase			:							str	    =	layer_type
																			__UpperCAmelCase			:							Any	    =	True
																			check_hidden_states_output(lowercase__				,     lowercase__				,     lowercase__)

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

																			check_hidden_states_output(lowercase__				,     lowercase__				,     lowercase__)


	def  A(    self):
							__UpperCAmelCase			:							Dict	    =	self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_image_classification(*lowercase__)


	@slow
	def  A(    self):
							for model_name in TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													__UpperCAmelCase			:							Optional[int]	    =	TFResNetModel.from_pretrained(lowercase__)
													self.assertIsNotNone(lowercase__)






def     __SCREAMING_SNAKE_CASE							(       )		->     Optional[int]:




						'''simple docstring'''







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





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


	@cached_property
	def  A(    self):
							return (
							    AutoImageProcessor.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0])
							    if is_vision_available()
							    else None
							)


	@slow
	def  A(    self):
							__UpperCAmelCase			:							Optional[int]	    =	TFResNetForImageClassification.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0])

							__UpperCAmelCase			:							Tuple	    =	self.default_image_processor
							__UpperCAmelCase			:							Any	    =	prepare_img()
							__UpperCAmelCase			:							Optional[Any]	    =	image_processor(images=lowercase__				,     return_tensors='''tf''')

							# forward pass
							__UpperCAmelCase			:							int	    =	model(**lowercase__)

							# verify the logits
							__UpperCAmelCase			:							Dict	    =	tf.TensorShape((1, 1_0_0_0))
							self.assertEqual(outputs.logits.shape				,     lowercase__)

							__UpperCAmelCase			:							List[str]	    =	tf.constant([-1_1.1_0_6_9, -9.7_8_7_7, -8.3_7_7_7])

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





import inspect
import os
import sys
import unittest

import accelerate
from accelerate.test_utils import execute_subprocess_async, require_tpu




class 							lowerCamelCase   (  unittest.TestCase ):


	def  A(    self):
							__UpperCAmelCase			:							List[Any]	    =	inspect.getfile(accelerate.test_utils)
							__UpperCAmelCase			:							Dict	    =	os.path.sep.join(mod_file.split(os.path.sep)[:-1] + ['''scripts''', '''test_script.py'''])
							__UpperCAmelCase			:							Union[str, Any]	    =	os.path.sep.join(inspect.getfile(self.__class__).split(os.path.sep)[:-1])


	@require_tpu
	def  A(    self):
							__UpperCAmelCase			:							Dict	    =	F"\n            {self.test_dir}/xla_spawn.py\n            --num_cores 8\n            {self.test_file_path}\n        ".split()
							__UpperCAmelCase			:							Union[str, Any]	    =	[sys.executable] + distributed_args
							execute_subprocess_async(lowercase__				,     env=os.environ.copy())

