Buckets:

hf-doc-build
/

doc

Files
xet
hf-doc-build/doc / diffusers /v0.43.0 /id /api /pipelines /stable_diffusion /text2img.md
mishig
2 days ago
preview code
download
raw
38.4 kB
# Teks-ke-gambar

  

Model Stable Diffusion dibuat oleh peneliti dan insinyur dari [CompVis](https://github.com/CompVis), [Stability AI](https://stability.ai/), [Runway](https://github.com/runwayml), dan [LAION](https://laion.ai/). [StableDiffusionPipeline](/docs/diffusers/v0.43.0/id/api/pipelines/stable_diffusion/text2img#diffusers.StableDiffusionPipeline) mampu menghasilkan gambar fotorealistis dari input teks apa pun. Model ini dilatih pada gambar 512x512 dari subset dataset LAION-5B. Model ini menggunakan text encoder CLIP ViT-L/14 yang dibekukan untuk mengondisikan model pada prompt teks. Dengan UNet 860M dan text encoder 123M, model ini relatif ringan dan dapat dijalankan pada GPU konsumen. Latent diffusion adalah riset yang menjadi dasar pembangunan Stable Diffusion. Riset ini diusulkan dalam [High-Resolution Image Synthesis with Latent Diffusion Models](https://huggingface.co/papers/2112.10752) oleh Robin Rombach, Andreas Blattmann, Dominik Lorenz, Patrick Esser, Björn Ommer.

Abstrak dari makalah tersebut adalah:

*Dengan menguraikan proses pembentukan gambar menjadi penerapan berurutan dari autoencoder denoising, model difusi (DM) mencapai hasil sintesis state-of-the-art pada data gambar dan di luar itu. Selain itu, formulasi mereka memungkinkan mekanisme panduan untuk mengendalikan proses generasi gambar tanpa pelatihan ulang. Namun, karena model-model ini biasanya beroperasi langsung di ruang piksel, optimasi DM yang kuat sering kali mengonsumsi ratusan hari GPU dan inferensi menjadi mahal karena evaluasi berurutan. Untuk memungkinkan pelatihan DM pada sumber daya komputasi yang terbatas sambil mempertahankan kualitas dan fleksibilitas mereka, kami menerapkannya di ruang laten dari autoencoder pretrained yang kuat. Berbeda dengan pekerjaan sebelumnya, pelatihan model difusi pada representasi semacam itu untuk pertama kalinya memungkinkan pencapaian titik yang hampir optimal antara reduksi kompleksitas dan preservasi detail, yang sangat meningkatkan fidelitas visual. Dengan memperkenalkan lapisan cross-attention ke dalam arsitektur model, kami mengubah model difusi menjadi generator yang kuat dan fleksibel untuk input kondisioning umum seperti teks atau bounding box, dan sintesis resolusi tinggi menjadi mungkin secara konvolusional. Model difusi laten (LDM) kami mencapai state of the art baru untuk inpainting gambar dan kinerja yang sangat kompetitif pada berbagai tugas, termasuk generasi gambar tanpa syarat, sintesis adegan semantik, dan super-resolusi, sambil secara signifikan mengurangi persyaratan komputasi dibandingkan DM berbasis piksel. Kode tersedia di https://github.com/CompVis/latent-diffusion.*

> [!TIP]
> Pastikan untuk melihat bagian [Tips](overview#tips) Stable Diffusion untuk mempelajari cara mengeksplorasi tradeoff antara kecepatan dan kualitas scheduler, serta cara menggunakan ulang komponen pipeline secara efisien!
>
> Jika Anda tertarik menggunakan salah satu checkpoint resmi untuk tugas tertentu, jelajahi organisasi Hub [CompVis](https://huggingface.co/CompVis) dan [Stability AI](https://huggingface.co/stabilityai)!

## StableDiffusionPipeline[[diffusers.StableDiffusionPipeline]]

#### diffusers.StableDiffusionPipeline[[diffusers.StableDiffusionPipeline]]

```python
diffusers.StableDiffusionPipeline(vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, unet: UNet2DConditionModel, scheduler: KarrasDiffusionSchedulers, safety_checker: StableDiffusionSafetyChecker, feature_extractor: CLIPImageProcessorPil, image_encoder: CLIPVisionModelWithProjection = None, requires_safety_checker: bool = True)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/stable_diffusion/pipeline_stable_diffusion.py#L154)

**Parameter:**

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

text_encoder ([CLIPTextModel](https://huggingface.co/docs/transformers/v5.22.2/en/model_doc/clip#transformers.CLIPTextModel)) : text-encoder beku ([clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14)).
tokenizer ([CLIPTokenizer](https://huggingface.co/docs/transformers/v5.22.2/en/model_doc/clip#transformers.CLIPTokenizer)) : Sebuah `CLIPTokenizer` untuk melakukan tokenisasi teks.
unet ([UNet2DConditionModel](/docs/diffusers/v0.43.0/id/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Sebuah `UNet2DConditionModel` untuk menghilangkan noise dari latens gambar yang telah dikodekan.
scheduler ([SchedulerMixin](/docs/diffusers/v0.43.0/id/api/schedulers/overview#diffusers.SchedulerMixin)) : Penjadwal yang digunakan bersama `unet` untuk menghilangkan noise pada latens gambar yang telah dikodekan. Bisa berupa [DDIMScheduler](/docs/diffusers/v0.43.0/id/api/schedulers/ddim#diffusers.DDIMScheduler), [LMSDiscreteScheduler](/docs/diffusers/v0.43.0/id/api/schedulers/lms_discrete#diffusers.LMSDiscreteScheduler), atau [PNDMScheduler](/docs/diffusers/v0.43.0/id/api/schedulers/pndm#diffusers.PNDMScheduler).
safety_checker (`StableDiffusionSafetyChecker`) : Modul klasifikasi yang memperkirakan apakah gambar yang dihasilkan dapat dianggap ofensif atau berbahaya. Silakan lihat [model card](https://huggingface.co/stable-diffusion-v1-5/stable-diffusion-v1-5) untuk detail lebih lanjut tentang potensi bahaya suatu model.

feature_extractor ([CLIPImageProcessor](https://huggingface.co/docs/transformers/v5.22.2/en/model_doc/clip#transformers.CLIPImageProcessor)) : Sebuah `CLIPImageProcessor` untuk mengekstrak fitur dari gambar yang dihasilkan; digunakan sebagai input untuk `safety_checker`.

Pipeline untuk generasi teks-ke-gambar menggunakan Stable Diffusion.

Model ini mewarisi dari [DiffusionPipeline](/docs/diffusers/v0.43.0/id/api/pipelines/overview#diffusers.DiffusionPipeline). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan untuk semua pipeline (mengunduh, menyimpan, menjalankan pada perangkat tertentu, dll.).

Pipeline juga mewarisi metode pemuatan berikut:
- [load_textual_inversion()](/docs/diffusers/v0.43.0/id/api/loaders/textual_inversion#diffusers.loaders.TextualInversionLoaderMixin.load_textual_inversion) untuk memuat embedding textual inversion
- [load_lora_weights()](/docs/diffusers/v0.43.0/id/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) untuk memuat bobot LoRA
- [save_lora_weights()](/docs/diffusers/v0.43.0/id/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) untuk menyimpan bobot LoRA
- untuk memuat file `.ckpt` dengan [from_single_file()](/docs/diffusers/v0.43.0/id/api/loaders/single_file#diffusers.loaders.FromSingleFileMixin.from_single_file)
- [load_ip_adapter()](/docs/diffusers/v0.43.0/id/api/loaders/ip_adapter#diffusers.loaders.IPAdapterMixin.load_ip_adapter) untuk memuat IP Adapter

#### __call__[[diffusers.StableDiffusionPipeline.__call__]]

```python
__call__(prompt: str | list[str] = None, height: int | None = None, width: int | None = None, num_inference_steps: int = 50, timesteps: list[int] = None, sigmas: list[float] = None, guidance_scale: float = 7.5, negative_prompt: 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, 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, clip_skip: int | None = None, callback_on_step_end: typing.Union[typing.Callable[[int, int], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], **kwargs)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/stable_diffusion/pipeline_stable_diffusion.py#L778)

**Parameter:**

prompt (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt untuk memandu generasi gambar. Jika tidak didefinisikan, Anda perlu meneruskan `prompt_embeds`.

height (`int`, *opsional*, defaultnya `self.unet.config.sample_size * self.vae_scale_factor`) : Tinggi gambar yang dihasilkan dalam piksel.

width (`int`, *opsional*, defaultnya `self.unet.config.sample_size * self.vae_scale_factor`) : Lebar gambar yang dihasilkan dalam piksel.

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.

guidance_scale (`float`, *opsional*, default 7.5) : Nilai guidance scale yang lebih tinggi mendorong model untuk menghasilkan gambar yang sangat terkait dengan `prompt` teks, dengan mengorbankan kualitas gambar yang lebih rendah. Guidance scale diaktifkan ketika `guidance_scale > 1`.

negative_prompt (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt untuk mengarahkan apa yang tidak boleh disertakan dalam pembuatan gambar. Jika tidak didefinisikan, Anda perlu meneruskan `negative_prompt_embeds` sebagai gantinya. Diabaikan saat tidak menggunakan panduan (`guidance_scale < 1`).

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 (η) dari paper [DDIM](https://huggingface.co/papers/2010.02502). Hanya berlaku untuk [DDIMScheduler](/docs/diffusers/v0.43.0/id/api/schedulers/ddim#diffusers.DDIMScheduler), dan diabaikan pada scheduler lainnya.
generator (`torch.Generator` atau `list[torch.Generator]`, *opsional*) : Sebuah [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) untuk membuat proses generasi menjadi deterministik.
latents (`torch.Tensor`, *opsional*) : Laten berisik yang telah dibuat sebelumnya, diambil dari distribusi Gaussian, untuk digunakan sebagai input untuk generasi gambar. Dapat digunakan untuk menyesuaikan generasi yang sama dengan prompt yang berbeda. Jika tidak disediakan, tensor laten akan dibuat dengan pengambilan sampel menggunakan `generator` acak yang diberikan.
prompt_embeds (`torch.Tensor`, *opsional*) : Embedding teks yang telah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks (pemberian bobot pada 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 (pemberian bobot pada prompt). Jika tidak disediakan, `negative_prompt_embeds` akan dibuat 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.Image` atau `np.array`.

return_dict (`bool`, *opsional*, defaultnya `True`) : Apakah akan mengembalikan [StableDiffusionPipelineOutput](/docs/diffusers/v0.43.0/id/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) alih-alih tuple biasa.
cross_attention_kwargs (`dict`, *opsional*) : Kamus kwargs yang jika ditentukan akan diteruskan ke `AttentionProcessor` seperti yang didefinisikan dalam [`self.processor`](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).
guidance_rescale (`float`, *opsional*, default 0.0) : Faktor rescale guidance dari [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://huggingface.co/papers/2305.08891). Faktor rescale guidance harus memperbaiki overexposure saat menggunakan zero terminal SNR.

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:** [StableDiffusionPipelineOutput](/docs/diffusers/v0.43.0/id/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) atau `tuple`

Jika `return_dict` adalah `True`, [StableDiffusionPipelineOutput](/docs/diffusers/v0.43.0/id/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) dikembalikan, selain itu sebuah `tuple` dikembalikan di mana elemen pertama adalah daftar dengan gambar yang dihasilkan dan elemen kedua adalah daftar `bool` yang menunjukkan apakah gambar yang dihasilkan yang sesuai mengandung konten "not-safe-for-work" (nsfw).

Fungsi panggilan untuk pipeline pada generasi.

Contoh:
```py
>>> import torch
>>> from diffusers import StableDiffusionPipeline
>>> pipe = StableDiffusionPipeline.from_pretrained(
...     "stable-diffusion-v1-5/stable-diffusion-v1-5", torch_dtype=torch.float16
... )
>>> pipe = pipe.to("cuda")
>>> prompt = "a photo of an astronaut riding a horse on mars"
>>> image = pipe(prompt).images[0]
```

#### enable_attention_slicing[[diffusers.StableDiffusionPipeline.enable_attention_slicing]]

```python
enable_attention_slicing(slice_size: str | int = 'auto')
```

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

**Parameter:**

slice_size (`str` atau `int`, *opsional*, defaultnya `"auto"`) : Ketika `"auto"`, input ke attention heads dibagi dua, sehingga attention akan dihitung dalam dua langkah. Jika `"max"`, jumlah memori maksimum akan dihemat dengan hanya menjalankan satu slice pada satu waktu. Jika angka diberikan, menggunakan sebanyak slice sebanyak `attention_head_dim // slice_size`. Dalam kasus ini, `attention_head_dim` harus merupakan kelipatan dari `slice_size`.
Aktifkan perhitungan perhatian terpotong. Ketika opsi ini diaktifkan, modul perhatian membagi tensor input menjadi potongan-potongan untuk menghitung perhatian dalam beberapa langkah. Untuk lebih dari satu kepala perhatian, perhitungan dilakukan secara berurutan untuk setiap kepala. Ini berguna untuk menghemat sebagian memori dengan mengorbankan sedikit penurunan kecepatan.
> [!WARNING] > ⚠️ Jangan aktifkan attention slicing jika Anda sudah menggunakan `scaled_dot_product_attention` (SDPA)
dari PyTorch > 2.0 atau xFormers. Perhitungan atensi ini sudah sangat hemat memori sehingga Anda tidak perlu mengaktifkan > fungsi ini. Jika Anda mengaktifkan pemotongan atensi dengan SDPA atau xFormers, hal itu dapat menyebabkan perlambatan yang serius!

Contoh:

```py
>>> import torch
>>> from diffusers import StableDiffusionPipeline
>>> pipe = StableDiffusionPipeline.from_pretrained(
...     "stable-diffusion-v1-5/stable-diffusion-v1-5",
...     dtype=torch.float16,
...     use_safetensors=True,
... )
>>> prompt = "a photo of an astronaut riding a horse on mars"
>>> pipe.enable_attention_slicing()
>>> image = pipe(prompt).images[0]
```

#### disable_attention_slicing[[diffusers.StableDiffusionPipeline.disable_attention_slicing]]

```python
disable_attention_slicing()
```

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

Nonaktifkan perhitungan perhatian yang dipotong. Jika `enable_attention_slicing` sebelumnya dipanggil, perhatian dihitung dalam satu langkah.

#### enable_xformers_memory_efficient_attention[[diffusers.StableDiffusionPipeline.enable_xformers_memory_efficient_attention]]

```python
enable_xformers_memory_efficient_attention(attention_op: typing.Optional[typing.Callable] = None)
```

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

**Parameter:**

attention_op (`Callable`, *opsional*) : Menimpa operator `None` bawaan untuk digunakan sebagai argumen `op` pada fungsi [`memory_efficient_attention()`](https://facebookresearch.github.io/xformers/components/ops.html#xformers.ops.memory_efficient_attention) dari xFormers.
Aktifkan perhatian hemat memori dari [xFormers](https://facebookresearch.github.io/xformers/). Ketika opsi ini diaktifkan, Anda seharusnya mengamati penggunaan memori GPU yang lebih rendah dan potensi percepatan selama inferensi. Percepatan selama pelatihan tidak dijamin.
> [!WARNING] > ⚠️ Ketika memory efficient attention dan sliced attention keduanya diaktifkan, memory efficient
attention memiliki > preseden.
Contoh:
```py
>>> import torch
>>> from diffusers import DiffusionPipeline
>>> from xformers.ops import MemoryEfficientAttentionFlashAttentionOp
>>> pipe = DiffusionPipeline.from_pretrained("stabilityai/stable-diffusion-2-1", dtype=torch.float16)
>>> pipe = pipe.to("cuda")
>>> pipe.enable_xformers_memory_efficient_attention(attention_op=MemoryEfficientAttentionFlashAttentionOp)
>>> # Workaround for not accepting attention shape using VAE for Flash Attention
>>> pipe.vae.enable_xformers_memory_efficient_attention(attention_op=None)
```
#### disable_xformers_memory_efficient_attention[[diffusers.StableDiffusionPipeline.disable_xformers_memory_efficient_attention]]
```python
disable_xformers_memory_efficient_attention()
```
[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L2006)
Nonaktifkan perhatian hemat memori dari [xFormers](https://facebookresearch.github.io/xformers/).
#### load_textual_inversion[[diffusers.StableDiffusionPipeline.load_textual_inversion]]
```python
load_textual_inversion(pretrained_model_name_or_path: str | list[str] | dict[str, torch.Tensor] | list[dict[str, torch.Tensor]], token: str | list[str] | None = None, tokenizer: 'PreTrainedTokenizer' | None = None, text_encoder: 'PreTrainedModel' | None = None, **kwargs)
```
[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/textual_inversion.py#L271)
**Parameter:**
pretrained_model_name_or_path (`str` atau `os.PathLike` atau `list[str or os.PathLike]` atau `Dict` atau `list[Dict]`) : Dapat berupa salah satu dari berikut ini atau daftar dari salah satu di antaranya: - String, *model id* (misalnya `sd-concepts-library/low-poly-hd-logos-icons`) dari model pretrained yang dihosting di Hub. - Path ke *directory* (misalnya `./my_text_inversion_directory/`) yang berisi bobot textual inversion. - Path ke *file* (misalnya `./my_text_inversions.pt`) yang berisi bobot textual inversion. - [torch state dict](https://pytorch.org/tutorials/beginner/saving_loading_models.html#what-is-a-state-dict).

token (`str` atau `list[str]`, *opsional*) : Menimpa token yang digunakan untuk bobot inversi tekstual. Jika `pretrained_model_name_or_path` adalah daftar, maka `token` juga harus berupa daftar dengan panjang yang sama.

text_encoder ([CLIPTextModel](https://huggingface.co/docs/transformers/v5.22.2/en/model_doc/clip#transformers.CLIPTextModel), *opsional*) : Text-encoder beku ([clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14)). Jika tidak ditentukan, fungsi akan mengambil self.tokenizer.
tokenizer ([CLIPTokenizer](https://huggingface.co/docs/transformers/v5.22.2/en/model_doc/clip#transformers.CLIPTokenizer), *opsional*) : `CLIPTokenizer` untuk melakukan tokenisasi teks. Jika tidak ditentukan, fungsi akan mengambil self.tokenizer.
weight_name (`str`, *opsional*) : Nama file bobot kustom. Ini harus digunakan ketika: - File textual inversion yang disimpan berada dalam format 🤗 Diffusers, tetapi disimpan dengan nama bobot tertentu seperti `text_inv.bin`. - File textual inversion yang disimpan berada dalam format Automatic1111.

cache_dir (`str | os.PathLike`, *opsional*) : Path ke direktori tempat konfigurasi model pretrained yang diunduh di-cache jika cache standar tidak digunakan.
force_download (`bool`, *opsional*, defaultnya `False`) : Apakah akan memaksa (mengunduh ulang) bobot model dan file konfigurasi, menimpa versi yang di-cache jika ada.

proxies (`dict[str, str]`, *opsional*) : Kamus server proxy yang akan digunakan berdasarkan protokol atau endpoint, misalnya `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}`. Proxy digunakan pada setiap permintaan.

local_files_only (`bool`, *opsional*, defaultnya `False`) : Apakah hanya memuat bobot model dan file konfigurasi lokal atau tidak. Jika diatur ke `True`, model tidak akan diunduh dari Hub.

hf_token (`str` atau *bool*, *opsional*) : Token yang digunakan sebagai otorisasi bearer HTTP untuk file jarak jauh. Jika `True`, token yang dihasilkan dari `diffusers-cli login` (disimpan di `~/.huggingface`) akan digunakan.
revision (`str`, *opsional*, defaultnya `"main"`) : Versi model spesifik yang akan digunakan. Bisa berupa nama branch, nama tag, id commit, atau identifikasi apa pun yang diizinkan oleh Git.
subfolder (`str`, *opsional*, defaultnya `""`) : Lokasi subfolder dari file model di dalam repositori model yang lebih besar di Hub atau secara lokal.
mirror (`str`, *opsional*) : Sumber cermin untuk menyelesaikan masalah aksesibilitas jika Anda mengunduh model di Tiongkok. Kami tidak menjamin ketepatan waktu atau keamanan sumber, dan Anda harus merujuk ke situs cermin untuk informasi lebih lanjut.
Muat embedding Textual Inversion ke dalam text encoder dari [StableDiffusionPipeline](/docs/diffusers/v0.43.0/id/api/pipelines/stable_diffusion/text2img#diffusers.StableDiffusionPipeline) (format 🤗 Diffusers dan Automatic1111 didukung).
Contoh:
Untuk memuat vektor embedding Textual Inversion dalam format 🤗 Diffusers:
```py
from diffusers import StableDiffusionPipeline
import torch
model_id = "stable-diffusion-v1-5/stable-diffusion-v1-5"
pipe = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float16).to("cuda")
pipe.load_textual_inversion("sd-concepts-library/cat-toy")
prompt = "A <cat-toy> backpack"
image = pipe(prompt, num_inference_steps=50).images[0]
image.save("cat-backpack.png")
```
Untuk memuat vektor embedding Textual Inversion dalam format Automatic1111, pastikan untuk mengunduh vektornya terlebih dahulu (misalnya dari [civitAI](https://civitai.com/models/3036?modelVersionId=9857)) dan kemudian memuat vektor tersebut
secara lokal:
```py
from diffusers import StableDiffusionPipeline
import torch
model_id = "stable-diffusion-v1-5/stable-diffusion-v1-5"
pipe = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float16).to("cuda")
pipe.load_textual_inversion("./charturnerv2.pt", token="charturnerv2")
prompt = "charturnerv2, multiple views of the same character in the same outfit, a character turnaround of a woman wearing a black jacket and red shirt, best quality, intricate details."
image = pipe(prompt, num_inference_steps=50).images[0]
image.save("character.png")
```
#### from_single_file[[diffusers.StableDiffusionPipeline.from_single_file]]
```python
from_single_file(pretrained_model_link_or_path, **kwargs)
```
[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/single_file.py#L248)
**Parameter:**
pretrained_model_link_or_path (`str` atau `os.PathLike`, *opsional*) : Bisa berupa: - Tautan ke file `.ckpt` (misalnya `"https://huggingface.co/<repo_id>/blob/main/<path_to_file>.ckpt"`) di Hub. - Path ke *file* yang berisi semua bobot pipeline.
dtype (`str` atau `torch.dtype`, *opsional*) : Menimpa `torch.dtype` bawaan dan memuat model dengan dtype lain.
force_download (`bool`, *opsional*, defaultnya `False`) : Apakah akan memaksa (mengunduh ulang) bobot model dan file konfigurasi, menimpa versi yang di-cache jika ada.

cache_dir (`str | os.PathLike`, *opsional*) : Path ke direktori tempat konfigurasi model pretrained yang diunduh di-cache jika cache standar tidak digunakan.
proxies (`dict[str, str]`, *opsional*) : Kamus server proxy yang akan digunakan berdasarkan protokol atau endpoint, misalnya `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}`. Proxy digunakan pada setiap permintaan.
local_files_only (`bool`, *opsional*, defaultnya `False`) : Apakah hanya memuat bobot model dan file konfigurasi lokal atau tidak. Jika diatur ke `True`, model tidak akan diunduh dari Hub.
token (`str` atau *bool*, *opsional*) : Token yang digunakan sebagai otorisasi bearer HTTP untuk file jarak jauh. Jika `True`, token yang dihasilkan dari `diffusers-cli login` (disimpan di `~/.huggingface`) akan digunakan.
revision (`str`, *opsional*, defaultnya `"main"`) : Versi model spesifik yang akan digunakan. Bisa berupa nama branch, nama tag, id commit, atau identifikasi apa pun yang diizinkan oleh Git.
original_config_file (`str`, *opsional*) : Path ke file config asli yang digunakan untuk melatih model. Jika tidak disediakan, file config akan disimpulkan dari file checkpoint.
config (`str`, *opsional*) : Bisa berupa: - String, *repo id* (misalnya `CompVis/ldm-text2im-large-256`) dari pipeline pretrained yang dihosting di Hub. - Path ke *direktori* (misalnya `./my_pipeline_directory/`) yang berisi konfigurasi komponen pipeline dalam format Diffusers.
disable_mmap ('bool', *opsional*, default 'False') : Apakah akan menonaktifkan mmap saat memuat model Safetensors. Opsi ini dapat memberikan performa yang lebih baik ketika model berada di network mount atau hard drive.

kwargs (sisa kamus argumen kata kunci, *opsional*) : Dapat digunakan untuk menimpa variabel yang dapat dimuat dan disimpan (komponen pipeline dari kelas pipeline tertentu). Komponen yang ditimpa tersebut diteruskan langsung ke metode `__init__` pipeline. Lihat contoh di bawah untuk informasi lebih lanjut.

Instansiasi [DiffusionPipeline](/docs/diffusers/v0.43.0/id/api/pipelines/overview#diffusers.DiffusionPipeline) dari bobot pipeline pretrained yang disimpan dalam format `.ckpt` atau `.safetensors`. Pipeline secara default diatur dalam mode evaluasi (`model.eval()`).

Contoh:

```py
>>> from diffusers import StableDiffusionPipeline
>>> # Download pipeline from huggingface.co and cache.
>>> pipeline = StableDiffusionPipeline.from_single_file(
...     "https://huggingface.co/WarriorMama777/OrangeMixs/blob/main/Models/AbyssOrangeMix/AbyssOrangeMix.safetensors"
... )
>>> # Download pipeline from local file
>>> # file is downloaded under ./v1-5-pruned-emaonly.ckpt
>>> pipeline = StableDiffusionPipeline.from_single_file("./v1-5-pruned-emaonly.ckpt")
>>> # Enable float16 and move to GPU
>>> pipeline = StableDiffusionPipeline.from_single_file(
...     "https://huggingface.co/stable-diffusion-v1-5/stable-diffusion-v1-5/blob/main/v1-5-pruned-emaonly.ckpt",
...     torch_dtype=torch.float16,
... )
>>> pipeline.to("cuda")
```

#### load_lora_weights[[diffusers.StableDiffusionPipeline.load_lora_weights]]

```python
load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L148)

**Parameter:**

pretrained_model_name_or_path_or_dict (`str` atau `os.PathLike` atau `dict`) : Lihat [lora_state_dict()](/docs/diffusers/v0.43.0/id/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict).

adapter_name (`str`, *opsional*) : Nama adapter yang akan digunakan untuk merujuk model adapter yang dimuat. Jika tidak ditentukan, akan digunakan `default_{i}` di mana i adalah total jumlah adapter yang dimuat.

low_cpu_mem_usage (`bool`, *opsional*) : Mempercepat pemuatan model dengan hanya memuat bobot LoRA pretrained dan tidak menginisialisasi bobot acak.
hotswap (`bool`, *opsional*) : Bawaan adalah `False`. Apakah akan mengganti adapter (LoRA) yang sudah ada dengan adapter yang baru dimuat secara in-place. Artinya, alih-alih memuat adapter tambahan, proses ini akan mengambil bobot adapter yang ada dan menggantinya dengan bobot dari adapter baru. Hal ini bisa lebih cepat dan lebih efisien dalam penggunaan memori. Namun, keunggulan utama dari hotswapping adalah ketika model dikompilasi dengan torch.compile, pemuatan adapter baru tidak memerlukan kompilasi ulang model. Saat menggunakan hotswapping, `adapter_name` yang diberikan harus berupa nama dari adapter yang sudah dimuat. Jika adapter baru dan adapter lama memiliki rank dan/atau LoRA alphas (yaitu scaling) yang berbeda, Anda perlu memanggil metode tambahan sebelum memuat adapter: ```py pipeline = ...  # load diffusers pipeline max_rank = ...  # the highest rank among all LoRAs that you want to load # call *before* compiling and loading the LoRA adapter pipeline.enable_lora_hotswap(target_rank=max_rank) pipeline.load_lora_weights(file_name) # optionally compile the model now ``` Perhatikan bahwa hotswapping adapter untuk text encoder belum didukung. Ada beberapa keterbatasan lain untuk teknik ini, yang didokumentasikan di sini: https://huggingface.co/docs/peft/main/en/package_reference/hotswap
kwargs (`dict`, *opsional*) : Lihat [lora_state_dict()](/docs/diffusers/v0.43.0/id/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict).
Muat bobot LoRA yang ditentukan dalam `pretrained_model_name_or_path_or_dict` ke `self.unet` dan `self.text_encoder`.

Semua kwargs diteruskan ke `self.lora_state_dict`.

Lihat [lora_state_dict()](/docs/diffusers/v0.43.0/id/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) untuk detail lebih lanjut tentang cara state dict dimuat.

Lihat [load_lora_into_unet()](/docs/diffusers/v0.43.0/id/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) untuk detail lebih lanjut tentang bagaimana state dict dimuat ke dalam `self.unet`.

Lihat [load_lora_into_text_encoder()](/docs/diffusers/v0.43.0/id/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_text_encoder) untuk detail lebih lanjut tentang bagaimana state dict dimuat ke dalam `self.text_encoder`.

#### save_lora_weights[[diffusers.StableDiffusionPipeline.save_lora_weights]]

```python
save_lora_weights(save_directory: str | os.PathLike, unet_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, text_encoder_lora_layers: dict[str, torch.nn.Module] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, unet_lora_adapter_metadata = None, text_encoder_lora_adapter_metadata = None)
```

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

**Parameter:**

save_directory (`str` atau `os.PathLike`) : Direktori untuk menyimpan parameter LoRA. Akan dibuat jika belum ada.
unet_lora_layers (`dict[str, torch.nn.Module]` atau `dict[str, torch.Tensor]`) : State dict dari lapisan LoRA yang sesuai dengan `unet`.
text_encoder_lora_layers (`dict[str, torch.nn.Module]` atau `dict[str, torch.Tensor]`) : State dict dari lapisan LoRA yang sesuai dengan `text_encoder`. Anda harus secara eksplisit meneruskan state dict LoRA untuk text encoder karena berasal dari 🤗 Transformers.

is_main_process (`bool`, *opsional*, defaultnya `True`) : Apakah proses yang memanggil ini adalah proses utama atau tidak. Berguna selama pelatihan terdistribusi dan Anda perlu memanggil fungsi ini di semua proses. Dalam kasus ini, atur `is_main_process=True` hanya pada proses utama untuk menghindari kondisi balapan.

save_function (`Callable`) : Fungsi yang digunakan untuk menyimpan state dictionary. Berguna selama pelatihan terdistribusi ketika Anda perlu mengganti `torch.save` dengan metode lain. Dapat dikonfigurasi dengan variabel lingkungan `DIFFUSERS_SAVE_MODE`.
safe_serialization (`bool`, *opsional*, defaultnya `True`) : Apakah model disimpan menggunakan `safetensors` atau cara tradisional PyTorch dengan `pickle`.

unet_lora_adapter_metadata : Metadata adapter LoRA yang terkait dengan unet untuk diserialisasi bersama state dict.
text_encoder_lora_adapter_metadata : Metadata adapter LoRA yang terkait dengan text encoder untuk diserialisasi bersama state dict.
Simpan parameter LoRA yang sesuai dengan UNet dan text encoder.
#### encode_prompt[[diffusers.StableDiffusionPipeline.encode_prompt]]
```python
encode_prompt(prompt, device, num_images_per_prompt, do_classifier_free_guidance, negative_prompt = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, lora_scale: float | None = None, clip_skip: int | None = None)
```
[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/stable_diffusion/pipeline_stable_diffusion.py#L332)
**Parameter:**
prompt (`str` atau `list[str]`, *opsional*) : prompt yang akan dienkod
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`).
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`.
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.StableDiffusionPipeline.get_guidance_scale_embedding]]
```python
get_guidance_scale_embedding(w: Tensor, embedding_dim: int = 512, dtype: dtype = torch.float32)
```
[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/stable_diffusion/pipeline_stable_diffusion.py#L717)
**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
## StableDiffusionPipelineOutput[[diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput]]
#### diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput[[diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput]]
```python
diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput(images: list[PIL.Image.Image] | numpy.ndarray, nsfw_content_detected: list[bool] | None)
```
[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/stable_diffusion/pipeline_output.py#L10)
**Parameter:**
images (`list[PIL.Image.Image]` atau `np.ndarray`) : daftar gambar PIL yang telah didenoise dengan panjang `batch_size` atau array NumPy dengan bentuk `(batch_size, height, width, num_channels)`.

nsfw_content_detected (`list[bool]`) : daftar yang menunjukkan apakah gambar yang dihasilkan yang sesuai mengandung konten "not-safe-for-work" (nsfw) atau `None` jika pemeriksaan keamanan tidak dapat dilakukan.

Kelas output untuk pipeline Stable Diffusion.
Xet Storage Details

Size:: 38.4 kB
Xet hash:: 73e696c856862870b6e0af32150d58493ae7cb3da582f00a54020638e0495d3e
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.