





'''simple docstring'''


import unittest

from transformers import BertGenerationConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
       import torch

       from transformers import BertGenerationDecoder, BertGenerationEncoder

class    lowerCAmelCase_		:




 def __init__(	self			,     _lowerCAmelCase			,     _lowerCAmelCase=13			,     _lowerCAmelCase=7			,     _lowerCAmelCase=True			,     _lowerCAmelCase=True			,     _lowerCAmelCase=99			,     _lowerCAmelCase=32			,     _lowerCAmelCase=5			,     _lowerCAmelCase=4			,     _lowerCAmelCase=37			,     _lowerCAmelCase="gelu"			,     _lowerCAmelCase=0.1			,     _lowerCAmelCase=0.1			,     _lowerCAmelCase=50			,     _lowerCAmelCase=0.02			,     _lowerCAmelCase=True			,     _lowerCAmelCase=None			,     )    ->							List[Any]:
     _lowerCAmelCase				=      parent
     _lowerCAmelCase				=      batch_size
     _lowerCAmelCase				=      seq_length
     _lowerCAmelCase				=      is_training
     _lowerCAmelCase				=      use_input_mask
     _lowerCAmelCase				=      vocab_size
     _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				=      max_position_embeddings
     _lowerCAmelCase				=      initializer_range
     _lowerCAmelCase				=      use_labels
     _lowerCAmelCase				=      scope




 def 							_snake_case   (	self		)    ->							Any:
     _lowerCAmelCase				=      ids_tensor([self.batch_size, self.seq_length]			,     self.vocab_size		)

     _lowerCAmelCase				=      None
     if self.use_input_mask:
         _lowerCAmelCase				=      random_attention_mask([self.batch_size, self.seq_length]		)

     if self.use_labels:
         _lowerCAmelCase				=      ids_tensor([self.batch_size, self.seq_length]			,     self.vocab_size		)

     _lowerCAmelCase				=      self.get_config()

     return config, input_ids, input_mask, token_labels




 def 							_snake_case   (	self		)    ->							List[Any]:
     return BertGenerationConfig(
         vocab_size=self.vocab_size			,     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			,     max_position_embeddings=self.max_position_embeddings			,     is_decoder=_lowerCAmelCase			,     initializer_range=self.initializer_range			,     )




 def 							_snake_case   (	self		)    ->							int:
     (
         (
         _lowerCAmelCase
     )			,			(
         _lowerCAmelCase
     )			,			(
         _lowerCAmelCase
     )			,			(
         _lowerCAmelCase
     )			,			
     )				=      self.prepare_config_and_inputs()

     _lowerCAmelCase				=      True
     _lowerCAmelCase				=      floats_tensor([self.batch_size, self.seq_length, self.hidden_size]		)
     _lowerCAmelCase				=      ids_tensor([self.batch_size, self.seq_length]			,     vocab_size=2		)

     return (
         config,
         input_ids,
         input_mask,
         token_labels,
         encoder_hidden_states,
         encoder_attention_mask,
     )




 def 							_snake_case   (	self			,     _lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase			,     **_lowerCAmelCase			,     )    ->							int:
     _lowerCAmelCase				=      BertGenerationEncoder(config=_lowerCAmelCase		)
     model.to(_lowerCAmelCase		)
     model.eval()
     _lowerCAmelCase				=      model(_lowerCAmelCase			,     attention_mask=_lowerCAmelCase		)
     _lowerCAmelCase				=      model(_lowerCAmelCase		)
     self.parent.assertEqual(result.last_hidden_state.shape			,     (self.batch_size, self.seq_length, self.hidden_size)		)




 def 							_snake_case   (	self			,     _lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase			,     **_lowerCAmelCase			,     )    ->							List[str]:
     _lowerCAmelCase				=      True
     _lowerCAmelCase				=      BertGenerationEncoder(config=_lowerCAmelCase		)
     model.to(_lowerCAmelCase		)
     model.eval()
     _lowerCAmelCase				=      model(
         _lowerCAmelCase			,     attention_mask=_lowerCAmelCase			,     encoder_hidden_states=_lowerCAmelCase			,     encoder_attention_mask=_lowerCAmelCase			,     )
     _lowerCAmelCase				=      model(
         _lowerCAmelCase			,     attention_mask=_lowerCAmelCase			,     encoder_hidden_states=_lowerCAmelCase			,     )
     self.parent.assertEqual(result.last_hidden_state.shape			,     (self.batch_size, self.seq_length, self.hidden_size)		)




 def 							_snake_case   (	self			,     _lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase			,     **_lowerCAmelCase			,     )    ->							Tuple:
     _lowerCAmelCase				=      True
     _lowerCAmelCase				=      True
     _lowerCAmelCase				=      BertGenerationDecoder(config=_lowerCAmelCase		).to(_lowerCAmelCase		).eval()

     # first forward pass
     _lowerCAmelCase				=      model(
         _lowerCAmelCase			,     attention_mask=_lowerCAmelCase			,     encoder_hidden_states=_lowerCAmelCase			,     encoder_attention_mask=_lowerCAmelCase			,     use_cache=_lowerCAmelCase			,     )
     _lowerCAmelCase				=      outputs.past_key_values

     # create hypothetical multiple next token and extent to next_input_ids
     _lowerCAmelCase				=      ids_tensor((self.batch_size, 3)			,     config.vocab_size		)
     _lowerCAmelCase				=      ids_tensor((self.batch_size, 3)			,     vocab_size=2		)

     # append to next input_ids and
     _lowerCAmelCase				=      torch.cat([input_ids, next_tokens]			,     dim=-1		)
     _lowerCAmelCase				=      torch.cat([input_mask, next_mask]			,     dim=-1		)

     _lowerCAmelCase				=      model(
         _lowerCAmelCase			,     attention_mask=_lowerCAmelCase			,     encoder_hidden_states=_lowerCAmelCase			,     encoder_attention_mask=_lowerCAmelCase			,     output_hidden_states=_lowerCAmelCase			,     )["hidden_states"][0]
     _lowerCAmelCase				=      model(
         _lowerCAmelCase			,     attention_mask=_lowerCAmelCase			,     encoder_hidden_states=_lowerCAmelCase			,     encoder_attention_mask=_lowerCAmelCase			,     past_key_values=_lowerCAmelCase			,     output_hidden_states=_lowerCAmelCase			,     )["hidden_states"][0]

     # select random slice
     _lowerCAmelCase				=      ids_tensor((1,)			,     output_from_past.shape[-1]		).item()
     _lowerCAmelCase				=      output_from_no_past[:, -3:, random_slice_idx].detach()
     _lowerCAmelCase				=      output_from_past[:, :, random_slice_idx].detach()

     self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1]		)

     # test that outputs are equal for slice
     self.parent.assertTrue(torch.allclose(_lowerCAmelCase			,     _lowerCAmelCase			,     atol=1E-3		)		)




 def 							_snake_case   (	self			,     _lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase			,     *_lowerCAmelCase			,     )    ->							Optional[int]:
     _lowerCAmelCase				=      BertGenerationDecoder(_lowerCAmelCase		)
     model.to(_lowerCAmelCase		)
     model.eval()
     _lowerCAmelCase				=      model(_lowerCAmelCase			,     attention_mask=_lowerCAmelCase			,     labels=_lowerCAmelCase		)
     self.parent.assertEqual(result.logits.shape			,     (self.batch_size, self.seq_length, self.vocab_size)		)





 def 							_snake_case   (	self		)    ->							Dict:
     _lowerCAmelCase			,			_lowerCAmelCase			,			_lowerCAmelCase			,			_lowerCAmelCase				=      self.prepare_config_and_inputs()
     _lowerCAmelCase				=      {"input_ids": input_ids, "attention_mask": input_mask}
     return config, inputs_dict







