






'''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     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      ,		)  ->				Any:



           """simple docstring"""






           UpperCamelCase      = parent
           UpperCamelCase      = batch_size
           UpperCamelCase      = image_size
           UpperCamelCase      = patch_size
           UpperCamelCase      = num_channels
           UpperCamelCase      = is_training
           UpperCamelCase      = use_labels
           UpperCamelCase      = hidden_size
           UpperCamelCase      = num_hidden_layers
           UpperCamelCase      = num_attention_heads
           UpperCamelCase      = intermediate_size
           UpperCamelCase      = hidden_act
           UpperCamelCase      = hidden_dropout_prob
           UpperCamelCase      = attention_probs_dropout_prob
           UpperCamelCase      = type_sequence_label_size
           UpperCamelCase      = initializer_range
           UpperCamelCase      = scope
           UpperCamelCase      = 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      = (self.image_size // 32) ** 2
           UpperCamelCase      = num_patches + 1

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



           """simple docstring"""






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

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

           UpperCamelCase      = self.get_config()

           return config, pixel_values, labels

     def   A__						(				self				)  ->				Dict:



           """simple docstring"""






           UpperCamelCase      = {
               "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   A__						(				self      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE				)  ->				Dict:



           """simple docstring"""






           UpperCamelCase      = ViTHybridModel(config=_snake_case				)
           model.to(_snake_case				)
           model.eval()
           UpperCamelCase      = model(_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				)  ->				Dict:



           """simple docstring"""






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


     def   A__						(				self				)  ->				Tuple:



           """simple docstring"""






           UpperCamelCase      = self.prepare_config_and_inputs()
           UpperCamelCase      = config_and_inputs
           UpperCamelCase      = {"pixel_values": pixel_values}
           return config, inputs_dict






@require_torch
class     a_						(      __SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	unittest.TestCase    ):
     lowercase							=				(ViTHybridModel, ViTHybridForImageClassification) if is_torch_available() else ()
     lowercase							=				(
         {"feature-extraction": ViTHybridModel, "image-classification": ViTHybridForImageClassification}
         if is_torch_available()
         else {}
     )
     lowercase							=				False
     lowercase							=				False
     lowercase							=				False

     def   A__						(				self				)  ->				str:



           """simple docstring"""






           UpperCamelCase      = ViTHybridModelTester(self				)
           UpperCamelCase      = ConfigTester(self      ,		config_class=_snake_case      ,		has_text_modality=_snake_case      ,		hidden_size=37				)

     def   A__						(				self				)  ->				Tuple:



           """simple docstring"""






           self.config_tester.run_common_tests()

     @unittest.skip(reason="""ViT does not use inputs_embeds"""				)
     def   A__						(				self				)  ->				Union[str, Any]:



           """simple docstring"""






           pass

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



           """simple docstring"""






           UpperCamelCase      = self.model_tester.prepare_config_and_inputs_for_common()

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

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



           """simple docstring"""






           UpperCamelCase      = self.model_tester.prepare_config_and_inputs_for_common()

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

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

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



           """simple docstring"""






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

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



           """simple docstring"""






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

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



           """simple docstring"""






           UpperCamelCase      = self.model_tester.prepare_config_and_inputs_for_common()

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



           """simple docstring"""






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







def    lowercase__			(				)->			str:
      UpperCamelCase      = Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""   )
      return image






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

     @cached_property
     def   A__						(				self				)  ->				List[str]:



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






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

           UpperCamelCase      = self.default_image_processor
           UpperCamelCase      = prepare_img()
           UpperCamelCase      = image_processor(images=_snake_case      ,		return_tensors="""pt"""				).to(_snake_case				)

           # forward pass
           with torch.no_grad():
                 UpperCamelCase      = model(**_snake_case				)

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

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

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


     @slow
     @require_accelerate
     def   A__						(				self				)  ->				Tuple:



           """simple docstring"""






           UpperCamelCase      = ViTHybridImageProcessor.from_pretrained("""google/vit-hybrid-base-bit-384"""				)
           UpperCamelCase      = ViTHybridForImageClassification.from_pretrained("""google/vit-hybrid-base-bit-384"""      ,		device_map="""auto"""				)

           UpperCamelCase      = prepare_img()

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

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








'''simple docstring'''

import unittest

from transformers.utils.backbone_utils import (
    BackboneMixin,
    get_aligned_output_features_output_indices,
    verify_out_features_out_indices,
)






class     a_						(      unittest.TestCase    ):

  def   A__						(				self				)  ->				Tuple:



        """simple docstring"""






        UpperCamelCase      = ["""a""", """b""", """c"""]

        # Defaults to last layer if both are None
        UpperCamelCase  ,UpperCamelCase      = get_aligned_output_features_output_indices(_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE				)
        self.assertEqual(_SCREAMING_SNAKE_CASE      ,		["""c"""]				)
        self.assertEqual(_SCREAMING_SNAKE_CASE      ,		[2]				)

        # Out indices set to match out features
        UpperCamelCase  ,UpperCamelCase      = get_aligned_output_features_output_indices(["""a""", """c"""]      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE				)
        self.assertEqual(_SCREAMING_SNAKE_CASE      ,		["""a""", """c"""]				)
        self.assertEqual(_SCREAMING_SNAKE_CASE      ,		[0, 2]				)

        # Out features set to match out indices
        UpperCamelCase  ,UpperCamelCase      = get_aligned_output_features_output_indices(_SCREAMING_SNAKE_CASE      ,		[0, 2]      ,		_SCREAMING_SNAKE_CASE				)
        self.assertEqual(_SCREAMING_SNAKE_CASE      ,		["""a""", """c"""]				)
        self.assertEqual(_SCREAMING_SNAKE_CASE      ,		[0, 2]				)

        # Out features selected from negative indices
        UpperCamelCase  ,UpperCamelCase      = get_aligned_output_features_output_indices(_SCREAMING_SNAKE_CASE      ,		[-3, -1]      ,		_SCREAMING_SNAKE_CASE				)
        self.assertEqual(_SCREAMING_SNAKE_CASE      ,		["""a""", """c"""]				)
        self.assertEqual(_SCREAMING_SNAKE_CASE      ,		[-3, -1]				)

  def   A__						(				self				)  ->				str:



        """simple docstring"""






        with self.assertRaises(_SCREAMING_SNAKE_CASE				):
              verify_out_features_out_indices(["""a""", """b"""]      ,		(0, 1)      ,		_SCREAMING_SNAKE_CASE				)

        # Out features must be a list
        with self.assertRaises(_SCREAMING_SNAKE_CASE				):
              verify_out_features_out_indices(("""a""", """b""")      ,		(0, 1)      ,		["""a""", """b"""]				)

        # Out features must be a subset of stage names
        with self.assertRaises(_SCREAMING_SNAKE_CASE				):
              verify_out_features_out_indices(["""a""", """b"""]      ,		(0, 1)      ,		["""a"""]				)

        # Out indices must be a list or tuple
        with self.assertRaises(_SCREAMING_SNAKE_CASE				):
              verify_out_features_out_indices(_SCREAMING_SNAKE_CASE      ,		0      ,		["""a""", """b"""]				)

        # Out indices must be a subset of stage names
        with self.assertRaises(_SCREAMING_SNAKE_CASE				):
              verify_out_features_out_indices(_SCREAMING_SNAKE_CASE      ,		(0, 1)      ,		["""a"""]				)

        # Out features and out indices must be the same length
        with self.assertRaises(_SCREAMING_SNAKE_CASE				):
              verify_out_features_out_indices(["""a""", """b"""]      ,		(0,)      ,		["""a""", """b""", """c"""]				)

        # Out features should match out indices
        with self.assertRaises(_SCREAMING_SNAKE_CASE				):
              verify_out_features_out_indices(["""a""", """b"""]      ,		(0, 2)      ,		["""a""", """b""", """c"""]				)

        # Out features and out indices should be in order
        with self.assertRaises(_SCREAMING_SNAKE_CASE				):
              verify_out_features_out_indices(["""b""", """a"""]      ,		(0, 1)      ,		["""a""", """b"""]				)

        # Check passes with valid inputs
        verify_out_features_out_indices(["""a""", """b""", """d"""]      ,		(0, 1, -1)      ,		["""a""", """b""", """c""", """d"""]				)


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



        """simple docstring"""






        UpperCamelCase      = BackboneMixin()

        UpperCamelCase      = ["""a""", """b""", """c"""]
        UpperCamelCase      = ["""a""", """c"""]
        UpperCamelCase      = [0, 2]

        # Check that the output features and indices are set correctly
        self.assertEqual(backbone.out_features      ,		["""a""", """c"""]				)
        self.assertEqual(backbone.out_indices      ,		[0, 2]				)

        # Check out features and indices are updated correctly
        UpperCamelCase      = ["""a""", """b"""]
        self.assertEqual(backbone.out_features      ,		["""a""", """b"""]				)
        self.assertEqual(backbone.out_indices      ,		[0, 1]				)

        UpperCamelCase      = [-3, -1]
        self.assertEqual(backbone.out_features      ,		["""a""", """c"""]				)
        self.assertEqual(backbone.out_indices      ,		[-3, -1]				)
