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



			"""simple docstring"""






			@slow
			def      lowerCamelCase   (       self				):
									snake_case   :					Optional[int]							=						XLMProphetNetForConditionalGeneration.from_pretrained("microsoft/xprophetnet-large-wiki100-cased"				)
									model.to(snake_case_				)

									# encoder-decoder outputs
									snake_case   :					Union[str, Any]							=						torch.tensor([[17, 96_208, 103_471, 2]]				).to(snake_case_				)
									snake_case   :					List[str]							=						torch.tensor(
									    [[2, 250, 9_953, 34, 69_489, 1_620, 32, 118_424, 624, 210, 105, 2_913, 1_032, 351]]				).to(snake_case_				)
									snake_case   :					List[Any]							=						model(
									    input_ids=snake_case_							, attention_mask=snake_case_							, encoder_outputs=snake_case_							, decoder_input_ids=snake_case_				)
									snake_case   :					str							=						output[0]
									snake_case   :					Union[str, Any]							=						torch.Size((1, 14, 250_012)				)
									self.assertEqual(output_predited_logis.shape							, snake_case_				)
									snake_case   :					Any							=						torch.tensor(
									    [[[-6.3_986, -8.2_391, 12.5_189], [-6.3_289, -8.0_864, 12.6_211], [-6.2_418, -8.0_445, 12.7_968]]]				).to(snake_case_				)
									self.assertTrue(torch.allclose(output_predited_logis[:, :3, :3]							, snake_case_							, atol=1e-4				)				)

									# encoder outputs
									snake_case   :					Optional[Any]							=						model.prophetnet.encoder(snake_case_				)[0]
									snake_case   :					Optional[Any]							=						torch.tensor(
									    [[[-1.4_260, -0.7_628, 0.8_453], [-1.4_719, -0.1_391, 0.7_807], [-1.7_678, 0.0_114, 0.4_646]]]				).to(snake_case_				)
									snake_case   :					int							=						torch.Size((1, 4, 1_024)				)
									self.assertEqual(encoder_outputs.shape							, snake_case_				)
									self.assertTrue(torch.allclose(encoder_outputs[:, :3, :3]							, snake_case_							, atol=1e-4				)				)

									# decoder outputs
									snake_case   :					int							=						model.prophetnet.decoder(
									    snake_case_							, encoder_hidden_states=snake_case_							, )
									snake_case   :					Tuple							=						decoder_outputs[1].view(1							, model.config.ngram							, 14							, -1				)
									snake_case   :					Any							=						model.lm_head(snake_case_				)
									snake_case   :					Optional[Any]							=						predicting_streams_logits[:, 0]
									self.assertTrue(torch.allclose(next_first_stream_logits[:, :3, :3]							, snake_case_							, atol=1e-4				)				)



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

									snake_case   :					Tuple							=						torch.tensor([[17, 96_208, 103_471, 2]]				).to(snake_case_				)
									snake_case   :					Tuple							=						torch.tensor(
									    [[2, 250, 9_953, 34, 69_489, 1_620, 32, 118_424, 624, 210, 105, 2_913, 1_032, 351]]				).to(snake_case_				)
									snake_case   :					str							=						model(
									    input_ids=snake_case_							, attention_mask=snake_case_							, encoder_outputs=snake_case_							, decoder_input_ids=snake_case_				)
									snake_case   :					Union[str, Any]							=						output[0]
									snake_case   :					Dict							=						torch.Size((1, 14, 250_012)				)
									self.assertEqual(output_predited_logis.shape							, snake_case_				)
									# compare the actual values for a slice.
									snake_case   :					List[str]							=						torch.tensor(
									    [[[-9.2_253, -9.7_173, -6.3_529], [-7.6_701, -9.0_145, -1.9_382], [-8.0_195, -7.0_004, -0.1_523]]]				).to(snake_case_				)

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






			@slow
			def      lowerCamelCase   (       self				):
									snake_case   :					List[str]							=						XLMProphetNetForConditionalGeneration.from_pretrained(
									    "microsoft/xprophetnet-large-wiki100-cased-xglue-ntg"				)
									model.to(snake_case_				)
									snake_case   :					List[Any]							=						512

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

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

									snake_case   :					Union[str, Any]							=						tokenizer(
									    [EN_SENTENCE, RU_SENTENCE, ZH_SENTENCE]							, padding=snake_case_							, max_length=255							, return_tensors="pt"				).input_ids
									snake_case   :					Tuple							=						input_ids.to(snake_case_				)

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

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






'''simple docstring'''

from typing import TYPE_CHECKING

from ..utils import OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_tf_available, is_torch_available


