



'''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 __A    :



 '''simple docstring'''







 def __init__(self				,     A				,     A=13				,     A=30				,     A=2				,     A=3				,     A=True				,     A=True				,     A=32				,     A=5				,     A=4				,     A=37				,     A="gelu"				,     A=0.1				,     A=0.1				,     A=10				,     A=0.02				,     A=None				,     )					->  int:


      """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       a__						(self )					->  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       a__						(self )					->  Optional[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       a__						(self				,     A				,     A				,     A )					->  List[str]:


      """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       a__						(self				,     A				,     A				,     A )					->  Optional[Any]:


      """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       a__						(self )					->  Union[str, Any]:


      """simple docstring"""



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






@require_torch
class __A    (						A     ,     A     ,     unittest.TestCase		):



 '''simple docstring'''







 __lowerCamelCase					: str    = (ViTMSNModel, ViTMSNForImageClassification) if is_torch_available() else ()
 __lowerCamelCase					: int    = (
     {'feature-extraction': ViTMSNModel, 'image-classification': ViTMSNForImageClassification}
     if is_torch_available()
     else {}
 )

 __lowerCamelCase					: int    = False
 __lowerCamelCase					: List[str]    = False
 __lowerCamelCase					: Tuple    = False
 __lowerCamelCase					: str    = False



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


      """simple docstring"""



      _a											=						ViTMSNModelTester(self )
      _a											=						ConfigTester(self				,     config_class=A				,     has_text_modality=A				,     hidden_size=37 )



 def       a__						(self )					->  Dict:


      """simple docstring"""



      self.config_tester.run_common_tests()



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


      """simple docstring"""



      pass



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


      """simple docstring"""



      _a						,					_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       a__						(self )					->  int:


      """simple docstring"""



      _a						,					_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       a__						(self )					->  List[str]:


      """simple docstring"""



      _a											=						self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*A )



 def       a__						(self )					->  Dict:


      """simple docstring"""



      _a											=						self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_image_classification(*A )



 @slow
 def       a__						(self )					->  Tuple:


      """simple docstring"""



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





def lowerCAmelCase						():



     """simple docstring"""



     _a											=						Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''')
     return image






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



 '''simple docstring'''







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


      """simple docstring"""



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



 @slow
 def       a__						(self )					->  Union[str, 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, 1_000) )
      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 unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
  import torch

if is_vision_available():
  from PIL import Image

  from transformers import MobileNetVaImageProcessor






class __A    (						unittest.TestCase		):



 '''simple docstring'''







 def __init__(self				,     A				,     A=7				,     A=3				,     A=18				,     A=30				,     A=400				,     A=True				,     A=None				,     A=True				,     A=None				,     )					->  Any:


      """simple docstring"""



      _a											=						size if size is not None else {'''shortest_edge''': 20}
      _a											=						crop_size if crop_size is not None else {'''height''': 18, '''width''': 18}
      _a											=						parent
      _a											=						batch_size
      _a											=						num_channels
      _a											=						image_size
      _a											=						min_resolution
      _a											=						max_resolution
      _a											=						do_resize
      _a											=						size
      _a											=						do_center_crop
      _a											=						crop_size



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


      """simple docstring"""



      return {
          "do_resize": self.do_resize,
          "size": self.size,
          "do_center_crop": self.do_center_crop,
          "crop_size": self.crop_size,
      }






