




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     a__					(      snake_case__   ):






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											__lowerCAmelCase            = self.config_class(**self.inputs_dict    )
											self.parent.assertTrue(hasattr(_A	,    "embed_dim"    )    )
											self.parent.assertTrue(hasattr(_A	,    "num_heads"    )    )






class     a__					:






						def __init__(     self	,    _A	,    _A=1_3	,    _A=6_4	,    _A=3	,    _A=[1_6, 4_8, 9_6]	,    _A=[1, 3, 6]	,    _A=[1, 2, 1_0]	,    _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-1_2	,    _A=True	,    _A=True	,    _A=2	,    ):




											"""simple docstring"""



											__lowerCAmelCase            = parent
											__lowerCAmelCase            = batch_size
											__lowerCAmelCase            = image_size
											__lowerCAmelCase            = patch_sizes
											__lowerCAmelCase            = patch_stride
											__lowerCAmelCase            = patch_padding
											__lowerCAmelCase            = is_training
											__lowerCAmelCase            = use_labels
											__lowerCAmelCase            = num_labels
											__lowerCAmelCase            = num_channels
											__lowerCAmelCase            = embed_dim
											__lowerCAmelCase            = num_heads
											__lowerCAmelCase            = stride_kv
											__lowerCAmelCase            = depth
											__lowerCAmelCase            = cls_token
											__lowerCAmelCase            = attention_drop_rate
											__lowerCAmelCase            = initializer_range
											__lowerCAmelCase            = layer_norm_eps






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



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

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

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






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											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        __SCREAMING_SNAKE_CASE(     self	,    _A	,    _A	,    _A    ):




											"""simple docstring"""



											__lowerCAmelCase            = TFCvtModel(config=_A    )
											__lowerCAmelCase            = model(_A	,    training=_A    )
											__lowerCAmelCase            = (self.image_size, self.image_size)
											__lowerCAmelCase     ,							__lowerCAmelCase            = image_size[0], image_size[1]
											for i in range(len(self.depth    )    ):
																__lowerCAmelCase            = floor(((height + 2 * self.patch_padding[i] - self.patch_sizes[i]) / self.patch_stride[i]) + 1    )
																__lowerCAmelCase            = 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        __SCREAMING_SNAKE_CASE(     self	,    _A	,    _A	,    _A    ):




											"""simple docstring"""



											__lowerCAmelCase            = self.num_labels
											__lowerCAmelCase            = TFCvtForImageClassification(_A    )
											__lowerCAmelCase            = model(_A	,    labels=_A	,    training=_A    )
											self.parent.assertEqual(result.logits.shape	,    (self.batch_size, self.num_labels)    )






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



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






