



'''simple docstring'''





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


__a          =		logging.get_logger(__name__)

__a          =		{
    "bigcode/gpt_bigcode-santacoder": "https://huggingface.co/bigcode/gpt_bigcode-santacoder/resolve/main/config.json",
}







class     UpperCAmelCase_       (       _a	):
    """simple docstring"""







    lowercase					=		"gpt_bigcode"
    lowercase					=		["past_key_values"]
    lowercase					=		{
        "hidden_size": "n_embd",
        "max_position_embeddings": "n_positions",
        "num_attention_heads": "n_head",
        "num_hidden_layers": "n_layer",
    }




    def __init__(    self					:     List[str] ,     snake_case_					:     str=50_257 ,     snake_case_					:     Tuple=1_024 ,     snake_case_					:     Union[str, Any]=768 ,     snake_case_					:     List[Any]=12 ,     snake_case_					:     Optional[int]=12 ,     snake_case_					:     Dict=None ,     snake_case_					:     Optional[Any]="gelu_pytorch_tanh" ,     snake_case_					:     Dict=0.1 ,     snake_case_					:     int=0.1 ,     snake_case_					:     Optional[Any]=0.1 ,     snake_case_					:     Dict=1E-5 ,     snake_case_					:     Optional[int]=0.02 ,     snake_case_					:     Dict=True ,     snake_case_					:     List[str]=True ,     snake_case_					:     Optional[Any]=50_256 ,     snake_case_					:     Any=50_256 ,     snake_case_					:     List[str]=True ,     snake_case_					:     Optional[Any]=True ,     snake_case_					:     Any=True ,     **snake_case_					:     int ,     ):
          snake_case__  :    Optional[Any]    						=      vocab_size
          snake_case__  :    Tuple    						=      n_positions
          snake_case__  :    Any    						=      n_embd
          snake_case__  :    List[str]    						=      n_layer
          snake_case__  :    Union[str, Any]    						=      n_head
          snake_case__  :    Optional[int]    						=      n_inner
          snake_case__  :    Any    						=      activation_function
          snake_case__  :    List[Any]    						=      resid_pdrop
          snake_case__  :    Tuple    						=      embd_pdrop
          snake_case__  :    Tuple    						=      attn_pdrop
          snake_case__  :    Optional[int]    						=      layer_norm_epsilon
          snake_case__  :    Dict    						=      initializer_range
          snake_case__  :    Dict    						=      scale_attn_weights
          snake_case__  :    Optional[Any]    						=      use_cache
          snake_case__  :    str    						=      attention_softmax_in_fpaa
          snake_case__  :    List[Any]    						=      scale_attention_softmax_in_fpaa
          snake_case__  :    Tuple    						=      multi_query

          snake_case__  :    Optional[int]    						=      bos_token_id
          snake_case__  :    int    						=      eos_token_id

          super().__init__(bos_token_id=snake_case_ ,     eos_token_id=snake_case_ ,     **snake_case_						)








import random
import unittest

import torch

from diffusers import IFImgaImgSuperResolutionPipeline
from diffusers.utils import floats_tensor
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import skip_mps, torch_device

from ..pipeline_params import TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineTesterMixin
from . import IFPipelineTesterMixin



@skip_mps
class   lowerCamelCase      (_snake_case ,  _snake_case ,  unittest.TestCase			):







		'''simple docstring'''



		_snake_case    :    Union[str, Any]       						=  IFImgaImgSuperResolutionPipeline
		_snake_case    :    Union[str, Any]       						=  TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'''width''', '''height'''}
		_snake_case    :    List[Any]       						=  TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({'''original_image'''}			)
		_snake_case    :    List[str]       						=  PipelineTesterMixin.required_optional_params - {'''latents'''}



		def 					__UpperCAmelCase			(							self   )	->							Optional[Any]:
							return self._get_superresolution_dummy_components()



		def 					__UpperCAmelCase			(							self				,		_UpperCamelCase				,		_UpperCamelCase=0   )	->							Any:
							if str(_UpperCamelCase   ).startswith('mps'   ):
												UpperCAmelCase_    :      List[Any]            =						torch.manual_seed(_UpperCamelCase   )
							else:
												UpperCAmelCase_    :      int            =						torch.Generator(device=_UpperCamelCase   ).manual_seed(_UpperCamelCase   )

							UpperCAmelCase_    :      List[Any]            =						floats_tensor((1, 3, 3_2, 3_2)				,		rng=random.Random(_UpperCamelCase   )   ).to(_UpperCamelCase   )
							UpperCAmelCase_    :      Dict            =						floats_tensor((1, 3, 1_6, 1_6)				,		rng=random.Random(_UpperCamelCase   )   ).to(_UpperCamelCase   )

							UpperCAmelCase_    :      Tuple            =						{
							    'prompt': 'A painting of a squirrel eating a burger',
							    'image': image,
							    'original_image': original_image,
							    'generator': generator,
							    'num_inference_steps': 2,
							    'output_type': 'numpy',
							}

							return inputs



		@unittest.skipIf(
		    torch_device != 'cuda' or not is_xformers_available()				,		reason='XFormers attention is only available with CUDA and `xformers` installed'				,		)
		def 					__UpperCAmelCase			(							self   )	->							Any:
							self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3   )



		def 					__UpperCAmelCase			(							self   )	->							Dict:
							self._test_save_load_optional_components()



		@unittest.skipIf(torch_device != 'cuda'				,		reason='float16 requires CUDA'   )
		def 					__UpperCAmelCase			(							self   )	->							str:
							# Due to non-determinism in save load of the hf-internal-testing/tiny-random-t5 text encoder
							super().test_save_load_floataa(expected_max_diff=1E-1   )



		def 					__UpperCAmelCase			(							self   )	->							List[Any]:
							self._test_attention_slicing_forward_pass(expected_max_diff=1E-2   )



		def 					__UpperCAmelCase			(							self   )	->							Union[str, Any]:
							self._test_save_load_local()



		def 					__UpperCAmelCase			(							self   )	->							Dict:
							self._test_inference_batch_single_identical(
							    expected_max_diff=1E-2				,		)






