





"""simple docstring"""





import logging
import math
from functools import partial
from typing import Any, Callable, Dict, Iterable, List, Optional, Sequence, Tuple, Union

import torch

from .tensor_utils import tensor_tree_map, tree_map






def       a__					(					_SCREAMING_SNAKE_CASE    ):




		"""simple docstring"""


		UpperCamelCase   =	[]
		if isinstance(__snake_case  ,	__snake_case    ):
				for v in tree.values():
						shapes.extend(_fetch_dims(__snake_case    )    )
		elif isinstance(__snake_case  ,	(list, tuple)    ):
				for t in tree:
						shapes.extend(_fetch_dims(__snake_case    )    )
		elif isinstance(__snake_case  ,	torch.Tensor    ):
				shapes.append(tree.shape    )
		else:
				raise ValueError("Not supported"    )

		return shapes






@torch.jit.ignore
def       a__					(					_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE    ):




		"""simple docstring"""


		UpperCamelCase   =	[]
		for d in reversed(__snake_case    ):
				idx.append(flat_idx % d    )
				UpperCamelCase   =	flat_idx // d

		return tuple(reversed(__snake_case    )    )






@torch.jit.ignore
def       a__					(					_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE = None  ,	_SCREAMING_SNAKE_CASE = None  ,	):




		"""simple docstring"""


		def reduce_edge_list(_SCREAMING_SNAKE_CASE    ) -> None:
				UpperCamelCase   =	True
				for i in range(len(__snake_case    )    ):
						UpperCamelCase   =	-1 * (i + 1)
						l[reversed_idx] &= tally
						UpperCamelCase   =	l[reversed_idx]

		if start_edges is None:
				UpperCamelCase   =	[s == 0 for s in start]
				reduce_edge_list(__snake_case    )
		if end_edges is None:
				UpperCamelCase   =	[e == (d - 1) for e, d in zip(__snake_case  ,	__snake_case    )]
				reduce_edge_list(__snake_case    )

		# Base cases. Either start/end are empty and we're done, or the final,
		# one-dimensional tensor can be simply sliced
		if len(__snake_case    ) == 0:
				return [()]
		elif len(__snake_case    ) == 1:
				return [(slice(start[0]  ,	end[0] + 1    ),)]

		UpperCamelCase   =	[]
		UpperCamelCase   =	[]

		# Dimensions common to start and end can be selected directly
		for s, e in zip(__snake_case  ,	__snake_case    ):
				if s == e:
						path_list.append(slice(__snake_case  ,	s + 1    )    )
				else:
						break

		UpperCamelCase   =	tuple(__snake_case    )
		UpperCamelCase   =	len(__snake_case    )

		# start == end, and we're done
		if divergence_idx == len(__snake_case    ):
				return [path]

		def upper() -> Tuple[Tuple[slice, ...], ...]:
				assert start_edges is not None
				assert end_edges is not None

				UpperCamelCase   =	start[divergence_idx]
				return tuple(
				    path + (slice(__snake_case  ,	sdi + 1    ),) + s
				    for s in _get_minimal_slice_set(
				        start[divergence_idx + 1 :]  ,	[d - 1 for d in dims[divergence_idx + 1 :]]  ,	dims[divergence_idx + 1 :]  ,	start_edges=start_edges[divergence_idx + 1 :]  ,	end_edges=[True for _ in end_edges[divergence_idx + 1 :]]  ,	)    )

		def lower() -> Tuple[Tuple[slice, ...], ...]:
				assert start_edges is not None
				assert end_edges is not None

				UpperCamelCase   =	end[divergence_idx]
				return tuple(
				    path + (slice(__snake_case  ,	edi + 1    ),) + s
				    for s in _get_minimal_slice_set(
				        [0 for _ in start[divergence_idx + 1 :]]  ,	end[divergence_idx + 1 :]  ,	dims[divergence_idx + 1 :]  ,	start_edges=[True for _ in start_edges[divergence_idx + 1 :]]  ,	end_edges=end_edges[divergence_idx + 1 :]  ,	)    )

		# If both start and end are at the edges of the subtree rooted at
		# divergence_idx, we can just select the whole subtree at once
		if start_edges[divergence_idx] and end_edges[divergence_idx]:
				slices.append(path + (slice(start[divergence_idx]  ,	end[divergence_idx] + 1    ),)    )
		# If just start is at the edge, we can grab almost all of the subtree,
		# treating only the ragged bottom edge as an edge case
		elif start_edges[divergence_idx]:
				slices.append(path + (slice(start[divergence_idx]  ,	end[divergence_idx]    ),)    )
				slices.extend(lower()    )
		# Analogous to the previous case, but the top is ragged this time
		elif end_edges[divergence_idx]:
				slices.extend(upper()    )
				slices.append(path + (slice(start[divergence_idx] + 1  ,	end[divergence_idx] + 1    ),)    )
		# If both sides of the range are ragged, we need to handle both sides
		# separately. If there's contiguous meat in between them, we can index it
		# in one big chunk
		else:
				slices.extend(upper()    )
				UpperCamelCase   =	end[divergence_idx] - start[divergence_idx]
				if middle_ground > 1:
						slices.append(path + (slice(start[divergence_idx] + 1  ,	end[divergence_idx]    ),)    )
				slices.extend(lower()    )

		return slices






