






"""simple docstring"""







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       ,  snake_case__       ,  snake_case__=13       ,  snake_case__=7       ,  snake_case__=True       ,  snake_case__=True       ,  snake_case__=True       ,  snake_case__=True       ,  snake_case__=99       ,  snake_case__=32       ,  snake_case__=5       ,  snake_case__=4       ,  snake_case__=37       ,  snake_case__="gelu"       ,  snake_case__=0.1       ,  snake_case__=0.1       ,  snake_case__=512       ,  snake_case__=16       ,  snake_case__=2       ,  snake_case__=0.02       ,  snake_case__=3       ,  snake_case__=None       ,  snake_case__=20       ,  snake_case__=30       ,  snake_case__=2       ,  snake_case__=2       ,  snake_case__=10       ,  ):
												'''simple docstring'''
												lowercase__				:      Optional[int]=       parent
												lowercase__				:      int=       batch_size
												lowercase__				:      Optional[int]=       seq_length
												lowercase__				:      Tuple=       is_training
												lowercase__				:      List[Any]=       use_input_mask
												lowercase__				:      List[Any]=       use_token_type_ids
												lowercase__				:      Optional[int]=       use_labels
												lowercase__				:      str=       vocab_size
												lowercase__				:      Optional[int]=       hidden_size
												lowercase__				:      Any=       num_hidden_layers
												lowercase__				:      Tuple=       num_attention_heads
												lowercase__				:      int=       intermediate_size
												lowercase__				:      List[str]=       hidden_act
												lowercase__				:      Dict=       hidden_dropout_prob
												lowercase__				:      int=       attention_probs_dropout_prob
												lowercase__				:      str=       max_position_embeddings
												lowercase__				:      Optional[Any]=       type_vocab_size
												lowercase__				:      Union[str, Any]=       type_sequence_label_size
												lowercase__				:      Dict=       initializer_range
												lowercase__				:      Any=       num_labels
												lowercase__				:      Optional[Any]=       scope
												lowercase__				:      List[str]=       max_xpath_tag_unit_embeddings
												lowercase__				:      str=       max_xpath_subs_unit_embeddings
												lowercase__				:      List[Any]=       tag_pad_id
												lowercase__				:      int=       subs_pad_id
												lowercase__				:      int=       max_depth




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												lowercase__				:      int=       ids_tensor([self.batch_size, self.seq_length]       ,  self.vocab_size			)

												lowercase__				:      Union[str, Any]=       ids_tensor(
												    [self.batch_size, self.seq_length, self.max_depth]       ,  self.max_xpath_tag_unit_embeddings			)

												lowercase__				:      List[Any]=       ids_tensor(
												    [self.batch_size, self.seq_length, self.max_depth]       ,  self.max_xpath_subs_unit_embeddings			)

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

												lowercase__				:      str=       None
												if self.use_token_type_ids:
																		lowercase__				:      Union[str, Any]=       ids_tensor([self.batch_size, self.seq_length]       ,  self.type_vocab_size			)

												lowercase__				:      Union[str, Any]=       None
												lowercase__				:      int=       None
												if self.use_labels:
																		lowercase__				:      List[str]=       ids_tensor([self.batch_size]       ,  self.type_sequence_label_size			)
																		lowercase__				:      Union[str, Any]=       ids_tensor([self.batch_size, self.seq_length]       ,  self.num_labels			)

												lowercase__				:      Any=       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			):
												'''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       ,  snake_case__       ,  snake_case__       ,  snake_case__       ,  snake_case__       ,  snake_case__       ,  snake_case__       ,  snake_case__       ,  snake_case__       ,  ):
												'''simple docstring'''
												lowercase__				:      Any=       MarkupLMModel(config=snake_case__			)
												model.to(snake_case__			)
												model.eval()
												print("Configs:"       ,  model.config.tag_pad_id       ,  model.config.subs_pad_id			)
												lowercase__				:      List[str]=       model(snake_case__       ,  attention_mask=snake_case__       ,  token_type_ids=snake_case__			)
												lowercase__				:      Union[str, Any]=       model(snake_case__       ,  token_type_ids=snake_case__			)
												lowercase__				:      Any=       model(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       ,  snake_case__       ,  snake_case__       ,  snake_case__       ,  snake_case__       ,  snake_case__       ,  snake_case__       ,  snake_case__       ,  snake_case__       ,  ):
												'''simple docstring'''
												lowercase__				:      int=       self.num_labels
												lowercase__				:      Optional[int]=       MarkupLMForSequenceClassification(snake_case__			)
												model.to(snake_case__			)
												model.eval()
												lowercase__				:      int=       model(
												    snake_case__       ,  xpath_tags_seq=snake_case__       ,  xpath_subs_seq=snake_case__       ,  attention_mask=snake_case__       ,  token_type_ids=snake_case__       ,  labels=snake_case__       ,  )
												self.parent.assertEqual(result.logits.shape       ,  (self.batch_size, self.num_labels)			)




						def 		UpperCAmelCase_       (   self       ,  snake_case__       ,  snake_case__       ,  snake_case__       ,  snake_case__       ,  snake_case__       ,  snake_case__       ,  snake_case__       ,  snake_case__       ,  ):
												'''simple docstring'''
												lowercase__				:      Union[str, Any]=       self.num_labels
												lowercase__				:      int=       MarkupLMForTokenClassification(config=snake_case__			)
												model.to(snake_case__			)
												model.eval()
												lowercase__				:      Dict=       model(
												    snake_case__       ,  xpath_tags_seq=snake_case__       ,  xpath_subs_seq=snake_case__       ,  attention_mask=snake_case__       ,  token_type_ids=snake_case__       ,  labels=snake_case__       ,  )
												self.parent.assertEqual(result.logits.shape       ,  (self.batch_size, self.seq_length, self.num_labels)			)




						def 		UpperCAmelCase_       (   self       ,  snake_case__       ,  snake_case__       ,  snake_case__       ,  snake_case__       ,  snake_case__       ,  snake_case__       ,  snake_case__       ,  snake_case__       ,  ):
												'''simple docstring'''
												lowercase__				:      Optional[Any]=       MarkupLMForQuestionAnswering(config=snake_case__			)
												model.to(snake_case__			)
												model.eval()
												lowercase__				:      int=       model(
												    snake_case__       ,  xpath_tags_seq=snake_case__       ,  xpath_subs_seq=snake_case__       ,  attention_mask=snake_case__       ,  token_type_ids=snake_case__       ,  start_positions=snake_case__       ,  end_positions=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			):
												'''simple docstring'''
												lowercase__				:      int=       self.prepare_config_and_inputs()
												(
												    (
												    lowercase__
												),	(
												    lowercase__
												),	(
												    lowercase__
												),	(
												    lowercase__
												),	(
												    lowercase__
												),	(
												    lowercase__
												),	(
												    lowercase__
												),	(
												    lowercase__
												),	
												)				:      Union[str, Any]=       config_and_inputs
												lowercase__				:      List[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     __UpperCAmelCase(   SCREAMING_SNAKE_CASE__  ,  SCREAMING_SNAKE_CASE__  ,  unittest.TestCase							):




						"""simple docstring"""




						__lowerCamelCase				       =					(
						    (
						        MarkupLMModel,
						        MarkupLMForSequenceClassification,
						        MarkupLMForTokenClassification,
						        MarkupLMForQuestionAnswering,
						    )
						    if is_torch_available()
						    else None
						)
						__lowerCamelCase				       =					(
						    {
						        "feature-extraction": MarkupLMModel,
						        "question-answering": MarkupLMForQuestionAnswering,
						        "text-classification": MarkupLMForSequenceClassification,
						        "token-classification": MarkupLMForTokenClassification,
						        "zero-shot": MarkupLMForSequenceClassification,
						    }
						    if is_torch_available()
						    else {}
						)




						def 		UpperCAmelCase_       (   self       ,  snake_case__       ,  snake_case__       ,  snake_case__       ,  snake_case__       ,  snake_case__			):
												'''simple docstring'''
												# ValueError: Nodes must be of type `List[str]` (single pretokenized example), or `List[List[str]]`
												# (batch of pretokenized examples).
												return True




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												lowercase__				:      str=       MarkupLMModelTester(self			)
												lowercase__				:      Optional[int]=       ConfigTester(self       ,  config_class=snake_case__       ,  hidden_size=37			)




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												self.config_tester.run_common_tests()




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												lowercase__				:      Tuple=       self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_model(*snake_case__			)




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												lowercase__				:      Optional[int]=       self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_sequence_classification(*snake_case__			)




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												lowercase__				:      Any=       self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_token_classification(*snake_case__			)




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												lowercase__				:      Any=       self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_question_answering(*snake_case__			)





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




						"""simple docstring"""



						lowercase__				:      Optional[int]=       "\n    <!DOCTYPE html>\n    <html>\n    <head>\n    <title>Page Title</title>\n    </head>\n    <body>\n\n    <h1>This is a Heading</h1>\n    <p>This is a paragraph.</p>\n\n    </body>\n    </html>\n    "

						return html_string







@require_torch
class     __UpperCAmelCase(   unittest.TestCase							):




						"""simple docstring"""




						@cached_property
						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												# TODO use from_pretrained here
												lowercase__				:      Tuple=       MarkupLMFeatureExtractor()
												lowercase__				:      int=       MarkupLMTokenizer.from_pretrained("microsoft/markuplm-base"			)

												return MarkupLMProcessor(snake_case__       ,  snake_case__			)




						@slow
						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												lowercase__				:      Tuple=       MarkupLMModel.from_pretrained("microsoft/markuplm-base"			).to(snake_case__			)

												lowercase__				:      List[Any]=       self.default_processor

												lowercase__				:      Tuple=       processor(prepare_html_string()       ,  return_tensors="pt"			)
												lowercase__				:      List[Any]=       inputs.to(snake_case__			)

												# forward pass
												with torch.no_grad():
																		lowercase__				:      Optional[Any]=       model(**snake_case__			)

												# verify the last hidden states
												lowercase__				:      Optional[Any]=       torch.Size([1, 14, 768]			)
												self.assertEqual(outputs.last_hidden_state.shape       ,  snake_case__			)

												lowercase__				:      Tuple=       torch.tensor(
												    [[0.06_75, -0.00_52, 0.50_01], [-0.22_81, 0.08_02, 0.21_92], [-0.05_83, -0.33_11, 0.11_85]]			).to(snake_case__			)

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














"""simple docstring"""







import unittest

from transformers import is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device


if is_torch_available():
			import torch

			from transformers import XLMProphetNetForConditionalGeneration, XLMProphetNetTokenizer


@require_torch
class     __UpperCAmelCase(   unittest.TestCase							):




						"""simple docstring"""




						@slow
						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												lowercase__				:      Optional[int]=       XLMProphetNetForConditionalGeneration.from_pretrained("microsoft/xprophetnet-large-wiki100-cased"			)
												model.to(snake_case__			)

												# encoder-decoder outputs
												lowercase__				:      Dict=       torch.tensor([[17, 96208, 103471, 2]]			).to(snake_case__			)
												lowercase__				:      Optional[Any]=       torch.tensor(
												    [[2, 250, 9953, 34, 69489, 1620, 32, 118424, 624, 210, 105, 2913, 1032, 351]]			).to(snake_case__			)
												lowercase__				:      Dict=       model(
												    input_ids=snake_case__       ,  attention_mask=snake_case__       ,  encoder_outputs=snake_case__       ,  decoder_input_ids=snake_case__			)
												lowercase__				:      int=       output[0]
												lowercase__				:      str=       torch.Size((1, 14, 250012)			)
												self.assertEqual(output_predited_logis.shape       ,  snake_case__			)
												lowercase__				:      Union[str, Any]=       torch.tensor(
												    [[[-6.39_86, -8.23_91, 12.51_89], [-6.32_89, -8.08_64, 12.62_11], [-6.24_18, -8.04_45, 12.79_68]]]			).to(snake_case__			)
												self.assertTrue(torch.allclose(output_predited_logis[:, :3, :3]       ,  snake_case__       ,  atol=1e-4			)			)

												# encoder outputs
												lowercase__				:      Tuple=       model.prophetnet.encoder(snake_case__			)[0]
												lowercase__				:      Union[str, Any]=       torch.tensor(
												    [[[-1.42_60, -0.76_28, 0.84_53], [-1.47_19, -0.13_91, 0.78_07], [-1.76_78, 0.01_14, 0.46_46]]]			).to(snake_case__			)
												lowercase__				:      List[Any]=       torch.Size((1, 4, 1024)			)
												self.assertEqual(encoder_outputs.shape       ,  snake_case__			)
												self.assertTrue(torch.allclose(encoder_outputs[:, :3, :3]       ,  snake_case__       ,  atol=1e-4			)			)

												# decoder outputs
												lowercase__				:      int=       model.prophetnet.decoder(
												    snake_case__       ,  encoder_hidden_states=snake_case__       ,  )
												lowercase__				:      Union[str, Any]=       decoder_outputs[1].view(1       ,  model.config.ngram       ,  14       ,  -1			)
												lowercase__				:      List[Any]=       model.lm_head(snake_case__			)
												lowercase__				:      str=       predicting_streams_logits[:, 0]
												self.assertTrue(torch.allclose(next_first_stream_logits[:, :3, :3]       ,  snake_case__       ,  atol=1e-4			)			)




						@slow
						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												lowercase__				:      Union[str, Any]=       XLMProphetNetForConditionalGeneration.from_pretrained(
												    "microsoft/xprophetnet-large-wiki100-cased-xglue-ntg"			)
												model.to(snake_case__			)

												lowercase__				:      Dict=       torch.tensor([[17, 96208, 103471, 2]]			).to(snake_case__			)
												lowercase__				:      List[str]=       torch.tensor(
												    [[2, 250, 9953, 34, 69489, 1620, 32, 118424, 624, 210, 105, 2913, 1032, 351]]			).to(snake_case__			)
												lowercase__				:      List[Any]=       model(
												    input_ids=snake_case__       ,  attention_mask=snake_case__       ,  encoder_outputs=snake_case__       ,  decoder_input_ids=snake_case__			)
												lowercase__				:      str=       output[0]
												lowercase__				:      Optional[Any]=       torch.Size((1, 14, 250012)			)
												self.assertEqual(output_predited_logis.shape       ,  snake_case__			)
												# compare the actual values for a slice.
												lowercase__				:      str=       torch.tensor(
												    [[[-9.22_53, -9.71_73, -6.35_29], [-7.67_01, -9.01_45, -1.93_82], [-8.01_95, -7.00_04, -0.15_23]]]			).to(snake_case__			)

												self.assertTrue(torch.allclose(output_predited_logis[:, :3, :3]       ,  snake_case__       ,  atol=1e-4			)			)




						@slow
						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												lowercase__				:      Tuple=       XLMProphetNetForConditionalGeneration.from_pretrained(
												    "microsoft/xprophetnet-large-wiki100-cased-xglue-ntg"			)
												model.to(snake_case__			)
												lowercase__				:      Optional[int]=       512

												lowercase__				:      int=       XLMProphetNetTokenizer.from_pretrained("microsoft/xprophetnet-large-wiki100-cased-xglue-ntg"			)

												lowercase__				:      str=       (
												    "Microsoft Corporation intends to officially end free support for the Windows 7 operating system after"
												    " January 14, 2020, according to the official portal of the organization. From that day, users of this"
												    " system will not be able to receive security updates, which could make their computers vulnerable to"
												    " cyber attacks."
												)
												lowercase__				:      Tuple=       (
												    "орпорация Microsoft намерена официально прекратить бесплатную поддержку операционной системы Windows 7"
												    " после 14 января 2020 года, сообщается на официальном портале организации . С указанного дня пользователи"
												    " этой системы не смогут получать обновления безопасности, из-за чего их компьютеры могут стать уязвимыми"
												    " к кибератакам."
												)
												lowercase__				:      Optional[int]=       (
												    "根据该组织的官方门户网站，微软公司打算在2020年1月14日之后正式终止对Windows 7操作系统的免费支持。从那时起，该系统的用户将无法接收安全更新，这可能会使他们的计算机容易受到网络攻击。"
												)

												lowercase__				:      Dict=       tokenizer(
												    [EN_SENTENCE, RU_SENTENCE, ZH_SENTENCE]       ,  padding=snake_case__       ,  max_length=255       ,  return_tensors="pt"			).input_ids
												lowercase__				:      Any=       input_ids.to(snake_case__			)

												lowercase__				:      List[Any]=       model.generate(
												    snake_case__       ,  num_beams=10       ,  length_penalty=1.0       ,  no_repeat_ngram_size=3       ,  early_stopping=snake_case__			)
												lowercase__				:      str=       [tokenizer.decode(snake_case__       ,  skip_special_tokens=snake_case__			) for g in summary_ids]
												lowercase__				:      Dict=       "Microsoft to end Windows 7 free support after January 14, 2020"
												lowercase__				:      int=       "Microsoft намерена прекратить бесплатную поддержку Windows 7 после 14 января 2020 года"
												lowercase__				:      List[str]=       "微软打算终止对Windows 7操作系统的免费支持"
												self.assertListEqual(
												    [EXPECTED_TITLE_EN, EXPECTED_TITLE_RU, EXPECTED_TITLE_ZH]       ,  snake_case__       ,  )

												lowercase__				:      List[str]=       model.generate(
												    snake_case__       ,  num_beams=1       ,  length_penalty=1.0       ,  no_repeat_ngram_size=3       ,  early_stopping=snake_case__			)
												lowercase__				:      Optional[Any]=       [
												    tokenizer.convert_ids_to_tokens(snake_case__       ,  skip_special_tokens=snake_case__			) for g in summary_ids_beama
												]
												lowercase__				:      List[str]=       "▁Microsoft ▁to ▁end ▁free ▁support ▁for ▁Windows ▁7".split(" "			)
												lowercase__				:      List[Any]=       "▁Microsoft ▁намерен а ▁прекрати ть ▁бес плат ную ▁поддержку ▁Windows ▁7 ▁после ▁14 ▁января ▁2020 ▁года".split(
												    " "			)
												lowercase__				:      int=       "微软 公司 打算 终止 对 Windows ▁7 操作 系统的 免费 支持".split(" "			)
												self.assertListEqual(
												    [EXPECTED_TITLE_EN_BEAM1_TOK, EXPECTED_TITLE_RU_BEAM1_TOK, EXPECTED_TITLE_ZH_BEAM1_TOK]       ,  snake_case__       ,  )






