

import copy
import os
from typing import TYPE_CHECKING, List, Union


if TYPE_CHECKING:
	pass

from ...configuration_utils import PretrainedConfig
from ...utils import logging


A_       : str         =			logging.get_logger(__name__)

A_       : Tuple         =			{
    'kakaobrain/align-base': 'https://huggingface.co/kakaobrain/align-base/resolve/main/config.json',
}



class     _a						(__magic_name__				):


					'''simple docstring'''






					UpperCAmelCase__:   Optional[int]  							=       '''align_text_model'''






					def __init__( self    ,       A__=3_0522    ,       A__=768    ,       A__=12    ,       A__=12    ,       A__=3072    ,       A__="gelu"    ,       A__=0.1    ,       A__=0.1    ,       A__=512    ,       A__=2    ,       A__=0.0_2    ,       A__=1e-12    ,       A__=0    ,       A__="absolute"    ,       A__=True    ,       **A__    ,       ):
						super().__init__(**A__			)

						A__							:    List[Any]        =		vocab_size
						A__							:    List[str]        =		hidden_size
						A__							:    Any        =		num_hidden_layers
						A__							:    Optional[Any]        =		num_attention_heads
						A__							:    Optional[Any]        =		hidden_act
						A__							:    Tuple        =		intermediate_size
						A__							:    str        =		hidden_dropout_prob
						A__							:    List[Any]        =		attention_probs_dropout_prob
						A__							:    Union[str, Any]        =		max_position_embeddings
						A__							:    str        =		type_vocab_size
						A__							:    List[Any]        =		initializer_range
						A__							:    int        =		layer_norm_eps
						A__							:    Tuple        =		position_embedding_type
						A__							:    int        =		use_cache
						A__							:    Tuple        =		pad_token_id






					@classmethod
					def   __A			( cls    ,       A__    ,       **A__			):
						cls._set_token_in_kwargs(A__			)

						A__   ,   A__							:    Dict        =		cls.get_config_dict(A__    ,       **A__			)

						# get the text config dict if we are loading from AlignConfig
						if config_dict.get("""model_type"""			) == "align":
							A__							:    Any        =		config_dict["""text_config"""]

						if "model_type" in config_dict and hasattr(cls    ,       """model_type"""			) and config_dict["model_type"] != cls.model_type:
							logger.warning(
							    F"""You are using a model of type {config_dict['model_type']} to instantiate a model of type """
							    F"""{cls.model_type}. This is not supported for all configurations of models and can yield errors."""			)

						return cls.from_dict(A__    ,       **A__			)



class     _a						(__magic_name__				):


					'''simple docstring'''






					UpperCAmelCase__:   Union[str, Any]  							=       '''align_vision_model'''






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

						A__							:    Optional[Any]        =		num_channels
						A__							:    Dict        =		image_size
						A__							:    Union[str, Any]        =		width_coefficient
						A__							:    Optional[Any]        =		depth_coefficient
						A__							:    str        =		depth_divisor
						A__							:    Optional[Any]        =		kernel_sizes
						A__							:    Union[str, Any]        =		in_channels
						A__							:    Union[str, Any]        =		out_channels
						A__							:    List[Any]        =		depthwise_padding
						A__							:    str        =		strides
						A__							:    int        =		num_block_repeats
						A__							:    List[Any]        =		expand_ratios
						A__							:    Dict        =		squeeze_expansion_ratio
						A__							:    Optional[Any]        =		hidden_act
						A__							:    Union[str, Any]        =		hidden_dim
						A__							:    List[Any]        =		pooling_type
						A__							:    List[Any]        =		initializer_range
						A__							:    int        =		batch_norm_eps
						A__							:    int        =		batch_norm_momentum
						A__							:    Dict        =		drop_connect_rate
						A__							:    List[str]        =		sum(A__			) * 4






					@classmethod
					def   __A			( cls    ,       A__    ,       **A__			):
						cls._set_token_in_kwargs(A__			)

						A__   ,   A__							:    List[Any]        =		cls.get_config_dict(A__    ,       **A__			)

						# get the vision config dict if we are loading from AlignConfig
						if config_dict.get("""model_type"""			) == "align":
							A__							:    Tuple        =		config_dict["""vision_config"""]

						if "model_type" in config_dict and hasattr(cls    ,       """model_type"""			) and config_dict["model_type"] != cls.model_type:
							logger.warning(
							    F"""You are using a model of type {config_dict['model_type']} to instantiate a model of type """
							    F"""{cls.model_type}. This is not supported for all configurations of models and can yield errors."""			)

						return cls.from_dict(A__    ,       **A__			)



