





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

			"""simple docstring"""







			def __init__(      self						,   _A						,   _A=1_3						,   _A=6_4						,   _A=2						,   _A=3						,   _A=True						,   _A=True						,   _A=3_2						,   _A=5						,   _A=4						,   _A=3_7						,   _A="gelu"						,   _A=0.1						,   _A=0.1						,   _A=1_0						,   _A=0.02						,   _A=[1, 1_6, 4, 4]						,   _A=None						,   ):






									'''simple docstring'''







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







			def   _a      (      self    ):






									'''simple docstring'''







									UpperCamelCase				:		List[Any]				   =			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]    )

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

									UpperCamelCase				:		Any				   =			self.get_config()

									return config, pixel_values, labels







			def   _a      (      self    ):






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







			def   _a      (      self						,   _A						,   _A						,   _A    ):






									'''simple docstring'''







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







			def   _a      (      self						,   _A						,   _A						,   _A    ):






									'''simple docstring'''







									UpperCamelCase				:		Any				   =			self.type_sequence_label_size
									UpperCamelCase				:		Any				   =			ViTHybridForImageClassification(_snake_case    )
									model.to(_snake_case    )
									model.eval()
									UpperCamelCase				:		str				   =			model(_snake_case						,   labels=_snake_case    )
									self.parent.assertEqual(result.logits.shape						,   (self.batch_size, self.type_sequence_label_size)    )







			def   _a      (      self    ):






									'''simple docstring'''







									UpperCamelCase				:		str				   =			self.prepare_config_and_inputs()
									UpperCamelCase   ,						UpperCamelCase   ,						UpperCamelCase				:		Optional[Any]				   =			config_and_inputs
									UpperCamelCase				:		Optional[Any]				   =			{"""pixel_values""": pixel_values}
									return config, inputs_dict






@require_torch
class 							lowercase__			(   UpperCAmelCase_					,     UpperCAmelCase_					,     unittest.TestCase	):

			"""simple docstring"""
			__lowerCAmelCase     :				Any										=  (ViTHybridModel, ViTHybridForImageClassification) if is_torch_available() else ()
			__lowerCAmelCase     :				str										=  (
			    {"feature-extraction": ViTHybridModel, "image-classification": ViTHybridForImageClassification}
			    if is_torch_available()
			    else {}
			)
			__lowerCAmelCase     :				int										=  False
			__lowerCAmelCase     :				Dict										=  False
			__lowerCAmelCase     :				Tuple										=  False







			def   _a      (      self    ):






									'''simple docstring'''







									UpperCamelCase				:		Tuple				   =			ViTHybridModelTester(self    )
									UpperCamelCase				:		Dict				   =			ConfigTester(self						,   config_class=_snake_case						,   has_text_modality=_snake_case						,   hidden_size=3_7    )







			def   _a      (      self    ):






									'''simple docstring'''







									self.config_tester.run_common_tests()







			@unittest.skip(reason="""ViT does not use inputs_embeds"""    )
			def   _a      (      self    ):






									'''simple docstring'''







									pass







			def   _a      (      self    ):






									'''simple docstring'''







									UpperCamelCase   ,						UpperCamelCase				:		int				   =			self.model_tester.prepare_config_and_inputs_for_common()

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







			def   _a      (      self    ):






									'''simple docstring'''







									UpperCamelCase   ,						UpperCamelCase				:		Union[str, Any]				   =			self.model_tester.prepare_config_and_inputs_for_common()

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

															UpperCamelCase				:		List[Any]				   =			["""pixel_values"""]
															self.assertListEqual(arg_names[:1]						,   _snake_case    )







			def   _a      (      self    ):






									'''simple docstring'''







									UpperCamelCase				:		Dict				   =			self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*_snake_case    )







			def   _a      (      self    ):






									'''simple docstring'''







									UpperCamelCase				:		str				   =			self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_image_classification(*_snake_case    )







			def   _a      (      self    ):






									'''simple docstring'''







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

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






									'''simple docstring'''







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


def      UpperCamelCase							():
						UpperCamelCase				:		Optional[Any]				   =			Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""     )
						return image






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

			"""simple docstring"""







			@cached_property
			def   _a      (      self    ):






									'''simple docstring'''







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







			@slow
			def   _a      (      self    ):






									'''simple docstring'''







									UpperCamelCase				:		List[Any]				   =			ViTHybridForImageClassification.from_pretrained(VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[0]    ).to(
									    _snake_case    )

									UpperCamelCase				:		Dict				   =			self.default_image_processor
									UpperCamelCase				:		Any				   =			prepare_img()
									UpperCamelCase				:		Optional[int]				   =			image_processor(images=_snake_case						,   return_tensors="""pt"""    ).to(_snake_case    )

									# forward pass
									with torch.no_grad():
															UpperCamelCase				:		Optional[Any]				   =			model(**_snake_case    )

									# verify the logits
									UpperCamelCase				:		Union[str, Any]				   =			torch.Size((1, 1_0_0_0)    )
									self.assertEqual(outputs.logits.shape						,   _snake_case    )

									UpperCamelCase				:		Any				   =			torch.tensor([-1.90_90, -0.49_93, -0.23_89]    ).to(_snake_case    )

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







			@slow
			@require_accelerate
			def   _a      (      self    ):






									'''simple docstring'''







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

									UpperCamelCase				:		Optional[Any]				   =			prepare_img()

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

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








from __future__ import annotations

from fractions import Fraction


def A    (							__UpperCamelCase			,						__UpperCamelCase       )    ->   bool:
			return (
			    num != den and num % 10 == den // 10 and (num // 10) / (den % 10) == num / den
			)


def A    (							__UpperCamelCase       )    ->   list[str]:
			A__	  =     []
			A__	  =     11
			A__	  =     int('1' + '0' * digit_len       )
			for num in range(__UpperCamelCase			,						__UpperCamelCase       ):
						while den <= 99:
									if (num != den) and (num % 10 == den // 10) and (den % 10 != 0):
												if is_digit_cancelling(__UpperCamelCase			,						__UpperCamelCase       ):
															solutions.append(f'''{num}/{den}'''       )
									den += 1
						num += 1
						A__	  =     10
			return solutions


def A    (							__UpperCamelCase = 2       )    ->   int:
			A__	  =     1.0
			for fraction in fraction_list(__UpperCamelCase       ):
						A__	  =     Fraction(__UpperCamelCase       )
						result *= frac.denominator / frac.numerator
			return int(__UpperCamelCase       )


if __name__ == "__main__":
							print(solution())




