import unittest

import numpy as np
import timeout_decorator  # noqa

from transformers import MBartConfig, is_flax_available
from transformers.testing_utils import require_flax, require_sentencepiece, require_tokenizers, slow
from transformers.utils import cached_property

from ...generation.test_flax_utils import FlaxGenerationTesterMixin
from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor


if is_flax_available():
  import os

  # The slow tests are often failing with OOM error on GPU
  # This makes JAX allocate exactly what is needed on demand, and deallocate memory that is no longer needed
  # but will be slower as stated here https://jax.readthedocs.io/en/latest/gpu_memory_allocation.html
  UpperCAmelCase				 =   """platform"""

  import jax
  import jax.numpy as jnp

  from transformers import AutoTokenizer
  from transformers.models.mbart.modeling_flax_mbart import (
      FlaxMBartForConditionalGeneration,
      FlaxMBartForQuestionAnswering,
      FlaxMBartForSequenceClassification,
      FlaxMBartModel,
      shift_tokens_right,
  )







def 						UpperCAmelCase							(		lowerCAmelCase_    ,   lowerCAmelCase_    ,   lowerCAmelCase_=None    ,   lowerCAmelCase_=None    ,   lowerCAmelCase_=None    ,   lowerCAmelCase_=None    ,   lowerCAmelCase_=None    ,   lowerCAmelCase_=None    ,   )						->						Dict:
     if attention_mask is None:
          a	:     int						      =    np.where(input_ids != config.pad_token_id    ,   1    ,   0							)
     if decoder_attention_mask is None:
          a	:     Optional[Any]						      =    np.where(decoder_input_ids != config.pad_token_id    ,   1    ,   0							)
     if head_mask is None:
          a	:     List[Any]						      =    np.ones((config.encoder_layers, config.encoder_attention_heads)							)
     if decoder_head_mask is None:
          a	:     str						      =    np.ones((config.decoder_layers, config.decoder_attention_heads)							)
     if cross_attn_head_mask is None:
          a	:     Union[str, Any]						      =    np.ones((config.decoder_layers, config.decoder_attention_heads)							)
     return {
         "input_ids": input_ids,
         "decoder_input_ids": decoder_input_ids,
         "attention_mask": attention_mask,
         "decoder_attention_mask": decoder_attention_mask,
     }






