


def        lowerCAmelCase_  (      __lowerCamelCase = 3							,			__lowerCamelCase = 7							,			__lowerCamelCase = 1_0_0_0_0_0_0			):
							__snake_case	:    List[Any]											=     0
							__snake_case	:    str											=     1

							for current_denominator in range(1							,			limit + 1			):
														__snake_case	:    Optional[Any]											=     current_denominator * numerator // denominator
														if current_denominator % denominator == 0:
																					current_numerator -= 1
														if current_numerator * max_denominator > current_denominator * max_numerator:
																					__snake_case	:    Optional[Any]											=     current_numerator
																					__snake_case	:    Union[str, Any]											=     current_denominator
							return max_numerator


if __name__ == "__main__":
			print(solution(numerator=3, denominator=7, limit=1_000_000))





import gc
import unittest

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

from diffusers import AutoencoderKL, DDIMScheduler, LDMTextToImagePipeline, UNetaDConditionModel
from diffusers.utils.testing_utils import (
    enable_full_determinism,
    load_numpy,
    nightly,
    require_torch_gpu,
    slow,
    torch_device,
)

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()

class        a	(_lowerCAmelCase  ,       unittest.TestCase   ):




							"""simple docstring"""


							__UpperCAmelCase					:							Optional[Any]  						=						LDMTextToImagePipeline
							__UpperCAmelCase					:							List[Any]  						=						TEXT_TO_IMAGE_PARAMS - {
							    "negative_prompt",
							    "negative_prompt_embeds",
							    "cross_attention_kwargs",
							    "prompt_embeds",
							}
							__UpperCAmelCase					:							int  						=						PipelineTesterMixin.required_optional_params - {
							    "num_images_per_prompt",
							    "callback",
							    "callback_steps",
							}
							__UpperCAmelCase					:							Any  						=						TEXT_TO_IMAGE_BATCH_PARAMS
							__UpperCAmelCase					:							int  						=						False

							def 					__snake_case      (							self :						Union[str, Any]       )			->					str:
														torch.manual_seed(0       )
														__snake_case	:    List[Any]											=     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					,			)
														__snake_case	:    Any											=     DDIMScheduler(
														    beta_start=0.0_00_85					,			beta_end=0.0_12					,			beta_schedule="scaled_linear"					,			clip_sample=lowerCamelCase					,			set_alpha_to_one=lowerCamelCase					,			)
														torch.manual_seed(0       )
														__snake_case	:    Dict											=     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					,			)
														torch.manual_seed(0       )
														__snake_case	:    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=1000					,			)
														__snake_case	:    Any											=     CLIPTextModel(lowerCamelCase       )
														__snake_case	:    Dict											=     CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"       )

														__snake_case	:    List[str]											=     {
														    "unet": unet,
														    "scheduler": scheduler,
														    "vqvae": vae,
														    "bert": text_encoder,
														    "tokenizer": tokenizer,
														}
														return components

							def 					__snake_case      (							self :						List[Any]					,			lowerCamelCase :						str					,			lowerCamelCase :						Any=0       )			->					str:
														if str(lowerCamelCase       ).startswith("mps"       ):
																					__snake_case	:    Union[str, Any]											=     torch.manual_seed(lowerCamelCase       )
														else:
																					__snake_case	:    str											=     torch.Generator(device=lowerCamelCase       ).manual_seed(lowerCamelCase       )
														__snake_case	:    Dict											=     {
														    "prompt": "A painting of a squirrel eating a burger",
														    "generator": generator,
														    "num_inference_steps": 2,
														    "guidance_scale": 6.0,
														    "output_type": "numpy",
														}
														return inputs






							def 					__snake_case      (							self :						Dict       )			->					Optional[Any]:
														__snake_case	:    List[Any]											=     "cpu"  # ensure determinism for the device-dependent torch.Generator

														__snake_case	:    Union[str, Any]											=     self.get_dummy_components()
														__snake_case	:    int											=     LDMTextToImagePipeline(**lowerCamelCase       )
														pipe.to(lowerCamelCase       )
														pipe.set_progress_bar_config(disable=lowerCamelCase       )

														__snake_case	:    Optional[Any]											=     self.get_dummy_inputs(lowerCamelCase       )
														__snake_case	:    Optional[Any]											=     pipe(**lowerCamelCase       ).images
														__snake_case	:    Optional[int]											=     image[0, -3:, -3:, -1]

														assert image.shape == (1, 16, 16, 3)
														__snake_case	:    int											=     np.array([0.61_01, 0.61_56, 0.56_22, 0.48_95, 0.66_61, 0.38_04, 0.57_48, 0.61_36, 0.50_14]       )

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

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




							"""simple docstring"""


							def 					__snake_case      (							self :						int       )			->					str:
														super().tearDown()
														gc.collect()
														torch.cuda.empty_cache()

							def 					__snake_case      (							self :						Optional[int]					,			lowerCamelCase :						Dict					,			lowerCamelCase :						Any=torch.floataa					,			lowerCamelCase :						List[Any]=0       )			->					Dict:
														__snake_case	:    List[Any]											=     torch.manual_seed(lowerCamelCase       )
														__snake_case	:    Tuple											=     np.random.RandomState(lowerCamelCase       ).standard_normal((1, 4, 32, 32)       )
														__snake_case	:    int											=     torch.from_numpy(lowerCamelCase       ).to(device=lowerCamelCase					,			dtype=lowerCamelCase       )
														__snake_case	:    List[str]											=     {
														    "prompt": "A painting of a squirrel eating a burger",
														    "latents": latents,
														    "generator": generator,
														    "num_inference_steps": 3,
														    "guidance_scale": 6.0,
														    "output_type": "numpy",
														}
														return inputs






							def 					__snake_case      (							self :						Tuple       )			->					Optional[Any]:
														__snake_case	:    str											=     LDMTextToImagePipeline.from_pretrained("CompVis/ldm-text2im-large-256"       ).to(lowerCamelCase       )
														pipe.set_progress_bar_config(disable=lowerCamelCase       )

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

														assert image.shape == (1, 256, 256, 3)
														__snake_case	:    int											=     np.array([0.5_18_25, 0.5_28_50, 0.5_25_43, 0.5_42_58, 0.5_23_04, 0.5_25_69, 0.5_43_63, 0.5_52_76, 0.5_68_78]       )
														__snake_case	:    List[str]											=     np.abs(expected_slice - image_slice       ).max()
														assert max_diff < 1E-3