@require_torch
class    lowerCAmelCase_		(		__magic_name__						,__magic_name__						,__magic_name__						,unittest.TestCase		):
 __lowerCamelCase						:							Optional[int]         =					(BertGenerationEncoder, BertGenerationDecoder) if is_torch_available() else ()
 __lowerCamelCase						:							int         =					(BertGenerationDecoder,) if is_torch_available() else ()
 __lowerCamelCase						:							List[Any]         =					(
     {"feature-extraction": BertGenerationEncoder, "text-generation": BertGenerationDecoder}
     if is_torch_available()
     else {}
 )




 def 							_snake_case   (	self		)    ->							int:
     _lowerCAmelCase				=      BertGenerationEncoderTester(self		)
     _lowerCAmelCase				=      ConfigTester(self			,     config_class=_lowerCAmelCase			,     hidden_size=37		)




 def 							_snake_case   (	self		)    ->							Any:
     self.config_tester.run_common_tests()




 def 							_snake_case   (	self		)    ->							Optional[int]:
     _lowerCAmelCase				=      self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(*_lowerCAmelCase		)




 def 							_snake_case   (	self		)    ->							Optional[int]:
     _lowerCAmelCase			,			_lowerCAmelCase			,			_lowerCAmelCase			,			_lowerCAmelCase				=      self.model_tester.prepare_config_and_inputs()
     _lowerCAmelCase				=      "bert"
     self.model_tester.create_and_check_model(_lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase		)




 def 							_snake_case   (	self		)    ->							str:
     _lowerCAmelCase				=      self.model_tester.prepare_config_and_inputs_for_decoder()
     self.model_tester.create_and_check_model_as_decoder(*_lowerCAmelCase		)




 def 							_snake_case   (	self		)    ->							Optional[int]:
     _lowerCAmelCase				=      self.model_tester.prepare_config_and_inputs_for_decoder()
     self.model_tester.create_and_check_decoder_model_past_large_inputs(*_lowerCAmelCase		)




 def 							_snake_case   (	self		)    ->							Optional[int]:
     # This regression test was failing with PyTorch < 1.3
     (
         (
         _lowerCAmelCase
     )			,			(
         _lowerCAmelCase
     )			,			(
         _lowerCAmelCase
     )			,			(
         _lowerCAmelCase
     )			,			(
         _lowerCAmelCase
     )			,			(
         _lowerCAmelCase
     )			,			
     )				=      self.model_tester.prepare_config_and_inputs_for_decoder()

     _lowerCAmelCase				=      None

     self.model_tester.create_and_check_model_as_decoder(
         _lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase			,     )




 def 							_snake_case   (	self		)    ->							int:
     _lowerCAmelCase				=      self.model_tester.prepare_config_and_inputs_for_decoder()
     self.model_tester.create_and_check_for_causal_lm(*_lowerCAmelCase		)





 @slow
 def 							_snake_case   (	self		)    ->							Optional[int]:
     _lowerCAmelCase				=      BertGenerationEncoder.from_pretrained("google/bert_for_seq_generation_L-24_bbc_encoder"		)
     self.assertIsNotNone(_lowerCAmelCase		)







