


import unittest

from transformers.testing_utils import is_torch_available, require_torch, tooslow

from ...generation.test_utils import torch_device
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 import (
							    CpmAntConfig,
							    CpmAntForCausalLM,
							    CpmAntModel,
							    CpmAntTokenizer,
							)

@require_torch
class   A__							:




						def __init__(    self   : int			,      _a   : Optional[Any]			,      _a   : List[Any]=2			,      _a   : Tuple=8			,      _a   : int=True			,      _a   : Tuple=False			,      _a   : int=False			,      _a   : List[str]=False			,      _a   : Optional[Any]=False			,      _a   : Any=99			,      _a   : str=32			,      _a   : Tuple=3			,      _a   : Any=4			,      _a   : Tuple=37			,      _a   : Optional[int]=32			,      _a   : Tuple=128			,      _a   : Union[str, Any]=8			,      _a   : List[Any]=8			,      _a   : List[str]=8			,      _a   : Union[str, Any]=1.0			,      _a   : Dict=True			,      )							->       int:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE     					=parent
										_SCREAMING_SNAKE_CASE     					=batch_size
										_SCREAMING_SNAKE_CASE     					=seq_length
										_SCREAMING_SNAKE_CASE     					=is_training
										_SCREAMING_SNAKE_CASE     					=use_token_type_ids
										_SCREAMING_SNAKE_CASE     					=use_input_mask
										_SCREAMING_SNAKE_CASE     					=use_labels
										_SCREAMING_SNAKE_CASE     					=use_mc_token_ids
										_SCREAMING_SNAKE_CASE     					=vocab_size
										_SCREAMING_SNAKE_CASE     					=hidden_size
										_SCREAMING_SNAKE_CASE     					=num_hidden_layers
										_SCREAMING_SNAKE_CASE     					=num_attention_heads
										_SCREAMING_SNAKE_CASE     					=intermediate_size
										_SCREAMING_SNAKE_CASE     					=num_buckets
										_SCREAMING_SNAKE_CASE     					=max_distance
										_SCREAMING_SNAKE_CASE     					=prompt_length
										_SCREAMING_SNAKE_CASE     					=prompt_types
										_SCREAMING_SNAKE_CASE     					=segment_types
										_SCREAMING_SNAKE_CASE     					=init_std
										_SCREAMING_SNAKE_CASE     					=return_dict




						def 							__UpperCamelCase			(    self   : Any					)							->       str:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE     					={}
										_SCREAMING_SNAKE_CASE     					=ids_tensor([self.batch_size, self.seq_length]			,      self.vocab_size					).type(torch.intaa					)
										_SCREAMING_SNAKE_CASE     					=False

										_SCREAMING_SNAKE_CASE     					=self.get_config()

										return (config, input_ids)




						def 							__UpperCamelCase			(    self   : List[Any]					)							->       Tuple:


										"""simple docstring"""





										return CpmAntConfig(
										    vocab_size=self.vocab_size			,      hidden_size=self.hidden_size			,      num_hidden_layers=self.num_hidden_layers			,      num_attention_heads=self.num_attention_heads			,      dim_ff=self.intermediate_size			,      position_bias_num_buckets=self.num_buckets			,      position_bias_max_distance=self.max_distance			,      prompt_types=self.prompt_types			,      prompt_length=self.prompt_length			,      segment_types=self.segment_types			,      use_cache=_a			,      init_std=self.init_std			,      return_dict=self.return_dict			,      )




						def 							__UpperCamelCase			(    self   : Optional[Any]			,      _a   : Dict			,      _a   : List[str]			,      *_a   : int					)							->       Any:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE     					=CpmAntModel(config=_a					)
										model.to(_a					)
										model.eval()

										_SCREAMING_SNAKE_CASE     					=model(**_a					).last_hidden_state

										self.parent.assertEqual(hidden_states.shape			,      (self.batch_size, self.seq_length, config.hidden_size)					)




						def 							__UpperCamelCase			(    self   : Any			,      _a   : List[Any]			,      _a   : Tuple			,      *_a   : Tuple					)							->       Tuple:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE     					=CpmAntForCausalLM(_a					)
										model.to(_a					)
										_SCREAMING_SNAKE_CASE     					=input_ids['''input_ids'''].to(_a					)
										model.eval()

										_SCREAMING_SNAKE_CASE     					=model(**_a					)
										self.parent.assertEqual(
										    model_output.logits.shape			,      (self.batch_size, self.seq_length, config.vocab_size + config.prompt_types * config.prompt_length)			,      )




						def 							__UpperCamelCase			(    self   : List[Any]					)							->       List[str]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE					,			_SCREAMING_SNAKE_CASE     					=self.prepare_config_and_inputs()
										return config, inputs_dict

