

from __future__ import annotations

import unittest

from transformers import RoFormerConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

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


if is_tf_available():
					import tensorflow as tf

					from transformers import (
					    TFRoFormerForCausalLM,
					    TFRoFormerForMaskedLM,
					    TFRoFormerForMultipleChoice,
					    TFRoFormerForQuestionAnswering,
					    TFRoFormerForSequenceClassification,
					    TFRoFormerForTokenClassification,
					    TFRoFormerModel,
					)
					from transformers.models.roformer.modeling_tf_roformer import (
					    TFRoFormerSelfAttention,
					    TFRoFormerSinusoidalPositionalEmbedding,
					)






class        A_		:
							def __init__(		self		:			Dict   ,SCREAMING_SNAKE_CASE__		:			str   ,SCREAMING_SNAKE_CASE__		:			Tuple=1_3   ,SCREAMING_SNAKE_CASE__		:			Tuple=7   ,SCREAMING_SNAKE_CASE__		:			Tuple=True   ,SCREAMING_SNAKE_CASE__		:			List[str]=True   ,SCREAMING_SNAKE_CASE__		:			List[Any]=True   ,SCREAMING_SNAKE_CASE__		:			List[Any]=True   ,SCREAMING_SNAKE_CASE__		:			List[str]=9_9   ,SCREAMING_SNAKE_CASE__		:			Any=3_2   ,SCREAMING_SNAKE_CASE__		:			List[str]=2   ,SCREAMING_SNAKE_CASE__		:			Tuple=4   ,SCREAMING_SNAKE_CASE__		:			Union[str, Any]=3_7   ,SCREAMING_SNAKE_CASE__		:			Tuple="gelu"   ,SCREAMING_SNAKE_CASE__		:			Optional[int]=0.1   ,SCREAMING_SNAKE_CASE__		:			int=0.1   ,SCREAMING_SNAKE_CASE__		:			int=5_1_2   ,SCREAMING_SNAKE_CASE__		:			str=1_6   ,SCREAMING_SNAKE_CASE__		:			Tuple=2   ,SCREAMING_SNAKE_CASE__		:			List[str]=0.02   ,SCREAMING_SNAKE_CASE__		:			int=3   ,SCREAMING_SNAKE_CASE__		:			int=4   ,SCREAMING_SNAKE_CASE__		:			str=None   ,):
								__lowerCamelCase				:				List[str]					       = parent
								__lowerCamelCase				:				Optional[Any]					       = 1_3
								__lowerCamelCase				:				Any					       = 7
								__lowerCamelCase				:				Dict					       = True
								__lowerCamelCase				:				List[Any]					       = True
								__lowerCamelCase				:				Union[str, Any]					       = True
								__lowerCamelCase				:				List[str]					       = True
								__lowerCamelCase				:				Optional[Any]					       = 9_9
								__lowerCamelCase				:				Optional[Any]					       = 3_2
								__lowerCamelCase				:				Tuple					       = 2
								__lowerCamelCase				:				List[str]					       = 4
								__lowerCamelCase				:				List[Any]					       = 3_7
								__lowerCamelCase				:				Tuple					       = 'gelu'
								__lowerCamelCase				:				str					       = 0.1
								__lowerCamelCase				:				Tuple					       = 0.1
								__lowerCamelCase				:				int					       = 5_1_2
								__lowerCamelCase				:				str					       = 1_6
								__lowerCamelCase				:				str					       = 2
								__lowerCamelCase				:				List[str]					       = 0.02
								__lowerCamelCase				:				Optional[int]					       = 3
								__lowerCamelCase				:				List[Any]					       = 4
								__lowerCamelCase				:				str					       = None
							def     lowerCAmelCase     (		self		:			List[Any]):
								__lowerCamelCase				:				Union[str, Any]					       = ids_tensor([self.batch_size, self.seq_length]   ,self.vocab_size)

								__lowerCamelCase				:				Optional[Any]					       = None
								if self.use_input_mask:
									__lowerCamelCase				:				Optional[Any]					       = random_attention_mask([self.batch_size, self.seq_length])

								__lowerCamelCase				:				int					       = None
								if self.use_token_type_ids:
									__lowerCamelCase				:				Any					       = ids_tensor([self.batch_size, self.seq_length]   ,self.type_vocab_size)

								__lowerCamelCase				:				Tuple					       = None
								__lowerCamelCase				:				Tuple					       = None
								__lowerCamelCase				:				Any					       = None
								if self.use_labels:
									__lowerCamelCase				:				Optional[int]					       = ids_tensor([self.batch_size]   ,self.type_sequence_label_size)
									__lowerCamelCase				:				int					       = ids_tensor([self.batch_size, self.seq_length]   ,self.num_labels)
									__lowerCamelCase				:				List[Any]					       = ids_tensor([self.batch_size]   ,self.num_choices)

								__lowerCamelCase				:				List[str]					       = RoFormerConfig(
								    vocab_size=self.vocab_size   ,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   ,max_position_embeddings=self.max_position_embeddings   ,type_vocab_size=self.type_vocab_size   ,initializer_range=self.initializer_range   ,return_dict=__UpperCamelCase   ,)

								return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels
							def     lowerCAmelCase     (		self		:			int   ,SCREAMING_SNAKE_CASE__		:			List[str]   ,SCREAMING_SNAKE_CASE__		:			List[str]   ,SCREAMING_SNAKE_CASE__		:			Optional[int]   ,SCREAMING_SNAKE_CASE__		:			Optional[int]   ,SCREAMING_SNAKE_CASE__		:			Tuple   ,SCREAMING_SNAKE_CASE__		:			List[Any]   ,SCREAMING_SNAKE_CASE__		:			int):
								__lowerCamelCase				:				List[Any]					       = TFRoFormerModel(config=__UpperCamelCase)
								__lowerCamelCase				:				Tuple					       = {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}

								__lowerCamelCase				:				Union[str, Any]					       = [input_ids, input_mask]
								__lowerCamelCase				:				Any					       = model(__UpperCamelCase)

								__lowerCamelCase				:				Optional[Any]					       = model(__UpperCamelCase)

								self.parent.assertEqual(result.last_hidden_state.shape   ,(self.batch_size, self.seq_length, self.hidden_size))
							def     lowerCAmelCase     (		self		:			Any   ,SCREAMING_SNAKE_CASE__		:			int   ,SCREAMING_SNAKE_CASE__		:			Union[str, Any]   ,SCREAMING_SNAKE_CASE__		:			int   ,SCREAMING_SNAKE_CASE__		:			int   ,SCREAMING_SNAKE_CASE__		:			Optional[int]   ,SCREAMING_SNAKE_CASE__		:			Any   ,SCREAMING_SNAKE_CASE__		:			Optional[int]):
								__lowerCamelCase				:				Tuple					       = True
								__lowerCamelCase				:				Optional[Any]					       = TFRoFormerForCausalLM(config=__UpperCamelCase)
								__lowerCamelCase				:				List[str]					       = {
								    'input_ids': input_ids,
								    'attention_mask': input_mask,
								    'token_type_ids': token_type_ids,
								}
								__lowerCamelCase				:				Union[str, Any]					       = model(__UpperCamelCase)['logits']
								self.parent.assertListEqual(
								    list(prediction_scores.numpy().shape)   ,[self.batch_size, self.seq_length, self.vocab_size])
							def     lowerCAmelCase     (		self		:			Dict   ,SCREAMING_SNAKE_CASE__		:			Optional[int]   ,SCREAMING_SNAKE_CASE__		:			Dict   ,SCREAMING_SNAKE_CASE__		:			List[Any]   ,SCREAMING_SNAKE_CASE__		:			str   ,SCREAMING_SNAKE_CASE__		:			Union[str, Any]   ,SCREAMING_SNAKE_CASE__		:			Tuple   ,SCREAMING_SNAKE_CASE__		:			Dict):
								__lowerCamelCase				:				Tuple					       = TFRoFormerForMaskedLM(config=__UpperCamelCase)
								__lowerCamelCase				:				List[Any]					       = {
								    'input_ids': input_ids,
								    'attention_mask': input_mask,
								    'token_type_ids': token_type_ids,
								}
								__lowerCamelCase				:				Any					       = model(__UpperCamelCase)
								self.parent.assertEqual(result.logits.shape   ,(self.batch_size, self.seq_length, self.vocab_size))
							def     lowerCAmelCase     (		self		:			Dict   ,SCREAMING_SNAKE_CASE__		:			Any   ,SCREAMING_SNAKE_CASE__		:			Union[str, Any]   ,SCREAMING_SNAKE_CASE__		:			Dict   ,SCREAMING_SNAKE_CASE__		:			Tuple   ,SCREAMING_SNAKE_CASE__		:			Union[str, Any]   ,SCREAMING_SNAKE_CASE__		:			Optional[Any]   ,SCREAMING_SNAKE_CASE__		:			Any):
								__lowerCamelCase				:				Optional[int]					       = self.num_labels
								__lowerCamelCase				:				Optional[int]					       = TFRoFormerForSequenceClassification(config=__UpperCamelCase)
								__lowerCamelCase				:				List[Any]					       = {
								    'input_ids': input_ids,
								    'attention_mask': input_mask,
								    'token_type_ids': token_type_ids,
								}

								__lowerCamelCase				:				int					       = model(__UpperCamelCase)
								self.parent.assertEqual(result.logits.shape   ,(self.batch_size, self.num_labels))
							def     lowerCAmelCase     (		self		:			Optional[Any]   ,SCREAMING_SNAKE_CASE__		:			Optional[Any]   ,SCREAMING_SNAKE_CASE__		:			Tuple   ,SCREAMING_SNAKE_CASE__		:			Dict   ,SCREAMING_SNAKE_CASE__		:			Optional[int]   ,SCREAMING_SNAKE_CASE__		:			List[Any]   ,SCREAMING_SNAKE_CASE__		:			int   ,SCREAMING_SNAKE_CASE__		:			str):
								__lowerCamelCase				:				Dict					       = self.num_choices
								__lowerCamelCase				:				Tuple					       = TFRoFormerForMultipleChoice(config=__UpperCamelCase)
								__lowerCamelCase				:				List[str]					       = tf.tile(tf.expand_dims(__UpperCamelCase   ,1)   ,(1, self.num_choices, 1))
								__lowerCamelCase				:				Dict					       = tf.tile(tf.expand_dims(__UpperCamelCase   ,1)   ,(1, self.num_choices, 1))
								__lowerCamelCase				:				str					       = tf.tile(tf.expand_dims(__UpperCamelCase   ,1)   ,(1, self.num_choices, 1))
								__lowerCamelCase				:				Optional[Any]					       = {
								    'input_ids': multiple_choice_inputs_ids,
								    'attention_mask': multiple_choice_input_mask,
								    'token_type_ids': multiple_choice_token_type_ids,
								}
								__lowerCamelCase				:				Optional[int]					       = model(__UpperCamelCase)
								self.parent.assertEqual(result.logits.shape   ,(self.batch_size, self.num_choices))
							def     lowerCAmelCase     (		self		:			Optional[int]   ,SCREAMING_SNAKE_CASE__		:			Tuple   ,SCREAMING_SNAKE_CASE__		:			List[str]   ,SCREAMING_SNAKE_CASE__		:			Optional[int]   ,SCREAMING_SNAKE_CASE__		:			int   ,SCREAMING_SNAKE_CASE__		:			Union[str, Any]   ,SCREAMING_SNAKE_CASE__		:			List[str]   ,SCREAMING_SNAKE_CASE__		:			Any):
								__lowerCamelCase				:				List[Any]					       = self.num_labels
								__lowerCamelCase				:				Optional[int]					       = TFRoFormerForTokenClassification(config=__UpperCamelCase)
								__lowerCamelCase				:				Tuple					       = {
								    'input_ids': input_ids,
								    'attention_mask': input_mask,
								    'token_type_ids': token_type_ids,
								}
								__lowerCamelCase				:				List[str]					       = model(__UpperCamelCase)
								self.parent.assertEqual(result.logits.shape   ,(self.batch_size, self.seq_length, self.num_labels))
							def     lowerCAmelCase     (		self		:			str   ,SCREAMING_SNAKE_CASE__		:			Union[str, Any]   ,SCREAMING_SNAKE_CASE__		:			Optional[Any]   ,SCREAMING_SNAKE_CASE__		:			Any   ,SCREAMING_SNAKE_CASE__		:			List[str]   ,SCREAMING_SNAKE_CASE__		:			Union[str, Any]   ,SCREAMING_SNAKE_CASE__		:			Tuple   ,SCREAMING_SNAKE_CASE__		:			Any):
								__lowerCamelCase				:				List[Any]					       = TFRoFormerForQuestionAnswering(config=__UpperCamelCase)
								__lowerCamelCase				:				int					       = {
								    'input_ids': input_ids,
								    'attention_mask': input_mask,
								    'token_type_ids': token_type_ids,
								}

								__lowerCamelCase				:				Tuple					       = model(__UpperCamelCase)
								self.parent.assertEqual(result.start_logits.shape   ,(self.batch_size, self.seq_length))
								self.parent.assertEqual(result.end_logits.shape   ,(self.batch_size, self.seq_length))


							def     lowerCAmelCase     (		self		:			List[Any]):
								__lowerCamelCase				:				List[Any]					       = self.prepare_config_and_inputs()
								(
								    __lowerCamelCase  
								)				:				List[Any]					       = config_and_inputs
								__lowerCamelCase				:				List[Any]					       = {'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
								return config, inputs_dict






@require_tf
class        A_		(       lowercase_			,							lowercase_			,							unittest.TestCase				):
							_UpperCAmelCase    :  Dict						      =      (
							    (
							        TFRoFormerModel,
							        TFRoFormerForCausalLM,
							        TFRoFormerForMaskedLM,
							        TFRoFormerForQuestionAnswering,
							        TFRoFormerForSequenceClassification,
							        TFRoFormerForTokenClassification,
							        TFRoFormerForMultipleChoice,
							    )
							    if is_tf_available()
							    else ()
							)
							_UpperCAmelCase    :  Optional[int]						      =      (
							    {
							        '''feature-extraction''': TFRoFormerModel,
							        '''fill-mask''': TFRoFormerForMaskedLM,
							        '''question-answering''': TFRoFormerForQuestionAnswering,
							        '''text-classification''': TFRoFormerForSequenceClassification,
							        '''text-generation''': TFRoFormerForCausalLM,
							        '''token-classification''': TFRoFormerForTokenClassification,
							        '''zero-shot''': TFRoFormerForSequenceClassification,
							    }
							    if is_tf_available()
							    else {}
							)

							_UpperCAmelCase    :  Optional[Any]						      =      False
							_UpperCAmelCase    :  Optional[Any]						      =      False
							def     lowerCAmelCase     (		self		:			List[Any]   ,SCREAMING_SNAKE_CASE__		:			str   ,SCREAMING_SNAKE_CASE__		:			Optional[Any]   ,SCREAMING_SNAKE_CASE__		:			List[str]   ,SCREAMING_SNAKE_CASE__		:			Any   ,SCREAMING_SNAKE_CASE__		:			List[str]):


								if pipeline_test_casse_name == "TextGenerationPipelineTests":
									return True

								return False
							def     lowerCAmelCase     (		self		:			int):
								__lowerCamelCase				:				Tuple					       = TFRoFormerModelTester(self)
								__lowerCamelCase				:				List[Any]					       = ConfigTester(self   ,config_class=__UpperCamelCase   ,hidden_size=3_7)
							def     lowerCAmelCase     (		self		:			int):
								self.config_tester.run_common_tests()
							def     lowerCAmelCase     (		self		:			int):
								__lowerCamelCase				:				Optional[Any]					       = self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*__UpperCamelCase)
							def     lowerCAmelCase     (		self		:			Optional[int]):
								__lowerCamelCase				:				Optional[Any]					       = self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_masked_lm(*__UpperCamelCase)
							def     lowerCAmelCase     (		self		:			Dict):
								__lowerCamelCase				:				str					       = self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_lm_head(*__UpperCamelCase)
							def     lowerCAmelCase     (		self		:			Union[str, Any]):
								__lowerCamelCase				:				Any					       = self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_multiple_choice(*__UpperCamelCase)
							def     lowerCAmelCase     (		self		:			Any):
								__lowerCamelCase				:				Any					       = self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_question_answering(*__UpperCamelCase)
							def     lowerCAmelCase     (		self		:			Optional[Any]):
								__lowerCamelCase				:				Union[str, Any]					       = self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_sequence_classification(*__UpperCamelCase)
							def     lowerCAmelCase     (		self		:			Union[str, Any]):
								__lowerCamelCase				:				str					       = self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_token_classification(*__UpperCamelCase)


							@slow
							def     lowerCAmelCase     (		self		:			List[str]):
								__lowerCamelCase				:				Union[str, Any]					       = TFRoFormerModel.from_pretrained('junnyu/roformer_chinese_base')
								self.assertIsNotNone(__UpperCamelCase)






