


'''simple docstring'''






import unittest

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

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


if is_torch_available():
 import torch

 from transformers import (
     XLMForMultipleChoice,
     XLMForQuestionAnswering,
     XLMForQuestionAnsweringSimple,
     XLMForSequenceClassification,
     XLMForTokenClassification,
     XLMModel,
     XLMWithLMHeadModel,
 )
 from transformers.models.xlm.modeling_xlm import XLM_PRETRAINED_MODEL_ARCHIVE_LIST






class    __magic_name__				:






       def __init__(     self    ,				snake_case    ,				snake_case=1_3    ,				snake_case=7    ,				snake_case=True    ,				snake_case=True    ,				snake_case=True    ,				snake_case=True    ,				snake_case=True    ,				snake_case=False    ,				snake_case=False    ,				snake_case=False    ,				snake_case=2    ,				snake_case=9_9    ,				snake_case=0    ,				snake_case=3_2    ,				snake_case=5    ,				snake_case=4    ,				snake_case=0.1    ,				snake_case=0.1    ,				snake_case=5_1_2    ,				snake_case=2    ,				snake_case=0.02    ,				snake_case=2    ,				snake_case=4    ,				snake_case="last"    ,				snake_case=True    ,				snake_case=None    ,				snake_case=0    ,				)		->    Union[str, Any]:




          '''simple docstring'''
          _UpperCAmelCase  :  List[Any]				       =parent
          _UpperCAmelCase  :  Dict				       =batch_size
          _UpperCAmelCase  :  Dict				       =seq_length
          _UpperCAmelCase  :  Optional[int]				       =is_training
          _UpperCAmelCase  :  Optional[int]				       =use_input_lengths
          _UpperCAmelCase  :  Any				       =use_token_type_ids
          _UpperCAmelCase  :  Tuple				       =use_labels
          _UpperCAmelCase  :  Optional[int]				       =gelu_activation
          _UpperCAmelCase  :  Optional[int]				       =sinusoidal_embeddings
          _UpperCAmelCase  :  Tuple				       =causal
          _UpperCAmelCase  :  List[str]				       =asm
          _UpperCAmelCase  :  Dict				       =n_langs
          _UpperCAmelCase  :  List[str]				       =vocab_size
          _UpperCAmelCase  :  Tuple				       =n_special
          _UpperCAmelCase  :  Optional[int]				       =hidden_size
          _UpperCAmelCase  :  Dict				       =num_hidden_layers
          _UpperCAmelCase  :  List[Any]				       =num_attention_heads
          _UpperCAmelCase  :  List[str]				       =hidden_dropout_prob
          _UpperCAmelCase  :  Dict				       =attention_probs_dropout_prob
          _UpperCAmelCase  :  int				       =max_position_embeddings
          _UpperCAmelCase  :  List[str]				       =type_sequence_label_size
          _UpperCAmelCase  :  Optional[int]				       =initializer_range
          _UpperCAmelCase  :  List[Any]				       =num_labels
          _UpperCAmelCase  :  int				       =num_choices
          _UpperCAmelCase  :  List[Any]				       =summary_type
          _UpperCAmelCase  :  List[Any]				       =use_proj
          _UpperCAmelCase  :  List[Any]				       =scope
          _UpperCAmelCase  :  Any				       =bos_token_id






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




          '''simple docstring'''
          _UpperCAmelCase  :  Any				       =ids_tensor([self.batch_size, self.seq_length]    ,				self.vocab_size)
          _UpperCAmelCase  :  Optional[int]				       =random_attention_mask([self.batch_size, self.seq_length])

          _UpperCAmelCase  :  Union[str, Any]				       =None
          if self.use_input_lengths:
             _UpperCAmelCase  :  Tuple				       =(
                 ids_tensor([self.batch_size]    ,				vocab_size=2) + self.seq_length - 2
             )  # small variation of seq_length

          _UpperCAmelCase  :  Optional[Any]				       =None
          if self.use_token_type_ids:
             _UpperCAmelCase  :  str				       =ids_tensor([self.batch_size, self.seq_length]    ,				self.n_langs)

          _UpperCAmelCase  :  Optional[int]				       =None
          _UpperCAmelCase  :  Optional[int]				       =None
          _UpperCAmelCase  :  Optional[int]				       =None
          if self.use_labels:
             _UpperCAmelCase  :  List[str]				       =ids_tensor([self.batch_size]    ,				self.type_sequence_label_size)
             _UpperCAmelCase  :  Optional[int]				       =ids_tensor([self.batch_size, self.seq_length]    ,				self.num_labels)
             _UpperCAmelCase  :  List[str]				       =ids_tensor([self.batch_size]    ,				2).float()
             _UpperCAmelCase  :  Any				       =ids_tensor([self.batch_size]    ,				self.num_choices)

          _UpperCAmelCase  :  List[str]				       =self.get_config()

          return (
              config,
              input_ids,
              token_type_ids,
              input_lengths,
              sequence_labels,
              token_labels,
              is_impossible_labels,
              choice_labels,
              input_mask,
          )






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




          '''simple docstring'''
          return XLMConfig(
              vocab_size=self.vocab_size    ,				n_special=self.n_special    ,				emb_dim=self.hidden_size    ,				n_layers=self.num_hidden_layers    ,				n_heads=self.num_attention_heads    ,				dropout=self.hidden_dropout_prob    ,				attention_dropout=self.attention_probs_dropout_prob    ,				gelu_activation=self.gelu_activation    ,				sinusoidal_embeddings=self.sinusoidal_embeddings    ,				asm=self.asm    ,				causal=self.causal    ,				n_langs=self.n_langs    ,				max_position_embeddings=self.max_position_embeddings    ,				initializer_range=self.initializer_range    ,				summary_type=self.summary_type    ,				use_proj=self.use_proj    ,				num_labels=self.num_labels    ,				bos_token_id=self.bos_token_id    ,				)






       def      lowerCAmelCase						(     self    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				)		->    Dict:




          '''simple docstring'''
          _UpperCAmelCase  :  Dict				       =XLMModel(config=snake_case)
          model.to(snake_case)
          model.eval()
          _UpperCAmelCase  :  List[Any]				       =model(snake_case    ,				lengths=snake_case    ,				langs=snake_case)
          _UpperCAmelCase  :  str				       =model(snake_case    ,				langs=snake_case)
          _UpperCAmelCase  :  Optional[int]				       =model(snake_case)
          self.parent.assertEqual(result.last_hidden_state.shape    ,				(self.batch_size, self.seq_length, self.hidden_size))






       def      lowerCAmelCase						(     self    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				)		->    Any:




          '''simple docstring'''
          _UpperCAmelCase  :  Optional[Any]				       =XLMWithLMHeadModel(snake_case)
          model.to(snake_case)
          model.eval()

          _UpperCAmelCase  :  Dict				       =model(snake_case    ,				token_type_ids=snake_case    ,				labels=snake_case)
          self.parent.assertEqual(result.loss.shape    ,				())
          self.parent.assertEqual(result.logits.shape    ,				(self.batch_size, self.seq_length, self.vocab_size))






       def      lowerCAmelCase						(     self    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				)		->    Any:




          '''simple docstring'''
          _UpperCAmelCase  :  Dict				       =XLMForQuestionAnsweringSimple(snake_case)
          model.to(snake_case)
          model.eval()

          _UpperCAmelCase  :  str				       =model(snake_case)

          _UpperCAmelCase  :  int				       =model(snake_case    ,				start_positions=snake_case    ,				end_positions=snake_case)
          _UpperCAmelCase  :  Optional[Any]				       =outputs
          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      lowerCAmelCase						(     self    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				)		->    Optional[int]:




          '''simple docstring'''
          _UpperCAmelCase  :  Tuple				       =XLMForQuestionAnswering(snake_case)
          model.to(snake_case)
          model.eval()

          _UpperCAmelCase  :  Dict				       =model(snake_case)

          _UpperCAmelCase  :  Tuple				       =model(
              snake_case    ,				start_positions=snake_case    ,				end_positions=snake_case    ,				cls_index=snake_case    ,				is_impossible=snake_case    ,				p_mask=snake_case    ,				)

          _UpperCAmelCase  :  Optional[int]				       =model(
              snake_case    ,				start_positions=snake_case    ,				end_positions=snake_case    ,				cls_index=snake_case    ,				is_impossible=snake_case    ,				)

          ((_UpperCAmelCase)       ,			)  :  Dict				       =result_with_labels.to_tuple()

          _UpperCAmelCase  :  Union[str, Any]				       =model(snake_case    ,				start_positions=snake_case    ,				end_positions=snake_case)

          ((_UpperCAmelCase)       ,			)  :  str				       =result_with_labels.to_tuple()

          self.parent.assertEqual(result_with_labels.loss.shape    ,				())
          self.parent.assertEqual(result.start_top_log_probs.shape    ,				(self.batch_size, model.config.start_n_top))
          self.parent.assertEqual(result.start_top_index.shape    ,				(self.batch_size, model.config.start_n_top))
          self.parent.assertEqual(
              result.end_top_log_probs.shape    ,				(self.batch_size, model.config.start_n_top * model.config.end_n_top))
          self.parent.assertEqual(
              result.end_top_index.shape    ,				(self.batch_size, model.config.start_n_top * model.config.end_n_top))
          self.parent.assertEqual(result.cls_logits.shape    ,				(self.batch_size,))






       def      lowerCAmelCase						(     self    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				)		->    Any:




          '''simple docstring'''
          _UpperCAmelCase  :  Optional[Any]				       =XLMForSequenceClassification(snake_case)
          model.to(snake_case)
          model.eval()

          _UpperCAmelCase  :  List[str]				       =model(snake_case)
          _UpperCAmelCase  :  List[str]				       =model(snake_case    ,				labels=snake_case)
          self.parent.assertEqual(result.loss.shape    ,				())
          self.parent.assertEqual(result.logits.shape    ,				(self.batch_size, self.type_sequence_label_size))






       def      lowerCAmelCase						(     self    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				)		->    Optional[Any]:




          '''simple docstring'''
          _UpperCAmelCase  :  Dict				       =self.num_labels
          _UpperCAmelCase  :  Tuple				       =XLMForTokenClassification(snake_case)
          model.to(snake_case)
          model.eval()

          _UpperCAmelCase  :  Dict				       =model(snake_case    ,				attention_mask=snake_case    ,				labels=snake_case)
          self.parent.assertEqual(result.logits.shape    ,				(self.batch_size, self.seq_length, self.num_labels))






       def      lowerCAmelCase						(     self    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				)		->    Any:




          '''simple docstring'''
          _UpperCAmelCase  :  Optional[Any]				       =self.num_choices
          _UpperCAmelCase  :  Union[str, Any]				       =XLMForMultipleChoice(config=snake_case)
          model.to(snake_case)
          model.eval()
          _UpperCAmelCase  :  Optional[int]				       =input_ids.unsqueeze(1).expand(-1    ,				self.num_choices    ,				-1).contiguous()
          _UpperCAmelCase  :  List[str]				       =token_type_ids.unsqueeze(1).expand(-1    ,				self.num_choices    ,				-1).contiguous()
          _UpperCAmelCase  :  Optional[int]				       =input_mask.unsqueeze(1).expand(-1    ,				self.num_choices    ,				-1).contiguous()
          _UpperCAmelCase  :  Tuple				       =model(
              snake_case    ,				attention_mask=snake_case    ,				token_type_ids=snake_case    ,				labels=snake_case    ,				)
          self.parent.assertEqual(result.logits.shape    ,				(self.batch_size, self.num_choices))






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




          '''simple docstring'''
          _UpperCAmelCase  :  int				       =self.prepare_config_and_inputs()
          (
              (
              _UpperCAmelCase
          )       ,			(
              _UpperCAmelCase
          )       ,			(
              _UpperCAmelCase
          )       ,			(
              _UpperCAmelCase
          )       ,			(
              _UpperCAmelCase
          )       ,			(
              _UpperCAmelCase
          )       ,			(
              _UpperCAmelCase
          )       ,			(
              _UpperCAmelCase
          )       ,			(
              _UpperCAmelCase
          )       ,			
          )  :  Tuple				       =config_and_inputs
          _UpperCAmelCase  :  Dict				       ={'input_ids': input_ids, 'token_type_ids': token_type_ids, 'lengths': input_lengths}
          return config, inputs_dict






