





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






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






		def 						snake_case__				(							self  )       -> List[str]:






									"""simple docstring"""
									lowercase_	:   List[str]  				=     floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )

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

									lowercase_	:   Dict  				=     self.get_config()

									return config, pixel_values, labels






		def 						snake_case__				(							self  )       -> Dict:






									"""simple docstring"""
									lowercase_	:   Optional[Any]  				=     {
									    '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=__snake_case,   initializer_range=self.initializer_range,   backbone_featmap_shape=self.backbone_featmap_shape,   backbone_config=__snake_case,   )






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






									"""simple docstring"""
									lowercase_	:   List[str]  				=     ViTHybridModel(config=__snake_case  )
									model.to(__snake_case  )
									model.eval()
									lowercase_	:   Dict  				=     model(__snake_case  )
									self.parent.assertEqual(result.last_hidden_state.shape,   (self.batch_size, self.seq_length, self.hidden_size)  )






		def 						snake_case__				(							self,   snake_case__,   snake_case__,   snake_case__  )       -> Union[str, Any]:






									"""simple docstring"""
									lowercase_	:   Optional[int]  				=     self.type_sequence_label_size
									lowercase_	:   List[str]  				=     ViTHybridForImageClassification(__snake_case  )
									model.to(__snake_case  )
									model.eval()
									lowercase_	:   Any  				=     model(__snake_case,   labels=__snake_case  )
									self.parent.assertEqual(result.logits.shape,   (self.batch_size, self.type_sequence_label_size)  )






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






									"""simple docstring"""
									lowercase_	:   int  				=     self.prepare_config_and_inputs()
									lowercase_	:   Any  				=     config_and_inputs
									lowercase_	:   List[Any]  				=     {'pixel_values': pixel_values}
									return config, inputs_dict




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






		'''simple docstring'''






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






		def 						snake_case__				(							self  )       -> Optional[Any]:






									"""simple docstring"""
									lowercase_	:   Union[str, Any]  				=     ViTHybridModelTester(self  )
									lowercase_	:   Optional[Any]  				=     ConfigTester(self,   config_class=__snake_case,   has_text_modality=__snake_case,   hidden_size=37  )






		def 						snake_case__				(							self  )       -> int:






									"""simple docstring"""
									self.config_tester.run_common_tests()






		@unittest.skip(reason="""ViT does not use inputs_embeds"""  )
		def 						snake_case__				(							self  )       -> Optional[int]:






									"""simple docstring"""
									pass






		def 						snake_case__				(							self  )       -> int:






									"""simple docstring"""
									lowercase_	:   Tuple  				=     self.model_tester.prepare_config_and_inputs_for_common()

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






		def 						snake_case__				(							self  )       -> int:






									"""simple docstring"""
									lowercase_	:   Tuple  				=     self.model_tester.prepare_config_and_inputs_for_common()

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

																lowercase_	:   int  				=     ['pixel_values']
																self.assertListEqual(arg_names[:1],   __snake_case  )






		def 						snake_case__				(							self  )       -> Any:






									"""simple docstring"""
									lowercase_	:   Dict  				=     self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*__snake_case  )






		def 						snake_case__				(							self  )       -> Union[str, Any]:






									"""simple docstring"""
									lowercase_	:   int  				=     self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_image_classification(*__snake_case  )






		def 						snake_case__				(							self  )       -> Optional[Any]:






									"""simple docstring"""
									lowercase_	:   Dict  				=     self.model_tester.prepare_config_and_inputs_for_common()

									lowercase_	:   Optional[Any]  				=     _config_zero_init(__snake_case  )
									for model_class in self.all_model_classes:
																lowercase_	:   Union[str, Any]  				=     model_class(config=__snake_case  )
																# Skip the check for the backbone
																for name, module in model.named_modules():
																							if module.__class__.__name__ == "ViTHybridPatchEmbeddings":
																														lowercase_	:   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 						snake_case__				(							self  )       -> Any:






									"""simple docstring"""
									for model_name in VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																lowercase_	:   int  				=     ViTHybridModel.from_pretrained(__snake_case  )
																self.assertIsNotNone(__snake_case  )





def  __magic_name__  (				)				-> Union[str, Any]:

							"""simple docstring"""



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




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






		'''simple docstring'''






		@cached_property
		def 						snake_case__				(							self  )       -> List[Any]:






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






		@slow
		def 						snake_case__				(							self  )       -> Optional[int]:






									"""simple docstring"""
									lowercase_	:   Dict  				=     ViTHybridForImageClassification.from_pretrained(VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[0]  ).to(
									    __snake_case  )

									lowercase_	:   Any  				=     self.default_image_processor
									lowercase_	:   Optional[int]  				=     prepare_img()
									lowercase_	:   str  				=     image_processor(images=__snake_case,   return_tensors="""pt"""  ).to(__snake_case  )

									# forward pass
									with torch.no_grad():
																lowercase_	:   List[Any]  				=     model(**__snake_case  )

									# verify the logits
									lowercase_	:   List[str]  				=     torch.Size((1, 10_00)  )
									self.assertEqual(outputs.logits.shape,   __snake_case  )

									lowercase_	:   Any  				=     torch.tensor([-1.9090, -0.4993, -0.2389]  ).to(__snake_case  )

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






		@slow
		@require_accelerate
		def 						snake_case__				(							self  )       -> Any:






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

									lowercase_	:   List[Any]  				=     prepare_img()

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

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




'''simple docstring'''






from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_torch_available,
)


lowerCAmelCase:   List[str]					=		{
    'configuration_falcon': ['FALCON_PRETRAINED_CONFIG_ARCHIVE_MAP', 'FalconConfig'],
}

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     lowerCAmelCase:   str					=		[
         'FALCON_PRETRAINED_MODEL_ARCHIVE_LIST',
         'FalconForCausalLM',
         'FalconModel',
         'FalconPreTrainedModel',
         'FalconForSequenceClassification',
         'FalconForTokenClassification',
         'FalconForQuestionAnswering',
     ]


if TYPE_CHECKING:
     from .configuration_falcon import FALCON_PRETRAINED_CONFIG_ARCHIVE_MAP, FalconConfig

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_falcon import (
              FALCON_PRETRAINED_MODEL_ARCHIVE_LIST,
              FalconForCausalLM,
              FalconForQuestionAnswering,
              FalconForSequenceClassification,
              FalconForTokenClassification,
              FalconModel,
              FalconPreTrainedModel,
          )


else:
     import sys

     lowerCAmelCase:   Optional[int]					=		_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)