


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




 __lowerCAmelCase						: str							  =		StableDiffusionPanoramaPipeline
 __lowerCAmelCase						: List[Any]							  =		TEXT_TO_IMAGE_PARAMS
 __lowerCAmelCase						: Optional[Any]							  =		TEXT_TO_IMAGE_BATCH_PARAMS
 __lowerCAmelCase						: Any							  =		TEXT_TO_IMAGE_IMAGE_PARAMS
 __lowerCAmelCase						: List[str]							  =		TEXT_TO_IMAGE_IMAGE_PARAMS




 def   __UpperCamelCase   (    self      )      ->    Any:
    torch.manual_seed(0      )
    _a					:  Dict						=  UNetaDConditionModel(
        block_out_channels=(3_2, 6_4)		,      layers_per_block=1		,      sample_size=3_2		,      in_channels=4		,      out_channels=4		,      down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')		,      up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D')		,      cross_attention_dim=3_2		,      )
    _a					:  str						=  DDIMScheduler()
    torch.manual_seed(0      )
    _a					:  int						=  AutoencoderKL(
        block_out_channels=[3_2, 6_4]		,      in_channels=3		,      out_channels=3		,      down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D']		,      up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D']		,      latent_channels=4		,      )
    torch.manual_seed(0      )
    _a					:  Optional[Any]						=  CLIPTextConfig(
        bos_token_id=0		,      eos_token_id=2		,      hidden_size=3_2		,      intermediate_size=3_7		,      layer_norm_eps=1e-05		,      num_attention_heads=4		,      num_hidden_layers=5		,      pad_token_id=1		,      vocab_size=1_0_0_0		,      )
    _a					:  str						=  CLIPTextModel(lowerCamelCase_      )
    _a					:  List[Any]						=  CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'      )

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




 def   __UpperCamelCase   (    self		,      lowerCamelCase_		,      lowerCamelCase_=0      )      ->    Dict:
    _a					:  str						=  torch.manual_seed(lowerCamelCase_      )
    _a					:  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   __UpperCamelCase   (    self      )      ->    Optional[int]:
    _a					:  int						=  'cpu'  # ensure determinism for the device-dependent torch.Generator
    _a					:  Any						=  self.get_dummy_components()
    _a					:  str						=  StableDiffusionPanoramaPipeline(**lowerCamelCase_      )
    _a					:  Tuple						=  sd_pipe.to(lowerCamelCase_      )
    sd_pipe.set_progress_bar_config(disable=lowerCamelCase_      )

    _a					:  int						=  self.get_dummy_inputs(lowerCamelCase_      )
    _a					:  List[Any]						=  sd_pipe(**lowerCamelCase_      ).images
    _a					:  Optional[int]						=  image[0, -3:, -3:, -1]
    assert image.shape == (1, 6_4, 6_4, 3)

    _a					:  str						=  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   __UpperCamelCase   (    self      )      ->    Union[str, Any]:
    super().test_inference_batch_consistent(batch_sizes=[1, 2]      )




 def   __UpperCamelCase   (    self      )      ->    str:
    super().test_inference_batch_single_identical(batch_size=2		,      expected_max_diff=3.25e-3      )




 def   __UpperCamelCase   (    self      )      ->    Optional[Any]:
    _a					:  Optional[int]						=  'cpu'  # ensure determinism for the device-dependent torch.Generator
    _a					:  List[str]						=  self.get_dummy_components()
    _a					:  Tuple						=  StableDiffusionPanoramaPipeline(**lowerCamelCase_      )
    _a					:  int						=  sd_pipe.to(lowerCamelCase_      )
    sd_pipe.set_progress_bar_config(disable=lowerCamelCase_      )

    _a					:  Tuple						=  self.get_dummy_inputs(lowerCamelCase_      )
    _a					:  Any						=  'french fries'
    _a					:  List[str]						=  sd_pipe(**lowerCamelCase_		,      negative_prompt=lowerCamelCase_      )
    _a					:  Optional[Any]						=  output.images
    _a					:  Optional[int]						=  image[0, -3:, -3:, -1]

    assert image.shape == (1, 6_4, 6_4, 3)

    _a					:  List[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   __UpperCamelCase   (    self      )      ->    List[str]:
    _a					:  Union[str, Any]						=  'cpu'  # ensure determinism for the device-dependent torch.Generator
    _a					:  str						=  self.get_dummy_components()
    _a					:  str						=  StableDiffusionPanoramaPipeline(**lowerCamelCase_      )
    _a					:  Dict						=  sd_pipe.to(lowerCamelCase_      )
    sd_pipe.set_progress_bar_config(disable=lowerCamelCase_      )

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

    assert image.shape == (1, 6_4, 6_4, 3)

    _a					:  Tuple						=  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   __UpperCamelCase   (    self      )      ->    Union[str, Any]:
    _a					:  Tuple						=  'cpu'  # ensure determinism for the device-dependent torch.Generator
    _a					:  Union[str, Any]						=  self.get_dummy_components()
    _a					:  List[Any]						=  EulerAncestralDiscreteScheduler(
        beta_start=0.00085		,      beta_end=0.012		,      beta_schedule='scaled_linear'      )
    _a					:  int						=  StableDiffusionPanoramaPipeline(**lowerCamelCase_      )
    _a					:  List[Any]						=  sd_pipe.to(lowerCamelCase_      )
    sd_pipe.set_progress_bar_config(disable=lowerCamelCase_      )

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

    assert image.shape == (1, 6_4, 6_4, 3)

    _a					:  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   __UpperCamelCase   (    self      )      ->    Dict:
    _a					:  Optional[Any]						=  'cpu'  # ensure determinism for the device-dependent torch.Generator
    _a					:  Optional[int]						=  self.get_dummy_components()
    _a					:  Dict						=  PNDMScheduler(
        beta_start=0.00085		,      beta_end=0.012		,      beta_schedule='scaled_linear'		,      skip_prk_steps=lowerCamelCase_      )
    _a					:  Any						=  StableDiffusionPanoramaPipeline(**lowerCamelCase_      )
    _a					:  Union[str, Any]						=  sd_pipe.to(lowerCamelCase_      )
    sd_pipe.set_progress_bar_config(disable=lowerCamelCase_      )

    _a					:  List[Any]						=  self.get_dummy_inputs(lowerCamelCase_      )
    _a					:  Union[str, Any]						=  sd_pipe(**lowerCamelCase_      ).images
    _a					:  str						=  image[0, -3:, -3:, -1]

    assert image.shape == (1, 6_4, 6_4, 3)

    _a					:  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  ):
 '''simple docstring'''




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




 def   __UpperCamelCase   (    self		,      lowerCamelCase_=0      )      ->    Optional[Any]:
    _a					:  List[str]						=  torch.manual_seed(lowerCamelCase_      )
    _a					:  Tuple						=  {
        'prompt': 'a photo of the dolomites',
        'generator': generator,
        'num_inference_steps': 3,
        'guidance_scale': 7.5,
        'output_type': 'numpy',
    }
    return inputs




 def   __UpperCamelCase   (    self      )      ->    Any:
    _a					:  Optional[int]						=  'stabilityai/stable-diffusion-2-base'
    _a					:  Union[str, Any]						=  DDIMScheduler.from_pretrained(lowerCamelCase_		,      subfolder='scheduler'      )
    _a					:  Dict						=  StableDiffusionPanoramaPipeline.from_pretrained(lowerCamelCase_		,      scheduler=lowerCamelCase_		,      safety_checker=lowerCamelCase_      )
    pipe.to(lowerCamelCase_      )
    pipe.set_progress_bar_config(disable=lowerCamelCase_      )
    pipe.enable_attention_slicing()

    _a					:  Any						=  self.get_inputs()
    _a					:  Tuple						=  pipe(**lowerCamelCase_      ).images
    _a					:  List[Any]						=  image[0, -3:, -3:, -1].flatten()

    assert image.shape == (1, 5_1_2, 2_0_4_8, 3)

    _a					:  int						=  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   __UpperCamelCase   (    self      )      ->    Optional[Any]:
    _a					:  Any						=  StableDiffusionPanoramaPipeline.from_pretrained(
        'stabilityai/stable-diffusion-2-base'		,      safety_checker=lowerCamelCase_      )
    _a					:  List[str]						=  LMSDiscreteScheduler.from_config(pipe.scheduler.config      )
    pipe.to(lowerCamelCase_      )
    pipe.set_progress_bar_config(disable=lowerCamelCase_      )
    pipe.enable_attention_slicing()

    _a					:  str						=  self.get_inputs()
    _a					:  Dict						=  pipe(**lowerCamelCase_      ).images
    _a					:  List[str]						=  image[0, -3:, -3:, -1].flatten()

    assert image.shape == (1, 5_1_2, 2_0_4_8, 3)

    _a					:  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   __UpperCamelCase   (    self      )      ->    Optional[Any]:
    _a					:  Optional[Any]						=  0

    def callback_fn(lowerCamelCase_		,      lowerCamelCase_		,      lowerCamelCase_      ) -> None:
       _a					:  List[str]						=  True
       nonlocal number_of_steps
       number_of_steps += 1
       if step == 1:
          _a					:  List[Any]						=  latents.detach().cpu().numpy()
          assert latents.shape == (1, 4, 6_4, 2_5_6)
          _a					:  Tuple						=  latents[0, -3:, -3:, -1]

          _a					:  List[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:
          _a					:  Tuple						=  latents.detach().cpu().numpy()
          assert latents.shape == (1, 4, 6_4, 2_5_6)
          _a					:  List[str]						=  latents[0, -3:, -3:, -1]

          _a					:  Optional[Any]						=  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

    _a					:  List[str]						=  False

    _a					:  Dict						=  'stabilityai/stable-diffusion-2-base'
    _a					:  Union[str, Any]						=  DDIMScheduler.from_pretrained(lowerCamelCase_		,      subfolder='scheduler'      )
    _a					:  Tuple						=  StableDiffusionPanoramaPipeline.from_pretrained(lowerCamelCase_		,      scheduler=lowerCamelCase_		,      safety_checker=lowerCamelCase_      )
    _a					:  Optional[int]						=  pipe.to(lowerCamelCase_      )
    pipe.set_progress_bar_config(disable=lowerCamelCase_      )
    pipe.enable_attention_slicing()

    _a					:  Any						=  self.get_inputs()
    pipe(**lowerCamelCase_		,      callback=lowerCamelCase_		,      callback_steps=1      )
    assert callback_fn.has_been_called
    assert number_of_steps == 3




 def   __UpperCamelCase   (    self      )      ->    Any:
    torch.cuda.empty_cache()
    torch.cuda.reset_max_memory_allocated()
    torch.cuda.reset_peak_memory_stats()

    _a					:  str						=  'stabilityai/stable-diffusion-2-base'
    _a					:  Any						=  DDIMScheduler.from_pretrained(lowerCamelCase_		,      subfolder='scheduler'      )
    _a					:  int						=  StableDiffusionPanoramaPipeline.from_pretrained(lowerCamelCase_		,      scheduler=lowerCamelCase_		,      safety_checker=lowerCamelCase_      )
    _a					:  Union[str, Any]						=  pipe.to(lowerCamelCase_      )
    pipe.set_progress_bar_config(disable=lowerCamelCase_      )
    pipe.enable_attention_slicing(1      )
    pipe.enable_sequential_cpu_offload()

    _a					:  List[str]						=  self.get_inputs()
    _a					:  str						=  pipe(**lowerCamelCase_      )

    _a					:  Optional[Any]						=  torch.cuda.max_memory_allocated()
    # make sure that less than 5.2 GB is allocated
    assert mem_bytes < 5.5 * 1_0**9






'''simple docstring'''




import warnings
from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


UpperCAmelCase_      :		int          =		logging.get_logger(__name__)

UpperCAmelCase_      :		Optional[Any]          =		{
    "nvidia/segformer-b0-finetuned-ade-512-512": (
        "https://huggingface.co/nvidia/segformer-b0-finetuned-ade-512-512/resolve/main/config.json"
    ),
    # See all SegFormer models at https://huggingface.co/models?filter=segformer
}







class 					a			(				snake_case__  ):
 '''simple docstring'''




 __lowerCAmelCase						: List[Any]							  =		"""segformer"""




 def __init__(    self		,      lowerCamelCase_=3		,      lowerCamelCase_=4		,      lowerCamelCase_=[2, 2, 2, 2]		,      lowerCamelCase_=[8, 4, 2, 1]		,      lowerCamelCase_=[3_2, 6_4, 1_6_0, 2_5_6]		,      lowerCamelCase_=[7, 3, 3, 3]		,      lowerCamelCase_=[4, 2, 2, 2]		,      lowerCamelCase_=[1, 2, 5, 8]		,      lowerCamelCase_=[4, 4, 4, 4]		,      lowerCamelCase_="gelu"		,      lowerCamelCase_=0.0		,      lowerCamelCase_=0.0		,      lowerCamelCase_=0.1		,      lowerCamelCase_=0.02		,      lowerCamelCase_=0.1		,      lowerCamelCase_=1e-6		,      lowerCamelCase_=2_5_6		,      lowerCamelCase_=2_5_5		,      **lowerCamelCase_		,      )      ->    Union[str, Any]:
    super().__init__(**lowerCamelCase_      )

    if "reshape_last_stage" in kwargs and kwargs["reshape_last_stage"] is False:
       warnings.warn(
           'Reshape_last_stage is set to False in this config. This argument is deprecated and will soon be'
           ' removed, as the behaviour will default to that of reshape_last_stage = True.'		,      lowerCamelCase_		,      )

    _a					:  Union[str, Any]						=  num_channels
    _a					:  Any						=  num_encoder_blocks
    _a					:  Union[str, Any]						=  depths
    _a					:  int						=  sr_ratios
    _a					:  List[str]						=  hidden_sizes
    _a					:  Tuple						=  patch_sizes
    _a					:  Any						=  strides
    _a					:  List[Any]						=  mlp_ratios
    _a					:  str						=  num_attention_heads
    _a					:  str						=  hidden_act
    _a					:  List[Any]						=  hidden_dropout_prob
    _a					:  int						=  attention_probs_dropout_prob
    _a					:  Any						=  classifier_dropout_prob
    _a					:  Optional[Any]						=  initializer_range
    _a					:  int						=  drop_path_rate
    _a					:  int						=  layer_norm_eps
    _a					:  Optional[Any]						=  decoder_hidden_size
    _a					:  int						=  kwargs.get('reshape_last_stage'		,      lowerCamelCase_      )
    _a					:  str						=  semantic_loss_ignore_index







class 					a			(				snake_case__  ):
 '''simple docstring'''




 __lowerCAmelCase						: Any							  =		version.parse("""1.11"""  )




 @property
 def   __UpperCamelCase   (    self      )      ->    Mapping[str, Mapping[int, str]]:
    return OrderedDict(
        [
            ('pixel_values', {0: 'batch', 1: 'num_channels', 2: 'height', 3: 'width'}),
        ]      )




 @property
 def   __UpperCamelCase   (    self      )      ->    float:
    return 1e-4




 @property
 def   __UpperCamelCase   (    self      )      ->    int:
    return 1_2


