
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 					lowerCAmelCase__		(				self       :				str					):
							UpperCamelCase_:							Any		=  XLMProphetNetForConditionalGeneration.from_pretrained("""microsoft/xprophetnet-large-wiki100-cased"""					)
							model.to(snake_case_					)

							# encoder-decoder outputs
							UpperCamelCase_:							Optional[int]		=  torch.tensor([[17, 9_6208, 10_3471, 2]]					).to(snake_case_					)
							UpperCamelCase_:							Union[str, Any]		=  torch.tensor(
							    [[2, 250, 9953, 34, 6_9489, 1620, 32, 11_8424, 624, 210, 105, 2913, 1032, 351]]					).to(snake_case_					)
							UpperCamelCase_:							Any		=  model(
							    input_ids=snake_case_  ,		attention_mask=snake_case_  ,		encoder_outputs=snake_case_  ,		decoder_input_ids=snake_case_					)
							UpperCamelCase_:							int		=  output[0]
							UpperCamelCase_:							Optional[int]		=  torch.Size((1, 14, 25_0012)					)
							self.assertEqual(output_predited_logis.shape  ,		snake_case_					)
							UpperCamelCase_:							Dict		=  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
							UpperCamelCase_:							Optional[int]		=  model.prophetnet.encoder(snake_case_					)[0]
							UpperCamelCase_:							Dict		=  torch.tensor(
							    [[[-1.4260, -0.7628, 0.8453], [-1.4719, -0.1391, 0.7807], [-1.7678, 0.0114, 0.4646]]]					).to(snake_case_					)
							UpperCamelCase_:							Tuple		=  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
							UpperCamelCase_:							List[str]		=  model.prophetnet.decoder(
							    snake_case_  ,		encoder_hidden_states=snake_case_  ,		)
							UpperCamelCase_:							Optional[Any]		=  decoder_outputs[1].view(1  ,		model.config.ngram  ,		14  ,		-1					)
							UpperCamelCase_:							Union[str, Any]		=  model.lm_head(snake_case_					)
							UpperCamelCase_:							Union[str, Any]		=  predicting_streams_logits[:, 0]
							self.assertTrue(torch.allclose(next_first_stream_logits[:, :3, :3]  ,		snake_case_  ,		atol=1e-4					)					)

			@slow
			def 					lowerCAmelCase__		(				self       :				int					):
							UpperCamelCase_:							int		=  XLMProphetNetForConditionalGeneration.from_pretrained(
							    """microsoft/xprophetnet-large-wiki100-cased-xglue-ntg"""					)
							model.to(snake_case_					)

							UpperCamelCase_:							int		=  torch.tensor([[17, 9_6208, 10_3471, 2]]					).to(snake_case_					)
							UpperCamelCase_:							Tuple		=  torch.tensor(
							    [[2, 250, 9953, 34, 6_9489, 1620, 32, 11_8424, 624, 210, 105, 2913, 1032, 351]]					).to(snake_case_					)
							UpperCamelCase_:							int		=  model(
							    input_ids=snake_case_  ,		attention_mask=snake_case_  ,		encoder_outputs=snake_case_  ,		decoder_input_ids=snake_case_					)
							UpperCamelCase_:							List[Any]		=  output[0]
							UpperCamelCase_:							str		=  torch.Size((1, 14, 25_0012)					)
							self.assertEqual(output_predited_logis.shape  ,		snake_case_					)
							# compare the actual values for a slice.
							UpperCamelCase_:							int		=  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 					lowerCAmelCase__		(				self       :				Optional[Any]					):
							UpperCamelCase_:							Tuple		=  XLMProphetNetForConditionalGeneration.from_pretrained(
							    """microsoft/xprophetnet-large-wiki100-cased-xglue-ntg"""					)
							model.to(snake_case_					)
							UpperCamelCase_:							Optional[int]		=  512

							UpperCamelCase_:							Union[str, Any]		=  XLMProphetNetTokenizer.from_pretrained("""microsoft/xprophetnet-large-wiki100-cased-xglue-ntg"""					)

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

							UpperCamelCase_:							str		=  tokenizer(
							    [EN_SENTENCE, RU_SENTENCE, ZH_SENTENCE]  ,		padding=snake_case_  ,		max_length=255  ,		return_tensors="""pt"""					).input_ids
							UpperCamelCase_:							Dict		=  input_ids.to(snake_case_					)

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

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














"""simple docstring"""







import unittest

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

from ...generation.test_utils import GenerationTesterMixin
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.models.speech_to_text_a.modeling_speech_to_text_a import (
			    SpeechaTextaDecoder,
			    SpeechaTextaForCausalLM,
			)


