
"""simple docstring"""







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 			A__	:

		def __init__(				self	,		_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE=3	,		_SCREAMING_SNAKE_CASE=32	,		_SCREAMING_SNAKE_CASE=3	,		_SCREAMING_SNAKE_CASE=10	,		_SCREAMING_SNAKE_CASE=[10, 20, 30, 40]	,		_SCREAMING_SNAKE_CASE=[1, 1, 2, 1]	,		_SCREAMING_SNAKE_CASE=True	,		_SCREAMING_SNAKE_CASE=True	,		_SCREAMING_SNAKE_CASE="relu"	,		_SCREAMING_SNAKE_CASE=3	,		_SCREAMING_SNAKE_CASE=None	,		):
			__lowerCAmelCase      :						Union[str, Any]						      =				parent
			__lowerCAmelCase      :						Tuple						      =				batch_size
			__lowerCAmelCase      :						Optional[int]						      =				image_size
			__lowerCAmelCase      :						int						      =				num_channels
			__lowerCAmelCase      :						Any						      =				embeddings_size
			__lowerCAmelCase      :						List[str]						      =				hidden_sizes
			__lowerCAmelCase      :						List[str]						      =				depths
			__lowerCAmelCase      :						Optional[Any]						      =				is_training
			__lowerCAmelCase      :						str						      =				use_labels
			__lowerCAmelCase      :						str						      =				hidden_act
			__lowerCAmelCase      :						str						      =				num_labels
			__lowerCAmelCase      :						List[Any]						      =				scope
			__lowerCAmelCase      :						List[str]						      =				len(_SCREAMING_SNAKE_CASE			)

		def 							__lowerCamelCase							(				self			):
			__lowerCAmelCase      :						List[str]						      =				floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]			)

			__lowerCAmelCase      :						str						      =				None
			if self.use_labels:
				__lowerCAmelCase      :						Union[str, Any]						      =				ids_tensor([self.batch_size]	,		self.num_labels			)

			__lowerCAmelCase      :						List[Any]						      =				self.get_config()

			return config, pixel_values, labels

		def 							__lowerCamelCase							(				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 							__lowerCamelCase							(				self	,		_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE			):
			__lowerCAmelCase      :						Optional[int]						      =				TFResNetModel(config=_SCREAMING_SNAKE_CASE			)
			__lowerCAmelCase      :						int						      =				model(_SCREAMING_SNAKE_CASE			)
			# 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 							__lowerCamelCase							(				self	,		_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE			):
			__lowerCAmelCase      :						Any						      =				self.num_labels
			__lowerCAmelCase      :						Tuple						      =				TFResNetForImageClassification(_SCREAMING_SNAKE_CASE			)
			__lowerCAmelCase      :						int						      =				model(_SCREAMING_SNAKE_CASE	,		labels=_SCREAMING_SNAKE_CASE			)
			self.parent.assertEqual(result.logits.shape	,		(self.batch_size, self.num_labels)			)







		def 							__lowerCamelCase							(				self			):
			__lowerCAmelCase      :						Dict						      =				self.prepare_config_and_inputs()
			__lowerCAmelCase      ,       __lowerCAmelCase      ,       __lowerCAmelCase      :						List[str]						      =				config_and_inputs
			__lowerCAmelCase      :						Optional[int]						      =				{'pixel_values': pixel_values}
			return config, inputs_dict




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

		A_						:	str           =     False
		A_						:	Union[str, Any]           =     False
		A_						:	str           =     False
		A_						:	Optional[int]           =     False
		A_						:	Any           =     False

		def 							__lowerCamelCase							(				self			):
			__lowerCAmelCase      :						Tuple						      =				TFResNetModelTester(self			)
			__lowerCAmelCase      :						Tuple						      =				ConfigTester(self	,		config_class=_SCREAMING_SNAKE_CASE	,		has_text_modality=_SCREAMING_SNAKE_CASE			)

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

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

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

		def 							__lowerCamelCase							(				self			):
			__lowerCAmelCase      ,       __lowerCAmelCase      :						Optional[int]						      =				self.model_tester.prepare_config_and_inputs_for_common()

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

				__lowerCAmelCase      :						List[Any]						      =				['pixel_values']
				self.assertListEqual(arg_names[:1]	,		_SCREAMING_SNAKE_CASE			)

		def 							__lowerCamelCase							(				self			):
			__lowerCAmelCase      :						List[str]						      =				self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_model(*_SCREAMING_SNAKE_CASE			)

		def 							__lowerCamelCase							(				self			):
			def check_hidden_states_output(_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE			):
				__lowerCAmelCase      :						Optional[int]						      =				model_class(_SCREAMING_SNAKE_CASE			)
				__lowerCAmelCase      :						Union[str, Any]						      =				model(**self._prepare_for_class(_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE			)			)

				__lowerCAmelCase      :						List[str]						      =				outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

				__lowerCAmelCase      :						List[Any]						      =				self.model_tester.num_stages
				self.assertEqual(len(_SCREAMING_SNAKE_CASE			)	,		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]	,		)

			__lowerCAmelCase      ,       __lowerCAmelCase      :						Any						      =				self.model_tester.prepare_config_and_inputs_for_common()
			__lowerCAmelCase      :						List[Any]						      =				['basic', 'bottleneck']
			for model_class in self.all_model_classes:
				for layer_type in layers_type:
					__lowerCAmelCase      :						Optional[int]						      =				layer_type
					__lowerCAmelCase      :						List[Any]						      =				True
					check_hidden_states_output(_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE			)

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

					check_hidden_states_output(_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE			)

		def 							__lowerCamelCase							(				self			):
			__lowerCAmelCase      :						Optional[Any]						      =				self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_for_image_classification(*_SCREAMING_SNAKE_CASE			)







		@slow
		def 							__lowerCamelCase							(				self			):
			for model_name in TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
				__lowerCAmelCase      :						List[str]						      =				TFResNetModel.from_pretrained(_SCREAMING_SNAKE_CASE			)
				self.assertIsNotNone(_SCREAMING_SNAKE_CASE			)



