





"""simple docstring"""



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 		__snake_case					:





 """simple docstring"""


 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					,						):



     '''simple docstring'''




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

     # in DeiT, the seq length equals the number of patches + 2 (we add 2 for the [CLS] and distilation tokens)
     __A    :						List[str]						 =     (image_size // patch_size) ** 2
     __A    :						Dict						 =     num_patches + 2

 def 					UpperCamelCase__(    self  ):



     '''simple docstring'''




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

     __A    :						int						 =     None
     if self.use_labels:
         __A    :						Optional[int]						 =     ids_tensor([self.batch_size]					,						self.type_sequence_label_size  )

     __A    :						List[Any]						 =     self.get_config()

     return config, pixel_values, labels

 def 					UpperCamelCase__(    self  ):



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



     '''simple docstring'''




     __A    :						Union[str, Any]						 =     DeiTModel(config=__lowerCamelCase  )
     model.to(__lowerCamelCase  )
     model.eval()
     __A    :						Optional[Any]						 =     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  ):



     '''simple docstring'''




     __A    :						List[str]						 =     DeiTForMaskedImageModeling(config=__lowerCamelCase  )
     model.to(__lowerCamelCase  )
     model.eval()
     __A    :						str						 =     model(__lowerCamelCase  )
     self.parent.assertEqual(
         result.reconstruction.shape					,						(self.batch_size, self.num_channels, self.image_size, self.image_size)  )

     # test greyscale images
     __A    :						Optional[int]						 =     1
     __A    :						Union[str, Any]						 =     DeiTForMaskedImageModeling(__lowerCamelCase  )
     model.to(__lowerCamelCase  )
     model.eval()

     __A    :						int						 =     floats_tensor([self.batch_size, 1, self.image_size, self.image_size]  )
     __A    :						List[Any]						 =     model(__lowerCamelCase  )
     self.parent.assertEqual(result.reconstruction.shape					,						(self.batch_size, 1, self.image_size, self.image_size)  )

 def 					UpperCamelCase__(    self					,						__lowerCamelCase					,						__lowerCamelCase					,						__lowerCamelCase  ):



     '''simple docstring'''




     __A    :						List[str]						 =     self.type_sequence_label_size
     __A    :						int						 =     DeiTForImageClassification(__lowerCamelCase  )
     model.to(__lowerCamelCase  )
     model.eval()
     __A    :						Optional[int]						 =     model(__lowerCamelCase					,						labels=__lowerCamelCase  )
     self.parent.assertEqual(result.logits.shape					,						(self.batch_size, self.type_sequence_label_size)  )

     # test greyscale images
     __A    :						Tuple						 =     1
     __A    :						str						 =     DeiTForImageClassification(__lowerCamelCase  )
     model.to(__lowerCamelCase  )
     model.eval()

     __A    :						Union[str, Any]						 =     floats_tensor([self.batch_size, 1, self.image_size, self.image_size]  )
     __A    :						Dict						 =     model(__lowerCamelCase					,						labels=__lowerCamelCase  )
     self.parent.assertEqual(result.logits.shape					,						(self.batch_size, self.type_sequence_label_size)  )







 def 					UpperCamelCase__(    self  ):



     '''simple docstring'''




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