@require_tf
class        A_		(       unittest.TestCase				):
							@slow
							def     lowerCAmelCase     (		self		:			Tuple):
								__lowerCamelCase				:				Tuple					       = TFRoFormerForMaskedLM.from_pretrained('junnyu/roformer_chinese_base')
								__lowerCamelCase				:				Optional[Any]					       = tf.constant([[0, 1, 2, 3, 4, 5]])
								__lowerCamelCase				:				List[Any]					       = model(__UpperCamelCase)[0]

								# TODO Replace vocab size
								__lowerCamelCase				:				List[str]					       = 5_0_0_0_0

								__lowerCamelCase				:				List[Any]					       = [1, 6, vocab_size]
								self.assertEqual(output.shape   ,__UpperCamelCase)

								print(output[:, :3, :3])

								# TODO Replace values below with what was printed above.
								__lowerCamelCase				:				Optional[int]					       = tf.constant(
								    [
								        [
								            [-0.12053341, -1.0264901, 0.29221946],
								            [-1.5133783, 0.197433, 0.15190607],
								            [-5.0135403, -3.900256, -0.84038764],
								        ]
								    ])
								tf.debugging.assert_near(output[:, :3, :3]   ,__UpperCamelCase   ,atol=1E-4)






@require_tf
class        A_		(       unittest.TestCase				):
							_UpperCAmelCase    :  Dict						      =      1E-4
							def     lowerCAmelCase     (		self		:			Tuple):
								__lowerCamelCase				:				int					       = tf.constant([[4, 1_0]])
								__lowerCamelCase				:				int					       = TFRoFormerSinusoidalPositionalEmbedding(num_positions=6   ,embedding_dim=6)

								__lowerCamelCase				:				Any					       = emba(input_ids.shape)
								__lowerCamelCase				:				Dict					       = tf.constant(
								    [[0.0000, 0.0000, 0.0000, 1.0000, 1.0000, 1.0000], [0.8415, 0.0464, 0.0022, 0.5403, 0.9989, 1.0000]])

								tf.debugging.assert_near(__UpperCamelCase   ,__UpperCamelCase   ,atol=self.tolerance)


							def     lowerCAmelCase     (		self		:			Optional[Any]):
								__lowerCamelCase				:				int					       = tf.constant(
								    [
								        [0.0000, 0.0000, 0.0000, 0.0000, 0.0000],
								        [0.8415, 0.8219, 0.8020, 0.7819, 0.7617],
								        [0.9093, 0.9364, 0.9581, 0.9749, 0.9870],
								    ])
								__lowerCamelCase				:				Optional[Any]					       = TFRoFormerSinusoidalPositionalEmbedding(num_positions=5_1_2   ,embedding_dim=5_1_2)
								emba([2, 1_6, 5_1_2])
								__lowerCamelCase				:				str					       = emba.weight[:3, :5]

								tf.debugging.assert_near(__UpperCamelCase   ,__UpperCamelCase   ,atol=self.tolerance)






