# Model Konsistensi Laten

  

Latent Consistency Models (LCMs) diusulkan dalam [Latent Consistency Models: Synthesizing High-Resolution Images with Few-Step Inference](https://huggingface.co/papers/2310.04378) oleh Simian Luo, Yiqin Tan, Longbo Huang, Jian Li, dan Hang Zhao.

Abstrak dari makalah tersebut adalah sebagai berikut:

*Model Latent Diffusion (LDM) telah mencapai hasil yang luar biasa dalam mensintesis gambar resolusi tinggi. Namun, proses sampling iteratifnya sangat intensif secara komputasi dan menyebabkan generasi yang lambat. Terinspirasi oleh Consistency Models (song et al.), kami mengusulkan Latent Consistency Models (LCM), yang memungkinkan inferensi cepat dengan langkah minimal pada LDM mana pun yang telah dilatih sebelumnya, termasuk Stable Diffusion (rombach et al). Dengan memandang proses difusi terbalik yang dipandu sebagai penyelesaian augmented probability flow ODE (PF-ODE), LCM dirancang untuk langsung memprediksi solusi ODE tersebut di ruang laten, sehingga mengurangi kebutuhan akan banyak iterasi dan memungkinkan sampling yang cepat dengan fidelitas tinggi. Didistilasi secara efisien dari model difusi classifier-free guided yang telah dilatih sebelumnya, LCM berkualitas tinggi 768 x 768 2~4-step hanya membutuhkan 32 jam GPU A100 untuk pelatihan. Selain itu, kami memperkenalkan Latent Consistency Fine-tuning (LCF), metode baru yang dirancang khusus untuk fine-tuning LCM pada dataset gambar yang dikustomisasi. Evaluasi pada dataset LAION-5B-Aesthetics menunjukkan bahwa LCM mencapai kinerja generasi teks-ke-gambar state-of-the-art dengan inferensi langkah sedikit. Halaman Proyek: [this https URL](https://latent-consistency-models.github.io/).*

Demo untuk checkpoint [SimianLuo/LCM_Dreamshaper_v7](https://huggingface.co/SimianLuo/LCM_Dreamshaper_v7) dapat ditemukan [di sini](https://huggingface.co/spaces/SimianLuo/Latent_Consistency_Model).

Pipeline-pipeline ini disumbangkan oleh [luosiallen](https://luosiallen.github.io/), [nagolinc](https://github.com/nagolinc), dan [dg845](https://github.com/dg845).

> [!TIP]
> LCM dan LCM-LoRA tersedia untuk Stable Diffusion v1.5, Stable Diffusion XL, dan model SSD-1B. Anda dapat menemukan checkpoint mereka di Koleksi [Latent Consistency](https://hf.co/collections/latent-consistency/latent-consistency-models-weights-654ce61a95edd6dffccef6a8).

## Teks-ke-gambar

Untuk menggunakan LCM, Anda perlu memuat checkpoint LCM untuk model yang didukung ke dalam [UNet2DConditionModel](/docs/diffusers/v0.43.0/id/api/models/unet2d-cond#diffusers.UNet2DConditionModel) dan mengganti scheduler dengan [LCMScheduler](/docs/diffusers/v0.43.0/id/api/schedulers/lcm#diffusers.LCMScheduler). Setelah itu, Anda dapat menggunakan pipeline seperti biasa, dan meneruskan prompt teks untuk menghasilkan gambar hanya dalam 4 langkah.

Beberapa hal yang perlu diperhatikan saat menggunakan LCM adalah:

* Biasanya, ukuran batch digandakan di dalam pipeline untuk classifier-free guidance. Namun, LCM menerapkan guidance dengan guidance embeddings dan tidak perlu menggandakan ukuran batch, yang menghasilkan inferensi yang lebih cepat. Kekurangannya adalah prompt negatif tidak berfungsi dengan LCM karena tidak memiliki efek pada proses denoising.
* Rentang ideal untuk `guidance_scale` adalah [3., 13.] karena itulah yang digunakan saat pelatihan UNet. Namun, menonaktifkan `guidance_scale` dengan nilai 1.0 juga efektif dalam kebanyakan kasus.

```python
from diffusers import StableDiffusionXLPipeline, UNet2DConditionModel, LCMScheduler
import torch

unet = UNet2DConditionModel.from_pretrained(
    "latent-consistency/lcm-sdxl",
    dtype=torch.float16,
    variant="fp16",
)
pipe = StableDiffusionXLPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", unet=unet, dtype=torch.float16, variant="fp16",
).to("cuda")  # or "mps", "xpu", "cpu"
pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)

prompt = "Self-portrait oil painting, a beautiful cyborg with golden hair, 8k"
generator = torch.manual_seed(0)
image = pipe(
    prompt=prompt, num_inference_steps=4, generator=generator, guidance_scale=8.0
).images[0]
image
```

    

Untuk menggunakan LCM-LoRAs, Anda perlu mengganti scheduler dengan [LCMScheduler](/docs/diffusers/v0.43.0/id/api/schedulers/lcm#diffusers.LCMScheduler) dan memuat bobot LCM-LoRA dengan metode [load_lora_weights()](/docs/diffusers/v0.43.0/id/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights). Setelah itu, Anda dapat menggunakan pipeline seperti biasa, dan meneruskan prompt teks untuk menghasilkan gambar hanya dalam 4 langkah.

Beberapa hal yang perlu diperhatikan saat menggunakan LCM-LoRAs adalah:

* Biasanya, ukuran batch digandakan di dalam pipeline untuk classifier-free guidance. Namun, LCM menerapkan guidance dengan guidance embeddings dan tidak perlu menggandakan ukuran batch, yang menghasilkan inferensi yang lebih cepat. Kekurangannya adalah prompt negatif tidak berfungsi dengan LCM karena tidak memiliki efek pada proses denoising.
* Anda dapat menggunakan guidance dengan LCM-LoRAs, tetapi sangat sensitif terhadap nilai `guidance_scale` yang tinggi dan dapat menyebabkan artefak pada gambar yang dihasilkan. Nilai terbaik yang kami temukan berada di antara [1.0, 2.0].
* Ganti [stabilityai/stable-diffusion-xl-base-1.0](https://hf.co/stabilityai/stable-diffusion-xl-base-1.0) dengan model finetuned apa pun. Sebagai contoh, coba gunakan checkpoint [animagine-xl](https://huggingface.co/Linaqruf/animagine-xl) untuk menghasilkan gambar anime dengan SDXL.

```py
import torch
from diffusers import DiffusionPipeline, LCMScheduler

pipe = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    variant="fp16",
    dtype=torch.float16
).to("cuda")  # or "mps", "xpu", "cpu"
pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)
pipe.load_lora_weights("latent-consistency/lcm-lora-sdxl")

prompt = "Self-portrait oil painting, a beautiful cyborg with golden hair, 8k"
generator = torch.manual_seed(42)
image = pipe(
    prompt=prompt, num_inference_steps=4, generator=generator, guidance_scale=1.0
).images[0]
image
```

    

## Gambar-ke-gambar

Untuk menggunakan LCM untuk image-to-image, Anda perlu memuat checkpoint LCM untuk model yang didukung ke dalam [UNet2DConditionModel](/docs/diffusers/v0.43.0/id/api/models/unet2d-cond#diffusers.UNet2DConditionModel) dan mengganti scheduler dengan [LCMScheduler](/docs/diffusers/v0.43.0/id/api/schedulers/lcm#diffusers.LCMScheduler). Kemudian Anda dapat menggunakan pipeline seperti biasa, dan meneruskan prompt teks serta gambar awal untuk menghasilkan gambar hanya dalam 4 langkah.

> [!TIP]
> Eksperimen dengan nilai yang berbeda untuk `num_inference_steps`, `strength`, dan `guidance_scale` untuk mendapatkan hasil terbaik.

```python
import torch
from diffusers import AutoPipelineForImage2Image, UNet2DConditionModel, LCMScheduler
from diffusers.utils import load_image

unet = UNet2DConditionModel.from_pretrained(
    "SimianLuo/LCM_Dreamshaper_v7",
    subfolder="unet",
    dtype=torch.float16,
)

pipe = AutoPipelineForImage2Image.from_pretrained(
    "Lykon/dreamshaper-7",
    unet=unet,
    dtype=torch.float16,
    variant="fp16",
).to("cuda")  # or "mps", "xpu", "cpu"
pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)

init_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/img2img-init.png")
prompt = "Astronauts in a jungle, cold color palette, muted colors, detailed, 8k"
generator = torch.manual_seed(0)
image = pipe(
    prompt,
    image=init_image,
    num_inference_steps=4,
    guidance_scale=7.5,
    strength=0.5,
    generator=generator
).images[0]
image
```

  
    
    gambar awal
  
  
    
    gambar yang dihasilkan
  

Untuk menggunakan LCM-LoRAs untuk image-to-image, Anda perlu mengganti scheduler dengan [LCMScheduler](/docs/diffusers/v0.43.0/id/api/schedulers/lcm#diffusers.LCMScheduler) dan memuat bobot LCM-LoRA dengan metode [load_lora_weights()](/docs/diffusers/v0.43.0/id/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights). Kemudian Anda dapat menggunakan pipeline seperti biasa, dan meneruskan prompt teks serta gambar awal untuk menghasilkan gambar hanya dalam 4 langkah.

> [!TIP]
> Eksperimen dengan nilai yang berbeda untuk `num_inference_steps`, `strength`, dan `guidance_scale` untuk mendapatkan hasil terbaik.

```py
import torch
from diffusers import AutoPipelineForImage2Image, LCMScheduler
from diffusers.utils import make_image_grid, load_image

pipe = AutoPipelineForImage2Image.from_pretrained(
    "Lykon/dreamshaper-7",
    dtype=torch.float16,
    variant="fp16",
).to("cuda")  # or "mps", "xpu", "cpu"

pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)

pipe.load_lora_weights("latent-consistency/lcm-lora-sdv1-5")

init_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/img2img-init.png")
prompt = "Astronauts in a jungle, cold color palette, muted colors, detailed, 8k"

generator = torch.manual_seed(0)
image = pipe(
    prompt,
    image=init_image,
    num_inference_steps=4,
    guidance_scale=1,
    strength=0.6,
    generator=generator
).images[0]
image
```

  
    
    gambar awal
  
  
    
    gambar yang dihasilkan
  

## Inpainting

Untuk menggunakan LCM-LoRAs untuk inpainting, Anda perlu mengganti scheduler dengan [LCMScheduler](/docs/diffusers/v0.43.0/id/api/schedulers/lcm#diffusers.LCMScheduler) dan memuat bobot LCM-LoRA dengan metode [load_lora_weights()](/docs/diffusers/v0.43.0/id/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights). Setelah itu, Anda dapat menggunakan pipeline seperti biasa, dan meneruskan prompt teks, gambar awal, serta gambar mask untuk menghasilkan gambar hanya dalam 4 langkah.

```py
import torch
from diffusers import AutoPipelineForInpainting, LCMScheduler
from diffusers.utils import load_image, make_image_grid

pipe = AutoPipelineForInpainting.from_pretrained(
    "stable-diffusion-v1-5/stable-diffusion-inpainting",
    dtype=torch.float16,
    variant="fp16",
).to("cuda")  # or "mps", "xpu", "cpu"

pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)

pipe.load_lora_weights("latent-consistency/lcm-lora-sdv1-5")

init_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/inpaint.png")
mask_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/inpaint_mask.png")

prompt = "concept art digital painting of an elven castle, inspired by lord of the rings, highly detailed, 8k"
generator = torch.manual_seed(0)
image = pipe(
    prompt=prompt,
    image=init_image,
    mask_image=mask_image,
    generator=generator,
    num_inference_steps=4,
    guidance_scale=4,
).images[0]
image
```

  
    
    gambar awal
  
  
    
    gambar yang dihasilkan
  

## Adapters

LCM kompatibel dengan adapter seperti LoRA, ControlNet, T2I-Adapter, dan AnimateDiff. Anda dapat membawa kecepatan LCM ke adapter-adaptor ini untuk menghasilkan gambar dalam gaya tertentu atau mengondisikan model pada input lain seperti gambar canny.

### LoRA

Adaptasi [LoRA](../../tutorials/using_peft_for_inference) dapat ditala ulang dengan cepat untuk mempelajari gaya baru dari hanya beberapa gambar, lalu disematkan ke model pra-terlatih untuk menghasilkan gambar dalam gaya tersebut.

Muat checkpoint LCM untuk model yang didukung ke dalam [UNet2DConditionModel](/docs/diffusers/v0.43.0/id/api/models/unet2d-cond#diffusers.UNet2DConditionModel) dan ganti scheduler dengan [LCMScheduler](/docs/diffusers/v0.43.0/id/api/schedulers/lcm#diffusers.LCMScheduler). Kemudian, Anda dapat menggunakan metode [load_lora_weights()](/docs/diffusers/v0.43.0/id/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) untuk memuat bobot LoRA ke dalam LCM dan menghasilkan gambar bergaya dalam beberapa langkah.

```python
from diffusers import StableDiffusionXLPipeline, UNet2DConditionModel, LCMScheduler
import torch

unet = UNet2DConditionModel.from_pretrained(
    "latent-consistency/lcm-sdxl",
    dtype=torch.float16,
    variant="fp16",
)
pipe = StableDiffusionXLPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", unet=unet, dtype=torch.float16, variant="fp16",
).to("cuda")  # or "mps", "xpu", "cpu"
pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)
pipe.load_lora_weights("TheLastBen/Papercut_SDXL", weight_name="papercut.safetensors", adapter_name="papercut")

prompt = "papercut, a cute fox"
generator = torch.manual_seed(0)
image = pipe(
    prompt=prompt, num_inference_steps=4, generator=generator, guidance_scale=8.0
).images[0]
image
```

    

Ganti scheduler dengan [LCMScheduler](/docs/diffusers/v0.43.0/id/api/schedulers/lcm#diffusers.LCMScheduler). Kemudian Anda dapat menggunakan metode [load_lora_weights()](/docs/diffusers/v0.43.0/id/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) untuk memuat bobot LCM-LoRA dan LoRA gaya yang ingin Anda gunakan. Gabungkan kedua adapter LoRA dengan metode `~loaders.UNet2DConditionLoadersMixin.set_adapters` dan hasilkan gambar bergaya dalam beberapa langkah.

```py
import torch
from diffusers import DiffusionPipeline, LCMScheduler

pipe = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    variant="fp16",
    dtype=torch.float16
).to("cuda")  # or "mps", "xpu", "cpu"

pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)

pipe.load_lora_weights("latent-consistency/lcm-lora-sdxl", adapter_name="lcm")
pipe.load_lora_weights("TheLastBen/Papercut_SDXL", weight_name="papercut.safetensors", adapter_name="papercut")

pipe.set_adapters(["lcm", "papercut"], adapter_weights=[1.0, 0.8])

prompt = "papercut, a cute fox"
generator = torch.manual_seed(0)
image = pipe(prompt, num_inference_steps=4, guidance_scale=1, generator=generator).images[0]
image
```

    

### ControlNet

[ControlNet](./controlnet) adalah adapter yang dapat dilatih pada berbagai jenis input seperti canny edge, pose estimation, atau depth. ControlNet dapat disisipkan ke dalam pipeline untuk memberikan kondisioning dan kontrol tambahan pada model guna menghasilkan generasi yang lebih akurat.

Anda dapat menemukan model ControlNet tambahan yang dilatih pada input lain di repositori [lllyasviel](https://hf.co/lllyasviel).

Muat model ControlNet yang dilatih pada gambar canny dan teruskan ke [ControlNetModel](/docs/diffusers/v0.43.0/id/api/models/controlnet#diffusers.ControlNetModel). Kemudian, Anda dapat memuat model LCM ke dalam [StableDiffusionControlNetPipeline](/docs/diffusers/v0.43.0/id/api/pipelines/controlnet#diffusers.StableDiffusionControlNetPipeline) dan mengganti scheduler dengan [LCMScheduler](/docs/diffusers/v0.43.0/id/api/schedulers/lcm#diffusers.LCMScheduler). Sekarang, teruskan gambar canny ke pipeline dan hasilkan sebuah gambar.

> [!TIP]
> Eksperimen dengan nilai yang berbeda untuk `num_inference_steps`, `controlnet_conditioning_scale`, `cross_attention_kwargs`, dan `guidance_scale` untuk mendapatkan hasil terbaik.

```python
import torch
import cv2
import numpy as np
from PIL import Image

from diffusers import StableDiffusionControlNetPipeline, ControlNetModel, LCMScheduler
from diffusers.utils import load_image, make_image_grid

image = load_image(
    "https://hf.co/datasets/huggingface/documentation-images/resolve/main/diffusers/input_image_vermeer.png"
).resize((512, 512))

image = np.array(image)

low_threshold = 100
high_threshold = 200

image = cv2.Canny(image, low_threshold, high_threshold)
image = image[:, :, None]
image = np.concatenate([image, image, image], axis=2)
canny_image = Image.fromarray(image)

controlnet = ControlNetModel.from_pretrained("lllyasviel/sd-controlnet-canny", dtype=torch.float16)
pipe = StableDiffusionControlNetPipeline.from_pretrained(
    "SimianLuo/LCM_Dreamshaper_v7",
    controlnet=controlnet,
    dtype=torch.float16,
    safety_checker=None,
).to("cuda")  # or "mps", "xpu", "cpu"
pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)

generator = torch.manual_seed(0)
image = pipe(
    "the mona lisa",
    image=canny_image,
    num_inference_steps=4,
    generator=generator,
).images[0]
make_image_grid([canny_image, image], rows=1, cols=2)
```

    

Muat model ControlNet yang dilatih pada gambar canny dan teruskan ke [ControlNetModel](/docs/diffusers/v0.43.0/id/api/models/controlnet#diffusers.ControlNetModel). Kemudian, Anda dapat memuat model Stable Diffusion v1.5 ke dalam [StableDiffusionControlNetPipeline](/docs/diffusers/v0.43.0/id/api/pipelines/controlnet#diffusers.StableDiffusionControlNetPipeline) dan mengganti scheduler dengan [LCMScheduler](/docs/diffusers/v0.43.0/id/api/schedulers/lcm#diffusers.LCMScheduler). Gunakan metode [load_lora_weights()](/docs/diffusers/v0.43.0/id/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) untuk memuat bobot LCM-LoRA, lalu teruskan gambar canny ke pipeline dan hasilkan sebuah gambar.

> [!TIP]
> Eksperimen dengan nilai yang berbeda untuk `num_inference_steps`, `controlnet_conditioning_scale`, `cross_attention_kwargs`, dan `guidance_scale` untuk mendapatkan hasil terbaik.

```py
import torch
import cv2
import numpy as np
from PIL import Image

from diffusers import StableDiffusionControlNetPipeline, ControlNetModel, LCMScheduler
from diffusers.utils import load_image

image = load_image(
    "https://hf.co/datasets/huggingface/documentation-images/resolve/main/diffusers/input_image_vermeer.png"
).resize((512, 512))

image = np.array(image)

low_threshold = 100
high_threshold = 200

image = cv2.Canny(image, low_threshold, high_threshold)
image = image[:, :, None]
image = np.concatenate([image, image, image], axis=2)
canny_image = Image.fromarray(image)

controlnet = ControlNetModel.from_pretrained("lllyasviel/sd-controlnet-canny", dtype=torch.float16)
pipe = StableDiffusionControlNetPipeline.from_pretrained(
    "stable-diffusion-v1-5/stable-diffusion-v1-5",
    controlnet=controlnet,
    dtype=torch.float16,
    safety_checker=None,
    variant="fp16"
).to("cuda")  # or "mps", "xpu", "cpu"

pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)

pipe.load_lora_weights("latent-consistency/lcm-lora-sdv1-5")

generator = torch.manual_seed(0)
image = pipe(
    "the mona lisa",
    image=canny_image,
    num_inference_steps=4,
    guidance_scale=1.5,
    controlnet_conditioning_scale=0.8,
    cross_attention_kwargs={"scale": 1},
    generator=generator,
).images[0]
image
```

    

### T2I-Adapter

[T2I-Adapter](../../using-diffusers/legacy_adapters#t2i-adapter) adalah adapter yang lebih ringan daripada ControlNet, yang menyediakan input tambahan untuk mengondisikan model yang telah dilatih sebelumnya. Kecepatannya lebih tinggi daripada ControlNet, tetapi hasilnya mungkin sedikit lebih buruk.

Anda dapat menemukan checkpoint T2I-Adapter tambahan yang dilatih pada input lain di repositori [TencentArc](https://hf.co/TencentARC).

Muat T2IAdapter yang dilatih pada gambar canny dan teruskan ke [StableDiffusionXLAdapterPipeline](/docs/diffusers/v0.43.0/id/api/pipelines/stable_diffusion/adapter#diffusers.StableDiffusionXLAdapterPipeline). Kemudian muat checkpoint LCM ke dalam [UNet2DConditionModel](/docs/diffusers/v0.43.0/id/api/models/unet2d-cond#diffusers.UNet2DConditionModel) dan ganti scheduler dengan [LCMScheduler](/docs/diffusers/v0.43.0/id/api/schedulers/lcm#diffusers.LCMScheduler). Sekarang teruskan gambar canny ke pipeline dan hasilkan sebuah gambar.

```python
import torch
import cv2
import numpy as np
from PIL import Image

from diffusers import StableDiffusionXLAdapterPipeline, UNet2DConditionModel, T2IAdapter, LCMScheduler
from diffusers.utils import load_image, make_image_grid

# detect the canny map in low resolution to avoid high-frequency details
image = load_image(
    "https://hf.co/datasets/huggingface/documentation-images/resolve/main/diffusers/input_image_vermeer.png"
).resize((384, 384))

image = np.array(image)

low_threshold = 100
high_threshold = 200

image = cv2.Canny(image, low_threshold, high_threshold)
image = image[:, :, None]
image = np.concatenate([image, image, image], axis=2)
canny_image = Image.fromarray(image).resize((1024, 1216))

adapter = T2IAdapter.from_pretrained("TencentARC/t2i-adapter-canny-sdxl-1.0", dtype=torch.float16, variant="fp16").to("cuda")  # or "mps", "xpu", "cpu"

unet = UNet2DConditionModel.from_pretrained(
    "latent-consistency/lcm-sdxl",
    dtype=torch.float16,
    variant="fp16",
)
pipe = StableDiffusionXLAdapterPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    unet=unet,
    adapter=adapter,
    dtype=torch.float16,
    variant="fp16",
).to("cuda")

pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)

prompt = "the mona lisa, 4k picture, high quality"
negative_prompt = "extra digit, fewer digits, cropped, worst quality, low quality, glitch, deformed, mutated, ugly, disfigured"

generator = torch.manual_seed(0)
image = pipe(
    prompt=prompt,
    negative_prompt=negative_prompt,
    image=canny_image,
    num_inference_steps=4,
    guidance_scale=5,
    adapter_conditioning_scale=0.8,
    adapter_conditioning_factor=1,
    generator=generator,
).images[0]
```

    

Muat T2IAdapter yang dilatih pada gambar canny dan teruskan ke [StableDiffusionXLAdapterPipeline](/docs/diffusers/v0.43.0/id/api/pipelines/stable_diffusion/adapter#diffusers.StableDiffusionXLAdapterPipeline). Ganti scheduler dengan [LCMScheduler](/docs/diffusers/v0.43.0/id/api/schedulers/lcm#diffusers.LCMScheduler), dan gunakan metode [load_lora_weights()](/docs/diffusers/v0.43.0/id/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) untuk memuat bobot LCM-LoRA. Teruskan gambar canny ke pipeline dan hasilkan sebuah gambar.

```py
import torch
import cv2
import numpy as np
from PIL import Image

from diffusers import StableDiffusionXLAdapterPipeline, UNet2DConditionModel, T2IAdapter, LCMScheduler
from diffusers.utils import load_image, make_image_grid

# detect the canny map in low resolution to avoid high-frequency details
image = load_image(
    "https://hf.co/datasets/huggingface/documentation-images/resolve/main/diffusers/input_image_vermeer.png"
).resize((384, 384))

image = np.array(image)

low_threshold = 100
high_threshold = 200

image = cv2.Canny(image, low_threshold, high_threshold)
image = image[:, :, None]
image = np.concatenate([image, image, image], axis=2)
canny_image = Image.fromarray(image).resize((1024, 1024))

adapter = T2IAdapter.from_pretrained("TencentARC/t2i-adapter-canny-sdxl-1.0", dtype=torch.float16, variant="fp16").to("cuda")  # or "mps", "xpu", "cpu"

pipe = StableDiffusionXLAdapterPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    adapter=adapter,
    dtype=torch.float16,
    variant="fp16",
).to("cuda")

pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)

pipe.load_lora_weights("latent-consistency/lcm-lora-sdxl")

prompt = "the mona lisa, 4k picture, high quality"
negative_prompt = "extra digit, fewer digits, cropped, worst quality, low quality, glitch, deformed, mutated, ugly, disfigured"

generator = torch.manual_seed(0)
image = pipe(
    prompt=prompt,
    negative_prompt=negative_prompt,
    image=canny_image,
    num_inference_steps=4,
    guidance_scale=1.5,
    adapter_conditioning_scale=0.8,
    adapter_conditioning_factor=1,
    generator=generator,
).images[0]
```

    

### AnimateDiff

[AnimateDiff](./animatediff) adalah adapter yang menambahkan gerakan ke gambar. Adapter ini dapat digunakan dengan sebagian besar model Stable Diffusion, sehingga secara efektif mengubahnya menjadi model "generasi video". Menghasilkan hasil yang baik dengan model video biasanya memerlukan pembuatan beberapa frame (16-24), yang bisa sangat lambat dengan model Stable Diffusion biasa. LCM-LoRA dapat mempercepat proses ini dengan hanya membutuhkan 4-8 langkah untuk setiap frame.

Muat [AnimateDiffPipeline](/docs/diffusers/v0.43.0/id/api/pipelines/animatediff#diffusers.AnimateDiffPipeline) dan berikan `MotionAdapter` ke dalamnya. Kemudian ganti scheduler dengan [LCMScheduler](/docs/diffusers/v0.43.0/id/api/schedulers/lcm#diffusers.LCMScheduler), dan gabungkan kedua adapter LoRA dengan metode `~loaders.UNet2DConditionLoadersMixin.set_adapters`. Sekarang Anda dapat memberikan prompt ke pipeline dan menghasilkan gambar animasi.

```py
import torch
from diffusers import MotionAdapter, AnimateDiffPipeline, DDIMScheduler, LCMScheduler
from diffusers.utils import export_to_gif

adapter = MotionAdapter.from_pretrained("guoyww/animatediff-motion-adapter-v1-5")
pipe = AnimateDiffPipeline.from_pretrained(
    "frankjoshua/toonyou_beta6",
    motion_adapter=adapter,
).to("cuda")  # or "mps", "xpu", "cpu"

# set scheduler
pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)

# load LCM-LoRA
pipe.load_lora_weights("latent-consistency/lcm-lora-sdv1-5", adapter_name="lcm")
pipe.load_lora_weights("guoyww/animatediff-motion-lora-zoom-in", weight_name="diffusion_pytorch_model.safetensors", adapter_name="motion-lora")

pipe.set_adapters(["lcm", "motion-lora"], adapter_weights=[0.55, 1.2])

prompt = "best quality, masterpiece, 1girl, looking at viewer, blurry background, upper body, contemporary, dress"
generator = torch.manual_seed(0)
frames = pipe(
    prompt=prompt,
    num_inference_steps=5,
    guidance_scale=1.25,
    cross_attention_kwargs={"scale": 1},
    num_frames=24,
    generator=generator
).frames[0]
export_to_gif(frames, "animation.gif")
```

    

## LatentConsistencyModelPipeline[[diffusers.LatentConsistencyModelPipeline]]

#### diffusers.LatentConsistencyModelPipeline[[diffusers.LatentConsistencyModelPipeline]]

```python
diffusers.LatentConsistencyModelPipeline(vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, unet: UNet2DConditionModel, scheduler: LCMScheduler, safety_checker: StableDiffusionSafetyChecker, feature_extractor: CLIPImageProcessorPil, image_encoder: transformers.models.clip.modeling_clip.CLIPVisionModelWithProjection | None = None, requires_safety_checker: bool = True)
```

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

**Parameter:**

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

text_encoder ([CLIPTextModel](https://huggingface.co/docs/transformers/v5.22.2/en/model_doc/clip#transformers.CLIPTextModel)) : text-encoder beku ([clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14)).

tokenizer ([CLIPTokenizer](https://huggingface.co/docs/transformers/v5.22.2/en/model_doc/clip#transformers.CLIPTokenizer)) : Sebuah `CLIPTokenizer` untuk melakukan tokenisasi teks.

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

scheduler ([SchedulerMixin](/docs/diffusers/v0.43.0/id/api/schedulers/overview#diffusers.SchedulerMixin)) : Penjadwal yang digunakan bersama `unet` untuk menghilangkan noise pada latens gambar yang telah dikodekan. Saat ini hanya mendukung [LCMScheduler](/docs/diffusers/v0.43.0/id/api/schedulers/lcm#diffusers.LCMScheduler).

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

requires_safety_checker (`bool`, *opsional*, defaultnya `True`) : Apakah pipeline memerlukan komponen safety checker.

Pipeline untuk generasi teks-ke-gambar menggunakan model konsistensi laten.

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

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

#### __call__[[diffusers.LatentConsistencyModelPipeline.__call__]]

```python
__call__(prompt: str | list[str] = None, height: int | None = None, width: int | None = None, num_inference_steps: int = 4, original_inference_steps: int = None, timesteps: list[int] = None, guidance_scale: float = 8.5, num_images_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, 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 = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], **kwargs)
```

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

**Parameter:**

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

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

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

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

original_inference_steps (`int`, *opsional*) : Jumlah langkah inferensi asli yang digunakan untuk menghasilkan jadwal timestep yang berjarak linear, yang darinya kami akan mengambil `num_inference_steps` timestep yang berjarak merata sebagai jadwal timestep akhir, mengikuti metode Skipping-Step dalam makalah (lihat Bagian 4.3). Jika tidak diatur, nilai ini akan secara default menggunakan atribut `original_inference_steps` dari scheduler.

timesteps (`list[int]`, *opsional*) : Timesteps kustom untuk digunakan dalam proses denoising. Jika tidak didefinisikan, timesteps `num_inference_steps` yang berjarak sama pada jadwal timestep pelatihan/distilasi LCM asli akan digunakan. Harus dalam urutan menurun.

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`. Perhatikan bahwa paper asli latent consistency models menggunakan formulasi CFG yang berbeda di mana guidance scales dikurangi 1 (sehingga dalam formulasi paper, CFG diaktifkan ketika `guidance_scale > 0`).

num_images_per_prompt (`int`, *opsional*, default 1) : Jumlah gambar yang akan dihasilkan per prompt.

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

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`, *opsional*) : Fungsi yang dipanggil di akhir setiap langkah denoising selama inferensi. Fungsi ini dipanggil dengan argumen berikut: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` akan berisi daftar semua tensor sesuai yang ditentukan oleh `callback_on_step_end_tensor_inputs`.

callback_on_step_end_tensor_inputs (`list`, *opsional*) : Daftar input tensor untuk fungsi `callback_on_step_end`. Tensor yang ditentukan dalam daftar akan diteruskan sebagai argumen `callback_kwargs`. Anda hanya dapat menyertakan variabel yang tercantum dalam atribut `._callback_tensor_inputs` dari kelas pipeline Anda.

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

Jika `return_dict` adalah `True`, [StableDiffusionPipelineOutput](/docs/diffusers/v0.43.0/id/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) dikembalikan, selain itu sebuah `tuple` dikembalikan di mana elemen pertama adalah daftar dengan gambar yang dihasilkan 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
>>> from diffusers import DiffusionPipeline
>>> import torch

>>> pipe = DiffusionPipeline.from_pretrained("SimianLuo/LCM_Dreamshaper_v7")
>>> # To save GPU memory, torch.float16 can be used, but it may compromise image quality.
>>> pipe.to(torch_device="cuda", torch_dtype=torch.float32)

>>> prompt = "Self-portrait oil painting, a beautiful cyborg with golden hair, 8k"

>>> # Can be set to 1~50 steps. LCM support fast inference even <= 4 steps. Recommend: 1~8 steps.
>>> num_inference_steps = 4
>>> images = pipe(prompt=prompt, num_inference_steps=num_inference_steps, guidance_scale=8.0).images
>>> images[0].save("image.png")
```

#### enable_freeu[[diffusers.LatentConsistencyModelPipeline.enable_freeu]]

```python
enable_freeu(s1: float, s2: float, b1: float, b2: float)
```

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

**Parameter:**

s1 (`float`) : Faktor penskalaan untuk tahap 1 untuk meredam kontribusi fitur skip. Hal ini dilakukan untuk memitigasi "efek oversmoothing" dalam proses denoising yang ditingkatkan.

s2 (`float`) : Faktor penskalaan untuk tahap 2 untuk meredam kontribusi fitur skip. Hal ini dilakukan untuk memitigasi "efek oversmoothing" dalam proses denoising yang ditingkatkan.

b1 (`float`) : Faktor penskalaan untuk tahap 1 untuk memperkuat kontribusi fitur backbone.

b2 (`float`) : Faktor penskalaan untuk tahap 2 untuk memperkuat kontribusi fitur backbone.

Mengaktifkan mekanisme FreeU seperti yang dijelaskan di https://huggingface.co/papers/2309.11497.

Awalan setelah faktor penskalaan mewakili tahap di mana faktor tersebut diterapkan.

Silakan merujuk ke [respositori resmi](https://github.com/ChenyangSi/FreeU) untuk kombinasi nilai yang diketahui bekerja dengan baik untuk berbagai pipeline seperti Stable Diffusion v1, v2, dan Stable Diffusion XL.

#### disable_freeu[[diffusers.LatentConsistencyModelPipeline.disable_freeu]]

```python
disable_freeu()
```

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

Menonaktifkan mekanisme FreeU jika diaktifkan.

#### encode_prompt[[diffusers.LatentConsistencyModelPipeline.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/latent_consistency_models/pipeline_latent_consistency_text2img.py#L226)

**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.LatentConsistencyModelPipeline.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/latent_consistency_models/pipeline_latent_consistency_text2img.py#L517)

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

## LatentConsistencyModelImg2ImgPipeline[[diffusers.LatentConsistencyModelImg2ImgPipeline]]

#### diffusers.LatentConsistencyModelImg2ImgPipeline[[diffusers.LatentConsistencyModelImg2ImgPipeline]]

```python
diffusers.LatentConsistencyModelImg2ImgPipeline(vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, unet: UNet2DConditionModel, scheduler: LCMScheduler, safety_checker: StableDiffusionSafetyChecker, feature_extractor: CLIPImageProcessorPil, image_encoder: transformers.models.clip.modeling_clip.CLIPVisionModelWithProjection | None = None, requires_safety_checker: bool = True)
```

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

**Parameter:**

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

text_encoder ([CLIPTextModel](https://huggingface.co/docs/transformers/v5.22.2/en/model_doc/clip#transformers.CLIPTextModel)) : text-encoder beku ([clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14)).

tokenizer ([CLIPTokenizer](https://huggingface.co/docs/transformers/v5.22.2/en/model_doc/clip#transformers.CLIPTokenizer)) : Sebuah `CLIPTokenizer` untuk melakukan tokenisasi teks.

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

scheduler ([SchedulerMixin](/docs/diffusers/v0.43.0/id/api/schedulers/overview#diffusers.SchedulerMixin)) : Penjadwal yang digunakan bersama `unet` untuk menghilangkan noise pada latens gambar yang telah dikodekan. Saat ini hanya mendukung [LCMScheduler](/docs/diffusers/v0.43.0/id/api/schedulers/lcm#diffusers.LCMScheduler).

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

requires_safety_checker (`bool`, *opsional*, defaultnya `True`) : Apakah pipeline memerlukan komponen safety checker.

Pipeline untuk generasi gambar-ke-gambar menggunakan model konsistensi laten.

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

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

#### __call__[[diffusers.LatentConsistencyModelImg2ImgPipeline.__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 = 4, strength: float = 0.8, original_inference_steps: int = None, timesteps: list[int] = None, guidance_scale: float = 8.5, num_images_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, 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 = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], **kwargs)
```

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

**Parameter:**

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

image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]`, atau `list[np.ndarray]`) : `Image` atau tensor yang mewakili batch gambar untuk digunakan sebagai titik awal. Dapat juga menerima latens gambar sebagai `image`, tetapi jika latens dilewatkan secara langsung, ia tidak akan di-encode ulang.

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.

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

original_inference_steps (`int`, *opsional*) : Jumlah langkah inferensi asli yang digunakan untuk menghasilkan jadwal timestep yang berjarak linear, yang darinya kami akan mengambil `num_inference_steps` timestep yang berjarak merata sebagai jadwal timestep akhir, mengikuti metode Skipping-Step dalam makalah (lihat Bagian 4.3). Jika tidak diatur, nilai ini akan secara default menggunakan atribut `original_inference_steps` dari scheduler.

timesteps (`list[int]`, *opsional*) : Timesteps kustom untuk digunakan dalam proses denoising. Jika tidak didefinisikan, timesteps `num_inference_steps` yang berjarak sama pada jadwal timestep pelatihan/distilasi LCM asli akan digunakan. Harus dalam urutan menurun.

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`. Perhatikan bahwa paper asli latent consistency models menggunakan formulasi CFG yang berbeda di mana guidance scales dikurangi 1 (sehingga dalam formulasi paper, CFG diaktifkan ketika `guidance_scale > 0`).

num_images_per_prompt (`int`, *opsional*, default 1) : Jumlah gambar yang akan dihasilkan per prompt.

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

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`, *opsional*) : Fungsi yang dipanggil di akhir setiap langkah denoising selama inferensi. Fungsi ini dipanggil dengan argumen berikut: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` akan berisi daftar semua tensor sesuai yang ditentukan oleh `callback_on_step_end_tensor_inputs`.

callback_on_step_end_tensor_inputs (`list`, *opsional*) : Daftar input tensor untuk fungsi `callback_on_step_end`. Tensor yang ditentukan dalam daftar akan diteruskan sebagai argumen `callback_kwargs`. Anda hanya dapat menyertakan variabel yang tercantum dalam atribut `._callback_tensor_inputs` dari kelas pipeline Anda.

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

Jika `return_dict` adalah `True`, [StableDiffusionPipelineOutput](/docs/diffusers/v0.43.0/id/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) dikembalikan, selain itu sebuah `tuple` dikembalikan di mana elemen pertama adalah daftar dengan gambar yang dihasilkan 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
>>> from diffusers import AutoPipelineForImage2Image
>>> import torch
>>> import PIL

>>> pipe = AutoPipelineForImage2Image.from_pretrained("SimianLuo/LCM_Dreamshaper_v7")
>>> # To save GPU memory, torch.float16 can be used, but it may compromise image quality.
>>> pipe.to(torch_device="cuda", torch_dtype=torch.float32)

>>> prompt = "High altitude snowy mountains"
>>> image = PIL.Image.open("./snowy_mountains.png")

>>> # Can be set to 1~50 steps. LCM support fast inference even <= 4 steps. Recommend: 1~8 steps.
>>> num_inference_steps = 4
>>> images = pipe(
...     prompt=prompt, image=image, num_inference_steps=num_inference_steps, guidance_scale=8.0
... ).images

>>> images[0].save("image.png")
```

#### enable_freeu[[diffusers.LatentConsistencyModelImg2ImgPipeline.enable_freeu]]

```python
enable_freeu(s1: float, s2: float, b1: float, b2: float)
```

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

**Parameter:**

s1 (`float`) : Faktor penskalaan untuk tahap 1 untuk meredam kontribusi fitur skip. Hal ini dilakukan untuk memitigasi "efek oversmoothing" dalam proses denoising yang ditingkatkan.

s2 (`float`) : Faktor penskalaan untuk tahap 2 untuk meredam kontribusi fitur skip. Hal ini dilakukan untuk memitigasi "efek oversmoothing" dalam proses denoising yang ditingkatkan.

b1 (`float`) : Faktor penskalaan untuk tahap 1 untuk memperkuat kontribusi fitur backbone.

b2 (`float`) : Faktor penskalaan untuk tahap 2 untuk memperkuat kontribusi fitur backbone.

Mengaktifkan mekanisme FreeU seperti yang dijelaskan di https://huggingface.co/papers/2309.11497.

Awalan setelah faktor penskalaan mewakili tahap di mana faktor tersebut diterapkan.

Silakan merujuk ke [respositori resmi](https://github.com/ChenyangSi/FreeU) untuk kombinasi nilai yang diketahui bekerja dengan baik untuk berbagai pipeline seperti Stable Diffusion v1, v2, dan Stable Diffusion XL.

#### disable_freeu[[diffusers.LatentConsistencyModelImg2ImgPipeline.disable_freeu]]

```python
disable_freeu()
```

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

Menonaktifkan mekanisme FreeU jika diaktifkan.

#### encode_prompt[[diffusers.LatentConsistencyModelImg2ImgPipeline.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/latent_consistency_models/pipeline_latent_consistency_img2img.py#L241)

**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.LatentConsistencyModelImg2ImgPipeline.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/latent_consistency_models/pipeline_latent_consistency_img2img.py#L576)

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