
import inspect
import unittest

from transformers import ViTConfig
from transformers.testing_utils import (
    require_accelerate,
    require_torch,
    require_torch_gpu,
    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 ViTForImageClassification, ViTForMaskedImageModeling, ViTModel
  from transformers.models.vit.modeling_vit import VIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
  from PIL import Image

  from transformers import ViTImageProcessor





class       __A:

     def __init__(	self					:     int   ,					__UpperCamelCase					:     Optional[int]   ,					__UpperCamelCase					:     Any=1_3   ,					__UpperCamelCase					:     Optional[Any]=3_0   ,					__UpperCamelCase					:     List[Any]=2   ,					__UpperCamelCase					:     Tuple=3   ,					__UpperCamelCase					:     List[Any]=True   ,					__UpperCamelCase					:     List[Any]=True   ,					__UpperCamelCase					:     Union[str, Any]=3_2   ,					__UpperCamelCase					:     Union[str, Any]=5   ,					__UpperCamelCase					:     Dict=4   ,					__UpperCamelCase					:     Optional[Any]=3_7   ,					__UpperCamelCase					:     str="gelu"   ,					__UpperCamelCase					:     Any=0.1   ,					__UpperCamelCase					:     int=0.1   ,					__UpperCamelCase					:     int=1_0   ,					__UpperCamelCase					:     Dict=0.02   ,					__UpperCamelCase					:     Any=None   ,					__UpperCamelCase					:     str=2   ,					):
            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_							  =					encoder_stride

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

     def    lowercase__      (	self					:     List[str]   ):
            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    lowercase__      (	self					:     Union[str, Any]   ):
            return ViTConfig(
                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=__UpperCamelCase   ,					initializer_range=self.initializer_range   ,					encoder_stride=self.encoder_stride   ,					)

     def    lowercase__      (	self					:     int   ,					__UpperCamelCase					:     str   ,					__UpperCamelCase					:     Optional[Any]   ,					__UpperCamelCase					:     int   ):
            lowerCamelCase_							  =					ViTModel(config=__UpperCamelCase   )
            model.to(__UpperCamelCase   )
            model.eval()
            lowerCamelCase_							  =					model(__UpperCamelCase   )
            self.parent.assertEqual(result.last_hidden_state.shape   ,					(self.batch_size, self.seq_length, self.hidden_size)   )

     def    lowercase__      (	self					:     List[str]   ,					__UpperCamelCase					:     Tuple   ,					__UpperCamelCase					:     Union[str, Any]   ,					__UpperCamelCase					:     List[Any]   ):
            lowerCamelCase_							  =					ViTForMaskedImageModeling(config=__UpperCamelCase   )
            model.to(__UpperCamelCase   )
            model.eval()
            lowerCamelCase_							  =					model(__UpperCamelCase   )
            self.parent.assertEqual(
                result.reconstruction.shape   ,					(self.batch_size, self.num_channels, self.image_size, self.image_size)   )

            # test greyscale images
            lowerCamelCase_							  =					1
            lowerCamelCase_							  =					ViTForMaskedImageModeling(__UpperCamelCase   )
            model.to(__UpperCamelCase   )
            model.eval()

            lowerCamelCase_							  =					floats_tensor([self.batch_size, 1, self.image_size, self.image_size]   )
            lowerCamelCase_							  =					model(__UpperCamelCase   )
            self.parent.assertEqual(result.reconstruction.shape   ,					(self.batch_size, 1, self.image_size, self.image_size)   )

     def    lowercase__      (	self					:     List[str]   ,					__UpperCamelCase					:     List[str]   ,					__UpperCamelCase					:     int   ,					__UpperCamelCase					:     Tuple   ):
            lowerCamelCase_							  =					self.type_sequence_label_size
            lowerCamelCase_							  =					ViTForImageClassification(__UpperCamelCase   )
            model.to(__UpperCamelCase   )
            model.eval()
            lowerCamelCase_							  =					model(__UpperCamelCase   ,					labels=__UpperCamelCase   )
            self.parent.assertEqual(result.logits.shape   ,					(self.batch_size, self.type_sequence_label_size)   )

            # test greyscale images
            lowerCamelCase_							  =					1
            lowerCamelCase_							  =					ViTForImageClassification(__UpperCamelCase   )
            model.to(__UpperCamelCase   )
            model.eval()

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



     def    lowercase__      (	self					:     int   ):
            lowerCamelCase_							  =					self.prepare_config_and_inputs()
            (
                (
                lowerCamelCase_   
            )  ,   (
                lowerCamelCase_   
            )  ,   (
                lowerCamelCase_   
            )  ,      
            )							  =					config_and_inputs
            lowerCamelCase_							  =					{"""pixel_values""": pixel_values}
            return config, inputs_dict





@require_torch
class       __A(				UpperCAmelCase     ,		UpperCAmelCase     ,		unittest.TestCase       ):
     SCREAMING_SNAKE_CASE			    =    (
         (
             ViTModel,
             ViTForImageClassification,
             ViTForMaskedImageModeling,
         )
         if is_torch_available()
         else ()
     )
     SCREAMING_SNAKE_CASE			    =    (
         {'''feature-extraction''': ViTModel, '''image-classification''': ViTForImageClassification}
         if is_torch_available()
         else {}
     )
     SCREAMING_SNAKE_CASE			    =    True

     SCREAMING_SNAKE_CASE			    =    False
     SCREAMING_SNAKE_CASE			    =    False
     SCREAMING_SNAKE_CASE			    =    False

     def    lowercase__      (	self					:     Dict   ):
            lowerCamelCase_							  =					ViTModelTester(self   )
            lowerCamelCase_							  =					ConfigTester(self   ,					config_class=__UpperCamelCase   ,					has_text_modality=__UpperCamelCase   ,					hidden_size=3_7   )

     def    lowercase__      (	self					:     List[str]   ):
            self.config_tester.run_common_tests()

     @unittest.skip(reason="""ViT does not use inputs_embeds"""   )
     def    lowercase__      (	self					:     List[Any]   ):
            pass

     def    lowercase__      (	self					:     Optional[int]   ):
            lowerCamelCase_  ,   lowerCamelCase_							  =					self.model_tester.prepare_config_and_inputs_for_common()

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

     def    lowercase__      (	self					:     Any   ):
            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    lowercase__      (	self					:     Dict   ):
            lowerCamelCase_							  =					self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_model(*__UpperCamelCase   )

     def    lowercase__      (	self					:     Optional[int]   ):
            lowerCamelCase_							  =					self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_masked_image_modeling(*__UpperCamelCase   )

     def    lowercase__      (	self					:     Dict   ):
            lowerCamelCase_							  =					self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_image_classification(*__UpperCamelCase   )



     @slow
     def    lowercase__      (	self					:     Union[str, Any]   ):
            for model_name in VIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                   lowerCamelCase_							  =					ViTModel.from_pretrained(__UpperCamelCase   )
                   self.assertIsNotNone(__UpperCamelCase   )



def      __lowerCAmelCase						(							)  ->    Dict:
       lowerCamelCase_							  =					Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""       )
       return image





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

     @cached_property
     def    lowercase__      (	self					:     Any   ):
            return ViTImageProcessor.from_pretrained("""google/vit-base-patch16-224"""   ) if is_vision_available() else None

     @slow
     def    lowercase__      (	self					:     Dict   ):
            lowerCamelCase_							  =					ViTForImageClassification.from_pretrained("""google/vit-base-patch16-224"""   ).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.2744, 0.8215, -0.0836]   ).to(__UpperCamelCase   )

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

     @slow
     def    lowercase__      (	self					:     Any   ):
            # ViT models have an `interpolate_pos_encoding` argument in their forward method,
            # allowing to interpolate the pre-trained position embeddings in order to use
            # the model on higher resolutions. The DINO model by Facebook AI leverages this
            # to visualize self-attention on higher resolution images.
            lowerCamelCase_							  =					ViTModel.from_pretrained("""facebook/dino-vits8"""   ).to(__UpperCamelCase   )

            lowerCamelCase_							  =					ViTImageProcessor.from_pretrained("""facebook/dino-vits8"""   ,					size=4_8_0   )
            lowerCamelCase_							  =					prepare_img()
            lowerCamelCase_							  =					image_processor(images=__UpperCamelCase   ,					return_tensors="""pt"""   )
            lowerCamelCase_							  =					inputs.pixel_values.to(__UpperCamelCase   )

            # forward pass
            with torch.no_grad():
                   lowerCamelCase_							  =					model(__UpperCamelCase   ,					interpolate_pos_encoding=__UpperCamelCase   )

            # verify the logits
            lowerCamelCase_							  =					torch.Size((1, 3_6_0_1, 3_8_4)   )
            self.assertEqual(outputs.last_hidden_state.shape   ,					__UpperCamelCase   )

            lowerCamelCase_							  =					torch.tensor(
                [[4.2340, 4.3906, -6.6692], [4.5463, 1.8928, -6.7257], [4.4429, 0.8496, -5.8585]]   ).to(__UpperCamelCase   )

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



     @slow
     @require_accelerate
     @require_torch_gpu
     def    lowercase__      (	self					:     List[Any]   ):
            lowerCamelCase_							  =					ViTModel.from_pretrained("""facebook/dino-vits8"""   ,					torch_dtype=torch.floataa   ,					device_map="""auto"""   )
            lowerCamelCase_							  =					self.default_image_processor

            lowerCamelCase_							  =					prepare_img()
            lowerCamelCase_							  =					image_processor(images=__UpperCamelCase   ,					return_tensors="""pt"""   )
            lowerCamelCase_							  =					inputs.pixel_values.to(__UpperCamelCase   )

            # forward pass to make sure inference works in fp16
            with torch.no_grad():
                   lowerCamelCase_							  =					model(__UpperCamelCase   )







from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_torch_available


lowercase        =  {'''configuration_speech_encoder_decoder''': ['''SpeechEncoderDecoderConfig''']}

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		lowercase        =  ['''SpeechEncoderDecoderModel''']

try:
		if not is_flax_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		lowercase        =  ['''FlaxSpeechEncoderDecoderModel''']

if TYPE_CHECKING:
		from .configuration_speech_encoder_decoder import SpeechEncoderDecoderConfig

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_speech_encoder_decoder import SpeechEncoderDecoderModel

		try:
				if not is_flax_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_flax_speech_encoder_decoder import FlaxSpeechEncoderDecoderModel

else:
		import sys

		lowercase        =  _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)





