






"""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    snake_case						:


   '''simple docstring'''

   def __init__(      self					:	Dict,			_lowerCamelCase					:	str,			_lowerCamelCase					:	Dict=99,			_lowerCamelCase					:	Optional[int]=13,			_lowerCamelCase					:	List[Any]=16,			_lowerCamelCase					:	int=7,			_lowerCamelCase					:	str=True,			_lowerCamelCase					:	Optional[int]=True,			_lowerCamelCase					:	Optional[int]=True,			_lowerCamelCase					:	Tuple=False,			_lowerCamelCase					:	Any=True,			_lowerCamelCase					:	Dict=2,			_lowerCamelCase					:	List[Any]=32,			_lowerCamelCase					:	List[str]=4,			_lowerCamelCase					:	Dict=4,			_lowerCamelCase					:	List[str]=30,			_lowerCamelCase					:	Optional[Any]=0,			_lowerCamelCase					:	Any=1,			_lowerCamelCase					:	Optional[int]=2,			_lowerCamelCase					:	Optional[Any]=None,			):

     '''simple docstring'''
     __A		     =					parent
     __A		     =					batch_size
     __A		     =					decoder_seq_length
     # For common tests
     __A		     =					self.decoder_seq_length
     __A		     =					is_training
     __A		     =					use_attention_mask
     __A		     =					use_labels

     __A		     =					vocab_size
     __A		     =					d_model
     __A		     =					d_model
     __A		     =					decoder_layers
     __A		     =					decoder_layers
     __A		     =					decoder_ffn_dim
     __A		     =					decoder_attention_heads
     __A		     =					decoder_attention_heads
     __A		     =					eos_token_id
     __A		     =					bos_token_id
     __A		     =					pad_token_id
     __A		     =					decoder_start_token_id
     __A		     =					use_cache
     __A		     =					max_position_embeddings

     __A		     =					None
     __A		     =					decoder_seq_length
     __A		     =					2
     __A		     =					1


   def 							_SCREAMING_SNAKE_CASE							(      self					:	Any    ):

     '''simple docstring'''
     __A		     =					ids_tensor([self.batch_size, self.decoder_seq_length],			self.vocab_size    )

     __A		     =					None
     if self.use_attention_mask:
       __A		     =					ids_tensor([self.batch_size, self.decoder_seq_length],			vocab_size=2    )

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

     __A		     =					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 							_SCREAMING_SNAKE_CASE							(      self					:	Dict,			_lowerCamelCase					:	str,			_lowerCamelCase					:	Dict,			_lowerCamelCase					:	Optional[Any],			_lowerCamelCase					:	Union[str, Any],			):

     '''simple docstring'''
     __A		     =					True
     __A		     =					SpeechaTextaDecoder(config=_lowerCamelCase    ).to(_lowerCamelCase    ).eval()
     __A		     =					input_ids[:2]

     input_ids[input_ids == 0] += 1
     # first forward pass
     __A		     =					model(_lowerCamelCase,			use_cache=_lowerCamelCase    )
     __A		     =					model(_lowerCamelCase    )
     __A		     =					model(_lowerCamelCase,			use_cache=_lowerCamelCase    )

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

     __A		     =					outputs['''past_key_values''']

     # create hypothetical next token and extent to next_input_ids
     __A		     =					ids_tensor((2, 1),			config.vocab_size - 1    ) + 1

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

     print(_lowerCamelCase    )

     __A		     =					model(_lowerCamelCase    )['''last_hidden_state''']
     __A		     =					model(_lowerCamelCase,			past_key_values=_lowerCamelCase    )['''last_hidden_state''']

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

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






   def 							_SCREAMING_SNAKE_CASE							(      self					:	Dict    ):

     '''simple docstring'''
     __A		     =					self.prepare_config_and_inputs()
     (
         (
         __A
     )     ,       (
         __A
     )     ,       (
         __A
     )     ,       (
         __A
     )     ,       
     )		     =					config_and_inputs

     __A		     =					{
         '''input_ids''': input_ids,
         '''attention_mask''': attention_mask,
     }
     return config, inputs_dict





@require_torch
class    snake_case						(				_lowerCAmelCase  ,      _lowerCAmelCase  ,      _lowerCAmelCase  ,      unittest.TestCase		):


   '''simple docstring'''

   A_		:      List[str]							=					(SpeechaTextaDecoder, SpeechaTextaForCausalLM) if is_torch_available() else ()
   A_		:      Dict							=					(SpeechaTextaForCausalLM,) if is_torch_available() else ()
   A_		:      Optional[Any]							=					{"text-generation": SpeechaTextaForCausalLM} if is_torch_available() else {}
   A_		:      Any							=					True
   A_		:      str							=					False


   def 							_SCREAMING_SNAKE_CASE							(      self					:	str,			):

     '''simple docstring'''
     __A		     =					SpeechaTextaStandaloneDecoderModelTester(self,			is_training=_lowerCamelCase    )
     __A		     =					ConfigTester(self,			config_class=_lowerCamelCase    )


   def 							_SCREAMING_SNAKE_CASE							(      self					:	str    ):

     '''simple docstring'''
     pass


   def 							_SCREAMING_SNAKE_CASE							(      self					:	Optional[int]    ):

     '''simple docstring'''
     pass


   def 							_SCREAMING_SNAKE_CASE							(      self					:	Tuple    ):

     '''simple docstring'''
     pass


   def 							_SCREAMING_SNAKE_CASE							(      self					:	Optional[Any]    ):

     '''simple docstring'''
     self.config_tester.run_common_tests()


   def 							_SCREAMING_SNAKE_CASE							(      self					:	Optional[int]    ):

     '''simple docstring'''
     __A		     =					self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_decoder_model_past(*_lowerCamelCase    )






   def 							_SCREAMING_SNAKE_CASE							(      self					:	Any    ):

     '''simple docstring'''
     return












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







    @slow
    def      UpperCamelCase_ (     self			):
      lowercase				       =			XLMProphetNetForConditionalGeneration.from_pretrained('microsoft/xprophetnet-large-wiki100-cased'			)
      model.to(_lowerCamelCase			)

      # encoder-decoder outputs
      lowercase				       =			torch.tensor([[1_7, 9_6_2_0_8, 1_0_3_4_7_1, 2]]			).to(_lowerCamelCase			)
      lowercase				       =			torch.tensor(
          [[2, 2_5_0, 9_9_5_3, 3_4, 6_9_4_8_9, 1_6_2_0, 3_2, 1_1_8_4_2_4, 6_2_4, 2_1_0, 1_0_5, 2_9_1_3, 1_0_3_2, 3_5_1]]			).to(_lowerCamelCase			)
      lowercase				       =			model(
          input_ids=_lowerCamelCase				,						attention_mask=_lowerCamelCase				,						encoder_outputs=_lowerCamelCase				,						decoder_input_ids=_lowerCamelCase			)
      lowercase				       =			output[0]
      lowercase				       =			torch.Size((1, 1_4, 2_5_0_0_1_2)			)
      self.assertEqual(output_predited_logis.shape				,						_lowerCamelCase			)
      lowercase				       =			torch.tensor(
          [[[-6.3_9_8_6, -8.2_3_9_1, 1_2.5_1_8_9], [-6.3_2_8_9, -8.0_8_6_4, 1_2.6_2_1_1], [-6.2_4_1_8, -8.0_4_4_5, 1_2.7_9_6_8]]]			).to(_lowerCamelCase			)
      self.assertTrue(torch.allclose(output_predited_logis[:, :3, :3]				,						_lowerCamelCase				,						atol=1e-4			)			)

      # encoder outputs
      lowercase				       =			model.prophetnet.encoder(_lowerCamelCase			)[0]
      lowercase				       =			torch.tensor(
          [[[-1.4_2_6_0, -0.7_6_2_8, 0.8_4_5_3], [-1.4_7_1_9, -0.1_3_9_1, 0.7_8_0_7], [-1.7_6_7_8, 0.0_1_1_4, 0.4_6_4_6]]]			).to(_lowerCamelCase			)
      lowercase				       =			torch.Size((1, 4, 1_0_2_4)			)
      self.assertEqual(encoder_outputs.shape				,						_lowerCamelCase			)
      self.assertTrue(torch.allclose(encoder_outputs[:, :3, :3]				,						_lowerCamelCase				,						atol=1e-4			)			)

      # decoder outputs
      lowercase				       =			model.prophetnet.decoder(
          _lowerCamelCase				,						encoder_hidden_states=_lowerCamelCase				,						)
      lowercase				       =			decoder_outputs[1].view(1				,						model.config.ngram				,						1_4				,						-1			)
      lowercase				       =			model.lm_head(_lowerCamelCase			)
      lowercase				       =			predicting_streams_logits[:, 0]
      self.assertTrue(torch.allclose(next_first_stream_logits[:, :3, :3]				,						_lowerCamelCase				,						atol=1e-4			)			)







    @slow
    def      UpperCamelCase_ (     self			):
      lowercase				       =			XLMProphetNetForConditionalGeneration.from_pretrained(
          'microsoft/xprophetnet-large-wiki100-cased-xglue-ntg'			)
      model.to(_lowerCamelCase			)

      lowercase				       =			torch.tensor([[1_7, 9_6_2_0_8, 1_0_3_4_7_1, 2]]			).to(_lowerCamelCase			)
      lowercase				       =			torch.tensor(
          [[2, 2_5_0, 9_9_5_3, 3_4, 6_9_4_8_9, 1_6_2_0, 3_2, 1_1_8_4_2_4, 6_2_4, 2_1_0, 1_0_5, 2_9_1_3, 1_0_3_2, 3_5_1]]			).to(_lowerCamelCase			)
      lowercase				       =			model(
          input_ids=_lowerCamelCase				,						attention_mask=_lowerCamelCase				,						encoder_outputs=_lowerCamelCase				,						decoder_input_ids=_lowerCamelCase			)
      lowercase				       =			output[0]
      lowercase				       =			torch.Size((1, 1_4, 2_5_0_0_1_2)			)
      self.assertEqual(output_predited_logis.shape				,						_lowerCamelCase			)
      # compare the actual values for a slice.
      lowercase				       =			torch.tensor(
          [[[-9.2_2_5_3, -9.7_1_7_3, -6.3_5_2_9], [-7.6_7_0_1, -9.0_1_4_5, -1.9_3_8_2], [-8.0_1_9_5, -7.0_0_0_4, -0.1_5_2_3]]]			).to(_lowerCamelCase			)

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







    @slow
    def      UpperCamelCase_ (     self			):
      lowercase				       =			XLMProphetNetForConditionalGeneration.from_pretrained(
          'microsoft/xprophetnet-large-wiki100-cased-xglue-ntg'			)
      model.to(_lowerCamelCase			)
      lowercase				       =			5_1_2

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

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

      lowercase				       =			tokenizer(
          [EN_SENTENCE, RU_SENTENCE, ZH_SENTENCE]				,						padding=_lowerCamelCase				,						max_length=2_5_5				,						return_tensors='pt'			).input_ids
      lowercase				       =			input_ids.to(_lowerCamelCase			)

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

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


