

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 			__magic_name__					(    unittest.TestCase   ):





			@slow
			def 	__magic_name__					(	self      )     ->				Dict:




						'''simple docstring'''
						__a						   =XLMProphetNetForConditionalGeneration.from_pretrained('microsoft/xprophetnet-large-wiki100-cased'      )
						model.to(__snake_case      )

						# encoder-decoder outputs
						__a						   =torch.tensor([[17, 9_6208, 10_3471, 2]]      ).to(__snake_case      )
						__a						   =torch.tensor(
						    [[2, 250, 9953, 34, 6_9489, 1620, 32, 11_8424, 624, 210, 105, 2913, 1032, 351]]      ).to(__snake_case      )
						__a						   =model(
						    input_ids=__snake_case      ,						attention_mask=__snake_case      ,						encoder_outputs=__snake_case      ,						decoder_input_ids=__snake_case      )
						__a						   =output[0]
						__a						   =torch.Size((1, 14, 25_0012)      )
						self.assertEqual(output_predited_logis.shape      ,						__snake_case      )
						__a						   =torch.tensor(
						    [[[-6.3986, -8.2391, 12.5189], [-6.3289, -8.0864, 12.6211], [-6.2418, -8.0445, 12.7968]]]      ).to(__snake_case      )
						self.assertTrue(torch.allclose(output_predited_logis[:, :3, :3]      ,						__snake_case      ,						atol=1e-4      )      )

						# encoder outputs
						__a						   =model.prophetnet.encoder(__snake_case      )[0]
						__a						   =torch.tensor(
						    [[[-1.4260, -0.7628, 0.8453], [-1.4719, -0.1391, 0.7807], [-1.7678, 0.0114, 0.4646]]]      ).to(__snake_case      )
						__a						   =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
						__a						   =model.prophetnet.decoder(
						    __snake_case      ,						encoder_hidden_states=__snake_case      ,						)
						__a						   =decoder_outputs[1].view(1      ,						model.config.ngram      ,						14      ,						-1      )
						__a						   =model.lm_head(__snake_case      )
						__a						   =predicting_streams_logits[:, 0]
						self.assertTrue(torch.allclose(next_first_stream_logits[:, :3, :3]      ,						__snake_case      ,						atol=1e-4      )      )





			@slow
			def 	__magic_name__					(	self      )     ->				List[Any]:




						'''simple docstring'''
						__a						   =XLMProphetNetForConditionalGeneration.from_pretrained(
						    'microsoft/xprophetnet-large-wiki100-cased-xglue-ntg'      )
						model.to(__snake_case      )

						__a						   =torch.tensor([[17, 9_6208, 10_3471, 2]]      ).to(__snake_case      )
						__a						   =torch.tensor(
						    [[2, 250, 9953, 34, 6_9489, 1620, 32, 11_8424, 624, 210, 105, 2913, 1032, 351]]      ).to(__snake_case      )
						__a						   =model(
						    input_ids=__snake_case      ,						attention_mask=__snake_case      ,						encoder_outputs=__snake_case      ,						decoder_input_ids=__snake_case      )
						__a						   =output[0]
						__a						   =torch.Size((1, 14, 25_0012)      )
						self.assertEqual(output_predited_logis.shape      ,						__snake_case      )
						# compare the actual values for a slice.
						__a						   =torch.tensor(
						    [[[-9.2253, -9.7173, -6.3529], [-7.6701, -9.0145, -1.9382], [-8.0195, -7.0004, -0.1523]]]      ).to(__snake_case      )

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





			@slow
			def 	__magic_name__					(	self      )     ->				int:




						'''simple docstring'''
						__a						   =XLMProphetNetForConditionalGeneration.from_pretrained(
						    'microsoft/xprophetnet-large-wiki100-cased-xglue-ntg'      )
						model.to(__snake_case      )
						__a						   =512

						__a						   =XLMProphetNetTokenizer.from_pretrained('microsoft/xprophetnet-large-wiki100-cased-xglue-ntg'      )

						__a						   =(
						    '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.'
						)
						__a						   =(
						    'орпорация Microsoft намерена официально прекратить бесплатную поддержку операционной системы Windows 7'
						    ' после 14 января 2020 года, сообщается на официальном портале организации . С указанного дня пользователи'
						    ' этой системы не смогут получать обновления безопасности, из-за чего их компьютеры могут стать уязвимыми'
						    ' к кибератакам.'
						)
						__a						   =(
						    '根据该组织的官方门户网站，微软公司打算在2020年1月14日之后正式终止对Windows 7操作系统的免费支持。从那时起，该系统的用户将无法接收安全更新，这可能会使他们的计算机容易受到网络攻击。'
						)

						__a						   =tokenizer(
						    [EN_SENTENCE, RU_SENTENCE, ZH_SENTENCE]      ,						padding=__snake_case      ,						max_length=255      ,						return_tensors='pt'      ).input_ids
						__a						   =input_ids.to(__snake_case      )

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

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









