






"""simple docstring"""


import gc
import unittest

import numpy as np
import torch

from diffusers import StableDiffusionKDiffusionPipeline
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu


enable_full_determinism()






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





    def     lowerCamelCase__				(							self     : Tuple      ):


      '''simple docstring'''




      super().tearDown()
      gc.collect()
      torch.cuda.empty_cache()





    def     lowerCamelCase__				(							self     : Union[str, Any]      ):


      '''simple docstring'''




      a					:      List[Any]    =       StableDiffusionKDiffusionPipeline.from_pretrained('CompVis/stable-diffusion-v1-4'      )
      a					:      Union[str, Any]    =       sd_pipe.to(A      )
      sd_pipe.set_progress_bar_config(disable=A      )

      sd_pipe.set_scheduler('sample_euler'      )

      a					:      Any    =       'A painting of a squirrel eating a burger'
      a					:      List[Any]    =       torch.manual_seed(0      )
      a					:      Tuple    =       sd_pipe([prompt]    ,		generator=A    ,		guidance_scale=9.0    ,		num_inference_steps=2_0    ,		output_type='np'      )

      a					:      Any    =       output.images

      a					:      Optional[int]    =       image[0, -3:, -3:, -1]

      assert image.shape == (1, 5_1_2, 5_1_2, 3)
      a					:      str    =       np.array([0.04_47, 0.04_92, 0.04_68, 0.04_08, 0.03_83, 0.04_08, 0.03_54, 0.03_80, 0.03_39]      )

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





    def     lowerCamelCase__				(							self     : Any      ):


      '''simple docstring'''




      a					:      List[str]    =       StableDiffusionKDiffusionPipeline.from_pretrained('stabilityai/stable-diffusion-2-1-base'      )
      a					:      Any    =       sd_pipe.to(A      )
      sd_pipe.set_progress_bar_config(disable=A      )

      sd_pipe.set_scheduler('sample_euler'      )

      a					:      Union[str, Any]    =       'A painting of a squirrel eating a burger'
      a					:      List[Any]    =       torch.manual_seed(0      )
      a					:      Any    =       sd_pipe([prompt]    ,		generator=A    ,		guidance_scale=9.0    ,		num_inference_steps=2_0    ,		output_type='np'      )

      a					:      List[str]    =       output.images

      a					:      Union[str, Any]    =       image[0, -3:, -3:, -1]

      assert image.shape == (1, 5_1_2, 5_1_2, 3)
      a					:      Any    =       np.array([0.12_37, 0.13_20, 0.14_38, 0.13_59, 0.13_90, 0.11_32, 0.12_77, 0.11_75, 0.11_12]      )

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





    def     lowerCamelCase__				(							self     : Dict      ):


      '''simple docstring'''




      a					:      str    =       StableDiffusionKDiffusionPipeline.from_pretrained('stabilityai/stable-diffusion-2-1-base'      )
      a					:      List[str]    =       sd_pipe.to(A      )
      sd_pipe.set_progress_bar_config(disable=A      )

      sd_pipe.set_scheduler('sample_dpmpp_2m'      )

      a					:      int    =       'A painting of a squirrel eating a burger'
      a					:      Union[str, Any]    =       torch.manual_seed(0      )
      a					:      Tuple    =       sd_pipe(
          [prompt]    ,		generator=A    ,		guidance_scale=7.5    ,		num_inference_steps=1_5    ,		output_type='np'    ,		use_karras_sigmas=A    ,		)

      a					:      Tuple    =       output.images

      a					:      Any    =       image[0, -3:, -3:, -1]

      assert image.shape == (1, 5_1_2, 5_1_2, 3)
      a					:      Union[str, Any]    =       np.array(
          [0.11_38_16_89, 0.12_11_29_21, 0.1_38_94_57, 0.12_54_96_06, 0.1_24_49_64, 0.10_83_15_17, 0.11_56_28_66, 0.10_86_78_16, 0.10_49_90_48]      )

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












"""simple docstring"""


import os
import sys

_UpperCamelCase    :   str   			=						os.path.join(os.path.dirname(__file__), 'src')
sys.path.append(SRC_DIR)


from transformers import (
    AutoConfig,
    AutoModel,
    AutoModelForCausalLM,
    AutoModelForMaskedLM,
    AutoModelForQuestionAnswering,
    AutoModelForSequenceClassification,
    AutoTokenizer,
    add_start_docstrings,
)


_UpperCamelCase    :   int   			=						[
    'torch',
    'numpy',
    'tokenizers',
    'filelock',
    'requests',
    'tqdm',
    'regex',
    'sentencepiece',
    'sacremoses',
    'importlib_metadata',
    'huggingface_hub',
]




@add_start_docstrings(AutoConfig.__doc__				)
def       snake_case  (*A_				:Optional[int]     ,      **A_				:int				):







  '''simple docstring'''

  return AutoConfig.from_pretrained(*A_     ,      **A_				)




@add_start_docstrings(AutoTokenizer.__doc__				)
def       snake_case  (*A_				:Optional[int]     ,      **A_				:List[Any]				):







  '''simple docstring'''

  return AutoTokenizer.from_pretrained(*A_     ,      **A_				)




@add_start_docstrings(AutoModel.__doc__				)
def       snake_case  (*A_				:Optional[Any]     ,      **A_				:Tuple				):







  '''simple docstring'''

  return AutoModel.from_pretrained(*A_     ,      **A_				)




@add_start_docstrings(AutoModelForCausalLM.__doc__				)
def       snake_case  (*A_				:str     ,      **A_				:Optional[int]				):







  '''simple docstring'''

  return AutoModelForCausalLM.from_pretrained(*A_     ,      **A_				)




@add_start_docstrings(AutoModelForMaskedLM.__doc__				)
def       snake_case  (*A_				:Optional[Any]     ,      **A_				:Dict				):







  '''simple docstring'''

  return AutoModelForMaskedLM.from_pretrained(*A_     ,      **A_				)




@add_start_docstrings(AutoModelForSequenceClassification.__doc__				)
def       snake_case  (*A_				:Dict     ,      **A_				:str				):







  '''simple docstring'''

  return AutoModelForSequenceClassification.from_pretrained(*A_     ,      **A_				)






@add_start_docstrings(AutoModelForQuestionAnswering.__doc__				)
def       snake_case  (*A_				:Dict     ,      **A_				:List[Any]				):







  '''simple docstring'''

  return AutoModelForQuestionAnswering.from_pretrained(*A_     ,      **A_				)




