
import math
import time

from transformers import Trainer, is_torch_tpu_available
from transformers.trainer_utils import PredictionOutput, speed_metrics


if is_torch_tpu_available(check_device=False):
						import torch_xla.core.xla_model as xm
						import torch_xla.debug.metrics as met
class  lowercase__(				UpperCAmelCase							):



	"""simple docstring"""




	def __init__(       self  :			str       ,							*SCREAMING_SNAKE_CASE_  :			Optional[int]       ,							SCREAMING_SNAKE_CASE_  :			Dict=None       ,							SCREAMING_SNAKE_CASE_  :			Optional[int]=None       ,							**SCREAMING_SNAKE_CASE_  :			str       )       ->     int:
					super().__init__(*SCREAMING_SNAKE_CASE_       ,							**SCREAMING_SNAKE_CASE_       )
					lowercase_       =					eval_examples
					lowercase_       =					post_process_function
	def 						_lowercase  (       self  :			Optional[int]       ,							SCREAMING_SNAKE_CASE_  :			List[str]=None       ,							SCREAMING_SNAKE_CASE_  :			str=None       ,							SCREAMING_SNAKE_CASE_  :			int=None       ,							SCREAMING_SNAKE_CASE_  :			str = "eval"       )       ->     Union[str, Any]:
					lowercase_       =					self.eval_dataset if eval_dataset is None else eval_dataset
					lowercase_       =					self.get_eval_dataloader(SCREAMING_SNAKE_CASE_       )
					lowercase_       =					self.eval_examples if eval_examples is None else eval_examples

					# Temporarily disable metric computation, we will do it in the loop here.
					lowercase_       =					self.compute_metrics
					lowercase_       =					None
					lowercase_       =					self.prediction_loop if self.args.use_legacy_prediction_loop else self.evaluation_loop
					lowercase_       =					time.time()
					try:
									lowercase_       =					eval_loop(
									    SCREAMING_SNAKE_CASE_       ,							description='''Evaluation'''       ,							prediction_loss_only=True if compute_metrics is None else None       ,							ignore_keys=SCREAMING_SNAKE_CASE_       ,							metric_key_prefix=SCREAMING_SNAKE_CASE_       ,							)
					finally:
									lowercase_       =					compute_metrics
					lowercase_       =					self.args.eval_batch_size * self.args.world_size
					if f'''{metric_key_prefix}_jit_compilation_time''' in output.metrics:
									start_time += output.metrics[f'''{metric_key_prefix}_jit_compilation_time''']
					output.metrics.update(
					    speed_metrics(
					        SCREAMING_SNAKE_CASE_       ,							SCREAMING_SNAKE_CASE_       ,							num_samples=output.num_samples       ,							num_steps=math.ceil(output.num_samples / total_batch_size       )       ,							)       )
					if self.post_process_function is not None and self.compute_metrics is not None and self.args.should_save:
									# Only the main node write the results by default
									lowercase_       =					self.post_process_function(SCREAMING_SNAKE_CASE_       ,							SCREAMING_SNAKE_CASE_       ,							output.predictions       )
									lowercase_       =					self.compute_metrics(SCREAMING_SNAKE_CASE_       )

									# Prefix all keys with metric_key_prefix + '_'
									for key in list(metrics.keys()       ):
													if not key.startswith(f'''{metric_key_prefix}_'''       ):
																	lowercase_       =					metrics.pop(SCREAMING_SNAKE_CASE_       )
									metrics.update(output.metrics       )
					else:
									lowercase_       =					output.metrics

					if self.args.should_log:
									# Only the main node log the results by default
									self.log(SCREAMING_SNAKE_CASE_       )

					if self.args.tpu_metrics_debug or self.args.debug:
									# tpu-comment: Logging debug metrics for PyTorch/XLA (compile, execute times, ops, etc.)
									xm.master_print(met.metrics_report()       )

					lowercase_       =					self.callback_handler.on_evaluate(self.args       ,							self.state       ,							self.control       ,							SCREAMING_SNAKE_CASE_       )
					return metrics




	def 						_lowercase  (       self  :			List[Any]       ,							SCREAMING_SNAKE_CASE_  :			List[Any]       ,							SCREAMING_SNAKE_CASE_  :			Dict       ,							SCREAMING_SNAKE_CASE_  :			int=None       ,							SCREAMING_SNAKE_CASE_  :			str = "test"       )       ->     Optional[Any]:
					lowercase_       =					self.get_test_dataloader(SCREAMING_SNAKE_CASE_       )

					# Temporarily disable metric computation, we will do it in the loop here.
					lowercase_       =					self.compute_metrics
					lowercase_       =					None
					lowercase_       =					self.prediction_loop if self.args.use_legacy_prediction_loop else self.evaluation_loop
					lowercase_       =					time.time()
					try:
									lowercase_       =					eval_loop(
									    SCREAMING_SNAKE_CASE_       ,							description='''Prediction'''       ,							prediction_loss_only=True if compute_metrics is None else None       ,							ignore_keys=SCREAMING_SNAKE_CASE_       ,							metric_key_prefix=SCREAMING_SNAKE_CASE_       ,							)
					finally:
									lowercase_       =					compute_metrics
					lowercase_       =					self.args.eval_batch_size * self.args.world_size
					if f'''{metric_key_prefix}_jit_compilation_time''' in output.metrics:
									start_time += output.metrics[f'''{metric_key_prefix}_jit_compilation_time''']
					output.metrics.update(
					    speed_metrics(
					        SCREAMING_SNAKE_CASE_       ,							SCREAMING_SNAKE_CASE_       ,							num_samples=output.num_samples       ,							num_steps=math.ceil(output.num_samples / total_batch_size       )       ,							)       )

					if self.post_process_function is None or self.compute_metrics is None:
									return output

					lowercase_       =					self.post_process_function(SCREAMING_SNAKE_CASE_       ,							SCREAMING_SNAKE_CASE_       ,							output.predictions       ,							'''predict'''       )
					lowercase_       =					self.compute_metrics(SCREAMING_SNAKE_CASE_       )

					# Prefix all keys with metric_key_prefix + '_'
					for key in list(metrics.keys()       ):
									if not key.startswith(f'''{metric_key_prefix}_'''       ):
													lowercase_       =					metrics.pop(SCREAMING_SNAKE_CASE_       )
					metrics.update(output.metrics       )
					return PredictionOutput(predictions=predictions.predictions       ,							label_ids=predictions.label_ids       ,							metrics=SCREAMING_SNAKE_CASE_       )






