


import gc
import random
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTextModelWithProjection, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DiffusionPipeline,
    EulerDiscreteScheduler,
    StableDiffusionXLImgaImgPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import floats_tensor, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import (
    IMAGE_TO_IMAGE_IMAGE_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_PARAMS,
)
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()






class _lowerCamelCase(		_a,				_a,				unittest.TestCase     ):
       lowercase_				:			Dict									=    StableDiffusionXLImgaImgPipeline
       lowercase_				:			Tuple									=    TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"""height""", """width"""}
       lowercase_				:			List[str]									=    PipelineTesterMixin.required_optional_params - {"""latents"""}
       lowercase_				:			Optional[Any]									=    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
       lowercase_				:			Tuple									=    IMAGE_TO_IMAGE_IMAGE_PARAMS
       lowercase_				:			Union[str, Any]									=    IMAGE_TO_IMAGE_IMAGE_PARAMS
       def     UpperCamelCase  (      self) ->     Tuple:




           """simple docstring"""

           torch.manual_seed(0)
           _lowercase :							Optional[int]   	=	UNetaDConditionModel(
               block_out_channels=(32, 64),   layers_per_block=2,   sample_size=32,   in_channels=4,   out_channels=4,   down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D'),   up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D'),   attention_head_dim=(2, 4),   use_linear_projection=lowerCamelCase,   addition_embed_type='text_time',   addition_time_embed_dim=8,   transformer_layers_per_block=(1, 2),   projection_class_embeddings_input_dim=80,   cross_attention_dim=64,   )
           _lowercase :							Tuple   	=	EulerDiscreteScheduler(
               beta_start=0.0_0_0_8_5,   beta_end=0.0_1_2,   steps_offset=1,   beta_schedule='scaled_linear',   timestep_spacing='leading',   )
           torch.manual_seed(0)
           _lowercase :							Dict   	=	AutoencoderKL(
               block_out_channels=[32, 64],   in_channels=3,   out_channels=3,   down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D'],   up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D'],   latent_channels=4,   sample_size=1_28,   )
           torch.manual_seed(0)
           _lowercase :							Dict   	=	CLIPTextConfig(
               bos_token_id=0,   eos_token_id=2,   hidden_size=32,   intermediate_size=37,   layer_norm_eps=1E-05,   num_attention_heads=4,   num_hidden_layers=5,   pad_token_id=1,   vocab_size=10_00,   hidden_act='gelu',   projection_dim=32,   )
           _lowercase :							Optional[int]   	=	CLIPTextModel(lowerCamelCase)
           _lowercase :							List[str]   	=	CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip',   local_files_only=lowerCamelCase)

           _lowercase :							str   	=	CLIPTextModelWithProjection(lowerCamelCase)
           _lowercase :							str   	=	CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip',   local_files_only=lowerCamelCase)

           _lowercase :							int   	=	{
               'unet': unet,
               'scheduler': scheduler,
               'vae': vae,
               'text_encoder': text_encoder,
               'tokenizer': tokenizer,
               'text_encoder_2': text_encoder_a,
               'tokenizer_2': tokenizer_a,
               # "safety_checker": None,
               # "feature_extractor": None,
           }
           return components
       def     UpperCamelCase  (      self,   lowerCamelCase,   lowerCamelCase=0) ->     List[str]:




           """simple docstring"""

           _lowercase :							Dict   	=	floats_tensor((1, 3, 32, 32),   rng=random.Random(lowerCamelCase)).to(lowerCamelCase)
           _lowercase :							Tuple   	=	image / 2 + 0.5
           if str(lowerCamelCase).startswith('mps'):
               _lowercase :							Union[str, Any]   	=	torch.manual_seed(lowerCamelCase)
           else:
               _lowercase :							Optional[int]   	=	torch.Generator(device=lowerCamelCase).manual_seed(lowerCamelCase)
           _lowercase :							Optional[int]   	=	{
               'prompt': 'A painting of a squirrel eating a burger',
               'image': image,
               'generator': generator,
               'num_inference_steps': 2,
               'guidance_scale': 5.0,
               'output_type': 'numpy',
               'strength': 0.7_5,
           }
           return inputs
       def     UpperCamelCase  (      self) ->     Tuple:




           """simple docstring"""

           _lowercase :							Optional[int]   	=	'cpu'  # ensure determinism for the device-dependent torch.Generator
           _lowercase :							List[Any]   	=	self.get_dummy_components()
           _lowercase :							Dict   	=	StableDiffusionXLImgaImgPipeline(**lowerCamelCase)
           _lowercase :							Optional[int]   	=	sd_pipe.to(lowerCamelCase)
           sd_pipe.set_progress_bar_config(disable=lowerCamelCase)

           _lowercase :							Any   	=	self.get_dummy_inputs(lowerCamelCase)
           _lowercase :							Dict   	=	sd_pipe(**lowerCamelCase).images
           _lowercase :							List[str]   	=	image[0, -3:, -3:, -1]

           assert image.shape == (1, 32, 32, 3)

           _lowercase :							Union[str, Any]   	=	np.array([0.4_6_5_6, 0.4_8_4_0, 0.4_4_3_9, 0.6_6_9_8, 0.5_5_7_4, 0.4_5_2_4, 0.5_7_9_9, 0.5_9_4_3, 0.5_1_6_5])

           assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2
       def     UpperCamelCase  (      self) ->     Optional[Any]:




           """simple docstring"""

           super().test_attention_slicing_forward_pass(expected_max_diff=3E-3)
       def     UpperCamelCase  (      self) ->     int:




           """simple docstring"""

           super().test_inference_batch_single_identical(expected_max_diff=3E-3)
       def     UpperCamelCase  (      self) ->     Optional[int]:




           """simple docstring"""

           pass




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




           """simple docstring"""

           _lowercase :							int   	=	self.get_dummy_components()
           _lowercase :							Any   	=	StableDiffusionXLImgaImgPipeline(**lowerCamelCase)
           _lowercase :							Dict   	=	sd_pipe.to(lowerCamelCase)
           _lowercase :							Optional[int]   	=	sd_pipe.to(lowerCamelCase)
           sd_pipe.set_progress_bar_config(disable=lowerCamelCase)

           # forward without prompt embeds
           _lowercase :							List[Any]   	=	self.get_dummy_inputs(lowerCamelCase)
           _lowercase :							Union[str, Any]   	=	3 * ['this is a negative prompt']
           _lowercase :							Optional[Any]   	=	negative_prompt
           _lowercase :							int   	=	3 * [inputs['prompt']]

           _lowercase :							Optional[Any]   	=	sd_pipe(**lowerCamelCase)
           _lowercase :							Optional[int]   	=	output.images[0, -3:, -3:, -1]

           # forward with prompt embeds
           _lowercase :							str   	=	self.get_dummy_inputs(lowerCamelCase)
           _lowercase :							Optional[int]   	=	3 * ['this is a negative prompt']
           _lowercase :							Tuple   	=	3 * [inputs.pop('prompt')]

           (
               _lowercase       
           ) :							Optional[int]   	=	sd_pipe.encode_prompt(lowerCamelCase,   negative_prompt=lowerCamelCase)

           _lowercase :							Union[str, Any]   	=	sd_pipe(
               **lowerCamelCase,   prompt_embeds=lowerCamelCase,   negative_prompt_embeds=lowerCamelCase,   pooled_prompt_embeds=lowerCamelCase,   negative_pooled_prompt_embeds=lowerCamelCase,   )
           _lowercase :							Optional[int]   	=	output.images[0, -3:, -3:, -1]

           # make sure that it's equal
           assert np.abs(image_slice_a.flatten() - image_slice_a.flatten()).max() < 1E-4