@torch.jit.ignore
def       a__					(					_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE    ):




		"""simple docstring"""


		UpperCamelCase   =	t.shape[:no_batch_dims]
		UpperCamelCase   =	list(_flat_idx_to_idx(__snake_case  ,	__snake_case    )    )
		# _get_minimal_slice_set is inclusive
		UpperCamelCase   =	list(_flat_idx_to_idx(flat_end - 1  ,	__snake_case    )    )

		# Get an ordered list of slices to perform
		UpperCamelCase   =	_get_minimal_slice_set(
		    __snake_case  ,	__snake_case  ,	__snake_case  ,	)

		UpperCamelCase   =	[t[s] for s in slices]

		return torch.cat([s.view((-1,) + t.shape[no_batch_dims:]    ) for s in sliced_tensors]    )






def       a__					(					_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE = False  ,	_SCREAMING_SNAKE_CASE = None  ,	_SCREAMING_SNAKE_CASE = False  ,	):




		"""simple docstring"""


		if not (len(__snake_case    ) > 0):
				raise ValueError("Must provide at least one input"    )

		UpperCamelCase   =	[shape[:no_batch_dims] for shape in _fetch_dims(__snake_case    )]
		UpperCamelCase   =	tuple([max(__snake_case    ) for s in zip(*__snake_case    )]    )

		def _prep_inputs(_SCREAMING_SNAKE_CASE    ) -> torch.Tensor:
				if not low_mem:
						if not sum(t.shape[:no_batch_dims]    ) == no_batch_dims:
								UpperCamelCase   =	t.expand(orig_batch_dims + t.shape[no_batch_dims:]    )
						UpperCamelCase   =	t.reshape(-1  ,	*t.shape[no_batch_dims:]    )
				else:
						UpperCamelCase   =	t.expand(orig_batch_dims + t.shape[no_batch_dims:]    )
				return t

		UpperCamelCase   =	tensor_tree_map(_prep_inputs  ,	__snake_case    )
		UpperCamelCase   =	None
		if _out is not None:
				UpperCamelCase   =	tensor_tree_map(lambda _SCREAMING_SNAKE_CASE    : t.view([-1] + list(t.shape[no_batch_dims:]    )    )  ,	_out    )

		UpperCamelCase   =	1
		for d in orig_batch_dims:
				flat_batch_dim *= d

		UpperCamelCase   =	flat_batch_dim // chunk_size + (flat_batch_dim % chunk_size != 0)

		def _select_chunk(_SCREAMING_SNAKE_CASE    ) -> torch.Tensor:
				return t[i : i + chunk_size] if t.shape[0] != 1 else t

		UpperCamelCase   =	0
		UpperCamelCase   =	prepped_outputs
		for _ in range(__snake_case    ):
				# Chunk the input
				if not low_mem:
						UpperCamelCase   =	_select_chunk
				else:
						UpperCamelCase   =	partial(
						    _chunk_slice  ,	flat_start=__snake_case  ,	flat_end=min(__snake_case  ,	i + chunk_size    )  ,	no_batch_dims=len(__snake_case    )  ,	)

				UpperCamelCase   =	tensor_tree_map(__snake_case  ,	__snake_case    )

				# Run the layer on the chunk
				UpperCamelCase   =	layer(**__snake_case    )

				# Allocate space for the output
				if out is None:
						UpperCamelCase   =	tensor_tree_map(lambda _SCREAMING_SNAKE_CASE    : t.new_zeros((flat_batch_dim,) + t.shape[1:]    )  ,	__snake_case    )

				# Put the chunk in its pre-allocated space
				if isinstance(__snake_case  ,	__snake_case    ):

						def assign(_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE    ) -> None:
								for k, v in da.items():
										if isinstance(__snake_case  ,	__snake_case    ):
												assign(__snake_case  ,	da[k]    )
										else:
												if _add_into_out:
														v[i : i + chunk_size] += da[k]
												else:
														UpperCamelCase   =	da[k]

						assign(__snake_case  ,	__snake_case    )
				elif isinstance(__snake_case  ,	__snake_case    ):
						for xa, xa in zip(__snake_case  ,	__snake_case    ):
								if _add_into_out:
										xa[i : i + chunk_size] += xa
								else:
										UpperCamelCase   =	xa
				elif isinstance(__snake_case  ,	torch.Tensor    ):
						if _add_into_out:
								out[i : i + chunk_size] += output_chunk
						else:
								UpperCamelCase   =	output_chunk
				else:
						raise ValueError("Not supported"    )

				i += chunk_size

		UpperCamelCase   =	tensor_tree_map(lambda _SCREAMING_SNAKE_CASE    : t.view(orig_batch_dims + t.shape[1:]    )  ,	__snake_case    )

		return out






