





import random
import unittest

import numpy as np
import torch

from diffusers import DDIMScheduler, LDMSuperResolutionPipeline, UNetaDModel, VQModel
from diffusers.utils import PIL_INTERPOLATION, floats_tensor, load_image, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch


enable_full_determinism()





class 					lowerCAmelCase							(   unittest.TestCase					):







  @property
  def   UpperCAmelCase     (			self  :List[str]					):






     '''simple docstring'''





     lowercase__    =  1
     lowercase__    =  3
     lowercase__    =  (32, 32)

     lowercase__    =  floats_tensor((batch_size, num_channels) + sizes    ,							rng=random.Random(0					)					).to(_lowercase					)
     return image







  @property
  def   UpperCAmelCase     (			self  :Tuple					):






     '''simple docstring'''





     torch.manual_seed(0					)
     lowercase__    =  UNetaDModel(
         block_out_channels=(32, 64)    ,							layers_per_block=2    ,							sample_size=32    ,							in_channels=6    ,							out_channels=3    ,							down_block_types=("DownBlock2D", "AttnDownBlock2D")    ,							up_block_types=("AttnUpBlock2D", "UpBlock2D")    ,							)
     return model







  @property
  def   UpperCAmelCase     (			self  :str					):






     '''simple docstring'''





     torch.manual_seed(0					)
     lowercase__    =  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







  def   UpperCAmelCase     (			self  :List[str]					):






     '''simple docstring'''





     lowercase__    =  "cpu"
     lowercase__    =  self.dummy_uncond_unet
     lowercase__    =  DDIMScheduler()
     lowercase__    =  self.dummy_vq_model

     lowercase__    =  LDMSuperResolutionPipeline(unet=_lowercase    ,							vqvae=_lowercase    ,							scheduler=_lowercase					)
     ldm.to(_lowercase					)
     ldm.set_progress_bar_config(disable=_lowercase					)

     lowercase__    =  self.dummy_image.to(_lowercase					)

     lowercase__    =  torch.Generator(device=_lowercase					).manual_seed(0					)
     lowercase__    =  ldm(image=_lowercase    ,							generator=_lowercase    ,							num_inference_steps=2    ,							output_type="numpy"					).images

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

     assert image.shape == (1, 64, 64, 3)
     lowercase__    =  np.array([0.8678, 0.8245, 0.6381, 0.6830, 0.4385, 0.5599, 0.4641, 0.6201, 0.5150]					)

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







  @unittest.skipIf(torch_device != "cuda"    ,							"This test requires a GPU"					)
  def   UpperCAmelCase     (			self  :Optional[int]					):






     '''simple docstring'''





     lowercase__    =  self.dummy_uncond_unet
     lowercase__    =  DDIMScheduler()
     lowercase__    =  self.dummy_vq_model

     # put models in fp16
     lowercase__    =  unet.half()
     lowercase__    =  vqvae.half()

     lowercase__    =  LDMSuperResolutionPipeline(unet=_lowercase    ,							vqvae=_lowercase    ,							scheduler=_lowercase					)
     ldm.to(_lowercase					)
     ldm.set_progress_bar_config(disable=_lowercase					)

     lowercase__    =  self.dummy_image.to(_lowercase					)

     lowercase__    =  ldm(_lowercase    ,							num_inference_steps=2    ,							output_type="numpy"					).images

     assert image.shape == (1, 64, 64, 3)





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







  def   UpperCAmelCase     (			self  :List[Any]					):






     '''simple docstring'''





     lowercase__    =  load_image(
         "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
         "/vq_diffusion/teddy_bear_pool.png"					)
     lowercase__    =  init_image.resize((64, 64)    ,							resample=PIL_INTERPOLATION["lanczos"]					)

     lowercase__    =  LDMSuperResolutionPipeline.from_pretrained("duongna/ldm-super-resolution"    ,							device_map="auto"					)
     ldm.set_progress_bar_config(disable=_lowercase					)

     lowercase__    =  torch.manual_seed(0					)
     lowercase__    =  ldm(image=_lowercase    ,							generator=_lowercase    ,							num_inference_steps=20    ,							output_type="numpy"					).images

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

     assert image.shape == (1, 2_56, 2_56, 3)
     lowercase__    =  np.array([0.7644, 0.7679, 0.7642, 0.7633, 0.7666, 0.7560, 0.7425, 0.7257, 0.6907]					)

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













from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


_snake_case				= {"""configuration_dinat""": ["""DINAT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """DinatConfig"""]}


try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  _snake_case				= [
      """DINAT_PRETRAINED_MODEL_ARCHIVE_LIST""",
      """DinatForImageClassification""",
      """DinatModel""",
      """DinatPreTrainedModel""",
      """DinatBackbone""",
  ]

if TYPE_CHECKING:
  from .configuration_dinat import DINAT_PRETRAINED_CONFIG_ARCHIVE_MAP, DinatConfig

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_dinat import (
        DINAT_PRETRAINED_MODEL_ARCHIVE_LIST,
        DinatBackbone,
        DinatForImageClassification,
        DinatModel,
        DinatPreTrainedModel,
    )

else:
  import sys

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






