



"""simple docstring"""


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      UpperCAmelCase__					( self			:int )    ->      List[str]:
												torch.manual_seed(0 )
												UpperCAmelCase					=			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      UpperCAmelCase__					( self			:str )    ->      Union[str, Any]:
												torch.manual_seed(0 )
												UpperCAmelCase					=			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      UpperCAmelCase__					( self			:str )    ->      int:
												torch.manual_seed(0 )
												UpperCAmelCase					=			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=10_00       ,  )
												return CLIPTextModel(lowercase_ )






						def      UpperCAmelCase__					( self			:Union[str, Any] )    ->      List[Any]:
												UpperCAmelCase					=			self.dummy_uncond_unet
												UpperCAmelCase					=			DDIMScheduler()
												UpperCAmelCase					=			self.dummy_vq_model

												UpperCAmelCase					=			LDMPipeline(unet=lowercase_       ,  vqvae=lowercase_       ,  scheduler=lowercase_ )
												ldm.to(lowercase_ )
												ldm.set_progress_bar_config(disable=lowercase_ )

												UpperCAmelCase					=			torch.manual_seed(0 )
												UpperCAmelCase					=			ldm(generator=lowercase_       ,  num_inference_steps=2       ,  output_type='numpy' ).images

												UpperCAmelCase					=			torch.manual_seed(0 )
												UpperCAmelCase					=			ldm(generator=lowercase_       ,  num_inference_steps=2       ,  output_type='numpy'       ,  return_dict=lowercase_ )[0]

												UpperCAmelCase					=			image[0, -3:, -3:, -1]
												UpperCAmelCase					=			image_from_tuple[0, -3:, -3:, -1]

												assert image.shape == (1, 64, 64, 3)
												UpperCAmelCase					=			np.array([0.8512, 0.818, 0.6411, 0.6808, 0.4465, 0.5618, 0.46, 0.6231, 0.5172] )
												UpperCAmelCase					=			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      UpperCAmelCase__					( self			:int )    ->      Tuple:
												UpperCAmelCase					=			LDMPipeline.from_pretrained('CompVis/ldm-celebahq-256' )
												ldm.to(lowercase_ )
												ldm.set_progress_bar_config(disable=lowercase_ )

												UpperCAmelCase					=			torch.manual_seed(0 )
												UpperCAmelCase					=			ldm(generator=lowercase_       ,  num_inference_steps=5       ,  output_type='numpy' ).images

												UpperCAmelCase					=			image[0, -3:, -3:, -1]

												assert image.shape == (1, 2_56, 2_56, 3)
												UpperCAmelCase					=			np.array([0.4399, 0.4_4975, 0.4_6825, 0.474, 0.4359, 0.4581, 0.4_5095, 0.4341, 0.4447] )
												UpperCAmelCase					=			1E-2 if torch_device != 'mps' else 3E-2

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




"""simple docstring"""


# Copyright 2022 The HuggingFace Team and The OpenBMB Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import TYPE_CHECKING

# rely on isort to merge the imports
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available


snake_case_    					=	{
    """configuration_cpmant""": ["""CPMANT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """CpmAntConfig"""],
    """tokenization_cpmant""": ["""CpmAntTokenizer"""],
}

try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				snake_case_    					=	[
				    """CPMANT_PRETRAINED_MODEL_ARCHIVE_LIST""",
				    """CpmAntForCausalLM""",
				    """CpmAntModel""",
				    """CpmAntPreTrainedModel""",
				]


if TYPE_CHECKING:
				from .configuration_cpmant import CPMANT_PRETRAINED_CONFIG_ARCHIVE_MAP, CpmAntConfig
				from .tokenization_cpmant import CpmAntTokenizer

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_cpmant import (
								    CPMANT_PRETRAINED_MODEL_ARCHIVE_LIST,
								    CpmAntForCausalLM,
								    CpmAntModel,
								    CpmAntPreTrainedModel,
								)


else:
				import sys

				snake_case_    					=	_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)





