



"""simple docstring"""

import gc
import unittest

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

from diffusers import TransformeraDModel, VQDiffusionPipeline, VQDiffusionScheduler, VQModel
from diffusers.pipelines.vq_diffusion.pipeline_vq_diffusion import LearnedClassifierFreeSamplingEmbeddings
from diffusers.utils import load_numpy, slow, torch_device
from diffusers.utils.testing_utils import require_torch_gpu


lowercase__			   =  False




class SCREAMING_SNAKE_CASE__					(		unittest.TestCase      ):



						def     lowerCAmelCase__(self							):





													'''simple docstring'''

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



						@property
						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													return 12



						@property
						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													return 12



						@property
						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													return 32



						@property
						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													torch.manual_seed(0							)
													__a		:		Dict									=       VQModel(
													    block_out_channels=[32, 64]						,     in_channels=3						,     out_channels=3						,     down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""]						,     up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""]						,     latent_channels=3						,     num_vq_embeddings=self.num_embed						,     vq_embed_dim=3						,     )
													return model



						@property
						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													__a		:		Optional[Any]									=       CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""							)
													return tokenizer



						@property
						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													torch.manual_seed(0							)
													__a		:		str									=       CLIPTextConfig(
													    bos_token_id=0						,     eos_token_id=2						,     hidden_size=self.text_embedder_hidden_size						,     intermediate_size=37						,     layer_norm_eps=1e-05						,     num_attention_heads=4						,     num_hidden_layers=5						,     pad_token_id=1						,     vocab_size=1000						,     )
													return CLIPTextModel(_lowercase							)



						@property
						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													torch.manual_seed(0							)

													__a		:		int									=       12
													__a		:		List[Any]									=       12

													__a		:		Dict									=       {
													    """attention_bias""": True,
													    """cross_attention_dim""": 32,
													    """attention_head_dim""": height * width,
													    """num_attention_heads""": 1,
													    """num_vector_embeds""": self.num_embed,
													    """num_embeds_ada_norm""": self.num_embeds_ada_norm,
													    """norm_num_groups""": 32,
													    """sample_size""": width,
													    """activation_fn""": """geglu-approximate""",
													}

													__a		:		List[Any]									=       TransformeraDModel(**_lowercase							)
													return model



						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													__a		:		Optional[int]									=       """cpu"""

													__a		:		Optional[Any]									=       self.dummy_vqvae
													__a		:		Tuple									=       self.dummy_text_encoder
													__a		:		Tuple									=       self.dummy_tokenizer
													__a		:		Tuple									=       self.dummy_transformer
													__a		:		Union[str, Any]									=       VQDiffusionScheduler(self.num_embed							)
													__a		:		str									=       LearnedClassifierFreeSamplingEmbeddings(learnable=_lowercase							)

													__a		:		Optional[Any]									=       VQDiffusionPipeline(
													    vqvae=_lowercase						,     text_encoder=_lowercase						,     tokenizer=_lowercase						,     transformer=_lowercase						,     scheduler=_lowercase						,     learned_classifier_free_sampling_embeddings=_lowercase						,     )
													__a		:		Tuple									=       pipe.to(_lowercase							)
													pipe.set_progress_bar_config(disable=_lowercase							)

													__a		:		Union[str, Any]									=       """teddy bear playing in the pool"""

													__a		:		int									=       torch.Generator(device=_lowercase							).manual_seed(0							)
													__a		:		int									=       pipe([prompt]						,     generator=_lowercase						,     num_inference_steps=2						,     output_type="""np"""							)
													__a		:		List[str]									=       output.images

													__a		:		List[Any]									=       torch.Generator(device=_lowercase							).manual_seed(0							)
													__a		:		Tuple									=       pipe(
													    [prompt]						,     generator=_lowercase						,     output_type="""np"""						,     return_dict=_lowercase						,     num_inference_steps=2							)[0]

													__a		:		Tuple									=       image[0, -3:, -3:, -1]
													__a		:		Optional[int]									=       image_from_tuple[0, -3:, -3:, -1]

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

													__a		:		Dict									=       np.array([0.6551, 0.6168, 0.5008, 0.5676, 0.5659, 0.4295, 0.6073, 0.5599, 0.4992]							)

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





						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													__a		:		List[Any]									=       """cpu"""

													__a		:		str									=       self.dummy_vqvae
													__a		:		Any									=       self.dummy_text_encoder
													__a		:		Any									=       self.dummy_tokenizer
													__a		:		Dict									=       self.dummy_transformer
													__a		:		Any									=       VQDiffusionScheduler(self.num_embed							)
													__a		:		List[Any]									=       LearnedClassifierFreeSamplingEmbeddings(
													    learnable=_lowercase						,     hidden_size=self.text_embedder_hidden_size						,     length=tokenizer.model_max_length							)

													__a		:		str									=       VQDiffusionPipeline(
													    vqvae=_lowercase						,     text_encoder=_lowercase						,     tokenizer=_lowercase						,     transformer=_lowercase						,     scheduler=_lowercase						,     learned_classifier_free_sampling_embeddings=_lowercase						,     )
													__a		:		int									=       pipe.to(_lowercase							)
													pipe.set_progress_bar_config(disable=_lowercase							)

													__a		:		Any									=       """teddy bear playing in the pool"""

													__a		:		Optional[int]									=       torch.Generator(device=_lowercase							).manual_seed(0							)
													__a		:		Tuple									=       pipe([prompt]						,     generator=_lowercase						,     num_inference_steps=2						,     output_type="""np"""							)
													__a		:		Any									=       output.images

													__a		:		int									=       torch.Generator(device=_lowercase							).manual_seed(0							)
													__a		:		Dict									=       pipe(
													    [prompt]						,     generator=_lowercase						,     output_type="""np"""						,     return_dict=_lowercase						,     num_inference_steps=2							)[0]

													__a		:		List[str]									=       image[0, -3:, -3:, -1]
													__a		:		Optional[Any]									=       image_from_tuple[0, -3:, -3:, -1]

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

													__a		:		Dict									=       np.array([0.6693, 0.6075, 0.4959, 0.5701, 0.5583, 0.4333, 0.6171, 0.5684, 0.4988]							)

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







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



						def     lowerCAmelCase__(self							):





													'''simple docstring'''

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





						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													__a		:		int									=       load_numpy(
													    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
													    """/vq_diffusion/teddy_bear_pool_classifier_free_sampling.npy"""							)

													__a		:		Dict									=       VQDiffusionPipeline.from_pretrained("""microsoft/vq-diffusion-ithq"""							)
													__a		:		Union[str, Any]									=       pipeline.to(_lowercase							)
													pipeline.set_progress_bar_config(disable=_lowercase							)

													# requires GPU generator for gumbel softmax
													# don't use GPU generator in tests though
													__a		:		Any									=       torch.Generator(device=_lowercase							).manual_seed(0							)
													__a		:		Optional[Any]									=       pipeline(
													    """teddy bear playing in the pool"""						,     num_images_per_prompt=1						,     generator=_lowercase						,     output_type="""np"""						,     )

													__a		:		List[str]									=       output.images[0]

													assert image.shape == (256, 256, 3)
													assert np.abs(expected_image - image							).max() < 2.0






