



import json
import os
from functools import lru_cache
from typing import TYPE_CHECKING, List, Optional, Tuple

import regex as re

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


if TYPE_CHECKING:
		from transformers.pipelines.conversational import Conversation

__lowerCamelCase     :							str  							=				logging.get_logger(__name__)


__lowerCamelCase     :							Dict  							=				{
    "vocab_file": "vocab.json",
    "merges_file": "merges.txt",
    "tokenizer_config_file": "tokenizer_config.json",
}

__lowerCamelCase     :							Optional[Any]  							=				{
    "vocab_file": {"facebook/blenderbot-3B": "https://huggingface.co/facebook/blenderbot-3B/resolve/main/vocab.json"},
    "merges_file": {"facebook/blenderbot-3B": "https://huggingface.co/facebook/blenderbot-3B/resolve/main/merges.txt"},
    "tokenizer_config_file": {
        "facebook/blenderbot-3B": "https://huggingface.co/facebook/blenderbot-3B/resolve/main/tokenizer_config.json"
    },
}

__lowerCamelCase     :							Tuple  							=				{"facebook/blenderbot-3B": 128}

@lru_cache()
# Copied from transformers.models.roberta.tokenization_roberta.bytes_to_unicode
def    lowerCamelCase_() ->       Dict:
						UpperCAmelCase         =     (
						    list(range(ord("!"    )    ,   ord("~"    ) + 1    )    ) + list(range(ord("¡"    )    ,   ord("¬"    ) + 1    )    ) + list(range(ord("®"    )    ,   ord("ÿ"    ) + 1    )    )
						)
						UpperCAmelCase         =     bs[:]
						UpperCAmelCase         =     0
						for b in range(2**8    ):
												if b not in bs:
																		bs.append(lowerCamelCase_    )
																		cs.append(2**8 + n    )
																		n += 1
						UpperCAmelCase         =     [chr(lowerCamelCase_    ) for n in cs]
						return dict(zip(lowerCamelCase_    ,   lowerCamelCase_    )    )

def    lowerCamelCase_(lowerCamelCase_    ) ->       Dict:
						UpperCAmelCase         =     set()
						UpperCAmelCase         =     word[0]
						for char in word[1:]:
												pairs.add((prev_char, char)    )
												UpperCAmelCase         =     char
						return pairs