import inspect
import unittest

import numpy as np

from transformers import ViTConfig, is_flax_available
from transformers.testing_utils import require_flax, slow

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


if is_flax_available():
		import jax

		from transformers.models.vit.modeling_flax_vit import FlaxViTForImageClassification, FlaxViTModel




class  lowerCamelCase__							(				unittest.TestCase):




	'''simple docstring'''




	def __init__(					self		:List[str]     ,   a		:Any     ,   a		:List[Any]=1_3     ,   a		:Any=3_0     ,   a		:Dict=2     ,   a		:List[str]=3     ,   a		:Union[str, Any]=True     ,   a		:Optional[int]=True     ,   a		:Tuple=3_2     ,   a		:Any=5     ,   a		:List[str]=4     ,   a		:Optional[Any]=3_7     ,   a		:List[Any]="gelu"     ,   a		:Any=0.1     ,   a		:Any=0.1     ,   a		:List[str]=1_0     ,   a		:str=0.02     ,   )		-> Union[str, Any]:
								__UpperCamelCase	:   int			   =					parent
								__UpperCamelCase	:   List[Any]			   =					batch_size
								__UpperCamelCase	:   Optional[Any]			   =					image_size
								__UpperCamelCase	:   int			   =					patch_size
								__UpperCamelCase	:   Optional[Any]			   =					num_channels
								__UpperCamelCase	:   Optional[int]			   =					is_training
								__UpperCamelCase	:   Union[str, Any]			   =					use_labels
								__UpperCamelCase	:   Tuple			   =					hidden_size
								__UpperCamelCase	:   List[Any]			   =					num_hidden_layers
								__UpperCamelCase	:   List[Any]			   =					num_attention_heads
								__UpperCamelCase	:   Dict			   =					intermediate_size
								__UpperCamelCase	:   Optional[int]			   =					hidden_act
								__UpperCamelCase	:   List[Any]			   =					hidden_dropout_prob
								__UpperCamelCase	:   str			   =					attention_probs_dropout_prob
								__UpperCamelCase	:   List[str]			   =					type_sequence_label_size
								__UpperCamelCase	:   List[str]			   =					initializer_range

								# in ViT, the seq length equals the number of patches + 1 (we add 1 for the [CLS] token)
								__UpperCamelCase	:   Union[str, Any]			   =					(image_size // patch_size) ** 2
								__UpperCamelCase	:   Optional[int]			   =					num_patches + 1







	def    _lowerCamelCase				(					self		:Optional[int]						)		-> Union[str, Any]:
								__UpperCamelCase	:   Optional[int]			   =					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

								__UpperCamelCase	:   Tuple			   =					ViTConfig(
								    image_size=self.image_size     ,   patch_size=self.patch_size     ,   num_channels=self.num_channels     ,   hidden_size=self.hidden_size     ,   num_hidden_layers=self.num_hidden_layers     ,   num_attention_heads=self.num_attention_heads     ,   intermediate_size=self.intermediate_size     ,   hidden_act=self.hidden_act     ,   hidden_dropout_prob=self.hidden_dropout_prob     ,   attention_probs_dropout_prob=self.attention_probs_dropout_prob     ,   is_decoder=a     ,   initializer_range=self.initializer_range     ,   )

								return config, pixel_values







	def    _lowerCamelCase				(					self		:Tuple     ,   a		:Optional[int]     ,   a		:Optional[int]						)		-> Optional[int]:
								__UpperCamelCase	:   Optional[Any]			   =					FlaxViTModel(config=a						)
								__UpperCamelCase	:   int			   =					model(a						)
								# expected sequence length = num_patches + 1 (we add 1 for the [CLS] token)
								__UpperCamelCase	:   Any			   =					(self.image_size, self.image_size)
								__UpperCamelCase	:   Optional[int]			   =					(self.patch_size, self.patch_size)
								__UpperCamelCase	:   Optional[int]			   =					(image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])
								self.parent.assertEqual(result.last_hidden_state.shape     ,   (self.batch_size, num_patches + 1, self.hidden_size)						)







	def    _lowerCamelCase				(					self		:Dict     ,   a		:List[str]     ,   a		:Any						)		-> str:
								__UpperCamelCase	:   Dict			   =					self.type_sequence_label_size
								__UpperCamelCase	:   Dict			   =					FlaxViTForImageClassification(config=a						)
								__UpperCamelCase	:   Tuple			   =					model(a						)
								self.parent.assertEqual(result.logits.shape     ,   (self.batch_size, self.type_sequence_label_size)						)

								# test greyscale images
								__UpperCamelCase	:   Dict			   =					1
								__UpperCamelCase	:   Optional[Any]			   =					FlaxViTForImageClassification(a						)

								__UpperCamelCase	:   List[str]			   =					floats_tensor([self.batch_size, 1, self.image_size, self.image_size]						)
								__UpperCamelCase	:   str			   =					model(a						)







	def    _lowerCamelCase				(					self		:str						)		-> Optional[int]:
								__UpperCamelCase	:   str			   =					self.prepare_config_and_inputs()
								(
								    (
								    __UpperCamelCase
								)   ,						(
								    __UpperCamelCase
								)   ,						
								)	:   List[Any]			   =					config_and_inputs
								__UpperCamelCase	:   str			   =					{"pixel_values": pixel_values}
								return config, inputs_dict




