# Qwen-Image 2.1

Qwen-Image 2.1 mengodekan prompt dan gambar kondisi apa pun bersama dengan model Qwen3-VL, kemudian melakukan denoising pada gambar target dengan transformer block-causal single-stream. Lihat [`QwenImage21Transformer2DModel`](../models/qwenimage21_transformer2d) untuk perhatian block-causal, prosesor perhatian, dan `causal_condition`.

Nilai bawaan adalah nilai yang direkomendasikan oleh Qwen: 40 langkah dan tanpa panduan. Sertakan `negative_prompt` bersama dengan `true_cfg_scale > 1` untuk mengaktifkan classifier-free guidance, yang menggandakan pekerjaan per langkah.

```python
import torch
from diffusers import QwenImage21Pipeline

pipe = QwenImage21Pipeline.from_pretrained("Qwen/Qwen-Image-2.1", dtype=torch.bfloat16).to("cuda")

# Text-to-image
image = pipe("A capybara wearing a wizard hat, oil painting").images[0]
image.save("t2i.png")

# Image-conditioned editing
edited = pipe("Move it to a snowy mountain top", image=image).images[0]
edited.save("edit.png")
```

## Gambar kondisi ganda

Lewatkan daftar ke `image` dan setiap entri menjadi blok tersendiri dalam urutan gabungan: encoder Qwen3-VL melihatnya sebagai konteks visual dan VAE menyumbang token laten mereka. Atensi blok-kausal menjaga setiap blok tetap bidireksional secara internal sambil memungkinkan blok-blok berikutnya dan gambar target untuk memperhatikan blok-blok sebelumnya, sehingga urutan yang Anda lewati adalah urutan yang dibaca model.

```python
edited = pipe("Put the flowers from the first image into the second scene", image=[flowers, scene]).images[0]
```

## Perhatian lebih cepat dengan flex_attention

`QwenImage21AttnProcessor` default menjalankan prefill blok-kausal sebagai satu panggilan perhatian per segmen prefiks. Tidak memerlukan kompilasi dan berfungsi pada build PyTorch apa pun. `QwenImage21FlexAttnProcessor` mengekspresikan mask yang sama sebagai satu panggilan `flex_attention`, yang lebih cepat setelah model **_dikompilasi_**.

> [!TIP]
> Compile model saat Anda beralih ke flex processor. `flex_attention` yang tidak di-compile akan mematerialisasi matriks skor perhatian penuh dalam fp32, yang jauh lebih lambat dan kehabisan memori pada resolusi tinggi.

```python
from diffusers.models.transformers.transformer_qwenimage21 import QwenImage21FlexAttnProcessor

pipe.transformer.set_attn_processor(QwenImage21FlexAttnProcessor())
pipe.transformer.compile()
```

## Memuat checkpoint file tunggal

```python
import torch
from diffusers import QwenImage21Pipeline, QwenImage21Transformer2DModel

transformer = QwenImage21Transformer2DModel.from_single_file(
    "https://huggingface.co/Comfy-Org/Qwen-Image-2.1/blob/main/diffusion_models/qwen_image_2.1_bf16.safetensors",
    dtype=torch.bfloat16,
)
pipe = QwenImage21Pipeline.from_pretrained("Qwen/Qwen-Image-2.1", transformer=transformer, dtype=torch.bfloat16).to(
    "cuda"
)
```

## Sigma sampling

Penulis model dapat mengonfigurasi grid sampling default dengan `sample_sigmas` dalam konfigurasi pipeline. Saat Anda memuat checkpoint yang dirilis, pengaturan grid dan scheduler defaultnya dipulihkan secara otomatis.

Untuk bereksperimen dengan grid yang berbeda saat runtime, berikan `sigmas` ke panggilan pipeline:

```python
# Use the checkpoint's default sampling grid.
image = pipe(prompt).images[0]

# Override the default grid for this call.
image = pipe(prompt, sigmas=[1.0, 0.8, 0.5, 0.2]).images[0]
```

