




"""simple docstring"""






from ...configuration_utils import PretrainedConfig
from ...utils import logging


lowercase__     						=						logging.get_logger(__name__)

lowercase__     						=						{
    """google/realm-cc-news-pretrained-embedder""": (
        """https://huggingface.co/google/realm-cc-news-pretrained-embedder/resolve/main/config.json"""
    ),
    """google/realm-cc-news-pretrained-encoder""": (
        """https://huggingface.co/google/realm-cc-news-pretrained-encoder/resolve/main/config.json"""
    ),
    """google/realm-cc-news-pretrained-scorer""": (
        """https://huggingface.co/google/realm-cc-news-pretrained-scorer/resolve/main/config.json"""
    ),
    """google/realm-cc-news-pretrained-openqa""": (
        """https://huggingface.co/google/realm-cc-news-pretrained-openqa/aresolve/main/config.json"""
    ),
    """google/realm-orqa-nq-openqa""": """https://huggingface.co/google/realm-orqa-nq-openqa/resolve/main/config.json""",
    """google/realm-orqa-nq-reader""": """https://huggingface.co/google/realm-orqa-nq-reader/resolve/main/config.json""",
    """google/realm-orqa-wq-openqa""": """https://huggingface.co/google/realm-orqa-wq-openqa/resolve/main/config.json""",
    """google/realm-orqa-wq-reader""": """https://huggingface.co/google/realm-orqa-wq-reader/resolve/main/config.json""",
    # See all REALM models at https://huggingface.co/models?filter=realm
}






class lowerCAmelCase__	(     lowercase						):






			'''simple docstring'''



			lowerCamelCase__      =			"""realm"""
			def __init__(  self  ,      lowercase=30522  ,      lowercase=768  ,      lowercase=128  ,      lowercase=12  ,      lowercase=12  ,      lowercase=8  ,      lowercase=3072  ,      lowercase="gelu_new"  ,      lowercase=0.1  ,      lowercase=0.1  ,      lowercase=512  ,      lowercase=2  ,      lowercase=0.02  ,      lowercase=1E-12  ,      lowercase=256  ,      lowercase=10  ,      lowercase=1E-3  ,      lowercase=5  ,      lowercase=320  ,      lowercase=13353718  ,      lowercase=5000  ,      lowercase=1  ,      lowercase=0  ,      lowercase=2  ,      **lowercase  ,      ):
							super().__init__(pad_token_id=lowercase  ,      bos_token_id=lowercase  ,      eos_token_id=lowercase  ,      **lowercase  )

							# Common config
							_lowerCamelCase     :			Tuple    =    vocab_size
							_lowerCamelCase     :			int    =    max_position_embeddings
							_lowerCamelCase     :			List[Any]    =    hidden_size
							_lowerCamelCase     :			Union[str, Any]    =    retriever_proj_size
							_lowerCamelCase     :			Tuple    =    num_hidden_layers
							_lowerCamelCase     :			List[str]    =    num_attention_heads
							_lowerCamelCase     :			Union[str, Any]    =    num_candidates
							_lowerCamelCase     :			Dict    =    intermediate_size
							_lowerCamelCase     :			str    =    hidden_act
							_lowerCamelCase     :			int    =    hidden_dropout_prob
							_lowerCamelCase     :			Dict    =    attention_probs_dropout_prob
							_lowerCamelCase     :			List[Any]    =    initializer_range
							_lowerCamelCase     :			Union[str, Any]    =    type_vocab_size
							_lowerCamelCase     :			str    =    layer_norm_eps

							# Reader config
							_lowerCamelCase     :			List[str]    =    span_hidden_size
							_lowerCamelCase     :			str    =    max_span_width
							_lowerCamelCase     :			Any    =    reader_layer_norm_eps
							_lowerCamelCase     :			List[Any]    =    reader_beam_size
							_lowerCamelCase     :			Any    =    reader_seq_len

							# Retrieval config
							_lowerCamelCase     :			Tuple    =    num_block_records
							_lowerCamelCase     :			str    =    searcher_beam_size





"""simple docstring"""






import unittest

import numpy as np
import torch

from diffusers import DDIMPipeline, DDIMScheduler, UNetaDModel
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu, slow, torch_device

from ..pipeline_params import UNCONDITIONAL_IMAGE_GENERATION_BATCH_PARAMS, UNCONDITIONAL_IMAGE_GENERATION_PARAMS
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()






