


"""simple docstring"""







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




	def   UpperCAmelCase_				(			self      :    List[Any]       )	->     Union[str, Any]:
						__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   UpperCAmelCase_				(			self      :    List[str]       )	->     Tuple:
						__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, 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=UpperCAmelCase__      ,      initializer_range=self.initializer_range      ,      backbone_featmap_shape=self.backbone_featmap_shape      ,      backbone_config=UpperCAmelCase__      ,      )




	def   UpperCAmelCase_				(			self      :    Optional[Any]      ,      UpperCAmelCase__      :    Optional[int]      ,      UpperCAmelCase__      :    Union[str, Any]      ,      UpperCAmelCase__      :    List[Any]       )	->     int:
						__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   UpperCAmelCase_				(			self      :    Dict      ,      UpperCAmelCase__      :    Optional[Any]      ,      UpperCAmelCase__      :    int      ,      UpperCAmelCase__      :    Union[str, Any]       )	->     str:
						__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   UpperCAmelCase_				(			self      :    Optional[Any]       )	->     Union[str, Any]:
						__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 			UpperCamelCase_     (			UpperCamelCase      ,  UpperCamelCase      ,  unittest.TestCase):

	"""simple docstring"""





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




	def   UpperCAmelCase_				(			self      :    int       )	->     Dict:
						__SCREAMING_SNAKE_CASE						       =    ViTHybridModelTester(self       )
						__SCREAMING_SNAKE_CASE						       =    ConfigTester(self      ,      config_class=UpperCAmelCase__      ,      has_text_modality=UpperCAmelCase__      ,      hidden_size=3_7       )




	def   UpperCAmelCase_				(			self      :    Dict       )	->     Tuple:
						self.config_tester.run_common_tests()




	@unittest.skip(reason="ViT does not use inputs_embeds"       )
	def   UpperCAmelCase_				(			self      :    Any       )	->     str:
						pass




	def   UpperCAmelCase_				(			self      :    List[Any]       )	->     Any:
						__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   UpperCAmelCase_				(			self      :    Dict       )	->     List[Any]:
						__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   UpperCAmelCase_				(			self      :    Any       )	->     Optional[Any]:
						__SCREAMING_SNAKE_CASE						       =    self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*UpperCAmelCase__       )




	def   UpperCAmelCase_				(			self      :    Any       )	->     int:
						__SCREAMING_SNAKE_CASE						       =    self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_image_classification(*UpperCAmelCase__       )




	def   UpperCAmelCase_				(			self      :    Union[str, Any]       )	->     Union[str, Any]:
						__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   UpperCAmelCase_				(			self      :    Any       )	->     str:
						for model_name in VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											__SCREAMING_SNAKE_CASE						       =    ViTHybridModel.from_pretrained(UpperCAmelCase__       )
											self.assertIsNotNone(UpperCAmelCase__       )




def        UpperCAmelCase__	():




					'''simple docstring'''


					__SCREAMING_SNAKE_CASE						       =    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      :    Optional[Any]       )	->     str:
						return (
						    ViTHybridImageProcessor.from_pretrained(VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[0]       )
						    if is_vision_available()
						    else None
						)




	@slow
	def   UpperCAmelCase_				(			self      :    str       )	->     Dict:
						__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_0_0_0)       )
						self.assertEqual(outputs.logits.shape      ,      UpperCAmelCase__       )

						__SCREAMING_SNAKE_CASE						       =    torch.tensor([-1.9_090, -0.4_993, -0.2_389]       ).to(UpperCAmelCase__       )

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




	@slow
	@require_accelerate
	def   UpperCAmelCase_				(			self      :    Any       )	->     Optional[int]:
						__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"       )




"""simple docstring"""







def        UpperCAmelCase__	(lowerCAmelCase_  ,						lowerCAmelCase_       ):




					'''simple docstring'''


					if digit_amount > 0:
										return round(number - int(lowerCAmelCase_       )  ,						lowerCAmelCase_       )
					return number - int(lowerCAmelCase_       )


if __name__ == "__main__":
		print(decimal_isolate(1.53, 0))
		print(decimal_isolate(35.3_45, 1))
		print(decimal_isolate(35.3_45, 2))
		print(decimal_isolate(35.3_45, 3))
		print(decimal_isolate(-14.7_89, 3))
		print(decimal_isolate(0, 2))
		print(decimal_isolate(-14.1_23, 1))
		print(decimal_isolate(-14.1_23, 2))
		print(decimal_isolate(-14.1_23, 3))
