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




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



												'''simple docstring'''

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




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



												'''simple docstring'''

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

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

												SCREAMING_SNAKE_CASE           =    self.get_config()

												return config, pixel_values, labels




							def 		__snake_case(  self				:   Dict )   ->			List[str]:



												'''simple docstring'''

												SCREAMING_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, 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=_UpperCamelCase		,							initializer_range=self.initializer_range		,							backbone_featmap_shape=self.backbone_featmap_shape		,							backbone_config=_UpperCamelCase		,							)




							def 		__snake_case(  self				:   Any		,							_UpperCamelCase				:   List[str]		,							_UpperCamelCase				:   Optional[int]		,							_UpperCamelCase				:   int )   ->			Optional[int]:



												'''simple docstring'''

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




							def 		__snake_case(  self				:   Optional[Any]		,							_UpperCamelCase				:   List[Any]		,							_UpperCamelCase				:   str		,							_UpperCamelCase				:   str )   ->			Dict:



												'''simple docstring'''

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





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



												'''simple docstring'''

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



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




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



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    ViTHybridModelTester(self )
												SCREAMING_SNAKE_CASE           =    ConfigTester(self		,							config_class=_UpperCamelCase		,							has_text_modality=_UpperCamelCase		,							hidden_size=37 )




							def 		__snake_case(  self				:   Dict )   ->			Dict:



												'''simple docstring'''

												self.config_tester.run_common_tests()




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



												'''simple docstring'''

												pass




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



												'''simple docstring'''

												SCREAMING_SNAKE_CASE     ,				SCREAMING_SNAKE_CASE           =    self.model_tester.prepare_config_and_inputs_for_common()

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




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



												'''simple docstring'''

												SCREAMING_SNAKE_CASE     ,				SCREAMING_SNAKE_CASE           =    self.model_tester.prepare_config_and_inputs_for_common()

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

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




							def 		__snake_case(  self				:   Dict )   ->			Dict:



												'''simple docstring'''

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




							def 		__snake_case(  self				:   Tuple )   ->			Dict:



												'''simple docstring'''

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




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



												'''simple docstring'''

												SCREAMING_SNAKE_CASE     ,				SCREAMING_SNAKE_CASE           =    self.model_tester.prepare_config_and_inputs_for_common()

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



												'''simple docstring'''

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





def 		__lowerCamelCase							():
					SCREAMING_SNAKE_CASE           =    Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"					)
					return image


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




							@cached_property
							def 		__snake_case(  self				:   Union[str, Any] )   ->			List[str]:



												'''simple docstring'''

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




							@slow
							def 		__snake_case(  self				:   Any )   ->			Tuple:



												'''simple docstring'''

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

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

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

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

												SCREAMING_SNAKE_CASE           =    torch.tensor([-1.9_0_9_0, -0.4_9_9_3, -0.2_3_8_9] ).to(_UpperCamelCase )

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





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



												'''simple docstring'''

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

												SCREAMING_SNAKE_CASE           =    prepare_img()

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

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





import unittest

from transformers import AutoTokenizer, is_flax_available
from transformers.testing_utils import require_flax, require_sentencepiece, require_tokenizers, slow


if is_flax_available():
							import jax.numpy as jnp

							from transformers import FlaxXLMRobertaModel


@require_sentencepiece
@require_tokenizers
@require_flax
class   lowercase      (       unittest.TestCase       ):




							@slow
							def 		__snake_case(  self				:   Optional[int] )   ->			List[Any]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    FlaxXLMRobertaModel.from_pretrained("xlm-roberta-base" )
												SCREAMING_SNAKE_CASE           =    AutoTokenizer.from_pretrained("xlm-roberta-base" )
												SCREAMING_SNAKE_CASE           =    "The dog is cute and lives in the garden house"
												SCREAMING_SNAKE_CASE           =    jnp.array([tokenizer.encode(_UpperCamelCase )] )

												SCREAMING_SNAKE_CASE           =    (1, 12, 768)  # batch_size, sequence_length, embedding_vector_dim
												SCREAMING_SNAKE_CASE           =    jnp.array(
												    [[-0.0_1_0_1, 0.1_2_1_8, -0.0_8_0_3, 0.0_8_0_1, 0.1_3_2_7, 0.0_7_7_6, -0.1_2_1_5, 0.2_3_8_3, 0.3_3_3_8, 0.3_1_0_6, 0.0_3_0_0, 0.0_2_5_2]] )

												SCREAMING_SNAKE_CASE           =    model(_UpperCamelCase )["last_hidden_state"]
												self.assertEqual(output.shape		,							_UpperCamelCase )
												# compare the actual values for a slice of last dim
												self.assertTrue(jnp.allclose(output[:, :, -1]		,							_UpperCamelCase		,							atol=1e-3 ) )




