






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






						@slow
						def 		lowerCAmelCase   (					self)			->  Optional[Any]:




											"""simple docstring"""





											lowerCamelCase__				=XLMProphetNetForConditionalGeneration.from_pretrained('microsoft/xprophetnet-large-wiki100-cased')
											model.to(_SCREAMING_SNAKE_CASE)

											# encoder-decoder outputs
											lowerCamelCase__				=torch.tensor([[17, 9_62_08, 10_34_71, 2]]).to(_SCREAMING_SNAKE_CASE)
											lowerCamelCase__				=torch.tensor(
											    [[2, 2_50, 99_53, 34, 6_94_89, 16_20, 32, 11_84_24, 6_24, 2_10, 1_05, 29_13, 10_32, 3_51]]).to(_SCREAMING_SNAKE_CASE)
											lowerCamelCase__				=model(
											    input_ids=_SCREAMING_SNAKE_CASE    ,						attention_mask=_SCREAMING_SNAKE_CASE    ,						encoder_outputs=_SCREAMING_SNAKE_CASE    ,						decoder_input_ids=_SCREAMING_SNAKE_CASE)
											lowerCamelCase__				=output[0]
											lowerCamelCase__				=torch.Size((1, 14, 25_00_12))
											self.assertEqual(output_predited_logis.shape    ,						_SCREAMING_SNAKE_CASE)
											lowerCamelCase__				=torch.tensor(
											    [[[-6.3986, -8.2391, 12.5189], [-6.3289, -8.0864, 12.6211], [-6.2418, -8.0445, 12.7968]]]).to(_SCREAMING_SNAKE_CASE)
											self.assertTrue(torch.allclose(output_predited_logis[:, :3, :3]    ,						_SCREAMING_SNAKE_CASE    ,						atol=1E-4))

											# encoder outputs
											lowerCamelCase__				=model.prophetnet.encoder(_SCREAMING_SNAKE_CASE)[0]
											lowerCamelCase__				=torch.tensor(
											    [[[-1.4260, -0.7628, 0.8453], [-1.4719, -0.1391, 0.7807], [-1.7678, 0.0114, 0.4646]]]).to(_SCREAMING_SNAKE_CASE)
											lowerCamelCase__				=torch.Size((1, 4, 10_24))
											self.assertEqual(encoder_outputs.shape    ,						_SCREAMING_SNAKE_CASE)
											self.assertTrue(torch.allclose(encoder_outputs[:, :3, :3]    ,						_SCREAMING_SNAKE_CASE    ,						atol=1E-4))

											# decoder outputs
											lowerCamelCase__				=model.prophetnet.decoder(
											    _SCREAMING_SNAKE_CASE    ,						encoder_hidden_states=_SCREAMING_SNAKE_CASE    ,						)
											lowerCamelCase__				=decoder_outputs[1].view(1    ,						model.config.ngram    ,						14    ,						-1)
											lowerCamelCase__				=model.lm_head(_SCREAMING_SNAKE_CASE)
											lowerCamelCase__				=predicting_streams_logits[:, 0]
											self.assertTrue(torch.allclose(next_first_stream_logits[:, :3, :3]    ,						_SCREAMING_SNAKE_CASE    ,						atol=1E-4))






						@slow
						def 		lowerCAmelCase   (					self)			->  Tuple:




											"""simple docstring"""





											lowerCamelCase__				=XLMProphetNetForConditionalGeneration.from_pretrained(
											    'microsoft/xprophetnet-large-wiki100-cased-xglue-ntg')
											model.to(_SCREAMING_SNAKE_CASE)

											lowerCamelCase__				=torch.tensor([[17, 9_62_08, 10_34_71, 2]]).to(_SCREAMING_SNAKE_CASE)
											lowerCamelCase__				=torch.tensor(
											    [[2, 2_50, 99_53, 34, 6_94_89, 16_20, 32, 11_84_24, 6_24, 2_10, 1_05, 29_13, 10_32, 3_51]]).to(_SCREAMING_SNAKE_CASE)
											lowerCamelCase__				=model(
											    input_ids=_SCREAMING_SNAKE_CASE    ,						attention_mask=_SCREAMING_SNAKE_CASE    ,						encoder_outputs=_SCREAMING_SNAKE_CASE    ,						decoder_input_ids=_SCREAMING_SNAKE_CASE)
											lowerCamelCase__				=output[0]
											lowerCamelCase__				=torch.Size((1, 14, 25_00_12))
											self.assertEqual(output_predited_logis.shape    ,						_SCREAMING_SNAKE_CASE)
											# compare the actual values for a slice.
											lowerCamelCase__				=torch.tensor(
											    [[[-9.2253, -9.7173, -6.3529], [-7.6701, -9.0145, -1.9382], [-8.0195, -7.0004, -0.1523]]]).to(_SCREAMING_SNAKE_CASE)

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






						@slow
						def 		lowerCAmelCase   (					self)			->  str:




											"""simple docstring"""





											lowerCamelCase__				=XLMProphetNetForConditionalGeneration.from_pretrained(
											    'microsoft/xprophetnet-large-wiki100-cased-xglue-ntg')
											model.to(_SCREAMING_SNAKE_CASE)
											lowerCamelCase__				=5_12

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

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

											lowerCamelCase__				=tokenizer(
											    [EN_SENTENCE, RU_SENTENCE, ZH_SENTENCE]    ,						padding=_SCREAMING_SNAKE_CASE    ,						max_length=2_55    ,						return_tensors='pt').input_ids
											lowerCamelCase__				=input_ids.to(_SCREAMING_SNAKE_CASE)

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

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







"""simple docstring"""



import math

import qiskit
from qiskit import Aer, ClassicalRegister, QuantumCircuit, QuantumRegister, execute




def 						lowerCamelCase_				(  __A  :		int = 1			,	__A  :		int = 1			):
					if isinstance(__A			,	__A			) or isinstance(__A			,	__A			):
										raise TypeError('inputs must be integers.'			)
					if (bit_a < 0) or (bit_a < 0):
										raise ValueError('inputs must be positive.'			)
					if (math.floor(__A			) != bit_a) or (math.floor(__A			) != bit_a):
										raise ValueError('inputs must be exact integers.'			)
					if (bit_a > 1) or (bit_a > 1):
										raise ValueError('inputs must be less or equal to 1.'			)

					# build registers
					lowerCamelCase__				=QuantumRegister(2			,	'qr'			)
					lowerCamelCase__				=ClassicalRegister(2			,	'cr'			)

					lowerCamelCase__				=QuantumCircuit(__A			,	__A			)

					# entanglement the qubits
					quantum_circuit.h(1			)
					quantum_circuit.cx(1			,	0			)

					# send the information
					lowerCamelCase__				=str(__A			) + str(__A			)

					if c_information == "11":
										quantum_circuit.x(1			)
										quantum_circuit.z(1			)
					elif c_information == "10":
										quantum_circuit.z(1			)
					elif c_information == "01":
										quantum_circuit.x(1			)
					else:
										quantum_circuit.i(1			)

					# unentangled the circuit
					quantum_circuit.cx(1			,	0			)
					quantum_circuit.h(1			)

					# measure the circuit
					quantum_circuit.measure(__A			,	__A			)

					lowerCamelCase__				=Aer.get_backend('aer_simulator'			)
					lowerCamelCase__				=execute(__A			,	__A			,	shots=1000			)

					return job.result().get_counts(__A			)


if __name__ == "__main__":
						print(f"Counts for classical state send: {superdense_coding(1,1)}")