





import collections
import inspect
import unittest

from transformers import DinatConfig
from transformers.testing_utils import require_natten, require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
    import torch
    from torch import nn

    from transformers import DinatBackbone, DinatForImageClassification, DinatModel
    from transformers.models.dinat.modeling_dinat import DINAT_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
    from PIL import Image

    from transformers import AutoImageProcessor







class 		_lowerCAmelCase:

  """simple docstring"""







  def __init__(   self    ,							UpperCAmelCase    ,							UpperCAmelCase=13    ,							UpperCAmelCase=64    ,							UpperCAmelCase=4    ,							UpperCAmelCase=3    ,							UpperCAmelCase=16    ,							UpperCAmelCase=[1, 2, 1]    ,							UpperCAmelCase=[2, 4, 8]    ,							UpperCAmelCase=3    ,							UpperCAmelCase=[[3], [1, 2], [1]]    ,							UpperCAmelCase=2.0    ,							UpperCAmelCase=True    ,							UpperCAmelCase=0.0    ,							UpperCAmelCase=0.0    ,							UpperCAmelCase=0.1    ,							UpperCAmelCase="gelu"    ,							UpperCAmelCase=True    ,							UpperCAmelCase=0.02    ,							UpperCAmelCase=1e-5    ,							UpperCAmelCase=True    ,							UpperCAmelCase=None    ,							UpperCAmelCase=True    ,							UpperCAmelCase=10    ,							UpperCAmelCase=["stage1", "stage2"]    ,							UpperCAmelCase=[1, 2]    ,							)->   str:
     __A    =  parent
     __A    =  batch_size
     __A    =  image_size
     __A    =  patch_size
     __A    =  num_channels
     __A    =  embed_dim
     __A    =  depths
     __A    =  num_heads
     __A    =  kernel_size
     __A    =  dilations
     __A    =  mlp_ratio
     __A    =  qkv_bias
     __A    =  hidden_dropout_prob
     __A    =  attention_probs_dropout_prob
     __A    =  drop_path_rate
     __A    =  hidden_act
     __A    =  patch_norm
     __A    =  layer_norm_eps
     __A    =  initializer_range
     __A    =  is_training
     __A    =  scope
     __A    =  use_labels
     __A    =  num_labels
     __A    =  out_features
     __A    =  out_indices

  def 						SCREAMING_SNAKE_CASE__			(   self      )->   Any:
     __A    =  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]      )

     __A    =  None
     if self.use_labels:
        __A    =  ids_tensor([self.batch_size]    ,							self.num_labels      )

     __A    =  self.get_config()

     return config, pixel_values, labels

  def 						SCREAMING_SNAKE_CASE__			(   self      )->   Dict:
     return DinatConfig(
         num_labels=self.num_labels    ,							image_size=self.image_size    ,							patch_size=self.patch_size    ,							num_channels=self.num_channels    ,							embed_dim=self.embed_dim    ,							depths=self.depths    ,							num_heads=self.num_heads    ,							kernel_size=self.kernel_size    ,							dilations=self.dilations    ,							mlp_ratio=self.mlp_ratio    ,							qkv_bias=self.qkv_bias    ,							hidden_dropout_prob=self.hidden_dropout_prob    ,							attention_probs_dropout_prob=self.attention_probs_dropout_prob    ,							drop_path_rate=self.drop_path_rate    ,							hidden_act=self.hidden_act    ,							patch_norm=self.patch_norm    ,							layer_norm_eps=self.layer_norm_eps    ,							initializer_range=self.initializer_range    ,							out_features=self.out_features    ,							out_indices=self.out_indices    ,							)

  def 						SCREAMING_SNAKE_CASE__			(   self    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase      )->   List[Any]:
     __A    =  DinatModel(config=lowercase_      )
     model.to(lowercase_      )
     model.eval()
     __A    =  model(lowercase_      )

     __A    =  __A    =  (config.image_size // config.patch_size) // (2 ** (len(config.depths      ) - 1))
     __A    =  int(config.embed_dim * 2 ** (len(config.depths      ) - 1)      )

     self.parent.assertEqual(
         result.last_hidden_state.shape    ,							(self.batch_size, expected_height, expected_width, expected_dim)      )

  def 						SCREAMING_SNAKE_CASE__			(   self    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase      )->   Optional[int]:
     __A    =  DinatForImageClassification(lowercase_      )
     model.to(lowercase_      )
     model.eval()
     __A    =  model(lowercase_    ,							labels=lowercase_      )
     self.parent.assertEqual(result.logits.shape    ,							(self.batch_size, self.num_labels)      )

     # test greyscale images
     __A    =  1
     __A    =  DinatForImageClassification(lowercase_      )
     model.to(lowercase_      )
     model.eval()

     __A    =  floats_tensor([self.batch_size, 1, self.image_size, self.image_size]      )
     __A    =  model(lowercase_      )
     self.parent.assertEqual(result.logits.shape    ,							(self.batch_size, self.num_labels)      )

  def 						SCREAMING_SNAKE_CASE__			(   self    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase      )->   Any:
     __A    =  DinatBackbone(config=lowercase_      )
     model.to(lowercase_      )
     model.eval()
     __A    =  model(lowercase_      )

     # verify hidden states
     self.parent.assertEqual(len(result.feature_maps      )    ,							len(config.out_features      )      )
     self.parent.assertListEqual(list(result.feature_maps[0].shape      )    ,							[self.batch_size, model.channels[0], 16, 16]      )

     # verify channels
     self.parent.assertEqual(len(model.channels      )    ,							len(config.out_features      )      )

     # verify backbone works with out_features=None
     __A    =  None
     __A    =  DinatBackbone(config=lowercase_      )
     model.to(lowercase_      )
     model.eval()
     __A    =  model(lowercase_      )

     # verify feature maps
     self.parent.assertEqual(len(result.feature_maps      )    ,							1      )
     self.parent.assertListEqual(list(result.feature_maps[0].shape      )    ,							[self.batch_size, model.channels[-1], 4, 4]      )

     # verify channels
     self.parent.assertEqual(len(model.channels      )    ,							1      )





  def 						SCREAMING_SNAKE_CASE__			(   self      )->   Optional[int]:
     __A    =  self.prepare_config_and_inputs()
     __A   ,		__A   ,		__A    =  config_and_inputs
     __A    =  {'''pixel_values''': pixel_values}
     return config, inputs_dict







@require_natten
@require_torch
class 		_lowerCAmelCase(		lowerCamelCase__						,       lowerCamelCase__						,       unittest.TestCase):

  """simple docstring"""







  lowerCamelCase__     	=       (
      (
          DinatModel,
          DinatForImageClassification,
          DinatBackbone,
      )
      if is_torch_available()
      else ()
  )
  lowerCamelCase__     	=       (
      {'feature-extraction': DinatModel, 'image-classification': DinatForImageClassification}
      if is_torch_available()
      else {}
  )
  lowerCamelCase__     	=       False

  lowerCamelCase__     	=       False
  lowerCamelCase__     	=       False
  lowerCamelCase__     	=       False
  lowerCamelCase__     	=       False

  def 						SCREAMING_SNAKE_CASE__			(   self      )->   int:
     __A    =  DinatModelTester(self      )
     __A    =  ConfigTester(self    ,							config_class=lowercase_    ,							embed_dim=37      )

  def 						SCREAMING_SNAKE_CASE__			(   self      )->   Optional[int]:
     self.create_and_test_config_common_properties()
     self.config_tester.create_and_test_config_to_json_string()
     self.config_tester.create_and_test_config_to_json_file()
     self.config_tester.create_and_test_config_from_and_save_pretrained()
     self.config_tester.create_and_test_config_with_num_labels()
     self.config_tester.check_config_can_be_init_without_params()
     self.config_tester.check_config_arguments_init()

  def 						SCREAMING_SNAKE_CASE__			(   self      )->   Optional[int]:
     return

  def 						SCREAMING_SNAKE_CASE__			(   self      )->   List[Any]:
     __A    =  self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(*lowercase_      )

  def 						SCREAMING_SNAKE_CASE__			(   self      )->   List[Any]:
     __A    =  self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_image_classification(*lowercase_      )

  def 						SCREAMING_SNAKE_CASE__			(   self      )->   str:
     __A    =  self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_backbone(*lowercase_      )

  @unittest.skip(reason='''Dinat does not use inputs_embeds'''      )
  def 						SCREAMING_SNAKE_CASE__			(   self      )->   Tuple:
     pass

  @unittest.skip(reason='''Dinat does not use feedforward chunking'''      )
  def 						SCREAMING_SNAKE_CASE__			(   self      )->   Tuple:
     pass

  def 						SCREAMING_SNAKE_CASE__			(   self      )->   Tuple:
     __A   ,		__A    =  self.model_tester.prepare_config_and_inputs_for_common()

     for model_class in self.all_model_classes:
        __A    =  model_class(lowercase_      )
        self.assertIsInstance(model.get_input_embeddings()    ,							(nn.Module)      )
        __A    =  model.get_output_embeddings()
        self.assertTrue(x is None or isinstance(lowercase_    ,							nn.Linear      )      )

  def 						SCREAMING_SNAKE_CASE__			(   self      )->   Dict:
     __A   ,		__A    =  self.model_tester.prepare_config_and_inputs_for_common()

     for model_class in self.all_model_classes:
        __A    =  model_class(lowercase_      )
        __A    =  inspect.signature(model.forward      )
        # signature.parameters is an OrderedDict => so arg_names order is deterministic
        __A    =  [*signature.parameters.keys()]

        __A    =  ['''pixel_values''']
        self.assertListEqual(arg_names[:1]    ,							lowercase_      )

  def 						SCREAMING_SNAKE_CASE__			(   self      )->   Dict:
     self.skipTest('''Dinat\'s attention operation is handled entirely by NATTEN.'''      )

  def 						SCREAMING_SNAKE_CASE__			(   self    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase      )->   Union[str, Any]:
     __A    =  model_class(lowercase_      )
     model.to(lowercase_      )
     model.eval()

     with torch.no_grad():
        __A    =  model(**self._prepare_for_class(lowercase_    ,							lowercase_      )      )

     __A    =  outputs.hidden_states

     __A    =  getattr(
         self.model_tester    ,							'''expected_num_hidden_layers'''    ,							len(self.model_tester.depths      ) + 1      )
     self.assertEqual(len(lowercase_      )    ,							lowercase_      )

     # Dinat has a different seq_length
     __A    =  (
         config.patch_size
         if isinstance(config.patch_size    ,							collections.abc.Iterable      )
         else (config.patch_size, config.patch_size)
     )

     __A    =  image_size[0] // patch_size[0]
     __A    =  image_size[1] // patch_size[1]

     self.assertListEqual(
         list(hidden_states[0].shape[-3:]      )    ,							[height, width, self.model_tester.embed_dim]    ,							)

     if model_class.__name__ != "DinatBackbone":
        __A    =  outputs.reshaped_hidden_states
        self.assertEqual(len(lowercase_      )    ,							lowercase_      )

        __A   ,		__A   ,		__A   ,		__A    =  reshaped_hidden_states[0].shape
        __A    =  (
            reshaped_hidden_states[0].view(lowercase_    ,							lowercase_    ,							lowercase_    ,							lowercase_      ).permute(0    ,							2    ,							3    ,							1      )
        )
        self.assertListEqual(
            list(reshaped_hidden_states.shape[-3:]      )    ,							[height, width, self.model_tester.embed_dim]    ,							)

  def 						SCREAMING_SNAKE_CASE__			(   self      )->   Optional[Any]:
     __A   ,		__A    =  self.model_tester.prepare_config_and_inputs_for_common()

     __A    =  (
         self.model_tester.image_size
         if isinstance(self.model_tester.image_size    ,							collections.abc.Iterable      )
         else (self.model_tester.image_size, self.model_tester.image_size)
     )

     for model_class in self.all_model_classes:
        __A    =  True
        self.check_hidden_states_output(lowercase_    ,							lowercase_    ,							lowercase_    ,							lowercase_      )

        # check that output_hidden_states also work using config
        del inputs_dict["output_hidden_states"]
        __A    =  True

        self.check_hidden_states_output(lowercase_    ,							lowercase_    ,							lowercase_    ,							lowercase_      )

  @slow
  def 						SCREAMING_SNAKE_CASE__			(   self      )->   Any:






     for model_name in DINAT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
        __A    =  DinatModel.from_pretrained(lowercase_      )
        self.assertIsNotNone(lowercase_      )





  def 						SCREAMING_SNAKE_CASE__			(   self      )->   List[Any]:
     __A   ,		__A    =  self.model_tester.prepare_config_and_inputs_for_common()

     __A    =  _config_zero_init(lowercase_      )
     for model_class in self.all_model_classes:
        __A    =  model_class(config=lowercase_      )
        for name, param in model.named_parameters():
           if "embeddings" not in name and param.requires_grad:
              self.assertIn(
                  ((param.data.mean() * 1e9).round() / 1e9).item()    ,							[0.0, 1.0]    ,							msg=f"Parameter {name} of model {model_class} seems not properly initialized"    ,							)







@require_natten
@require_vision
@require_torch
class 		_lowerCAmelCase(		unittest.TestCase):

  """simple docstring"""







  @cached_property
  def 						SCREAMING_SNAKE_CASE__			(   self      )->   List[str]:
     return AutoImageProcessor.from_pretrained('''shi-labs/dinat-mini-in1k-224'''      ) if is_vision_available() else None





  @slow
  def 						SCREAMING_SNAKE_CASE__			(   self      )->   int:
     __A    =  DinatForImageClassification.from_pretrained('''shi-labs/dinat-mini-in1k-224'''      ).to(lowercase_      )
     __A    =  self.default_image_processor

     __A    =  Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''      )
     __A    =  image_processor(images=lowercase_    ,							return_tensors='''pt'''      ).to(lowercase_      )

     # forward pass
     with torch.no_grad():
        __A    =  model(**lowercase_      )

     # verify the logits
     __A    =  torch.Size((1, 10_00)      )
     self.assertEqual(outputs.logits.shape    ,							lowercase_      )
     __A    =  torch.tensor([-0.1545, -0.7667, 0.4642]      ).to(lowercase_      )
     self.assertTrue(torch.allclose(outputs.logits[0, :3]    ,							lowercase_    ,							atol=1e-4      )      )