@require_torch
class    lowerCAmelCase_		(		unittest.TestCase		):




 @slow
 def 							_snake_case   (	self		)    ->							Optional[Any]:
     _lowerCAmelCase				=      BertGenerationEncoder.from_pretrained("google/bert_for_seq_generation_L-24_bbc_encoder"		)
     _lowerCAmelCase				=      torch.tensor([[101, 7592, 1010, 2026, 3899, 2003, 10140, 102]]		)
     with torch.no_grad():
         _lowerCAmelCase				=      model(_lowerCAmelCase		)[0]
     _lowerCAmelCase				=      torch.Size([1, 8, 1024]		)
     self.assertEqual(output.shape			,     _lowerCAmelCase		)
     _lowerCAmelCase				=      torch.tensor(
         [[[0.1775, 0.0083, -0.0321], [1.6002, 0.1287, 0.3912], [2.1473, 0.5791, 0.6066]]]		)
     self.assertTrue(torch.allclose(output[:, :3, :3]			,     _lowerCAmelCase			,     atol=1E-4		)		)







@require_torch
class    lowerCAmelCase_		(		unittest.TestCase		):




 @slow
 def 							_snake_case   (	self		)    ->							Dict:
     _lowerCAmelCase				=      BertGenerationDecoder.from_pretrained("google/bert_for_seq_generation_L-24_bbc_encoder"		)
     _lowerCAmelCase				=      torch.tensor([[101, 7592, 1010, 2026, 3899, 2003, 10140, 102]]		)
     with torch.no_grad():
         _lowerCAmelCase				=      model(_lowerCAmelCase		)[0]
     _lowerCAmelCase				=      torch.Size([1, 8, 50358]		)
     self.assertEqual(output.shape			,     _lowerCAmelCase		)
     _lowerCAmelCase				=      torch.tensor(
         [[[-0.5788, -2.5994, -3.7054], [0.0438, 4.7997, 1.8795], [1.5862, 6.6409, 4.4638]]]		)
     self.assertTrue(torch.allclose(output[:, :3, :3]			,     _lowerCAmelCase			,     atol=1E-4		)		)









