code: 
  
  
  
  
  
  import logging
  import os
  from dataclasses import dataclass, field
  from importlib import import_module
  from typing import Dict, List, Optional, Tuple
  
  import numpy as np
  from seqeval.metrics import classification_report, fa_score, precision_score, recall_score
  from utils_ner import Split, TFTokenClassificationDataset, TokenClassificationTask
  
  from transformers import (
      AutoConfig,
      AutoTokenizer,
      EvalPrediction,
      HfArgumentParser,
      TFAutoModelForTokenClassification,
      TFTrainer,
      TFTrainingArguments,
  )
  from transformers.utils import logging as hf_logging
  
  
  hf_logging.set_verbosity_info()
  hf_logging.enable_default_handler()
  hf_logging.enable_explicit_format()
  
  
  lowerCAmelCase_   =   logging.getLogger(__name__)
  
  @dataclass
  class 				A    :
        _SCREAMING_SNAKE_CASE					=							field(
            metadata={"""help""": """Path to pretrained model or model identifier from huggingface.co/models"""}				)
        _SCREAMING_SNAKE_CASE					=							field(
            default=__UpperCAmelCase       ,metadata={"""help""": """Pretrained config name or path if not the same as model_name"""}				)
        _SCREAMING_SNAKE_CASE					=							field(
            default="""NER"""       ,metadata={"""help""": """Task type to fine tune in training (e.g. NER, POS, etc)"""}				)
        _SCREAMING_SNAKE_CASE					=							field(
            default=__UpperCAmelCase       ,metadata={"""help""": """Pretrained tokenizer name or path if not the same as model_name"""}				)
        _SCREAMING_SNAKE_CASE					=							field(default=__UpperCAmelCase       ,metadata={"""help""": """Set this flag to use fast tokenization."""}				)
        # If you want to tweak more attributes on your tokenizer, you should do it in a distinct script,
        # or just modify its tokenizer_config.json.
        _SCREAMING_SNAKE_CASE					=							field(
            default=__UpperCAmelCase       ,metadata={"""help""": """Where do you want to store the pretrained models downloaded from huggingface.co"""}       ,)
  
  
  @dataclass
  class 				A    :
        _SCREAMING_SNAKE_CASE					=							field(
            metadata={"""help""": """The input data dir. Should contain the .txt files for a CoNLL-2003-formatted task."""}				)
        _SCREAMING_SNAKE_CASE					=							field(
            metadata={"""help""": """Path to a file containing all labels. If not specified, CoNLL-2003 labels are used."""}				)
        _SCREAMING_SNAKE_CASE					=							field(
            default=128       ,metadata={
                """help""": (
                    """The maximum total input sequence length after tokenization. Sequences longer """
                    """than this will be truncated, sequences shorter will be padded."""
                )
            }       ,)
        _SCREAMING_SNAKE_CASE					=							field(
            default=__UpperCAmelCase       ,metadata={"""help""": """Overwrite the cached training and evaluation sets"""}				)
  
  
  
  
  def 						A_			(  )			->						str:
         # See all possible arguments in src/transformers/training_args.py
         # or by passing the --help flag to this script.
         # We now keep distinct sets of args, for a cleaner separation of concerns.
         _snake_case      :							Any     				=						HfArgumentParser((ModelArguments, DataTrainingArguments, TFTrainingArguments)  )
         _snake_case      :							List[Any]     				=						parser.parse_args_into_dataclasses()
  
         if (
             os.path.exists(training_args.output_dir  )
             and os.listdir(training_args.output_dir  )
             and training_args.do_train
             and not training_args.overwrite_output_dir
         ):
                raise ValueError(
                    f'''Output directory ({training_args.output_dir}) already exists and is not empty. Use'''
                    ''' --overwrite_output_dir to overcome.'''  )
  
         _snake_case      :							Optional[Any]     				=						import_module('''tasks'''  )
  
         try:
                _snake_case      :							List[Any]     				=						getattr(lowercase_      ,		model_args.task_type  )
                _snake_case      :							TokenClassificationTask     				=						token_classification_task_clazz()
         except AttributeError:
                raise ValueError(
                    f'''Task {model_args.task_type} needs to be defined as a TokenClassificationTask subclass in {module}. '''
                    f'''Available tasks classes are: {TokenClassificationTask.__subclasses__()}'''  )
  
         # Setup logging
         logging.basicConfig(
             format='''%(asctime)s - %(levelname)s - %(name)s - %(message)s'''      ,		datefmt='''%m/%d/%Y %H:%M:%S'''      ,		level=logging.INFO      ,		)
         logger.info(
             '''n_replicas: %s, distributed training: %s, 16-bits training: %s'''      ,		training_args.n_replicas      ,		bool(training_args.n_replicas > 1  )      ,		training_args.fpaa      ,		)
         logger.info('''Training/evaluation parameters %s'''      ,		lowercase_  )
  
         # Prepare Token Classification task
         _snake_case      :							Optional[int]     				=						token_classification_task.get_labels(data_args.labels  )
         _snake_case      :							Dict[int, str]     				=						dict(enumerate(lowercase_  )  )
         _snake_case      :							Any     				=						len(lowercase_  )
  
         # Load pretrained model and tokenizer
         #
         # Distributed training:
         # The .from_pretrained methods guarantee that only one local process can concurrently
         # download model & vocab.
  
         _snake_case      :							Dict     				=						AutoConfig.from_pretrained(
             model_args.config_name if model_args.config_name else model_args.model_name_or_path      ,		num_labels=lowercase_      ,		idalabel=lowercase_      ,		labelaid={label: i for i, label in enumerate(lowercase_  )}      ,		cache_dir=model_args.cache_dir      ,		)
         _snake_case      :							Optional[int]     				=						AutoTokenizer.from_pretrained(
             model_args.tokenizer_name if model_args.tokenizer_name else model_args.model_name_or_path      ,		cache_dir=model_args.cache_dir      ,		use_fast=model_args.use_fast      ,		)
  
         with training_args.strategy.scope():
                _snake_case      :							List[str]     				=						TFAutoModelForTokenClassification.from_pretrained(
                    model_args.model_name_or_path      ,		from_pt=bool('''.bin''' in model_args.model_name_or_path  )      ,		config=lowercase_      ,		cache_dir=model_args.cache_dir      ,		)
  
         # Get datasets
         _snake_case      :							Dict     				=						(
             TFTokenClassificationDataset(
                 token_classification_task=lowercase_      ,		data_dir=data_args.data_dir      ,		tokenizer=lowercase_      ,		labels=lowercase_      ,		model_type=config.model_type      ,		max_seq_length=data_args.max_seq_length      ,		overwrite_cache=data_args.overwrite_cache      ,		mode=Split.train      ,		)
             if training_args.do_train
             else None
         )
         _snake_case      :							List[Any]     				=						(
             TFTokenClassificationDataset(
                 token_classification_task=lowercase_      ,		data_dir=data_args.data_dir      ,		tokenizer=lowercase_      ,		labels=lowercase_      ,		model_type=config.model_type      ,		max_seq_length=data_args.max_seq_length      ,		overwrite_cache=data_args.overwrite_cache      ,		mode=Split.dev      ,		)
             if training_args.do_eval
             else None
         )
  
         def align_predictions(lowercase_      ,		lowercase_  ) -> Tuple[List[int], List[int]]:
                _snake_case      :							str     				=						np.argmax(lowercase_      ,		axis=2  )
                _snake_case      :							Optional[int]     				=						preds.shape
                _snake_case      :							Any     				=						[[] for _ in range(lowercase_  )]
                _snake_case      :							List[str]     				=						[[] for _ in range(lowercase_  )]
  
                for i in range(lowercase_  ):
                       for j in range(lowercase_  ):
                              if label_ids[i, j] != -100:
                                     out_label_list[i].append(label_map[label_ids[i][j]]  )
                                     preds_list[i].append(label_map[preds[i][j]]  )
  
                return preds_list, out_label_list
  
         def compute_metrics(lowercase_  ) -> Dict:
                _snake_case      :							Tuple     				=						align_predictions(p.predictions      ,		p.label_ids  )
  
                return {
                    "precision": precision_score(lowercase_      ,		lowercase_  ),
                    "recall": recall_score(lowercase_      ,		lowercase_  ),
                    "f1": fa_score(lowercase_      ,		lowercase_  ),
                }
  
         # Initialize our Trainer
         _snake_case      :							Dict     				=						TFTrainer(
             model=lowercase_      ,		args=lowercase_      ,		train_dataset=train_dataset.get_dataset() if train_dataset else None      ,		eval_dataset=eval_dataset.get_dataset() if eval_dataset else None      ,		compute_metrics=lowercase_      ,		)
  
         # Training
         if training_args.do_train:
                trainer.train()
                trainer.save_model()
                tokenizer.save_pretrained(training_args.output_dir  )
  
         # Evaluation
         _snake_case      :							str     				=						{}
         if training_args.do_eval:
                logger.info('''*** Evaluate ***'''  )
  
                _snake_case      :							List[str]     				=						trainer.evaluate()
                _snake_case      :							Optional[Any]     				=						os.path.join(training_args.output_dir      ,		'''eval_results.txt'''  )
  
                with open(lowercase_      ,		'''w'''  ) as writer:
                       logger.info('''***** Eval results *****'''  )
  
                       for key, value in result.items():
                              logger.info('''  %s = %s'''      ,		lowercase_      ,		lowercase_  )
                              writer.write('''%s = %s\n''' % (key, value)  )
  
                       results.update(lowercase_  )
  
      # Predict
         if training_args.do_predict:
                _snake_case      :							Union[str, Any]     				=						TFTokenClassificationDataset(
                    token_classification_task=lowercase_      ,		data_dir=data_args.data_dir      ,		tokenizer=lowercase_      ,		labels=lowercase_      ,		model_type=config.model_type      ,		max_seq_length=data_args.max_seq_length      ,		overwrite_cache=data_args.overwrite_cache      ,		mode=Split.test      ,		)
  
                _snake_case      :							Dict     				=						trainer.predict(test_dataset.get_dataset()  )
                _snake_case      :							List[Any]     				=						align_predictions(lowercase_      ,		lowercase_  )
                _snake_case      :							List[Any]     				=						classification_report(lowercase_      ,		lowercase_  )
  
                logger.info('''\n%s'''      ,		lowercase_  )
  
                _snake_case      :							Any     				=						os.path.join(training_args.output_dir      ,		'''test_results.txt'''  )
  
                with open(lowercase_      ,		'''w'''  ) as writer:
                       writer.write('''%s\n''' % report  )
  
                # Save predictions
                _snake_case      :							Union[str, Any]     				=						os.path.join(training_args.output_dir      ,		'''test_predictions.txt'''  )
  
                with open(lowercase_      ,		'''w'''  ) as writer:
                       with open(os.path.join(data_args.data_dir      ,		'''test.txt'''  )      ,		'''r'''  ) as f:
                              _snake_case      :							List[str]     				=						0
  
                              for line in f:
                                     if line.startswith('''-DOCSTART-'''  ) or line == "" or line == "\n":
                                            writer.write(lowercase_  )
  
                                            if not preds_list[example_id]:
                                                   example_id += 1
                                     elif preds_list[example_id]:
                                            _snake_case      :							Any     				=						line.split()[0] + ''' ''' + preds_list[example_id].pop(0  ) + '''\n'''
  
                                            writer.write(lowercase_  )
                                     else:
                                            logger.warning('''Maximum sequence length exceeded: No prediction for \'%s\'.'''      ,		line.split()[0]  )
  
         return results
  
  
  if __name__ == "__main__":
         main()
  
  
  
  
  
  
  
