



import argparse

import requests
import torch

# pip3 install salesforce-lavis
# I'm actually installing a slightly modified version: pip3 install git+https://github.com/nielsrogge/LAVIS.git@fix_lavis_float32 (there's also the fix_lavis branch)
# also note: to convert Vicuna checkpoints, we had to include /home/niels/python_projects/checkpoints/FastChat/vicuna-7b in lavis/configs/models/blip2/blip2_instruct_vicuna7b.yaml
# same for Vicuna-13b
from lavis.models import load_model_and_preprocess
from PIL import Image

from transformers import (
    AutoTokenizer,
    BlipImageProcessor,
    InstructBlipConfig,
    InstructBlipForConditionalGeneration,
    InstructBlipProcessor,
    InstructBlipQFormerConfig,
    InstructBlipVisionConfig,
    LlamaConfig,
    LlamaTokenizerFast,
    TaConfig,
    TaTokenizerFast,
)
from transformers.utils.constants import OPENAI_CLIP_MEAN, OPENAI_CLIP_STD

def 	_lowerCAmelCase (    ):
      lowercase__  =	'https://raw.githubusercontent.com/salesforce/LAVIS/main/docs/_static/Confusing-Pictures.jpg'
      lowercase__  =	Image.open(requests.get(A__    ,	stream=A__						).raw						).convert('RGB'						)

      return image

def 	_lowerCAmelCase (    A__						):
      lowercase__  =	[]
      # fmt: off

      # vision encoder
      rename_keys.append(('visual_encoder.cls_token', 'vision_model.embeddings.class_embedding')						)
      rename_keys.append(('visual_encoder.pos_embed', 'vision_model.embeddings.position_embedding')						)
      rename_keys.append(('visual_encoder.patch_embed.proj.weight', 'vision_model.embeddings.patch_embedding.weight')						)
      rename_keys.append(('visual_encoder.patch_embed.proj.bias', 'vision_model.embeddings.patch_embedding.bias')						)
      rename_keys.append(('ln_vision.weight', 'vision_model.post_layernorm.weight')						)
      rename_keys.append(('ln_vision.bias', 'vision_model.post_layernorm.bias')						)

      for i in range(config.vision_config.num_hidden_layers						):
            rename_keys.append((F'''visual_encoder.blocks.{i}.norm1.weight''', F'''vision_model.encoder.layers.{i}.layer_norm1.weight''')						)
            rename_keys.append((F'''visual_encoder.blocks.{i}.norm1.bias''', F'''vision_model.encoder.layers.{i}.layer_norm1.bias''')						)
            rename_keys.append((F'''visual_encoder.blocks.{i}.norm2.weight''', F'''vision_model.encoder.layers.{i}.layer_norm2.weight''')						)
            rename_keys.append((F'''visual_encoder.blocks.{i}.norm2.bias''', F'''vision_model.encoder.layers.{i}.layer_norm2.bias''')						)
            rename_keys.append((F'''visual_encoder.blocks.{i}.attn.qkv.weight''', F'''vision_model.encoder.layers.{i}.self_attn.qkv.weight''')						)
            rename_keys.append((F'''visual_encoder.blocks.{i}.attn.proj.weight''', F'''vision_model.encoder.layers.{i}.self_attn.projection.weight''',)						)
            rename_keys.append((F'''visual_encoder.blocks.{i}.attn.proj.bias''', F'''vision_model.encoder.layers.{i}.self_attn.projection.bias''')						)
            rename_keys.append((F'''visual_encoder.blocks.{i}.mlp.fc1.weight''', F'''vision_model.encoder.layers.{i}.mlp.fc1.weight''')						)
            rename_keys.append((F'''visual_encoder.blocks.{i}.mlp.fc1.bias''', F'''vision_model.encoder.layers.{i}.mlp.fc1.bias''')						)
            rename_keys.append((F'''visual_encoder.blocks.{i}.mlp.fc2.weight''', F'''vision_model.encoder.layers.{i}.mlp.fc2.weight''')						)
            rename_keys.append((F'''visual_encoder.blocks.{i}.mlp.fc2.bias''', F'''vision_model.encoder.layers.{i}.mlp.fc2.bias''')						)

      # QFormer
      rename_keys.append(('Qformer.bert.embeddings.LayerNorm.weight', 'qformer.embeddings.layernorm.weight')						)
      rename_keys.append(('Qformer.bert.embeddings.LayerNorm.bias', 'qformer.embeddings.layernorm.bias')						)

      # fmt: on
      return rename_keys

