






'''simple docstring'''



import inspect
import unittest

from transformers import ViTMSNConfig
from transformers.testing_utils import 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, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
 import torch
 from torch import nn

 from transformers import ViTMSNForImageClassification, ViTMSNModel
 from transformers.models.vit_msn.modeling_vit_msn import VIT_MSN_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
 from PIL import Image

 from transformers import ViTImageProcessor
class 							__SCREAMING_SNAKE_CASE       :




      def __init__(  self ,   lowerCamelCase ,   lowerCamelCase=13 ,   lowerCamelCase=30 ,   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=None ,   )							->str:



         '''simple docstring'''
         __a				     =    parent
         __a				     =    batch_size
         __a				     =    image_size
         __a				     =    patch_size
         __a				     =    num_channels
         __a				     =    is_training
         __a				     =    use_labels
         __a				     =    hidden_size
         __a				     =    num_hidden_layers
         __a				     =    num_attention_heads
         __a				     =    intermediate_size
         __a				     =    hidden_act
         __a				     =    hidden_dropout_prob
         __a				     =    attention_probs_dropout_prob
         __a				     =    type_sequence_label_size
         __a				     =    initializer_range
         __a				     =    scope

         # in ViT MSN, the seq length equals the number of patches + 1 (we add 1 for the [CLS] token)
         __a				     =    (image_size // patch_size) ** 2
         __a				     =    num_patches + 1




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



         '''simple docstring'''
         __a				     =    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]      )

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

         __a				     =    self.get_config()

         return config, pixel_values, labels




      def  __UpperCamelCase							(  self      )							->Any:



         '''simple docstring'''
         return ViTMSNConfig(
             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 ,   initializer_range=self.initializer_range ,   )




      def  __UpperCamelCase							(  self ,   lowerCamelCase ,   lowerCamelCase ,   lowerCamelCase      )							->List[Any]:



         '''simple docstring'''
         __a				     =    ViTMSNModel(config=_A      )
         model.to(_A      )
         model.eval()
         __a				     =    model(_A      )
         self.parent.assertEqual(result.last_hidden_state.shape ,   (self.batch_size, self.seq_length, self.hidden_size)      )




      def  __UpperCamelCase							(  self ,   lowerCamelCase ,   lowerCamelCase ,   lowerCamelCase      )							->Optional[int]:



         '''simple docstring'''
         __a				     =    self.type_sequence_label_size
         __a				     =    ViTMSNForImageClassification(_A      )
         model.to(_A      )
         model.eval()
         __a				     =    model(_A ,   labels=_A      )
         print('Pixel and labels shape: {pixel_values.shape}, {labels.shape}'      )
         print('Labels: {labels}'      )
         self.parent.assertEqual(result.logits.shape ,   (self.batch_size, self.type_sequence_label_size)      )

         # test greyscale images
         __a				     =    1
         __a				     =    ViTMSNForImageClassification(_A      )
         model.to(_A      )
         model.eval()

         __a				     =    floats_tensor([self.batch_size, 1, self.image_size, self.image_size]      )
         __a				     =    model(_A      )
         self.parent.assertEqual(result.logits.shape ,   (self.batch_size, self.type_sequence_label_size)      )






      def  __UpperCamelCase							(  self      )							->int:



         '''simple docstring'''
         __a				     =    self.prepare_config_and_inputs()
         __a				     =    config_and_inputs
         __a				     =    {'pixel_values': pixel_values}
         return config, inputs_dict







@require_torch
class 							__SCREAMING_SNAKE_CASE       (							a__      ,      a__      ,      unittest.TestCase     ):
      __a  					=(ViTMSNModel, ViTMSNForImageClassification) if is_torch_available() else ()
      __a  					=(
          {"feature-extraction": ViTMSNModel, "image-classification": ViTMSNForImageClassification}
          if is_torch_available()
          else {}
      )

      __a  					=False
      __a  					=False
      __a  					=False
      __a  					=False




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



         '''simple docstring'''
         __a				     =    ViTMSNModelTester(self      )
         __a				     =    ConfigTester(self ,   config_class=_A ,   has_text_modality=_A ,   hidden_size=37      )




      def  __UpperCamelCase							(  self      )							->int:



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




      @unittest.skip(reason='ViTMSN does not use inputs_embeds'      )
      def  __UpperCamelCase							(  self      )							->Any:



         '''simple docstring'''
         pass




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



         '''simple docstring'''
         __a				     =    self.model_tester.prepare_config_and_inputs_for_common()

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




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



         '''simple docstring'''
         __a				     =    self.model_tester.prepare_config_and_inputs_for_common()

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

            __a				     =    ['pixel_values']
            self.assertListEqual(arg_names[:1] ,   _A      )




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



         '''simple docstring'''
         __a				     =    self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*_A      )




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



         '''simple docstring'''
         __a				     =    self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*_A      )






      @slow
      def  __UpperCamelCase							(  self      )							->Any:



         '''simple docstring'''

         for model_name in VIT_MSN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
            __a				     =    ViTMSNModel.from_pretrained(_A      )
            self.assertIsNotNone(_A      )







def    __UpperCAmelCase	(				)  ->			Tuple:

   """simple docstring"""
   __a				     =    Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'    )
   return image



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




      @cached_property
      def  __UpperCamelCase							(  self      )							->Any:



         '''simple docstring'''
         return ViTImageProcessor.from_pretrained('facebook/vit-msn-small'      ) if is_vision_available() else None






      @slow
      def  __UpperCamelCase							(  self      )							->List[Any]:



         '''simple docstring'''
         torch.manual_seed(2      )
         __a				     =    ViTMSNForImageClassification.from_pretrained('facebook/vit-msn-small'      ).to(_A      )

         __a				     =    self.default_image_processor
         __a				     =    prepare_img()
         __a				     =    image_processor(images=_A ,   return_tensors='pt'      ).to(_A      )

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

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

         __a				     =    torch.tensor([-0.0803, -0.4454, -0.2375]      ).to(_A      )

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








'''simple docstring'''



import warnings

from .generation import TFGenerationMixin
class 							__SCREAMING_SNAKE_CASE       (							_lowerCAmelCase     ):
      # warning at import time
      warnings.warn(
          "Importing `TFGenerationMixin` from `src/transformers/generation_tf_utils.py` is deprecated and will "
          "be removed in Transformers v5. Import as `from transformers import TFGenerationMixin` instead."      ,      _lowerCAmelCase      ,      )