class  __magic_name__   (							A__						):
		lowercase      :       int          =VOCAB_FILES_NAMES
		lowercase      :       int          =PRETRAINED_VOCAB_FILES_MAP
		lowercase      :       Any          =PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
		lowercase      :       List[str]          =['''input_ids''', '''attention_mask''']






		def __init__(						self      :     Optional[Any]				,		UpperCamelCase__      :     Tuple				,		UpperCamelCase__      :     int				,		UpperCamelCase__      :     Tuple="replace"				,		UpperCamelCase__      :     Union[str, Any]="<s>"				,		UpperCamelCase__      :     List[Any]="</s>"				,		UpperCamelCase__      :     int="</s>"				,		UpperCamelCase__      :     Dict="<s>"				,		UpperCamelCase__      :     Dict="<unk>"				,		UpperCamelCase__      :     Optional[Any]="<pad>"				,		UpperCamelCase__      :     int="<mask>"				,		UpperCamelCase__      :     Tuple=False				,		**UpperCamelCase__      :     Union[str, Any]				,		)				->					Optional[Any]:
								'''simple docstring'''







								UpperCAmelCase         =     AddedToken(UpperCamelCase__				,		lstrip=UpperCamelCase__				,		rstrip=UpperCamelCase__      ) if isinstance(UpperCamelCase__				,		UpperCamelCase__      ) else bos_token
								UpperCAmelCase         =     AddedToken(UpperCamelCase__				,		lstrip=UpperCamelCase__				,		rstrip=UpperCamelCase__      ) if isinstance(UpperCamelCase__				,		UpperCamelCase__      ) else eos_token
								UpperCAmelCase         =     AddedToken(UpperCamelCase__				,		lstrip=UpperCamelCase__				,		rstrip=UpperCamelCase__      ) if isinstance(UpperCamelCase__				,		UpperCamelCase__      ) else sep_token
								UpperCAmelCase         =     AddedToken(UpperCamelCase__				,		lstrip=UpperCamelCase__				,		rstrip=UpperCamelCase__      ) if isinstance(UpperCamelCase__				,		UpperCamelCase__      ) else cls_token
								UpperCAmelCase         =     AddedToken(UpperCamelCase__				,		lstrip=UpperCamelCase__				,		rstrip=UpperCamelCase__      ) if isinstance(UpperCamelCase__				,		UpperCamelCase__      ) else unk_token
								UpperCAmelCase         =     AddedToken(UpperCamelCase__				,		lstrip=UpperCamelCase__				,		rstrip=UpperCamelCase__      ) if isinstance(UpperCamelCase__				,		UpperCamelCase__      ) else pad_token

								# Mask token behave like a normal word, i.e. include the space before it
								UpperCAmelCase         =     AddedToken(UpperCamelCase__				,		lstrip=UpperCamelCase__				,		rstrip=UpperCamelCase__      ) if isinstance(UpperCamelCase__				,		UpperCamelCase__      ) else mask_token

								super().__init__(
								    errors=UpperCamelCase__				,		bos_token=UpperCamelCase__				,		eos_token=UpperCamelCase__				,		unk_token=UpperCamelCase__				,		sep_token=UpperCamelCase__				,		cls_token=UpperCamelCase__				,		pad_token=UpperCamelCase__				,		mask_token=UpperCamelCase__				,		add_prefix_space=UpperCamelCase__				,		**UpperCamelCase__				,		)

								with open(UpperCamelCase__				,		encoding="utf-8"      ) as vocab_handle:
														UpperCAmelCase         =     json.load(UpperCamelCase__      )
								UpperCAmelCase         =     {v: k for k, v in self.encoder.items()}
								UpperCAmelCase         =     errors  # how to handle errors in decoding
								UpperCAmelCase         =     bytes_to_unicode()
								UpperCAmelCase         =     {v: k for k, v in self.byte_encoder.items()}
								with open(UpperCamelCase__				,		encoding="utf-8"      ) as merges_handle:
														UpperCAmelCase         =     merges_handle.read().split("\n"      )[1:-1]
								UpperCAmelCase         =     [tuple(merge.split()      ) for merge in bpe_merges]
								UpperCAmelCase         =     dict(zip(UpperCamelCase__				,		range(len(UpperCamelCase__      )      )      )      )
								UpperCAmelCase         =     {}
								UpperCAmelCase         =     add_prefix_space

								# Should have added re.IGNORECASE so BPE merges can happen for capitalized versions of contractions
								UpperCAmelCase         =     re.compile(R"'s|'t|'re|'ve|'m|'ll|'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+"      )






		@property
		# Copied from transformers.models.roberta.tokenization_roberta.RobertaTokenizer.vocab_size with Roberta->Blenderbot, RoBERTa->Blenderbot
		def SCREAMING_SNAKE_CASE_			(						self      :     Optional[int]      )				->					Union[str, Any]:
								'''simple docstring'''







								return len(self.encoder      )






		def SCREAMING_SNAKE_CASE_			(						self      :     int      )				->					Union[str, Any]:
								'''simple docstring'''







								return dict(self.encoder				,		**self.added_tokens_encoder      )






		def SCREAMING_SNAKE_CASE_			(						self      :     Union[str, Any]				,		UpperCamelCase__      :     Tuple      )				->					Union[str, Any]:
								'''simple docstring'''







								if token in self.cache:
														return self.cache[token]
								UpperCAmelCase         =     tuple(UpperCamelCase__      )
								UpperCAmelCase         =     get_pairs(UpperCamelCase__      )

								if not pairs:
														return token

								while True:
														UpperCAmelCase         =     min(UpperCamelCase__				,		key=lambda UpperCamelCase__      : self.bpe_ranks.get(UpperCamelCase__				,		float("inf"      )      )      )
														if bigram not in self.bpe_ranks:
																				break
														UpperCAmelCase       ,		UpperCAmelCase         =     bigram
														UpperCAmelCase         =     []
														UpperCAmelCase         =     0
														while i < len(UpperCamelCase__      ):
																				try:
																										UpperCAmelCase         =     word.index(UpperCamelCase__				,		UpperCamelCase__      )
																				except ValueError:
																										new_word.extend(word[i:]      )
																										break
																				else:
																										new_word.extend(word[i:j]      )
																										UpperCAmelCase         =     j

																				if word[i] == first and i < len(UpperCamelCase__      ) - 1 and word[i + 1] == second:
																										new_word.append(first + second      )
																										i += 2
																				else:
																										new_word.append(word[i]      )
																										i += 1
														UpperCAmelCase         =     tuple(UpperCamelCase__      )
														UpperCAmelCase         =     new_word
														if len(UpperCamelCase__      ) == 1:
																				break
														else:
																				UpperCAmelCase         =     get_pairs(UpperCamelCase__      )
								UpperCAmelCase         =     " ".join(UpperCamelCase__      )
								UpperCAmelCase         =     word
								return word






		def SCREAMING_SNAKE_CASE_			(						self      :     List[Any]				,		UpperCamelCase__      :     Tuple      )				->					int:
								'''simple docstring'''







								UpperCAmelCase         =     []
								for token in re.findall(self.pat				,		UpperCamelCase__      ):
														UpperCAmelCase         =     "".join(
														    self.byte_encoder[b] for b in token.encode("utf-8"      )      )  # Maps all our bytes to unicode strings, avoiding control tokens of the BPE (spaces in our case)
														bpe_tokens.extend(bpe_token for bpe_token in self.bpe(UpperCamelCase__      ).split(" "      )      )
								return bpe_tokens






		def SCREAMING_SNAKE_CASE_			(						self      :     int				,		UpperCamelCase__      :     Tuple      )				->					List[str]:
								'''simple docstring'''







								return self.encoder.get(UpperCamelCase__				,		self.encoder.get(self.unk_token      )      )






		def SCREAMING_SNAKE_CASE_			(						self      :     List[str]				,		UpperCamelCase__      :     Optional[Any]      )				->					Dict:
								'''simple docstring'''







								return self.decoder.get(UpperCamelCase__      )






		def SCREAMING_SNAKE_CASE_			(						self      :     str				,		UpperCamelCase__      :     Tuple      )				->					List[str]:
								'''simple docstring'''







								UpperCAmelCase         =     "".join(UpperCamelCase__      )
								UpperCAmelCase         =     bytearray([self.byte_decoder[c] for c in text]      ).decode("utf-8"				,		errors=self.errors      )
								return text






		def SCREAMING_SNAKE_CASE_			(						self      :     str				,		UpperCamelCase__      :     str				,		UpperCamelCase__      :     Optional[str] = None      )				->					Tuple[str]:
								'''simple docstring'''







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

								with open(UpperCamelCase__				,		"w"				,		encoding="utf-8"      ) as f:
														f.write(json.dumps(self.encoder				,		indent=2				,		sort_keys=UpperCamelCase__				,		ensure_ascii=UpperCamelCase__      ) + "\n"      )

								UpperCAmelCase         =     0
								with open(UpperCamelCase__				,		"w"				,		encoding="utf-8"      ) as writer:
														writer.write("#version: 0.2\n"      )
														for bpe_tokens, token_index in sorted(self.bpe_ranks.items()				,		key=lambda UpperCamelCase__      : kv[1]      ):
																				if index != token_index:
																										logger.warning(
																										    F'Saving vocabulary to {merge_file}: BPE merge indices are not consecutive.'
																										    " Please check that the tokenizer is not corrupted!"      )
																										UpperCAmelCase         =     token_index
																				writer.write(" ".join(UpperCamelCase__      ) + "\n"      )
																				index += 1

								return vocab_file, merge_file






		def SCREAMING_SNAKE_CASE_			(						self      :     Dict				,		UpperCamelCase__      :     List[int]				,		UpperCamelCase__      :     Optional[List[int]] = None				,		UpperCamelCase__      :     bool = False      )				->					List[int]:
								'''simple docstring'''







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

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






		def SCREAMING_SNAKE_CASE_			(						self      :     Optional[Any]				,		UpperCamelCase__      :     List[int]				,		UpperCamelCase__      :     Optional[List[int]] = None      )				->					List[int]:
								'''simple docstring'''







								UpperCAmelCase         =     [self.sep_token_id]
								UpperCAmelCase         =     [self.cls_token_id]

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






		def SCREAMING_SNAKE_CASE_			(						self      :     List[str]				,		UpperCamelCase__      :     str				,		UpperCamelCase__      :     Any=False				,		**UpperCamelCase__      :     Dict      )				->					Any:
								'''simple docstring'''







								UpperCAmelCase         =     kwargs.pop("add_prefix_space"				,		self.add_prefix_space      )
								if (is_split_into_words or add_prefix_space) and (len(UpperCamelCase__      ) > 0 and not text[0].isspace()):
														UpperCAmelCase         =     " " + text
								return (text, kwargs)






		def SCREAMING_SNAKE_CASE_			(						self      :     Dict				,		UpperCamelCase__      :     List[int]				,		UpperCamelCase__      :     Optional[List[int]] = None      )				->					Tuple:
								'''simple docstring'''







								return token_ids_a + [self.eos_token_id]







		def SCREAMING_SNAKE_CASE_			(						self      :     List[Any]				,		UpperCamelCase__      :     "Conversation"      )				->					List[int]:
								'''simple docstring'''







								UpperCAmelCase         =     []
								for is_user, text in conversation.iter_texts():
														if is_user:
																				# We need to space prefix as it's being done within blenderbot
																				inputs.append(" " + text      )
														else:
																				# Generated responses should contain them already.
																				inputs.append(UpperCamelCase__      )

								UpperCAmelCase         =     "  ".join(UpperCamelCase__      )
								UpperCAmelCase         =     self.encode(UpperCamelCase__      )
								if len(UpperCamelCase__      ) > self.model_max_length:
														UpperCAmelCase         =     input_ids[-self.model_max_length :]
														logger.warning(F'Trimmed input from conversation as it was longer than {self.model_max_length} tokens.'      )
								return input_ids








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






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







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






		def SCREAMING_SNAKE_CASE_			(						self      :     Optional[Any]      )				->					Optional[Any]:
								'''simple docstring'''







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

								UpperCAmelCase         =     self.get_config()

								return config, pixel_values






		def SCREAMING_SNAKE_CASE_			(						self      :     Any      )				->					Any:
								'''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 SCREAMING_SNAKE_CASE_			(						self      :     Optional[Any]				,		UpperCamelCase__      :     Union[str, Any]				,		UpperCamelCase__      :     List[str]      )				->					Any:
								'''simple docstring'''







								UpperCAmelCase         =     FlaxRegNetModel(config=UpperCamelCase__      )
								UpperCAmelCase         =     model(UpperCamelCase__      )

								# 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 SCREAMING_SNAKE_CASE_			(						self      :     Union[str, Any]				,		UpperCamelCase__      :     Any				,		UpperCamelCase__      :     str      )				->					Union[str, Any]:
								'''simple docstring'''







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







		def SCREAMING_SNAKE_CASE_			(						self      :     str      )				->					List[Any]:
								'''simple docstring'''







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





@require_flax
class  __magic_name__   (							A__,  unittest.TestCase						):
		lowercase      :       List[str]          =(FlaxRegNetModel, FlaxRegNetForImageClassification) if is_flax_available() else ()

		lowercase      :       Tuple          =False
		lowercase      :       Union[str, Any]          =False
		lowercase      :       Dict          =False






		def SCREAMING_SNAKE_CASE_			(						self      :     List[Any]      )				->					None:
								'''simple docstring'''







								UpperCAmelCase         =     FlaxRegNetModelTester(self      )
								UpperCAmelCase         =     ConfigTester(self				,		config_class=UpperCamelCase__				,		has_text_modality=UpperCamelCase__      )






		def SCREAMING_SNAKE_CASE_			(						self      :     List[str]      )				->					Optional[Any]:
								'''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 SCREAMING_SNAKE_CASE_			(						self      :     int      )				->					Dict:
								'''simple docstring'''







								return






		def SCREAMING_SNAKE_CASE_			(						self      :     List[Any]      )				->					List[str]:
								'''simple docstring'''







								UpperCAmelCase         =     self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*UpperCamelCase__      )






		def SCREAMING_SNAKE_CASE_			(						self      :     str      )				->					Tuple:
								'''simple docstring'''







								UpperCAmelCase         =     self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_image_classification(*UpperCamelCase__      )






		@unittest.skip(reason="RegNet does not use inputs_embeds"      )
		def SCREAMING_SNAKE_CASE_			(						self      :     str      )				->					Optional[int]:
								'''simple docstring'''







								pass






		@unittest.skip(reason="RegNet does not support input and output embeddings"      )
		def SCREAMING_SNAKE_CASE_			(						self      :     int      )				->					Optional[Any]:
								'''simple docstring'''







								pass






		def SCREAMING_SNAKE_CASE_			(						self      :     List[str]      )				->					Optional[Any]:
								'''simple docstring'''







								UpperCAmelCase       ,		UpperCAmelCase         =     self.model_tester.prepare_config_and_inputs_for_common()

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

														UpperCAmelCase         =     ["pixel_values"]
														self.assertListEqual(arg_names[:1]				,		UpperCamelCase__      )






		def SCREAMING_SNAKE_CASE_			(						self      :     Tuple      )				->					Dict:
								'''simple docstring'''







								def check_hidden_states_output(UpperCamelCase__      :     List[str]				,		UpperCamelCase__      :     Any				,		UpperCamelCase__      :     Any      ):
														UpperCAmelCase         =     model_class(UpperCamelCase__      )

														UpperCAmelCase         =     model(**self._prepare_for_class(UpperCamelCase__				,		UpperCamelCase__      )      )

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

														UpperCAmelCase         =     self.model_tester.num_stages
														self.assertEqual(len(UpperCamelCase__      )				,		expected_num_stages + 1      )

								UpperCAmelCase       ,		UpperCAmelCase         =     self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
														UpperCAmelCase         =     True
														check_hidden_states_output(UpperCamelCase__				,		UpperCamelCase__				,		UpperCamelCase__      )

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

														check_hidden_states_output(UpperCamelCase__				,		UpperCamelCase__				,		UpperCamelCase__      )







		def SCREAMING_SNAKE_CASE_			(						self      :     List[str]      )				->					Optional[int]:
								'''simple docstring'''







								UpperCAmelCase       ,		UpperCAmelCase         =     self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
														with self.subTest(model_class.__name__      ):
																				UpperCAmelCase         =     self._prepare_for_class(UpperCamelCase__				,		UpperCamelCase__      )
																				UpperCAmelCase         =     model_class(UpperCamelCase__      )

																				@jax.jit
																				def model_jitted(UpperCamelCase__      :     Optional[int]				,		**UpperCamelCase__      :     Union[str, Any]      ):
																										return model(pixel_values=UpperCamelCase__				,		**UpperCamelCase__      )

																				with self.subTest("JIT Enabled"      ):
																										UpperCAmelCase         =     model_jitted(**UpperCamelCase__      ).to_tuple()

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

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

def    lowerCamelCase_() ->       Union[str, Any]:
						UpperCAmelCase         =     Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"    )
						return image





@require_flax
class  __magic_name__   (							unittest.TestCase						):






		@cached_property
		def SCREAMING_SNAKE_CASE_			(						self      :     Union[str, Any]      )				->					Optional[Any]:
								'''simple docstring'''







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







		@slow
		def SCREAMING_SNAKE_CASE_			(						self      :     Optional[int]      )				->					Tuple:
								'''simple docstring'''







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

								UpperCAmelCase         =     self.default_image_processor
								UpperCAmelCase         =     prepare_img()
								UpperCAmelCase         =     image_processor(images=UpperCamelCase__				,		return_tensors="np"      )

								UpperCAmelCase         =     model(**UpperCamelCase__      )

								# verify the logits
								UpperCAmelCase         =     (1, 10_00)
								self.assertEqual(outputs.logits.shape				,		UpperCamelCase__      )

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

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



