




import inspect
import unittest

from transformers import ViTHybridConfig
from transformers.testing_utils import require_accelerate, require_torch, 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, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
  import torch
  from torch import nn

  from transformers import ViTHybridForImageClassification, ViTHybridImageProcessor, ViTHybridModel
  from transformers.models.vit_hybrid.modeling_vit_hybrid import VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
  from PIL import Image


class 				UpperCamelCase_    :

    '''simple docstring'''






    def __init__(			self      :	List[str]					, UpperCAmelCase__      :	Optional[int]					, UpperCAmelCase__      :	List[str]=13					, UpperCAmelCase__      :	List[Any]=64					, UpperCAmelCase__      :	Optional[int]=2					, UpperCAmelCase__      :	List[str]=3					, UpperCAmelCase__      :	int=True					, UpperCAmelCase__      :	Optional[int]=True					, UpperCAmelCase__      :	List[Any]=32					, UpperCAmelCase__      :	Any=5					, UpperCAmelCase__      :	List[str]=4					, UpperCAmelCase__      :	Any=37					, UpperCAmelCase__      :	Dict="gelu"					, UpperCAmelCase__      :	List[Any]=0.1					, UpperCAmelCase__      :	Union[str, Any]=0.1					, UpperCAmelCase__      :	int=10					, UpperCAmelCase__      :	Tuple=0.02					, UpperCAmelCase__      :	Tuple=[1, 16, 4, 4]					, UpperCAmelCase__      :	Any=None					, )						->Tuple:





           '''simple docstring'''

           A__       =    parent
           A__       =    batch_size
           A__       =    image_size
           A__       =    patch_size
           A__       =    num_channels
           A__       =    is_training
           A__       =    use_labels
           A__       =    hidden_size
           A__       =    num_hidden_layers
           A__       =    num_attention_heads
           A__       =    intermediate_size
           A__       =    hidden_act
           A__       =    hidden_dropout_prob
           A__       =    attention_probs_dropout_prob
           A__       =    type_sequence_label_size
           A__       =    initializer_range
           A__       =    scope
           A__       =    backbone_featmap_shape

           # in ViT hybrid, the seq length equals the number of patches + 1 (we add 1 for the [CLS] token)
           # the number of patches is based on the feature map of the backbone, which by default uses an output stride
           # of 32, which means that the feature map has a spatial resolution of 1/32 of the input image size
           A__       =    (self.image_size // 32) ** 2
           A__       =    num_patches + 1


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





           '''simple docstring'''

           A__       =    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

           A__       =    None
           if self.use_labels:
                  A__       =    ids_tensor([self.batch_size]					, self.type_sequence_label_size)

           A__       =    self.get_config()

           return config, pixel_values, labels


    def        SCREAMING_SNAKE_CASE							(			self      :	Optional[Any])						->List[Any]:





           '''simple docstring'''

           A__       =    {
               '''global_padding''': '''same''',
               '''layer_type''': '''bottleneck''',
               '''depths''': [3, 4, 9],
               '''out_features''': ['''stage1''', '''stage2''', '''stage3'''],
               '''embedding_dynamic_padding''': True,
               '''hidden_sizes''': [4, 8, 16, 32],
               '''num_groups''': 2,
           }

           return ViTHybridConfig(
               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					, backbone_featmap_shape=self.backbone_featmap_shape					, backbone_config=UpperCAmelCase__					, )


    def        SCREAMING_SNAKE_CASE							(			self      :	Optional[int]					, UpperCAmelCase__      :	Union[str, Any]					, UpperCAmelCase__      :	List[Any]					, UpperCAmelCase__      :	int)						->Optional[int]:





           '''simple docstring'''

           A__       =    ViTHybridModel(config=UpperCAmelCase__)
           model.to(UpperCAmelCase__)
           model.eval()
           A__       =    model(UpperCAmelCase__)
           self.parent.assertEqual(result.last_hidden_state.shape					, (self.batch_size, self.seq_length, self.hidden_size))


    def        SCREAMING_SNAKE_CASE							(			self      :	Tuple					, UpperCAmelCase__      :	Union[str, Any]					, UpperCAmelCase__      :	Union[str, Any]					, UpperCAmelCase__      :	Optional[Any])						->Tuple:





           '''simple docstring'''

           A__       =    self.type_sequence_label_size
           A__       =    ViTHybridForImageClassification(UpperCAmelCase__)
           model.to(UpperCAmelCase__)
           model.eval()
           A__       =    model(UpperCAmelCase__					, labels=UpperCAmelCase__)
           self.parent.assertEqual(result.logits.shape					, (self.batch_size, self.type_sequence_label_size))





    def        SCREAMING_SNAKE_CASE							(			self      :	Any)						->Any:





           '''simple docstring'''

           A__       =    self.prepare_config_and_inputs()
           A__ ,							A__ ,							A__       =    config_and_inputs
           A__       =    {'''pixel_values''': pixel_values}
           return config, inputs_dict


@require_torch
class 				UpperCamelCase_    ( UpperCAmelCase__		,					UpperCAmelCase__		,					unittest.TestCase     ):

    '''simple docstring'''






    UpperCAmelCase__							  =      (ViTHybridModel, ViTHybridForImageClassification) if is_torch_available() else ()
    UpperCAmelCase__							  =      (
        {'''feature-extraction''': ViTHybridModel, '''image-classification''': ViTHybridForImageClassification}
        if is_torch_available()
        else {}
    )
    UpperCAmelCase__							  =      False
    UpperCAmelCase__							  =      False
    UpperCAmelCase__							  =      False


    def        SCREAMING_SNAKE_CASE							(			self      :	Dict)						->Dict:





           '''simple docstring'''

           A__       =    ViTHybridModelTester(self)
           A__       =    ConfigTester(self					, config_class=UpperCAmelCase__					, has_text_modality=UpperCAmelCase__					, hidden_size=37)


    def        SCREAMING_SNAKE_CASE							(			self      :	Optional[Any])						->Any:





           '''simple docstring'''

           self.config_tester.run_common_tests()


    @unittest.skip(reason='''ViT does not use inputs_embeds''')
    def        SCREAMING_SNAKE_CASE							(			self      :	str)						->Any:





           '''simple docstring'''

           pass


    def        SCREAMING_SNAKE_CASE							(			self      :	str)						->int:





           '''simple docstring'''

           A__ ,							A__       =    self.model_tester.prepare_config_and_inputs_for_common()

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


    def        SCREAMING_SNAKE_CASE							(			self      :	List[Any])						->Dict:





           '''simple docstring'''

           A__ ,							A__       =    self.model_tester.prepare_config_and_inputs_for_common()

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

                  A__       =    ['''pixel_values''']
                  self.assertListEqual(arg_names[:1]					, UpperCAmelCase__)


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





           '''simple docstring'''

           A__       =    self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_model(*UpperCAmelCase__)


    def        SCREAMING_SNAKE_CASE							(			self      :	Union[str, Any])						->Optional[int]:





           '''simple docstring'''

           A__       =    self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_image_classification(*UpperCAmelCase__)


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





           '''simple docstring'''

           A__ ,							A__       =    self.model_tester.prepare_config_and_inputs_for_common()

           A__       =    _config_zero_init(UpperCAmelCase__)
           for model_class in self.all_model_classes:
                  A__       =    model_class(config=UpperCAmelCase__)
                  # Skip the check for the backbone
                  for name, module in model.named_modules():
                         if module.__class__.__name__ == "ViTHybridPatchEmbeddings":
                                A__       =    [f"""{name}.{key}""" for key in module.state_dict().keys()]
                                break

                  for name, param in model.named_parameters():
                         if param.requires_grad:
                                if name in backbone_params:
                                       continue
                                self.assertIn(
                                    ((param.data.mean() * 1e9).round() / 1e9).item()					, [0.0, 1.0]					, msg=f"""Parameter {name} of model {model_class} seems not properly initialized"""					, )





    @slow
    def        SCREAMING_SNAKE_CASE							(			self      :	Optional[int])						->int:





           '''simple docstring'''

           for model_name in VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                  A__       =    ViTHybridModel.from_pretrained(UpperCAmelCase__)
                  self.assertIsNotNone(UpperCAmelCase__)







def SCREAMING_SNAKE_CASE				(       )   ->       List[str]:



       """simple docstring"""

       A__       =    Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''						)
       return image


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

    '''simple docstring'''






    @cached_property
    def        SCREAMING_SNAKE_CASE							(			self      :	List[str])						->Dict:





           '''simple docstring'''

           return (
               ViTHybridImageProcessor.from_pretrained(VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[0])
               if is_vision_available()
               else None
           )


    @slow
    def        SCREAMING_SNAKE_CASE							(			self      :	Tuple)						->Union[str, Any]:





           '''simple docstring'''

           A__       =    ViTHybridForImageClassification.from_pretrained(VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[0]).to(
               UpperCAmelCase__)

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

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

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

           A__       =    torch.tensor([-1.9090, -0.4993, -0.2389]).to(UpperCAmelCase__)

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





    @slow
    @require_accelerate
    def        SCREAMING_SNAKE_CASE							(			self      :	Union[str, Any])						->str:





           '''simple docstring'''

           A__       =    ViTHybridImageProcessor.from_pretrained('''google/vit-hybrid-base-bit-384''')
           A__       =    ViTHybridForImageClassification.from_pretrained('''google/vit-hybrid-base-bit-384'''					, device_map='''auto''')

           A__       =    prepare_img()

           A__       =    image_processor(images=UpperCAmelCase__					, return_tensors='''pt''')
           A__       =    model(**UpperCAmelCase__)
           A__       =    outputs.logits
           # model predicts one of the 1000 ImageNet classes
           A__       =    logits.argmax(-1).item()

           self.assertTrue(model.config.idalabel[predicted_class_idx]					, '''tabby, tabby cat''')








