code: 
  
  
  
  
  
  
  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     UpperCAmelCase_		:
  
  
  
        """simple docstring"""
        def __init__(       self					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_=13					,       SCREAMING_SNAKE_CASE_=7					,       SCREAMING_SNAKE_CASE_=True					,       SCREAMING_SNAKE_CASE_=True					,       SCREAMING_SNAKE_CASE_=True					,       SCREAMING_SNAKE_CASE_=True					,       SCREAMING_SNAKE_CASE_=99					,       SCREAMING_SNAKE_CASE_=32					,       SCREAMING_SNAKE_CASE_=5					,       SCREAMING_SNAKE_CASE_=4					,       SCREAMING_SNAKE_CASE_=37					,       SCREAMING_SNAKE_CASE_="gelu"					,       SCREAMING_SNAKE_CASE_=0.1					,       SCREAMING_SNAKE_CASE_=0.1					,       SCREAMING_SNAKE_CASE_=512					,       SCREAMING_SNAKE_CASE_=16					,       SCREAMING_SNAKE_CASE_=2					,       SCREAMING_SNAKE_CASE_=0.02					,       SCREAMING_SNAKE_CASE_=3					,       SCREAMING_SNAKE_CASE_=None					,       SCREAMING_SNAKE_CASE_=20					,       SCREAMING_SNAKE_CASE_=30					,       SCREAMING_SNAKE_CASE_=2					,       SCREAMING_SNAKE_CASE_=2					,       SCREAMING_SNAKE_CASE_=10					,       )       ->   Optional[Any]:
            UpperCamelCase :Union[str, Any]										=     parent
            UpperCamelCase :Dict										=     batch_size
            UpperCamelCase :Optional[int]										=     seq_length
            UpperCamelCase :int										=     is_training
            UpperCamelCase :Dict										=     use_input_mask
            UpperCamelCase :Dict										=     use_token_type_ids
            UpperCamelCase :List[str]										=     use_labels
            UpperCamelCase :Any										=     vocab_size
            UpperCamelCase :str										=     hidden_size
            UpperCamelCase :int										=     num_hidden_layers
            UpperCamelCase :str										=     num_attention_heads
            UpperCamelCase :List[Any]										=     intermediate_size
            UpperCamelCase :Union[str, Any]										=     hidden_act
            UpperCamelCase :Dict										=     hidden_dropout_prob
            UpperCamelCase :Optional[int]										=     attention_probs_dropout_prob
            UpperCamelCase :Tuple										=     max_position_embeddings
            UpperCamelCase :List[Any]										=     type_vocab_size
            UpperCamelCase :Tuple										=     type_sequence_label_size
            UpperCamelCase :Any										=     initializer_range
            UpperCamelCase :List[Any]										=     num_labels
            UpperCamelCase :List[str]										=     scope
            UpperCamelCase :Optional[int]										=     max_xpath_tag_unit_embeddings
            UpperCamelCase :List[Any]										=     max_xpath_subs_unit_embeddings
            UpperCamelCase :List[Any]										=     tag_pad_id
            UpperCamelCase :str										=     subs_pad_id
            UpperCamelCase :Dict										=     max_depth
        def 					UpperCAmelCase		(       self				)       ->   Dict:
            UpperCamelCase :Tuple										=     ids_tensor([self.batch_size, self.seq_length]					,       self.vocab_size				)
  
            UpperCamelCase :Dict										=     ids_tensor(
                [self.batch_size, self.seq_length, self.max_depth]					,       self.max_xpath_tag_unit_embeddings				)
  
            UpperCamelCase :List[str]										=     ids_tensor(
                [self.batch_size, self.seq_length, self.max_depth]					,       self.max_xpath_subs_unit_embeddings				)
  
            UpperCamelCase :Dict										=     None
            if self.use_input_mask:
                UpperCamelCase :Any										=     ids_tensor([self.batch_size, self.seq_length]					,       vocab_size=2				)
  
            UpperCamelCase :str										=     None
            if self.use_token_type_ids:
                UpperCamelCase :Tuple										=     ids_tensor([self.batch_size, self.seq_length]					,       self.type_vocab_size				)
  
            UpperCamelCase :Dict										=     None
            UpperCamelCase :Optional[int]										=     None
            if self.use_labels:
                UpperCamelCase :str										=     ids_tensor([self.batch_size]					,       self.type_sequence_label_size				)
                UpperCamelCase :str										=     ids_tensor([self.batch_size, self.seq_length]					,       self.num_labels				)
  
            UpperCamelCase :Tuple										=     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				)       ->   int:
            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					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       )       ->   str:
            UpperCamelCase :Optional[Any]										=     MarkupLMModel(config=SCREAMING_SNAKE_CASE_				)
            model.to(SCREAMING_SNAKE_CASE_				)
            model.eval()
            print('''Configs:'''					,       model.config.tag_pad_id					,       model.config.subs_pad_id				)
            UpperCamelCase :List[str]										=     model(SCREAMING_SNAKE_CASE_					,       attention_mask=SCREAMING_SNAKE_CASE_					,       token_type_ids=SCREAMING_SNAKE_CASE_				)
            UpperCamelCase :int										=     model(SCREAMING_SNAKE_CASE_					,       token_type_ids=SCREAMING_SNAKE_CASE_				)
            UpperCamelCase :Optional[int]										=     model(SCREAMING_SNAKE_CASE_				)
            self.parent.assertEqual(result.last_hidden_state.shape					,       (self.batch_size, self.seq_length, self.hidden_size)				)
            self.parent.assertEqual(result.pooler_output.shape					,       (self.batch_size, self.hidden_size)				)
        def 					UpperCAmelCase		(       self					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       )       ->   Tuple:
            UpperCamelCase :Dict										=     self.num_labels
            UpperCamelCase :List[str]										=     MarkupLMForSequenceClassification(SCREAMING_SNAKE_CASE_				)
            model.to(SCREAMING_SNAKE_CASE_				)
            model.eval()
            UpperCamelCase :Optional[int]										=     model(
                SCREAMING_SNAKE_CASE_					,       xpath_tags_seq=SCREAMING_SNAKE_CASE_					,       xpath_subs_seq=SCREAMING_SNAKE_CASE_					,       attention_mask=SCREAMING_SNAKE_CASE_					,       token_type_ids=SCREAMING_SNAKE_CASE_					,       labels=SCREAMING_SNAKE_CASE_					,       )
            self.parent.assertEqual(result.logits.shape					,       (self.batch_size, self.num_labels)				)
        def 					UpperCAmelCase		(       self					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       )       ->   List[Any]:
            UpperCamelCase :str										=     self.num_labels
            UpperCamelCase :Any										=     MarkupLMForTokenClassification(config=SCREAMING_SNAKE_CASE_				)
            model.to(SCREAMING_SNAKE_CASE_				)
            model.eval()
            UpperCamelCase :Optional[int]										=     model(
                SCREAMING_SNAKE_CASE_					,       xpath_tags_seq=SCREAMING_SNAKE_CASE_					,       xpath_subs_seq=SCREAMING_SNAKE_CASE_					,       attention_mask=SCREAMING_SNAKE_CASE_					,       token_type_ids=SCREAMING_SNAKE_CASE_					,       labels=SCREAMING_SNAKE_CASE_					,       )
            self.parent.assertEqual(result.logits.shape					,       (self.batch_size, self.seq_length, self.num_labels)				)
        def 					UpperCAmelCase		(       self					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       )       ->   str:
            UpperCamelCase :Dict										=     MarkupLMForQuestionAnswering(config=SCREAMING_SNAKE_CASE_				)
            model.to(SCREAMING_SNAKE_CASE_				)
            model.eval()
            UpperCamelCase :str										=     model(
                SCREAMING_SNAKE_CASE_					,       xpath_tags_seq=SCREAMING_SNAKE_CASE_					,       xpath_subs_seq=SCREAMING_SNAKE_CASE_					,       attention_mask=SCREAMING_SNAKE_CASE_					,       token_type_ids=SCREAMING_SNAKE_CASE_					,       start_positions=SCREAMING_SNAKE_CASE_					,       end_positions=SCREAMING_SNAKE_CASE_					,       )
            self.parent.assertEqual(result.start_logits.shape					,       (self.batch_size, self.seq_length)				)
            self.parent.assertEqual(result.end_logits.shape					,       (self.batch_size, self.seq_length)				)
  
  
  
  
        def 					UpperCAmelCase		(       self				)       ->   int:
            UpperCamelCase :List[Any]										=     self.prepare_config_and_inputs()
            (
                (
                UpperCamelCase
            )							,     (
                UpperCamelCase
            )							,     (
                UpperCamelCase
            )							,     (
                UpperCamelCase
            )							,     (
                UpperCamelCase
            )							,     (
                UpperCamelCase
            )							,     (
                UpperCamelCase
            )							,     (
                UpperCamelCase
            )							,     
            ) :Union[str, Any]										=     config_and_inputs
            UpperCamelCase :List[Any]										=     {
                '''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     UpperCAmelCase_		(      lowercase,			lowercase,			unittest.TestCase				):
  
  
  
        """simple docstring"""
        UpperCamelCase_       :      Union[str, Any]     =(
            (
                MarkupLMModel,
                MarkupLMForSequenceClassification,
                MarkupLMForTokenClassification,
                MarkupLMForQuestionAnswering,
            )
            if is_torch_available()
            else None
        )
        UpperCamelCase_       :      str     =(
            {
                'feature-extraction': MarkupLMModel,
                'question-answering': MarkupLMForQuestionAnswering,
                'text-classification': MarkupLMForSequenceClassification,
                'token-classification': MarkupLMForTokenClassification,
                'zero-shot': MarkupLMForSequenceClassification,
            }
            if is_torch_available()
            else {}
        )
        def 					UpperCAmelCase		(       self					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_				)       ->   List[str]:
            # ValueError: Nodes must be of type `List[str]` (single pretokenized example), or `List[List[str]]`
            # (batch of pretokenized examples).
            return True
        def 					UpperCAmelCase		(       self				)       ->   int:
            UpperCamelCase :Dict										=     MarkupLMModelTester(self				)
            UpperCamelCase :Any										=     ConfigTester(self					,       config_class=SCREAMING_SNAKE_CASE_					,       hidden_size=37				)
        def 					UpperCAmelCase		(       self				)       ->   str:
            self.config_tester.run_common_tests()
        def 					UpperCAmelCase		(       self				)       ->   List[str]:
            UpperCamelCase :List[Any]										=     self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE_				)
        def 					UpperCAmelCase		(       self				)       ->   Tuple:
            UpperCamelCase :Any										=     self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_sequence_classification(*SCREAMING_SNAKE_CASE_				)
        def 					UpperCAmelCase		(       self				)       ->   Dict:
            UpperCamelCase :List[Any]										=     self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_token_classification(*SCREAMING_SNAKE_CASE_				)
  
  
  
  
        def 					UpperCAmelCase		(       self				)       ->   Any:
            UpperCamelCase :Any										=     self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_question_answering(*SCREAMING_SNAKE_CASE_				)
  
  
  
  
  
  
  
  def 						_A     (       ):
      UpperCamelCase :Dict										=     '''
      <!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     UpperCAmelCase_		(      unittest.TestCase				):
  
  
  
        """simple docstring"""
        @cached_property
        def 					UpperCAmelCase		(       self				)       ->   List[Any]:
            # TODO use from_pretrained here
            UpperCamelCase :int										=     MarkupLMFeatureExtractor()
            UpperCamelCase :Any										=     MarkupLMTokenizer.from_pretrained('''microsoft/markuplm-base'''				)
  
            return MarkupLMProcessor(SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_				)
  
  
  
  
        @slow
        def 					UpperCAmelCase		(       self				)       ->   Union[str, Any]:
            UpperCamelCase :int										=     MarkupLMModel.from_pretrained('''microsoft/markuplm-base'''				).to(SCREAMING_SNAKE_CASE_				)
  
            UpperCamelCase :Any										=     self.default_processor
  
            UpperCamelCase :Union[str, Any]										=     processor(prepare_html_string()					,       return_tensors='''pt'''				)
            UpperCamelCase :Any										=     inputs.to(SCREAMING_SNAKE_CASE_				)
  
            # forward pass
            with torch.no_grad():
                UpperCamelCase :int										=     model(**SCREAMING_SNAKE_CASE_				)
  
            # verify the last hidden states
            UpperCamelCase :int										=     torch.Size([1, 14, 768]				)
            self.assertEqual(outputs.last_hidden_state.shape					,       SCREAMING_SNAKE_CASE_				)
  
            UpperCamelCase :List[str]										=     torch.tensor(
                [[0.0675, -0.0052, 0.5001], [-0.2281, 0.0802, 0.2192], [-0.0583, -0.3311, 0.1185]]				).to(SCREAMING_SNAKE_CASE_				)
  
            self.assertTrue(torch.allclose(outputs.last_hidden_state[0, :3, :3]					,       SCREAMING_SNAKE_CASE_					,       atol=1e-4				)				)
  
  
  
  
  
  
style_context: 
  
  
  
  
  
  
  # as due to their complexity multi-gpu tests could impact other tests, and to aid debug we have those in a separate module.
  
  import os
  import sys
  
  from transformers.testing_utils import TestCasePlus, execute_subprocess_async, get_gpu_count, require_torch_gpu, slow
  
  from .utils import load_json
  
  
  
  
  
  
  
  class     UpperCAmelCase_		(      lowercase				):
  
  
  
        """simple docstring"""
        @classmethod
        def 					UpperCAmelCase		(       cls				)       ->   List[Any]:
            return cls
  
  
  
  
        @slow
        @require_torch_gpu
        def 					UpperCAmelCase		(       self				)       ->   int:
            UpperCamelCase :int										=     self.get_auto_remove_tmp_dir()
            UpperCamelCase :List[str]										=     F'''
              --model_name Helsinki-NLP/opus-mt-en-ro
              --save_dir {output_dir}
              --data_dir {self.test_file_dir_str}/test_data/wmt_en_ro
              --num_beams 2
              --task translation
          '''.split()
  
            # we want this test to run even if there is only one GPU, but if there are more we use them all
            UpperCamelCase :List[str]										=     get_gpu_count()
            UpperCamelCase :Optional[Any]										=     F'''
              -m torch.distributed.launch
              --nproc_per_node={n_gpu}
              {self.test_file_dir}/run_distributed_eval.py
          '''.split()
            UpperCamelCase :List[Any]										=     [sys.executable] + distributed_args + args
            execute_subprocess_async(SCREAMING_SNAKE_CASE_					,       env=self.get_env()				)
  
            UpperCamelCase :Tuple										=     os.path.join(SCREAMING_SNAKE_CASE_					,       '''test_bleu.json'''				)
            UpperCamelCase :str										=     load_json(SCREAMING_SNAKE_CASE_				)
            # print(metrics)
            self.assertGreaterEqual(metrics['''bleu''']					,       25				)
  
  
  
  
  
  