





import math
import os
import re
import sys
import unittest
from pathlib import Path
from typing import Tuple
from unittest.mock import patch

from parameterized import parameterized

from transformers.testing_utils import (
    CaptureStderr,
    ExtendSysPath,
    TestCasePlus,
    execute_subprocess_async,
    get_gpu_count,
    get_torch_dist_unique_port,
    require_apex,
    require_bitsandbytes,
    require_fairscale,
    require_torch,
    require_torch_gpu,
    require_torch_multi_gpu,
    require_torch_non_multi_gpu,
    slow,
)
from transformers.trainer_callback import TrainerState
from transformers.trainer_utils import set_seed


A__:  List[str]        =     os.path.abspath(os.path.dirname(__file__))
with ExtendSysPath(f"{bindir}/../../examples/pytorch/translation"):
   from run_translation import main  # noqa


set_seed(42)
A__:  Any        =     "sshleifer/student_marian_en_ro_6_1"
A__:  Optional[Any]        =     "sshleifer/tiny-mbart"




@require_torch
class     _a  (  SCREAMING_SNAKE_CASE__):

      """simple docstring"""


      def        UpperCAmelCase_    (						self:       Dict     ,  __lowerCamelCase:       Any=False     ,  __lowerCamelCase:       Tuple=None     ,  __lowerCamelCase:       Dict=True     ,  __lowerCamelCase:       Any=True     ,  __lowerCamelCase:       int=True     ,  __lowerCamelCase:       Tuple=True     ,  ):
          '''simple docstring'''


          UpperCamelCase__:     Tuple     							=			self.run_trainer(
              eval_steps=1     ,  max_len=12     ,  model_name=A__     ,  num_train_epochs=1     ,  distributed=A__     ,  extra_args_str=A__     ,  predict_with_generate=A__     ,  do_train=A__     ,  do_eval=A__     ,  do_predict=A__     ,  )
          UpperCamelCase__:     int     							=			TrainerState.load_from_json(os.path.join(A__     ,  "trainer_state.json" ) ).log_history

          if not do_eval:
              return

          UpperCamelCase__:     Tuple     							=			[log for log in logs if "eval_loss" in log.keys()]

          UpperCamelCase__:     Dict     							=			eval_metrics[0]
          if predict_with_generate:
              assert "eval_bleu" in first_step_stats

              UpperCamelCase__:     int     							=			eval_metrics[-1]
              assert isinstance(last_step_stats["eval_bleu"]     ,  A__ )
              assert not math.isnan(float(last_step_stats["eval_loss"] ) ), "eval_loss must not be `nan`"






      @require_torch_non_multi_gpu
      def        UpperCAmelCase_    (						self:       Dict ):
          '''simple docstring'''


          self.run_seqaseq_quick()






      @require_torch_multi_gpu
      def        UpperCAmelCase_    (						self:       Tuple ):
          '''simple docstring'''


          self.run_seqaseq_quick(distributed=A__ )






      @require_torch_multi_gpu
      def        UpperCAmelCase_    (						self:       Optional[Any] ):
          '''simple docstring'''


          self.run_seqaseq_quick(distributed=A__ )






      @unittest.skip("Requires an update of the env running those tests" )
      @require_torch_multi_gpu
      @require_fairscale
      def        UpperCAmelCase_    (						self:       Tuple ):
          '''simple docstring'''


          self.run_seqaseq_quick(distributed=A__     ,  extra_args_str="--sharded_ddp simple" )






      @unittest.skip("Requires an update of the env running those tests" )
      @require_torch_multi_gpu
      @require_fairscale
      def        UpperCAmelCase_    (						self:       str ):
          '''simple docstring'''


          self.run_seqaseq_quick(distributed=A__     ,  extra_args_str="--sharded_ddp simple --fp16" )






      @unittest.skip("Requires an update of the env running those tests" )
      @require_torch_multi_gpu
      @require_fairscale
      def        UpperCAmelCase_    (						self:       List[Any] ):
          '''simple docstring'''


          self.run_seqaseq_quick(distributed=A__     ,  extra_args_str="--sharded_ddp zero_dp_2"     ,  predict_with_generate=A__ )






      @unittest.skip("Requires an update of the env running those tests" )
      @require_torch_multi_gpu
      @require_fairscale
      def        UpperCAmelCase_    (						self:       Dict ):
          '''simple docstring'''


          self.run_seqaseq_quick(
              distributed=A__     ,  extra_args_str="--sharded_ddp zero_dp_2 --fp16"     ,  predict_with_generate=A__ )






      @require_apex
      @require_torch_gpu
      def        UpperCAmelCase_    (						self:       str ):
          '''simple docstring'''


          self.run_seqaseq_quick(distributed=A__     ,  extra_args_str="--fp16 --fp16_backend=apex" )
          # test 2nd time - was getting eval_loss': nan'
          # to reproduce the problem set distributed=False
          self.run_seqaseq_quick(distributed=A__     ,  extra_args_str="--fp16 --fp16_backend=apex" )






      @parameterized.expand(["base", "low", "high", "mixed"] )
      @require_torch_multi_gpu
      def        UpperCAmelCase_    (						self:       List[str]     ,  __lowerCamelCase:       int ):
          '''simple docstring'''


          UpperCamelCase__:     Optional[int]     							=			{
              # test with the default log_level - should be info and thus log info once
              "base": {"extra_args_str": "", "n_matches": 1},
              # test with low log_level and log_level_replica - should be noisy on all processes
              # now the info string should appear twice on 2 processes
              "low": {"extra_args_str": "--log_level debug --log_level_replica debug", "n_matches": 2},
              # test with high log_level and low log_level_replica
              # now the info string should appear once only on the replica
              "high": {"extra_args_str": "--log_level error --log_level_replica debug", "n_matches": 1},
              # test with high log_level and log_level_replica - should be quiet on all processes
              "mixed": {"extra_args_str": "--log_level error --log_level_replica error", "n_matches": 0},
          }

          UpperCamelCase__:     Dict     							=			experiments[experiment_id]
          UpperCamelCase__:     Any     							=			{"distributed": True, "predict_with_generate": False, "do_eval": False, "do_predict": False}
          UpperCamelCase__:     Optional[Any]     							=			"Running training"
          with CaptureStderr() as cl:
              self.run_seqaseq_quick(**A__     ,  extra_args_str=data["extra_args_str"] )
          UpperCamelCase__:     Optional[Any]     							=			len(re.findall(A__     ,  cl.err ) )
          self.assertEqual(A__     ,  data["n_matches"] )






      @slow
      def        UpperCAmelCase_    (						self:       Union[str, Any] ):
          '''simple docstring'''


          UpperCamelCase__:     Dict     							=			self.run_trainer(
              eval_steps=2     ,  max_len=128     ,  model_name=A__     ,  learning_rate=3e-4     ,  num_train_epochs=10     ,  distributed=A__     ,  )

          # Check metrics
          UpperCamelCase__:     Optional[Any]     							=			TrainerState.load_from_json(os.path.join(A__     ,  "trainer_state.json" ) ).log_history
          UpperCamelCase__:     int     							=			[log for log in logs if "eval_loss" in log.keys()]
          UpperCamelCase__:     Tuple     							=			eval_metrics[0]
          UpperCamelCase__:     Any     							=			eval_metrics[-1]

          assert first_step_stats["eval_loss"] > last_step_stats["eval_loss"], "model learned nothing"
          assert isinstance(last_step_stats["eval_bleu"]     ,  A__ )

          # test if do_predict saves generations and metrics
          UpperCamelCase__:     int     							=			os.listdir(A__ )
          UpperCamelCase__:     Union[str, Any]     							=			{os.path.basename(A__ ) for p in contents}
          assert "generated_predictions.txt" in contents
          assert "predict_results.json" in contents






      @slow
      @require_bitsandbytes
      def        UpperCAmelCase_    (						self:       Dict ):
          '''simple docstring'''


          from transformers.training_args import OptimizerNames

          def train_and_return_metrics(__lowerCamelCase:       Optional[int] ) -> Tuple[int, float]:
              UpperCamelCase__:     int     							=			"--skip_memory_metrics 0"

              UpperCamelCase__:     Union[str, Any]     							=			self.run_trainer(
                  max_len=128     ,  model_name=A__     ,  learning_rate=3e-4     ,  num_train_epochs=1     ,  optim=A__     ,  distributed=A__     ,  extra_args_str=A__     ,  do_eval=A__     ,  do_predict=A__     ,  n_gpus_to_use=1     ,  )

              # Check metrics
              UpperCamelCase__:     List[str]     							=			TrainerState.load_from_json(Path(A__     ,  "trainer_state.json" ) ).log_history
              UpperCamelCase__:     Tuple     							=			int(logs[0]["train_mem_gpu_peaked_delta"] / 2**20 )
              UpperCamelCase__:     Dict     							=			int(logs[0]["train_mem_gpu_alloc_delta"] / 2**20 )

              UpperCamelCase__:     List[str]     							=			logs[0]["train_loss"]
              return gpu_peak_mem_mb, gpu_alloc_mem_mb, loss

          UpperCamelCase__							,      UpperCamelCase__							,      UpperCamelCase__:     Dict     							=			train_and_return_metrics(OptimizerNames.ADAMW_TORCH.value )
          UpperCamelCase__							,      UpperCamelCase__							,      UpperCamelCase__:     Any     							=			train_and_return_metrics(OptimizerNames.ADAMW_BNB.value )

          UpperCamelCase__:     str     							=			gpu_alloc_mem_orig - gpu_alloc_mem_bnb

          UpperCamelCase__:     List[str]     							=			gpu_peak_mem_orig + gpu_alloc_mem_orig
          UpperCamelCase__:     List[str]     							=			gpu_peak_mem_bnb + gpu_alloc_mem_bnb
          UpperCamelCase__:     List[Any]     							=			gpu_total_mem_orig - gpu_total_mem_bnb

          # sshleifer/student_marian_en_ro_6_1 has 54M parameter, 29M of which is `nn.Embedding` which
          # doesn't get quantized and remains in fp32. Therefore we only have 25M parameters quantized
          # in 2 bytes and the diff in optim memory usage is derived as so:
          #
          # - normal 25*8=~200MB (8 bytes per param)
          # - bnb    25*2= ~50MB (2 bytes per param)
          #
          # Thus we should expect ~150MB total memory saved.
          #
          # Peak memory should be the same - the total should be different by about that same margin
          #
          # After leaving a small margin to accommodate for differences between gpus let's check
          # that we have at least 120MB in savings
          UpperCamelCase__:     Any     							=			120

          # uncomment the following if this test starts failing - requires py38 for a new print feature
          # gpu_peak_mem_diff = gpu_peak_mem_orig - gpu_peak_mem_bnb
          # print(f"{gpu_alloc_mem_orig=}MB {gpu_peak_mem_orig=}MB {gpu_alloc_mem_orig+gpu_peak_mem_orig=}MB")
          # print(f" {gpu_alloc_mem_bnb=}MB  {gpu_peak_mem_bnb=}MB  {gpu_alloc_mem_bnb+gpu_peak_mem_bnb=}MB")
          # print(f"{gpu_alloc_mem_diff=}MB")
          # print(f"{gpu_peak_mem_diff=}MB")
          # print(f"{gpu_total_mem_orig=}MB, {gpu_total_mem_bnb=}MB")
          # print(f"{gpu_total_mem_diff=}MB, {gpu_total_mem_diff=}MB")

          self.assertGreater(
              A__     ,  A__     ,  "should use ~150MB less alloc gpu memory with BNB, compared to without it for this model but got"
              F" a difference of {gpu_alloc_mem_diff}MB, with gpu_alloc_mem_orig={gpu_alloc_mem_orig}MB and"
              F" gpu_alloc_mem_bnb={gpu_alloc_mem_bnb}MB"     ,  )

          self.assertGreater(
              A__     ,  A__     ,  "should use ~150MB less total gpu memory with BNB, compared to without it for this model but got"
              F" a difference of {gpu_total_mem_diff}MB, with gpu_total_mem_orig={gpu_total_mem_orig}MB and"
              F" gpu_total_mem_bnb={gpu_total_mem_bnb}MB"     ,  )

          self.assertEqual(
              A__     ,  A__     ,  F"loss should be the same, but got loss_orig={loss_orig}, loss_bnb={loss_bnb}" )






      def        UpperCAmelCase_    (						self:       Dict     ,  __lowerCamelCase:       Dict     ,  __lowerCamelCase:       Optional[int]     ,  __lowerCamelCase:       List[Any]     ,  __lowerCamelCase:       Tuple = 3e-3     ,  __lowerCamelCase:       Dict = "adafactor"     ,  __lowerCamelCase:       List[str] = False     ,  __lowerCamelCase:       Dict = None     ,  __lowerCamelCase:       Any = 0     ,  __lowerCamelCase:       str = True     ,  __lowerCamelCase:       Tuple = True     ,  __lowerCamelCase:       Tuple = True     ,  __lowerCamelCase:       str = True     ,  __lowerCamelCase:       List[str] = None     ,  ):
          '''simple docstring'''


          UpperCamelCase__:     Dict     							=			self.test_file_dir / "../fixtures/tests_samples/wmt_en_ro"
          UpperCamelCase__:     int     							=			self.get_auto_remove_tmp_dir()
          UpperCamelCase__:     Any     							=			F"\n            --model_name_or_path {model_name}\n            --train_file {data_dir}/train.json\n            --validation_file {data_dir}/val.json\n            --test_file {data_dir}/test.json\n            --output_dir {output_dir}\n            --overwrite_output_dir\n            --max_train_samples 8\n            --max_source_length {max_len}\n            --max_target_length {max_len}\n            --do_train\n            --num_train_epochs {str(A__ )}\n            --per_device_train_batch_size 4\n            --learning_rate {learning_rate}\n            --warmup_steps 8\n            --logging_steps 0\n            --logging_strategy no\n            --save_steps {str(A__ )}\n            --group_by_length\n            --label_smoothing_factor 0.1\n            --target_lang ro_RO\n            --source_lang en_XX\n        ".split()

          UpperCamelCase__:     Any     							=			F"\n            --do_eval\n            --per_device_eval_batch_size 4\n            --max_eval_samples 8\n            --val_max_target_length {max_len}\n            --evaluation_strategy steps\n            --eval_steps {str(A__ )}\n        ".split()

          UpperCamelCase__:     int     							=			"\n            --do_predict\n        ".split()

          UpperCamelCase__:     Any     							=			[]
          if do_train:
              args += args_train

          if do_eval:
              args += args_eval

          if do_predict:
              args += args_predict

          if predict_with_generate:
              args += "--predict_with_generate".split()

          if do_train:
              if optim == "adafactor":
                  args += "--adafactor".split()
              else:
                  args += F"--optim {optim}".split()

          if extra_args_str is not None:
              args += extra_args_str.split()

          if distributed:
              if n_gpus_to_use is None:
                  UpperCamelCase__:     Optional[int]     							=			get_gpu_count()
              UpperCamelCase__:     Optional[int]     							=			get_torch_dist_unique_port()
              UpperCamelCase__:     Any     							=			F"\n                -m torch.distributed.run\n                --nproc_per_node={n_gpus_to_use}\n                --master_port={master_port}\n                {self.examples_dir_str}/pytorch/translation/run_translation.py\n            ".split()
              UpperCamelCase__:     Any     							=			[sys.executable] + distributed_args + args
              # keep for quick debug
              # print(" ".join([f"\nPYTHONPATH={self.src_dir_str}"] +cmd)); die
              execute_subprocess_async(A__     ,  env=self.get_env() )
          else:
              UpperCamelCase__:     Union[str, Any]     							=			["run_translation.py"] + args
              with patch.object(A__     ,  "argv"     ,  A__ ):
                  main()

          return output_dir