def 	_lowerCAmelCase (    A__    ,	A__    ,	A__						):
      lowercase__  =	dct.pop(A__						)
      lowercase__  =	val

def 	_lowerCAmelCase (    A__    ,	A__						):
      for i in range(config.vision_config.num_hidden_layers						):
            # read in original q and v biases
            lowercase__  =	state_dict.pop(F'''visual_encoder.blocks.{i}.attn.q_bias'''						)
            lowercase__  =	state_dict.pop(F'''visual_encoder.blocks.{i}.attn.v_bias'''						)

            # next, set bias in the state dict
            lowercase__  =	torch.cat((q_bias, torch.zeros_like(A__    ,	requires_grad=A__						), v_bias)						)
            lowercase__  =	qkv_bias

def 	_lowerCAmelCase (    A__						):
      lowercase__  =	364 if 'coco' in model_name else 224
      lowercase__  =	InstructBlipVisionConfig(image_size=A__						).to_dict()

      # make sure the models have proper bos_token_id and eos_token_id set (important for generation)
      # seems like flan-T5 models don't have bos_token_id properly set?
      if "t5-xl" in model_name:
            lowercase__  =	TaConfig.from_pretrained('google/flan-t5-xl'    ,	dense_act_fn='gelu'    ,	bos_token_id=1						).to_dict()
      elif "t5-xxl" in model_name:
            lowercase__  =	TaConfig.from_pretrained('google/flan-t5-xxl'    ,	dense_act_fn='gelu'    ,	bos_token_id=1						).to_dict()
      elif "vicuna-7b" in model_name:
            lowercase__  =	LlamaConfig.from_pretrained('decapoda-research/llama-7b-hf'    ,	vocab_size=32_001						).to_dict()
      elif "vicuna-13b" in model_name:
            lowercase__  =	LlamaConfig.from_pretrained('decapoda-research/llama-13b-hf'    ,	vocab_size=32_001						).to_dict()
      else:
            raise ValueError('Model name not supported'						)

      # the authors add one special "[DEC]" token to the vocab of Q-Former, hence vocab size = 30522 + 1
      lowercase__  =	InstructBlipQFormerConfig(vocab_size=30_523						).to_dict()
      lowercase__  =	InstructBlipConfig(vision_config=A__    ,	text_config=A__    ,	qformer_config=A__						)

      return config, image_size

