




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





	def __init__(							self      ,     SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE=13      ,     SCREAMING_SNAKE_CASE=64      ,     SCREAMING_SNAKE_CASE=2      ,     SCREAMING_SNAKE_CASE=3      ,     SCREAMING_SNAKE_CASE=True      ,     SCREAMING_SNAKE_CASE=True      ,     SCREAMING_SNAKE_CASE=32      ,     SCREAMING_SNAKE_CASE=5      ,     SCREAMING_SNAKE_CASE=4      ,     SCREAMING_SNAKE_CASE=37      ,     SCREAMING_SNAKE_CASE="gelu"      ,     SCREAMING_SNAKE_CASE=0.1      ,     SCREAMING_SNAKE_CASE=0.1      ,     SCREAMING_SNAKE_CASE=10      ,     SCREAMING_SNAKE_CASE=0.0_2      ,     SCREAMING_SNAKE_CASE=[1, 16, 4, 4]      ,     SCREAMING_SNAKE_CASE=None      ,     )  ->					List[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 						A_(							self      )  ->					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 						A_(							self      )  ->					int:




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





	def 						A_(							self      ,     SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE      )  ->					int:




				"""simple docstring"""



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





	def 						A_(							self      ,     SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE      )  ->					Optional[Any]:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_								=						self.type_sequence_label_size
				SCREAMING_SNAKE_CASE_								=						ViTHybridForImageClassification(SCREAMING_SNAKE_CASE      )
				model.to(SCREAMING_SNAKE_CASE      )
				model.eval()
				SCREAMING_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 						A_(							self      )  ->					Optional[int]:




				"""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       a_       (     SCREAMING_SNAKE_CASE__  ,    SCREAMING_SNAKE_CASE__  ,    unittest.TestCase     ):
	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 						A_(							self      )  ->					Any:




				"""simple docstring"""



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





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




				"""simple docstring"""



				self.config_tester.run_common_tests()





	@unittest.skip(reason='ViT does not use inputs_embeds'      )
	def 						A_(							self      )  ->					int:




				"""simple docstring"""



				pass





	def 						A_(							self      )  ->					Union[str, 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(SCREAMING_SNAKE_CASE      )
							self.assertIsInstance(model.get_input_embeddings()      ,     (nn.Module)      )
							SCREAMING_SNAKE_CASE_								=						model.get_output_embeddings()
							self.assertTrue(x is None or isinstance(SCREAMING_SNAKE_CASE      ,     nn.Linear      )      )





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




				"""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(SCREAMING_SNAKE_CASE      )
							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]      ,     SCREAMING_SNAKE_CASE      )





	def 						A_(							self      )  ->					Any:




				"""simple docstring"""



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





	def 						A_(							self      )  ->					Any:




				"""simple docstring"""



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





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




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_						,		SCREAMING_SNAKE_CASE_								=						self.model_tester.prepare_config_and_inputs_for_common()

				SCREAMING_SNAKE_CASE_								=						_config_zero_init(SCREAMING_SNAKE_CASE      )
				for model_class in self.all_model_classes:
							SCREAMING_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":
													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 						A_(							self      )  ->					Optional[int]:




				"""simple docstring"""



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




def lowercase    (  )			->							Tuple:


			'''simple docstring'''







			SCREAMING_SNAKE_CASE_								=						Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png' )
			return image



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





	@cached_property
	def 						A_(							self      )  ->					int:




				"""simple docstring"""



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





	@slow
	def 						A_(							self      )  ->					Tuple:




				"""simple docstring"""



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

				SCREAMING_SNAKE_CASE_								=						self.default_image_processor
				SCREAMING_SNAKE_CASE_								=						prepare_img()
				SCREAMING_SNAKE_CASE_								=						image_processor(images=SCREAMING_SNAKE_CASE      ,     return_tensors='pt'      ).to(SCREAMING_SNAKE_CASE      )

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

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

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

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





	@slow
	@require_accelerate
	def 						A_(							self      )  ->					str:




				"""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=SCREAMING_SNAKE_CASE      ,     return_tensors='pt'      )
				SCREAMING_SNAKE_CASE_								=						model(**SCREAMING_SNAKE_CASE      )
				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'      )






from __future__ import annotations

from typing import Any

def lowercase    (  SCREAMING_SNAKE_CASE )			->							None:


			'''simple docstring'''







			create_state_space_tree(SCREAMING_SNAKE_CASE       ,    []       ,    0 )

def lowercase    (  SCREAMING_SNAKE_CASE       ,    SCREAMING_SNAKE_CASE       ,    SCREAMING_SNAKE_CASE )			->							None:


			'''simple docstring'''







			if index == len(SCREAMING_SNAKE_CASE ):
						print(SCREAMING_SNAKE_CASE )
						return

			create_state_space_tree(SCREAMING_SNAKE_CASE       ,    SCREAMING_SNAKE_CASE       ,    index + 1 )
			current_subsequence.append(sequence[index] )
			create_state_space_tree(SCREAMING_SNAKE_CASE       ,    SCREAMING_SNAKE_CASE       ,    index + 1 )
			current_subsequence.pop()


if __name__ == "__main__":
				SCREAMING_SNAKE_CASE__     :     list[Any]		    =       [3, 1, 2, 4]
				generate_all_subsequences(seq)

				seq.clear()
				seq.extend(["A", "B", "C"])
				generate_all_subsequences(seq)
