





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




 def __init__(	self			,     _lowerCAmelCase			,     _lowerCAmelCase=13			,     _lowerCAmelCase=64			,     _lowerCAmelCase=2			,     _lowerCAmelCase=3			,     _lowerCAmelCase=True			,     _lowerCAmelCase=True			,     _lowerCAmelCase=32			,     _lowerCAmelCase=5			,     _lowerCAmelCase=4			,     _lowerCAmelCase=37			,     _lowerCAmelCase="gelu"			,     _lowerCAmelCase=0.1			,     _lowerCAmelCase=0.1			,     _lowerCAmelCase=10			,     _lowerCAmelCase=0.02			,     _lowerCAmelCase=[1, 16, 4, 4]			,     _lowerCAmelCase=None			,     )    ->							Any:
     _lowerCAmelCase				=      parent
     _lowerCAmelCase				=      batch_size
     _lowerCAmelCase				=      image_size
     _lowerCAmelCase				=      patch_size
     _lowerCAmelCase				=      num_channels
     _lowerCAmelCase				=      is_training
     _lowerCAmelCase				=      use_labels
     _lowerCAmelCase				=      hidden_size
     _lowerCAmelCase				=      num_hidden_layers
     _lowerCAmelCase				=      num_attention_heads
     _lowerCAmelCase				=      intermediate_size
     _lowerCAmelCase				=      hidden_act
     _lowerCAmelCase				=      hidden_dropout_prob
     _lowerCAmelCase				=      attention_probs_dropout_prob
     _lowerCAmelCase				=      type_sequence_label_size
     _lowerCAmelCase				=      initializer_range
     _lowerCAmelCase				=      scope
     _lowerCAmelCase				=      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
     _lowerCAmelCase				=      (self.image_size // 32) ** 2
     _lowerCAmelCase				=      num_patches + 1




 def 							_snake_case   (	self		)    ->							Dict:
     _lowerCAmelCase				=      floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]		)

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

     _lowerCAmelCase				=      self.get_config()

     return config, pixel_values, labels




 def 							_snake_case   (	self		)    ->							List[str]:
     _lowerCAmelCase				=      {
         "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=_lowerCAmelCase			,     initializer_range=self.initializer_range			,     backbone_featmap_shape=self.backbone_featmap_shape			,     backbone_config=_lowerCAmelCase			,     )




 def 							_snake_case   (	self			,     _lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase		)    ->							Dict:
     _lowerCAmelCase				=      ViTHybridModel(config=_lowerCAmelCase		)
     model.to(_lowerCAmelCase		)
     model.eval()
     _lowerCAmelCase				=      model(_lowerCAmelCase		)
     self.parent.assertEqual(result.last_hidden_state.shape			,     (self.batch_size, self.seq_length, self.hidden_size)		)




 def 							_snake_case   (	self			,     _lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase		)    ->							List[str]:
     _lowerCAmelCase				=      self.type_sequence_label_size
     _lowerCAmelCase				=      ViTHybridForImageClassification(_lowerCAmelCase		)
     model.to(_lowerCAmelCase		)
     model.eval()
     _lowerCAmelCase				=      model(_lowerCAmelCase			,     labels=_lowerCAmelCase		)
     self.parent.assertEqual(result.logits.shape			,     (self.batch_size, self.type_sequence_label_size)		)





 def 							_snake_case   (	self		)    ->							List[str]:
     _lowerCAmelCase				=      self.prepare_config_and_inputs()
     _lowerCAmelCase			,			_lowerCAmelCase			,			_lowerCAmelCase				=      config_and_inputs
     _lowerCAmelCase				=      {"pixel_values": pixel_values}
     return config, inputs_dict







@require_torch
class    lowerCAmelCase_		(		__magic_name__						,__magic_name__						,unittest.TestCase		):
 __lowerCamelCase						:							Optional[int]         =					(ViTHybridModel, ViTHybridForImageClassification) if is_torch_available() else ()
 __lowerCamelCase						:							Any         =					(
     {"feature-extraction": ViTHybridModel, "image-classification": ViTHybridForImageClassification}
     if is_torch_available()
     else {}
 )
 __lowerCamelCase						:							Tuple         =					False
 __lowerCamelCase						:							str         =					False
 __lowerCamelCase						:							Dict         =					False




 def 							_snake_case   (	self		)    ->							List[Any]:
     _lowerCAmelCase				=      ViTHybridModelTester(self		)
     _lowerCAmelCase				=      ConfigTester(self			,     config_class=_lowerCAmelCase			,     has_text_modality=_lowerCAmelCase			,     hidden_size=37		)




 def 							_snake_case   (	self		)    ->							List[str]:
     self.config_tester.run_common_tests()




 @unittest.skip(reason="ViT does not use inputs_embeds"		)
 def 							_snake_case   (	self		)    ->							Dict:
     pass




 def 							_snake_case   (	self		)    ->							str:
     _lowerCAmelCase			,			_lowerCAmelCase				=      self.model_tester.prepare_config_and_inputs_for_common()

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




 def 							_snake_case   (	self		)    ->							List[str]:
     _lowerCAmelCase			,			_lowerCAmelCase				=      self.model_tester.prepare_config_and_inputs_for_common()

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

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




 def 							_snake_case   (	self		)    ->							Union[str, Any]:
     _lowerCAmelCase				=      self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(*_lowerCAmelCase		)




 def 							_snake_case   (	self		)    ->							Tuple:
     _lowerCAmelCase				=      self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_image_classification(*_lowerCAmelCase		)




 def 							_snake_case   (	self		)    ->							List[str]:
     _lowerCAmelCase			,			_lowerCAmelCase				=      self.model_tester.prepare_config_and_inputs_for_common()

     _lowerCAmelCase				=      _config_zero_init(_lowerCAmelCase		)
     for model_class in self.all_model_classes:
         _lowerCAmelCase				=      model_class(config=_lowerCAmelCase		)
         # Skip the check for the backbone
         for name, module in model.named_modules():
             if module.__class__.__name__ == "ViTHybridPatchEmbeddings":
                 _lowerCAmelCase				=      [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		)    ->							int:
     for model_name in VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         _lowerCAmelCase				=      ViTHybridModel.from_pretrained(_lowerCAmelCase		)
         self.assertIsNotNone(_lowerCAmelCase		)







def 	__a():



    '''simple docstring'''





    _lowerCAmelCase				=      Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"    )
    return image





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




 @cached_property
 def 							_snake_case   (	self		)    ->							List[Any]:
     return (
         ViTHybridImageProcessor.from_pretrained(VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[0]		)
         if is_vision_available()
         else None
     )




 @slow
 def 							_snake_case   (	self		)    ->							str:
     _lowerCAmelCase				=      ViTHybridForImageClassification.from_pretrained(VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[0]		).to(
         _lowerCAmelCase		)

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

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

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

     _lowerCAmelCase				=      torch.tensor([-1.9090, -0.4993, -0.2389]		).to(_lowerCAmelCase		)

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





 @slow
 @require_accelerate
 def 							_snake_case   (	self		)    ->							Union[str, Any]:
     _lowerCAmelCase				=      ViTHybridImageProcessor.from_pretrained("google/vit-hybrid-base-bit-384"		)
     _lowerCAmelCase				=      ViTHybridForImageClassification.from_pretrained("google/vit-hybrid-base-bit-384"			,     device_map="auto"		)

     _lowerCAmelCase				=      prepare_img()

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

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









'''simple docstring'''


import unittest

from transformers import (
    MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
    TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
    TextClassificationPipeline,
    pipeline,
)
from transformers.testing_utils import is_pipeline_test, nested_simplify, require_tf, require_torch, slow

from .test_pipelines_common import ANY


# These 2 model types require different inputs than those of the usual text models.
_SCREAMING_SNAKE_CASE	 =							{"LayoutLMv2Config", "LayoutLMv3Config"}

@is_pipeline_test
class    lowerCAmelCase_		(		unittest.TestCase		):
 __lowerCamelCase						:							Optional[Any]         =					MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
 __lowerCamelCase						:							str         =					TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

 if model_mapping is not None:
  __lowerCamelCase						:							Optional[int]         =					{config: model for config, model in model_mapping.items() if config.__name__ not in _TO_SKIP}
 if tf_model_mapping is not None:
  __lowerCamelCase						:							List[Any]         =					{
      config: model for config, model in tf_model_mapping.items() if config.__name__ not in _TO_SKIP
  }




 @require_torch
 def 							_snake_case   (	self		)    ->							str:
     _lowerCAmelCase				=      pipeline(
         task="text-classification"			,     model="hf-internal-testing/tiny-random-distilbert"			,     framework="pt"		)

     _lowerCAmelCase				=      text_classifier("This is great !"		)
     self.assertEqual(nested_simplify(_lowerCAmelCase		)			,     [{"label": "LABEL_0", "score": 0.504}]		)

     _lowerCAmelCase				=      text_classifier("This is great !"			,     top_k=2		)
     self.assertEqual(
         nested_simplify(_lowerCAmelCase		)			,     [{"label": "LABEL_0", "score": 0.504}, {"label": "LABEL_1", "score": 0.496}]		)

     _lowerCAmelCase				=      text_classifier(["This is great !", "This is bad"]			,     top_k=2		)
     self.assertEqual(
         nested_simplify(_lowerCAmelCase		)			,     [
             [{"label": "LABEL_0", "score": 0.504}, {"label": "LABEL_1", "score": 0.496}],
             [{"label": "LABEL_0", "score": 0.504}, {"label": "LABEL_1", "score": 0.496}],
         ]			,     )

     _lowerCAmelCase				=      text_classifier("This is great !"			,     top_k=1		)
     self.assertEqual(nested_simplify(_lowerCAmelCase		)			,     [{"label": "LABEL_0", "score": 0.504}]		)

     # Legacy behavior
     _lowerCAmelCase				=      text_classifier("This is great !"			,     return_all_scores=_lowerCAmelCase		)
     self.assertEqual(nested_simplify(_lowerCAmelCase		)			,     [{"label": "LABEL_0", "score": 0.504}]		)

     _lowerCAmelCase				=      text_classifier("This is great !"			,     return_all_scores=_lowerCAmelCase		)
     self.assertEqual(
         nested_simplify(_lowerCAmelCase		)			,     [[{"label": "LABEL_0", "score": 0.504}, {"label": "LABEL_1", "score": 0.496}]]		)

     _lowerCAmelCase				=      text_classifier(["This is great !", "Something else"]			,     return_all_scores=_lowerCAmelCase		)
     self.assertEqual(
         nested_simplify(_lowerCAmelCase		)			,     [
             [{"label": "LABEL_0", "score": 0.504}, {"label": "LABEL_1", "score": 0.496}],
             [{"label": "LABEL_0", "score": 0.504}, {"label": "LABEL_1", "score": 0.496}],
         ]			,     )

     _lowerCAmelCase				=      text_classifier(["This is great !", "Something else"]			,     return_all_scores=_lowerCAmelCase		)
     self.assertEqual(
         nested_simplify(_lowerCAmelCase		)			,     [
             {"label": "LABEL_0", "score": 0.504},
             {"label": "LABEL_0", "score": 0.504},
         ]			,     )




 @require_torch
 def 							_snake_case   (	self		)    ->							Tuple:
     import torch

     _lowerCAmelCase				=      pipeline(
         task="text-classification"			,     model="hf-internal-testing/tiny-random-distilbert"			,     framework="pt"			,     device=torch.device("cpu"		)			,     )

     _lowerCAmelCase				=      text_classifier("This is great !"		)
     self.assertEqual(nested_simplify(_lowerCAmelCase		)			,     [{"label": "LABEL_0", "score": 0.504}]		)




 @require_tf
 def 							_snake_case   (	self		)    ->							Any:
     _lowerCAmelCase				=      pipeline(
         task="text-classification"			,     model="hf-internal-testing/tiny-random-distilbert"			,     framework="tf"		)

     _lowerCAmelCase				=      text_classifier("This is great !"		)
     self.assertEqual(nested_simplify(_lowerCAmelCase		)			,     [{"label": "LABEL_0", "score": 0.504}]		)




 @slow
 @require_torch
 def 							_snake_case   (	self		)    ->							Dict:
     _lowerCAmelCase				=      pipeline("text-classification"		)

     _lowerCAmelCase				=      text_classifier("This is great !"		)
     self.assertEqual(nested_simplify(_lowerCAmelCase		)			,     [{"label": "POSITIVE", "score": 1.0}]		)
     _lowerCAmelCase				=      text_classifier("This is bad !"		)
     self.assertEqual(nested_simplify(_lowerCAmelCase		)			,     [{"label": "NEGATIVE", "score": 1.0}]		)
     _lowerCAmelCase				=      text_classifier("Birds are a type of animal"		)
     self.assertEqual(nested_simplify(_lowerCAmelCase		)			,     [{"label": "POSITIVE", "score": 0.988}]		)




 @slow
 @require_tf
 def 							_snake_case   (	self		)    ->							Any:
     _lowerCAmelCase				=      pipeline("text-classification"			,     framework="tf"		)

     _lowerCAmelCase				=      text_classifier("This is great !"		)
     self.assertEqual(nested_simplify(_lowerCAmelCase		)			,     [{"label": "POSITIVE", "score": 1.0}]		)
     _lowerCAmelCase				=      text_classifier("This is bad !"		)
     self.assertEqual(nested_simplify(_lowerCAmelCase		)			,     [{"label": "NEGATIVE", "score": 1.0}]		)
     _lowerCAmelCase				=      text_classifier("Birds are a type of animal"		)
     self.assertEqual(nested_simplify(_lowerCAmelCase		)			,     [{"label": "POSITIVE", "score": 0.988}]		)




 def 							_snake_case   (	self			,     _lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase		)    ->							str:
     _lowerCAmelCase				=      TextClassificationPipeline(model=_lowerCAmelCase			,     tokenizer=_lowerCAmelCase		)
     return text_classifier, ["HuggingFace is in", "This is another test"]





 def 							_snake_case   (	self			,     _lowerCAmelCase			,     _lowerCAmelCase		)    ->							Union[str, Any]:
     _lowerCAmelCase				=      text_classifier.model
     # Small inputs because BartTokenizer tiny has maximum position embeddings = 22
     _lowerCAmelCase				=      "HuggingFace is in"
     _lowerCAmelCase				=      text_classifier(_lowerCAmelCase		)

     self.assertEqual(nested_simplify(_lowerCAmelCase		)			,     [{"label": ANY(_lowerCAmelCase		), "score": ANY(_lowerCAmelCase		)}]		)
     self.assertTrue(outputs[0]["label"] in model.config.idalabel.values()		)

     _lowerCAmelCase				=      ["HuggingFace is in ", "Paris is in France"]
     _lowerCAmelCase				=      text_classifier(_lowerCAmelCase		)
     self.assertEqual(
         nested_simplify(_lowerCAmelCase		)			,     [{"label": ANY(_lowerCAmelCase		), "score": ANY(_lowerCAmelCase		)}, {"label": ANY(_lowerCAmelCase		), "score": ANY(_lowerCAmelCase		)}]			,     )
     self.assertTrue(outputs[0]["label"] in model.config.idalabel.values()		)
     self.assertTrue(outputs[1]["label"] in model.config.idalabel.values()		)

     # Forcing to get all results with `top_k=None`
     # This is NOT the legacy format
     _lowerCAmelCase				=      text_classifier(_lowerCAmelCase			,     top_k=_lowerCAmelCase		)
     _lowerCAmelCase				=      len(model.config.idalabel.values()		)
     self.assertEqual(
         nested_simplify(_lowerCAmelCase		)			,     [[{"label": ANY(_lowerCAmelCase		), "score": ANY(_lowerCAmelCase		)}] * N, [{"label": ANY(_lowerCAmelCase		), "score": ANY(_lowerCAmelCase		)}] * N]			,     )

     _lowerCAmelCase				=      {"text": "HuggingFace is in ", "text_pair": "Paris is in France"}
     _lowerCAmelCase				=      text_classifier(_lowerCAmelCase		)
     self.assertEqual(
         nested_simplify(_lowerCAmelCase		)			,     {"label": ANY(_lowerCAmelCase		), "score": ANY(_lowerCAmelCase		)}			,     )
     self.assertTrue(outputs["label"] in model.config.idalabel.values()		)

     # This might be used a text pair, but tokenizer + pipe interaction
     # makes it hard to understand that it's not using the pair properly
     # https://github.com/huggingface/transformers/issues/17305
     # We disabled this usage instead as it was outputting wrong outputs.
     _lowerCAmelCase				=      [["HuggingFace is in ", "Paris is in France"]]
     with self.assertRaises(_lowerCAmelCase		):
         text_classifier(_lowerCAmelCase		)

     # This used to be valid for doing text pairs
     # We're keeping it working because of backward compatibility
     _lowerCAmelCase				=      text_classifier([[["HuggingFace is in ", "Paris is in France"]]]		)
     self.assertEqual(
         nested_simplify(_lowerCAmelCase		)			,     [{"label": ANY(_lowerCAmelCase		), "score": ANY(_lowerCAmelCase		)}]			,     )
     self.assertTrue(outputs[0]["label"] in model.config.idalabel.values()		)


