
'''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       _lowerCAmelCase   (   unittest.TestCase				):







       '''simple docstring'''

       @property
       def 	lowercase							(self  )					->       Union[str, Any]:
              torch.manual_seed(0  )
              _snake_case       =  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 	lowercase							(self  )					->       str:
              torch.manual_seed(0  )
              _snake_case       =  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 	lowercase							(self  )					->       List[str]:
              torch.manual_seed(0  )
              _snake_case       =  CLIPTextConfig(
                  bos_token_id=0  ,  eos_token_id=2  ,  hidden_size=32  ,  intermediate_size=37  ,  layer_norm_eps=1e-0_5  ,  num_attention_heads=4  ,  num_hidden_layers=5  ,  pad_token_id=1  ,  vocab_size=1000  ,  )
              return CLIPTextModel(UpperCamelCase__  )





       def 	lowercase							(self  )					->       List[Any]:
              _snake_case       =  self.dummy_uncond_unet
              _snake_case       =  DDIMScheduler()
              _snake_case       =  self.dummy_vq_model

              _snake_case       =  LDMPipeline(unet=UpperCamelCase__  ,  vqvae=UpperCamelCase__  ,  scheduler=UpperCamelCase__  )
              ldm.to(UpperCamelCase__  )
              ldm.set_progress_bar_config(disable=UpperCamelCase__  )

              _snake_case       =  torch.manual_seed(0  )
              _snake_case       =  ldm(generator=UpperCamelCase__  ,  num_inference_steps=2  ,  output_type="""numpy"""  ).images

              _snake_case       =  torch.manual_seed(0  )
              _snake_case       =  ldm(generator=UpperCamelCase__  ,  num_inference_steps=2  ,  output_type="""numpy"""  ,  return_dict=UpperCamelCase__  )[0]

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

              assert image.shape == (1, 64, 64, 3)
              _snake_case       =  np.array([0.8512, 0.818, 0.6411, 0.6808, 0.4465, 0.5618, 0.46, 0.6231, 0.5172]  )
              _snake_case       =  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       _lowerCAmelCase   (   unittest.TestCase				):







       '''simple docstring'''

       def 	lowercase							(self  )					->       Dict:
              _snake_case       =  LDMPipeline.from_pretrained("""CompVis/ldm-celebahq-256"""  )
              ldm.to(UpperCamelCase__  )
              ldm.set_progress_bar_config(disable=UpperCamelCase__  )

              _snake_case       =  torch.manual_seed(0  )
              _snake_case       =  ldm(generator=UpperCamelCase__  ,  num_inference_steps=5  ,  output_type="""numpy"""  ).images

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

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

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

'''simple docstring'''
from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_torch_available,
)


__lowerCAmelCase												=	{
    'configuration_resnet': ['RESNET_PRETRAINED_CONFIG_ARCHIVE_MAP', 'ResNetConfig', 'ResNetOnnxConfig']
}

try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				__lowerCAmelCase												=	[
				    'RESNET_PRETRAINED_MODEL_ARCHIVE_LIST',
				    'ResNetForImageClassification',
				    'ResNetModel',
				    'ResNetPreTrainedModel',
				    'ResNetBackbone',
				]

try:
				if not is_tf_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				__lowerCAmelCase												=	[
				    'TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST',
				    'TFResNetForImageClassification',
				    'TFResNetModel',
				    'TFResNetPreTrainedModel',
				]

try:
				if not is_flax_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				__lowerCAmelCase												=	[
				    'FlaxResNetForImageClassification',
				    'FlaxResNetModel',
				    'FlaxResNetPreTrainedModel',
				]

if TYPE_CHECKING:
				from .configuration_resnet import RESNET_PRETRAINED_CONFIG_ARCHIVE_MAP, ResNetConfig, ResNetOnnxConfig

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_resnet import (
								    RESNET_PRETRAINED_MODEL_ARCHIVE_LIST,
								    ResNetBackbone,
								    ResNetForImageClassification,
								    ResNetModel,
								    ResNetPreTrainedModel,
								)

				try:
								if not is_tf_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_tf_resnet import (
								    TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST,
								    TFResNetForImageClassification,
								    TFResNetModel,
								    TFResNetPreTrainedModel,
								)

				try:
								if not is_flax_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_flax_resnet import FlaxResNetForImageClassification, FlaxResNetModel, FlaxResNetPreTrainedModel


else:
				import sys

				__lowerCAmelCase												=	_LazyModule(__name__, globals()['__file__'], _import_structure)