


"""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      lowerCamelCase__   :







					"""simple docstring"""


					def __init__(       self    : str ,       UpperCamelCase    : Tuple ,       UpperCamelCase    : Tuple=13 ,       UpperCamelCase    : Any=64 ,       UpperCamelCase    : Optional[Any]=2 ,       UpperCamelCase    : int=3 ,       UpperCamelCase    : Optional[Any]=True ,       UpperCamelCase    : Optional[int]=True ,       UpperCamelCase    : int=32 ,       UpperCamelCase    : List[str]=5 ,       UpperCamelCase    : Optional[Any]=4 ,       UpperCamelCase    : List[Any]=37 ,       UpperCamelCase    : Optional[int]="gelu" ,       UpperCamelCase    : List[Any]=0.1 ,       UpperCamelCase    : int=0.1 ,       UpperCamelCase    : Dict=10 ,       UpperCamelCase    : Optional[int]=0.02 ,       UpperCamelCase    : Optional[int]=[1, 16, 4, 4] ,       UpperCamelCase    : Tuple=None ,       ):
												'''simple docstring'''






												__UpperCAmelCase   :						int      							=					parent
												__UpperCAmelCase   :						Tuple      							=					batch_size
												__UpperCAmelCase   :						int      							=					image_size
												__UpperCAmelCase   :						Any      							=					patch_size
												__UpperCAmelCase   :						Tuple      							=					num_channels
												__UpperCAmelCase   :						Dict      							=					is_training
												__UpperCAmelCase   :						List[Any]      							=					use_labels
												__UpperCAmelCase   :						Dict      							=					hidden_size
												__UpperCAmelCase   :						Any      							=					num_hidden_layers
												__UpperCAmelCase   :						Optional[Any]      							=					num_attention_heads
												__UpperCAmelCase   :						List[str]      							=					intermediate_size
												__UpperCAmelCase   :						Tuple      							=					hidden_act
												__UpperCAmelCase   :						List[str]      							=					hidden_dropout_prob
												__UpperCAmelCase   :						Optional[Any]      							=					attention_probs_dropout_prob
												__UpperCAmelCase   :						Optional[Any]      							=					type_sequence_label_size
												__UpperCAmelCase   :						str      							=					initializer_range
												__UpperCAmelCase   :						Dict      							=					scope
												__UpperCAmelCase   :						str      							=					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
												__UpperCAmelCase   :						Dict      							=					(self.image_size // 32) ** 2
												__UpperCAmelCase   :						List[str]      							=					num_patches + 1






					def lowerCamelCase__							(       self    : List[str]  ):
												'''simple docstring'''






												__UpperCAmelCase   :						Dict      							=					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )

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

												__UpperCAmelCase   :						List[Any]      							=					self.get_config()

												return config, pixel_values, labels






					def lowerCamelCase__							(       self    : Optional[Any]  ):
												'''simple docstring'''






												__UpperCAmelCase   :						List[str]      							=					{
												    """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 lowerCamelCase__							(       self    : Optional[Any] ,       UpperCamelCase    : List[Any] ,       UpperCamelCase    : Union[str, Any] ,       UpperCamelCase    : Union[str, Any]  ):
												'''simple docstring'''






												__UpperCAmelCase   :						str      							=					ViTHybridModel(config=UpperCamelCase  )
												model.to(UpperCamelCase  )
												model.eval()
												__UpperCAmelCase   :						Union[str, Any]      							=					model(UpperCamelCase  )
												self.parent.assertEqual(result.last_hidden_state.shape ,       (self.batch_size, self.seq_length, self.hidden_size)  )






					def lowerCamelCase__							(       self    : str ,       UpperCamelCase    : Optional[int] ,       UpperCamelCase    : str ,       UpperCamelCase    : Any  ):
												'''simple docstring'''






												__UpperCAmelCase   :						Union[str, Any]      							=					self.type_sequence_label_size
												__UpperCAmelCase   :						Optional[int]      							=					ViTHybridForImageClassification(UpperCamelCase  )
												model.to(UpperCamelCase  )
												model.eval()
												__UpperCAmelCase   :						Tuple      							=					model(UpperCamelCase ,       labels=UpperCamelCase  )
												self.parent.assertEqual(result.logits.shape ,       (self.batch_size, self.type_sequence_label_size)  )






					def lowerCamelCase__							(       self    : str  ):
												'''simple docstring'''






												__UpperCAmelCase   :						Dict      							=					self.prepare_config_and_inputs()
												__UpperCAmelCase							,__UpperCAmelCase							,__UpperCAmelCase   :						Optional[int]      							=					config_and_inputs
												__UpperCAmelCase   :						int      							=					{"""pixel_values""": pixel_values}
												return config, inputs_dict






