


import unittest

from transformers import AutoTokenizer, NystromformerConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
	import torch

	from transformers import (
	    NystromformerForMaskedLM,
	    NystromformerForMultipleChoice,
	    NystromformerForQuestionAnswering,
	    NystromformerForSequenceClassification,
	    NystromformerForTokenClassification,
	    NystromformerModel,
	)
	from transformers.models.nystromformer.modeling_nystromformer import NYSTROMFORMER_PRETRAINED_MODEL_ARCHIVE_LIST






class     UpperCamelCase:


					def __init__(						self	:		Tuple     ,    SCREAMING_SNAKE_CASE	:		Optional[int]     ,    SCREAMING_SNAKE_CASE	:		Any=1_3     ,    SCREAMING_SNAKE_CASE	:		Optional[int]=7     ,    SCREAMING_SNAKE_CASE	:		Dict=True     ,    SCREAMING_SNAKE_CASE	:		int=True     ,    SCREAMING_SNAKE_CASE	:		str=True     ,    SCREAMING_SNAKE_CASE	:		Tuple=True     ,    SCREAMING_SNAKE_CASE	:		Dict=9_9     ,    SCREAMING_SNAKE_CASE	:		List[str]=3_2     ,    SCREAMING_SNAKE_CASE	:		Optional[Any]=5     ,    SCREAMING_SNAKE_CASE	:		List[str]=4     ,    SCREAMING_SNAKE_CASE	:		Optional[Any]=3_7     ,    SCREAMING_SNAKE_CASE	:		List[Any]="gelu"     ,    SCREAMING_SNAKE_CASE	:		List[Any]=0.1     ,    SCREAMING_SNAKE_CASE	:		int=0.1     ,    SCREAMING_SNAKE_CASE	:		Dict=5_1_2     ,    SCREAMING_SNAKE_CASE	:		Optional[Any]=1_6     ,    SCREAMING_SNAKE_CASE	:		List[str]=2     ,    SCREAMING_SNAKE_CASE	:		List[str]=0.02     ,    SCREAMING_SNAKE_CASE	:		Optional[Any]=3     ,    SCREAMING_SNAKE_CASE	:		int=4     ,    SCREAMING_SNAKE_CASE	:		List[str]=None     ,    )			->	Optional[Any]:




											'''simple docstring'''

											__snake_case				=		parent
											__snake_case				=		batch_size
											__snake_case				=		seq_length
											__snake_case				=		is_training
											__snake_case				=		use_input_mask
											__snake_case				=		use_token_type_ids
											__snake_case				=		use_labels
											__snake_case				=		vocab_size
											__snake_case				=		hidden_size
											__snake_case				=		num_hidden_layers
											__snake_case				=		num_attention_heads
											__snake_case				=		intermediate_size
											__snake_case				=		hidden_act
											__snake_case				=		hidden_dropout_prob
											__snake_case				=		attention_probs_dropout_prob
											__snake_case				=		max_position_embeddings
											__snake_case				=		type_vocab_size
											__snake_case				=		type_sequence_label_size
											__snake_case				=		initializer_range
											__snake_case				=		num_labels
											__snake_case				=		num_choices
											__snake_case				=		scope


					def 							SCREAMING_SNAKE_CASE_  (						self	:		List[Any]						)			->	List[Any]:




											'''simple docstring'''

											__snake_case				=		ids_tensor([self.batch_size, self.seq_length]     ,    self.vocab_size						)

											__snake_case				=		None
											if self.use_input_mask:
																	__snake_case				=		random_attention_mask([self.batch_size, self.seq_length]						)

											__snake_case				=		None
											if self.use_token_type_ids:
																	__snake_case				=		ids_tensor([self.batch_size, self.seq_length]     ,    self.type_vocab_size						)

											__snake_case				=		None
											__snake_case				=		None
											__snake_case				=		None
											if self.use_labels:
																	__snake_case				=		ids_tensor([self.batch_size]     ,    self.type_sequence_label_size						)
																	__snake_case				=		ids_tensor([self.batch_size, self.seq_length]     ,    self.num_labels						)
																	__snake_case				=		ids_tensor([self.batch_size]     ,    self.num_choices						)

											__snake_case				=		self.get_config()

											return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels


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




											'''simple docstring'''

											return NystromformerConfig(
											    vocab_size=self.vocab_size     ,    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     ,    max_position_embeddings=self.max_position_embeddings     ,    type_vocab_size=self.type_vocab_size     ,    is_decoder=SCREAMING_SNAKE_CASE     ,    initializer_range=self.initializer_range     ,    )


					def 							SCREAMING_SNAKE_CASE_  (						self	:		int     ,    SCREAMING_SNAKE_CASE	:		Dict     ,    SCREAMING_SNAKE_CASE	:		Optional[Any]     ,    SCREAMING_SNAKE_CASE	:		Union[str, Any]     ,    SCREAMING_SNAKE_CASE	:		Tuple     ,    SCREAMING_SNAKE_CASE	:		List[Any]     ,    SCREAMING_SNAKE_CASE	:		List[str]     ,    SCREAMING_SNAKE_CASE	:		Any						)			->	str:




											'''simple docstring'''

											__snake_case				=		NystromformerModel(config=SCREAMING_SNAKE_CASE						)
											model.to(SCREAMING_SNAKE_CASE						)
											model.eval()
											__snake_case				=		model(SCREAMING_SNAKE_CASE     ,    attention_mask=SCREAMING_SNAKE_CASE     ,    token_type_ids=SCREAMING_SNAKE_CASE						)
											__snake_case				=		model(SCREAMING_SNAKE_CASE     ,    token_type_ids=SCREAMING_SNAKE_CASE						)
											__snake_case				=		model(SCREAMING_SNAKE_CASE						)
											self.parent.assertEqual(result.last_hidden_state.shape     ,    (self.batch_size, self.seq_length, self.hidden_size)						)


					def 							SCREAMING_SNAKE_CASE_  (						self	:		Optional[Any]     ,    SCREAMING_SNAKE_CASE	:		int     ,    SCREAMING_SNAKE_CASE	:		Tuple     ,    SCREAMING_SNAKE_CASE	:		Tuple     ,    SCREAMING_SNAKE_CASE	:		Tuple     ,    SCREAMING_SNAKE_CASE	:		List[Any]     ,    SCREAMING_SNAKE_CASE	:		Optional[Any]     ,    SCREAMING_SNAKE_CASE	:		List[str]						)			->	List[str]:




											'''simple docstring'''

											__snake_case				=		NystromformerForMaskedLM(config=SCREAMING_SNAKE_CASE						)
											model.to(SCREAMING_SNAKE_CASE						)
											model.eval()
											__snake_case				=		model(SCREAMING_SNAKE_CASE     ,    attention_mask=SCREAMING_SNAKE_CASE     ,    token_type_ids=SCREAMING_SNAKE_CASE     ,    labels=SCREAMING_SNAKE_CASE						)
											self.parent.assertEqual(result.logits.shape     ,    (self.batch_size, self.seq_length, self.vocab_size)						)


					def 							SCREAMING_SNAKE_CASE_  (						self	:		Optional[int]     ,    SCREAMING_SNAKE_CASE	:		int     ,    SCREAMING_SNAKE_CASE	:		Optional[Any]     ,    SCREAMING_SNAKE_CASE	:		List[Any]     ,    SCREAMING_SNAKE_CASE	:		Optional[Any]     ,    SCREAMING_SNAKE_CASE	:		Union[str, Any]     ,    SCREAMING_SNAKE_CASE	:		List[Any]     ,    SCREAMING_SNAKE_CASE	:		Tuple						)			->	List[str]:




											'''simple docstring'''

											__snake_case				=		NystromformerForQuestionAnswering(config=SCREAMING_SNAKE_CASE						)
											model.to(SCREAMING_SNAKE_CASE						)
											model.eval()
											__snake_case				=		model(
											    SCREAMING_SNAKE_CASE     ,    attention_mask=SCREAMING_SNAKE_CASE     ,    token_type_ids=SCREAMING_SNAKE_CASE     ,    start_positions=SCREAMING_SNAKE_CASE     ,    end_positions=SCREAMING_SNAKE_CASE     ,    )
											self.parent.assertEqual(result.start_logits.shape     ,    (self.batch_size, self.seq_length)						)
											self.parent.assertEqual(result.end_logits.shape     ,    (self.batch_size, self.seq_length)						)


					def 							SCREAMING_SNAKE_CASE_  (						self	:		List[Any]     ,    SCREAMING_SNAKE_CASE	:		List[Any]     ,    SCREAMING_SNAKE_CASE	:		Optional[int]     ,    SCREAMING_SNAKE_CASE	:		int     ,    SCREAMING_SNAKE_CASE	:		List[str]     ,    SCREAMING_SNAKE_CASE	:		Tuple     ,    SCREAMING_SNAKE_CASE	:		Union[str, Any]     ,    SCREAMING_SNAKE_CASE	:		List[str]						)			->	List[str]:




											'''simple docstring'''

											__snake_case				=		self.num_labels
											__snake_case				=		NystromformerForSequenceClassification(SCREAMING_SNAKE_CASE						)
											model.to(SCREAMING_SNAKE_CASE						)
											model.eval()
											__snake_case				=		model(SCREAMING_SNAKE_CASE     ,    attention_mask=SCREAMING_SNAKE_CASE     ,    token_type_ids=SCREAMING_SNAKE_CASE     ,    labels=SCREAMING_SNAKE_CASE						)
											self.parent.assertEqual(result.logits.shape     ,    (self.batch_size, self.num_labels)						)


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




											'''simple docstring'''

											__snake_case				=		self.num_labels
											__snake_case				=		NystromformerForTokenClassification(config=SCREAMING_SNAKE_CASE						)
											model.to(SCREAMING_SNAKE_CASE						)
											model.eval()
											__snake_case				=		model(SCREAMING_SNAKE_CASE     ,    attention_mask=SCREAMING_SNAKE_CASE     ,    token_type_ids=SCREAMING_SNAKE_CASE     ,    labels=SCREAMING_SNAKE_CASE						)
											self.parent.assertEqual(result.logits.shape     ,    (self.batch_size, self.seq_length, self.num_labels)						)


					def 							SCREAMING_SNAKE_CASE_  (						self	:		int     ,    SCREAMING_SNAKE_CASE	:		Optional[Any]     ,    SCREAMING_SNAKE_CASE	:		Tuple     ,    SCREAMING_SNAKE_CASE	:		Union[str, Any]     ,    SCREAMING_SNAKE_CASE	:		List[str]     ,    SCREAMING_SNAKE_CASE	:		Any     ,    SCREAMING_SNAKE_CASE	:		Dict     ,    SCREAMING_SNAKE_CASE	:		Dict						)			->	Any:




											'''simple docstring'''

											__snake_case				=		self.num_choices
											__snake_case				=		NystromformerForMultipleChoice(config=SCREAMING_SNAKE_CASE						)
											model.to(SCREAMING_SNAKE_CASE						)
											model.eval()
											__snake_case				=		input_ids.unsqueeze(1						).expand(-1     ,    self.num_choices     ,    -1						).contiguous()
											__snake_case				=		token_type_ids.unsqueeze(1						).expand(-1     ,    self.num_choices     ,    -1						).contiguous()
											__snake_case				=		input_mask.unsqueeze(1						).expand(-1     ,    self.num_choices     ,    -1						).contiguous()
											__snake_case				=		model(
											    SCREAMING_SNAKE_CASE     ,    attention_mask=SCREAMING_SNAKE_CASE     ,    token_type_ids=SCREAMING_SNAKE_CASE     ,    labels=SCREAMING_SNAKE_CASE     ,    )
											self.parent.assertEqual(result.logits.shape     ,    (self.batch_size, self.num_choices)						)






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




											'''simple docstring'''

											__snake_case				=		self.prepare_config_and_inputs()
											(
											    (
											    __snake_case
											)		,					(
											    __snake_case
											)		,					(
											    __snake_case
											)		,					(
											    __snake_case
											)		,					(
											    __snake_case
											)		,					(
											    __snake_case
											)		,					(
											    __snake_case
											)		,					
											)				=		config_and_inputs
											__snake_case				=		{"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": input_mask}
											return config, inputs_dict






