





"""simple docstring"""




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
   lowerCamelCase_	:		Tuple         =   '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__						(	_UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase=None					,   _UpperCAmelCase=None					,   _UpperCAmelCase=None					,   _UpperCAmelCase=None					,   _UpperCAmelCase=None					,   _UpperCAmelCase=None					,   ):






  """simple docstring"""





  if attention_mask is None:
    A_    :			List[Any]									=    np.where(input_ids != config.pad_token_id					,   1					,   0   )
  if decoder_attention_mask is None:
    A_    :			str									=    np.where(decoder_input_ids != config.pad_token_id					,   1					,   0   )
  if head_mask is None:
    A_    :			int									=    np.ones((config.encoder_layers, config.encoder_attention_heads)   )
  if decoder_head_mask is None:
    A_    :			int									=    np.ones((config.decoder_layers, config.decoder_attention_heads)   )
  if cross_attn_head_mask is None:
    A_    :			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 					_UpperCAmelCase    (  unittest.TestCase						):



      '''simple docstring'''

      def __init__(	self   , snake_case_   , snake_case_=1_3   , snake_case_=7   , snake_case_=True   , snake_case_=False   , snake_case_=9_9   , snake_case_=1_6   , snake_case_=2   , snake_case_=4   , snake_case_=4   , snake_case_="gelu"   , snake_case_=0.1   , snake_case_=0.1   , snake_case_=3_2   , snake_case_=2   , snake_case_=1   , snake_case_=0   , snake_case_=2   , snake_case_=0.02   , ):

        """simple docstring"""

        A_    :			List[str]									=    parent
        A_    :			List[Any]									=    batch_size
        A_    :			Union[str, Any]									=    seq_length
        A_    :			Any									=    is_training
        A_    :			List[Any]									=    use_labels
        A_    :			int									=    vocab_size
        A_    :			Dict									=    hidden_size
        A_    :			Optional[Any]									=    num_hidden_layers
        A_    :			List[Any]									=    num_attention_heads
        A_    :			List[str]									=    intermediate_size
        A_    :			int									=    hidden_act
        A_    :			Optional[Any]									=    hidden_dropout_prob
        A_    :			int									=    attention_probs_dropout_prob
        A_    :			List[Any]									=    max_position_embeddings
        A_    :			Dict									=    eos_token_id
        A_    :			int									=    pad_token_id
        A_    :			Optional[int]									=    bos_token_id
        A_    :			int									=    decoder_start_token_id
        A_    :			str									=    initializer_range

      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        A_    :			Dict									=    np.clip(ids_tensor([self.batch_size, self.seq_length - 1]   , self.vocab_size    )   , 3   , self.vocab_size    )
        A_    :			Tuple									=    np.concatenate((input_ids, 2 * np.ones((self.batch_size, 1)   , dtype=np.intaa    ))   , -1    )

        A_    :			Any									=    shift_tokens_right(_lowerCamelCase   , 1    )

        A_    :			Tuple									=    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=_lowerCamelCase   , )
        A_    :			Any									=    prepare_mbart_inputs_dict(_lowerCamelCase   , _lowerCamelCase   , _lowerCamelCase    )
        return config, inputs_dict

      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        A_    :			List[str]									=    self.prepare_config_and_inputs()
        return config, inputs_dict

      def    lowerCamelCase_     (	self   , snake_case_   , snake_case_   , snake_case_    ):

        """simple docstring"""

        A_    :			List[str]									=    2_0
        A_    :			Optional[Any]									=    model_class_name(_lowerCamelCase    )

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

        A_    :			Optional[Any]									=    (
            inputs_dict["""decoder_input_ids"""],
            inputs_dict["""decoder_attention_mask"""],
        )

        A_    :			Any									=    model.init_cache(decoder_input_ids.shape[0]   , _lowerCamelCase   , _lowerCamelCase    )
        A_    :			Optional[Any]									=    jnp.ones((decoder_input_ids.shape[0], max_decoder_length)   , dtype='i4'    )

        A_    :			Dict									=    jnp.broadcast_to(
            jnp.arange(decoder_input_ids.shape[-1] - 1    )[None, :]   , (decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1)   , )
        A_    :			Tuple									=    model.decode(
            decoder_input_ids[:, :-1]   , _lowerCamelCase   , decoder_attention_mask=_lowerCamelCase   , past_key_values=_lowerCamelCase   , decoder_position_ids=_lowerCamelCase   , )

        A_    :			Tuple									=    jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]]   , dtype='i4'    )
        A_    :			int									=    model.decode(
            decoder_input_ids[:, -1:]   , _lowerCamelCase   , decoder_attention_mask=_lowerCamelCase   , past_key_values=outputs_cache.past_key_values   , decoder_position_ids=_lowerCamelCase   , )

        A_    :			Dict									=    model.decode(_lowerCamelCase   , _lowerCamelCase    )

        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}"""    )

      def    lowerCamelCase_     (	self   , snake_case_   , snake_case_   , snake_case_    ):

        """simple docstring"""

        A_    :			Union[str, Any]									=    2_0
        A_    :			Union[str, Any]									=    model_class_name(_lowerCamelCase    )

        A_    :			str									=    model.encode(inputs_dict['input_ids']    )

        A_    :			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_    :			Any									=    model.init_cache(decoder_input_ids.shape[0]   , _lowerCamelCase   , _lowerCamelCase    )
        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]   , _lowerCamelCase   , decoder_attention_mask=_lowerCamelCase   , past_key_values=_lowerCamelCase   , decoder_position_ids=_lowerCamelCase   , )
        A_    :			List[Any]									=    jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]]   , dtype='i4'    )
        A_    :			Optional[int]									=    model.decode(
            decoder_input_ids[:, -1:]   , _lowerCamelCase   , past_key_values=outputs_cache.past_key_values   , decoder_attention_mask=_lowerCamelCase   , decoder_position_ids=_lowerCamelCase   , )

        A_    :			Optional[int]									=    model.decode(_lowerCamelCase   , _lowerCamelCase   , decoder_attention_mask=_lowerCamelCase    )

        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 					_UpperCAmelCase    (  unittest.TestCase						):



      '''simple docstring'''
      lowercase_ :					Dict             =  99

      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        A_    :			str									=    np.array(
            [
                [7_1, 8_2, 1_8, 3_3, 4_6, 9_1, 2],
                [6_8, 3_4, 2_6, 5_8, 3_0, 8_2, 2],
                [5, 9_7, 1_7, 3_9, 9_4, 4_0, 2],
                [7_6, 8_3, 9_4, 2_5, 7_0, 7_8, 2],
                [8_7, 5_9, 4_1, 3_5, 4_8, 6_6, 2],
                [5_5, 1_3, 1_6, 5_8, 5, 2, 1],  # note padding
                [6_4, 2_7, 3_1, 5_1, 1_2, 7_5, 2],
                [5_2, 6_4, 8_6, 1_7, 8_3, 3_9, 2],
                [4_8, 6_1, 9, 2_4, 7_1, 8_2, 2],
                [2_6, 1, 6_0, 4_8, 2_2, 1_3, 2],
                [2_1, 5, 6_2, 2_8, 1_4, 7_6, 2],
                [4_5, 9_8, 3_7, 8_6, 5_9, 4_8, 2],
                [7_0, 7_0, 5_0, 9, 2_8, 0, 2],
            ]   , dtype=np.intaa   , )

        A_    :			Optional[Any]									=    input_ids.shape[0]
        A_    :			Dict									=    MBartConfig(
            vocab_size=self.vocab_size   , d_model=2_4   , encoder_layers=2   , decoder_layers=2   , encoder_attention_heads=2   , decoder_attention_heads=2   , encoder_ffn_dim=3_2   , decoder_ffn_dim=3_2   , max_position_embeddings=4_8   , eos_token_id=2   , pad_token_id=1   , bos_token_id=0   , )
        return config, input_ids, batch_size

      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        A_    :			Optional[Any]									=    self._get_config_and_data()
        A_    :			Optional[Any]									=    FlaxMBartForSequenceClassification(_lowerCamelCase    )
        A_    :			Optional[int]									=    model(input_ids=_lowerCamelCase   , decoder_input_ids=_lowerCamelCase    )
        A_    :			List[str]									=    (batch_size, config.num_labels)
        self.assertEqual(outputs['logits'].shape   , _lowerCamelCase    )

      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        A_    :			Optional[Any]									=    self._get_config_and_data()
        A_    :			int									=    FlaxMBartForQuestionAnswering(_lowerCamelCase    )
        A_    :			int									=    model(input_ids=_lowerCamelCase    )

        self.assertEqual(outputs['start_logits'].shape   , input_ids.shape    )
        self.assertEqual(outputs['end_logits'].shape   , input_ids.shape    )

      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        A_    :			Union[str, Any]									=    self._get_config_and_data()
        A_    :			Dict									=    FlaxMBartForConditionalGeneration(_lowerCamelCase    )
        A_    :			str									=    lm_model(input_ids=_lowerCamelCase    )
        A_    :			int									=    (batch_size, input_ids.shape[1], config.vocab_size)
        self.assertEqual(outputs['logits'].shape   , _lowerCamelCase    )

      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        A_    :			Optional[Any]									=    MBartConfig(
            vocab_size=self.vocab_size   , d_model=1_4   , 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=4_8   , )
        A_    :			int									=    FlaxMBartForConditionalGeneration(_lowerCamelCase    )
        A_    :			Optional[int]									=    np.array([[7_1, 8_2, 1_8, 3_3, 4_6, 9_1, 2], [6_8, 3_4, 2_6, 5_8, 3_0, 2, 1]]   , dtype=np.intaa    )
        A_    :			int									=    np.array([[8_2, 7_1, 8_2, 1_8, 2], [5_8, 6_8, 2, 1, 1]]   , dtype=np.intaa    )
        A_    :			int									=    lm_model(input_ids=_lowerCamelCase   , decoder_input_ids=_lowerCamelCase    )
        A_    :			str									=    (*summary.shape, config.vocab_size)
        self.assertEqual(outputs['logits'].shape   , _lowerCamelCase    )

      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        A_    :			Optional[Any]									=    np.array([[7_1, 8_2, 1_8, 3_3, 2, 1, 1], [6_8, 3_4, 2_6, 5_8, 3_0, 8_2, 2]]   , dtype=np.intaa    )
        A_    :			List[str]									=    shift_tokens_right(_lowerCamelCase   , 1    )
        A_    :			Optional[int]									=    np.equal(_lowerCamelCase   , 1    ).astype(np.floataa    ).sum()
        A_    :			List[str]									=    np.equal(_lowerCamelCase   , 1    ).astype(np.floataa    ).sum()
        self.assertEqual(shifted.shape   , input_ids.shape    )
        self.assertEqual(_lowerCamelCase   , n_pad_before - 1    )
        self.assertTrue(np.equal(shifted[:, 0]   , 2    ).all()    )


@require_flax
class 					_UpperCAmelCase    (  __A     ,  unittest.TestCase     ,  __A						):



      '''simple docstring'''
      lowercase_ :					str             =  True
      lowercase_ :					str             =  (
          (
              FlaxMBartModel,
              FlaxMBartForConditionalGeneration,
              FlaxMBartForSequenceClassification,
              FlaxMBartForQuestionAnswering,
          )
          if is_flax_available()
          else ()
      )
      lowercase_ :					List[Any]             =  (FlaxMBartForConditionalGeneration,) if is_flax_available() else ()

      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        A_    :			str									=    FlaxMBartModelTester(self    )

      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        A_    :			Dict									=    self.model_tester.prepare_config_and_inputs()
        for model_class in self.all_model_classes:
          self.model_tester.check_use_cache_forward(_lowerCamelCase   , _lowerCamelCase   , _lowerCamelCase    )

      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        A_    :			Any									=    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(_lowerCamelCase   , _lowerCamelCase   , _lowerCamelCase    )

      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        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_    :			List[str]									=    self._prepare_for_class(_lowerCamelCase   , _lowerCamelCase    )
            A_    :			int									=    model_class(_lowerCamelCase    )

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

            with self.subTest('JIT Enabled'    ):
              A_    :			Any									=    encode_jitted(**_lowerCamelCase    ).to_tuple()

            with self.subTest('JIT Disabled'    ):
              with jax.disable_jit():
                A_    :			Any									=    encode_jitted(**_lowerCamelCase    ).to_tuple()

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

      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        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_    :			Dict									=    model_class(_lowerCamelCase    )
            A_    :			Optional[Any]									=    model.encode(inputs_dict['input_ids']   , inputs_dict['attention_mask']    )

            A_    :			Tuple									=    {
                """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(snake_case_   , snake_case_   , snake_case_    ):
              return model.decode(
                  decoder_input_ids=_lowerCamelCase   , decoder_attention_mask=_lowerCamelCase   , encoder_outputs=_lowerCamelCase   , )

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

            with self.subTest('JIT Disabled'    ):
              with jax.disable_jit():
                A_    :			Union[str, Any]									=    decode_jitted(**_lowerCamelCase    ).to_tuple()

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

      @slow
      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        for model_class_name in self.all_model_classes:
          A_    :			Dict									=    model_class_name.from_pretrained('facebook/mbart-large-cc25'   , from_pt=_lowerCamelCase    )
          # FlaxMBartForSequenceClassification expects eos token in input_ids
          A_    :			List[str]									=    np.ones((1, 1)    ) * model.config.eos_token_id
          A_    :			List[str]									=    model(_lowerCamelCase    )
          self.assertIsNotNone(_lowerCamelCase    )


