




'''simple docstring'''







import gc
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModelWithProjection, CLIPTokenizer

from diffusers import PriorTransformer, UnCLIPPipeline, UnCLIPScheduler, UNetaDConditionModel, UNetaDModel
from diffusers.pipelines.unclip.text_proj import UnCLIPTextProjModel
from diffusers.utils import load_numpy, nightly, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu, skip_mps

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()


class       _a  (     __a							,							unittest.TestCase			):
       __a    :					Tuple           = UnCLIPPipeline
       __a    :					int           = TEXT_TO_IMAGE_PARAMS - {
           """negative_prompt""",
           """height""",
           """width""",
           """negative_prompt_embeds""",
           """guidance_scale""",
           """prompt_embeds""",
           """cross_attention_kwargs""",
       }
       __a    :					Tuple           = TEXT_TO_IMAGE_BATCH_PARAMS
       __a    :					Union[str, Any]           = [
           """generator""",
           """return_dict""",
           """prior_num_inference_steps""",
           """decoder_num_inference_steps""",
           """super_res_num_inference_steps""",
       ]
       __a    :					List[str]           = False
       @property
       def    A				(     self						:     Tuple    ):



           '''simple docstring'''

           return 32
       @property
       def    A				(     self						:     int    ):



           '''simple docstring'''

           return 32
       @property
       def    A				(     self						:     Any    ):



           '''simple docstring'''

           return self.time_input_dim
       @property
       def    A				(     self						:     Union[str, Any]    ):



           '''simple docstring'''

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



           '''simple docstring'''

           return 100
       @property
       def    A				(     self						:     Optional[Any]    ):



           '''simple docstring'''

           UpperCAmelCase      	=		CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''    )
           return tokenizer
       @property
       def    A				(     self						:     Optional[Any]    ):



           '''simple docstring'''

           torch.manual_seed(0    )
           UpperCAmelCase      	=		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=1_000       ,    )
           return CLIPTextModelWithProjection(lowercase    )
       @property
       def    A				(     self						:     str    ):



           '''simple docstring'''

           torch.manual_seed(0    )

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

           UpperCAmelCase      	=		PriorTransformer(**lowercase    )
           return model
       @property
       def    A				(     self						:     Optional[Any]    ):



           '''simple docstring'''

           torch.manual_seed(0    )

           UpperCAmelCase      	=		{
               '''clip_embeddings_dim''': self.text_embedder_hidden_size,
               '''time_embed_dim''': self.time_embed_dim,
               '''cross_attention_dim''': self.cross_attention_dim,
           }

           UpperCAmelCase      	=		UnCLIPTextProjModel(**lowercase    )
           return model
       @property
       def    A				(     self						:     Any    ):



           '''simple docstring'''

           torch.manual_seed(0    )

           UpperCAmelCase      	=		{
               '''sample_size''': 32,
               # RGB in channels
               '''in_channels''': 3,
               # Out channels is double in channels because predicts mean and variance
               '''out_channels''': 6,
               '''down_block_types''': ('''ResnetDownsampleBlock2D''', '''SimpleCrossAttnDownBlock2D'''),
               '''up_block_types''': ('''SimpleCrossAttnUpBlock2D''', '''ResnetUpsampleBlock2D'''),
               '''mid_block_type''': '''UNetMidBlock2DSimpleCrossAttn''',
               '''block_out_channels''': (self.block_out_channels_a, self.block_out_channels_a * 2),
               '''layers_per_block''': 1,
               '''cross_attention_dim''': self.cross_attention_dim,
               '''attention_head_dim''': 4,
               '''resnet_time_scale_shift''': '''scale_shift''',
               '''class_embed_type''': '''identity''',
           }

           UpperCAmelCase      	=		UNetaDConditionModel(**lowercase    )
           return model
       @property
       def    A				(     self						:     Union[str, Any]    ):



           '''simple docstring'''

           return {
               "sample_size": 64,
               "layers_per_block": 1,
               "down_block_types": ("ResnetDownsampleBlock2D", "ResnetDownsampleBlock2D"),
               "up_block_types": ("ResnetUpsampleBlock2D", "ResnetUpsampleBlock2D"),
               "block_out_channels": (self.block_out_channels_a, self.block_out_channels_a * 2),
               "in_channels": 6,
               "out_channels": 3,
           }
       @property
       def    A				(     self						:     Any    ):



           '''simple docstring'''

           torch.manual_seed(0    )

           UpperCAmelCase      	=		UNetaDModel(**self.dummy_super_res_kwargs    )
           return model
       @property
       def    A				(     self						:     Tuple    ):



           '''simple docstring'''

           torch.manual_seed(1    )

           UpperCAmelCase      	=		UNetaDModel(**self.dummy_super_res_kwargs    )
           return model
       def    A				(     self						:     Tuple    ):



           '''simple docstring'''

           UpperCAmelCase      	=		self.dummy_prior
           UpperCAmelCase      	=		self.dummy_decoder
           UpperCAmelCase      	=		self.dummy_text_proj
           UpperCAmelCase      	=		self.dummy_text_encoder
           UpperCAmelCase      	=		self.dummy_tokenizer
           UpperCAmelCase      	=		self.dummy_super_res_first
           UpperCAmelCase      	=		self.dummy_super_res_last

           UpperCAmelCase      	=		UnCLIPScheduler(
               variance_type='''fixed_small_log'''       ,    prediction_type='''sample'''       ,    num_train_timesteps=1_000       ,    clip_sample_range=5.0       ,    )

           UpperCAmelCase      	=		UnCLIPScheduler(
               variance_type='''learned_range'''       ,    prediction_type='''epsilon'''       ,    num_train_timesteps=1_000       ,    )

           UpperCAmelCase      	=		UnCLIPScheduler(
               variance_type='''fixed_small_log'''       ,    prediction_type='''epsilon'''       ,    num_train_timesteps=1_000       ,    )

           UpperCAmelCase      	=		{
               '''prior''': prior,
               '''decoder''': decoder,
               '''text_proj''': text_proj,
               '''text_encoder''': text_encoder,
               '''tokenizer''': tokenizer,
               '''super_res_first''': super_res_first,
               '''super_res_last''': super_res_last,
               '''prior_scheduler''': prior_scheduler,
               '''decoder_scheduler''': decoder_scheduler,
               '''super_res_scheduler''': super_res_scheduler,
           }

           return components
       def    A				(     self						:     str       ,    lowercase						:     Tuple       ,    lowercase						:     List[Any]=0    ):



           '''simple docstring'''

           if str(lowercase    ).startswith('''mps'''    ):
               UpperCAmelCase      	=		torch.manual_seed(lowercase    )
           else:
               UpperCAmelCase      	=		torch.Generator(device=lowercase    ).manual_seed(lowercase    )
           UpperCAmelCase      	=		{
               '''prompt''': '''horse''',
               '''generator''': generator,
               '''prior_num_inference_steps''': 2,
               '''decoder_num_inference_steps''': 2,
               '''super_res_num_inference_steps''': 2,
               '''output_type''': '''numpy''',
           }
           return inputs
       def    A				(     self						:     Optional[int]    ):



           '''simple docstring'''

           UpperCAmelCase      	=		'''cpu'''

           UpperCAmelCase      	=		self.get_dummy_components()

           UpperCAmelCase      	=		self.pipeline_class(**lowercase    )
           UpperCAmelCase      	=		pipe.to(lowercase    )

           pipe.set_progress_bar_config(disable=lowercase    )

           UpperCAmelCase      	=		pipe(**self.get_dummy_inputs(lowercase    )    )
           UpperCAmelCase      	=		output.images

           UpperCAmelCase      	=		pipe(
               **self.get_dummy_inputs(lowercase    )       ,    return_dict=lowercase       ,    )[0]

           UpperCAmelCase      	=		image[0, -3:, -3:, -1]
           UpperCAmelCase      	=		image_from_tuple[0, -3:, -3:, -1]

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

           UpperCAmelCase      	=		np.array(
               [
                   0.9997,
                   0.9988,
                   0.0028,
                   0.9997,
                   0.9984,
                   0.9965,
                   0.0029,
                   0.9986,
                   0.0025,
               ]    )

           assert np.abs(image_slice.flatten() - expected_slice    ).max() < 1E-2
           assert np.abs(image_from_tuple_slice.flatten() - expected_slice    ).max() < 1E-2
       def    A				(     self						:     List[str]    ):



           '''simple docstring'''

           UpperCAmelCase      	=		torch.device('''cpu'''    )


           class       _a  :
                  __a    :					List[str]           = 1






           UpperCAmelCase      	=		self.get_dummy_components()

           UpperCAmelCase      	=		self.pipeline_class(**lowercase    )
           UpperCAmelCase      	=		pipe.to(lowercase    )

           UpperCAmelCase      	=		components['''prior''']
           UpperCAmelCase      	=		components['''decoder''']
           UpperCAmelCase      	=		components['''super_res_first''']
           UpperCAmelCase      	=		components['''tokenizer''']
           UpperCAmelCase      	=		components['''text_encoder''']

           UpperCAmelCase      	=		torch.Generator(device=lowercase    ).manual_seed(0    )
           UpperCAmelCase      	=		prior.dtype
           UpperCAmelCase      	=		1

           UpperCAmelCase      	=		(batch_size, prior.config.embedding_dim)
           UpperCAmelCase      	=		pipe.prepare_latents(
               lowercase       ,    dtype=lowercase       ,    device=lowercase       ,    generator=lowercase       ,    latents=lowercase       ,    scheduler=DummyScheduler()    )
           UpperCAmelCase      	=		(batch_size, decoder.config.in_channels, decoder.config.sample_size, decoder.config.sample_size)
           UpperCAmelCase      	=		pipe.prepare_latents(
               lowercase       ,    dtype=lowercase       ,    device=lowercase       ,    generator=lowercase       ,    latents=lowercase       ,    scheduler=DummyScheduler()    )

           UpperCAmelCase      	=		(
               batch_size,
               super_res_first.config.in_channels // 2,
               super_res_first.config.sample_size,
               super_res_first.config.sample_size,
           )
           UpperCAmelCase      	=		pipe.prepare_latents(
               lowercase       ,    dtype=lowercase       ,    device=lowercase       ,    generator=lowercase       ,    latents=lowercase       ,    scheduler=DummyScheduler()    )

           pipe.set_progress_bar_config(disable=lowercase    )

           UpperCAmelCase      	=		'''this is a prompt example'''

           UpperCAmelCase      	=		torch.Generator(device=lowercase    ).manual_seed(0    )
           UpperCAmelCase      	=		pipe(
               [prompt]       ,    generator=lowercase       ,    prior_num_inference_steps=2       ,    decoder_num_inference_steps=2       ,    super_res_num_inference_steps=2       ,    prior_latents=lowercase       ,    decoder_latents=lowercase       ,    super_res_latents=lowercase       ,    output_type='''np'''       ,    )
           UpperCAmelCase      	=		output.images

           UpperCAmelCase      	=		tokenizer(
               lowercase       ,    padding='''max_length'''       ,    max_length=tokenizer.model_max_length       ,    return_tensors='''pt'''       ,    )
           UpperCAmelCase      	=		text_encoder(text_inputs.input_ids    )
           UpperCAmelCase      	=		text_inputs.attention_mask

           UpperCAmelCase      	=		torch.Generator(device=lowercase    ).manual_seed(0    )
           UpperCAmelCase      	=		pipe(
               generator=lowercase       ,    prior_num_inference_steps=2       ,    decoder_num_inference_steps=2       ,    super_res_num_inference_steps=2       ,    prior_latents=lowercase       ,    decoder_latents=lowercase       ,    super_res_latents=lowercase       ,    text_model_output=lowercase       ,    text_attention_mask=lowercase       ,    output_type='''np'''       ,    )[0]

           # make sure passing text embeddings manually is identical
           assert np.abs(image - image_from_text    ).max() < 1E-4
       @skip_mps
       def    A				(     self						:     List[str]    ):



           '''simple docstring'''

           UpperCAmelCase      	=		torch_device == '''cpu'''

           self._test_attention_slicing_forward_pass(test_max_difference=lowercase       ,    expected_max_diff=0.01    )
       @skip_mps
       def    A				(     self						:     Union[str, Any]    ):



           '''simple docstring'''

           UpperCAmelCase      	=		torch_device == '''cpu'''
           UpperCAmelCase      	=		True
           UpperCAmelCase      	=		[
               '''prior_num_inference_steps''',
               '''decoder_num_inference_steps''',
               '''super_res_num_inference_steps''',
           ]

           self._test_inference_batch_single_identical(
               test_max_difference=lowercase       ,    relax_max_difference=lowercase       ,    additional_params_copy_to_batched_inputs=lowercase       ,    )
       def    A				(     self						:     List[str]    ):



           '''simple docstring'''

           UpperCAmelCase      	=		[
               '''prior_num_inference_steps''',
               '''decoder_num_inference_steps''',
               '''super_res_num_inference_steps''',
           ]

           if torch_device == "mps":
               # TODO: MPS errors with larger batch sizes
               UpperCAmelCase      	=		[2, 3]
               self._test_inference_batch_consistent(
                   batch_sizes=lowercase       ,    additional_params_copy_to_batched_inputs=lowercase       ,    )
           else:
               self._test_inference_batch_consistent(
                   additional_params_copy_to_batched_inputs=lowercase    )
       @skip_mps
       def    A				(     self						:     List[str]    ):



           '''simple docstring'''

           return super().test_dict_tuple_outputs_equivalent()
       @skip_mps
       def    A				(     self						:     Tuple    ):



           '''simple docstring'''

           return super().test_save_load_local()







       @skip_mps
       def    A				(     self						:     int    ):



           '''simple docstring'''

           return super().test_save_load_optional_components()