@require_torch
class   A__							(						UpperCamelCase__				,       UpperCamelCase__				,       unittest.TestCase					):
						UpperCAmelCase     =  (CpmAntModel, CpmAntForCausalLM) if is_torch_available() else ()
						UpperCAmelCase     =  (
						    {"feature-extraction": CpmAntModel, "text-generation": CpmAntForCausalLM} if is_torch_available() else {}
						)

						UpperCAmelCase     =  False
						UpperCAmelCase     =  False
						UpperCAmelCase     =  False
						UpperCAmelCase     =  False
						UpperCAmelCase     =  False




						def 							__UpperCamelCase			(    self   : Union[str, Any]					)							->       List[Any]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE     					=CpmAntModelTester(self					)
										_SCREAMING_SNAKE_CASE     					=ConfigTester(self			,      config_class=_a					)




						def 							__UpperCamelCase			(    self   : Union[str, Any]					)							->       Union[str, Any]:


										"""simple docstring"""





										self.config_tester.create_and_test_config_common_properties()
										self.config_tester.create_and_test_config_to_json_string()
										self.config_tester.create_and_test_config_to_json_file()
										self.config_tester.create_and_test_config_from_and_save_pretrained()
										self.config_tester.check_config_can_be_init_without_params()
										self.config_tester.check_config_arguments_init()




						def 							__UpperCamelCase			(    self   : Optional[int]					)							->       List[Any]:


										"""simple docstring"""





										unittest.skip('''CPMAnt doesn\'t support input_embeds.'''					)(self.test_inputs_embeds					)




						def 							__UpperCamelCase			(    self   : List[str]					)							->       Dict:


										"""simple docstring"""





										unittest.skip(
										    '''CPMAnt doesn\'t support retain grad in hidden_states or attentions, because prompt management will peel off the output.hidden_states from graph.\
                 So is attentions. We strongly recommand you use loss to tune model.'''					)(self.test_retain_grad_hidden_states_attentions					)




						def 							__UpperCamelCase			(    self   : Optional[Any]					)							->       Optional[int]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE					,			_SCREAMING_SNAKE_CASE     					=self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_cpmant_model(_a			,      _a					)




						def 							__UpperCamelCase			(    self   : Dict					)							->       Dict:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE					,			_SCREAMING_SNAKE_CASE     					=self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_lm_head_model(_a			,      _a					)

@require_torch
class   A__							(						unittest.TestCase					):




						@tooslow
						def 							__UpperCamelCase			(    self   : Tuple					)							->       Union[str, Any]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE     					='''今天天气真好！'''
										_SCREAMING_SNAKE_CASE     					='''openbmb/cpm-ant-10b'''
										_SCREAMING_SNAKE_CASE     					=CpmAntModel.from_pretrained(_a					)
										_SCREAMING_SNAKE_CASE     					=CpmAntTokenizer.from_pretrained(_a					)
										_SCREAMING_SNAKE_CASE     					=tokenizer(_a			,      return_tensors='''pt'''					)
										_SCREAMING_SNAKE_CASE     					=model(**_a					).last_hidden_state

										_SCREAMING_SNAKE_CASE     					=torch.tensor(
										    [[[6.17_08, 5.92_44, 1.08_35], [6.52_07, 6.28_93, -11.33_24], [-1.01_07, -0.05_76, -5.95_77]]]			,      )
										self.assertTrue(torch.allclose(hidden_states[:, :3, :3]			,      _a			,      atol=1E-2					)					)

