





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   UpperCamelCase_       (     unittest.TestCase    ):


							def __init__(							self    :Dict							,				__A    :List[Any]							,				__A    :List[str]=3							,				__A    :Any=32							,				__A    :Dict=3							,				__A    :Optional[int]=10							,				__A    :Dict=[10, 20, 30, 40]							,				__A    :List[str]=[1, 1, 2, 1]							,				__A    :int=True							,				__A    :str=True							,				__A    :List[str]="relu"							,				__A    :Optional[int]=3							,				__A    :List[Any]=None							,				)   ->   Dict:



									"""simple docstring"""



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


							def      _snake_case  (							self    :Optional[int]		)   ->   Dict:



									"""simple docstring"""



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

									SCREAMING_SNAKE_CASE__			=      self.get_config()

									return config, pixel_values


							def      _snake_case  (							self    :Optional[int]		)   ->   Tuple:



									"""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							,				image_size=self.image_size							,				)


							def      _snake_case  (							self    :str							,				__A    :int							,				__A    :str		)   ->   str:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__			=      FlaxRegNetModel(config=__A		)
									SCREAMING_SNAKE_CASE__			=      model(__A		)

									# 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      _snake_case  (							self    :Optional[Any]							,				__A    :Dict							,				__A    :Any		)   ->   Optional[int]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__			=      self.num_labels
									SCREAMING_SNAKE_CASE__			=      FlaxRegNetForImageClassification(config=__A		)
									SCREAMING_SNAKE_CASE__			=      model(__A		)
									self.parent.assertEqual(result.logits.shape							,				(self.batch_size, self.num_labels)		)


							def      _snake_case  (							self    :List[str]		)   ->   Union[str, Any]:



									"""simple docstring"""



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




@require_flax
class   UpperCamelCase_       (     UpperCamelCase__				,  unittest.TestCase    ):
							lowerCamelCase_           =					(FlaxRegNetModel, FlaxRegNetForImageClassification) if is_flax_available() else ()

							lowerCamelCase_           =					False
							lowerCamelCase_           =					False
							lowerCamelCase_           =					False


							def      _snake_case  (							self    :int		)   ->   None:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__			=      FlaxRegNetModelTester(self		)
									SCREAMING_SNAKE_CASE__			=      ConfigTester(self							,				config_class=__A							,				has_text_modality=__A		)


							def      _snake_case  (							self    :List[str]		)   ->   str:



									"""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      _snake_case  (							self    :List[str]		)   ->   List[str]:



									"""simple docstring"""



									return


							def      _snake_case  (							self    :Optional[int]		)   ->   Union[str, Any]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__			=      self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*__A		)


							def      _snake_case  (							self    :Optional[Any]		)   ->   Optional[int]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__			=      self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_image_classification(*__A		)


							@unittest.skip(reason="""RegNet does not use inputs_embeds"""		)
							def      _snake_case  (							self    :int		)   ->   Optional[Any]:



									"""simple docstring"""



									pass


							@unittest.skip(reason="""RegNet does not support input and output embeddings"""		)
							def      _snake_case  (							self    :Tuple		)   ->   List[Any]:



									"""simple docstring"""



									pass


							def      _snake_case  (							self    :Optional[Any]		)   ->   Any:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__	,						SCREAMING_SNAKE_CASE__			=      self.model_tester.prepare_config_and_inputs_for_common()

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

											SCREAMING_SNAKE_CASE__			=      ["""pixel_values"""]
											self.assertListEqual(arg_names[:1]							,				__A		)


							def      _snake_case  (							self    :Union[str, Any]		)   ->   str:



									"""simple docstring"""



									def check_hidden_states_output(__A    :Optional[int]							,				__A    :str							,				__A    :Optional[Any]		):
											SCREAMING_SNAKE_CASE__			=      model_class(__A		)

											SCREAMING_SNAKE_CASE__			=      model(**self._prepare_for_class(__A							,				__A		)		)

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

											SCREAMING_SNAKE_CASE__			=      self.model_tester.num_stages
											self.assertEqual(len(__A		)							,				expected_num_stages + 1		)

									SCREAMING_SNAKE_CASE__	,						SCREAMING_SNAKE_CASE__			=      self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
											SCREAMING_SNAKE_CASE__			=      True
											check_hidden_states_output(__A							,				__A							,				__A		)

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

											check_hidden_states_output(__A							,				__A							,				__A		)


							def      _snake_case  (							self    :Any		)   ->   Optional[int]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__	,						SCREAMING_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__		):
													SCREAMING_SNAKE_CASE__			=      self._prepare_for_class(__A							,				__A		)
													SCREAMING_SNAKE_CASE__			=      model_class(__A		)

													@jax.jit
													def model_jitted(__A    :Dict							,				**__A    :Any		):
															return model(pixel_values=__A							,				**__A		)

													with self.subTest("""JIT Enabled"""		):
															SCREAMING_SNAKE_CASE__			=      model_jitted(**__A		).to_tuple()

													with self.subTest("""JIT Disabled"""		):
															with jax.disable_jit():
																	SCREAMING_SNAKE_CASE__			=      model_jitted(**__A		).to_tuple()

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






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




@require_flax
class   UpperCamelCase_       (     unittest.TestCase    ):


							@cached_property
							def      _snake_case  (							self    :List[Any]		)   ->   Optional[Any]:



									"""simple docstring"""



									return AutoImageProcessor.from_pretrained("""facebook/regnet-y-040"""		) if is_vision_available() else None


							@slow
							def      _snake_case  (							self    :Any		)   ->   Optional[Any]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__			=      FlaxRegNetForImageClassification.from_pretrained("""facebook/regnet-y-040"""		)

									SCREAMING_SNAKE_CASE__			=      self.default_image_processor
									SCREAMING_SNAKE_CASE__			=      prepare_img()
									SCREAMING_SNAKE_CASE__			=      image_processor(images=__A							,				return_tensors="""np"""		)

									SCREAMING_SNAKE_CASE__			=      model(**__A		)

									# verify the logits
									SCREAMING_SNAKE_CASE__			=      (1, 1000)
									self.assertEqual(outputs.logits.shape							,				__A		)

									SCREAMING_SNAKE_CASE__			=      jnp.array([-0.4_1_8_0, -1.5_0_5_1, -3.4_8_3_6]		)

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






