# Upscaler laten

Model Stable Diffusion latent upscaler dibuat oleh [Katherine Crowson](https://github.com/crowsonkb/k-diffusion) bekerja sama dengan [Stability AI](https://stability.ai/). Model ini digunakan untuk meningkatkan resolusi gambar output sebesar faktor 2 (lihat [notebook](https://colab.research.google.com/drive/1o1qYJcFeywzCIdkfKJy7cTpgZTCM2EI4) demo ini untuk demonstrasi implementasi aslinya).

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

## StableDiffusionLatentUpscalePipeline[[diffusers.StableDiffusionLatentUpscalePipeline]]

#### diffusers.StableDiffusionLatentUpscalePipeline[[diffusers.StableDiffusionLatentUpscalePipeline]]

```python
diffusers.StableDiffusionLatentUpscalePipeline(vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, unet: UNet2DConditionModel, scheduler: EulerDiscreteScheduler)
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/stable_diffusion/pipeline_stable_diffusion_latent_upscale.py#L84)

**Parameter:**

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

text_encoder ([CLIPTextModel](https://huggingface.co/docs/transformers/main/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/main/en/model_doc/clip#transformers.CLIPTokenizer)) : Sebuah `CLIPTokenizer` untuk melakukan tokenisasi teks.

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

scheduler ([SchedulerMixin](/docs/diffusers/main/id/api/schedulers/overview#diffusers.SchedulerMixin)) : Sebuah [EulerDiscreteScheduler](/docs/diffusers/main/id/api/schedulers/euler#diffusers.EulerDiscreteScheduler) yang digunakan bersama dengan `unet` untuk menghilangkan noise pada latens gambar yang telah dikodekan.

Pipeline untuk meningkatkan resolusi gambar output Stable Diffusion sebesar faktor 2.

Model ini mewarisi dari [DiffusionPipeline](/docs/diffusers/main/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:
- [from_single_file()](/docs/diffusers/main/id/api/loaders/single_file#diffusers.loaders.FromSingleFileMixin.from_single_file) for loading `.ckpt` files

#### __call__[[diffusers.StableDiffusionLatentUpscalePipeline.__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, num_inference_steps: int = 75, guidance_scale: float = 9.0, negative_prompt: str | list[str] | None = None, 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, pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_pooled_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)
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/stable_diffusion/pipeline_stable_diffusion_latent_upscale.py#L396)

**Parameter:**

prompt (`str` atau `list[str]`) : Prompt atau prompt-prompt untuk memandu peningkatan resolusi gambar.

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 di-upscale. Jika berupa tensor, bisa berupa output laten dari model Stable Diffusion atau tensor gambar dalam rentang `[-1, 1]`. Dianggap sebagai `latent` jika `image.shape[1]` adalah `4`; selain itu, dianggap sebagai representasi gambar dan dikodekan menggunakan encoder `vae` dari pipeline ini.

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

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

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

pooled_prompt_embeds (`torch.Tensor`, *opsional*) : Pooled text embeddings yang telah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks (prompt weighting). Jika tidak disediakan, pooled text embeddings akan dihasilkan dari argumen input `prompt`.

negative_pooled_prompt_embeds (`torch.Tensor`, *opsional*) : Embedding teks negatif yang sudah dipooling sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks (penimbangan prompt). Jika tidak disediakan, `negative_prompt_embeds` yang dipooling akan dihasilkan 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/main/id/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) 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.

**Mengembalikan:** [StableDiffusionPipelineOutput](/docs/diffusers/main/id/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) atau `tuple`

Jika `return_dict` adalah `True`, [StableDiffusionPipelineOutput](/docs/diffusers/main/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
>>> from diffusers import StableDiffusionLatentUpscalePipeline, StableDiffusionPipeline
>>> import torch

>>> pipeline = StableDiffusionPipeline.from_pretrained(
...     "CompVis/stable-diffusion-v1-4", torch_dtype=torch.float16
... )
>>> pipeline.to("cuda")

>>> model_id = "stabilityai/sd-x2-latent-upscaler"
>>> upscaler = StableDiffusionLatentUpscalePipeline.from_pretrained(model_id, torch_dtype=torch.float16)
>>> upscaler.to("cuda")

>>> prompt = "a photo of an astronaut high resolution, unreal engine, ultra realistic"
>>> generator = torch.manual_seed(33)

>>> low_res_latents = pipeline(prompt, generator=generator, output_type="latent").images

>>> with torch.no_grad():
...     image = pipeline.decode_latents(low_res_latents)
>>> image = pipeline.numpy_to_pil(image)[0]

>>> image.save("../images/a1.png")

>>> upscaled_image = upscaler(
...     prompt=prompt,
...     image=low_res_latents,
...     num_inference_steps=20,
...     guidance_scale=0,
...     generator=generator,
... ).images[0]

>>> upscaled_image.save("../images/a2.png")
```

#### enable_sequential_cpu_offload[[diffusers.StableDiffusionLatentUpscalePipeline.enable_sequential_cpu_offload]]

```python
enable_sequential_cpu_offload(gpu_id: int | None = None, device: typing.Union[torch.device, str] = None)
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pipeline_utils.py#L1293)

**Parameter:**

gpu_id (`int`, *opsional*) : ID akselerator yang akan digunakan dalam inferensi. Jika tidak ditentukan, nilainya akan secara default menjadi 0.

device (`torch.Device` atau `str`, *opsional*, defaultnya None) : Jenis perangkat PyTorch dari akselerator yang akan digunakan dalam inferensi. Jika tidak ditentukan, akselerator yang tersedia akan dideteksi dan digunakan secara otomatis.

Meng-offload semua model ke CPU menggunakan 🤗 Accelerate, yang secara signifikan mengurangi penggunaan memori. Saat dipanggil, state dicts dari semua komponen `torch.nn.Module` (kecuali yang ada di `self._exclude_from_cpu_offload`) disimpan ke CPU, kemudian dipindahkan ke `torch.device('meta')`, dan dimuat ke accelerator hanya ketika metode `forward` dari submodul spesifik tersebut dipanggil. Offloading terjadi berdasarkan submodul. Penghematan memori lebih tinggi dibandingkan dengan `enable_model_cpu_offload`, tetapi performanya lebih rendah.

#### enable_attention_slicing[[diffusers.StableDiffusionLatentUpscalePipeline.enable_attention_slicing]]

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

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pipeline_utils.py#L2048)

**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.StableDiffusionLatentUpscalePipeline.disable_attention_slicing]]

```python
disable_attention_slicing()
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pipeline_utils.py#L2085)

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

#### enable_xformers_memory_efficient_attention[[diffusers.StableDiffusionLatentUpscalePipeline.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/main/src/diffusers/pipelines/pipeline_utils.py#L1993)

**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.StableDiffusionLatentUpscalePipeline.disable_xformers_memory_efficient_attention]]