@require_tf
class        A_		(       unittest.TestCase				):
							_UpperCAmelCase    :  str						      =      1E-4
							def     lowerCAmelCase     (		self		:			Dict):
								__lowerCamelCase				:				Optional[Any]					       = tf.reshape(tf.range(2 * 1_2 * 1_6 * 6_4   ,dtype=tf.floataa)   ,shape=(2, 1_2, 1_6, 6_4)) / 1_0_0

								__lowerCamelCase				:				int					       = -tf.reshape(tf.range(2 * 1_2 * 1_6 * 6_4   ,dtype=tf.floataa)   ,shape=(2, 1_2, 1_6, 6_4)) / 1_0_0

								__lowerCamelCase				:				Optional[int]					       = TFRoFormerSinusoidalPositionalEmbedding(num_positions=3_2   ,embedding_dim=6_4)
								__lowerCamelCase				:				int					       = embed_positions([2, 1_6, 7_6_8])[None, None, :, :]

								__lowerCamelCase				:				int					       = TFRoFormerSelfAttention.apply_rotary_position_embeddings(
								    __UpperCamelCase   ,__UpperCamelCase   ,__UpperCamelCase)

								__lowerCamelCase				:				Tuple					       = tf.constant(
								    [
								        [0.0000, 0.0100, 0.0200, 0.0300, 0.0400, 0.0500, 0.0600, 0.0700],
								        [-0.2012, 0.8897, 0.0263, 0.9401, 0.2074, 0.9463, 0.3481, 0.9343],
								        [-1.7057, 0.6271, -1.2145, 1.3897, -0.6303, 1.7647, -0.1173, 1.8985],
								        [-2.1731, -1.6397, -2.7358, 0.2854, -2.1840, 1.7183, -1.3018, 2.4871],
								        [0.2717, -3.6173, -2.9206, -2.1988, -3.6638, 0.3858, -2.9155, 2.2980],
								        [3.9859, -2.1580, -0.7984, -4.4904, -4.1181, -2.0252, -4.4782, 1.1253],
								    ])
								__lowerCamelCase				:				List[str]					       = tf.constant(
								    [
								        [0.0000, -0.0100, -0.0200, -0.0300, -0.0400, -0.0500, -0.0600, -0.0700],
								        [0.2012, -0.8897, -0.0263, -0.9401, -0.2074, -0.9463, -0.3481, -0.9343],
								        [1.7057, -0.6271, 1.2145, -1.3897, 0.6303, -1.7647, 0.1173, -1.8985],
								        [2.1731, 1.6397, 2.7358, -0.2854, 2.1840, -1.7183, 1.3018, -2.4871],
								        [-0.2717, 3.6173, 2.9206, 2.1988, 3.6638, -0.3858, 2.9155, -2.2980],
								        [-3.9859, 2.1580, 0.7984, 4.4904, 4.1181, 2.0252, 4.4782, -1.1253],
								    ])

								tf.debugging.assert_near(query_layer[0, 0, :6, :8]   ,__UpperCamelCase   ,atol=self.tolerance)
								tf.debugging.assert_near(key_layer[0, 0, :6, :8]   ,__UpperCamelCase   ,atol=self.tolerance)





