# Stable unCLIP

  

Checkpoint Stable unCLIP ditala ulang dari checkpoint [Stable Diffusion 2.1](./stable_diffusion/stable_diffusion_2) untuk mengondisikan pada embedding gambar CLIP. Stable unCLIP tetap mengondisikan pada embedding teks. Dengan dua pengkondisian terpisah tersebut, Stable unCLIP dapat digunakan untuk variasi gambar yang dipandu teks. Ketika dikombinasikan dengan prior unCLIP, ia juga dapat digunakan untuk generasi teks ke gambar secara penuh.

Abstrak dari makalah tersebut adalah:

*Model kontrasif seperti CLIP telah terbukti mampu mempelajari representasi gambar yang robust, yang menangkap baik semantik maupun gaya. Untuk memanfaatkan representasi ini untuk generasi gambar, kami mengusulkan model dua tahap: prior yang menghasilkan embedding gambar CLIP berdasarkan caption teks, dan decoder yang menghasilkan gambar yang dikondisikan pada embedding gambar tersebut. Kami menunjukkan bahwa secara eksplisit menghasilkan representasi gambar meningkatkan keragaman gambar dengan kehilangan minimal dalam hal fotorealisme dan kemiripan caption. Decoder kami yang dikondisikan pada representasi gambar juga dapat menghasilkan variasi dari sebuah gambar yang mempertahankan baik semantik maupun gayanya, sambil memvariasikan detail non-esensial yang tidak ada dalam representasi gambar tersebut. Selain itu, ruang embedding gabungan dari CLIP memungkinkan manipulasi gambar yang dipandu bahasa secara zero-shot. Kami menggunakan model difusi untuk decoder dan bereksperimen dengan model autoregresif maupun model difusi untuk prior, dan menemukan bahwa yang terakhir secara komputasi lebih efisien dan menghasilkan sampel dengan kualitas yang lebih tinggi.*

## Tips

Stable unCLIP mengambil `noise_level` sebagai input selama inferensi, yang menentukan seberapa banyak noise yang ditambahkan ke embedding gambar. Nilai `noise_level` yang lebih tinggi meningkatkan variasi pada gambar final yang telah di-un-noise. Secara default, kami tidak menambahkan noise tambahan apa pun ke embedding gambar (`noise_level = 0`).

