

import argparse
import glob
import logging
import os
from argparse import Namespace
from importlib import import_module

import numpy as np
import torch
from lightning_base import BaseTransformer, add_generic_args, generic_train
from seqeval.metrics import accuracy_score, fa_score, precision_score, recall_score
from torch.nn import CrossEntropyLoss
from torch.utils.data import DataLoader, TensorDataset
from utils_ner import TokenClassificationTask


__lowerCamelCase						    =      logging.getLogger(__name__)


class    A__ ( _snake_case     ):
    lowercase		   =						"token-classification"



    def __init__(   self						,			UpperCamelCase__    )  -> Any:





           '''simple docstring'''
           if type(UpperCamelCase__    ) == dict:
                  A_		   = Namespace(**UpperCamelCase__    )
           A_		   = import_module("""tasks"""    )
           try:
                  A_		   = getattr(UpperCamelCase__						,			hparams.task_type    )
                  A_		   = token_classification_task_clazz()
           except AttributeError:
                  raise ValueError(
                      f'''Task {hparams.task_type} needs to be defined as a TokenClassificationTask subclass in {module}. '''
                      f'''Available tasks classes are: {TokenClassificationTask.__subclasses__()}'''    )
           A_		   = self.token_classification_task.get_labels(hparams.labels    )
           A_		   = CrossEntropyLoss().ignore_index
           super().__init__(UpperCamelCase__						,			len(self.labels    )						,			self.mode    )



    def    snake_case_     (   self						,			**UpperCamelCase__    )  -> int:





           '''simple docstring'''
           return self.model(**UpperCamelCase__    )



    def    snake_case_     (   self						,			UpperCamelCase__						,			UpperCamelCase__    )  -> List[Any]:





           '''simple docstring'''
           A_		   = {"""input_ids""": batch[0], """attention_mask""": batch[1], """labels""": batch[3]}
           if self.config.model_type != "distilbert":
                  A_		   = (
                      batch[2] if self.config.model_type in ["""bert""", """xlnet"""] else None
                  )  # XLM and RoBERTa don"t use token_type_ids

           A_		   = self(**UpperCamelCase__    )
           A_		   = outputs[0]
           # tensorboard_logs = {"loss": loss, "rate": self.lr_scheduler.get_last_lr()[-1]}
           return {"loss": loss}



    def    snake_case_     (   self    )  -> Any:





           '''simple docstring'''
           A_		   = self.hparams
           for mode in ["train", "dev", "test"]:
                  A_		   = self._feature_file(UpperCamelCase__    )
                  if os.path.exists(UpperCamelCase__    ) and not args.overwrite_cache:
                         logger.info("""Loading features from cached file %s"""						,			UpperCamelCase__    )
                         A_		   = torch.load(UpperCamelCase__    )
                  else:
                         logger.info("""Creating features from dataset file at %s"""						,			args.data_dir    )
                         A_		   = self.token_classification_task.read_examples_from_file(args.data_dir						,			UpperCamelCase__    )
                         A_		   = self.token_classification_task.convert_examples_to_features(
                             UpperCamelCase__						,			self.labels						,			args.max_seq_length						,			self.tokenizer						,			cls_token_at_end=bool(self.config.model_type in ["""xlnet"""]    )						,			cls_token=self.tokenizer.cls_token						,			cls_token_segment_id=2 if self.config.model_type in ["""xlnet"""] else 0						,			sep_token=self.tokenizer.sep_token						,			sep_token_extra=UpperCamelCase__						,			pad_on_left=bool(self.config.model_type in ["""xlnet"""]    )						,			pad_token=self.tokenizer.pad_token_id						,			pad_token_segment_id=self.tokenizer.pad_token_type_id						,			pad_token_label_id=self.pad_token_label_id						,			)
                         logger.info("""Saving features into cached file %s"""						,			UpperCamelCase__    )
                         torch.save(UpperCamelCase__						,			UpperCamelCase__    )



    def    snake_case_     (   self						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__ = False    )  -> DataLoader:





           '''simple docstring'''
           A_		   = self._feature_file(UpperCamelCase__    )
           logger.info("""Loading features from cached file %s"""						,			UpperCamelCase__    )
           A_		   = torch.load(UpperCamelCase__    )
           A_		   = torch.tensor([f.input_ids for f in features]						,			dtype=torch.long    )
           A_		   = torch.tensor([f.attention_mask for f in features]						,			dtype=torch.long    )
           if features[0].token_type_ids is not None:
                  A_		   = torch.tensor([f.token_type_ids for f in features]						,			dtype=torch.long    )
           else:
                  A_		   = torch.tensor([0 for f in features]						,			dtype=torch.long    )
                  # HACK(we will not use this anymore soon)
           A_		   = torch.tensor([f.label_ids for f in features]						,			dtype=torch.long    )
           return DataLoader(
               TensorDataset(UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__    )						,			batch_size=UpperCamelCase__    )



    def    snake_case_     (   self						,			UpperCamelCase__						,			UpperCamelCase__    )  -> List[Any]:





           '''simple docstring'''
           """Compute validation""" ""
           A_		   = {"""input_ids""": batch[0], """attention_mask""": batch[1], """labels""": batch[3]}
           if self.config.model_type != "distilbert":
                  A_		   = (
                      batch[2] if self.config.model_type in ["""bert""", """xlnet"""] else None
                  )  # XLM and RoBERTa don"t use token_type_ids
           A_		   = self(**UpperCamelCase__    )
           A_   ,     A_		   = outputs[:2]
           A_		   = logits.detach().cpu().numpy()
           A_		   = inputs["""labels"""].detach().cpu().numpy()
           return {"val_loss": tmp_eval_loss.detach().cpu(), "pred": preds, "target": out_label_ids}



    def    snake_case_     (   self						,			UpperCamelCase__    )  -> int:





           '''simple docstring'''
           A_		   = torch.stack([x["""val_loss"""] for x in outputs]    ).mean()
           A_		   = np.concatenate([x["""pred"""] for x in outputs]						,			axis=0    )
           A_		   = np.argmax(UpperCamelCase__						,			axis=2    )
           A_		   = np.concatenate([x["""target"""] for x in outputs]						,			axis=0    )

           A_		   = dict(enumerate(self.labels    )    )
           A_		   = [[] for _ in range(out_label_ids.shape[0]    )]
           A_		   = [[] for _ in range(out_label_ids.shape[0]    )]

           for i in range(out_label_ids.shape[0]    ):
                  for j in range(out_label_ids.shape[1]    ):
                         if out_label_ids[i, j] != self.pad_token_label_id:
                                out_label_list[i].append(label_map[out_label_ids[i][j]]    )
                                preds_list[i].append(label_map[preds[i][j]]    )

           A_		   = {
               """val_loss""": val_loss_mean,
               """accuracy_score""": accuracy_score(UpperCamelCase__						,			UpperCamelCase__    ),
               """precision""": precision_score(UpperCamelCase__						,			UpperCamelCase__    ),
               """recall""": recall_score(UpperCamelCase__						,			UpperCamelCase__    ),
               """f1""": fa_score(UpperCamelCase__						,			UpperCamelCase__    ),
           }

           A_		   = dict(results.items()    )
           A_		   = results
           return ret, preds_list, out_label_list



    def    snake_case_     (   self						,			UpperCamelCase__    )  -> int:





           '''simple docstring'''
           A_   ,     A_   ,     A_		   = self._eval_end(UpperCamelCase__    )
           A_		   = ret["""log"""]
           return {"val_loss": logs["val_loss"], "log": logs, "progress_bar": logs}



    def    snake_case_     (   self						,			UpperCamelCase__    )  -> str:





           '''simple docstring'''
           A_   ,     A_   ,     A_		   = self._eval_end(UpperCamelCase__    )

           # Converting to the dict required by pl
           # https://github.com/PyTorchLightning/pytorch-lightning/blob/master/\
           # pytorch_lightning/trainer/logging.py#L139
           A_		   = ret["""log"""]
           # `val_loss` is the key returned by `self._eval_end()` but actually refers to `test_loss`
           return {"avg_test_loss": logs["val_loss"], "log": logs, "progress_bar": logs}







    @staticmethod
    def    snake_case_     (   UpperCamelCase__						,			UpperCamelCase__    )  -> List[Any]:





           '''simple docstring'''
           BaseTransformer.add_model_specific_args(UpperCamelCase__						,			UpperCamelCase__    )
           parser.add_argument(
               """--task_type"""						,			default="""NER"""						,			type=UpperCamelCase__						,			help="""Task type to fine tune in training (e.g. NER, POS, etc)"""    )
           parser.add_argument(
               """--max_seq_length"""						,			default=128						,			type=UpperCamelCase__						,			help=(
                   """The maximum total input sequence length after tokenization. Sequences longer """
                   """than this will be truncated, sequences shorter will be padded."""
               )						,			)

           parser.add_argument(
               """--labels"""						,			default=""""""						,			type=UpperCamelCase__						,			help="""Path to a file containing all labels. If not specified, CoNLL-2003 labels are used."""						,			)
           parser.add_argument(
               """--gpus"""						,			default=0						,			type=UpperCamelCase__						,			help="""The number of GPUs allocated for this, it is by default 0 meaning none"""						,			)

           parser.add_argument(
               """--overwrite_cache"""						,			action="""store_true"""						,			help="""Overwrite the cached training and evaluation sets"""    )

           return parser