@nightly
class       _a  (     unittest.TestCase			):
       def    A				(     self						:     Dict    ):



           '''simple docstring'''

           super().tearDown()
           gc.collect()
           torch.cuda.empty_cache()







       def    A				(     self						:     Optional[Any]    ):



           '''simple docstring'''

           UpperCAmelCase      	=		load_numpy(
               '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
               '''/unclip/karlo_v1_alpha_horse_cpu.npy'''    )

           UpperCAmelCase      	=		UnCLIPPipeline.from_pretrained('''kakaobrain/karlo-v1-alpha'''    )
           pipeline.set_progress_bar_config(disable=lowercase    )

           UpperCAmelCase      	=		torch.manual_seed(0    )
           UpperCAmelCase      	=		pipeline(
               '''horse'''       ,    num_images_per_prompt=1       ,    generator=lowercase       ,    output_type='''np'''       ,    )

           UpperCAmelCase      	=		output.images[0]

           assert image.shape == (256, 256, 3)
           assert np.abs(expected_image - image    ).max() < 1E-1






@slow
@require_torch_gpu
class       _a  (     unittest.TestCase			):
       def    A				(     self						:     Optional[int]    ):



           '''simple docstring'''

           super().tearDown()
           gc.collect()
           torch.cuda.empty_cache()
       def    A				(     self						:     Dict    ):



           '''simple docstring'''

           UpperCAmelCase      	=		load_numpy(
               '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
               '''/unclip/karlo_v1_alpha_horse_fp16.npy'''    )

           UpperCAmelCase      	=		UnCLIPPipeline.from_pretrained('''kakaobrain/karlo-v1-alpha'''       ,    torch_dtype=torch.floataa    )
           UpperCAmelCase      	=		pipeline.to(lowercase    )
           pipeline.set_progress_bar_config(disable=lowercase    )

           UpperCAmelCase      	=		torch.Generator(device='''cpu'''    ).manual_seed(0    )
           UpperCAmelCase      	=		pipeline(
               '''horse'''       ,    generator=lowercase       ,    output_type='''np'''       ,    )

           UpperCAmelCase      	=		output.images[0]

           assert image.shape == (256, 256, 3)

           assert_mean_pixel_difference(lowercase       ,    lowercase    )







       def    A				(     self						:     Tuple    ):



           '''simple docstring'''

           torch.cuda.empty_cache()
           torch.cuda.reset_max_memory_allocated()
           torch.cuda.reset_peak_memory_stats()

           UpperCAmelCase      	=		UnCLIPPipeline.from_pretrained('''kakaobrain/karlo-v1-alpha'''       ,    torch_dtype=torch.floataa    )
           UpperCAmelCase      	=		pipe.to(lowercase    )
           pipe.set_progress_bar_config(disable=lowercase    )
           pipe.enable_attention_slicing()
           pipe.enable_sequential_cpu_offload()

           UpperCAmelCase      	=		pipe(
               '''horse'''       ,    num_images_per_prompt=1       ,    prior_num_inference_steps=2       ,    decoder_num_inference_steps=2       ,    super_res_num_inference_steps=2       ,    output_type='''np'''       ,    )

           UpperCAmelCase      	=		torch.cuda.max_memory_allocated()
           # make sure that less than 7 GB is allocated
           assert mem_bytes < 7 * 10**9