A_        =   {
    "configuration_utils": ["GenerationConfig"],
    "streamers": ["TextIteratorStreamer", "TextStreamer"],
}

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						A_        =   [
						    "Constraint",
						    "ConstraintListState",
						    "DisjunctiveConstraint",
						    "PhrasalConstraint",
						]
						A_        =   [
						    "BeamHypotheses",
						    "BeamScorer",
						    "BeamSearchScorer",
						    "ConstrainedBeamSearchScorer",
						]
						A_        =   [
						    "EpsilonLogitsWarper",
						    "EtaLogitsWarper",
						    "ForcedBOSTokenLogitsProcessor",
						    "ForcedEOSTokenLogitsProcessor",
						    "HammingDiversityLogitsProcessor",
						    "InfNanRemoveLogitsProcessor",
						    "LogitsProcessor",
						    "LogitsProcessorList",
						    "LogitsWarper",
						    "MinLengthLogitsProcessor",
						    "MinNewTokensLengthLogitsProcessor",
						    "NoBadWordsLogitsProcessor",
						    "NoRepeatNGramLogitsProcessor",
						    "PrefixConstrainedLogitsProcessor",
						    "RepetitionPenaltyLogitsProcessor",
						    "SequenceBiasLogitsProcessor",
						    "EncoderRepetitionPenaltyLogitsProcessor",
						    "TemperatureLogitsWarper",
						    "TopKLogitsWarper",
						    "TopPLogitsWarper",
						    "TypicalLogitsWarper",
						    "EncoderNoRepeatNGramLogitsProcessor",
						    "ExponentialDecayLengthPenalty",
						    "LogitNormalization",
						]
						A_        =   [
						    "MaxNewTokensCriteria",
						    "MaxLengthCriteria",
						    "MaxTimeCriteria",
						    "StoppingCriteria",
						    "StoppingCriteriaList",
						    "validate_stopping_criteria",
						]
						A_        =   [
						    "GenerationMixin",
						    "top_k_top_p_filtering",
						    "GreedySearchEncoderDecoderOutput",
						    "GreedySearchDecoderOnlyOutput",
						    "SampleEncoderDecoderOutput",
						    "SampleDecoderOnlyOutput",
						    "BeamSearchEncoderDecoderOutput",
						    "BeamSearchDecoderOnlyOutput",
						    "BeamSampleEncoderDecoderOutput",
						    "BeamSampleDecoderOnlyOutput",
						    "ContrastiveSearchEncoderDecoderOutput",
						    "ContrastiveSearchDecoderOnlyOutput",
						]

try:
						if not is_tf_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						A_        =   [
						    "TFForcedBOSTokenLogitsProcessor",
						    "TFForcedEOSTokenLogitsProcessor",
						    "TFLogitsProcessor",
						    "TFLogitsProcessorList",
						    "TFLogitsWarper",
						    "TFMinLengthLogitsProcessor",
						    "TFNoBadWordsLogitsProcessor",
						    "TFNoRepeatNGramLogitsProcessor",
						    "TFRepetitionPenaltyLogitsProcessor",
						    "TFTemperatureLogitsWarper",
						    "TFTopKLogitsWarper",
						    "TFTopPLogitsWarper",
						    "TFForceTokensLogitsProcessor",
						    "TFSuppressTokensAtBeginLogitsProcessor",
						    "TFSuppressTokensLogitsProcessor",
						]
						A_        =   [
						    "TFGenerationMixin",
						    "tf_top_k_top_p_filtering",
						    "TFGreedySearchDecoderOnlyOutput",
						    "TFGreedySearchEncoderDecoderOutput",
						    "TFSampleEncoderDecoderOutput",
						    "TFSampleDecoderOnlyOutput",
						    "TFBeamSearchEncoderDecoderOutput",
						    "TFBeamSearchDecoderOnlyOutput",
						    "TFBeamSampleEncoderDecoderOutput",
						    "TFBeamSampleDecoderOnlyOutput",
						    "TFContrastiveSearchEncoderDecoderOutput",
						    "TFContrastiveSearchDecoderOnlyOutput",
						]

try:
						if not is_flax_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						A_        =   [
						    "FlaxForcedBOSTokenLogitsProcessor",
						    "FlaxForcedEOSTokenLogitsProcessor",
						    "FlaxLogitsProcessor",
						    "FlaxLogitsProcessorList",
						    "FlaxLogitsWarper",
						    "FlaxMinLengthLogitsProcessor",
						    "FlaxTemperatureLogitsWarper",
						    "FlaxTopKLogitsWarper",
						    "FlaxTopPLogitsWarper",
						]
						A_        =   [
						    "FlaxGenerationMixin",
						    "FlaxGreedySearchOutput",
						    "FlaxSampleOutput",
						    "FlaxBeamSearchOutput",
						]