from ...processing_utils import ProcessorMixin


class 				UpperCamelCase_    ( UpperCAmelCase__     ):

    '''simple docstring'''






    UpperCAmelCase__							  =      '''SpeechT5FeatureExtractor'''
    UpperCAmelCase__							  =      '''SpeechT5Tokenizer'''


    def __init__(			self      :	Any					, UpperCAmelCase__      :	Dict					, UpperCAmelCase__      :	Tuple)						->Union[str, Any]:





           '''simple docstring'''

           super().__init__(UpperCAmelCase__					, UpperCAmelCase__)


    def __call__(			self      :	Dict					, *UpperCAmelCase__      :	List[str]					, **UpperCAmelCase__      :	Any)						->Optional[Any]:





           '''simple docstring'''

           A__       =    kwargs.pop('''audio'''					, UpperCAmelCase__)
           A__       =    kwargs.pop('''text'''					, UpperCAmelCase__)
           A__       =    kwargs.pop('''text_target'''					, UpperCAmelCase__)
           A__       =    kwargs.pop('''audio_target'''					, UpperCAmelCase__)
           A__       =    kwargs.pop('''sampling_rate'''					, UpperCAmelCase__)

           if audio is not None and text is not None:
                  raise ValueError(
                      '''Cannot process both `audio` and `text` inputs. Did you mean `audio_target` or `text_target`?''')
           if audio_target is not None and text_target is not None:
                  raise ValueError(
                      '''Cannot process both `audio_target` and `text_target` inputs. Did you mean `audio` or `text`?''')
           if audio is None and audio_target is None and text is None and text_target is None:
                  raise ValueError(
                      '''You need to specify either an `audio`, `audio_target`, `text`, or `text_target` input to process.''')

           if audio is not None:
                  A__       =    self.feature_extractor(UpperCAmelCase__					, *UpperCAmelCase__					, sampling_rate=UpperCAmelCase__					, **UpperCAmelCase__)
           elif text is not None:
                  A__       =    self.tokenizer(UpperCAmelCase__					, **UpperCAmelCase__)
           else:
                  A__       =    None

           if audio_target is not None:
                  A__       =    self.feature_extractor(audio_target=UpperCAmelCase__					, *UpperCAmelCase__					, sampling_rate=UpperCAmelCase__					, **UpperCAmelCase__)
                  A__       =    targets['''input_values''']
           elif text_target is not None:
                  A__       =    self.tokenizer(UpperCAmelCase__					, **UpperCAmelCase__)
                  A__       =    targets['''input_ids''']
           else:
                  A__       =    None

           if inputs is None:
                  return targets

           if targets is not None:
                  A__       =    labels

                  A__       =    targets.get('''attention_mask''')
                  if decoder_attention_mask is not None:
                         A__       =    decoder_attention_mask

           return inputs


    def        SCREAMING_SNAKE_CASE							(			self      :	Optional[Any]					, *UpperCAmelCase__      :	Tuple					, **UpperCAmelCase__      :	int)						->Optional[int]:





           '''simple docstring'''

           A__       =    kwargs.pop('''input_values'''					, UpperCAmelCase__)
           A__       =    kwargs.pop('''input_ids'''					, UpperCAmelCase__)
           A__       =    kwargs.pop('''labels'''					, UpperCAmelCase__)

           if input_values is not None and input_ids is not None:
                  raise ValueError('''Cannot process both `input_values` and `input_ids` inputs.''')
           if input_values is None and input_ids is None and labels is None:
                  raise ValueError(
                      '''You need to specify either an `input_values`, `input_ids`, or `labels` input to be padded.''')

           if input_values is not None:
                  A__       =    self.feature_extractor.pad(UpperCAmelCase__					, *UpperCAmelCase__					, **UpperCAmelCase__)
           elif input_ids is not None:
                  A__       =    self.tokenizer.pad(UpperCAmelCase__					, **UpperCAmelCase__)
           else:
                  A__       =    None

           if labels is not None:
                  if "input_ids" in labels or (isinstance(UpperCAmelCase__					, UpperCAmelCase__) and "input_ids" in labels[0]):
                         A__       =    self.tokenizer.pad(UpperCAmelCase__					, **UpperCAmelCase__)
                         A__       =    targets['''input_ids''']
                  else:
                         A__       =    self.feature_extractor.feature_size
                         A__       =    self.feature_extractor.num_mel_bins
                         A__       =    self.feature_extractor.pad(UpperCAmelCase__					, *UpperCAmelCase__					, **UpperCAmelCase__)
                         A__       =    feature_size_hack
                         A__       =    targets['''input_values''']
           else:
                  A__       =    None

           if inputs is None:
                  return targets

           if targets is not None:
                  A__       =    labels

                  A__       =    targets.get('''attention_mask''')
                  if decoder_attention_mask is not None:
                         A__       =    decoder_attention_mask

           return inputs


    def        SCREAMING_SNAKE_CASE							(			self      :	Any					, *UpperCAmelCase__      :	Dict					, **UpperCAmelCase__      :	Optional[Any])						->Optional[Any]:





           '''simple docstring'''

           return self.tokenizer.batch_decode(*UpperCAmelCase__					, **UpperCAmelCase__)





    def        SCREAMING_SNAKE_CASE							(			self      :	Optional[Any]					, *UpperCAmelCase__      :	List[Any]					, **UpperCAmelCase__      :	Union[str, Any])						->Dict:





           '''simple docstring'''

           return self.tokenizer.decode(*UpperCAmelCase__					, **UpperCAmelCase__)