class 				_SCREAMING_SNAKE_CASE( unittest.TestCase						):
   def __init__(     self				,  lowerCAmelCase_				,  lowerCAmelCase_=13				,  lowerCAmelCase_=7				,  lowerCAmelCase_=True				,  lowerCAmelCase_=False				,  lowerCAmelCase_=99				,  lowerCAmelCase_=16				,  lowerCAmelCase_=2				,  lowerCAmelCase_=4				,  lowerCAmelCase_=4				,  lowerCAmelCase_="gelu"				,  lowerCAmelCase_=0.1				,  lowerCAmelCase_=0.1				,  lowerCAmelCase_=32				,  lowerCAmelCase_=2				,  lowerCAmelCase_=1				,  lowerCAmelCase_=0				,  lowerCAmelCase_=2				,  lowerCAmelCase_=0.02				,  )						->List[Any]:
        a	:     List[Any]						      =    parent
        a	:     Optional[int]						      =    batch_size
        a	:     List[str]						      =    seq_length
        a	:     Dict						      =    is_training
        a	:     int						      =    use_labels
        a	:     Tuple						      =    vocab_size
        a	:     Tuple						      =    hidden_size
        a	:     str						      =    num_hidden_layers
        a	:     Any						      =    num_attention_heads
        a	:     Optional[int]						      =    intermediate_size
        a	:     Union[str, Any]						      =    hidden_act
        a	:     Optional[int]						      =    hidden_dropout_prob
        a	:     Dict						      =    attention_probs_dropout_prob
        a	:     Tuple						      =    max_position_embeddings
        a	:     Union[str, Any]						      =    eos_token_id
        a	:     Optional[Any]						      =    pad_token_id
        a	:     List[str]						      =    bos_token_id
        a	:     List[str]						      =    decoder_start_token_id
        a	:     List[Any]						      =    initializer_range
   def _lowercase(     self     )						->Tuple:
        a	:     Union[str, Any]						      =    np.clip(ids_tensor([self.batch_size, self.seq_length - 1]				,  self.vocab_size     )				,  3				,  self.vocab_size     )
        a	:     List[Any]						      =    np.concatenate((input_ids, 2 * np.ones((self.batch_size, 1)				,  dtype=np.intaa     ))				,  -1     )

        a	:     List[str]						      =    shift_tokens_right(_lowercase				,  1     )

        a	:     Dict						      =    MBartConfig(
            vocab_size=self.vocab_size				,  d_model=self.hidden_size				,  encoder_layers=self.num_hidden_layers				,  decoder_layers=self.num_hidden_layers				,  encoder_attention_heads=self.num_attention_heads				,  decoder_attention_heads=self.num_attention_heads				,  encoder_ffn_dim=self.intermediate_size				,  decoder_ffn_dim=self.intermediate_size				,  dropout=self.hidden_dropout_prob				,  attention_dropout=self.attention_probs_dropout_prob				,  max_position_embeddings=self.max_position_embeddings				,  eos_token_id=self.eos_token_id				,  bos_token_id=self.bos_token_id				,  pad_token_id=self.pad_token_id				,  decoder_start_token_id=self.decoder_start_token_id				,  initializer_range=self.initializer_range				,  use_cache=_lowercase				,  )
        a	:     List[str]						      =    prepare_mbart_inputs_dict(_lowercase				,  _lowercase				,  _lowercase     )
        return config, inputs_dict
   def _lowercase(     self     )						->List[str]:
        a      ,				a	:     Optional[Any]						      =    self.prepare_config_and_inputs()
        return config, inputs_dict
   def _lowercase(     self				,  lowerCAmelCase_				,  lowerCAmelCase_				,  lowerCAmelCase_     )						->Optional[int]:
        a	:     str						      =    20
        a	:     Optional[int]						      =    model_class_name(_lowercase     )

        a	:     Union[str, Any]						      =    model.encode(inputs_dict['''input_ids''']     )

        a      ,				a	:     Optional[Any]						      =    (
            inputs_dict['''decoder_input_ids'''],
            inputs_dict['''decoder_attention_mask'''],
        )

        a	:     Dict						      =    model.init_cache(decoder_input_ids.shape[0]				,  _lowercase				,  _lowercase     )
        a	:     List[Any]						      =    jnp.ones((decoder_input_ids.shape[0], max_decoder_length)				,  dtype='''i4'''     )

        a	:     Union[str, Any]						      =    jnp.broadcast_to(
            jnp.arange(decoder_input_ids.shape[-1] - 1     )[None, :]				,  (decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1)				,  )
        a	:     Optional[Any]						      =    model.decode(
            decoder_input_ids[:, :-1]				,  _lowercase				,  decoder_attention_mask=_lowercase				,  past_key_values=_lowercase				,  decoder_position_ids=_lowercase				,  )

        a	:     str						      =    jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]]				,  dtype='''i4'''     )
        a	:     Any						      =    model.decode(
            decoder_input_ids[:, -1:]				,  _lowercase				,  decoder_attention_mask=_lowercase				,  past_key_values=outputs_cache.past_key_values				,  decoder_position_ids=_lowercase				,  )

        a	:     Any						      =    model.decode(_lowercase				,  _lowercase     )

        a	:     Optional[int]						      =    np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])     )     )
        self.parent.assertTrue(diff < 1e-3				,  msg=F"""Max diff is {diff}"""     )


   def _lowercase(     self				,  lowerCAmelCase_				,  lowerCAmelCase_				,  lowerCAmelCase_     )						->Any:
        a	:     str						      =    20
        a	:     int						      =    model_class_name(_lowercase     )

        a	:     Any						      =    model.encode(inputs_dict['''input_ids''']     )

        a      ,				a	:     Optional[int]						      =    (
            inputs_dict['''decoder_input_ids'''],
            inputs_dict['''decoder_attention_mask'''],
        )

        a	:     Optional[Any]						      =    jnp.concatenate(
            [
                decoder_attention_mask,
                jnp.zeros((decoder_attention_mask.shape[0], max_decoder_length - decoder_attention_mask.shape[1])     ),
            ]				,  axis=-1				,  )

        a	:     List[str]						      =    model.init_cache(decoder_input_ids.shape[0]				,  _lowercase				,  _lowercase     )
        a	:     str						      =    jnp.broadcast_to(
            jnp.arange(decoder_input_ids.shape[-1] - 1     )[None, :]				,  (decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1)				,  )

        a	:     List[str]						      =    model.decode(
            decoder_input_ids[:, :-1]				,  _lowercase				,  decoder_attention_mask=_lowercase				,  past_key_values=_lowercase				,  decoder_position_ids=_lowercase				,  )
        a	:     Tuple						      =    jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]]				,  dtype='''i4'''     )
        a	:     Optional[Any]						      =    model.decode(
            decoder_input_ids[:, -1:]				,  _lowercase				,  past_key_values=outputs_cache.past_key_values				,  decoder_attention_mask=_lowercase				,  decoder_position_ids=_lowercase				,  )

        a	:     List[Any]						      =    model.decode(_lowercase				,  _lowercase				,  decoder_attention_mask=_lowercase     )

        a	:     Union[str, Any]						      =    np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])     )     )
        self.parent.assertTrue(diff < 1e-3				,  msg=F"""Max diff is {diff}"""     )