@require_torch
class    __magic_name__				(						lowerCAmelCase   ,lowerCAmelCase   ,lowerCAmelCase   ,unittest.TestCase							):
       UpperCAmelCase		 =(
           (
               XLMModel,
               XLMWithLMHeadModel,
               XLMForQuestionAnswering,
               XLMForSequenceClassification,
               XLMForQuestionAnsweringSimple,
               XLMForTokenClassification,
               XLMForMultipleChoice,
           )
           if is_torch_available()
           else ()
       )
       UpperCAmelCase		 =(
           (XLMWithLMHeadModel,) if is_torch_available() else ()
       )  # TODO (PVP): Check other models whether language generation is also applicable
       UpperCAmelCase		 =(
           {
               "feature-extraction": XLMModel,
               "fill-mask": XLMWithLMHeadModel,
               "question-answering": XLMForQuestionAnsweringSimple,
               "text-classification": XLMForSequenceClassification,
               "text-generation": XLMWithLMHeadModel,
               "token-classification": XLMForTokenClassification,
               "zero-shot": XLMForSequenceClassification,
           }
           if is_torch_available()
           else {}
       )






       def      lowerCAmelCase						(     self    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case)		->    List[str]:




          '''simple docstring'''
          if (
              pipeline_test_casse_name == "QAPipelineTests"
              and tokenizer_name is not None
              and not tokenizer_name.endswith('Fast')
          ):
             # `QAPipelineTests` fails for a few models when the slower tokenizer are used.
             # (The slower tokenizers were never used for pipeline tests before the pipeline testing rework)
             # TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer
             return True

          return False






       def      lowerCAmelCase						(     self    ,				snake_case    ,				snake_case    ,				snake_case=False)		->    List[str]:




          '''simple docstring'''
          _UpperCAmelCase  :  int				       =super()._prepare_for_class(snake_case    ,				snake_case    ,				return_labels=snake_case)

          if return_labels:
             if model_class.__name__ == "XLMForQuestionAnswering":
                _UpperCAmelCase  :  List[str]				       =torch.zeros(
                    self.model_tester.batch_size    ,				dtype=torch.long    ,				device=snake_case)
                _UpperCAmelCase  :  List[Any]				       =torch.zeros(
                    self.model_tester.batch_size    ,				dtype=torch.long    ,				device=snake_case)

          return inputs_dict






       def      lowerCAmelCase						(     self)		->    Dict:




          '''simple docstring'''
          _UpperCAmelCase  :  Tuple				       =XLMModelTester(self)
          _UpperCAmelCase  :  Union[str, Any]				       =ConfigTester(self    ,				config_class=snake_case    ,				emb_dim=3_7)






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




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






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




          '''simple docstring'''
          _UpperCAmelCase  :  List[str]				       =self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_xlm_model(*snake_case)






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




          '''simple docstring'''
          _UpperCAmelCase  :  Optional[int]				       =self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_xlm_lm_head(*snake_case)






       def      lowerCAmelCase						(     self)		->    int:




          '''simple docstring'''
          _UpperCAmelCase  :  Union[str, Any]				       =self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_xlm_simple_qa(*snake_case)






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




          '''simple docstring'''
          _UpperCAmelCase  :  str				       =self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_xlm_qa(*snake_case)






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




          '''simple docstring'''
          _UpperCAmelCase  :  int				       =self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_xlm_sequence_classif(*snake_case)






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




          '''simple docstring'''
          _UpperCAmelCase  :  str				       =self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_xlm_token_classif(*snake_case)






       def      lowerCAmelCase						(     self)		->    Dict:




          '''simple docstring'''
          _UpperCAmelCase  :  Any				       =self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_xlm_for_multiple_choice(*snake_case)






       def      lowerCAmelCase						(     self    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case=False    ,				snake_case=1)		->    int:




          '''simple docstring'''
          self.assertIsInstance(snake_case    ,				snake_case)
          self.assertListEqual(
              [isinstance(snake_case    ,				snake_case) for iter_attentions in attentions]    ,				[True] * len(snake_case))
          self.assertEqual(len(snake_case)    ,				(max_length - min_length) * num_beam_groups)

          for idx, iter_attentions in enumerate(snake_case):
             # adds PAD dummy token
             _UpperCAmelCase  :  int				       =min_length + idx + 1
             _UpperCAmelCase  :  str				       =min_length + idx + 1

             _UpperCAmelCase  :  List[str]				       =(
                 batch_size * num_beam_groups,
                 config.num_attention_heads,
                 tgt_len,
                 src_len,
             )
             # check attn size
             self.assertListEqual(
                 [layer_attention.shape for layer_attention in iter_attentions]    ,				[expected_shape] * len(snake_case))






       def      lowerCAmelCase						(     self    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case=False    ,				snake_case=1)		->    List[str]:




          '''simple docstring'''
          self.assertIsInstance(snake_case    ,				snake_case)
          self.assertListEqual(
              [isinstance(snake_case    ,				snake_case) for iter_hidden_states in hidden_states]    ,				[True] * len(snake_case)    ,				)
          self.assertEqual(len(snake_case)    ,				(max_length - min_length) * num_beam_groups)

          for idx, iter_hidden_states in enumerate(snake_case):
             # adds PAD dummy token
             _UpperCAmelCase  :  Dict				       =min_length + idx + 1
             _UpperCAmelCase  :  int				       =(batch_size * num_beam_groups, seq_len, config.hidden_size)
             # check hidden size
             self.assertListEqual(
                 [layer_hidden_states.shape for layer_hidden_states in iter_hidden_states]    ,				[expected_shape] * len(snake_case)    ,				)
          pass






       @slow
       def      lowerCAmelCase						(     self)		->    Dict:




          '''simple docstring'''
          for model_name in XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             _UpperCAmelCase  :  Optional[Any]				       =XLMModel.from_pretrained(snake_case)
             self.assertIsNotNone(snake_case)