@nightly
@require_torch_gpu
class        a	(unittest.TestCase   ):




							"""simple docstring"""


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

							def 					__snake_case      (							self :						Any					,			lowerCamelCase :						Dict					,			lowerCamelCase :						Any=torch.floataa					,			lowerCamelCase :						List[Any]=0       )			->					Optional[Any]:
														__snake_case	:    int											=     torch.manual_seed(lowerCamelCase       )
														__snake_case	:    Tuple											=     np.random.RandomState(lowerCamelCase       ).standard_normal((1, 4, 32, 32)       )
														__snake_case	:    Optional[Any]											=     torch.from_numpy(lowerCamelCase       ).to(device=lowerCamelCase					,			dtype=lowerCamelCase       )
														__snake_case	:    List[Any]											=     {
														    "prompt": "A painting of a squirrel eating a burger",
														    "latents": latents,
														    "generator": generator,
														    "num_inference_steps": 50,
														    "guidance_scale": 6.0,
														    "output_type": "numpy",
														}
														return inputs






							def 					__snake_case      (							self :						List[str]       )			->					int:
														__snake_case	:    Union[str, Any]											=     LDMTextToImagePipeline.from_pretrained("CompVis/ldm-text2im-large-256"       ).to(lowerCamelCase       )
														pipe.set_progress_bar_config(disable=lowerCamelCase       )

														__snake_case	:    Optional[Any]											=     self.get_inputs(lowerCamelCase       )
														__snake_case	:    str											=     pipe(**lowerCamelCase       ).images[0]

														__snake_case	:    Tuple											=     load_numpy(
														    "https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/ldm_text2img/ldm_large_256_ddim.npy"       )
														__snake_case	:    str											=     np.abs(expected_image - image       ).max()
														assert max_diff < 1E-3

