

'''simple docstring'''
import gc
import unittest

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

from diffusers import AltDiffusionPipeline, AutoencoderKL, DDIMScheduler, PNDMScheduler, UNetaDConditionModel
from diffusers.pipelines.alt_diffusion.modeling_roberta_series import (
    RobertaSeriesConfig,
    RobertaSeriesModelWithTransformation,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

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


enable_full_determinism()
class 					_snake_case		(__SCREAMING_SNAKE_CASE			,			__SCREAMING_SNAKE_CASE			,			__SCREAMING_SNAKE_CASE			,			unittest.TestCase):
			__A  :	Any        =AltDiffusionPipeline
			__A  :	List[str]        =TEXT_TO_IMAGE_PARAMS
			__A  :	Optional[int]        =TEXT_TO_IMAGE_BATCH_PARAMS
			__A  :	List[Any]        =TEXT_TO_IMAGE_IMAGE_PARAMS
			__A  :	Dict        =TEXT_TO_IMAGE_IMAGE_PARAMS






			def 		UpperCamelCase__							(  self     ):
				torch.manual_seed(0     )
				UpperCAmelCase_     :      Tuple						=  UNetaDConditionModel(
				    block_out_channels=(32, 64)			,layers_per_block=2			,sample_size=32			,in_channels=4			,out_channels=4			,down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")			,up_block_types=("CrossAttnUpBlock2D", "UpBlock2D")			,cross_attention_dim=32			,)
				UpperCAmelCase_     :      int						=  DDIMScheduler(
				    beta_start=0.00085			,beta_end=0.012			,beta_schedule="scaled_linear"			,clip_sample=_snake_case			,set_alpha_to_one=_snake_case			,)
				torch.manual_seed(0     )
				UpperCAmelCase_     :      Optional[int]						=  AutoencoderKL(
				    block_out_channels=[32, 64]			,in_channels=3			,out_channels=3			,down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"]			,up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"]			,latent_channels=4			,)

				# TODO: address the non-deterministic text encoder (fails for save-load tests)
				# torch.manual_seed(0)
				# text_encoder_config = RobertaSeriesConfig(
				#     hidden_size=32,
				#     project_dim=32,
				#     intermediate_size=37,
				#     layer_norm_eps=1e-05,
				#     num_attention_heads=4,
				#     num_hidden_layers=5,
				#     vocab_size=5002,
				# )
				# text_encoder = RobertaSeriesModelWithTransformation(text_encoder_config)

				torch.manual_seed(0     )
				UpperCAmelCase_     :      str						=  CLIPTextConfig(
				    bos_token_id=0			,eos_token_id=2			,hidden_size=32			,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=50_02			,)
				UpperCAmelCase_     :      Union[str, Any]						=  CLIPTextModel(_snake_case     )

				UpperCAmelCase_     :      Optional[Any]						=  XLMRobertaTokenizer.from_pretrained("hf-internal-testing/tiny-xlm-roberta"     )
				UpperCAmelCase_     :      List[Any]						=  77

				UpperCAmelCase_     :      Optional[Any]						=  {
				    "unet": unet,
				    "scheduler": scheduler,
				    "vae": vae,
				    "text_encoder": text_encoder,
				    "tokenizer": tokenizer,
				    "safety_checker": None,
				    "feature_extractor": None,
				}
				return components






			def 		UpperCamelCase__							(  self			,_snake_case			,_snake_case=0     ):
				if str(_snake_case     ).startswith("mps"     ):
					UpperCAmelCase_     :      int						=  torch.manual_seed(_snake_case     )
				else:
					UpperCAmelCase_     :      Dict						=  torch.Generator(device=_snake_case     ).manual_seed(_snake_case     )
				UpperCAmelCase_     :      int						=  {
				    "prompt": "A painting of a squirrel eating a burger",
				    "generator": generator,
				    "num_inference_steps": 2,
				    "guidance_scale": 6.0,
				    "output_type": "numpy",
				}
				return inputs






			def 		UpperCamelCase__							(  self     ):
				super().test_attention_slicing_forward_pass(expected_max_diff=3E-3     )






			def 		UpperCamelCase__							(  self     ):
				super().test_inference_batch_single_identical(expected_max_diff=3E-3     )






			def 		UpperCamelCase__							(  self     ):
				UpperCAmelCase_     :      str						=  "cpu"  # ensure determinism for the device-dependent torch.Generator

				UpperCAmelCase_     :      List[Any]						=  self.get_dummy_components()
				torch.manual_seed(0     )
				UpperCAmelCase_     :      Union[str, Any]						=  RobertaSeriesConfig(
				    hidden_size=32			,project_dim=32			,intermediate_size=37			,layer_norm_eps=1E-05			,num_attention_heads=4			,num_hidden_layers=5			,vocab_size=50_02			,)
				# TODO: remove after fixing the non-deterministic text encoder
				UpperCAmelCase_     :      Any						=  RobertaSeriesModelWithTransformation(_snake_case     )
				UpperCAmelCase_     :      int						=  text_encoder

				UpperCAmelCase_     :      int						=  AltDiffusionPipeline(**_snake_case     )
				UpperCAmelCase_     :      Dict						=  alt_pipe.to(_snake_case     )
				alt_pipe.set_progress_bar_config(disable=_snake_case     )

				UpperCAmelCase_     :      Any						=  self.get_dummy_inputs(_snake_case     )
				UpperCAmelCase_     :      Any						=  "A photo of an astronaut"
				UpperCAmelCase_     :      Tuple						=  alt_pipe(**_snake_case     )
				UpperCAmelCase_     :      Union[str, Any]						=  output.images
				UpperCAmelCase_     :      int						=  image[0, -3:, -3:, -1]

				assert image.shape == (1, 64, 64, 3)
				UpperCAmelCase_     :      int						=  np.array(
				    [0.5748162, 0.60447145, 0.48821217, 0.50100636, 0.5431185, 0.45763683, 0.49657696, 0.48132733, 0.47573093]     )

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






			def 		UpperCamelCase__							(  self     ):
				UpperCAmelCase_     :      Optional[int]						=  "cpu"  # ensure determinism for the device-dependent torch.Generator

				UpperCAmelCase_     :      int						=  self.get_dummy_components()
				UpperCAmelCase_     :      Union[str, Any]						=  PNDMScheduler(skip_prk_steps=_snake_case     )
				torch.manual_seed(0     )
				UpperCAmelCase_     :      List[str]						=  RobertaSeriesConfig(
				    hidden_size=32			,project_dim=32			,intermediate_size=37			,layer_norm_eps=1E-05			,num_attention_heads=4			,num_hidden_layers=5			,vocab_size=50_02			,)
				# TODO: remove after fixing the non-deterministic text encoder
				UpperCAmelCase_     :      Union[str, Any]						=  RobertaSeriesModelWithTransformation(_snake_case     )
				UpperCAmelCase_     :      Tuple						=  text_encoder
				UpperCAmelCase_     :      List[str]						=  AltDiffusionPipeline(**_snake_case     )
				UpperCAmelCase_     :      int						=  alt_pipe.to(_snake_case     )
				alt_pipe.set_progress_bar_config(disable=_snake_case     )

				UpperCAmelCase_     :      Dict						=  self.get_dummy_inputs(_snake_case     )
				UpperCAmelCase_     :      List[Any]						=  alt_pipe(**_snake_case     )
				UpperCAmelCase_     :      Optional[Any]						=  output.images
				UpperCAmelCase_     :      int						=  image[0, -3:, -3:, -1]

				assert image.shape == (1, 64, 64, 3)
				UpperCAmelCase_     :      Optional[int]						=  np.array(
				    [0.51605093, 0.5707241, 0.47365507, 0.50578886, 0.5633877, 0.4642503, 0.5182081, 0.48763484, 0.49084237]     )

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




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






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






			def 		UpperCamelCase__							(  self     ):
				# make sure here that pndm scheduler skips prk
				UpperCAmelCase_     :      Optional[Any]						=  AltDiffusionPipeline.from_pretrained("BAAI/AltDiffusion"			,safety_checker=_snake_case     )
				UpperCAmelCase_     :      str						=  alt_pipe.to(_snake_case     )
				alt_pipe.set_progress_bar_config(disable=_snake_case     )

				UpperCAmelCase_     :      str						=  "A painting of a squirrel eating a burger"
				UpperCAmelCase_     :      Any						=  torch.manual_seed(0     )
				UpperCAmelCase_     :      Optional[Any]						=  alt_pipe([prompt]			,generator=_snake_case			,guidance_scale=6.0			,num_inference_steps=20			,output_type="np"     )

				UpperCAmelCase_     :      str						=  output.images

				UpperCAmelCase_     :      Optional[Any]						=  image[0, -3:, -3:, -1]

				assert image.shape == (1, 5_12, 5_12, 3)
				UpperCAmelCase_     :      Union[str, Any]						=  np.array([0.1010, 0.0800, 0.0794, 0.0885, 0.0843, 0.0762, 0.0769, 0.0729, 0.0586]     )

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






			def 		UpperCamelCase__							(  self     ):
				UpperCAmelCase_     :      List[str]						=  DDIMScheduler.from_pretrained("BAAI/AltDiffusion"			,subfolder="scheduler"     )

				UpperCAmelCase_     :      Union[str, Any]						=  AltDiffusionPipeline.from_pretrained("BAAI/AltDiffusion"			,scheduler=_snake_case			,safety_checker=_snake_case     )
				UpperCAmelCase_     :      int						=  alt_pipe.to(_snake_case     )
				alt_pipe.set_progress_bar_config(disable=_snake_case     )

				UpperCAmelCase_     :      List[Any]						=  "A painting of a squirrel eating a burger"
				UpperCAmelCase_     :      Optional[int]						=  torch.manual_seed(0     )

				UpperCAmelCase_     :      Dict						=  alt_pipe([prompt]			,generator=_snake_case			,num_inference_steps=2			,output_type="numpy"     )
				UpperCAmelCase_     :      int						=  output.images

				UpperCAmelCase_     :      List[Any]						=  image[0, -3:, -3:, -1]

				assert image.shape == (1, 5_12, 5_12, 3)
				UpperCAmelCase_     :      Union[str, Any]						=  np.array([0.4019, 0.4052, 0.3810, 0.4119, 0.3916, 0.3982, 0.4651, 0.4195, 0.5323]     )

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










'''simple docstring'''





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


UpperCamelCase_		:     int          =		logging.get_logger(__name__)

UpperCamelCase_		:     Any          =		{
    '''tiiuae/falcon-40b''': '''https://huggingface.co/tiiuae/falcon-40b/resolve/main/config.json''',
    '''tiiuae/falcon-7b''': '''https://huggingface.co/tiiuae/falcon-7b/resolve/main/config.json''',
}

class   _a							(		__lowerCAmelCase				):
     SCREAMING_SNAKE_CASE_				:       List[str]       							=		"""falcon"""
     SCREAMING_SNAKE_CASE_				:       Optional[int]       							=		["""past_key_values"""]






     def __init__(					self   ,_SCREAMING_SNAKE_CASE=65_024   ,_SCREAMING_SNAKE_CASE=4_544   ,_SCREAMING_SNAKE_CASE=32   ,_SCREAMING_SNAKE_CASE=71   ,_SCREAMING_SNAKE_CASE=1e-5   ,_SCREAMING_SNAKE_CASE=0.0_2   ,_SCREAMING_SNAKE_CASE=True   ,_SCREAMING_SNAKE_CASE=0.0   ,_SCREAMING_SNAKE_CASE=0.0   ,_SCREAMING_SNAKE_CASE=None   ,_SCREAMING_SNAKE_CASE=False   ,_SCREAMING_SNAKE_CASE=False   ,_SCREAMING_SNAKE_CASE=True   ,_SCREAMING_SNAKE_CASE=True   ,_SCREAMING_SNAKE_CASE=False   ,_SCREAMING_SNAKE_CASE=11   ,_SCREAMING_SNAKE_CASE=11   ,**_SCREAMING_SNAKE_CASE   ,)				->     Dict:
          _snake_case				= vocab_size
          # Backward compatibility with n_embed kwarg
          _snake_case				= kwargs.pop("n_embed"   ,_SCREAMING_SNAKE_CASE       )
          _snake_case				= hidden_size if n_embed is None else n_embed
          _snake_case				= num_hidden_layers
          _snake_case				= num_attention_heads
          _snake_case				= layer_norm_epsilon
          _snake_case				= initializer_range
          _snake_case				= use_cache
          _snake_case				= hidden_dropout
          _snake_case				= attention_dropout

          _snake_case				= bos_token_id
          _snake_case				= eos_token_id
          _snake_case				= num_attention_heads if num_kv_heads is None else num_kv_heads
          _snake_case				= alibi
          _snake_case				= new_decoder_architecture
          _snake_case				= multi_query  # Ignored when new_decoder_architecture is True
          _snake_case				= parallel_attn
          _snake_case				= bias

          super().__init__(bos_token_id=_SCREAMING_SNAKE_CASE   ,eos_token_id=_SCREAMING_SNAKE_CASE   ,**_SCREAMING_SNAKE_CASE       )






     @property
     def 							_lowercase      (					self       )				->     Union[str, Any]:
          return self.hidden_size // self.num_attention_heads






     @property
     def 							_lowercase      (					self       )				->     Optional[int]:
          return not self.alibi


