






import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DiffusionPipeline,
    EulerDiscreteScheduler,
    StableDiffusionXLPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

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()
class 							__snake_case(       __UpperCamelCase  ,							__UpperCamelCase  ,							unittest.TestCase   ):
 lowercase			:							str		   =		StableDiffusionXLPipeline
 lowercase			:							int		   =		TEXT_TO_IMAGE_PARAMS
 lowercase			:							Dict		   =		TEXT_TO_IMAGE_BATCH_PARAMS
 lowercase			:							List[Any]		   =		TEXT_TO_IMAGE_IMAGE_PARAMS
 lowercase			:							Optional[Any]		   =		TEXT_TO_IMAGE_IMAGE_PARAMS



 def     UpperCAmelCase     (						self : str						):

    """simple docstring"""






    torch.manual_seed(0						)
    lowercase__    :						str       =			UNetaDConditionModel(
        block_out_channels=(32, 64)			,		layers_per_block=2			,		sample_size=32			,		in_channels=4			,		out_channels=4			,		down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")			,		up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""")			,		attention_head_dim=(2, 4)			,		use_linear_projection=UpperCAmelCase__			,		addition_embed_type="""text_time"""			,		addition_time_embed_dim=8			,		transformer_layers_per_block=(1, 2)			,		projection_class_embeddings_input_dim=80			,		cross_attention_dim=64			,		)
    lowercase__    :						Dict       =			EulerDiscreteScheduler(
        beta_start=0.00_085			,		beta_end=0.012			,		steps_offset=1			,		beta_schedule="""scaled_linear"""			,		timestep_spacing="""leading"""			,		)
    torch.manual_seed(0						)
    lowercase__    :						List[Any]       =			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			,		sample_size=128			,		)
    torch.manual_seed(0						)
    lowercase__    :						Union[str, 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=1_000			,		hidden_act="""gelu"""			,		projection_dim=32			,		)
    lowercase__    :						str       =			CLIPTextModel(UpperCAmelCase__						)
    lowercase__    :						Dict       =			CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""			,		local_files_only=UpperCAmelCase__						)

    lowercase__    :						Optional[Any]       =			CLIPTextModelWithProjection(UpperCAmelCase__						)
    lowercase__    :						str       =			CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""			,		local_files_only=UpperCAmelCase__						)

    lowercase__    :						Any       =			{
        """unet""": unet,
        """scheduler""": scheduler,
        """vae""": vae,
        """text_encoder""": text_encoder,
        """tokenizer""": tokenizer,
        """text_encoder_2""": text_encoder_a,
        """tokenizer_2""": tokenizer_a,
        # "safety_checker": None,
        # "feature_extractor": None,
    }
    return components



 def     UpperCAmelCase     (						self : Union[str, Any]			,		UpperCAmelCase__ : List[str]			,		UpperCAmelCase__ : Optional[Any]=0						):

    """simple docstring"""






    if str(UpperCAmelCase__						).startswith("""mps"""						):
       lowercase__    :						List[str]       =			torch.manual_seed(UpperCAmelCase__						)
    else:
       lowercase__    :						str       =			torch.Generator(device=UpperCAmelCase__						).manual_seed(UpperCAmelCase__						)
    lowercase__    :						str       =			{
        """prompt""": """A painting of a squirrel eating a burger""",
        """generator""": generator,
        """num_inference_steps""": 2,
        """guidance_scale""": 5.0,
        """output_type""": """numpy""",
    }
    return inputs



 def     UpperCAmelCase     (						self : str						):

    """simple docstring"""






    lowercase__    :						List[Any]       =			"""cpu"""  # ensure determinism for the device-dependent torch.Generator
    lowercase__    :						Union[str, Any]       =			self.get_dummy_components()
    lowercase__    :						Union[str, Any]       =			StableDiffusionXLPipeline(**UpperCAmelCase__						)
    lowercase__    :						List[str]       =			sd_pipe.to(UpperCAmelCase__						)
    sd_pipe.set_progress_bar_config(disable=UpperCAmelCase__						)

    lowercase__    :						Union[str, Any]       =			self.get_dummy_inputs(UpperCAmelCase__						)
    lowercase__    :						Tuple       =			sd_pipe(**UpperCAmelCase__						).images
    lowercase__    :						str       =			image[0, -3:, -3:, -1]

    assert image.shape == (1, 64, 64, 3)
    lowercase__    :						List[Any]       =			np.array([0.5_873, 0.6_128, 0.4_797, 0.5_122, 0.5_674, 0.4_639, 0.5_227, 0.5_149, 0.4_747]						)

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



 def     UpperCAmelCase     (						self : str						):

    """simple docstring"""






    lowercase__    :						int       =			self.get_dummy_components()
    lowercase__    :						Any       =			StableDiffusionXLPipeline(**UpperCAmelCase__						)
    lowercase__    :						List[Any]       =			sd_pipe.to(UpperCAmelCase__						)
    lowercase__    :						int       =			sd_pipe.to(UpperCAmelCase__						)
    sd_pipe.set_progress_bar_config(disable=UpperCAmelCase__						)

    # forward without prompt embeds
    lowercase__    :						Optional[int]       =			self.get_dummy_inputs(UpperCAmelCase__						)
    lowercase__    :						Tuple       =			3 * ["""this is a negative prompt"""]
    lowercase__    :						Tuple       =			negative_prompt
    lowercase__    :						int       =			3 * [inputs["""prompt"""]]

    lowercase__    :						int       =			sd_pipe(**UpperCAmelCase__						)
    lowercase__    :						Union[str, Any]       =			output.images[0, -3:, -3:, -1]

    # forward with prompt embeds
    lowercase__    :						Union[str, Any]       =			self.get_dummy_inputs(UpperCAmelCase__						)
    lowercase__    :						str       =			3 * ["""this is a negative prompt"""]
    lowercase__    :						Optional[int]       =			3 * [inputs.pop("""prompt"""						)]

    (
        (
        lowercase__
    )  ,       (
        lowercase__
    )  ,       (
        lowercase__
    )  ,       (
        lowercase__
    )  ,       
    )    :						int       =			sd_pipe.encode_prompt(UpperCAmelCase__			,		negative_prompt=UpperCAmelCase__						)

    lowercase__    :						int       =			sd_pipe(
        **UpperCAmelCase__			,		prompt_embeds=UpperCAmelCase__			,		negative_prompt_embeds=UpperCAmelCase__			,		pooled_prompt_embeds=UpperCAmelCase__			,		negative_pooled_prompt_embeds=UpperCAmelCase__			,		)
    lowercase__    :						Tuple       =			output.images[0, -3:, -3:, -1]

    # make sure that it's equal
    assert np.abs(image_slice_a.flatten() - image_slice_a.flatten()						).max() < 1e-4



 def     UpperCAmelCase     (						self : Optional[int]						):

    """simple docstring"""






    super().test_attention_slicing_forward_pass(expected_max_diff=3e-3						)







 def     UpperCAmelCase     (						self : Optional[int]						):

    """simple docstring"""






    super().test_inference_batch_single_identical(expected_max_diff=3e-3						)
