


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 __snake_case		:





		"""simple docstring"""







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




								'''simple docstring'''

								lowerCAmelCase_	:     Dict          = parent
								lowerCAmelCase_	:     List[Any]          = batch_size
								lowerCAmelCase_	:     Optional[Any]          = image_size
								lowerCAmelCase_	:     Optional[Any]          = patch_size
								lowerCAmelCase_	:     Union[str, Any]          = num_channels
								lowerCAmelCase_	:     Any          = is_training
								lowerCAmelCase_	:     List[str]          = use_labels
								lowerCAmelCase_	:     Optional[int]          = hidden_size
								lowerCAmelCase_	:     Optional[int]          = num_hidden_layers
								lowerCAmelCase_	:     Optional[Any]          = num_attention_heads
								lowerCAmelCase_	:     int          = intermediate_size
								lowerCAmelCase_	:     List[str]          = hidden_act
								lowerCAmelCase_	:     Union[str, Any]          = hidden_dropout_prob
								lowerCAmelCase_	:     Optional[Any]          = attention_probs_dropout_prob
								lowerCAmelCase_	:     Any          = type_sequence_label_size
								lowerCAmelCase_	:     Any          = initializer_range
								lowerCAmelCase_	:     List[Any]          = scope
								lowerCAmelCase_	:     Union[str, Any]          = 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
								lowerCAmelCase_	:     List[Any]          = (self.image_size // 32) ** 2
								lowerCAmelCase_	:     Optional[int]          = num_patches + 1



		def  UpperCAmelCase_							(							self    :   Dict      )      ->							Any:




								'''simple docstring'''

								lowerCAmelCase_	:     Optional[Any]          = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]      )

								lowerCAmelCase_	:     str          = None
								if self.use_labels:
														lowerCAmelCase_	:     Optional[Any]          = ids_tensor([self.batch_size]						,self.type_sequence_label_size      )

								lowerCAmelCase_	:     str          = self.get_config()

								return config, pixel_values, labels



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




								'''simple docstring'''

								lowerCAmelCase_	:     Tuple          = {
								    "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=lowerCAmelCase__						,initializer_range=self.initializer_range						,backbone_featmap_shape=self.backbone_featmap_shape						,backbone_config=lowerCAmelCase__						,)



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




								'''simple docstring'''

								lowerCAmelCase_	:     Optional[int]          = ViTHybridModel(config=lowerCAmelCase__      )
								model.to(lowerCAmelCase__      )
								model.eval()
								lowerCAmelCase_	:     Union[str, Any]          = model(lowerCAmelCase__      )
								self.parent.assertEqual(result.last_hidden_state.shape						,(self.batch_size, self.seq_length, self.hidden_size)      )



		def  UpperCAmelCase_							(							self    :   Optional[Any]						,lowerCAmelCase__    :   Dict						,lowerCAmelCase__    :   List[str]						,lowerCAmelCase__    :   int      )      ->							List[str]:




								'''simple docstring'''

								lowerCAmelCase_	:     List[Any]          = self.type_sequence_label_size
								lowerCAmelCase_	:     Any          = ViTHybridForImageClassification(lowerCAmelCase__      )
								model.to(lowerCAmelCase__      )
								model.eval()
								lowerCAmelCase_	:     Optional[int]          = model(lowerCAmelCase__						,labels=lowerCAmelCase__      )
								self.parent.assertEqual(result.logits.shape						,(self.batch_size, self.type_sequence_label_size)      )



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




								'''simple docstring'''

								lowerCAmelCase_	:     Optional[int]          = self.prepare_config_and_inputs()
								lowerCAmelCase_    ,					lowerCAmelCase_    ,					lowerCAmelCase_	:     List[Any]          = config_and_inputs
								lowerCAmelCase_	:     Any          = {"pixel_values": pixel_values}
								return config, inputs_dict






@require_torch
class __snake_case		( __lowerCamelCase  ,				__lowerCamelCase  ,				unittest.TestCase ):





		"""simple docstring"""







		UpperCamelCase_				      =   (ViTHybridModel, ViTHybridForImageClassification) if is_torch_available() else ()
		UpperCamelCase_				      =   (
		    {'feature-extraction': ViTHybridModel, 'image-classification': ViTHybridForImageClassification}
		    if is_torch_available()
		    else {}
		)
		UpperCamelCase_				      =   False
		UpperCamelCase_				      =   False
		UpperCamelCase_				      =   False



		def  UpperCAmelCase_							(							self    :   Tuple      )      ->							Dict:




								'''simple docstring'''

								lowerCAmelCase_	:     List[str]          = ViTHybridModelTester(self      )
								lowerCAmelCase_	:     Optional[int]          = ConfigTester(self						,config_class=lowerCAmelCase__						,has_text_modality=lowerCAmelCase__						,hidden_size=37      )



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




								'''simple docstring'''

								self.config_tester.run_common_tests()



		@unittest.skip(reason="ViT does not use inputs_embeds"      )
		def  UpperCAmelCase_							(							self    :   Tuple      )      ->							Any:




								'''simple docstring'''

								pass



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




								'''simple docstring'''

								lowerCAmelCase_    ,					lowerCAmelCase_	:     List[Any]          = self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
														lowerCAmelCase_	:     List[str]          = model_class(lowerCAmelCase__      )
														self.assertIsInstance(model.get_input_embeddings()						,(nn.Module)      )
														lowerCAmelCase_	:     List[str]          = model.get_output_embeddings()
														self.assertTrue(x is None or isinstance(lowerCAmelCase__						,nn.Linear      )      )



		def  UpperCAmelCase_							(							self    :   Optional[int]      )      ->							Tuple:




								'''simple docstring'''

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

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

														lowerCAmelCase_	:     Dict          = ["pixel_values"]
														self.assertListEqual(arg_names[:1]						,lowerCAmelCase__      )



		def  UpperCAmelCase_							(							self    :   str      )      ->							List[Any]:




								'''simple docstring'''

								lowerCAmelCase_	:     Optional[Any]          = self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*lowerCAmelCase__      )



		def  UpperCAmelCase_							(							self    :   List[Any]      )      ->							Optional[int]:




								'''simple docstring'''

								lowerCAmelCase_	:     int          = self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase__      )



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




								'''simple docstring'''

								lowerCAmelCase_    ,					lowerCAmelCase_	:     List[Any]          = self.model_tester.prepare_config_and_inputs_for_common()

								lowerCAmelCase_	:     List[str]          = _config_zero_init(lowerCAmelCase__      )
								for model_class in self.all_model_classes:
														lowerCAmelCase_	:     Optional[int]          = model_class(config=lowerCAmelCase__      )
														# Skip the check for the backbone
														for name, module in model.named_modules():
																				if module.__class__.__name__ == "ViTHybridPatchEmbeddings":
																										lowerCAmelCase_	:     Any          = [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    :   Optional[Any]      )      ->							Optional[Any]:




								'''simple docstring'''

								for model_name in VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
														lowerCAmelCase_	:     List[str]          = ViTHybridModel.from_pretrained(lowerCAmelCase__      )
														self.assertIsNotNone(lowerCAmelCase__      )






