


import random
import unittest

import numpy as np
import torch
from PIL import Image
from torch import nn
from transformers import (
    CLIPImageProcessor,
    CLIPTextConfig,
    CLIPTextModelWithProjection,
    CLIPTokenizer,
    CLIPVisionConfig,
    CLIPVisionModelWithProjection,
)

from diffusers import KandinskyVaaPriorEmbaEmbPipeline, PriorTransformer, UnCLIPScheduler
from diffusers.utils import floats_tensor, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, skip_mps

from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()





class    A					(     A_      ,       unittest.TestCase				):
							UpperCamelCase_     :							Union[str, Any] =KandinskyVaaPriorEmbaEmbPipeline
							UpperCamelCase_     :							Optional[Any] =['''prompt''', '''image''']
							UpperCamelCase_     :							Any =['''prompt''', '''image''']
							UpperCamelCase_     :							Any =[
							    '''num_images_per_prompt''',
							    '''strength''',
							    '''generator''',
							    '''num_inference_steps''',
							    '''latents''',
							    '''negative_prompt''',
							    '''guidance_scale''',
							    '''output_type''',
							    '''return_dict''',
							]
							UpperCamelCase_     :							List[Any] =False


							@property
							def     _A (self      ):
									return 3_2


							@property
							def     _A (self      ):
									return 3_2


							@property
							def     _A (self      ):
									return self.time_input_dim


							@property
							def     _A (self      ):
									return self.time_input_dim * 4


							@property
							def     _A (self      ):
									return 1_0_0


							@property
							def     _A (self      ):
									__lowercase=    CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'      )
									return tokenizer


							@property
							def     _A (self      ):
									torch.manual_seed(0      )
									__lowercase=    CLIPTextConfig(
									    bos_token_id=0   ,       eos_token_id=2   ,       hidden_size=self.text_embedder_hidden_size   ,       projection_dim=self.text_embedder_hidden_size   ,       intermediate_size=3_7   ,       layer_norm_eps=1E-05   ,       num_attention_heads=4   ,       num_hidden_layers=5   ,       pad_token_id=1   ,       vocab_size=1_0_0_0   ,       )
									return CLIPTextModelWithProjection(lowerCAmelCase      )


							@property
							def     _A (self      ):
									torch.manual_seed(0      )

									__lowercase=    {
									    'num_attention_heads': 2,
									    'attention_head_dim': 1_2,
									    'embedding_dim': self.text_embedder_hidden_size,
									    'num_layers': 1,
									}

									__lowercase=    PriorTransformer(**lowerCAmelCase      )
									# clip_std and clip_mean is initialized to be 0 so PriorTransformer.post_process_latents will always return 0 - set clip_std to be 1 so it won't return 0
									__lowercase=    nn.Parameter(torch.ones(model.clip_std.shape      )      )
									return model


							@property
							def     _A (self      ):
									torch.manual_seed(0      )
									__lowercase=    CLIPVisionConfig(
									    hidden_size=self.text_embedder_hidden_size   ,       image_size=2_2_4   ,       projection_dim=self.text_embedder_hidden_size   ,       intermediate_size=3_7   ,       num_attention_heads=4   ,       num_channels=3   ,       num_hidden_layers=5   ,       patch_size=1_4   ,       )

									__lowercase=    CLIPVisionModelWithProjection(lowerCAmelCase      )
									return model


							@property
							def     _A (self      ):
									__lowercase=    CLIPImageProcessor(
									    crop_size=2_2_4   ,       do_center_crop=lowerCAmelCase   ,       do_normalize=lowerCAmelCase   ,       do_resize=lowerCAmelCase   ,       image_mean=[0.48_14_54_66, 0.4_57_82_75, 0.40_82_10_73]   ,       image_std=[0.26_86_29_54, 0.26_13_02_58, 0.27_57_77_11]   ,       resample=3   ,       size=2_2_4   ,       )

									return image_processor


							def     _A (self      ):
									__lowercase=    self.dummy_prior
									__lowercase=    self.dummy_image_encoder
									__lowercase=    self.dummy_text_encoder
									__lowercase=    self.dummy_tokenizer
									__lowercase=    self.dummy_image_processor

									__lowercase=    UnCLIPScheduler(
									    variance_type='fixed_small_log'   ,       prediction_type='sample'   ,       num_train_timesteps=1_0_0_0   ,       clip_sample=lowerCAmelCase   ,       clip_sample_range=10.0   ,       )

									__lowercase=    {
									    'prior': prior,
									    'image_encoder': image_encoder,
									    'text_encoder': text_encoder,
									    'tokenizer': tokenizer,
									    'scheduler': scheduler,
									    'image_processor': image_processor,
									}

									return components


							def     _A (self   ,       lowerCAmelCase   ,       lowerCAmelCase=0      ):
									if str(lowerCAmelCase      ).startswith('mps'      ):
											__lowercase=    torch.manual_seed(lowerCAmelCase      )
									else:
											__lowercase=    torch.Generator(device=lowerCAmelCase      ).manual_seed(lowerCAmelCase      )

									__lowercase=    floats_tensor((1, 3, 6_4, 6_4)   ,       rng=random.Random(lowerCAmelCase      )      ).to(lowerCAmelCase      )
									__lowercase=    image.cpu().permute(0   ,       2   ,       3   ,       1      )[0]
									__lowercase=    Image.fromarray(np.uinta(lowerCAmelCase      )      ).convert('RGB'      ).resize((2_5_6, 2_5_6)      )

									__lowercase=    {
									    'prompt': 'horse',
									    'image': init_image,
									    'strength': 0.5,
									    'generator': generator,
									    'guidance_scale': 4.0,
									    'num_inference_steps': 2,
									    'output_type': 'np',
									}
									return inputs


							def     _A (self      ):
									__lowercase=    'cpu'

									__lowercase=    self.get_dummy_components()

									__lowercase=    self.pipeline_class(**lowerCAmelCase      )
									__lowercase=    pipe.to(lowerCAmelCase      )

									pipe.set_progress_bar_config(disable=lowerCAmelCase      )

									__lowercase=    pipe(**self.get_dummy_inputs(lowerCAmelCase      )      )
									__lowercase=    output.image_embeds

									__lowercase=    pipe(
									    **self.get_dummy_inputs(lowerCAmelCase      )   ,       return_dict=lowerCAmelCase   ,       )[0]

									__lowercase=    image[0, -1_0:]
									__lowercase=    image_from_tuple[0, -1_0:]

									assert image.shape == (1, 3_2)

									__lowercase=    np.array(
									    [
									        0.1_07_12_84,
									        1.3_33_02_71,
									        0.61_26_02_23,
									        -0.6_69_10_65,
									        -0.3_84_68_52,
									        -1.0_30_36_61,
									        0.22_71_61_11,
									        0.03_34_89_01,
									        0.30_04_06_75,
									        -0.24_80_50_29,
									    ]      )

									assert np.abs(image_slice.flatten() - expected_slice      ).max() < 1E-2
									assert np.abs(image_from_tuple_slice.flatten() - expected_slice      ).max() < 1E-2


							@skip_mps
							def     _A (self      ):
									__lowercase=    torch_device == 'cpu'
									__lowercase=    True
									__lowercase=    False

									self._test_inference_batch_single_identical(
									    test_max_difference=lowerCAmelCase   ,       relax_max_difference=lowerCAmelCase   ,       test_mean_pixel_difference=lowerCAmelCase   ,       )







							@skip_mps
							def     _A (self      ):
									__lowercase=    torch_device == 'cpu'
									__lowercase=    False

									self._test_attention_slicing_forward_pass(
									    test_max_difference=lowerCAmelCase   ,       test_mean_pixel_difference=lowerCAmelCase   ,       )










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     _A (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.39_86, -8.23_91, 12.51_89], [-6.32_89, -8.08_64, 12.62_11], [-6.24_18, -8.04_45, 12.79_68]]]      ).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.42_60, -0.76_28, 0.84_53], [-1.47_19, -0.13_91, 0.78_07], [-1.76_78, 0.01_14, 0.46_46]]]      ).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     _A (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.22_53, -9.71_73, -6.35_29], [-7.67_01, -9.01_45, -1.93_82], [-8.01_95, -7.00_04, -0.15_23]]]      ).to(lowerCAmelCase      )

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







							@slow
							def     _A (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   ,       )