@require_torch
class     UpperCamelCase(  _a     ,							_a     ,							unittest.TestCase   ):
					snake_case_		:				List[str]										=	(
					    (
					        NystromformerModel,
					        NystromformerForMaskedLM,
					        NystromformerForMultipleChoice,
					        NystromformerForQuestionAnswering,
					        NystromformerForSequenceClassification,
					        NystromformerForTokenClassification,
					    )
					    if is_torch_available()
					    else ()
					)
					snake_case_		:				Optional[int]										=	(
					    {
					        """feature-extraction""": NystromformerModel,
					        """fill-mask""": NystromformerForMaskedLM,
					        """question-answering""": NystromformerForQuestionAnswering,
					        """text-classification""": NystromformerForSequenceClassification,
					        """token-classification""": NystromformerForTokenClassification,
					        """zero-shot""": NystromformerForSequenceClassification,
					    }
					    if is_torch_available()
					    else {}
					)
					snake_case_		:				Union[str, Any]										=	False
					snake_case_		:				str										=	False


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




											'''simple docstring'''

											__snake_case				=		NystromformerModelTester(self						)
											__snake_case				=		ConfigTester(self     ,    config_class=SCREAMING_SNAKE_CASE     ,    hidden_size=3_7						)


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




											'''simple docstring'''

											self.config_tester.run_common_tests()


					def 							SCREAMING_SNAKE_CASE_  (						self	:		Tuple						)			->	List[Any]:




											'''simple docstring'''

											__snake_case				=		self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE						)


					def 							SCREAMING_SNAKE_CASE_  (						self	:		Dict						)			->	Any:




											'''simple docstring'''

											__snake_case				=		self.model_tester.prepare_config_and_inputs()
											for type in ["absolute", "relative_key", "relative_key_query"]:
																	__snake_case				=		type
																	self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE						)


					def 							SCREAMING_SNAKE_CASE_  (						self	:		Any						)			->	str:




											'''simple docstring'''

											__snake_case				=		self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_masked_lm(*SCREAMING_SNAKE_CASE						)


					def 							SCREAMING_SNAKE_CASE_  (						self	:		Optional[Any]						)			->	Optional[Any]:




											'''simple docstring'''

											__snake_case				=		self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_multiple_choice(*SCREAMING_SNAKE_CASE						)


					def 							SCREAMING_SNAKE_CASE_  (						self	:		Optional[int]						)			->	Optional[int]:




											'''simple docstring'''

											__snake_case				=		self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_question_answering(*SCREAMING_SNAKE_CASE						)


					def 							SCREAMING_SNAKE_CASE_  (						self	:		Any						)			->	Tuple:




											'''simple docstring'''

											__snake_case				=		self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_sequence_classification(*SCREAMING_SNAKE_CASE						)


					def 							SCREAMING_SNAKE_CASE_  (						self	:		List[Any]						)			->	Any:




											'''simple docstring'''

											__snake_case				=		self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_token_classification(*SCREAMING_SNAKE_CASE						)






					@slow
					def 							SCREAMING_SNAKE_CASE_  (						self	:		int						)			->	Tuple:




											'''simple docstring'''

											for model_name in NYSTROMFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																	__snake_case				=		NystromformerModel.from_pretrained(SCREAMING_SNAKE_CASE						)
																	self.assertIsNotNone(SCREAMING_SNAKE_CASE						)