from collections import OrderedDict
from typing import Any, Mapping, Optional

from ... import PreTrainedTokenizer
from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig, OnnxConfigWithPast, OnnxSeqaSeqConfigWithPast
from ...onnx.utils import compute_effective_axis_dimension
from ...utils import TensorType, is_torch_available, logging


_lowerCAmelCase      :    str						       =    logging.get_logger(__name__)

_lowerCAmelCase      :    List[str]						       =    {
    "facebook/mbart-large-cc25": "https://huggingface.co/facebook/mbart-large-cc25/resolve/main/config.json",
    # See all MBART models at https://huggingface.co/models?filter=mbart
}






class 			__magic_name__					(    lowerCAmelCase_   ):
			SCREAMING_SNAKE_CASE							     =		'mbart'
			SCREAMING_SNAKE_CASE							     =		['past_key_values']
			SCREAMING_SNAKE_CASE							     =		{'num_attention_heads': 'encoder_attention_heads', 'hidden_size': 'd_model'}





			def __init__(	self      ,						__snake_case=5_0265      ,						__snake_case=1024      ,						__snake_case=12      ,						__snake_case=4096      ,						__snake_case=16      ,						__snake_case=12      ,						__snake_case=4096      ,						__snake_case=16      ,						__snake_case=0.0      ,						__snake_case=0.0      ,						__snake_case=True      ,						__snake_case=True      ,						__snake_case="gelu"      ,						__snake_case=1024      ,						__snake_case=0.1      ,						__snake_case=0.0      ,						__snake_case=0.0      ,						__snake_case=0.02      ,						__snake_case=0.0      ,						__snake_case=False      ,						__snake_case=1      ,						__snake_case=0      ,						__snake_case=2      ,						__snake_case=2      ,						**__snake_case      ,						)     ->				Optional[Any]:




						'''simple docstring'''
						__a						   =vocab_size
						__a						   =max_position_embeddings
						__a						   =d_model
						__a						   =encoder_ffn_dim
						__a						   =encoder_layers
						__a						   =encoder_attention_heads
						__a						   =decoder_ffn_dim
						__a						   =decoder_layers
						__a						   =decoder_attention_heads
						__a						   =dropout
						__a						   =attention_dropout
						__a						   =activation_dropout
						__a						   =activation_function
						__a						   =init_std
						__a						   =encoder_layerdrop
						__a						   =decoder_layerdrop
						__a						   =classifier_dropout
						__a						   =use_cache
						__a						   =encoder_layers
						__a						   =scale_embedding  # scale factor will be sqrt(d_model) if True
						super().__init__(
						    pad_token_id=__snake_case      ,						bos_token_id=__snake_case      ,						eos_token_id=__snake_case      ,						is_encoder_decoder=__snake_case      ,						forced_eos_token_id=__snake_case      ,						**__snake_case      ,						)