class        _lowerCamelCase      :


						def __init__(self   ,							__a = 5_12   ,							) ->   List[Any]:
								UpperCamelCase   =	max_chunk_size
								UpperCamelCase   =	None
								UpperCamelCase   =	None


						def     snake_case_   (self   ,							__a   ,							__a   ,							__a		) ->   int:
								logging.info("Tuning chunk size..."		)

								if min_chunk_size >= self.max_chunk_size:
										return min_chunk_size

								UpperCamelCase   =	[2**l for l in range(int(math.log(self.max_chunk_size   ,							2		)		) + 1		)]
								UpperCamelCase   =	[c for c in candidates if c > min_chunk_size]
								UpperCamelCase   =	[min_chunk_size] + candidates
								candidates[-1] += 4

								def test_chunk_size(__a		) -> bool:
										try:
												with torch.no_grad():
														fn(*__a   ,							chunk_size=__a		)
												return True
										except RuntimeError:
												return False

								UpperCamelCase   =	0
								UpperCamelCase   =	len(__a		) - 1
								while i > min_viable_chunk_size_index:
										UpperCamelCase   =	test_chunk_size(candidates[i]		)
										if not viable:
												UpperCamelCase   =	(min_viable_chunk_size_index + i) // 2
										else:
												UpperCamelCase   =	i
												UpperCamelCase   =	(i + len(__a		) - 1) // 2

								return candidates[min_viable_chunk_size_index]


						def     snake_case_   (self   ,							__a   ,							__a		) ->   bool:
								UpperCamelCase   =	True
								for aa, aa in zip(__a   ,							__a		):
										assert type(__a		) == type(__a		)
										if isinstance(__a   ,							(list, tuple)		):
												consistent &= self._compare_arg_caches(__a   ,							__a		)
										elif isinstance(__a   ,							__a		):
												UpperCamelCase   =	[v for _, v in sorted(aa.items()   ,							key=lambda __a		: x[0]		)]
												UpperCamelCase   =	[v for _, v in sorted(aa.items()   ,							key=lambda __a		: x[0]		)]
												consistent &= self._compare_arg_caches(__a   ,							__a		)
										else:
												consistent &= aa == aa

								return consistent




						def     snake_case_   (self   ,							__a   ,							__a   ,							__a   ,							) ->   int:
								UpperCamelCase   =	True
								UpperCamelCase   =	tree_map(lambda __a		: a.shape if isinstance(__a   ,							torch.Tensor		) else a   ,							__a   ,							__a		)
								if self.cached_arg_data is not None:
										# If args have changed shape/value, we need to re-tune
										assert len(self.cached_arg_data		) == len(__a		)
										UpperCamelCase   =	self._compare_arg_caches(self.cached_arg_data   ,							__a		)
								else:
										# Otherwise, we can reuse the precomputed value
										UpperCamelCase   =	False

								if not consistent:
										UpperCamelCase   =	self._determine_favorable_chunk_size(
										    __a   ,							__a   ,							__a   ,							)
										UpperCamelCase   =	arg_data

								assert self.cached_chunk_size is not None

								return self.cached_chunk_size