@require_torch
class 		__snake_case					(		SCREAMING_SNAKE_CASE__							,							SCREAMING_SNAKE_CASE__							,							unittest.TestCase     ):





 """simple docstring"""


 _lowerCamelCase        =     (
     (
         DeiTModel,
         DeiTForImageClassification,
         DeiTForImageClassificationWithTeacher,
         DeiTForMaskedImageModeling,
     )
     if is_torch_available()
     else ()
 )
 _lowerCamelCase        =     (
     {
         """feature-extraction""": DeiTModel,
         """image-classification""": (DeiTForImageClassification, DeiTForImageClassificationWithTeacher),
     }
     if is_torch_available()
     else {}
 )

 _lowerCamelCase        =     False
 _lowerCamelCase        =     False
 _lowerCamelCase        =     False

 def 					UpperCamelCase__(    self  ):



     '''simple docstring'''




     __A    :						int						 =     DeiTModelTester(self  )
     __A    :						List[Any]						 =     ConfigTester(self					,						config_class=__lowerCamelCase					,						has_text_modality=__lowerCamelCase					,						hidden_size=37  )

 def 					UpperCamelCase__(    self  ):



     '''simple docstring'''




     self.config_tester.run_common_tests()

 @unittest.skip(reason='''DeiT does not use inputs_embeds'''  )
 def 					UpperCamelCase__(    self  ):



     '''simple docstring'''




     pass

 def 					UpperCamelCase__(    self  ):



     '''simple docstring'''




     __A ,       __A    :						Tuple						 =     self.model_tester.prepare_config_and_inputs_for_common()

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

 def 					UpperCamelCase__(    self  ):



     '''simple docstring'''




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

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

         __A    :						Any						 =     ['''pixel_values''']
         self.assertListEqual(arg_names[:1]					,						__lowerCamelCase  )

 def 					UpperCamelCase__(    self  ):



     '''simple docstring'''




     __A    :						Any						 =     self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(*__lowerCamelCase  )

 def 					UpperCamelCase__(    self  ):



     '''simple docstring'''




     __A    :						Any						 =     self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_masked_image_modeling(*__lowerCamelCase  )

 def 					UpperCamelCase__(    self  ):



     '''simple docstring'''




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



     '''simple docstring'''




     __A    :						List[Any]						 =     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  ):



     '''simple docstring'''




     if not self.model_tester.is_training:
         return

     __A ,       __A    :						str						 =     self.model_tester.prepare_config_and_inputs_for_common()
     __A    :						Any						 =     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
         __A    :						int						 =     model_class(__lowerCamelCase  )
         model.to(__lowerCamelCase  )
         model.train()
         __A    :						Dict						 =     self._prepare_for_class(__lowerCamelCase					,						__lowerCamelCase					,						return_labels=__lowerCamelCase  )
         __A    :						List[Any]						 =     model(**__lowerCamelCase  ).loss
         loss.backward()

 def 					UpperCamelCase__(    self  ):



     '''simple docstring'''




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

     __A    :						Dict						 =     False
     __A    :						str						 =     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
         __A    :						Any						 =     model_class(__lowerCamelCase  )
         model.gradient_checkpointing_enable()
         model.to(__lowerCamelCase  )
         model.train()
         __A    :						int						 =     self._prepare_for_class(__lowerCamelCase					,						__lowerCamelCase					,						return_labels=__lowerCamelCase  )
         __A    :						str						 =     model(**__lowerCamelCase  ).loss
         loss.backward()

 def 					UpperCamelCase__(    self  ):



     '''simple docstring'''




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

     __A    :						Optional[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']}"""  ):
                 __A    :						int						 =     problem_type['''title''']
                 __A    :						str						 =     problem_type['''num_labels''']

                 __A    :						Any						 =     model_class(__lowerCamelCase  )
                 model.to(__lowerCamelCase  )
                 model.train()

                 __A    :						Any						 =     self._prepare_for_class(__lowerCamelCase					,						__lowerCamelCase					,						return_labels=__lowerCamelCase  )

                 if problem_type["num_labels"] > 1:
                     __A    :						Union[str, Any]						 =     inputs['''labels'''].unsqueeze(1  ).repeat(1					,						problem_type['''num_labels''']  )

                 __A    :						Any						 =     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:
                     __A    :						Any						 =     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  ):



     '''simple docstring'''




     for model_name in DEIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         __A    :						Union[str, Any]						 =     DeiTModel.from_pretrained(__lowerCamelCase  )
         self.assertIsNotNone(__lowerCamelCase  )







