


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__     ):


   '''simple docstring'''







   def 		UpperCamelCase  (     self		):
        lowercase_       :Optional[int]     =       self.config_class(**self.inputs_dict		)
        self.parent.assertTrue(hasattr(lowercase_   ,							'''hidden_sizes'''		)		)
        self.parent.assertTrue(hasattr(lowercase_   ,							'''num_attention_heads'''		)		)






class      UpperCamelCase					:


   '''simple docstring'''







   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   ,							):
        lowercase_       :Dict     =       parent
        lowercase_       :Optional[Any]     =       batch_size
        lowercase_       :Dict     =       image_size
        lowercase_       :int     =       num_channels
        lowercase_       :List[str]     =       kernel_size
        lowercase_       :List[str]     =       stride
        lowercase_       :Optional[int]     =       padding
        lowercase_       :int     =       hidden_sizes
        lowercase_       :Tuple     =       num_attention_heads
        lowercase_       :List[str]     =       depths
        lowercase_       :int     =       key_dim
        lowercase_       :Tuple     =       drop_path_rate
        lowercase_       :str     =       patch_size
        lowercase_       :List[str]     =       attention_ratio
        lowercase_       :Optional[int]     =       mlp_ratio
        lowercase_       :Tuple     =       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_       :int     =       use_labels
        lowercase_       :str     =       num_labels
        lowercase_       :List[Any]     =       initializer_range
   def 		UpperCamelCase  (     self		):
        lowercase_       :List[str]     =       floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]		)

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

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




   def 		UpperCamelCase  (     self		):
        lowercase_       :Optional[int]     =       self.prepare_config_and_inputs()
        lowercase_    ,      lowercase_    ,      lowercase_       :List[str]     =       config_and_inputs
        lowercase_       :Dict     =       {'''pixel_values''': pixel_values}
        return config, inputs_dict






@require_torch
class      UpperCamelCase					(		lowercase__						,      lowercase__						,      unittest.TestCase     ):


   '''simple docstring'''







   lowercase					:	List[str]									=(
       (LevitModel, LevitForImageClassification, LevitForImageClassificationWithTeacher)
       if is_torch_available()
       else ()
   )
   lowercase					:	int									=(
       {
           """feature-extraction""": LevitModel,
           """image-classification""": (LevitForImageClassification, LevitForImageClassificationWithTeacher),
       }
       if is_torch_available()
       else {}
   )

   lowercase					:	Any									=False
   lowercase					:	Tuple									=False
   lowercase					:	Any									=False
   lowercase					:	Optional[int]									=False
   lowercase					:	Dict									=False
   def 		UpperCamelCase  (     self		):
        lowercase_       :Dict     =       LevitModelTester(self		)
        lowercase_       :Optional[Any]     =       ConfigTester(self   ,							config_class=lowercase_   ,							has_text_modality=lowercase_   ,							hidden_size=37		)
   def 		UpperCamelCase  (     self		):
        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		):
        return
   @unittest.skip(reason='''Levit does not use inputs_embeds'''		)
   def 		UpperCamelCase  (     self		):
        pass
   @unittest.skip(reason='''Levit does not support input and output embeddings'''		)
   def 		UpperCamelCase  (     self		):
        pass
   @unittest.skip(reason='''Levit does not output attentions'''		)
   def 		UpperCamelCase  (     self		):
        pass
   def 		UpperCamelCase  (     self		):
        lowercase_    ,      lowercase_       :Union[str, Any]     =       self.model_tester.prepare_config_and_inputs_for_common()

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

             lowercase_       :int     =       ['''pixel_values''']
             self.assertListEqual(arg_names[:1]   ,							lowercase_		)
   def 		UpperCamelCase  (     self		):







        def check_hidden_states_output(UpperCamelCase_   ,							UpperCamelCase_   ,							UpperCamelCase_		):
             lowercase_       :Optional[int]     =       model_class(lowercase_		)
             model.to(lowercase_		)
             model.eval()

             with torch.no_grad():
                  lowercase_       :int     =       model(**self._prepare_for_class(lowercase_   ,							lowercase_		)		)

             lowercase_       :Any     =       outputs.hidden_states

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

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

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

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

             check_hidden_states_output(lowercase_   ,							lowercase_   ,							lowercase_		)
   @unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.'''		)
   def 		UpperCamelCase  (     self		):
        pass
   def 		UpperCamelCase  (     self   ,							UpperCamelCase_   ,							UpperCamelCase_   ,							UpperCamelCase_=False		):
        lowercase_       :Optional[Any]     =       super()._prepare_for_class(lowercase_   ,							lowercase_   ,							return_labels=lowercase_		)

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

        return inputs_dict
   def 		UpperCamelCase  (     self		):
        lowercase_       :Dict     =       self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*lowercase_		)
   def 		UpperCamelCase  (     self		):
        lowercase_       :str     =       self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_image_classification(*lowercase_		)
   def 		UpperCamelCase  (     self		):







        if not self.model_tester.is_training:
             return

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

        for model_class in self.all_model_classes:
             # LevitForImageClassificationWithTeacher supports inference-only
             if (
                 model_class in get_values(lowercase_		)
                 or model_class.__name__ == "LevitForImageClassificationWithTeacher"
             ):
                  continue
             lowercase_       :Dict     =       model_class(lowercase_		)
             model.to(lowercase_		)
             model.train()
             lowercase_       :Any     =       self._prepare_for_class(lowercase_   ,							lowercase_   ,							return_labels=lowercase_		)
             lowercase_       :Dict     =       model(**lowercase_		).loss
             loss.backward()
   def 		UpperCamelCase  (     self		):
        lowercase_    ,      lowercase_       :List[str]     =       self.model_tester.prepare_config_and_inputs_for_common()
        if not self.model_tester.is_training:
             return

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

        for model_class in self.all_model_classes:
             if model_class in get_values(lowercase_		) or not model_class.supports_gradient_checkpointing:
                  continue
             # LevitForImageClassificationWithTeacher supports inference-only
             if model_class.__name__ == "LevitForImageClassificationWithTeacher":
                  continue
             lowercase_       :int     =       model_class(lowercase_		)
             model.gradient_checkpointing_enable()
             model.to(lowercase_		)
             model.train()
             lowercase_       :List[str]     =       self._prepare_for_class(lowercase_   ,							lowercase_   ,							return_labels=lowercase_		)
             lowercase_       :Dict     =       model(**lowercase_		).loss
             loss.backward()
   def 		UpperCamelCase  (     self		):
        lowercase_    ,      lowercase_       :int     =       self.model_tester.prepare_config_and_inputs_for_common()

        lowercase_       :Union[str, Any]     =       [
            {'''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(lowercase_		),
                 ]
                 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_       :Tuple     =       problem_type['''title''']
                       lowercase_       :int     =       problem_type['''num_labels''']

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

                       lowercase_       :str     =       self._prepare_for_class(lowercase_   ,							lowercase_   ,							return_labels=lowercase_		)

                       if problem_type["num_labels"] > 1:
                            lowercase_       :int     =       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=lowercase_		) as warning_list:
                            lowercase_       :List[Any]     =       model(**lowercase_		).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		):







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