@require_torch
class   A__							(						unittest.TestCase					):




						@tooslow
						def 							__UpperCamelCase			(    self   : int					)							->       List[str]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE     					='''今天天气真好！'''
										_SCREAMING_SNAKE_CASE     					='''openbmb/cpm-ant-10b'''
										_SCREAMING_SNAKE_CASE     					=CpmAntForCausalLM.from_pretrained(_a					)
										_SCREAMING_SNAKE_CASE     					=CpmAntTokenizer.from_pretrained(_a					)
										_SCREAMING_SNAKE_CASE     					=tokenizer(_a			,      return_tensors='''pt'''					)
										_SCREAMING_SNAKE_CASE     					=model(**_a					).logits

										_SCREAMING_SNAKE_CASE     					=torch.tensor(
										    [[[-6.42_67, -6.40_83, -6.39_58], [-5.88_02, -5.94_47, -5.78_11], [-5.38_96, -5.48_20, -5.42_95]]]			,      )
										self.assertTrue(torch.allclose(hidden_states[:, :3, :3]			,      _a			,      atol=1E-2					)					)




						@tooslow
						def 							__UpperCamelCase			(    self   : Union[str, Any]					)							->       Dict:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE     					='''openbmb/cpm-ant-10b'''
										_SCREAMING_SNAKE_CASE     					=CpmAntForCausalLM.from_pretrained(_a					)
										_SCREAMING_SNAKE_CASE     					=CpmAntTokenizer.from_pretrained(_a					)
										_SCREAMING_SNAKE_CASE     					='''今天天气不错，'''
										_SCREAMING_SNAKE_CASE     					='''今天天气不错，阳光明媚，我和妈妈一起去超市买东西。\n在超市里，我看到了一个很好玩的玩具，它的名字叫“机器人”。它有一个圆圆的脑袋，两只圆圆的眼睛，还有一个圆圆的'''
										_SCREAMING_SNAKE_CASE     					=tokenizer(_a			,      return_tensors='''pt'''					)
										_SCREAMING_SNAKE_CASE     					=model.generate(**_a					)
										_SCREAMING_SNAKE_CASE     					=tokenizer.batch_decode(_a					)
										self.assertEqual(_a			,      _a					)




						@tooslow
						def 							__UpperCamelCase			(    self   : Dict					)							->       Any:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE     					='''openbmb/cpm-ant-10b'''
										_SCREAMING_SNAKE_CASE     					=CpmAntForCausalLM.from_pretrained(_a					)
										_SCREAMING_SNAKE_CASE     					=CpmAntTokenizer.from_pretrained(_a					)
										_SCREAMING_SNAKE_CASE     					=['''今天天气不错，''', '''新年快乐，万事如意！''']
										_SCREAMING_SNAKE_CASE     					=[
										    '''今天天气不错，阳光明媚，我和妈妈一起去超市买东西。\n在超市里，我看到了一个很好玩的玩具，它的名字叫“机器人”。它有一个圆圆的脑袋，两只圆圆的眼睛，还有一个圆圆的''',
										    '''新年快乐，万事如意！在这辞旧迎新的美好时刻，我谨代表《农村新技术》杂志社全体同仁，向一直以来关心、支持《农村新技术》杂志发展的各级领导、各界朋友和广大读者致以最诚挚的''',
										]
										_SCREAMING_SNAKE_CASE     					=tokenizer(_a			,      return_tensors='''pt'''			,      padding=_a					)
										_SCREAMING_SNAKE_CASE     					=model.generate(**_a					)
										_SCREAMING_SNAKE_CASE     					=tokenizer.batch_decode(_a					)
										self.assertEqual(_a			,      _a					)



import unittest

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

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

from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()

