




"""simple docstring"""





import gc
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    EulerAncestralDiscreteScheduler,
    LMSDiscreteScheduler,
    PNDMScheduler,
    StableDiffusionPanoramaPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu, skip_mps

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()



@skip_mps
class   a__					(						__magic_name__				,     __magic_name__				,     unittest.TestCase ):
			lowercase_		=						StableDiffusionPanoramaPipeline
			lowercase_		=						TEXT_TO_IMAGE_PARAMS
			lowercase_		=						TEXT_TO_IMAGE_BATCH_PARAMS
			lowercase_		=						TEXT_TO_IMAGE_IMAGE_PARAMS
			lowercase_		=						TEXT_TO_IMAGE_IMAGE_PARAMS


			def    a_  (   self   :     int):


						"""simple docstring"""




						torch.manual_seed(0)
						__UpperCAmelCase						:			Optional[int]												=       UNetaDConditionModel(
						    block_out_channels=(32, 64)   ,	layers_per_block=1   ,	sample_size=32   ,	in_channels=4   ,	out_channels=4   ,	down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")   ,	up_block_types=("CrossAttnUpBlock2D", "UpBlock2D")   ,	cross_attention_dim=32   ,	)
						__UpperCAmelCase						:			List[str]												=       DDIMScheduler()
						torch.manual_seed(0)
						__UpperCAmelCase						:			Dict												=       AutoencoderKL(
						    block_out_channels=[32, 64]   ,	in_channels=3   ,	out_channels=3   ,	down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"]   ,	up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"]   ,	latent_channels=4   ,	)
						torch.manual_seed(0)
						__UpperCAmelCase						:			Any												=       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=1000   ,	)
						__UpperCAmelCase						:			Optional[int]												=       CLIPTextModel(UpperCamelCase_)
						__UpperCAmelCase						:			List[str]												=       CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip")

						__UpperCAmelCase						:			List[str]												=       {
						    "unet": unet,
						    "scheduler": scheduler,
						    "vae": vae,
						    "text_encoder": text_encoder,
						    "tokenizer": tokenizer,
						    "safety_checker": None,
						    "feature_extractor": None,
						}
						return components


			def    a_  (   self   :     List[str]   ,	UpperCamelCase_   :     str   ,	UpperCamelCase_   :     List[Any]=0):


						"""simple docstring"""




						__UpperCAmelCase						:			Union[str, Any]												=       torch.manual_seed(UpperCamelCase_)
						__UpperCAmelCase						:			Dict												=       {
						    "prompt": "a photo of the dolomites",
						    "generator": generator,
						    # Setting height and width to None to prevent OOMs on CPU.
						    "height": None,
						    "width": None,
						    "num_inference_steps": 1,
						    "guidance_scale": 6.0,
						    "output_type": "numpy",
						}
						return inputs


			def    a_  (   self   :     List[Any]):


						"""simple docstring"""




						__UpperCAmelCase						:			Optional[int]												=       "cpu"  # ensure determinism for the device-dependent torch.Generator
						__UpperCAmelCase						:			Tuple												=       self.get_dummy_components()
						__UpperCAmelCase						:			Union[str, Any]												=       StableDiffusionPanoramaPipeline(**UpperCamelCase_)
						__UpperCAmelCase						:			Optional[int]												=       sd_pipe.to(UpperCamelCase_)
						sd_pipe.set_progress_bar_config(disable=UpperCamelCase_)

						__UpperCAmelCase						:			Tuple												=       self.get_dummy_inputs(UpperCamelCase_)
						__UpperCAmelCase						:			Optional[int]												=       sd_pipe(**UpperCamelCase_).images
						__UpperCAmelCase						:			Any												=       image[0, -3:, -3:, -1]
						assert image.shape == (1, 64, 64, 3)

						__UpperCAmelCase						:			Any												=       np.array([0.6186, 0.5374, 0.4915, 0.4135, 0.4114, 0.4563, 0.5128, 0.4977, 0.4757])

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


			def    a_  (   self   :     List[Any]):


						"""simple docstring"""




						super().test_inference_batch_consistent(batch_sizes=[1, 2])


			def    a_  (   self   :     Optional[int]):


						"""simple docstring"""




						super().test_inference_batch_single_identical(batch_size=2   ,	expected_max_diff=3.25e-3)


			def    a_  (   self   :     int):


						"""simple docstring"""




						__UpperCAmelCase						:			Union[str, Any]												=       "cpu"  # ensure determinism for the device-dependent torch.Generator
						__UpperCAmelCase						:			Optional[Any]												=       self.get_dummy_components()
						__UpperCAmelCase						:			Any												=       StableDiffusionPanoramaPipeline(**UpperCamelCase_)
						__UpperCAmelCase						:			Dict												=       sd_pipe.to(UpperCamelCase_)
						sd_pipe.set_progress_bar_config(disable=UpperCamelCase_)

						__UpperCAmelCase						:			Any												=       self.get_dummy_inputs(UpperCamelCase_)
						__UpperCAmelCase						:			List[str]												=       "french fries"
						__UpperCAmelCase						:			Any												=       sd_pipe(**UpperCamelCase_   ,	negative_prompt=UpperCamelCase_)
						__UpperCAmelCase						:			Optional[Any]												=       output.images
						__UpperCAmelCase						:			List[Any]												=       image[0, -3:, -3:, -1]

						assert image.shape == (1, 64, 64, 3)

						__UpperCAmelCase						:			str												=       np.array([0.6187, 0.5375, 0.4915, 0.4136, 0.4114, 0.4563, 0.5128, 0.4976, 0.4757])

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


			def    a_  (   self   :     List[str]):


						"""simple docstring"""




						__UpperCAmelCase						:			Tuple												=       "cpu"  # ensure determinism for the device-dependent torch.Generator
						__UpperCAmelCase						:			Optional[Any]												=       self.get_dummy_components()
						__UpperCAmelCase						:			Dict												=       StableDiffusionPanoramaPipeline(**UpperCamelCase_)
						__UpperCAmelCase						:			List[Any]												=       sd_pipe.to(UpperCamelCase_)
						sd_pipe.set_progress_bar_config(disable=UpperCamelCase_)

						__UpperCAmelCase						:			Union[str, Any]												=       self.get_dummy_inputs(UpperCamelCase_)
						__UpperCAmelCase						:			int												=       sd_pipe(**UpperCamelCase_   ,	view_batch_size=2)
						__UpperCAmelCase						:			Any												=       output.images
						__UpperCAmelCase						:			Optional[int]												=       image[0, -3:, -3:, -1]

						assert image.shape == (1, 64, 64, 3)

						__UpperCAmelCase						:			Optional[Any]												=       np.array([0.6187, 0.5375, 0.4915, 0.4136, 0.4114, 0.4563, 0.5128, 0.4976, 0.4757])

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


			def    a_  (   self   :     Optional[int]):


						"""simple docstring"""




						__UpperCAmelCase						:			Any												=       "cpu"  # ensure determinism for the device-dependent torch.Generator
						__UpperCAmelCase						:			Union[str, Any]												=       self.get_dummy_components()
						__UpperCAmelCase						:			Optional[Any]												=       EulerAncestralDiscreteScheduler(
						    beta_start=0.00085   ,	beta_end=0.012   ,	beta_schedule="scaled_linear")
						__UpperCAmelCase						:			Union[str, Any]												=       StableDiffusionPanoramaPipeline(**UpperCamelCase_)
						__UpperCAmelCase						:			List[str]												=       sd_pipe.to(UpperCamelCase_)
						sd_pipe.set_progress_bar_config(disable=UpperCamelCase_)

						__UpperCAmelCase						:			Optional[Any]												=       self.get_dummy_inputs(UpperCamelCase_)
						__UpperCAmelCase						:			str												=       sd_pipe(**UpperCamelCase_).images
						__UpperCAmelCase						:			List[Any]												=       image[0, -3:, -3:, -1]

						assert image.shape == (1, 64, 64, 3)

						__UpperCAmelCase						:			int												=       np.array([0.4024, 0.6510, 0.4901, 0.5378, 0.5813, 0.5622, 0.4795, 0.4467, 0.4952])

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


			def    a_  (   self   :     Any):


						"""simple docstring"""




						__UpperCAmelCase						:			List[Any]												=       "cpu"  # ensure determinism for the device-dependent torch.Generator
						__UpperCAmelCase						:			int												=       self.get_dummy_components()
						__UpperCAmelCase						:			List[Any]												=       PNDMScheduler(
						    beta_start=0.00085   ,	beta_end=0.012   ,	beta_schedule="scaled_linear"   ,	skip_prk_steps=UpperCamelCase_)
						__UpperCAmelCase						:			Tuple												=       StableDiffusionPanoramaPipeline(**UpperCamelCase_)
						__UpperCAmelCase						:			str												=       sd_pipe.to(UpperCamelCase_)
						sd_pipe.set_progress_bar_config(disable=UpperCamelCase_)

						__UpperCAmelCase						:			Optional[int]												=       self.get_dummy_inputs(UpperCamelCase_)
						__UpperCAmelCase						:			Union[str, Any]												=       sd_pipe(**UpperCamelCase_).images
						__UpperCAmelCase						:			Optional[Any]												=       image[0, -3:, -3:, -1]

						assert image.shape == (1, 64, 64, 3)

						__UpperCAmelCase						:			Any												=       np.array([0.6391, 0.6291, 0.4861, 0.5134, 0.5552, 0.4578, 0.5032, 0.5023, 0.4539])

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






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


			def    a_  (   self   :     List[Any]):


						"""simple docstring"""




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


			def    a_  (   self   :     Optional[Any]   ,	UpperCamelCase_   :     Optional[int]=0):


						"""simple docstring"""




						__UpperCAmelCase						:			List[str]												=       torch.manual_seed(UpperCamelCase_)
						__UpperCAmelCase						:			List[Any]												=       {
						    "prompt": "a photo of the dolomites",
						    "generator": generator,
						    "num_inference_steps": 3,
						    "guidance_scale": 7.5,
						    "output_type": "numpy",
						}
						return inputs


			def    a_  (   self   :     Dict):


						"""simple docstring"""




						__UpperCAmelCase						:			Optional[Any]												=       "stabilityai/stable-diffusion-2-base"
						__UpperCAmelCase						:			Dict												=       DDIMScheduler.from_pretrained(UpperCamelCase_   ,	subfolder="scheduler")
						__UpperCAmelCase						:			List[Any]												=       StableDiffusionPanoramaPipeline.from_pretrained(UpperCamelCase_   ,	scheduler=UpperCamelCase_   ,	safety_checker=UpperCamelCase_)
						pipe.to(UpperCamelCase_)
						pipe.set_progress_bar_config(disable=UpperCamelCase_)
						pipe.enable_attention_slicing()

						__UpperCAmelCase						:			Optional[Any]												=       self.get_inputs()
						__UpperCAmelCase						:			Optional[int]												=       pipe(**UpperCamelCase_).images
						__UpperCAmelCase						:			int												=       image[0, -3:, -3:, -1].flatten()

						assert image.shape == (1, 512, 2048, 3)

						__UpperCAmelCase						:			Tuple												=       np.array(
						    [
						        0.36968392,
						        0.27025372,
						        0.32446766,
						        0.28379387,
						        0.36363274,
						        0.30733347,
						        0.27100027,
						        0.27054125,
						        0.25536096,
						    ])

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


			def    a_  (   self   :     int):


						"""simple docstring"""




						__UpperCAmelCase						:			Dict												=       StableDiffusionPanoramaPipeline.from_pretrained(
						    "stabilityai/stable-diffusion-2-base"   ,	safety_checker=UpperCamelCase_)
						__UpperCAmelCase						:			Optional[int]												=       LMSDiscreteScheduler.from_config(pipe.scheduler.config)
						pipe.to(UpperCamelCase_)
						pipe.set_progress_bar_config(disable=UpperCamelCase_)
						pipe.enable_attention_slicing()

						__UpperCAmelCase						:			Dict												=       self.get_inputs()
						__UpperCAmelCase						:			Optional[int]												=       pipe(**UpperCamelCase_).images
						__UpperCAmelCase						:			Union[str, Any]												=       image[0, -3:, -3:, -1].flatten()

						assert image.shape == (1, 512, 2048, 3)

						__UpperCAmelCase						:			Optional[int]												=       np.array(
						    [
						        [
						            0.0,
						            0.0,
						            0.0,
						            0.0,
						            0.0,
						            0.0,
						            0.0,
						            0.0,
						            0.0,
						        ]
						    ])

						assert np.abs(expected_slice - image_slice).max() < 1e-3


			def    a_  (   self   :     Dict):


						"""simple docstring"""




						__UpperCAmelCase						:			List[Any]												=       0

						def callback_fn(UpperCamelCase_   :     int   ,	UpperCamelCase_   :     int   ,	UpperCamelCase_   :     torch.FloatTensor) -> None:
									__UpperCAmelCase						:			Any												=       True
									nonlocal number_of_steps
									number_of_steps += 1
									if step == 1:
												__UpperCAmelCase						:			List[Any]												=       latents.detach().cpu().numpy()
												assert latents.shape == (1, 4, 64, 256)
												__UpperCAmelCase						:			Dict												=       latents[0, -3:, -3:, -1]

												__UpperCAmelCase						:			Union[str, Any]												=       np.array(
												    [
												        0.18681869,
												        0.33907816,
												        0.5361276,
												        0.14432865,
												        -0.02856611,
												        -0.73941123,
												        0.23397987,
												        0.47322682,
												        -0.37823164,
												    ])
												assert np.abs(latents_slice.flatten() - expected_slice).max() < 5e-2
									elif step == 2:
												__UpperCAmelCase						:			Tuple												=       latents.detach().cpu().numpy()
												assert latents.shape == (1, 4, 64, 256)
												__UpperCAmelCase						:			Any												=       latents[0, -3:, -3:, -1]

												__UpperCAmelCase						:			Optional[int]												=       np.array(
												    [
												        0.18539645,
												        0.33987248,
												        0.5378559,
												        0.14437142,
												        -0.02455261,
												        -0.7338317,
												        0.23990755,
												        0.47356272,
												        -0.3786505,
												    ])

												assert np.abs(latents_slice.flatten() - expected_slice).max() < 5e-2

						__UpperCAmelCase						:			Dict												=       False

						__UpperCAmelCase						:			Any												=       "stabilityai/stable-diffusion-2-base"
						__UpperCAmelCase						:			str												=       DDIMScheduler.from_pretrained(UpperCamelCase_   ,	subfolder="scheduler")
						__UpperCAmelCase						:			Optional[int]												=       StableDiffusionPanoramaPipeline.from_pretrained(UpperCamelCase_   ,	scheduler=UpperCamelCase_   ,	safety_checker=UpperCamelCase_)
						__UpperCAmelCase						:			Any												=       pipe.to(UpperCamelCase_)
						pipe.set_progress_bar_config(disable=UpperCamelCase_)
						pipe.enable_attention_slicing()

						__UpperCAmelCase						:			str												=       self.get_inputs()
						pipe(**UpperCamelCase_   ,	callback=UpperCamelCase_   ,	callback_steps=1)
						assert callback_fn.has_been_called
						assert number_of_steps == 3


			def    a_  (   self   :     str):


						"""simple docstring"""




						torch.cuda.empty_cache()
						torch.cuda.reset_max_memory_allocated()
						torch.cuda.reset_peak_memory_stats()

						__UpperCAmelCase						:			Optional[int]												=       "stabilityai/stable-diffusion-2-base"
						__UpperCAmelCase						:			Any												=       DDIMScheduler.from_pretrained(UpperCamelCase_   ,	subfolder="scheduler")
						__UpperCAmelCase						:			List[str]												=       StableDiffusionPanoramaPipeline.from_pretrained(UpperCamelCase_   ,	scheduler=UpperCamelCase_   ,	safety_checker=UpperCamelCase_)
						__UpperCAmelCase						:			Tuple												=       pipe.to(UpperCamelCase_)
						pipe.set_progress_bar_config(disable=UpperCamelCase_)
						pipe.enable_attention_slicing(1)
						pipe.enable_sequential_cpu_offload()

						__UpperCAmelCase						:			int												=       self.get_inputs()
						__UpperCAmelCase						:			Optional[Any]												=       pipe(**UpperCamelCase_)

						__UpperCAmelCase						:			str												=       torch.cuda.max_memory_allocated()
						# make sure that less than 5.2 GB is allocated
						assert mem_bytes < 5.5 * 10**9






'''simple docstring'''
# 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.

from argparse import ArgumentParser

from accelerate.commands.config import get_config_parser
from accelerate.commands.env import env_command_parser
from accelerate.commands.launch import launch_command_parser
from accelerate.commands.test import test_command_parser
from accelerate.commands.tpu import tpu_command_parser


def       _lowercase							(					):
 __A	:		Dict	  =      ArgumentParser('Accelerate CLI tool',					usage='accelerate <command> [<args>]',					allow_abbrev=UpperCamelCase__      )
 __A	:		Any	  =      parser.add_subparsers(help='accelerate command helpers'      )

 # Register commands
 get_config_parser(subparsers=UpperCamelCase__      )
 env_command_parser(subparsers=UpperCamelCase__      )
 launch_command_parser(subparsers=UpperCamelCase__      )
 tpu_command_parser(subparsers=UpperCamelCase__      )
 test_command_parser(subparsers=UpperCamelCase__      )

 # Let's go
 __A	:		Optional[Any]	  =      parser.parse_args()

 if not hasattr(UpperCamelCase__,					'func'      ):
  parser.print_help()
  exit(1      )

 # Run
 args.func(UpperCamelCase__      )


if __name__ == "__main__":
 main()