@require_tf
class     a__					(      snake_case__				,       snake_case__				,       unittest.TestCase   ):
						_a							:					Union[str, Any]      =					(TFCvtModel, TFCvtForImageClassification) if is_tf_available() else ()
						_a							:					Optional[int]      =					(
						    {"""feature-extraction""": TFCvtModel, """image-classification""": TFCvtForImageClassification}
						    if is_tf_available()
						    else {}
						)
						_a							:					Tuple      =					False
						_a							:					Union[str, Any]      =					False
						_a							:					int      =					False
						_a							:					Any      =					False
						_a							:					Tuple      =					False






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											__lowerCAmelCase            = TFCvtModelTester(self    )
											__lowerCAmelCase            = TFCvtConfigTester(self	,    config_class=_A	,    has_text_modality=_A	,    hidden_size=3_7    )






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											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        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											pass






						@unittest.skip(reason="Cvt does not use inputs_embeds"    )
						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											pass






						@unittest.skip(reason="Cvt does not support input and output embeddings"    )
						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											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        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											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        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											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        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											__lowerCAmelCase            = 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        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											__lowerCAmelCase     ,							__lowerCAmelCase            = self.model_tester.prepare_config_and_inputs_for_common()

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

																__lowerCAmelCase            = ["pixel_values"]
																self.assertListEqual(arg_names[:1]	,    _A    )






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											def check_hidden_states_output(_A	,    _A	,    _A    ):
																__lowerCAmelCase            = model_class(_A    )

																__lowerCAmelCase            = model(**self._prepare_for_class(_A	,    _A    )    )
																__lowerCAmelCase            = outputs.hidden_states

																__lowerCAmelCase            = 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,
																    ]	,    )

											__lowerCAmelCase     ,							__lowerCAmelCase            = self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
																__lowerCAmelCase            = True
																check_hidden_states_output(_A	,    _A	,    _A    )

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

																check_hidden_states_output(_A	,    _A	,    _A    )






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											__lowerCAmelCase            = self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*_A    )






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											__lowerCAmelCase            = self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_image_classification(*_A    )






						@slow
						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											for model_name in TF_CVT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																__lowerCAmelCase            = TFCvtModel.from_pretrained(_A    )
																self.assertIsNotNone(_A    )







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


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






						@cached_property
						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											return AutoImageProcessor.from_pretrained(TF_CVT_PRETRAINED_MODEL_ARCHIVE_LIST[0]    )






						@slow
						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											__lowerCAmelCase            = TFCvtForImageClassification.from_pretrained(TF_CVT_PRETRAINED_MODEL_ARCHIVE_LIST[0]    )

											__lowerCAmelCase            = self.default_image_processor
											__lowerCAmelCase            = prepare_img()
											__lowerCAmelCase            = image_processor(images=_A	,    return_tensors="tf"    )

											# forward pass
											__lowerCAmelCase            = model(**_A    )

											# verify the logits
											__lowerCAmelCase            = tf.TensorShape((1, 1_0_0_0)    )
											self.assertEqual(outputs.logits.shape	,    _A    )

											__lowerCAmelCase            = tf.constant([0.92_85, 0.90_15, -0.31_50]    )
											self.assertTrue(np.allclose(outputs.logits[0, :3].numpy()	,    _A	,    atol=1E-4    )    )










from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


UpperCamelCase__					    =    {
    """configuration_ctrl""": ["""CTRL_PRETRAINED_CONFIG_ARCHIVE_MAP""", """CTRLConfig"""],
    """tokenization_ctrl""": ["""CTRLTokenizer"""],
}

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					UpperCamelCase__					    =    [
					    """CTRL_PRETRAINED_MODEL_ARCHIVE_LIST""",
					    """CTRLForSequenceClassification""",
					    """CTRLLMHeadModel""",
					    """CTRLModel""",
					    """CTRLPreTrainedModel""",
					]

try:
					if not is_tf_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					UpperCamelCase__					    =    [
					    """TF_CTRL_PRETRAINED_MODEL_ARCHIVE_LIST""",
					    """TFCTRLForSequenceClassification""",
					    """TFCTRLLMHeadModel""",
					    """TFCTRLModel""",
					    """TFCTRLPreTrainedModel""",
					]


if TYPE_CHECKING:
					from .configuration_ctrl import CTRL_PRETRAINED_CONFIG_ARCHIVE_MAP, CTRLConfig
					from .tokenization_ctrl import CTRLTokenizer

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_ctrl import (
										    CTRL_PRETRAINED_MODEL_ARCHIVE_LIST,
										    CTRLForSequenceClassification,
										    CTRLLMHeadModel,
										    CTRLModel,
										    CTRLPreTrainedModel,
										)

					try:
										if not is_tf_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_tf_ctrl import (
										    TF_CTRL_PRETRAINED_MODEL_ARCHIVE_LIST,
										    TFCTRLForSequenceClassification,
										    TFCTRLLMHeadModel,
										    TFCTRLModel,
										    TFCTRLPreTrainedModel,
										)

else:
					import sys

					UpperCamelCase__					    =    _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)