style_context: 
  
  
  
  
  
  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 				A    :
  
  
  
        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     ,  )      ->   Optional[int]:
  
  
  
               '''simple docstring'''
  
               _snake_case      :							Union[str, Any]     				=						parent
               _snake_case      :							List[str]     				=						batch_size
               _snake_case      :							str     				=						seq_length
               _snake_case      :							str     				=						is_training
               _snake_case      :							Optional[Any]     				=						use_input_mask
               _snake_case      :							Any     				=						use_token_type_ids
               _snake_case      :							str     				=						use_labels
               _snake_case      :							int     				=						vocab_size
               _snake_case      :							Tuple     				=						hidden_size
               _snake_case      :							str     				=						num_hidden_layers
               _snake_case      :							str     				=						num_attention_heads
               _snake_case      :							Optional[int]     				=						intermediate_size
               _snake_case      :							Tuple     				=						hidden_act
               _snake_case      :							Any     				=						hidden_dropout_prob
               _snake_case      :							Tuple     				=						attention_probs_dropout_prob
               _snake_case      :							str     				=						max_position_embeddings
               _snake_case      :							List[Any]     				=						type_vocab_size
               _snake_case      :							str     				=						type_sequence_label_size
               _snake_case      :							Any     				=						initializer_range
               _snake_case      :							Optional[Any]     				=						num_labels
               _snake_case      :							Union[str, Any]     				=						scope
               _snake_case      :							int     				=						max_xpath_tag_unit_embeddings
               _snake_case      :							Any     				=						max_xpath_subs_unit_embeddings
               _snake_case      :							Union[str, Any]     				=						tag_pad_id
               _snake_case      :							Union[str, Any]     				=						subs_pad_id
               _snake_case      :							int     				=						max_depth
  
  
  
        def    __a (					self					)      ->   Tuple:
  
  
  
               '''simple docstring'''
  
               _snake_case      :							List[Any]     				=						ids_tensor([self.batch_size, self.seq_length]     ,  self.vocab_size					)
  
               _snake_case      :							Any     				=						ids_tensor(
                   [self.batch_size, self.seq_length, self.max_depth]     ,  self.max_xpath_tag_unit_embeddings					)
  
               _snake_case      :							Tuple     				=						ids_tensor(
                   [self.batch_size, self.seq_length, self.max_depth]     ,  self.max_xpath_subs_unit_embeddings					)
  
               _snake_case      :							Optional[int]     				=						None
               if self.use_input_mask:
                      _snake_case      :							Optional[int]     				=						ids_tensor([self.batch_size, self.seq_length]     ,  vocab_size=2					)
  
               _snake_case      :							int     				=						None
               if self.use_token_type_ids:
                      _snake_case      :							List[Any]     				=						ids_tensor([self.batch_size, self.seq_length]     ,  self.type_vocab_size					)
  
               _snake_case      :							List[Any]     				=						None
               _snake_case      :							int     				=						None
               if self.use_labels:
                      _snake_case      :							Optional[int]     				=						ids_tensor([self.batch_size]     ,  self.type_sequence_label_size					)
                      _snake_case      :							Optional[int]     				=						ids_tensor([self.batch_size, self.seq_length]     ,  self.num_labels					)
  
               _snake_case      :							Tuple     				=						self.get_config()
  
               return (
                   config,
                   input_ids,
                   xpath_tags_seq,
                   xpath_subs_seq,
                   token_type_ids,
                   input_mask,
                   sequence_labels,
                   token_labels,
               )
  
  
  
        def    __a (					self					)      ->   Tuple:
  
  
  
               '''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    __a (					self     ,  lowercase_     ,  lowercase_     ,  lowercase_     ,  lowercase_     ,  lowercase_     ,  lowercase_     ,  lowercase_     ,  lowercase_     ,  )      ->   Optional[Any]:
  
  
  
               '''simple docstring'''
  
               _snake_case      :							Optional[Any]     				=						MarkupLMModel(config=lowercase_					)
               model.to(lowercase_					)
               model.eval()
               print('''Configs:'''     ,  model.config.tag_pad_id     ,  model.config.subs_pad_id					)
               _snake_case      :							int     				=						model(lowercase_     ,  attention_mask=lowercase_     ,  token_type_ids=lowercase_					)
               _snake_case      :							Dict     				=						model(lowercase_     ,  token_type_ids=lowercase_					)
               _snake_case      :							str     				=						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    __a (					self     ,  lowercase_     ,  lowercase_     ,  lowercase_     ,  lowercase_     ,  lowercase_     ,  lowercase_     ,  lowercase_     ,  lowercase_     ,  )      ->   Any:
  
  
  
               '''simple docstring'''
  
               _snake_case      :							Optional[Any]     				=						self.num_labels
               _snake_case      :							List[str]     				=						MarkupLMForSequenceClassification(lowercase_					)
               model.to(lowercase_					)
               model.eval()
               _snake_case      :							Optional[int]     				=						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    __a (					self     ,  lowercase_     ,  lowercase_     ,  lowercase_     ,  lowercase_     ,  lowercase_     ,  lowercase_     ,  lowercase_     ,  lowercase_     ,  )      ->   Optional[Any]:
  
  
  
               '''simple docstring'''
  
               _snake_case      :							List[Any]     				=						self.num_labels
               _snake_case      :							Dict     				=						MarkupLMForTokenClassification(config=lowercase_					)
               model.to(lowercase_					)
               model.eval()
               _snake_case      :							List[str]     				=						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    __a (					self     ,  lowercase_     ,  lowercase_     ,  lowercase_     ,  lowercase_     ,  lowercase_     ,  lowercase_     ,  lowercase_     ,  lowercase_     ,  )      ->   Tuple:
  
  
  
               '''simple docstring'''
  
               _snake_case      :							Optional[int]     				=						MarkupLMForQuestionAnswering(config=lowercase_					)
               model.to(lowercase_					)
               model.eval()
               _snake_case      :							Optional[int]     				=						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    __a (					self					)      ->   Optional[Any]:
  
  
  
               '''simple docstring'''
  
               _snake_case      :							Optional[int]     				=						self.prepare_config_and_inputs()
               (
                   (
                   _snake_case
               )				,    (
                   _snake_case
               )				,    (
                   _snake_case
               )				,    (
                   _snake_case
               )				,    (
                   _snake_case
               )				,    (
                   _snake_case
               )				,    (
                   _snake_case
               )				,    (
                   _snake_case
               )				,    
               )      :							Tuple     				=						config_and_inputs
               _snake_case      :							str     				=						{
                   '''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 				A    (__UpperCAmelCase       ,__UpperCAmelCase       ,unittest.TestCase				):
        _SCREAMING_SNAKE_CASE					=							(
            (
                MarkupLMModel,
                MarkupLMForSequenceClassification,
                MarkupLMForTokenClassification,
                MarkupLMForQuestionAnswering,
            )
            if is_torch_available()
            else None
        )
        _SCREAMING_SNAKE_CASE					=							(
            {
                """feature-extraction""": MarkupLMModel,
                """question-answering""": MarkupLMForQuestionAnswering,
                """text-classification""": MarkupLMForSequenceClassification,
                """token-classification""": MarkupLMForTokenClassification,
                """zero-shot""": MarkupLMForSequenceClassification,
            }
            if is_torch_available()
            else {}
        )
  
  
  
        def    __a (					self     ,  lowercase_     ,  lowercase_     ,  lowercase_     ,  lowercase_     ,  lowercase_					)      ->   List[str]:
  
  
  
               '''simple docstring'''
  
               return True
  
  
  
        def    __a (					self					)      ->   Optional[Any]:
  
  
  
               '''simple docstring'''
  
               _snake_case      :							Any     				=						MarkupLMModelTester(self					)
               _snake_case      :							Dict     				=						ConfigTester(self     ,  config_class=lowercase_     ,  hidden_size=37					)
  
  
  
        def    __a (					self					)      ->   Optional[int]:
  
  
  
               '''simple docstring'''
  
               self.config_tester.run_common_tests()
  
  
  
        def    __a (					self					)      ->   List[Any]:
  
  
  
               '''simple docstring'''
  
               _snake_case      :							Union[str, Any]     				=						self.model_tester.prepare_config_and_inputs()
               self.model_tester.create_and_check_model(*lowercase_					)
  
  
  
        def    __a (					self					)      ->   Optional[Any]:
  
  
  
               '''simple docstring'''
  
               _snake_case      :							Optional[int]     				=						self.model_tester.prepare_config_and_inputs()
               self.model_tester.create_and_check_for_sequence_classification(*lowercase_					)
  
  
  
        def    __a (					self					)      ->   Any:
  
  
  
               '''simple docstring'''
  
               _snake_case      :							Optional[Any]     				=						self.model_tester.prepare_config_and_inputs()
               self.model_tester.create_and_check_for_token_classification(*lowercase_					)
  
  
  
        def    __a (					self					)      ->   str:
  
  
  
               '''simple docstring'''
  
               _snake_case      :							Optional[int]     				=						self.model_tester.prepare_config_and_inputs()
               self.model_tester.create_and_check_for_question_answering(*lowercase_					)
  
  
  
  
  def 						A_			(  )			->						Any:
         _snake_case      :							Tuple     				=						'''
      <!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 				A    (unittest.TestCase				):
  
  
  
        @cached_property
        def    __a (					self					)      ->   int:
  
  
  
               '''simple docstring'''
  
               _snake_case      :							List[str]     				=						MarkupLMFeatureExtractor()
               _snake_case      :							Any     				=						MarkupLMTokenizer.from_pretrained('''microsoft/markuplm-base'''					)
  
               return MarkupLMProcessor(lowercase_     ,  lowercase_					)
  
  
  
        @slow
        def    __a (					self					)      ->   Optional[int]:
  
  
  
               '''simple docstring'''
  
               _snake_case      :							Any     				=						MarkupLMModel.from_pretrained('''microsoft/markuplm-base'''					).to(lowercase_					)
  
               _snake_case      :							Tuple     				=						self.default_processor
  
               _snake_case      :							Union[str, Any]     				=						processor(prepare_html_string()     ,  return_tensors='''pt'''					)
               _snake_case      :							List[Any]     				=						inputs.to(lowercase_					)
  
               # forward pass
               with torch.no_grad():
                      _snake_case      :							List[str]     				=						model(**lowercase_					)
  
               # verify the last hidden states
               _snake_case      :							Union[str, Any]     				=						torch.Size([1, 14, 768]					)
               self.assertEqual(outputs.last_hidden_state.shape     ,  lowercase_					)
  
               _snake_case      :							List[str]     				=						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					)					)
  
  
  
  
  
  
  