"""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        _lowerCamelCase      (       _lowercase  ,			_lowercase  ,			unittest.TestCase ):
						UpperCAmelCase_ =			StableDiffusionPanoramaPipeline
						UpperCAmelCase_ =			TEXT_TO_IMAGE_PARAMS
						UpperCAmelCase_ =			TEXT_TO_IMAGE_BATCH_PARAMS
						UpperCAmelCase_ =			TEXT_TO_IMAGE_IMAGE_PARAMS
						UpperCAmelCase_ =			TEXT_TO_IMAGE_IMAGE_PARAMS


						def     snake_case_   (self		) ->   int:
								torch.manual_seed(0		)
								UpperCamelCase   =	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   =	DDIMScheduler()
								torch.manual_seed(0		)
								UpperCamelCase   =	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   =	CLIPTextConfig(
								    bos_token_id=0   ,							eos_token_id=2   ,							hidden_size=32   ,							intermediate_size=37   ,							layer_norm_eps=1e-0_5   ,							num_attention_heads=4   ,							num_hidden_layers=5   ,							pad_token_id=1   ,							vocab_size=10_00   ,							)
								UpperCamelCase   =	CLIPTextModel(__a		)
								UpperCamelCase   =	CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"		)

								UpperCamelCase   =	{
								    "unet": unet,
								    "scheduler": scheduler,
								    "vae": vae,
								    "text_encoder": text_encoder,
								    "tokenizer": tokenizer,
								    "safety_checker": None,
								    "feature_extractor": None,
								}
								return components


						def     snake_case_   (self   ,							__a   ,							__a=0		) ->   List[str]:
								UpperCamelCase   =	torch.manual_seed(__a		)
								UpperCamelCase   =	{
								    "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     snake_case_   (self		) ->   int:
								UpperCamelCase   =	"cpu"  # ensure determinism for the device-dependent torch.Generator
								UpperCamelCase   =	self.get_dummy_components()
								UpperCamelCase   =	StableDiffusionPanoramaPipeline(**__a		)
								UpperCamelCase   =	sd_pipe.to(__a		)
								sd_pipe.set_progress_bar_config(disable=__a		)

								UpperCamelCase   =	self.get_dummy_inputs(__a		)
								UpperCamelCase   =	sd_pipe(**__a		).images
								UpperCamelCase   =	image[0, -3:, -3:, -1]
								assert image.shape == (1, 64, 64, 3)

								UpperCamelCase   =	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     snake_case_   (self		) ->   Optional[int]:
								super().test_inference_batch_consistent(batch_sizes=[1, 2]		)


						def     snake_case_   (self		) ->   Tuple:
								super().test_inference_batch_single_identical(batch_size=2   ,							expected_max_diff=3.2_5e-3		)


						def     snake_case_   (self		) ->   Tuple:
								UpperCamelCase   =	"cpu"  # ensure determinism for the device-dependent torch.Generator
								UpperCamelCase   =	self.get_dummy_components()
								UpperCamelCase   =	StableDiffusionPanoramaPipeline(**__a		)
								UpperCamelCase   =	sd_pipe.to(__a		)
								sd_pipe.set_progress_bar_config(disable=__a		)

								UpperCamelCase   =	self.get_dummy_inputs(__a		)
								UpperCamelCase   =	"french fries"
								UpperCamelCase   =	sd_pipe(**__a   ,							negative_prompt=__a		)
								UpperCamelCase   =	output.images
								UpperCamelCase   =	image[0, -3:, -3:, -1]

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

								UpperCamelCase   =	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     snake_case_   (self		) ->   Tuple:
								UpperCamelCase   =	"cpu"  # ensure determinism for the device-dependent torch.Generator
								UpperCamelCase   =	self.get_dummy_components()
								UpperCamelCase   =	StableDiffusionPanoramaPipeline(**__a		)
								UpperCamelCase   =	sd_pipe.to(__a		)
								sd_pipe.set_progress_bar_config(disable=__a		)

								UpperCamelCase   =	self.get_dummy_inputs(__a		)
								UpperCamelCase   =	sd_pipe(**__a   ,							view_batch_size=2		)
								UpperCamelCase   =	output.images
								UpperCamelCase   =	image[0, -3:, -3:, -1]

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

								UpperCamelCase   =	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     snake_case_   (self		) ->   Optional[int]:
								UpperCamelCase   =	"cpu"  # ensure determinism for the device-dependent torch.Generator
								UpperCamelCase   =	self.get_dummy_components()
								UpperCamelCase   =	EulerAncestralDiscreteScheduler(
								    beta_start=0.00085   ,							beta_end=0.012   ,							beta_schedule="scaled_linear"		)
								UpperCamelCase   =	StableDiffusionPanoramaPipeline(**__a		)
								UpperCamelCase   =	sd_pipe.to(__a		)
								sd_pipe.set_progress_bar_config(disable=__a		)

								UpperCamelCase   =	self.get_dummy_inputs(__a		)
								UpperCamelCase   =	sd_pipe(**__a		).images
								UpperCamelCase   =	image[0, -3:, -3:, -1]

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

								UpperCamelCase   =	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     snake_case_   (self		) ->   Optional[Any]:
								UpperCamelCase   =	"cpu"  # ensure determinism for the device-dependent torch.Generator
								UpperCamelCase   =	self.get_dummy_components()
								UpperCamelCase   =	PNDMScheduler(
								    beta_start=0.00085   ,							beta_end=0.012   ,							beta_schedule="scaled_linear"   ,							skip_prk_steps=__a		)
								UpperCamelCase   =	StableDiffusionPanoramaPipeline(**__a		)
								UpperCamelCase   =	sd_pipe.to(__a		)
								sd_pipe.set_progress_bar_config(disable=__a		)

								UpperCamelCase   =	self.get_dummy_inputs(__a		)
								UpperCamelCase   =	sd_pipe(**__a		).images
								UpperCamelCase   =	image[0, -3:, -3:, -1]

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

								UpperCamelCase   =	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        _lowerCamelCase      (       unittest.TestCase ):


						def     snake_case_   (self		) ->   List[str]:
								super().tearDown()
								gc.collect()
								torch.cuda.empty_cache()


						def     snake_case_   (self   ,							__a=0		) ->   List[str]:
								UpperCamelCase   =	torch.manual_seed(__a		)
								UpperCamelCase   =	{
								    "prompt": "a photo of the dolomites",
								    "generator": generator,
								    "num_inference_steps": 3,
								    "guidance_scale": 7.5,
								    "output_type": "numpy",
								}
								return inputs


						def     snake_case_   (self		) ->   Union[str, Any]:
								UpperCamelCase   =	"stabilityai/stable-diffusion-2-base"
								UpperCamelCase   =	DDIMScheduler.from_pretrained(__a   ,							subfolder="scheduler"		)
								UpperCamelCase   =	StableDiffusionPanoramaPipeline.from_pretrained(__a   ,							scheduler=__a   ,							safety_checker=__a		)
								pipe.to(__a		)
								pipe.set_progress_bar_config(disable=__a		)
								pipe.enable_attention_slicing()

								UpperCamelCase   =	self.get_inputs()
								UpperCamelCase   =	pipe(**__a		).images
								UpperCamelCase   =	image[0, -3:, -3:, -1].flatten()

								assert image.shape == (1, 5_12, 20_48, 3)

								UpperCamelCase   =	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     snake_case_   (self		) ->   Union[str, Any]:
								UpperCamelCase   =	StableDiffusionPanoramaPipeline.from_pretrained(
								    "stabilityai/stable-diffusion-2-base"   ,							safety_checker=__a		)
								UpperCamelCase   =	LMSDiscreteScheduler.from_config(pipe.scheduler.config		)
								pipe.to(__a		)
								pipe.set_progress_bar_config(disable=__a		)
								pipe.enable_attention_slicing()

								UpperCamelCase   =	self.get_inputs()
								UpperCamelCase   =	pipe(**__a		).images
								UpperCamelCase   =	image[0, -3:, -3:, -1].flatten()

								assert image.shape == (1, 5_12, 20_48, 3)

								UpperCamelCase   =	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     snake_case_   (self		) ->   Tuple:
								UpperCamelCase   =	0

								def callback_fn(__a   ,							__a   ,							__a		) -> None:
										UpperCamelCase   =	True
										nonlocal number_of_steps
										number_of_steps += 1
										if step == 1:
												UpperCamelCase   =	latents.detach().cpu().numpy()
												assert latents.shape == (1, 4, 64, 2_56)
												UpperCamelCase   =	latents[0, -3:, -3:, -1]

												UpperCamelCase   =	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   =	latents.detach().cpu().numpy()
												assert latents.shape == (1, 4, 64, 2_56)
												UpperCamelCase   =	latents[0, -3:, -3:, -1]

												UpperCamelCase   =	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   =	False

								UpperCamelCase   =	"stabilityai/stable-diffusion-2-base"
								UpperCamelCase   =	DDIMScheduler.from_pretrained(__a   ,							subfolder="scheduler"		)
								UpperCamelCase   =	StableDiffusionPanoramaPipeline.from_pretrained(__a   ,							scheduler=__a   ,							safety_checker=__a		)
								UpperCamelCase   =	pipe.to(__a		)
								pipe.set_progress_bar_config(disable=__a		)
								pipe.enable_attention_slicing()

								UpperCamelCase   =	self.get_inputs()
								pipe(**__a   ,							callback=__a   ,							callback_steps=1		)
								assert callback_fn.has_been_called
								assert number_of_steps == 3




						def     snake_case_   (self		) ->   List[Any]:
								torch.cuda.empty_cache()
								torch.cuda.reset_max_memory_allocated()
								torch.cuda.reset_peak_memory_stats()

								UpperCamelCase   =	"stabilityai/stable-diffusion-2-base"
								UpperCamelCase   =	DDIMScheduler.from_pretrained(__a   ,							subfolder="scheduler"		)
								UpperCamelCase   =	StableDiffusionPanoramaPipeline.from_pretrained(__a   ,							scheduler=__a   ,							safety_checker=__a		)
								UpperCamelCase   =	pipe.to(__a		)
								pipe.set_progress_bar_config(disable=__a		)
								pipe.enable_attention_slicing(1		)
								pipe.enable_sequential_cpu_offload()

								UpperCamelCase   =	self.get_inputs()
								UpperCamelCase   =	pipe(**__a		)

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






