Buckets:

hf-doc-build
/

doc

Files
xet
hf-doc-build/doc / diffusers /v0.43.0 /id /api /pipelines /stable_diffusion /depth2img.md
mishig
2 days ago
preview code
download
raw
29.3 kB
# Depth-to-image

  

Model Stable Diffusion juga dapat memperkirakan kedalaman berdasarkan gambar menggunakan [MiDaS](https://github.com/isl-org/MiDaS). Hal ini memungkinkan Anda untuk memberikan prompt teks dan gambar awal untuk mengondisikan pembuatan gambar baru, serta `depth_map` untuk mempertahankan struktur gambar.

> [!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)!

## StableDiffusionDepth2ImgPipeline[[diffusers.StableDiffusionDepth2ImgPipeline]]

#### diffusers.StableDiffusionDepth2ImgPipeline[[diffusers.StableDiffusionDepth2ImgPipeline]]

```python
diffusers.StableDiffusionDepth2ImgPipeline(vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, unet: UNet2DConditionModel, scheduler: KarrasDiffusionSchedulers, depth_estimator: DPTForDepthEstimation, feature_extractor: DPTImageProcessorPil)
```

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

**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).
Pipeline untuk generasi gambar-dari-gambar berbasis kedalaman yang dipandu teks 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
#### __call__[[diffusers.StableDiffusionDepth2ImgPipeline.__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]] = None, depth_map: typing.Optional[torch.Tensor] = None, strength: float = 0.8, num_inference_steps: int | None = 50, guidance_scale: float | None = 7.5, negative_prompt: str | list[str] | None = None, num_images_per_prompt: int | None = 1, eta: float | None = 0.0, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', return_dict: bool = True, cross_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[str] = ['latents'], **kwargs)
```
[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/stable_diffusion/pipeline_stable_diffusion_depth2img.py#L634)
**Parameter:**
prompt (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt untuk memandu generasi gambar. Jika tidak didefinisikan, Anda perlu meneruskan `prompt_embeds`.

image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]`, atau `list[np.ndarray]`) : `Image` atau tensor yang mewakili batch gambar untuk digunakan sebagai titik awal. Dapat menerima latens gambar sebagai `image` hanya jika `depth_map` bukan `None`.

depth_map (`torch.Tensor`, *opsional*) : Prediksi kedalaman yang akan digunakan sebagai kondisioning tambahan untuk proses generasi gambar. Jika tidak didefinisikan, kedalaman akan diprediksi secara otomatis dengan `self.depth_estimator`.

strength (`float`, *opsional*, default 0.8) : Menunjukkan sejauh mana `image` referensi akan ditransformasi. Nilai harus berada di antara 0 dan 1. `image` digunakan sebagai titik awal, dan semakin tinggi nilai `strength`, semakin banyak noise yang ditambahkan. Jumlah langkah denoising bergantung pada jumlah noise yang ditambahkan di awal. Ketika `strength` bernilai 1, noise yang ditambahkan maksimal dan proses denoising berjalan untuk jumlah iterasi penuh yang ditentukan dalam `num_inference_steps`. Nilai 1 pada dasarnya mengabaikan `image`.

num_inference_steps (`int`, *opsional*, default 50) : Jumlah langkah denoising. Semakin banyak langkah denoising, biasanya menghasilkan gambar dengan kualitas lebih tinggi, namun dengan biaya inferensi yang lebih lambat. Parameter ini dimodulasi oleh `strength`.

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

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

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.

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

Fungsi panggilan untuk pipeline pada generasi.

Contoh:

```py
>>> import torch
>>> import requests
>>> from PIL import Image
>>> from diffusers import StableDiffusionDepth2ImgPipeline
>>> pipe = StableDiffusionDepth2ImgPipeline.from_pretrained(
...     "stabilityai/stable-diffusion-2-depth",
...     torch_dtype=torch.float16,
... )
>>> pipe.to("cuda")
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> init_image = Image.open(requests.get(url, stream=True).raw)
>>> prompt = "two tigers"
>>> n_prompt = "bad, deformed, ugly, bad anotomy"
>>> image = pipe(prompt=prompt, image=init_image, negative_prompt=n_prompt, strength=0.7).images[0]
```

#### enable_attention_slicing[[diffusers.StableDiffusionDepth2ImgPipeline.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.StableDiffusionDepth2ImgPipeline.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.StableDiffusionDepth2ImgPipeline.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.StableDiffusionDepth2ImgPipeline.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.StableDiffusionDepth2ImgPipeline.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")
```
#### load_lora_weights[[diffusers.StableDiffusionDepth2ImgPipeline.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.StableDiffusionDepth2ImgPipeline.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.StableDiffusionDepth2ImgPipeline.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_depth2img.py#L204)
**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.
## 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:: 29.3 kB
Xet hash:: 8cc075d2a93630627fe94c483ba4628e14adaf9aba62c53d0c0e82b4ddd1239b
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.