'''simple docstring'''


from __future__ import annotations

import collections
import tempfile
import unittest

import numpy as np

from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import is_tf_available, is_vision_available

from ...test_modeling_tf_common import floats_tensor, ids_tensor, random_attention_mask
from ..bert.test_modeling_tf_bert import TFBertModelTester
from ..clip.test_modeling_tf_clip import TFCLIPVisionModelTester
from ..deit.test_modeling_tf_deit import TFDeiTModelTester
from ..roberta.test_modeling_tf_roberta import TFRobertaModelTester
from ..vit.test_modeling_tf_vit import TFViTModelTester


if is_tf_available():
       from transformers import (
           TFBertModel,
           TFCLIPVisionModel,
           TFDeiTModel,
           TFRobertaModel,
           TFVisionTextDualEncoderModel,
           TFViTModel,
           VisionTextDualEncoderConfig,
       )

if is_vision_available():
       from PIL import Image

       from transformers import VisionTextDualEncoderProcessor


def 	__a(SCREAMING_SNAKE_CASE_  :					str    ):



    '''simple docstring'''





    if isinstance(SCREAMING_SNAKE_CASE_		,       collections.abc.Iterable    ):
        return x
    return (x, x)

@require_tf
class    lowerCAmelCase_		:




 def 							_snake_case   (	self			,     _lowerCAmelCase			,     _lowerCAmelCase		)    ->							str:
     pass




 def 							_snake_case   (	self		)    ->							Dict:
     pass




 def 							_snake_case   (	self		)    ->							int:
     pass




 def 							_snake_case   (	self			,     _lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase=None			,     **_lowerCAmelCase		)    ->							Tuple:
     _lowerCAmelCase				=      VisionTextDualEncoderConfig.from_vision_text_configs(_lowerCAmelCase			,     _lowerCAmelCase		)

     _lowerCAmelCase				=      TFVisionTextDualEncoderModel(_lowerCAmelCase		)

     _lowerCAmelCase				=      model(input_ids=_lowerCAmelCase			,     pixel_values=_lowerCAmelCase			,     attention_mask=_lowerCAmelCase		)

     self.assertEqual(output["text_embeds"].shape			,     (input_ids.shape[0], config.projection_dim)		)
     self.assertEqual(output["image_embeds"].shape			,     (pixel_values.shape[0], config.projection_dim)		)




 def 							_snake_case   (	self			,     _lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase=None			,     **_lowerCAmelCase		)    ->							Tuple:
     _lowerCAmelCase			,			_lowerCAmelCase				=      self.get_vision_text_model(_lowerCAmelCase			,     _lowerCAmelCase		)
     _lowerCAmelCase				=      TFVisionTextDualEncoderModel(vision_model=_lowerCAmelCase			,     text_model=_lowerCAmelCase		)

     _lowerCAmelCase				=      model(input_ids=_lowerCAmelCase			,     pixel_values=_lowerCAmelCase			,     attention_mask=_lowerCAmelCase		)

     self.assertEqual(output["text_embeds"].shape			,     (input_ids.shape[0], model.config.projection_dim)		)
     self.assertEqual(output["image_embeds"].shape			,     (pixel_values.shape[0], model.config.projection_dim)		)




 def 							_snake_case   (	self			,     _lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase=None			,     **_lowerCAmelCase		)    ->							Tuple:
     _lowerCAmelCase			,			_lowerCAmelCase				=      self.get_vision_text_model(_lowerCAmelCase			,     _lowerCAmelCase		)
     _lowerCAmelCase				=      {"vision_model": vision_model, "text_model": text_model}
     _lowerCAmelCase				=      TFVisionTextDualEncoderModel.from_vision_text_pretrained(**_lowerCAmelCase		)

     _lowerCAmelCase				=      model(input_ids=_lowerCAmelCase			,     pixel_values=_lowerCAmelCase			,     attention_mask=_lowerCAmelCase		)

     self.assertEqual(output["text_embeds"].shape			,     (input_ids.shape[0], model.config.projection_dim)		)
     self.assertEqual(output["image_embeds"].shape			,     (pixel_values.shape[0], model.config.projection_dim)		)




 def 							_snake_case   (	self			,     _lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase=None			,     **_lowerCAmelCase		)    ->							Optional[int]:
     _lowerCAmelCase			,			_lowerCAmelCase				=      self.get_vision_text_model(_lowerCAmelCase			,     _lowerCAmelCase		)
     _lowerCAmelCase				=      TFVisionTextDualEncoderModel(vision_model=_lowerCAmelCase			,     text_model=_lowerCAmelCase		)

     _lowerCAmelCase				=      model(input_ids=_lowerCAmelCase			,     pixel_values=_lowerCAmelCase			,     attention_mask=_lowerCAmelCase		)
     _lowerCAmelCase				=      output[0].numpy()

     with tempfile.TemporaryDirectory() as tmpdirname:
         model.save_pretrained(_lowerCAmelCase		)
         _lowerCAmelCase				=      TFVisionTextDualEncoderModel.from_pretrained(_lowerCAmelCase		)

         _lowerCAmelCase				=      model(input_ids=_lowerCAmelCase			,     pixel_values=_lowerCAmelCase			,     attention_mask=_lowerCAmelCase		)
         _lowerCAmelCase				=      after_output[0].numpy()
         _lowerCAmelCase				=      np.amax(np.abs(out_a - out_a		)		)
         self.assertLessEqual(_lowerCAmelCase			,     1E-5		)




 def 							_snake_case   (	self			,     _lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase=None			,     **_lowerCAmelCase		)    ->							Dict:
     _lowerCAmelCase			,			_lowerCAmelCase				=      self.get_vision_text_model(_lowerCAmelCase			,     _lowerCAmelCase		)
     _lowerCAmelCase				=      TFVisionTextDualEncoderModel(vision_model=_lowerCAmelCase			,     text_model=_lowerCAmelCase		)

     _lowerCAmelCase				=      model(
         input_ids=_lowerCAmelCase			,     pixel_values=_lowerCAmelCase			,     attention_mask=_lowerCAmelCase			,     output_attentions=_lowerCAmelCase		)

     _lowerCAmelCase				=      output.vision_model_output.attentions
     self.assertEqual(len(_lowerCAmelCase		)			,     vision_config.num_hidden_layers		)

     # in ViT, the seq_len equals the number of patches + 1 (we add 1 for the [CLS] token)
     _lowerCAmelCase				=      to_atuple(vision_model.config.image_size		)
     _lowerCAmelCase				=      to_atuple(vision_model.config.patch_size		)
     _lowerCAmelCase				=      (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])
     _lowerCAmelCase				=      num_patches + 1
     self.assertEqual(vision_attentions[0].shape[-3:]			,     (vision_config.num_attention_heads, seq_len, seq_len)		)

     _lowerCAmelCase				=      output.text_model_output.attentions
     self.assertEqual(len(_lowerCAmelCase		)			,     text_config.num_hidden_layers		)

     self.assertEqual(
         text_attentions[0].shape[-3:]			,     (text_config.num_attention_heads, input_ids.shape[-1], input_ids.shape[-1])			,     )




 def 							_snake_case   (	self			,     _lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase		)    ->							Optional[int]:
     _lowerCAmelCase				=      np.abs((a - b)		).max()
     self.assertLessEqual(_lowerCAmelCase			,     _lowerCAmelCase			,     f'''Difference between torch and flax is {diff} (>= {tol}).'''		)




 def 							_snake_case   (	self		)    ->							Tuple:
     _lowerCAmelCase				=      self.prepare_config_and_inputs()
     self.check_vision_text_dual_encoder_model(**_lowerCAmelCase		)




 def 							_snake_case   (	self		)    ->							Optional[Any]:
     _lowerCAmelCase				=      self.prepare_config_and_inputs()
     self.check_model_from_pretrained_configs(**_lowerCAmelCase		)




 def 							_snake_case   (	self		)    ->							Union[str, Any]:
     _lowerCAmelCase				=      self.prepare_config_and_inputs()
     self.check_vision_text_dual_encoder_from_pretrained(**_lowerCAmelCase		)




 def 							_snake_case   (	self		)    ->							List[Any]:
     _lowerCAmelCase				=      self.prepare_config_and_inputs()
     self.check_save_load(**_lowerCAmelCase		)




 def 							_snake_case   (	self		)    ->							List[Any]:
     _lowerCAmelCase				=      self.prepare_config_and_inputs()
     self.check_vision_text_output_attention(**_lowerCAmelCase		)





 @slow
 def 							_snake_case   (	self		)    ->							List[Any]:
     _lowerCAmelCase			,			_lowerCAmelCase				=      self.get_pretrained_model_and_inputs()

     _lowerCAmelCase				=      model_a(**_lowerCAmelCase		)
     _lowerCAmelCase				=      outputs[0].numpy()

     with tempfile.TemporaryDirectory() as tmp_dirname:
         model_a.save_pretrained(_lowerCAmelCase		)
         _lowerCAmelCase				=      TFVisionTextDualEncoderModel.from_pretrained(_lowerCAmelCase		)

         _lowerCAmelCase				=      model_a(**_lowerCAmelCase		)
         _lowerCAmelCase				=      after_outputs[0].numpy()
         _lowerCAmelCase				=      np.amax(np.abs(out_a - out_a		)		)
         self.assertLessEqual(_lowerCAmelCase			,     1E-5		)