@require_flax
class 				_SCREAMING_SNAKE_CASE( unittest.TestCase						):
   UpperCamelCase_					:    List[Any]			      = 99
   def _lowercase(     self     )						->Union[str, Any]:
        a	:     Optional[int]						      =    np.array(
            [
                [71, 82, 18, 33, 46, 91, 2],
                [68, 34, 26, 58, 30, 82, 2],
                [5, 97, 17, 39, 94, 40, 2],
                [76, 83, 94, 25, 70, 78, 2],
                [87, 59, 41, 35, 48, 66, 2],
                [55, 13, 16, 58, 5, 2, 1],  # note padding
                [64, 27, 31, 51, 12, 75, 2],
                [52, 64, 86, 17, 83, 39, 2],
                [48, 61, 9, 24, 71, 82, 2],
                [26, 1, 60, 48, 22, 13, 2],
                [21, 5, 62, 28, 14, 76, 2],
                [45, 98, 37, 86, 59, 48, 2],
                [70, 70, 50, 9, 28, 0, 2],
            ]				,  dtype=np.intaa				,  )

        a	:     Optional[int]						      =    input_ids.shape[0]
        a	:     List[Any]						      =    MBartConfig(
            vocab_size=self.vocab_size				,  d_model=24				,  encoder_layers=2				,  decoder_layers=2				,  encoder_attention_heads=2				,  decoder_attention_heads=2				,  encoder_ffn_dim=32				,  decoder_ffn_dim=32				,  max_position_embeddings=48				,  eos_token_id=2				,  pad_token_id=1				,  bos_token_id=0				,  )
        return config, input_ids, batch_size
   def _lowercase(     self     )						->Any:
        a      ,				a      ,				a	:     Dict						      =    self._get_config_and_data()
        a	:     int						      =    FlaxMBartForSequenceClassification(_lowercase     )
        a	:     Any						      =    model(input_ids=_lowercase				,  decoder_input_ids=_lowercase     )
        a	:     Optional[Any]						      =    (batch_size, config.num_labels)
        self.assertEqual(outputs['''logits'''].shape				,  _lowercase     )
   def _lowercase(     self     )						->Any:
        a      ,				a      ,				a	:     Optional[int]						      =    self._get_config_and_data()
        a	:     int						      =    FlaxMBartForQuestionAnswering(_lowercase     )
        a	:     Optional[Any]						      =    model(input_ids=_lowercase     )

        self.assertEqual(outputs['''start_logits'''].shape				,  input_ids.shape     )
        self.assertEqual(outputs['''end_logits'''].shape				,  input_ids.shape     )
   def _lowercase(     self     )						->Dict:
        a      ,				a      ,				a	:     Any						      =    self._get_config_and_data()
        a	:     Optional[Any]						      =    FlaxMBartForConditionalGeneration(_lowercase     )
        a	:     Optional[Any]						      =    lm_model(input_ids=_lowercase     )
        a	:     Optional[Any]						      =    (batch_size, input_ids.shape[1], config.vocab_size)
        self.assertEqual(outputs['''logits'''].shape				,  _lowercase     )
   def _lowercase(     self     )						->Dict:
        a	:     Tuple						      =    MBartConfig(
            vocab_size=self.vocab_size				,  d_model=14				,  encoder_layers=2				,  decoder_layers=2				,  encoder_attention_heads=2				,  decoder_attention_heads=2				,  encoder_ffn_dim=8				,  decoder_ffn_dim=8				,  max_position_embeddings=48				,  )
        a	:     str						      =    FlaxMBartForConditionalGeneration(_lowercase     )
        a	:     Tuple						      =    np.array([[71, 82, 18, 33, 46, 91, 2], [68, 34, 26, 58, 30, 2, 1]]				,  dtype=np.intaa     )
        a	:     Optional[int]						      =    np.array([[82, 71, 82, 18, 2], [58, 68, 2, 1, 1]]				,  dtype=np.intaa     )
        a	:     int						      =    lm_model(input_ids=_lowercase				,  decoder_input_ids=_lowercase     )
        a	:     List[str]						      =    (*summary.shape, config.vocab_size)
        self.assertEqual(outputs['''logits'''].shape				,  _lowercase     )


   def _lowercase(     self     )						->Optional[Any]:
        a	:     List[Any]						      =    np.array([[71, 82, 18, 33, 2, 1, 1], [68, 34, 26, 58, 30, 82, 2]]				,  dtype=np.intaa     )
        a	:     Optional[int]						      =    shift_tokens_right(_lowercase				,  1     )
        a	:     Union[str, Any]						      =    np.equal(_lowercase				,  1     ).astype(np.floataa     ).sum()
        a	:     Optional[Any]						      =    np.equal(_lowercase				,  1     ).astype(np.floataa     ).sum()
        self.assertEqual(shifted.shape				,  input_ids.shape     )
        self.assertEqual(_lowercase				,  n_pad_before - 1     )
        self.assertTrue(np.equal(shifted[:, 0]				,  2     ).all()     )






