# Stable Diffusion 3

  
  

Stable Diffusion 3 (SD3) diusulkan dalam [Scaling Rectified Flow Transformers for High-Resolution Image Synthesis](https://huggingface.co/papers/2403.03206) oleh Patrick Esser, Sumith Kulal, Andreas Blattmann, Rahim Entezari, Jonas Muller, Harry Saini, Yam Levi, Dominik Lorenz, Axel Sauer, Frederic Boesel, Dustin Podell, Tim Dockhorn, Zion English, Kyle Lacey, Alex Goodwin, Yannik Marek, dan Robin Rombach.

Abstrak dari makalah tersebut adalah:

*Model difusi membuat data dari noise dengan membalikkan jalur maju data menuju noise, dan telah muncul sebagai teknik pemodelan generatif yang kuat untuk data berdimensi tinggi yang bersifat perseptual, seperti gambar dan video. Rectified flow adalah formulasi model generatif terbaru yang menghubungkan data dan noise dalam garis lurus. Meskipun memiliki sifat teoretis yang lebih baik dan kesederhanaan konseptual, pendekatan ini belum sepenuhnya mapan sebagai praktik standar. Dalam karya ini, kami meningkatkan teknik pengambilan sampel noise yang ada untuk melatih model rectified flow dengan memberinya bias menuju skala yang relevan secara perseptual. Melalui studi berskala besar, kami menunjukkan kinerja superior dari pendekatan ini dibandingkan dengan formulasi difusi yang sudah mapan untuk sintesis teks-ke-gambar resolusi tinggi. Selain itu, kami menyajikan arsitektur berbasis transformer yang baru untuk generasi teks-ke-gambar, yang menggunakan bobot terpisah untuk kedua modalitas dan memungkinkan aliran informasi dua arah antara token gambar dan teks, sehingga meningkatkan pemahaman teks, tipografi, dan penilaian preferensi manusia. Kami menunjukkan bahwa arsitektur ini mengikuti tren penskalaan yang dapat diprediksi dan mengaitkan penurunan loss validasi dengan peningkatan sintesis teks-ke-gambar, sebagaimana diukur oleh berbagai metrik dan evaluasi manusia.*

## Contoh Penggunaan

_Karena model ini bersifat gated, sebelum menggunakannya dengan diffusers Anda perlu terlebih dahulu membuka [halaman Stable Diffusion 3 Medium di Hugging Face](https://huggingface.co/stabilityai/stable-diffusion-3-medium-diffusers), mengisi formulir, dan menerima gate. Setelah Anda masuk, Anda perlu login agar sistem mengetahui bahwa Anda telah menerima gate._

Gunakan perintah di bawah ini untuk masuk:

```bash
hf auth login
```

> [!TIP]
> Pipeline SD3 menggunakan tiga text encoder untuk menghasilkan gambar. Model offloading diperlukan agar pipeline ini dapat berjalan di sebagian besar hardware komersial. Silakan gunakan tipe data `torch.float16` untuk penghematan memori tambahan.

```python
import torch
from diffusers import StableDiffusion3Pipeline

pipe = StableDiffusion3Pipeline.from_pretrained("stabilityai/stable-diffusion-3-medium-diffusers", dtype=torch.float16)
pipe.to("cuda")  # or "mps", "xpu", "cpu"

image = pipe(
    prompt="a photo of a cat holding a sign that says hello world",
    negative_prompt="",
    num_inference_steps=28,
    height=1024,
    width=1024,
    guidance_scale=7.0,
).images[0]

image.save("sd3_hello_world.png")
```

**Catatan:** Stable Diffusion 3.5 juga dapat dijalankan menggunakan pipeline SD3, dan semua optimasi serta teknik yang disebutkan berlaku juga untuknya. Secara total, terdapat tiga model resmi dalam keluarga SD3:
- [`stabilityai/stable-diffusion-3-medium-diffusers`](https://huggingface.co/stabilityai/stable-diffusion-3-medium-diffusers)
- [`stabilityai/stable-diffusion-3.5-large`](https://huggingface.co/stabilityai/stable-diffusion-3-5-large)
- [`stabilityai/stable-diffusion-3.5-large-turbo`](https://huggingface.co/stabilityai/stable-diffusion-3-5-large-turbo)

## Prompting Gambar dengan IP-Adapters

IP-Adapter memungkinkan Anda memberikan prompt SD3 dengan gambar, di samping prompt teks. Hal ini sangat berguna ketika Anda perlu mendeskripsikan konsep kompleks yang sulit diungkapkan hanya melalui teks dan Anda memiliki gambar referensi. Untuk memuat dan menggunakan IP-Adapter, Anda membutuhkan:

- `image_encoder`: Model visi terlatih sebelumnya yang digunakan untuk memperoleh fitur gambar, biasanya berupa pengkode gambar CLIP.
- `feature_extractor`: Pemroses gambar yang menyiapkan gambar input untuk `image_encoder` yang dipilih.
- `ip_adapter_id`: Checkpoint yang berisi parameter dari lapisan cross attention gambar dan proyeksi gambar.

IP-Adapters dilatih untuk arsitektur model tertentu, sehingga juga berfungsi pada variasi finetuned dari model dasar. Anda dapat menggunakan fungsi `~SD3IPAdapterMixin.set_ip_adapter_scale` untuk menyesuaikan seberapa kuat output selaras dengan prompt gambar. Semakin tinggi nilainya, semakin ketat model mengikuti prompt gambar. Nilai default 0,5 biasanya merupakan keseimbangan yang baik, memastikan model mempertimbangkan prompt teks dan gambar secara setara.

```python
import torch
from PIL import Image

from diffusers import StableDiffusion3Pipeline
from transformers import SiglipVisionModel, SiglipImageProcessor

image_encoder_id = "google/siglip-so400m-patch14-384"
ip_adapter_id = "InstantX/SD3.5-Large-IP-Adapter"

feature_extractor = SiglipImageProcessor.from_pretrained(
    image_encoder_id,
    dtype=torch.float16
)
image_encoder = SiglipVisionModel.from_pretrained(
    image_encoder_id,
    dtype=torch.float16
).to( "cuda")  # or "mps", "xpu", "cpu"

pipe = StableDiffusion3Pipeline.from_pretrained(
    "stabilityai/stable-diffusion-3.5-large",
    dtype=torch.float16,
    feature_extractor=feature_extractor,
    image_encoder=image_encoder,
).to("cuda")

pipe.load_ip_adapter(ip_adapter_id)
pipe.set_ip_adapter_scale(0.6)

ref_img = Image.open("image.jpg").convert('RGB')

image = pipe(
    width=1024,
    height=1024,
    prompt="a cat",
    negative_prompt="lowres, low quality, worst quality",
    num_inference_steps=24,
    guidance_scale=5.0,
    ip_adapter_image=ref_img
).images[0]

image.save("result.jpg")
```

    
    Contoh IP-Adapter dengan prompt "a cat"

> [!TIP]
> Lihat [IP-Adapter](../../../using-diffusers/ip_adapter) untuk mempelajari lebih lanjut tentang cara kerja IP-Adapter.

## Optimasi Memori untuk SD3

SD3 menggunakan tiga pengkode teks, salah satunya adalah model T5-XXL yang sangat besar. Hal ini membuat model sulit dijalankan pada GPU dengan VRAM kurang dari 24GB, bahkan saat menggunakan presisi `fp16`. Bagian berikut merangkum beberapa optimasi memori di Diffusers yang memudahkan eksekusi SD3 pada perangkat dengan sumber daya terbatas.

### Menjalankan Inferensi dengan Offloading Model

Optimasi memori paling dasar yang tersedia di Diffusers memungkinkan Anda untuk memindahkan komponen model ke CPU selama inferensi guna menghemat memori, dengan sedikit peningkatan latensi inferensi. Model offloading hanya akan memindahkan komponen model ke GPU ketika komponen tersebut perlu dieksekusi, sementara komponen lainnya tetap berada di CPU.

```python
import torch
from diffusers import StableDiffusion3Pipeline

pipe = StableDiffusion3Pipeline.from_pretrained("stabilityai/stable-diffusion-3-medium-diffusers", dtype=torch.float16)
pipe.enable_model_cpu_offload()

image = pipe(
    prompt="a photo of a cat holding a sign that says hello world",
    negative_prompt="",
    num_inference_steps=28,
    height=1024,
    width=1024,
    guidance_scale=7.0,
).images[0]

image.save("sd3_hello_world.png")
```

### Menghapus T5 Text Encoder saat Inferensi

Menghapus pengkode teks T5-XXL dengan 4,7 miliar parameter yang intensif memori selama inferensi dapat secara signifikan mengurangi kebutuhan memori untuk SD3 dengan sedikit penurunan kinerja.

```python
import torch
from diffusers import StableDiffusion3Pipeline

pipe = StableDiffusion3Pipeline.from_pretrained(
    "stabilityai/stable-diffusion-3-medium-diffusers",
    text_encoder_3=None,
    tokenizer_3=None,
    dtype=torch.float16
)
pipe.to("cuda")  # or "mps", "xpu", "cpu"

image = pipe(
    prompt="a photo of a cat holding a sign that says hello world",
    negative_prompt="",
    num_inference_steps=28,
    height=1024,
    width=1024,
    guidance_scale=7.0,
).images[0]

image.save("sd3_hello_world-no-T5.png")
```

### Menggunakan Versi Terkuantisasi dari T5 Text Encoder

Kita dapat memanfaatkan pustaka `bitsandbytes` untuk memuat dan mengkuantisasi T5-XXL text encoder ke presisi 8-bit. Hal ini memungkinkan Anda untuk tetap menggunakan ketiga text encoder sambil hanya sedikit memengaruhi kinerja.

Pertama, instal pustaka `bitsandbytes`.

```shell
pip install bitsandbytes
```

Lalu muat model T5-XXL menggunakan `BitsAndBytesConfig`.

```python
import torch
from diffusers import StableDiffusion3Pipeline
from transformers import T5EncoderModel, BitsAndBytesConfig

quantization_config = BitsAndBytesConfig(load_in_8bit=True)

model_id = "stabilityai/stable-diffusion-3-medium-diffusers"
text_encoder = T5EncoderModel.from_pretrained(
    model_id,
    subfolder="text_encoder_3",
    quantization_config=quantization_config,
)
pipe = StableDiffusion3Pipeline.from_pretrained(
    model_id,
    text_encoder_3=text_encoder,
    device_map="balanced",
    dtype=torch.float16
)

image = pipe(
    prompt="a photo of a cat holding a sign that says hello world",
    negative_prompt="",
    num_inference_steps=28,
    height=1024,
    width=1024,
    guidance_scale=7.0,
).images[0]

image.save("sd3_hello_world-8bit-T5.png")
```

Anda dapat menemukan skrip end-to-end [di sini](https://gist.github.com/sayakpaul/82acb5976509851f2db1a83456e504f1).

## Optimasi Kinerja untuk SD3

### Menggunakan Torch Compile untuk Mempercepat Inferensi

Menggunakan komponen terkompilasi dalam pipeline SD3 dapat mempercepat inferensi hingga 4X. Cuplikan kode berikut menunjukkan cara mengompilasi komponen Transformer dan VAE dari pipeline SD3.

```python
import torch
from diffusers import StableDiffusion3Pipeline

torch.set_float32_matmul_precision("high")

torch._inductor.config.conv_1x1_as_mm = True
torch._inductor.config.coordinate_descent_tuning = True
torch._inductor.config.epilogue_fusion = False
torch._inductor.config.coordinate_descent_check_all_directions = True

pipe = StableDiffusion3Pipeline.from_pretrained(
    "stabilityai/stable-diffusion-3-medium-diffusers",
    dtype=torch.float16
).to("cuda")  # or "mps", "xpu", "cpu"
pipe.set_progress_bar_config(disable=True)

pipe.transformer.to(memory_format=torch.channels_last)
pipe.vae.to(memory_format=torch.channels_last)

pipe.transformer = torch.compile(pipe.transformer, mode="max-autotune", fullgraph=True)
pipe.vae.decode = torch.compile(pipe.vae.decode, mode="max-autotune", fullgraph=True)

# Warm Up
prompt = "a photo of a cat holding a sign that says hello world"
for _ in range(3):
    _ = pipe(prompt=prompt, generator=torch.manual_seed(1))

# Run Inference
image = pipe(prompt=prompt, generator=torch.manual_seed(1)).images[0]
image.save("sd3_hello_world.png")
```

Lihat skrip lengkapnya [di sini](https://gist.github.com/sayakpaul/508d89d7aad4f454900813da5d42ca97).

## Kuantisasi

Quantization membantu mengurangi kebutuhan memori untuk model yang sangat besar dengan menyimpan bobot model dalam tipe data presisi yang lebih rendah. Namun, quantization dapat memiliki dampak yang bervariasi terhadap kualitas video tergantung pada model video yang digunakan.

Lihat ringkasan [Quantization](../../../quantization/overview) untuk mempelajari lebih lanjut tentang backend kuantisasi yang didukung dan memilih backend kuantisasi yang mendukung kasus penggunaan Anda. Contoh di bawah ini menunjukkan cara memuat [StableDiffusion3Pipeline](/docs/diffusers/main/id/api/pipelines/stable_diffusion/stable_diffusion_3#diffusers.StableDiffusion3Pipeline) yang dikuantisasi untuk inferensi dengan bitsandbytes.

```py
import torch
from diffusers import BitsAndBytesConfig as DiffusersBitsAndBytesConfig, SD3Transformer2DModel, StableDiffusion3Pipeline
from transformers import BitsAndBytesConfig as BitsAndBytesConfig, T5EncoderModel

quant_config = BitsAndBytesConfig(load_in_8bit=True)
text_encoder_8bit = T5EncoderModel.from_pretrained(
    "stabilityai/stable-diffusion-3.5-large",
    subfolder="text_encoder_3",
    quantization_config=quant_config,
    dtype=torch.float16,
)

quant_config = DiffusersBitsAndBytesConfig(load_in_8bit=True)
transformer_8bit = SD3Transformer2DModel.from_pretrained(
    "stabilityai/stable-diffusion-3.5-large",
    subfolder="transformer",
    quantization_config=quant_config,
    dtype=torch.float16,
)

pipeline = StableDiffusion3Pipeline.from_pretrained(
    "stabilityai/stable-diffusion-3.5-large",
    text_encoder=text_encoder_8bit,
    transformer=transformer_8bit,
    dtype=torch.float16,
    device_map="balanced",
)

prompt = "a tiny astronaut hatching from an egg on the moon"
image = pipeline(prompt, num_inference_steps=28, guidance_scale=7.0).images[0]
image.save("sd3.png")
```

## Menggunakan Prompt Panjang dengan T5 Text Encoder

Secara default, prompt T5 Text Encoder menggunakan panjang urutan maksimum `256`. Hal ini dapat disesuaikan dengan mengatur `max_sequence_length` untuk menerima lebih sedikit atau lebih banyak token. Perlu diingat bahwa urutan yang lebih panjang memerlukan sumber daya tambahan dan menghasilkan waktu generasi yang lebih lama, seperti saat batch inference.

```python
prompt = "A whimsical and creative image depicting a hybrid creature that is a mix of a waffle and a hippopotamus, basking in a river of melted butter amidst a breakfast-themed landscape. It features the distinctive, bulky body shape of a hippo. However, instead of the usual grey skin, the creature’s body resembles a golden-brown, crispy waffle fresh off the griddle. The skin is textured with the familiar grid pattern of a waffle, each square filled with a glistening sheen of syrup. The environment combines the natural habitat of a hippo with elements of a breakfast table setting, a river of warm, melted butter, with oversized utensils or plates peeking out from the lush, pancake-like foliage in the background, a towering pepper mill standing in for a tree.  As the sun rises in this fantastical world, it casts a warm, buttery glow over the scene. The creature, content in its butter river, lets out a yawn. Nearby, a flock of birds take flight"

image = pipe(
    prompt=prompt,
    negative_prompt="",
    num_inference_steps=28,
    guidance_scale=4.5,
    max_sequence_length=512,
).images[0]
```

### Mengirim prompt yang berbeda ke T5 Text Encoder

Anda dapat mengirim prompt yang berbeda ke CLIP Text Encoders dan T5 Text Encoder untuk mencegah prompt dipotong oleh CLIP Text Encoders dan untuk meningkatkan hasil generasi.

> [!TIP]
> Prompt dengan CLIP Text Encoders masih dipotong ke batas 77 token.

```python
prompt = "A whimsical and creative image depicting a hybrid creature that is a mix of a waffle and a hippopotamus, basking in a river of melted butter amidst a breakfast-themed landscape. A river of warm, melted butter, pancake-like foliage in the background, a towering pepper mill standing in for a tree."

prompt_3 = "A whimsical and creative image depicting a hybrid creature that is a mix of a waffle and a hippopotamus, basking in a river of melted butter amidst a breakfast-themed landscape. It features the distinctive, bulky body shape of a hippo. However, instead of the usual grey skin, the creature’s body resembles a golden-brown, crispy waffle fresh off the griddle. The skin is textured with the familiar grid pattern of a waffle, each square filled with a glistening sheen of syrup. The environment combines the natural habitat of a hippo with elements of a breakfast table setting, a river of warm, melted butter, with oversized utensils or plates peeking out from the lush, pancake-like foliage in the background, a towering pepper mill standing in for a tree.  As the sun rises in this fantastical world, it casts a warm, buttery glow over the scene. The creature, content in its butter river, lets out a yawn. Nearby, a flock of birds take flight"

image = pipe(
    prompt=prompt,
    prompt_3=prompt_3,
    negative_prompt="",
    num_inference_steps=28,
    guidance_scale=4.5,
    max_sequence_length=512,
).images[0]
```

## Tiny AutoEncoder untuk Stable Diffusion 3

Tiny AutoEncoder for Stable Diffusion (TAESD3) adalah versi kecil yang disuling dari VAE Stable Diffusion 3 oleh [Ollin Boer Bohan](https://github.com/madebyollin/taesd) yang dapat mendekode laten [StableDiffusion3Pipeline](/docs/diffusers/main/id/api/pipelines/stable_diffusion/stable_diffusion_3#diffusers.StableDiffusion3Pipeline) hampir seketika.

Untuk digunakan dengan Stable Diffusion 3:

```python
import torch
from diffusers import StableDiffusion3Pipeline, AutoencoderTiny

pipe = StableDiffusion3Pipeline.from_pretrained(
    "stabilityai/stable-diffusion-3-medium-diffusers", dtype=torch.float16
)
pipe.vae = AutoencoderTiny.from_pretrained("madebyollin/taesd3", dtype=torch.float16)
pipe = pipe.to("cuda")  # or "mps", "xpu", "cpu"

prompt = "slice of delicious New York-style berry cheesecake"
image = pipe(prompt, num_inference_steps=25).images[0]
image.save("cheesecake.png")
```

## Memuat checkpoint asli melalui `from_single_file`

Kelas `SD3Transformer2DModel` dan `StableDiffusion3Pipeline` mendukung pemuatan checkpoint asli melalui metode `from_single_file`. Metode ini memungkinkan Anda memuat file checkpoint asli yang digunakan untuk melatih model.

## Memuat checkpoint asli untuk `SD3Transformer2DModel`

```python
from diffusers import SD3Transformer2DModel

model = SD3Transformer2DModel.from_single_file("https://huggingface.co/stabilityai/stable-diffusion-3-medium/blob/main/sd3_medium.safetensors")
```

## Memuat checkpoint tunggal untuk `StableDiffusion3Pipeline`

### Memuat checkpoint file tunggal tanpa T5

```python
import torch
from diffusers import StableDiffusion3Pipeline

pipe = StableDiffusion3Pipeline.from_single_file(
    "https://huggingface.co/stabilityai/stable-diffusion-3-medium/blob/main/sd3_medium_incl_clips.safetensors",
    dtype=torch.float16,
    text_encoder_3=None
)
pipe.enable_model_cpu_offload()

image = pipe("a picture of a cat holding a sign that says hello world").images[0]
image.save('sd3-single-file.png')
```

### Memuat checkpoint file tunggal dengan T5

> [!TIP]
> Contoh berikut memuat checkpoint yang disimpan dalam format 8-bit floating point yang memerlukan PyTorch 2.3 atau lebih baru.

```python
import torch
from diffusers import StableDiffusion3Pipeline

pipe = StableDiffusion3Pipeline.from_single_file(
    "https://huggingface.co/stabilityai/stable-diffusion-3-medium/blob/main/sd3_medium_incl_clips_t5xxlfp8.safetensors",
    dtype=torch.float16,
)
pipe.enable_model_cpu_offload()

image = pipe("a picture of a cat holding a sign that says hello world").images[0]
image.save('sd3-single-file-t5-fp8.png')
```

### Memuat checkpoint file tunggal untuk Model Transformer Stable Diffusion 3.5

```python
import torch
from diffusers import SD3Transformer2DModel, StableDiffusion3Pipeline

transformer = SD3Transformer2DModel.from_single_file(
    "https://huggingface.co/stabilityai/stable-diffusion-3.5-large-turbo/blob/main/sd3.5_large.safetensors",
    dtype=torch.bfloat16,
)
pipe = StableDiffusion3Pipeline.from_pretrained(
    "stabilityai/stable-diffusion-3.5-large",
    transformer=transformer,
    dtype=torch.bfloat16,
)
pipe.enable_model_cpu_offload()
image = pipe("a cat holding a sign that says hello world").images[0]
image.save("sd35.png")
```

## StableDiffusion3Pipeline[[diffusers.StableDiffusion3Pipeline]]

#### diffusers.StableDiffusion3Pipeline[[diffusers.StableDiffusion3Pipeline]]

```python
diffusers.StableDiffusion3Pipeline(transformer: SD3Transformer2DModel, scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKL, text_encoder: CLIPTextModelWithProjection, tokenizer: CLIPTokenizer, text_encoder_2: CLIPTextModelWithProjection, tokenizer_2: CLIPTokenizer, text_encoder_3: T5EncoderModel, tokenizer_3: T5Tokenizer, image_encoder: SiglipVisionModel = None, feature_extractor: SiglipImageProcessorPil = None)
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/stable_diffusion_3/pipeline_stable_diffusion_3.py#L148)

**Parameter:**

transformer ([SD3Transformer2DModel](/docs/diffusers/main/id/api/models/sd3_transformer2d#diffusers.SD3Transformer2DModel)) : Arsitektur Conditional Transformer (MMDiT) untuk mendenoise latens gambar yang telah dikodekan.

scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/id/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Penjadwal yang digunakan bersama `transformer` untuk menghilangkan noise pada latens gambar yang telah dikodekan.

vae ([AutoencoderKL](/docs/diffusers/main/id/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Model Variational Auto-Encoder (VAE) untuk mengodekan dan mendekodekan gambar ke dan dari representasi laten.

text_encoder (`CLIPTextModelWithProjection`) : [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModelWithProjection), khususnya varian [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14), dengan lapisan proyeksi tambahan yang diinisialisasi dengan matriks diagonal berdimensi `hidden_size`.

text_encoder_2 (`CLIPTextModelWithProjection`) : [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).

text_encoder_3 (`T5EncoderModel`) : Pengkode teks beku. Stable Diffusion 3 menggunakan [T5](https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5EncoderModel), khususnya varian [t5-v1_1-xxl](https://huggingface.co/google/t5-v1_1-xxl).

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

tokenizer_3 (`T5TokenizerFast`) : Tokenizer dari kelas [T5Tokenizer](https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5Tokenizer).

image_encoder (`SiglipVisionModel`, *opsional*) : Model Visi yang telah dilatih sebelumnya untuk IP Adapter.

feature_extractor (`SiglipImageProcessor`, *opsional*) : Pemroses gambar untuk IP Adapter.

#### __call__[[diffusers.StableDiffusion3Pipeline.__call__]]

```python
__call__(prompt: str | list[str] = None, prompt_2: str | list[str] | None = None, prompt_3: str | list[str] | None = None, height: int | None = None, width: int | None = None, num_inference_steps: int = 28, sigmas: list[float] | None = None, guidance_scale: float = 7.0, negative_prompt: str | list[str] | None = None, negative_prompt_2: str | list[str] | None = None, negative_prompt_3: str | list[str] | None = None, num_images_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.FloatTensor] = None, prompt_embeds: typing.Optional[torch.FloatTensor] = None, negative_prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = 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: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', return_dict: bool = True, joint_attention_kwargs: dict[str, typing.Any] | None = None, clip_skip: int | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list = ['latents'], max_sequence_length: int = 256, skip_guidance_layers: list = None, skip_layer_guidance_scale: float = 2.8, skip_layer_guidance_stop: float = 0.2, skip_layer_guidance_start: float = 0.01, mu: float | None = None)
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/stable_diffusion_3/pipeline_stable_diffusion_3.py#L772)

**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` akan digunakan sebagai gantinya

prompt_3 (`str` atau `list[str]`, *opsional*) : Prompt atau prompt yang akan dikirim ke `tokenizer_3` dan `text_encoder_3`. Jika tidak didefinisikan, `prompt` akan digunakan sebagai gantinya

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.

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.

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.

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.

guidance_scale (`float`, *opsional*, default 7.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 sebagai gantinya

negative_prompt_3 (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt yang tidak akan memandu generasi gambar untuk dikirim ke `tokenizer_3` dan `text_encoder_3`. Jika tidak didefinisikan, `negative_prompt` digunakan sebagai gantinya

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

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.FloatTensor`, *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.FloatTensor`, *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.FloatTensor`, *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.FloatTensor`, *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 dibuat dari argumen input `prompt`.

negative_pooled_prompt_embeds (`torch.FloatTensor`, *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 (`torch.Tensor`, *opsional*) : Embedding gambar yang telah dibuat sebelumnya untuk IP-Adapter. Harus berupa tensor dengan bentuk `(batch_size, num_images, emb_dim)`. Harus berisi embedding gambar negatif 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_3.StableDiffusion3PipelineOutput` alih-alih tuple biasa.

joint_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).

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`, *opsional*) : Fungsi yang dipanggil di akhir setiap langkah denoising selama inferensi. Fungsi ini dipanggil 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.

max_sequence_length (`int` defaultnya 256) : Panjang maksimum urutan yang digunakan dengan `prompt`.

skip_guidance_layers (`list[int]`, *opsional*) : Daftar bilangan bulat yang menentukan lapisan untuk dilewati selama guidance. Jika tidak disediakan, semua lapisan akan digunakan untuk guidance. Jika disediakan, guidance hanya akan diterapkan pada lapisan yang ditentukan dalam daftar. Nilai yang direkomendasikan oleh StabiltyAI untuk Stable Diffusion 3.5 Medium adalah [7, 8, 9].

skip_layer_guidance_scale (`int`, *opsional*) : Skala panduan untuk lapisan yang ditentukan dalam `skip_guidance_layers`. Panduan akan diterapkan pada lapisan yang ditentukan dalam `skip_guidance_layers` dengan skala `skip_layer_guidance_scale`. Panduan akan diterapkan pada lapisan lainnya dengan skala `1`.

skip_layer_guidance_stop (`int`, *opsional*) : Langkah di mana panduan untuk lapisan yang ditentukan dalam `skip_guidance_layers` akan berhenti. Panduan akan diterapkan pada lapisan yang ditentukan dalam `skip_guidance_layers` hingga fraksi yang ditentukan dalam `skip_layer_guidance_stop`. Nilai yang direkomendasikan oleh StabiltyAI untuk Stable Diffusion 3.5 Medium adalah 0.2.

skip_layer_guidance_start (`int`, *opsional*) : Langkah di mana panduan untuk lapisan yang ditentukan dalam `skip_guidance_layers` akan dimulai. Panduan akan diterapkan pada lapisan yang ditentukan dalam `skip_guidance_layers` dari fraksi yang ditentukan dalam `skip_layer_guidance_start`. Nilai yang direkomendasikan oleh StabiltyAI untuk Stable Diffusion 3.5 Medium adalah 0.01.

mu (`float`, *opsional*) : nilai `mu` yang digunakan untuk `dynamic_shifting`.

**Mengembalikan:** `~pipelines.stable_diffusion_3.StableDiffusion3PipelineOutput` atau `tuple`

`~pipelines.stable_diffusion_3.StableDiffusion3PipelineOutput` 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 StableDiffusion3Pipeline

>>> pipe = StableDiffusion3Pipeline.from_pretrained(
...     "stabilityai/stable-diffusion-3-medium-diffusers", torch_dtype=torch.float16
... )
>>> pipe.to("cuda")
>>> prompt = "A cat holding a sign that says hello world"
>>> image = pipe(prompt).images[0]
>>> image.save("sd3.png")
```

#### encode_image[[diffusers.StableDiffusion3Pipeline.encode_image]]

```python
encode_image(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]], device: device)
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/stable_diffusion_3/pipeline_stable_diffusion_3.py#L696)

**Parameter:**

image (`PipelineImageInput`) : Gambar input yang akan dikodekan.

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

**Mengembalikan:** `torch.Tensor`

Representasi fitur gambar yang telah dikodekan.

Mengkodekan gambar yang diberikan menjadi representasi fitur menggunakan pengkode gambar yang telah dilatih sebelumnya.

#### encode_prompt[[diffusers.StableDiffusion3Pipeline.encode_prompt]]

```python
encode_prompt(prompt: str | list[str], prompt_2: str | list[str], prompt_3: str | list[str], device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, do_classifier_free_guidance: bool = True, negative_prompt: str | list[str] | None = None, negative_prompt_2: str | list[str] | None = None, negative_prompt_3: str | list[str] | None = None, prompt_embeds: typing.Optional[torch.FloatTensor] = None, negative_prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, clip_skip: int | None = None, max_sequence_length: int = 256, lora_scale: float | None = None)
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/stable_diffusion_3/pipeline_stable_diffusion_3.py#L344)

**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 semua text-encoder

prompt_3 (`str` atau `list[str]`, *opsional*) : Prompt atau prompt yang akan dikirim ke `tokenizer_3` dan `text_encoder_3`. Jika tidak didefinisikan, `prompt` digunakan di semua 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 semua text-encoder.

negative_prompt_3 (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt yang tidak akan memandu generasi gambar untuk dikirim ke `tokenizer_3` dan `text_encoder_3`. Jika tidak didefinisikan, `negative_prompt` digunakan di semua text-encoder.

prompt_embeds (`torch.FloatTensor`, *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.FloatTensor`, *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.FloatTensor`, *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 dibuat dari argumen input `prompt`.

negative_pooled_prompt_embeds (`torch.FloatTensor`, *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`.

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.

lora_scale (`float`, *opsional*) : Skala lora yang akan diterapkan ke semua lapisan LoRA dari text encoder jika lapisan LoRA dimuat.

#### prepare_ip_adapter_image_embeds[[diffusers.StableDiffusion3Pipeline.prepare_ip_adapter_image_embeds]]

```python
prepare_ip_adapter_image_embeds(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: typing.Optional[torch.Tensor] = None, device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, do_classifier_free_guidance: bool = True)
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/stable_diffusion_3/pipeline_stable_diffusion_3.py#L716)

**Parameter:**

ip_adapter_image (`PipelineImageInput`, *opsional*) : Gambar input untuk diekstrak fiturnya untuk IP-Adapter.

ip_adapter_image_embeds (`torch.Tensor`, *opsional*) : Embedding gambar yang sudah dihitung sebelumnya.

device : (`torch.device`, *opsional*): Perangkat Torch.

num_images_per_prompt (`int`, defaultnya 1) : Jumlah gambar yang harus dihasilkan per prompt.

do_classifier_free_guidance (`bool`, defaultnya True) : Apakah akan menggunakan classifier free guidance atau tidak.

Menyiapkan embedding gambar untuk digunakan dalam IP-Adapter.

`ip_adapter_image` atau `ip_adapter_image_embeds` harus diteruskan.