# Stable Diffusion XL Stable Diffusion XL (SDXL) diusulkan dalam [SDXL: Improving Latent Diffusion Models for High-Resolution Image Synthesis](https://huggingface.co/papers/2307.01952) oleh Dustin Podell, Zion English, Kyle Lacey, Andreas Blattmann, Tim Dockhorn, Jonas Müller, Joe Penna, dan Robin Rombach. Abstrak dari makalah tersebut adalah: *Kami memperkenalkan SDXL, model difusi laten untuk sintesis teks-ke-gambar. Dibandingkan dengan versi Stable Diffusion sebelumnya, SDXL memanfaatkan tulang punggung UNet yang tiga kali lebih besar: peningkatan parameter model terutama disebabkan oleh lebih banyak blok perhatian dan konteks cross-attention yang lebih besar karena SDXL menggunakan pengkode teks kedua. Kami merancang beberapa skema kondisioning baru dan melatih SDXL pada beberapa rasio aspek. Kami juga memperkenalkan model penyempurnaan yang digunakan untuk meningkatkan kesetiaan visual dari sampel yang dihasilkan oleh SDXL menggunakan teknik gambar-ke-gambar pasca-pemrosesan. Kami menunjukkan bahwa SDXL menunjukkan peningkatan kinerja yang drastis dibandingkan versi Stable Diffusion sebelumnya dan mencapai hasil yang kompetitif dengan generator gambar state-of-the-art black-box.* ## Tips - Menggunakan SDXL dengan penjadwal DPM++ untuk kurang dari 50 langkah diketahui menghasilkan [artefak visual](https://github.com/huggingface/diffusers/issues/5433) karena solver menjadi tidak stabil secara numerik. Untuk memperbaiki masalah ini, lihat [PR](https://github.com/huggingface/diffusers/pull/5541) ini yang merekomendasikan untuk solver ODE/SDE: - set `use_karras_sigmas=True` atau `lu_lambdas=True` untuk meningkatkan kualitas gambar - set `euler_at_final=True` jika Anda menggunakan solver dengan ukuran langkah seragam (DPM++2M atau DPM++2M SDE) - Sebagian besar checkpoint SDXL bekerja paling baik dengan ukuran gambar 1024x1024. Ukuran gambar 768x768 dan 512x512 juga didukung, tetapi hasilnya tidak sebaik itu. Ukuran di bawah 512x512 tidak disarankan dan kemungkinan besar tidak akan berfungsi untuk checkpoint default seperti [stabilityai/stable-diffusion-xl-base-1.0](https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0). - SDXL dapat meneruskan prompt yang berbeda untuk masing-masing text encoder yang digunakan dalam pelatihannya. Kita bahkan dapat meneruskan bagian-bagian yang berbeda dari prompt yang sama ke text encoder. - Gambar keluaran SDXL dapat ditingkatkan dengan memanfaatkan model refiner dalam pengaturan image-to-image. - SDXL menyediakan `negative_original_size`, `negative_crops_coords_top_left`, dan `negative_target_size` untuk mengondisikan model secara negatif terhadap parameter resolusi dan pemotongan gambar. > [!TIP] > Lihat organisasi [Stability AI](https://huggingface.co/stabilityai) di Hub untuk checkpoint model base dan refiner resmi! Pastikan Anda telah menginstal pustaka berikut. ```py # uncomment to install the necessary libraries in Colab #!pip install -q diffusers transformers accelerate invisible-watermark>=0.2.0 ``` > [!WARNING] > Kami merekomendasikan untuk menginstal pustaka [invisible-watermark](https://pypi.org/project/invisible-watermark/) untuk membantu mengidentifikasi gambar yang dihasilkan. Jika pustaka invisible-watermark terinstal, pustaka tersebut digunakan secara default. Untuk menonaktifkan watermarker: > > ```py > pipeline = StableDiffusionXLPipeline.from_pretrained(..., add_watermarker=False) > ``` ## Muat checkpoint model Bobot model mungkin disimpan di subfolder terpisah di Hub atau secara lokal, dalam hal ini, Anda harus menggunakan metode [from_pretrained()](/docs/diffusers/v0.43.0/id/api/pipelines/overview#diffusers.DiffusionPipeline.from_pretrained): ```py from diffusers import StableDiffusionXLPipeline, StableDiffusionXLImg2ImgPipeline import torch pipeline = StableDiffusionXLPipeline.from_pretrained( "stabilityai/stable-diffusion-xl-base-1.0", dtype=torch.float16, variant="fp16", use_safetensors=True ).to("cuda") # or "mps", "xpu", "cpu" refiner = StableDiffusionXLImg2ImgPipeline.from_pretrained( "stabilityai/stable-diffusion-xl-refiner-1.0", dtype=torch.float16, use_safetensors=True, variant="fp16" ).to("cuda") ``` Anda juga dapat menggunakan metode [from_single_file()](/docs/diffusers/v0.43.0/id/api/loaders/single_file#diffusers.loaders.FromSingleFileMixin.from_single_file) untuk memuat checkpoint model yang disimpan dalam format file tunggal (`.ckpt` atau `.safetensors`) dari Hub atau secara lokal: ```py from diffusers import StableDiffusionXLPipeline, StableDiffusionXLImg2ImgPipeline import torch pipeline = StableDiffusionXLPipeline.from_single_file( "https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0/blob/main/sd_xl_base_1.0.safetensors", dtype=torch.float16 ).to("cuda") # or "mps", "xpu", "cpu" refiner = StableDiffusionXLImg2ImgPipeline.from_single_file( "https://huggingface.co/stabilityai/stable-diffusion-xl-refiner-1.0/blob/main/sd_xl_refiner_1.0.safetensors", dtype=torch.float16 ).to("cuda") ``` ## Teks-ke-gambar Untuk text-to-image, berikan prompt teks. Secara default, SDXL menghasilkan gambar 1024x1024 untuk hasil terbaik. Anda dapat mencoba mengatur parameter `height` dan `width` menjadi 768x768 atau 512x512, tetapi ukuran di bawah 512x512 kemungkinan besar tidak akan berfungsi. ```py from diffusers import AutoPipelineForText2Image import torch pipeline_text2image = AutoPipelineForText2Image.from_pretrained( "stabilityai/stable-diffusion-xl-base-1.0", dtype=torch.float16, variant="fp16", use_safetensors=True ).to("cuda") # or "mps", "xpu", "cpu" prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k" image = pipeline_text2image(prompt=prompt).images[0] image ``` ## Gambar-ke-gambar Untuk image-to-image, SDXL bekerja sangat baik dengan ukuran gambar antara 768x768 dan 1024x1024. Berikan gambar awal, dan prompt teks untuk mengondisikan gambar dengan: ```py from diffusers import AutoPipelineForImage2Image from diffusers.utils import load_image, make_image_grid # use from_pipe to avoid consuming additional memory when loading a checkpoint pipeline = AutoPipelineForImage2Image.from_pipe(pipeline_text2image).to("cuda") # or "mps", "xpu", "cpu" url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/sdxl-text2img.png" init_image = load_image(url) prompt = "a dog catching a frisbee in the jungle" image = pipeline(prompt, image=init_image, strength=0.8, guidance_scale=10.5).images[0] make_image_grid([init_image, image], rows=1, cols=2) ``` ## Inpainting Untuk inpainting, Anda memerlukan gambar asli dan mask dari area yang ingin Anda ganti pada gambar asli. Buat prompt untuk menggambarkan apa yang ingin Anda gunakan untuk menggantikan area yang di-mask. ```py from diffusers import AutoPipelineForInpainting from diffusers.utils import load_image, make_image_grid # use from_pipe to avoid consuming additional memory when loading a checkpoint pipeline = AutoPipelineForInpainting.from_pipe(pipeline_text2image).to("cuda") # or "mps", "xpu", "cpu" img_url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/sdxl-text2img.png" mask_url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/sdxl-inpaint-mask.png" init_image = load_image(img_url) mask_image = load_image(mask_url) prompt = "A deep sea diver floating" image = pipeline(prompt=prompt, image=init_image, mask_image=mask_image, strength=0.85, guidance_scale=12.5).images[0] make_image_grid([init_image, mask_image, image], rows=1, cols=3) ``` ## Perbaiki kualitas gambar SDXL mencakup [model refiner](https://huggingface.co/stabilityai/stable-diffusion-xl-refiner-1.0) yang khusus untuk denoising gambar pada tahap noise rendah guna menghasilkan gambar berkualitas lebih tinggi dari model dasar. Ada dua cara untuk menggunakan refiner: 1. gunakan model base dan refiner secara bersama untuk menghasilkan gambar yang lebih halus 2. gunakan model dasar untuk menghasilkan gambar, kemudian gunakan model refiner untuk menambahkan lebih banyak detail ke gambar (inilah cara SDXL dilatih secara asli) ### Model dasar + penyempurna Ketika Anda menggunakan model dasar dan model penyempurna secara bersama-sama untuk menghasilkan gambar, hal ini dikenal sebagai [*ensemble of expert denoisers*](https://research.nvidia.com/labs/dir/eDiff-I/). Pendekatan ensemble of expert denoisers membutuhkan jumlah langkah denoising keseluruhan yang lebih sedikit dibandingkan meneruskan keluaran model dasar ke model penyempurna, sehingga seharusnya jauh lebih cepat untuk dijalankan. Namun, Anda tidak akan dapat memeriksa keluaran model dasar karena masih mengandung banyak noise. Sebagai ensemble dari denoiser ahli, model dasar berperan sebagai ahli selama tahap difusi berisik tinggi, dan model refiner berperan sebagai ahli selama tahap difusi berisik rendah. Muat model dasar dan model refiner: ```py from diffusers import DiffusionPipeline import torch base = DiffusionPipeline.from_pretrained( "stabilityai/stable-diffusion-xl-base-1.0", dtype=torch.float16, variant="fp16", use_safetensors=True ).to("cuda") # or "mps", "xpu", "cpu" refiner = DiffusionPipeline.from_pretrained( "stabilityai/stable-diffusion-xl-refiner-1.0", text_encoder_2=base.text_encoder_2, vae=base.vae, dtype=torch.float16, use_safetensors=True, variant="fp16", ).to("cuda") ``` Untuk menggunakan pendekatan ini, Anda perlu menentukan jumlah timestep untuk setiap model agar menjalankan tahap masing-masing. Untuk model dasar, ini dikendalikan oleh parameter [`denoising_end`](https://huggingface.co/docs/diffusers/main/en/api/pipelines/stable_diffusion/stable_diffusion_xl#diffusers.StableDiffusionXLPipeline.__call__.denoising_end) dan untuk model refiner, dikendalikan oleh parameter [`denoising_start`](https://huggingface.co/docs/diffusers/main/en/api/pipelines/stable_diffusion/stable_diffusion_xl#diffusers.StableDiffusionXLImg2ImgPipeline.__call__.denoising_start). > [!TIP] > Parameter `denoising_end` dan `denoising_start` harus berupa float antara 0 dan 1. Parameter ini direpresentasikan sebagai proporsi dari timestep diskrit yang didefinisikan oleh scheduler. Jika Anda juga menggunakan parameter `strength`, parameter tersebut akan diabaikan karena jumlah langkah denoising ditentukan oleh timestep diskrit yang digunakan dalam pelatihan model dan cutoff fraksional yang dideklarasikan. Mari kita atur `denoising_end=0.8` agar model dasar melakukan 80% pertama dari denoising pada timestep **high-noise** dan atur `denoising_start=0.8` agar model refiner melakukan 20% terakhir dari denoising pada timestep **low-noise**. Output model dasar harus berada di ruang **latent** alih-alih gambar PIL. ```py prompt = "A majestic lion jumping from a big stone at night" image = base( prompt=prompt, num_inference_steps=40, denoising_end=0.8, output_type="latent", ).images image = refiner( prompt=prompt, num_inference_steps=40, denoising_start=0.8, image=image, ).images[0] image ``` model dasar default ensemble dari denoiser ahli Model refiner juga dapat digunakan untuk inpainting di [StableDiffusionXLInpaintPipeline](/docs/diffusers/v0.43.0/id/api/pipelines/stable_diffusion/stable_diffusion_xl#diffusers.StableDiffusionXLInpaintPipeline): ```py from diffusers import StableDiffusionXLInpaintPipeline from diffusers.utils import load_image, make_image_grid import torch base = StableDiffusionXLInpaintPipeline.from_pretrained( "stabilityai/stable-diffusion-xl-base-1.0", dtype=torch.float16, variant="fp16", use_safetensors=True ).to("cuda") # or "mps", "xpu", "cpu" refiner = StableDiffusionXLInpaintPipeline.from_pretrained( "stabilityai/stable-diffusion-xl-refiner-1.0", text_encoder_2=base.text_encoder_2, vae=base.vae, dtype=torch.float16, use_safetensors=True, variant="fp16", ).to("cuda") img_url = "https://raw.githubusercontent.com/CompVis/latent-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo.png" mask_url = "https://raw.githubusercontent.com/CompVis/latent-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo_mask.png" init_image = load_image(img_url) mask_image = load_image(mask_url) prompt = "A majestic tiger sitting on a bench" num_inference_steps = 75 high_noise_frac = 0.7 image = base( prompt=prompt, image=init_image, mask_image=mask_image, num_inference_steps=num_inference_steps, denoising_end=high_noise_frac, output_type="latent", ).images image = refiner( prompt=prompt, image=image, mask_image=mask_image, num_inference_steps=num_inference_steps, denoising_start=high_noise_frac, ).images[0] make_image_grid([init_image, mask_image, image.resize((512, 512))], rows=1, cols=3) ``` Metode ensemble dari denoiser ahli ini bekerja dengan baik untuk semua scheduler yang tersedia! ### Model dasar ke model penyempurna SDXL mendapatkan peningkatan kualitas gambar dengan menggunakan model refiner untuk menambahkan detail berkualitas tinggi tambahan pada gambar yang sepenuhnya dinoised dari model dasar, dalam pengaturan image-to-image. Muat model dasar dan penyempurna: ```py from diffusers import DiffusionPipeline import torch base = DiffusionPipeline.from_pretrained( "stabilityai/stable-diffusion-xl-base-1.0", dtype=torch.float16, variant="fp16", use_safetensors=True ).to("cuda") # or "mps", "xpu", "cpu" refiner = DiffusionPipeline.from_pretrained( "stabilityai/stable-diffusion-xl-refiner-1.0", text_encoder_2=base.text_encoder_2, vae=base.vae, dtype=torch.float16, use_safetensors=True, variant="fp16", ).to("cuda") ``` > [!WARNING] > Anda dapat menggunakan SDXL refiner dengan model dasar yang berbeda. Misalnya, Anda dapat menggunakan pipeline [Hunyuan-DiT](../hunyuandit) atau [PixArt-Sigma](../pixart_sigma) untuk menghasilkan gambar dengan kepatuhan prompt yang lebih baik. Setelah Anda menghasilkan gambar, Anda dapat meneruskannya ke model SDXL refiner untuk meningkatkan kualitas akhir generasi. Buat gambar dari model dasar, dan atur keluaran model ke ruang **latent**: ```py prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k" image = base(prompt=prompt, output_type="latent").images[0] ``` Lewatkan gambar yang dihasilkan ke model refiner: ```py image = refiner(prompt=prompt, image=image[None, :]).images[0] ``` model dasar model dasar + model penyempurna Untuk inpainting, muat model dasar dan model refiner di [StableDiffusionXLInpaintPipeline](/docs/diffusers/v0.43.0/id/api/pipelines/stable_diffusion/stable_diffusion_xl#diffusers.StableDiffusionXLInpaintPipeline), hapus parameter `denoising_end` dan `denoising_start`, dan pilih jumlah langkah inferensi yang lebih kecil untuk refiner. ## Micro-conditioning Pelatihan SDXL melibatkan beberapa teknik kondisioning tambahan yang disebut sebagai *micro-conditioning*. Teknik ini mencakup ukuran gambar asli, ukuran gambar target, dan parameter pemotongan. Micro-conditioning dapat digunakan pada saat inferensi untuk membuat gambar berkualitas tinggi yang terpusat. > [!TIP] > Anda dapat menggunakan parameter micro-conditioning dan negative micro-conditioning berkat classifier-free guidance. Parameter ini tersedia di [StableDiffusionXLPipeline](/docs/diffusers/v0.43.0/id/api/pipelines/stable_diffusion/stable_diffusion_xl#diffusers.StableDiffusionXLPipeline), [StableDiffusionXLImg2ImgPipeline](/docs/diffusers/v0.43.0/id/api/pipelines/stable_diffusion/stable_diffusion_xl#diffusers.StableDiffusionXLImg2ImgPipeline), [StableDiffusionXLInpaintPipeline](/docs/diffusers/v0.43.0/id/api/pipelines/stable_diffusion/stable_diffusion_xl#diffusers.StableDiffusionXLInpaintPipeline), dan [StableDiffusionXLControlNetPipeline](/docs/diffusers/v0.43.0/id/api/pipelines/controlnet_sdxl#diffusers.StableDiffusionXLControlNetPipeline). ### Kondisioning ukuran Ada dua jenis kondisioning ukuran: - [`original_size`](https://huggingface.co/docs/diffusers/main/en/api/pipelines/stable_diffusion/stable_diffusion_xl#diffusers.StableDiffusionXLPipeline.__call__.original_size) conditioning berasal dari gambar yang di-upscale dalam batch pelatihan (karena membuang gambar-gambar kecil yang mencakup hampir 40% dari total data pelatihan akan menjadi pemborosan). Dengan cara ini, SDXL belajar bahwa artefak upscaling seharusnya tidak ada pada gambar resolusi tinggi. Saat inferensi, Anda dapat menggunakan `original_size` untuk menunjukkan resolusi gambar asli. Menggunakan nilai default `(1024, 1024)` menghasilkan gambar berkualitas lebih tinggi yang menyerupai gambar 1024x1024 dalam dataset. Jika Anda memilih untuk menggunakan resolusi yang lebih rendah, seperti `(256, 256)`, model tetap menghasilkan gambar 1024x1024, tetapi hasilnya akan terlihat seperti gambar resolusi rendah (pola lebih sederhana, blur) dalam dataset. - Kondisi [`target_size`](https://huggingface.co/docs/diffusers/main/en/api/pipelines/stable_diffusion/stable_diffusion_xl#diffusers.StableDiffusionXLPipeline.__call__.target_size) berasal dari finetuning SDXL untuk mendukung rasio aspek gambar yang berbeda. Selama inferensi, jika Anda menggunakan nilai default `(1024, 1024)`, Anda akan mendapatkan gambar yang menyerupai komposisi gambar persegi dalam dataset. Kami merekomendasikan menggunakan nilai yang sama untuk `target_size` dan `original_size`, tetapi silakan bereksperimen dengan opsi lain! 🤗 Diffusers juga memungkinkan Anda untuk menentukan kondisi negatif tentang ukuran gambar untuk mengarahkan generasi menjauh dari resolusi gambar tertentu: ```py from diffusers import StableDiffusionXLPipeline import torch pipe = StableDiffusionXLPipeline.from_pretrained( "stabilityai/stable-diffusion-xl-base-1.0", dtype=torch.float16, variant="fp16", use_safetensors=True ).to("cuda") # or "mps", "xpu", "cpu" prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k" image = pipe( prompt=prompt, negative_original_size=(512, 512), negative_target_size=(1024, 1024), ).images[0] ``` Gambar yang dikondisikan secara negatif pada resolusi gambar (128, 128), (256, 256), dan (512, 512). ### Crop conditioning Gambar yang dihasilkan oleh model Stable Diffusion sebelumnya terkadang tampak terpotong. Hal ini terjadi karena gambar memang dipotong selama pelatihan agar semua gambar dalam satu batch memiliki ukuran yang sama. Dengan mengondisikan pada koordinat pemotongan, SDXL *belajar* bahwa tidak ada pemotongan - koordinat `(0, 0)` - biasanya berkorelasi dengan subjek yang terpusat dan wajah yang utuh (ini adalah nilai default di 🤗 Diffusers). Anda dapat bereksperimen dengan koordinat yang berbeda jika ingin menghasilkan komposisi yang tidak terpusat! ```py from diffusers import StableDiffusionXLPipeline import torch pipeline = StableDiffusionXLPipeline.from_pretrained( "stabilityai/stable-diffusion-xl-base-1.0", dtype=torch.float16, variant="fp16", use_safetensors=True ).to("cuda") # or "mps", "xpu", "cpu" prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k" image = pipeline(prompt=prompt, crops_coords_top_left=(256, 0)).images[0] image ``` Anda juga dapat menentukan koordinat pemotongan negatif untuk mengarahkan generasi menjauh dari parameter pemotongan tertentu: ```py from diffusers import StableDiffusionXLPipeline import torch pipe = StableDiffusionXLPipeline.from_pretrained( "stabilityai/stable-diffusion-xl-base-1.0", dtype=torch.float16, variant="fp16", use_safetensors=True ).to("cuda") # or "mps", "xpu", "cpu" prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k" image = pipe( prompt=prompt, negative_original_size=(512, 512), negative_crops_coords_top_left=(0, 0), negative_target_size=(1024, 1024), ).images[0] image ``` ## Gunakan prompt yang berbeda untuk setiap text-encoder SDXL menggunakan dua text-encoder, sehingga Anda dapat memberikan prompt yang berbeda untuk masing-masing text-encoder, yang dapat [meningkatkan kualitas](https://github.com/huggingface/diffusers/issues/4004#issuecomment-1627764201). Berikan prompt asli Anda ke `prompt` dan prompt kedua ke `prompt_2` (gunakan `negative_prompt` dan `negative_prompt_2` jika Anda menggunakan negative prompt): ```py from diffusers import StableDiffusionXLPipeline import torch pipeline = StableDiffusionXLPipeline.from_pretrained( "stabilityai/stable-diffusion-xl-base-1.0", dtype=torch.float16, variant="fp16", use_safetensors=True ).to("cuda") # or "mps", "xpu", "cpu" # prompt is passed to OAI CLIP-ViT/L-14 prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k" # prompt_2 is passed to OpenCLIP-ViT/bigG-14 prompt_2 = "Van Gogh painting" image = pipeline(prompt=prompt, prompt_2=prompt_2).images[0] image ``` Dual text-encoders juga mendukung textual inversion embeddings yang perlu dimuat secara terpisah seperti dijelaskan dalam panduan [textual inversion](../../../using-diffusers/legacy_adapters#textual-inversion). ## Optimasi SDXL adalah model besar, dan Anda mungkin perlu mengoptimalkan memori agar dapat berjalan di perangkat keras Anda. Berikut adalah beberapa tips untuk menghemat memori dan mempercepat inferensi. 1. Offload model ke CPU dengan [enable_model_cpu_offload()](/docs/diffusers/v0.43.0/id/api/pipelines/overview#diffusers.DiffusionPipeline.enable_model_cpu_offload) untuk error out-of-memory: ```diff - base.to("cuda") # or "mps", "xpu", "cpu" - refiner.to("cuda") + base.enable_model_cpu_offload() + refiner.enable_model_cpu_offload() ``` 2. Gunakan `torch.compile` untuk percepatan ~20% (Anda membutuhkan `torch>=2.0`): ```diff + base.unet = torch.compile(base.unet, mode="reduce-overhead", fullgraph=True) + refiner.unet = torch.compile(refiner.unet, mode="reduce-overhead", fullgraph=True) ``` 3. Aktifkan [xFormers](../../../optimization/attention_backends) untuk menjalankan SDXL jika `torch<2.0`: ```diff + base.enable_xformers_memory_efficient_attention() + refiner.enable_xformers_memory_efficient_attention() ``` ## Sumber daya Jika Anda tertarik untuk bereksperimen dengan versi minimal dari [UNet2DConditionModel](/docs/diffusers/v0.43.0/id/api/models/unet2d-cond#diffusers.UNet2DConditionModel) yang digunakan dalam SDXL, lihatlah implementasi [minSDXL](https://github.com/cloneofsimo/minSDXL) yang ditulis dalam PyTorch dan langsung kompatibel dengan 🤗 Diffusers. ## StableDiffusionXLPipeline[[diffusers.StableDiffusionXLPipeline]] #### diffusers.StableDiffusionXLPipeline[[diffusers.StableDiffusionXLPipeline]] ```python diffusers.StableDiffusionXLPipeline(vae: AutoencoderKL, text_encoder: CLIPTextModel, text_encoder_2: CLIPTextModelWithProjection, tokenizer: CLIPTokenizer, tokenizer_2: CLIPTokenizer, unet: UNet2DConditionModel, scheduler: KarrasDiffusionSchedulers, image_encoder: CLIPVisionModelWithProjection = None, feature_extractor: CLIPImageProcessorPil = None, force_zeros_for_empty_prompt: bool = True, add_watermarker: bool | None = None) ``` [Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/stable_diffusion_xl/pipeline_stable_diffusion_xl.py#L170) **Parameter:** vae ([AutoencoderKL](/docs/diffusers/v0.43.0/id/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Model Variational Auto-Encoder (VAE) untuk mengodekan dan mendekodekan gambar ke dan dari representasi laten. text_encoder (`CLIPTextModel`) : Text-encoder yang dibekukan. Stable Diffusion XL menggunakan bagian teks dari [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), khususnya varian [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14). text_encoder_2 (` CLIPTextModelWithProjection`) : Text-encoder beku kedua. Stable Diffusion XL menggunakan bagian teks dan pool dari [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModelWithProjection), khususnya varian [laion/CLIP-ViT-bigG-14-laion2B-39B-b160k](https://huggingface.co/laion/CLIP-ViT-bigG-14-laion2B-39B-b160k). tokenizer (`CLIPTokenizer`) : Tokenizer dari kelas [CLIPTokenizer](https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.CLIPTokenizer). tokenizer_2 (`CLIPTokenizer`) : Tokenizer kedua dari kelas [CLIPTokenizer](https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.CLIPTokenizer). unet ([UNet2DConditionModel](/docs/diffusers/v0.43.0/id/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Arsitektur U-Net bersyarat untuk mendenoise latens gambar yang telah dikodekan. scheduler ([SchedulerMixin](/docs/diffusers/v0.43.0/id/api/schedulers/overview#diffusers.SchedulerMixin)) : Penjadwal yang digunakan bersama `unet` untuk menghilangkan noise pada latens gambar yang telah dikodekan. Bisa berupa [DDIMScheduler](/docs/diffusers/v0.43.0/id/api/schedulers/ddim#diffusers.DDIMScheduler), [LMSDiscreteScheduler](/docs/diffusers/v0.43.0/id/api/schedulers/lms_discrete#diffusers.LMSDiscreteScheduler), atau [PNDMScheduler](/docs/diffusers/v0.43.0/id/api/schedulers/pndm#diffusers.PNDMScheduler). force_zeros_for_empty_prompt (`bool`, *opsional*, defaultnya `"True"`) : Apakah embedding prompt negatif harus dipaksa selalu diatur ke 0. Lihat juga konfigurasi dari `stabilityai/stable-diffusion-xl-base-1-0`. add_watermarker (`bool`, *opsional*) : Apakah akan menggunakan [invisible_watermark library](https://github.com/ShieldMnt/invisible-watermark/) untuk memberi watermark pada gambar output. Jika tidak didefinisikan, nilainya akan default ke True jika paket tersebut terinstal, jika tidak, tidak akan ada watermarker yang digunakan. Pipeline untuk generasi teks-ke-gambar menggunakan Stable Diffusion XL. Model ini mewarisi dari [DiffusionPipeline](/docs/diffusers/v0.43.0/id/api/pipelines/overview#diffusers.DiffusionPipeline). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka untuk semua pipeline (seperti mengunduh atau menyimpan, menjalankan pada perangkat tertentu, dll.) Pipeline juga mewarisi metode pemuatan berikut: - [load_textual_inversion()](/docs/diffusers/v0.43.0/id/api/loaders/textual_inversion#diffusers.loaders.TextualInversionLoaderMixin.load_textual_inversion) untuk memuat embedding textual inversion - untuk memuat file `.ckpt` dengan [from_single_file()](/docs/diffusers/v0.43.0/id/api/loaders/single_file#diffusers.loaders.FromSingleFileMixin.from_single_file) - [load_lora_weights()](/docs/diffusers/v0.43.0/id/api/loaders/lora#diffusers.loaders.StableDiffusionXLLoraLoaderMixin.load_lora_weights) untuk memuat bobot LoRA - [save_lora_weights()](/docs/diffusers/v0.43.0/id/api/loaders/lora#diffusers.loaders.StableDiffusionXLLoraLoaderMixin.save_lora_weights) untuk menyimpan bobot LoRA - [load_ip_adapter()](/docs/diffusers/v0.43.0/id/api/loaders/ip_adapter#diffusers.loaders.IPAdapterMixin.load_ip_adapter) untuk memuat IP Adapter #### __call__[[diffusers.StableDiffusionXLPipeline.__call__]] ```python __call__(prompt: str | list[str] = None, prompt_2: str | list[str] | None = None, height: int | None = None, width: int | None = None, num_inference_steps: int = 50, timesteps: list[int] = None, sigmas: list[float] = None, denoising_end: float | None = None, guidance_scale: float = 5.0, negative_prompt: str | list[str] | None = None, negative_prompt_2: str | list[str] | None = None, num_images_per_prompt: int | None = 1, eta: float = 0.0, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, ip_adapter_image_embeds: list[torch.Tensor] | None = None, output_type: str | None = 'pil', return_dict: bool = True, cross_attention_kwargs: dict[str, typing.Any] | None = None, guidance_rescale: float = 0.0, original_size: tuple[int, int] | None = None, crops_coords_top_left: tuple[int, int] = (0, 0), target_size: tuple[int, int] | None = None, negative_original_size: tuple[int, int] | None = None, negative_crops_coords_top_left: tuple[int, int] = (0, 0), negative_target_size: tuple[int, int] | None = None, clip_skip: int | None = None, callback_on_step_end: typing.Union[typing.Callable[[int, int], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], **kwargs) ``` [Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/stable_diffusion_xl/pipeline_stable_diffusion_xl.py#L823) **Parameter:** prompt (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt untuk mengarahkan generasi gambar. Jika tidak didefinisikan, Anda harus melewatkan `prompt_embeds` sebagai gantinya. prompt_2 (`str` atau `list[str]`, *opsional*) : Prompt atau prompt yang akan dikirim ke `tokenizer_2` dan `text_encoder_2`. Jika tidak didefinisikan, `prompt` digunakan di kedua text-encoder height (`int`, *opsional*, defaultnya self.unet.config.sample_size * self.vae_scale_factor) : Tinggi gambar yang dihasilkan dalam piksel. Ini diatur ke 1024 secara default untuk hasil terbaik. Apa pun di bawah 512 piksel tidak akan berfungsi dengan baik untuk [stabilityai/stable-diffusion-xl-base-1.0](https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0) dan checkpoint yang tidak secara khusus dihaluskan pada resolusi rendah. width (`int`, *opsional*, defaultnya self.unet.config.sample_size * self.vae_scale_factor) : Lebar gambar yang dihasilkan dalam piksel. Ini diatur ke 1024 secara default untuk hasil terbaik. Apa pun di bawah 512 piksel tidak akan berfungsi dengan baik untuk [stabilityai/stable-diffusion-xl-base-1.0](https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0) dan checkpoint yang tidak secara khusus dihaluskan pada resolusi rendah. num_inference_steps (`int`, *opsional*, defaultnya 50) : Jumlah langkah denoising. Semakin banyak langkah denoising, biasanya menghasilkan gambar dengan kualitas lebih tinggi, namun dengan biaya inferensi yang lebih lambat. timesteps (`list[int]`, *opsional*) : Timesteps kustom untuk digunakan dalam proses denoising dengan scheduler yang mendukung argumen `timesteps` di metode `set_timesteps` mereka. Jika tidak didefinisikan, perilaku default saat `num_inference_steps` diteruskan akan digunakan. Harus dalam urutan menurun. sigmas (`list[float]`, *opsional*) : Sigmas kustom untuk digunakan dalam proses denoising dengan scheduler yang mendukung argumen `sigmas` di metode `set_timesteps` mereka. Jika tidak didefinisikan, perilaku default saat `num_inference_steps` diteruskan akan digunakan. denoising_end (`float`, *opsional*) : Jika ditentukan, menentukan fraksi (antara 0.0 dan 1.0) dari total proses denoising yang harus diselesaikan sebelum proses tersebut dihentikan secara dini secara sengaja. Akibatnya, sampel yang dikembalikan masih akan mempertahankan sejumlah besar noise, sebagaimana ditentukan oleh langkah-langkah diskrit yang dipilih oleh scheduler. Parameter denoising_end sebaiknya digunakan ketika pipeline ini merupakan bagian dari setup multi-pipeline "Mixture of Denoisers", seperti yang diuraikan dalam [**Refining the Image Output**](https://huggingface.co/docs/diffusers/api/pipelines/stable_diffusion/stable_diffusion_xl#refining-the-image-output) guidance_scale (`float`, *opsional*, default 5.0) : Skala panduan seperti yang didefinisikan dalam [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` didefinisikan sebagai `w` dari persamaan 2. pada [Imagen Paper](https://huggingface.co/papers/2205.11487). Skala panduan diaktifkan dengan mengatur `guidance_scale > 1`. Skala panduan yang lebih tinggi mendorong generasi gambar yang sangat terkait dengan `prompt` teks, biasanya dengan mengorbankan kualitas gambar yang lebih rendah. negative_prompt (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt yang tidak akan memandu generasi gambar. Jika tidak didefinisikan, Anda harus meneruskan `negative_prompt_embeds` sebagai gantinya. Diabaikan saat tidak menggunakan guidance (yaitu, diabaikan jika `guidance_scale` kurang dari `1`). negative_prompt_2 (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt yang tidak akan memandu generasi gambar untuk dikirim ke `tokenizer_2` dan `text_encoder_2`. Jika tidak didefinisikan, `negative_prompt` digunakan di kedua text-encoder num_images_per_prompt (`int`, *opsional*, default 1) : Jumlah gambar yang akan dihasilkan per prompt. eta (`float`, *opsional*, default 0.0) : Bersesuaian dengan parameter eta (η) dalam paper DDIM: https://huggingface.co/papers/2010.02502. Hanya berlaku untuk [schedulers.DDIMScheduler](/docs/diffusers/v0.43.0/id/api/schedulers/ddim#diffusers.DDIMScheduler), akan diabaikan untuk yang lain. generator (`torch.Generator` atau `list[torch.Generator]`, *opsional*) : Satu atau daftar [generator torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) untuk membuat proses generasi menjadi deterministik. latents (`torch.Tensor`, *opsional*) : Laten berisik yang telah dibuat sebelumnya, diambil dari distribusi Gaussian, untuk digunakan sebagai input untuk generasi gambar. Dapat digunakan untuk menyesuaikan generasi yang sama dengan prompt yang berbeda. Jika tidak disediakan, tensor laten akan dibuat dengan pengambilan sampel menggunakan `generator` acak yang diberikan. prompt_embeds (`torch.Tensor`, *opsional*) : Embedding teks yang sudah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, embedding teks akan dihasilkan dari argumen input `prompt`. negative_prompt_embeds (`torch.Tensor`, *opsional*) : Embedding teks negatif yang telah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, negative_prompt_embeds akan dibuat dari argumen input `negative_prompt`. pooled_prompt_embeds (`torch.Tensor`, *opsional*) : Pooled text embeddings yang telah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* pembobotan prompt. Jika tidak disediakan, pooled text embeddings akan dihasilkan dari argumen input `prompt`. negative_pooled_prompt_embeds (`torch.Tensor`, *opsional*) : Embedding teks negatif yang sudah dipooling sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, pooled negative_prompt_embeds akan dihasilkan dari argumen input `negative_prompt`. ip_adapter_image : (`PipelineImageInput`, *opsional*): Input gambar opsional untuk bekerja dengan IP Adapters. ip_adapter_image_embeds (`list[torch.Tensor]`, *opsional*) : Embedding gambar yang telah dibuat sebelumnya untuk IP-Adapter. Ini harus berupa daftar dengan panjang yang sama dengan jumlah IP-adapter. Setiap elemen harus berupa tensor dengan bentuk `(batch_size, num_images, emb_dim)`. Embedding gambar negatif harus disertakan jika `do_classifier_free_guidance` diatur ke `True`. Jika tidak disediakan, embedding dihitung dari argumen input `ip_adapter_image`. output_type (`str`, *opsional*, defaultnya `"pil"`) : Format output dari gambar yang dihasilkan. Pilih antara [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` atau `np.array`. return_dict (`bool`, *opsional*, defaultnya `True`) : Apakah akan mengembalikan `~pipelines.stable_diffusion_xl.StableDiffusionXLPipelineOutput` alih-alih tuple biasa. cross_attention_kwargs (`dict`, *opsional*) : Kamus kwargs yang jika ditentukan akan diteruskan ke `AttentionProcessor` seperti yang didefinisikan di bawah `self.processor` dalam [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). guidance_rescale (`float`, *opsional*, default 0.0) : Faktor rescale guidance yang diusulkan oleh [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://huggingface.co/papers/2305.08891) `guidance_scale` didefinisikan sebagai `φ` dalam persamaan 16. dari [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://huggingface.co/papers/2305.08891). Faktor rescale guidance harus memperbaiki overexposure saat menggunakan zero terminal SNR. original_size (`tuple[int]`, *opsional*, defaultnya (1024, 1024)) : Jika `original_size` tidak sama dengan `target_size`, gambar akan tampak di-downsample atau di-upsample. `original_size` defaultnya `(height, width)` jika tidak ditentukan. Bagian dari micro-conditioning SDXL seperti dijelaskan di bagian 2.2 dari [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). crops_coords_top_left (`tuple[int]`, *opsional*, defaultnya (0, 0)) : `crops_coords_top_left` dapat digunakan untuk menghasilkan gambar yang tampak "dipotong" dari posisi `crops_coords_top_left` ke bawah. Gambar yang bagus dan terpusat biasanya dicapai dengan mengatur `crops_coords_top_left` ke (0, 0). Bagian dari micro-conditioning SDXL seperti yang dijelaskan di bagian 2.2 dari [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). target_size (`tuple[int]`, *opsional*, defaultnya (1024, 1024)) : Untuk sebagian besar kasus, `target_size` sebaiknya diatur ke tinggi dan lebar yang diinginkan dari gambar yang dihasilkan. Jika tidak ditentukan, nilainya akan default ke `(height, width)`. Bagian dari micro-conditioning SDXL seperti yang dijelaskan di bagian 2.2 dari [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). negative_original_size (`tuple[int]`, *opsional*, defaultnya (1024, 1024)) : Untuk mengondisikan proses generasi secara negatif berdasarkan resolusi gambar tertentu. Bagian dari micro-conditioning SDXL seperti yang dijelaskan di bagian 2.2 dari [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). Untuk informasi lebih lanjut, lihat thread issue ini: https://github.com/huggingface/diffusers/issues/4208. negative_crops_coords_top_left (`tuple[int]`, *opsional*, defaultnya (0, 0)) : Untuk mengondisikan proses generasi secara negatif berdasarkan koordinat crop tertentu. Bagian dari micro-conditioning SDXL seperti yang dijelaskan di bagian 2.2 dari [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). Untuk informasi lebih lanjut, lihat thread issue ini: https://github.com/huggingface/diffusers/issues/4208. negative_target_size (`tuple[int]`, *opsional*, defaultnya (1024, 1024)) : Untuk mengondisikan proses generasi secara negatif berdasarkan resolusi gambar target. Sebaiknya sama dengan `target_size` untuk sebagian besar kasus. Bagian dari micro-conditioning SDXL seperti yang dijelaskan di bagian 2.2 dari [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). Untuk informasi lebih lanjut, lihat thread issue ini: https://github.com/huggingface/diffusers/issues/4208. clip_skip (`int`, *opsional*) : Jumlah lapisan yang akan dilewati dari CLIP saat menghitung prompt embeddings. Nilai 1 berarti bahwa output dari lapisan sebelum terakhir akan digunakan untuk menghitung prompt embeddings. callback_on_step_end (`Callable`, `PipelineCallback`, `MultiPipelineCallbacks`, *opsional*) : Fungsi atau subkelas dari `PipelineCallback` atau `MultiPipelineCallbacks` yang dipanggil di akhir setiap langkah denoising selama inferensi, dengan argumen berikut: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` akan berisi daftar semua tensor sesuai yang ditentukan oleh `callback_on_step_end_tensor_inputs`. callback_on_step_end_tensor_inputs (`list`, *opsional*) : Daftar input tensor untuk fungsi `callback_on_step_end`. Tensor yang ditentukan dalam daftar akan diteruskan sebagai argumen `callback_kwargs`. Anda hanya dapat menyertakan variabel yang tercantum dalam atribut `._callback_tensor_inputs` dari kelas pipeline Anda. **Mengembalikan:** `~pipelines.stable_diffusion_xl.StableDiffusionXLPipelineOutput` atau `tuple` `~pipelines.stable_diffusion_xl.StableDiffusionXLPipelineOutput` jika `return_dict` bernilai True, selain itu berupa `tuple`. Saat mengembalikan tuple, elemen pertama adalah daftar berisi gambar yang dihasilkan. Fungsi yang dipanggil saat memanggil pipeline untuk generasi. Contoh: ```py >>> import torch >>> from diffusers import StableDiffusionXLPipeline >>> pipe = StableDiffusionXLPipeline.from_pretrained( ... "stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float16 ... ) >>> pipe = pipe.to("cuda") >>> prompt = "a photo of an astronaut riding a horse on mars" >>> image = pipe(prompt).images[0] ``` #### encode_prompt[[diffusers.StableDiffusionXLPipeline.encode_prompt]] ```python encode_prompt(prompt: str, prompt_2: str | None = None, device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, do_classifier_free_guidance: bool = True, negative_prompt: str | None = None, negative_prompt_2: str | None = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, lora_scale: float | None = None, clip_skip: int | None = None) ``` [Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/stable_diffusion_xl/pipeline_stable_diffusion_xl.py#L283) **Parameter:** prompt (`str` atau `list[str]`, *opsional*) : prompt yang akan dienkod prompt_2 (`str` atau `list[str]`, *opsional*) : Prompt atau prompt yang akan dikirim ke `tokenizer_2` dan `text_encoder_2`. Jika tidak didefinisikan, `prompt` digunakan di kedua text-encoder device : (`torch.device`): perangkat torch num_images_per_prompt (`int`) : jumlah gambar yang harus dihasilkan per prompt do_classifier_free_guidance (`bool`) : apakah akan menggunakan classifier free guidance atau tidak negative_prompt (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt yang tidak akan memandu generasi gambar. Jika tidak didefinisikan, Anda harus meneruskan `negative_prompt_embeds` sebagai gantinya. Diabaikan saat tidak menggunakan guidance (yaitu, diabaikan jika `guidance_scale` kurang dari `1`). negative_prompt_2 (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt yang tidak akan memandu generasi gambar untuk dikirim ke `tokenizer_2` dan `text_encoder_2`. Jika tidak didefinisikan, `negative_prompt` digunakan di kedua text-encoder prompt_embeds (`torch.Tensor`, *opsional*) : Embedding teks yang sudah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, embedding teks akan dihasilkan dari argumen input `prompt`. negative_prompt_embeds (`torch.Tensor`, *opsional*) : Embedding teks negatif yang telah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, negative_prompt_embeds akan dibuat dari argumen input `negative_prompt`. pooled_prompt_embeds (`torch.Tensor`, *opsional*) : Pooled text embeddings yang telah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* pembobotan prompt. Jika tidak disediakan, pooled text embeddings akan dihasilkan dari argumen input `prompt`. negative_pooled_prompt_embeds (`torch.Tensor`, *opsional*) : Embedding teks negatif yang sudah dipooling sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, pooled negative_prompt_embeds akan dihasilkan dari argumen input `negative_prompt`. lora_scale (`float`, *opsional*) : Skala lora yang akan diterapkan ke semua lapisan LoRA dari text encoder jika lapisan LoRA dimuat. clip_skip (`int`, *opsional*) : Jumlah lapisan yang akan dilewati dari CLIP saat menghitung prompt embeddings. Nilai 1 berarti bahwa output dari lapisan sebelum terakhir akan digunakan untuk menghitung prompt embeddings. Mengkodekan prompt menjadi hidden states dari text encoder. #### get_guidance_scale_embedding[[diffusers.StableDiffusionXLPipeline.get_guidance_scale_embedding]] ```python get_guidance_scale_embedding(w: Tensor, embedding_dim: int = 512, dtype: dtype = torch.float32) ``` [Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/stable_diffusion_xl/pipeline_stable_diffusion_xl.py#L758) **Parameter:** w (`torch.Tensor`) : Menghasilkan vektor embedding dengan skala panduan yang ditentukan untuk selanjutnya memperkaya embedding timestep. embedding_dim (`int`, *opsional*, default 512) : Dimensi dari embedding yang akan dihasilkan. dtype (`torch.dtype`, *opsional*, defaultnya `torch.float32`) : Tipe data dari embedding yang dihasilkan. **Mengembalikan:** `torch.Tensor` Vektor embedding dengan bentuk `(len(w), embedding_dim)`. Lihat https://github.com/google-research/vdm/blob/dc27b98a554f65cdc654b800da5aa1846545d41b/model_vdm.py#L298 ## StableDiffusionXLImg2ImgPipeline[[diffusers.StableDiffusionXLImg2ImgPipeline]] #### diffusers.StableDiffusionXLImg2ImgPipeline[[diffusers.StableDiffusionXLImg2ImgPipeline]] ```python diffusers.StableDiffusionXLImg2ImgPipeline(vae: AutoencoderKL, text_encoder: CLIPTextModel, text_encoder_2: CLIPTextModelWithProjection, tokenizer: CLIPTokenizer, tokenizer_2: CLIPTokenizer, unet: UNet2DConditionModel, scheduler: KarrasDiffusionSchedulers, image_encoder: CLIPVisionModelWithProjection = None, feature_extractor: CLIPImageProcessorPil = None, requires_aesthetics_score: bool = False, force_zeros_for_empty_prompt: bool = True, add_watermarker: bool | None = None) ``` [Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/stable_diffusion_xl/pipeline_stable_diffusion_xl_img2img.py#L188) **Parameter:** vae ([AutoencoderKL](/docs/diffusers/v0.43.0/id/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Model Variational Auto-Encoder (VAE) untuk mengodekan dan mendekodekan gambar ke dan dari representasi laten. text_encoder (`CLIPTextModel`) : Text-encoder yang dibekukan. Stable Diffusion XL menggunakan bagian teks dari [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), khususnya varian [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14). text_encoder_2 (` CLIPTextModelWithProjection`) : Text-encoder beku kedua. Stable Diffusion XL menggunakan bagian teks dan pool dari [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModelWithProjection), khususnya varian [laion/CLIP-ViT-bigG-14-laion2B-39B-b160k](https://huggingface.co/laion/CLIP-ViT-bigG-14-laion2B-39B-b160k). tokenizer (`CLIPTokenizer`) : Tokenizer dari kelas [CLIPTokenizer](https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.CLIPTokenizer). tokenizer_2 (`CLIPTokenizer`) : Tokenizer kedua dari kelas [CLIPTokenizer](https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.CLIPTokenizer). unet ([UNet2DConditionModel](/docs/diffusers/v0.43.0/id/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Arsitektur U-Net bersyarat untuk mendenoise latens gambar yang telah dikodekan. scheduler ([SchedulerMixin](/docs/diffusers/v0.43.0/id/api/schedulers/overview#diffusers.SchedulerMixin)) : Penjadwal yang digunakan bersama `unet` untuk menghilangkan noise pada latens gambar yang telah dikodekan. Bisa berupa [DDIMScheduler](/docs/diffusers/v0.43.0/id/api/schedulers/ddim#diffusers.DDIMScheduler), [LMSDiscreteScheduler](/docs/diffusers/v0.43.0/id/api/schedulers/lms_discrete#diffusers.LMSDiscreteScheduler), atau [PNDMScheduler](/docs/diffusers/v0.43.0/id/api/schedulers/pndm#diffusers.PNDMScheduler). requires_aesthetics_score (`bool`, *opsional*, defaultnya `"False"`) : Apakah `unet` memerlukan kondisi `aesthetic_score` untuk diteruskan selama inferensi. Lihat juga konfigurasi dari `stabilityai/stable-diffusion-xl-refiner-1-0`. force_zeros_for_empty_prompt (`bool`, *opsional*, defaultnya `"True"`) : Apakah embedding prompt negatif harus dipaksa selalu diatur ke 0. Lihat juga konfigurasi dari `stabilityai/stable-diffusion-xl-base-1-0`. add_watermarker (`bool`, *opsional*) : Apakah akan menggunakan [invisible_watermark library](https://github.com/ShieldMnt/invisible-watermark/) untuk memberi watermark pada gambar output. Jika tidak didefinisikan, nilainya akan default ke True jika paket tersebut terinstal, jika tidak, tidak akan ada watermarker yang digunakan. Pipeline untuk generasi teks-ke-gambar menggunakan Stable Diffusion XL. Model ini mewarisi dari [DiffusionPipeline](/docs/diffusers/v0.43.0/id/api/pipelines/overview#diffusers.DiffusionPipeline). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka untuk semua pipeline (seperti mengunduh atau menyimpan, menjalankan pada perangkat tertentu, dll.) Pipeline juga mewarisi metode pemuatan berikut: - [load_textual_inversion()](/docs/diffusers/v0.43.0/id/api/loaders/textual_inversion#diffusers.loaders.TextualInversionLoaderMixin.load_textual_inversion) untuk memuat embedding textual inversion - untuk memuat file `.ckpt` dengan [from_single_file()](/docs/diffusers/v0.43.0/id/api/loaders/single_file#diffusers.loaders.FromSingleFileMixin.from_single_file) - [load_lora_weights()](/docs/diffusers/v0.43.0/id/api/loaders/lora#diffusers.loaders.StableDiffusionXLLoraLoaderMixin.load_lora_weights) untuk memuat bobot LoRA - [save_lora_weights()](/docs/diffusers/v0.43.0/id/api/loaders/lora#diffusers.loaders.StableDiffusionXLLoraLoaderMixin.save_lora_weights) untuk menyimpan bobot LoRA - [load_ip_adapter()](/docs/diffusers/v0.43.0/id/api/loaders/ip_adapter#diffusers.loaders.IPAdapterMixin.load_ip_adapter) untuk memuat IP Adapter #### __call__[[diffusers.StableDiffusionXLImg2ImgPipeline.__call__]] ```python __call__(prompt: str | list[str] = None, prompt_2: str | list[str] | None = None, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, strength: float = 0.3, num_inference_steps: int = 50, timesteps: list[int] = None, sigmas: list[float] = None, denoising_start: float | None = None, denoising_end: float | None = None, guidance_scale: float = 5.0, negative_prompt: str | list[str] | None = None, negative_prompt_2: str | list[str] | None = None, num_images_per_prompt: int | None = 1, eta: float = 0.0, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, ip_adapter_image_embeds: list[torch.Tensor] | None = None, output_type: str | None = 'pil', return_dict: bool = True, cross_attention_kwargs: dict[str, typing.Any] | None = None, guidance_rescale: float = 0.0, original_size: tuple[int, int] = None, crops_coords_top_left: tuple[int, int] = (0, 0), target_size: tuple[int, int] = None, negative_original_size: tuple[int, int] | None = None, negative_crops_coords_top_left: tuple[int, int] = (0, 0), negative_target_size: tuple[int, int] | None = None, aesthetic_score: float = 6.0, negative_aesthetic_score: float = 2.5, clip_skip: int | None = None, callback_on_step_end: typing.Union[typing.Callable[[int, int], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], **kwargs) ``` [Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/stable_diffusion_xl/pipeline_stable_diffusion_xl_img2img.py#L975) **Parameter:** prompt (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt untuk mengarahkan generasi gambar. Jika tidak didefinisikan, Anda harus melewatkan `prompt_embeds` sebagai gantinya. prompt_2 (`str` atau `list[str]`, *opsional*) : Prompt atau prompt yang akan dikirim ke `tokenizer_2` dan `text_encoder_2`. Jika tidak didefinisikan, `prompt` digunakan di kedua text-encoder image (`torch.Tensor` atau `PIL.Image.Image` atau `np.ndarray` atau `list[torch.Tensor]` atau `list[PIL.Image.Image]` atau `list[np.ndarray]`) : Gambar yang akan dimodifikasi dengan pipeline. strength (`float`, *opsional*, default 0.3) : Secara konseptual, menunjukkan seberapa besar transformasi pada `image` referensi. Harus berada di antara 0 dan 1. `image` akan digunakan sebagai titik awal, dengan penambahan noise yang semakin besar seiring meningkatnya `strength`. Jumlah langkah denoising bergantung pada jumlah noise yang awalnya ditambahkan. Ketika `strength` bernilai 1, noise yang ditambahkan akan maksimal dan proses denoising akan berjalan untuk jumlah iterasi penuh yang ditentukan dalam `num_inference_steps`. Dengan demikian, nilai 1 pada dasarnya mengabaikan `image`. Perhatikan bahwa jika `denoising_start` dideklarasikan sebagai bilangan bulat, nilai `strength` akan diabaikan. num_inference_steps (`int`, *opsional*, defaultnya 50) : Jumlah langkah denoising. Semakin banyak langkah denoising, biasanya menghasilkan gambar dengan kualitas lebih tinggi, namun dengan biaya inferensi yang lebih lambat. timesteps (`list[int]`, *opsional*) : Timesteps kustom untuk digunakan dalam proses denoising dengan scheduler yang mendukung argumen `timesteps` di metode `set_timesteps` mereka. Jika tidak didefinisikan, perilaku default saat `num_inference_steps` diteruskan akan digunakan. Harus dalam urutan menurun. sigmas (`list[float]`, *opsional*) : Sigmas kustom untuk digunakan dalam proses denoising dengan scheduler yang mendukung argumen `sigmas` di metode `set_timesteps` mereka. Jika tidak didefinisikan, perilaku default saat `num_inference_steps` diteruskan akan digunakan. denoising_start (`float`, *opsional*) : Jika ditentukan, menunjukkan fraksi (antara 0.0 dan 1.0) dari total proses denoising yang akan dilewati sebelum proses dimulai. Akibatnya, bagian awal dari proses denoising diabaikan dan diasumsikan bahwa `image` yang diberikan adalah gambar yang telah didenoi sebagian. Perhatikan bahwa ketika ini ditentukan, strength akan diabaikan. Parameter `denoising_start` sangat bermanfaat ketika pipeline ini diintegrasikan ke dalam setup multi-pipeline "Mixture of Denoisers", seperti yang dijelaskan dalam [**Refine Image Quality**](https://huggingface.co/docs/diffusers/using-diffusers/sdxl#refine-image-quality). denoising_end (`float`, *opsional*) : Jika ditentukan, menentukan fraksi (antara 0.0 dan 1.0) dari total proses denoising yang harus diselesaikan sebelum proses tersebut dihentikan secara dini secara sengaja. Akibatnya, sampel yang dikembalikan masih akan mempertahankan sejumlah besar noise (sekitar 20% akhir dari timestep masih diperlukan) dan harus didenoise oleh pipeline penerus yang memiliki `denoising_start` diatur ke 0.8 agar hanya mendenoise 20% akhir dari scheduler. Parameter denoising_end sebaiknya digunakan ketika pipeline ini merupakan bagian dari setup multi-pipeline "Mixture of Denoisers", seperti yang diuraikan dalam [**Refine Image Quality**](https://huggingface.co/docs/diffusers/using-diffusers/sdxl#refine-image-quality). guidance_scale (`float`, *opsional*, default 7.5) : Skala panduan seperti yang didefinisikan dalam [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` didefinisikan sebagai `w` dari persamaan 2. pada [Imagen Paper](https://huggingface.co/papers/2205.11487). Skala panduan diaktifkan dengan mengatur `guidance_scale > 1`. Skala panduan yang lebih tinggi mendorong generasi gambar yang sangat terkait dengan `prompt` teks, biasanya dengan mengorbankan kualitas gambar yang lebih rendah. negative_prompt (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt yang tidak akan memandu generasi gambar. Jika tidak didefinisikan, Anda harus meneruskan `negative_prompt_embeds` sebagai gantinya. Diabaikan saat tidak menggunakan guidance (yaitu, diabaikan jika `guidance_scale` kurang dari `1`). negative_prompt_2 (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt yang tidak akan memandu generasi gambar untuk dikirim ke `tokenizer_2` dan `text_encoder_2`. Jika tidak didefinisikan, `negative_prompt` digunakan di kedua text-encoder num_images_per_prompt (`int`, *opsional*, default 1) : Jumlah gambar yang akan dihasilkan per prompt. eta (`float`, *opsional*, default 0.0) : Bersesuaian dengan parameter eta (η) dalam paper DDIM: https://huggingface.co/papers/2010.02502. Hanya berlaku untuk [schedulers.DDIMScheduler](/docs/diffusers/v0.43.0/id/api/schedulers/ddim#diffusers.DDIMScheduler), akan diabaikan untuk yang lain. generator (`torch.Generator` atau `list[torch.Generator]`, *opsional*) : Satu atau daftar [generator torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) untuk membuat proses generasi menjadi deterministik. latents (`torch.Tensor`, *opsional*) : Laten berisik yang telah dibuat sebelumnya, diambil dari distribusi Gaussian, untuk digunakan sebagai input untuk generasi gambar. Dapat digunakan untuk menyesuaikan generasi yang sama dengan prompt yang berbeda. Jika tidak disediakan, tensor laten akan dibuat dengan pengambilan sampel menggunakan `generator` acak yang diberikan. prompt_embeds (`torch.Tensor`, *opsional*) : Embedding teks yang sudah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, embedding teks akan dihasilkan dari argumen input `prompt`. negative_prompt_embeds (`torch.Tensor`, *opsional*) : Embedding teks negatif yang telah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, negative_prompt_embeds akan dibuat dari argumen input `negative_prompt`. pooled_prompt_embeds (`torch.Tensor`, *opsional*) : Pooled text embeddings yang telah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* pembobotan prompt. Jika tidak disediakan, pooled text embeddings akan dihasilkan dari argumen input `prompt`. negative_pooled_prompt_embeds (`torch.Tensor`, *opsional*) : Embedding teks negatif yang sudah dipooling sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, pooled negative_prompt_embeds akan dihasilkan dari argumen input `negative_prompt`. ip_adapter_image : (`PipelineImageInput`, *opsional*): Input gambar opsional untuk bekerja dengan IP Adapters. ip_adapter_image_embeds (`list[torch.Tensor]`, *opsional*) : Embedding gambar yang telah dibuat sebelumnya untuk IP-Adapter. Ini harus berupa daftar dengan panjang yang sama dengan jumlah IP-adapter. Setiap elemen harus berupa tensor dengan bentuk `(batch_size, num_images, emb_dim)`. Embedding gambar negatif harus disertakan jika `do_classifier_free_guidance` diatur ke `True`. Jika tidak disediakan, embedding dihitung dari argumen input `ip_adapter_image`. output_type (`str`, *opsional*, defaultnya `"pil"`) : Format output dari gambar yang dihasilkan. Pilih antara [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` atau `np.array`. return_dict (`bool`, *opsional*, defaultnya `True`) : Apakah akan mengembalikan `~pipelines.stable_diffusion.StableDiffusionXLPipelineOutput` alih-alih tuple biasa. cross_attention_kwargs (`dict`, *opsional*) : Kamus kwargs yang jika ditentukan akan diteruskan ke `AttentionProcessor` seperti yang didefinisikan di bawah `self.processor` dalam [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). guidance_rescale (`float`, *opsional*, default 0.0) : Faktor rescale guidance yang diusulkan oleh [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://huggingface.co/papers/2305.08891) `guidance_scale` didefinisikan sebagai `φ` dalam persamaan 16. dari [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://huggingface.co/papers/2305.08891). Faktor rescale guidance harus memperbaiki overexposure saat menggunakan zero terminal SNR. original_size (`tuple[int]`, *opsional*, defaultnya (1024, 1024)) : Jika `original_size` tidak sama dengan `target_size`, gambar akan tampak di-downsample atau di-upsample. `original_size` defaultnya `(height, width)` jika tidak ditentukan. Bagian dari micro-conditioning SDXL seperti dijelaskan di bagian 2.2 dari [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). crops_coords_top_left (`tuple[int]`, *opsional*, defaultnya (0, 0)) : `crops_coords_top_left` dapat digunakan untuk menghasilkan gambar yang tampak "dipotong" dari posisi `crops_coords_top_left` ke bawah. Gambar yang bagus dan terpusat biasanya dicapai dengan mengatur `crops_coords_top_left` ke (0, 0). Bagian dari micro-conditioning SDXL seperti yang dijelaskan di bagian 2.2 dari [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). target_size (`tuple[int]`, *opsional*, defaultnya (1024, 1024)) : Untuk sebagian besar kasus, `target_size` sebaiknya diatur ke tinggi dan lebar yang diinginkan dari gambar yang dihasilkan. Jika tidak ditentukan, nilainya akan default ke `(height, width)`. Bagian dari micro-conditioning SDXL seperti yang dijelaskan di bagian 2.2 dari [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). negative_original_size (`tuple[int]`, *opsional*, defaultnya (1024, 1024)) : Untuk mengondisikan proses generasi secara negatif berdasarkan resolusi gambar tertentu. Bagian dari micro-conditioning SDXL seperti yang dijelaskan di bagian 2.2 dari [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). Untuk informasi lebih lanjut, lihat thread issue ini: https://github.com/huggingface/diffusers/issues/4208. negative_crops_coords_top_left (`tuple[int]`, *opsional*, defaultnya (0, 0)) : Untuk mengondisikan proses generasi secara negatif berdasarkan koordinat crop tertentu. Bagian dari micro-conditioning SDXL seperti yang dijelaskan di bagian 2.2 dari [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). Untuk informasi lebih lanjut, lihat thread issue ini: https://github.com/huggingface/diffusers/issues/4208. negative_target_size (`tuple[int]`, *opsional*, defaultnya (1024, 1024)) : Untuk mengondisikan proses generasi secara negatif berdasarkan resolusi gambar target. Sebaiknya sama dengan `target_size` untuk sebagian besar kasus. Bagian dari micro-conditioning SDXL seperti yang dijelaskan di bagian 2.2 dari [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). Untuk informasi lebih lanjut, lihat thread issue ini: https://github.com/huggingface/diffusers/issues/4208. aesthetic_score (`float`, *opsional*, default 6.0) : Digunakan untuk mensimulasikan skor estetika dari gambar yang dihasilkan dengan memengaruhi kondisi teks positif. Bagian dari micro-conditioning SDXL seperti yang dijelaskan di bagian 2.2 dari [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). negative_aesthetic_score (`float`, *opsional*, default 2.5) : Bagian dari micro-conditioning SDXL seperti dijelaskan di bagian 2.2 dari [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). Dapat digunakan untuk mensimulasikan skor estetika dari gambar yang dihasilkan dengan memengaruhi kondisi teks negatif. clip_skip (`int`, *opsional*) : Jumlah lapisan yang akan dilewati dari CLIP saat menghitung prompt embeddings. Nilai 1 berarti bahwa output dari lapisan sebelum terakhir akan digunakan untuk menghitung prompt embeddings. callback_on_step_end (`Callable`, `PipelineCallback`, `MultiPipelineCallbacks`, *opsional*) : Fungsi atau subkelas dari `PipelineCallback` atau `MultiPipelineCallbacks` yang dipanggil di akhir setiap langkah denoising selama inferensi, dengan argumen berikut: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` akan berisi daftar semua tensor sesuai yang ditentukan oleh `callback_on_step_end_tensor_inputs`. callback_on_step_end_tensor_inputs (`list`, *opsional*) : Daftar input tensor untuk fungsi `callback_on_step_end`. Tensor yang ditentukan dalam daftar akan diteruskan sebagai argumen `callback_kwargs`. Anda hanya dapat menyertakan variabel yang tercantum dalam atribut `._callback_tensor_inputs` dari kelas pipeline Anda. **Mengembalikan:** `~pipelines.stable_diffusion.StableDiffusionXLPipelineOutput` atau `tuple` `~pipelines.stable_diffusion.StableDiffusionXLPipelineOutput` jika `return_dict` bernilai True, selain itu berupa `tuple. Saat mengembalikan tuple, elemen pertama adalah daftar berisi gambar yang dihasilkan. Fungsi yang dipanggil saat memanggil pipeline untuk generasi. Contoh: ```py >>> import torch >>> from diffusers import StableDiffusionXLImg2ImgPipeline >>> from diffusers.utils import load_image >>> pipe = StableDiffusionXLImg2ImgPipeline.from_pretrained( ... "stabilityai/stable-diffusion-xl-refiner-1.0", torch_dtype=torch.float16 ... ) >>> pipe = pipe.to("cuda") >>> url = "https://huggingface.co/datasets/patrickvonplaten/images/resolve/main/aa_xl/000000009.png" >>> init_image = load_image(url).convert("RGB") >>> prompt = "a photo of an astronaut riding a horse on mars" >>> image = pipe(prompt, image=init_image).images[0] ``` #### encode_prompt[[diffusers.StableDiffusionXLImg2ImgPipeline.encode_prompt]] ```python encode_prompt(prompt: str, prompt_2: str | None = None, device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, do_classifier_free_guidance: bool = True, negative_prompt: str | None = None, negative_prompt_2: str | None = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, lora_scale: float | None = None, clip_skip: int | None = None) ``` [Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/stable_diffusion_xl/pipeline_stable_diffusion_xl_img2img.py#L301) **Parameter:** prompt (`str` atau `list[str]`, *opsional*) : prompt yang akan dienkod prompt_2 (`str` atau `list[str]`, *opsional*) : Prompt atau prompt yang akan dikirim ke `tokenizer_2` dan `text_encoder_2`. Jika tidak didefinisikan, `prompt` digunakan di kedua text-encoder device : (`torch.device`): perangkat torch num_images_per_prompt (`int`) : jumlah gambar yang harus dihasilkan per prompt do_classifier_free_guidance (`bool`) : apakah akan menggunakan classifier free guidance atau tidak negative_prompt (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt yang tidak akan memandu generasi gambar. Jika tidak didefinisikan, Anda harus meneruskan `negative_prompt_embeds` sebagai gantinya. Diabaikan saat tidak menggunakan guidance (yaitu, diabaikan jika `guidance_scale` kurang dari `1`). negative_prompt_2 (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt yang tidak akan memandu generasi gambar untuk dikirim ke `tokenizer_2` dan `text_encoder_2`. Jika tidak didefinisikan, `negative_prompt` digunakan di kedua text-encoder prompt_embeds (`torch.Tensor`, *opsional*) : Embedding teks yang sudah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, embedding teks akan dihasilkan dari argumen input `prompt`. negative_prompt_embeds (`torch.Tensor`, *opsional*) : Embedding teks negatif yang telah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, negative_prompt_embeds akan dibuat dari argumen input `negative_prompt`. pooled_prompt_embeds (`torch.Tensor`, *opsional*) : Pooled text embeddings yang telah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* pembobotan prompt. Jika tidak disediakan, pooled text embeddings akan dihasilkan dari argumen input `prompt`. negative_pooled_prompt_embeds (`torch.Tensor`, *opsional*) : Embedding teks negatif yang sudah dipooling sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, pooled negative_prompt_embeds akan dihasilkan dari argumen input `negative_prompt`. lora_scale (`float`, *opsional*) : Skala lora yang akan diterapkan ke semua lapisan LoRA dari text encoder jika lapisan LoRA dimuat. clip_skip (`int`, *opsional*) : Jumlah lapisan yang akan dilewati dari CLIP saat menghitung prompt embeddings. Nilai 1 berarti bahwa output dari lapisan sebelum terakhir akan digunakan untuk menghitung prompt embeddings. Mengkodekan prompt menjadi hidden states dari text encoder. #### get_guidance_scale_embedding[[diffusers.StableDiffusionXLImg2ImgPipeline.get_guidance_scale_embedding]] ```python get_guidance_scale_embedding(w: Tensor, embedding_dim: int = 512, dtype: dtype = torch.float32) ``` [Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/stable_diffusion_xl/pipeline_stable_diffusion_xl_img2img.py#L906) **Parameter:** w (`torch.Tensor`) : Menghasilkan vektor embedding dengan skala panduan yang ditentukan untuk selanjutnya memperkaya embedding timestep. embedding_dim (`int`, *opsional*, default 512) : Dimensi dari embedding yang akan dihasilkan. dtype (`torch.dtype`, *opsional*, defaultnya `torch.float32`) : Tipe data dari embedding yang dihasilkan. **Mengembalikan:** `torch.Tensor` Vektor embedding dengan bentuk `(len(w), embedding_dim)`. Lihat https://github.com/google-research/vdm/blob/dc27b98a554f65cdc654b800da5aa1846545d41b/model_vdm.py#L298 ## StableDiffusionXLInpaintPipeline[[diffusers.StableDiffusionXLInpaintPipeline]] #### diffusers.StableDiffusionXLInpaintPipeline[[diffusers.StableDiffusionXLInpaintPipeline]] ```python diffusers.StableDiffusionXLInpaintPipeline(vae: AutoencoderKL, text_encoder: CLIPTextModel, text_encoder_2: CLIPTextModelWithProjection, tokenizer: CLIPTokenizer, tokenizer_2: CLIPTokenizer, unet: UNet2DConditionModel, scheduler: KarrasDiffusionSchedulers, image_encoder: CLIPVisionModelWithProjection = None, feature_extractor: CLIPImageProcessorPil = None, requires_aesthetics_score: bool = False, force_zeros_for_empty_prompt: bool = True, add_watermarker: bool | None = None) ``` [Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/stable_diffusion_xl/pipeline_stable_diffusion_xl_inpaint.py#L215) **Parameter:** vae ([AutoencoderKL](/docs/diffusers/v0.43.0/id/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Model Variational Auto-Encoder (VAE) untuk mengodekan dan mendekodekan gambar ke dan dari representasi laten. text_encoder (`CLIPTextModel`) : Text-encoder yang dibekukan. Stable Diffusion XL menggunakan bagian teks dari [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), khususnya varian [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14). text_encoder_2 (` CLIPTextModelWithProjection`) : Text-encoder beku kedua. Stable Diffusion XL menggunakan bagian teks dan pool dari [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModelWithProjection), khususnya varian [laion/CLIP-ViT-bigG-14-laion2B-39B-b160k](https://huggingface.co/laion/CLIP-ViT-bigG-14-laion2B-39B-b160k). tokenizer (`CLIPTokenizer`) : Tokenizer dari kelas [CLIPTokenizer](https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.CLIPTokenizer). tokenizer_2 (`CLIPTokenizer`) : Tokenizer kedua dari kelas [CLIPTokenizer](https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.CLIPTokenizer). unet ([UNet2DConditionModel](/docs/diffusers/v0.43.0/id/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Arsitektur U-Net bersyarat untuk mendenoise latens gambar yang telah dikodekan. scheduler ([SchedulerMixin](/docs/diffusers/v0.43.0/id/api/schedulers/overview#diffusers.SchedulerMixin)) : Penjadwal yang digunakan bersama `unet` untuk menghilangkan noise pada latens gambar yang telah dikodekan. Bisa berupa [DDIMScheduler](/docs/diffusers/v0.43.0/id/api/schedulers/ddim#diffusers.DDIMScheduler), [LMSDiscreteScheduler](/docs/diffusers/v0.43.0/id/api/schedulers/lms_discrete#diffusers.LMSDiscreteScheduler), atau [PNDMScheduler](/docs/diffusers/v0.43.0/id/api/schedulers/pndm#diffusers.PNDMScheduler). requires_aesthetics_score (`bool`, *opsional*, defaultnya `"False"`) : Apakah `unet` memerlukan kondisi aesthetic_score untuk diteruskan selama inferensi. Lihat juga konfigurasi dari `stabilityai/stable-diffusion-xl-refiner-1-0`. force_zeros_for_empty_prompt (`bool`, *opsional*, defaultnya `"True"`) : Apakah embedding prompt negatif harus dipaksa selalu diatur ke 0. Lihat juga konfigurasi dari `stabilityai/stable-diffusion-xl-base-1-0`. add_watermarker (`bool`, *opsional*) : Apakah akan menggunakan [invisible_watermark library](https://github.com/ShieldMnt/invisible-watermark/) untuk memberi watermark pada gambar output. Jika tidak didefinisikan, nilainya akan default ke True jika paket tersebut terinstal, jika tidak, tidak akan ada watermarker yang digunakan. Pipeline untuk generasi teks-ke-gambar menggunakan Stable Diffusion XL. Model ini mewarisi dari [DiffusionPipeline](/docs/diffusers/v0.43.0/id/api/pipelines/overview#diffusers.DiffusionPipeline). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka untuk semua pipeline (seperti mengunduh atau menyimpan, menjalankan pada perangkat tertentu, dll.) Pipeline juga mewarisi metode pemuatan berikut: - [load_textual_inversion()](/docs/diffusers/v0.43.0/id/api/loaders/textual_inversion#diffusers.loaders.TextualInversionLoaderMixin.load_textual_inversion) untuk memuat embedding textual inversion - untuk memuat file `.ckpt` dengan [from_single_file()](/docs/diffusers/v0.43.0/id/api/loaders/single_file#diffusers.loaders.FromSingleFileMixin.from_single_file) - [load_lora_weights()](/docs/diffusers/v0.43.0/id/api/loaders/lora#diffusers.loaders.StableDiffusionXLLoraLoaderMixin.load_lora_weights) untuk memuat bobot LoRA - [save_lora_weights()](/docs/diffusers/v0.43.0/id/api/loaders/lora#diffusers.loaders.StableDiffusionXLLoraLoaderMixin.save_lora_weights) untuk menyimpan bobot LoRA - [load_ip_adapter()](/docs/diffusers/v0.43.0/id/api/loaders/ip_adapter#diffusers.loaders.IPAdapterMixin.load_ip_adapter) untuk memuat IP Adapter #### __call__[[diffusers.StableDiffusionXLInpaintPipeline.__call__]] ```python __call__(prompt: str | list[str] = None, prompt_2: str | list[str] | None = None, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, mask_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, masked_image_latents: Tensor = None, height: int | None = None, width: int | None = None, padding_mask_crop: int | None = None, strength: float = 0.9999, num_inference_steps: int = 50, timesteps: list[int] = None, sigmas: list[float] = None, denoising_start: float | None = None, denoising_end: float | None = None, guidance_scale: float = 7.5, negative_prompt: str | list[str] | None = None, negative_prompt_2: str | list[str] | None = None, num_images_per_prompt: int | None = 1, eta: float = 0.0, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, ip_adapter_image_embeds: list[torch.Tensor] | None = None, output_type: str | None = 'pil', return_dict: bool = True, cross_attention_kwargs: dict[str, typing.Any] | None = None, guidance_rescale: float = 0.0, original_size: tuple[int, int] = None, crops_coords_top_left: tuple[int, int] = (0, 0), target_size: tuple[int, int] = None, negative_original_size: tuple[int, int] | None = None, negative_crops_coords_top_left: tuple[int, int] = (0, 0), negative_target_size: tuple[int, int] | None = None, aesthetic_score: float = 6.0, negative_aesthetic_score: float = 2.5, clip_skip: int | None = None, callback_on_step_end: typing.Union[typing.Callable[[int, int], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], **kwargs) ``` [Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/stable_diffusion_xl/pipeline_stable_diffusion_xl_inpaint.py#L1080) **Parameter:** prompt (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt untuk mengarahkan generasi gambar. Jika tidak didefinisikan, Anda harus melewatkan `prompt_embeds` sebagai gantinya. prompt_2 (`str` atau `list[str]`, *opsional*) : Prompt atau prompt yang akan dikirim ke `tokenizer_2` dan `text_encoder_2`. Jika tidak didefinisikan, `prompt` digunakan di kedua text-encoder image (`PIL.Image.Image`) : `Image`, atau tensor yang mewakili batch gambar yang akan di-inpaint, *yaitu* bagian dari gambar akan dimask dengan `mask_image` dan dilukis ulang sesuai dengan `prompt`. mask_image (`PIL.Image.Image`) : `Image`, atau tensor yang mewakili batch gambar, untuk memasker `image`. Piksel putih pada mask akan diwarnai ulang, sedangkan piksel hitam akan dipertahankan. Jika `mask_image` adalah gambar PIL, gambar tersebut akan dikonversi menjadi satu saluran (luminance) sebelum digunakan. Jika berupa tensor, tensor tersebut harus berisi satu saluran warna (L) alih-alih 3, sehingga bentuk yang diharapkan adalah `(B, H, W, 1)`. masked_image_latents (`torch.Tensor`, *opsional*) : Laten terenkod praproses dari gambar yang dimasker (untuk inpainting). height (`int`, *opsional*, defaultnya self.unet.config.sample_size * self.vae_scale_factor) : Tinggi gambar yang dihasilkan dalam piksel. Ini diatur ke 1024 secara default untuk hasil terbaik. Apa pun di bawah 512 piksel tidak akan berfungsi dengan baik untuk [stabilityai/stable-diffusion-xl-base-1.0](https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0) dan checkpoint yang tidak secara khusus dihaluskan pada resolusi rendah. width (`int`, *opsional*, defaultnya self.unet.config.sample_size * self.vae_scale_factor) : Lebar gambar yang dihasilkan dalam piksel. Ini diatur ke 1024 secara default untuk hasil terbaik. Apa pun di bawah 512 piksel tidak akan berfungsi dengan baik untuk [stabilityai/stable-diffusion-xl-base-1.0](https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0) dan checkpoint yang tidak secara khusus dihaluskan pada resolusi rendah. padding_mask_crop (`int`, *opsional*, defaultnya `None`) : Ukuran margin pada crop yang akan diterapkan ke gambar dan masking. Jika `None`, tidak ada crop yang diterapkan ke image dan mask_image. Jika `padding_mask_crop` bukan `None`, sistem akan terlebih dahulu menemukan area persegi panjang dengan rasio aspek yang sama dengan gambar dan mencakup semua area yang di-mask, kemudian memperluas area tersebut berdasarkan `padding_mask_crop`. Gambar dan mask_image kemudian akan di-crop berdasarkan area yang telah diperluas sebelum di-resize ke ukuran gambar asli untuk inpainting. Hal ini berguna ketika area yang di-mask kecil sementara gambarnya besar dan mengandung informasi yang tidak relevan untuk inpainting, seperti latar belakang. strength (`float`, *opsional*, default 0.9999) : Secara konseptual, menunjukkan seberapa besar transformasi pada bagian yang dimasker dari `image` referensi. Nilai harus berada di antara 0 dan 1. `image` akan digunakan sebagai titik awal, dengan penambahan noise yang semakin besar seiring meningkatnya `strength`. Jumlah langkah denoising bergantung pada jumlah noise yang ditambahkan di awal. Ketika `strength` bernilai 1, noise yang ditambahkan akan maksimal dan proses denoising akan berjalan untuk jumlah iterasi penuh yang ditentukan dalam `num_inference_steps`. Dengan demikian, nilai 1 pada dasarnya mengabaikan bagian yang dimasker dari `image` referensi. Perhatikan bahwa jika `denoising_start` dideklarasikan sebagai bilangan bulat, nilai `strength` akan diabaikan. num_inference_steps (`int`, *opsional*, defaultnya 50) : Jumlah langkah denoising. Semakin banyak langkah denoising, biasanya menghasilkan gambar dengan kualitas lebih tinggi, namun dengan biaya inferensi yang lebih lambat. timesteps (`list[int]`, *opsional*) : Timesteps kustom untuk digunakan dalam proses denoising dengan scheduler yang mendukung argumen `timesteps` di metode `set_timesteps` mereka. Jika tidak didefinisikan, perilaku default saat `num_inference_steps` diteruskan akan digunakan. Harus dalam urutan menurun. sigmas (`list[float]`, *opsional*) : Sigmas kustom untuk digunakan dalam proses denoising dengan scheduler yang mendukung argumen `sigmas` di metode `set_timesteps` mereka. Jika tidak didefinisikan, perilaku default saat `num_inference_steps` diteruskan akan digunakan. denoising_start (`float`, *opsional*) : Jika ditentukan, menunjukkan fraksi (antara 0.0 dan 1.0) dari total proses denoising yang akan dilewati sebelum proses dimulai. Akibatnya, bagian awal dari proses denoising diabaikan dan diasumsikan bahwa `image` yang diberikan adalah gambar yang telah didenoi sebagian. Perhatikan bahwa ketika ini ditentukan, strength akan diabaikan. Parameter `denoising_start` sangat bermanfaat ketika pipeline ini diintegrasikan ke dalam setup multi-pipeline "Mixture of Denoisers", seperti yang dijelaskan dalam [**Refining the Image Output**](https://huggingface.co/docs/diffusers/api/pipelines/stable_diffusion/stable_diffusion_xl#refining-the-image-output). denoising_end (`float`, *opsional*) : Jika ditentukan, menentukan fraksi (antara 0.0 dan 1.0) dari total proses denoising yang harus diselesaikan sebelum proses tersebut dihentikan secara dini secara sengaja. Akibatnya, sampel yang dikembalikan masih akan mempertahankan sejumlah besar noise (sekitar 20% akhir dari timestep masih diperlukan) dan harus didenoise oleh pipeline penerus yang memiliki `denoising_start` diatur ke 0.8 agar hanya mendenoise 20% akhir dari scheduler. Parameter denoising_end sebaiknya digunakan ketika pipeline ini merupakan bagian dari setup multi-pipeline "Mixture of Denoisers", seperti yang diuraikan dalam [**Refining the Image Output**](https://huggingface.co/docs/diffusers/api/pipelines/stable_diffusion/stable_diffusion_xl#refining-the-image-output). guidance_scale (`float`, *opsional*, default 7.5) : Skala panduan seperti yang didefinisikan dalam [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` didefinisikan sebagai `w` dari persamaan 2. pada [Imagen Paper](https://huggingface.co/papers/2205.11487). Skala panduan diaktifkan dengan mengatur `guidance_scale > 1`. Skala panduan yang lebih tinggi mendorong generasi gambar yang sangat terkait dengan `prompt` teks, biasanya dengan mengorbankan kualitas gambar yang lebih rendah. negative_prompt (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt yang tidak akan memandu generasi gambar. Jika tidak didefinisikan, Anda harus meneruskan `negative_prompt_embeds` sebagai gantinya. Diabaikan saat tidak menggunakan guidance (yaitu, diabaikan jika `guidance_scale` kurang dari `1`). negative_prompt_2 (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt yang tidak akan memandu generasi gambar untuk dikirim ke `tokenizer_2` dan `text_encoder_2`. Jika tidak didefinisikan, `negative_prompt` digunakan di kedua text-encoder prompt_embeds (`torch.Tensor`, *opsional*) : Embedding teks yang sudah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, embedding teks akan dihasilkan dari argumen input `prompt`. negative_prompt_embeds (`torch.Tensor`, *opsional*) : Embedding teks negatif yang telah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, negative_prompt_embeds akan dibuat dari argumen input `negative_prompt`. pooled_prompt_embeds (`torch.Tensor`, *opsional*) : Pooled text embeddings yang telah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* pembobotan prompt. Jika tidak disediakan, pooled text embeddings akan dihasilkan dari argumen input `prompt`. negative_pooled_prompt_embeds (`torch.Tensor`, *opsional*) : Embedding teks negatif yang sudah dipooling sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, pooled negative_prompt_embeds akan dihasilkan dari argumen input `negative_prompt`. ip_adapter_image : (`PipelineImageInput`, *opsional*): Input gambar opsional untuk bekerja dengan IP Adapters. ip_adapter_image_embeds (`list[torch.Tensor]`, *opsional*) : Embedding gambar yang telah dibuat sebelumnya untuk IP-Adapter. Ini harus berupa daftar dengan panjang yang sama dengan jumlah IP-adapter. Setiap elemen harus berupa tensor dengan bentuk `(batch_size, num_images, emb_dim)`. Embedding gambar negatif harus disertakan jika `do_classifier_free_guidance` diatur ke `True`. Jika tidak disediakan, embedding dihitung dari argumen input `ip_adapter_image`. num_images_per_prompt (`int`, *opsional*, default 1) : Jumlah gambar yang akan dihasilkan per prompt. eta (`float`, *opsional*, default 0.0) : Bersesuaian dengan parameter eta (η) dalam paper DDIM: https://huggingface.co/papers/2010.02502. Hanya berlaku untuk [schedulers.DDIMScheduler](/docs/diffusers/v0.43.0/id/api/schedulers/ddim#diffusers.DDIMScheduler), akan diabaikan untuk yang lain. generator (`torch.Generator`, *opsional*) : Satu atau daftar [generator torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) untuk membuat generasi menjadi deterministik. latents (`torch.Tensor`, *opsional*) : Laten berisik yang telah dibuat sebelumnya, diambil dari distribusi Gaussian, untuk digunakan sebagai input untuk generasi gambar. Dapat digunakan untuk menyesuaikan generasi yang sama dengan prompt yang berbeda. Jika tidak disediakan, tensor laten akan dibuat dengan pengambilan sampel menggunakan `generator` acak yang diberikan. output_type (`str`, *opsional*, defaultnya `"pil"`) : Format output dari gambar yang dihasilkan. Pilih antara [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` atau `np.array`. return_dict (`bool`, *opsional*, defaultnya `True`) : Apakah akan mengembalikan [StableDiffusionPipelineOutput](/docs/diffusers/v0.43.0/id/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) alih-alih tuple biasa. cross_attention_kwargs (`dict`, *opsional*) : Kamus kwargs yang jika ditentukan akan diteruskan ke `AttentionProcessor` seperti yang didefinisikan di bawah `self.processor` dalam [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). original_size (`tuple[int]`, *opsional*, defaultnya (1024, 1024)) : Jika `original_size` tidak sama dengan `target_size`, gambar akan tampak di-downsample atau di-upsample. `original_size` defaultnya `(height, width)` jika tidak ditentukan. Bagian dari micro-conditioning SDXL seperti dijelaskan di bagian 2.2 dari [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). crops_coords_top_left (`tuple[int]`, *opsional*, defaultnya (0, 0)) : `crops_coords_top_left` dapat digunakan untuk menghasilkan gambar yang tampak "dipotong" dari posisi `crops_coords_top_left` ke bawah. Gambar yang bagus dan terpusat biasanya dicapai dengan mengatur `crops_coords_top_left` ke (0, 0). Bagian dari micro-conditioning SDXL seperti yang dijelaskan di bagian 2.2 dari [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). target_size (`tuple[int]`, *opsional*, defaultnya (1024, 1024)) : Untuk sebagian besar kasus, `target_size` sebaiknya diatur ke tinggi dan lebar yang diinginkan dari gambar yang dihasilkan. Jika tidak ditentukan, nilainya akan default ke `(height, width)`. Bagian dari micro-conditioning SDXL seperti yang dijelaskan di bagian 2.2 dari [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). negative_original_size (`tuple[int]`, *opsional*, defaultnya (1024, 1024)) : Untuk mengondisikan proses generasi secara negatif berdasarkan resolusi gambar tertentu. Bagian dari micro-conditioning SDXL seperti yang dijelaskan di bagian 2.2 dari [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). Untuk informasi lebih lanjut, lihat thread issue ini: https://github.com/huggingface/diffusers/issues/4208. negative_crops_coords_top_left (`tuple[int]`, *opsional*, defaultnya (0, 0)) : Untuk mengondisikan proses generasi secara negatif berdasarkan koordinat crop tertentu. Bagian dari micro-conditioning SDXL seperti yang dijelaskan di bagian 2.2 dari [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). Untuk informasi lebih lanjut, lihat thread issue ini: https://github.com/huggingface/diffusers/issues/4208. negative_target_size (`tuple[int]`, *opsional*, defaultnya (1024, 1024)) : Untuk mengondisikan proses generasi secara negatif berdasarkan resolusi gambar target. Sebaiknya sama dengan `target_size` untuk sebagian besar kasus. Bagian dari micro-conditioning SDXL seperti yang dijelaskan di bagian 2.2 dari [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). Untuk informasi lebih lanjut, lihat thread issue ini: https://github.com/huggingface/diffusers/issues/4208. aesthetic_score (`float`, *opsional*, default 6.0) : Digunakan untuk mensimulasikan skor estetika dari gambar yang dihasilkan dengan memengaruhi kondisi teks positif. Bagian dari micro-conditioning SDXL seperti yang dijelaskan di bagian 2.2 dari [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). negative_aesthetic_score (`float`, *opsional*, default 2.5) : Bagian dari micro-conditioning SDXL seperti dijelaskan di bagian 2.2 dari [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). Dapat digunakan untuk mensimulasikan skor estetika dari gambar yang dihasilkan dengan memengaruhi kondisi teks negatif. guidance_rescale (`float`, *opsional*, default 0.0) : Faktor rescale guidance dari [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://arxiv.org/pdf/2305.08891.pdf). clip_skip (`int`, *opsional*) : Jumlah lapisan yang akan dilewati dari CLIP saat menghitung prompt embeddings. Nilai 1 berarti bahwa output dari lapisan sebelum terakhir akan digunakan untuk menghitung prompt embeddings. callback_on_step_end (`Callable`, `PipelineCallback`, `MultiPipelineCallbacks`, *opsional*) : Fungsi atau subkelas dari `PipelineCallback` atau `MultiPipelineCallbacks` yang dipanggil di akhir setiap langkah denoising selama inferensi, dengan argumen berikut: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` akan berisi daftar semua tensor sesuai yang ditentukan oleh `callback_on_step_end_tensor_inputs`. callback_on_step_end_tensor_inputs (`list`, *opsional*) : Daftar input tensor untuk fungsi `callback_on_step_end`. Tensor yang ditentukan dalam daftar akan diteruskan sebagai argumen `callback_kwargs`. Anda hanya dapat menyertakan variabel yang tercantum dalam atribut `._callback_tensor_inputs` dari kelas pipeline Anda. **Mengembalikan:** `~pipelines.stable_diffusion.StableDiffusionXLPipelineOutput` atau `tuple` `~pipelines.stable_diffusion.StableDiffusionXLPipelineOutput` jika `return_dict` bernilai True, selain itu berupa `tuple. `tuple. Saat mengembalikan tuple, elemen pertama adalah daftar berisi gambar yang dihasilkan. Fungsi yang dipanggil saat memanggil pipeline untuk generasi. Contoh: ```py >>> import torch >>> from diffusers import StableDiffusionXLInpaintPipeline >>> from diffusers.utils import load_image >>> pipe = StableDiffusionXLInpaintPipeline.from_pretrained( ... "stabilityai/stable-diffusion-xl-base-1.0", ... torch_dtype=torch.float16, ... variant="fp16", ... use_safetensors=True, ... ) >>> pipe.to("cuda") >>> img_url = "https://raw.githubusercontent.com/CompVis/latent-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo.png" >>> mask_url = "https://raw.githubusercontent.com/CompVis/latent-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo_mask.png" >>> init_image = load_image(img_url).convert("RGB") >>> mask_image = load_image(mask_url).convert("RGB") >>> prompt = "A majestic tiger sitting on a bench" >>> image = pipe( ... prompt=prompt, image=init_image, mask_image=mask_image, num_inference_steps=50, strength=0.80 ... ).images[0] ``` #### encode_prompt[[diffusers.StableDiffusionXLInpaintPipeline.encode_prompt]] ```python encode_prompt(prompt: str, prompt_2: str | None = None, device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, do_classifier_free_guidance: bool = True, negative_prompt: str | None = None, negative_prompt_2: str | None = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, lora_scale: float | None = None, clip_skip: int | None = None) ``` [Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/stable_diffusion_xl/pipeline_stable_diffusion_xl_inpaint.py#L405) **Parameter:** prompt (`str` atau `list[str]`, *opsional*) : prompt yang akan dienkod prompt_2 (`str` atau `list[str]`, *opsional*) : Prompt atau prompt yang akan dikirim ke `tokenizer_2` dan `text_encoder_2`. Jika tidak didefinisikan, `prompt` digunakan di kedua text-encoder device : (`torch.device`): perangkat torch num_images_per_prompt (`int`) : jumlah gambar yang harus dihasilkan per prompt do_classifier_free_guidance (`bool`) : apakah akan menggunakan classifier free guidance atau tidak negative_prompt (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt yang tidak akan memandu generasi gambar. Jika tidak didefinisikan, Anda harus meneruskan `negative_prompt_embeds` sebagai gantinya. Diabaikan saat tidak menggunakan guidance (yaitu, diabaikan jika `guidance_scale` kurang dari `1`). negative_prompt_2 (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt yang tidak akan memandu generasi gambar untuk dikirim ke `tokenizer_2` dan `text_encoder_2`. Jika tidak didefinisikan, `negative_prompt` digunakan di kedua text-encoder prompt_embeds (`torch.Tensor`, *opsional*) : Embedding teks yang sudah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, embedding teks akan dihasilkan dari argumen input `prompt`. negative_prompt_embeds (`torch.Tensor`, *opsional*) : Embedding teks negatif yang telah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, negative_prompt_embeds akan dibuat dari argumen input `negative_prompt`. pooled_prompt_embeds (`torch.Tensor`, *opsional*) : Pooled text embeddings yang telah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* pembobotan prompt. Jika tidak disediakan, pooled text embeddings akan dihasilkan dari argumen input `prompt`. negative_pooled_prompt_embeds (`torch.Tensor`, *opsional*) : Embedding teks negatif yang sudah dipooling sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, pooled negative_prompt_embeds akan dihasilkan dari argumen input `negative_prompt`. lora_scale (`float`, *opsional*) : Skala lora yang akan diterapkan ke semua lapisan LoRA dari text encoder jika lapisan LoRA dimuat. clip_skip (`int`, *opsional*) : Jumlah lapisan yang akan dilewati dari CLIP saat menghitung prompt embeddings. Nilai 1 berarti bahwa output dari lapisan sebelum terakhir akan digunakan untuk menghitung prompt embeddings. Mengkodekan prompt menjadi hidden states dari text encoder. #### get_guidance_scale_embedding[[diffusers.StableDiffusionXLInpaintPipeline.get_guidance_scale_embedding]] ```python get_guidance_scale_embedding(w: Tensor, embedding_dim: int = 512, dtype: dtype = torch.float32) ``` [Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/stable_diffusion_xl/pipeline_stable_diffusion_xl_inpaint.py#L1011) **Parameter:** w (`torch.Tensor`) : Menghasilkan vektor embedding dengan skala panduan yang ditentukan untuk selanjutnya memperkaya embedding timestep. embedding_dim (`int`, *opsional*, default 512) : Dimensi dari embedding yang akan dihasilkan. dtype (`torch.dtype`, *opsional*, defaultnya `torch.float32`) : Tipe data dari embedding yang dihasilkan. **Mengembalikan:** `torch.Tensor` Vektor embedding dengan bentuk `(len(w), embedding_dim)`. Lihat https://github.com/google-research/vdm/blob/dc27b98a554f65cdc654b800da5aa1846545d41b/model_vdm.py#L298