






from __future__ import annotations

import inspect
import unittest
from math import floor

import numpy as np

from transformers import CvtConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
	import tensorflow as tf

	from transformers import TFCvtForImageClassification, TFCvtModel
	from transformers.models.cvt.modeling_tf_cvt import TF_CVT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
	from PIL import Image

	from transformers import AutoImageProcessor




class  UpperCamelCase_      (			snake_case_				):



	'''simple docstring'''




	def 							_UpperCamelCase			(       self					)       ->    List[str]:
								snake_case_				=							self.config_class(**self.inputs_dict					)
								self.parent.assertTrue(hasattr(a       ,			'embed_dim'					)					)
								self.parent.assertTrue(hasattr(a       ,			'num_heads'					)					)






class  UpperCamelCase_      :



	'''simple docstring'''




	def __init__(       self       ,			a       ,			a=13       ,			a=64       ,			a=3       ,			a=[16, 48, 96]       ,			a=[1, 3, 6]       ,			a=[1, 2, 10]       ,			a=[7, 3, 3]       ,			a=[4, 2, 2]       ,			a=[2, 1, 1]       ,			a=[2, 2, 2]       ,			a=[False, False, True]       ,			a=[0.0, 0.0, 0.0]       ,			a=0.02       ,			a=1E-12       ,			a=True       ,			a=True       ,			a=2       ,			)       ->    Optional[int]:
								snake_case_				=							parent
								snake_case_				=							batch_size
								snake_case_				=							image_size
								snake_case_				=							patch_sizes
								snake_case_				=							patch_stride
								snake_case_				=							patch_padding
								snake_case_				=							is_training
								snake_case_				=							use_labels
								snake_case_				=							num_labels
								snake_case_				=							num_channels
								snake_case_				=							embed_dim
								snake_case_				=							num_heads
								snake_case_				=							stride_kv
								snake_case_				=							depth
								snake_case_				=							cls_token
								snake_case_				=							attention_drop_rate
								snake_case_				=							initializer_range
								snake_case_				=							layer_norm_eps




	def 							_UpperCamelCase			(       self					)       ->    int:
								snake_case_				=							floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)

								snake_case_				=							None
								if self.use_labels:
															# create a random int32 tensor of given shape
															snake_case_				=							ids_tensor([self.batch_size]       ,			self.num_labels					)

								snake_case_				=							self.get_config()
								return config, pixel_values, labels




	def 							_UpperCamelCase			(       self					)       ->    str:
								return CvtConfig(
								    image_size=self.image_size       ,			num_labels=self.num_labels       ,			num_channels=self.num_channels       ,			embed_dim=self.embed_dim       ,			num_heads=self.num_heads       ,			patch_sizes=self.patch_sizes       ,			patch_padding=self.patch_padding       ,			patch_stride=self.patch_stride       ,			stride_kv=self.stride_kv       ,			depth=self.depth       ,			cls_token=self.cls_token       ,			attention_drop_rate=self.attention_drop_rate       ,			initializer_range=self.initializer_range       ,			)




	def 							_UpperCamelCase			(       self       ,			a       ,			a       ,			a					)       ->    Optional[int]:
								snake_case_				=							TFCvtModel(config=a					)
								snake_case_				=							model(a       ,			training=a					)
								snake_case_				=							(self.image_size, self.image_size)
								snake_case_			,		snake_case_				=							image_size[0], image_size[1]
								for i in range(len(self.depth					)					):
															snake_case_				=							floor(((height + 2 * self.patch_padding[i] - self.patch_sizes[i]) / self.patch_stride[i]) + 1					)
															snake_case_				=							floor(((width + 2 * self.patch_padding[i] - self.patch_sizes[i]) / self.patch_stride[i]) + 1					)
								self.parent.assertEqual(result.last_hidden_state.shape       ,			(self.batch_size, self.embed_dim[-1], height, width)					)




	def 							_UpperCamelCase			(       self       ,			a       ,			a       ,			a					)       ->    str:
								snake_case_				=							self.num_labels
								snake_case_				=							TFCvtForImageClassification(a					)
								snake_case_				=							model(a       ,			labels=a       ,			training=a					)
								self.parent.assertEqual(result.logits.shape       ,			(self.batch_size, self.num_labels)					)






	def 							_UpperCamelCase			(       self					)       ->    Tuple:
								snake_case_				=							self.prepare_config_and_inputs()
								snake_case_			,		snake_case_			,		snake_case_				=							config_and_inputs
								snake_case_				=							{'pixel_values': pixel_values}
								return config, inputs_dict