@require_torch
@require_vision
class __A    (						A     ,     unittest.TestCase		):



 '''simple docstring'''







 __lowerCamelCase					: Tuple    = MobileNetVaImageProcessor if is_vision_available() else None



 def       a__						(self )					->  int:


      """simple docstring"""



      _a											=						MobileNetVaImageProcessingTester(self )



 @property
 def       a__						(self )					->  Optional[Any]:


      """simple docstring"""



      return self.image_processor_tester.prepare_image_processor_dict()



 def       a__						(self )					->  str:


      """simple docstring"""



      _a											=						self.image_processing_class(**self.image_processor_dict )
      self.assertTrue(hasattr(A				,     '''do_resize''' ) )
      self.assertTrue(hasattr(A				,     '''size''' ) )
      self.assertTrue(hasattr(A				,     '''do_center_crop''' ) )
      self.assertTrue(hasattr(A				,     '''crop_size''' ) )



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


      """simple docstring"""



      _a											=						self.image_processing_class.from_dict(self.image_processor_dict )
      self.assertEqual(image_processor.size				,     {'''shortest_edge''': 20} )
      self.assertEqual(image_processor.crop_size				,     {'''height''': 18, '''width''': 18} )

      _a											=						self.image_processing_class.from_dict(self.image_processor_dict				,     size=42				,     crop_size=84 )
      self.assertEqual(image_processor.size				,     {'''shortest_edge''': 42} )
      self.assertEqual(image_processor.crop_size				,     {'''height''': 84, '''width''': 84} )



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


      """simple docstring"""



      pass



 def       a__						(self )					->  Any:


      """simple docstring"""



      _a											=						self.image_processing_class(**self.image_processor_dict )
      # create random PIL images
      _a											=						prepare_image_inputs(self.image_processor_tester				,     equal_resolution=A )
      for image in image_inputs:
           self.assertIsInstance(A				,     Image.Image )

      # Test not batched input
      _a											=						image_processing(image_inputs[0]				,     return_tensors='''pt''' ).pixel_values
      self.assertEqual(
          encoded_images.shape				,     (
              1,
              self.image_processor_tester.num_channels,
              self.image_processor_tester.crop_size['''height'''],
              self.image_processor_tester.crop_size['''width'''],
          )				,     )

      # Test batched
      _a											=						image_processing(A				,     return_tensors='''pt''' ).pixel_values
      self.assertEqual(
          encoded_images.shape				,     (
              self.image_processor_tester.batch_size,
              self.image_processor_tester.num_channels,
              self.image_processor_tester.crop_size['''height'''],
              self.image_processor_tester.crop_size['''width'''],
          )				,     )



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


      """simple docstring"""



      _a											=						self.image_processing_class(**self.image_processor_dict )
      # create random numpy tensors
      _a											=						prepare_image_inputs(self.image_processor_tester				,     equal_resolution=A				,     numpify=A )
      for image in image_inputs:
           self.assertIsInstance(A				,     np.ndarray )

      # Test not batched input
      _a											=						image_processing(image_inputs[0]				,     return_tensors='''pt''' ).pixel_values
      self.assertEqual(
          encoded_images.shape				,     (
              1,
              self.image_processor_tester.num_channels,
              self.image_processor_tester.crop_size['''height'''],
              self.image_processor_tester.crop_size['''width'''],
          )				,     )

      # Test batched
      _a											=						image_processing(A				,     return_tensors='''pt''' ).pixel_values
      self.assertEqual(
          encoded_images.shape				,     (
              self.image_processor_tester.batch_size,
              self.image_processor_tester.num_channels,
              self.image_processor_tester.crop_size['''height'''],
              self.image_processor_tester.crop_size['''width'''],
          )				,     )



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


      """simple docstring"""



      _a											=						self.image_processing_class(**self.image_processor_dict )
      # create random PyTorch tensors
      _a											=						prepare_image_inputs(self.image_processor_tester				,     equal_resolution=A				,     torchify=A )
      for image in image_inputs:
           self.assertIsInstance(A				,     torch.Tensor )

      # Test not batched input
      _a											=						image_processing(image_inputs[0]				,     return_tensors='''pt''' ).pixel_values
      self.assertEqual(
          encoded_images.shape				,     (
              1,
              self.image_processor_tester.num_channels,
              self.image_processor_tester.crop_size['''height'''],
              self.image_processor_tester.crop_size['''width'''],
          )				,     )

      # Test batched
      _a											=						image_processing(A				,     return_tensors='''pt''' ).pixel_values
      self.assertEqual(
          encoded_images.shape				,     (
              self.image_processor_tester.batch_size,
              self.image_processor_tester.num_channels,
              self.image_processor_tester.crop_size['''height'''],
              self.image_processor_tester.crop_size['''width'''],
          )				,     )



