






'''simple docstring'''







import inspect
import unittest

from transformers import MobileViTVaConfig
from transformers.testing_utils import require_torch, require_torch_multi_gpu, 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, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
							import torch

							from transformers import MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation, MobileViTVaModel
							from transformers.models.mobilevitva.modeling_mobilevitva import (
							    MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST,
							    make_divisible,
							)


if is_vision_available():
							from PIL import Image

							from transformers import MobileViTImageProcessor




class 		UpperCamelCase__     (a      ):




		'''simple docstring'''





		def       UpperCamelCase_       (   self							):
								lowerCamelCase__								=	self.config_class(**self.inputs_dict							)
								self.parent.assertTrue(hasattr(_lowerCAmelCase ,"""width_multiplier"""							)							)




class 		UpperCamelCase__     :




		'''simple docstring'''





		def __init__(   self ,_lowerCAmelCase ,_lowerCAmelCase=13 ,_lowerCAmelCase=64 ,_lowerCAmelCase=2 ,_lowerCAmelCase=3 ,_lowerCAmelCase="swish" ,_lowerCAmelCase=3 ,_lowerCAmelCase=32 ,_lowerCAmelCase=0.1 ,_lowerCAmelCase=0.02 ,_lowerCAmelCase=True ,_lowerCAmelCase=True ,_lowerCAmelCase=10 ,_lowerCAmelCase=None ,_lowerCAmelCase=0.25 ,_lowerCAmelCase=0.0 ,_lowerCAmelCase=0.0 ,):
								lowerCamelCase__								=	parent
								lowerCamelCase__								=	batch_size
								lowerCamelCase__								=	image_size
								lowerCamelCase__								=	patch_size
								lowerCamelCase__								=	num_channels
								lowerCamelCase__								=	make_divisible(5_12 * width_multiplier ,divisor=8							)
								lowerCamelCase__								=	hidden_act
								lowerCamelCase__								=	conv_kernel_size
								lowerCamelCase__								=	output_stride
								lowerCamelCase__								=	classifier_dropout_prob
								lowerCamelCase__								=	use_labels
								lowerCamelCase__								=	is_training
								lowerCamelCase__								=	num_labels
								lowerCamelCase__								=	initializer_range
								lowerCamelCase__								=	scope
								lowerCamelCase__								=	width_multiplier
								lowerCamelCase__								=	ffn_dropout
								lowerCamelCase__								=	attn_dropout






		def       UpperCamelCase_       (   self							):
								lowerCamelCase__								=	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

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

								lowerCamelCase__								=	self.get_config()

								return config, pixel_values, labels, pixel_labels






		def       UpperCamelCase_       (   self							):
								return MobileViTVaConfig(
								    image_size=self.image_size ,patch_size=self.patch_size ,num_channels=self.num_channels ,hidden_act=self.hidden_act ,conv_kernel_size=self.conv_kernel_size ,output_stride=self.output_stride ,classifier_dropout_prob=self.classifier_dropout_prob ,initializer_range=self.initializer_range ,width_multiplier=self.width_multiplier ,ffn_dropout=self.ffn_dropout_prob ,attn_dropout=self.attn_dropout_prob ,)






		def       UpperCamelCase_       (   self ,_lowerCAmelCase ,_lowerCAmelCase ,_lowerCAmelCase ,_lowerCAmelCase							):
								lowerCamelCase__								=	MobileViTVaModel(config=_lowerCAmelCase							)
								model.to(_lowerCAmelCase							)
								model.eval()
								lowerCamelCase__								=	model(_lowerCAmelCase							)
								self.parent.assertEqual(
								    result.last_hidden_state.shape ,(
								        self.batch_size,
								        self.last_hidden_size,
								        self.image_size // self.output_stride,
								        self.image_size // self.output_stride,
								    ) ,)






		def       UpperCamelCase_       (   self ,_lowerCAmelCase ,_lowerCAmelCase ,_lowerCAmelCase ,_lowerCAmelCase							):
								lowerCamelCase__								=	self.num_labels
								lowerCamelCase__								=	MobileViTVaForImageClassification(_lowerCAmelCase							)
								model.to(_lowerCAmelCase							)
								model.eval()
								lowerCamelCase__								=	model(_lowerCAmelCase ,labels=_lowerCAmelCase							)
								self.parent.assertEqual(result.logits.shape ,(self.batch_size, self.num_labels)							)






		def       UpperCamelCase_       (   self ,_lowerCAmelCase ,_lowerCAmelCase ,_lowerCAmelCase ,_lowerCAmelCase							):
								lowerCamelCase__								=	self.num_labels
								lowerCamelCase__								=	MobileViTVaForSemanticSegmentation(_lowerCAmelCase							)
								model.to(_lowerCAmelCase							)
								model.eval()
								lowerCamelCase__								=	model(_lowerCAmelCase							)
								self.parent.assertEqual(
								    result.logits.shape ,(
								        self.batch_size,
								        self.num_labels,
								        self.image_size // self.output_stride,
								        self.image_size // self.output_stride,
								    ) ,)
								lowerCamelCase__								=	model(_lowerCAmelCase ,labels=_lowerCAmelCase							)
								self.parent.assertEqual(
								    result.logits.shape ,(
								        self.batch_size,
								        self.num_labels,
								        self.image_size // self.output_stride,
								        self.image_size // self.output_stride,
								    ) ,)






		def       UpperCamelCase_       (   self							):
								lowerCamelCase__								=	self.prepare_config_and_inputs()
								lowerCamelCase__							,      lowerCamelCase__							,      lowerCamelCase__							,      lowerCamelCase__								=	config_and_inputs
								lowerCamelCase__								=	{"""pixel_values""": pixel_values}
								return config, inputs_dict




