






# Copyright 2021 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import argparse
import os

from accelerate.test_utils import execute_subprocess_async


def   lowerCamelCase__			(     lowercase=None				):

  """simple docstring"""






  if subparsers is not None:
    SCREAMING_SNAKE_CASE       :      Dict							=    subparsers.add_parser("test"				)
  else:
    SCREAMING_SNAKE_CASE       :      List[Any]							=    argparse.ArgumentParser("Accelerate test command"				)

  parser.add_argument(
      "--config_file"						,     default=lowercase						,     help=(
          "The path to use to store the config file. Will default to a file named default_config.yaml in the cache "
          "location, which is the content of the environment `HF_HOME` suffixed with 'accelerate', or if you don't have "
          "such an environment variable, your cache directory ('~/.cache' or the content of `XDG_CACHE_HOME`) suffixed "
          "with 'huggingface'."
      )						,     )

  if subparsers is not None:
    parser.set_defaults(func=lowercase				)
  return parser


def   lowerCamelCase__			(     lowercase				):

  """simple docstring"""






  SCREAMING_SNAKE_CASE       :      Tuple							=    os.path.sep.join(__file__.split(os.path.sep				)[:-2] + ["test_utils", "scripts", "test_script.py"]				)

  if args.config_file is None:
    SCREAMING_SNAKE_CASE       :      List[Any]							=    script_name
  else:
    SCREAMING_SNAKE_CASE       :      List[Any]							=    F'''--config_file={args.config_file} {script_name}'''

  SCREAMING_SNAKE_CASE       :      str							=    ["accelerate-launch"] + test_args.split()
  SCREAMING_SNAKE_CASE       :      List[Any]							=    execute_subprocess_async(lowercase						,     env=os.environ.copy()				)
  if result.returncode == 0:
    print("Test is a success! You are ready for your distributed training!"				)


def   lowerCamelCase__			(     ):

  """simple docstring"""






  SCREAMING_SNAKE_CASE       :      List[str]							=    test_command_parser()
  SCREAMING_SNAKE_CASE       :      str							=    parser.parse_args()
  test_command(lowercase				)


if __name__ == "__main__":
   main()














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  SCREAMING_SNAKE_CASE			(			unittest.TestCase					):
     '''simple docstring'''


     def 				_A       (				self       :	List[Any]      ):
       # clean up the VRAM after each test
       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()


     def 				_A       (				self       :	str      ):
       SCREAMING_SNAKE_CASE       :      List[str]							=    StableDiffusionKDiffusionPipeline.from_pretrained("CompVis/stable-diffusion-v1-4"      )
       SCREAMING_SNAKE_CASE       :      int							=    sd_pipe.to(UpperCAmelCase_      )
       sd_pipe.set_progress_bar_config(disable=UpperCAmelCase_      )

       sd_pipe.set_scheduler("sample_euler"      )

       SCREAMING_SNAKE_CASE       :      str							=    "A painting of a squirrel eating a burger"
       SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    torch.manual_seed(0      )
       SCREAMING_SNAKE_CASE       :      Any							=    sd_pipe([prompt]					, generator=UpperCAmelCase_					, guidance_scale=9.0					, num_inference_steps=20					, output_type="np"      )

       SCREAMING_SNAKE_CASE       :      List[str]							=    output.images

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

       assert image.shape == (1, 512, 512, 3)
       SCREAMING_SNAKE_CASE       :      int							=    np.array([0.0_447, 0.0_492, 0.0_468, 0.0_408, 0.0_383, 0.0_408, 0.0_354, 0.0_380, 0.0_339]      )

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


     def 				_A       (				self       :	List[Any]      ):
       SCREAMING_SNAKE_CASE       :      str							=    StableDiffusionKDiffusionPipeline.from_pretrained("stabilityai/stable-diffusion-2-1-base"      )
       SCREAMING_SNAKE_CASE       :      str							=    sd_pipe.to(UpperCAmelCase_      )
       sd_pipe.set_progress_bar_config(disable=UpperCAmelCase_      )

       sd_pipe.set_scheduler("sample_euler"      )

       SCREAMING_SNAKE_CASE       :      List[str]							=    "A painting of a squirrel eating a burger"
       SCREAMING_SNAKE_CASE       :      Dict							=    torch.manual_seed(0      )
       SCREAMING_SNAKE_CASE       :      Optional[int]							=    sd_pipe([prompt]					, generator=UpperCAmelCase_					, guidance_scale=9.0					, num_inference_steps=20					, output_type="np"      )

       SCREAMING_SNAKE_CASE       :      Optional[int]							=    output.images

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

       assert image.shape == (1, 512, 512, 3)
       SCREAMING_SNAKE_CASE       :      int							=    np.array([0.1_237, 0.1_320, 0.1_438, 0.1_359, 0.1_390, 0.1_132, 0.1_277, 0.1_175, 0.1_112]      )

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






     def 				_A       (				self       :	Optional[int]      ):
       SCREAMING_SNAKE_CASE       :      List[str]							=    StableDiffusionKDiffusionPipeline.from_pretrained("stabilityai/stable-diffusion-2-1-base"      )
       SCREAMING_SNAKE_CASE       :      Any							=    sd_pipe.to(UpperCAmelCase_      )
       sd_pipe.set_progress_bar_config(disable=UpperCAmelCase_      )

       sd_pipe.set_scheduler("sample_dpmpp_2m"      )

       SCREAMING_SNAKE_CASE       :      List[str]							=    "A painting of a squirrel eating a burger"
       SCREAMING_SNAKE_CASE       :      Any							=    torch.manual_seed(0      )
       SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    sd_pipe(
           [prompt]					, generator=UpperCAmelCase_					, guidance_scale=7.5					, num_inference_steps=15					, output_type="np"					, use_karras_sigmas=UpperCAmelCase_					, )

       SCREAMING_SNAKE_CASE       :      Optional[Any]							=    output.images

       SCREAMING_SNAKE_CASE       :      List[Any]							=    image[0, -3:, -3:, -1]

       assert image.shape == (1, 512, 512, 3)
       SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    np.array(
           [0.11_381_689, 0.12_112_921, 0.1_389_457, 0.12_549_606, 0.1_244_964, 0.10_831_517, 0.11_562_866, 0.10_867_816, 0.10_499_048]      )

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






