# Inpainting

  

Model Stable Diffusion juga dapat diterapkan untuk inpainting, yang memungkinkan Anda mengedit bagian tertentu dari gambar dengan menyediakan mask dan prompt teks menggunakan Stable Diffusion.

## Tips

Disarankan untuk menggunakan pipeline ini dengan checkpoint yang telah di-fine-tune secara khusus untuk inpainting, seperti [stable-diffusion-v1-5/stable-diffusion-inpainting](https://huggingface.co/stable-diffusion-v1-5/stable-diffusion-inpainting). Checkpoint Stable Diffusion text-to-image default, seperti [stable-diffusion-v1-5/stable-diffusion-v1-5](https://huggingface.co/stable-diffusion-v1-5/stable-diffusion-v1-5), juga kompatibel tetapi mungkin kurang performan.

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

## StableDiffusionInpaintPipeline[[diffusers.StableDiffusionInpaintPipeline]]

#### diffusers.StableDiffusionInpaintPipeline[[diffusers.StableDiffusionInpaintPipeline]]

```python
diffusers.StableDiffusionInpaintPipeline(vae: diffusers.models.autoencoders.autoencoder_kl.AutoencoderKL | diffusers.models.autoencoders.autoencoder_asym_kl.AsymmetricAutoencoderKL, 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_inpaint.py#L128)

**Parameter:**

vae ([`AutoencoderKL`, `AsymmetricAutoencoderKL`]) : Model Variational Auto-Encoder (VAE) untuk mengodekan dan mendekodekan gambar ke dan dari representasi laten.

text_encoder (`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 inpainting gambar 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
- [load_ip_adapter()](/docs/diffusers/v0.43.0/id/api/loaders/ip_adapter#diffusers.loaders.IPAdapterMixin.load_ip_adapter) untuk memuat IP Adapter
- untuk memuat file `.ckpt` dengan [from_single_file()](/docs/diffusers/v0.43.0/id/api/loaders/single_file#diffusers.loaders.FromSingleFileMixin.from_single_file)

#### __call__[[diffusers.StableDiffusionInpaintPipeline.__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, mask_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, masked_image_latents: Tensor = None, height: int | None = None, width: int | None = None, padding_mask_crop: int | None = None, strength: float = 1.0, 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, clip_skip: int = 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_inpaint.py#L880)

**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`, array numpy, atau tensor yang merepresentasikan batch gambar untuk di-inpaint (bagian mana dari gambar yang akan dimask dengan `mask_image` dan dilukis ulang sesuai dengan `prompt`). Baik untuk array numpy maupun tensor pytorch, rentang nilai yang diharapkan adalah antara `[0, 1]`. Jika berupa tensor atau daftar tensor, bentuk yang diharapkan adalah `(B, C, H, W)` atau `(C, H, W)`. Jika berupa array numpy atau daftar array, bentuk yang diharapkan adalah `(B, H, W, C)` atau `(H, W, C)`. Parameter ini juga dapat menerima latents gambar sebagai `image`, namun jika latents dilewatkan secara langsung, latents tersebut tidak akan di-encode ulang.

mask_image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]`, atau `list[np.ndarray]`) : `Image`, array numpy, atau tensor yang merepresentasikan batch gambar untuk memasker `image`. Piksel putih pada mask akan diwarnai ulang, sedangkan piksel hitam dipertahankan. Jika `mask_image` adalah gambar PIL, gambar tersebut dikonversi menjadi satu saluran (luminance) sebelum digunakan. Jika berupa array numpy atau tensor pytorch, array/tensor tersebut harus berisi satu saluran warna (L) alih-alih 3, sehingga bentuk yang diharapkan untuk tensor pytorch adalah `(B, 1, H, W)`, `(B, H, W)`, `(1, H, W)`, atau `(H, W)`. Dan untuk array numpy, bentuknya adalah `(B, H, W, 1)`, `(B, H, W)`, `(H, W, 1)`, atau `(H, W)`.

masked_image_latents (`torch.Tensor`, *opsional*) : Laten terenkod praproses dari gambar yang dimasker (untuk inpainting).

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.

padding_mask_crop (`int`, *opsional*, defaultnya `None`) : Ukuran margin pada crop yang akan diterapkan ke gambar dan masking. Jika `None`, tidak ada crop yang diterapkan ke image dan mask_image. Jika `padding_mask_crop` bukan `None`, sistem akan terlebih dahulu menemukan area persegi panjang dengan rasio aspek yang sama dengan gambar dan mencakup semua area yang di-mask, kemudian memperluas area tersebut berdasarkan `padding_mask_crop`. Gambar dan mask_image kemudian akan di-crop berdasarkan area yang telah diperluas sebelum di-resize ke ukuran gambar asli untuk inpainting. Hal ini berguna ketika area yang di-mask kecil sementara gambarnya besar dan mengandung informasi yang tidak relevan untuk inpainting, seperti latar belakang.

strength (`float`, *opsional*, default 1.0) : Menunjukkan sejauh mana transformasi dilakukan pada `image` referensi. 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`.

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

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 PIL
>>> import requests
>>> import torch
>>> from io import BytesIO

>>> from diffusers import StableDiffusionInpaintPipeline

>>> def download_image(url):
...     response = requests.get(url)
...     return PIL.Image.open(BytesIO(response.content)).convert("RGB")

>>> img_url = "https://raw.githubusercontent.com/CompVis/latent-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo.png"
>>> mask_url = "https://raw.githubusercontent.com/CompVis/latent-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo_mask.png"

>>> init_image = download_image(img_url).resize((512, 512))
>>> mask_image = download_image(mask_url).resize((512, 512))

>>> pipe = StableDiffusionInpaintPipeline.from_pretrained(
...     "stable-diffusion-v1-5/stable-diffusion-inpainting", torch_dtype=torch.float16
... )
>>> pipe = pipe.to("cuda")

>>> prompt = "Face of a yellow cat, high resolution, sitting on a park bench"
>>> image = pipe(prompt=prompt, image=init_image, mask_image=mask_image).images[0]
```

#### enable_attention_slicing[[diffusers.StableDiffusionInpaintPipeline.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.StableDiffusionInpaintPipeline.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.StableDiffusionInpaintPipeline.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.StableDiffusionInpaintPipeline.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.StableDiffusionInpaintPipeline.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.StableDiffusionInpaintPipeline.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.StableDiffusionInpaintPipeline.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.StableDiffusionInpaintPipeline.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_inpaint.py#L312)

**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.StableDiffusionInpaintPipeline.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_inpaint.py#L823)

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