"""simple docstring"""







import inspect
import unittest
import warnings
from math import ceil, floor

from transformers import LevitConfig
from transformers.file_utils import cached_property, is_torch_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_vision, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
       import torch

       from transformers import (
           MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
           MODEL_MAPPING,
           LevitForImageClassification,
           LevitForImageClassificationWithTeacher,
           LevitModel,
       )
       from transformers.models.levit.modeling_levit import LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
       from PIL import Image

       from transformers import LevitImageProcessor







class        UpperCamelCase		(			lowercase_  ):
   def 			_UpperCAmelCase   (			self			)	->      Any:


        '''simple docstring'''


        lowercase_	:				Any													=	self.config_class(**self.inputs_dict			)
        self.parent.assertTrue(hasattr(__UpperCamelCase     ,'hidden_sizes'			)			)
        self.parent.assertTrue(hasattr(__UpperCamelCase     ,'num_attention_heads'			)			)







class        UpperCamelCase		:
   def __init__(			self     ,__UpperCamelCase     ,__UpperCamelCase=13     ,__UpperCamelCase=64     ,__UpperCamelCase=3     ,__UpperCamelCase=3     ,__UpperCamelCase=2     ,__UpperCamelCase=1     ,__UpperCamelCase=16     ,__UpperCamelCase=[128, 256, 384]     ,__UpperCamelCase=[4, 6, 8]     ,__UpperCamelCase=[2, 3, 4]     ,__UpperCamelCase=[16, 16, 16]     ,__UpperCamelCase=0     ,__UpperCamelCase=[2, 2, 2]     ,__UpperCamelCase=[2, 2, 2]     ,__UpperCamelCase=0.02     ,__UpperCamelCase=True     ,__UpperCamelCase=True     ,__UpperCamelCase=2     ,)	->      str:


        '''simple docstring'''


        lowercase_	:				Optional[Any]													=	parent
        lowercase_	:				Any													=	batch_size
        lowercase_	:				str													=	image_size
        lowercase_	:				List[Any]													=	num_channels
        lowercase_	:				Any													=	kernel_size
        lowercase_	:				Any													=	stride
        lowercase_	:				List[str]													=	padding
        lowercase_	:				Tuple													=	hidden_sizes
        lowercase_	:				List[Any]													=	num_attention_heads
        lowercase_	:				Optional[int]													=	depths
        lowercase_	:				Union[str, Any]													=	key_dim
        lowercase_	:				List[str]													=	drop_path_rate
        lowercase_	:				Dict													=	patch_size
        lowercase_	:				List[Any]													=	attention_ratio
        lowercase_	:				Optional[int]													=	mlp_ratio
        lowercase_	:				Any													=	initializer_range
        lowercase_	:				Optional[Any]													=	[
            ['Subsample', key_dim[0], hidden_sizes[0] // key_dim[0], 4, 2, 2],
            ['Subsample', key_dim[0], hidden_sizes[1] // key_dim[0], 4, 2, 2],
        ]
        lowercase_	:				Dict													=	is_training
        lowercase_	:				Tuple													=	use_labels
        lowercase_	:				Dict													=	num_labels
        lowercase_	:				Union[str, Any]													=	initializer_range
   def 			_UpperCAmelCase   (			self			)	->      List[str]:


        '''simple docstring'''


        lowercase_	:				Union[str, Any]													=	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]			)

        lowercase_	:				List[str]													=	None
        if self.use_labels:
             lowercase_	:				List[Any]													=	ids_tensor([self.batch_size]     ,self.num_labels			)

        lowercase_	:				List[str]													=	self.get_config()
        return config, pixel_values, labels
   def 			_UpperCAmelCase   (			self			)	->      List[str]:


        '''simple docstring'''


        return LevitConfig(
            image_size=self.image_size     ,num_channels=self.num_channels     ,kernel_size=self.kernel_size     ,stride=self.stride     ,padding=self.padding     ,patch_size=self.patch_size     ,hidden_sizes=self.hidden_sizes     ,num_attention_heads=self.num_attention_heads     ,depths=self.depths     ,key_dim=self.key_dim     ,drop_path_rate=self.drop_path_rate     ,mlp_ratio=self.mlp_ratio     ,attention_ratio=self.attention_ratio     ,initializer_range=self.initializer_range     ,down_ops=self.down_ops     ,)
   def 			_UpperCAmelCase   (			self     ,__UpperCamelCase     ,__UpperCamelCase     ,__UpperCamelCase			)	->      Any:


        '''simple docstring'''


        lowercase_	:				Union[str, Any]													=	LevitModel(config=__UpperCamelCase			)
        model.to(__UpperCamelCase			)
        model.eval()
        lowercase_	:				Optional[Any]													=	model(__UpperCamelCase			)
        lowercase_	:				Union[str, Any]													=	(self.image_size, self.image_size)
        lowercase_							,  lowercase_	:				Tuple													=	image_size[0], image_size[1]
        for _ in range(4			):
             lowercase_	:				Optional[int]													=	floor(((height + 2 * self.padding - self.kernel_size) / self.stride) + 1			)
             lowercase_	:				Dict													=	floor(((width + 2 * self.padding - self.kernel_size) / self.stride) + 1			)
        self.parent.assertEqual(
            result.last_hidden_state.shape     ,(self.batch_size, ceil(height / 4			) * ceil(width / 4			), self.hidden_sizes[-1])     ,)
   def 			_UpperCAmelCase   (			self     ,__UpperCamelCase     ,__UpperCamelCase     ,__UpperCamelCase			)	->      Union[str, Any]:


        '''simple docstring'''


        lowercase_	:				str													=	self.num_labels
        lowercase_	:				Optional[Any]													=	LevitForImageClassification(__UpperCamelCase			)
        model.to(__UpperCamelCase			)
        model.eval()
        lowercase_	:				Union[str, Any]													=	model(__UpperCamelCase     ,labels=__UpperCamelCase			)
        self.parent.assertEqual(result.logits.shape     ,(self.batch_size, self.num_labels)			)







   def 			_UpperCAmelCase   (			self			)	->      List[Any]:


        '''simple docstring'''


        lowercase_	:				Union[str, Any]													=	self.prepare_config_and_inputs()
        lowercase_							,  lowercase_							,  lowercase_	:				Tuple													=	config_and_inputs
        lowercase_	:				int													=	{'pixel_values': pixel_values}
        return config, inputs_dict







