



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				):

			@property
			def     __snake_case					(self				)					->      Optional[Any]:
						UpperCAmelCase_:		Tuple       			=    1
						UpperCAmelCase_:		List[Any]       			=    3
						UpperCAmelCase_:		Tuple       			=    (32, 32)

						UpperCAmelCase_:		Union[str, Any]       			=    floats_tensor((batch_size, num_channels) + sizes,      rng=random.Random(0				)				).to(lowerCamelCase_				)
						return image

			@property
			def     __snake_case					(self				)					->      List[Any]:
						torch.manual_seed(0				)
						UpperCAmelCase_:		List[str]       			=    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     __snake_case					(self				)					->      Tuple:
						torch.manual_seed(0				)
						UpperCAmelCase_:		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     __snake_case					(self				)					->      int:
						UpperCAmelCase_:		Union[str, Any]       			=    """cpu"""
						UpperCAmelCase_:		Optional[int]       			=    self.dummy_uncond_unet
						UpperCAmelCase_:		int       			=    DDIMScheduler()
						UpperCAmelCase_:		Optional[Any]       			=    self.dummy_vq_model

						UpperCAmelCase_:		Tuple       			=    LDMSuperResolutionPipeline(unet=lowerCamelCase_,      vqvae=lowerCamelCase_,      scheduler=lowerCamelCase_				)
						ldm.to(lowerCamelCase_				)
						ldm.set_progress_bar_config(disable=lowerCamelCase_				)

						UpperCAmelCase_:		List[str]       			=    self.dummy_image.to(lowerCamelCase_				)

						UpperCAmelCase_:		Dict       			=    torch.Generator(device=lowerCamelCase_				).manual_seed(0				)
						UpperCAmelCase_:		Optional[int]       			=    ldm(image=lowerCamelCase_,      generator=lowerCamelCase_,      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_6_7_8, 0.8_2_4_5, 0.6_3_8_1, 0.6_8_3_0, 0.4_3_8_5, 0.5_5_9_9, 0.4_6_4_1, 0.6_2_0_1, 0.5_1_5_0]				)

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

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

						# put models in fp16
						UpperCAmelCase_:		List[str]       			=    unet.half()
						UpperCAmelCase_:		Any       			=    vqvae.half()

						UpperCAmelCase_:		Tuple       			=    LDMSuperResolutionPipeline(unet=lowerCamelCase_,      vqvae=lowerCamelCase_,      scheduler=lowerCamelCase_				)
						ldm.to(lowerCamelCase_				)
						ldm.set_progress_bar_config(disable=lowerCamelCase_				)

						UpperCAmelCase_:		Dict       			=    self.dummy_image.to(lowerCamelCase_				)

						UpperCAmelCase_:		Optional[Any]       			=    ldm(lowerCamelCase_,      num_inference_steps=2,      output_type="""numpy"""				).images

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







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

			def     __snake_case					(self				)					->      str:
						UpperCAmelCase_:		Dict       			=    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_:		int       			=    LDMSuperResolutionPipeline.from_pretrained("""duongna/ldm-super-resolution""",      device_map="""auto"""				)
						ldm.set_progress_bar_config(disable=lowerCamelCase_				)

						UpperCAmelCase_:		Any       			=    torch.manual_seed(0				)
						UpperCAmelCase_:		Dict       			=    ldm(image=lowerCamelCase_,      generator=lowerCamelCase_,      num_inference_steps=20,      output_type="""numpy"""				).images

						UpperCAmelCase_:		str       			=    image[0, -3:, -3:, -1]

						assert image.shape == (1, 256, 256, 3)
						UpperCAmelCase_:		Dict       			=    np.array([0.7_6_4_4, 0.7_6_7_9, 0.7_6_4_2, 0.7_6_3_3, 0.7_6_6_6, 0.7_5_6_0, 0.7_4_2_5, 0.7_2_5_7, 0.6_9_0_7]				)

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











from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


a			:     List[str]     = {'configuration_visual_bert': ['VISUAL_BERT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'VisualBertConfig']}

try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	a			:     List[str]     = [
	    'VISUAL_BERT_PRETRAINED_MODEL_ARCHIVE_LIST',
	    'VisualBertForMultipleChoice',
	    'VisualBertForPreTraining',
	    'VisualBertForQuestionAnswering',
	    'VisualBertForRegionToPhraseAlignment',
	    'VisualBertForVisualReasoning',
	    'VisualBertLayer',
	    'VisualBertModel',
	    'VisualBertPreTrainedModel',
	]


if TYPE_CHECKING:
	from .configuration_visual_bert import VISUAL_BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, VisualBertConfig

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_visual_bert import (
		    VISUAL_BERT_PRETRAINED_MODEL_ARCHIVE_LIST,
		    VisualBertForMultipleChoice,
		    VisualBertForPreTraining,
		    VisualBertForQuestionAnswering,
		    VisualBertForRegionToPhraseAlignment,
		    VisualBertForVisualReasoning,
		    VisualBertLayer,
		    VisualBertModel,
		    VisualBertPreTrainedModel,
		)


else:
	import sys

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