if TYPE_CHECKING:
						from .configuration_utils import GenerationConfig
						from .streamers import TextIteratorStreamer, TextStreamer

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .beam_constraints import Constraint, ConstraintListState, DisjunctiveConstraint, PhrasalConstraint
												from .beam_search import BeamHypotheses, BeamScorer, BeamSearchScorer, ConstrainedBeamSearchScorer
												from .logits_process import (
												    EncoderNoRepeatNGramLogitsProcessor,
												    EncoderRepetitionPenaltyLogitsProcessor,
												    EpsilonLogitsWarper,
												    EtaLogitsWarper,
												    ExponentialDecayLengthPenalty,
												    ForcedBOSTokenLogitsProcessor,
												    ForcedEOSTokenLogitsProcessor,
												    HammingDiversityLogitsProcessor,
												    InfNanRemoveLogitsProcessor,
												    LogitNormalization,
												    LogitsProcessor,
												    LogitsProcessorList,
												    LogitsWarper,
												    MinLengthLogitsProcessor,
												    MinNewTokensLengthLogitsProcessor,
												    NoBadWordsLogitsProcessor,
												    NoRepeatNGramLogitsProcessor,
												    PrefixConstrainedLogitsProcessor,
												    RepetitionPenaltyLogitsProcessor,
												    SequenceBiasLogitsProcessor,
												    TemperatureLogitsWarper,
												    TopKLogitsWarper,
												    TopPLogitsWarper,
												    TypicalLogitsWarper,
												)
												from .stopping_criteria import (
												    MaxLengthCriteria,
												    MaxNewTokensCriteria,
												    MaxTimeCriteria,
												    StoppingCriteria,
												    StoppingCriteriaList,
												    validate_stopping_criteria,
												)
												from .utils import (
												    BeamSampleDecoderOnlyOutput,
												    BeamSampleEncoderDecoderOutput,
												    BeamSearchDecoderOnlyOutput,
												    BeamSearchEncoderDecoderOutput,
												    ContrastiveSearchDecoderOnlyOutput,
												    ContrastiveSearchEncoderDecoderOutput,
												    GenerationMixin,
												    GreedySearchDecoderOnlyOutput,
												    GreedySearchEncoderDecoderOutput,
												    SampleDecoderOnlyOutput,
												    SampleEncoderDecoderOutput,
												    top_k_top_p_filtering,
												)

						try:
												if not is_tf_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .tf_logits_process import (
												    TFForcedBOSTokenLogitsProcessor,
												    TFForcedEOSTokenLogitsProcessor,
												    TFForceTokensLogitsProcessor,
												    TFLogitsProcessor,
												    TFLogitsProcessorList,
												    TFLogitsWarper,
												    TFMinLengthLogitsProcessor,
												    TFNoBadWordsLogitsProcessor,
												    TFNoRepeatNGramLogitsProcessor,
												    TFRepetitionPenaltyLogitsProcessor,
												    TFSuppressTokensAtBeginLogitsProcessor,
												    TFSuppressTokensLogitsProcessor,
												    TFTemperatureLogitsWarper,
												    TFTopKLogitsWarper,
												    TFTopPLogitsWarper,
												)
												from .tf_utils import (
												    TFBeamSampleDecoderOnlyOutput,
												    TFBeamSampleEncoderDecoderOutput,
												    TFBeamSearchDecoderOnlyOutput,
												    TFBeamSearchEncoderDecoderOutput,
												    TFContrastiveSearchDecoderOnlyOutput,
												    TFContrastiveSearchEncoderDecoderOutput,
												    TFGenerationMixin,
												    TFGreedySearchDecoderOnlyOutput,
												    TFGreedySearchEncoderDecoderOutput,
												    TFSampleDecoderOnlyOutput,
												    TFSampleEncoderDecoderOutput,
												    tf_top_k_top_p_filtering,
												)

						try:
												if not is_flax_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .flax_logits_process import (
												    FlaxForcedBOSTokenLogitsProcessor,
												    FlaxForcedEOSTokenLogitsProcessor,
												    FlaxLogitsProcessor,
												    FlaxLogitsProcessorList,
												    FlaxLogitsWarper,
												    FlaxMinLengthLogitsProcessor,
												    FlaxTemperatureLogitsWarper,
												    FlaxTopKLogitsWarper,
												    FlaxTopPLogitsWarper,
												)
												from .flax_utils import FlaxBeamSearchOutput, FlaxGenerationMixin, FlaxGreedySearchOutput, FlaxSampleOutput
else:
						import sys

						A_        =   _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)