import copy
import unittest

from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

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


if is_torch_available():
							import torch

							from transformers import (
							    MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
							    MODEL_FOR_QUESTION_ANSWERING_MAPPING,
							    MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
							    MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
							    LayoutLMvaConfig,
							    LayoutLMvaForQuestionAnswering,
							    LayoutLMvaForSequenceClassification,
							    LayoutLMvaForTokenClassification,
							    LayoutLMvaModel,
							)
							from transformers.models.layoutlmva.modeling_layoutlmva import LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
							from PIL import Image

							from transformers import LayoutLMvaImageProcessor







class 				lowercase		:




							def __init__(				self   ,A__   ,A__=2   ,A__=3   ,A__=4   ,A__=2   ,A__=7   ,A__=True   ,A__=True   ,A__=True   ,A__=True   ,A__=9_9   ,A__=3_6   ,A__=3   ,A__=4   ,A__=3_7   ,A__="gelu"   ,A__=0.1   ,A__=0.1   ,A__=5_1_2   ,A__=1_6   ,A__=2   ,A__=0.02   ,A__=6   ,A__=6   ,A__=3   ,A__=4   ,A__=None   ,A__=1_0_0_0   ,):
												lowercase							=						parent
												lowercase							=						batch_size
												lowercase							=						num_channels
												lowercase							=						image_size
												lowercase							=						patch_size
												lowercase							=						text_seq_length
												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  A__      (				self):
												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)
												# 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							=						t
																						if bbox[i, j, 2] < bbox[i, j, 0]:
																											lowercase							=						bbox[i, j, 2]
																											lowercase							=						bbox[i, j, 0]
																											lowercase							=						t

												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  A__      (				self   ,A__   ,A__   ,A__   ,A__   ,A__   ,A__   ,A__   ,A__):
												lowercase							=						LayoutLMvaModel(config=A__)
												model.to(A__)
												model.eval()

												# text + image
												lowercase							=						model(A__   ,pixel_values=A__)
												lowercase							=						model(
												    A__   ,bbox=A__   ,pixel_values=A__   ,attention_mask=A__   ,token_type_ids=A__)
												lowercase							=						model(A__   ,bbox=A__   ,pixel_values=A__   ,token_type_ids=A__)
												lowercase							=						model(A__   ,bbox=A__   ,pixel_values=A__)

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

												# text only
												lowercase							=						model(A__)
												self.parent.assertEqual(
												    result.last_hidden_state.shape   ,(self.batch_size, self.text_seq_length, self.hidden_size))

												# image only
												lowercase							=						model(pixel_values=A__)
												self.parent.assertEqual(
												    result.last_hidden_state.shape   ,(self.batch_size, self.image_seq_length, self.hidden_size))




							def  A__      (				self   ,A__   ,A__   ,A__   ,A__   ,A__   ,A__   ,A__   ,A__):
												lowercase							=						self.num_labels
												lowercase							=						LayoutLMvaForSequenceClassification(A__)
												model.to(A__)
												model.eval()
												lowercase							=						model(
												    A__   ,bbox=A__   ,pixel_values=A__   ,attention_mask=A__   ,token_type_ids=A__   ,labels=A__   ,)
												self.parent.assertEqual(result.logits.shape   ,(self.batch_size, self.num_labels))




							def  A__      (				self   ,A__   ,A__   ,A__   ,A__   ,A__   ,A__   ,A__   ,A__):
												lowercase							=						self.num_labels
												lowercase							=						LayoutLMvaForTokenClassification(config=A__)
												model.to(A__)
												model.eval()
												lowercase							=						model(
												    A__   ,bbox=A__   ,pixel_values=A__   ,attention_mask=A__   ,token_type_ids=A__   ,labels=A__   ,)
												self.parent.assertEqual(result.logits.shape   ,(self.batch_size, self.text_seq_length, self.num_labels))




							def  A__      (				self   ,A__   ,A__   ,A__   ,A__   ,A__   ,A__   ,A__   ,A__):
												lowercase							=						LayoutLMvaForQuestionAnswering(config=A__)
												model.to(A__)
												model.eval()
												lowercase							=						model(
												    A__   ,bbox=A__   ,pixel_values=A__   ,attention_mask=A__   ,token_type_ids=A__   ,start_positions=A__   ,end_positions=A__   ,)
												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  A__      (				self):
												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_torch
