




'''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   _a							(		__lowerCAmelCase				):






     def 							_lowercase      (					self       )				->     List[Any]:
          _snake_case				= self.config_class(**self.inputs_dict       )
          self.parent.assertTrue(hasattr(_SCREAMING_SNAKE_CASE   ,"hidden_sizes"       )       )
          self.parent.assertTrue(hasattr(_SCREAMING_SNAKE_CASE   ,"num_attention_heads"       )       )







class   _a							:






     def __init__(					self   ,_SCREAMING_SNAKE_CASE   ,_SCREAMING_SNAKE_CASE=13   ,_SCREAMING_SNAKE_CASE=64   ,_SCREAMING_SNAKE_CASE=3   ,_SCREAMING_SNAKE_CASE=3   ,_SCREAMING_SNAKE_CASE=2   ,_SCREAMING_SNAKE_CASE=1   ,_SCREAMING_SNAKE_CASE=16   ,_SCREAMING_SNAKE_CASE=[128, 256, 384]   ,_SCREAMING_SNAKE_CASE=[4, 6, 8]   ,_SCREAMING_SNAKE_CASE=[2, 3, 4]   ,_SCREAMING_SNAKE_CASE=[16, 16, 16]   ,_SCREAMING_SNAKE_CASE=0   ,_SCREAMING_SNAKE_CASE=[2, 2, 2]   ,_SCREAMING_SNAKE_CASE=[2, 2, 2]   ,_SCREAMING_SNAKE_CASE=0.0_2   ,_SCREAMING_SNAKE_CASE=True   ,_SCREAMING_SNAKE_CASE=True   ,_SCREAMING_SNAKE_CASE=2   ,)				->     Dict:
          _snake_case				= parent
          _snake_case				= batch_size
          _snake_case				= image_size
          _snake_case				= num_channels
          _snake_case				= kernel_size
          _snake_case				= stride
          _snake_case				= padding
          _snake_case				= hidden_sizes
          _snake_case				= num_attention_heads
          _snake_case				= depths
          _snake_case				= key_dim
          _snake_case				= drop_path_rate
          _snake_case				= patch_size
          _snake_case				= attention_ratio
          _snake_case				= mlp_ratio
          _snake_case				= initializer_range
          _snake_case				= [
              ["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				= is_training
          _snake_case				= use_labels
          _snake_case				= num_labels
          _snake_case				= initializer_range






     def 							_lowercase      (					self       )				->     Dict:
          _snake_case				= floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]       )

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

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






     def 							_lowercase      (					self       )				->     Dict:
          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 							_lowercase      (					self   ,_SCREAMING_SNAKE_CASE   ,_SCREAMING_SNAKE_CASE   ,_SCREAMING_SNAKE_CASE       )				->     Any:
          _snake_case				= LevitModel(config=_SCREAMING_SNAKE_CASE       )
          model.to(_SCREAMING_SNAKE_CASE       )
          model.eval()
          _snake_case				= model(_SCREAMING_SNAKE_CASE       )
          _snake_case				= (self.image_size, self.image_size)
          _snake_case				,   _snake_case				= image_size[0], image_size[1]
          for _ in range(4       ):
               _snake_case				= floor(((height + 2 * self.padding - self.kernel_size) / self.stride) + 1       )
               _snake_case				= 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 							_lowercase      (					self   ,_SCREAMING_SNAKE_CASE   ,_SCREAMING_SNAKE_CASE   ,_SCREAMING_SNAKE_CASE       )				->     Union[str, Any]:
          _snake_case				= self.num_labels
          _snake_case				= LevitForImageClassification(_SCREAMING_SNAKE_CASE       )
          model.to(_SCREAMING_SNAKE_CASE       )
          model.eval()
          _snake_case				= model(_SCREAMING_SNAKE_CASE   ,labels=_SCREAMING_SNAKE_CASE       )
          self.parent.assertEqual(result.logits.shape   ,(self.batch_size, self.num_labels)       )






     def 							_lowercase      (					self       )				->     Dict:
          _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_torch
class   _a							(		__lowerCAmelCase   ,   __lowerCAmelCase   ,   unittest.TestCase				):
     SCREAMING_SNAKE_CASE_				:       List[Any]       							=		(
         (LevitModel, LevitForImageClassification, LevitForImageClassificationWithTeacher)
         if is_torch_available()
         else ()
     )
     SCREAMING_SNAKE_CASE_				:       Tuple       							=		(
         {
             """feature-extraction""": LevitModel,
             """image-classification""": (LevitForImageClassification, LevitForImageClassificationWithTeacher),
         }
         if is_torch_available()
         else {}
     )

     SCREAMING_SNAKE_CASE_				:       str       							=		False
     SCREAMING_SNAKE_CASE_				:       int       							=		False
     SCREAMING_SNAKE_CASE_				:       Optional[int]       							=		False
     SCREAMING_SNAKE_CASE_				:       Tuple       							=		False
     SCREAMING_SNAKE_CASE_				:       List[Any]       							=		False






     def 							_lowercase      (					self       )				->     Dict:
          _snake_case				= LevitModelTester(self       )
          _snake_case				= ConfigTester(self   ,config_class=_SCREAMING_SNAKE_CASE   ,has_text_modality=_SCREAMING_SNAKE_CASE   ,hidden_size=37       )






     def 							_lowercase      (					self       )				->     int:
          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 							_lowercase      (					self       )				->     Any:
          return






     @unittest.skip(reason="Levit does not use inputs_embeds"       )
     def 							_lowercase      (					self       )				->     Any:
          pass






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






     @unittest.skip(reason="Levit does not output attentions"       )
     def 							_lowercase      (					self       )				->     Any:
          pass






     def 							_lowercase      (					self       )				->     str:
          _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(_SCREAMING_SNAKE_CASE       )
               _snake_case				= inspect.signature(model.forward       )
               # 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]   ,_SCREAMING_SNAKE_CASE       )






     def 							_lowercase      (					self       )				->     List[Any]:
          def check_hidden_states_output(_SCREAMING_SNAKE_CASE   ,_SCREAMING_SNAKE_CASE   ,_SCREAMING_SNAKE_CASE       ):
               _snake_case				= model_class(_SCREAMING_SNAKE_CASE       )
               model.to(_SCREAMING_SNAKE_CASE       )
               model.eval()

               with torch.no_grad():
                    _snake_case				= model(**self._prepare_for_class(_SCREAMING_SNAKE_CASE   ,_SCREAMING_SNAKE_CASE       )       )

               _snake_case				= outputs.hidden_states

               _snake_case				= len(self.model_tester.depths       ) + 1
               self.assertEqual(len(_SCREAMING_SNAKE_CASE       )   ,_SCREAMING_SNAKE_CASE       )

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

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

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

               check_hidden_states_output(_SCREAMING_SNAKE_CASE   ,_SCREAMING_SNAKE_CASE   ,_SCREAMING_SNAKE_CASE       )






     @unittest.skip("Will be fixed soon by reducing the size of the model used for common tests."       )
     def 							_lowercase      (					self       )				->     List[Any]:
          pass






     def 							_lowercase      (					self   ,_SCREAMING_SNAKE_CASE   ,_SCREAMING_SNAKE_CASE   ,_SCREAMING_SNAKE_CASE=False       )				->     str:
          _snake_case				= super()._prepare_for_class(_SCREAMING_SNAKE_CASE   ,_SCREAMING_SNAKE_CASE   ,return_labels=_SCREAMING_SNAKE_CASE       )

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

          return inputs_dict






     def 							_lowercase      (					self       )				->     int:
          _snake_case				= self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*_SCREAMING_SNAKE_CASE       )






     def 							_lowercase      (					self       )				->     int:
          _snake_case				= self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_image_classification(*_SCREAMING_SNAKE_CASE       )






     def 							_lowercase      (					self       )				->     Union[str, Any]:
          if not self.model_tester.is_training:
               return

          _snake_case				,   _snake_case				= self.model_tester.prepare_config_and_inputs_for_common()
          _snake_case				= True

          for model_class in self.all_model_classes:
               # LevitForImageClassificationWithTeacher supports inference-only
               if (
                   model_class in get_values(_SCREAMING_SNAKE_CASE       )
                   or model_class.__name__ == "LevitForImageClassificationWithTeacher"
               ):
                    continue
               _snake_case				= model_class(_SCREAMING_SNAKE_CASE       )
               model.to(_SCREAMING_SNAKE_CASE       )
               model.train()
               _snake_case				= self._prepare_for_class(_SCREAMING_SNAKE_CASE   ,_SCREAMING_SNAKE_CASE   ,return_labels=_SCREAMING_SNAKE_CASE       )
               _snake_case				= model(**_SCREAMING_SNAKE_CASE       ).loss
               loss.backward()






     def 							_lowercase      (					self       )				->     Dict:
          _snake_case				,   _snake_case				= self.model_tester.prepare_config_and_inputs_for_common()
          if not self.model_tester.is_training:
               return

          _snake_case				= False
          _snake_case				= True

          for model_class in self.all_model_classes:
               if model_class in get_values(_SCREAMING_SNAKE_CASE       ) or not model_class.supports_gradient_checkpointing:
                    continue
               # LevitForImageClassificationWithTeacher supports inference-only
               if model_class.__name__ == "LevitForImageClassificationWithTeacher":
                    continue
               _snake_case				= model_class(_SCREAMING_SNAKE_CASE       )
               model.gradient_checkpointing_enable()
               model.to(_SCREAMING_SNAKE_CASE       )
               model.train()
               _snake_case				= self._prepare_for_class(_SCREAMING_SNAKE_CASE   ,_SCREAMING_SNAKE_CASE   ,return_labels=_SCREAMING_SNAKE_CASE       )
               _snake_case				= model(**_SCREAMING_SNAKE_CASE       ).loss
               loss.backward()






     def 							_lowercase      (					self       )				->     int:
          _snake_case				,   _snake_case				= self.model_tester.prepare_config_and_inputs_for_common()

          _snake_case				= [
              {"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(_SCREAMING_SNAKE_CASE       ),
                   ]
                   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				= problem_type["title"]
                         _snake_case				= problem_type["num_labels"]

                         _snake_case				= model_class(_SCREAMING_SNAKE_CASE       )
                         model.to(_SCREAMING_SNAKE_CASE       )
                         model.train()

                         _snake_case				= self._prepare_for_class(_SCREAMING_SNAKE_CASE   ,_SCREAMING_SNAKE_CASE   ,return_labels=_SCREAMING_SNAKE_CASE       )

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

                         _snake_case				= 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=_SCREAMING_SNAKE_CASE       ) as warning_list:
                              _snake_case				= model(**_SCREAMING_SNAKE_CASE       ).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 							_lowercase      (					self       )				->     str:
          for model_name in LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               _snake_case				= LevitModel.from_pretrained(_SCREAMING_SNAKE_CASE       )
               self.assertIsNotNone(_SCREAMING_SNAKE_CASE       )







def       __a      (  )		->					Dict:

     """simple docstring"""




     _snake_case				= Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"       )
     return image





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






     @cached_property
     def 							_lowercase      (					self       )				->     Optional[int]:
          return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]       )






     @slow
     def 							_lowercase      (					self       )				->     List[Any]:
          _snake_case				= LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]       ).to(
              _SCREAMING_SNAKE_CASE       )

          _snake_case				= self.default_image_processor
          _snake_case				= prepare_img()
          _snake_case				= image_processor(images=_SCREAMING_SNAKE_CASE   ,return_tensors="pt"       ).to(_SCREAMING_SNAKE_CASE       )

          # forward pass
          with torch.no_grad():
               _snake_case				= model(**_SCREAMING_SNAKE_CASE       )

          # verify the logits
          _snake_case				= torch.Size((1, 1_000)       )
          self.assertEqual(outputs.logits.shape   ,_SCREAMING_SNAKE_CASE       )

          _snake_case				= torch.tensor([1.0_4_4_8, -0.3_7_4_5, -1.8_3_1_7]       ).to(_SCREAMING_SNAKE_CASE       )

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








'''simple docstring'''





from typing import TYPE_CHECKING

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


UpperCamelCase_		:     Optional[Any]          =		{
    '''configuration_roc_bert''': ['''ROC_BERT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''RoCBertConfig'''],
    '''tokenization_roc_bert''': ['''RoCBertTokenizer'''],
}

try:
   if not is_tokenizers_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   pass

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   UpperCamelCase_		:     Union[str, Any]          =		[
       '''ROC_BERT_PRETRAINED_MODEL_ARCHIVE_LIST''',
       '''RoCBertForCausalLM''',
       '''RoCBertForMaskedLM''',
       '''RoCBertForMultipleChoice''',
       '''RoCBertForPreTraining''',
       '''RoCBertForQuestionAnswering''',
       '''RoCBertForSequenceClassification''',
       '''RoCBertForTokenClassification''',
       '''RoCBertLayer''',
       '''RoCBertModel''',
       '''RoCBertPreTrainedModel''',
       '''load_tf_weights_in_roc_bert''',
   ]

if TYPE_CHECKING:
   from .configuration_roc_bert import ROC_BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, RoCBertConfig
   from .tokenization_roc_bert import RoCBertTokenizer

   try:
      if not is_tokenizers_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      raise OptionalDependencyNotAvailable()

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_roc_bert import (
          ROC_BERT_PRETRAINED_MODEL_ARCHIVE_LIST,
          RoCBertForCausalLM,
          RoCBertForMaskedLM,
          RoCBertForMultipleChoice,
          RoCBertForPreTraining,
          RoCBertForQuestionAnswering,
          RoCBertForSequenceClassification,
          RoCBertForTokenClassification,
          RoCBertLayer,
          RoCBertModel,
          RoCBertPreTrainedModel,
          load_tf_weights_in_roc_bert,
      )


else:
   import sys

   UpperCamelCase_		:     int          =		_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)