@require_tf
class    lowerCAmelCase_		(		__magic_name__						,unittest.TestCase		):




 def 							_snake_case   (	self		)    ->							Union[str, Any]:
     _lowerCAmelCase				=      TFVisionTextDualEncoderModel.from_vision_text_pretrained(
         "hf-internal-testing/tiny-random-vit"			,     "hf-internal-testing/tiny-random-bert"		)
     _lowerCAmelCase				=      13
     _lowerCAmelCase				=      floats_tensor(
         [
             batch_size,
             model.vision_model.config.num_channels,
             model.vision_model.config.image_size,
             model.vision_model.config.image_size,
         ]		)
     _lowerCAmelCase				=      ids_tensor([batch_size, 4]			,     model.text_model.config.vocab_size		)
     _lowerCAmelCase				=      random_attention_mask([batch_size, 4]		)
     _lowerCAmelCase				=      {"pixel_values": pixel_values, "input_ids": input_ids, "attention_mask": attention_mask}

     return model, inputs




 def 							_snake_case   (	self			,     _lowerCAmelCase			,     _lowerCAmelCase		)    ->							Optional[Any]:
     _lowerCAmelCase				=      TFViTModel(_lowerCAmelCase			,     name="vision_model"		)
     _lowerCAmelCase				=      TFBertModel(_lowerCAmelCase			,     name="text_model"		)
     return vision_model, text_model





 def 							_snake_case   (	self		)    ->							Optional[int]:
     _lowerCAmelCase				=      TFViTModelTester(self		)
     _lowerCAmelCase				=      TFBertModelTester(self		)
     _lowerCAmelCase				=      vit_model_tester.prepare_config_and_inputs()
     _lowerCAmelCase				=      bert_model_tester.prepare_config_and_inputs()

     _lowerCAmelCase			,			_lowerCAmelCase			,			_lowerCAmelCase				=      vision_config_and_inputs

     (
         (
         _lowerCAmelCase
     )			,			(
         _lowerCAmelCase
     )			,			(
         _lowerCAmelCase
     )			,			(
         _lowerCAmelCase
     )			,			(
         _lowerCAmelCase
     )			,			(
         _lowerCAmelCase
     )			,			(
         _lowerCAmelCase
     )			,			
     )				=      text_config_and_inputs

     return {
         "text_config": text_config,
         "vision_config": vision_config,
         "pixel_values": pixel_values,
         "attention_mask": input_mask,
         "input_ids": input_ids,
         "text_token_type_ids": token_type_ids,
         "text_sequence_labels": sequence_labels,
         "text_token_labels": token_labels,
         "text_choice_labels": choice_labels,
     }