@require_torch
class     __UpperCAmelCase:




						"""simple docstring"""




						def __init__(   self       ,  snake_case__       ,  snake_case__=99       ,  snake_case__=13       ,  snake_case__=16       ,  snake_case__=7       ,  snake_case__=True       ,  snake_case__=True       ,  snake_case__=True       ,  snake_case__=False       ,  snake_case__=True       ,  snake_case__=2       ,  snake_case__=32       ,  snake_case__=4       ,  snake_case__=4       ,  snake_case__=30       ,  snake_case__=0       ,  snake_case__=1       ,  snake_case__=2       ,  snake_case__=None       ,  ):
												'''simple docstring'''
												lowercase__				:      List[str]=       parent
												lowercase__				:      Dict=       batch_size
												lowercase__				:      List[str]=       decoder_seq_length
												# For common tests
												lowercase__				:      List[str]=       self.decoder_seq_length
												lowercase__				:      int=       is_training
												lowercase__				:      Any=       use_attention_mask
												lowercase__				:      List[str]=       use_labels

												lowercase__				:      Dict=       vocab_size
												lowercase__				:      Dict=       d_model
												lowercase__				:      Union[str, Any]=       d_model
												lowercase__				:      List[str]=       decoder_layers
												lowercase__				:      Optional[Any]=       decoder_layers
												lowercase__				:      Optional[Any]=       decoder_ffn_dim
												lowercase__				:      Union[str, Any]=       decoder_attention_heads
												lowercase__				:      Tuple=       decoder_attention_heads
												lowercase__				:      Optional[Any]=       eos_token_id
												lowercase__				:      List[Any]=       bos_token_id
												lowercase__				:      Any=       pad_token_id
												lowercase__				:      Union[str, Any]=       decoder_start_token_id
												lowercase__				:      Optional[Any]=       use_cache
												lowercase__				:      List[Any]=       max_position_embeddings

												lowercase__				:      Tuple=       None
												lowercase__				:      Optional[Any]=       decoder_seq_length
												lowercase__				:      Optional[int]=       2
												lowercase__				:      Tuple=       1




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												lowercase__				:      List[Any]=       ids_tensor([self.batch_size, self.decoder_seq_length]       ,  self.vocab_size			)

												lowercase__				:      Tuple=       None
												if self.use_attention_mask:
																		lowercase__				:      List[str]=       ids_tensor([self.batch_size, self.decoder_seq_length]       ,  vocab_size=2			)

												lowercase__				:      Any=       None
												if self.use_labels:
																		lowercase__				:      str=       ids_tensor([self.batch_size, self.decoder_seq_length]       ,  self.vocab_size			)

												lowercase__				:      Dict=       SpeechaTextaConfig(
												    vocab_size=self.vocab_size       ,  d_model=self.d_model       ,  decoder_layers=self.decoder_layers       ,  decoder_ffn_dim=self.decoder_ffn_dim       ,  decoder_attention_heads=self.decoder_attention_heads       ,  eos_token_id=self.eos_token_id       ,  bos_token_id=self.bos_token_id       ,  use_cache=self.use_cache       ,  pad_token_id=self.pad_token_id       ,  decoder_start_token_id=self.decoder_start_token_id       ,  max_position_embeddings=self.max_position_embeddings       ,  )

												return (
												    config,
												    input_ids,
												    attention_mask,
												    lm_labels,
												)




						def 		UpperCAmelCase_       (   self       ,  snake_case__       ,  snake_case__       ,  snake_case__       ,  snake_case__       ,  ):
												'''simple docstring'''
												lowercase__				:      Union[str, Any]=       True
												lowercase__				:      List[Any]=       SpeechaTextaDecoder(config=snake_case__			).to(snake_case__			).eval()
												lowercase__				:      Any=       input_ids[:2]

												input_ids[input_ids == 0] += 1
												# first forward pass
												lowercase__				:      List[str]=       model(snake_case__       ,  use_cache=snake_case__			)
												lowercase__				:      Optional[Any]=       model(snake_case__			)
												lowercase__				:      List[Any]=       model(snake_case__       ,  use_cache=snake_case__			)

												self.parent.assertTrue(len(snake_case__			) == len(snake_case__			)			)
												self.parent.assertTrue(len(snake_case__			) == len(snake_case__			) + 1			)

												lowercase__				:      List[Any]=       outputs["past_key_values"]

												# create hypothetical next token and extent to next_input_ids
												lowercase__				:      List[Any]=       ids_tensor((2, 1)       ,  config.vocab_size - 1			) + 1

												# append to next input_ids and
												lowercase__				:      Tuple=       torch.cat([input_ids, next_tokens]       ,  dim=-1			)

												print(snake_case__			)

												lowercase__				:      int=       model(snake_case__			)["last_hidden_state"]
												lowercase__				:      int=       model(snake_case__       ,  past_key_values=snake_case__			)["last_hidden_state"]

												# select random slice
												lowercase__				:      str=       ids_tensor((1,)       ,  output_from_past.shape[-1]			).item()
												lowercase__				:      Any=       output_from_no_past[:, next_input_ids.shape[-1] - 1, random_slice_idx].detach()
												lowercase__				:      int=       output_from_past[:, 0, random_slice_idx].detach()

												# test that outputs are equal for slice
												assert torch.allclose(snake_case__       ,  snake_case__       ,  atol=1e-3			)




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												lowercase__				:      str=       self.prepare_config_and_inputs()
												(
												    (
												    lowercase__
												),	(
												    lowercase__
												),	(
												    lowercase__
												),	(
												    lowercase__
												),	
												)				:      Dict=       config_and_inputs

												lowercase__				:      Optional[int]=       {
												    "input_ids": input_ids,
												    "attention_mask": attention_mask,
												}
												return config, inputs_dict


@require_torch
class     __UpperCAmelCase(   SCREAMING_SNAKE_CASE__  ,  SCREAMING_SNAKE_CASE__  ,  SCREAMING_SNAKE_CASE__  ,  unittest.TestCase							):




						"""simple docstring"""




						__lowerCamelCase				       =					(SpeechaTextaDecoder, SpeechaTextaForCausalLM) if is_torch_available() else ()
						__lowerCamelCase				       =					(SpeechaTextaForCausalLM,) if is_torch_available() else ()
						__lowerCamelCase				       =					{"text-generation": SpeechaTextaForCausalLM} if is_torch_available() else {}
						__lowerCamelCase				       =					True
						__lowerCamelCase				       =					False




						def 		UpperCAmelCase_       (   self       ,  ):
												'''simple docstring'''
												lowercase__				:      List[str]=       SpeechaTextaStandaloneDecoderModelTester(self       ,  is_training=snake_case__			)
												lowercase__				:      int=       ConfigTester(self       ,  config_class=snake_case__			)




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												pass




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												pass




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												pass




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




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




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												return






