





'''simple docstring'''


import argparse
import os
import re

import tensorflow as tf
import torch

from transformers import BertConfig, BertModel
from transformers.utils import logging


logging.set_verbosity_info()
_SCREAMING_SNAKE_CASE	 =							logging.get_logger(__name__)


def 	__a(SCREAMING_SNAKE_CASE_  :					Optional[Any]		,       SCREAMING_SNAKE_CASE_  :					List[str]		,       SCREAMING_SNAKE_CASE_  :					List[Any]    ):



    '''simple docstring'''





    _lowerCAmelCase				=      os.path.abspath(SCREAMING_SNAKE_CASE_    )
    logger.info(F'''Converting TensorFlow checkpoint from {tf_path}'''    )
    # Load weights from TF model
    _lowerCAmelCase				=      tf.train.list_variables(SCREAMING_SNAKE_CASE_    )
    _lowerCAmelCase				=      []
    _lowerCAmelCase				=      []
    _lowerCAmelCase				=      []
    for full_name, shape in init_vars:
        # logger.info(f"Loading TF weight {name} with shape {shape}")
        _lowerCAmelCase				=      full_name.split("/"    )
        if full_name == "_CHECKPOINTABLE_OBJECT_GRAPH" or name[0] in ["global_step", "save_counter"]:
            logger.info(F'''Skipping non-model layer {full_name}'''    )
            continue
        if "optimizer" in full_name:
            logger.info(F'''Skipping optimization layer {full_name}'''    )
            continue
        if name[0] == "model":
            # ignore initial 'model'
            _lowerCAmelCase				=      name[1:]
        # figure out how many levels deep the name is
        _lowerCAmelCase				=      0
        for _name in name:
            if _name.startswith("layer_with_weights"    ):
                depth += 1
            else:
                break
        layer_depth.append(SCREAMING_SNAKE_CASE_    )
        # read data
        _lowerCAmelCase				=      tf.train.load_variable(SCREAMING_SNAKE_CASE_		,       SCREAMING_SNAKE_CASE_    )
        names.append("/".join(SCREAMING_SNAKE_CASE_    )    )
        arrays.append(SCREAMING_SNAKE_CASE_    )
    logger.info(F'''Read a total of {len(SCREAMING_SNAKE_CASE_    ):,} layers'''    )

    # Sanity check
    if len(set(SCREAMING_SNAKE_CASE_    )    ) != 1:
        raise ValueError(F'''Found layer names with different depths (layer depth {list(set(SCREAMING_SNAKE_CASE_    )    )})'''    )
    _lowerCAmelCase				=      list(set(SCREAMING_SNAKE_CASE_    )    )[0]
    if layer_depth != 1:
        raise ValueError(
            "The model contains more than just the embedding/encoder layers. This script does not handle MLM/NSP"
            " heads."    )

    # convert layers
    logger.info("Converting weights..."    )
    for full_name, array in zip(SCREAMING_SNAKE_CASE_		,       SCREAMING_SNAKE_CASE_    ):
        _lowerCAmelCase				=      full_name.split("/"    )
        _lowerCAmelCase				=      model
        _lowerCAmelCase				=      []
        for i, m_name in enumerate(SCREAMING_SNAKE_CASE_    ):
            if m_name == ".ATTRIBUTES":
                # variable names end with .ATTRIBUTES/VARIABLE_VALUE
                break
            if m_name.startswith("layer_with_weights"    ):
                _lowerCAmelCase				=      int(m_name.split("-"    )[-1]    )
                if layer_num <= 2:
                    # embedding layers
                    # layer_num 0: word_embeddings
                    # layer_num 1: position_embeddings
                    # layer_num 2: token_type_embeddings
                    continue
                elif layer_num == 3:
                    # embedding LayerNorm
                    trace.extend(["embeddings", "LayerNorm"]    )
                    _lowerCAmelCase				=      getattr(SCREAMING_SNAKE_CASE_		,       "embeddings"    )
                    _lowerCAmelCase				=      getattr(SCREAMING_SNAKE_CASE_		,       "LayerNorm"    )
                elif layer_num > 3 and layer_num < config.num_hidden_layers + 4:
                    # encoder layers
                    trace.extend(["encoder", "layer", str(layer_num - 4    )]    )
                    _lowerCAmelCase				=      getattr(SCREAMING_SNAKE_CASE_		,       "encoder"    )
                    _lowerCAmelCase				=      getattr(SCREAMING_SNAKE_CASE_		,       "layer"    )
                    _lowerCAmelCase				=      pointer[layer_num - 4]
                elif layer_num == config.num_hidden_layers + 4:
                    # pooler layer
                    trace.extend(["pooler", "dense"]    )
                    _lowerCAmelCase				=      getattr(SCREAMING_SNAKE_CASE_		,       "pooler"    )
                    _lowerCAmelCase				=      getattr(SCREAMING_SNAKE_CASE_		,       "dense"    )
            elif m_name == "embeddings":
                trace.append("embeddings"    )
                _lowerCAmelCase				=      getattr(SCREAMING_SNAKE_CASE_		,       "embeddings"    )
                if layer_num == 0:
                    trace.append("word_embeddings"    )
                    _lowerCAmelCase				=      getattr(SCREAMING_SNAKE_CASE_		,       "word_embeddings"    )
                elif layer_num == 1:
                    trace.append("position_embeddings"    )
                    _lowerCAmelCase				=      getattr(SCREAMING_SNAKE_CASE_		,       "position_embeddings"    )
                elif layer_num == 2:
                    trace.append("token_type_embeddings"    )
                    _lowerCAmelCase				=      getattr(SCREAMING_SNAKE_CASE_		,       "token_type_embeddings"    )
                else:
                    raise ValueError(F'''Unknown embedding layer with name {full_name}'''    )
                trace.append("weight"    )
                _lowerCAmelCase				=      getattr(SCREAMING_SNAKE_CASE_		,       "weight"    )
            elif m_name == "_attention_layer":
                # self-attention layer
                trace.extend(["attention", "self"]    )
                _lowerCAmelCase				=      getattr(SCREAMING_SNAKE_CASE_		,       "attention"    )
                _lowerCAmelCase				=      getattr(SCREAMING_SNAKE_CASE_		,       "self"    )
            elif m_name == "_attention_layer_norm":
                # output attention norm
                trace.extend(["attention", "output", "LayerNorm"]    )
                _lowerCAmelCase				=      getattr(SCREAMING_SNAKE_CASE_		,       "attention"    )
                _lowerCAmelCase				=      getattr(SCREAMING_SNAKE_CASE_		,       "output"    )
                _lowerCAmelCase				=      getattr(SCREAMING_SNAKE_CASE_		,       "LayerNorm"    )
            elif m_name == "_attention_output_dense":
                # output attention dense
                trace.extend(["attention", "output", "dense"]    )
                _lowerCAmelCase				=      getattr(SCREAMING_SNAKE_CASE_		,       "attention"    )
                _lowerCAmelCase				=      getattr(SCREAMING_SNAKE_CASE_		,       "output"    )
                _lowerCAmelCase				=      getattr(SCREAMING_SNAKE_CASE_		,       "dense"    )
            elif m_name == "_output_dense":
                # output dense
                trace.extend(["output", "dense"]    )
                _lowerCAmelCase				=      getattr(SCREAMING_SNAKE_CASE_		,       "output"    )
                _lowerCAmelCase				=      getattr(SCREAMING_SNAKE_CASE_		,       "dense"    )
            elif m_name == "_output_layer_norm":
                # output dense
                trace.extend(["output", "LayerNorm"]    )
                _lowerCAmelCase				=      getattr(SCREAMING_SNAKE_CASE_		,       "output"    )
                _lowerCAmelCase				=      getattr(SCREAMING_SNAKE_CASE_		,       "LayerNorm"    )
            elif m_name == "_key_dense":
                # attention key
                trace.append("key"    )
                _lowerCAmelCase				=      getattr(SCREAMING_SNAKE_CASE_		,       "key"    )
            elif m_name == "_query_dense":
                # attention query
                trace.append("query"    )
                _lowerCAmelCase				=      getattr(SCREAMING_SNAKE_CASE_		,       "query"    )
            elif m_name == "_value_dense":
                # attention value
                trace.append("value"    )
                _lowerCAmelCase				=      getattr(SCREAMING_SNAKE_CASE_		,       "value"    )
            elif m_name == "_intermediate_dense":
                # attention intermediate dense
                trace.extend(["intermediate", "dense"]    )
                _lowerCAmelCase				=      getattr(SCREAMING_SNAKE_CASE_		,       "intermediate"    )
                _lowerCAmelCase				=      getattr(SCREAMING_SNAKE_CASE_		,       "dense"    )
            elif m_name == "_output_layer_norm":
                # output layer norm
                trace.append("output"    )
                _lowerCAmelCase				=      getattr(SCREAMING_SNAKE_CASE_		,       "output"    )
            # weights & biases
            elif m_name in ["bias", "beta"]:
                trace.append("bias"    )
                _lowerCAmelCase				=      getattr(SCREAMING_SNAKE_CASE_		,       "bias"    )
            elif m_name in ["kernel", "gamma"]:
                trace.append("weight"    )
                _lowerCAmelCase				=      getattr(SCREAMING_SNAKE_CASE_		,       "weight"    )
            else:
                logger.warning(F'''Ignored {m_name}'''    )
        # for certain layers reshape is necessary
        _lowerCAmelCase				=      ".".join(SCREAMING_SNAKE_CASE_    )
        if re.match(R"(\S+)\.attention\.self\.(key|value|query)\.(bias|weight)"		,       SCREAMING_SNAKE_CASE_    ) or re.match(
            R"(\S+)\.attention\.output\.dense\.weight"		,       SCREAMING_SNAKE_CASE_    ):
            _lowerCAmelCase				=      array.reshape(pointer.data.shape    )
        if "kernel" in full_name:
            _lowerCAmelCase				=      array.transpose()
        if pointer.shape == array.shape:
            _lowerCAmelCase				=      torch.from_numpy(SCREAMING_SNAKE_CASE_    )
        else:
            raise ValueError(
                F'''Shape mismatch in layer {full_name}: Model expects shape {pointer.shape} but layer contains shape:'''
                F''' {array.shape}'''    )
        logger.info(F'''Successfully set variable {full_name} to PyTorch layer {trace}'''    )
    return model