@require_tf
class    lowerCAmelCase_		(		__magic_name__						,unittest.TestCase		):




 def 							_snake_case   (	self		)    ->							List[Any]:
     # DeiT repo doesn't have TF weights, but we don't actually use the weights at all so let's
     # just reinitialize it.
     _lowerCAmelCase				=      TFVisionTextDualEncoderModel.from_vision_text_pretrained(
         "Rocketknight1/tiny-random-deit-tf"			,     "hf-internal-testing/tiny-random-roberta"		)
     _lowerCAmelCase				=      13
     _lowerCAmelCase				=      floats_tensor(
         [
             batch_size,
             model.vision_model.config.num_channels,
             model.vision_model.config.image_size,
             model.vision_model.config.image_size,
         ]		)
     _lowerCAmelCase				=      ids_tensor([batch_size, 4]			,     model.text_model.config.vocab_size		)
     _lowerCAmelCase				=      random_attention_mask([batch_size, 4]		)
     _lowerCAmelCase				=      {"pixel_values": pixel_values, "input_ids": input_ids, "attention_mask": attention_mask}

     return model, inputs




 def 							_snake_case   (	self			,     _lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase=None			,     **_lowerCAmelCase		)    ->							int:
     _lowerCAmelCase			,			_lowerCAmelCase				=      self.get_vision_text_model(_lowerCAmelCase			,     _lowerCAmelCase		)
     _lowerCAmelCase				=      TFVisionTextDualEncoderModel(vision_model=_lowerCAmelCase			,     text_model=_lowerCAmelCase		)

     _lowerCAmelCase				=      model(
         input_ids=_lowerCAmelCase			,     pixel_values=_lowerCAmelCase			,     attention_mask=_lowerCAmelCase			,     output_attentions=_lowerCAmelCase		)

     _lowerCAmelCase				=      output.vision_model_output.attentions
     self.assertEqual(len(_lowerCAmelCase		)			,     vision_config.num_hidden_layers		)

     # in DEiT, the seq_len equals the number of patches + 2 (we add 2 for the [CLS] and distillation tokens)
     _lowerCAmelCase				=      to_atuple(vision_model.config.image_size		)
     _lowerCAmelCase				=      to_atuple(vision_model.config.patch_size		)
     _lowerCAmelCase				=      (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])
     _lowerCAmelCase				=      num_patches + 2
     self.assertEqual(vision_attentions[0].shape[-3:]			,     (vision_config.num_attention_heads, seq_len, seq_len)		)

     _lowerCAmelCase				=      output.text_model_output.attentions
     self.assertEqual(len(_lowerCAmelCase		)			,     text_config.num_hidden_layers		)

     self.assertEqual(
         text_attentions[0].shape[-3:]			,     (text_config.num_attention_heads, input_ids.shape[-1], input_ids.shape[-1])			,     )




 def 							_snake_case   (	self			,     _lowerCAmelCase			,     _lowerCAmelCase		)    ->							Optional[Any]:
     _lowerCAmelCase				=      TFDeiTModel(_lowerCAmelCase			,     name="vision_model"		)
     _lowerCAmelCase				=      TFRobertaModel(_lowerCAmelCase			,     name="text_model"		)
     return vision_model, text_model





 def 							_snake_case   (	self		)    ->							List[str]:
     _lowerCAmelCase				=      TFDeiTModelTester(self		)
     _lowerCAmelCase				=      TFRobertaModelTester(self		)
     _lowerCAmelCase				=      vit_model_tester.prepare_config_and_inputs()
     _lowerCAmelCase				=      bert_model_tester.prepare_config_and_inputs()

     _lowerCAmelCase			,			_lowerCAmelCase			,			_lowerCAmelCase				=      vision_config_and_inputs

     (
         (
         _lowerCAmelCase
     )			,			(
         _lowerCAmelCase
     )			,			(
         _lowerCAmelCase
     )			,			(
         _lowerCAmelCase
     )			,			(
         _lowerCAmelCase
     )			,			(
         _lowerCAmelCase
     )			,			(
         _lowerCAmelCase
     )			,			
     )				=      text_config_and_inputs

     return {
         "text_config": text_config,
         "vision_config": vision_config,
         "pixel_values": pixel_values,
         "attention_mask": input_mask,
         "input_ids": input_ids,
         "text_token_type_ids": token_type_ids,
         "text_sequence_labels": sequence_labels,
         "text_token_labels": token_labels,
         "text_choice_labels": choice_labels,
     }







