


import unittest

from transformers import SPIECE_UNDERLINE, XLNetTokenizer, XLNetTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin


_SCREAMING_SNAKE_CASE      :			Dict								=   get_tests_dir("fixtures/test_sentencepiece.model")

@require_sentencepiece
@require_tokenizers
class   A__ (   snake_case__	, unittest.TestCase     ):







    """simple docstring"""

    __magic_name__        =		XLNetTokenizer
    __magic_name__        =		XLNetTokenizerFast
    __magic_name__        =		True
    __magic_name__        =		True
    def 		a_      (	self   ):
         super().setUp()

         # We have a SentencePiece fixture for testing
         snake_case					=    XLNetTokenizer(__snake_case      , keep_accents=__snake_case   )
         tokenizer.sanitize_special_tokens()
         tokenizer.save_pretrained(self.tmpdirname   )
    def 		a_      (	self   ):
         snake_case					=    '''<s>'''
         snake_case					=    1

         self.assertEqual(self.get_tokenizer()._convert_token_to_id(__snake_case   )      , __snake_case   )
         self.assertEqual(self.get_tokenizer()._convert_id_to_token(__snake_case   )      , __snake_case   )
    def 		a_      (	self   ):
         snake_case					=    list(self.get_tokenizer().get_vocab().keys()   )

         self.assertEqual(vocab_keys[0]      , '''<unk>'''   )
         self.assertEqual(vocab_keys[1]      , '''<s>'''   )
         self.assertEqual(vocab_keys[-1]      , '''<eod>'''   )
         self.assertEqual(len(__snake_case   )      , 1_0_0_6   )
    def 		a_      (	self   ):
         self.assertEqual(self.get_tokenizer().vocab_size      , 1_0_0_0   )
    def 		a_      (	self   ):
         snake_case					=    XLNetTokenizer(__snake_case      , keep_accents=__snake_case   )

         snake_case					=    tokenizer.tokenize('''This is a test'''   )
         self.assertListEqual(__snake_case      , ['''▁This''', '''▁is''', '''▁a''', '''▁t''', '''est''']   )

         self.assertListEqual(tokenizer.convert_tokens_to_ids(__snake_case   )      , [2_8_5, 4_6, 1_0, 1_7_0, 3_8_2]   )

         snake_case					=    tokenizer.tokenize('''I was born in 92000, and this is falsé.'''   )
         self.assertListEqual(
             __snake_case      , [
                 SPIECE_UNDERLINE + '''I''',
                 SPIECE_UNDERLINE + '''was''',
                 SPIECE_UNDERLINE + '''b''',
                 '''or''',
                 '''n''',
                 SPIECE_UNDERLINE + '''in''',
                 SPIECE_UNDERLINE + '''''',
                 '''9''',
                 '''2''',
                 '''0''',
                 '''0''',
                 '''0''',
                 ''',''',
                 SPIECE_UNDERLINE + '''and''',
                 SPIECE_UNDERLINE + '''this''',
                 SPIECE_UNDERLINE + '''is''',
                 SPIECE_UNDERLINE + '''f''',
                 '''al''',
                 '''s''',
                 '''é''',
                 '''.''',
             ]      , )
         snake_case					=    tokenizer.convert_tokens_to_ids(__snake_case   )
         self.assertListEqual(__snake_case      , [8, 2_1, 8_4, 5_5, 2_4, 1_9, 7, 0, 6_0_2, 3_4_7, 3_4_7, 3_4_7, 3, 1_2, 6_6, 4_6, 7_2, 8_0, 6, 0, 4]   )

         snake_case					=    tokenizer.convert_ids_to_tokens(__snake_case   )
         self.assertListEqual(
             __snake_case      , [
                 SPIECE_UNDERLINE + '''I''',
                 SPIECE_UNDERLINE + '''was''',
                 SPIECE_UNDERLINE + '''b''',
                 '''or''',
                 '''n''',
                 SPIECE_UNDERLINE + '''in''',
                 SPIECE_UNDERLINE + '''''',
                 '''<unk>''',
                 '''2''',
                 '''0''',
                 '''0''',
                 '''0''',
                 ''',''',
                 SPIECE_UNDERLINE + '''and''',
                 SPIECE_UNDERLINE + '''this''',
                 SPIECE_UNDERLINE + '''is''',
                 SPIECE_UNDERLINE + '''f''',
                 '''al''',
                 '''s''',
                 '''<unk>''',
                 '''.''',
             ]      , )
    def 		a_      (	self   ):
         snake_case					=    XLNetTokenizer(__snake_case      , do_lower_case=__snake_case   )
         snake_case					=    tokenizer.tokenize('''I was born in 92000, and this is falsé.'''   )
         self.assertListEqual(
             __snake_case      , [
                 SPIECE_UNDERLINE + '''''',
                 '''i''',
                 SPIECE_UNDERLINE + '''was''',
                 SPIECE_UNDERLINE + '''b''',
                 '''or''',
                 '''n''',
                 SPIECE_UNDERLINE + '''in''',
                 SPIECE_UNDERLINE + '''''',
                 '''9''',
                 '''2''',
                 '''0''',
                 '''0''',
                 '''0''',
                 ''',''',
                 SPIECE_UNDERLINE + '''and''',
                 SPIECE_UNDERLINE + '''this''',
                 SPIECE_UNDERLINE + '''is''',
                 SPIECE_UNDERLINE + '''f''',
                 '''al''',
                 '''se''',
                 '''.''',
             ]      , )
         self.assertListEqual(tokenizer.tokenize('''H\u00E9llo'''   )      , ['''▁he''', '''ll''', '''o''']   )
    def 		a_      (	self   ):
         snake_case					=    XLNetTokenizer(__snake_case      , do_lower_case=__snake_case   )
         snake_case					=    tokenizer.tokenize('''I was born in 92000, and this is falsé.'''   )
         self.assertListEqual(
             __snake_case      , [
                 SPIECE_UNDERLINE + '''I''',
                 SPIECE_UNDERLINE + '''was''',
                 SPIECE_UNDERLINE + '''b''',
                 '''or''',
                 '''n''',
                 SPIECE_UNDERLINE + '''in''',
                 SPIECE_UNDERLINE + '''''',
                 '''9''',
                 '''2''',
                 '''0''',
                 '''0''',
                 '''0''',
                 ''',''',
                 SPIECE_UNDERLINE + '''and''',
                 SPIECE_UNDERLINE + '''this''',
                 SPIECE_UNDERLINE + '''is''',
                 SPIECE_UNDERLINE + '''f''',
                 '''al''',
                 '''se''',
                 '''.''',
             ]      , )
    @slow
    def 		a_      (	self   ):
         snake_case					=    XLNetTokenizer.from_pretrained('''xlnet-base-cased'''   )

         snake_case					=    tokenizer.encode('''sequence builders'''      , add_special_tokens=__snake_case   )
         snake_case					=    tokenizer.encode('''multi-sequence build'''      , add_special_tokens=__snake_case   )

         snake_case					=    tokenizer.build_inputs_with_special_tokens(__snake_case   )
         snake_case					=    tokenizer.build_inputs_with_special_tokens(__snake_case      , __snake_case   )

         assert encoded_sentence == text + [4, 3]
         assert encoded_pair == text + [4] + text_a + [4, 3]




    @slow
    def 		a_      (	self   ):
         # fmt: off
         snake_case					=    {'''input_ids''': [[1_7, 2_1_4_4_2, 2_7_0, 1_7, 1_0, 1_4_6_4_5, 3_1_8, 3_4, 1_7, 4_5_4_6, 3_1_4_5, 7_8_7, 1_3, 7_7_5_2, 2_2_0_1_8, 2_3, 2_1, 1_7, 4_5_4_6, 3_1_4_5, 7_8_7, 1_3, 3_3_5_2, 1_4_4_3_1, 1_3, 5_5_0_0, 1_1, 1_1_7_6, 5_8_0, 1_3, 1_6_8_1_9, 4_7_9_7, 2_3, 1_7, 1_0, 1_7_1_3_5, 6_5_8, 1_9, 4_5_7, 7_9_3_2, 1_3, 1_8_4, 1_9, 3_1_5_4, 1_7_1_3_5, 6_4_6_8, 1_9, 1_4_0_4, 1_2_2_6_9, 1_9, 4_2_2_9, 5_3_5_6, 1_6_2_6_4, 4_6, 1_9, 1_7, 2_0_5_4_5, 1_0_3_9_5, 9, 9, 9, 1_1, 2_8, 6_4_2_1, 9_5_3_1, 2_0_7_2_9, 1_7, 1_0, 3_5_3, 1_7_0_2_2, 1_1, 2_1, 6_4_2_1, 9_5_3_1, 1_6_9_4_9, 1_7, 1_0, 1_1_5_0_9, 7_5_3, 1_1, 3_3, 9_5, 2_4_2_1, 7_3_8_5, 9_5_6, 1_4_4_3_1, 2_6_2_6, 2_5, 8_4_2, 7_3_8_5, 4_8_3_6, 2_1, 1_4_2_9, 2_2_7_2, 9_8_5_5, 3_1_2_0, 1_6_1, 2_4_7_3_8, 1_9, 1_3_2_0_3, 6_5_8, 2_1_8, 7_8_7, 2_1, 4_3_0, 1_8_4_8_2, 8_4_7, 2_6_3_7, 9, 4, 3], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 3_2_2, 2_2_1_7_8, 2_7, 1_0_6_4, 2_2, 9_5_6, 1_3, 1_1_1_0_1, 1_4_2_9, 5_8_5_4, 2_4_3_1_3, 1_8_9_5_3, 4_0, 4_2_2, 2_4_3_6_6, 6_8, 1_7_5_8, 3_7, 1_0_4_8_3, 1_4_2_5_7, 3_1, 2_0_7, 2_6_3, 2_1, 2_0_3, 3_7_7_3, 2_5, 7_1, 9_7_3_5, 9, 4, 3], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 3_2, 2_0_4_9, 3_4_4_2, 1_7, 1_3_8_9_4, 3_3_8_0, 2_3, 9_5, 1_8, 1_7_6_3_4, 2_2_8_8, 9, 4, 3]], '''token_type_ids''': [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2]], '''attention_mask''': [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]}  # noqa: E501
         # fmt: on

         self.tokenizer_integration_test_util(
             expected_encoding=__snake_case      , model_name='''xlnet-base-cased'''      , revision='''c841166438c31ec7ca9a106dee7bb312b73ae511'''      , )