def     UpperCamelCase    (      )					->							List[str]:
     '''simple docstring'''





     lowercase_       :Optional[int]     =       Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''		)
     return image






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


   '''simple docstring'''







   @cached_property
   def 		UpperCamelCase  (     self		):
        return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]		)




   @slow
   def 		UpperCamelCase  (     self		):
        lowercase_       :Optional[int]     =       LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]		).to(
            lowercase_		)

        lowercase_       :str     =       self.default_image_processor
        lowercase_       :Tuple     =       prepare_img()
        lowercase_       :Any     =       image_processor(images=lowercase_   ,							return_tensors='''pt'''		).to(lowercase_		)

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

        # verify the logits
        lowercase_       :List[Any]     =       torch.Size((1, 1000)		)
        self.assertEqual(outputs.logits.shape   ,							lowercase_		)

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

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





import argparse

import torch

from transformers import OpenAIGPTConfig, OpenAIGPTModel, load_tf_weights_in_openai_gpt
from transformers.utils import CONFIG_NAME, WEIGHTS_NAME, logging


logging.set_verbosity_info()




def     UpperCamelCase    (      _a       ,		_a       ,		_a		)					->							List[str]:
     '''simple docstring'''





     if openai_config_file == "":
          lowercase_       :str     =       OpenAIGPTConfig()
     else:
          lowercase_       :int     =       OpenAIGPTConfig.from_json_file(_a		)
     lowercase_       :int     =       OpenAIGPTModel(_a		)

     # Load weights from numpy
     load_tf_weights_in_openai_gpt(_a       ,		_a       ,		_a		)

     # Save pytorch-model
     lowercase_       :Optional[int]     =       pytorch_dump_folder_path + '''/''' + WEIGHTS_NAME
     lowercase_       :List[str]     =       pytorch_dump_folder_path + '''/''' + CONFIG_NAME
     print(f"Save PyTorch model to {pytorch_weights_dump_path}"		)
     torch.save(model.state_dict()       ,		_a		)
     print(f"Save configuration file to {pytorch_config_dump_path}"		)
     with open(_a       ,		'''w'''       ,		encoding='''utf-8'''		) as f:
          f.write(config.to_json_string()		)


if __name__ == "__main__":
   SCREAMING_SNAKE_CASE       :		List[str]         =				argparse.ArgumentParser()
   # Required parameters
   parser.add_argument(
       "--openai_checkpoint_folder_path",
       default=None,
       type=str,
       required=True,
       help="Path to the TensorFlow checkpoint path.",
   )
   parser.add_argument(
       "--pytorch_dump_folder_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
   )
   parser.add_argument(
       "--openai_config_file",
       default="",
       type=str,
       help=(
           "An optional config json file corresponding to the pre-trained OpenAI model. \n"
           "This specifies the model architecture."
       ),
   )
   SCREAMING_SNAKE_CASE       :		Optional[Any]         =				parser.parse_args()
   convert_openai_checkpoint_to_pytorch(
       args.openai_checkpoint_folder_path, args.openai_config_file, args.pytorch_dump_folder_path
   )

