


'''simple docstring'''




import inspect
import unittest
from math import floor

from transformers import CvtConfig
from transformers.file_utils import cached_property, is_torch_available, is_vision_available
from transformers.testing_utils import require_torch, require_vision, slow, torch_device

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 transformers import CvtForImageClassification, CvtModel
       from transformers.models.cvt.modeling_cvt import CVT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
       from PIL import Image

       from transformers import AutoImageProcessor

class 		UpperCAmelCase_      (  __lowercase		):





     def 							__UpperCAmelCase      ( self       :      Union[str, Any]    )				->  str:
        lowerCAmelCase     =			self.config_class(**self.inputs_dict    )
        self.parent.assertTrue(hasattr(UpperCAmelCase__    ,      'embed_dim'    )    )
        self.parent.assertTrue(hasattr(UpperCAmelCase__    ,      'num_heads'    )    )




class 		UpperCAmelCase_      :





     def __init__( self       :      str    ,      UpperCAmelCase__       :      str    ,      UpperCAmelCase__       :      Union[str, Any]=1_3    ,      UpperCAmelCase__       :      Dict=6_4    ,      UpperCAmelCase__       :      Tuple=3    ,      UpperCAmelCase__       :      Union[str, Any]=[1_6, 4_8, 9_6]    ,      UpperCAmelCase__       :      Dict=[1, 3, 6]    ,      UpperCAmelCase__       :      Optional[Any]=[1, 2, 1_0]    ,      UpperCAmelCase__       :      List[Any]=[7, 3, 3]    ,      UpperCAmelCase__       :      Union[str, Any]=[4, 2, 2]    ,      UpperCAmelCase__       :      List[Any]=[2, 1, 1]    ,      UpperCAmelCase__       :      Union[str, Any]=[2, 2, 2]    ,      UpperCAmelCase__       :      Dict=[False, False, True]    ,      UpperCAmelCase__       :      Any=[0.0, 0.0, 0.0]    ,      UpperCAmelCase__       :      str=0.02    ,      UpperCAmelCase__       :      str=1E-12    ,      UpperCAmelCase__       :      List[str]=True    ,      UpperCAmelCase__       :      List[Any]=True    ,      UpperCAmelCase__       :      Optional[Any]=2    ,      )				->  Tuple:
        lowerCAmelCase     =			parent
        lowerCAmelCase     =			batch_size
        lowerCAmelCase     =			image_size
        lowerCAmelCase     =			patch_sizes
        lowerCAmelCase     =			patch_stride
        lowerCAmelCase     =			patch_padding
        lowerCAmelCase     =			is_training
        lowerCAmelCase     =			use_labels
        lowerCAmelCase     =			num_labels
        lowerCAmelCase     =			num_channels
        lowerCAmelCase     =			embed_dim
        lowerCAmelCase     =			num_heads
        lowerCAmelCase     =			stride_kv
        lowerCAmelCase     =			depth
        lowerCAmelCase     =			cls_token
        lowerCAmelCase     =			attention_drop_rate
        lowerCAmelCase     =			initializer_range
        lowerCAmelCase     =			layer_norm_eps





     def 							__UpperCAmelCase      ( self       :      int    )				->  List[Any]:
        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.num_labels    )

        lowerCAmelCase     =			self.get_config()
        return config, pixel_values, labels





     def 							__UpperCAmelCase      ( self       :      str    )				->  str:
        return CvtConfig(
            image_size=self.image_size    ,      num_labels=self.num_labels    ,      num_channels=self.num_channels    ,      embed_dim=self.embed_dim    ,      num_heads=self.num_heads    ,      patch_sizes=self.patch_sizes    ,      patch_padding=self.patch_padding    ,      patch_stride=self.patch_stride    ,      stride_kv=self.stride_kv    ,      depth=self.depth    ,      cls_token=self.cls_token    ,      attention_drop_rate=self.attention_drop_rate    ,      initializer_range=self.initializer_range    ,      )





     def 							__UpperCAmelCase      ( self       :      Tuple    ,      UpperCAmelCase__       :      str    ,      UpperCAmelCase__       :      int    ,      UpperCAmelCase__       :      List[str]    )				->  Dict:
        lowerCAmelCase     =			CvtModel(config=UpperCAmelCase__    )
        model.to(UpperCAmelCase__    )
        model.eval()
        lowerCAmelCase     =			model(UpperCAmelCase__    )
        lowerCAmelCase     =			(self.image_size, self.image_size)
        lowerCAmelCase     ,  lowerCAmelCase     =			image_size[0], image_size[1]
        for i in range(len(self.depth    )    ):
           lowerCAmelCase     =			floor(((height + 2 * self.patch_padding[i] - self.patch_sizes[i]) / self.patch_stride[i]) + 1    )
           lowerCAmelCase     =			floor(((width + 2 * self.patch_padding[i] - self.patch_sizes[i]) / self.patch_stride[i]) + 1    )
        self.parent.assertEqual(result.last_hidden_state.shape    ,      (self.batch_size, self.embed_dim[-1], height, width)    )





     def 							__UpperCAmelCase      ( self       :      Tuple    ,      UpperCAmelCase__       :      Optional[Any]    ,      UpperCAmelCase__       :      List[str]    ,      UpperCAmelCase__       :      Any    )				->  List[str]:
        lowerCAmelCase     =			self.num_labels
        lowerCAmelCase     =			CvtForImageClassification(UpperCAmelCase__    )
        model.to(UpperCAmelCase__    )
        model.eval()
        lowerCAmelCase     =			model(UpperCAmelCase__    ,      labels=UpperCAmelCase__    )
        self.parent.assertEqual(result.logits.shape    ,      (self.batch_size, self.num_labels)    )





     def 							__UpperCAmelCase      ( self       :      Dict    )				->  Optional[Any]:
        lowerCAmelCase     =			self.prepare_config_and_inputs()
        lowerCAmelCase     ,  lowerCAmelCase     ,  lowerCAmelCase     =			config_and_inputs
        lowerCAmelCase     =			{'pixel_values': pixel_values}
        return config, inputs_dict