import json
import os
import unittest

from transformers import OpenAIGPTTokenizer, OpenAIGPTTokenizerFast
from transformers.models.openai.tokenization_openai import VOCAB_FILES_NAMES
from transformers.testing_utils import require_ftfy, require_spacy, require_tokenizers

from ...test_tokenization_common import TokenizerTesterMixin




@require_tokenizers
class   UpperCamelCase_       (     UpperCamelCase__				,  unittest.TestCase    ):
							lowerCamelCase_           =					OpenAIGPTTokenizer
							lowerCamelCase_           =					OpenAIGPTTokenizerFast
							lowerCamelCase_           =					True
							lowerCamelCase_           =					False


							def      _snake_case  (							self    :Optional[Any]		)   ->   Dict:



									"""simple docstring"""



									super().setUp()

									# Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
									SCREAMING_SNAKE_CASE__			=      [
									    """l""",
									    """o""",
									    """w""",
									    """e""",
									    """r""",
									    """s""",
									    """t""",
									    """i""",
									    """d""",
									    """n""",
									    """w</w>""",
									    """r</w>""",
									    """t</w>""",
									    """lo""",
									    """low""",
									    """er</w>""",
									    """low</w>""",
									    """lowest</w>""",
									    """newer</w>""",
									    """wider</w>""",
									    """<unk>""",
									]
									SCREAMING_SNAKE_CASE__			=      dict(zip(__A							,				range(len(__A		)		)		)		)
									SCREAMING_SNAKE_CASE__			=      ["""#version: 0.2""", """l o""", """lo w""", """e r</w>""", """"""]

									SCREAMING_SNAKE_CASE__			=      os.path.join(self.tmpdirname							,				VOCAB_FILES_NAMES["""vocab_file"""]		)
									SCREAMING_SNAKE_CASE__			=      os.path.join(self.tmpdirname							,				VOCAB_FILES_NAMES["""merges_file"""]		)
									with open(self.vocab_file							,				"""w"""		) as fp:
											fp.write(json.dumps(__A		)		)
									with open(self.merges_file							,				"""w"""		) as fp:
											fp.write("""\n""".join(__A		)		)


							def      _snake_case  (							self    :Union[str, Any]							,				__A    :str		)   ->   List[Any]:



									"""simple docstring"""



									return "lower newer", "lower newer"


							def      _snake_case  (							self    :Optional[Any]		)   ->   Tuple:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__			=      OpenAIGPTTokenizer(self.vocab_file							,				self.merges_file		)

									SCREAMING_SNAKE_CASE__			=      """lower"""
									SCREAMING_SNAKE_CASE__			=      ["""low""", """er</w>"""]
									SCREAMING_SNAKE_CASE__			=      tokenizer.tokenize(__A		)
									self.assertListEqual(__A							,				__A		)

									SCREAMING_SNAKE_CASE__			=      tokens + ["""<unk>"""]
									SCREAMING_SNAKE_CASE__			=      [14, 15, 20]
									self.assertListEqual(tokenizer.convert_tokens_to_ids(__A		)							,				__A		)


							def      _snake_case  (							self    :Optional[Any]							,				__A    :Optional[Any]=15		)   ->   Any:



									"""simple docstring"""



									for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
											with self.subTest(f'''{tokenizer.__class__.__name__} ({pretrained_name})'''		):
													SCREAMING_SNAKE_CASE__			=      self.rust_tokenizer_class.from_pretrained(__A							,				**__A		)

													# Simple input
													SCREAMING_SNAKE_CASE__			=      """This is a simple input"""
													SCREAMING_SNAKE_CASE__			=      ["""This is a simple input 1""", """This is a simple input 2"""]
													SCREAMING_SNAKE_CASE__			=      ("""This is a simple input""", """This is a pair""")
													SCREAMING_SNAKE_CASE__			=      [
													    ("""This is a simple input 1""", """This is a simple input 2"""),
													    ("""This is a simple pair 1""", """This is a simple pair 2"""),
													]

													# Simple input tests
													self.assertRaises(__A							,				tokenizer_r.encode							,				__A							,				max_length=__A							,				padding="""max_length"""		)

													# Simple input
													self.assertRaises(__A							,				tokenizer_r.encode_plus							,				__A							,				max_length=__A							,				padding="""max_length"""		)

													# Simple input
													self.assertRaises(
													    __A							,				tokenizer_r.batch_encode_plus							,				__A							,				max_length=__A							,				padding="""max_length"""							,				)

													# Pair input
													self.assertRaises(__A							,				tokenizer_r.encode							,				__A							,				max_length=__A							,				padding="""max_length"""		)

													# Pair input
													self.assertRaises(__A							,				tokenizer_r.encode_plus							,				__A							,				max_length=__A							,				padding="""max_length"""		)

													# Pair input
													self.assertRaises(
													    __A							,				tokenizer_r.batch_encode_plus							,				__A							,				max_length=__A							,				padding="""max_length"""							,				)


							def      _snake_case  (							self    :Dict		)   ->   List[Any]:



									"""simple docstring"""



									pass




@require_ftfy
@require_spacy
@require_tokenizers
class   UpperCamelCase_       (     UpperCamelCase__    ):
							pass