def   UpperCamelCase			(      ):
						lowerCAmelCase_	:     Optional[int]          = 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    :   Dict      )      ->							str:




								'''simple docstring'''

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



		@slow
		def  UpperCAmelCase_							(							self    :   Union[str, Any]      )      ->							List[Any]:




								'''simple docstring'''

								lowerCAmelCase_	:     Tuple          = ViTHybridForImageClassification.from_pretrained(VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[0]      ).to(
								    lowerCAmelCase__      )

								lowerCAmelCase_	:     Optional[Any]          = self.default_image_processor
								lowerCAmelCase_	:     Dict          = prepare_img()
								lowerCAmelCase_	:     List[Any]          = image_processor(images=lowerCAmelCase__						,return_tensors="pt"      ).to(lowerCAmelCase__      )

								# forward pass
								with torch.no_grad():
														lowerCAmelCase_	:     List[Any]          = model(**lowerCAmelCase__      )

								# verify the logits
								lowerCAmelCase_	:     Dict          = torch.Size((1, 10_00)      )
								self.assertEqual(outputs.logits.shape						,lowerCAmelCase__      )

								lowerCAmelCase_	:     Dict          = torch.tensor([-1.9_090, -0.4_993, -0.2_389]      ).to(lowerCAmelCase__      )

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



		@slow
		@require_accelerate
		def  UpperCAmelCase_							(							self    :   Union[str, Any]      )      ->							Optional[int]:




								'''simple docstring'''

								lowerCAmelCase_	:     Optional[Any]          = ViTHybridImageProcessor.from_pretrained("google/vit-hybrid-base-bit-384"      )
								lowerCAmelCase_	:     List[Any]          = ViTHybridForImageClassification.from_pretrained("google/vit-hybrid-base-bit-384"						,device_map="auto"      )

								lowerCAmelCase_	:     Dict          = prepare_img()

								lowerCAmelCase_	:     str          = image_processor(images=lowerCAmelCase__						,return_tensors="pt"      )
								lowerCAmelCase_	:     int          = model(**lowerCAmelCase__      )
								lowerCAmelCase_	:     Optional[int]          = outputs.logits
								# model predicts one of the 1000 ImageNet classes
								lowerCAmelCase_	:     Tuple          = logits.argmax(-1      ).item()

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