def 		__lowercase     (   )   ->Optional[int]:



    '''simple docstring'''







    __A    :						Optional[int]						 =     Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''						)
    return image






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





 """simple docstring"""


 @cached_property
 def 					UpperCamelCase__(    self  ):



     '''simple docstring'''




     return (
         DeiTImageProcessor.from_pretrained('''facebook/deit-base-distilled-patch16-224'''  )
         if is_vision_available()
         else None
     )

 @slow
 def 					UpperCamelCase__(    self  ):



     '''simple docstring'''




     __A    :						int						 =     DeiTForImageClassificationWithTeacher.from_pretrained('''facebook/deit-base-distilled-patch16-224'''  ).to(
         __lowerCamelCase  )

     __A    :						str						 =     self.default_image_processor
     __A    :						List[str]						 =     prepare_img()
     __A    :						List[Any]						 =     image_processor(images=__lowerCamelCase					,						return_tensors='''pt'''  ).to(__lowerCamelCase  )

     # forward pass
     with torch.no_grad():
         __A    :						str						 =     model(**__lowerCamelCase  )

     # verify the logits
     __A    :						Optional[int]						 =     torch.Size((1, 1000)  )
     self.assertEqual(outputs.logits.shape					,						__lowerCamelCase  )

     __A    :						Tuple						 =     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  ):



     '''simple docstring'''




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

     __A    :						Any						 =     prepare_img()
     __A    :						List[Any]						 =     image_processor(images=__lowerCamelCase					,						return_tensors='''pt'''  )
     __A    :						List[Any]						 =     inputs.pixel_values.to(__lowerCamelCase  )

     # forward pass to make sure inference works in fp16
     with torch.no_grad():
         __A    :						Any						 =     model(__lowerCamelCase  )











"""simple docstring"""



# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import torch

from ..models.speechta import SpeechTaForTextToSpeech, SpeechTaHifiGan, SpeechTaProcessor
from ..utils import is_datasets_available
from .base import PipelineTool


if is_datasets_available():
       from datasets import load_dataset






class 		__snake_case					(		SCREAMING_SNAKE_CASE__     ):





 """simple docstring"""


 _lowerCamelCase        =     """microsoft/speecht5_tts"""
 _lowerCamelCase        =     (
     """This is a tool that reads an English text out loud. It takes an input named `text` which should contain the """
     """text to read (in English) and returns a waveform object containing the sound."""
 )
 _lowerCamelCase        =     """text_reader"""
 _lowerCamelCase        =     SpeechTaProcessor
 _lowerCamelCase        =     SpeechTaForTextToSpeech
 _lowerCamelCase        =     SpeechTaHifiGan

 _lowerCamelCase        =     ["""text"""]
 _lowerCamelCase        =     ["""audio"""]

 def 					UpperCamelCase__(    self  ):



     '''simple docstring'''




     if self.post_processor is None:
         __A    :						List[str]						 =     '''microsoft/speecht5_hifigan'''
     super().setup()

 def 					UpperCamelCase__(    self					,						__lowerCamelCase					,						__lowerCamelCase=None  ):



     '''simple docstring'''




     __A    :						int						 =     self.pre_processor(text=__lowerCamelCase					,						return_tensors='''pt'''					,						truncation=__lowerCamelCase  )

     if speaker_embeddings is None:
         if not is_datasets_available():
             raise ImportError('''Datasets needs to be installed if not passing speaker embeddings.'''  )

         __A    :						List[Any]						 =     load_dataset('''Matthijs/cmu-arctic-xvectors'''					,						split='''validation'''  )
         __A    :						int						 =     torch.tensor(embeddings_dataset[7305]['''xvector''']  ).unsqueeze(0  )

     return {"input_ids": inputs["input_ids"], "speaker_embeddings": speaker_embeddings}

 def 					UpperCamelCase__(    self					,						__lowerCamelCase  ):



     '''simple docstring'''




     with torch.no_grad():
         return self.model.generate_speech(**__lowerCamelCase  )







 def 					UpperCamelCase__(    self					,						__lowerCamelCase  ):



     '''simple docstring'''




     with torch.no_grad():
         return self.post_processor(__lowerCamelCase  ).cpu().detach()