@torch.no_grad()
def 	_lowerCAmelCase (    A__    ,	A__=None    ,	A__=False						):
      lowercase__  =	AutoTokenizer.from_pretrained('bert-base-uncased'    ,	truncation_side='left'						)
      qformer_tokenizer.add_special_tokens({'bos_token': '[DEC]'}						)

      if "t5" in model_name:
            lowercase__  =	TaTokenizerFast.from_pretrained('google/flan-t5-xl'    ,	truncation_side='left'						)
      elif "vicuna" in model_name:
            # the following was used in the original implementation:
            # tokenizer = LlamaTokenizer.from_pretrained("huggyllama/llama-7b", use_fast=False, truncation_side="left")
            # tokenizer.add_special_tokens({"pad_token": "[PAD]"})
            # tokenizer.add_special_tokens({"bos_token": "</s>"})
            # tokenizer.add_special_tokens({"eos_token": "</s>"})
            # tokenizer.add_special_tokens({"unk_token": "</s>"})
            lowercase__  =	LlamaTokenizerFast.from_pretrained(
                'huggyllama/llama-7b'    ,	truncation_side='left'    ,	bos_token='</s>'    ,	unk_token='</s>'						)
            tokenizer.add_special_tokens({'pad_token': '[PAD]'}						)

      lowercase__,						lowercase__  =	get_blipa_config(A__						)
      lowercase__  =	InstructBlipForConditionalGeneration(A__						).eval()

      lowercase__  =	{
          'instructblip-vicuna-7b': ('blip2_vicuna_instruct', 'vicuna7b'),
          'instructblip-vicuna-13b': ('blip2_vicuna_instruct', 'vicuna13b'),
          'instructblip-flan-t5-xl': ('blip2_t5_instruct', 'flant5xl'),
          'instructblip-flan-t5-xxl': ('blip2_t5_instruct', 'flant5xxl'),
      }

      lowercase__,						lowercase__  =	model_name_to_original[model_name]

      # load original model
      print('Loading original model...'						)
      lowercase__  =	'cuda:1' if torch.cuda.is_available() else 'cpu'
      lowercase__  =	'cuda:2' if torch.cuda.is_available() else 'cpu'
      lowercase__,						lowercase__,						lowercase__  =	load_model_and_preprocess(
          name=A__    ,	model_type=A__    ,	is_eval=A__    ,	device=A__						)
      original_model.eval()
      print('Done!'						)

      # update state dict keys
      lowercase__  =	original_model.state_dict()
      lowercase__  =	create_rename_keys(A__						)
      for src, dest in rename_keys:
            rename_key(A__    ,	A__    ,	A__						)

      # some keys can be renamed efficiently
      for key, val in state_dict.copy().items():
            lowercase__  =	state_dict.pop(A__						)
            if key.startswith('Qformer.bert'						):
                  lowercase__  =	key.replace('Qformer.bert'    ,	'qformer'						)
            if "attention.self" in key:
                  lowercase__  =	key.replace('self'    ,	'attention'						)
            if "llm_proj" in key:
                  lowercase__  =	key.replace('llm_proj'    ,	'language_projection'						)
            if "t5_proj" in key:
                  lowercase__  =	key.replace('t5_proj'    ,	'language_projection'						)
            if key.startswith('llm_model'						):
                  lowercase__  =	key.replace('llm_model'    ,	'language_model'						)
            if key.startswith('t5'						):
                  lowercase__  =	key.replace('t5'    ,	'language'						)
            lowercase__  =	val

      # read in qv biases
      read_in_q_v_bias(A__    ,	A__						)

      # note: weights get loaded in torch.float32 by default
      hf_model.load_state_dict(A__    ,	strict=A__						)

      lowercase__  =	load_demo_image()
      lowercase__  =	'What is unusual about this image?'

      # create processor
      lowercase__  =	BlipImageProcessor(
          size={'height': image_size, 'width': image_size}    ,	image_mean=A__    ,	image_std=A__						)
      lowercase__  =	InstructBlipProcessor(
          image_processor=A__    ,	tokenizer=A__    ,	qformer_tokenizer=A__    ,	)
      lowercase__  =	processor(images=A__    ,	text=A__    ,	return_tensors='pt'						).to(A__						)

      # make sure processor creates exact same pixel values
      lowercase__  =	vis_processors['eval'](A__						).unsqueeze(0						).to(A__						)
      lowercase__  =	inputs.pixel_values
      assert torch.allclose(original_pixel_values.to(pixel_values.device						)    ,	A__						)

      original_model.to(A__						)
      hf_model.to(A__						)
      with torch.no_grad():
            if "vicuna" in model_name:
                  lowercase__  =	original_model({'image': original_pixel_values, 'text_input': [prompt]}						).logits
                  lowercase__  =	hf_model(**A__						).logits
            else:
                  lowercase__  =	original_model(
                      {'image': original_pixel_values, 'text_input': [prompt], 'text_output': ['\n']}						).logits
                  lowercase__  =	tokenizer('\n'    ,	return_tensors='pt'						).input_ids.to(A__						)
                  lowercase__  =	label_input_ids.masked_fill(label_input_ids == tokenizer.pad_token_id    ,	-100						)
                  lowercase__  =	hf_model(**A__    ,	labels=A__						).logits

      print('First values of original logits:'    ,	original_logits[0, :3, :3]						)
      print('First values of HF logits:'    ,	logits[0, :3, :3]						)

      # assert values
      assert original_logits.shape == logits.shape
      lowercase__  =	1E-4 if 'vicuna' in model_name else 1E-5
      assert torch.allclose(original_logits.to(logits.device						)    ,	A__    ,	atol=A__						)
      print('Looks ok!'						)

      print('Generating with original model...'						)
      lowercase__  =	original_model.generate({'image': original_pixel_values, 'prompt': prompt}    ,	num_beams=5						)

      # important: we need to cast the weights of the HF model to the appropriate type
      print('Generating with HF model...'						)
      lowercase__  =	hf_model.generate(
          **A__    ,	do_sample=A__    ,	num_beams=5    ,	max_length=256    ,	min_length=1    ,	top_p=0.9    ,	repetition_penalty=1.5    ,	length_penalty=1.0    ,	temperature=1    ,	)
      if "vicuna" in model_name:
            # convert output id 0 to 2 (eos_token_id)
            # TODO add this in the generate method?
            lowercase__  =	2
      print('Original generation:'    ,	A__						)
      lowercase__  =	processor.batch_decode(A__    ,	skip_special_tokens=A__						)
      lowercase__  =	[text.strip() for text in output_text]
      print('HF generation:'    ,	A__						)

      if pytorch_dump_folder_path is not None:
            processor.save_pretrained(A__						)
            hf_model.save_pretrained(A__						)

      if push_to_hub:
            processor.push_to_hub(F'''Salesforce/{model_name}'''						)
            hf_model.push_to_hub(F'''Salesforce/{model_name}'''						)


