





import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_video_inputs


if is_torch_available():
	import torch

if is_vision_available():
	from PIL import Image

	from transformers import VivitImageProcessor




class 	UpperCamelCase_							(  unittest.TestCase     ):


							def __init__(				self     :str				,					__A     :List[Any]				,					__A     :Optional[Any]=7				,					__A     :int=3				,					__A     :int=10				,					__A     :Dict=18				,					__A     :str=30				,					__A     :Any=400				,					__A     :Dict=True				,					__A     :Any=None				,					__A     :List[str]=True				,					__A     :Dict=[0.5, 0.5, 0.5]				,					__A     :List[str]=[0.5, 0.5, 0.5]				,					__A     :List[str]=None				,					) -> List[Any]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   size if size is not None else {"""shortest_edge""": 18}
									SCREAMING_SNAKE_CASE__								=   crop_size if crop_size is not None else {"""height""": 18, """width""": 18}

									SCREAMING_SNAKE_CASE__								=   parent
									SCREAMING_SNAKE_CASE__								=   batch_size
									SCREAMING_SNAKE_CASE__								=   num_channels
									SCREAMING_SNAKE_CASE__								=   num_frames
									SCREAMING_SNAKE_CASE__								=   image_size
									SCREAMING_SNAKE_CASE__								=   min_resolution
									SCREAMING_SNAKE_CASE__								=   max_resolution
									SCREAMING_SNAKE_CASE__								=   do_resize
									SCREAMING_SNAKE_CASE__								=   size
									SCREAMING_SNAKE_CASE__								=   do_normalize
									SCREAMING_SNAKE_CASE__								=   image_mean
									SCREAMING_SNAKE_CASE__								=   image_std
									SCREAMING_SNAKE_CASE__								=   crop_size


							def   _snake_case	(				self     :Tuple		) -> str:



									"""simple docstring"""



									return {
									    "image_mean": self.image_mean,
									    "image_std": self.image_std,
									    "do_normalize": self.do_normalize,
									    "do_resize": self.do_resize,
									    "size": self.size,
									    "crop_size": self.crop_size,
									}




