

'''simple docstring'''
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 					_snake_case		(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			,):
				UpperCAmelCase_     :      Union[str, Any]						=  parent
				UpperCAmelCase_     :      List[str]						=  batch_size
				UpperCAmelCase_     :      Union[str, Any]						=  image_size
				UpperCAmelCase_     :      Any						=  num_channels
				UpperCAmelCase_     :      Optional[Any]						=  embeddings_size
				UpperCAmelCase_     :      int						=  hidden_sizes
				UpperCAmelCase_     :      Tuple						=  depths
				UpperCAmelCase_     :      Optional[int]						=  is_training
				UpperCAmelCase_     :      Tuple						=  use_labels
				UpperCAmelCase_     :      str						=  hidden_act
				UpperCAmelCase_     :      List[Any]						=  num_labels
				UpperCAmelCase_     :      Any						=  scope
				UpperCAmelCase_     :      str						=  len(_snake_case     )






			def 		UpperCamelCase__							(  self     ):
				UpperCAmelCase_     :      str						=  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]     )

				UpperCAmelCase_     :      List[str]						=  self.get_config()

				return config, pixel_values






			def 		UpperCamelCase__							(  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 		UpperCamelCase__							(  self			,_snake_case			,_snake_case     ):
				UpperCAmelCase_     :      int						=  FlaxRegNetModel(config=_snake_case     )
				UpperCAmelCase_     :      int						=  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 		UpperCamelCase__							(  self			,_snake_case			,_snake_case     ):
				UpperCAmelCase_     :      str						=  self.num_labels
				UpperCAmelCase_     :      int						=  FlaxRegNetForImageClassification(config=_snake_case     )
				UpperCAmelCase_     :      Optional[Any]						=  model(_snake_case     )
				self.parent.assertEqual(result.logits.shape			,(self.batch_size, self.num_labels)     )






			def 		UpperCamelCase__							(  self     ):
				UpperCAmelCase_     :      str						=  self.prepare_config_and_inputs()
				UpperCAmelCase_					,					UpperCAmelCase_     :      Union[str, Any]						=  config_and_inputs
				UpperCAmelCase_     :      Union[str, Any]						=  {"pixel_values": pixel_values}
				return config, inputs_dict




@require_flax
class 					_snake_case		(__SCREAMING_SNAKE_CASE			,			unittest.TestCase):
			__A  :	Union[str, Any]        =(FlaxRegNetModel, FlaxRegNetForImageClassification) if is_flax_available() else ()

			__A  :	Any        =False
			__A  :	List[str]        =False
			__A  :	Union[str, Any]        =False






			def 		UpperCamelCase__							(  self     ):
				UpperCAmelCase_     :      Union[str, Any]						=  FlaxRegNetModelTester(self     )
				UpperCAmelCase_     :      Tuple						=  ConfigTester(self			,config_class=_snake_case			,has_text_modality=_snake_case     )






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






			def 		UpperCamelCase__							(  self     ):
				UpperCAmelCase_     :      Tuple						=  self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_model(*_snake_case     )






			def 		UpperCamelCase__							(  self     ):
				UpperCAmelCase_     :      Tuple						=  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 		UpperCamelCase__							(  self     ):
				pass






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






			def 		UpperCamelCase__							(  self     ):
				UpperCAmelCase_					,					UpperCAmelCase_     :      Optional[int]						=  self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes:
					UpperCAmelCase_     :      Tuple						=  model_class(_snake_case     )
					UpperCAmelCase_     :      Tuple						=  inspect.signature(model.__call__     )
					# signature.parameters is an OrderedDict => so arg_names order is deterministic
					UpperCAmelCase_     :      Union[str, Any]						=  [*signature.parameters.keys()]

					UpperCAmelCase_     :      Union[str, Any]						=  ["pixel_values"]
					self.assertListEqual(arg_names[:1]			,_snake_case     )






			def 		UpperCamelCase__							(  self     ):
				def check_hidden_states_output(_snake_case			,_snake_case			,_snake_case     ):
					UpperCAmelCase_     :      str						=  model_class(_snake_case     )

					UpperCAmelCase_     :      Any						=  model(**self._prepare_for_class(_snake_case			,_snake_case     )     )

					UpperCAmelCase_     :      Dict						=  outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

					UpperCAmelCase_     :      Tuple						=  self.model_tester.num_stages
					self.assertEqual(len(_snake_case     )			,expected_num_stages + 1     )

				UpperCAmelCase_					,					UpperCAmelCase_     :      int						=  self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes:
					UpperCAmelCase_     :      Tuple						=  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"]
					UpperCAmelCase_     :      List[str]						=  True

					check_hidden_states_output(_snake_case			,_snake_case			,_snake_case     )






			def 		UpperCamelCase__							(  self     ):
				UpperCAmelCase_					,					UpperCAmelCase_     :      Union[str, Any]						=  self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes:
					with self.subTest(model_class.__name__     ):
						UpperCAmelCase_     :      Optional[Any]						=  self._prepare_for_class(_snake_case			,_snake_case     )
						UpperCAmelCase_     :      Union[str, Any]						=  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"     ):
							UpperCAmelCase_     :      Tuple						=  model_jitted(**_snake_case     ).to_tuple()

						with self.subTest("JIT Disabled"     ):
							with jax.disable_jit():
								UpperCAmelCase_     :      Optional[int]						=  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  a__       (    )     ->					str:


	"""simple docstring"""





	UpperCAmelCase_     :      List[Any]						=  Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"				)
	return image





@require_flax
class 					_snake_case		(unittest.TestCase):






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






			@slow
			def 		UpperCamelCase__							(  self     ):
				UpperCAmelCase_     :      Union[str, Any]						=  FlaxRegNetForImageClassification.from_pretrained("facebook/regnet-y-040"     )

				UpperCAmelCase_     :      Dict						=  self.default_image_processor
				UpperCAmelCase_     :      List[Any]						=  prepare_img()
				UpperCAmelCase_     :      Tuple						=  image_processor(images=_snake_case			,return_tensors="np"     )

				UpperCAmelCase_     :      int						=  model(**_snake_case     )

				# verify the logits
				UpperCAmelCase_     :      Tuple						=  (1, 10_00)
				self.assertEqual(outputs.logits.shape			,_snake_case     )

				UpperCAmelCase_     :      Any						=  jnp.array([-0.4180, -1.5051, -3.4836]     )

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








import os
import unicodedata
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple

import sentencepiece as spm

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import SPIECE_UNDERLINE, logging


A				:       List[str]      =  logging.get_logger(__name__)

A				:       List[Any]      =  {'vocab_file': 'spiece.model'}

A				:       Tuple      =  {
    'vocab_file': {
        'xlnet-base-cased': 'https://huggingface.co/xlnet-base-cased/resolve/main/spiece.model',
        'xlnet-large-cased': 'https://huggingface.co/xlnet-large-cased/resolve/main/spiece.model',
    }
}

A				:       Any      =  {
    'xlnet-base-cased': None,
    'xlnet-large-cased': None,
}

# Segments (not really needed)
A				:       Tuple      =  0
A				:       str      =  1
A				:       str      =  2
A				:       Union[str, Any]      =  3
A				:       Optional[Any]      =  4






class      UpperCamelCase(	_a ):
					snake_case_		:					Union[str, Any]    					=						VOCAB_FILES_NAMES
					snake_case_		:					List[Any]    					=						PRETRAINED_VOCAB_FILES_MAP
					snake_case_		:					str    					=						PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
					snake_case_		:					Tuple    					=						"""left"""


					def __init__(    self						:		Optional[Any]  ,     SCREAMING_SNAKE_CASE						:		Optional[int]  ,     SCREAMING_SNAKE_CASE						:		Any=False  ,     SCREAMING_SNAKE_CASE						:		List[Any]=True  ,     SCREAMING_SNAKE_CASE						:		Dict=False  ,     SCREAMING_SNAKE_CASE						:		Tuple="<s>"  ,     SCREAMING_SNAKE_CASE						:		Optional[int]="</s>"  ,     SCREAMING_SNAKE_CASE						:		List[str]="<unk>"  ,     SCREAMING_SNAKE_CASE						:		List[str]="<sep>"  ,     SCREAMING_SNAKE_CASE						:		Optional[int]="<pad>"  ,     SCREAMING_SNAKE_CASE						:		Union[str, Any]="<cls>"  ,     SCREAMING_SNAKE_CASE						:		str="<mask>"  ,     SCREAMING_SNAKE_CASE						:		int=["<eop>", "<eod>"]  ,     SCREAMING_SNAKE_CASE						:		Optional[Dict[str, Any]] = None  ,     **SCREAMING_SNAKE_CASE						:		Dict  ,     )      ->						None:




											'''simple docstring'''

											__snake_case				=		AddedToken(SCREAMING_SNAKE_CASE  ,     lstrip=SCREAMING_SNAKE_CASE  ,     rstrip=SCREAMING_SNAKE_CASE    ) if isinstance(SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE    ) else mask_token

											__snake_case				=		{} if sp_model_kwargs is None else sp_model_kwargs

											super().__init__(
											    do_lower_case=SCREAMING_SNAKE_CASE  ,     remove_space=SCREAMING_SNAKE_CASE  ,     keep_accents=SCREAMING_SNAKE_CASE  ,     bos_token=SCREAMING_SNAKE_CASE  ,     eos_token=SCREAMING_SNAKE_CASE  ,     unk_token=SCREAMING_SNAKE_CASE  ,     sep_token=SCREAMING_SNAKE_CASE  ,     pad_token=SCREAMING_SNAKE_CASE  ,     cls_token=SCREAMING_SNAKE_CASE  ,     mask_token=SCREAMING_SNAKE_CASE  ,     additional_special_tokens=SCREAMING_SNAKE_CASE  ,     sp_model_kwargs=self.sp_model_kwargs  ,     **SCREAMING_SNAKE_CASE  ,     )

											__snake_case				=		3

											__snake_case				=		do_lower_case
											__snake_case				=		remove_space
											__snake_case				=		keep_accents
											__snake_case				=		vocab_file

											__snake_case				=		spm.SentencePieceProcessor(**self.sp_model_kwargs    )
											self.sp_model.Load(SCREAMING_SNAKE_CASE    )


					@property
					def 				SCREAMING_SNAKE_CASE_	(    self						:		Optional[int]    )      ->						Union[str, Any]:




											'''simple docstring'''

											return len(self.sp_model    )


					def 				SCREAMING_SNAKE_CASE_	(    self						:		str    )      ->						Tuple:




											'''simple docstring'''

											__snake_case				=		{self.convert_ids_to_tokens(SCREAMING_SNAKE_CASE    ): i for i in range(self.vocab_size    )}
											vocab.update(self.added_tokens_encoder    )
											return vocab


					def __getstate__(    self						:		Any    )      ->						str:




											'''simple docstring'''

											__snake_case				=		self.__dict__.copy()
											__snake_case				=		None
											return state


					def __setstate__(    self						:		List[Any]  ,     SCREAMING_SNAKE_CASE						:		Optional[int]    )      ->						int:




											'''simple docstring'''

											__snake_case				=		d

											# for backward compatibility
											if not hasattr(self  ,     "sp_model_kwargs"    ):
																	__snake_case				=		{}

											__snake_case				=		spm.SentencePieceProcessor(**self.sp_model_kwargs    )
											self.sp_model.Load(self.vocab_file    )


					def 				SCREAMING_SNAKE_CASE_	(    self						:		Optional[int]  ,     SCREAMING_SNAKE_CASE						:		List[Any]    )      ->						int:




											'''simple docstring'''

											if self.remove_space:
																	__snake_case				=		" ".join(inputs.strip().split()    )
											else:
																	__snake_case				=		inputs
											__snake_case				=		outputs.replace("``"  ,     "\""    ).replace("''"  ,     "\""    )

											if not self.keep_accents:
																	__snake_case				=		unicodedata.normalize("NFKD"  ,     SCREAMING_SNAKE_CASE    )
																	__snake_case				=		"".join([c for c in outputs if not unicodedata.combining(SCREAMING_SNAKE_CASE    )]    )
											if self.do_lower_case:
																	__snake_case				=		outputs.lower()

											return outputs


					def 				SCREAMING_SNAKE_CASE_	(    self						:		int  ,     SCREAMING_SNAKE_CASE						:		str    )      ->						List[str]:




											'''simple docstring'''

											__snake_case				=		self.preprocess_text(SCREAMING_SNAKE_CASE    )
											__snake_case				=		self.sp_model.encode(SCREAMING_SNAKE_CASE  ,     out_type=SCREAMING_SNAKE_CASE    )
											__snake_case				=		[]
											for piece in pieces:
																	if len(SCREAMING_SNAKE_CASE    ) > 1 and piece[-1] == str(","    ) and piece[-2].isdigit():
																							__snake_case				=		self.sp_model.EncodeAsPieces(piece[:-1].replace(SCREAMING_SNAKE_CASE  ,     ""    )    )
																							if piece[0] != SPIECE_UNDERLINE and cur_pieces[0][0] == SPIECE_UNDERLINE:
																													if len(cur_pieces[0]    ) == 1:
																																			__snake_case				=		cur_pieces[1:]
																													else:
																																			__snake_case				=		cur_pieces[0][1:]
																							cur_pieces.append(piece[-1]    )
																							new_pieces.extend(SCREAMING_SNAKE_CASE    )
																	else:
																							new_pieces.append(SCREAMING_SNAKE_CASE    )

											return new_pieces


					def 				SCREAMING_SNAKE_CASE_	(    self						:		List[str]  ,     SCREAMING_SNAKE_CASE						:		Optional[int]    )      ->						Optional[Any]:




											'''simple docstring'''

											return self.sp_model.PieceToId(SCREAMING_SNAKE_CASE    )


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




											'''simple docstring'''

											return self.sp_model.IdToPiece(SCREAMING_SNAKE_CASE    )


					def 				SCREAMING_SNAKE_CASE_	(    self						:		List[str]  ,     SCREAMING_SNAKE_CASE						:		int    )      ->						List[Any]:




											'''simple docstring'''

											__snake_case				=		"".join(SCREAMING_SNAKE_CASE    ).replace(SCREAMING_SNAKE_CASE  ,     " "    ).strip()
											return out_string


					def 				SCREAMING_SNAKE_CASE_	(    self						:		Tuple  ,     SCREAMING_SNAKE_CASE						:		List[int]  ,     SCREAMING_SNAKE_CASE						:		bool = False  ,     SCREAMING_SNAKE_CASE						:		bool = None  ,     SCREAMING_SNAKE_CASE						:		bool = True  ,     **SCREAMING_SNAKE_CASE						:		Optional[int]  ,     )      ->						str:




											'''simple docstring'''

											__snake_case				=		kwargs.pop("use_source_tokenizer"  ,     SCREAMING_SNAKE_CASE    )

											__snake_case				=		self.convert_ids_to_tokens(SCREAMING_SNAKE_CASE  ,     skip_special_tokens=SCREAMING_SNAKE_CASE    )

											# To avoid mixing byte-level and unicode for byte-level BPT
											# we need to build string separately for added tokens and byte-level tokens
											# cf. https://github.com/huggingface/transformers/issues/1133
											__snake_case				=		[]
											__snake_case				=		[]
											for token in filtered_tokens:
																	if skip_special_tokens and token in self.all_special_ids:
																							continue
																	if token in self.added_tokens_encoder:
																							if current_sub_text:
																													sub_texts.append(self.convert_tokens_to_string(SCREAMING_SNAKE_CASE    )    )
																													__snake_case				=		[]
																							sub_texts.append(SCREAMING_SNAKE_CASE    )
																	else:
																							current_sub_text.append(SCREAMING_SNAKE_CASE    )
											if current_sub_text:
																	sub_texts.append(self.convert_tokens_to_string(SCREAMING_SNAKE_CASE    )    )

											# Mimic the behavior of the Rust tokenizer:
											# By default, there are no spaces between special tokens
											__snake_case				=		"".join(SCREAMING_SNAKE_CASE    )

											__snake_case				=		(
											    clean_up_tokenization_spaces
											    if clean_up_tokenization_spaces is not None
											    else self.clean_up_tokenization_spaces
											)
											if clean_up_tokenization_spaces:
																	__snake_case				=		self.clean_up_tokenization(SCREAMING_SNAKE_CASE    )
																	return clean_text
											else:
																	return text


					def 				SCREAMING_SNAKE_CASE_	(    self						:		Tuple  ,     SCREAMING_SNAKE_CASE						:		List[int]  ,     SCREAMING_SNAKE_CASE						:		Optional[List[int]] = None    )      ->						List[int]:




											'''simple docstring'''

											__snake_case				=		[self.sep_token_id]
											__snake_case				=		[self.cls_token_id]
											if token_ids_a is None:
																	return token_ids_a + sep + cls
											return token_ids_a + sep + token_ids_a + sep + cls


					def 				SCREAMING_SNAKE_CASE_	(    self						:		int  ,     SCREAMING_SNAKE_CASE						:		List[int]  ,     SCREAMING_SNAKE_CASE						:		Optional[List[int]] = None  ,     SCREAMING_SNAKE_CASE						:		bool = False    )      ->						List[int]:




											'''simple docstring'''

											if already_has_special_tokens:
																	return super().get_special_tokens_mask(
																	    token_ids_a=SCREAMING_SNAKE_CASE  ,     token_ids_a=SCREAMING_SNAKE_CASE  ,     already_has_special_tokens=SCREAMING_SNAKE_CASE    )

											if token_ids_a is not None:
																	return ([0] * len(SCREAMING_SNAKE_CASE    )) + [1] + ([0] * len(SCREAMING_SNAKE_CASE    )) + [1, 1]
											return ([0] * len(SCREAMING_SNAKE_CASE    )) + [1, 1]


					def 				SCREAMING_SNAKE_CASE_	(    self						:		Optional[int]  ,     SCREAMING_SNAKE_CASE						:		List[int]  ,     SCREAMING_SNAKE_CASE						:		Optional[List[int]] = None    )      ->						List[int]:




											'''simple docstring'''

											__snake_case				=		[self.sep_token_id]
											__snake_case				=		[2]

											if token_ids_a is None:
																	return len(token_ids_a + sep    ) * [0] + cls_segment_id
											return len(token_ids_a + sep    ) * [0] + len(token_ids_a + sep    ) * [1] + cls_segment_id






					def 				SCREAMING_SNAKE_CASE_	(    self						:		Tuple  ,     SCREAMING_SNAKE_CASE						:		str  ,     SCREAMING_SNAKE_CASE						:		Optional[str] = None    )      ->						Tuple[str]:




											'''simple docstring'''

											if not os.path.isdir(SCREAMING_SNAKE_CASE    ):
																	logger.error(f'''Vocabulary path ({save_directory}) should be a directory'''    )
																	return
											__snake_case				=		os.path.join(
											    SCREAMING_SNAKE_CASE  ,     (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"]    )

											if os.path.abspath(self.vocab_file    ) != os.path.abspath(SCREAMING_SNAKE_CASE    ) and os.path.isfile(self.vocab_file    ):
																	copyfile(self.vocab_file  ,     SCREAMING_SNAKE_CASE    )
											elif not os.path.isfile(self.vocab_file    ):
																	with open(SCREAMING_SNAKE_CASE  ,     "wb"    ) as fi:
																							__snake_case				=		self.sp_model.serialized_model_proto()
																							fi.write(SCREAMING_SNAKE_CASE    )

											return (out_vocab_file,)