if __name__ == "__main__":
       a__   :					Tuple 						=      argparse.ArgumentParser()
       a__   :					Any 						=      [
           "instructblip-vicuna-7b",
           "instructblip-vicuna-13b",
           "instructblip-flan-t5-xl",
           "instructblip-flan-t5-xxl",
       ]
       parser.add_argument(
           "--model_name",
           default="instructblip-flan-t5-xl",
           choices=choices,
           type=str,
           help="Path to hf config.json of model to convert",
       )
       parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
       parser.add_argument(
           "--push_to_hub",
           action="store_true",
           help="Whether to push the model and processor to the hub after converting",
       )

       a__   :					List[Any] 						=      parser.parse_args()

       convert_blipa_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)





from __future__ import annotations

import copy
import inspect
import unittest

import numpy as np

from transformers import is_tf_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_tf, slow
from transformers.utils import cached_property

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
       import tensorflow as tf

       from transformers import (
           TF_LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST,
           TF_MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
           TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
           TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
           TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
           LayoutLMvaConfig,
           TFLayoutLMvaForQuestionAnswering,
           TFLayoutLMvaForSequenceClassification,
           TFLayoutLMvaForTokenClassification,
           TFLayoutLMvaModel,
       )

if is_vision_available():
       from PIL import Image

       from transformers import LayoutLMvaImageProcessor