@require_torch
class 		UpperCamelCase__     (a ,a ,unittest.TestCase      ):




		'''simple docstring'''





		_UpperCamelCase						=       (
		    (MobileViTVaModel, MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation)
		    if is_torch_available()
		    else ()
		)

		_UpperCamelCase						=       (
		    {
		        'feature-extraction': MobileViTVaModel,
		        'image-classification': MobileViTVaForImageClassification,
		        'image-segmentation': MobileViTVaForSemanticSegmentation,
		    }
		    if is_torch_available()
		    else {}
		)

		_UpperCamelCase						=       False
		_UpperCamelCase						=       False
		_UpperCamelCase						=       False
		_UpperCamelCase						=       False






		def       UpperCamelCase_       (   self							):
								lowerCamelCase__								=	MobileViTVaModelTester(self							)
								lowerCamelCase__								=	MobileViTVaConfigTester(self ,config_class=_lowerCAmelCase ,has_text_modality=_lowerCAmelCase							)






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






		@unittest.skip(reason="""MobileViTV2 does not use inputs_embeds"""							)
		def       UpperCamelCase_       (   self							):
								pass






		@unittest.skip(reason="""MobileViTV2 does not support input and output embeddings"""							)
		def       UpperCamelCase_       (   self							):
								pass






		@unittest.skip(reason="""MobileViTV2 does not output attentions"""							)
		def       UpperCamelCase_       (   self							):
								pass






		@require_torch_multi_gpu
		@unittest.skip(reason="""Got `CUDA error: misaligned address` for tests after this one being run."""							)
		def       UpperCamelCase_       (   self							):
								pass






		@unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests."""							)
		def       UpperCamelCase_       (   self							):
								pass






		def       UpperCamelCase_       (   self							):
								lowerCamelCase__							,      lowerCamelCase__								=	self.model_tester.prepare_config_and_inputs_for_common()

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

														lowerCamelCase__								=	["""pixel_values"""]
														self.assertListEqual(arg_names[:1] ,_lowerCAmelCase							)






		def       UpperCamelCase_       (   self							):
								lowerCamelCase__								=	self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*_lowerCAmelCase							)






		def       UpperCamelCase_       (   self							):
								def check_hidden_states_output(_lowerCAmelCase ,_lowerCAmelCase ,_lowerCAmelCase							):
														lowerCamelCase__								=	model_class(_lowerCAmelCase							)
														model.to(_lowerCAmelCase							)
														model.eval()

														with torch.no_grad():
																				lowerCamelCase__								=	model(**self._prepare_for_class(_lowerCAmelCase ,_lowerCAmelCase							)							)

														lowerCamelCase__								=	outputs.hidden_states

														lowerCamelCase__								=	5
														self.assertEqual(len(_lowerCAmelCase							) ,_lowerCAmelCase							)

														# MobileViTV2's feature maps are of shape (batch_size, num_channels, height, width)
														# with the width and height being successively divided by 2.
														lowerCamelCase__								=	2
														for i in range(len(_lowerCAmelCase							)							):
																				self.assertListEqual(
																				    list(hidden_states[i].shape[-2:]							) ,[self.model_tester.image_size // divisor, self.model_tester.image_size // divisor] ,)
																				divisor *= 2

														self.assertEqual(self.model_tester.output_stride ,divisor // 2							)

								lowerCamelCase__							,      lowerCamelCase__								=	self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
														lowerCamelCase__								=	True
														check_hidden_states_output(_lowerCAmelCase ,_lowerCAmelCase ,_lowerCAmelCase							)

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

														check_hidden_states_output(_lowerCAmelCase ,_lowerCAmelCase ,_lowerCAmelCase							)






		def       UpperCamelCase_       (   self							):
								lowerCamelCase__								=	self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_image_classification(*_lowerCAmelCase							)






		def       UpperCamelCase_       (   self							):
								lowerCamelCase__								=	self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_semantic_segmentation(*_lowerCAmelCase							)






		@slow
		def       UpperCamelCase_       (   self							):
								for model_name in MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
														lowerCamelCase__								=	MobileViTVaModel.from_pretrained(_lowerCAmelCase							)
														self.assertIsNotNone(_lowerCAmelCase							)



def     A__      (					):
						lowerCamelCase__								=	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 (
								    MobileViTImageProcessor.from_pretrained("""apple/mobilevitv2-1.0-imagenet1k-256"""							)
								    if is_vision_available()
								    else None
								)






		@slow
		def       UpperCamelCase_       (   self							):
								lowerCamelCase__								=	MobileViTVaForImageClassification.from_pretrained("""apple/mobilevitv2-1.0-imagenet1k-256"""							).to(
								    _lowerCAmelCase							)

								lowerCamelCase__								=	self.default_image_processor
								lowerCamelCase__								=	prepare_img()
								lowerCamelCase__								=	image_processor(images=_lowerCAmelCase ,return_tensors="""pt"""							).to(_lowerCAmelCase							)

								# forward pass
								with torch.no_grad():
														lowerCamelCase__								=	model(**_lowerCAmelCase							)

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

								lowerCamelCase__								=	torch.tensor([-1.6336E00, -7.3204E-02, -5.1883E-01]							).to(_lowerCAmelCase							)

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






		@slow
		def       UpperCamelCase_       (   self							):
								lowerCamelCase__								=	MobileViTVaForSemanticSegmentation.from_pretrained("""shehan97/mobilevitv2-1.0-voc-deeplabv3"""							)
								lowerCamelCase__								=	model.to(_lowerCAmelCase							)

								lowerCamelCase__								=	MobileViTImageProcessor.from_pretrained("""shehan97/mobilevitv2-1.0-voc-deeplabv3"""							)

								lowerCamelCase__								=	prepare_img()
								lowerCamelCase__								=	image_processor(images=_lowerCAmelCase ,return_tensors="""pt"""							).to(_lowerCAmelCase							)

								# forward pass
								with torch.no_grad():
														lowerCamelCase__								=	model(**_lowerCAmelCase							)
								lowerCamelCase__								=	outputs.logits

								# verify the logits
								lowerCamelCase__								=	torch.Size((1, 21, 32, 32)							)
								self.assertEqual(logits.shape ,_lowerCAmelCase							)

								lowerCamelCase__								=	torch.tensor(
								    [
								        [[7.0863, 7.1525, 6.8201], [6.6931, 6.8770, 6.8933], [6.2978, 7.0366, 6.9636]],
								        [[-3.7134, -3.6712, -3.6675], [-3.5825, -3.3549, -3.4777], [-3.3435, -3.3979, -3.2857]],
								        [[-2.9329, -2.8003, -2.7369], [-3.0564, -2.4780, -2.0207], [-2.6889, -1.9298, -1.7640]],
								    ] ,device=_lowerCAmelCase ,)

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






		@slow
		def       UpperCamelCase_       (   self							):
								lowerCamelCase__								=	MobileViTVaForSemanticSegmentation.from_pretrained("""shehan97/mobilevitv2-1.0-voc-deeplabv3"""							)
								lowerCamelCase__								=	model.to(_lowerCAmelCase							)

								lowerCamelCase__								=	MobileViTImageProcessor.from_pretrained("""shehan97/mobilevitv2-1.0-voc-deeplabv3"""							)

								lowerCamelCase__								=	prepare_img()
								lowerCamelCase__								=	image_processor(images=_lowerCAmelCase ,return_tensors="""pt"""							).to(_lowerCAmelCase							)

								# forward pass
								with torch.no_grad():
														lowerCamelCase__								=	model(**_lowerCAmelCase							)

								lowerCamelCase__								=	outputs.logits.detach().cpu()

								lowerCamelCase__								=	image_processor.post_process_semantic_segmentation(outputs=_lowerCAmelCase ,target_sizes=[(50, 60)]							)
								lowerCamelCase__								=	torch.Size((50, 60)							)
								self.assertEqual(segmentation[0].shape ,_lowerCAmelCase							)

								lowerCamelCase__								=	image_processor.post_process_semantic_segmentation(outputs=_lowerCAmelCase							)
								lowerCamelCase__								=	torch.Size((32, 32)							)
								self.assertEqual(segmentation[0].shape ,_lowerCAmelCase							)






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

   '''simple docstring'''




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




         """simple docstring"""

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


   def       UpperCAmelCase		(    self	:      Dict)						->					Any:




         """simple docstring"""

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

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

         lowercase__  =	self.get_config()

         return config, pixel_values, labels


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




         """simple docstring"""

         lowercase__  =	{
             '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	:      Optional[int]      ,					lowerCAmelCase	:      Any      ,					lowerCAmelCase	:      Optional[int]      ,					lowerCAmelCase	:      Union[str, Any])						->					int:




         """simple docstring"""

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


   def       UpperCAmelCase		(    self	:      Dict      ,					lowerCAmelCase	:      Union[str, Any]      ,					lowerCAmelCase	:      int      ,					lowerCAmelCase	:      List[str])						->					Tuple:




         """simple docstring"""

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



   def       UpperCAmelCase		(    self	:      str)						->					Optional[Any]:




         """simple docstring"""

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



@require_torch
class    UpperCAmelCase__(				lowerCamelCase  ,				lowerCamelCase  ,				unittest.TestCase						):

   '''simple docstring'''




   A     :	Any												=     (ViTHybridModel, ViTHybridForImageClassification) if is_torch_available() else ()
   A     :	int												=     (
       {"feature-extraction": ViTHybridModel, "image-classification": ViTHybridForImageClassification}
       if is_torch_available()
       else {}
   )
   A     :	Tuple												=     False
   A     :	Tuple												=     False
   A     :	Union[str, Any]												=     False


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




         """simple docstring"""

         lowercase__  =	ViTHybridModelTester(self)
         lowercase__  =	ConfigTester(self      ,					config_class=lowerCAmelCase      ,					has_text_modality=lowerCAmelCase      ,					hidden_size=37)


   def       UpperCAmelCase		(    self	:      Dict)						->					Any:




         """simple docstring"""

         self.config_tester.run_common_tests()


   @unittest.skip(reason='ViT does not use inputs_embeds')
   def       UpperCAmelCase		(    self	:      Dict)						->					Dict:




         """simple docstring"""

         pass


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




         """simple docstring"""

         lowercase__,						lowercase__  =	self.model_tester.prepare_config_and_inputs_for_common()

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


   def       UpperCAmelCase		(    self	:      Tuple)						->					Optional[Any]:




         """simple docstring"""

         lowercase__,						lowercase__  =	self.model_tester.prepare_config_and_inputs_for_common()

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

               lowercase__  =	['pixel_values']
               self.assertListEqual(arg_names[:1]      ,					lowerCAmelCase)


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




         """simple docstring"""

         lowercase__  =	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*lowerCAmelCase)


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




         """simple docstring"""

         lowercase__  =	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase)


   def       UpperCAmelCase		(    self	:      str)						->					Tuple:




         """simple docstring"""

         lowercase__,						lowercase__  =	self.model_tester.prepare_config_and_inputs_for_common()

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




         """simple docstring"""

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

def 	_lowerCAmelCase (    ):
      lowercase__  =	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	:      int)						->					Union[str, Any]:




         """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])						->					Optional[Any]:




         """simple docstring"""

         lowercase__  =	ViTHybridForImageClassification.from_pretrained(VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[0]).to(
             lowerCAmelCase)

         lowercase__  =	self.default_image_processor
         lowercase__  =	prepare_img()
         lowercase__  =	image_processor(images=lowerCAmelCase      ,					return_tensors='pt').to(lowerCAmelCase)

         # forward pass
         with torch.no_grad():
               lowercase__  =	model(**lowerCAmelCase)

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

         lowercase__  =	torch.tensor([-1.90_90, -0.49_93, -0.23_89]).to(lowerCAmelCase)

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



   @slow
   @require_accelerate
   def       UpperCAmelCase		(    self	:      int)						->					Dict:




         """simple docstring"""

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

         lowercase__  =	prepare_img()

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

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