@require_flax
class 				_SCREAMING_SNAKE_CASE( __lowerCamelCase							,   unittest.TestCase							,   __lowerCamelCase						):
   UpperCamelCase_					:    Optional[Any]			      = True
   UpperCamelCase_					:    Dict			      = (
       (
           FlaxMBartModel,
           FlaxMBartForConditionalGeneration,
           FlaxMBartForSequenceClassification,
           FlaxMBartForQuestionAnswering,
       )
       if is_flax_available()
       else ()
   )
   UpperCamelCase_					:    List[str]			      = (FlaxMBartForConditionalGeneration,) if is_flax_available() else ()
   def _lowercase(     self     )						->str:
        a	:     Optional[int]						      =    FlaxMBartModelTester(self     )
   def _lowercase(     self     )						->List[Any]:
        a      ,				a	:     Optional[int]						      =    self.model_tester.prepare_config_and_inputs()
        for model_class in self.all_model_classes:
             self.model_tester.check_use_cache_forward(_lowercase				,  _lowercase				,  _lowercase     )
   def _lowercase(     self     )						->str:
        a      ,				a	:     Optional[int]						      =    self.model_tester.prepare_config_and_inputs()
        for model_class in self.all_model_classes:
             self.model_tester.check_use_cache_forward_with_attn_mask(_lowercase				,  _lowercase				,  _lowercase     )
   def _lowercase(     self     )						->Union[str, Any]:
        a      ,				a	:     Optional[Any]						      =    self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
             with self.subTest(model_class.__name__     ):
                  a	:     int						      =    self._prepare_for_class(_lowercase				,  _lowercase     )
                  a	:     Union[str, Any]						      =    model_class(_lowercase     )

                  @jax.jit
                  def encode_jitted(lowerCAmelCase_				,  lowerCAmelCase_=None				,  **lowerCAmelCase_     ):
                       return model.encode(input_ids=_lowercase				,  attention_mask=_lowercase     )

                  with self.subTest('''JIT Enabled'''     ):
                       a	:     List[Any]						      =    encode_jitted(**_lowercase     ).to_tuple()

                  with self.subTest('''JIT Disabled'''     ):
                       with jax.disable_jit():
                            a	:     List[Any]						      =    encode_jitted(**_lowercase     ).to_tuple()

                  self.assertEqual(len(_lowercase     )				,  len(_lowercase     )     )
                  for jitted_output, output in zip(_lowercase				,  _lowercase     ):
                       self.assertEqual(jitted_output.shape				,  output.shape     )
   def _lowercase(     self     )						->Union[str, Any]:
        a      ,				a	:     int						      =    self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
             with self.subTest(model_class.__name__     ):
                  a	:     Any						      =    model_class(_lowercase     )
                  a	:     int						      =    model.encode(inputs_dict['''input_ids''']				,  inputs_dict['''attention_mask''']     )

                  a	:     Optional[Any]						      =    {
                      '''decoder_input_ids''': inputs_dict['''decoder_input_ids'''],
                      '''decoder_attention_mask''': inputs_dict['''decoder_attention_mask'''],
                      '''encoder_outputs''': encoder_outputs,
                  }

                  @jax.jit
                  def decode_jitted(lowerCAmelCase_				,  lowerCAmelCase_				,  lowerCAmelCase_     ):
                       return model.decode(
                           decoder_input_ids=_lowercase				,  decoder_attention_mask=_lowercase				,  encoder_outputs=_lowercase				,  )

                  with self.subTest('''JIT Enabled'''     ):
                       a	:     Union[str, Any]						      =    decode_jitted(**_lowercase     ).to_tuple()

                  with self.subTest('''JIT Disabled'''     ):
                       with jax.disable_jit():
                            a	:     Dict						      =    decode_jitted(**_lowercase     ).to_tuple()

                  self.assertEqual(len(_lowercase     )				,  len(_lowercase     )     )
                  for jitted_output, output in zip(_lowercase				,  _lowercase     ):
                       self.assertEqual(jitted_output.shape				,  output.shape     )


   @slow
   def _lowercase(     self     )						->int:
        for model_class_name in self.all_model_classes:
             a	:     Tuple						      =    model_class_name.from_pretrained('''facebook/mbart-large-cc25'''				,  from_pt=_lowercase     )
             # FlaxMBartForSequenceClassification expects eos token in input_ids
             a	:     Tuple						      =    np.ones((1, 1)     ) * model.config.eos_token_id
             a	:     Any						      =    model(_lowercase     )
             self.assertIsNotNone(_lowercase     )






