






'''simple docstring'''





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



      """simple docstring"""


      @property
      def 			UpperCAmelCase   (   self      :    List[str]      )							->   Dict:
        __UpperCAmelCase							:			List[str]     =						1
        __UpperCAmelCase							:			Optional[int]     =						3
        __UpperCAmelCase							:			Dict     =						(32, 32)

        __UpperCAmelCase							:			str     =						floats_tensor((batch_size, num_channels) + sizes	,   rng=random.Random(0      )      ).to(A_      )
        return image
      @property
      def 			UpperCAmelCase   (   self      :    str      )							->   Tuple:
        torch.manual_seed(0      )
        __UpperCAmelCase							:			Dict     =						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      :    Any      )							->   Tuple:
        torch.manual_seed(0      )
        __UpperCAmelCase							:			Union[str, Any]     =						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      :    Tuple      )							->   Any:
        __UpperCAmelCase							:			Optional[int]     =						"""cpu"""
        __UpperCAmelCase							:			int     =						self.dummy_uncond_unet
        __UpperCAmelCase							:			Optional[int]     =						DDIMScheduler()
        __UpperCAmelCase							:			Union[str, Any]     =						self.dummy_vq_model

        __UpperCAmelCase							:			Any     =						LDMSuperResolutionPipeline(unet=A_	,   vqvae=A_	,   scheduler=A_      )
        ldm.to(A_      )
        ldm.set_progress_bar_config(disable=A_      )

        __UpperCAmelCase							:			Optional[int]     =						self.dummy_image.to(A_      )

        __UpperCAmelCase							:			int     =						torch.Generator(device=A_      ).manual_seed(0      )
        __UpperCAmelCase							:			Any     =						ldm(image=A_	,   generator=A_	,   num_inference_steps=2	,   output_type="""numpy"""      ).images

        __UpperCAmelCase							:			Dict     =						image[0, -3:, -3:, -1]

        assert image.shape == (1, 64, 64, 3)
        __UpperCAmelCase							:			List[str]     =						np.array([0.8_678, 0.8_245, 0.6_381, 0.6_830, 0.4_385, 0.5_599, 0.4_641, 0.6_201, 0.5_150]      )

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




      @unittest.skipIf(torch_device != """cuda"""	,   """This test requires a GPU"""      )
      def 			UpperCAmelCase   (   self      :    List[str]      )							->   Optional[Any]:
        __UpperCAmelCase							:			Optional[int]     =						self.dummy_uncond_unet
        __UpperCAmelCase							:			List[Any]     =						DDIMScheduler()
        __UpperCAmelCase							:			List[Any]     =						self.dummy_vq_model

        # put models in fp16
        __UpperCAmelCase							:			Any     =						unet.half()
        __UpperCAmelCase							:			Union[str, Any]     =						vqvae.half()

        __UpperCAmelCase							:			List[Any]     =						LDMSuperResolutionPipeline(unet=A_	,   vqvae=A_	,   scheduler=A_      )
        ldm.to(A_      )
        ldm.set_progress_bar_config(disable=A_      )

        __UpperCAmelCase							:			List[str]     =						self.dummy_image.to(A_      )

        __UpperCAmelCase							:			List[str]     =						ldm(A_	,   num_inference_steps=2	,   output_type="""numpy"""      ).images

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


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



      """simple docstring"""


      def 			UpperCAmelCase   (   self      :    Optional[Any]      )							->   List[str]:
        __UpperCAmelCase							:			Optional[Any]     =						load_image(
            """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
            """/vq_diffusion/teddy_bear_pool.png"""      )
        __UpperCAmelCase							:			List[Any]     =						init_image.resize((64, 64)	,   resample=PIL_INTERPOLATION["""lanczos"""]      )

        __UpperCAmelCase							:			Optional[Any]     =						LDMSuperResolutionPipeline.from_pretrained("""duongna/ldm-super-resolution"""	,   device_map="""auto"""      )
        ldm.set_progress_bar_config(disable=A_      )

        __UpperCAmelCase							:			Union[str, Any]     =						torch.manual_seed(0      )
        __UpperCAmelCase							:			int     =						ldm(image=A_	,   generator=A_	,   num_inference_steps=20	,   output_type="""numpy"""      ).images

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

        assert image.shape == (1, 256, 256, 3)
        __UpperCAmelCase							:			int     =						np.array([0.7_644, 0.7_679, 0.7_642, 0.7_633, 0.7_666, 0.7_560, 0.7_425, 0.7_257, 0.6_907]      )

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










from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


a	: Union[str, Any]      =				{
    "configuration_mobilenet_v1": [
        "MOBILENET_V1_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "MobileNetV1Config",
        "MobileNetV1OnnxConfig",
    ],
}

try:
       if not is_vision_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       a	: int      =				["MobileNetV1FeatureExtractor"]
       a	: int      =				["MobileNetV1ImageProcessor"]

try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       a	: int      =				[
           "MOBILENET_V1_PRETRAINED_MODEL_ARCHIVE_LIST",
           "MobileNetV1ForImageClassification",
           "MobileNetV1Model",
           "MobileNetV1PreTrainedModel",
           "load_tf_weights_in_mobilenet_v1",
       ]


if TYPE_CHECKING:
       from .configuration_mobilenet_va import (
           MOBILENET_V1_PRETRAINED_CONFIG_ARCHIVE_MAP,
           MobileNetVaConfig,
           MobileNetVaOnnxConfig,
       )

       try:
              if not is_vision_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .feature_extraction_mobilenet_va import MobileNetVaFeatureExtractor
              from .image_processing_mobilenet_va import MobileNetVaImageProcessor

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_mobilenet_va import (
                  MOBILENET_V1_PRETRAINED_MODEL_ARCHIVE_LIST,
                  MobileNetVaForImageClassification,
                  MobileNetVaModel,
                  MobileNetVaPreTrainedModel,
                  load_tf_weights_in_mobilenet_va,
              )


else:
       import sys

       a	: str      =				_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)


