





"""simple docstring"""



import copy
import inspect
import unittest

from transformers import AutoBackbone
from transformers.configuration_utils import PretrainedConfig
from transformers.testing_utils import require_timm, require_torch, torch_device
from transformers.utils.import_utils import is_torch_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor


if is_torch_available():
       import torch

       from transformers import TimmBackbone, TimmBackboneConfig

from ...test_pipeline_mixin import PipelineTesterMixin






class 		__snake_case					:





 """simple docstring"""


 def __init__(    self					,						__lowerCamelCase					,						__lowerCamelCase=None					,						__lowerCamelCase=None					,						__lowerCamelCase=None					,						__lowerCamelCase="resnet50"					,						__lowerCamelCase=3					,						__lowerCamelCase=32					,						__lowerCamelCase=3					,						__lowerCamelCase=True					,						__lowerCamelCase=True					,						):



     '''simple docstring'''




     __A    :						Union[str, Any]						 =     parent
     __A    :						Tuple						 =     out_indices if out_indices is not None else [4]
     __A    :						Tuple						 =     stage_names
     __A    :						Dict						 =     out_features
     __A    :						int						 =     backbone
     __A    :						Dict						 =     batch_size
     __A    :						List[Any]						 =     image_size
     __A    :						Dict						 =     num_channels
     __A    :						str						 =     use_pretrained_backbone
     __A    :						List[Any]						 =     is_training

 def 					UpperCamelCase__(    self  ):



     '''simple docstring'''




     __A    :						Tuple						 =     floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )
     __A    :						Dict						 =     self.get_config()

     return config, pixel_values

 def 					UpperCamelCase__(    self  ):



     '''simple docstring'''




     return TimmBackboneConfig(
         image_size=self.image_size					,						num_channels=self.num_channels					,						out_features=self.out_features					,						out_indices=self.out_indices					,						stage_names=self.stage_names					,						use_pretrained_backbone=self.use_pretrained_backbone					,						backbone=self.backbone					,						)

 def 					UpperCamelCase__(    self					,						__lowerCamelCase					,						__lowerCamelCase  ):



     '''simple docstring'''




     __A    :						Union[str, Any]						 =     TimmBackbone(config=__lowerCamelCase  )
     model.to(__lowerCamelCase  )
     model.eval()
     with torch.no_grad():
         __A    :						Tuple						 =     model(__lowerCamelCase  )
     self.parent.assertEqual(
         result.feature_map[-1].shape					,						(self.batch_size, model.channels[-1], 14, 14)					,						)







 def 					UpperCamelCase__(    self  ):



     '''simple docstring'''




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






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





 """simple docstring"""


 _lowerCamelCase        =     (TimmBackbone,) if is_torch_available() else ()
 _lowerCamelCase        =     {"""feature-extraction""": TimmBackbone} if is_torch_available() else {}
 _lowerCamelCase        =     False
 _lowerCamelCase        =     False
 _lowerCamelCase        =     False
 _lowerCamelCase        =     False

 def 					UpperCamelCase__(    self  ):



     '''simple docstring'''




     __A    :						Any						 =     TimmBackboneModelTester(self  )
     __A    :						Optional[int]						 =     ConfigTester(self					,						config_class=__lowerCamelCase					,						has_text_modality=__lowerCamelCase  )

 def 					UpperCamelCase__(    self  ):



     '''simple docstring'''




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



     '''simple docstring'''




     __A    :						Union[str, Any]						 =     '''resnet18'''
     __A    :						Tuple						 =     '''microsoft/resnet-18'''

     __A    :						Tuple						 =     AutoBackbone.from_pretrained(__lowerCamelCase					,						use_timm_backbone=__lowerCamelCase  )
     __A    :						List[str]						 =     AutoBackbone.from_pretrained(__lowerCamelCase  )

     self.assertEqual(len(timm_model.out_features  )					,						len(transformers_model.out_features  )  )
     self.assertEqual(len(timm_model.stage_names  )					,						len(transformers_model.stage_names  )  )
     self.assertEqual(timm_model.channels					,						transformers_model.channels  )
     # Out indices are set to the last layer by default. For timm models, we don't know
     # the number of layers in advance, so we set it to (-1,), whereas for transformers
     # models, we set it to [len(stage_names) - 1] (kept for backward compatibility).
     self.assertEqual(timm_model.out_indices					,						(-1,)  )
     self.assertEqual(transformers_model.out_indices					,						[len(timm_model.stage_names  ) - 1]  )

     __A    :						Optional[int]						 =     AutoBackbone.from_pretrained(__lowerCamelCase					,						use_timm_backbone=__lowerCamelCase					,						out_indices=[1, 2, 3]  )
     __A    :						Dict						 =     AutoBackbone.from_pretrained(__lowerCamelCase					,						out_indices=[1, 2, 3]  )

     self.assertEqual(timm_model.out_indices					,						transformers_model.out_indices  )
     self.assertEqual(len(timm_model.out_features  )					,						len(transformers_model.out_features  )  )
     self.assertEqual(timm_model.channels					,						transformers_model.channels  )

 @unittest.skip('''TimmBackbone doesn\'t support feed forward chunking'''  )
 def 					UpperCamelCase__(    self  ):



     '''simple docstring'''




     pass

 @unittest.skip('''TimmBackbone doesn\'t have num_hidden_layers attribute'''  )
 def 					UpperCamelCase__(    self  ):



     '''simple docstring'''




     pass

 @unittest.skip('''TimmBackbone initialization is managed on the timm side'''  )
 def 					UpperCamelCase__(    self  ):



     '''simple docstring'''




     pass

 @unittest.skip('''TimmBackbone models doesn\'t have inputs_embeds'''  )
 def 					UpperCamelCase__(    self  ):



     '''simple docstring'''




     pass

 @unittest.skip('''TimmBackbone models doesn\'t have inputs_embeds'''  )
 def 					UpperCamelCase__(    self  ):



     '''simple docstring'''




     pass

 @unittest.skip('''TimmBackbone model cannot be created without specifying a backbone checkpoint'''  )
 def 					UpperCamelCase__(    self  ):



     '''simple docstring'''




     pass

 @unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone'''  )
 def 					UpperCamelCase__(    self  ):



     '''simple docstring'''




     pass

 @unittest.skip('''model weights aren\'t tied in TimmBackbone.'''  )
 def 					UpperCamelCase__(    self  ):



     '''simple docstring'''




     pass

 @unittest.skip('''model weights aren\'t tied in TimmBackbone.'''  )
 def 					UpperCamelCase__(    self  ):



     '''simple docstring'''




     pass

 @unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone'''  )
 def 					UpperCamelCase__(    self  ):



     '''simple docstring'''




     pass

 @unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone'''  )
 def 					UpperCamelCase__(    self  ):



     '''simple docstring'''




     pass

 @unittest.skip('''TimmBackbone doesn\'t have hidden size info in its configuration.'''  )
 def 					UpperCamelCase__(    self  ):



     '''simple docstring'''




     pass

 @unittest.skip('''TimmBackbone doesn\'t support output_attentions.'''  )
 def 					UpperCamelCase__(    self  ):



     '''simple docstring'''




     pass

 @unittest.skip('''Safetensors is not supported by timm.'''  )
 def 					UpperCamelCase__(    self  ):



     '''simple docstring'''




     pass

 @unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.'''  )
 def 					UpperCamelCase__(    self  ):



     '''simple docstring'''




     pass

 def 					UpperCamelCase__(    self  ):



     '''simple docstring'''




     __A ,       __A    :						Optional[int]						 =     self.model_tester.prepare_config_and_inputs_for_common()

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

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

 def 					UpperCamelCase__(    self  ):



     '''simple docstring'''




     __A ,       __A    :						List[str]						 =     self.model_tester.prepare_config_and_inputs_for_common()
     __A    :						Any						 =     True
     __A    :						List[str]						 =     self.has_attentions

     # no need to test all models as different heads yield the same functionality
     __A    :						Tuple						 =     self.all_model_classes[0]
     __A    :						Optional[Any]						 =     model_class(__lowerCamelCase  )
     model.to(__lowerCamelCase  )

     __A    :						List[Any]						 =     self._prepare_for_class(__lowerCamelCase					,						__lowerCamelCase  )
     __A    :						Tuple						 =     model(**__lowerCamelCase  )
     __A    :						List[str]						 =     outputs[0][-1]

     # Encoder-/Decoder-only models
     __A    :						Dict						 =     outputs.hidden_states[0]
     hidden_states.retain_grad()

     if self.has_attentions:
         __A    :						Optional[Any]						 =     outputs.attentions[0]
         attentions.retain_grad()

     output.flatten()[0].backward(retain_graph=__lowerCamelCase  )

     self.assertIsNotNone(hidden_states.grad  )

     if self.has_attentions:
         self.assertIsNotNone(attentions.grad  )







 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  )
         model.to(__lowerCamelCase  )
         model.eval()
         __A    :						Optional[int]						 =     model(**__lowerCamelCase  )

         self.assertEqual(len(result.feature_maps  )					,						len(config.out_indices  )  )
         self.assertEqual(len(model.channels  )					,						len(config.out_indices  )  )

         # Check output of last stage is taken if out_features=None, out_indices=None
         __A    :						Tuple						 =     copy.deepcopy(__lowerCamelCase  )
         __A    :						List[str]						 =     None
         __A    :						List[str]						 =     model_class(__lowerCamelCase  )
         model.to(__lowerCamelCase  )
         model.eval()
         __A    :						Union[str, Any]						 =     model(**__lowerCamelCase  )

         self.assertEqual(len(result.feature_maps  )					,						1  )
         self.assertEqual(len(model.channels  )					,						1  )

         # Check backbone can be initialized with fresh weights
         __A    :						int						 =     copy.deepcopy(__lowerCamelCase  )
         __A    :						Optional[Any]						 =     False
         __A    :						List[Any]						 =     model_class(__lowerCamelCase  )
         model.to(__lowerCamelCase  )
         model.eval()
         __A    :						Optional[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()