Grid kustom di atas mengilustrasikan API; kualitas generasi bergantung pada checkpoint dan grid. Daftar sigma mengecualikan sigma terminal, yang ditambahkan oleh scheduler. `sigmas` eksplisit menimpa `sample_sigmas` yang dikonfigurasi, dan salah satu daftar menentukan jumlah langkah alih-alih `num_inference_steps`. Jika keduanya tidak disediakan, pipeline menggunakan `num_inference_steps` untuk menghasilkan jadwal. Scheduler menerapkan pemrosesannya yang dikonfigurasi ke salah satu grid.

## Modular

Qwen-Image 2.1 juga tersedia sebagai [pipeline modular](../../modular_diffusers/overview). Blok yang sama menjalankan generasi teks-ke-gambar dan generasi yang dikondisikan oleh gambar: berikan `image` untuk mengondisikan pada satu atau lebih gambar. Panduan bebas klasifikator (classifier-free guidance) dikonfigurasi melalui komponen `guider` alih-alih argumen pemanggilan `true_cfg_scale`, dan cache KV prefiks aktif secara default (`use_kv_cache=False` mematikannya).

```python
import torch
from diffusers import ClassifierFreeGuidance, ModularPipeline

pipe = ModularPipeline.from_pretrained("Qwen/Qwen-Image-2.1")
pipe.load_components(dtype=torch.bfloat16)
pipe.to("cuda")

image = pipe(prompt="A capybara wearing a wizard hat, oil painting").images[0]

# Turn classifier-free guidance on for an edit.
pipe.update_components(guider=ClassifierFreeGuidance(guidance_scale=4.0))
edited = pipe(prompt="Move it to a snowy mountain top", negative_prompt="blurry", image=image).images[0]
```