"""simple docstring"""

import unittest

from knapsack import knapsack as k




class SCREAMING_SNAKE_CASE__					(		unittest.TestCase      ):



						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													__a		:		str									=       0
													__a		:		Optional[Any]									=       [0]
													__a		:		int									=       [0]
													__a		:		str									=       len(_lowercase							)
													self.assertEqual(k.knapsack(_lowercase						,     _lowercase						,     _lowercase						,     _lowercase							)						,     0							)

													__a		:		int									=       [60]
													__a		:		Union[str, Any]									=       [10]
													__a		:		Tuple									=       len(_lowercase							)
													self.assertEqual(k.knapsack(_lowercase						,     _lowercase						,     _lowercase						,     _lowercase							)						,     0							)



						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													__a		:		int									=       3
													__a		:		str									=       [1, 2, 3]
													__a		:		Optional[Any]									=       [3, 2, 1]
													__a		:		int									=       len(_lowercase							)
													self.assertEqual(k.knapsack(_lowercase						,     _lowercase						,     _lowercase						,     _lowercase							)						,     5							)





						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													__a		:		Dict									=       50
													__a		:		Tuple									=       [60, 100, 120]
													__a		:		List[str]									=       [10, 20, 30]
													__a		:		Union[str, Any]									=       len(_lowercase							)
													self.assertEqual(k.knapsack(_lowercase						,     _lowercase						,     _lowercase						,     _lowercase							)						,     220							)


if __name__ == "__main__":
	unittest.main()

