





import gc
import random
import unittest

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

from diffusers import AutoencoderKL, DDIMScheduler, DDPMScheduler, StableUnCLIPImgaImgPipeline, UNetaDConditionModel
from diffusers.pipelines.pipeline_utils import DiffusionPipeline
from diffusers.pipelines.stable_diffusion.stable_unclip_image_normalizer import StableUnCLIPImageNormalizer
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import (
    enable_full_determinism,
    floats_tensor,
    load_image,
    load_numpy,
    require_torch_gpu,
    skip_mps,
    slow,
    torch_device,
)

from ..pipeline_params import TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import (
    PipelineKarrasSchedulerTesterMixin,
    PipelineLatentTesterMixin,
    PipelineTesterMixin,
    assert_mean_pixel_difference,
)


enable_full_determinism()

class     snake_case_		(   a,		a,		a,		unittest.TestCase							):






 '''simple docstring'''





 __UpperCamelCase       =      StableUnCLIPImgaImgPipeline
 __UpperCamelCase       =      TEXT_GUIDED_IMAGE_VARIATION_PARAMS
 __UpperCamelCase       =      TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
 __UpperCamelCase       =      frozenset(
     []							)  # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
 __UpperCamelCase       =      frozenset([]							)

 def  __UpperCAmelCase						(  self		)	->       List[Any]:
    UpperCAmelCase__						=32
    UpperCAmelCase__						=embedder_hidden_size

    # image encoding components

    UpperCAmelCase__						=CLIPImageProcessor(crop_size=32,		size=32		)

    torch.manual_seed(0		)
    UpperCAmelCase__						=CLIPVisionModelWithProjection(
        CLIPVisionConfig(
            hidden_size=A_,		projection_dim=A_,		num_hidden_layers=5,		num_attention_heads=4,		image_size=32,		intermediate_size=37,		patch_size=1,		)		)

    # regular denoising components

    torch.manual_seed(0		)
    UpperCAmelCase__						=StableUnCLIPImageNormalizer(embedding_dim=A_		)
    UpperCAmelCase__						=DDPMScheduler(beta_schedule="squaredcos_cap_v2"		)

    torch.manual_seed(0		)
    UpperCAmelCase__						=CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"		)

    torch.manual_seed(0		)
    UpperCAmelCase__						=CLIPTextModel(
        CLIPTextConfig(
            bos_token_id=0,		eos_token_id=2,		hidden_size=A_,		projection_dim=32,		intermediate_size=37,		layer_norm_eps=1E-05,		num_attention_heads=4,		num_hidden_layers=5,		pad_token_id=1,		vocab_size=1000,		)		)

    torch.manual_seed(0		)
    UpperCAmelCase__						=UNetaDConditionModel(
        sample_size=32,		in_channels=4,		out_channels=4,		down_block_types=("CrossAttnDownBlock2D", "DownBlock2D"),		up_block_types=("UpBlock2D", "CrossAttnUpBlock2D"),		block_out_channels=(32, 64),		attention_head_dim=(2, 4),		class_embed_type="projection",		projection_class_embeddings_input_dim=embedder_projection_dim * 2,		cross_attention_dim=A_,		layers_per_block=1,		upcast_attention=A_,		use_linear_projection=A_,		)

    torch.manual_seed(0		)
    UpperCAmelCase__						=DDIMScheduler(
        beta_schedule="scaled_linear",		beta_start=0.0_00_85,		beta_end=0.0_12,		prediction_type="v_prediction",		set_alpha_to_one=A_,		steps_offset=1,		)

    torch.manual_seed(0		)
    UpperCAmelCase__						=AutoencoderKL()

    UpperCAmelCase__						={
        # image encoding components
        "feature_extractor": feature_extractor,
        "image_encoder": image_encoder.eval(),
        # image noising components
        "image_normalizer": image_normalizer.eval(),
        "image_noising_scheduler": image_noising_scheduler,
        # regular denoising components
        "tokenizer": tokenizer,
        "text_encoder": text_encoder.eval(),
        "unet": unet.eval(),
        "scheduler": scheduler,
        "vae": vae.eval(),
    }

    return components

 def  __UpperCAmelCase						(  self,		A_,		A_=0,		A_=True		)	->       Tuple:
    if str(A_		).startswith("mps"		):
       UpperCAmelCase__						=torch.manual_seed(A_		)
    else:
       UpperCAmelCase__						=torch.Generator(device=A_		).manual_seed(A_		)

    UpperCAmelCase__						=floats_tensor((1, 3, 32, 32),		rng=random.Random(A_		)		).to(A_		)

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

    return {
        "prompt": "An anime racoon running a marathon",
        "image": input_image,
        "generator": generator,
        "num_inference_steps": 2,
        "output_type": "np",
    }

 @skip_mps
 def  __UpperCAmelCase						(  self		)	->       List[Any]:
    UpperCAmelCase__						="cpu"  # ensure determinism for the device-dependent torch.Generator
    UpperCAmelCase__						=self.get_dummy_components()
    UpperCAmelCase__						=StableUnCLIPImgaImgPipeline(**A_		)
    UpperCAmelCase__						=sd_pipe.to(A_		)
    sd_pipe.set_progress_bar_config(disable=A_		)

    UpperCAmelCase__						=self.get_dummy_inputs(A_		)
    inputs.update({"image_embeds": None}		)
    UpperCAmelCase__						=sd_pipe(**A_		).images
    UpperCAmelCase__						=image[0, -3:, -3:, -1]

    assert image.shape == (1, 32, 32, 3)
    UpperCAmelCase__						=np.array([0.38_72, 0.72_24, 0.56_01, 0.47_41, 0.68_72, 0.58_14, 0.46_36, 0.38_67, 0.50_78]		)

    assert np.abs(image_slice.flatten() - expected_slice		).max() < 1E-3

 def  __UpperCAmelCase						(  self		)	->       Dict:
    UpperCAmelCase__						=torch_device in ["cpu", "mps"]

    self._test_attention_slicing_forward_pass(test_max_difference=A_		)

 def  __UpperCAmelCase						(  self		)	->       int:
    UpperCAmelCase__						=torch_device in ["cpu", "mps"]

    self._test_inference_batch_single_identical(test_max_difference=A_		)






 @unittest.skipIf(
     torch_device != "cuda" or not is_xformers_available(),		reason="XFormers attention is only available with CUDA and `xformers` installed",		)
 def  __UpperCAmelCase						(  self		)	->       Dict:
    self._test_xformers_attention_forwardGenerator_pass(test_max_difference=A_		)

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






 '''simple docstring'''





 def  __UpperCAmelCase						(  self		)	->       List[Any]:
    # clean up the VRAM after each test
    super().tearDown()
    gc.collect()
    torch.cuda.empty_cache()

 def  __UpperCAmelCase						(  self		)	->       Any:
    UpperCAmelCase__						=load_image(
        "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/turtle.png"		)

    UpperCAmelCase__						=load_numpy(
        "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_l_img2img_anime_turtle_fp16.npy"		)

    UpperCAmelCase__						=StableUnCLIPImgaImgPipeline.from_pretrained(
        "fusing/stable-unclip-2-1-l-img2img",		torch_dtype=torch.floataa		)
    pipe.to(A_		)
    pipe.set_progress_bar_config(disable=A_		)
    # stable unclip will oom when integration tests are run on a V100,
    # so turn on memory savings
    pipe.enable_attention_slicing()
    pipe.enable_sequential_cpu_offload()

    UpperCAmelCase__						=torch.Generator(device="cpu"		).manual_seed(0		)
    UpperCAmelCase__						=pipe(A_,		"anime turle",		generator=A_,		output_type="np"		)

    UpperCAmelCase__						=output.images[0]

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

    assert_mean_pixel_difference(A_,		A_		)

 def  __UpperCAmelCase						(  self		)	->       str:
    UpperCAmelCase__						=load_image(
        "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/turtle.png"		)

    UpperCAmelCase__						=load_numpy(
        "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_h_img2img_anime_turtle_fp16.npy"		)

    UpperCAmelCase__						=StableUnCLIPImgaImgPipeline.from_pretrained(
        "fusing/stable-unclip-2-1-h-img2img",		torch_dtype=torch.floataa		)
    pipe.to(A_		)
    pipe.set_progress_bar_config(disable=A_		)
    # stable unclip will oom when integration tests are run on a V100,
    # so turn on memory savings
    pipe.enable_attention_slicing()
    pipe.enable_sequential_cpu_offload()

    UpperCAmelCase__						=torch.Generator(device="cpu"		).manual_seed(0		)
    UpperCAmelCase__						=pipe(A_,		"anime turle",		generator=A_,		output_type="np"		)

    UpperCAmelCase__						=output.images[0]

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

    assert_mean_pixel_difference(A_,		A_		)






 def  __UpperCAmelCase						(  self		)	->       Any:
    UpperCAmelCase__						=load_image(
        "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/turtle.png"		)

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

    UpperCAmelCase__						=StableUnCLIPImgaImgPipeline.from_pretrained(
        "fusing/stable-unclip-2-1-h-img2img",		torch_dtype=torch.floataa		)
    UpperCAmelCase__						=pipe.to(A_		)
    pipe.set_progress_bar_config(disable=A_		)
    pipe.enable_attention_slicing()
    pipe.enable_sequential_cpu_offload()

    UpperCAmelCase__						=pipe(
        A_,		"anime turtle",		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










import os

import torch

from ..logging import get_logger
from .constants import FSDP_PYTORCH_VERSION, MODEL_NAME, OPTIMIZER_NAME
from .versions import is_torch_version


if is_torch_version('>=', FSDP_PYTORCH_VERSION):
    import torch.distributed.checkpoint as dist_cp
    from torch.distributed.checkpoint.default_planner import DefaultLoadPlanner, DefaultSavePlanner
    from torch.distributed.checkpoint.optimizer import load_sharded_optimizer_state_dict
    from torch.distributed.fsdp.fully_sharded_data_parallel import FullyShardedDataParallel as FSDP
    from torch.distributed.fsdp.fully_sharded_data_parallel import StateDictType


UpperCamelCase_												=	get_logger(__name__)






def 				_UpperCAmelCase			(    A				,							A				,							A				,							A				,							A=0     ):




   '''simple docstring'''

   os.makedirs(A				,							exist_ok=A     )
   with FSDP.state_dict_type(
       A				,							fsdp_plugin.state_dict_type				,							fsdp_plugin.state_dict_config				,							fsdp_plugin.optim_state_dict_config     ):
      UpperCAmelCase__						=model.state_dict()
      if fsdp_plugin.state_dict_type == StateDictType.FULL_STATE_DICT:
         UpperCAmelCase__						=F"""{MODEL_NAME}.bin""" if model_index == 0 else F"""{MODEL_NAME}_{model_index}.bin"""
         UpperCAmelCase__						=os.path.join(A				,							A     )
         if accelerator.process_index == 0:
            logger.info(F"""Saving model to {output_model_file}"""     )
            torch.save(A				,							A     )
            logger.info(F"""Model saved to {output_model_file}"""     )
      elif fsdp_plugin.state_dict_type == StateDictType.LOCAL_STATE_DICT:
         UpperCAmelCase__						=(
             F"""{MODEL_NAME}_rank{accelerator.process_index}.bin"""
             if model_index == 0
             else F"""{MODEL_NAME}_{model_index}_rank{accelerator.process_index}.bin"""
         )
         UpperCAmelCase__						=os.path.join(A				,							A     )
         logger.info(F"""Saving model to {output_model_file}"""     )
         torch.save(A				,							A     )
         logger.info(F"""Model saved to {output_model_file}"""     )
      elif fsdp_plugin.state_dict_type == StateDictType.SHARDED_STATE_DICT:
         UpperCAmelCase__						=os.path.join(A				,							F"""{MODEL_NAME}_{model_index}"""     )
         os.makedirs(A				,							exist_ok=A     )
         logger.info(F"""Saving model to {ckpt_dir}"""     )
         UpperCAmelCase__						={"model": state_dict}

         dist_cp.save_state_dict(
             state_dict=A				,							storage_writer=dist_cp.FileSystemWriter(A     )				,							planner=DefaultSavePlanner()				,							)
         logger.info(F"""Model saved to {ckpt_dir}"""     )






def 				_UpperCAmelCase			(    A				,							A				,							A				,							A				,							A=0     ):




   '''simple docstring'''

   accelerator.wait_for_everyone()
   with FSDP.state_dict_type(
       A				,							fsdp_plugin.state_dict_type				,							fsdp_plugin.state_dict_config				,							fsdp_plugin.optim_state_dict_config     ):
      if fsdp_plugin.state_dict_type == StateDictType.FULL_STATE_DICT:
         if type(A     ) != FSDP and accelerator.process_index != 0:
            if not fsdp_plugin.sync_module_states:
               raise ValueError(
                   "Set the `sync_module_states` flag to `True` so that model states are synced across processes when "
                   "initializing FSDP object"     )
            return
         UpperCAmelCase__						=F"""{MODEL_NAME}.bin""" if model_index == 0 else F"""{MODEL_NAME}_{model_index}.bin"""
         UpperCAmelCase__						=os.path.join(A				,							A     )
         logger.info(F"""Loading model from {input_model_file}"""     )
         UpperCAmelCase__						=torch.load(A     )
         logger.info(F"""Model loaded from {input_model_file}"""     )
      elif fsdp_plugin.state_dict_type == StateDictType.LOCAL_STATE_DICT:
         UpperCAmelCase__						=(
             F"""{MODEL_NAME}_rank{accelerator.process_index}.bin"""
             if model_index == 0
             else F"""{MODEL_NAME}_{model_index}_rank{accelerator.process_index}.bin"""
         )
         UpperCAmelCase__						=os.path.join(A				,							A     )
         logger.info(F"""Loading model from {input_model_file}"""     )
         UpperCAmelCase__						=torch.load(A     )
         logger.info(F"""Model loaded from {input_model_file}"""     )
      elif fsdp_plugin.state_dict_type == StateDictType.SHARDED_STATE_DICT:
         UpperCAmelCase__						=(
             os.path.join(A				,							F"""{MODEL_NAME}_{model_index}"""     )
             if F"""{MODEL_NAME}""" not in input_dir
             else input_dir
         )
         logger.info(F"""Loading model from {ckpt_dir}"""     )
         UpperCAmelCase__						={"model": model.state_dict()}
         dist_cp.load_state_dict(
             state_dict=A				,							storage_reader=dist_cp.FileSystemReader(A     )				,							planner=DefaultLoadPlanner()				,							)
         UpperCAmelCase__						=state_dict["model"]
         logger.info(F"""Model loaded from {ckpt_dir}"""     )
      model.load_state_dict(A     )






def 				_UpperCAmelCase			(    A				,							A				,							A				,							A				,							A				,							A=0     ):




   '''simple docstring'''

   os.makedirs(A				,							exist_ok=A     )
   with FSDP.state_dict_type(
       A				,							fsdp_plugin.state_dict_type				,							fsdp_plugin.state_dict_config				,							fsdp_plugin.optim_state_dict_config     ):
      UpperCAmelCase__						=FSDP.optim_state_dict(A				,							A     )
      if fsdp_plugin.state_dict_type == StateDictType.FULL_STATE_DICT:
         if accelerator.process_index == 0:
            UpperCAmelCase__						=(
                F"""{OPTIMIZER_NAME}.bin""" if optimizer_index == 0 else F"""{OPTIMIZER_NAME}_{optimizer_index}.bin"""
            )
            UpperCAmelCase__						=os.path.join(A				,							A     )
            logger.info(F"""Saving Optimizer state to {output_optimizer_file}"""     )
            torch.save(A				,							A     )
            logger.info(F"""Optimizer state saved in {output_optimizer_file}"""     )
      else:
         UpperCAmelCase__						=os.path.join(A				,							F"""{OPTIMIZER_NAME}_{optimizer_index}"""     )
         os.makedirs(A				,							exist_ok=A     )
         logger.info(F"""Saving Optimizer state to {ckpt_dir}"""     )
         dist_cp.save_state_dict(
             state_dict={"optimizer": optim_state}				,							storage_writer=dist_cp.FileSystemWriter(A     )				,							planner=DefaultSavePlanner()				,							)
         logger.info(F"""Optimizer state saved in {ckpt_dir}"""     )






def 				_UpperCAmelCase			(    A				,							A				,							A				,							A				,							A				,							A=0     ):




   '''simple docstring'''

   accelerator.wait_for_everyone()
   with FSDP.state_dict_type(
       A				,							fsdp_plugin.state_dict_type				,							fsdp_plugin.state_dict_config				,							fsdp_plugin.optim_state_dict_config     ):
      if fsdp_plugin.state_dict_type == StateDictType.FULL_STATE_DICT:
         UpperCAmelCase__						=None
         # below check should work but currently it isn't working (mostly opytorch issue),
         # in the meantime disabling it at the cost of excess memory usage
         # if accelerator.process_index == 0 or not fsdp_plugin.optim_state_dict_config.rank0_only:
         UpperCAmelCase__						=(
             F"""{OPTIMIZER_NAME}.bin""" if optimizer_index == 0 else F"""{OPTIMIZER_NAME}_{optimizer_index}.bin"""
         )
         UpperCAmelCase__						=os.path.join(A				,							A     )
         logger.info(F"""Loading Optimizer state from {input_optimizer_file}"""     )
         UpperCAmelCase__						=torch.load(A     )
         logger.info(F"""Optimizer state loaded from {input_optimizer_file}"""     )
      else:
         UpperCAmelCase__						=(
             os.path.join(A				,							F"""{OPTIMIZER_NAME}_{optimizer_index}"""     )
             if F"""{OPTIMIZER_NAME}""" not in input_dir
             else input_dir
         )
         logger.info(F"""Loading Optimizer from {ckpt_dir}"""     )
         UpperCAmelCase__						=load_sharded_optimizer_state_dict(
             model_state_dict=model.state_dict()				,							optimizer_key="optimizer"				,							storage_reader=dist_cp.FileSystemReader(A     )				,							)
         UpperCAmelCase__						=optim_state["optimizer"]
         logger.info(F"""Optimizer loaded from {ckpt_dir}"""     )
      UpperCAmelCase__						=FSDP.optim_state_dict_to_load(A				,							A				,							A     )
      optimizer.load_state_dict(A     )



