






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

   @slow
   def     SCREAMING_SNAKE_CASE__			(       self   )		->							List[Any]:
       UpperCamelCase__								=     XLMProphetNetForConditionalGeneration.from_pretrained('microsoft/xprophetnet-large-wiki100-cased'   )
       model.to(snake_case_   )

       # encoder-decoder outputs
       UpperCamelCase__								=     torch.tensor([[17, 9_6208, 10_3471, 2]]   ).to(snake_case_   )
       UpperCamelCase__								=     torch.tensor(
           [[2, 250, 9953, 34, 6_9489, 1620, 32, 11_8424, 624, 210, 105, 2913, 1032, 351]]   ).to(snake_case_   )
       UpperCamelCase__								=     model(
           input_ids=snake_case_			,					attention_mask=snake_case_			,					encoder_outputs=snake_case_			,					decoder_input_ids=snake_case_   )
       UpperCamelCase__								=     output[0]
       UpperCamelCase__								=     torch.Size((1, 14, 25_0012)   )
       self.assertEqual(output_predited_logis.shape			,					snake_case_   )
       UpperCamelCase__								=     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
       UpperCamelCase__								=     model.prophetnet.encoder(snake_case_   )[0]
       UpperCamelCase__								=     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_   )
       UpperCamelCase__								=     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__								=     model.prophetnet.decoder(
           snake_case_			,					encoder_hidden_states=snake_case_			,					)
       UpperCamelCase__								=     decoder_outputs[1].view(1			,					model.config.ngram			,					14			,					-1   )
       UpperCamelCase__								=     model.lm_head(snake_case_   )
       UpperCamelCase__								=     predicting_streams_logits[:, 0]
       self.assertTrue(torch.allclose(next_first_stream_logits[:, :3, :3]			,					snake_case_			,					atol=1E-4   )   )

   @slow
   def     SCREAMING_SNAKE_CASE__			(       self   )		->							List[Any]:
       UpperCamelCase__								=     XLMProphetNetForConditionalGeneration.from_pretrained(
           'microsoft/xprophetnet-large-wiki100-cased-xglue-ntg'   )
       model.to(snake_case_   )

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

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

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

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

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

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












"""simple docstring"""





def 	lowerCAmelCase_(			SCREAMING_SNAKE_CASE			,						SCREAMING_SNAKE_CASE = 10_00       )       ->						str:
    """simple docstring"""

    if (not isinstance(SCREAMING_SNAKE_CASE			,						SCREAMING_SNAKE_CASE       )) or (digit_position <= 0):
        raise ValueError('Digit position must be a positive integer'       )
    elif (not isinstance(SCREAMING_SNAKE_CASE			,						SCREAMING_SNAKE_CASE       )) or (precision < 0):
        raise ValueError('Precision must be a nonnegative integer'       )

    # compute an approximation of (16 ** (n - 1)) * pi whose fractional part is mostly
    # accurate
    UpperCamelCase__								=     (
        4 * _subsum(SCREAMING_SNAKE_CASE			,						1			,						SCREAMING_SNAKE_CASE       )
        - 2 * _subsum(SCREAMING_SNAKE_CASE			,						4			,						SCREAMING_SNAKE_CASE       )
        - _subsum(SCREAMING_SNAKE_CASE			,						5			,						SCREAMING_SNAKE_CASE       )
        - _subsum(SCREAMING_SNAKE_CASE			,						6			,						SCREAMING_SNAKE_CASE       )
    )

    # return the first hex digit of the fractional part of the result
    return hex(int((sum_result % 1) * 16       )       )[2:]







def 	lowerCAmelCase_(			SCREAMING_SNAKE_CASE			,						SCREAMING_SNAKE_CASE			,						SCREAMING_SNAKE_CASE       )       ->						float:
    """simple docstring"""

    UpperCamelCase__								=     0.0
    for sum_index in range(digit_pos_to_extract + precision       ):
        UpperCamelCase__								=     8 * sum_index + denominator_addend
        if sum_index < digit_pos_to_extract:
            # if the exponential term is an integer and we mod it by the denominator
            # before dividing, only the integer part of the sum will change;
            # the fractional part will not
            UpperCamelCase__								=     pow(
                16			,						digit_pos_to_extract - 1 - sum_index			,						SCREAMING_SNAKE_CASE       )
        else:
            UpperCamelCase__								=     pow(16			,						digit_pos_to_extract - 1 - sum_index       )
        total += exponential_term / denominator
    return total


if __name__ == "__main__":
  import doctest

  doctest.testmod()