@require_torch
class     UpperCamelCase(  unittest.TestCase   ):


					@slow
					def 							SCREAMING_SNAKE_CASE_  (						self	:		Any						)			->	int:




											'''simple docstring'''

											__snake_case				=		NystromformerModel.from_pretrained("uw-madison/nystromformer-512"						)
											__snake_case				=		torch.tensor([[0, 1, 2, 3, 4, 5]]						)

											with torch.no_grad():
																	__snake_case				=		model(SCREAMING_SNAKE_CASE						)[0]

											__snake_case				=		torch.Size((1, 6, 7_6_8)						)
											self.assertEqual(output.shape     ,    SCREAMING_SNAKE_CASE						)

											__snake_case				=		torch.tensor(
											    [[[-0.4532, -0.0936, 0.5137], [-0.2676, 0.0628, 0.6186], [-0.3629, -0.1726, 0.4716]]]						)

											self.assertTrue(torch.allclose(output[:, :3, :3]     ,    SCREAMING_SNAKE_CASE     ,    atol=1e-4						)						)






					@slow
					def 							SCREAMING_SNAKE_CASE_  (						self	:		Dict						)			->	Dict:




											'''simple docstring'''

											__snake_case				=		"the [MASK] of Belgium is Brussels"

											__snake_case				=		AutoTokenizer.from_pretrained("uw-madison/nystromformer-512"						)
											__snake_case				=		NystromformerForMaskedLM.from_pretrained("uw-madison/nystromformer-512"						)

											__snake_case				=		tokenizer(SCREAMING_SNAKE_CASE     ,    return_tensors="pt"						)

											with torch.no_grad():
																	__snake_case				=		model(encoding.input_ids						).logits

											__snake_case				=		token_logits[:, 2, :].argmax(-1						)[0]

											self.assertEqual(tokenizer.decode(SCREAMING_SNAKE_CASE						)     ,    "capital"						)









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	:		List[Any]     ,    SCREAMING_SNAKE_CASE	:		Union[str, Any]     ,    SCREAMING_SNAKE_CASE	:		List[Any]=1_3     ,    SCREAMING_SNAKE_CASE	:		Optional[Any]=6_4     ,    SCREAMING_SNAKE_CASE	:		Union[str, Any]=2     ,    SCREAMING_SNAKE_CASE	:		Union[str, Any]=3     ,    SCREAMING_SNAKE_CASE	:		List[str]=True     ,    SCREAMING_SNAKE_CASE	:		List[Any]=True     ,    SCREAMING_SNAKE_CASE	:		Any=3_2     ,    SCREAMING_SNAKE_CASE	:		Any=5     ,    SCREAMING_SNAKE_CASE	:		List[Any]=4     ,    SCREAMING_SNAKE_CASE	:		Optional[int]=3_7     ,    SCREAMING_SNAKE_CASE	:		Union[str, Any]="gelu"     ,    SCREAMING_SNAKE_CASE	:		Dict=0.1     ,    SCREAMING_SNAKE_CASE	:		Optional[Any]=0.1     ,    SCREAMING_SNAKE_CASE	:		Optional[int]=1_0     ,    SCREAMING_SNAKE_CASE	:		int=0.02     ,    SCREAMING_SNAKE_CASE	:		Dict=[1, 1_6, 4, 4]     ,    SCREAMING_SNAKE_CASE	:		List[str]=None     ,    )			->	int:




											'''simple docstring'''

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


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




											'''simple docstring'''

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

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

											__snake_case				=		self.get_config()

											return config, pixel_values, labels


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




											'''simple docstring'''

											__snake_case				=		{
											    "global_padding": "same",
											    "layer_type": "bottleneck",
											    "depths": [3, 4, 9],
											    "out_features": ["stage1", "stage2", "stage3"],
											    "embedding_dynamic_padding": True,
											    "hidden_sizes": [4, 8, 1_6, 3_2],
											    "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=SCREAMING_SNAKE_CASE     ,    initializer_range=self.initializer_range     ,    backbone_featmap_shape=self.backbone_featmap_shape     ,    backbone_config=SCREAMING_SNAKE_CASE     ,    )


					def 							SCREAMING_SNAKE_CASE_  (						self	:		Any     ,    SCREAMING_SNAKE_CASE	:		Optional[Any]     ,    SCREAMING_SNAKE_CASE	:		Optional[int]     ,    SCREAMING_SNAKE_CASE	:		str						)			->	int:




											'''simple docstring'''

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


					def 							SCREAMING_SNAKE_CASE_  (						self	:		Tuple     ,    SCREAMING_SNAKE_CASE	:		Tuple     ,    SCREAMING_SNAKE_CASE	:		List[Any]     ,    SCREAMING_SNAKE_CASE	:		List[str]						)			->	List[Any]:




											'''simple docstring'''

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






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




											'''simple docstring'''

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






@require_torch
class     UpperCamelCase(  _a     ,							_a     ,							unittest.TestCase   ):
					snake_case_		:				Union[str, Any]										=	(ViTHybridModel, ViTHybridForImageClassification) if is_torch_available() else ()
					snake_case_		:				str										=	(
					    {"""feature-extraction""": ViTHybridModel, """image-classification""": ViTHybridForImageClassification}
					    if is_torch_available()
					    else {}
					)
					snake_case_		:				Tuple										=	False
					snake_case_		:				Optional[Any]										=	False
					snake_case_		:				Dict										=	False


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




											'''simple docstring'''

											__snake_case				=		ViTHybridModelTester(self						)
											__snake_case				=		ConfigTester(self     ,    config_class=SCREAMING_SNAKE_CASE     ,    has_text_modality=SCREAMING_SNAKE_CASE     ,    hidden_size=3_7						)


					def 							SCREAMING_SNAKE_CASE_  (						self	:		Tuple						)			->	List[Any]:




											'''simple docstring'''

											self.config_tester.run_common_tests()


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




											'''simple docstring'''

											pass


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




											'''simple docstring'''

											__snake_case		,					__snake_case				=		self.model_tester.prepare_config_and_inputs_for_common()

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


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




											'''simple docstring'''

											__snake_case		,					__snake_case				=		self.model_tester.prepare_config_and_inputs_for_common()

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

																	__snake_case				=		["pixel_values"]
																	self.assertListEqual(arg_names[:1]     ,    SCREAMING_SNAKE_CASE						)


					def 							SCREAMING_SNAKE_CASE_  (						self	:		Any						)			->	Dict:




											'''simple docstring'''

											__snake_case				=		self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE						)


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




											'''simple docstring'''

											__snake_case				=		self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_image_classification(*SCREAMING_SNAKE_CASE						)


					def 							SCREAMING_SNAKE_CASE_  (						self	:		List[str]						)			->	List[str]:




											'''simple docstring'''

											__snake_case		,					__snake_case				=		self.model_tester.prepare_config_and_inputs_for_common()

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




											'''simple docstring'''

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