@require_tf
class    lowerCAmelCase_		(		__magic_name__						,unittest.TestCase		):




 def 							_snake_case   (	self		)    ->							Any:
     _lowerCAmelCase				=      TFVisionTextDualEncoderModel.from_vision_text_pretrained(
         "Rocketknight1/tiny-random-clip-tf"			,     "hf-internal-testing/tiny-random-bert"		)
     _lowerCAmelCase				=      13
     _lowerCAmelCase				=      floats_tensor(
         [
             batch_size,
             model.vision_model.config.num_channels,
             model.vision_model.config.image_size,
             model.vision_model.config.image_size,
         ]		)
     _lowerCAmelCase				=      ids_tensor([batch_size, 4]			,     model.text_model.config.vocab_size		)
     _lowerCAmelCase				=      random_attention_mask([batch_size, 4]		)
     _lowerCAmelCase				=      {"pixel_values": pixel_values, "input_ids": input_ids, "attention_mask": attention_mask}

     return model, inputs




 def 							_snake_case   (	self			,     _lowerCAmelCase			,     _lowerCAmelCase		)    ->							int:
     _lowerCAmelCase				=      TFCLIPVisionModel(_lowerCAmelCase			,     name="vision_model"		)
     _lowerCAmelCase				=      TFBertModel(_lowerCAmelCase			,     name="text_model"		)
     return vision_model, text_model





 def 							_snake_case   (	self		)    ->							Union[str, Any]:
     _lowerCAmelCase				=      TFCLIPVisionModelTester(self		)
     _lowerCAmelCase				=      TFBertModelTester(self		)
     _lowerCAmelCase				=      clip_model_tester.prepare_config_and_inputs()
     _lowerCAmelCase				=      bert_model_tester.prepare_config_and_inputs()

     _lowerCAmelCase			,			_lowerCAmelCase				=      vision_config_and_inputs

     (
         (
         _lowerCAmelCase
     )			,			(
         _lowerCAmelCase
     )			,			(
         _lowerCAmelCase
     )			,			(
         _lowerCAmelCase
     )			,			(
         _lowerCAmelCase
     )			,			(
         _lowerCAmelCase
     )			,			(
         _lowerCAmelCase
     )			,			
     )				=      text_config_and_inputs

     return {
         "text_config": text_config,
         "vision_config": vision_config,
         "pixel_values": pixel_values,
         "attention_mask": input_mask,
         "input_ids": input_ids,
         "text_token_type_ids": token_type_ids,
         "text_sequence_labels": sequence_labels,
         "text_token_labels": token_labels,
         "text_choice_labels": choice_labels,
     }







