hf-doc-build/doc / diffusers /main /id /api /pipelines /stable_diffusion /stable_diffusion_xl.md

|

98.3 kB

Stable Diffusion XL

Stable Diffusion XL (SDXL) diusulkan dalam SDXL: Improving Latent Diffusion Models for High-Resolution Image Synthesis 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 karena solver menjadi tidak stabil secara numerik. Untuk memperbaiki masalah ini, lihat PR 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.
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.

Lihat organisasi Stability AI di Hub untuk checkpoint model base dan refiner resmi!

Pastikan Anda telah menginstal pustaka berikut.

# uncomment to install the necessary libraries in Colab
#!pip install -q diffusers transformers accelerate invisible-watermark>=0.2.0

Kami merekomendasikan untuk menginstal pustaka invisible-watermark untuk membantu mengidentifikasi gambar yang dihasilkan. Jika pustaka invisible-watermark terinstal, pustaka tersebut digunakan secara default. Untuk menonaktifkan watermarker:
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():

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() untuk memuat checkpoint model yang disimpan dalam format file tunggal (.ckpt atau .safetensors) dari Hub atau secara lokal:

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.

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:

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.

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 yang khusus untuk denoising gambar pada tahap noise rendah guna menghasilkan gambar berkualitas lebih tinggi dari model dasar. Ada dua cara untuk menggunakan refiner:

gunakan model base dan refiner secara bersama untuk menghasilkan gambar yang lebih halus
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. 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:

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 dan untuk model refiner, dikendalikan oleh parameter denoising_start.

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.

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:

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:

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")

Anda dapat menggunakan SDXL refiner dengan model dasar yang berbeda. Misalnya, Anda dapat menggunakan pipeline Hunyuan-DiT atau 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:

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:

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, 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.

Anda dapat menggunakan parameter micro-conditioning dan negative micro-conditioning berkat classifier-free guidance. Parameter ini tersedia di StableDiffusionXLPipeline, StableDiffusionXLImg2ImgPipeline, StableDiffusionXLInpaintPipeline, dan StableDiffusionXLControlNetPipeline.

Kondisioning ukuran

Ada dua jenis kondisioning ukuran:

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 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:

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!

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:

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. Berikan prompt asli Anda ke prompt dan prompt kedua ke prompt_2 (gunakan negative_prompt dan negative_prompt_2 jika Anda menggunakan negative prompt):

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.

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.

Offload model ke CPU dengan enable_model_cpu_offload() untuk error out-of-memory:

- base.to("cuda")  # or "mps", "xpu", "cpu"
- refiner.to("cuda")
+ base.enable_model_cpu_offload()
+ refiner.enable_model_cpu_offload()

Gunakan torch.compile untuk percepatan ~20% (Anda membutuhkan torch>=2.0):

+ base.unet = torch.compile(base.unet, mode="reduce-overhead", fullgraph=True)
+ refiner.unet = torch.compile(refiner.unet, mode="reduce-overhead", fullgraph=True)

Aktifkan xFormers untuk menjalankan SDXL jika torch<2.0:

+ base.enable_xformers_memory_efficient_attention()
+ refiner.enable_xformers_memory_efficient_attention()

Sumber daya

Jika Anda tertarik untuk bereksperimen dengan versi minimal dari UNet2DConditionModel yang digunakan dalam SDXL, lihatlah implementasi minSDXL yang ditulis dalam PyTorch dan langsung kompatibel dengan 🤗 Diffusers.

StableDiffusionXLPipeline[[diffusers.StableDiffusionXLPipeline]]

diffusers.StableDiffusionXLPipeline[[diffusers.StableDiffusionXLPipeline]]

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

Parameter:

vae (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, khususnya varian clip-vit-large-patch14.

text_encoder_2 ( CLIPTextModelWithProjection) : Text-encoder beku kedua. Stable Diffusion XL menggunakan bagian teks dan pool dari CLIP, khususnya varian laion/CLIP-ViT-bigG-14-laion2B-39B-b160k.

tokenizer (CLIPTokenizer) : Tokenizer dari kelas CLIPTokenizer.

tokenizer_2 (CLIPTokenizer) : Tokenizer kedua dari kelas CLIPTokenizer.

unet (UNet2DConditionModel) : Arsitektur U-Net bersyarat untuk mendenoise latens gambar yang telah dikodekan.

scheduler (SchedulerMixin) : Penjadwal yang digunakan bersama unet untuk menghilangkan noise pada latens gambar yang telah dikodekan. Bisa berupa DDIMScheduler, LMSDiscreteScheduler, atau 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 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. 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() untuk memuat embedding textual inversion
untuk memuat file .ckpt dengan from_single_file()
load_lora_weights() untuk memuat bobot LoRA
save_lora_weights() untuk menyimpan bobot LoRA
load_ip_adapter() untuk memuat IP Adapter

call[[diffusers.StableDiffusionXLPipeline.call]]

__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

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 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 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

guidance_scale (float, opsional, default 5.0) : Skala panduan seperti yang didefinisikan dalam Classifier-Free Diffusion Guidance. guidance_scale didefinisikan sebagai w dari persamaan 2. pada Imagen Paper. 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, akan diabaikan untuk yang lain.

generator (torch.Generator atau list[torch.Generator], opsional) : Satu atau daftar generator torch 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: 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.

guidance_rescale (float, opsional, default 0.0) : Faktor rescale guidance yang diusulkan oleh Common Diffusion Noise Schedules and Sample Steps are Flawed guidance_scale didefinisikan sebagai φ dalam persamaan 16. dari Common Diffusion Noise Schedules and Sample Steps are Flawed. 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.

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.

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.

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. 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. 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. 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:

>>> 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]]

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

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]]

get_guidance_scale_embedding(w: Tensor, embedding_dim: int = 512, dtype: dtype = torch.float32)

Sumber

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]]

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

Parameter:

vae (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, khususnya varian clip-vit-large-patch14.

text_encoder_2 ( CLIPTextModelWithProjection) : Text-encoder beku kedua. Stable Diffusion XL menggunakan bagian teks dan pool dari CLIP, khususnya varian laion/CLIP-ViT-bigG-14-laion2B-39B-b160k.

tokenizer (CLIPTokenizer) : Tokenizer dari kelas CLIPTokenizer.

tokenizer_2 (CLIPTokenizer) : Tokenizer kedua dari kelas CLIPTokenizer.

unet (UNet2DConditionModel) : Arsitektur U-Net bersyarat untuk mendenoise latens gambar yang telah dikodekan.

scheduler (SchedulerMixin) : Penjadwal yang digunakan bersama unet untuk menghilangkan noise pada latens gambar yang telah dikodekan. Bisa berupa DDIMScheduler, LMSDiscreteScheduler, atau 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 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. 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() untuk memuat embedding textual inversion
untuk memuat file .ckpt dengan from_single_file()
load_lora_weights() untuk memuat bobot LoRA
save_lora_weights() untuk menyimpan bobot LoRA
load_ip_adapter() untuk memuat IP Adapter

call[[diffusers.StableDiffusionXLImg2ImgPipeline.call]]

__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

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.

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.

guidance_scale (float, opsional, default 7.5) : Skala panduan seperti yang didefinisikan dalam Classifier-Free Diffusion Guidance. guidance_scale didefinisikan sebagai w dari persamaan 2. pada Imagen Paper. 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.