```python
disable_xformers_memory_efficient_attention()
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pipeline_utils.py#L2024)

Nonaktifkan perhatian hemat memori dari [xFormers](https://facebookresearch.github.io/xformers/).

#### encode_prompt[[diffusers.StableDiffusionLatentUpscalePipeline.encode_prompt]]

```python
encode_prompt(prompt, device, do_classifier_free_guidance, negative_prompt = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.Tensor] = None)
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/stable_diffusion/pipeline_stable_diffusion_latent_upscale.py#L166)

**Parameter:**

prompt (`str` atau `list(int)`) : prompt yang akan dienkod

device : (`torch.device`): perangkat torch

do_classifier_free_guidance (`bool`) : apakah akan menggunakan classifier free guidance atau tidak

negative_prompt (`str` atau `list[str]`) : Prompt atau prompt-prompt yang tidak akan memandu generasi gambar. Diabaikan saat tidak menggunakan panduan (yaitu, diabaikan jika `guidance_scale` kurang dari `1`).

prompt_embeds (`torch.FloatTensor`, *opsional*) : Embedding teks yang sudah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, embedding teks akan dihasilkan dari argumen input `prompt`.

negative_prompt_embeds (`torch.FloatTensor`, *opsional*) : Embedding teks negatif yang telah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, negative_prompt_embeds akan dibuat dari argumen input `negative_prompt`.

pooled_prompt_embeds (`torch.Tensor`, *opsional*) : Pooled text embeddings yang telah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* pembobotan prompt. Jika tidak disediakan, pooled text embeddings akan dihasilkan dari argumen input `prompt`.

negative_pooled_prompt_embeds (`torch.Tensor`, *opsional*) : Embedding teks negatif yang sudah dipooling sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, pooled negative_prompt_embeds akan dihasilkan dari argumen input `negative_prompt`.

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/main/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.