def 	__a(SCREAMING_SNAKE_CASE_  :					str		,       SCREAMING_SNAKE_CASE_  :					Union[str, Any]		,       SCREAMING_SNAKE_CASE_  :					List[Any]    ):



    '''simple docstring'''





    logger.info(F'''Loading model based on config from {config_path}...'''    )
    _lowerCAmelCase				=      BertConfig.from_json_file(SCREAMING_SNAKE_CASE_    )
    _lowerCAmelCase				=      BertModel(SCREAMING_SNAKE_CASE_    )

    # Load weights from checkpoint
    logger.info(F'''Loading weights from checkpoint {tf_checkpoint_path}...'''    )
    load_tfa_weights_in_bert(SCREAMING_SNAKE_CASE_		,       SCREAMING_SNAKE_CASE_		,       SCREAMING_SNAKE_CASE_    )

    # Save pytorch-model
    logger.info(F'''Saving PyTorch model to {pytorch_dump_path}...'''    )
    torch.save(model.state_dict()		,       SCREAMING_SNAKE_CASE_    )


if __name__ == "__main__":
       _SCREAMING_SNAKE_CASE	 =							argparse.ArgumentParser()
       parser.add_argument(
           "--tf_checkpoint_path", type=str, required=True, help="Path to the TensorFlow 2.x checkpoint path."
       )
       parser.add_argument(
           "--bert_config_file",
           type=str,
           required=True,
           help="The config json file corresponding to the BERT model. This specifies the model architecture.",
       )
       parser.add_argument(
           "--pytorch_dump_path",
           type=str,
           required=True,
           help="Path to the output PyTorch model (must include filename).",
       )
       _SCREAMING_SNAKE_CASE	 =							parser.parse_args()
       convert_tfa_checkpoint_to_pytorch(args.tf_checkpoint_path, args.bert_config_file, args.pytorch_dump_path)









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