@require_flax
class  lowerCamelCase__							(				__lowercase     ,						unittest.TestCase):




	'''simple docstring'''




	_A								=     (FlaxViTModel, FlaxViTForImageClassification) if is_flax_available() else ()







	def    _lowerCamelCase				(					self		:Optional[int]						)		-> None:
								__UpperCamelCase	:   int			   =					FlaxViTModelTester(self						)
								__UpperCamelCase	:   Any			   =					ConfigTester(self     ,   config_class=a     ,   has_text_modality=a     ,   hidden_size=3_7						)







	def    _lowerCamelCase				(					self		:List[Any]						)		-> str:
								self.config_tester.run_common_tests()







	def    _lowerCamelCase				(					self		:List[Any]						)		-> List[str]:
								__UpperCamelCase	:   int			   =					self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*a						)







	def    _lowerCamelCase				(					self		:List[str]						)		-> Union[str, Any]:
								__UpperCamelCase	:   Any			   =					self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_image_classification(*a						)







	def    _lowerCamelCase				(					self		:Tuple						)		-> Any:
								__UpperCamelCase   ,						__UpperCamelCase	:   Optional[Any]			   =					self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
															__UpperCamelCase	:   List[Any]			   =					model_class(a						)
															__UpperCamelCase	:   Optional[int]			   =					inspect.signature(model.__call__						)
															# signature.parameters is an OrderedDict => so arg_names order is deterministic
															__UpperCamelCase	:   Dict			   =					[*signature.parameters.keys()]

															__UpperCamelCase	:   Any			   =					["pixel_values"]
															self.assertListEqual(arg_names[:1]     ,   a						)







	def    _lowerCamelCase				(					self		:str						)		-> Any:
								__UpperCamelCase   ,						__UpperCamelCase	:   List[str]			   =					self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
															with self.subTest(model_class.__name__						):
																						__UpperCamelCase	:   List[Any]			   =					self._prepare_for_class(a     ,   a						)
																						__UpperCamelCase	:   List[Any]			   =					model_class(a						)

																						@jax.jit
																						def model_jitted(a		:List[str]     ,   **a		:List[Any]						):
																													return model(pixel_values=a     ,   **a						)

																						with self.subTest("JIT Enabled"						):
																													__UpperCamelCase	:   int			   =					model_jitted(**a						).to_tuple()

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







	@slow
	def    _lowerCamelCase				(					self		:Dict						)		-> str:
								for model_class_name in self.all_model_classes:
															__UpperCamelCase	:   List[Any]			   =					model_class_name.from_pretrained("google/vit-base-patch16-224"						)
															__UpperCamelCase	:   Optional[int]			   =					model(np.ones((1, 3, 2_2_4, 2_2_4)						)						)
															self.assertIsNotNone(a						)