@require_torch
class    __magic_name__				(						unittest.TestCase							):






       @slow
       def      lowerCAmelCase						(     self)		->    Optional[int]:




          '''simple docstring'''
          _UpperCAmelCase  :  int				       =XLMWithLMHeadModel.from_pretrained('xlm-mlm-en-2048')
          model.to(snake_case)
          _UpperCAmelCase  :  List[str]				       =torch.tensor([[1_4, 4_4_7]]    ,				dtype=torch.long    ,				device=snake_case)  # the president
          _UpperCAmelCase  :  str				       =[
              1_4,
              4_4_7,
              1_4,
              4_4_7,
              1_4,
              4_4_7,
              1_4,
              4_4_7,
              1_4,
              4_4_7,
              1_4,
              4_4_7,
              1_4,
              4_4_7,
              1_4,
              4_4_7,
              1_4,
              4_4_7,
              1_4,
              4_4_7,
          ]  # the president the president the president the president the president the president the president the president the president the president
          # TODO(PVP): this and other input_ids I tried for generation give pretty bad results. Not sure why. Model might just not be made for auto-regressive inference
          _UpperCAmelCase  :  Optional[int]				       =model.generate(snake_case    ,				do_sample=snake_case)
          self.assertListEqual(output_ids[0].cpu().numpy().tolist()    ,				snake_case)