@require_flax
@require_sentencepiece
@require_tokenizers
class 				_SCREAMING_SNAKE_CASE( unittest.TestCase						):
   UpperCamelCase_					:    Optional[Any]			      = [
       ' UN Chief Says There Is No Military Solution in Syria',
   ]
   UpperCamelCase_					:    Optional[Any]			      = [
       'Şeful ONU declară că nu există o soluţie militară în Siria',
   ]
   UpperCamelCase_					:    Any			      = 'facebook/mbart-large-en-ro'
   @cached_property
   def _lowercase(     self     )						->Any:
        return AutoTokenizer.from_pretrained(self.model_name     )
   @cached_property
   def _lowercase(     self     )						->List[Any]:
        a	:     List[str]						      =    FlaxMBartForConditionalGeneration.from_pretrained(self.model_name				,  from_pt=_lowercase     )
        return model
   def _lowercase(     self				,  **lowerCAmelCase_     )						->Tuple:
        a	:     Optional[Any]						      =    self.translate_src_text(**_lowercase     )
        self.assertListEqual(self.expected_text				,  _lowercase     )
   def _lowercase(     self				,  **lowerCAmelCase_     )						->int:
        a	:     str						      =    self.tokenizer(self.src_text				,  **_lowercase				,  return_tensors='''np'''     )
        a	:     Dict						      =    self.model.generate(
            model_inputs.input_ids				,  attention_mask=model_inputs.attention_mask				,  decoder_start_token_id=self.tokenizer.lang_code_to_id['''ro_RO''']				,  early_stopping=_lowercase				,  num_beams=2				,  ).sequences
        a	:     str						      =    self.tokenizer.batch_decode(_lowercase				,  skip_special_tokens=_lowercase     )
        return generated_words


   @slow
   def _lowercase(     self     )						->Tuple:
        self._assert_generated_batch_equal_expected()
"""simple docstring"""







import unittest

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

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


if is_torch_available():
						import torch

						from transformers import (
						    LayoutLMForMaskedLM,
						    LayoutLMForQuestionAnswering,
						    LayoutLMForSequenceClassification,
						    LayoutLMForTokenClassification,
						    LayoutLMModel,
						)