class    UpperCAmelCase__:

   '''simple docstring'''




   def __init__(    self	:      Dict      ,					lowerCAmelCase	:      Union[str, Any]      ,					lowerCAmelCase	:      Tuple=2      ,					lowerCAmelCase	:      Any=3      ,					lowerCAmelCase	:      Any=4      ,					lowerCAmelCase	:      Optional[Any]=2      ,					lowerCAmelCase	:      Optional[Any]=7      ,					lowerCAmelCase	:      Tuple=True      ,					lowerCAmelCase	:      Optional[int]=True      ,					lowerCAmelCase	:      int=True      ,					lowerCAmelCase	:      Dict=True      ,					lowerCAmelCase	:      Dict=99      ,					lowerCAmelCase	:      Optional[int]=36      ,					lowerCAmelCase	:      List[Any]=2      ,					lowerCAmelCase	:      Dict=4      ,					lowerCAmelCase	:      int=37      ,					lowerCAmelCase	:      Optional[int]="gelu"      ,					lowerCAmelCase	:      str=0.1      ,					lowerCAmelCase	:      str=0.1      ,					lowerCAmelCase	:      List[Any]=5_12      ,					lowerCAmelCase	:      List[str]=16      ,					lowerCAmelCase	:      Union[str, Any]=2      ,					lowerCAmelCase	:      Dict=0.02      ,					lowerCAmelCase	:      Tuple=6      ,					lowerCAmelCase	:      Tuple=6      ,					lowerCAmelCase	:      Dict=3      ,					lowerCAmelCase	:      List[str]=4      ,					lowerCAmelCase	:      List[str]=None      ,					lowerCAmelCase	:      Optional[Any]=10_00      ,					)						->					Dict:




         """simple docstring"""

         lowercase__  =	parent
         lowercase__  =	batch_size
         lowercase__  =	num_channels
         lowercase__  =	image_size
         lowercase__  =	patch_size
         lowercase__  =	is_training
         lowercase__  =	use_input_mask
         lowercase__  =	use_token_type_ids
         lowercase__  =	use_labels
         lowercase__  =	vocab_size
         lowercase__  =	hidden_size
         lowercase__  =	num_hidden_layers
         lowercase__  =	num_attention_heads
         lowercase__  =	intermediate_size
         lowercase__  =	hidden_act
         lowercase__  =	hidden_dropout_prob
         lowercase__  =	attention_probs_dropout_prob
         lowercase__  =	max_position_embeddings
         lowercase__  =	type_vocab_size
         lowercase__  =	type_sequence_label_size
         lowercase__  =	initializer_range
         lowercase__  =	coordinate_size
         lowercase__  =	shape_size
         lowercase__  =	num_labels
         lowercase__  =	num_choices
         lowercase__  =	scope
         lowercase__  =	range_bbox

         # LayoutLMv3's sequence length equals the number of text tokens + number of patches + 1 (we add 1 for the CLS token)
         lowercase__  =	text_seq_length
         lowercase__  =	(image_size // patch_size) ** 2 + 1
         lowercase__  =	self.text_seq_length + self.image_seq_length


   def       UpperCAmelCase		(    self	:      str)						->					List[str]:




         """simple docstring"""

         lowercase__  =	ids_tensor([self.batch_size, self.text_seq_length]      ,					self.vocab_size)

         lowercase__  =	ids_tensor([self.batch_size, self.text_seq_length, 4]      ,					self.range_bbox)
         lowercase__  =	bbox.numpy()
         # Ensure that bbox is legal
         for i in range(bbox.shape[0]):
               for j in range(bbox.shape[1]):
                     if bbox[i, j, 3] < bbox[i, j, 1]:
                           lowercase__  =	bbox[i, j, 3]
                           lowercase__  =	bbox[i, j, 1]
                           lowercase__  =	tmp_coordinate
                     if bbox[i, j, 2] < bbox[i, j, 0]:
                           lowercase__  =	bbox[i, j, 2]
                           lowercase__  =	bbox[i, j, 0]
                           lowercase__  =	tmp_coordinate
         lowercase__  =	tf.constant(lowerCAmelCase)

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

         lowercase__  =	None
         if self.use_input_mask:
               lowercase__  =	random_attention_mask([self.batch_size, self.text_seq_length])

         lowercase__  =	None
         if self.use_token_type_ids:
               lowercase__  =	ids_tensor([self.batch_size, self.text_seq_length]      ,					self.type_vocab_size)

         lowercase__  =	None
         lowercase__  =	None
         if self.use_labels:
               lowercase__  =	ids_tensor([self.batch_size]      ,					self.type_sequence_label_size)
               lowercase__  =	ids_tensor([self.batch_size, self.text_seq_length]      ,					self.num_labels)

         lowercase__  =	LayoutLMvaConfig(
             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      ,					type_vocab_size=self.type_vocab_size      ,					initializer_range=self.initializer_range      ,					coordinate_size=self.coordinate_size      ,					shape_size=self.shape_size      ,					input_size=self.image_size      ,					patch_size=self.patch_size      ,					)

         return config, input_ids, bbox, pixel_values, token_type_ids, input_mask, sequence_labels, token_labels


   def       UpperCAmelCase		(    self	:      Optional[Any]      ,					lowerCAmelCase	:      Any      ,					lowerCAmelCase	:      str      ,					lowerCAmelCase	:      int      ,					lowerCAmelCase	:      int      ,					lowerCAmelCase	:      Tuple      ,					lowerCAmelCase	:      List[Any])						->					List[str]:




         """simple docstring"""

         lowercase__  =	TFLayoutLMvaModel(config=lowerCAmelCase)

         # text + image
         lowercase__  =	model(lowerCAmelCase      ,					pixel_values=lowerCAmelCase      ,					training=lowerCAmelCase)
         lowercase__  =	model(
             lowerCAmelCase      ,					bbox=lowerCAmelCase      ,					pixel_values=lowerCAmelCase      ,					attention_mask=lowerCAmelCase      ,					token_type_ids=lowerCAmelCase      ,					training=lowerCAmelCase      ,					)
         lowercase__  =	model(lowerCAmelCase      ,					bbox=lowerCAmelCase      ,					pixel_values=lowerCAmelCase      ,					training=lowerCAmelCase)

         self.parent.assertEqual(result.last_hidden_state.shape      ,					(self.batch_size, self.seq_length, self.hidden_size))

         # text only
         lowercase__  =	model(lowerCAmelCase      ,					training=lowerCAmelCase)
         self.parent.assertEqual(
             result.last_hidden_state.shape      ,					(self.batch_size, self.text_seq_length, self.hidden_size))

         # image only
         lowercase__  =	model({'pixel_values': pixel_values}      ,					training=lowerCAmelCase)
         self.parent.assertEqual(
             result.last_hidden_state.shape      ,					(self.batch_size, self.image_seq_length, self.hidden_size))


   def       UpperCAmelCase		(    self	:      Any      ,					lowerCAmelCase	:      Optional[int]      ,					lowerCAmelCase	:      int      ,					lowerCAmelCase	:      Dict      ,					lowerCAmelCase	:      List[Any]      ,					lowerCAmelCase	:      Optional[Any]      ,					lowerCAmelCase	:      List[str]      ,					lowerCAmelCase	:      List[str])						->					Union[str, Any]:




         """simple docstring"""

         lowercase__  =	self.num_labels
         lowercase__  =	TFLayoutLMvaForSequenceClassification(config=lowerCAmelCase)
         lowercase__  =	model(
             lowerCAmelCase      ,					bbox=lowerCAmelCase      ,					pixel_values=lowerCAmelCase      ,					attention_mask=lowerCAmelCase      ,					token_type_ids=lowerCAmelCase      ,					labels=lowerCAmelCase      ,					training=lowerCAmelCase      ,					)
         self.parent.assertEqual(result.logits.shape      ,					(self.batch_size, self.num_labels))


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




         """simple docstring"""

         lowercase__  =	self.num_labels
         lowercase__  =	TFLayoutLMvaForTokenClassification(config=lowerCAmelCase)
         lowercase__  =	model(
             lowerCAmelCase      ,					bbox=lowerCAmelCase      ,					pixel_values=lowerCAmelCase      ,					attention_mask=lowerCAmelCase      ,					token_type_ids=lowerCAmelCase      ,					labels=lowerCAmelCase      ,					training=lowerCAmelCase      ,					)
         self.parent.assertEqual(result.logits.shape      ,					(self.batch_size, self.text_seq_length, self.num_labels))


   def       UpperCAmelCase		(    self	:      int      ,					lowerCAmelCase	:      int      ,					lowerCAmelCase	:      List[str]      ,					lowerCAmelCase	:      Dict      ,					lowerCAmelCase	:      int      ,					lowerCAmelCase	:      str      ,					lowerCAmelCase	:      List[str]      ,					lowerCAmelCase	:      List[Any])						->					int:




         """simple docstring"""

         lowercase__  =	2
         lowercase__  =	TFLayoutLMvaForQuestionAnswering(config=lowerCAmelCase)
         lowercase__  =	model(
             lowerCAmelCase      ,					bbox=lowerCAmelCase      ,					pixel_values=lowerCAmelCase      ,					attention_mask=lowerCAmelCase      ,					token_type_ids=lowerCAmelCase      ,					start_positions=lowerCAmelCase      ,					end_positions=lowerCAmelCase      ,					training=lowerCAmelCase      ,					)
         self.parent.assertEqual(result.start_logits.shape      ,					(self.batch_size, self.seq_length))
         self.parent.assertEqual(result.end_logits.shape      ,					(self.batch_size, self.seq_length))



   def       UpperCAmelCase		(    self	:      Dict)						->					Dict:




         """simple docstring"""

         lowercase__  =	self.prepare_config_and_inputs()
         ((lowercase__),						(lowercase__),						(lowercase__),						(lowercase__),						(lowercase__),						(lowercase__),						(lowercase__),						(lowercase__))  =	config_and_inputs
         lowercase__  =	{
             'input_ids': input_ids,
             'bbox': bbox,
             'pixel_values': pixel_values,
             'token_type_ids': token_type_ids,
             'attention_mask': input_mask,
         }
         return config, inputs_dict



@require_tf
class    UpperCAmelCase__(				lowerCamelCase  ,				lowerCamelCase  ,				unittest.TestCase						):

   '''simple docstring'''




   A     :	Optional[Any]												=     (
       (
           TFLayoutLMvaModel,
           TFLayoutLMvaForQuestionAnswering,
           TFLayoutLMvaForSequenceClassification,
           TFLayoutLMvaForTokenClassification,
       )
       if is_tf_available()
       else ()
   )
   A     :	List[Any]												=     (
       {"document-question-answering": TFLayoutLMvaForQuestionAnswering, "feature-extraction": TFLayoutLMvaModel}
       if is_tf_available()
       else {}
   )

   A     :	Any												=     False
   A     :	Any												=     False
   A     :	Dict												=     False


   def       UpperCAmelCase		(    self	:      int      ,					lowerCAmelCase	:      int      ,					lowerCAmelCase	:      Dict      ,					lowerCAmelCase	:      Any      ,					lowerCAmelCase	:      List[Any]      ,					lowerCAmelCase	:      Dict)						->					Tuple:




         """simple docstring"""

         return True


   def       UpperCAmelCase		(    self	:      Tuple      ,					lowerCAmelCase	:      Union[str, Any]      ,					lowerCAmelCase	:      Optional[Any]      ,					lowerCAmelCase	:      List[str]=False)						->					dict:




         """simple docstring"""

         lowercase__  =	copy.deepcopy(lowerCAmelCase)

         if model_class in get_values(lowerCAmelCase):
               lowercase__  =	{
                   k: tf.tile(tf.expand_dims(lowerCAmelCase      ,					1)      ,					(1, self.model_tester.num_choices) + (1,) * (v.ndim - 1))
                   if isinstance(lowerCAmelCase      ,					tf.Tensor) and v.ndim > 0
                   else v
                   for k, v in inputs_dict.items()
               }

         if return_labels:
               if model_class in get_values(lowerCAmelCase):
                     lowercase__  =	tf.ones(self.model_tester.batch_size      ,					dtype=tf.intaa)
               elif model_class in get_values(lowerCAmelCase):
                     lowercase__  =	tf.zeros(self.model_tester.batch_size      ,					dtype=tf.intaa)
                     lowercase__  =	tf.zeros(self.model_tester.batch_size      ,					dtype=tf.intaa)
               elif model_class in get_values(lowerCAmelCase):
                     lowercase__  =	tf.zeros(self.model_tester.batch_size      ,					dtype=tf.intaa)
               elif model_class in get_values(lowerCAmelCase):
                     lowercase__  =	tf.zeros(
                         (self.model_tester.batch_size, self.model_tester.text_seq_length)      ,					dtype=tf.intaa)

         return inputs_dict


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




         """simple docstring"""

         lowercase__  =	TFLayoutLMvaModelTester(self)
         lowercase__  =	ConfigTester(self      ,					config_class=lowerCAmelCase      ,					hidden_size=37)


   def       UpperCAmelCase		(    self	:      Optional[Any])						->					str:




         """simple docstring"""

         self.config_tester.run_common_tests()


   def       UpperCAmelCase		(    self	:      List[Any])						->					List[str]:




         """simple docstring"""

         lowercase__,						lowercase__  =	self.model_tester.prepare_config_and_inputs_for_common()
         for model_class in self.all_model_classes:
               lowercase__  =	model_class(lowerCAmelCase)
               if getattr(lowerCAmelCase      ,					'hf_compute_loss'      ,					lowerCAmelCase):
                     # The number of elements in the loss should be the same as the number of elements in the label
                     lowercase__  =	self._prepare_for_class(inputs_dict.copy()      ,					lowerCAmelCase      ,					return_labels=lowerCAmelCase)
                     lowercase__  =	prepared_for_class[
                         sorted(prepared_for_class.keys() - inputs_dict.keys()      ,					reverse=lowerCAmelCase)[0]
                     ]
                     lowercase__  =	added_label.shape.as_list()[:1]

                     # Test that model correctly compute the loss with kwargs
                     lowercase__  =	self._prepare_for_class(inputs_dict.copy()      ,					lowerCAmelCase      ,					return_labels=lowerCAmelCase)
                     lowercase__  =	prepared_for_class.pop('input_ids')

                     lowercase__  =	model(lowerCAmelCase      ,					**lowerCAmelCase)[0]
                     self.assertTrue(loss.shape.as_list() == expected_loss_size or loss.shape.as_list() == [1])

                     # Test that model correctly compute the loss when we mask some positions
                     lowercase__  =	self._prepare_for_class(inputs_dict.copy()      ,					lowerCAmelCase      ,					return_labels=lowerCAmelCase)
                     lowercase__  =	prepared_for_class.pop('input_ids')
                     if "labels" in prepared_for_class:
                           lowercase__  =	prepared_for_class['labels'].numpy()
                           if len(labels.shape) > 1 and labels.shape[1] != 1:
                                 lowercase__  =	-1_00
                                 lowercase__  =	tf.convert_to_tensor(lowerCAmelCase)
                                 lowercase__  =	model(lowerCAmelCase      ,					**lowerCAmelCase)[0]
                                 self.assertTrue(loss.shape.as_list() == expected_loss_size or loss.shape.as_list() == [1])
                                 self.assertTrue(not np.any(np.isnan(loss.numpy())))

                # Test that model correctly compute the loss with a dict
                     lowercase__  =	self._prepare_for_class(inputs_dict.copy()      ,					lowerCAmelCase      ,					return_labels=lowerCAmelCase)
                     lowercase__  =	model(lowerCAmelCase)[0]
                     self.assertTrue(loss.shape.as_list() == expected_loss_size or loss.shape.as_list() == [1])

                     # Test that model correctly compute the loss with a tuple
                     lowercase__  =	self._prepare_for_class(inputs_dict.copy()      ,					lowerCAmelCase      ,					return_labels=lowerCAmelCase)

                     # Get keys that were added with the _prepare_for_class function
                     lowercase__  =	prepared_for_class.keys() - inputs_dict.keys()
                     lowercase__  =	inspect.signature(model.call).parameters
                     lowercase__  =	list(signature.keys())

                     # Create a dictionary holding the location of the tensors in the tuple
                     lowercase__  =	{0: 'input_ids'}
                     for label_key in label_keys:
                           lowercase__  =	signature_names.index(lowerCAmelCase)
                           lowercase__  =	label_key
                     lowercase__  =	sorted(tuple_index_mapping.items())
                     # Initialize a list with their default values, update the values and convert to a tuple
                     lowercase__  =	[]

                     for name in signature_names:
                           if name != "kwargs":
                                 list_input.append(signature[name].default)

                     for index, value in sorted_tuple_index_mapping:
                           lowercase__  =	prepared_for_class[value]

                     lowercase__  =	tuple(lowerCAmelCase)

                     # Send to model
                     lowercase__  =	model(tuple_input[:-1])[0]

                     self.assertTrue(loss.shape.as_list() == expected_loss_size or loss.shape.as_list() == [1])


   def       UpperCAmelCase		(    self	:      str)						->					Any:




         """simple docstring"""

         (
             (
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						
         )  =	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(lowerCAmelCase      ,					lowerCAmelCase      ,					lowerCAmelCase      ,					lowerCAmelCase      ,					lowerCAmelCase      ,					lowerCAmelCase)


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




         """simple docstring"""

         (
             (
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						
         )  =	self.model_tester.prepare_config_and_inputs()
         for type in ["absolute", "relative_key", "relative_key_query"]:
               lowercase__  =	type
               self.model_tester.create_and_check_model(lowerCAmelCase      ,					lowerCAmelCase      ,					lowerCAmelCase      ,					lowerCAmelCase      ,					lowerCAmelCase      ,					lowerCAmelCase)


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




         """simple docstring"""

         (
             (
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						
         )  =	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_sequence_classification(
             lowerCAmelCase      ,					lowerCAmelCase      ,					lowerCAmelCase      ,					lowerCAmelCase      ,					lowerCAmelCase      ,					lowerCAmelCase      ,					lowerCAmelCase)


   def       UpperCAmelCase		(    self	:      List[str])						->					int:




         """simple docstring"""

         (
             (
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						
         )  =	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_token_classification(
             lowerCAmelCase      ,					lowerCAmelCase      ,					lowerCAmelCase      ,					lowerCAmelCase      ,					lowerCAmelCase      ,					lowerCAmelCase      ,					lowerCAmelCase)


   def       UpperCAmelCase		(    self	:      int)						->					Dict:




         """simple docstring"""

         (
             (
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						
         )  =	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_question_answering(
             lowerCAmelCase      ,					lowerCAmelCase      ,					lowerCAmelCase      ,					lowerCAmelCase      ,					lowerCAmelCase      ,					lowerCAmelCase      ,					lowerCAmelCase)



   @slow
   def       UpperCAmelCase		(    self	:      List[Any])						->					Tuple:




         """simple docstring"""

         for model_name in TF_LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               lowercase__  =	TFLayoutLMvaModel.from_pretrained(lowerCAmelCase)
               self.assertIsNotNone(lowerCAmelCase)

def 	_lowerCAmelCase (    ):
      lowercase__  =	Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'						)
      return image



@require_tf
class    UpperCAmelCase__(				unittest.TestCase						):

   '''simple docstring'''




   @cached_property
   def       UpperCAmelCase		(    self	:      Union[str, Any])						->					Tuple:




         """simple docstring"""

         return LayoutLMvaImageProcessor(apply_ocr=lowerCAmelCase) if is_vision_available() else None



   @slow
   def       UpperCAmelCase		(    self	:      str)						->					str:




         """simple docstring"""

         lowercase__  =	TFLayoutLMvaModel.from_pretrained('microsoft/layoutlmv3-base')

         lowercase__  =	self.default_image_processor
         lowercase__  =	prepare_img()
         lowercase__  =	image_processor(images=lowerCAmelCase      ,					return_tensors='tf').pixel_values

         lowercase__  =	tf.constant([[1, 2]])
         lowercase__  =	tf.expand_dims(tf.constant([[1, 2, 3, 4], [5, 6, 7, 8]])      ,					axis=0)

         # forward pass
         lowercase__  =	model(input_ids=lowerCAmelCase      ,					bbox=lowerCAmelCase      ,					pixel_values=lowerCAmelCase      ,					training=lowerCAmelCase)

         # verify the logits
         lowercase__  =	(1, 1_99, 7_68)
         self.assertEqual(outputs.last_hidden_state.shape      ,					lowerCAmelCase)

         lowercase__  =	tf.constant(
             [[-0.05_29, 0.36_18, 0.16_32], [-0.15_87, -0.16_67, -0.04_00], [-0.15_57, -0.16_71, -0.05_05]])

         self.assertTrue(np.allclose(outputs.last_hidden_state[0, :3, :3]      ,					lowerCAmelCase      ,					atol=1E-4))