'''simple docstring'''






from __future__ import annotations

import unittest

import numpy as np

from transformers import LayoutLMConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

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


if is_tf_available():
 import tensorflow as tf

 from transformers.models.layoutlm.modeling_tf_layoutlm import (
     TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST,
     TFLayoutLMForMaskedLM,
     TFLayoutLMForQuestionAnswering,
     TFLayoutLMForSequenceClassification,
     TFLayoutLMForTokenClassification,
     TFLayoutLMModel,
 )






class    __magic_name__				:






       def __init__(     self    ,				snake_case    ,				snake_case=1_3    ,				snake_case=7    ,				snake_case=True    ,				snake_case=True    ,				snake_case=True    ,				snake_case=True    ,				snake_case=9_9    ,				snake_case=3_2    ,				snake_case=2    ,				snake_case=4    ,				snake_case=3_7    ,				snake_case="gelu"    ,				snake_case=0.1    ,				snake_case=0.1    ,				snake_case=5_1_2    ,				snake_case=1_6    ,				snake_case=2    ,				snake_case=0.02    ,				snake_case=3    ,				snake_case=4    ,				snake_case=None    ,				snake_case=1_0_0_0    ,				)		->    Optional[Any]:




          '''simple docstring'''
          _UpperCAmelCase  :  List[str]				       =parent
          _UpperCAmelCase  :  str				       =batch_size
          _UpperCAmelCase  :  List[Any]				       =seq_length
          _UpperCAmelCase  :  List[str]				       =is_training
          _UpperCAmelCase  :  Any				       =use_input_mask
          _UpperCAmelCase  :  List[str]				       =use_token_type_ids
          _UpperCAmelCase  :  Optional[int]				       =use_labels
          _UpperCAmelCase  :  Optional[Any]				       =vocab_size
          _UpperCAmelCase  :  str				       =hidden_size
          _UpperCAmelCase  :  str				       =num_hidden_layers
          _UpperCAmelCase  :  Tuple				       =num_attention_heads
          _UpperCAmelCase  :  List[Any]				       =intermediate_size
          _UpperCAmelCase  :  str				       =hidden_act
          _UpperCAmelCase  :  str				       =hidden_dropout_prob
          _UpperCAmelCase  :  Any				       =attention_probs_dropout_prob
          _UpperCAmelCase  :  int				       =max_position_embeddings
          _UpperCAmelCase  :  List[Any]				       =type_vocab_size
          _UpperCAmelCase  :  List[str]				       =type_sequence_label_size
          _UpperCAmelCase  :  Union[str, Any]				       =initializer_range
          _UpperCAmelCase  :  Tuple				       =num_labels
          _UpperCAmelCase  :  int				       =num_choices
          _UpperCAmelCase  :  List[str]				       =scope
          _UpperCAmelCase  :  Any				       =range_bbox






       def      lowerCAmelCase						(     self)		->    List[Any]:




          '''simple docstring'''
          _UpperCAmelCase  :  Tuple				       =ids_tensor([self.batch_size, self.seq_length]    ,				self.vocab_size)

          # convert bbox to numpy since TF does not support item assignment
          _UpperCAmelCase  :  List[str]				       =ids_tensor([self.batch_size, self.seq_length, 4]    ,				self.range_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]:
                   _UpperCAmelCase  :  Optional[Any]				       =bbox[i, j, 3]
                   _UpperCAmelCase  :  Optional[Any]				       =bbox[i, j, 1]
                   _UpperCAmelCase  :  str				       =t
                if bbox[i, j, 2] < bbox[i, j, 0]:
                   _UpperCAmelCase  :  Optional[int]				       =bbox[i, j, 2]
                   _UpperCAmelCase  :  Tuple				       =bbox[i, j, 0]
                   _UpperCAmelCase  :  Dict				       =t
          _UpperCAmelCase  :  Union[str, Any]				       =tf.convert_to_tensor(snake_case)

          _UpperCAmelCase  :  str				       =None
          if self.use_input_mask:
             _UpperCAmelCase  :  Optional[Any]				       =random_attention_mask([self.batch_size, self.seq_length])

          _UpperCAmelCase  :  Union[str, Any]				       =None
          if self.use_token_type_ids:
             _UpperCAmelCase  :  Optional[Any]				       =ids_tensor([self.batch_size, self.seq_length]    ,				self.type_vocab_size)

          _UpperCAmelCase  :  Optional[int]				       =None
          _UpperCAmelCase  :  Tuple				       =None
          _UpperCAmelCase  :  int				       =None
          if self.use_labels:
             _UpperCAmelCase  :  str				       =ids_tensor([self.batch_size]    ,				self.type_sequence_label_size)
             _UpperCAmelCase  :  List[str]				       =ids_tensor([self.batch_size, self.seq_length]    ,				self.num_labels)
             _UpperCAmelCase  :  Tuple				       =ids_tensor([self.batch_size]    ,				self.num_choices)

          _UpperCAmelCase  :  Optional[int]				       =LayoutLMConfig(
              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    ,				)

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






       def      lowerCAmelCase						(     self    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case)		->    Dict:




          '''simple docstring'''
          _UpperCAmelCase  :  int				       =TFLayoutLMModel(config=snake_case)

          _UpperCAmelCase  :  Dict				       =model(snake_case    ,				snake_case    ,				attention_mask=snake_case    ,				token_type_ids=snake_case)
          _UpperCAmelCase  :  Dict				       =model(snake_case    ,				snake_case    ,				token_type_ids=snake_case)
          _UpperCAmelCase  :  int				       =model(snake_case    ,				snake_case)
          self.parent.assertEqual(result.last_hidden_state.shape    ,				(self.batch_size, self.seq_length, self.hidden_size))
          self.parent.assertEqual(result.pooler_output.shape    ,				(self.batch_size, self.hidden_size))






       def      lowerCAmelCase						(     self    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case)		->    List[Any]:




          '''simple docstring'''
          _UpperCAmelCase  :  Optional[Any]				       =TFLayoutLMForMaskedLM(config=snake_case)

          _UpperCAmelCase  :  Optional[Any]				       =model(snake_case    ,				snake_case    ,				attention_mask=snake_case    ,				token_type_ids=snake_case    ,				labels=snake_case)
          self.parent.assertEqual(result.logits.shape    ,				(self.batch_size, self.seq_length, self.vocab_size))






       def      lowerCAmelCase						(     self    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case)		->    Any:




          '''simple docstring'''
          _UpperCAmelCase  :  Dict				       =self.num_labels
          _UpperCAmelCase  :  Dict				       =TFLayoutLMForSequenceClassification(config=snake_case)

          _UpperCAmelCase  :  Union[str, Any]				       =model(snake_case    ,				snake_case    ,				attention_mask=snake_case    ,				token_type_ids=snake_case)
          self.parent.assertEqual(result.logits.shape    ,				(self.batch_size, self.num_labels))






       def      lowerCAmelCase						(     self    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case)		->    Optional[Any]:




          '''simple docstring'''
          _UpperCAmelCase  :  str				       =self.num_labels
          _UpperCAmelCase  :  Any				       =TFLayoutLMForTokenClassification(config=snake_case)

          _UpperCAmelCase  :  str				       =model(snake_case    ,				snake_case    ,				attention_mask=snake_case    ,				token_type_ids=snake_case    ,				labels=snake_case)
          self.parent.assertEqual(result.logits.shape    ,				(self.batch_size, self.seq_length, self.num_labels))






       def      lowerCAmelCase						(     self    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case    ,				snake_case)		->    str:




          '''simple docstring'''
          _UpperCAmelCase  :  Any				       =TFLayoutLMForQuestionAnswering(config=snake_case)

          _UpperCAmelCase  :  Union[str, Any]				       =model(snake_case    ,				snake_case    ,				attention_mask=snake_case    ,				token_type_ids=snake_case)
          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      lowerCAmelCase						(     self)		->    Tuple:




          '''simple docstring'''
          _UpperCAmelCase  :  Any				       =self.prepare_config_and_inputs()
          (
              (
              _UpperCAmelCase
          )       ,			(
              _UpperCAmelCase
          )       ,			(
              _UpperCAmelCase
          )       ,			(
              _UpperCAmelCase
          )       ,			(
              _UpperCAmelCase
          )       ,			(
              _UpperCAmelCase
          )       ,			(
              _UpperCAmelCase
          )       ,			(
              _UpperCAmelCase
          )       ,			
          )  :  Optional[int]				       =config_and_inputs
          _UpperCAmelCase  :  Any				       ={
              'input_ids': input_ids,
              'bbox': bbox,
              'token_type_ids': token_type_ids,
              'attention_mask': input_mask,
          }
          return config, inputs_dict






