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        lowercase_				:
  
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  
  
  
  
  							def __init__(   self			,    _UpperCAmelCase			,    _UpperCAmelCase=13			,    _UpperCAmelCase=7			,    _UpperCAmelCase=True			,    _UpperCAmelCase=True			,    _UpperCAmelCase=True			,    _UpperCAmelCase=True			,    _UpperCAmelCase=99			,    _UpperCAmelCase=32			,    _UpperCAmelCase=5			,    _UpperCAmelCase=4			,    _UpperCAmelCase=37			,    _UpperCAmelCase="gelu"			,    _UpperCAmelCase=0.1			,    _UpperCAmelCase=0.1			,    _UpperCAmelCase=512			,    _UpperCAmelCase=16			,    _UpperCAmelCase=2			,    _UpperCAmelCase=0.0_2			,    _UpperCAmelCase=3			,    _UpperCAmelCase=None			,    _UpperCAmelCase=20			,    _UpperCAmelCase=30			,    _UpperCAmelCase=2			,    _UpperCAmelCase=2			,    _UpperCAmelCase=10			,    ):
  
  
  
  
  
  
  
  													"""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 						lowercase__     (   self		):
  
  
  
  
  
  
  
  													"""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 						lowercase__     (   self		):
  
  
  
  
  
  
  
  													"""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 						lowercase__     (   self			,    _UpperCAmelCase			,    _UpperCAmelCase			,    _UpperCAmelCase			,    _UpperCAmelCase			,    _UpperCAmelCase			,    _UpperCAmelCase			,    _UpperCAmelCase			,    _UpperCAmelCase			,    ):
  
  
  
  
  
  
  
  													"""simple docstring"""
  
  
  													a_					=		MarkupLMModel(config=_UpperCAmelCase		)
  													model.to(_UpperCAmelCase		)
  													model.eval()
  													print("""Configs:"""			,    model.config.tag_pad_id			,    model.config.subs_pad_id		)
  													a_					=		model(_UpperCAmelCase			,    attention_mask=_UpperCAmelCase			,    token_type_ids=_UpperCAmelCase		)
  													a_					=		model(_UpperCAmelCase			,    token_type_ids=_UpperCAmelCase		)
  													a_					=		model(_UpperCAmelCase		)
  													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 						lowercase__     (   self			,    _UpperCAmelCase			,    _UpperCAmelCase			,    _UpperCAmelCase			,    _UpperCAmelCase			,    _UpperCAmelCase			,    _UpperCAmelCase			,    _UpperCAmelCase			,    _UpperCAmelCase			,    ):
  
  
  
  
  
  
  
  													"""simple docstring"""
  
  
  													a_					=		self.num_labels
  													a_					=		MarkupLMForSequenceClassification(_UpperCAmelCase		)
  													model.to(_UpperCAmelCase		)
  													model.eval()
  													a_					=		model(
  													    _UpperCAmelCase			,    xpath_tags_seq=_UpperCAmelCase			,    xpath_subs_seq=_UpperCAmelCase			,    attention_mask=_UpperCAmelCase			,    token_type_ids=_UpperCAmelCase			,    labels=_UpperCAmelCase			,    )
  													self.parent.assertEqual(result.logits.shape			,    (self.batch_size, self.num_labels)		)
  
  
  							def 						lowercase__     (   self			,    _UpperCAmelCase			,    _UpperCAmelCase			,    _UpperCAmelCase			,    _UpperCAmelCase			,    _UpperCAmelCase			,    _UpperCAmelCase			,    _UpperCAmelCase			,    _UpperCAmelCase			,    ):
  
  
  
  
  
  
  
  													"""simple docstring"""
  
  
  													a_					=		self.num_labels
  													a_					=		MarkupLMForTokenClassification(config=_UpperCAmelCase		)
  													model.to(_UpperCAmelCase		)
  													model.eval()
  													a_					=		model(
  													    _UpperCAmelCase			,    xpath_tags_seq=_UpperCAmelCase			,    xpath_subs_seq=_UpperCAmelCase			,    attention_mask=_UpperCAmelCase			,    token_type_ids=_UpperCAmelCase			,    labels=_UpperCAmelCase			,    )
  													self.parent.assertEqual(result.logits.shape			,    (self.batch_size, self.seq_length, self.num_labels)		)
  
  
  							def 						lowercase__     (   self			,    _UpperCAmelCase			,    _UpperCAmelCase			,    _UpperCAmelCase			,    _UpperCAmelCase			,    _UpperCAmelCase			,    _UpperCAmelCase			,    _UpperCAmelCase			,    _UpperCAmelCase			,    ):
  
  
  
  
  
  
  
  													"""simple docstring"""
  
  
  													a_					=		MarkupLMForQuestionAnswering(config=_UpperCAmelCase		)
  													model.to(_UpperCAmelCase		)
  													model.eval()
  													a_					=		model(
  													    _UpperCAmelCase			,    xpath_tags_seq=_UpperCAmelCase			,    xpath_subs_seq=_UpperCAmelCase			,    attention_mask=_UpperCAmelCase			,    token_type_ids=_UpperCAmelCase			,    start_positions=_UpperCAmelCase			,    end_positions=_UpperCAmelCase			,    )
  													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 						lowercase__     (   self		):
  
  
  
  
  
  
  
  													"""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        lowercase_				( UpperCamelCase__			,UpperCamelCase__			,unittest.TestCase):
  
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  
  
  
  
  							snake_case_        =		(
  							    (
  							        MarkupLMModel,
  							        MarkupLMForSequenceClassification,
  							        MarkupLMForTokenClassification,
  							        MarkupLMForQuestionAnswering,
  							    )
  							    if is_torch_available()
  							    else None
  							)
  							snake_case_        =		(
  							    {
  							        '''feature-extraction''': MarkupLMModel,
  							        '''question-answering''': MarkupLMForQuestionAnswering,
  							        '''text-classification''': MarkupLMForSequenceClassification,
  							        '''token-classification''': MarkupLMForTokenClassification,
  							        '''zero-shot''': MarkupLMForSequenceClassification,
  							    }
  							    if is_torch_available()
  							    else {}
  							)
  
  
  							def 						lowercase__     (   self			,    _UpperCAmelCase			,    _UpperCAmelCase			,    _UpperCAmelCase			,    _UpperCAmelCase			,    _UpperCAmelCase		):
  
  
  
  
  
  
  
  													"""simple docstring"""
  
  
  													return True
  
  
  							def 						lowercase__     (   self		):
  
  
  
  
  
  
  
  													"""simple docstring"""
  
  
  													a_					=		MarkupLMModelTester(self		)
  													a_					=		ConfigTester(self			,    config_class=_UpperCAmelCase			,    hidden_size=37		)
  
  
  							def 						lowercase__     (   self		):
  
  
  
  
  
  
  
  													"""simple docstring"""
  
  
  													self.config_tester.run_common_tests()
  
  
  							def 						lowercase__     (   self		):
  
  
  
  
  
  
  
  													"""simple docstring"""
  
  
  													a_					=		self.model_tester.prepare_config_and_inputs()
  													self.model_tester.create_and_check_model(*_UpperCAmelCase		)
  
  
  							def 						lowercase__     (   self		):
  
  
  
  
  
  
  
  													"""simple docstring"""
  
  
  													a_					=		self.model_tester.prepare_config_and_inputs()
  													self.model_tester.create_and_check_for_sequence_classification(*_UpperCAmelCase		)
  
  
  							def 						lowercase__     (   self		):
  
  
  
  
  
  
  
  													"""simple docstring"""
  
  
  													a_					=		self.model_tester.prepare_config_and_inputs()
  													self.model_tester.create_and_check_for_token_classification(*_UpperCAmelCase		)
  
  
  
  
  
  
  							def 						lowercase__     (   self		):
  
  
  
  
  
  
  
  													"""simple docstring"""
  
  
  													a_					=		self.model_tester.prepare_config_and_inputs()
  													self.model_tester.create_and_check_for_question_answering(*_UpperCAmelCase		)
  
  
  
  
  def   lowerCamelCase_       (					):
  
  
  
  						"""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        lowercase_				( unittest.TestCase):
  
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  
  
  
  
  							@cached_property
  							def 						lowercase__     (   self		):
  
  
  
  
  
  
  
  													"""simple docstring"""
  
  
  													a_					=		MarkupLMFeatureExtractor()
  													a_					=		MarkupLMTokenizer.from_pretrained("""microsoft/markuplm-base"""		)
  
  													return MarkupLMProcessor(_UpperCAmelCase			,    _UpperCAmelCase		)
  
  
  
  
  
  
  							@slow
  							def 						lowercase__     (   self		):
  
  
  
  
  
  
  
  													"""simple docstring"""
  
  
  													a_					=		MarkupLMModel.from_pretrained("""microsoft/markuplm-base"""		).to(_UpperCAmelCase		)
  
  													a_					=		self.default_processor
  
  													a_					=		processor(prepare_html_string()			,    return_tensors="""pt"""		)
  													a_					=		inputs.to(_UpperCAmelCase		)
  
  													# forward pass
  													with torch.no_grad():
  																			a_					=		model(**_UpperCAmelCase		)
  
  													# verify the last hidden states
  													a_					=		torch.Size([1, 14, 768]		)
  													self.assertEqual(outputs.last_hidden_state.shape			,    _UpperCAmelCase		)
  
  													a_					=		torch.tensor(
  													    [[0.0_6_7_5, -0.0_0_5_2, 0.5_0_0_1], [-0.2_2_8_1, 0.0_8_0_2, 0.2_1_9_2], [-0.0_5_8_3, -0.3_3_1_1, 0.1_1_8_5]]		).to(_UpperCAmelCase		)
  
  													self.assertTrue(torch.allclose(outputs.last_hidden_state[0, :3, :3]			,    _UpperCAmelCase			,    atol=1e-4		)		)
style_context: 
  
  
  import importlib
  import sys
  from argparse import REMAINDER, ArgumentParser
  from pathlib import Path
  
  import torch_xla.distributed.xla_multiprocessing as xmp
  
  
  
  
  def   lowerCamelCase_       (					):
  
  
  
  						"""simple docstring"""
  
  
  
  
  						a_					=		ArgumentParser(
  						    description=(
  						        """PyTorch TPU distributed training launch helper utility that will spawn up multiple distributed processes"""
  						    )      )
  
  						# Optional arguments for the launch helper
  						parser.add_argument("""--num_cores"""       ,    type=UpperCAmelCase__       ,    default=1       ,    help="""Number of TPU cores to use (1 or 8)."""      )
  
  						# positional
  						parser.add_argument(
  						    """training_script"""       ,    type=UpperCAmelCase__       ,    help=(
  						        """The full path to the single TPU training """
  						        """program/script to be launched in parallel, """
  						        """followed by all the arguments for the """
  						        """training script"""
  						    )       ,    )
  
  						# rest from the training program
  						parser.add_argument("""training_script_args"""       ,    nargs=UpperCAmelCase__      )
  
  						return parser.parse_args()
  
  
  
  
  def   lowerCamelCase_       (					):
  
  
  
  						"""simple docstring"""
  
  
  
  
  						a_					=		parse_args()
  
  						# Import training_script as a module.
  						a_					=		Path(args.training_script      )
  						sys.path.append(str(script_fpath.parent.resolve()      )      )
  						a_					=		script_fpath.stem
  						a_					=		importlib.import_module(UpperCAmelCase__      )
  
  						# Patch sys.argv
  						a_					=		[args.training_script] + args.training_script_args + ["""--tpu_num_cores""", str(args.num_cores      )]
  
  						xmp.spawn(mod._mp_fn       ,    args=()       ,    nprocs=args.num_cores      )
  
  
  if __name__ == "__main__":
  	main()