



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


UpperCamelCase__					    =    False
class     a__					(      unittest.TestCase   ):






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



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






						@property
						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											return 1_2






						@property
						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											return 1_2






						@property
						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											return 3_2






						@property
						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											torch.manual_seed(0    )
											__lowerCAmelCase            = VQModel(
											    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=3	,    num_vq_embeddings=self.num_embed	,    vq_embed_dim=3	,    )
											return model






						@property
						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											__lowerCAmelCase            = CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"    )
											return tokenizer






						@property
						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											torch.manual_seed(0    )
											__lowerCAmelCase            = CLIPTextConfig(
											    bos_token_id=0	,    eos_token_id=2	,    hidden_size=self.text_embedder_hidden_size	,    intermediate_size=3_7	,    layer_norm_eps=1E-0_5	,    num_attention_heads=4	,    num_hidden_layers=5	,    pad_token_id=1	,    vocab_size=1_0_0_0	,    )
											return CLIPTextModel(_A    )






						@property
						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											torch.manual_seed(0    )

											__lowerCAmelCase            = 1_2
											__lowerCAmelCase            = 1_2

											__lowerCAmelCase            = {
											    "attention_bias": True,
											    "cross_attention_dim": 3_2,
											    "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": 3_2,
											    "sample_size": width,
											    "activation_fn": "geglu-approximate",
											}

											__lowerCAmelCase            = TransformeraDModel(**_A    )
											return model






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											__lowerCAmelCase            = "cpu"

											__lowerCAmelCase            = self.dummy_vqvae
											__lowerCAmelCase            = self.dummy_text_encoder
											__lowerCAmelCase            = self.dummy_tokenizer
											__lowerCAmelCase            = self.dummy_transformer
											__lowerCAmelCase            = VQDiffusionScheduler(self.num_embed    )
											__lowerCAmelCase            = LearnedClassifierFreeSamplingEmbeddings(learnable=_A    )

											__lowerCAmelCase            = VQDiffusionPipeline(
											    vqvae=_A	,    text_encoder=_A	,    tokenizer=_A	,    transformer=_A	,    scheduler=_A	,    learned_classifier_free_sampling_embeddings=_A	,    )
											__lowerCAmelCase            = pipe.to(_A    )
											pipe.set_progress_bar_config(disable=_A    )

											__lowerCAmelCase            = "teddy bear playing in the pool"

											__lowerCAmelCase            = torch.Generator(device=_A    ).manual_seed(0    )
											__lowerCAmelCase            = pipe([prompt]	,    generator=_A	,    num_inference_steps=2	,    output_type="np"    )
											__lowerCAmelCase            = output.images

											__lowerCAmelCase            = torch.Generator(device=_A    ).manual_seed(0    )
											__lowerCAmelCase            = pipe(
											    [prompt]	,    generator=_A	,    output_type="np"	,    return_dict=_A	,    num_inference_steps=2    )[0]

											__lowerCAmelCase            = image[0, -3:, -3:, -1]
											__lowerCAmelCase            = image_from_tuple[0, -3:, -3:, -1]

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

											__lowerCAmelCase            = np.array([0.65_51, 0.61_68, 0.50_08, 0.56_76, 0.56_59, 0.42_95, 0.60_73, 0.55_99, 0.49_92]    )

											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        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											__lowerCAmelCase            = "cpu"

											__lowerCAmelCase            = self.dummy_vqvae
											__lowerCAmelCase            = self.dummy_text_encoder
											__lowerCAmelCase            = self.dummy_tokenizer
											__lowerCAmelCase            = self.dummy_transformer
											__lowerCAmelCase            = VQDiffusionScheduler(self.num_embed    )
											__lowerCAmelCase            = LearnedClassifierFreeSamplingEmbeddings(
											    learnable=_A	,    hidden_size=self.text_embedder_hidden_size	,    length=tokenizer.model_max_length    )

											__lowerCAmelCase            = VQDiffusionPipeline(
											    vqvae=_A	,    text_encoder=_A	,    tokenizer=_A	,    transformer=_A	,    scheduler=_A	,    learned_classifier_free_sampling_embeddings=_A	,    )
											__lowerCAmelCase            = pipe.to(_A    )
											pipe.set_progress_bar_config(disable=_A    )

											__lowerCAmelCase            = "teddy bear playing in the pool"

											__lowerCAmelCase            = torch.Generator(device=_A    ).manual_seed(0    )
											__lowerCAmelCase            = pipe([prompt]	,    generator=_A	,    num_inference_steps=2	,    output_type="np"    )
											__lowerCAmelCase            = output.images

											__lowerCAmelCase            = torch.Generator(device=_A    ).manual_seed(0    )
											__lowerCAmelCase            = pipe(
											    [prompt]	,    generator=_A	,    output_type="np"	,    return_dict=_A	,    num_inference_steps=2    )[0]

											__lowerCAmelCase            = image[0, -3:, -3:, -1]
											__lowerCAmelCase            = image_from_tuple[0, -3:, -3:, -1]

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

											__lowerCAmelCase            = np.array([0.66_93, 0.60_75, 0.49_59, 0.57_01, 0.55_83, 0.43_33, 0.61_71, 0.56_84, 0.49_88]    )

											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     a__					(      unittest.TestCase   ):






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



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






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



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

											__lowerCAmelCase            = VQDiffusionPipeline.from_pretrained("microsoft/vq-diffusion-ithq"    )
											__lowerCAmelCase            = pipeline.to(_A    )
											pipeline.set_progress_bar_config(disable=_A    )

											# requires GPU generator for gumbel softmax
											# don't use GPU generator in tests though
											__lowerCAmelCase            = torch.Generator(device=_A    ).manual_seed(0    )
											__lowerCAmelCase            = pipeline(
											    "teddy bear playing in the pool"	,    num_images_per_prompt=1	,    generator=_A	,    output_type="np"	,    )

											__lowerCAmelCase            = output.images[0]

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










from math import sqrt







def 			_a   (		SCREAMING_SNAKE_CASE_							:       int  ):

					if 1 < number < 4:
										# 2 and 3 are primes
										return True
					elif number < 2 or number % 2 == 0 or number % 3 == 0:
										# Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
										return False

					# All primes number are in format of 6k +/- 1
					for i in range(5   ,   int(sqrt(SCREAMING_SNAKE_CASE_  ) + 1  )   ,   6  ):
										if number % i == 0 or number % (i + 2) == 0:
															return False
					return True







def 			_a   (		SCREAMING_SNAKE_CASE_							:       int = 1_00_01  ):
					__lowerCAmelCase            = 0
					__lowerCAmelCase            = 1
					while count != nth and number < 3:
										number += 1
										if is_prime(SCREAMING_SNAKE_CASE_  ):
															count += 1
					while count != nth:
										number += 2
										if is_prime(SCREAMING_SNAKE_CASE_  ):
															count += 1
					return number


if __name__ == "__main__":
					print(f'''{solution() = }''')




