





"""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		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__=13		,SCREAMING_SNAKE_CASE__=30		,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__=None		,)			->      Any:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE   :List[str]						=  parent
             __SCREAMING_SNAKE_CASE   :List[Any]						=  batch_size
             __SCREAMING_SNAKE_CASE   :str						=  image_size
             __SCREAMING_SNAKE_CASE   :Optional[Any]						=  patch_size
             __SCREAMING_SNAKE_CASE   :Optional[Any]						=  num_channels
             __SCREAMING_SNAKE_CASE   :Dict						=  is_training
             __SCREAMING_SNAKE_CASE   :Any						=  use_labels
             __SCREAMING_SNAKE_CASE   :Union[str, Any]						=  hidden_size
             __SCREAMING_SNAKE_CASE   :Union[str, Any]						=  num_hidden_layers
             __SCREAMING_SNAKE_CASE   :str						=  num_attention_heads
             __SCREAMING_SNAKE_CASE   :List[Any]						=  intermediate_size
             __SCREAMING_SNAKE_CASE   :List[Any]						=  hidden_act
             __SCREAMING_SNAKE_CASE   :Dict						=  hidden_dropout_prob
             __SCREAMING_SNAKE_CASE   :int						=  attention_probs_dropout_prob
             __SCREAMING_SNAKE_CASE   :List[str]						=  type_sequence_label_size
             __SCREAMING_SNAKE_CASE   :Any						=  initializer_range
             __SCREAMING_SNAKE_CASE   :Any						=  scope

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




       def     _UpperCamelCase     (						self							)			->      Dict:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE   :Optional[int]						=  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

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

             __SCREAMING_SNAKE_CASE   :List[str]						=  self.get_config()

             return config, pixel_values, labels




       def     _UpperCamelCase     (						self							)			->      List[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		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__							)			->      Optional[int]:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE   :Any						=  ViTMSNModel(config=SCREAMING_SNAKE_CASE__							)
             model.to(SCREAMING_SNAKE_CASE__							)
             model.eval()
             __SCREAMING_SNAKE_CASE   :List[str]						=  model(SCREAMING_SNAKE_CASE__							)
             self.parent.assertEqual(result.last_hidden_state.shape		,(self.batch_size, self.seq_length, self.hidden_size)							)




       def     _UpperCamelCase     (						self		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__							)			->      Dict:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE   :Tuple						=  self.type_sequence_label_size
             __SCREAMING_SNAKE_CASE   :str						=  ViTMSNForImageClassification(SCREAMING_SNAKE_CASE__							)
             model.to(SCREAMING_SNAKE_CASE__							)
             model.eval()
             __SCREAMING_SNAKE_CASE   :int						=  model(SCREAMING_SNAKE_CASE__		,labels=SCREAMING_SNAKE_CASE__							)
             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
             __SCREAMING_SNAKE_CASE   :Union[str, Any]						=  1
             __SCREAMING_SNAKE_CASE   :Dict						=  ViTMSNForImageClassification(SCREAMING_SNAKE_CASE__							)
             model.to(SCREAMING_SNAKE_CASE__							)
             model.eval()

             __SCREAMING_SNAKE_CASE   :Tuple						=  floats_tensor([self.batch_size, 1, self.image_size, self.image_size]							)
             __SCREAMING_SNAKE_CASE   :Union[str, Any]						=  model(SCREAMING_SNAKE_CASE__							)
             self.parent.assertEqual(result.logits.shape		,(self.batch_size, self.type_sequence_label_size)							)




       def     _UpperCamelCase     (						self							)			->      str:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE   :Union[str, Any]						=  self.prepare_config_and_inputs()
             __SCREAMING_SNAKE_CASE				,__SCREAMING_SNAKE_CASE				,__SCREAMING_SNAKE_CASE   :str						=  config_and_inputs
             __SCREAMING_SNAKE_CASE   :Optional[int]						=  {'''pixel_values''': pixel_values}
             return config, inputs_dict






@require_torch
class 					_SCREAMING_SNAKE_CASE(   A    ,	A    ,	unittest.TestCase  ):
       SCREAMING_SNAKE_CASE_   :      Dict							=  (ViTMSNModel, ViTMSNForImageClassification) if is_torch_available() else ()
       SCREAMING_SNAKE_CASE_   :      Union[str, Any]							=  (
           {'''feature-extraction''': ViTMSNModel, '''image-classification''': ViTMSNForImageClassification}
           if is_torch_available()
           else {}
       )

       SCREAMING_SNAKE_CASE_   :      Union[str, Any]							=  False
       SCREAMING_SNAKE_CASE_   :      Any							=  False
       SCREAMING_SNAKE_CASE_   :      List[Any]							=  False
       SCREAMING_SNAKE_CASE_   :      Union[str, Any]							=  False




       def     _UpperCamelCase     (						self							)			->      str:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE   :Optional[Any]						=  ViTMSNModelTester(self							)
             __SCREAMING_SNAKE_CASE   :int						=  ConfigTester(self		,config_class=SCREAMING_SNAKE_CASE__		,has_text_modality=SCREAMING_SNAKE_CASE__		,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							)			->      List[str]:





             """simple docstring"""






             pass




       def     _UpperCamelCase     (						self							)			->      Tuple:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE				,__SCREAMING_SNAKE_CASE   :Dict						=  self.model_tester.prepare_config_and_inputs_for_common()

             for model_class in self.all_model_classes:
                   __SCREAMING_SNAKE_CASE   :List[str]						=  model_class(SCREAMING_SNAKE_CASE__							)
                   self.assertIsInstance(model.get_input_embeddings()		,(nn.Module)							)
                   __SCREAMING_SNAKE_CASE   :str						=  model.get_output_embeddings()
                   self.assertTrue(x is None or isinstance(SCREAMING_SNAKE_CASE__		,nn.Linear							)							)




       def     _UpperCamelCase     (						self							)			->      Dict:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE				,__SCREAMING_SNAKE_CASE   :int						=  self.model_tester.prepare_config_and_inputs_for_common()

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

                   __SCREAMING_SNAKE_CASE   :Tuple						=  ['''pixel_values''']
                   self.assertListEqual(arg_names[:1]		,SCREAMING_SNAKE_CASE__							)




       def     _UpperCamelCase     (						self							)			->      Any:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE   :str						=  self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE__							)




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





             """simple docstring"""






             __SCREAMING_SNAKE_CASE   :str						=  self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_image_classification(*SCREAMING_SNAKE_CASE__							)




       @slow
       def     _UpperCamelCase     (						self							)			->      int:





             """simple docstring"""






             for model_name in VIT_MSN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                   __SCREAMING_SNAKE_CASE   :Dict						=  ViTMSNModel.from_pretrained(SCREAMING_SNAKE_CASE__							)
                   self.assertIsNotNone(SCREAMING_SNAKE_CASE__							)




def      __lowerCamelCase   (							)			->      Any:
      __SCREAMING_SNAKE_CASE   :List[Any]						=  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							)			->      Any:





             """simple docstring"""






             torch.manual_seed(2							)
             __SCREAMING_SNAKE_CASE   :int						=  ViTMSNForImageClassification.from_pretrained('''facebook/vit-msn-small'''							).to(SCREAMING_SNAKE_CASE__							)

             __SCREAMING_SNAKE_CASE   :List[Any]						=  self.default_image_processor
             __SCREAMING_SNAKE_CASE   :int						=  prepare_img()
             __SCREAMING_SNAKE_CASE   :int						=  image_processor(images=SCREAMING_SNAKE_CASE__		,return_tensors='''pt'''							).to(SCREAMING_SNAKE_CASE__							)

             # forward pass
             with torch.no_grad():
                   __SCREAMING_SNAKE_CASE   :Union[str, Any]						=  model(**SCREAMING_SNAKE_CASE__							)

             # verify the logits
             __SCREAMING_SNAKE_CASE   :Dict						=  torch.Size((1, 10_00)							)
             self.assertEqual(outputs.logits.shape		,SCREAMING_SNAKE_CASE__							)

             __SCREAMING_SNAKE_CASE   :Dict						=  torch.tensor([-0.0_8_0_3, -0.4_4_5_4, -0.2_3_7_5]							).to(SCREAMING_SNAKE_CASE__							)

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






"""simple docstring"""
from collections.abc import Callable

import numpy as np



def      __lowerCamelCase   (							a_     :		Callable ,   a_     :		float ,   a_     :		float ,   a_     :		float ,   a_     :		float							)			->      np.ndarray:
      __SCREAMING_SNAKE_CASE   :List[Any]						=  int(np.ceil((x_end - xa) / step_size							)							)
      __SCREAMING_SNAKE_CASE   :Optional[Any]						=  np.zeros((n + 1,)							)
      __SCREAMING_SNAKE_CASE   :int						=  ya
      __SCREAMING_SNAKE_CASE   :str						=  xa

      for k in range(a_							):
            __SCREAMING_SNAKE_CASE   :Optional[int]						=  y[k] + step_size * ode_func(a_ ,   y[k]							)
            x += step_size

      return y


if __name__ == "__main__":
  import doctest

  doctest.testmod()