

"""simple docstring"""





import gc
import unittest

import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTextModelWithProjection, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DDPMScheduler,
    PriorTransformer,
    StableUnCLIPPipeline,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.stable_unclip_image_normalizer import StableUnCLIPImageNormalizer
from diffusers.utils.testing_utils import enable_full_determinism, load_numpy, require_torch_gpu, slow, torch_device

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import (
    PipelineKarrasSchedulerTesterMixin,
    PipelineLatentTesterMixin,
    PipelineTesterMixin,
    assert_mean_pixel_difference,
)


enable_full_determinism()




class 					_lowerCAmelCase  (	lowercase     ,lowercase     ,lowercase     ,unittest.TestCase   ):







 """simple docstring"""







 __UpperCAmelCase	:					Tuple   		=	StableUnCLIPPipeline
 __UpperCAmelCase	:					List[Any]   		=	TEXT_TO_IMAGE_PARAMS
 __UpperCAmelCase	:					Tuple   		=	TEXT_TO_IMAGE_BATCH_PARAMS
 __UpperCAmelCase	:					List[Any]   		=	TEXT_TO_IMAGE_IMAGE_PARAMS
 __UpperCAmelCase	:					Union[str, Any]   		=	TEXT_TO_IMAGE_IMAGE_PARAMS

 # TODO(will) Expected attn_bias.stride(1) == 0 to be true, but got false
 __UpperCAmelCase	:					int   		=	False


 def 					_lowercase (			self							:			Union[str, Any]	):
    __lowercase								=						3_2
    __lowercase								=						embedder_hidden_size

    # prior components

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

    torch.manual_seed(0	)
    __lowercase								=						CLIPTextModelWithProjection(
        CLIPTextConfig(
            bos_token_id=0,					eos_token_id=2,					hidden_size=UpperCAmelCase__,					projection_dim=UpperCAmelCase__,					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,					)	)

    torch.manual_seed(0	)
    __lowercase								=						PriorTransformer(
        num_attention_heads=2,					attention_head_dim=1_2,					embedding_dim=UpperCAmelCase__,					num_layers=1,					)

    torch.manual_seed(0	)
    __lowercase								=						DDPMScheduler(
        variance_type="fixed_small_log",					prediction_type="sample",					num_train_timesteps=1_0_0_0,					clip_sample=UpperCAmelCase__,					clip_sample_range=5.0,					beta_schedule="squaredcos_cap_v2",					)

    # regular denoising components

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

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

    torch.manual_seed(0	)
    __lowercase								=						CLIPTextModel(
        CLIPTextConfig(
            bos_token_id=0,					eos_token_id=2,					hidden_size=UpperCAmelCase__,					projection_dim=3_2,					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,					)	)

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

    torch.manual_seed(0	)
    __lowercase								=						DDIMScheduler(
        beta_schedule="scaled_linear",					beta_start=0.00_085,					beta_end=0.012,					prediction_type="v_prediction",					set_alpha_to_one=UpperCAmelCase__,					steps_offset=1,					)

    torch.manual_seed(0	)
    __lowercase								=						AutoencoderKL()

    __lowercase								=						{
        # prior components
        "prior_tokenizer": prior_tokenizer,
        "prior_text_encoder": prior_text_encoder,
        "prior": prior,
        "prior_scheduler": prior_scheduler,
        # image noising components
        "image_normalizer": image_normalizer,
        "image_noising_scheduler": image_noising_scheduler,
        # regular denoising components
        "tokenizer": tokenizer,
        "text_encoder": text_encoder,
        "unet": unet,
        "scheduler": scheduler,
        "vae": vae,
    }

    return components


 def 					_lowercase (			self							:			Dict,					UpperCAmelCase__							:			Optional[Any],					UpperCAmelCase__							:			List[str]=0	):
    if str(UpperCAmelCase__	).startswith("mps"	):
       __lowercase								=						torch.manual_seed(UpperCAmelCase__	)
    else:
       __lowercase								=						torch.Generator(device=UpperCAmelCase__	).manual_seed(UpperCAmelCase__	)
    __lowercase								=						{
        "prompt": "A painting of a squirrel eating a burger",
        "generator": generator,
        "num_inference_steps": 2,
        "prior_num_inference_steps": 2,
        "output_type": "numpy",
    }
    return inputs


 def 					_lowercase (			self							:			Tuple	):
    __lowercase								=						torch_device == "cpu"

    self._test_attention_slicing_forward_pass(test_max_difference=UpperCAmelCase__	)



 def 					_lowercase (			self							:			int	):
    __lowercase								=						torch_device in ["cpu", "mps"]

    self._test_inference_batch_single_identical(test_max_difference=UpperCAmelCase__	)







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







 """simple docstring"""







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


 def 					_lowercase (			self							:			int	):
    __lowercase								=						load_numpy(
        "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_l_anime_turtle_fp16.npy"	)

    __lowercase								=						StableUnCLIPPipeline.from_pretrained("fusing/stable-unclip-2-1-l",					torch_dtype=torch.floataa	)
    pipe.to(UpperCAmelCase__	)
    pipe.set_progress_bar_config(disable=UpperCAmelCase__	)
    # 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()

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

    __lowercase								=						output.images[0]

    assert image.shape == (7_6_8, 7_6_8, 3)

    assert_mean_pixel_difference(UpperCAmelCase__,					UpperCAmelCase__	)



 def 					_lowercase (			self							:			Dict	):
    torch.cuda.empty_cache()
    torch.cuda.reset_max_memory_allocated()
    torch.cuda.reset_peak_memory_stats()

    __lowercase								=						StableUnCLIPPipeline.from_pretrained("fusing/stable-unclip-2-1-l",					torch_dtype=torch.floataa	)
    __lowercase								=						pipe.to(UpperCAmelCase__	)
    pipe.set_progress_bar_config(disable=UpperCAmelCase__	)
    pipe.enable_attention_slicing()
    pipe.enable_sequential_cpu_offload()

    __lowercase								=						pipe(
        "anime turtle",					prior_num_inference_steps=2,					num_inference_steps=2,					output_type="np",					)

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