@slow
@require_torch_gpu
class _lowerCamelCase(		unittest.TestCase     ):
       def     UpperCamelCase  (      self) ->     Dict:




           """simple docstring"""

           super().tearDown()
           gc.collect()
           torch.cuda.empty_cache()
       def     UpperCamelCase  (      self,   lowerCamelCase,   lowerCamelCase="cpu",   lowerCamelCase=torch.floataa,   lowerCamelCase=0) ->     List[str]:




           """simple docstring"""

           _lowercase :							List[Any]   	=	torch.Generator(device=lowerCamelCase).manual_seed(lowerCamelCase)
           _lowercase :							str   	=	np.random.RandomState(lowerCamelCase).standard_normal((1, 4, 64, 64))
           _lowercase :							str   	=	torch.from_numpy(lowerCamelCase).to(device=lowerCamelCase,   dtype=lowerCamelCase)
           _lowercase :							Optional[int]   	=	{
               'prompt': 'a photograph of an astronaut riding a horse',
               'latents': latents,
               'generator': generator,
               'num_inference_steps': 3,
               'guidance_scale': 7.5,
               'output_type': 'numpy',
           }
           return inputs




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




           """simple docstring"""

           _lowercase :							Dict   	=	DiffusionPipeline.from_pretrained('stabilityai/stable-diffusion-2-base')
           pipe.to(lowerCamelCase)
           pipe.set_progress_bar_config(disable=lowerCamelCase)

           _lowercase :							Tuple   	=	self.get_inputs(lowerCamelCase)
           _lowercase :							Optional[int]   	=	pipe(**lowerCamelCase).images
           _lowercase :							List[Any]   	=	image[0, -3:, -3:, -1].flatten()

           assert image.shape == (1, 5_12, 5_12, 3)
           _lowercase :							Dict   	=	np.array([0.4_9_4_9_3, 0.4_7_8_9_6, 0.4_0_7_9_8, 0.5_4_2_1_4, 0.5_3_2_1_2, 0.4_8_2_0_2, 0.4_7_6_5_6, 0.4_6_3_2_9, 0.4_8_5_0_6])
           assert np.abs(image_slice - expected_slice).max() < 7E-3