@require_torch
class 		UpperCAmelCase_      (  __lowercase       ,	__lowercase       ,	unittest.TestCase		):
     lowerCamelCase				:	Any		=     (CvtModel, CvtForImageClassification) if is_torch_available() else ()
     lowerCamelCase				:	str		=     (
         {'''feature-extraction''': CvtModel, '''image-classification''': CvtForImageClassification}
         if is_torch_available()
         else {}
     )

     lowerCamelCase				:	Optional[Any]		=     False
     lowerCamelCase				:	Dict		=     False
     lowerCamelCase				:	List[str]		=     False
     lowerCamelCase				:	Union[str, Any]		=     False
     lowerCamelCase				:	Tuple		=     False





     def 							__UpperCAmelCase      ( self       :      Dict    )				->  Optional[Any]:
        lowerCAmelCase     =			CvtModelTester(self    )
        lowerCAmelCase     =			ConfigTester(self    ,      config_class=UpperCAmelCase__    ,      has_text_modality=UpperCAmelCase__    ,      hidden_size=3_7    )





     def 							__UpperCAmelCase      ( self       :      Optional[Any]    )				->  int:
        self.create_and_test_config_common_properties()
        self.config_tester.create_and_test_config_to_json_string()
        self.config_tester.create_and_test_config_to_json_file()
        self.config_tester.create_and_test_config_from_and_save_pretrained()
        self.config_tester.create_and_test_config_with_num_labels()
        self.config_tester.check_config_can_be_init_without_params()
        self.config_tester.check_config_arguments_init()





     def 							__UpperCAmelCase      ( self       :      List[Any]    )				->  List[str]:
        return





     @unittest.skip(reason='Cvt does not output attentions'    )
     def 							__UpperCAmelCase      ( self       :      Tuple    )				->  List[Any]:
        pass





     @unittest.skip(reason='Cvt does not use inputs_embeds'    )
     def 							__UpperCAmelCase      ( self       :      Union[str, Any]    )				->  str:
        pass





     @unittest.skip(reason='Cvt does not support input and output embeddings'    )
     def 							__UpperCAmelCase      ( self       :      Tuple    )				->  Any:
        pass





     def 							__UpperCAmelCase      ( self       :      Any    )				->  int:
        lowerCAmelCase     ,  lowerCAmelCase     =			self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
           lowerCAmelCase     =			model_class(UpperCAmelCase__    )
           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]    ,      UpperCAmelCase__    )





     def 							__UpperCAmelCase      ( self       :      Dict    )				->  Dict:
        lowerCAmelCase     =			self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*UpperCAmelCase__    )





     def 							__UpperCAmelCase      ( self       :      Optional[int]    )				->  List[str]:
        def check_hidden_states_output(UpperCAmelCase__       :      Optional[Any]    ,      UpperCAmelCase__       :      Dict    ,      UpperCAmelCase__       :      Any    ):
           lowerCAmelCase     =			model_class(UpperCAmelCase__    )
           model.to(UpperCAmelCase__    )
           model.eval()

           with torch.no_grad():
              lowerCAmelCase     =			model(**self._prepare_for_class(UpperCAmelCase__    ,      UpperCAmelCase__    )    )

           lowerCAmelCase     =			outputs.hidden_states

           lowerCAmelCase     =			len(self.model_tester.depth    )
           self.assertEqual(len(UpperCAmelCase__    )    ,      UpperCAmelCase__    )

           # verify the first hidden states (first block)
           self.assertListEqual(
               list(hidden_states[0].shape[-3:]    )    ,      [
                   self.model_tester.embed_dim[0],
                   self.model_tester.image_size // 4,
                   self.model_tester.image_size // 4,
               ]    ,      )

        lowerCAmelCase     ,  lowerCAmelCase     =			self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
           lowerCAmelCase     =			True
           check_hidden_states_output(UpperCAmelCase__    ,      UpperCAmelCase__    ,      UpperCAmelCase__    )

           # check that output_hidden_states also work using config
           del inputs_dict["output_hidden_states"]
           lowerCAmelCase     =			True

           check_hidden_states_output(UpperCAmelCase__    ,      UpperCAmelCase__    ,      UpperCAmelCase__    )





     def 							__UpperCAmelCase      ( self       :      int    )				->  Dict:
        lowerCAmelCase     =			self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_image_classification(*UpperCAmelCase__    )





     @unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.'    )
     def 							__UpperCAmelCase      ( self       :      List[str]    )				->  Optional[int]:
        pass





     @slow
     def 							__UpperCAmelCase      ( self       :      Tuple    )				->  Union[str, Any]:
        for model_name in CVT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           lowerCAmelCase     =			CvtModel.from_pretrained(UpperCAmelCase__    )
           self.assertIsNotNone(UpperCAmelCase__    )