@slow
@require_torch_gpu
class 							__snake_case(       unittest.TestCase   ):



 def     UpperCAmelCase     (						self : Dict						):

    """simple docstring"""






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



 def     UpperCAmelCase     (						self : Any			,		UpperCAmelCase__ : List[Any]			,		UpperCAmelCase__ : Tuple="cpu"			,		UpperCAmelCase__ : List[str]=torch.floataa			,		UpperCAmelCase__ : Dict=0						):

    """simple docstring"""






    lowercase__    :						Tuple       =			torch.Generator(device=UpperCAmelCase__						).manual_seed(UpperCAmelCase__						)
    lowercase__    :						str       =			np.random.RandomState(UpperCAmelCase__						).standard_normal((1, 4, 64, 64)						)
    lowercase__    :						Optional[int]       =			torch.from_numpy(UpperCAmelCase__						).to(device=UpperCAmelCase__			,		dtype=UpperCAmelCase__						)
    lowercase__    :						List[str]       =			{
        """prompt""": """a photograph of an astronaut riding a horse""",
        """latents""": latents,
        """generator""": generator,
        """num_inference_steps""": 3,
        """guidance_scale""": 7.5,
        """output_type""": """numpy""",
    }
    return inputs







 def     UpperCAmelCase     (						self : int						):

    """simple docstring"""






    lowercase__    :						Optional[int]       =			DiffusionPipeline.from_pretrained("""stabilityai/stable-diffusion-2-base"""						)
    pipe.to(UpperCAmelCase__						)
    pipe.set_progress_bar_config(disable=UpperCAmelCase__						)

    lowercase__    :						Optional[Any]       =			self.get_inputs(UpperCAmelCase__						)
    lowercase__    :						Any       =			pipe(**UpperCAmelCase__						).images
    lowercase__    :						List[str]       =			image[0, -3:, -3:, -1].flatten()

    assert image.shape == (1, 512, 512, 3)
    lowercase__    :						Union[str, Any]       =			np.array([0.49_493, 0.47_896, 0.40_798, 0.54_214, 0.53_212, 0.48_202, 0.47_656, 0.46_329, 0.48_506]						)
    assert np.abs(image_slice - expected_slice						).max() < 7e-3










