# Latent Tutarlılık Damıtma

[Latent Consistency Models (LCM)](https://hf.co/papers/2310.04378), yalnızca birkaç adımda yüksek kaliteli görseller üretebilir; bu, birçok pipeline'ın en az 25+ adım gerektirmesi nedeniyle büyük bir ilerleme niteliğindedir. LCM'ler, herhangi bir Stable Diffusion modeline latent tutarlılık damıtma (distillation) yönteminin uygulanmasıyla elde edilir. Bu yöntem, latent uzaya *tek aşamalı yönlendirilmiş damıtma* uygulayarak ve damıtma sürecini hızlandırmak için zaman adımlarını tutarlı bir şekilde atlamak üzere *adım atlama* (skipping-step) yöntemini birleştirerek çalışır (daha fazla ayrıntı için makalenin 4.1, 4.2 ve 4.3 bölümlerine bakınız).

Sınırlı vRAM'a sahip bir GPU üzerinde eğitim yapıyorsanız, bellek kullanımını azaltmak ve eğitimi hızlandırmak için `gradient_checkpointing`, `gradient_accumulation_steps` ve `mixed_precision` özelliklerini etkinleştirmeyi deneyin. [xFormers](../optimization/attention_backends) ve [bitsandbytes'](https://github.com/TimDettmers/bitsandbytes) 8-bit optimizatörünü kullanarak bellek verimli dikkati etkinleştirerek bellek kullanımınızı daha da azaltabilirsiniz.

Bu kılavuz, [train_lcm_distill_sd_wds.py](https://github.com/huggingface/diffusers/blob/main/examples/consistency_distillation/train_lcm_distill_sd_wds.py) betiğini inceleyerek onu daha yakından tanımanıza ve kendi kullanım senaryonuza nasıl uyarlayabileceğinize yardımcı olacaktır.

Betik çalıştırmadan önce, kütüphanenin kaynak kodundan yüklendiğinden emin olun:

```bash
git clone https://github.com/huggingface/diffusers
cd diffusers
pip install .
```

Ardından, eğitim betiğini içeren örnek klasörüne gidin ve kullandığınız betik için gerekli bağımlılıkları yükleyin:

```bash
cd examples/consistency_distillation
pip install -r requirements.txt
```

> [!TIP]
> 🤗 Accelerate, birden fazla GPU/TPU ile veya karma hassasiyetle eğitim yapmanıza yardımcı olmak için tasarlanmış bir kütüphanedir. Donanımınıza ve ortamınıza göre eğitim kurulumunuzu otomatik olarak yapılandırır. Daha fazla bilgi edinmek için 🤗 Accelerate [Hızlı tur](https://huggingface.co/docs/accelerate/quicktour) sayfasına göz atın.

🤗 Accelerate ortamını başlatın (eğitimi önemli ölçüde hızlandırmak için `torch.compile` etkinleştirmeyi deneyin):

```bash
accelerate config
```

Herhangi bir yapılandırma seçmeden varsayılan bir 🤗 Accelerate ortamı kurmak için:

```bash
accelerate config default
```

Ya da ortamınız, bir notebook gibi, etkileşimli bir kabuğu desteklemiyorsa, şunu kullanabilirsiniz:

```py
from accelerate.utils import write_basic_config

write_basic_config()
```

Son olarak, kendi veri setiniz üzerinde bir model eğitmek istiyorsanız, eğitim scriptiyle uyumlu bir veri seti oluşturma yöntemini öğrenmek için [Eğitim için veri seti oluşturma](create_dataset) kılavuzuna göz atın.

## Betik parametreleri

> [!TIP]
> Aşağıdaki bölümler, betiğin nasıl değiştirileceğini anlamak için önemli olan eğitim betiğinin kısımlarını vurgular, ancak betiğin her yönünü ayrıntılı olarak kapsamaz. Daha fazla bilgi edinmek isterseniz, [betiği](https://github.com/huggingface/diffusers/blob/main/examples/consistency_distillation/train_lcm_distill_sd_wds.py) okumaktan çekinmeyin ve herhangi bir sorunuz veya endişeniz varsa bize bildirin.

Eğitim betiği, eğitim çalışmanızı özelleştirmenize yardımcı olmak için birçok parametre sağlar. Tüm parametreler ve açıklamaları [`parse_args()`](https://github.com/huggingface/diffusers/blob/3b37488fa3280aed6a95de044d7a42ffdcb565ef/examples/consistency_distillation/train_lcm_distill_sd_wds.py#L419) fonksiyonunda bulunur. Bu fonksiyon, eğitim batch boyutu ve öğrenme oranı gibi her parametre için varsayılan değerler sağlar, ancak isterseniz kendi değerlerinizi eğitim komutunda da belirleyebilirsiniz.

Örneğin, fp16 biçimini kullanarak karma hassasiyetle eğitimi hızlandırmak için eğitim komutuna `--mixed_precision` parametresini ekleyin:

```bash
accelerate launch train_lcm_distill_sd_wds.py \
  --mixed_precision="fp16"
```

Parametrelerin çoğu [Metinden görüntüye](text2image#script-parameters) eğitim kılavuzundaki parametrelerle aynıdır, bu nedenle bu kılavuzda latent tutarlılık damıtmasıyla ilgili parametrelere odaklanacaksınız.

- `--pretrained_teacher_model`: öğretmen modeli olarak kullanılacak önceden eğitilmiş latent difüzyon modelinin yolu
- `--pretrained_vae_model_name_or_path`: önceden eğitilmiş bir VAE'nin yolu; SDXL VAE'sinin sayısal kararsızlıktan muzdarip olduğu bilinmektedir, bu nedenle bu parametre, fp16'da çalışan madebyollin tarafından geliştirilen (örneğin bu [VAE](https://huggingface.co/madebyollin/sdxl-vae-fp16-fix)) alternatif bir VAE belirtmenize olanak tanır)
- `--w_min` ve `--w_max`: rehberlik ölçeği örneklemesi için minimum ve maksimum rehberlik ölçeği değerleri
- `--num_ddim_timesteps`: DDIM örneklemesi için zaman adımı sayısı
- `--loss_type`: latent consistency distillation için hesaplanacak kayıp türü (L2 veya Huber); Huber kaybı, aykırı değerlere karşı daha dayanıklı olduğu için genellikle tercih edilir
- `--huber_c`: Huber kaybı parametresi

## Eğitim betiği

Eğitim betiği, görüntülerin ön işlenmesi ve bir eğitim veri setinin oluşturulması için bir veri seti sınıfı olan [`Text2ImageDataset`](https://github.com/huggingface/diffusers/blob/3b37488fa3280aed6a95de044d7a42ffdcb565ef/examples/consistency_distillation/train_lcm_distill_sd_wds.py#L141) oluşturarak başlar.

```py
def transform(example):
    image = example["image"]
    image = TF.resize(image, resolution, interpolation=transforms.InterpolationMode.BILINEAR)

    c_top, c_left, _, _ = transforms.RandomCrop.get_params(image, output_size=(resolution, resolution))
    image = TF.crop(image, c_top, c_left, resolution, resolution)
    image = TF.to_tensor(image)
    image = TF.normalize(image, [0.5], [0.5])

    example["image"] = image
    return example
```

Bulut ortamında depolanan büyük veri setlerinin okunması ve yazılmasında performansın artırılması için bu betik, dönüştürmeleri uygulamak ve eğitim için bir veri seti ile dataloader oluşturmak üzere bir ön işleme hattı oluşturmak için [WebDataset](https://github.com/webdataset/webdataset) biçimini kullanır. Görseller, önce tam veri setinin indirilmesine gerek kalmadan işlenir ve eğitim döngüsüne aktarılır.

```py
processing_pipeline = [
    wds.decode("pil", handler=wds.ignore_and_continue),
    wds.rename(image="jpg;png;jpeg;webp", text="text;txt;caption", handler=wds.warn_and_continue),
    wds.map(filter_keys({"image", "text"})),
    wds.map(transform),
    wds.to_tuple("image", "text"),
]
```

[`main()`](https://github.com/huggingface/diffusers/blob/3b37488fa3280aed6a95de044d7a42ffdcb565ef/examples/consistency_distillation/train_lcm_distill_sd_wds.py#L768) fonksiyonunda, gürültü zamanlayıcısı, tokenizörler, metin kodlayıcılar ve VAE gibi gerekli tüm bileşenler yüklenir. Öğretmen UNet de burada yüklenir ve ardından öğretmen UNet'ten bir öğrenci UNet oluşturulabilir. Öğrenci UNet, eğitim sırasında optimizatör tarafından güncellenir.

```py
teacher_unet = UNet2DConditionModel.from_pretrained(
    args.pretrained_teacher_model, subfolder="unet", revision=args.teacher_revision
)

unet = UNet2DConditionModel(**teacher_unet.config)
unet.load_state_dict(teacher_unet.state_dict(), strict=False)
unet.train()
```

Şimdi UNet parametrelerini güncellemek için [optimizer](https://github.com/huggingface/diffusers/blob/3b37488fa3280aed6a95de044d7a42ffdcb565ef/examples/consistency_distillation/train_lcm_distill_sd_wds.py#L979) oluşturabilirsiniz:

```py
optimizer = optimizer_class(
    unet.parameters(),
    lr=args.learning_rate,
    betas=(args.adam_beta1, args.adam_beta2),
    weight_decay=args.adam_weight_decay,
    eps=args.adam_epsilon,
)
```

[veri setini](https://github.com/huggingface/diffusers/blob/3b37488fa3280aed6a95de044d7a42ffdcb565ef/examples/consistency_distillation/train_lcm_distill_sd_wds.py#L994) oluşturun:

```py
dataset = Text2ImageDataset(
    train_shards_path_or_url=args.train_shards_path_or_url,
    num_train_examples=args.max_train_samples,
    per_gpu_batch_size=args.train_batch_size,
    global_batch_size=args.train_batch_size * accelerator.num_processes,
    num_workers=args.dataloader_num_workers,
    resolution=args.resolution,
    shuffle_buffer_size=1000,
    pin_memory=True,
    persistent_workers=True,
)
train_dataloader = dataset.train_dataloader
```

Ardından, [eğitim döngüsünü](https://github.com/huggingface/diffusers/blob/3b37488fa3280aed6a95de044d7a42ffdcb565ef/examples/consistency_distillation/train_lcm_distill_sd_wds.py#L1049) kurmaya ve latent tutarlılık damıtma yöntemini uygulamaya hazırsınız (daha fazla ayrıntı için makaledeki Algoritma 1'e bakın). Betiğin bu bölümü, latentlere gürültü ekleme, örneklem alma ve yönlendirme ölçeği gömme oluşturma ile gürültüden orijinal görüntüyü tahmin etme işlemlerini ele alır.

```py
pred_x_0 = predicted_origin(
    noise_pred,
    start_timesteps,
    noisy_model_input,
    noise_scheduler.config.prediction_type,
    alpha_schedule,
    sigma_schedule,
)

model_pred = c_skip_start * noisy_model_input + c_out_start * pred_x_0
```

Ardından [öğretmen modelinin tahminlerini](https://github.com/huggingface/diffusers/blob/3b37488fa3280aed6a95de044d7a42ffdcb565ef/examples/consistency_distillation/train_lcm_distill_sd_wds.py#L1172) ve [LCM tahminlerini](https://github.com/huggingface/diffusers/blob/3b37488fa3280aed6a95de044d7a42ffdcb565ef/examples/consistency_distillation/train_lcm_distill_sd_wds.py#L1209) alır, kaybı hesaplar ve ardından bu kaybı LCM'ye geri yayılım (backpropagation) ile iletir.

```py
if args.loss_type == "l2":
    loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean")
elif args.loss_type == "huber":
    loss = torch.mean(
        torch.sqrt((model_pred.float() - target.float()) ** 2 + args.huber_c**2) - args.huber_c
    )
```

Eğitim döngüsünün nasıl çalıştığı hakkında daha fazla bilgi edinmek isterseniz, gürültü azaltma sürecinin temel kalıbını açıklayan [Pipeline, modeller ve zamanlayıcıları anlama](../using-diffusers/write_own_pipeline) eğitimine göz atın.

## Betik başlat

Şimdi eğitim betiğini başlatıp damıtma işlemine başlamak için hazırsınız!

Bu kılavuzda, Hub üzerinde [burada](https://huggingface.co/datasets/laion/conceptual-captions-12m-webdataset) saklanan [Conceptual Captions 12M](https://github.com/google-research-datasets/conceptual-12m) veri setinin yolunu belirtmek için `--train_shards_path_or_url` parametresini kullanacaksınız. `MODEL_DIR` ortam değişkenini öğretmen modelinin adını, `OUTPUT_DIR` değişkenini ise modelin kaydedilmesini istediğiniz konumu belirtmek üzere ayarlayın.

```bash
export MODEL_DIR="stable-diffusion-v1-5/stable-diffusion-v1-5"
export OUTPUT_DIR="path/to/saved/model"

accelerate launch train_lcm_distill_sd_wds.py \
    --pretrained_teacher_model=$MODEL_DIR \
    --output_dir=$OUTPUT_DIR \
    --mixed_precision=fp16 \
    --resolution=512 \
    --learning_rate=1e-6 --loss_type="huber" --ema_decay=0.95 --adam_weight_decay=0.0 \
    --max_train_steps=1000 \
    --max_train_samples=4000000 \
    --dataloader_num_workers=8 \
    --train_shards_path_or_url="pipe:curl -L -s https://huggingface.co/datasets/laion/conceptual-captions-12m-webdataset/resolve/main/data/{00000..01099}.tar?download=true" \
    --validation_steps=200 \
    --checkpointing_steps=200 --checkpoints_total_limit=10 \
    --train_batch_size=12 \
    --gradient_checkpointing --enable_xformers_memory_efficient_attention \
    --gradient_accumulation_steps=1 \
    --use_8bit_adam \
    --resume_from_checkpoint=latest \
    --report_to=wandb \
    --seed=453645634 \
    --push_to_hub
```

Eğitim tamamlandığında, yeni LCM'nizi çıkarım için kullanabilirsiniz.

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

unet = UNet2DConditionModel.from_pretrained("your-username/your-model", dtype=torch.float16, variant="fp16")
pipeline = DiffusionPipeline.from_pretrained("stable-diffusion-v1-5/stable-diffusion-v1-5", unet=unet, dtype=torch.float16, variant="fp16")

pipeline.scheduler = LCMScheduler.from_config(pipe.scheduler.config)
pipeline.to("cuda")  # or "mps", "xpu", "cpu"

prompt = "sushi rolls in the form of panda heads, sushi platter"

image = pipeline(prompt, num_inference_steps=4, guidance_scale=1.0).images[0]
```

## LoRA

LoRA, eğitilebilir parametre sayısını önemli ölçüde azaltmak için kullanılan bir eğitim tekniğidir. Sonuç olarak, eğitim daha hızlıdır ve elde edilen ağırlıklar çok daha küçük (~100MB) olduğu için saklaması daha kolaydır. LoRA ile eğitim yapmak için [train_lcm_distill_lora_sd_wds.py](https://github.com/huggingface/diffusers/blob/main/examples/consistency_distillation/train_lcm_distill_lora_sd_wds.py) veya [train_lcm_distill_lora_sdxl.wds.py](https://github.com/huggingface/diffusers/blob/main/examples/consistency_distillation/train_lcm_distill_lora_sdxl_wds.py) betiğini kullanın.

LoRA eğitim betiği, [LoRA eğitimi](lora) kılavuzunda daha ayrıntılı olarak ele alınır.

## Stable Diffusion XL

Stable Diffusion XL (SDXL), yüksek çözünürlüklü görüntüler üreten güçlü bir metinden görüntüye modelidir ve mimarisine ikinci bir metin kodlayıcı ekler. Bir SDXL modelini LoRA ile eğitmek için [train_lcm_distill_sdxl_wds.py](https://github.com/huggingface/diffusers/blob/main/examples/consistency_distillation/train_lcm_distill_sdxl_wds.py) betiğini kullanın.

SDXL eğitim betiği, [SDXL eğitimi](sdxl) kılavuzunda daha ayrıntılı olarak ele alınmaktadır.

## Sonraki adımlar

Bir LCM modeli damıttığınız için tebrikler! LCM hakkında daha fazla bilgi edinmek için aşağıdakiler faydalı olabilir:

- Metinden görüntüye, görüntüden görüntüye ve LoRA kontrol noktalarıyla [LCM'leri çıkarım için nasıl kullanacağınızı öğrenin.](../api/pipelines/latent_consistency_models)
- SDXL LCM-LoRA'ların süper hızlı çıkarım, kalite karşılaştırmaları, ölçümler ve daha fazlası hakkında daha fazla bilgi edinmek için [Latent Consistency LoRAs ile 4 adımda SDXL](https://huggingface.co/blog/lcm_lora) blog yazısını okuyun.