'''simple docstring'''







import json
import os
import unittest

from transformers import HerbertTokenizer, HerbertTokenizerFast
from transformers.models.herbert.tokenization_herbert import VOCAB_FILES_NAMES
from transformers.testing_utils import get_tests_dir, require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin


@require_tokenizers
class       _a  (     __a							,							unittest.TestCase			):
       __a    :					str           = HerbertTokenizer
       __a    :					Optional[Any]           = HerbertTokenizerFast
       __a    :					Any           = True
       def    A				(     self						:     Any    ):



           '''simple docstring'''

           super().setUp()

           # Use a simpler test file without japanese/chinese characters
           with open(f"{get_tests_dir()}/fixtures/sample_text_no_unicode.txt"       ,    encoding='''utf-8'''    ) as f_data:
               UpperCAmelCase      	=		f_data.read().replace('''\n\n'''       ,    '''\n'''    ).strip()

           UpperCAmelCase      	=		[
               '''<s>''',
               '''</s>''',
               '''l''',
               '''o''',
               '''w''',
               '''e''',
               '''r''',
               '''s''',
               '''t''',
               '''i''',
               '''d''',
               '''n''',
               '''w</w>''',
               '''r</w>''',
               '''t</w>''',
               '''lo''',
               '''low''',
               '''er</w>''',
               '''low</w>''',
               '''lowest</w>''',
               '''newer</w>''',
               '''wider</w>''',
               ''',</w>''',
               '''<unk>''',
           ]
           UpperCAmelCase      	=		dict(zip(lowercase       ,    range(len(lowercase    )    )    )    )
           UpperCAmelCase      	=		['''l o 123''', '''lo w 1456''', '''e r</w> 1789''', '''''']

           UpperCAmelCase      	=		os.path.join(self.tmpdirname       ,    VOCAB_FILES_NAMES['''vocab_file''']    )
           UpperCAmelCase      	=		os.path.join(self.tmpdirname       ,    VOCAB_FILES_NAMES['''merges_file''']    )
           with open(self.vocab_file       ,    '''w'''    ) as fp:
               fp.write(json.dumps(lowercase    )    )
           with open(self.merges_file       ,    '''w'''    ) as fp:
               fp.write('''\n'''.join(lowercase    )    )
       def    A				(     self						:     List[Any]       ,    lowercase						:     Optional[Any]    ):



           '''simple docstring'''

           UpperCAmelCase      	=		'''lower newer'''
           UpperCAmelCase      	=		'''lower newer'''
           return input_text, output_text
       def    A				(     self						:     int    ):



           '''simple docstring'''

           UpperCAmelCase      	=		self.tokenizer_class(vocab_file=self.vocab_file       ,    merges_file=self.merges_file    )

           UpperCAmelCase      	=		'''lower'''
           UpperCAmelCase      	=		['''low''', '''er</w>''']
           UpperCAmelCase      	=		tokenizer.tokenize(lowercase    )
           self.assertListEqual(lowercase       ,    lowercase    )

           UpperCAmelCase      	=		tokens + ['''<unk>''']
           UpperCAmelCase      	=		[16, 17, 23]
           self.assertListEqual(tokenizer.convert_tokens_to_ids(lowercase    )       ,    lowercase    )
       def    A				(     self						:     str    ):



           '''simple docstring'''

           if not self.test_rust_tokenizer:
               return

           UpperCAmelCase      	=		self.get_tokenizer()
           UpperCAmelCase      	=		self.get_rust_tokenizer()

           UpperCAmelCase      	=		'''lower,newer'''

           UpperCAmelCase      	=		tokenizer.tokenize(lowercase    )
           UpperCAmelCase      	=		rust_tokenizer.tokenize(lowercase    )
           self.assertListEqual(lowercase       ,    lowercase    )

           UpperCAmelCase      	=		tokenizer.encode(lowercase       ,    add_special_tokens=lowercase    )
           UpperCAmelCase      	=		rust_tokenizer.encode(lowercase       ,    add_special_tokens=lowercase    )
           self.assertListEqual(lowercase       ,    lowercase    )

           UpperCAmelCase      	=		self.get_rust_tokenizer()
           UpperCAmelCase      	=		tokenizer.encode(lowercase    )
           UpperCAmelCase      	=		rust_tokenizer.encode(lowercase    )
           self.assertListEqual(lowercase       ,    lowercase    )







       @slow
       def    A				(     self						:     int    ):



           '''simple docstring'''

           UpperCAmelCase      	=		self.tokenizer_class.from_pretrained('''allegro/herbert-base-cased'''    )

           UpperCAmelCase      	=		tokenizer.encode('''konstruowanie sekwencji'''       ,    add_special_tokens=lowercase    )
           UpperCAmelCase      	=		tokenizer.encode('''konstruowanie wielu sekwencji'''       ,    add_special_tokens=lowercase    )

           UpperCAmelCase      	=		tokenizer.build_inputs_with_special_tokens(lowercase    )
           UpperCAmelCase      	=		tokenizer.build_inputs_with_special_tokens(lowercase       ,    lowercase    )

           assert encoded_sentence == [0] + text + [2]
           assert encoded_pair == [0] + text + [2] + text_a + [2]