from typing import Any

import numpy as np
class 							__snake_case:



 def __init__(						self : str			,		UpperCAmelCase__ : np.ndarray			,		UpperCAmelCase__ : int						):

    """simple docstring"""






    if np.any(tableau[:, -1]			,		where=tableau[:, -1] < 0						):
       raise ValueError("""RHS must be > 0"""						)

    lowercase__    :						List[str]       =			tableau
    lowercase__  ,       lowercase__    :						Optional[Any]       =			tableau.shape

    # Number of decision variables x1, x2, x3...
    lowercase__    :						List[str]       =			n_vars

    # Number of artificial variables to be minimised
    lowercase__    :						str       =			len(np.where(tableau[self.n_vars : -1] == -1						)[0]						)

    # 2 if there are >= or == constraints (nonstandard), 1 otherwise (std)
    lowercase__    :						Optional[Any]       =			(self.n_art_vars > 0) + 1

    # Number of slack variables added to make inequalities into equalities
    lowercase__    :						Optional[int]       =			self.n_rows - self.n_stages

    # Objectives for each stage
    lowercase__    :						Any       =			["""max"""]

    # In two stage simplex, first minimise then maximise
    if self.n_art_vars:
       self.objectives.append("""min"""						)

    lowercase__    :						Union[str, Any]       =			[""""""]

    # Index of current pivot row and column
    lowercase__    :						List[str]       =			None
    lowercase__    :						List[str]       =			None

    # Does objective row only contain (non)-negative values?
    lowercase__    :						str       =			False



 @staticmethod
 def     UpperCAmelCase     (						*UpperCAmelCase__ : int						):

    """simple docstring"""






    if len(UpperCAmelCase__						) != 3:
       raise ValueError("""Must provide n_vars, n_slack, and n_art_vars"""						)

    if not all(x >= 0 and isinstance(UpperCAmelCase__			,		UpperCAmelCase__						) for x in args						):
       raise ValueError("""All arguments must be non-negative integers"""						)

    # decision | slack | artificial
    lowercase__    :						Optional[int]       =			["""x""", """s""", """a"""]
    lowercase__    :						int       =			[]
    for i in range(3						):
       for j in range(args[i]						):
          titles.append(string_starts[i] + str(j + 1						)						)
    titles.append("""RHS"""						)
    return titles



 def     UpperCAmelCase     (						self : List[str]			,		UpperCAmelCase__ : np.ndarray						):

    """simple docstring"""






    lowercase__    :						Optional[Any]       =			self.objectives[-1]

    # Find entries of highest magnitude in objective rows
    lowercase__    :						Union[str, Any]       =			(objective == """min""") - (objective == """max""")
    lowercase__    :						Optional[int]       =			np.argmax(sign * tableau[0, : self.n_vars]						)

    # Choice is only valid if below 0 for maximise, and above for minimise
    if sign * self.tableau[0, col_idx] <= 0:
       lowercase__    :						Optional[int]       =			True
       return 0, 0

    # Pivot row is chosen as having the lowest quotient when elements of
    # the pivot column divide the right-hand side

    # Slice excluding the objective rows
    lowercase__    :						Any       =			slice(self.n_stages			,		self.n_rows						)

    # RHS
    lowercase__    :						Union[str, Any]       =			tableau[s, -1]

    # Elements of pivot column within slice
    lowercase__    :						Optional[int]       =			tableau[s, col_idx]

    # Array filled with nans
    lowercase__    :						Optional[int]       =			np.full(self.n_rows - self.n_stages			,		np.nan						)

    # If element in pivot column is greater than zeron_stages, return
    # quotient or nan otherwise
    lowercase__    :						Optional[int]       =			np.divide(UpperCAmelCase__			,		UpperCAmelCase__			,		out=UpperCAmelCase__			,		where=divisor > 0						)

    # Arg of minimum quotient excluding the nan values. n_stages is added
    # to compensate for earlier exclusion of objective columns
    lowercase__    :						Dict       =			np.nanargmin(UpperCAmelCase__						) + self.n_stages
    return row_idx, col_idx



 def     UpperCAmelCase     (						self : Union[str, Any]			,		UpperCAmelCase__ : np.ndarray			,		UpperCAmelCase__ : int			,		UpperCAmelCase__ : int						):

    """simple docstring"""






    lowercase__    :						int       =			tableau[row_idx].copy()

    lowercase__    :						Optional[Any]       =			piv_row[col_idx]

    # Entry becomes 1
    piv_row *= 1 / piv_val

    # Variable in pivot column becomes basic, ie the only non-zero entry
    for idx, coeff in enumerate(tableau[:, col_idx]						):
       tableau[idx] += -coeff * piv_row
    lowercase__    :						Any       =			piv_row
    return tableau



 def     UpperCAmelCase     (						self : Optional[Any]			,		UpperCAmelCase__ : np.ndarray						):

    """simple docstring"""






    self.objectives.pop()

    if not self.objectives:
       return tableau

    # Slice containing ids for artificial columns
    lowercase__    :						Optional[int]       =			slice(-self.n_art_vars - 1			,		-1						)

    # Delete the artificial variable columns
    lowercase__    :						Dict       =			np.delete(UpperCAmelCase__			,		UpperCAmelCase__			,		axis=1						)

    # Delete the objective row of the first stage
    lowercase__    :						Optional[Any]       =			np.delete(UpperCAmelCase__			,		0			,		axis=0						)

    lowercase__    :						str       =			1
    self.n_rows -= 1
    lowercase__    :						List[str]       =			0
    lowercase__    :						List[Any]       =			False
    return tableau



 def     UpperCAmelCase     (						self : Optional[Any]						):

    """simple docstring"""






    for _ in range(100						):
       # Completion of each stage removes an objective. If both stages
       # are complete, then no objectives are left
       if not self.objectives:
          lowercase__    :						List[Any]       =			self.generate_col_titles(
              self.n_vars			,		self.n_slack			,		self.n_art_vars						)

          # Find the values of each variable at optimal solution
          return self.interpret_tableau(self.tableau			,		self.col_titles						)

       lowercase__  ,       lowercase__    :						Optional[Any]       =			self.find_pivot(self.tableau						)

       # If there are no more negative values in objective row
       if self.stop_iter:
          # Delete artificial variable columns and rows. Update attributes
          lowercase__    :						Any       =			self.change_stage(self.tableau						)
       else:
          lowercase__    :						str       =			self.pivot(self.tableau			,		UpperCAmelCase__			,		UpperCAmelCase__						)
    return {}







 def     UpperCAmelCase     (						self : str			,		UpperCAmelCase__ : np.ndarray			,		UpperCAmelCase__ : list[str]						):

    """simple docstring"""






    lowercase__    :						List[str]       =			{"""P""": abs(tableau[0, -1]						)}

    for i in range(self.n_vars						):
       # Gives ids of nonzero entries in the ith column
       lowercase__    :						int       =			np.nonzero(tableau[:, i]						)
       lowercase__    :						Tuple       =			len(nonzero[0]						)

       # First entry in the nonzero ids
       lowercase__    :						int       =			nonzero[0][0]
       lowercase__    :						Tuple       =			tableau[nonzero_rowidx, i]

       # If there is only one nonzero value in column, which is one
       if n_nonzero == nonzero_val == 1:
          lowercase__    :						Tuple       =			tableau[nonzero_rowidx, -1]
          lowercase__    :						Union[str, Any]       =			rhs_val

        # Check for basic variables
    for title in col_titles:
       # Don't add RHS or slack variables to output dict
       if title[0] not in "R-s-a":
          output_dict.setdefault(UpperCAmelCase__			,		0						)
    return output_dict


if __name__ == "__main__":
 import doctest

 doctest.testmod()