Checkpoint Turbo dipetakan ke blok-bloknya sendiri ([QwenImage21TurboAutoBlocks](/docs/diffusers/v0.43.0/id/api/pipelines/qwenimage21#diffusers.QwenImage21TurboAutoBlocks)): berjalan tanpa `guider`, tidak menerima `negative_prompt`, dan mengambil sampel dari grid sigma yang disertakan. `ModularPipeline.from_pretrained` memilih blok Turbo dari entri `sample_sigmas` dalam konfigurasi checkpoint, sehingga tidak ada yang perlu dikonfigurasi:

```python
import torch
from diffusers import ModularPipeline

pipe = ModularPipeline.from_pretrained("Qwen/Qwen-Image-2.1-Turbo")
pipe.load_components(dtype=torch.bfloat16)
pipe.to("cuda")

image = pipe(prompt="A capybara wearing a wizard hat, oil painting").images[0]
```

## QwenImage21Pipeline[[diffusers.QwenImage21Pipeline]]

#### diffusers.QwenImage21Pipeline[[diffusers.QwenImage21Pipeline]]

```python
diffusers.QwenImage21Pipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKLQwenImage21, text_encoder: Qwen3VLForConditionalGeneration, processor: Qwen3VLProcessor, transformer: QwenImage21Transformer2DModel, sample_sigmas: list[float] | None = None)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/qwenimage21/pipeline_qwenimage21.py#L159)

**Parameter:**

scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/v0.43.0/id/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Scheduler yang digunakan untuk menghilangkan noise dari latens gambar yang telah dikodekan.

vae ([AutoencoderKLQwenImage21](/docs/diffusers/v0.43.0/id/api/models/autoencoderkl_qwenimage21#diffusers.AutoencoderKLQwenImage21)) : Variational auto-encoder yang memetakan gambar ke dan dari ruang laten 64-channel.

text_encoder (`Qwen3VLForConditionalGeneration`) : Model Qwen3-VL yang menghasilkan embedding teks/gambar gabungan.

processor (`Qwen3VLProcessor`) : Processor yang membangun template chat dan melakukan tokenisasi prompt serta gambar kondisi.

transformer ([QwenImage21Transformer2DModel](/docs/diffusers/v0.43.0/id/api/models/qwenimage21_transformer2d#diffusers.QwenImage21Transformer2DModel)) : Transformer blok-kausal single-stream yang melakukan denoising pada latents.

sample_sigmas (`list[float]`, *opsional*) : Sigma sampling default yang dikonfigurasi oleh pengembang model, tidak termasuk sigma terminal. Panjangnya menentukan jumlah langkah denoising. Untuk bereksperimen dengan grid yang berbeda saat runtime, berikan `sigmas` ke `__call__`.

Generasi teks-ke-gambar dan berbasis kondisi gambar dengan Qwen-Image 2.1.

Gambar prompt dan gambar kondisi dikodekan bersama oleh model Qwen3-VL, sehingga gambar kondisi menempati slot visi yang dialokasikan oleh encoder untuknya, dan transformer melihat satu urutan teks/gambar yang diselang-seling.

#### __call__[[diffusers.QwenImage21Pipeline.__call__]]

```python
__call__(prompt: str | list[str] = None, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, negative_prompt: str | list[str] = None, true_cfg_scale: float = 1.0, height: int | None = None, width: int | None = None, num_inference_steps: int = 40, sigmas: list[float] | None = None, num_images_per_prompt: int = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_embeds_mask: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds_mask: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', return_dict: bool = True, attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int, dict], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], output_resolution: int = 1024, use_kv_cache: bool = True)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/qwenimage21/pipeline_qwenimage21.py#L509)

**Parameter:**

prompt (`str` atau `list[str]`, *opsional*) : Prompt untuk memandu generasi gambar. Gunakan `prompt_embeds` sebagai gantinya untuk menyediakan embedding secara langsung.

image (`PipelineImageInput`, *opsional*) : Satu atau beberapa gambar kondisi, berupa gambar PIL atau array numpy. Gambar-gambar ini dikodekan oleh text encoder sebagai konteks visual dan oleh VAE menjadi token laten yang ditambahkan di depan noise. Sebuah list adalah satu set gambar yang dibagikan oleh setiap prompt dalam batch, bukan satu entri per prompt.

negative_prompt (`str` atau `list[str]`, *opsional*) : Prompt yang tidak digunakan untuk memandu generasi gambar. Diabaikan ketika `true_cfg_scale` tidak lebih besar dari 1.

true_cfg_scale (`float`, *opsional*, default 1.0) : Skala panduan bebas klasifikasi. Diaktifkan oleh `true_cfg_scale > 1` bersama dengan prompt negatif. Qwen-Image 2.1 dimaksudkan untuk disampelkan tanpa panduan, sehingga defaultnya adalah 1.0.

height (`int`, *opsional*) : Tinggi gambar yang dihasilkan dalam piksel. Diturunkan dari rasio aspek gambar kondisi jika diabaikan.

width (`int`, *opsional*) : Lebar gambar yang dihasilkan dalam piksel. Diturunkan dari rasio aspek gambar kondisi jika diabaikan.

num_inference_steps (`int`, *opsional*, default 40) : Jumlah langkah denoising. Diabaikan ketika `sigmas` atau `sample_sigmas` yang dikonfigurasi pada pipeline digunakan; panjang jadwal tersebut menentukan jumlah langkah.

sigmas (`list[float]`, *opsional*) : Sigma sampling yang akan dicoba untuk panggilan ini, tidak termasuk sigma terminal. Menimpa `sample_sigmas` yang dikonfigurasi pada pipeline dan menentukan jumlah langkah denoising. Scheduler menerapkan pemrosesannya yang dikonfigurasi ke nilai-nilai ini.

num_images_per_prompt (`int`, *opsional*, default 1) : Jumlah gambar yang dihasilkan per prompt.

generator (`torch.Generator` atau `list[torch.Generator]`, *opsional*) : Generator untuk membuat proses generasi menjadi deterministik.

latents (`torch.Tensor`, *opsional*) : Laten berisik yang telah dibuat sebelumnya.

prompt_embeds (`torch.Tensor`, *opsional*) : Embedding teks yang sudah dibuat sebelumnya, yang melewati pengkodean prompt. Sertakan `prompt_embeds_mask` bersamanya.

prompt_embeds_mask (`torch.Tensor`, *opsional*) : Mask Bool yang menandai posisi valid dari `prompt_embeds`.

negative_prompt_embeds (`torch.Tensor`, *opsional*) : Embedding teks negatif yang telah dibuat sebelumnya, digunakan sebagai pengganti `negative_prompt`. Sertakan `negative_prompt_embeds_mask` bersamanya.

negative_prompt_embeds_mask (`torch.Tensor`, *opsional*) : Mask Bool yang menandai posisi valid dari `negative_prompt_embeds`.

output_type (`str`, *opsional*, defaultnya `"pil"`) : Format output, `"pil"`, `"np"`, `"pt"` atau `"latent"`.

return_dict (`bool`, *opsional*, defaultnya `True`) : Apakah akan mengembalikan `~pipelines.qwenimage.QwenImagePipelineOutput` alih-alih tuple biasa.

attention_kwargs (`dict`, *opsional*) : Diteruskan ke pemroses perhatian.

callback_on_step_end (`Callable`, *opsional*) : Dipanggil di akhir setiap langkah denoising.

callback_on_step_end_tensor_inputs (`list[str]`, *opsional*, defaultnya `["latents"]`) : Tensor dari loop denoising untuk diteruskan ke `callback_on_step_end`. Mereka harus terdaftar dalam `_callback_tensor_inputs` pipeline.

output_resolution (`int`, *opsional*, default 1024) : Sisi target yang digunakan untuk menurunkan `height`/`width` dan untuk mengubah ukuran gambar kondisi.

use_kv_cache (`bool`, *opsional*, defaultnya `True`) : Menyimpan kunci dan nilai teks serta gambar kondisi dalam cache setelah langkah pertama. Hal ini valid karena `causal_condition` memodulasi token-token tersebut dari `t = 0`, sehingga aktivasi mereka tidak bergantung pada langkah. Mengubah flag ini tidak akan mereproduksi gambar yang sama secara bit-per-bit pada presisi yang dikurangi. Caching membuat langkah decode melakukan perhatian dengan tata letak urutan yang berbeda dari langkah prefill, sehingga keduanya dipecah menjadi tile yang berbeda dan menghasilkan pembulatan yang berbeda; keduanya tetap sesuai dengan referensi fp32 pada toleransi yang sama. Perbedaan satu ULP pada blok pertama kemudian diperkuat oleh 32 blok dan setiap langkah sampler, sehingga kedua pengaturan menghasilkan sampel yang sama validnya tetapi terlihat berbeda. Perbaiki sampel dengan menetapkan flag ini.

**Mengembalikan:** `~pipelines.qwenimage.QwenImagePipelineOutput` atau `tuple`

`~pipelines.qwenimage.QwenImagePipelineOutput` jika `return_dict` bernilai True, selain itu berupa `tuple` yang elemen pertamanya adalah daftar berisi gambar yang dihasilkan.

Fungsi yang dipanggil saat memanggil pipeline untuk generasi.

Contoh:
```py
>>> import torch
>>> from diffusers import QwenImage21Pipeline

>>> pipe = QwenImage21Pipeline.from_pretrained("Qwen/Qwen-Image-2.1", dtype=torch.bfloat16)
>>> pipe.to("cuda")
>>> prompt = "A capybara wearing a wizard hat, reading a book by candlelight, oil painting"
>>> image = pipe(prompt).images[0]
>>> image.save("qwenimage21.png")
```

#### encode_prompt[[diffusers.QwenImage21Pipeline.encode_prompt]]

```python
encode_prompt(prompt: str | list[str], image: list[typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]] | None = None, device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_embeds_mask: typing.Optional[torch.Tensor] = None, image_pad_mask: typing.Optional[torch.Tensor] = None)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/qwenimage21/pipeline_qwenimage21.py#L339)

**Parameter:**

prompt (`str` atau `list[str]`, *opsional*) : Prompt yang akan dienkod.

image (`list[PipelineImageInput]`, *opsional*) : Gambar kondisi untuk di-encode bersama prompt.

device (`torch.device`) : Perangkat Torch.

num_images_per_prompt (`int`) : Jumlah gambar yang dihasilkan per prompt.

prompt_embeds (`torch.Tensor`, *opsional*) : Embedding teks yang telah dibuat sebelumnya. Melompati proses encoding jika disediakan.

## QwenImagePipelineOutput[[diffusers.pipelines.qwenimage.pipeline_output.QwenImagePipelineOutput]]

#### diffusers.pipelines.qwenimage.pipeline_output.QwenImagePipelineOutput[[diffusers.pipelines.qwenimage.pipeline_output.QwenImagePipelineOutput]]

```python
diffusers.pipelines.qwenimage.pipeline_output.QwenImagePipelineOutput(images: list[PIL.Image.Image] | numpy.ndarray)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/qwenimage/pipeline_output.py#L10)

**Parameter:**

images (`list[PIL.Image.Image]` atau `np.ndarray`) : daftar gambar PIL yang telah didenois dengan panjang `batch_size` atau array numpy dengan bentuk `(batch_size, height, width, num_channels)`. Gambar PIL atau array numpy menyajikan gambar-gambar yang telah didenois dari pipeline difusi.

Kelas output untuk pipeline Stable Diffusion.

## QwenImage21ModularPipeline[[diffusers.QwenImage21ModularPipeline]]

#### diffusers.QwenImage21ModularPipeline[[diffusers.QwenImage21ModularPipeline]]

```python
diffusers.QwenImage21ModularPipeline(blocks: diffusers.modular_pipelines.modular_pipeline.ModularPipelineBlocks | None = None, pretrained_model_name_or_path: str | os.PathLike | None = None, components_manager: diffusers.modular_pipelines.components_manager.ComponentsManager | None = None, collection: str | None = None, workflow: str | None = None, modular_config_dict: dict[str, typing.Any] | None = None, config_dict: dict[str, typing.Any] | None = None, **kwargs)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/qwenimage21/modular_pipeline.py#L23)

ModularPipeline untuk Qwen-Image 2.1.

## QwenImage21AutoBlocks[[diffusers.QwenImage21AutoBlocks]]

#### diffusers.QwenImage21AutoBlocks[[diffusers.QwenImage21AutoBlocks]]

```python
diffusers.QwenImage21AutoBlocks()
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/qwenimage21/modular_blocks_qwenimage21.py#L497)

Pipeline modular otomatis untuk pembuatan teks-ke-gambar dan pembuatan yang dikondisikan oleh gambar menggunakan Qwen-Image 2.1.
- untuk generasi teks-ke-gambar, yang perlu Anda berikan hanyalah `prompt`
- untuk generasi yang dikondisikan oleh gambar, Anda perlu menyediakan `prompt` dan `image` (satu gambar atau daftar)

Alur kerja yang didukung:
- `text2image`: membutuhkan `prompt`
- `image_conditioned`: membutuhkan `prompt`, `image`

Komponen: image_processor (`VaeImageProcessor`) text_encoder (`Qwen3VLForConditionalGeneration`) processor (`Qwen3VLProcessor`) vae (`AutoencoderKLQwenImage21`) scheduler (`FlowMatchEulerDiscreteScheduler`) guider (`ClassifierFreeGuidance`) transformer (`QwenImage21Transformer2DModel`)

Inputs: image (`Image | list`, *optional*): Reference image(s) for denoising. Can be a single image or list of images. output_resolution (`int`, *optional*, defaults to 1024): Target side length used to derive the output size and to resize condition images. prompt (`str`): The prompt or prompts to guide image generation. negative_prompt (`str`, *optional*): The prompt or prompts not to guide the image generation. generator (`Generator`, *optional*): Torch generator for deterministic generation. num_images_per_prompt (`int`, *optional*, defaults to 1): The number of images to generate per prompt. height (`int`, *optional*): The height in pixels of the generated image. width (`int`, *optional*): The width in pixels of the generated image. image_latents (`list`, *optional*): Normalized latents of each condition image. Can be generated from vae_encoder step. latents (`Tensor`): Pre-generated noisy latents for image generation. num_inference_steps (`int`): The number of denoising steps. sigmas (`list`, *optional*): Custom sigmas for the denoising process. use_kv_cache (`bool`, *optional*, defaults to True): Cache the text and condition-image keys and values after the first step. Valid because `causal_condition` modulates those tokens from `t = 0`, making their activations step-independent. Toggling it does not reproduce the same image bit-for-bit in reduced precision. attention_kwargs (`dict`, *optional*): Additional kwargs for attention processors. **denoiser_input_fields (`None`, *optional*): conditional model inputs for the denoiser: e.g. prompt_embeds, negative_prompt_embeds, etc. output_type (`str`, *optional*, defaults to pil): Output format: 'pil', 'np', 'pt'.

Output: gambar (`list`): Gambar yang dihasilkan.

## QwenImage21TurboModularPipeline[[diffusers.QwenImage21TurboModularPipeline]]

#### diffusers.QwenImage21TurboModularPipeline[[diffusers.QwenImage21TurboModularPipeline]]

```python
diffusers.QwenImage21TurboModularPipeline(blocks: diffusers.modular_pipelines.modular_pipeline.ModularPipelineBlocks | None = None, pretrained_model_name_or_path: str | os.PathLike | None = None, components_manager: diffusers.modular_pipelines.components_manager.ComponentsManager | None = None, collection: str | None = None, workflow: str | None = None, modular_config_dict: dict[str, typing.Any] | None = None, config_dict: dict[str, typing.Any] | None = None, **kwargs)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/qwenimage21/modular_pipeline.py#L54)

ModularPipeline untuk Qwen-Image 2.1 Turbo, checkpoint yang dipercepat dan melakukan sampling dalam beberapa langkah tanpa panduan.

## QwenImage21TurboAutoBlocks[[diffusers.QwenImage21TurboAutoBlocks]]

#### diffusers.QwenImage21TurboAutoBlocks[[diffusers.QwenImage21TurboAutoBlocks]]

```python
diffusers.QwenImage21TurboAutoBlocks()
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/qwenimage21/modular_blocks_qwenimage21_turbo.py#L466)

Auto Modular pipeline untuk text-to-image dan generasi yang dikondisikan oleh gambar menggunakan Qwen-Image 2.1 Turbo, checkpoint yang dipercepat yang mengambil sampel grid sigma bawaannya dalam beberapa langkah tanpa guidance.
- untuk generasi teks-ke-gambar, yang perlu Anda berikan hanyalah `prompt`
- untuk generasi yang dikondisikan oleh gambar, Anda perlu menyediakan `prompt` dan `image` (satu gambar atau daftar)

Alur kerja yang didukung:
- `text2image`: membutuhkan `prompt`
- `image_conditioned`: membutuhkan `prompt`, `image`

Komponen: image_processor (`VaeImageProcessor`) text_encoder (`Qwen3VLForConditionalGeneration`) processor (`Qwen3VLProcessor`) vae (`AutoencoderKLQwenImage21`) scheduler (`FlowMatchEulerDiscreteScheduler`) transformer (`QwenImage21Transformer2DModel`)

Konfigurasi: sample_sigmas (default: None): Grid sampling yang disertakan bersama checkpoint, digunakan ketika `sigmas` tidak diteruskan.

Inputs: image (`Image | list`, *optional*): Reference image(s) for denoising. Can be a single image or list of images. output_resolution (`int`, *optional*, defaults to 1024): Target side length used to derive the output size and to resize condition images. prompt (`str`): The prompt or prompts to guide image generation. generator (`Generator`, *optional*): Torch generator for deterministic generation. num_images_per_prompt (`int`, *optional*, defaults to 1): The number of images to generate per prompt. height (`int`, *optional*): The height in pixels of the generated image. width (`int`, *optional*): The width in pixels of the generated image. image_latents (`list`, *optional*): Normalized latents of each condition image. Can be generated from vae_encoder step. latents (`Tensor`): Pre-generated noisy latents for image generation. num_inference_steps (`int`): The number of denoising steps. sigmas (`list`, *optional*): Custom sigmas for the denoising process. use_kv_cache (`bool`, *optional*, defaults to True): Cache the text and condition-image keys and values after the first step. Valid because `causal_condition` modulates those tokens from `t = 0`, making their activations step-independent. Toggling it does not reproduce the same image bit-for-bit in reduced precision. attention_kwargs (`dict`, *optional*): Additional kwargs for attention processors. **denoiser_input_fields (`None`, *optional*): conditional model inputs for the denoiser: e.g. prompt_embeds, negative_prompt_embeds, etc. output_type (`str`, *optional*, defaults to pil): Output format: 'pil', 'np', 'pt'.

Output: gambar (`list`): Gambar yang dihasilkan.