






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   :				Optional[Any]							,					_lowerCAmelCase   :				int							,					_lowerCAmelCase   :				str=13							,					_lowerCAmelCase   :				List[Any]=64							,					_lowerCAmelCase   :				int=2							,					_lowerCAmelCase   :				Any=3							,					_lowerCAmelCase   :				Tuple=True							,					_lowerCAmelCase   :				Tuple=True							,					_lowerCAmelCase   :				Optional[Any]=32							,					_lowerCAmelCase   :				int=5							,					_lowerCAmelCase   :				List[Any]=4							,					_lowerCAmelCase   :				int=37							,					_lowerCAmelCase   :				Any="gelu"							,					_lowerCAmelCase   :				Any=0.1							,					_lowerCAmelCase   :				Optional[Any]=0.1							,					_lowerCAmelCase   :				List[Any]=10							,					_lowerCAmelCase   :				Union[str, Any]=0.02							,					_lowerCAmelCase   :				Tuple=[1, 16, 4, 4]							,					_lowerCAmelCase   :				str=None							,					)		->			str:
		"""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 			_a (	self   :				int      )		->			List[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 			_a (	self   :				str      )		->			List[str]:
		"""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 			_a (	self   :				Optional[Any]							,					_lowerCAmelCase   :				List[Any]							,					_lowerCAmelCase   :				Union[str, Any]							,					_lowerCAmelCase   :				Union[str, Any]      )		->			List[str]:
		"""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 			_a (	self   :				int							,					_lowerCAmelCase   :				Tuple							,					_lowerCAmelCase   :				Optional[int]							,					_lowerCAmelCase   :				Optional[Any]      )		->			Any:
		"""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 			_a (	self   :				Optional[int]      )		->			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 ):
	__snake_case						:Union[str, Any] =							(ViTHybridModel, ViTHybridForImageClassification) if is_torch_available() else ()
	__snake_case						:int =							(
	    {'feature-extraction': ViTHybridModel, 'image-classification': ViTHybridForImageClassification}
	    if is_torch_available()
	    else {}
	)
	__snake_case						:Optional[Any] =							False
	__snake_case						:Union[str, Any] =							False
	__snake_case						:List[Any] =							False







	def 			_a (	self   :				Optional[int]      )		->			str:
		"""simple docstring"""







		__lowercase   							=	ViTHybridModelTester(self      )
		__lowercase   							=	ConfigTester(self							,					config_class=_lowerCAmelCase							,					has_text_modality=_lowerCAmelCase							,					hidden_size=37      )







	def 			_a (	self   :				int      )		->			Dict:
		"""simple docstring"""







		self.config_tester.run_common_tests()







	@unittest.skip(reason="""ViT does not use inputs_embeds"""      )
	def 			_a (	self   :				int      )		->			Optional[Any]:
		"""simple docstring"""







		pass







	def 			_a (	self   :				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 			_a (	self   :				Dict      )		->			List[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 			_a (	self   :				List[Any]      )		->			List[str]:
		"""simple docstring"""







		__lowercase   							=	self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_model(*_lowerCAmelCase      )







	def 			_a (	self   :				Tuple      )		->			int:
		"""simple docstring"""







		__lowercase   							=	self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_for_image_classification(*_lowerCAmelCase      )







	def 			_a (	self   :				Dict      )		->			Optional[Any]:
		"""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 			_a (	self   :				Optional[Any]      )		->			Dict:
		"""simple docstring"""







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





def 					snake_case	(  ):




	'''simple docstring'''







	__lowercase   							=	Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""       )
	return image




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







	@cached_property
	def 			_a (	self   :				Optional[int]      )		->			str:
		"""simple docstring"""







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







	@slow
	def 			_a (	self   :				List[Any]      )		->			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, 1000)      )
		self.assertEqual(outputs.logits.shape							,					_lowerCAmelCase      )

		__lowercase   							=	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 			_a (	self   :				Optional[Any]      )		->			str:
		"""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"""      )








import unittest

from huggingface_hub import hf_hub_download

from transformers import MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING, VideoMAEFeatureExtractor
from transformers.pipelines import VideoClassificationPipeline, pipeline
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_decord,
    require_tf,
    require_torch,
    require_torch_or_tf,
    require_vision,
)

from .test_pipelines_common import ANY




@is_pipeline_test
@require_torch_or_tf
@require_vision
@require_decord
class        SCREAMING_SNAKE_CASE__					(		unittest.TestCase ):
 __SCREAMING_SNAKE_CASE							=      MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING



 def 							UpperCamelCase     (				self,__lowerCamelCase,__lowerCamelCase,__lowerCamelCase					):
        A__		   =		hf_hub_download(
            repo_id='''nateraw/video-demo''',filename='''archery.mp4''',repo_type='''dataset'''					)
        A__		   =		VideoClassificationPipeline(model=__lowerCamelCase,image_processor=__lowerCamelCase,top_k=2					)
        A__		   =		[
            example_video_filepath,
            '''https://huggingface.co/datasets/nateraw/video-demo/resolve/main/archery.mp4''',
        ]
        return video_classifier, examples



 def 							UpperCamelCase     (				self,__lowerCamelCase,__lowerCamelCase					):
        for example in examples:
               A__		   =		video_classifier(__lowerCamelCase					)

               self.assertEqual(
                   __lowerCamelCase,[
                       {'''score''': ANY(__lowerCamelCase					), '''label''': ANY(__lowerCamelCase					)},
                       {'''score''': ANY(__lowerCamelCase					), '''label''': ANY(__lowerCamelCase					)},
                   ],)



 @require_torch
 def 							UpperCamelCase     (				self					):
        A__		   =		'''hf-internal-testing/tiny-random-VideoMAEForVideoClassification'''
        A__		   =		VideoMAEFeatureExtractor(
            size={'''shortest_edge''': 10},crop_size={'''height''': 10, '''width''': 10}					)
        A__		   =		pipeline(
            '''video-classification''',model=__lowerCamelCase,feature_extractor=__lowerCamelCase,frame_sampling_rate=4					)

        A__		   =		hf_hub_download(repo_id='''nateraw/video-demo''',filename='''archery.mp4''',repo_type='''dataset'''					)
        A__		   =		video_classifier(__lowerCamelCase,top_k=2					)
        self.assertEqual(
            nested_simplify(__lowerCamelCase,decimals=4					),[{'''score''': 0.5199, '''label''': '''LABEL_0'''}, {'''score''': 0.4801, '''label''': '''LABEL_1'''}],)

        A__		   =		video_classifier(
            [
                video_file_path,
                video_file_path,
            ],top_k=2,)
        self.assertEqual(
            nested_simplify(__lowerCamelCase,decimals=4					),[
                [{'''score''': 0.5199, '''label''': '''LABEL_0'''}, {'''score''': 0.4801, '''label''': '''LABEL_1'''}],
                [{'''score''': 0.5199, '''label''': '''LABEL_0'''}, {'''score''': 0.4801, '''label''': '''LABEL_1'''}],
            ],)




 @require_tf
 def 							UpperCamelCase     (				self					):
        pass