import inspect
import unittest
import warnings

from transformers import DeiTConfig
from transformers.models.auto import get_values
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 (
     MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
     MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
     MODEL_MAPPING,
     DeiTForImageClassification,
     DeiTForImageClassificationWithTeacher,
     DeiTForMaskedImageModeling,
     DeiTModel,
 )
 from transformers.models.deit.modeling_deit import DEIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
 from PIL import Image

 from transformers import DeiTImageProcessor






class _lowerCamelCase:
       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.0_2,   lowerCamelCase=3,   lowerCamelCase=None,   lowerCamelCase=2,   ) ->     Optional[int]:




           """simple docstring"""

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

           # in DeiT, the seq length equals the number of patches + 2 (we add 2 for the [CLS] and distilation tokens)
           _lowercase :							Union[str, Any]   	=	(image_size // patch_size) ** 2
           _lowercase :							Any   	=	num_patches + 2
       def     UpperCamelCase  (      self) ->     str:




           """simple docstring"""

           _lowercase :							Optional[Any]   	=	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

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

           _lowercase :							str   	=	self.get_config()

           return config, pixel_values, labels
       def     UpperCamelCase  (      self) ->     int:




           """simple docstring"""

           return DeiTConfig(
               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=lowerCamelCase,   initializer_range=self.initializer_range,   encoder_stride=self.encoder_stride,   )
       def     UpperCamelCase  (      self,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase) ->     Optional[int]:




           """simple docstring"""

           _lowercase :							Any   	=	DeiTModel(config=lowerCamelCase)
           model.to(lowerCamelCase)
           model.eval()
           _lowercase :							Optional[int]   	=	model(lowerCamelCase)
           self.parent.assertEqual(result.last_hidden_state.shape,   (self.batch_size, self.seq_length, self.hidden_size))
       def     UpperCamelCase  (      self,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase) ->     int:




           """simple docstring"""

           _lowercase :							Optional[Any]   	=	DeiTForMaskedImageModeling(config=lowerCamelCase)
           model.to(lowerCamelCase)
           model.eval()
           _lowercase :							List[Any]   	=	model(lowerCamelCase)
           self.parent.assertEqual(
               result.reconstruction.shape,   (self.batch_size, self.num_channels, self.image_size, self.image_size))

           # test greyscale images
           _lowercase :							Any   	=	1
           _lowercase :							Optional[Any]   	=	DeiTForMaskedImageModeling(lowerCamelCase)
           model.to(lowerCamelCase)
           model.eval()

           _lowercase :							List[str]   	=	floats_tensor([self.batch_size, 1, self.image_size, self.image_size])
           _lowercase :							Optional[int]   	=	model(lowerCamelCase)
           self.parent.assertEqual(result.reconstruction.shape,   (self.batch_size, 1, self.image_size, self.image_size))
       def     UpperCamelCase  (      self,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase) ->     Any:




           """simple docstring"""

           _lowercase :							str   	=	self.type_sequence_label_size
           _lowercase :							Dict   	=	DeiTForImageClassification(lowerCamelCase)
           model.to(lowerCamelCase)
           model.eval()
           _lowercase :							List[Any]   	=	model(lowerCamelCase,   labels=lowerCamelCase)
           self.parent.assertEqual(result.logits.shape,   (self.batch_size, self.type_sequence_label_size))

           # test greyscale images
           _lowercase :							Optional[Any]   	=	1
           _lowercase :							Optional[Any]   	=	DeiTForImageClassification(lowerCamelCase)
           model.to(lowerCamelCase)
           model.eval()

           _lowercase :							List[str]   	=	floats_tensor([self.batch_size, 1, self.image_size, self.image_size])
           _lowercase :							List[Any]   	=	model(lowerCamelCase,   labels=lowerCamelCase)
           self.parent.assertEqual(result.logits.shape,   (self.batch_size, self.type_sequence_label_size))




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




           """simple docstring"""

           _lowercase :							Tuple   	=	self.prepare_config_and_inputs()
           (
               (
               _lowercase
           )	,       (
               _lowercase
           )	,       (
               _lowercase
           )	,       
           ) :							List[str]   	=	config_and_inputs
           _lowercase :							List[str]   	=	{'pixel_values': pixel_values}
           return config, inputs_dict






@require_torch
class _lowerCamelCase(		_a,				_a,				unittest.TestCase     ):
       lowercase_				:			Optional[Any]									=    (
           (
               DeiTModel,
               DeiTForImageClassification,
               DeiTForImageClassificationWithTeacher,
               DeiTForMaskedImageModeling,
           )
           if is_torch_available()
           else ()
       )
       lowercase_				:			Optional[Any]									=    (
           {
               """feature-extraction""": DeiTModel,
               """image-classification""": (DeiTForImageClassification, DeiTForImageClassificationWithTeacher),
           }
           if is_torch_available()
           else {}
       )

       lowercase_				:			Dict									=    False
       lowercase_				:			List[str]									=    False
       lowercase_				:			Union[str, Any]									=    False
       def     UpperCamelCase  (      self) ->     Optional[Any]:




           """simple docstring"""

           _lowercase :							int   	=	DeiTModelTester(self)
           _lowercase :							Optional[Any]   	=	ConfigTester(self,   config_class=lowerCamelCase,   has_text_modality=lowerCamelCase,   hidden_size=37)
       def     UpperCamelCase  (      self) ->     Union[str, Any]:




           """simple docstring"""

           self.config_tester.run_common_tests()
       @unittest.skip(reason='DeiT does not use inputs_embeds')
       def     UpperCamelCase  (      self) ->     str:




           """simple docstring"""

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




           """simple docstring"""

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

           for model_class in self.all_model_classes:
               _lowercase :							int   	=	model_class(lowerCamelCase)
               self.assertIsInstance(model.get_input_embeddings(),   (nn.Module))
               _lowercase :							Union[str, Any]   	=	model.get_output_embeddings()
               self.assertTrue(x is None or isinstance(lowerCamelCase,   nn.Linear))
       def     UpperCamelCase  (      self) ->     int:




           """simple docstring"""

           _lowercase	,       _lowercase :							Any   	=	self.model_tester.prepare_config_and_inputs_for_common()

           for model_class in self.all_model_classes:
               _lowercase :							Any   	=	model_class(lowerCamelCase)
               _lowercase :							Optional[Any]   	=	inspect.signature(model.forward)
               # signature.parameters is an OrderedDict => so arg_names order is deterministic
               _lowercase :							Union[str, Any]   	=	[*signature.parameters.keys()]

               _lowercase :							str   	=	['pixel_values']
               self.assertListEqual(arg_names[:1],   lowerCamelCase)
       def     UpperCamelCase  (      self) ->     List[str]:




           """simple docstring"""

           _lowercase :							Union[str, Any]   	=	self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_model(*lowerCamelCase)
       def     UpperCamelCase  (      self) ->     str:




           """simple docstring"""

           _lowercase :							Optional[int]   	=	self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_masked_image_modeling(*lowerCamelCase)
       def     UpperCamelCase  (      self) ->     List[str]:




           """simple docstring"""

           _lowercase :							int   	=	self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_image_classification(*lowerCamelCase)
       def     UpperCamelCase  (      self,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase=False) ->     Any:




           """simple docstring"""

           _lowercase :							Dict   	=	super()._prepare_for_class(lowerCamelCase,   lowerCamelCase,   return_labels=lowerCamelCase)

           if return_labels:
               if model_class.__name__ == "DeiTForImageClassificationWithTeacher":
                   del inputs_dict["labels"]

           return inputs_dict
       def     UpperCamelCase  (      self) ->     Optional[int]:




           """simple docstring"""

           if not self.model_tester.is_training:
               return

           _lowercase	,       _lowercase :							str   	=	self.model_tester.prepare_config_and_inputs_for_common()
           _lowercase :							Tuple   	=	True

           for model_class in self.all_model_classes:
               # DeiTForImageClassificationWithTeacher supports inference-only
               if (
                   model_class in get_values(lowerCamelCase)
                   or model_class.__name__ == "DeiTForImageClassificationWithTeacher"
               ):
                   continue
               _lowercase :							Optional[int]   	=	model_class(lowerCamelCase)
               model.to(lowerCamelCase)
               model.train()
               _lowercase :							Optional[Any]   	=	self._prepare_for_class(lowerCamelCase,   lowerCamelCase,   return_labels=lowerCamelCase)
               _lowercase :							List[str]   	=	model(**lowerCamelCase).loss
               loss.backward()
       def     UpperCamelCase  (      self) ->     Optional[Any]:




           """simple docstring"""

           _lowercase	,       _lowercase :							Union[str, Any]   	=	self.model_tester.prepare_config_and_inputs_for_common()
           if not self.model_tester.is_training:
               return

           _lowercase :							Dict   	=	False
           _lowercase :							Optional[int]   	=	True

           for model_class in self.all_model_classes:
               if model_class in get_values(lowerCamelCase) or not model_class.supports_gradient_checkpointing:
                   continue
               # DeiTForImageClassificationWithTeacher supports inference-only
               if model_class.__name__ == "DeiTForImageClassificationWithTeacher":
                   continue
               _lowercase :							str   	=	model_class(lowerCamelCase)
               model.gradient_checkpointing_enable()
               model.to(lowerCamelCase)
               model.train()
               _lowercase :							Union[str, Any]   	=	self._prepare_for_class(lowerCamelCase,   lowerCamelCase,   return_labels=lowerCamelCase)
               _lowercase :							List[Any]   	=	model(**lowerCamelCase).loss
               loss.backward()
       def     UpperCamelCase  (      self) ->     Union[str, Any]:




           """simple docstring"""

           _lowercase	,       _lowercase :							Optional[Any]   	=	self.model_tester.prepare_config_and_inputs_for_common()

           _lowercase :							int   	=	[
               {'title': 'multi_label_classification', 'num_labels': 2, 'dtype': torch.float},
               {'title': 'single_label_classification', 'num_labels': 1, 'dtype': torch.long},
               {'title': 'regression', 'num_labels': 1, 'dtype': torch.float},
           ]

           for model_class in self.all_model_classes:
               if (
                   model_class
                   not in [
                       *get_values(lowerCamelCase),
                       *get_values(lowerCamelCase),
                   ]
                   or model_class.__name__ == "DeiTForImageClassificationWithTeacher"
               ):
                   continue

               for problem_type in problem_types:
                   with self.subTest(msg=F'''Testing {model_class} with {problem_type["title"]}'''):
                       _lowercase :							List[Any]   	=	problem_type['title']
                       _lowercase :							str   	=	problem_type['num_labels']

                       _lowercase :							Optional[int]   	=	model_class(lowerCamelCase)
                       model.to(lowerCamelCase)
                       model.train()

                       _lowercase :							Tuple   	=	self._prepare_for_class(lowerCamelCase,   lowerCamelCase,   return_labels=lowerCamelCase)

                       if problem_type["num_labels"] > 1:
                           _lowercase :							Dict   	=	inputs['labels'].unsqueeze(1).repeat(1,   problem_type['num_labels'])

                       _lowercase :							Optional[int]   	=	inputs['labels'].to(problem_type['dtype'])

                       # This tests that we do not trigger the warning form PyTorch "Using a target size that is different
                       # to the input size. This will likely lead to incorrect results due to broadcasting. Please ensure
                       # they have the same size." which is a symptom something in wrong for the regression problem.
                       # See https://github.com/huggingface/transformers/issues/11780
                       with warnings.catch_warnings(record=lowerCamelCase) as warning_list:
                           _lowercase :							Dict   	=	model(**lowerCamelCase).loss
                       for w in warning_list:
                           if "Using a target size that is different to the input size" in str(w.message):
                               raise ValueError(
                                   F'''Something is going wrong in the regression problem: intercepted {w.message}''')

                       loss.backward()




       @slow
       def     UpperCamelCase  (      self) ->     str:




           """simple docstring"""

           for model_name in DEIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               _lowercase :							Tuple   	=	DeiTModel.from_pretrained(lowerCamelCase)
               self.assertIsNotNone(lowerCamelCase)



def        UpperCamelCase_(   )					->		List[str]:
    _lowercase :							Optional[Any]   	=	Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'				)
    return image






@require_torch
@require_vision
class _lowerCamelCase(		unittest.TestCase     ):
       @cached_property
       def     UpperCamelCase  (      self) ->     Dict:




           """simple docstring"""

           return (
               DeiTImageProcessor.from_pretrained('facebook/deit-base-distilled-patch16-224')
               if is_vision_available()
               else None
           )
       @slow
       def     UpperCamelCase  (      self) ->     Dict:




           """simple docstring"""

           _lowercase :							Optional[int]   	=	DeiTForImageClassificationWithTeacher.from_pretrained('facebook/deit-base-distilled-patch16-224').to(
               lowerCamelCase)

           _lowercase :							List[str]   	=	self.default_image_processor
           _lowercase :							List[str]   	=	prepare_img()
           _lowercase :							Tuple   	=	image_processor(images=lowerCamelCase,   return_tensors='pt').to(lowerCamelCase)

           # forward pass
           with torch.no_grad():
               _lowercase :							int   	=	model(**lowerCamelCase)

           # verify the logits
           _lowercase :							Any   	=	torch.Size((1, 10_00))
           self.assertEqual(outputs.logits.shape,   lowerCamelCase)

           _lowercase :							Union[str, Any]   	=	torch.tensor([-1.0_2_6_6, 0.1_9_1_2, -1.2_8_6_1]).to(lowerCamelCase)

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




       @slow
       @require_accelerate
       @require_torch_gpu
       def     UpperCamelCase  (      self) ->     List[Any]:




           """simple docstring"""

           _lowercase :							Tuple   	=	DeiTModel.from_pretrained(
               'facebook/deit-base-distilled-patch16-224',   torch_dtype=torch.floataa,   device_map='auto')
           _lowercase :							Union[str, Any]   	=	self.default_image_processor

           _lowercase :							Union[str, Any]   	=	prepare_img()
           _lowercase :							int   	=	image_processor(images=lowerCamelCase,   return_tensors='pt')
           _lowercase :							Union[str, Any]   	=	inputs.pixel_values.to(lowerCamelCase)

           # forward pass to make sure inference works in fp16
           with torch.no_grad():
               _lowercase :							Optional[int]   	=	model(lowerCamelCase)


