





import gc
import random
import unittest

import numpy as np
import torch

from diffusers import (
    DDIMScheduler,
    KandinskyVaaControlnetPipeline,
    KandinskyVaaPriorPipeline,
    UNetaDConditionModel,
    VQModel,
)
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()


class     __magic_name__     (							UpperCamelCase__			, unittest.TestCase							):





     """simple docstring"""



     __UpperCamelCase    			=   KandinskyVaaControlnetPipeline
     __UpperCamelCase    			=   ["""image_embeds""", """negative_image_embeds""", """hint"""]
     __UpperCamelCase    			=   ["""image_embeds""", """negative_image_embeds""", """hint"""]
     __UpperCamelCase    			=   [
         """generator""",
         """height""",
         """width""",
         """latents""",
         """guidance_scale""",
         """num_inference_steps""",
         """return_dict""",
         """guidance_scale""",
         """num_images_per_prompt""",
         """output_type""",
         """return_dict""",
     ]
     __UpperCamelCase    			=   False



     @property
     def   SCREAMING_SNAKE_CASE						(							self				:Union[str, Any]     ):





        '''simple docstring'''




        return 32



     @property
     def   SCREAMING_SNAKE_CASE						(							self				:str     ):





        '''simple docstring'''




        return 32



     @property
     def   SCREAMING_SNAKE_CASE						(							self				:int     ):





        '''simple docstring'''




        return self.time_input_dim



     @property
     def   SCREAMING_SNAKE_CASE						(							self				:Optional[Any]     ):





        '''simple docstring'''




        return self.time_input_dim * 4



     @property
     def   SCREAMING_SNAKE_CASE						(							self				:int     ):





        '''simple docstring'''




        return 100



     @property
     def   SCREAMING_SNAKE_CASE						(							self				:Dict     ):





        '''simple docstring'''




        torch.manual_seed(0     )

        A_    : str								=	{
            "in_channels": 8,
            # Out channels is double in channels because predicts mean and variance
            "out_channels": 8,
            "addition_embed_type": "image_hint",
            "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,
            "encoder_hid_dim": self.text_embedder_hidden_size,
            "encoder_hid_dim_type": "image_proj",
            "cross_attention_dim": self.cross_attention_dim,
            "attention_head_dim": 4,
            "resnet_time_scale_shift": "scale_shift",
            "class_embed_type": None,
        }

        A_    : int								=	UNetaDConditionModel(**__a     )
        return model



     @property
     def   SCREAMING_SNAKE_CASE						(							self				:Optional[int]     ):





        '''simple docstring'''




        return {
            "block_out_channels": [32, 32, 64, 64],
            "down_block_types": [
                "DownEncoderBlock2D",
                "DownEncoderBlock2D",
                "DownEncoderBlock2D",
                "AttnDownEncoderBlock2D",
            ],
            "in_channels": 3,
            "latent_channels": 4,
            "layers_per_block": 1,
            "norm_num_groups": 8,
            "norm_type": "spatial",
            "num_vq_embeddings": 12,
            "out_channels": 3,
            "up_block_types": ["AttnUpDecoderBlock2D", "UpDecoderBlock2D", "UpDecoderBlock2D", "UpDecoderBlock2D"],
            "vq_embed_dim": 4,
        }



     @property
     def   SCREAMING_SNAKE_CASE						(							self				:Tuple     ):





        '''simple docstring'''




        torch.manual_seed(0     )
        A_    : Optional[Any]								=	VQModel(**self.dummy_movq_kwargs     )
        return model



     def   SCREAMING_SNAKE_CASE						(							self				:str     ):





        '''simple docstring'''




        A_    : Any								=	self.dummy_unet
        A_    : Optional[int]								=	self.dummy_movq

        A_    : Any								=	DDIMScheduler(
            num_train_timesteps=1_000	,					beta_schedule="linear"	,					beta_start=0.00085	,					beta_end=0.012	,					clip_sample=__a	,					set_alpha_to_one=__a	,					steps_offset=1	,					prediction_type="epsilon"	,					thresholding=__a	,					)

        A_    : Dict								=	{
            "unet": unet,
            "scheduler": scheduler,
            "movq": movq,
        }
        return components



     def   SCREAMING_SNAKE_CASE						(							self				:str	,					snake_case				:str	,					snake_case				:List[str]=0     ):





        '''simple docstring'''




        A_    : str								=	floats_tensor((1, self.text_embedder_hidden_size)	,					rng=random.Random(__a     )     ).to(__a     )
        A_    : Any								=	floats_tensor((1, self.text_embedder_hidden_size)	,					rng=random.Random(seed + 1     )     ).to(
            __a     )

        # create hint
        A_    : Union[str, Any]								=	floats_tensor((1, 3, 64, 64)	,					rng=random.Random(__a     )     ).to(__a     )

        if str(__a     ).startswith("mps"     ):
           A_    : List[str]								=	torch.manual_seed(__a     )
        else:
           A_    : Any								=	torch.Generator(device=__a     ).manual_seed(__a     )
        A_    : Tuple								=	{
            "image_embeds": image_embeds,
            "negative_image_embeds": negative_image_embeds,
            "hint": hint,
            "generator": generator,
            "height": 64,
            "width": 64,
            "guidance_scale": 4.0,
            "num_inference_steps": 2,
            "output_type": "np",
        }
        return inputs





     def   SCREAMING_SNAKE_CASE						(							self				:Union[str, Any]     ):





        '''simple docstring'''




        A_    : List[Any]								=	"cpu"

        A_    : Optional[int]								=	self.get_dummy_components()

        A_    : Dict								=	self.pipeline_class(**__a     )
        A_    : Optional[Any]								=	pipe.to(__a     )

        pipe.set_progress_bar_config(disable=__a     )

        A_    : List[Any]								=	pipe(**self.get_dummy_inputs(__a     )     )
        A_    : int								=	output.images

        A_    : Optional[Any]								=	pipe(
            **self.get_dummy_inputs(__a     )	,					return_dict=__a	,					)[0]

        A_    : Dict								=	image[0, -3:, -3:, -1]
        A_    : Optional[int]								=	image_from_tuple[0, -3:, -3:, -1]

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

        A_    : Union[str, Any]								=	np.array(
            [0.6959826, 0.868279, 0.7558092, 0.68769467, 0.85805804, 0.65977496, 0.44885302, 0.5959111, 0.4251595]     )

        assert (
            np.abs(image_slice.flatten() - expected_slice     ).max() < 1e-2
        ), f" expected_slice {expected_slice}, but got {image_slice.flatten()}"

        assert (
            np.abs(image_from_tuple_slice.flatten() - expected_slice     ).max() < 1e-2
        ), f" expected_slice {expected_slice}, but got {image_from_tuple_slice.flatten()}"




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





     """simple docstring"""



     def   SCREAMING_SNAKE_CASE						(							self				:List[str]     ):





        '''simple docstring'''




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





     def   SCREAMING_SNAKE_CASE						(							self				:List[str]     ):





        '''simple docstring'''




        A_    : Union[str, Any]								=	load_numpy(
            "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
            "/kandinskyv22/kandinskyv22_controlnet_robotcat_fp16.npy"     )

        A_    : str								=	load_image(
            "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
            "/kandinskyv22/hint_image_cat.png"     )
        A_    : Optional[Any]								=	torch.from_numpy(np.array(__a     )     ).float() / 255.0
        A_    : Optional[Any]								=	hint.permute(2	,					0	,					1     ).unsqueeze(0     )

        A_    : str								=	KandinskyVaaPriorPipeline.from_pretrained(
            "kandinsky-community/kandinsky-2-2-prior"	,					torch_dtype=torch.floataa     )
        pipe_prior.to(__a     )

        A_    : List[str]								=	KandinskyVaaControlnetPipeline.from_pretrained(
            "kandinsky-community/kandinsky-2-2-controlnet-depth"	,					torch_dtype=torch.floataa     )
        A_    : Any								=	pipeline.to(__a     )
        pipeline.set_progress_bar_config(disable=__a     )

        A_    : List[str]								=	"A robot, 4k photo"

        A_    : Dict								=	torch.Generator(device="cuda"     ).manual_seed(0     )
        A_					,  A_    : str								=	pipe_prior(
            __a	,					generator=__a	,					num_inference_steps=5	,					negative_prompt=""	,					).to_tuple()

        A_    : Optional[int]								=	torch.Generator(device="cuda"     ).manual_seed(0     )
        A_    : List[Any]								=	pipeline(
            image_embeds=__a	,					negative_image_embeds=__a	,					hint=__a	,					generator=__a	,					num_inference_steps=100	,					output_type="np"	,					)

        A_    : Union[str, Any]								=	output.images[0]

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

        assert_mean_pixel_difference(__a	,					__a     )

'''simple docstring'''





import os
from math import logaa





def 	lowerCAmelCase_				(					snake_case_       : str = "base_exp.txt"			)    ->      int:


     '''simple docstring'''




     UpperCAmelCase_           =   0
     UpperCAmelCase_           =   0
     for i, line in enumerate(open(os.path.join(os.path.dirname(snake_case_			)					,    snake_case_			)			)			):
          UpperCAmelCase_    , UpperCAmelCase_           =   list(map(snake_case_					,    line.split(","			)			)			)
          if x * logaa(snake_case_			) > largest:
               UpperCAmelCase_           =   x * logaa(snake_case_			)
               UpperCAmelCase_           =   i + 1
     return result


if __name__ == "__main__":
    print(solution())




