



from __future__ import annotations

import inspect
import unittest
from typing import List, Tuple

from transformers import RegNetConfig
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 TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST, TFRegNetForImageClassification, TFRegNetModel


if is_vision_available():
	from PIL import Image

	from transformers import AutoImageProcessor





class 					__lowerCAmelCase :




				def __init__(							self						,				_snake_case						,				_snake_case=3						,				_snake_case=32						,				_snake_case=3						,				_snake_case=10						,				_snake_case=[10, 20, 30, 40]						,				_snake_case=[1, 1, 2, 1]						,				_snake_case=True						,				_snake_case=True						,				_snake_case="relu"						,				_snake_case=3						,				_snake_case=None						,				):



									"""simple docstring"""





									_lowerCAmelCase						=    parent
									_lowerCAmelCase						=    batch_size
									_lowerCAmelCase						=    image_size
									_lowerCAmelCase						=    num_channels
									_lowerCAmelCase						=    embeddings_size
									_lowerCAmelCase						=    hidden_sizes
									_lowerCAmelCase						=    depths
									_lowerCAmelCase						=    is_training
									_lowerCAmelCase						=    use_labels
									_lowerCAmelCase						=    hidden_act
									_lowerCAmelCase						=    num_labels
									_lowerCAmelCase						=    scope
									_lowerCAmelCase						=    len(SCREAMING_SNAKE_CASE_		)




				def 							snake_case   (							self		):



									"""simple docstring"""





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

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

									_lowerCAmelCase						=    self.get_config()
									return config, pixel_values, labels




				def 							snake_case   (							self		):



									"""simple docstring"""





									return RegNetConfig(
									    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						,				)




				def 							snake_case   (							self						,				_snake_case						,				_snake_case						,				_snake_case		):



									"""simple docstring"""





									_lowerCAmelCase						=    TFRegNetModel(config=SCREAMING_SNAKE_CASE_		)
									_lowerCAmelCase						=    model(SCREAMING_SNAKE_CASE_						,				training=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 							snake_case   (							self						,				_snake_case						,				_snake_case						,				_snake_case		):



									"""simple docstring"""





									_lowerCAmelCase						=    self.num_labels
									_lowerCAmelCase						=    TFRegNetForImageClassification(SCREAMING_SNAKE_CASE_		)
									_lowerCAmelCase						=    model(SCREAMING_SNAKE_CASE_						,				labels=SCREAMING_SNAKE_CASE_						,				training=SCREAMING_SNAKE_CASE_		)
									self.parent.assertEqual(result.logits.shape						,				(self.batch_size, self.num_labels)		)




				def 							snake_case   (							self		):



									"""simple docstring"""





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





@require_tf
class 					__lowerCAmelCase (     lowerCamelCase__       ,						lowerCamelCase__       ,						unittest.TestCase       ):
				__lowerCamelCase =				(TFRegNetModel, TFRegNetForImageClassification) if is_tf_available() else ()
				__lowerCamelCase =				(
				    {'feature-extraction': TFRegNetModel, 'image-classification': TFRegNetForImageClassification}
				    if is_tf_available()
				    else {}
				)

				__lowerCamelCase =				False
				__lowerCamelCase =				False
				__lowerCamelCase =				False
				__lowerCamelCase =				False
				__lowerCamelCase =				False




				def 							snake_case   (							self		):



									"""simple docstring"""





									_lowerCAmelCase						=    TFRegNetModelTester(self		)
									_lowerCAmelCase						=    ConfigTester(self						,				config_class=SCREAMING_SNAKE_CASE_						,				has_text_modality=SCREAMING_SNAKE_CASE_		)




				def 							snake_case   (							self		):



									"""simple docstring"""





									return




				@unittest.skip(reason="""RegNet does not use inputs_embeds"""		)
				def 							snake_case   (							self		):



									"""simple docstring"""





									pass




				@unittest.skipIf(
				    not is_tf_available() or len(tf.config.list_physical_devices("""GPU"""		)		) == 0						,				reason="""TF does not support backprop for grouped convolutions on CPU."""						,				)
				@slow
				def 							snake_case   (							self		):



									"""simple docstring"""





									super().test_keras_fit()




				@unittest.skip(reason="""RegNet does not support input and output embeddings"""		)
				def 							snake_case   (							self		):



									"""simple docstring"""





									pass




				def 							snake_case   (							self		):



									"""simple docstring"""





									_lowerCAmelCase	,	_lowerCAmelCase						=    self.model_tester.prepare_config_and_inputs_for_common()

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

														_lowerCAmelCase						=    ["""pixel_values"""]
														self.assertListEqual(arg_names[:1]						,				SCREAMING_SNAKE_CASE_		)




				def 							snake_case   (							self		):



									"""simple docstring"""





									_lowerCAmelCase						=    self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE_		)




				def 							snake_case   (							self		):



									"""simple docstring"""





									def check_hidden_states_output(_snake_case						,				_snake_case						,				_snake_case		):
														_lowerCAmelCase						=    model_class(SCREAMING_SNAKE_CASE_		)
														_lowerCAmelCase						=    model(**self._prepare_for_class(SCREAMING_SNAKE_CASE_						,				SCREAMING_SNAKE_CASE_		)						,				training=SCREAMING_SNAKE_CASE_		)

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

														_lowerCAmelCase						=    self.model_tester.num_stages
														self.assertEqual(len(SCREAMING_SNAKE_CASE_		)						,				expected_num_stages + 1		)

														# RegNet'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 // 2, self.model_tester.image_size // 2]						,				)

									_lowerCAmelCase	,	_lowerCAmelCase						=    self.model_tester.prepare_config_and_inputs_for_common()
									_lowerCAmelCase						=    ["""basic""", """bottleneck"""]
									for model_class in self.all_model_classes:
														for layer_type in layers_type:
																			_lowerCAmelCase						=    layer_type
																			_lowerCAmelCase						=    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						=    True

																			check_hidden_states_output(SCREAMING_SNAKE_CASE_						,				SCREAMING_SNAKE_CASE_						,				SCREAMING_SNAKE_CASE_		)




				def 							snake_case   (							self		):



									"""simple docstring"""





									_lowerCAmelCase	,	_lowerCAmelCase						=    self.model_tester.prepare_config_and_inputs_for_common()

									def check_equivalence(_snake_case						,				_snake_case						,				_snake_case						,				_snake_case={}		):
														_lowerCAmelCase						=    model(SCREAMING_SNAKE_CASE_						,				return_dict=SCREAMING_SNAKE_CASE_						,				**SCREAMING_SNAKE_CASE_		)
														_lowerCAmelCase						=    model(SCREAMING_SNAKE_CASE_						,				return_dict=SCREAMING_SNAKE_CASE_						,				**SCREAMING_SNAKE_CASE_		).to_tuple()

														def recursive_check(_snake_case						,				_snake_case		):
																			if isinstance(SCREAMING_SNAKE_CASE_						,				(List, Tuple)		):
																								for tuple_iterable_value, dict_iterable_value in zip(SCREAMING_SNAKE_CASE_						,				SCREAMING_SNAKE_CASE_		):
																													recursive_check(SCREAMING_SNAKE_CASE_						,				SCREAMING_SNAKE_CASE_		)
																			elif tuple_object is None:
																								return
																			else:
																								self.assertTrue(
																								    all(tf.equal(SCREAMING_SNAKE_CASE_						,				SCREAMING_SNAKE_CASE_		)		)						,				msg=(
																								        """Tuple and dict output are not equal. Difference:"""
																								        F' {tf.math.reduce_max(tf.abs(tuple_object - dict_object		)		)}'
																								    )						,				)

																			recursive_check(SCREAMING_SNAKE_CASE_						,				SCREAMING_SNAKE_CASE_		)

									for model_class in self.all_model_classes:
														_lowerCAmelCase						=    model_class(SCREAMING_SNAKE_CASE_		)

														_lowerCAmelCase						=    self._prepare_for_class(SCREAMING_SNAKE_CASE_						,				SCREAMING_SNAKE_CASE_		)
														_lowerCAmelCase						=    self._prepare_for_class(SCREAMING_SNAKE_CASE_						,				SCREAMING_SNAKE_CASE_		)
														check_equivalence(SCREAMING_SNAKE_CASE_						,				SCREAMING_SNAKE_CASE_						,				SCREAMING_SNAKE_CASE_		)

														_lowerCAmelCase						=    self._prepare_for_class(SCREAMING_SNAKE_CASE_						,				SCREAMING_SNAKE_CASE_						,				return_labels=SCREAMING_SNAKE_CASE_		)
														_lowerCAmelCase						=    self._prepare_for_class(SCREAMING_SNAKE_CASE_						,				SCREAMING_SNAKE_CASE_						,				return_labels=SCREAMING_SNAKE_CASE_		)
														check_equivalence(SCREAMING_SNAKE_CASE_						,				SCREAMING_SNAKE_CASE_						,				SCREAMING_SNAKE_CASE_		)

														_lowerCAmelCase						=    self._prepare_for_class(SCREAMING_SNAKE_CASE_						,				SCREAMING_SNAKE_CASE_		)
														_lowerCAmelCase						=    self._prepare_for_class(SCREAMING_SNAKE_CASE_						,				SCREAMING_SNAKE_CASE_		)
														check_equivalence(SCREAMING_SNAKE_CASE_						,				SCREAMING_SNAKE_CASE_						,				SCREAMING_SNAKE_CASE_						,				{"""output_hidden_states""": True}		)

														_lowerCAmelCase						=    self._prepare_for_class(SCREAMING_SNAKE_CASE_						,				SCREAMING_SNAKE_CASE_						,				return_labels=SCREAMING_SNAKE_CASE_		)
														_lowerCAmelCase						=    self._prepare_for_class(SCREAMING_SNAKE_CASE_						,				SCREAMING_SNAKE_CASE_						,				return_labels=SCREAMING_SNAKE_CASE_		)
														check_equivalence(SCREAMING_SNAKE_CASE_						,				SCREAMING_SNAKE_CASE_						,				SCREAMING_SNAKE_CASE_						,				{"""output_hidden_states""": True}		)




				def 							snake_case   (							self		):



									"""simple docstring"""





									_lowerCAmelCase						=    self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_image_classification(*SCREAMING_SNAKE_CASE_		)




				@slow
				def 							snake_case   (							self		):



									"""simple docstring"""





									for model_name in TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
														_lowerCAmelCase						=    TFRegNetModel.from_pretrained(SCREAMING_SNAKE_CASE_		)
														self.assertIsNotNone(SCREAMING_SNAKE_CASE_		)


