



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 		snake_case						(	SCREAMING_SNAKE_CASE_  ):



   '''simple docstring'''






   def      UpperCamelCase_  (					self							:			List[Any])				->				Dict:

    """simple docstring"""







    _snake_case    :  Optional[Any]					=					self.config_class(**self.inputs_dict)
    self.parent.assertTrue(hasattr(__UpperCamelCase				,		"""hidden_sizes"""))
    self.parent.assertTrue(hasattr(__UpperCamelCase				,		"""num_attention_heads"""))







class 		snake_case						:



   '''simple docstring'''






   def __init__(					self							:			Tuple				,		lowerCAmelCase							:			Any				,		lowerCAmelCase							:			List[Any]=13				,		lowerCAmelCase							:			Tuple=64				,		lowerCAmelCase							:			int=3				,		lowerCAmelCase							:			int=3				,		lowerCAmelCase							:			Tuple=2				,		lowerCAmelCase							:			int=1				,		lowerCAmelCase							:			Any=16				,		lowerCAmelCase							:			Optional[Any]=[128, 256, 384]				,		lowerCAmelCase							:			Any=[4, 6, 8]				,		lowerCAmelCase							:			Any=[2, 3, 4]				,		lowerCAmelCase							:			Optional[int]=[16, 16, 16]				,		lowerCAmelCase							:			List[str]=0				,		lowerCAmelCase							:			List[str]=[2, 2, 2]				,		lowerCAmelCase							:			List[Any]=[2, 2, 2]				,		lowerCAmelCase							:			Tuple=0.02				,		lowerCAmelCase							:			Union[str, Any]=True				,		lowerCAmelCase							:			str=True				,		lowerCAmelCase							:			List[str]=2				,		)				->				Union[str, Any]:

    """simple docstring"""







    _snake_case    :  List[str]					=					parent
    _snake_case    :  Optional[Any]					=					batch_size
    _snake_case    :  Any					=					image_size
    _snake_case    :  str					=					num_channels
    _snake_case    :  Optional[Any]					=					kernel_size
    _snake_case    :  Any					=					stride
    _snake_case    :  int					=					padding
    _snake_case    :  List[str]					=					hidden_sizes
    _snake_case    :  Tuple					=					num_attention_heads
    _snake_case    :  Optional[Any]					=					depths
    _snake_case    :  int					=					key_dim
    _snake_case    :  Optional[int]					=					drop_path_rate
    _snake_case    :  Union[str, Any]					=					patch_size
    _snake_case    :  Dict					=					attention_ratio
    _snake_case    :  int					=					mlp_ratio
    _snake_case    :  Union[str, Any]					=					initializer_range
    _snake_case    :  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],
    ]
    _snake_case    :  Dict					=					is_training
    _snake_case    :  Dict					=					use_labels
    _snake_case    :  str					=					num_labels
    _snake_case    :  str					=					initializer_range

   def      UpperCamelCase_  (					self							:			Optional[Any])				->				Union[str, Any]:

    """simple docstring"""







    _snake_case    :  List[Any]					=					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

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

    _snake_case    :  Tuple					=					self.get_config()
    return config, pixel_values, labels

   def      UpperCamelCase_  (					self							:			Tuple)				->				Any:

    """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							:			Union[str, Any]				,		lowerCAmelCase							:			Any				,		lowerCAmelCase							:			str				,		lowerCAmelCase							:			Optional[int])				->				List[Any]:

    """simple docstring"""







    _snake_case    :  List[Any]					=					LevitModel(config=__UpperCamelCase)
    model.to(__UpperCamelCase)
    model.eval()
    _snake_case    :  List[str]					=					model(__UpperCamelCase)
    _snake_case    :  Optional[int]					=					(self.image_size, self.image_size)
    _snake_case	,    _snake_case    :  Any					=					image_size[0], image_size[1]
    for _ in range(4):
     _snake_case    :  Dict					=					floor(((height + 2 * self.padding - self.kernel_size) / self.stride) + 1)
     _snake_case    :  Optional[int]					=					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							:			Dict				,		lowerCAmelCase							:			List[str]				,		lowerCAmelCase							:			int				,		lowerCAmelCase							:			int)				->				Tuple:

    """simple docstring"""







    _snake_case    :  Dict					=					self.num_labels
    _snake_case    :  Tuple					=					LevitForImageClassification(__UpperCamelCase)
    model.to(__UpperCamelCase)
    model.eval()
    _snake_case    :  Dict					=					model(__UpperCamelCase				,		labels=__UpperCamelCase)
    self.parent.assertEqual(result.logits.shape				,		(self.batch_size, self.num_labels))


   def      UpperCamelCase_  (					self							:			Union[str, Any])				->				Union[str, Any]:

    """simple docstring"""







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







@require_torch
class 		snake_case						(	SCREAMING_SNAKE_CASE_					,SCREAMING_SNAKE_CASE_					,unittest.TestCase  ):



   '''simple docstring'''






   snake_case_					: Optional[Any]          =		(
       (LevitModel, LevitForImageClassification, LevitForImageClassificationWithTeacher)
       if is_torch_available()
       else ()
   )
   snake_case_					: Any          =		(
       {
           """feature-extraction""": LevitModel,
           """image-classification""": (LevitForImageClassification, LevitForImageClassificationWithTeacher),
       }
       if is_torch_available()
       else {}
   )

   snake_case_					: str          =		False
   snake_case_					: Optional[Any]          =		False
   snake_case_					: str          =		False
   snake_case_					: Tuple          =		False
   snake_case_					: Optional[Any]          =		False

   def      UpperCamelCase_  (					self							:			List[str])				->				Dict:

    """simple docstring"""







    _snake_case    :  Union[str, Any]					=					LevitModelTester(self)
    _snake_case    :  List[Any]					=					ConfigTester(self				,		config_class=__UpperCamelCase				,		has_text_modality=__UpperCamelCase				,		hidden_size=37)

   def      UpperCamelCase_  (					self							:			Tuple)				->				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      UpperCamelCase_  (					self							:			Union[str, Any])				->				int:

    """simple docstring"""







    return

   @unittest.skip(reason="""Levit does not use inputs_embeds""")
   def      UpperCamelCase_  (					self							:			str)				->				Optional[Any]:

    """simple docstring"""







    pass

   @unittest.skip(reason="""Levit does not support input and output embeddings""")
   def      UpperCamelCase_  (					self							:			int)				->				str:

    """simple docstring"""







    pass

   @unittest.skip(reason="""Levit does not output attentions""")
   def      UpperCamelCase_  (					self							:			Tuple)				->				Tuple:

    """simple docstring"""







    pass

   def      UpperCamelCase_  (					self							:			str)				->				Optional[int]:

    """simple docstring"""







    _snake_case	,    _snake_case    :  int					=					self.model_tester.prepare_config_and_inputs_for_common()

    for model_class in self.all_model_classes:
     _snake_case    :  int					=					model_class(__UpperCamelCase)
     _snake_case    :  str					=					inspect.signature(model.forward)
     # signature.parameters is an OrderedDict => so arg_names order is deterministic
     _snake_case    :  List[str]					=					[*signature.parameters.keys()]

     _snake_case    :  Tuple					=					["""pixel_values"""]
     self.assertListEqual(arg_names[:1]				,		__UpperCamelCase)

   def      UpperCamelCase_  (					self							:			Union[str, Any])				->				List[Any]:

    """simple docstring"""







    def check_hidden_states_output(lowerCAmelCase							:			int				,		lowerCAmelCase							:			Optional[int]				,		lowerCAmelCase							:			int):
     _snake_case    :  List[str]					=					model_class(__UpperCamelCase)
     model.to(__UpperCamelCase)
     model.eval()

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

     _snake_case    :  List[Any]					=					outputs.hidden_states

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

     _snake_case    :  Any					=					(self.model_tester.image_size, self.model_tester.image_size)
     _snake_case	,    _snake_case    :  Any					=					image_size[0], image_size[1]
     for _ in range(4):
      _snake_case    :  Union[str, Any]					=					floor(
          (
              (height + 2 * self.model_tester.padding - self.model_tester.kernel_size)
              / self.model_tester.stride
          )
          + 1)
      _snake_case    :  Dict					=					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],
         ]				,		)

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

    for model_class in self.all_model_classes:
     _snake_case    :  str					=					True
     check_hidden_states_output(__UpperCamelCase				,		__UpperCamelCase				,		__UpperCamelCase)

     # check that output_hidden_states also work using config
     del inputs_dict["output_hidden_states"]
     _snake_case    :  List[str]					=					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							:			str)				->				int:

    """simple docstring"""







    pass

   def      UpperCamelCase_  (					self							:			Optional[Any]				,		lowerCAmelCase							:			Union[str, Any]				,		lowerCAmelCase							:			List[Any]				,		lowerCAmelCase							:			Union[str, Any]=False)				->				Dict:

    """simple docstring"""







    _snake_case    :  List[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							:			List[Any])				->				List[Any]:

    """simple docstring"""







    _snake_case    :  Optional[int]					=					self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_model(*__UpperCamelCase)

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

    """simple docstring"""







    _snake_case    :  str					=					self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_image_classification(*__UpperCamelCase)

   def      UpperCamelCase_  (					self							:			Tuple)				->				List[str]:

    """simple docstring"""







    if not self.model_tester.is_training:
     return

    _snake_case	,    _snake_case    :  Union[str, Any]					=					self.model_tester.prepare_config_and_inputs_for_common()
    _snake_case    :  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
     _snake_case    :  Optional[Any]					=					model_class(__UpperCamelCase)
     model.to(__UpperCamelCase)
     model.train()
     _snake_case    :  Union[str, Any]					=					self._prepare_for_class(__UpperCamelCase				,		__UpperCamelCase				,		return_labels=__UpperCamelCase)
     _snake_case    :  int					=					model(**__UpperCamelCase).loss
     loss.backward()

   def      UpperCamelCase_  (					self							:			int)				->				Any:

    """simple docstring"""







    _snake_case	,    _snake_case    :  Optional[int]					=					self.model_tester.prepare_config_and_inputs_for_common()
    if not self.model_tester.is_training:
     return

    _snake_case    :  Optional[int]					=					False
    _snake_case    :  str					=					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
     _snake_case    :  Optional[Any]					=					model_class(__UpperCamelCase)
     model.gradient_checkpointing_enable()
     model.to(__UpperCamelCase)
     model.train()
     _snake_case    :  int					=					self._prepare_for_class(__UpperCamelCase				,		__UpperCamelCase				,		return_labels=__UpperCamelCase)
     _snake_case    :  str					=					model(**__UpperCamelCase).loss
     loss.backward()

   def      UpperCamelCase_  (					self							:			List[str])				->				str:

    """simple docstring"""







    _snake_case	,    _snake_case    :  Tuple					=					self.model_tester.prepare_config_and_inputs_for_common()

    _snake_case    :  List[str]					=					[
        {"""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']}'''):
       _snake_case    :  str					=					problem_type["""title"""]
       _snake_case    :  Dict					=					problem_type["""num_labels"""]

       _snake_case    :  List[Any]					=					model_class(__UpperCamelCase)
       model.to(__UpperCamelCase)
       model.train()

       _snake_case    :  Dict					=					self._prepare_for_class(__UpperCamelCase				,		__UpperCamelCase				,		return_labels=__UpperCamelCase)

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

       _snake_case    :  Dict					=					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:
        _snake_case    :  Tuple					=					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])				->				Union[str, Any]:

    """simple docstring"""







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