class 			__magic_name__					(    lowerCAmelCase_   ):





			@property
			def 	__magic_name__					(	self      )     ->				Mapping[str, Mapping[int, str]]:




						'''simple docstring'''
						if self.task in ["default", "seq2seq-lm"]:
									__a						   =OrderedDict(
									    [
									        ('input_ids', {0: 'batch', 1: 'encoder_sequence'}),
									        ('attention_mask', {0: 'batch', 1: 'encoder_sequence'}),
									    ]      )

									if self.use_past:
												__a						   ={0: 'batch'}
												__a						   ={0: 'batch', 1: 'past_decoder_sequence + sequence'}
									else:
												__a						   ={0: 'batch', 1: 'decoder_sequence'}
												__a						   ={0: 'batch', 1: 'decoder_sequence'}

									if self.use_past:
												self.fill_with_past_key_values_(__snake_case      ,						direction='inputs'      )
						elif self.task == "causal-lm":
									# TODO: figure this case out.
									__a						   =OrderedDict(
									    [
									        ('input_ids', {0: 'batch', 1: 'encoder_sequence'}),
									        ('attention_mask', {0: 'batch', 1: 'encoder_sequence'}),
									    ]      )
									if self.use_past:
												__a   ,					__a						   =self.num_layers
												for i in range(__snake_case      ):
															__a						   ={0: 'batch', 2: 'past_sequence + sequence'}
															__a						   ={0: 'batch', 2: 'past_sequence + sequence'}
						else:
									__a						   =OrderedDict(
									    [
									        ('input_ids', {0: 'batch', 1: 'encoder_sequence'}),
									        ('attention_mask', {0: 'batch', 1: 'encoder_sequence'}),
									        ('decoder_input_ids', {0: 'batch', 1: 'decoder_sequence'}),
									        ('decoder_attention_mask', {0: 'batch', 1: 'decoder_sequence'}),
									    ]      )

						return common_inputs





			@property
			def 	__magic_name__					(	self      )     ->				Mapping[str, Mapping[int, str]]:




						'''simple docstring'''
						if self.task in ["default", "seq2seq-lm"]:
									__a						   =super().outputs
						else:
									__a						   =super(__snake_case      ,						self      ).outputs
									if self.use_past:
												__a   ,					__a						   =self.num_layers
												for i in range(__snake_case      ):
															__a						   ={0: 'batch', 2: 'past_sequence + sequence'}
															__a						   ={0: 'batch', 2: 'past_sequence + sequence'}
						return common_outputs





			def 	__magic_name__					(	self      ,						__snake_case      ,						__snake_case = -1      ,						__snake_case = -1      ,						__snake_case = False      ,						__snake_case = None      ,						)     ->				Mapping[str, Any]:




						'''simple docstring'''
						__a						   =self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
						    __snake_case      ,						__snake_case      ,						__snake_case      ,						__snake_case      ,						__snake_case      )

						# Generate decoder inputs
						__a						   =seq_length if not self.use_past else 1
						__a						   =self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
						    __snake_case      ,						__snake_case      ,						__snake_case      ,						__snake_case      ,						__snake_case      )
						__a						   ={f'decoder_{name}': tensor for name, tensor in decoder_inputs.items()}
						__a						   =dict(**__snake_case      ,						**__snake_case      )

						if self.use_past:
									if not is_torch_available():
												raise ValueError('Cannot generate dummy past_keys inputs without PyTorch installed.'      )
									else:
												import torch
									__a   ,					__a						   =common_inputs['input_ids'].shape
									__a						   =common_inputs['decoder_input_ids'].shape[1]
									__a   ,					__a						   =self.num_attention_heads
									__a						   =(
									    batch,
									    num_encoder_attention_heads,
									    encoder_seq_length,
									    self._config.hidden_size // num_encoder_attention_heads,
									)
									__a						   =decoder_seq_length + 3
									__a						   =(
									    batch,
									    num_decoder_attention_heads,
									    decoder_past_length,
									    self._config.hidden_size // num_decoder_attention_heads,
									)

									__a						   =torch.cat(
									    [common_inputs['decoder_attention_mask'], torch.ones(__snake_case      ,						__snake_case      )]      ,						dim=1      )

									__a						   =[]
									# If the number of encoder and decoder layers are present in the model configuration, both are considered
									__a   ,					__a						   =self.num_layers
									__a						   =min(__snake_case      ,						__snake_case      )
									__a						   =max(__snake_case      ,						__snake_case      ) - min_num_layers
									__a						   ='encoder' if num_encoder_layers > num_decoder_layers else 'decoder'

									for _ in range(__snake_case      ):
												common_inputs["past_key_values"].append(
												    (
												        torch.zeros(__snake_case      ),
												        torch.zeros(__snake_case      ),
												        torch.zeros(__snake_case      ),
												        torch.zeros(__snake_case      ),
												    )      )
									# TODO: test this.
									__a						   =encoder_shape if remaining_side_name == 'encoder' else decoder_shape
									for _ in range(__snake_case      ,						__snake_case      ):
												common_inputs["past_key_values"].append((torch.zeros(__snake_case      ), torch.zeros(__snake_case      ))      )
						return common_inputs





			def 	__magic_name__					(	self      ,						__snake_case      ,						__snake_case = -1      ,						__snake_case = -1      ,						__snake_case = False      ,						__snake_case = None      ,						)     ->				Mapping[str, Any]:




						'''simple docstring'''
						__a						   =self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
						    __snake_case      ,						__snake_case      ,						__snake_case      ,						__snake_case      ,						__snake_case      )

						if self.use_past:
									if not is_torch_available():
												raise ValueError('Cannot generate dummy past_keys inputs without PyTorch installed.'      )
									else:
												import torch
									__a   ,					__a						   =common_inputs['input_ids'].shape
									# Not using the same length for past_key_values
									__a						   =seqlen + 2
									__a   ,					__a						   =self.num_layers
									__a   ,					__a						   =self.num_attention_heads
									__a						   =(
									    batch,
									    num_encoder_attention_heads,
									    past_key_values_length,
									    self._config.hidden_size // num_encoder_attention_heads,
									)

									__a						   =common_inputs['attention_mask'].dtype
									__a						   =torch.cat(
									    [common_inputs['attention_mask'], torch.ones(__snake_case      ,						__snake_case      ,						dtype=__snake_case      )]      ,						dim=1      )
									__a						   =[
									    (torch.zeros(__snake_case      ), torch.zeros(__snake_case      )) for _ in range(__snake_case      )
									]
						return common_inputs





			def 	__magic_name__					(	self      ,						__snake_case      ,						__snake_case = -1      ,						__snake_case = -1      ,						__snake_case = False      ,						__snake_case = None      ,						)     ->				Mapping[str, Any]:




						'''simple docstring'''
						# Copied from OnnxConfig.generate_dummy_inputs
						# Did not use super(OnnxConfigWithPast, self).generate_dummy_inputs for code clarity.
						# If dynamic axis (-1) we forward with a fixed dimension of 2 samples to avoid optimizations made by ONNX
						__a						   =compute_effective_axis_dimension(
						    __snake_case      ,						fixed_dimension=OnnxConfig.default_fixed_batch      ,						num_token_to_add=0      )

						# If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX
						__a						   =tokenizer.num_special_tokens_to_add(__snake_case      )
						__a						   =compute_effective_axis_dimension(
						    __snake_case      ,						fixed_dimension=OnnxConfig.default_fixed_sequence      ,						num_token_to_add=__snake_case      )

						# Generate dummy inputs according to compute batch and sequence
						__a						   =[' '.join([tokenizer.unk_token]      ) * seq_length] * batch_size
						__a						   =dict(tokenizer(__snake_case      ,						return_tensors=__snake_case      )      )
						return common_inputs





			def 	__magic_name__					(	self      ,						__snake_case      ,						__snake_case = -1      ,						__snake_case = -1      ,						__snake_case = False      ,						__snake_case = None      ,						)     ->				Mapping[str, Any]:




						'''simple docstring'''
						if self.task in ["default", "seq2seq-lm"]:
									__a						   =self._generate_dummy_inputs_for_default_and_seqaseq_lm(
									    __snake_case      ,						batch_size=__snake_case      ,						seq_length=__snake_case      ,						is_pair=__snake_case      ,						framework=__snake_case      )

						elif self.task == "causal-lm":
									__a						   =self._generate_dummy_inputs_for_causal_lm(
									    __snake_case      ,						batch_size=__snake_case      ,						seq_length=__snake_case      ,						is_pair=__snake_case      ,						framework=__snake_case      )
						else:
									__a						   =self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
									    __snake_case      ,						batch_size=__snake_case      ,						seq_length=__snake_case      ,						is_pair=__snake_case      ,						framework=__snake_case      )

						return common_inputs





			def 	__magic_name__					(	self      ,						__snake_case      ,						__snake_case      ,						__snake_case      ,						__snake_case      )     ->				str:




						'''simple docstring'''
						if self.task in ["default", "seq2seq-lm"]:
									__a						   =super()._flatten_past_key_values_(__snake_case      ,						__snake_case      ,						__snake_case      ,						__snake_case      )
						else:
									__a						   =super(__snake_case      ,						self      )._flatten_past_key_values_(
									    __snake_case      ,						__snake_case      ,						__snake_case      ,						__snake_case      )