@require_torch
class      lowerCamelCase__   (     A     ,    A     ,    unittest.TestCase				):







					"""simple docstring"""


					__a	       =							(ViTHybridModel, ViTHybridForImageClassification) if is_torch_available() else ()
					__a	       =							(
					    {"""feature-extraction""": ViTHybridModel, """image-classification""": ViTHybridForImageClassification}
					    if is_torch_available()
					    else {}
					)
					__a	       =							False
					__a	       =							False
					__a	       =							False






					def lowerCamelCase__							(       self    : List[str]  ):
												'''simple docstring'''






												__UpperCAmelCase   :						List[Any]      							=					ViTHybridModelTester(self  )
												__UpperCAmelCase   :						Union[str, Any]      							=					ConfigTester(self ,       config_class=UpperCamelCase ,       has_text_modality=UpperCamelCase ,       hidden_size=37  )






					def lowerCamelCase__							(       self    : Optional[Any]  ):
												'''simple docstring'''






												self.config_tester.run_common_tests()






					@unittest.skip(reason="""ViT does not use inputs_embeds"""  )
					def lowerCamelCase__							(       self    : Optional[Any]  ):
												'''simple docstring'''






												pass






					def lowerCamelCase__							(       self    : List[str]  ):
												'''simple docstring'''






												__UpperCAmelCase							,__UpperCAmelCase   :						Optional[Any]      							=					self.model_tester.prepare_config_and_inputs_for_common()

												for model_class in self.all_model_classes:
																			__UpperCAmelCase   :						Union[str, Any]      							=					model_class(UpperCamelCase  )
																			self.assertIsInstance(model.get_input_embeddings() ,       (nn.Module)  )
																			__UpperCAmelCase   :						List[str]      							=					model.get_output_embeddings()
																			self.assertTrue(x is None or isinstance(UpperCamelCase ,       nn.Linear  )  )






					def lowerCamelCase__							(       self    : Any  ):
												'''simple docstring'''






												__UpperCAmelCase							,__UpperCAmelCase   :						Any      							=					self.model_tester.prepare_config_and_inputs_for_common()

												for model_class in self.all_model_classes:
																			__UpperCAmelCase   :						Optional[Any]      							=					model_class(UpperCamelCase  )
																			__UpperCAmelCase   :						Optional[int]      							=					inspect.signature(model.forward  )
																			# signature.parameters is an OrderedDict => so arg_names order is deterministic
																			__UpperCAmelCase   :						Union[str, Any]      							=					[*signature.parameters.keys()]

																			__UpperCAmelCase   :						Dict      							=					["""pixel_values"""]
																			self.assertListEqual(arg_names[:1] ,       UpperCamelCase  )






					def lowerCamelCase__							(       self    : Optional[int]  ):
												'''simple docstring'''






												__UpperCAmelCase   :						Optional[int]      							=					self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_model(*UpperCamelCase  )






					def lowerCamelCase__							(       self    : Optional[int]  ):
												'''simple docstring'''






												__UpperCAmelCase   :						int      							=					self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_image_classification(*UpperCamelCase  )






					def lowerCamelCase__							(       self    : Any  ):
												'''simple docstring'''






												__UpperCAmelCase							,__UpperCAmelCase   :						str      							=					self.model_tester.prepare_config_and_inputs_for_common()

												__UpperCAmelCase   :						str      							=					_config_zero_init(UpperCamelCase  )
												for model_class in self.all_model_classes:
																			__UpperCAmelCase   :						Dict      							=					model_class(config=UpperCamelCase  )
																			# Skip the check for the backbone
																			for name, module in model.named_modules():
																										if module.__class__.__name__ == "ViTHybridPatchEmbeddings":
																																	__UpperCAmelCase   :						Union[str, Any]      							=					[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 lowerCamelCase__							(       self    : int  ):
												'''simple docstring'''






												for model_name in VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																			__UpperCAmelCase   :						Optional[int]      							=					ViTHybridModel.from_pretrained(UpperCamelCase  )
																			self.assertIsNotNone(UpperCamelCase  )






def      lowerCamelCase       (     )		->       Dict:

							'''simple docstring'''



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





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







					"""simple docstring"""


					@cached_property
					def lowerCamelCase__							(       self    : Dict  ):
												'''simple docstring'''






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






					@slow
					def lowerCamelCase__							(       self    : Any  ):
												'''simple docstring'''






												__UpperCAmelCase   :						Dict      							=					ViTHybridForImageClassification.from_pretrained(VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[0]  ).to(
												    UpperCamelCase  )

												__UpperCAmelCase   :						Tuple      							=					self.default_image_processor
												__UpperCAmelCase   :						str      							=					prepare_img()
												__UpperCAmelCase   :						Dict      							=					image_processor(images=UpperCamelCase ,       return_tensors="""pt"""  ).to(UpperCamelCase  )

												# forward pass
												with torch.no_grad():
																			__UpperCAmelCase   :						Union[str, Any]      							=					model(**UpperCamelCase  )

												# verify the logits
												__UpperCAmelCase   :						Optional[Any]      							=					torch.Size((1, 1_000)  )
												self.assertEqual(outputs.logits.shape ,       UpperCamelCase  )

												__UpperCAmelCase   :						int      							=					torch.tensor([-1.9090, -0.4993, -0.2389]  ).to(UpperCamelCase  )

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






					@slow
					@require_accelerate
					def lowerCamelCase__							(       self    : Dict  ):
												'''simple docstring'''






												__UpperCAmelCase   :						List[str]      							=					ViTHybridImageProcessor.from_pretrained("""google/vit-hybrid-base-bit-384"""  )
												__UpperCAmelCase   :						List[str]      							=					ViTHybridForImageClassification.from_pretrained("""google/vit-hybrid-base-bit-384""" ,       device_map="""auto"""  )

												__UpperCAmelCase   :						int      							=					prepare_img()

												__UpperCAmelCase   :						List[Any]      							=					image_processor(images=UpperCamelCase ,       return_tensors="""pt"""  )
												__UpperCAmelCase   :						Optional[int]      							=					model(**UpperCamelCase  )
												__UpperCAmelCase   :						str      							=					outputs.logits
												# model predicts one of the 1000 ImageNet classes
												__UpperCAmelCase   :						Optional[int]      							=					logits.argmax(-1  ).item()

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




"""simple docstring"""






from collections.abc import Callable
def      lowerCamelCase       (     _UpperCamelCase		:      Callable[[float], float]       ,			_UpperCamelCase		:      float       ,			_UpperCamelCase		:      float							)		->       float:

							'''simple docstring'''



							__UpperCAmelCase   :						float      							=					a
							__UpperCAmelCase   :						float      							=					b
							if function(_UpperCamelCase							) == 0:  # one of the a or b is a root for the function
														return a
							elif function(_UpperCamelCase							) == 0:
														return b
							elif (
							    function(_UpperCamelCase							) * function(_UpperCamelCase							) > 0
							):  # if none of these are root and they are both positive or negative,
														# then this algorithm can't find the root
														raise ValueError("""could not find root in given interval."""							)
							else:
														__UpperCAmelCase   :						float      							=					start + (end - start) / 2.0
														while abs(start - mid							) > 1_0**-7:  # until precisely equals to 10^-7
																					if function(_UpperCamelCase							) == 0:
																												return mid
																					elif function(_UpperCamelCase							) * function(_UpperCamelCase							) < 0:
																												__UpperCAmelCase   :						Union[str, Any]      							=					mid
																					else:
																												__UpperCAmelCase   :						List[Any]      							=					mid
																					__UpperCAmelCase   :						Optional[Any]      							=					start + (end - start) / 2.0
														return mid
def      lowerCamelCase       (     _UpperCamelCase		:      float							)		->       float:

							'''simple docstring'''



							return x**3 - 2 * x - 5


if __name__ == "__main__":
							print(bisection(f, 1, 1000))

							import doctest

							doctest.testmod()
