DreamBooth

DreamBooth, bir konu veya stilin yalnızca birkaç görseli üzerinde eğitim yaparak tüm difüzyon modelini güncelleyen bir eğitim tekniğidir. Özel bir kelimeyi örnek görsellerle ilişkilendirerek çalışır.

Eğitilmiş bir kontrol noktasını çıkarım için yüklemek için DreamBooth modelini çıkarım için yükleme bölümüne bakın.

Sınırlı vRAM'a sahip bir GPU üzerinde eğitim yapıyorsanız, eğitim komutunda gradient_checkpointing ve mixed_precision parametrelerini etkinleştirmeyi denemelisiniz. Ayrıca xFormers ile bellek verimli dikkat (attention) kullanarak bellek ayak izinizi azaltabilirsiniz.

Bu kılavuz, train_dreambooth.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:

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

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

cd examples/dreambooth
pip install -r requirements.txt

🤗 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 sayfasına göz atın.

Bir 🤗 Accelerate ortamı başlatın:

accelerate config

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

accelerate config default

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

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 kılavuzuna göz atın.

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 okumaktan çekinmeyin ve herhangi bir sorunuz veya endişeniz varsa bize bildirin.

Betik parametreleri

DreamBooth, eğitim hiperparametrelerine karşı çok hassastır ve aşırı öğrenme (overfitting) kolayca oluşabilir. Farklı konular için önerilen ayarları incelemenize ve uygun hiperparametreleri seçmenize yardımcı olmak için Training Stable Diffusion with Dreambooth using 🧨 Diffusers blog yazısını okuyun.

Eğitim betiği, eğitim çalıştırmanızı özelleştirmek için birçok parametre sunar. Tüm parametreler ve açıklamaları parse_args() fonksiyonunda bulunur. Parametreler, kutudan çıktığı gibi oldukça iyi çalışacak şekilde varsayılan değerlerle ayarlanmıştır; ancak isterseniz eğitim komutunda kendi değerlerinizi de belirleyebilirsiniz.

Örneğin, bf16 biçiminde eğitim yapmak için:

accelerate launch train_dreambooth.py \
    --mixed_precision="bf16"

Bilmek ve belirtmek gereken bazı temel ve önemli parametreler şunlardır:

--pretrained_model_name_or_path: Hub'daki modelin adı veya önceden eğitilmiş modele yerel bir yol
--instance_data_dir: eğitim veri setini (örnek görüntüler) içeren klasörün yolu
--instance_prompt: örnek görseller için özel kelimeyi içeren metin komutu
--train_text_encoder: metin kodlayıcısının da eğitilip eğitilmeyeceği
--output_dir: eğitilen modelin kaydedileceği yer
--push_to_hub: eğitilen modelin Hub'a gönderilip gönderilmeyeceği
--checkpointing_steps: modelin eğitim sırasında checkpoint kaydetme sıklığı; eğitim herhangi bir nedenle yarıda kesilirse, eğitim komutunuza --resume_from_checkpoint ekleyerek bu checkpoint'ten eğitim devam ettirebilirsiniz

Min-SNR ağırlıklandırma

Min-SNR ağırlıklandırma stratejisi, kaybı yeniden dengeleyerek daha hızlı yakınsama elde edilmesine yardımcı olarak eğitime katkıda bulunabilir. Eğitim betiği, epsilon (gürültü) veya v_prediction tahmin etmeyi destekler, ancak Min-SNR her iki tahmin türüyle de uyumludur. Bu ağırlıklandırma stratejisi yalnızca PyTorch tarafından desteklenir.

--snr_gamma parametresini ekleyin ve önerilen değer olan 5.0 olarak ayarlayın:

accelerate launch train_dreambooth.py \
  --snr_gamma=5.0

Önceden var olan bilgi kaybı

Öncül koruma kaybı, bir modelin kendi ürettiği örnekleri kullanarak daha çeşitli görseller üretmeyi öğrenmesine yardımcı olan bir yöntemdir. Bu üretilmiş örnek görsellerler, sağladığınız görsellerle aynı sınıfa ait olduğu için, modelin sınıfa dair öğrendiklerini korumasına ve sınıfa zaten bildiklerini kullanarak yeni kompozisyonlar oluşturmasına yardımcı olurlar.

--with_prior_preservation: prior preservation loss kullanılıp kullanılmayacağı
--prior_loss_weight: model üzerindeki öncül koruma kaybının etkisini kontrol eder
--class_data_dir: üretilen sınıf örnek görsellerini içeren klasöre giden yol
--class_prompt: üretilen örnek görsellerin sınıfını açıklayan metin komutu