if __name__ == "__main__":
      __lowerCamelCase						    =      argparse.ArgumentParser()
      add_generic_args(parser, os.getcwd())
      __lowerCamelCase						    =      NERTransformer.add_model_specific_args(parser, os.getcwd())
      __lowerCamelCase						    =      parser.parse_args()
      __lowerCamelCase						    =      NERTransformer(args)
      __lowerCamelCase						    =      generic_train(model, args)

      if args.do_predict:
            # See https://github.com/huggingface/transformers/issues/3159
            # pl use this default format to create a checkpoint:
            # https://github.com/PyTorchLightning/pytorch-lightning/blob/master\
            # /pytorch_lightning/callbacks/model_checkpoint.py#L322
            __lowerCamelCase						    =      sorted(glob.glob(os.path.join(args.output_dir, '''checkpoint-epoch=*.ckpt'''), recursive=True))
            __lowerCamelCase						    =      model.load_from_checkpoint(checkpoints[-1])
            trainer.test(model)



'''simple docstring'''







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    A__ :



    def __init__(   self						,			UpperCamelCase__						,			UpperCamelCase__=2						,			UpperCamelCase__=3						,			UpperCamelCase__=4						,			UpperCamelCase__=2						,			UpperCamelCase__=7						,			UpperCamelCase__=True						,			UpperCamelCase__=True						,			UpperCamelCase__=True						,			UpperCamelCase__=True						,			UpperCamelCase__=99						,			UpperCamelCase__=36						,			UpperCamelCase__=3						,			UpperCamelCase__=4						,			UpperCamelCase__=37						,			UpperCamelCase__="gelu"						,			UpperCamelCase__=0.1						,			UpperCamelCase__=0.1						,			UpperCamelCase__=512						,			UpperCamelCase__=16						,			UpperCamelCase__=2						,			UpperCamelCase__=0.02						,			UpperCamelCase__=6						,			UpperCamelCase__=6						,			UpperCamelCase__=3						,			UpperCamelCase__=4						,			UpperCamelCase__=None						,			UpperCamelCase__=1000						,			)  -> Optional[int]:





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

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



    def    snake_case_     (   self    )  -> Any:





           '''simple docstring'''
           A_		   = ids_tensor([self.batch_size, self.text_seq_length]						,			self.vocab_size    )

           A_		   = 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]:
                                A_		   = bbox[i, j, 3]
                                A_		   = bbox[i, j, 1]
                                A_		   = t
                         if bbox[i, j, 2] < bbox[i, j, 0]:
                                A_		   = bbox[i, j, 2]
                                A_		   = bbox[i, j, 0]
                                A_		   = t

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

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

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

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

           A_		   = 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    snake_case_     (   self						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__    )  -> str:





           '''simple docstring'''
           A_		   = LayoutLMvaModel(config=UpperCamelCase__    )
           model.to(UpperCamelCase__    )
           model.eval()

           # text + image
           A_		   = model(UpperCamelCase__						,			pixel_values=UpperCamelCase__    )
           A_		   = model(
               UpperCamelCase__						,			bbox=UpperCamelCase__						,			pixel_values=UpperCamelCase__						,			attention_mask=UpperCamelCase__						,			token_type_ids=UpperCamelCase__    )
           A_		   = model(UpperCamelCase__						,			bbox=UpperCamelCase__						,			pixel_values=UpperCamelCase__						,			token_type_ids=UpperCamelCase__    )
           A_		   = model(UpperCamelCase__						,			bbox=UpperCamelCase__						,			pixel_values=UpperCamelCase__    )

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

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

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



    def    snake_case_     (   self						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__    )  -> Optional[Any]:





           '''simple docstring'''
           A_		   = self.num_labels
           A_		   = LayoutLMvaForSequenceClassification(UpperCamelCase__    )
           model.to(UpperCamelCase__    )
           model.eval()
           A_		   = model(
               UpperCamelCase__						,			bbox=UpperCamelCase__						,			pixel_values=UpperCamelCase__						,			attention_mask=UpperCamelCase__						,			token_type_ids=UpperCamelCase__						,			labels=UpperCamelCase__						,			)
           self.parent.assertEqual(result.logits.shape						,			(self.batch_size, self.num_labels)    )



    def    snake_case_     (   self						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__    )  -> str:





           '''simple docstring'''
           A_		   = self.num_labels
           A_		   = LayoutLMvaForTokenClassification(config=UpperCamelCase__    )
           model.to(UpperCamelCase__    )
           model.eval()
           A_		   = model(
               UpperCamelCase__						,			bbox=UpperCamelCase__						,			pixel_values=UpperCamelCase__						,			attention_mask=UpperCamelCase__						,			token_type_ids=UpperCamelCase__						,			labels=UpperCamelCase__						,			)
           self.parent.assertEqual(result.logits.shape						,			(self.batch_size, self.text_seq_length, self.num_labels)    )



    def    snake_case_     (   self						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__    )  -> int:





           '''simple docstring'''
           A_		   = LayoutLMvaForQuestionAnswering(config=UpperCamelCase__    )
           model.to(UpperCamelCase__    )
           model.eval()
           A_		   = model(
               UpperCamelCase__						,			bbox=UpperCamelCase__						,			pixel_values=UpperCamelCase__						,			attention_mask=UpperCamelCase__						,			token_type_ids=UpperCamelCase__						,			start_positions=UpperCamelCase__						,			end_positions=UpperCamelCase__						,			)
           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    snake_case_     (   self    )  -> int:





           '''simple docstring'''
           A_		   = self.prepare_config_and_inputs()
           (
               (
               A_
           )   ,     (
               A_
           )   ,     (
               A_
           )   ,     (
               A_
           )   ,     (
               A_
           )   ,     (
               A_
           )   ,     (
               A_
           )   ,     (
               A_
           )   ,     
           )		   = config_and_inputs
           A_		   = {
               """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    A__ ( _snake_case  ,  _snake_case  ,  unittest.TestCase     ):
    lowercase		   =						False
    lowercase		   =						False
    lowercase		   =						False

    lowercase		   =						(
        (
            LayoutLMvaModel,
            LayoutLMvaForSequenceClassification,
            LayoutLMvaForTokenClassification,
            LayoutLMvaForQuestionAnswering,
        )
        if is_torch_available()
        else ()
    )
    lowercase		   =						(
        {"document-question-answering": LayoutLMvaForQuestionAnswering, "feature-extraction": LayoutLMvaModel}
        if is_torch_available()
        else {}
    )



    def    snake_case_     (   self						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__    )  -> Dict:





           '''simple docstring'''
           # `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    snake_case_     (   self    )  -> str:





           '''simple docstring'''
           A_		   = LayoutLMvaModelTester(self    )
           A_		   = ConfigTester(self						,			config_class=UpperCamelCase__						,			hidden_size=37    )



    def    snake_case_     (   self						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__=False    )  -> Union[str, Any]:





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

           return inputs_dict



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





           '''simple docstring'''
           self.config_tester.run_common_tests()



    def    snake_case_     (   self    )  -> Dict:





           '''simple docstring'''
           A_		   = self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_model(*UpperCamelCase__    )



    def    snake_case_     (   self    )  -> Dict:





           '''simple docstring'''
           A_		   = self.model_tester.prepare_config_and_inputs()
           for type in ["absolute", "relative_key", "relative_key_query"]:
                  A_		   = type
                  self.model_tester.create_and_check_model(*UpperCamelCase__    )



    def    snake_case_     (   self    )  -> Dict:





           '''simple docstring'''
           A_		   = self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_sequence_classification(*UpperCamelCase__    )



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





           '''simple docstring'''
           A_		   = self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_token_classification(*UpperCamelCase__    )



    def    snake_case_     (   self    )  -> Tuple:





           '''simple docstring'''
           A_		   = self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_question_answering(*UpperCamelCase__    )







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





           '''simple docstring'''
           for model_name in LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                  A_		   = LayoutLMvaModel.from_pretrained(UpperCamelCase__    )
                  self.assertIsNotNone(UpperCamelCase__    )

def  UpperCAmelCase__      ( )     ->     Dict:
       A_		   = Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""			)
       return image







@require_torch
class    A__ ( unittest.TestCase     ):



    @cached_property
    def    snake_case_     (   self    )  -> List[Any]:





           '''simple docstring'''
           return LayoutLMvaImageProcessor(apply_ocr=UpperCamelCase__    ) if is_vision_available() else None







    @slow
    def    snake_case_     (   self    )  -> Optional[Any]:





           '''simple docstring'''
           A_		   = LayoutLMvaModel.from_pretrained("""microsoft/layoutlmv3-base"""    ).to(UpperCamelCase__    )

           A_		   = self.default_image_processor
           A_		   = prepare_img()
           A_		   = image_processor(images=UpperCamelCase__						,			return_tensors="""pt"""    ).pixel_values.to(UpperCamelCase__    )

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

           # forward pass
           A_		   = model(
               input_ids=input_ids.to(UpperCamelCase__    )						,			bbox=bbox.to(UpperCamelCase__    )						,			pixel_values=pixel_values.to(UpperCamelCase__    )						,			)

           # verify the logits
           A_		   = torch.Size((1, 199, 768)    )
           self.assertEqual(outputs.last_hidden_state.shape						,			UpperCamelCase__    )

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

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