from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


__lowerCAmelCase					   =       {
    'configuration_deberta': ['DEBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP', 'DebertaConfig', 'DebertaOnnxConfig'],
    'tokenization_deberta': ['DebertaTokenizer'],
}

try:
							if not is_tokenizers_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							__lowerCAmelCase					   =       ['DebertaTokenizerFast']

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							__lowerCAmelCase					   =       [
							    'DEBERTA_PRETRAINED_MODEL_ARCHIVE_LIST',
							    'DebertaForMaskedLM',
							    'DebertaForQuestionAnswering',
							    'DebertaForSequenceClassification',
							    'DebertaForTokenClassification',
							    'DebertaModel',
							    'DebertaPreTrainedModel',
							]

try:
							if not is_tf_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							__lowerCAmelCase					   =       [
							    'TF_DEBERTA_PRETRAINED_MODEL_ARCHIVE_LIST',
							    'TFDebertaForMaskedLM',
							    'TFDebertaForQuestionAnswering',
							    'TFDebertaForSequenceClassification',
							    'TFDebertaForTokenClassification',
							    'TFDebertaModel',
							    'TFDebertaPreTrainedModel',
							]


if TYPE_CHECKING:
							from .configuration_deberta import DEBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, DebertaConfig, DebertaOnnxConfig
							from .tokenization_deberta import DebertaTokenizer

							try:
														if not is_tokenizers_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .tokenization_deberta_fast import DebertaTokenizerFast

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_deberta import (
														    DEBERTA_PRETRAINED_MODEL_ARCHIVE_LIST,
														    DebertaForMaskedLM,
														    DebertaForQuestionAnswering,
														    DebertaForSequenceClassification,
														    DebertaForTokenClassification,
														    DebertaModel,
														    DebertaPreTrainedModel,
														)

							try:
														if not is_tf_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_tf_deberta import (
														    TF_DEBERTA_PRETRAINED_MODEL_ARCHIVE_LIST,
														    TFDebertaForMaskedLM,
														    TFDebertaForQuestionAnswering,
														    TFDebertaForSequenceClassification,
														    TFDebertaForTokenClassification,
														    TFDebertaModel,
														    TFDebertaPreTrainedModel,
														)


else:
							import sys

							__lowerCAmelCase					   =       _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)