### Generasi Teks-ke-Gambar
Stable unCLIP dapat dimanfaatkan untuk generasi teks-ke-gambar dengan memipelinnya bersama model prior dari replikasi DALL-E 2 open source KakaoBrain, [Karlo](https://huggingface.co/kakaobrain/karlo-v1-alpha):

```python
import torch
from diffusers import UnCLIPScheduler, DDPMScheduler, StableUnCLIPPipeline
from diffusers.models import PriorTransformer
from transformers import CLIPTokenizer, CLIPTextModelWithProjection

prior_model_id = "kakaobrain/karlo-v1-alpha"
data_type = torch.float16
prior = PriorTransformer.from_pretrained(prior_model_id, subfolder="prior", dtype=data_type)

prior_text_model_id = "openai/clip-vit-large-patch14"
prior_tokenizer = CLIPTokenizer.from_pretrained(prior_text_model_id)
prior_text_model = CLIPTextModelWithProjection.from_pretrained(prior_text_model_id, dtype=data_type)
prior_scheduler = UnCLIPScheduler.from_pretrained(prior_model_id, subfolder="prior_scheduler")
prior_scheduler = DDPMScheduler.from_config(prior_scheduler.config)

stable_unclip_model_id = "stabilityai/stable-diffusion-2-1-unclip-small"

pipe = StableUnCLIPPipeline.from_pretrained(
    stable_unclip_model_id,
    dtype=data_type,
    variant="fp16",
    prior_tokenizer=prior_tokenizer,
    prior_text_encoder=prior_text_model,
    prior=prior,
    prior_scheduler=prior_scheduler,
)

pipe = pipe.to("cuda")  # or "mps", "xpu", "cpu"
wave_prompt = "dramatic wave, the Oceans roar, Strong wave spiral across the oceans as the waves unfurl into roaring crests; perfect wave form; perfect wave shape; dramatic wave shape; wave shape unbelievable; wave; wave shape spectacular"

image = pipe(prompt=wave_prompt).images[0]
image
```
> [!WARNING]
> Untuk text-to-image, kami menggunakan `stabilityai/stable-diffusion-2-1-unclip-small` karena model ini dilatih pada embedding CLIP ViT-L/14, yang sama dengan prior model Karlo. [stabilityai/stable-diffusion-2-1-unclip](https://hf.co/stabilityai/stable-diffusion-2-1-unclip) dilatih pada OpenCLIP ViT-H, sehingga kami tidak merekomendasikannya.

### Variasi Image-to-Image yang Dipandu Teks

```python
from diffusers import StableUnCLIPImg2ImgPipeline
from diffusers.utils import load_image
import torch

pipe = StableUnCLIPImg2ImgPipeline.from_pretrained(
    "stabilityai/stable-diffusion-2-1-unclip", dtype=torch.float16, variation="fp16"
)
pipe = pipe.to("cuda")  # or "mps", "xpu", "cpu"

url = "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/tarsila_do_amaral.png"
init_image = load_image(url)

images = pipe(init_image).images
images[0].save("variation_image.png")
```

Secara opsional, Anda juga dapat meneruskan prompt ke `pipe` seperti:

```python
prompt = "A fantasy landscape, trending on artstation"

image = pipe(init_image, prompt=prompt).images[0]
image
```

> [!TIP]
> Pastikan untuk melihat [panduan](../../using-diffusers/schedulers) Schedulers untuk mempelajari cara mengeksplorasi tradeoff antara kecepatan dan kualitas scheduler, serta lihat bagian [reuse components across pipelines](../../using-diffusers/loading#reusing-models-in-multiple-pipelines) untuk mempelajari cara memuat komponen yang sama secara efisien ke dalam beberapa pipeline.

## StableUnCLIPPipeline[[diffusers.StableUnCLIPPipeline]]

#### diffusers.StableUnCLIPPipeline[[diffusers.StableUnCLIPPipeline]]

```python
diffusers.StableUnCLIPPipeline(prior_tokenizer: CLIPTokenizer, prior_text_encoder: CLIPTextModelWithProjection, prior: PriorTransformer, prior_scheduler: KarrasDiffusionSchedulers, image_normalizer: StableUnCLIPImageNormalizer, image_noising_scheduler: KarrasDiffusionSchedulers, tokenizer: CLIPTokenizer, text_encoder: CLIPTextModel, unet: UNet2DConditionModel, scheduler: KarrasDiffusionSchedulers, vae: AutoencoderKL)
```

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

**Parameter:**

prior_tokenizer (`CLIPTokenizer`) : A `CLIPTokenizer`.

prior_text_encoder (`CLIPTextModelWithProjection`) : text-encoder `CLIPTextModelWithProjection` yang dibekukan.

prior ([PriorTransformer](/docs/diffusers/v0.43.0/id/api/models/prior_transformer#diffusers.PriorTransformer)) : Prior unCLIP kanonik untuk mengaproksimasi embedding gambar dari embedding teks.

prior_scheduler (`KarrasDiffusionSchedulers`) : Scheduler yang digunakan dalam proses denoising sebelumnya.

image_normalizer (`StableUnCLIPImageNormalizer`) : Digunakan untuk menormalisasi embedding gambar yang diprediksi sebelum noise diterapkan dan menormalisasi kembali embedding gambar setelah noise diterapkan.

image_noising_scheduler (`KarrasDiffusionSchedulers`) : Jadwal noise untuk menambahkan noise ke embedding gambar yang diprediksi. Jumlah noise yang ditambahkan ditentukan oleh `noise_level`.

tokenizer (`CLIPTokenizer`) : A `CLIPTokenizer`.

text_encoder (`CLIPTextModel`) : text-encoder `CLIPTextModel` yang dibekukan.

unet ([UNet2DConditionModel](/docs/diffusers/v0.43.0/id/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Sebuah [UNet2DConditionModel](/docs/diffusers/v0.43.0/id/api/models/unet2d-cond#diffusers.UNet2DConditionModel) untuk menghilangkan noise dari latens gambar yang telah dikodekan.

scheduler (`KarrasDiffusionSchedulers`) : Penjadwal yang digunakan bersama `unet` untuk menghilangkan noise pada latens gambar yang telah dikodekan.

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.

Pipeline untuk generasi teks-ke-gambar menggunakan stable unCLIP.

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.StableUnCLIPPipeline.__call__]]

```python
__call__(prompt: str | list[str] | None = None, height: int | None = None, width: int | None = None, num_inference_steps: int = 20, guidance_scale: float = 10.0, negative_prompt: str | list[str] | None = None, num_images_per_prompt: int | None = 1, eta: float = 0.0, generator: typing.Optional[torch.Generator] = None, latents: typing.Optional[torch.Tensor] = 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, callback: typing.Optional[typing.Callable[[int, int, torch.Tensor], NoneType]] = None, callback_steps: int = 1, cross_attention_kwargs: dict[str, typing.Any] | None = None, noise_level: int = 0, prior_num_inference_steps: int = 25, prior_guidance_scale: float = 4.0, prior_latents: typing.Optional[torch.Tensor] = None, clip_skip: int | None = None)
```

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

**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 20) : Jumlah langkah denoising. Semakin banyak langkah denoising, biasanya menghasilkan gambar dengan kualitas lebih tinggi, namun dengan biaya inferensi yang lebih lambat.

guidance_scale (`float`, *opsional*, default 10.0) : 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`.

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 [ImagePipelineOutput](/docs/diffusers/v0.43.0/id/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) alih-alih tuple biasa.

callback (`Callable`, *opsional*) : Fungsi yang dipanggil setiap `callback_steps` langkah selama inferensi. Fungsi ini dipanggil dengan argumen berikut: `callback(step: int, timestep: int, latents: torch.Tensor)`.

callback_steps (`int`, *opsional*, default 1) : Frekuensi pemanggilan fungsi `callback`. Jika tidak ditentukan, callback dipanggil di setiap langkah.

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

noise_level (`int`, *opsional*, defaultnya `0`) : Jumlah noise yang ditambahkan ke embedding gambar. Nilai `noise_level` yang lebih tinggi meningkatkan varians pada gambar akhir yang sudah dihilangkan noise-nya. Lihat [StableUnCLIPPipeline.noise_image_embeddings()](/docs/diffusers/v0.43.0/id/api/pipelines/stable_unclip#diffusers.StableUnCLIPPipeline.noise_image_embeddings) untuk detail lebih lanjut.

prior_num_inference_steps (`int`, *opsional*, default 25) : Jumlah langkah denoising dalam proses denoising prior. Semakin banyak langkah denoising, biasanya menghasilkan gambar dengan kualitas lebih tinggi, namun dengan biaya inferensi yang lebih lambat.

prior_guidance_scale (`float`, *opsional*, default 4.0) : 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`.

prior_latents (`torch.Tensor`, *opsional*) : Laten berisik yang telah dibuat sebelumnya, diambil dari distribusi Gaussian, untuk digunakan sebagai input bagi pembuatan embedding gambar dalam proses denoising prior. 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.

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.

**Mengembalikan:** [ImagePipelineOutput](/docs/diffusers/v0.43.0/id/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) atau `tuple`

`~ pipeline_utils.ImagePipelineOutput` jika `return_dict` bernilai True, selain itu berupa `tuple`. Saat mengembalikan tuple, elemen pertama adalah daftar berisi gambar yang dihasilkan.

Fungsi panggilan untuk pipeline pada generasi.

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

>>> pipe = StableUnCLIPPipeline.from_pretrained(
...     "fusing/stable-unclip-2-1-l", torch_dtype=torch.float16
... )  # TODO update model path
>>> pipe = pipe.to("cuda")

>>> prompt = "a photo of an astronaut riding a horse on mars"
>>> images = pipe(prompt).images
>>> images[0].save("astronaut_horse.png")
```

#### enable_attention_slicing[[diffusers.StableUnCLIPPipeline.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.StableUnCLIPPipeline.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.StableUnCLIPPipeline.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.StableUnCLIPPipeline.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/).

#### encode_prompt[[diffusers.StableUnCLIPPipeline.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_unclip.py#L297)

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

#### noise_image_embeddings[[diffusers.StableUnCLIPPipeline.noise_image_embeddings]]

```python
noise_image_embeddings(image_embeds: Tensor, noise_level: int, noise: typing.Optional[torch.Tensor] = None, generator: typing.Optional[torch.Generator] = None)
```

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

Tambahkan noise ke embedding gambar. Jumlah noise dikendalikan oleh input `noise_level`. Nilai `noise_level` yang lebih tinggi meningkatkan varians pada gambar akhir yang sudah dihilangkan noise-nya.

Noise diterapkan dengan dua cara:
1. Jadwal noise diterapkan langsung ke embedding.
2. Vektor embedding waktu sinusoidal ditambahkan ke output.

Dalam kedua kasus, jumlah noise dikendalikan oleh `noise_level` yang sama.

Embeddings dinormalisasi sebelum noise diterapkan dan dinormalisasi kembali setelah noise diterapkan.

## StableUnCLIPImg2ImgPipeline[[diffusers.StableUnCLIPImg2ImgPipeline]]

#### diffusers.StableUnCLIPImg2ImgPipeline[[diffusers.StableUnCLIPImg2ImgPipeline]]

```python
diffusers.StableUnCLIPImg2ImgPipeline(feature_extractor: CLIPImageProcessorPil, image_encoder: CLIPVisionModelWithProjection, image_normalizer: StableUnCLIPImageNormalizer, image_noising_scheduler: KarrasDiffusionSchedulers, tokenizer: CLIPTokenizer, text_encoder: CLIPTextModel, unet: UNet2DConditionModel, scheduler: KarrasDiffusionSchedulers, vae: AutoencoderKL)
```

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

**Parameter:**

feature_extractor (`CLIPImageProcessor`) : Ekstraktor fitur untuk pra-pemrosesan gambar sebelum dienkod.

image_encoder (`CLIPVisionModelWithProjection`) : Model visi CLIP untuk mengkodekan gambar.

image_normalizer (`StableUnCLIPImageNormalizer`) : Digunakan untuk menormalisasi embedding gambar yang diprediksi sebelum noise diterapkan dan menormalisasi kembali embedding gambar setelah noise diterapkan.

image_noising_scheduler (`KarrasDiffusionSchedulers`) : Jadwal noise untuk menambahkan noise ke embedding gambar yang diprediksi. Jumlah noise yang ditambahkan ditentukan oleh `noise_level`.

tokenizer (`~transformers.CLIPTokenizer`) : A [`~transformers.CLIPTokenizer`)].

text_encoder ([CLIPTextModel](https://huggingface.co/docs/transformers/v5.22.2/en/model_doc/clip#transformers.CLIPTextModel)) : text-encoder [CLIPTextModel](https://huggingface.co/docs/transformers/v5.22.2/en/model_doc/clip#transformers.CLIPTextModel) yang dibekukan.

unet ([UNet2DConditionModel](/docs/diffusers/v0.43.0/id/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Sebuah [UNet2DConditionModel](/docs/diffusers/v0.43.0/id/api/models/unet2d-cond#diffusers.UNet2DConditionModel) untuk menghilangkan noise dari latens gambar yang telah dikodekan.

scheduler (`KarrasDiffusionSchedulers`) : Penjadwal yang digunakan bersama `unet` untuk menghilangkan noise pada latens gambar yang telah dikodekan.

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.

Pipeline untuk generasi gambar-ke-gambar yang dipandu teks menggunakan stable unCLIP.

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.StableUnCLIPImg2ImgPipeline.__call__]]

```python
__call__(image: typing.Union[torch.Tensor, PIL.Image.Image] = None, prompt: str | list[str] = None, height: int | None = None, width: int | None = None, num_inference_steps: int = 20, guidance_scale: float = 10, negative_prompt: str | list[str] | None = None, num_images_per_prompt: int | None = 1, eta: float = 0.0, generator: typing.Optional[torch.Generator] = None, latents: typing.Optional[torch.Tensor] = 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, callback: typing.Optional[typing.Callable[[int, int, torch.Tensor], NoneType]] = None, callback_steps: int = 1, cross_attention_kwargs: dict[str, typing.Any] | None = None, noise_level: int = 0, image_embeds: typing.Optional[torch.Tensor] = None, clip_skip: int | None = None)
```

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

**Parameter:**

prompt (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt untuk mengarahkan generasi gambar. Jika tidak didefinisikan, `prompt_embeds` akan digunakan atau prompt diinisialisasi ke `""`.

image (`torch.Tensor` atau `PIL.Image.Image`) : `Image` atau tensor yang mewakili batch gambar. Gambar tersebut dienkod ke dalam embedding CLIP-nya, yang menjadi kondisi bagi `unet`. Gambar tersebut _tidak_ dienkod oleh `vae` dan kemudian digunakan sebagai latents dalam proses denoising, seperti yang terjadi pada proses variasi gambar berbasis teks Stable Diffusion standar.

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 20) : Jumlah langkah denoising. Semakin banyak langkah denoising, biasanya menghasilkan gambar dengan kualitas lebih tinggi, namun dengan biaya inferensi yang lebih lambat.

guidance_scale (`float`, *opsional*, default 10.0) : 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`.

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 [ImagePipelineOutput](/docs/diffusers/v0.43.0/id/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) alih-alih tuple biasa.

callback (`Callable`, *opsional*) : Fungsi yang dipanggil setiap `callback_steps` langkah selama inferensi. Fungsi ini dipanggil dengan argumen berikut: `callback(step: int, timestep: int, latents: torch.Tensor)`.

callback_steps (`int`, *opsional*, default 1) : Frekuensi pemanggilan fungsi `callback`. Jika tidak ditentukan, callback dipanggil di setiap langkah.

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

noise_level (`int`, *opsional*, defaultnya `0`) : Jumlah noise yang ditambahkan ke embedding gambar. Nilai `noise_level` yang lebih tinggi meningkatkan varians pada gambar akhir yang sudah dihilangkan noise-nya. Lihat [StableUnCLIPPipeline.noise_image_embeddings()](/docs/diffusers/v0.43.0/id/api/pipelines/stable_unclip#diffusers.StableUnCLIPPipeline.noise_image_embeddings) untuk detail lebih lanjut.

image_embeds (`torch.Tensor`, *opsional*) : Embedding CLIP yang telah dibuat sebelumnya untuk mengondisikan `unet`. Laten ini tidak digunakan dalam proses denoising. Jika Anda ingin menyediakan laten yang telah dibuat sebelumnya, berikan ke `__call__` sebagai `latents`.

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.

**Mengembalikan:** [ImagePipelineOutput](/docs/diffusers/v0.43.0/id/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) atau `tuple`

`~ pipeline_utils.ImagePipelineOutput` jika `return_dict` bernilai True, selain itu berupa `tuple`. Saat mengembalikan tuple, elemen pertama adalah daftar berisi gambar yang dihasilkan.

Fungsi panggilan untuk pipeline pada generasi.

Contoh:
```py
>>> import requests
>>> import torch
>>> from PIL import Image
>>> from io import BytesIO

>>> from diffusers import StableUnCLIPImg2ImgPipeline

>>> pipe = StableUnCLIPImg2ImgPipeline.from_pretrained(
...     "stabilityai/stable-diffusion-2-1-unclip-small", torch_dtype=torch.float16
... )
>>> pipe = pipe.to("cuda")

>>> url = "https://raw.githubusercontent.com/CompVis/stable-diffusion/main/assets/stable-samples/img2img/sketch-mountains-input.jpg"

>>> response = requests.get(url)
>>> init_image = Image.open(BytesIO(response.content)).convert("RGB")
>>> init_image = init_image.resize((768, 512))

>>> prompt = "A fantasy landscape, trending on artstation"

>>> images = pipe(init_image, prompt).images
>>> images[0].save("fantasy_landscape.png")
```

#### enable_attention_slicing[[diffusers.StableUnCLIPImg2ImgPipeline.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.StableUnCLIPImg2ImgPipeline.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.StableUnCLIPImg2ImgPipeline.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.StableUnCLIPImg2ImgPipeline.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/).

#### encode_prompt[[diffusers.StableUnCLIPImg2ImgPipeline.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_unclip_img2img.py#L259)

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

#### noise_image_embeddings[[diffusers.StableUnCLIPImg2ImgPipeline.noise_image_embeddings]]

```python
noise_image_embeddings(image_embeds: Tensor, noise_level: int, noise: typing.Optional[torch.Tensor] = None, generator: typing.Optional[torch.Generator] = None)
```

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

Tambahkan noise ke embedding gambar. Jumlah noise dikendalikan oleh input `noise_level`. Nilai `noise_level` yang lebih tinggi meningkatkan varians pada gambar akhir yang sudah dihilangkan noise-nya.

Noise diterapkan dengan dua cara:
1. Jadwal noise diterapkan langsung ke embedding.
2. Vektor embedding waktu sinusoidal ditambahkan ke output.

Dalam kedua kasus, jumlah noise dikendalikan oleh `noise_level` yang sama.

Embeddings dinormalisasi sebelum noise diterapkan dan dinormalisasi kembali setelah noise diterapkan.

## ImagePipelineOutput[[diffusers.ImagePipelineOutput]]

#### diffusers.ImagePipelineOutput[[diffusers.ImagePipelineOutput]]

```python
diffusers.ImagePipelineOutput(images: list[PIL.Image.Image] | numpy.ndarray)
```

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

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

Kelas output untuk pipeline gambar.