




import torch

from accelerate import PartialState
from accelerate.utils.operations import broadcast, gather, gather_object, pad_across_processes, reduce





def 						__A						(      __lowerCamelCase       ) ->			int:
	return (torch.arange(state.num_processes       ) + 1.0 + (state.num_processes * state.process_index)).to(state.device       )





def 						__A						(      __lowerCamelCase       ) ->			Dict:
	a									=				create_tensor(__A       )
	a									=				gather(__A       )
	assert gathered_tensor.tolist() == list(range(1				,     state.num_processes**2 + 1       )       )





def 						__A						(      __lowerCamelCase       ) ->			Union[str, Any]:
	a									=				[state.process_index]
	a									=				gather_object(__A       )
	assert len(__A       ) == state.num_processes, f'{gathered_obj}, {len(__A       )} != {state.num_processes}'
	assert gathered_obj == list(range(state.num_processes       )       ), f'{gathered_obj} != {list(range(state.num_processes       )       )}'





def 						__A						(      __lowerCamelCase       ) ->			Optional[Any]:
	a									=				create_tensor(__A       )
	a									=				broadcast(__A       )
	assert broadcasted_tensor.shape == torch.Size([state.num_processes]       )
	assert broadcasted_tensor.tolist() == list(range(1				,     state.num_processes + 1       )       )





def 						__A						(      __lowerCamelCase       ) ->			List[str]:
	# We need to pad the tensor with one more element if we are the main process
	# to ensure that we can pad
	if state.is_main_process:
		a									=				torch.arange(state.num_processes + 1       ).to(state.device       )
	else:
		a									=				torch.arange(state.num_processes       ).to(state.device       )
	a									=				pad_across_processes(__A       )
	assert padded_tensor.shape == torch.Size([state.num_processes + 1]       )
	if not state.is_main_process:
		assert padded_tensor.tolist() == list(range(0				,     state.num_processes       )       ) + [0]





def 						__A						(      __lowerCamelCase       ) ->			Optional[int]:
	# For now runs on only two processes
	if state.num_processes != 2:
		return
	a									=				create_tensor(__A       )
	a									=				reduce(__A				,     """sum"""       )
	a									=				torch.tensor([4.0, 6]       ).to(state.device       )
	assert torch.allclose(__A				,     __A       ), f'{reduced_tensor} != {truth_tensor}'





def 						__A						(      __lowerCamelCase       ) ->			Optional[int]:
	# For now runs on only two processes
	if state.num_processes != 2:
		return
	a									=				create_tensor(__A       )
	a									=				reduce(__A				,     """mean"""       )
	a									=				torch.tensor([2.0, 3]       ).to(state.device       )
	assert torch.allclose(__A				,     __A       ), f'{reduced_tensor} != {truth_tensor}'





def 						__A						(      __lowerCamelCase       ) ->			Optional[Any]:
	main()





def 						__A						(      ) ->			Optional[Any]:
	a									=				PartialState()
	state.print(f'State: {state}'       )
	state.print("""testing gather"""       )
	test_gather(__A       )
	state.print("""testing gather_object"""       )
	test_gather_object(__A       )
	state.print("""testing broadcast"""       )
	test_broadcast(__A       )
	state.print("""testing pad_across_processes"""       )
	test_pad_across_processes(__A       )
	state.print("""testing reduce_sum"""       )
	test_reduce_sum(__A       )
	state.print("""testing reduce_mean"""       )
	test_reduce_mean(__A       )


if __name__ == "__main__":
		main()






"""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     lowerCAmelCase__						(	unittest.TestCase ):


	'''simple docstring'''







	def 			_lowerCAmelCase     (      self				:       List[Any]    )						->	str:





					"""simple docstring"""


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





	def 			_lowerCAmelCase     (      self				:       Any    )						->	str:





					"""simple docstring"""


					SCREAMING_SNAKE_CASE						:							int							=     StableDiffusionKDiffusionPipeline.from_pretrained('CompVis/stable-diffusion-v1-4'    )
					SCREAMING_SNAKE_CASE						:							Dict							=     sd_pipe.to(_SCREAMING_SNAKE_CASE    )
					sd_pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE    )

					sd_pipe.set_scheduler('sample_euler'    )

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

					SCREAMING_SNAKE_CASE						:							str							=     output.images

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

					assert image.shape == (1, 512, 512, 3)
					SCREAMING_SNAKE_CASE						:							Union[str, Any]							=     np.array([0.0_4_4_7, 0.0_4_9_2, 0.0_4_6_8, 0.0_4_0_8, 0.0_3_8_3, 0.0_4_0_8, 0.0_3_5_4, 0.0_3_8_0, 0.0_3_3_9]    )

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





	def 			_lowerCAmelCase     (      self				:       Dict    )						->	Optional[int]:





					"""simple docstring"""


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

					sd_pipe.set_scheduler('sample_euler'    )

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

					SCREAMING_SNAKE_CASE						:							Optional[int]							=     output.images

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

					assert image.shape == (1, 512, 512, 3)
					SCREAMING_SNAKE_CASE						:							List[Any]							=     np.array([0.1_2_3_7, 0.1_3_2_0, 0.1_4_3_8, 0.1_3_5_9, 0.1_3_9_0, 0.1_1_3_2, 0.1_2_7_7, 0.1_1_7_5, 0.1_1_1_2]    )

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







	def 			_lowerCAmelCase     (      self				:       Dict    )						->	Optional[Any]:





					"""simple docstring"""


					SCREAMING_SNAKE_CASE						:							Optional[int]							=     StableDiffusionKDiffusionPipeline.from_pretrained('stabilityai/stable-diffusion-2-1-base'    )
					SCREAMING_SNAKE_CASE						:							Union[str, Any]							=     sd_pipe.to(_SCREAMING_SNAKE_CASE    )
					sd_pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE    )

					sd_pipe.set_scheduler('sample_dpmpp_2m'    )

					SCREAMING_SNAKE_CASE						:							Optional[int]							=     'A painting of a squirrel eating a burger'
					SCREAMING_SNAKE_CASE						:							str							=     torch.manual_seed(0    )
					SCREAMING_SNAKE_CASE						:							Optional[Any]							=     sd_pipe(
					    [prompt]     ,       generator=_SCREAMING_SNAKE_CASE     ,       guidance_scale=7.5     ,       num_inference_steps=15     ,       output_type='np'     ,       use_karras_sigmas=_SCREAMING_SNAKE_CASE     ,       )

					SCREAMING_SNAKE_CASE						:							int							=     output.images

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

					assert image.shape == (1, 512, 512, 3)
					SCREAMING_SNAKE_CASE						:							int							=     np.array(
					    [0.1_1_3_8_1_6_8_9, 0.1_2_1_1_2_9_2_1, 0.1_3_8_9_4_5_7, 0.1_2_5_4_9_6_0_6, 0.1_2_4_4_9_6_4, 0.1_0_8_3_1_5_1_7, 0.1_1_5_6_2_8_6_6, 0.1_0_8_6_7_8_1_6, 0.1_0_4_9_9_0_4_8]    )

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