@require_vision
@require_tf
class    lowerCAmelCase_		(		unittest.TestCase		):




 @slow
 def 							_snake_case   (	self		)    ->							Union[str, Any]:
     _lowerCAmelCase				=      TFVisionTextDualEncoderModel.from_pretrained(
         "clip-italian/clip-italian"			,     logit_scale_init_value=1.0			,     from_pt=_lowerCAmelCase		)
     _lowerCAmelCase				=      VisionTextDualEncoderProcessor.from_pretrained("clip-italian/clip-italian"		)

     _lowerCAmelCase				=      Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"		)
     _lowerCAmelCase				=      processor(
         text=["una foto di un gatto", "una foto di un cane"]			,     images=_lowerCAmelCase			,     padding=_lowerCAmelCase			,     return_tensors="np"		)

     _lowerCAmelCase				=      model(**_lowerCAmelCase		)

     # verify the logits
     self.assertEqual(outputs.logits_per_image.shape			,     (inputs.pixel_values.shape[0], inputs.input_ids.shape[0])		)
     self.assertEqual(
         outputs.logits_per_text.shape			,     (inputs.input_ids.shape[0], inputs.pixel_values.shape[0])			,     )

     _lowerCAmelCase				=      np.array([[1.2284727, 0.3104122]]		)

     self.assertTrue(np.allclose(outputs.logits_per_image.numpy()			,     _lowerCAmelCase			,     atol=1E-3		)		)