class       _lowercase		:

				def __init__(  self							:     Tuple							,     _lowercase							:     Union[str, Any]							,     _lowercase							:     List[Any]=1_3							,     _lowercase							:     Dict=7							,     _lowercase							:     Tuple=True							,     _lowercase							:     Optional[Any]=True							,     _lowercase							:     Union[str, Any]=True							,     _lowercase							:     Any=True							,     _lowercase							:     Dict=9_9							,     _lowercase							:     Optional[int]=3_2							,     _lowercase							:     Optional[int]=5							,     _lowercase							:     Tuple=4							,     _lowercase							:     Dict=3_7							,     _lowercase							:     Optional[int]="gelu"							,     _lowercase							:     Union[str, Any]=0.1							,     _lowercase							:     Dict=0.1							,     _lowercase							:     Optional[int]=5_1_2							,     _lowercase							:     List[str]=1_6							,     _lowercase							:     List[str]=2							,     _lowercase							:     Optional[Any]=0.02							,     _lowercase							:     List[Any]=3							,     _lowercase							:     Tuple=4							,     _lowercase							:     List[Any]=None							,     _lowercase							:     List[str]=1_0_0_0							,     ):


										'''simple docstring'''
										UpperCAmelCase__       						=		parent
										UpperCAmelCase__       						=		batch_size
										UpperCAmelCase__       						=		seq_length
										UpperCAmelCase__       						=		is_training
										UpperCAmelCase__       						=		use_input_mask
										UpperCAmelCase__       						=		use_token_type_ids
										UpperCAmelCase__       						=		use_labels
										UpperCAmelCase__       						=		vocab_size
										UpperCAmelCase__       						=		hidden_size
										UpperCAmelCase__       						=		num_hidden_layers
										UpperCAmelCase__       						=		num_attention_heads
										UpperCAmelCase__       						=		intermediate_size
										UpperCAmelCase__       						=		hidden_act
										UpperCAmelCase__       						=		hidden_dropout_prob
										UpperCAmelCase__       						=		attention_probs_dropout_prob
										UpperCAmelCase__       						=		max_position_embeddings
										UpperCAmelCase__       						=		type_vocab_size
										UpperCAmelCase__       						=		type_sequence_label_size
										UpperCAmelCase__       						=		initializer_range
										UpperCAmelCase__       						=		num_labels
										UpperCAmelCase__       						=		num_choices
										UpperCAmelCase__       						=		scope
										UpperCAmelCase__       						=		range_bbox

				def 							A			(  self							:     Tuple  ):


										'''simple docstring'''
										UpperCAmelCase__       						=		ids_tensor([self.batch_size, self.seq_length]							,     self.vocab_size  )

										UpperCAmelCase__       						=		ids_tensor([self.batch_size, self.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]:
																												UpperCAmelCase__       						=		bbox[i, j, 3]
																												UpperCAmelCase__       						=		bbox[i, j, 1]
																												UpperCAmelCase__       						=		t
																						if bbox[i, j, 2] < bbox[i, j, 0]:
																												UpperCAmelCase__       						=		bbox[i, j, 2]
																												UpperCAmelCase__       						=		bbox[i, j, 0]
																												UpperCAmelCase__       						=		t

										UpperCAmelCase__       						=		None
										if self.use_input_mask:
																UpperCAmelCase__       						=		ids_tensor([self.batch_size, self.seq_length]							,     vocab_size=2  )

										UpperCAmelCase__       						=		None
										if self.use_token_type_ids:
																UpperCAmelCase__       						=		ids_tensor([self.batch_size, self.seq_length]							,     self.type_vocab_size  )

										UpperCAmelCase__       						=		None
										UpperCAmelCase__       						=		None
										UpperCAmelCase__       						=		None
										if self.use_labels:
																UpperCAmelCase__       						=		ids_tensor([self.batch_size]							,     self.type_sequence_label_size  )
																UpperCAmelCase__       						=		ids_tensor([self.batch_size, self.seq_length]							,     self.num_labels  )
																UpperCAmelCase__       						=		ids_tensor([self.batch_size]							,     self.num_choices  )

										UpperCAmelCase__       						=		self.get_config()

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

				def 							A			(  self							:     str  ):


										'''simple docstring'''
										return 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							,     )

				def 							A			(  self							:     Dict							,     _lowercase							:     List[Any]							,     _lowercase							:     Union[str, Any]							,     _lowercase							:     int							,     _lowercase							:     List[Any]							,     _lowercase							:     Optional[int]							,     _lowercase							:     Dict							,     _lowercase							:     Optional[int]							,     _lowercase							:     List[str]  ):


										'''simple docstring'''
										UpperCAmelCase__       						=		LayoutLMModel(config=_lowercase  )
										model.to(_lowercase  )
										model.eval()
										UpperCAmelCase__       						=		model(_lowercase							,     _lowercase							,     attention_mask=_lowercase							,     token_type_ids=_lowercase  )
										UpperCAmelCase__       						=		model(_lowercase							,     _lowercase							,     token_type_ids=_lowercase  )
										UpperCAmelCase__       						=		model(_lowercase							,     _lowercase  )
										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 							A			(  self							:     List[str]							,     _lowercase							:     Optional[int]							,     _lowercase							:     Tuple							,     _lowercase							:     Dict							,     _lowercase							:     int							,     _lowercase							:     Tuple							,     _lowercase							:     int							,     _lowercase							:     Optional[int]							,     _lowercase							:     Optional[int]  ):


										'''simple docstring'''
										UpperCAmelCase__       						=		LayoutLMForMaskedLM(config=_lowercase  )
										model.to(_lowercase  )
										model.eval()
										UpperCAmelCase__       						=		model(_lowercase							,     _lowercase							,     attention_mask=_lowercase							,     token_type_ids=_lowercase							,     labels=_lowercase  )
										self.parent.assertEqual(result.logits.shape							,     (self.batch_size, self.seq_length, self.vocab_size)  )

				def 							A			(  self							:     Union[str, Any]							,     _lowercase							:     Optional[Any]							,     _lowercase							:     Union[str, Any]							,     _lowercase							:     Dict							,     _lowercase							:     Tuple							,     _lowercase							:     List[Any]							,     _lowercase							:     str							,     _lowercase							:     Optional[int]							,     _lowercase							:     str  ):


										'''simple docstring'''
										UpperCAmelCase__       						=		self.num_labels
										UpperCAmelCase__       						=		LayoutLMForSequenceClassification(_lowercase  )
										model.to(_lowercase  )
										model.eval()
										UpperCAmelCase__       						=		model(
										    _lowercase							,     _lowercase							,     attention_mask=_lowercase							,     token_type_ids=_lowercase							,     labels=_lowercase  )
										self.parent.assertEqual(result.logits.shape							,     (self.batch_size, self.num_labels)  )

				def 							A			(  self							:     Dict							,     _lowercase							:     Dict							,     _lowercase							:     Any							,     _lowercase							:     Union[str, Any]							,     _lowercase							:     int							,     _lowercase							:     List[str]							,     _lowercase							:     Optional[Any]							,     _lowercase							:     Any							,     _lowercase							:     int  ):


										'''simple docstring'''
										UpperCAmelCase__       						=		self.num_labels
										UpperCAmelCase__       						=		LayoutLMForTokenClassification(config=_lowercase  )
										model.to(_lowercase  )
										model.eval()
										UpperCAmelCase__       						=		model(_lowercase							,     _lowercase							,     attention_mask=_lowercase							,     token_type_ids=_lowercase							,     labels=_lowercase  )
										self.parent.assertEqual(result.logits.shape							,     (self.batch_size, self.seq_length, self.num_labels)  )

				def 							A			(  self							:     List[Any]							,     _lowercase							:     Dict							,     _lowercase							:     Union[str, Any]							,     _lowercase							:     Tuple							,     _lowercase							:     Union[str, Any]							,     _lowercase							:     Optional[int]							,     _lowercase							:     Tuple							,     _lowercase							:     Optional[int]							,     _lowercase							:     Union[str, Any]  ):


										'''simple docstring'''
										UpperCAmelCase__       						=		LayoutLMForQuestionAnswering(config=_lowercase  )
										model.to(_lowercase  )
										model.eval()
										UpperCAmelCase__       						=		model(
										    _lowercase							,     bbox=_lowercase							,     attention_mask=_lowercase							,     token_type_ids=_lowercase							,     start_positions=_lowercase							,     end_positions=_lowercase							,     )
										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							:     int  ):


										'''simple docstring'''
										UpperCAmelCase__       						=		self.prepare_config_and_inputs()
										(
										    (
										    UpperCAmelCase__
										)						,   (
										    UpperCAmelCase__
										)						,   (
										    UpperCAmelCase__
										)						,   (
										    UpperCAmelCase__
										)						,   (
										    UpperCAmelCase__
										)						,   (
										    UpperCAmelCase__
										)						,   (
										    UpperCAmelCase__
										)						,   (
										    UpperCAmelCase__
										)						,   
										)       						=		config_and_inputs
										UpperCAmelCase__       						=		{
										    """input_ids""": input_ids,
										    """bbox""": bbox,
										    """token_type_ids""": token_type_ids,
										    """attention_mask""": input_mask,
										}
										return config, inputs_dict