@require_tf
class  UpperCamelCase_      (			snake_case_       ,					snake_case_       ,					unittest.TestCase				):



	'''simple docstring'''




	lowerCAmelCase													= (TFCvtModel, TFCvtForImageClassification) if is_tf_available() else ()
	lowerCAmelCase													= (
	    {'''feature-extraction''': TFCvtModel, '''image-classification''': TFCvtForImageClassification}
	    if is_tf_available()
	    else {}
	)
	lowerCAmelCase													= False
	lowerCAmelCase													= False
	lowerCAmelCase													= False
	lowerCAmelCase													= False
	lowerCAmelCase													= False




	def 							_UpperCamelCase			(       self					)       ->    Optional[int]:
								snake_case_				=							TFCvtModelTester(self					)
								snake_case_				=							TFCvtConfigTester(self       ,			config_class=a       ,			has_text_modality=a       ,			hidden_size=37					)




	def 							_UpperCamelCase			(       self					)       ->    int:
								self.config_tester.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()




	@unittest.skip(reason='Cvt does not output attentions'					)
	def 							_UpperCamelCase			(       self					)       ->    List[Any]:
								pass




	@unittest.skip(reason='Cvt does not use inputs_embeds'					)
	def 							_UpperCamelCase			(       self					)       ->    List[Any]:
								pass




	@unittest.skip(reason='Cvt does not support input and output embeddings'					)
	def 							_UpperCamelCase			(       self					)       ->    Union[str, Any]:
								pass




	@unittest.skipIf(
	    not is_tf_available() or len(tf.config.list_physical_devices('GPU'					)					) == 0       ,			reason='TF does not support backprop for grouped convolutions on CPU.'       ,			)
	def 							_UpperCamelCase			(       self					)       ->    Union[str, Any]:
								super().test_dataset_conversion()




	@unittest.skipIf(
	    not is_tf_available() or len(tf.config.list_physical_devices('GPU'					)					) == 0       ,			reason='TF does not support backprop for grouped convolutions on CPU.'       ,			)
	@slow
	def 							_UpperCamelCase			(       self					)       ->    List[str]:
								super().test_keras_fit()




	@unittest.skip(reason='Get `Failed to determine best cudnn convolution algo.` error after using TF 2.12+cuda 11.8'					)
	def 							_UpperCamelCase			(       self					)       ->    str:
								snake_case_				=							tf.keras.mixed_precision.Policy('mixed_float16'					)
								tf.keras.mixed_precision.set_global_policy(a					)
								super().test_keras_fit()
								tf.keras.mixed_precision.set_global_policy('float32'					)




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




	def 							_UpperCamelCase			(       self					)       ->    Optional[int]:
								def check_hidden_states_output(a       ,			a       ,			a					):
															snake_case_				=							model_class(a					)

															snake_case_				=							model(**self._prepare_for_class(a       ,			a					)					)
															snake_case_				=							outputs.hidden_states

															snake_case_				=							len(self.model_tester.depth					)
															self.assertEqual(len(a					)       ,			a					)

															# verify the first hidden states (first block)
															self.assertListEqual(
															    list(hidden_states[0].shape[-3:]					)       ,			[
															        self.model_tester.embed_dim[0],
															        self.model_tester.image_size // 4,
															        self.model_tester.image_size // 4,
															    ]       ,			)

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

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

															check_hidden_states_output(a       ,			a       ,			a					)




	def 							_UpperCamelCase			(       self					)       ->    Any:
								snake_case_				=							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*a					)




	def 							_UpperCamelCase			(       self					)       ->    Any:
								snake_case_				=							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_image_classification(*a					)






	@slow
	def 							_UpperCamelCase			(       self					)       ->    Optional[Any]:
								for model_name in TF_CVT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
															snake_case_				=							TFCvtModel.from_pretrained(a					)
															self.assertIsNotNone(a					)






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




@require_tf
@require_vision
class  UpperCamelCase_      (			unittest.TestCase				):



	'''simple docstring'''




	@cached_property
	def 							_UpperCamelCase			(       self					)       ->    Tuple:
								return AutoImageProcessor.from_pretrained(TF_CVT_PRETRAINED_MODEL_ARCHIVE_LIST[0]					)






	@slow
	def 							_UpperCamelCase			(       self					)       ->    int:
								snake_case_				=							TFCvtForImageClassification.from_pretrained(TF_CVT_PRETRAINED_MODEL_ARCHIVE_LIST[0]					)

								snake_case_				=							self.default_image_processor
								snake_case_				=							prepare_img()
								snake_case_				=							image_processor(images=a       ,			return_tensors='tf'					)

								# forward pass
								snake_case_				=							model(**a					)

								# verify the logits
								snake_case_				=							tf.TensorShape((1, 10_00)					)
								self.assertEqual(outputs.logits.shape       ,			a					)

								snake_case_				=							tf.constant([0.9_285, 0.9_015, -0.3_150]					)
								self.assertTrue(np.allclose(outputs.logits[0, :3].numpy()       ,			a       ,			atol=1E-4					)					)













import unittest

from transformers import is_torch_available, is_vision_available
from transformers.testing_utils import require_torch, require_vision, slow, torch_device


if is_torch_available():
	import torch

	from transformers import AutoModelForImageClassification

if is_vision_available():
	from transformers import AutoImageProcessor




@require_torch
@require_vision
class  UpperCamelCase_      (			unittest.TestCase				):



	'''simple docstring'''




	@slow
	def 							_UpperCamelCase			(       self					)       ->    int:
								snake_case_				=							AutoImageProcessor.from_pretrained('microsoft/dit-base-finetuned-rvlcdip'					)
								snake_case_				=							AutoModelForImageClassification.from_pretrained('microsoft/dit-base-finetuned-rvlcdip'					)
								model.to(a					)

								from datasets import load_dataset

								snake_case_				=							load_dataset('nielsr/rvlcdip-demo'					)

								snake_case_				=							dataset['train'][0]['image'].convert('RGB'					)

								snake_case_				=							image_processor(a       ,			return_tensors='pt'					).to(a					)

								# forward pass
								with torch.no_grad():
															snake_case_				=							model(**a					)
															snake_case_				=							outputs.logits

								snake_case_				=							torch.Size((1, 16)					)
								self.assertEqual(logits.shape       ,			a					)

								snake_case_				=							torch.tensor(
								    [-0.4_158, -0.4_092, -0.4_347]       ,			device=a       ,			dtype=torch.float       ,			)
								self.assertTrue(torch.allclose(logits[0, :3]       ,			a       ,			atol=1E-4					)					)