class   A__							(						UpperCamelCase__				,       unittest.TestCase					):
						UpperCAmelCase     =  KandinskyPriorPipeline
						UpperCAmelCase     =  ["prompt"]
						UpperCAmelCase     =  ["prompt", "negative_prompt"]
						UpperCAmelCase     =  [
						    "num_images_per_prompt",
						    "generator",
						    "num_inference_steps",
						    "latents",
						    "negative_prompt",
						    "guidance_scale",
						    "output_type",
						    "return_dict",
						]
						UpperCAmelCase     =  False




						@property
						def 							__UpperCamelCase			(    self   : Tuple					)							->       Tuple:


										"""simple docstring"""





										return 32




						@property
						def 							__UpperCamelCase			(    self   : Optional[int]					)							->       Tuple:


										"""simple docstring"""





										return 32




						@property
						def 							__UpperCamelCase			(    self   : Tuple					)							->       int:


										"""simple docstring"""





										return self.time_input_dim




						@property
						def 							__UpperCamelCase			(    self   : Optional[Any]					)							->       Any:


										"""simple docstring"""





										return self.time_input_dim * 4




						@property
						def 							__UpperCamelCase			(    self   : List[str]					)							->       str:


										"""simple docstring"""





										return 100




						@property
						def 							__UpperCamelCase			(    self   : List[Any]					)							->       List[str]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE     					=CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''					)
										return tokenizer




						@property
						def 							__UpperCamelCase			(    self   : Any					)							->       Dict:


										"""simple docstring"""





										torch.manual_seed(0					)
										_SCREAMING_SNAKE_CASE     					=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=37			,      layer_norm_eps=1E-05			,      num_attention_heads=4			,      num_hidden_layers=5			,      pad_token_id=1			,      vocab_size=1000			,      )
										return CLIPTextModelWithProjection(_a					)




						@property
						def 							__UpperCamelCase			(    self   : int					)							->       Any:


										"""simple docstring"""





										torch.manual_seed(0					)

										_SCREAMING_SNAKE_CASE     					={
										    '''num_attention_heads''': 2,
										    '''attention_head_dim''': 12,
										    '''embedding_dim''': self.text_embedder_hidden_size,
										    '''num_layers''': 1,
										}

										_SCREAMING_SNAKE_CASE     					=PriorTransformer(**_a					)
										# 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
										_SCREAMING_SNAKE_CASE     					=nn.Parameter(torch.ones(model.clip_std.shape					)					)
										return model




						@property
						def 							__UpperCamelCase			(    self   : List[str]					)							->       Optional[Any]:


										"""simple docstring"""





										torch.manual_seed(0					)
										_SCREAMING_SNAKE_CASE     					=CLIPVisionConfig(
										    hidden_size=self.text_embedder_hidden_size			,      image_size=224			,      projection_dim=self.text_embedder_hidden_size			,      intermediate_size=37			,      num_attention_heads=4			,      num_channels=3			,      num_hidden_layers=5			,      patch_size=14			,      )

										_SCREAMING_SNAKE_CASE     					=CLIPVisionModelWithProjection(_a					)
										return model




						@property
						def 							__UpperCamelCase			(    self   : Any					)							->       int:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE     					=CLIPImageProcessor(
										    crop_size=224			,      do_center_crop=_a			,      do_normalize=_a			,      do_resize=_a			,      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=224			,      )

										return image_processor




						def 							__UpperCamelCase			(    self   : int					)							->       Optional[int]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE     					=self.dummy_prior
										_SCREAMING_SNAKE_CASE     					=self.dummy_image_encoder
										_SCREAMING_SNAKE_CASE     					=self.dummy_text_encoder
										_SCREAMING_SNAKE_CASE     					=self.dummy_tokenizer
										_SCREAMING_SNAKE_CASE     					=self.dummy_image_processor

										_SCREAMING_SNAKE_CASE     					=UnCLIPScheduler(
										    variance_type='''fixed_small_log'''			,      prediction_type='''sample'''			,      num_train_timesteps=1000			,      clip_sample=_a			,      clip_sample_range=10.0			,      )

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

										return components




						def 							__UpperCamelCase			(    self   : Optional[Any]			,      _a   : Tuple			,      _a   : str=0					)							->       Any:


										"""simple docstring"""





										if str(_a					).startswith('''mps'''					):
														_SCREAMING_SNAKE_CASE     					=torch.manual_seed(_a					)
										else:
														_SCREAMING_SNAKE_CASE     					=torch.Generator(device=_a					).manual_seed(_a					)
										_SCREAMING_SNAKE_CASE     					={
										    '''prompt''': '''horse''',
										    '''generator''': generator,
										    '''guidance_scale''': 4.0,
										    '''num_inference_steps''': 2,
										    '''output_type''': '''np''',
										}
										return inputs




						def 							__UpperCamelCase			(    self   : Optional[int]					)							->       Tuple:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE     					='''cpu'''

										_SCREAMING_SNAKE_CASE     					=self.get_dummy_components()

										_SCREAMING_SNAKE_CASE     					=self.pipeline_class(**_a					)
										_SCREAMING_SNAKE_CASE     					=pipe.to(_a					)

										pipe.set_progress_bar_config(disable=_a					)

										_SCREAMING_SNAKE_CASE     					=pipe(**self.get_dummy_inputs(_a					)					)
										_SCREAMING_SNAKE_CASE     					=output.image_embeds

										_SCREAMING_SNAKE_CASE     					=pipe(
										    **self.get_dummy_inputs(_a					)			,      return_dict=_a			,      )[0]

										_SCREAMING_SNAKE_CASE     					=image[0, -10:]
										_SCREAMING_SNAKE_CASE     					=image_from_tuple[0, -10:]

										assert image.shape == (1, 32)

										_SCREAMING_SNAKE_CASE     					=np.array(
										    [-0.05_32, 1.71_20, 0.36_56, -1.08_52, -0.89_46, -1.17_56, 0.43_48, 0.24_82, 0.51_46, -0.11_56]					)

										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 							__UpperCamelCase			(    self   : List[str]					)							->       List[Any]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE     					=torch_device == '''cpu'''
										_SCREAMING_SNAKE_CASE     					=True
										_SCREAMING_SNAKE_CASE     					=False

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




						@skip_mps
						def 							__UpperCamelCase			(    self   : List[Any]					)							->       str:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE     					=torch_device == '''cpu'''
										_SCREAMING_SNAKE_CASE     					=False

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