





import inspect
import unittest

from transformers import ViTHybridConfig
from transformers.testing_utils import require_accelerate, require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

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


if is_torch_available():
   import torch
   from torch import nn

   from transformers import ViTHybridForImageClassification, ViTHybridImageProcessor, ViTHybridModel
   from transformers.models.vit_hybrid.modeling_vit_hybrid import VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
   from PIL import Image




class 			__UpperCamelCase    :





     def __init__(     self				,							_UpperCamelCase				,							_UpperCamelCase=13				,							_UpperCamelCase=64				,							_UpperCamelCase=2				,							_UpperCamelCase=3				,							_UpperCamelCase=True				,							_UpperCamelCase=True				,							_UpperCamelCase=32				,							_UpperCamelCase=5				,							_UpperCamelCase=4				,							_UpperCamelCase=37				,							_UpperCamelCase="gelu"				,							_UpperCamelCase=0.1				,							_UpperCamelCase=0.1				,							_UpperCamelCase=10				,							_UpperCamelCase=0.02				,							_UpperCamelCase=[1, 16, 4, 4]				,							_UpperCamelCase=None				,							):
        _UpperCAmelCase           =   parent
        _UpperCAmelCase           =   batch_size
        _UpperCAmelCase           =   image_size
        _UpperCAmelCase           =   patch_size
        _UpperCAmelCase           =   num_channels
        _UpperCAmelCase           =   is_training
        _UpperCAmelCase           =   use_labels
        _UpperCAmelCase           =   hidden_size
        _UpperCAmelCase           =   num_hidden_layers
        _UpperCAmelCase           =   num_attention_heads
        _UpperCAmelCase           =   intermediate_size
        _UpperCAmelCase           =   hidden_act
        _UpperCAmelCase           =   hidden_dropout_prob
        _UpperCAmelCase           =   attention_probs_dropout_prob
        _UpperCAmelCase           =   type_sequence_label_size
        _UpperCAmelCase           =   initializer_range
        _UpperCAmelCase           =   scope
        _UpperCAmelCase           =   backbone_featmap_shape

        # in ViT hybrid, the seq length equals the number of patches + 1 (we add 1 for the [CLS] token)
        # the number of patches is based on the feature map of the backbone, which by default uses an output stride
        # of 32, which means that the feature map has a spatial resolution of 1/32 of the input image size
        _UpperCAmelCase           =   (self.image_size // 32) ** 2
        _UpperCAmelCase           =   num_patches + 1





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase           =   floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)

        _UpperCAmelCase           =   None
        if self.use_labels:
           _UpperCAmelCase           =   ids_tensor([self.batch_size]				,							self.type_sequence_label_size					)

        _UpperCAmelCase           =   self.get_config()

        return config, pixel_values, labels





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase           =   {
            '''global_padding''': '''same''',
            '''layer_type''': '''bottleneck''',
            '''depths''': [3, 4, 9],
            '''out_features''': ['''stage1''', '''stage2''', '''stage3'''],
            '''embedding_dynamic_padding''': True,
            '''hidden_sizes''': [4, 8, 16, 32],
            '''num_groups''': 2,
        }

        return ViTHybridConfig(
            image_size=self.image_size				,							patch_size=self.patch_size				,							num_channels=self.num_channels				,							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				,							is_decoder=_UpperCamelCase				,							initializer_range=self.initializer_range				,							backbone_featmap_shape=self.backbone_featmap_shape				,							backbone_config=_UpperCamelCase				,							)





     def 		UpperCamelCase(     self				,							_UpperCamelCase				,							_UpperCamelCase				,							_UpperCamelCase					):
        _UpperCAmelCase           =   ViTHybridModel(config=_UpperCamelCase					)
        model.to(_UpperCamelCase					)
        model.eval()
        _UpperCAmelCase           =   model(_UpperCamelCase					)
        self.parent.assertEqual(result.last_hidden_state.shape				,							(self.batch_size, self.seq_length, self.hidden_size)					)





     def 		UpperCamelCase(     self				,							_UpperCamelCase				,							_UpperCamelCase				,							_UpperCamelCase					):
        _UpperCAmelCase           =   self.type_sequence_label_size
        _UpperCAmelCase           =   ViTHybridForImageClassification(_UpperCamelCase					)
        model.to(_UpperCamelCase					)
        model.eval()
        _UpperCAmelCase           =   model(_UpperCamelCase				,							labels=_UpperCamelCase					)
        self.parent.assertEqual(result.logits.shape				,							(self.batch_size, self.type_sequence_label_size)					)





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase           =   self.prepare_config_and_inputs()
        _UpperCAmelCase       ,      _UpperCAmelCase       ,      _UpperCAmelCase           =   config_and_inputs
        _UpperCAmelCase           =   {'''pixel_values''': pixel_values}
        return config, inputs_dict