class 				lowercase		(					SCREAMING_SNAKE_CASE__       ,  SCREAMING_SNAKE_CASE__       ,  unittest.TestCase		):
							lowercase_       :       Dict       					=False
							lowercase_       :       Any       					=False
							lowercase_       :       Tuple       					=False

							lowercase_       :       Any       					=(
							    (
							        LayoutLMvaModel,
							        LayoutLMvaForSequenceClassification,
							        LayoutLMvaForTokenClassification,
							        LayoutLMvaForQuestionAnswering,
							    )
							    if is_torch_available()
							    else ()
							)
							lowercase_       :       int       					=(
							    {'''document-question-answering''': LayoutLMvaForQuestionAnswering, '''feature-extraction''': LayoutLMvaModel}
							    if is_torch_available()
							    else {}
							)




							def  A__      (				self   ,A__   ,A__   ,A__   ,A__   ,A__):
												# `DocumentQuestionAnsweringPipeline` is expected to work with this model, but it combines the text and visual
												# embedding along the sequence dimension (dim 1), which causes an error during post-processing as `p_mask` has
												# the sequence dimension of the text embedding only.
												# (see the line `embedding_output = torch.cat([embedding_output, visual_embeddings], dim=1)`)
												return True




							def  A__      (				self):
												lowercase							=						LayoutLMvaModelTester(self)
												lowercase							=						ConfigTester(self   ,config_class=A__   ,hidden_size=3_7)




							def  A__      (				self   ,A__   ,A__   ,A__=False):
												lowercase							=						copy.deepcopy(A__)
												if model_class in get_values(A__):
																	lowercase							=						{
																	    k: v.unsqueeze(1).expand(-1   ,self.model_tester.num_choices   ,-1).contiguous()
																	    if isinstance(A__   ,torch.Tensor) and v.ndim > 1
																	    else v
																	    for k, v in inputs_dict.items()
																	}
												if return_labels:
																	if model_class in get_values(A__):
																						lowercase							=						torch.ones(self.model_tester.batch_size   ,dtype=torch.long   ,device=A__)
																	elif model_class in get_values(A__):
																						lowercase							=						torch.zeros(
																						    self.model_tester.batch_size   ,dtype=torch.long   ,device=A__)
																						lowercase							=						torch.zeros(
																						    self.model_tester.batch_size   ,dtype=torch.long   ,device=A__)
																	elif model_class in [
																	    *get_values(A__),
																	]:
																						lowercase							=						torch.zeros(
																						    self.model_tester.batch_size   ,dtype=torch.long   ,device=A__)
																	elif model_class in [
																	    *get_values(A__),
																	]:
																						lowercase							=						torch.zeros(
																						    (self.model_tester.batch_size, self.model_tester.text_seq_length)   ,dtype=torch.long   ,device=A__   ,)

												return inputs_dict




							def  A__      (				self):
												self.config_tester.run_common_tests()




							def  A__      (				self):
												lowercase							=						self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_model(*A__)




							def  A__      (				self):
												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(*A__)




							def  A__      (				self):
												lowercase							=						self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_sequence_classification(*A__)




							def  A__      (				self):
												lowercase							=						self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_token_classification(*A__)




							def  A__      (				self):
												lowercase							=						self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_question_answering(*A__)





							@slow
							def  A__      (				self):
												for model_name in LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																	lowercase							=						LayoutLMvaModel.from_pretrained(A__)
																	self.assertIsNotNone(A__)



def        UpperCamelCase    (							):
					'''simple docstring'''
					lowercase							=						Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''		)
					return image







@require_torch
class 				lowercase		(					unittest.TestCase		):




							@cached_property
							def  A__      (				self):
												return LayoutLMvaImageProcessor(apply_ocr=A__) if is_vision_available() else None





							@slow
							def  A__      (				self):
												lowercase							=						LayoutLMvaModel.from_pretrained('''microsoft/layoutlmv3-base''').to(A__)

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

												lowercase							=						torch.tensor([[1, 2]])
												lowercase							=						torch.tensor([[1, 2, 3, 4], [5, 6, 7, 8]]).unsqueeze(0)

												# forward pass
												lowercase							=						model(
												    input_ids=input_ids.to(A__)   ,bbox=bbox.to(A__)   ,pixel_values=pixel_values.to(A__)   ,)

												# verify the logits
												lowercase							=						torch.Size((1, 1_9_9, 7_6_8))
												self.assertEqual(outputs.last_hidden_state.shape   ,A__)

												lowercase							=						torch.tensor(
												    [[-0.0529, 0.3618, 0.1632], [-0.1587, -0.1667, -0.0400], [-0.1557, -0.1671, -0.0505]]).to(A__)

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