def    __lowerCAmelCase    ():
	__lowerCAmelCase      :						Optional[Any]						      =				Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'		)
	return image




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

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







		@slow
		def 							__lowerCamelCase							(				self			):
			__lowerCAmelCase      :						Optional[Any]						      =				TFResNetForImageClassification.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]			)

			__lowerCAmelCase      :						Optional[int]						      =				self.default_image_processor
			__lowerCAmelCase      :						Optional[int]						      =				prepare_img()
			__lowerCAmelCase      :						Tuple						      =				image_processor(images=_SCREAMING_SNAKE_CASE	,		return_tensors='tf'			)

			# forward pass
			__lowerCAmelCase      :						List[str]						      =				model(**_SCREAMING_SNAKE_CASE			)

			# verify the logits
			__lowerCAmelCase      :						Optional[int]						      =				tf.TensorShape((1, 10_00)			)
			self.assertEqual(outputs.logits.shape	,		_SCREAMING_SNAKE_CASE			)

			__lowerCAmelCase      :						Optional[Any]						      =				tf.constant([-11.1069, -9.7877, -8.3777]			)

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

"""simple docstring"""







import pytest

import datasets.config
from datasets.utils.info_utils import is_small_dataset
@pytest.mark.parametrize('dataset_size'	,  [None, 400 * 2**20, 600 * 2**20]		)
@pytest.mark.parametrize('input_in_memory_max_size'	,  ['default', 0, 100 * 2**20, 900 * 2**20]		)
def    __lowerCAmelCase    (_UpperCamelCase	,  _UpperCamelCase	,  _UpperCamelCase		):
	if input_in_memory_max_size != "default":
		monkeypatch.setattr(datasets.config	,  'IN_MEMORY_MAX_SIZE'	,  _UpperCamelCase		)
	__lowerCAmelCase      :						Union[str, Any]						      =				datasets.config.IN_MEMORY_MAX_SIZE
	if input_in_memory_max_size == "default":
		assert in_memory_max_size == 0
	else:
		assert in_memory_max_size == input_in_memory_max_size
	if dataset_size and in_memory_max_size:
		__lowerCAmelCase      :						Tuple						      =				dataset_size < in_memory_max_size
	else:
		__lowerCAmelCase      :						str						      =				False
	__lowerCAmelCase      :						Optional[int]						      =				is_small_dataset(_UpperCamelCase		)
	assert result == expected