@require_tf
class    __magic_name__				(						lowerCAmelCase   ,lowerCAmelCase   ,unittest.TestCase							):
       UpperCAmelCase		 =(
           (
               TFLayoutLMModel,
               TFLayoutLMForMaskedLM,
               TFLayoutLMForTokenClassification,
               TFLayoutLMForSequenceClassification,
               TFLayoutLMForQuestionAnswering,
           )
           if is_tf_available()
           else ()
       )
       UpperCAmelCase		 =(
           {
               "feature-extraction": TFLayoutLMModel,
               "fill-mask": TFLayoutLMForMaskedLM,
               "text-classification": TFLayoutLMForSequenceClassification,
               "token-classification": TFLayoutLMForTokenClassification,
               "zero-shot": TFLayoutLMForSequenceClassification,
           }
           if is_tf_available()
           else {}
       )
       UpperCAmelCase		 =False
       UpperCAmelCase		 =True
       UpperCAmelCase		 =1_0






       def      lowerCAmelCase						(     self)		->    Tuple:




          '''simple docstring'''
          _UpperCAmelCase  :  List[str]				       =TFLayoutLMModelTester(self)
          _UpperCAmelCase  :  int				       =ConfigTester(self    ,				config_class=snake_case    ,				hidden_size=3_7)






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




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






       def      lowerCAmelCase						(     self)		->    Dict:




          '''simple docstring'''
          _UpperCAmelCase  :  Tuple				       =self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*snake_case)






       def      lowerCAmelCase						(     self)		->    Tuple:




          '''simple docstring'''
          _UpperCAmelCase  :  List[str]				       =self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_masked_lm(*snake_case)






       def      lowerCAmelCase						(     self)		->    Dict:




          '''simple docstring'''
          _UpperCAmelCase  :  Optional[int]				       =self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_sequence_classification(*snake_case)






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




          '''simple docstring'''
          _UpperCAmelCase  :  str				       =self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_token_classification(*snake_case)






       def      lowerCAmelCase						(     self)		->    str:




          '''simple docstring'''
          _UpperCAmelCase  :  Dict				       =self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_question_answering(*snake_case)






       @slow
       def      lowerCAmelCase						(     self)		->    Tuple:




          '''simple docstring'''
          for model_name in TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             _UpperCAmelCase  :  str				       =TFLayoutLMModel.from_pretrained(snake_case)
             self.assertIsNotNone(snake_case)






       @unittest.skip('Onnx compliancy broke with TF 2.10')
       def      lowerCAmelCase						(     self)		->    int:




          '''simple docstring'''
          pass