@require_torch
class       _lowercase		( __lowerCamelCase   ,   __lowerCamelCase   ,   unittest.TestCase	):
				lowerCamelCase__							=							(
				    (
				        LayoutLMModel,
				        LayoutLMForMaskedLM,
				        LayoutLMForSequenceClassification,
				        LayoutLMForTokenClassification,
				        LayoutLMForQuestionAnswering,
				    )
				    if is_torch_available()
				    else None
				)
				lowerCamelCase__							=							(
				    {
				        'document-question-answering': LayoutLMForQuestionAnswering,
				        'feature-extraction': LayoutLMModel,
				        'fill-mask': LayoutLMForMaskedLM,
				        'text-classification': LayoutLMForSequenceClassification,
				        'token-classification': LayoutLMForTokenClassification,
				        'zero-shot': LayoutLMForSequenceClassification,
				    }
				    if is_torch_available()
				    else {}
				)
				lowerCamelCase__							=							True

				def 							A			(  self							:     Union[str, Any]  ):


										'''simple docstring'''
										UpperCAmelCase__       						=		LayoutLMModelTester(self  )
										UpperCAmelCase__       						=		ConfigTester(self							,     config_class=_lowercase							,     hidden_size=3_7  )

				def 							A			(  self							:     str  ):


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

				def 							A			(  self							:     Any  ):


										'''simple docstring'''
										UpperCAmelCase__       						=		self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*_lowercase  )

				def 							A			(  self							:     Optional[Any]  ):


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

				def 							A			(  self							:     Optional[int]  ):


										'''simple docstring'''
										UpperCAmelCase__       						=		self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_masked_lm(*_lowercase  )

				def 							A			(  self							:     Optional[Any]  ):


										'''simple docstring'''
										UpperCAmelCase__       						=		self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_sequence_classification(*_lowercase  )

				def 							A			(  self							:     List[Any]  ):


										'''simple docstring'''
										UpperCAmelCase__       						=		self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_token_classification(*_lowercase  )

				def 							A			(  self							:     Union[str, Any]  ):


										'''simple docstring'''
										UpperCAmelCase__       						=		self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_question_answering(*_lowercase  )

				@unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests."""  )
				def 							A			(  self							:     str  ):


										'''simple docstring'''
										pass


def 	a__   (		)->						Any:
						# Here we prepare a batch of 2 sequences to test a LayoutLM forward pass on:
						# fmt: off
						UpperCAmelCase__       						=		torch.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]]		,      device=UpperCAmelCase__      )  # noqa: E231
						UpperCAmelCase__       						=		torch.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],]		,      device=UpperCAmelCase__      )  # noqa: E231
						UpperCAmelCase__       						=		torch.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]]]		,      device=UpperCAmelCase__      )  # noqa: E231
						UpperCAmelCase__       						=		torch.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]]		,      device=UpperCAmelCase__      )  # noqa: E231
						# these are sequence labels (i.e. at the token level)
						UpperCAmelCase__       						=		torch.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]]		,      device=UpperCAmelCase__      )  # noqa: E231
						# fmt: on

						return input_ids, attention_mask, bbox, token_type_ids, labels







@require_torch
class       _lowercase		( unittest.TestCase	):

				@slow
				def 							A			(  self							:     List[Any]  ):


										'''simple docstring'''
										UpperCAmelCase__       						=		LayoutLMModel.from_pretrained("""microsoft/layoutlm-base-uncased"""  ).to(_lowercase  )

										UpperCAmelCase__						,   UpperCAmelCase__						,   UpperCAmelCase__						,   UpperCAmelCase__						,   UpperCAmelCase__       						=		prepare_layoutlm_batch_inputs()

										# forward pass
										UpperCAmelCase__       						=		model(input_ids=_lowercase							,     bbox=_lowercase							,     attention_mask=_lowercase							,     token_type_ids=_lowercase  )

										# test the sequence output on [0, :3, :3]
										UpperCAmelCase__       						=		torch.tensor(
										    [[0.1785, -0.1947, -0.0425], [-0.3254, -0.2807, 0.2553], [-0.5391, -0.3322, 0.3364]]							,     device=_lowercase							,     )

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

										# test the pooled output on [1, :3]
										UpperCAmelCase__       						=		torch.tensor([-0.6580, -0.0214, 0.8552]							,     device=_lowercase  )

										self.assertTrue(torch.allclose(outputs.pooler_output[1, :3]							,     _lowercase							,     atol=1e-3  )  )

				@slow
				def 							A			(  self							:     Optional[Any]  ):


										'''simple docstring'''
										# initialize model with randomly initialized sequence classification head
										UpperCAmelCase__       						=		LayoutLMForSequenceClassification.from_pretrained("""microsoft/layoutlm-base-uncased"""							,     num_labels=2  ).to(
										    _lowercase  )

										UpperCAmelCase__						,   UpperCAmelCase__						,   UpperCAmelCase__						,   UpperCAmelCase__						,   UpperCAmelCase__       						=		prepare_layoutlm_batch_inputs()

										# forward pass
										UpperCAmelCase__       						=		model(
										    input_ids=_lowercase							,     bbox=_lowercase							,     attention_mask=_lowercase							,     token_type_ids=_lowercase							,     labels=torch.tensor([1, 1]							,     device=_lowercase  )							,     )

										# test whether we get a loss as a scalar
										UpperCAmelCase__       						=		outputs.loss
										UpperCAmelCase__       						=		torch.Size([]  )
										self.assertEqual(loss.shape							,     _lowercase  )

										# test the shape of the logits
										UpperCAmelCase__       						=		outputs.logits
										UpperCAmelCase__       						=		torch.Size((2, 2)  )
										self.assertEqual(logits.shape							,     _lowercase  )

				@slow
				def 							A			(  self							:     Any  ):


										'''simple docstring'''
										# initialize model with randomly initialized token classification head
										UpperCAmelCase__       						=		LayoutLMForTokenClassification.from_pretrained("""microsoft/layoutlm-base-uncased"""							,     num_labels=1_3  ).to(
										    _lowercase  )

										UpperCAmelCase__						,   UpperCAmelCase__						,   UpperCAmelCase__						,   UpperCAmelCase__						,   UpperCAmelCase__       						=		prepare_layoutlm_batch_inputs()

										# forward pass
										UpperCAmelCase__       						=		model(
										    input_ids=_lowercase							,     bbox=_lowercase							,     attention_mask=_lowercase							,     token_type_ids=_lowercase							,     labels=_lowercase  )

										# test the loss calculation to be around 2.65
										# expected_loss = torch.tensor(2.65, device=torch_device)

										# The loss is currently somewhat random and can vary between 0.1-0.3 atol.
										# self.assertTrue(torch.allclose(outputs.loss, expected_loss, atol=0.1))

										# test the shape of the logits
										UpperCAmelCase__       						=		outputs.logits
										UpperCAmelCase__       						=		torch.Size((2, 2_5, 1_3)  )
										self.assertEqual(logits.shape							,     _lowercase  )

				@slow
				def 							A			(  self							:     Optional[int]  ):


										'''simple docstring'''
										# initialize model with randomly initialized token classification head
										UpperCAmelCase__       						=		LayoutLMForQuestionAnswering.from_pretrained("""microsoft/layoutlm-base-uncased"""  ).to(_lowercase  )

										UpperCAmelCase__						,   UpperCAmelCase__						,   UpperCAmelCase__						,   UpperCAmelCase__						,   UpperCAmelCase__       						=		prepare_layoutlm_batch_inputs()

										# forward pass
										UpperCAmelCase__       						=		model(input_ids=_lowercase							,     bbox=_lowercase							,     attention_mask=_lowercase							,     token_type_ids=_lowercase  )

										# test the shape of the logits
										UpperCAmelCase__       						=		torch.Size((2, 2_5)  )
										self.assertEqual(outputs.start_logits.shape							,     _lowercase  )
										self.assertEqual(outputs.end_logits.shape							,     _lowercase  )