@require_torch
@require_natten
class 		_lowerCAmelCase(		unittest.TestCase						,       lowerCamelCase__):

  """simple docstring"""







  lowerCamelCase__     	=       (DinatBackbone,) if is_torch_available() else ()
  lowerCamelCase__     	=       DinatConfig

  def 						SCREAMING_SNAKE_CASE__			(   self      )->   str:
     __A    =  DinatModelTester(self      )




import unittest

from transformers import MarkupLMConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device
from transformers.utils import cached_property

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 (
           MarkupLMForQuestionAnswering,
           MarkupLMForSequenceClassification,
           MarkupLMForTokenClassification,
           MarkupLMModel,
       )

# TODO check dependencies
from transformers import MarkupLMFeatureExtractor, MarkupLMProcessor, MarkupLMTokenizer







class 		__magic_name__     :

   '''simple docstring'''




   def __init__(							self,       lowercase_,       lowercase_=13,       lowercase_=7,       lowercase_=True,       lowercase_=True,       lowercase_=True,       lowercase_=True,       lowercase_=99,       lowercase_=32,       lowercase_=5,       lowercase_=4,       lowercase_=37,       lowercase_="gelu",       lowercase_=0.1,       lowercase_=0.1,       lowercase_=512,       lowercase_=16,       lowercase_=2,       lowercase_=0.02,       lowercase_=3,       lowercase_=None,       lowercase_=20,       lowercase_=30,       lowercase_=2,       lowercase_=2,       lowercase_=10,       )				->       Dict:






     """simple docstring"""






     a__    =parent
     a__    =batch_size
     a__    =seq_length
     a__    =is_training
     a__    =use_input_mask
     a__    =use_token_type_ids
     a__    =use_labels
     a__    =vocab_size
     a__    =hidden_size
     a__    =num_hidden_layers
     a__    =num_attention_heads
     a__    =intermediate_size
     a__    =hidden_act
     a__    =hidden_dropout_prob
     a__    =attention_probs_dropout_prob
     a__    =max_position_embeddings
     a__    =type_vocab_size
     a__    =type_sequence_label_size
     a__    =initializer_range
     a__    =num_labels
     a__    =scope
     a__    =max_xpath_tag_unit_embeddings
     a__    =max_xpath_subs_unit_embeddings
     a__    =tag_pad_id
     a__    =subs_pad_id
     a__    =max_depth



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






     """simple docstring"""






     a__    =ids_tensor([self.batch_size, self.seq_length],       self.vocab_size			)

     a__    =ids_tensor(
         [self.batch_size, self.seq_length, self.max_depth],       self.max_xpath_tag_unit_embeddings			)

     a__    =ids_tensor(
         [self.batch_size, self.seq_length, self.max_depth],       self.max_xpath_subs_unit_embeddings			)

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

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

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

     a__    =self.get_config()

     return (
         config,
         input_ids,
         xpath_tags_seq,
         xpath_subs_seq,
         token_type_ids,
         input_mask,
         sequence_labels,
         token_labels,
     )



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






     """simple docstring"""






     return MarkupLMConfig(
         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,       max_xpath_tag_unit_embeddings=self.max_xpath_tag_unit_embeddings,       max_xpath_subs_unit_embeddings=self.max_xpath_subs_unit_embeddings,       tag_pad_id=self.tag_pad_id,       subs_pad_id=self.subs_pad_id,       max_depth=self.max_depth,       )



   def 					_UpperCAmelCase					(							self,       lowercase_,       lowercase_,       lowercase_,       lowercase_,       lowercase_,       lowercase_,       lowercase_,       lowercase_,       )				->       Tuple:






     """simple docstring"""






     a__    =MarkupLMModel(config=lowercase_			)
     model.to(lowercase_			)
     model.eval()
     print('''Configs:''',       model.config.tag_pad_id,       model.config.subs_pad_id			)
     a__    =model(lowercase_,       attention_mask=lowercase_,       token_type_ids=lowercase_			)
     a__    =model(lowercase_,       token_type_ids=lowercase_			)
     a__    =model(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 					_UpperCAmelCase					(							self,       lowercase_,       lowercase_,       lowercase_,       lowercase_,       lowercase_,       lowercase_,       lowercase_,       lowercase_,       )				->       Tuple:






     """simple docstring"""






     a__    =self.num_labels
     a__    =MarkupLMForSequenceClassification(lowercase_			)
     model.to(lowercase_			)
     model.eval()
     a__    =model(
         lowercase_,       xpath_tags_seq=lowercase_,       xpath_subs_seq=lowercase_,       attention_mask=lowercase_,       token_type_ids=lowercase_,       labels=lowercase_,       )
     self.parent.assertEqual(result.logits.shape,       (self.batch_size, self.num_labels)			)



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






     """simple docstring"""






     a__    =self.num_labels
     a__    =MarkupLMForTokenClassification(config=lowercase_			)
     model.to(lowercase_			)
     model.eval()
     a__    =model(
         lowercase_,       xpath_tags_seq=lowercase_,       xpath_subs_seq=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 					_UpperCAmelCase					(							self,       lowercase_,       lowercase_,       lowercase_,       lowercase_,       lowercase_,       lowercase_,       lowercase_,       lowercase_,       )				->       Any:






     """simple docstring"""






     a__    =MarkupLMForQuestionAnswering(config=lowercase_			)
     model.to(lowercase_			)
     model.eval()
     a__    =model(
         lowercase_,       xpath_tags_seq=lowercase_,       xpath_subs_seq=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 					_UpperCAmelCase					(							self			)				->       Union[str, Any]:






     """simple docstring"""






     a__    =self.prepare_config_and_inputs()
     (
         (
         a__
     ), (
         a__
     ), (
         a__
     ), (
         a__
     ), (
         a__
     ), (
         a__
     ), (
         a__
     ), (
         a__
     ), 
     )    =config_and_inputs
     a__    ={
         '''input_ids''': input_ids,
         '''xpath_tags_seq''': xpath_tags_seq,
         '''xpath_subs_seq''': xpath_subs_seq,
         '''token_type_ids''': token_type_ids,
         '''attention_mask''': input_mask,
     }
     return config, inputs_dict







@require_torch
class 		__magic_name__     (				lowerCamelCase__						,			lowerCamelCase__						,			unittest.TestCase				):

   '''simple docstring'''




   lowerCamelCase__					:      Tuple        =  (
       (
           MarkupLMModel,
           MarkupLMForSequenceClassification,
           MarkupLMForTokenClassification,
           MarkupLMForQuestionAnswering,
       )
       if is_torch_available()
       else None
   )
   lowerCamelCase__					:      Union[str, Any]        =  (
       {
           'feature-extraction': MarkupLMModel,
           'question-answering': MarkupLMForQuestionAnswering,
           'text-classification': MarkupLMForSequenceClassification,
           'token-classification': MarkupLMForTokenClassification,
           'zero-shot': MarkupLMForSequenceClassification,
       }
       if is_torch_available()
       else {}
   )



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






     """simple docstring"""






     return True



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






     """simple docstring"""






     a__    =MarkupLMModelTester(self			)
     a__    =ConfigTester(self,       config_class=lowercase_,       hidden_size=37			)



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






     """simple docstring"""






     self.config_tester.run_common_tests()



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






     """simple docstring"""






     a__    =self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(*lowercase_			)



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






     """simple docstring"""






     a__    =self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_sequence_classification(*lowercase_			)



   def 					_UpperCAmelCase					(							self			)				->       Tuple:






     """simple docstring"""






     a__    =self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_token_classification(*lowercase_			)



   def 					_UpperCAmelCase					(							self			)				->       int:






     """simple docstring"""






     a__    =self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_question_answering(*lowercase_			)





def      UpperCAmelCase__							(     ):





  '''simple docstring'''







  a__    ='''
    <!DOCTYPE html>
    <html>
    <head>
    <title>Page Title</title>
    </head>
    <body>

    <h1>This is a Heading</h1>
    <p>This is a paragraph.</p>

    </body>
    </html>
    '''

  return html_string







@require_torch
class 		__magic_name__     (				unittest.TestCase				):

   '''simple docstring'''




   @cached_property
   def 					_UpperCAmelCase					(							self			)				->       List[str]:






     """simple docstring"""






     a__    =MarkupLMFeatureExtractor()
     a__    =MarkupLMTokenizer.from_pretrained('''microsoft/markuplm-base'''			)

     return MarkupLMProcessor(lowercase_,       lowercase_			)



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






     """simple docstring"""






     a__    =MarkupLMModel.from_pretrained('''microsoft/markuplm-base'''			).to(lowercase_			)

     a__    =self.default_processor

     a__    =processor(prepare_html_string(),       return_tensors='''pt'''			)
     a__    =inputs.to(lowercase_			)

     # forward pass
     with torch.no_grad():
       a__    =model(**lowercase_			)

     # verify the last hidden states
     a__    =torch.Size([1, 14, 768]			)
     self.assertEqual(outputs.last_hidden_state.shape,       lowercase_			)

     a__    =torch.tensor(
         [[0.0675, -0.0052, 0.5001], [-0.2281, 0.0802, 0.2192], [-0.0583, -0.3311, 0.1185]]			).to(lowercase_			)

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