class lowerCAmelCase__	(     lowercase,	unittest.TestCase						):






			'''simple docstring'''



			lowerCamelCase__      =			DDIMPipeline
			lowerCamelCase__      =			UNCONDITIONAL_IMAGE_GENERATION_PARAMS
			lowerCamelCase__      =			PipelineTesterMixin.required_optional_params - {
			    """num_images_per_prompt""",
			    """latents""",
			    """callback""",
			    """callback_steps""",
			}
			lowerCamelCase__      =			UNCONDITIONAL_IMAGE_GENERATION_BATCH_PARAMS
			lowerCamelCase__      =			False
			def 					A_    (  self  ):
							torch.manual_seed(0  )
							_lowerCamelCase     :			List[Any]    =    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')  ,      )
							_lowerCamelCase     :			List[str]    =    DDIMScheduler()
							_lowerCamelCase     :			Optional[int]    =    {'unet': unet, 'scheduler': scheduler}
							return components
			def 					A_    (  self  ,      lowercase  ,      lowercase=0  ):
							if str(lowercase  ).startswith('mps'  ):
											_lowerCamelCase     :			Dict    =    torch.manual_seed(lowercase  )
							else:
											_lowerCamelCase     :			List[str]    =    torch.Generator(device=lowercase  ).manual_seed(lowercase  )
							_lowerCamelCase     :			Tuple    =    {
							    'batch_size': 1,
							    'generator': generator,
							    'num_inference_steps': 2,
							    'output_type': 'numpy',
							}
							return inputs
			def 					A_    (  self  ):
							_lowerCamelCase     :			Any    =    'cpu'

							_lowerCamelCase     :			Tuple    =    self.get_dummy_components()
							_lowerCamelCase     :			Optional[Any]    =    self.pipeline_class(**lowercase  )
							pipe.to(lowercase  )
							pipe.set_progress_bar_config(disable=lowercase  )

							_lowerCamelCase     :			str    =    self.get_dummy_inputs(lowercase  )
							_lowerCamelCase     :			int    =    pipe(**lowercase  ).images
							_lowerCamelCase     :			Any    =    image[0, -3:, -3:, -1]

							self.assertEqual(image.shape  ,      (1, 32, 32, 3)  )
							_lowerCamelCase     :			Tuple    =    np.array(
							    [1.000E00, 5.717E-01, 4.717E-01, 1.000E00, 0.000E00, 1.000E00, 3.000E-04, 0.000E00, 9.000E-04]  )
							_lowerCamelCase     :			str    =    np.abs(image_slice.flatten() - expected_slice  ).max()
							self.assertLessEqual(lowercase  ,      1E-3  )
			def 					A_    (  self  ):
							super().test_dict_tuple_outputs_equivalent(expected_max_difference=3E-3  )
			def 					A_    (  self  ):
							super().test_save_load_local(expected_max_difference=3E-3  )
			def 					A_    (  self  ):
							super().test_save_load_optional_components(expected_max_difference=3E-3  )






			def 					A_    (  self  ):
							super().test_inference_batch_single_identical(expected_max_diff=3E-3  )






@slow
@require_torch_gpu
class lowerCAmelCase__	(     unittest.TestCase						):






			'''simple docstring'''



			def 					A_    (  self  ):
							_lowerCamelCase     :			Optional[Any]    =    'google/ddpm-cifar10-32'

							_lowerCamelCase     :			Optional[Any]    =    UNetaDModel.from_pretrained(lowercase  )
							_lowerCamelCase     :			Dict    =    DDIMScheduler()

							_lowerCamelCase     :			Dict    =    DDIMPipeline(unet=lowercase  ,      scheduler=lowercase  )
							ddim.to(lowercase  )
							ddim.set_progress_bar_config(disable=lowercase  )

							_lowerCamelCase     :			List[str]    =    torch.manual_seed(0  )
							_lowerCamelCase     :			str    =    ddim(generator=lowercase  ,      eta=0.0  ,      output_type='numpy'  ).images

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

							assert image.shape == (1, 32, 32, 3)
							_lowerCamelCase     :			List[Any]    =    np.array([0.17_23, 0.16_17, 0.16_00, 0.16_26, 0.14_97, 0.15_13, 0.15_05, 0.14_42, 0.14_53]  )

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






			def 					A_    (  self  ):
							_lowerCamelCase     :			Optional[int]    =    'google/ddpm-ema-bedroom-256'

							_lowerCamelCase     :			str    =    UNetaDModel.from_pretrained(lowercase  )
							_lowerCamelCase     :			str    =    DDIMScheduler.from_pretrained(lowercase  )

							_lowerCamelCase     :			Optional[int]    =    DDIMPipeline(unet=lowercase  ,      scheduler=lowercase  )
							ddpm.to(lowercase  )
							ddpm.set_progress_bar_config(disable=lowercase  )

							_lowerCamelCase     :			Tuple    =    torch.manual_seed(0  )
							_lowerCamelCase     :			int    =    ddpm(generator=lowercase  ,      output_type='numpy'  ).images

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

							assert image.shape == (1, 256, 256, 3)
							_lowerCamelCase     :			str    =    np.array([0.00_60, 0.02_01, 0.03_44, 0.00_24, 0.00_18, 0.00_02, 0.00_22, 0.00_00, 0.00_69]  )

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