@require_flax
@require_sentencepiece
@require_tokenizers
class 					_UpperCAmelCase    (  unittest.TestCase						):



      '''simple docstring'''
      lowercase_ :					Optional[int]             =  [
          """ UN Chief Says There Is No Military Solution in Syria""",
      ]
      lowercase_ :					List[Any]             =  [
          """Şeful ONU declară că nu există o soluţie militară în Siria""",
      ]
      lowercase_ :					Optional[Any]             =  """facebook/mbart-large-en-ro"""

      @cached_property
      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        return AutoTokenizer.from_pretrained(self.model_name    )

      @cached_property
      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        A_    :			Optional[int]									=    FlaxMBartForConditionalGeneration.from_pretrained(self.model_name   , from_pt=_lowerCamelCase    )
        return model

      def    lowerCamelCase_     (	self   , **snake_case_    ):

        """simple docstring"""

        A_    :			int									=    self.translate_src_text(**_lowerCamelCase    )
        self.assertListEqual(self.expected_text   , _lowerCamelCase    )

      def    lowerCamelCase_     (	self   , **snake_case_    ):

        """simple docstring"""

        A_    :			Tuple									=    self.tokenizer(self.src_text   , **_lowerCamelCase   , return_tensors='np'    )
        A_    :			str									=    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=_lowerCamelCase   , num_beams=2   , ).sequences
        A_    :			Union[str, Any]									=    self.tokenizer.batch_decode(_lowerCamelCase   , skip_special_tokens=_lowerCamelCase    )
        return generated_words

      @slow
      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        self._assert_generated_batch_equal_expected()




