



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   __lowerCAmelCase  :
					"""simple docstring"""






					def __init__(  self       :							List[Any]					,       _snake_case       :							Dict					,       _snake_case       :							Union[str, Any]=13					,       _snake_case       :							Tuple=64					,       _snake_case       :							Any=2					,       _snake_case       :							Optional[Any]=3					,       _snake_case       :							Any=True					,       _snake_case       :							Dict=True					,       _snake_case       :							Optional[int]=32					,       _snake_case       :							List[str]=5					,       _snake_case       :							Union[str, Any]=4					,       _snake_case       :							str=37					,       _snake_case       :							str="gelu"					,       _snake_case       :							Dict=0.1					,       _snake_case       :							Union[str, Any]=0.1					,       _snake_case       :							Union[str, Any]=10					,       _snake_case       :							Optional[int]=0.02					,       _snake_case       :							Optional[Any]=[1, 16, 4, 4]					,       _snake_case       :							Optional[Any]=None					,       ):






								"""simple docstring"""


								A__	  =     parent
								A__	  =     batch_size
								A__	  =     image_size
								A__	  =     patch_size
								A__	  =     num_channels
								A__	  =     is_training
								A__	  =     use_labels
								A__	  =     hidden_size
								A__	  =     num_hidden_layers
								A__	  =     num_attention_heads
								A__	  =     intermediate_size
								A__	  =     hidden_act
								A__	  =     hidden_dropout_prob
								A__	  =     attention_probs_dropout_prob
								A__	  =     type_sequence_label_size
								A__	  =     initializer_range
								A__	  =     scope
								A__	  =     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
								A__	  =     (self.image_size // 32) ** 2
								A__	  =     num_patches + 1



					def      _a				(  self       :							Optional[Any]       ):






								"""simple docstring"""


								A__	  =     floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]       )

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

								A__	  =     self.get_config()

								return config, pixel_values, labels



					def      _a				(  self       :							Any       ):






								"""simple docstring"""


								A__	  =     {
								    '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=_snake_case					,       initializer_range=self.initializer_range					,       backbone_featmap_shape=self.backbone_featmap_shape					,       backbone_config=_snake_case					,       )



					def      _a				(  self       :							Union[str, Any]					,       _snake_case       :							int					,       _snake_case       :							Optional[int]					,       _snake_case       :							int       ):






								"""simple docstring"""


								A__	  =     ViTHybridModel(config=_snake_case       )
								model.to(_snake_case       )
								model.eval()
								A__	  =     model(_snake_case       )
								self.parent.assertEqual(result.last_hidden_state.shape					,       (self.batch_size, self.seq_length, self.hidden_size)       )



					def      _a				(  self       :							int					,       _snake_case       :							Dict					,       _snake_case       :							Dict					,       _snake_case       :							Optional[Any]       ):






								"""simple docstring"""


								A__	  =     self.type_sequence_label_size
								A__	  =     ViTHybridForImageClassification(_snake_case       )
								model.to(_snake_case       )
								model.eval()
								A__	  =     model(_snake_case					,       labels=_snake_case       )
								self.parent.assertEqual(result.logits.shape					,       (self.batch_size, self.type_sequence_label_size)       )



					def      _a				(  self       :							Any       ):






								"""simple docstring"""


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







@require_torch
class   __lowerCAmelCase  (		UpperCAmelCase_				,  UpperCAmelCase_				,  unittest.TestCase   ):
					"""simple docstring"""






					A__					:		Any      							=     (ViTHybridModel, ViTHybridForImageClassification) if is_torch_available() else ()
					A__					:		str      							=     (
					    {"feature-extraction": ViTHybridModel, "image-classification": ViTHybridForImageClassification}
					    if is_torch_available()
					    else {}
					)
					A__					:		int      							=     False
					A__					:		Dict      							=     False
					A__					:		Tuple      							=     False



					def      _a				(  self       :							List[str]       ):






								"""simple docstring"""


								A__	  =     ViTHybridModelTester(self       )
								A__	  =     ConfigTester(self					,       config_class=_snake_case					,       has_text_modality=_snake_case					,       hidden_size=37       )



					def      _a				(  self       :							int       ):






								"""simple docstring"""


								self.config_tester.run_common_tests()



					@unittest.skip(reason='ViT does not use inputs_embeds'       )
					def      _a				(  self       :							Optional[int]       ):






								"""simple docstring"""


								pass



					def      _a				(  self       :							int       ):






								"""simple docstring"""


								A__  ,			A__	  =     self.model_tester.prepare_config_and_inputs_for_common()

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



					def      _a				(  self       :							Dict       ):






								"""simple docstring"""


								A__  ,			A__	  =     self.model_tester.prepare_config_and_inputs_for_common()

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

											A__	  =     ['pixel_values']
											self.assertListEqual(arg_names[:1]					,       _snake_case       )



					def      _a				(  self       :							List[str]       ):






								"""simple docstring"""


								A__	  =     self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*_snake_case       )



					def      _a				(  self       :							List[Any]       ):






								"""simple docstring"""


								A__	  =     self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_image_classification(*_snake_case       )



					def      _a				(  self       :							Optional[Any]       ):






								"""simple docstring"""


								A__  ,			A__	  =     self.model_tester.prepare_config_and_inputs_for_common()

								A__	  =     _config_zero_init(_snake_case       )
								for model_class in self.all_model_classes:
											A__	  =     model_class(config=_snake_case       )
											# Skip the check for the backbone
											for name, module in model.named_modules():
														if module.__class__.__name__ == "ViTHybridPatchEmbeddings":
																	A__	  =     [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      _a				(  self       :							Any       ):






								"""simple docstring"""


								for model_name in VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											A__	  =     ViTHybridModel.from_pretrained(_snake_case       )
											self.assertIsNotNone(_snake_case       )







def A    (							)    ->   Optional[Any]:
			A__	  =     Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'       )
			return image






@require_torch
@require_vision
class   __lowerCAmelCase  (		unittest.TestCase   ):
					"""simple docstring"""






					@cached_property
					def      _a				(  self       :							int       ):






								"""simple docstring"""


								return (
								    ViTHybridImageProcessor.from_pretrained(VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[0]       )
								    if is_vision_available()
								    else None
								)



					@slow
					def      _a				(  self       :							Any       ):






								"""simple docstring"""


								A__	  =     ViTHybridForImageClassification.from_pretrained(VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[0]       ).to(
								    _snake_case       )

								A__	  =     self.default_image_processor
								A__	  =     prepare_img()
								A__	  =     image_processor(images=_snake_case					,       return_tensors='pt'       ).to(_snake_case       )

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

								# verify the logits
								A__	  =     torch.Size((1, 10_00)       )
								self.assertEqual(outputs.logits.shape					,       _snake_case       )

								A__	  =     torch.tensor([-1.9090, -0.4993, -0.2389]       ).to(_snake_case       )

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



					@slow
					@require_accelerate
					def      _a				(  self       :							str       ):






								"""simple docstring"""


								A__	  =     ViTHybridImageProcessor.from_pretrained('google/vit-hybrid-base-bit-384'       )
								A__	  =     ViTHybridForImageClassification.from_pretrained('google/vit-hybrid-base-bit-384'					,       device_map='auto'       )

								A__	  =     prepare_img()

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

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











'''simple docstring'''


def 						__a(SCREAMING_SNAKE_CASE_	:       int		,							SCREAMING_SNAKE_CASE_	:       int     ):



    '''simple docstring'''





    return numa ^ numa < 0


if __name__ == "__main__":
       import doctest

       doctest.testmod()