accelerate launch train_dreambooth.py \
  --with_prior_preservation \
  --prior_loss_weight=1.0 \
  --class_data_dir="path/to/class/images" \
  --class_prompt="text prompt describing class"

Metin kodlayıcıyı eğit

Üretilen çıktıların kalitesini artırmak için UNet'in yanı sıra metin kodlayıcısını da eğitebilirsiniz. Bunun için ek bellek gerekir ve en az 24GB vRAM'e sahip bir GPU'ya ihtiyacınız olacaktır. Gerekli donanıma sahipseniz, metin kodlayıcısını eğitmek daha iyi sonuçlar verir, özellikle yüz görüntüleri oluşturulurken. Bu seçeneği şu şekilde etkinleştirin:

accelerate launch train_dreambooth.py \
  --train_text_encoder

Eğitim betiği

DreamBooth kendi veri seti sınıflarıyla birlikte gelir:

DreamBoothDataset: eğitim için görüntüleri ve sınıf görüntülerini ön işler, istemleri (prompts) belirteçlere (token) ayırır
PromptDataset: sınıf görsellerini üretmek için istem gömme değerlerini oluşturur

prior preservation loss etkinleştirdiyseniz, sınıf görüntüleri burada oluşturulur:

sample_dataset = PromptDataset(args.class_prompt, num_new_images)
sample_dataloader = torch.utils.data.DataLoader(sample_dataset, batch_size=args.sample_batch_size)

sample_dataloader = accelerator.prepare(sample_dataloader)
pipeline.to(accelerator.device)

for example in tqdm(
    sample_dataloader, desc="Generating class images", disable=not accelerator.is_local_main_process
):
    images = pipeline(example["prompt"]).images

Sıradaki, eğitim için veri setinin hazırlanmasını ve eğitim döngüsünün kendisini yöneten main() fonksiyonudur. Betik, tokenizer, zamanlayıcı ve modelleri yükler:

# Load the tokenizer
if args.tokenizer_name:
    tokenizer = AutoTokenizer.from_pretrained(args.tokenizer_name, revision=args.revision, use_fast=False)
elif args.pretrained_model_name_or_path:
    tokenizer = AutoTokenizer.from_pretrained(
        args.pretrained_model_name_or_path,
        subfolder="tokenizer",
        revision=args.revision,
        use_fast=False,
    )

# Load scheduler and models
noise_scheduler = DDPMScheduler.from_pretrained(args.pretrained_model_name_or_path, subfolder="scheduler")
text_encoder = text_encoder_cls.from_pretrained(
    args.pretrained_model_name_or_path, subfolder="text_encoder", revision=args.revision
)

if model_has_vae(args):
    vae = AutoencoderKL.from_pretrained(
        args.pretrained_model_name_or_path, subfolder="vae", revision=args.revision
    )
else:
    vae = None

unet = UNet2DConditionModel.from_pretrained(
    args.pretrained_model_name_or_path, subfolder="unet", revision=args.revision
)

Ardından, DreamBoothDataset üzerinden eğitim veri setini ve DataLoader'ı oluşturma zamanı:

train_dataset = DreamBoothDataset(
    instance_data_root=args.instance_data_dir,
    instance_prompt=args.instance_prompt,
    class_data_root=args.class_data_dir if args.with_prior_preservation else None,
    class_prompt=args.class_prompt,
    class_num=args.num_class_images,
    tokenizer=tokenizer,
    size=args.resolution,
    center_crop=args.center_crop,
    encoder_hidden_states=pre_computed_encoder_hidden_states,
    class_prompt_encoder_hidden_states=pre_computed_class_prompt_encoder_hidden_states,
    tokenizer_max_length=args.tokenizer_max_length,
)

train_dataloader = torch.utils.data.DataLoader(
    train_dataset,
    batch_size=args.train_batch_size,
    shuffle=True,
    collate_fn=lambda examples: collate_fn(examples, args.with_prior_preservation),
    num_workers=args.dataloader_num_workers,
)

Son olarak, eğitim döngüsü, görüntüleri latent uzaya dönüştürme, girdiye gürültü ekleme, gürültü artığını tahmin etme ve kaybı hesaplama gibi kalan adımları ele alır.

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 Understanding pipelines, models and schedulers eğitim materyaline göz atın.

Betik başlat

Artık eğitim betiğini başlatmaya hazırsınız! 🚀

Bu kılavuz için bir köpeğin bazı görüntülerini indirip bir dizinde saklayacaksınız. Ancak isterseniz kendi veri setinizi oluşturup kullanabilirsiniz (Eğitim için veri seti oluşturma kılavuzuna bakın).

from huggingface_hub import snapshot_download