def 		_UpperCAmelCase				(      ):





					"""simple docstring"""

					_lowerCAmelCase						=    Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""			)
					return image





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




				@cached_property
				def 							snake_case   (							self		):



									"""simple docstring"""





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




				@slow
				def 							snake_case   (							self		):



									"""simple docstring"""





									_lowerCAmelCase						=    TFRegNetForImageClassification.from_pretrained(TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]		)

									_lowerCAmelCase						=    self.default_image_processor
									_lowerCAmelCase						=    prepare_img()
									_lowerCAmelCase						=    image_processor(images=SCREAMING_SNAKE_CASE_						,				return_tensors="""tf"""		)

									# forward pass
									_lowerCAmelCase						=    model(**SCREAMING_SNAKE_CASE_						,				training=SCREAMING_SNAKE_CASE_		)

									# verify the logits
									_lowerCAmelCase						=    tf.TensorShape((1, 1000)		)
									self.assertEqual(outputs.logits.shape						,				SCREAMING_SNAKE_CASE_		)

									_lowerCAmelCase						=    tf.constant([-0.4180, -1.5051, -3.4836]		)

									tf.debugging.assert_near(outputs.logits[0, :3]						,				SCREAMING_SNAKE_CASE_						,				atol=1e-4		)





from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_sentencepiece_available,
    is_speech_available,
    is_torch_available,
)


__a  			=					{
    'configuration_trocr': ['TROCR_PRETRAINED_CONFIG_ARCHIVE_MAP', 'TrOCRConfig'],
    'processing_trocr': ['TrOCRProcessor'],
}


try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__a  			=					[
						    'TROCR_PRETRAINED_MODEL_ARCHIVE_LIST',
						    'TrOCRForCausalLM',
						    'TrOCRPreTrainedModel',
						]


if TYPE_CHECKING:
						from .configuration_trocr import TROCR_PRETRAINED_CONFIG_ARCHIVE_MAP, TrOCRConfig
						from .processing_trocr import TrOCRProcessor

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_trocr import TROCR_PRETRAINED_MODEL_ARCHIVE_LIST, TrOCRForCausalLM, TrOCRPreTrainedModel

else:
						import sys

						__a  			=					_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)