@require_torch
class        UpperCamelCase		(			lowercase_						,      lowercase_						,      unittest.TestCase  ):
   lowercase							=  (
       (LevitModel, LevitForImageClassification, LevitForImageClassificationWithTeacher)
       if is_torch_available()
       else ()
   )
   lowercase							=  (
       {
           'feature-extraction': LevitModel,
           'image-classification': (LevitForImageClassification, LevitForImageClassificationWithTeacher),
       }
       if is_torch_available()
       else {}
   )

   lowercase							=  False
   lowercase							=  False
   lowercase							=  False
   lowercase							=  False
   lowercase							=  False
   def 			_UpperCAmelCase   (			self			)	->      List[str]:


        '''simple docstring'''


        lowercase_	:				Tuple													=	LevitModelTester(self			)
        lowercase_	:				Dict													=	ConfigTester(self     ,config_class=__UpperCamelCase     ,has_text_modality=__UpperCamelCase     ,hidden_size=37			)
   def 			_UpperCAmelCase   (			self			)	->      List[str]:


        '''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 			_UpperCAmelCase   (			self			)	->      List[Any]:


        '''simple docstring'''


        return
   @unittest.skip(reason='Levit does not use inputs_embeds'			)
   def 			_UpperCAmelCase   (			self			)	->      Tuple:


        '''simple docstring'''


        pass
   @unittest.skip(reason='Levit does not support input and output embeddings'			)
   def 			_UpperCAmelCase   (			self			)	->      Tuple:


        '''simple docstring'''


        pass
   @unittest.skip(reason='Levit does not output attentions'			)
   def 			_UpperCAmelCase   (			self			)	->      Optional[Any]:


        '''simple docstring'''


        pass
   def 			_UpperCAmelCase   (			self			)	->      List[str]:


        '''simple docstring'''


        lowercase_							,  lowercase_	:				Optional[int]													=	self.model_tester.prepare_config_and_inputs_for_common()

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

             lowercase_	:				Optional[int]													=	['pixel_values']
             self.assertListEqual(arg_names[:1]     ,__UpperCamelCase			)
   def 			_UpperCAmelCase   (			self			)	->      Dict:


        '''simple docstring'''


        def check_hidden_states_output(__UpperCamelCase     ,__UpperCamelCase     ,__UpperCamelCase			):
             lowercase_	:				List[Any]													=	model_class(__UpperCamelCase			)
             model.to(__UpperCamelCase			)
             model.eval()

             with torch.no_grad():
                  lowercase_	:				Optional[int]													=	model(**self._prepare_for_class(__UpperCamelCase     ,__UpperCamelCase			)			)

             lowercase_	:				Dict													=	outputs.hidden_states

             lowercase_	:				List[str]													=	len(self.model_tester.depths			) + 1
             self.assertEqual(len(__UpperCamelCase			)     ,__UpperCamelCase			)

             lowercase_	:				Optional[int]													=	(self.model_tester.image_size, self.model_tester.image_size)
             lowercase_							,  lowercase_	:				Union[str, Any]													=	image_size[0], image_size[1]
             for _ in range(4			):
                  lowercase_	:				Optional[Any]													=	floor(
                      (
                          (height + 2 * self.model_tester.padding - self.model_tester.kernel_size)
                          / self.model_tester.stride
                      )
                      + 1			)
                  lowercase_	:				Optional[int]													=	floor(
                      (
                          (width + 2 * self.model_tester.padding - self.model_tester.kernel_size)
                          / self.model_tester.stride
                      )
                      + 1			)
             # verify the first hidden states (first block)
             self.assertListEqual(
                 list(hidden_states[0].shape[-2:]			)     ,[
                     height * width,
                     self.model_tester.hidden_sizes[0],
                 ]     ,)

        lowercase_							,  lowercase_	:				List[str]													=	self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
             lowercase_	:				Any													=	True
             check_hidden_states_output(__UpperCamelCase     ,__UpperCamelCase     ,__UpperCamelCase			)

             # check that output_hidden_states also work using config
             del inputs_dict["output_hidden_states"]
             lowercase_	:				Optional[int]													=	True

             check_hidden_states_output(__UpperCamelCase     ,__UpperCamelCase     ,__UpperCamelCase			)
   @unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.'			)
   def 			_UpperCAmelCase   (			self			)	->      Tuple:


        '''simple docstring'''


        pass
   def 			_UpperCAmelCase   (			self     ,__UpperCamelCase     ,__UpperCamelCase     ,__UpperCamelCase=False			)	->      List[Any]:


        '''simple docstring'''


        lowercase_	:				Optional[Any]													=	super()._prepare_for_class(__UpperCamelCase     ,__UpperCamelCase     ,return_labels=__UpperCamelCase			)

        if return_labels:
             if model_class.__name__ == "LevitForImageClassificationWithTeacher":
                  del inputs_dict["labels"]

        return inputs_dict
   def 			_UpperCAmelCase   (			self			)	->      Union[str, Any]:


        '''simple docstring'''


        lowercase_	:				Any													=	self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*__UpperCamelCase			)
   def 			_UpperCAmelCase   (			self			)	->      Optional[int]:


        '''simple docstring'''


        lowercase_	:				Dict													=	self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_image_classification(*__UpperCamelCase			)
   def 			_UpperCAmelCase   (			self			)	->      Union[str, Any]:


        '''simple docstring'''


        if not self.model_tester.is_training:
             return

        lowercase_							,  lowercase_	:				Union[str, Any]													=	self.model_tester.prepare_config_and_inputs_for_common()
        lowercase_	:				Optional[Any]													=	True

        for model_class in self.all_model_classes:
             # LevitForImageClassificationWithTeacher supports inference-only
             if (
                 model_class in get_values(__UpperCamelCase			)
                 or model_class.__name__ == "LevitForImageClassificationWithTeacher"
             ):
                  continue
             lowercase_	:				Dict													=	model_class(__UpperCamelCase			)
             model.to(__UpperCamelCase			)
             model.train()
             lowercase_	:				List[Any]													=	self._prepare_for_class(__UpperCamelCase     ,__UpperCamelCase     ,return_labels=__UpperCamelCase			)
             lowercase_	:				Union[str, Any]													=	model(**__UpperCamelCase			).loss
             loss.backward()
   def 			_UpperCAmelCase   (			self			)	->      str:


        '''simple docstring'''


        lowercase_							,  lowercase_	:				int													=	self.model_tester.prepare_config_and_inputs_for_common()
        if not self.model_tester.is_training:
             return

        lowercase_	:				Union[str, Any]													=	False
        lowercase_	:				Dict													=	True

        for model_class in self.all_model_classes:
             if model_class in get_values(__UpperCamelCase			) or not model_class.supports_gradient_checkpointing:
                  continue
             # LevitForImageClassificationWithTeacher supports inference-only
             if model_class.__name__ == "LevitForImageClassificationWithTeacher":
                  continue
             lowercase_	:				Dict													=	model_class(__UpperCamelCase			)
             model.gradient_checkpointing_enable()
             model.to(__UpperCamelCase			)
             model.train()
             lowercase_	:				Tuple													=	self._prepare_for_class(__UpperCamelCase     ,__UpperCamelCase     ,return_labels=__UpperCamelCase			)
             lowercase_	:				Any													=	model(**__UpperCamelCase			).loss
             loss.backward()
   def 			_UpperCAmelCase   (			self			)	->      Optional[Any]:


        '''simple docstring'''


        lowercase_							,  lowercase_	:				Any													=	self.model_tester.prepare_config_and_inputs_for_common()

        lowercase_	:				int													=	[
            {'title': 'multi_label_classification', 'num_labels': 2, 'dtype': torch.float},
            {'title': 'single_label_classification', 'num_labels': 1, 'dtype': torch.long},
            {'title': 'regression', 'num_labels': 1, 'dtype': torch.float},
        ]

        for model_class in self.all_model_classes:
             if (
                 model_class
                 not in [
                     *get_values(__UpperCamelCase			),
                 ]
                 or model_class.__name__ == "LevitForImageClassificationWithTeacher"
             ):
                  continue

             for problem_type in problem_types:
                  with self.subTest(msg=f'''Testing {model_class} with {problem_type["title"]}'''			):
                       lowercase_	:				Any													=	problem_type['title']
                       lowercase_	:				Tuple													=	problem_type['num_labels']

                       lowercase_	:				Tuple													=	model_class(__UpperCamelCase			)
                       model.to(__UpperCamelCase			)
                       model.train()

                       lowercase_	:				Optional[int]													=	self._prepare_for_class(__UpperCamelCase     ,__UpperCamelCase     ,return_labels=__UpperCamelCase			)

                       if problem_type["num_labels"] > 1:
                            lowercase_	:				Any													=	inputs['labels'].unsqueeze(1			).repeat(1     ,problem_type['num_labels']			)

                       lowercase_	:				str													=	inputs['labels'].to(problem_type['dtype']			)

                       # This tests that we do not trigger the warning form PyTorch "Using a target size that is different
                       # to the input size. This will likely lead to incorrect results due to broadcasting. Please ensure
                       # they have the same size." which is a symptom something in wrong for the regression problem.
                       # See https://github.com/huggingface/transformers/issues/11780
                       with warnings.catch_warnings(record=__UpperCamelCase			) as warning_list:
                            lowercase_	:				int													=	model(**__UpperCamelCase			).loss
                       for w in warning_list:
                            if "Using a target size that is different to the input size" in str(w.message			):
                                 raise ValueError(
                                     f'''Something is going wrong in the regression problem: intercepted {w.message}'''			)

                       loss.backward()







   @slow
   def 			_UpperCAmelCase   (			self			)	->      List[Any]:


        '''simple docstring'''


        for model_name in LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             lowercase_	:				List[Any]													=	LevitModel.from_pretrained(__UpperCamelCase			)
             self.assertIsNotNone(__UpperCamelCase			)






def 			lowercase__(       ):
     lowercase_	:				Any													=	Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'      )
     return image







@require_torch
@require_vision
class        UpperCamelCase		(			unittest.TestCase  ):
   @cached_property
   def 			_UpperCAmelCase   (			self			)	->      Tuple:


        '''simple docstring'''


        return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]			)







   @slow
   def 			_UpperCAmelCase   (			self			)	->      Optional[Any]:


        '''simple docstring'''


        lowercase_	:				Any													=	LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]			).to(
            __UpperCamelCase			)

        lowercase_	:				str													=	self.default_image_processor
        lowercase_	:				Any													=	prepare_img()
        lowercase_	:				Optional[int]													=	image_processor(images=__UpperCamelCase     ,return_tensors='pt'			).to(__UpperCamelCase			)

        # forward pass
        with torch.no_grad():
             lowercase_	:				Union[str, Any]													=	model(**__UpperCamelCase			)

        # verify the logits
        lowercase_	:				str													=	torch.Size((1, 1000)			)
        self.assertEqual(outputs.logits.shape     ,__UpperCamelCase			)

        lowercase_	:				Any													=	torch.tensor([1.0448, -0.3745, -1.8317]			).to(__UpperCamelCase			)

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