local_dir = "./dog"
snapshot_download(
    "diffusers/dog-example",
    local_dir=local_dir,
    repo_type="dataset",
    ignore_patterns=".gitattributes",
)

Ortam değişkeni MODEL_NAME'i Hub'daki bir model kimliğine veya yerel bir modele giden yola, INSTANCE_DIR'i az önce köpek görsellerini indirdiğiniz konuma ve OUTPUT_DIR'i modeli kaydetmek istediğiniz konuma ayarlayın. Eğitimi bağlamak için özel kelime olarak sks'yi kullanacaksınız.

Eğitim sürecini takip etmekle ilgileniyorsanız, eğitim ilerledikçe üretilen görüntüleri periyodik olarak kaydedebilirsiniz. Eğitim komutuna aşağıdaki parametreleri ekleyin:

--validation_prompt="a photo of a sks dog"
--num_validation_images=4
--validation_steps=100

Betik başlatmadan önce bir şey daha! Kullandığınız GPU'ya bağlı olarak, DreamBooth'u eğitmek için belirli optimizasyonları etkinleştirmeniz gerekebilir.

16GB

12GB

8GB

export MODEL_NAME="stable-diffusion-v1-5/stable-diffusion-v1-5"
export INSTANCE_DIR="./dog"
export OUTPUT_DIR="path_to_saved_model"

accelerate launch train_dreambooth.py \
  --pretrained_model_name_or_path=$MODEL_NAME  \
  --instance_data_dir=$INSTANCE_DIR \
  --output_dir=$OUTPUT_DIR \
  --instance_prompt="a photo of sks dog" \
  --resolution=512 \
  --train_batch_size=1 \
  --gradient_accumulation_steps=1 \
  --learning_rate=5e-6 \
  --lr_scheduler="constant" \
  --lr_warmup_steps=0 \
  --max_train_steps=400 \
  --push_to_hub

Eğitim tamamlandığında, yeni eğittiğiniz modeli çıkarım için kullanabilirsiniz!

Eğitim tamamlanmadan önce modelinizi çıkarım için denemek için sabırsızlanıyor musunuz? 🤭 🤗 Accelerate'in en son sürümünün yüklü olduğundan emin olun.

from diffusers import DiffusionPipeline, UNet2DConditionModel
from transformers import CLIPTextModel
import torch

unet = UNet2DConditionModel.from_pretrained("path/to/model/checkpoint-100/unet")

# if you have trained with `--args.train_text_encoder` make sure to also load the text encoder
text_encoder = CLIPTextModel.from_pretrained("path/to/model/checkpoint-100/checkpoint-100/text_encoder")

pipeline = DiffusionPipeline.from_pretrained(
    "stable-diffusion-v1-5/stable-diffusion-v1-5", unet=unet, text_encoder=text_encoder, dtype=torch.float16,
).to("cuda")

image = pipeline("A photo of sks dog in a bucket", num_inference_steps=50, guidance_scale=7.5).images[0]
image.save("dog-bucket.png")

from diffusers import DiffusionPipeline
import torch

pipeline = DiffusionPipeline.from_pretrained("path_to_saved_model", dtype=torch.float16, use_safetensors=True).to("cuda")  # or "mps", "xpu", "cpu"
image = pipeline("A photo of sks dog in a bucket", num_inference_steps=50, guidance_scale=7.5).images[0]
image.save("dog-bucket.png")

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_dreambooth_lora.py betiğini kullanın.

LoRA eğitim betiği, LoRA eğitimi 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_dreambooth_lora_sdxl.py betiğini kullanın.

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

DeepFloyd IF

DeepFloyd IF, üç aşamalı kademeli piksel difüzyon modelidir. Birinci aşama temel bir görüntü üretirken ikinci ve üçüncü aşamalar, temel görüntüyü kademeli olarak 1024x1024 çözünürlüğünde yüksek çözünürlüklü bir görüntüye ölçekler. Bir DeepFloyd IF modelini LoRA ile veya tam model olarak eğitmek için train_dreambooth_lora.py veya train_dreambooth.py betiklerini kullanın.

DeepFloyd IF tahmini varyans kullanır, ancak Diffusers eğitim betikleri tahmini hata kullandığı için eğitilen DeepFloyd IF modelleri sabit bir varyans zamanlamasına geçirilir. Eğitim betikleri, tamamen eğitilmiş modelin zamanlayıcı yapılandırmasını sizin için günceller. Ancak, kaydedilen LoRA ağırlıklarını yüklediğinizde, hattın zamanlayıcı yapılandırmasını da güncellemeniz gerekir.

from diffusers import DiffusionPipeline

pipe = DiffusionPipeline.from_pretrained("DeepFloyd/IF-I-XL-v1.0", use_safetensors=True)