class     _a						(__magic_name__				):


					'''simple docstring'''






					UpperCAmelCase__:   Optional[Any]  							=       '''align'''
					UpperCAmelCase__:   Any  							=       True






					def __init__( self    ,       A__=None    ,       A__=None    ,       A__=640    ,       A__=1.0    ,       A__=0.0_2    ,       **A__    ,       ):
						super().__init__(**A__			)

						if text_config is None:
							A__							:    Dict        =		{}
							logger.info("""text_config is None. Initializing the AlignTextConfig with default values."""			)

						if vision_config is None:
							A__							:    str        =		{}
							logger.info("""vision_config is None. Initializing the AlignVisionConfig with default values."""			)

						A__							:    Dict        =		AlignTextConfig(**A__			)
						A__							:    List[Any]        =		AlignVisionConfig(**A__			)

						A__							:    int        =		projection_dim
						A__							:    List[Any]        =		temperature_init_value
						A__							:    str        =		initializer_range






					@classmethod
					def   __A			( cls    ,       A__    ,       A__    ,       **A__			):
						return cls(text_config=text_config.to_dict()    ,       vision_config=vision_config.to_dict()    ,       **A__			)






					def   __A			( self			):
						A__							:    int        =		copy.deepcopy(self.__dict__			)
						A__							:    Optional[Any]        =		self.text_config.to_dict()
						A__							:    Any        =		self.vision_config.to_dict()
						A__							:    Optional[Any]        =		self.__class__.model_type
						return output






import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel

from diffusers import DDIMScheduler, LDMPipeline, UNetaDModel, VQModel
from diffusers.utils.testing_utils import enable_full_determinism, require_torch, slow, torch_device


enable_full_determinism()



class     _a						(unittest.TestCase				):


					'''simple docstring'''






					@property
					def   __A			( self			):
						torch.manual_seed(0			)
						A__							:    int        =		UNetaDModel(
						    block_out_channels=(32, 64)    ,       layers_per_block=2    ,       sample_size=32    ,       in_channels=3    ,       out_channels=3    ,       down_block_types=("""DownBlock2D""", """AttnDownBlock2D""")    ,       up_block_types=("""AttnUpBlock2D""", """UpBlock2D""")    ,       )
						return model






					@property
					def   __A			( self			):
						torch.manual_seed(0			)
						A__							:    Dict        =		VQModel(
						    block_out_channels=[32, 64]    ,       in_channels=3    ,       out_channels=3    ,       down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""]    ,       up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""]    ,       latent_channels=3    ,       )
						return model






					@property
					def   __A			( self			):
						torch.manual_seed(0			)
						A__							:    int        =		CLIPTextConfig(
						    bos_token_id=0    ,       eos_token_id=2    ,       hidden_size=32    ,       intermediate_size=37    ,       layer_norm_eps=1e-05    ,       num_attention_heads=4    ,       num_hidden_layers=5    ,       pad_token_id=1    ,       vocab_size=1000    ,       )
						return CLIPTextModel(A__			)






					def   __A			( self			):
						A__							:    int        =		self.dummy_uncond_unet
						A__							:    Optional[int]        =		DDIMScheduler()
						A__							:    List[Any]        =		self.dummy_vq_model

						A__							:    Optional[int]        =		LDMPipeline(unet=A__    ,       vqvae=A__    ,       scheduler=A__			)
						ldm.to(A__			)
						ldm.set_progress_bar_config(disable=A__			)

						A__							:    Tuple        =		torch.manual_seed(0			)
						A__							:    List[Any]        =		ldm(generator=A__    ,       num_inference_steps=2    ,       output_type="""numpy"""			).images

						A__							:    Optional[int]        =		torch.manual_seed(0			)
						A__							:    List[Any]        =		ldm(generator=A__    ,       num_inference_steps=2    ,       output_type="""numpy"""    ,       return_dict=A__			)[0]

						A__							:    str        =		image[0, -3:, -3:, -1]
						A__							:    Tuple        =		image_from_tuple[0, -3:, -3:, -1]

						assert image.shape == (1, 64, 64, 3)
						A__							:    Dict        =		np.array([0.8_5_1_2, 0.8_1_8, 0.6_4_1_1, 0.6_8_0_8, 0.4_4_6_5, 0.5_6_1_8, 0.4_6, 0.6_2_3_1, 0.5_1_7_2]			)
						A__							:    List[Any]        =		1e-2 if torch_device != """mps""" else 3e-2

						assert np.abs(image_slice.flatten() - expected_slice			).max() < tolerance
						assert np.abs(image_from_tuple_slice.flatten() - expected_slice			).max() < tolerance



@slow
@require_torch
class     _a						(unittest.TestCase				):


					'''simple docstring'''






					def   __A			( self			):
						A__							:    Optional[Any]        =		LDMPipeline.from_pretrained("""CompVis/ldm-celebahq-256"""			)
						ldm.to(A__			)
						ldm.set_progress_bar_config(disable=A__			)

						A__							:    Tuple        =		torch.manual_seed(0			)
						A__							:    List[Any]        =		ldm(generator=A__    ,       num_inference_steps=5    ,       output_type="""numpy"""			).images

						A__							:    int        =		image[0, -3:, -3:, -1]

						assert image.shape == (1, 256, 256, 3)
						A__							:    Any        =		np.array([0.4_3_9_9, 0.4_4_9_7_5, 0.4_6_8_2_5, 0.4_7_4, 0.4_3_5_9, 0.4_5_8_1, 0.4_5_0_9_5, 0.4_3_4_1, 0.4_4_4_7]			)
						A__							:    int        =		1e-2 if torch_device != """mps""" else 3e-2

						assert np.abs(image_slice.flatten() - expected_slice			).max() < tolerance