def 	a_					( ):
   lowerCAmelCase     =			Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'				)
   return image




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





     @cached_property
     def 							__UpperCAmelCase      ( self       :      Tuple    )				->  Optional[int]:
        return AutoImageProcessor.from_pretrained(CVT_PRETRAINED_MODEL_ARCHIVE_LIST[0]    )





     @slow
     def 							__UpperCAmelCase      ( self       :      Tuple    )				->  Optional[Any]:
        lowerCAmelCase     =			CvtForImageClassification.from_pretrained(CVT_PRETRAINED_MODEL_ARCHIVE_LIST[0]    ).to(UpperCAmelCase__    )

        lowerCAmelCase     =			self.default_image_processor
        lowerCAmelCase     =			prepare_img()
        lowerCAmelCase     =			image_processor(images=UpperCAmelCase__    ,      return_tensors='pt'    ).to(UpperCAmelCase__    )

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

        # verify the logits
        lowerCAmelCase     =			torch.Size((1, 1_0_0_0)    )
        self.assertEqual(outputs.logits.shape    ,      UpperCAmelCase__    )

        lowerCAmelCase     =			torch.tensor([0.9_285, 0.9_015, -0.3_150]    ).to(UpperCAmelCase__    )

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












"""simple docstring"""





import tempfile
import unittest

from transformers import AutoModelForSeqaSeqLM, AutoTokenizer
from transformers.testing_utils import (
    is_torch_available,
    require_optimum,
    require_torch,
    slow,
)


if is_torch_available():
  import torch






@require_torch
@require_optimum
@slow
class 					_lowerCAmelCase   (     unittest.TestCase       ):
       """simple docstring"""




       def      snake_case						(    self      ):



         '''simple docstring'''

         lowerCAmelCase__			:Optional[Any]											=							'hf-internal-testing/tiny-random-t5'
         lowerCAmelCase__			:List[Any]											=							AutoTokenizer.from_pretrained(__UpperCAmelCase      )
         lowerCAmelCase__			:str											=							AutoModelForSeqaSeqLM.from_pretrained(__UpperCAmelCase      )

         lowerCAmelCase__			:Any											=							tokenizer('This is me'    , return_tensors='pt'      )

         lowerCAmelCase__			:Dict											=							model.to_bettertransformer()

         self.assertTrue(any('BetterTransformer' in mod.__class__.__name__ for _, mod in model.named_modules()      )      )

         lowerCAmelCase__			:Optional[Any]											=							model.generate(**__UpperCAmelCase      )

         lowerCAmelCase__			:List[Any]											=							model.reverse_bettertransformer()

         self.assertFalse(any('BetterTransformer' in mod.__class__.__name__ for _, mod in model.named_modules()      )      )

         with tempfile.TemporaryDirectory() as tmpdirname:
           model.save_pretrained(__UpperCAmelCase      )

           lowerCAmelCase__			:Any											=							AutoModelForSeqaSeqLM.from_pretrained(__UpperCAmelCase      )

           self.assertFalse(
               any('BetterTransformer' in mod.__class__.__name__ for _, mod in model_reloaded.named_modules()      )      )

           lowerCAmelCase__			:Union[str, Any]											=							model_reloaded.generate(**__UpperCAmelCase      )
           self.assertTrue(torch.allclose(__UpperCAmelCase    , __UpperCAmelCase      )      )






       def      snake_case						(    self      ):



         '''simple docstring'''

         lowerCAmelCase__			:int											=							'hf-internal-testing/tiny-random-t5'
         lowerCAmelCase__			:Union[str, Any]											=							AutoModelForSeqaSeqLM.from_pretrained(__UpperCAmelCase      )

         lowerCAmelCase__			:str											=							model.to_bettertransformer()

         with tempfile.TemporaryDirectory() as tmpdirname:
           with self.assertRaises(__UpperCAmelCase      ):
             model.save_pretrained(__UpperCAmelCase      )

           lowerCAmelCase__			:Optional[int]											=							model.reverse_bettertransformer()
           model.save_pretrained(__UpperCAmelCase      )