"""simple docstring"""






from collections import OrderedDict
from typing import List, Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


__lowerCAmelCase    :       List[Any]					     =logging.get_logger(__name__)

__lowerCAmelCase    :       Union[str, Any]					     ={
    """google/efficientnet-b7""": """https://huggingface.co/google/efficientnet-b7/resolve/main/config.json""",
}





class  _A						(       lowerCAmelCase	):
      snake_case__			:   Optional[int]							  =	'efficientnet'

      def __init__(						self		,       __lowerCAmelCase = 3		,       __lowerCAmelCase = 600		,       __lowerCAmelCase = 2.0		,       __lowerCAmelCase = 3.1		,       __lowerCAmelCase = 8		,       __lowerCAmelCase = [3, 3, 5, 3, 5, 5, 3]		,       __lowerCAmelCase = [32, 16, 24, 40, 80, 112, 192]		,       __lowerCAmelCase = [16, 24, 40, 80, 112, 192, 320]		,       __lowerCAmelCase = []		,       __lowerCAmelCase = [1, 2, 2, 2, 1, 2, 1]		,       __lowerCAmelCase = [1, 2, 2, 3, 3, 4, 1]		,       __lowerCAmelCase = [1, 6, 6, 6, 6, 6, 6]		,       __lowerCAmelCase = 0.2_5		,       __lowerCAmelCase = "swish"		,       __lowerCAmelCase = 2560		,       __lowerCAmelCase = "mean"		,       __lowerCAmelCase = 0.0_2		,       __lowerCAmelCase = 0.0_0_1		,       __lowerCAmelCase = 0.9_9		,       __lowerCAmelCase = 0.5		,       __lowerCAmelCase = 0.2		,       **__lowerCAmelCase		,       ):







            """simple docstring"""



            super().__init__(**__lowerCAmelCase						)

            lowercase														=	num_channels
            lowercase														=	image_size
            lowercase														=	width_coefficient
            lowercase														=	depth_coefficient
            lowercase														=	depth_divisor
            lowercase														=	kernel_sizes
            lowercase														=	in_channels
            lowercase														=	out_channels
            lowercase														=	depthwise_padding
            lowercase														=	strides
            lowercase														=	num_block_repeats
            lowercase														=	expand_ratios
            lowercase														=	squeeze_expansion_ratio
            lowercase														=	hidden_act
            lowercase														=	hidden_dim
            lowercase														=	pooling_type
            lowercase														=	initializer_range
            lowercase														=	batch_norm_eps
            lowercase														=	batch_norm_momentum
            lowercase														=	dropout_rate
            lowercase														=	drop_connect_rate
            lowercase														=	sum(__lowerCAmelCase						) * 4






class  _A						(       lowerCAmelCase	):
      snake_case__			:   Dict							  =	version.parse('1.11'	)

      @property
      def 				A__       (						self						):







            """simple docstring"""



            return OrderedDict(
                [
                    ("""pixel_values""", {0: """batch""", 1: """num_channels""", 2: """height""", 3: """width"""}),
                ]						)







      @property
      def 				A__       (						self						):







            """simple docstring"""



            return 1E-5