def lowerCamelCase__     (		):







   '''simple docstring'''




   _UpperCAmelCase  :  int				       =tf.convert_to_tensor([[1_0_1,1_0_1_9,1_0_1_4,1_0_1_6,1_0_3_7,1_2_8_4_9,4_7_4_7,1_0_0_4,1_4_2_4_6,2_2_7_8,5_4_3_9,4_5_2_4,5_0_0_2,2_9_3_0,2_1_9_3,2_9_3_0,4_3_4_1,3_2_0_8,1_0_0_5,1_0_5_5,2_1_7_1,2_8_4_8,1_1_3_0_0,3_5_3_1,1_0_2],[1_0_1,4_0_7_0,4_0_3_4,7_0_2_0,1_0_2_4,3_0_5_8,1_0_1_5,1_0_1_3,2_8_6_1,1_0_1_3,6_0_7_0,1_9_2_7_4,2_7_7_2,6_2_0_5,2_7_8_1_4,1_6_1_4_7,1_6_1_4_7,4_3_4_3,2_0_4_7,1_0_2_8_3,1_0_9_6_9,1_4_3_8_9,1_0_1_2,2_3_3_8,1_0_2]]				)  # noqa: E231
   _UpperCAmelCase  :  Optional[int]				       =tf.convert_to_tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],]				)  # noqa: E231
   _UpperCAmelCase  :  Dict				       =tf.convert_to_tensor([[[0,0,0,0],[4_2_3,2_3_7,4_4_0,2_5_1],[4_2_7,2_7_2,4_4_1,2_8_7],[4_1_9,1_1_5,4_3_7,1_2_9],[9_6_1,8_8_5,9_9_2,9_1_2],[2_5_6,3_8,3_3_0,5_8],[2_5_6,3_8,3_3_0,5_8],[3_3_6,4_2,3_5_3,5_7],[3_6_0,3_9,4_0_1,5_6],[3_6_0,3_9,4_0_1,5_6],[4_1_1,3_9,4_7_1,5_9],[4_7_9,4_1,5_2_8,5_9],[5_3_3,3_9,6_3_0,6_0],[6_7,1_1_3,1_3_4,1_3_1],[1_4_1,1_1_5,2_0_9,1_3_2],[6_8,1_4_9,1_3_3,1_6_6],[1_4_1,1_4_9,1_8_7,1_6_4],[1_9_5,1_4_8,2_8_7,1_6_5],[1_9_5,1_4_8,2_8_7,1_6_5],[1_9_5,1_4_8,2_8_7,1_6_5],[2_9_5,1_4_8,3_4_9,1_6_5],[4_4_1,1_4_9,4_9_2,1_6_6],[4_9_7,1_4_9,5_4_6,1_6_4],[6_4,2_0_1,1_2_5,2_1_8],[1_0_0_0,1_0_0_0,1_0_0_0,1_0_0_0]],[[0,0,0,0],[6_6_2,1_5_0,7_5_4,1_6_6],[6_6_5,1_9_9,7_4_2,2_1_1],[5_1_9,2_1_3,5_5_4,2_2_8],[5_1_9,2_1_3,5_5_4,2_2_8],[1_3_4,4_3_3,1_8_7,4_5_4],[1_3_0,4_6_7,2_0_4,4_8_0],[1_3_0,4_6_7,2_0_4,4_8_0],[1_3_0,4_6_7,2_0_4,4_8_0],[1_3_0,4_6_7,2_0_4,4_8_0],[1_3_0,4_6_7,2_0_4,4_8_0],[3_1_4,4_6_9,3_7_6,4_8_2],[5_0_4,6_8_4,5_8_2,7_0_6],[9_4_1,8_2_5,9_7_3,9_0_0],[9_4_1,8_2_5,9_7_3,9_0_0],[9_4_1,8_2_5,9_7_3,9_0_0],[9_4_1,8_2_5,9_7_3,9_0_0],[6_1_0,7_4_9,6_5_2,7_6_5],[1_3_0,6_5_9,1_6_8,6_7_2],[1_7_6,6_5_7,2_3_7,6_7_2],[2_3_8,6_5_7,3_1_2,6_7_2],[4_4_3,6_5_3,6_2_8,6_7_2],[4_4_3,6_5_3,6_2_8,6_7_2],[7_1_6,3_0_1,8_2_5,3_1_7],[1_0_0_0,1_0_0_0,1_0_0_0,1_0_0_0]]]				)  # noqa: E231
   _UpperCAmelCase  :  List[Any]				       =tf.convert_to_tensor([[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]				)  # noqa: E231
   # these are sequence labels (i.e. at the token level)
   _UpperCAmelCase  :  List[Any]				       =tf.convert_to_tensor([[-1_0_0,1_0,1_0,1_0,9,1,-1_0_0,7,7,-1_0_0,7,7,4,2,5,2,8,8,-1_0_0,-1_0_0,5,0,3,2,-1_0_0],[-1_0_0,1_2,1_2,1_2,-1_0_0,1_2,1_0,-1_0_0,-1_0_0,-1_0_0,-1_0_0,1_0,1_2,9,-1_0_0,-1_0_0,-1_0_0,1_0,1_0,1_0,9,1_2,-1_0_0,1_0,-1_0_0]]				)  # noqa: E231
   # fmt: on

   return input_ids, attention_mask, bbox, token_type_ids, labels






@require_tf
class    __magic_name__				(						unittest.TestCase							):






       @slow
       def      lowerCAmelCase						(     self)		->    Optional[int]:




          '''simple docstring'''
          _UpperCAmelCase  :  Optional[Any]				       =TFLayoutLMModel.from_pretrained('microsoft/layoutlm-base-uncased')

          _UpperCAmelCase       ,			_UpperCAmelCase       ,			_UpperCAmelCase       ,			_UpperCAmelCase       ,			_UpperCAmelCase  :  Tuple				       =prepare_layoutlm_batch_inputs()

          # forward pass
          _UpperCAmelCase  :  Dict				       =model(input_ids=snake_case    ,				bbox=snake_case    ,				attention_mask=snake_case    ,				token_type_ids=snake_case)

          # test the sequence output on [0, :3, :3]
          _UpperCAmelCase  :  List[Any]				       =tf.convert_to_tensor(
              [[0.17_85, -0.19_47, -0.04_25], [-0.32_54, -0.28_07, 0.25_53], [-0.53_91, -0.33_22, 0.33_64]]    ,				)

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

          # test the pooled output on [1, :3]
          _UpperCAmelCase  :  List[Any]				       =tf.convert_to_tensor([-0.65_80, -0.02_14, 0.85_52])

          self.assertTrue(np.allclose(outputs.pooler_output[1, :3]    ,				snake_case    ,				atol=1E-3))






       @slow
       def      lowerCAmelCase						(     self)		->    Dict:




          '''simple docstring'''
          # initialize model with randomly initialized sequence classification head
          _UpperCAmelCase  :  str				       =TFLayoutLMForSequenceClassification.from_pretrained('microsoft/layoutlm-base-uncased'    ,				num_labels=2)

          _UpperCAmelCase       ,			_UpperCAmelCase       ,			_UpperCAmelCase       ,			_UpperCAmelCase       ,			_UpperCAmelCase  :  int				       =prepare_layoutlm_batch_inputs()

          # forward pass
          _UpperCAmelCase  :  Optional[Any]				       =model(
              input_ids=snake_case    ,				bbox=snake_case    ,				attention_mask=snake_case    ,				token_type_ids=snake_case    ,				labels=tf.convert_to_tensor([1, 1])    ,				)

          # test whether we get a loss as a scalar
          _UpperCAmelCase  :  Optional[int]				       =outputs.loss
          _UpperCAmelCase  :  int				       =(2,)
          self.assertEqual(loss.shape    ,				snake_case)

          # test the shape of the logits
          _UpperCAmelCase  :  int				       =outputs.logits
          _UpperCAmelCase  :  Union[str, Any]				       =(2, 2)
          self.assertEqual(logits.shape    ,				snake_case)






       @slow
       def      lowerCAmelCase						(     self)		->    int:




          '''simple docstring'''
          # initialize model with randomly initialized token classification head
          _UpperCAmelCase  :  Optional[int]				       =TFLayoutLMForTokenClassification.from_pretrained('microsoft/layoutlm-base-uncased'    ,				num_labels=1_3)

          _UpperCAmelCase       ,			_UpperCAmelCase       ,			_UpperCAmelCase       ,			_UpperCAmelCase       ,			_UpperCAmelCase  :  Optional[Any]				       =prepare_layoutlm_batch_inputs()

          # forward pass
          _UpperCAmelCase  :  str				       =model(
              input_ids=snake_case    ,				bbox=snake_case    ,				attention_mask=snake_case    ,				token_type_ids=snake_case    ,				labels=snake_case)

          # test the shape of the logits
          _UpperCAmelCase  :  str				       =outputs.logits
          _UpperCAmelCase  :  Optional[Any]				       =tf.convert_to_tensor((2, 2_5, 1_3))
          self.assertEqual(logits.shape    ,				snake_case)






       @slow
       def      lowerCAmelCase						(     self)		->    Optional[int]:




          '''simple docstring'''
          # initialize model with randomly initialized token classification head
          _UpperCAmelCase  :  Optional[Any]				       =TFLayoutLMForQuestionAnswering.from_pretrained('microsoft/layoutlm-base-uncased')

          _UpperCAmelCase       ,			_UpperCAmelCase       ,			_UpperCAmelCase       ,			_UpperCAmelCase       ,			_UpperCAmelCase  :  Optional[Any]				       =prepare_layoutlm_batch_inputs()

          # forward pass
          _UpperCAmelCase  :  Any				       =model(input_ids=snake_case    ,				bbox=snake_case    ,				attention_mask=snake_case    ,				token_type_ids=snake_case)

          # test the shape of the logits
          _UpperCAmelCase  :  Optional[int]				       =tf.convert_to_tensor((2, 2_5))
          self.assertEqual(outputs.start_logits.shape    ,				snake_case)
          self.assertEqual(outputs.end_logits.shape    ,				snake_case)