@require_torch
@require_vision
class 	UpperCamelCase_							(  UpperCamelCase__					,	unittest.TestCase     ):
							lowerCamelCase_							     =       VivitImageProcessor if is_vision_available() else None


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



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   VivitImageProcessingTester(self		)


							@property
							def   _snake_case	(				self     :Optional[Any]		) -> List[Any]:



									"""simple docstring"""



									return self.image_processor_tester.prepare_image_processor_dict()


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



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   self.image_processing_class(**self.image_processor_dict		)
									self.assertTrue(hasattr(__A				,					"""image_mean"""		)		)
									self.assertTrue(hasattr(__A				,					"""image_std"""		)		)
									self.assertTrue(hasattr(__A				,					"""do_normalize"""		)		)
									self.assertTrue(hasattr(__A				,					"""do_resize"""		)		)
									self.assertTrue(hasattr(__A				,					"""do_center_crop"""		)		)
									self.assertTrue(hasattr(__A				,					"""size"""		)		)


							def   _snake_case	(				self     :Optional[Any]		) -> Dict:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   self.image_processing_class.from_dict(self.image_processor_dict		)
									self.assertEqual(image_processor.size				,					{"""shortest_edge""": 18}		)
									self.assertEqual(image_processor.crop_size				,					{"""height""": 18, """width""": 18}		)

									SCREAMING_SNAKE_CASE__								=   self.image_processing_class.from_dict(self.image_processor_dict				,					size=42				,					crop_size=84		)
									self.assertEqual(image_processor.size				,					{"""shortest_edge""": 42}		)
									self.assertEqual(image_processor.crop_size				,					{"""height""": 84, """width""": 84}		)


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



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   self.image_processing_class(**self.image_processor_dict		)
									# create random PIL videos
									SCREAMING_SNAKE_CASE__								=   prepare_video_inputs(self.image_processor_tester				,					equal_resolution=__A		)
									for video in video_inputs:
											self.assertIsInstance(__A				,					__A		)
											self.assertIsInstance(video[0]				,					Image.Image		)

									# Test not batched input
									SCREAMING_SNAKE_CASE__								=   image_processing(video_inputs[0]				,					return_tensors="""pt"""		).pixel_values
									self.assertEqual(
									    encoded_videos.shape				,					(
									        1,
									        self.image_processor_tester.num_frames,
									        self.image_processor_tester.num_channels,
									        self.image_processor_tester.crop_size["""height"""],
									        self.image_processor_tester.crop_size["""width"""],
									    )				,					)

									# Test batched
									SCREAMING_SNAKE_CASE__								=   image_processing(__A				,					return_tensors="""pt"""		).pixel_values
									self.assertEqual(
									    encoded_videos.shape				,					(
									        self.image_processor_tester.batch_size,
									        self.image_processor_tester.num_frames,
									        self.image_processor_tester.num_channels,
									        self.image_processor_tester.crop_size["""height"""],
									        self.image_processor_tester.crop_size["""width"""],
									    )				,					)


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



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   self.image_processing_class(**self.image_processor_dict		)
									# create random numpy tensors
									SCREAMING_SNAKE_CASE__								=   prepare_video_inputs(self.image_processor_tester				,					equal_resolution=__A				,					numpify=__A		)
									for video in video_inputs:
											self.assertIsInstance(__A				,					__A		)
											self.assertIsInstance(video[0]				,					np.ndarray		)

									# Test not batched input
									SCREAMING_SNAKE_CASE__								=   image_processing(video_inputs[0]				,					return_tensors="""pt"""		).pixel_values
									self.assertEqual(
									    encoded_videos.shape				,					(
									        1,
									        self.image_processor_tester.num_frames,
									        self.image_processor_tester.num_channels,
									        self.image_processor_tester.crop_size["""height"""],
									        self.image_processor_tester.crop_size["""width"""],
									    )				,					)

									# Test batched
									SCREAMING_SNAKE_CASE__								=   image_processing(__A				,					return_tensors="""pt"""		).pixel_values
									self.assertEqual(
									    encoded_videos.shape				,					(
									        self.image_processor_tester.batch_size,
									        self.image_processor_tester.num_frames,
									        self.image_processor_tester.num_channels,
									        self.image_processor_tester.crop_size["""height"""],
									        self.image_processor_tester.crop_size["""width"""],
									    )				,					)


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



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   self.image_processing_class(**self.image_processor_dict		)
									# create random PyTorch tensors
									SCREAMING_SNAKE_CASE__								=   prepare_video_inputs(self.image_processor_tester				,					equal_resolution=__A				,					torchify=__A		)
									for video in video_inputs:
											self.assertIsInstance(__A				,					__A		)
											self.assertIsInstance(video[0]				,					torch.Tensor		)

									# Test not batched input
									SCREAMING_SNAKE_CASE__								=   image_processing(video_inputs[0]				,					return_tensors="""pt"""		).pixel_values
									self.assertEqual(
									    encoded_videos.shape				,					(
									        1,
									        self.image_processor_tester.num_frames,
									        self.image_processor_tester.num_channels,
									        self.image_processor_tester.crop_size["""height"""],
									        self.image_processor_tester.crop_size["""width"""],
									    )				,					)

									# Test batched
									SCREAMING_SNAKE_CASE__								=   image_processing(__A				,					return_tensors="""pt"""		).pixel_values
									self.assertEqual(
									    encoded_videos.shape				,					(
									        self.image_processor_tester.batch_size,
									        self.image_processor_tester.num_frames,
									        self.image_processor_tester.num_channels,
									        self.image_processor_tester.crop_size["""height"""],
									        self.image_processor_tester.crop_size["""width"""],
									    )				,					)




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')