pipe.load_lora_weights("<lora weights path>")

# Update scheduler config to fixed variance schedule
pipe.scheduler = pipe.scheduler.__class__.from_config(pipe.scheduler.config, variance_type="fixed_small")

2. aşama modeli, büyütme işlemi için ek doğrulama görüntüleri gerektirir. Bunun için eğitim görüntülerinin küçültülmüş bir sürümünü indirip kullanabilirsiniz.

from huggingface_hub import snapshot_download

local_dir = "./dog_downsized"
snapshot_download(
    "diffusers/dog-example-downsized",
    local_dir=local_dir,
    repo_type="dataset",
    ignore_patterns=".gitattributes",
)

Aşağıdaki kod örnekleri, bir DeepFloyd IF modelini DreamBooth ve LoRA kombinasyonuyla nasıl eğiteceğinize dair kısa bir genel bakış sunar. Dikkat edilmesi gereken bazı önemli parametreler şunlardır:

--resolution=64, DeepFloyd IF bir piksel difüzyon modeli olduğu ve sıkıştırılmamış pikseller üzerinde çalıştığı için girdi görüntülerinin daha küçük olması gerekir, bu nedenle çok daha düşük bir çözünürlük gereklidir
--pre_compute_text_embeddings, T5Model çok fazla bellek kullanabildiğinden bellek tasarrufu sağlamak için metin gömme değerlerini önceden hesaplayın
--tokenizer_max_length=77, metin kodlayıcı olarak T5 kullanırken daha uzun varsayılan metin uzunluğu kullanabilirsiniz ancak varsayılan model kodlama prosedürü daha kısa bir metin uzunluğu kullanır
--text_encoder_use_attention_mask, dikkat maskesini metin kodlayıcıya iletmek için

Aşama 1 LoRA DreamBooth

Aşama 2 LoRA DreamBooth

Aşama 1 DreamBooth

Aşama 2 DreamBooth

DeepFloyd IF'in LoRA ve DreamBooth ile 1. aşama eğitimi ~28GB bellek gerektirir.

export MODEL_NAME="DeepFloyd/IF-I-XL-v1.0"
export INSTANCE_DIR="dog"
export OUTPUT_DIR="dreambooth_dog_lora"

accelerate launch train_dreambooth_lora.py \
  --report_to wandb \
  --pretrained_model_name_or_path=$MODEL_NAME  \
  --instance_data_dir=$INSTANCE_DIR \
  --output_dir=$OUTPUT_DIR \
  --instance_prompt="a sks dog" \
  --resolution=64 \
  --train_batch_size=4 \
  --gradient_accumulation_steps=1 \
  --learning_rate=5e-6 \
  --scale_lr \
  --max_train_steps=1200 \
  --validation_prompt="a sks dog" \
  --validation_epochs=25 \
  --checkpointing_steps=100 \
  --pre_compute_text_embeddings \
  --tokenizer_max_length=77 \
  --text_encoder_use_attention_mask

Eğitim ipuçları

DeepFloyd IF modelinin eğitimi zorlayıcı olabilir, ancak işe yaradığını gördüğümüz bazı ipuçları şunlardır:

Modelin düşük çözünürlüğü, daha ince detayların temsil edilmesini her durumda zorlaştırdığı için 1. aşama modelinin eğitiminde LoRA yeterlidir.
Ortak veya basit nesneler için upscaler'ı ince ayar yapmanız gerekmez. Upscaler'a iletilen prompt'un, örnek promptundan yeni token'ı kaldıracak şekilde ayarlandığından emin olun. Örneğin, 1. aşama prompt'unuz “a sks dog” ise 2. aşama prompt'unuz “a dog” olmalıdır.
Yüzler gibi daha ince detaylar için, 2. aşama upscaler'ı tamamen eğitmek, 2. aşama modelini LoRA ile eğitmekten daha iyidir. Ayrıca, daha düşük öğrenme oranlarını daha büyük batch boyutlarıyla kullanmak da faydalıdır.
2. aşama modelini eğitmek için daha düşük öğrenme oranları kullanılmalıdır.
DDPMScheduler, eğitim betiklerinde kullanılan DPMSolver'dan daha iyi çalışır.

Sonraki adımlar

DreamBooth modelinizi eğittiğiniz için tebrikler! Yeni modelinizi nasıl kullanacağınızı öğrenmek için aşağıdaki kılavuz size yardımcı olabilir:

Çıkarım için DreamBooth kontrol noktası yükleme yöntemini öğrenin.
LoRA ile eğitim yaptıysanız, çevrimdışı için LoRA bölümüne bakın.

Update on GitHub