def 	_lowerCAmelCase       (    )						->	List[str]:


						'''simple docstring'''






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






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


					@cached_property
					def 							SCREAMING_SNAKE_CASE_  (						self	:		List[str]						)			->	int:




											'''simple docstring'''

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


					@slow
					def 							SCREAMING_SNAKE_CASE_  (						self	:		int						)			->	str:




											'''simple docstring'''

											__snake_case				=		ViTHybridForImageClassification.from_pretrained(VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[0]						).to(
											    SCREAMING_SNAKE_CASE						)

											__snake_case				=		self.default_image_processor
											__snake_case				=		prepare_img()
											__snake_case				=		image_processor(images=SCREAMING_SNAKE_CASE     ,    return_tensors="pt"						).to(SCREAMING_SNAKE_CASE						)

											# forward pass
											with torch.no_grad():
																	__snake_case				=		model(**SCREAMING_SNAKE_CASE						)

											# verify the logits
											__snake_case				=		torch.Size((1, 1_0_0_0)						)
											self.assertEqual(outputs.logits.shape     ,    SCREAMING_SNAKE_CASE						)

											__snake_case				=		torch.tensor([-1.9090, -0.4993, -0.2389]						).to(SCREAMING_SNAKE_CASE						)

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






					@slow
					@require_accelerate
					def 							SCREAMING_SNAKE_CASE_  (						self	:		List[str]						)			->	Optional[int]:




											'''simple docstring'''

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

											__snake_case				=		prepare_img()

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

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