def       lowercase       (   )  ->     str:
 _snake_case    :  List[Any]					=					Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""				)
 return image







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



   '''simple docstring'''






   @cached_property
   def      UpperCamelCase_  (					self							:			Optional[Any])				->				int:

    """simple docstring"""







    return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0])


   @slow
   def      UpperCamelCase_  (					self							:			str)				->				Any:

    """simple docstring"""







    _snake_case    :  Union[str, Any]					=					LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]).to(
        __UpperCamelCase)

    _snake_case    :  List[str]					=					self.default_image_processor
    _snake_case    :  Tuple					=					prepare_img()
    _snake_case    :  Optional[int]					=					image_processor(images=__UpperCamelCase				,		return_tensors="""pt""").to(__UpperCamelCase)

    # forward pass
    with torch.no_grad():
     _snake_case    :  Optional[int]					=					model(**__UpperCamelCase)

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

    _snake_case    :  Dict					=					torch.tensor([1.0_448, -0.3_745, -1.8_317]).to(__UpperCamelCase)

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





import json
import os
import unittest

from transformers.models.ctrl.tokenization_ctrl import VOCAB_FILES_NAMES, CTRLTokenizer

from ...test_tokenization_common import TokenizerTesterMixin







class 		snake_case						(	SCREAMING_SNAKE_CASE_					,unittest.TestCase  ):



   '''simple docstring'''






   snake_case_					: Optional[Any]          =		CTRLTokenizer
   snake_case_					: Optional[Any]          =		False
   snake_case_					: List[Any]          =		False

   def      UpperCamelCase_  (					self							:			int)				->				Dict:

    """simple docstring"""







    super().setUp()

    # Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
    _snake_case    :  Dict					=					["""adapt""", """re@@""", """a@@""", """apt""", """c@@""", """t""", """<unk>"""]
    _snake_case    :  Optional[int]					=					dict(zip(lowerCAmelCase				,		range(len(lowerCAmelCase))))
    _snake_case    :  int					=					["""#version: 0.2""", """a p""", """ap t</w>""", """r e""", """a d""", """ad apt</w>""", """"""]
    _snake_case    :  List[Any]					=					{"""unk_token""": """<unk>"""}

    _snake_case    :  Dict					=					os.path.join(self.tmpdirname				,		VOCAB_FILES_NAMES["""vocab_file"""])
    _snake_case    :  Any					=					os.path.join(self.tmpdirname				,		VOCAB_FILES_NAMES["""merges_file"""])
    with open(self.vocab_file				,		"""w"""				,		encoding="""utf-8""") as fp:
     fp.write(json.dumps(lowerCAmelCase) + """\n""")
    with open(self.merges_file				,		"""w"""				,		encoding="""utf-8""") as fp:
     fp.write("""\n""".join(lowerCAmelCase))

   def      UpperCamelCase_  (					self							:			Dict				,		**lowerCAmelCase							:			int)				->				Optional[Any]:

    """simple docstring"""







    kwargs.update(self.special_tokens_map)
    return CTRLTokenizer.from_pretrained(self.tmpdirname				,		**lowerCAmelCase)

   def      UpperCamelCase_  (					self							:			Any				,		lowerCAmelCase							:			Optional[int])				->				Optional[int]:

    """simple docstring"""







    _snake_case    :  Tuple					=					"""adapt react readapt apt"""
    _snake_case    :  Tuple					=					"""adapt react readapt apt"""
    return input_text, output_text


   def      UpperCamelCase_  (					self							:			Union[str, Any])				->				str:

    """simple docstring"""







    _snake_case    :  str					=					CTRLTokenizer(self.vocab_file				,		self.merges_file				,		**self.special_tokens_map)
    _snake_case    :  Dict					=					"""adapt react readapt apt"""
    _snake_case    :  int					=					"""adapt re@@ a@@ c@@ t re@@ adapt apt""".split()
    _snake_case    :  Tuple					=					tokenizer.tokenize(lowerCAmelCase)
    self.assertListEqual(lowerCAmelCase				,		lowerCAmelCase)

    _snake_case    :  str					=					tokens + [tokenizer.unk_token]

    _snake_case    :  Union[str, Any]					=					[0, 1, 2, 4, 5, 1, 0, 3, 6]
    self.assertListEqual(tokenizer.convert_tokens_to_ids(lowerCAmelCase)				,		lowerCAmelCase)
