





'''simple docstring'''

import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMParallelScheduler,
    DDPMParallelScheduler,
    StableDiffusionParadigmsPipeline,
    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 lowerCamelCase    (a__    ,   a__    ,   unittest.TestCase       ):
  _lowercase	:						Union[str, Any]							       =					StableDiffusionParadigmsPipeline
  _lowercase	:						List[str]							       =					TEXT_TO_IMAGE_PARAMS
  _lowercase	:						Optional[Any]							       =					TEXT_TO_IMAGE_BATCH_PARAMS
  _lowercase	:						Dict							       =					TEXT_TO_IMAGE_IMAGE_PARAMS
  _lowercase	:						Any							       =					TEXT_TO_IMAGE_IMAGE_PARAMS







  def 					UpperCAmelCase_					(		self		)		->    List[Any]:






        """simple docstring"""





        torch.manual_seed(0		)
        _snake_case		:						Tuple         =  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''')  ,  cross_attention_dim=32  ,  attention_head_dim=(2, 4)  ,  use_linear_projection=lowercase__  ,  )
        _snake_case		:						Dict         =  DDIMParallelScheduler(
            beta_start=0.00_085  ,  beta_end=0.012  ,  beta_schedule='''scaled_linear'''  ,  clip_sample=lowercase__  ,  set_alpha_to_one=lowercase__  ,  )
        torch.manual_seed(0		)
        _snake_case		:						Optional[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		)
        _snake_case		:						Optional[Any]         =  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=1_000  ,  hidden_act='''gelu'''  ,  projection_dim=512  ,  )
        _snake_case		:						List[str]         =  CLIPTextModel(lowercase__		)
        _snake_case		:						Union[str, Any]         =  CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''		)

        _snake_case		:						int         =  {
            '''unet''': unet,
            '''scheduler''': scheduler,
            '''vae''': vae,
            '''text_encoder''': text_encoder,
            '''tokenizer''': tokenizer,
            '''safety_checker''': None,
            '''feature_extractor''': None,
        }
        return components







  def 					UpperCAmelCase_					(		self  ,  lowercase__  ,  lowercase__=0		)		->    List[str]:






        """simple docstring"""





        if str(lowercase__		).startswith('''mps'''		):
              _snake_case		:						Optional[int]         =  torch.manual_seed(lowercase__		)
        else:
              _snake_case		:						Any         =  torch.Generator(device=lowercase__		).manual_seed(lowercase__		)
        _snake_case		:						Union[str, Any]         =  {
            '''prompt''': '''a photograph of an astronaut riding a horse''',
            '''generator''': generator,
            '''num_inference_steps''': 10,
            '''guidance_scale''': 6.0,
            '''output_type''': '''numpy''',
            '''parallel''': 3,
            '''debug''': True,
        }
        return inputs







  def 					UpperCAmelCase_					(		self		)		->    Optional[Any]:






        """simple docstring"""





        _snake_case		:						List[str]         =  '''cpu'''  # ensure determinism for the device-dependent torch.Generator
        _snake_case		:						Dict         =  self.get_dummy_components()
        _snake_case		:						Optional[Any]         =  StableDiffusionParadigmsPipeline(**lowercase__		)
        _snake_case		:						Dict         =  sd_pipe.to(lowercase__		)
        sd_pipe.set_progress_bar_config(disable=lowercase__		)

        _snake_case		:						Tuple         =  self.get_dummy_inputs(lowercase__		)
        _snake_case		:						Dict         =  sd_pipe(**lowercase__		).images
        _snake_case		:						List[Any]         =  image[0, -3:, -3:, -1]
        assert image.shape == (1, 64, 64, 3)

        _snake_case		:						Union[str, Any]         =  np.array([0.4_773, 0.5_417, 0.4_723, 0.4_925, 0.5_631, 0.4_752, 0.5_240, 0.4_935, 0.5_023]		)

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







  def 					UpperCAmelCase_					(		self		)		->    Any:






        """simple docstring"""





        _snake_case		:						Any         =  '''cpu'''  # ensure determinism for the device-dependent torch.Generator
        _snake_case		:						Optional[Any]         =  self.get_dummy_components()
        torch.manual_seed(0		)
        _snake_case		:						str         =  DDPMParallelScheduler()
        torch.manual_seed(0		)
        _snake_case		:						List[Any]         =  StableDiffusionParadigmsPipeline(**lowercase__		)
        _snake_case		:						Tuple         =  sd_pipe.to(lowercase__		)
        sd_pipe.set_progress_bar_config(disable=lowercase__		)

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

        _snake_case		:						Optional[int]         =  np.array([0.3_573, 0.4_420, 0.4_960, 0.4_799, 0.3_796, 0.3_879, 0.4_819, 0.4_365, 0.4_468]		)

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







  def 					UpperCAmelCase_					(		self		)		->    int:






        """simple docstring"""





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







  def 					UpperCAmelCase_					(		self		)		->    Optional[int]:






        """simple docstring"""





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







  def 					UpperCAmelCase_					(		self		)		->    str:






        """simple docstring"""





        _snake_case		:						str         =  '''cpu'''  # ensure determinism for the device-dependent torch.Generator
        _snake_case		:						Union[str, Any]         =  self.get_dummy_components()
        _snake_case		:						int         =  StableDiffusionParadigmsPipeline(**lowercase__		)
        _snake_case		:						Any         =  sd_pipe.to(lowercase__		)
        sd_pipe.set_progress_bar_config(disable=lowercase__		)

        _snake_case		:						Optional[int]         =  self.get_dummy_inputs(lowercase__		)
        _snake_case		:						Optional[int]         =  '''french fries'''
        _snake_case		:						str         =  sd_pipe(**lowercase__  ,  negative_prompt=lowercase__		)
        _snake_case		:						Union[str, Any]         =  output.images
        _snake_case		:						Optional[Any]         =  image[0, -3:, -3:, -1]

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

        _snake_case		:						Optional[Any]         =  np.array([0.4_771, 0.5_420, 0.4_683, 0.4_918, 0.5_636, 0.4_725, 0.5_230, 0.4_923, 0.5_015]		)

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





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







  def 					UpperCAmelCase_					(		self		)		->    Any:






        """simple docstring"""





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







  def 					UpperCAmelCase_					(		self  ,  lowercase__=0		)		->    Optional[int]:






        """simple docstring"""





        _snake_case		:						Dict         =  torch.Generator(device=lowercase__		).manual_seed(lowercase__		)
        _snake_case		:						Union[str, Any]         =  {
            '''prompt''': '''a photograph of an astronaut riding a horse''',
            '''generator''': generator,
            '''num_inference_steps''': 10,
            '''guidance_scale''': 7.5,
            '''output_type''': '''numpy''',
            '''parallel''': 3,
            '''debug''': True,
        }
        return inputs







  def 					UpperCAmelCase_					(		self		)		->    Dict:






        """simple docstring"""





        _snake_case		:						str         =  '''stabilityai/stable-diffusion-2-base'''
        _snake_case		:						str         =  DDIMParallelScheduler.from_pretrained(lowercase__  ,  subfolder='''scheduler'''		)
        _snake_case		:						List[Any]         =  StableDiffusionParadigmsPipeline.from_pretrained(lowercase__  ,  scheduler=lowercase__  ,  safety_checker=lowercase__		)
        pipe.to(lowercase__		)
        pipe.set_progress_bar_config(disable=lowercase__		)
        pipe.enable_attention_slicing()

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

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

        _snake_case		:						str         =  np.array([0.9_622, 0.9_602, 0.9_748, 0.9_591, 0.9_630, 0.9_691, 0.9_661, 0.9_631, 0.9_741]		)

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









'''simple docstring'''

from __future__ import annotations




def  _a     (				lowerCAmelCase_      ,   lowerCAmelCase_      ,   lowerCAmelCase_      ,   lowerCAmelCase_						):





      """simple docstring"""



      if counter == 0 or capacity == 0:
            return 0

      # If weight of the nth item is more than Knapsack of capacity,
      #   then this item cannot be included in the optimal solution,
      # else return the maximum of two cases:
      #   (1) nth item included
      #   (2) not included
      if weights[counter - 1] > capacity:
            return knapsack(lowerCAmelCase_      ,   lowerCAmelCase_      ,   lowerCAmelCase_      ,   counter - 1						)
      else:
            _snake_case		:						List[str]         =  capacity - weights[counter - 1]
            _snake_case		:						Tuple         =  values[counter - 1] + knapsack(
                lowerCAmelCase_      ,   lowerCAmelCase_      ,   lowerCAmelCase_      ,   counter - 1						)
            _snake_case		:						Any         =  knapsack(lowerCAmelCase_      ,   lowerCAmelCase_      ,   lowerCAmelCase_      ,   counter - 1						)
            return max(lowerCAmelCase_      ,   lowerCAmelCase_						)


if __name__ == "__main__":
   import doctest

   doctest.testmod()