'''simple docstring'''





from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


UpperCamelCase__    :     List[Any]			  =   {
    'configuration_layoutlm': ['LAYOUTLM_PRETRAINED_CONFIG_ARCHIVE_MAP', 'LayoutLMConfig', 'LayoutLMOnnxConfig'],
    'tokenization_layoutlm': ['LayoutLMTokenizer'],
}

try:
  if not is_tokenizers_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  UpperCamelCase__    :     Any			  =   ['LayoutLMTokenizerFast']

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  UpperCamelCase__    :     Optional[Any]			  =   [
      'LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST',
      'LayoutLMForMaskedLM',
      'LayoutLMForSequenceClassification',
      'LayoutLMForTokenClassification',
      'LayoutLMForQuestionAnswering',
      'LayoutLMModel',
      'LayoutLMPreTrainedModel',
  ]

try:
  if not is_tf_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  UpperCamelCase__    :     str			  =   [
      'TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST',
      'TFLayoutLMForMaskedLM',
      'TFLayoutLMForSequenceClassification',
      'TFLayoutLMForTokenClassification',
      'TFLayoutLMForQuestionAnswering',
      'TFLayoutLMMainLayer',
      'TFLayoutLMModel',
      'TFLayoutLMPreTrainedModel',
  ]


if TYPE_CHECKING:
  from .configuration_layoutlm import LAYOUTLM_PRETRAINED_CONFIG_ARCHIVE_MAP, LayoutLMConfig, LayoutLMOnnxConfig
  from .tokenization_layoutlm import LayoutLMTokenizer

  try:
    if not is_tokenizers_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .tokenization_layoutlm_fast import LayoutLMTokenizerFast

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_layoutlm import (
        LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST,
        LayoutLMForMaskedLM,
        LayoutLMForQuestionAnswering,
        LayoutLMForSequenceClassification,
        LayoutLMForTokenClassification,
        LayoutLMModel,
        LayoutLMPreTrainedModel,
    )
  try:
    if not is_tf_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_tf_layoutlm import (
        TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST,
        TFLayoutLMForMaskedLM,
        TFLayoutLMForQuestionAnswering,
        TFLayoutLMForSequenceClassification,
        TFLayoutLMForTokenClassification,
        TFLayoutLMMainLayer,
        TFLayoutLMModel,
        TFLayoutLMPreTrainedModel,
    )

else:
  import sys

  UpperCamelCase__    :     List[str]			  =   _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
