"""simple docstring"""




import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel

from diffusers import DDIMScheduler, LDMPipeline, UNetaDModel, VQModel
from diffusers.utils.testing_utils import enable_full_determinism, require_torch, slow, torch_device


enable_full_determinism()
class 		__A							(				unittest.TestCase	):






     @property
     def 					__A						(	self						):
       torch.manual_seed(0						)
       _lowerCAmelCase		: Any						    =  UNetaDModel(
           block_out_channels=(32, 64)       ,  layers_per_block=2       ,  sample_size=32       ,  in_channels=3       ,  out_channels=3       ,  down_block_types=("""DownBlock2D""", """AttnDownBlock2D""")       ,  up_block_types=("""AttnUpBlock2D""", """UpBlock2D""")       ,  )
       return model






     @property
     def 					__A						(	self						):
       torch.manual_seed(0						)
       _lowerCAmelCase		: Tuple						    =  VQModel(
           block_out_channels=[32, 64]       ,  in_channels=3       ,  out_channels=3       ,  down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""]       ,  up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""]       ,  latent_channels=3       ,  )
       return model






     @property
     def 					__A						(	self						):
       torch.manual_seed(0						)
       _lowerCAmelCase		: Tuple						    =  CLIPTextConfig(
           bos_token_id=0       ,  eos_token_id=2       ,  hidden_size=32       ,  intermediate_size=37       ,  layer_norm_eps=1e-05       ,  num_attention_heads=4       ,  num_hidden_layers=5       ,  pad_token_id=1       ,  vocab_size=1000       ,  )
       return CLIPTextModel(a__						)






     def 					__A						(	self						):
       _lowerCAmelCase		: List[Any]						    =  self.dummy_uncond_unet
       _lowerCAmelCase		: List[str]						    =  DDIMScheduler()
       _lowerCAmelCase		: List[Any]						    =  self.dummy_vq_model

       _lowerCAmelCase		: Tuple						    =  LDMPipeline(unet=a__       ,  vqvae=a__       ,  scheduler=a__						)
       ldm.to(a__						)
       ldm.set_progress_bar_config(disable=a__						)

       _lowerCAmelCase		: int						    =  torch.manual_seed(0						)
       _lowerCAmelCase		: str						    =  ldm(generator=a__       ,  num_inference_steps=2       ,  output_type="""numpy"""						).images

       _lowerCAmelCase		: List[Any]						    =  torch.manual_seed(0						)
       _lowerCAmelCase		: List[str]						    =  ldm(generator=a__       ,  num_inference_steps=2       ,  output_type="""numpy"""       ,  return_dict=a__						)[0]

       _lowerCAmelCase		: Optional[Any]						    =  image[0, -3:, -3:, -1]
       _lowerCAmelCase		: int						    =  image_from_tuple[0, -3:, -3:, -1]

       assert image.shape == (1, 64, 64, 3)
       _lowerCAmelCase		: int						    =  np.array([0.8_5_1_2, 0.8_1_8, 0.6_4_1_1, 0.6_8_0_8, 0.4_4_6_5, 0.5_6_1_8, 0.4_6, 0.6_2_3_1, 0.5_1_7_2]						)
       _lowerCAmelCase		: Optional[Any]						    =  1e-2 if torch_device != """mps""" else 3e-2

       assert np.abs(image_slice.flatten() - expected_slice						).max() < tolerance
       assert np.abs(image_from_tuple_slice.flatten() - expected_slice						).max() < tolerance







@slow
@require_torch
class 		__A							(				unittest.TestCase	):






     def 					__A						(	self						):
       _lowerCAmelCase		: List[str]						    =  LDMPipeline.from_pretrained("""CompVis/ldm-celebahq-256"""						)
       ldm.to(a__						)
       ldm.set_progress_bar_config(disable=a__						)

       _lowerCAmelCase		: Union[str, Any]						    =  torch.manual_seed(0						)
       _lowerCAmelCase		: int						    =  ldm(generator=a__       ,  num_inference_steps=5       ,  output_type="""numpy"""						).images

       _lowerCAmelCase		: Union[str, Any]						    =  image[0, -3:, -3:, -1]

       assert image.shape == (1, 256, 256, 3)
       _lowerCAmelCase		: List[Any]						    =  np.array([0.4_3_9_9, 0.4_4_9_7_5, 0.4_6_8_2_5, 0.4_7_4, 0.4_3_5_9, 0.4_5_8_1, 0.4_5_0_9_5, 0.4_3_4_1, 0.4_4_4_7]						)
       _lowerCAmelCase		: Dict						    =  1e-2 if torch_device != """mps""" else 3e-2

       assert np.abs(image_slice.flatten() - expected_slice						).max() < tolerance





"""simple docstring"""




import os
import unittest

from transformers.models.cpmant.tokenization_cpmant import VOCAB_FILES_NAMES, CpmAntTokenizer
from transformers.testing_utils import require_jieba, tooslow

from ...test_tokenization_common import TokenizerTesterMixin
@require_jieba
class 		__A							(				SCREAMING_SNAKE_CASE_					,			unittest.TestCase	):
     _UpperCamelCase							:    str	      =	CpmAntTokenizer
     _UpperCamelCase							:    List[Any]	      =	False






     def 					__A						(	self						):
       super().setUp()

       _lowerCAmelCase		: Dict						    =  [
           """<d>""",
           """</d>""",
           """<s>""",
           """</s>""",
           """</_>""",
           """<unk>""",
           """<pad>""",
           """</n>""",
           """我""",
           """是""",
           """C""",
           """P""",
           """M""",
           """A""",
           """n""",
           """t""",
       ]
       _lowerCAmelCase		: int						    =  os.path.join(self.tmpdirname       ,  VOCAB_FILES_NAMES["""vocab_file"""]						)
       with open(self.vocab_file       ,  """w"""       ,  encoding="""utf-8"""						) as vocab_writer:
         vocab_writer.write("""""".join([x + """\n""" for x in vocab_tokens]						)						)






     @tooslow
     def 					__A						(	self						):
       _lowerCAmelCase		: Tuple						    =  CpmAntTokenizer.from_pretrained("""openbmb/cpm-ant-10b"""						)
       _lowerCAmelCase		: Optional[Any]						    =  """今天天气真好！"""
       _lowerCAmelCase		: Any						    =  ["""今天""", """天气""", """真""", """好""", """！"""]
       _lowerCAmelCase		: str						    =  tokenizer.tokenize(a__						)
       self.assertListEqual(a__       ,  a__						)
       _lowerCAmelCase		: Tuple						    =  """今天天气真好！"""
       _lowerCAmelCase		: Optional[Any]						    =  [tokenizer.bos_token] + tokens

       _lowerCAmelCase		: Optional[int]						    =  [6, 9802, 14962, 2082, 831, 244]
       self.assertListEqual(tokenizer.convert_tokens_to_ids(a__						)       ,  a__						)

       _lowerCAmelCase		: Tuple						    =  tokenizer.decode(a__						)
       self.assertEqual(a__       ,  a__						)




