





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			:		int ,				lowerCamelCase_			:		Dict ,				lowerCamelCase_			:		List[Any]=13 ,				lowerCamelCase_			:		Any=64 ,				lowerCamelCase_			:		Union[str, Any]=2 ,				lowerCamelCase_			:		List[str]=3 ,				lowerCamelCase_			:		Union[str, Any]=True ,				lowerCamelCase_			:		Optional[int]=True ,				lowerCamelCase_			:		Dict=32 ,				lowerCamelCase_			:		List[str]=5 ,				lowerCamelCase_			:		Union[str, Any]=4 ,				lowerCamelCase_			:		Dict=37 ,				lowerCamelCase_			:		List[str]="gelu" ,				lowerCamelCase_			:		str=0.1 ,				lowerCamelCase_			:		List[str]=0.1 ,				lowerCamelCase_			:		List[Any]=10 ,				lowerCamelCase_			:		Tuple=0.02 ,				lowerCamelCase_			:		int=[1, 16, 4, 4] ,				lowerCamelCase_			:		int=None ,				):





										'''simple docstring'''







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







						def 		__UpperCAmelCase       (    self			:		Union[str, Any]					):





										'''simple docstring'''







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

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

										_snake_case :			Optional[int]  						=   self.get_config()

										return config, pixel_values, labels







						def 		__UpperCAmelCase       (    self			:		List[str]					):





										'''simple docstring'''







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







						def 		__UpperCAmelCase       (    self			:		Dict ,				lowerCamelCase_			:		Optional[Any] ,				lowerCamelCase_			:		Tuple ,				lowerCamelCase_			:		Dict					):





										'''simple docstring'''







										_snake_case :			List[str]  						=   ViTHybridModel(config=_lowercase					)
										model.to(_lowercase					)
										model.eval()
										_snake_case :			int  						=   model(_lowercase					)
										self.parent.assertEqual(result.last_hidden_state.shape ,				(self.batch_size, self.seq_length, self.hidden_size)					)







						def 		__UpperCAmelCase       (    self			:		Tuple ,				lowerCamelCase_			:		Tuple ,				lowerCamelCase_			:		Tuple ,				lowerCamelCase_			:		List[Any]					):





										'''simple docstring'''







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







						def 		__UpperCAmelCase       (    self			:		int					):





										'''simple docstring'''







										_snake_case :			int  						=   self.prepare_config_and_inputs()
										_snake_case						,			_snake_case						,			_snake_case :			int  						=   config_and_inputs
										_snake_case :			List[str]  						=   {'pixel_values': pixel_values}
										return config, inputs_dict



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



						"""simple docstring"""

						_UpperCamelCase  :	Optional[int]								=	(ViTHybridModel, ViTHybridForImageClassification) if is_torch_available() else ()
						_UpperCamelCase  :	Tuple								=	(
						    {"feature-extraction": ViTHybridModel, "image-classification": ViTHybridForImageClassification}
						    if is_torch_available()
						    else {}
						)
						_UpperCamelCase  :	int								=	False
						_UpperCamelCase  :	Dict								=	False
						_UpperCamelCase  :	int								=	False







						def 		__UpperCAmelCase       (    self			:		Optional[Any]					):





										'''simple docstring'''







										_snake_case :			int  						=   ViTHybridModelTester(self					)
										_snake_case :			List[Any]  						=   ConfigTester(self ,				config_class=_lowercase ,				has_text_modality=_lowercase ,				hidden_size=37					)







						def 		__UpperCAmelCase       (    self			:		Union[str, Any]					):





										'''simple docstring'''







										self.config_tester.run_common_tests()







						@unittest.skip(reason='ViT does not use inputs_embeds'					)
						def 		__UpperCAmelCase       (    self			:		Tuple					):





										'''simple docstring'''







										pass







						def 		__UpperCAmelCase       (    self			:		List[str]					):





										'''simple docstring'''







										_snake_case						,			_snake_case :			List[str]  						=   self.model_tester.prepare_config_and_inputs_for_common()

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







						def 		__UpperCAmelCase       (    self			:		int					):





										'''simple docstring'''







										_snake_case						,			_snake_case :			Optional[int]  						=   self.model_tester.prepare_config_and_inputs_for_common()

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

														_snake_case :			int  						=   ['pixel_values']
														self.assertListEqual(arg_names[:1] ,				_lowercase					)







						def 		__UpperCAmelCase       (    self			:		List[Any]					):





										'''simple docstring'''







										_snake_case :			Optional[Any]  						=   self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*_lowercase					)







						def 		__UpperCAmelCase       (    self			:		int					):





										'''simple docstring'''







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







						def 		__UpperCAmelCase       (    self			:		Optional[int]					):





										'''simple docstring'''







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

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





										'''simple docstring'''







										for model_name in VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
														_snake_case :			Any  						=   ViTHybridModel.from_pretrained(_lowercase					)
														self.assertIsNotNone(_lowercase					)



def       A__(		):
				_snake_case :			Optional[int]  						=   Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png' )
				return image


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



						"""simple docstring"""

						@cached_property
						def 		__UpperCAmelCase       (    self			:		int					):





										'''simple docstring'''







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







						@slow
						def 		__UpperCAmelCase       (    self			:		Optional[int]					):





										'''simple docstring'''







										_snake_case :			List[str]  						=   ViTHybridForImageClassification.from_pretrained(VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[0]					).to(
										    _lowercase					)

										_snake_case :			Dict  						=   self.default_image_processor
										_snake_case :			int  						=   prepare_img()
										_snake_case :			Any  						=   image_processor(images=_lowercase ,				return_tensors='pt'					).to(_lowercase					)

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

										# verify the logits
										_snake_case :			Optional[Any]  						=   torch.Size((1, 10_00)					)
										self.assertEqual(outputs.logits.shape ,				_lowercase					)

										_snake_case :			Union[str, Any]  						=   torch.tensor([-1.9090, -0.4993, -0.2389]					).to(_lowercase					)

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







						@slow
						@require_accelerate
						def 		__UpperCAmelCase       (    self			:		str					):





										'''simple docstring'''







										_snake_case :			Optional[Any]  						=   ViTHybridImageProcessor.from_pretrained('google/vit-hybrid-base-bit-384'					)
										_snake_case :			Any  						=   ViTHybridForImageClassification.from_pretrained('google/vit-hybrid-base-bit-384' ,				device_map='auto'					)

										_snake_case :			Tuple  						=   prepare_img()

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

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








import warnings

from ...utils import logging
from .image_processing_segformer import SegformerImageProcessor


lowercase_		:				str				=						logging.get_logger(__name__)


class 			lowercase				(							a_     ):



						"""simple docstring"""

						def __init__(    self			:		int ,				*lowerCamelCase_			:		str ,				**lowerCamelCase_			:		Tuple					):





										'''simple docstring'''







										warnings.warn(
										    'The class SegformerFeatureExtractor is deprecated and will be removed in version 5 of Transformers.'
										    ' Please use SegformerImageProcessor instead.' ,				lowerCamelCase_ ,				)
										super().__init__(*lowerCamelCase_ ,				**lowerCamelCase_					)