@require_torch
class 			__UpperCamelCase    (							A__	, A__	, unittest.TestCase    ):
     __A	:  Tuple							  =   (ViTHybridModel, ViTHybridForImageClassification) if is_torch_available() else ()
     __A	:  Tuple							  =   (
         {"""feature-extraction""": ViTHybridModel, """image-classification""": ViTHybridForImageClassification}
         if is_torch_available()
         else {}
     )
     __A	:  Optional[Any]							  =   False
     __A	:  Optional[int]							  =   False
     __A	:  int							  =   False





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase           =   ViTHybridModelTester(self					)
        _UpperCAmelCase           =   ConfigTester(self				,							config_class=_UpperCamelCase				,							has_text_modality=_UpperCamelCase				,							hidden_size=37					)





     def 		UpperCamelCase(     self					):
        self.config_tester.run_common_tests()





     @unittest.skip(reason='''ViT does not use inputs_embeds'''					)
     def 		UpperCamelCase(     self					):
        pass





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase       ,      _UpperCAmelCase           =   self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
           _UpperCAmelCase           =   model_class(_UpperCamelCase					)
           self.assertIsInstance(model.get_input_embeddings()				,							(nn.Module)					)
           _UpperCAmelCase           =   model.get_output_embeddings()
           self.assertTrue(x is None or isinstance(_UpperCamelCase				,							nn.Linear					)					)





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase       ,      _UpperCAmelCase           =   self.model_tester.prepare_config_and_inputs_for_common()

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

           _UpperCAmelCase           =   ['''pixel_values''']
           self.assertListEqual(arg_names[:1]				,							_UpperCamelCase					)





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase           =   self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*_UpperCamelCase					)





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase           =   self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_image_classification(*_UpperCamelCase					)





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase       ,      _UpperCAmelCase           =   self.model_tester.prepare_config_and_inputs_for_common()

        _UpperCAmelCase           =   _config_zero_init(_UpperCamelCase					)
        for model_class in self.all_model_classes:
           _UpperCAmelCase           =   model_class(config=_UpperCamelCase					)
           # Skip the check for the backbone
           for name, module in model.named_modules():
              if module.__class__.__name__ == "ViTHybridPatchEmbeddings":
                 _UpperCAmelCase           =   [f'''{name}.{key}''' for key in module.state_dict().keys()]
                 break

           for name, param in model.named_parameters():
              if param.requires_grad:
                 if name in backbone_params:
                    continue
                 self.assertIn(
                     ((param.data.mean() * 1e9).round() / 1e9).item()				,							[0.0, 1.0]				,							msg=f'''Parameter {name} of model {model_class} seems not properly initialized'''				,							)





     @slow
     def 		UpperCamelCase(     self					):
        for model_name in VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           _UpperCAmelCase           =   ViTHybridModel.from_pretrained(_UpperCamelCase					)
           self.assertIsNotNone(_UpperCamelCase					)




def      A__       (    )  ->  Optional[Any]:






   """simple docstring"""







   _UpperCAmelCase           =   Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''						)
   return image




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





     @cached_property
     def 		UpperCamelCase(     self					):
        return (
            ViTHybridImageProcessor.from_pretrained(VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[0]					)
            if is_vision_available()
            else None
        )





     @slow
     def 		UpperCamelCase(     self					):
        _UpperCAmelCase           =   ViTHybridForImageClassification.from_pretrained(VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[0]					).to(
            _UpperCamelCase					)

        _UpperCAmelCase           =   self.default_image_processor
        _UpperCAmelCase           =   prepare_img()
        _UpperCAmelCase           =   image_processor(images=_UpperCamelCase				,							return_tensors='''pt'''					).to(_UpperCamelCase					)

        # forward pass
        with torch.no_grad():
           _UpperCAmelCase           =   model(**_UpperCamelCase					)

        # verify the logits
        _UpperCAmelCase           =   torch.Size((1, 1000)					)
        self.assertEqual(outputs.logits.shape				,							_UpperCamelCase					)

        _UpperCAmelCase           =   torch.tensor([-1.9090, -0.4993, -0.2389]					).to(_UpperCamelCase					)

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





     @slow
     @require_accelerate
     def 		UpperCamelCase(     self					):
        _UpperCAmelCase           =   ViTHybridImageProcessor.from_pretrained('''google/vit-hybrid-base-bit-384'''					)
        _UpperCAmelCase           =   ViTHybridForImageClassification.from_pretrained('''google/vit-hybrid-base-bit-384'''				,							device_map='''auto'''					)

        _UpperCAmelCase           =   prepare_img()

        _UpperCAmelCase           =   image_processor(images=_UpperCamelCase				,							return_tensors='''pt'''					)
        _UpperCAmelCase           =   model(**_UpperCamelCase					)
        _UpperCAmelCase           =   outputs.logits
        # model predicts one of the 1000 ImageNet classes
        _UpperCAmelCase           =   logits.argmax(-1					).item()

        self.assertTrue(model.config.idalabel[predicted_class_idx]				,							'''tabby, tabby cat'''					)






import baseaa
def      A__       (    SCREAMING_SNAKE_CASE_   :      str						)  ->  bytes:






   """simple docstring"""







   return baseaa.baaencode(string.encode('''utf-8'''						)						)
def      A__       (    SCREAMING_SNAKE_CASE_   :      bytes						)  ->  str:






   """simple docstring"""







   return baseaa.baadecode(SCREAMING_SNAKE_CASE_						).decode('''utf-8'''						)


if __name__ == "__main__":
   UpperCAmelCase_           =	"Hello World!"
   UpperCAmelCase_           =	baseaa_encode(test)
   print(encoded)

   UpperCAmelCase_           =	baseaa_decode(encoded)
   print(decoded)