






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




      @property
      def        __magic_name__		( self		:							List[Any] )		->  Union[str, Any]:
            torch.manual_seed(0 )
            SCREAMING_SNAKE_CASE__       :			Tuple													=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        __magic_name__		( self		:							int )		->  str:
            torch.manual_seed(0 )
            SCREAMING_SNAKE_CASE__       :			List[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




      @property
      def        __magic_name__		( self		:							List[str] )		->  List[str]:
            torch.manual_seed(0 )
            SCREAMING_SNAKE_CASE__       :			Tuple													=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(UpperCamelCase__ )




      def        __magic_name__		( self		:							List[str] )		->  List[Any]:
            SCREAMING_SNAKE_CASE__       :			int													=self.dummy_uncond_unet
            SCREAMING_SNAKE_CASE__       :			List[Any]													=DDIMScheduler()
            SCREAMING_SNAKE_CASE__       :			Optional[int]													=self.dummy_vq_model

            SCREAMING_SNAKE_CASE__       :			int													=LDMPipeline(unet=UpperCamelCase__   , vqvae=UpperCamelCase__   , scheduler=UpperCamelCase__ )
            ldm.to(UpperCamelCase__ )
            ldm.set_progress_bar_config(disable=UpperCamelCase__ )

            SCREAMING_SNAKE_CASE__       :			Union[str, Any]													=torch.manual_seed(0 )
            SCREAMING_SNAKE_CASE__       :			List[str]													=ldm(generator=UpperCamelCase__   , num_inference_steps=2   , output_type='''numpy''' ).images

            SCREAMING_SNAKE_CASE__       :			Any													=torch.manual_seed(0 )
            SCREAMING_SNAKE_CASE__       :			Optional[Any]													=ldm(generator=UpperCamelCase__   , num_inference_steps=2   , output_type='''numpy'''   , return_dict=UpperCamelCase__ )[0]

            SCREAMING_SNAKE_CASE__       :			Dict													=image[0, -3:, -3:, -1]
            SCREAMING_SNAKE_CASE__       :			List[str]													=image_from_tuple[0, -3:, -3:, -1]

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




      def        __magic_name__		( self		:							Any )		->  Dict:
            SCREAMING_SNAKE_CASE__       :			int													=LDMPipeline.from_pretrained('''CompVis/ldm-celebahq-256''' )
            ldm.to(UpperCamelCase__ )
            ldm.set_progress_bar_config(disable=UpperCamelCase__ )

            SCREAMING_SNAKE_CASE__       :			int													=torch.manual_seed(0 )
            SCREAMING_SNAKE_CASE__       :			Optional[Any]													=ldm(generator=UpperCamelCase__   , num_inference_steps=5   , output_type='''numpy''' ).images

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

            assert image.shape == (1, 2_56, 2_56, 3)
            SCREAMING_SNAKE_CASE__       :			List[Any]													=np.array([0.4399, 0.44975, 0.46825, 0.474, 0.4359, 0.4581, 0.45095, 0.4341, 0.4447] )
            SCREAMING_SNAKE_CASE__       :			Optional[Any]													=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_torch_available


a_					=	{
    'configuration_instructblip': [
        'INSTRUCTBLIP_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'InstructBlipConfig',
        'InstructBlipQFormerConfig',
        'InstructBlipVisionConfig',
    ],
    'processing_instructblip': ['InstructBlipProcessor'],
}

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  a_					=	[
      'INSTRUCTBLIP_PRETRAINED_MODEL_ARCHIVE_LIST',
      'InstructBlipQFormerModel',
      'InstructBlipPreTrainedModel',
      'InstructBlipForConditionalGeneration',
      'InstructBlipVisionModel',
  ]

if TYPE_CHECKING:
  from .configuration_instructblip import (
      INSTRUCTBLIP_PRETRAINED_CONFIG_ARCHIVE_MAP,
      InstructBlipConfig,
      InstructBlipQFormerConfig,
      InstructBlipVisionConfig,
  )
  from .processing_instructblip import InstructBlipProcessor

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_instructblip import (
        INSTRUCTBLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
        InstructBlipForConditionalGeneration,
        InstructBlipPreTrainedModel,
        InstructBlipQFormerModel,
        InstructBlipVisionModel,
    )

else:
  import sys

  a_					=	_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)