import gc
import random
import unittest

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

from diffusers import (
    DiffusionPipeline,
    UnCLIPImageVariationPipeline,
    UnCLIPScheduler,
    UNetaDConditionModel,
    UNetaDModel,
)
from diffusers.pipelines.unclip.text_proj import UnCLIPTextProjModel
from diffusers.utils import floats_tensor, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, load_image, require_torch_gpu, skip_mps

from ..pipeline_params import IMAGE_VARIATION_BATCH_PARAMS, IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()

class   A__ (   snake_case__	, unittest.TestCase     ):







    """simple docstring"""

    __magic_name__        =		UnCLIPImageVariationPipeline
    __magic_name__        =		IMAGE_VARIATION_PARAMS - {'height', 'width', 'guidance_scale'}
    __magic_name__        =		IMAGE_VARIATION_BATCH_PARAMS

    __magic_name__        =		[
        'generator',
        'return_dict',
        'decoder_num_inference_steps',
        'super_res_num_inference_steps',
    ]
    __magic_name__        =		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   ):
         snake_case					=    CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''   )
         return tokenizer
    @property
    def 		a_      (	self   ):
         torch.manual_seed(0   )
         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=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(__snake_case   )
    @property
    def 		a_      (	self   ):
         torch.manual_seed(0   )
         snake_case					=    CLIPVisionConfig(
             hidden_size=self.text_embedder_hidden_size      , projection_dim=self.text_embedder_hidden_size      , num_hidden_layers=5      , num_attention_heads=4      , image_size=3_2      , intermediate_size=3_7      , patch_size=1      , )
         return CLIPVisionModelWithProjection(__snake_case   )
    @property
    def 		a_      (	self   ):
         torch.manual_seed(0   )

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

         snake_case					=    UnCLIPTextProjModel(**__snake_case   )
         return model
    @property
    def 		a_      (	self   ):
         torch.manual_seed(0   )

         snake_case					=    {
             '''sample_size''': 3_2,
             # 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''',
         }

         snake_case					=    UNetaDConditionModel(**__snake_case   )
         return model
    @property
    def 		a_      (	self   ):
         return {
             "sample_size": 6_4,
             "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   ):
         torch.manual_seed(0   )

         snake_case					=    UNetaDModel(**self.dummy_super_res_kwargs   )
         return model
    @property
    def 		a_      (	self   ):
         # seeded differently to get different unet than `self.dummy_super_res_first`
         torch.manual_seed(1   )

         snake_case					=    UNetaDModel(**self.dummy_super_res_kwargs   )
         return model
    def 		a_      (	self   ):
         snake_case					=    self.dummy_decoder
         snake_case					=    self.dummy_text_proj
         snake_case					=    self.dummy_text_encoder
         snake_case					=    self.dummy_tokenizer
         snake_case					=    self.dummy_super_res_first
         snake_case					=    self.dummy_super_res_last

         snake_case					=    UnCLIPScheduler(
             variance_type='''learned_range'''      , prediction_type='''epsilon'''      , num_train_timesteps=1_0_0_0      , )

         snake_case					=    UnCLIPScheduler(
             variance_type='''fixed_small_log'''      , prediction_type='''epsilon'''      , num_train_timesteps=1_0_0_0      , )

         snake_case					=    CLIPImageProcessor(crop_size=3_2      , size=3_2   )

         snake_case					=    self.dummy_image_encoder

         return {
             "decoder": decoder,
             "text_encoder": text_encoder,
             "tokenizer": tokenizer,
             "text_proj": text_proj,
             "feature_extractor": feature_extractor,
             "image_encoder": image_encoder,
             "super_res_first": super_res_first,
             "super_res_last": super_res_last,
             "decoder_scheduler": decoder_scheduler,
             "super_res_scheduler": super_res_scheduler,
         }
    def 		a_      (	self      , __snake_case      , __snake_case=0      , __snake_case=True   ):
         snake_case					=    floats_tensor((1, 3, 3_2, 3_2)      , rng=random.Random(__snake_case   )   ).to(__snake_case   )
         if str(__snake_case   ).startswith('''mps'''   ):
              snake_case					=    torch.manual_seed(__snake_case   )
         else:
              snake_case					=    torch.Generator(device=__snake_case   ).manual_seed(__snake_case   )

         if pil_image:
              snake_case					=    input_image * 0.5 + 0.5
              snake_case					=    input_image.clamp(0      , 1   )
              snake_case					=    input_image.cpu().permute(0      , 2      , 3      , 1   ).float().numpy()
              snake_case					=    DiffusionPipeline.numpy_to_pil(__snake_case   )[0]

         return {
             "image": input_image,
             "generator": generator,
             "decoder_num_inference_steps": 2,
             "super_res_num_inference_steps": 2,
             "output_type": "np",
         }
    def 		a_      (	self   ):
         snake_case					=    '''cpu'''

         snake_case					=    self.get_dummy_components()

         snake_case					=    self.pipeline_class(**__snake_case   )
         snake_case					=    pipe.to(__snake_case   )

         pipe.set_progress_bar_config(disable=__snake_case   )

         snake_case					=    self.get_dummy_inputs(__snake_case      , pil_image=__snake_case   )

         snake_case					=    pipe(**__snake_case   )
         snake_case					=    output.images

         snake_case					=    self.get_dummy_inputs(__snake_case      , pil_image=__snake_case   )

         snake_case					=    pipe(
             **__snake_case      , return_dict=__snake_case      , )[0]

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

         assert image.shape == (1, 6_4, 6_4, 3)

         snake_case					=    np.array(
             [
                 0.9997,
                 0.0002,
                 0.9997,
                 0.9997,
                 0.9969,
                 0.0023,
                 0.9997,
                 0.9969,
                 0.9970,
             ]   )

         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   ):
         snake_case					=    '''cpu'''

         snake_case					=    self.get_dummy_components()

         snake_case					=    self.pipeline_class(**__snake_case   )
         snake_case					=    pipe.to(__snake_case   )

         pipe.set_progress_bar_config(disable=__snake_case   )

         snake_case					=    self.get_dummy_inputs(__snake_case      , pil_image=__snake_case   )

         snake_case					=    pipe(**__snake_case   )
         snake_case					=    output.images

         snake_case					=    self.get_dummy_inputs(__snake_case      , pil_image=__snake_case   )

         snake_case					=    pipe(
             **__snake_case      , return_dict=__snake_case      , )[0]

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

         assert image.shape == (1, 6_4, 6_4, 3)

         snake_case					=    np.array([0.9997, 0.0003, 0.9997, 0.9997, 0.9970, 0.0024, 0.9997, 0.9971, 0.9971]   )

         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   ):
         snake_case					=    '''cpu'''

         snake_case					=    self.get_dummy_components()

         snake_case					=    self.pipeline_class(**__snake_case   )
         snake_case					=    pipe.to(__snake_case   )

         pipe.set_progress_bar_config(disable=__snake_case   )

         snake_case					=    self.get_dummy_inputs(__snake_case      , pil_image=__snake_case   )
         snake_case					=    [
             pipeline_inputs['''image'''],
             pipeline_inputs['''image'''],
         ]

         snake_case					=    pipe(**__snake_case   )
         snake_case					=    output.images

         snake_case					=    self.get_dummy_inputs(__snake_case      , pil_image=__snake_case   )
         snake_case					=    [
             tuple_pipeline_inputs['''image'''],
             tuple_pipeline_inputs['''image'''],
         ]

         snake_case					=    pipe(
             **__snake_case      , return_dict=__snake_case      , )[0]

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

         assert image.shape == (2, 6_4, 6_4, 3)

         snake_case					=    np.array(
             [
                 0.9997,
                 0.9989,
                 0.0008,
                 0.0021,
                 0.9960,
                 0.0018,
                 0.0014,
                 0.0002,
                 0.9933,
             ]   )

         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   ):
         snake_case					=    torch.device('''cpu'''   )

         class   A__ :







             """simple docstring"""

             __magic_name__        =		1






         snake_case					=    self.get_dummy_components()

         snake_case					=    self.pipeline_class(**__snake_case   )
         snake_case					=    pipe.to(__snake_case   )

         pipe.set_progress_bar_config(disable=__snake_case   )

         snake_case					=    torch.Generator(device=__snake_case   ).manual_seed(0   )
         snake_case					=    pipe.decoder.dtype
         snake_case					=    1

         snake_case					=    (
             batch_size,
             pipe.decoder.config.in_channels,
             pipe.decoder.config.sample_size,
             pipe.decoder.config.sample_size,
         )
         snake_case					=    pipe.prepare_latents(
             __snake_case      , dtype=__snake_case      , device=__snake_case      , generator=__snake_case      , latents=__snake_case      , scheduler=DummyScheduler()   )

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

         snake_case					=    self.get_dummy_inputs(__snake_case      , pil_image=__snake_case   )

         snake_case					=    pipe(
             **__snake_case      , decoder_latents=__snake_case      , super_res_latents=__snake_case   ).images

         snake_case					=    self.get_dummy_inputs(__snake_case      , pil_image=__snake_case   )
         # Don't pass image, instead pass embedding
         snake_case					=    pipeline_inputs.pop('''image'''   )
         snake_case					=    pipe.image_encoder(__snake_case   ).image_embeds

         snake_case					=    pipe(
             **__snake_case      , decoder_latents=__snake_case      , super_res_latents=__snake_case      , image_embeddings=__snake_case      , ).images

         # make sure passing text embeddings manually is identical
         assert np.abs(img_out_a - img_out_a   ).max() < 1E-4
    @skip_mps
    def 		a_      (	self   ):
         snake_case					=    torch_device == '''cpu'''

         # Check is relaxed because there is not a torch 2.0 sliced attention added kv processor
         snake_case					=    1E-2

         self._test_attention_slicing_forward_pass(
             test_max_difference=__snake_case      , expected_max_diff=__snake_case   )
    @skip_mps
    def 		a_      (	self   ):
         snake_case					=    torch_device == '''cpu'''
         snake_case					=    True
         snake_case					=    [
             '''decoder_num_inference_steps''',
             '''super_res_num_inference_steps''',
         ]

         self._test_inference_batch_single_identical(
             test_max_difference=__snake_case      , relax_max_difference=__snake_case      , additional_params_copy_to_batched_inputs=__snake_case      , )
    def 		a_      (	self   ):
         snake_case					=    [
             '''decoder_num_inference_steps''',
             '''super_res_num_inference_steps''',
         ]

         if torch_device == "mps":
              # TODO: MPS errors with larger batch sizes
              snake_case					=    [2, 3]
              self._test_inference_batch_consistent(
                  batch_sizes=__snake_case      , additional_params_copy_to_batched_inputs=__snake_case      , )
         else:
              self._test_inference_batch_consistent(
                  additional_params_copy_to_batched_inputs=__snake_case   )
    @skip_mps
    def 		a_      (	self   ):
         return super().test_dict_tuple_outputs_equivalent()
    @skip_mps
    def 		a_      (	self   ):
         return super().test_save_load_local()




    @skip_mps
    def 		a_      (	self   ):
         return super().test_save_load_optional_components()






@slow
@require_torch_gpu
class   A__ (   unittest.TestCase     ):







    """simple docstring"""

    def 		a_      (	self   ):
         # clean up the VRAM after each test
         super().tearDown()
         gc.collect()
         torch.cuda.empty_cache()




    def 		a_      (	self   ):
         snake_case					=    load_image(
             '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/unclip/cat.png'''   )
         snake_case					=    load_numpy(
             '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
             '''/unclip/karlo_v1_alpha_cat_variation_fp16.npy'''   )

         snake_case					=    UnCLIPImageVariationPipeline.from_pretrained(
             '''kakaobrain/karlo-v1-alpha-image-variations'''      , torch_dtype=torch.floataa   )
         snake_case					=    pipeline.to(__snake_case   )
         pipeline.set_progress_bar_config(disable=__snake_case   )

         snake_case					=    torch.Generator(device='''cpu'''   ).manual_seed(0   )
         snake_case					=    pipeline(
             __snake_case      , generator=__snake_case      , output_type='''np'''      , )

         snake_case					=    output.images[0]

         assert image.shape == (2_5_6, 2_5_6, 3)

         assert_mean_pixel_difference(__snake_case      , __snake_case      , 1_5   )




