

import inspect
import unittest

from transformers import RegNetConfig, is_flax_available
from transformers.testing_utils import require_flax, slow
from transformers.utils import cached_property, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor


if is_flax_available():
					import jax
					import jax.numpy as jnp

					from transformers.models.regnet.modeling_flax_regnet import FlaxRegNetForImageClassification, FlaxRegNetModel

if is_vision_available():
					from PIL import Image

					from transformers import AutoImageProcessor







class 			lowercase    (	unittest.TestCase      ):




				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				,       ):
											snake_case_          =   parent
											snake_case_          =   batch_size
											snake_case_          =   image_size
											snake_case_          =   num_channels
											snake_case_          =   embeddings_size
											snake_case_          =   hidden_sizes
											snake_case_          =   depths
											snake_case_          =   is_training
											snake_case_          =   use_labels
											snake_case_          =   hidden_act
											snake_case_          =   num_labels
											snake_case_          =   scope
											snake_case_          =   len(snake_case	)




				def    a							( self	):
											snake_case_          =   floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]	)

											snake_case_          =   self.get_config()

											return config, pixel_values




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




				def    a							( self				,       snake_case				,       snake_case	):
											snake_case_          =   FlaxRegNetModel(config=snake_case	)
											snake_case_          =   model(snake_case	)

											# Output shape (b, c, h, w)
											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				,       snake_case				,       snake_case	):
											snake_case_          =   self.num_labels
											snake_case_          =   FlaxRegNetForImageClassification(config=snake_case	)
											snake_case_          =   model(snake_case	)
											self.parent.assertEqual(result.logits.shape				,       (self.batch_size, self.num_labels)	)




				def    a							( self	):
											snake_case_          =   self.prepare_config_and_inputs()
											snake_case_    ,   snake_case_          =   config_and_inputs
											snake_case_          =   {'pixel_values': pixel_values}
											return config, inputs_dict







@require_flax
class 			lowercase    (	lowercase_     ,  unittest.TestCase      ):
				__SCREAMING_SNAKE_CASE :			str	      =      (FlaxRegNetModel, FlaxRegNetForImageClassification) if is_flax_available() else ()

				__SCREAMING_SNAKE_CASE :			Dict	      =      False
				__SCREAMING_SNAKE_CASE :			int	      =      False
				__SCREAMING_SNAKE_CASE :			Union[str, Any]	      =      False




				def    a							( self	):
											snake_case_          =   FlaxRegNetModelTester(self	)
											snake_case_          =   ConfigTester(self				,       config_class=snake_case				,       has_text_modality=snake_case	)




				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




				def    a							( self	):
											snake_case_          =   self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*snake_case	)




				def    a							( self	):
											snake_case_          =   self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_image_classification(*snake_case	)




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




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




				def    a							( self	):
											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(snake_case	)
																		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]				,       snake_case	)




				def    a							( self	):
											def check_hidden_states_output(snake_case				,       snake_case				,       snake_case	):
																		snake_case_          =   model_class(snake_case	)

																		snake_case_          =   model(**self._prepare_for_class(snake_case				,       snake_case	)	)

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

																		snake_case_          =   self.model_tester.num_stages
																		self.assertEqual(len(snake_case	)				,       expected_num_stages + 1	)

											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(snake_case				,       snake_case				,       snake_case	)

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

																		check_hidden_states_output(snake_case				,       snake_case				,       snake_case	)




				def    a							( self	):
											snake_case_    ,   snake_case_          =   self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
																		with self.subTest(model_class.__name__	):
																									snake_case_          =   self._prepare_for_class(snake_case				,       snake_case	)
																									snake_case_          =   model_class(snake_case	)

																									@jax.jit
																									def model_jitted(snake_case				,       **snake_case	):
																																return model(pixel_values=snake_case				,       **snake_case	)

																									with self.subTest('JIT Enabled'	):
																																snake_case_          =   model_jitted(**snake_case	).to_tuple()

																									with self.subTest('JIT Disabled'	):
																																with jax.disable_jit():
																																							snake_case_          =   model_jitted(**snake_case	).to_tuple()

																									self.assertEqual(len(snake_case	)				,       len(snake_case	)	)
																									for jitted_output, output in zip(snake_case				,       snake_case	):
																																self.assertEqual(jitted_output.shape				,       output.shape	)





def  __lowerCamelCase     (			):







							'''simple docstring'''






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







@require_flax
class 			lowercase    (	unittest.TestCase      ):




				@cached_property
				def    a							( self	):
											return AutoImageProcessor.from_pretrained('facebook/regnet-y-040'	) if is_vision_available() else None




				@slow
				def    a							( self	):
											snake_case_          =   FlaxRegNetForImageClassification.from_pretrained('facebook/regnet-y-040'	)

											snake_case_          =   self.default_image_processor
											snake_case_          =   prepare_img()
											snake_case_          =   image_processor(images=snake_case				,       return_tensors='np'	)

											snake_case_          =   model(**snake_case	)

											# verify the logits
											snake_case_          =   (1, 1000)
											self.assertEqual(outputs.logits.shape				,       snake_case	)

											snake_case_          =   jnp.array([-0.41_80, -1.50_51, -3.48_36]	)

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







from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


_UpperCAmelCase		:       Tuple						    =	{
    """configuration_xlm_roberta_xl""": [
        """XLM_ROBERTA_XL_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """XLMRobertaXLConfig""",
        """XLMRobertaXLOnnxConfig""",
    ],
}

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					_UpperCAmelCase		:       int						    =	[
					    """XLM_ROBERTA_XL_PRETRAINED_MODEL_ARCHIVE_LIST""",
					    """XLMRobertaXLForCausalLM""",
					    """XLMRobertaXLForMaskedLM""",
					    """XLMRobertaXLForMultipleChoice""",
					    """XLMRobertaXLForQuestionAnswering""",
					    """XLMRobertaXLForSequenceClassification""",
					    """XLMRobertaXLForTokenClassification""",
					    """XLMRobertaXLModel""",
					    """XLMRobertaXLPreTrainedModel""",
					]

if TYPE_CHECKING:
					from .configuration_xlm_roberta_xl import (
					    XLM_ROBERTA_XL_PRETRAINED_CONFIG_ARCHIVE_MAP,
					    XLMRobertaXLConfig,
					    XLMRobertaXLOnnxConfig,
					)

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_xlm_roberta_xl import (
										    XLM_ROBERTA_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
										    XLMRobertaXLForCausalLM,
										    XLMRobertaXLForMaskedLM,
										    XLMRobertaXLForMultipleChoice,
										    XLMRobertaXLForQuestionAnswering,
										    XLMRobertaXLForSequenceClassification,
										    XLMRobertaXLForTokenClassification,
										    XLMRobertaXLModel,
										    XLMRobertaXLPreTrainedModel,
										)

else:
					import sys

					_UpperCAmelCase		:       Optional[Any]						    =	_LazyModule(__name__, globals()["""__file__"""], _import_structure)




