diffusers/main/tr/tutorials/using_peft_for_inference.md

LoRA

LoRA (Low-Rank Adaptation), orijinal ağırlıkları dondurarak ve küçük bir yeni parametre seti eğiterek önceden eğitilmiş bir modeli yeni bir göreve uyarlar. Uyarlanma, tam ince ayara kıyasla daha hızlı ve daha ucundur; bu da onu yeni bir stilde görüntü üretme gibi görevler için pratik hale getirir.

LoRA kontrol noktaları genellikle yalnızca birkaç yüz MB boyutundadır. Bunları pipeline.load_lora_weights ile yükleyin ve weight_name parametresini kontrol noktası dosya adıyla eşleştirin. Ortak parametreler için load_lora_weights() bölümüne bakın.

import torch
from diffusers import AutoPipelineForText2Image

pipeline = AutoPipelineForText2Image.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    dtype=torch.float16
).to("cuda")  # or "mps", "xpu", "cpu"
pipeline.load_lora_weights(
    "ostris/super-cereal-sdxl-lora",
    weight_name="cereal_box_sdxl_v1.safetensors",
    adapter_name="cereal"
)
pipeline("bears, pizza bites").images[0]

import torch
from diffusers import LTXConditionPipeline
from diffusers.utils import export_to_video, load_image

pipeline = LTXConditionPipeline.from_pretrained(
    "Lightricks/LTX-Video-0.9.5", dtype=torch.bfloat16
).to("cuda")  # or "mps", "xpu", "cpu"

pipeline.load_lora_weights(
    "Lightricks/LTX-Video-Cakeify-LoRA",
    weight_name="ltxv_095_cakeify_lora.safetensors",
    adapter_name="cakeify"
)
pipeline.set_adapters("cakeify")

# use "CAKEIFY" to trigger the LoRA
prompt = "CAKEIFY a person using a knife to cut a cake shaped like a Pikachu plushie"
image = load_image("https://huggingface.co/Lightricks/LTX-Video-Cakeify-LoRA/resolve/main/assets/images/pikachu.png")

video = pipeline(
    prompt=prompt,
    image=image,
    width=576,
    height=576,
    num_frames=161,
    decode_timestep=0.03,
    decode_noise_scale=0.025,
    num_inference_steps=50,
).frames[0]
export_to_video(video, "output.mp4", fps=26)

Bu sayfadaki pipeline LoRA API'leri model aileleri arasında aynı şekilde çalışır. Gürültü azaltma modülü, Stable Diffusion ve SDXL için pipeline.unet, Flux, Stable Diffusion 3, AuraFlow ve LTX gibi DiT tarzı modeller için ise pipeline.transformer'dir. CogVideoX, HunyuanVideo ve Wan gibi video modellerine de aynı desen uygulanır. Model düzeyindeki PEFT yöntemleri bu özniteliği ve eşleşen bir prefix ("unet" veya "transformer") kullanır.

pipeline.load_lora_weights, LoRA ağırlıklarını gürültü azaltıcıya (UNet veya transformer) ve metin kodlayıcılara yüklemek için tercih edilen yöntemdir. Ortak parametreler için load_lora_weights() bölümüne bakın. Aşağıdaki durumları ele alabilir:

• kontrol noktası, gürültü azaltıcı ve metin kodlayıcılar arasında anahtarları paylaşır
• kontrol noktası ayrı denoiser ve text-encoder anahtarları kullanır

load_lora_adapter() metodu, UNet veya transformer gibi PeftAdapterMixin sınıfından türeyen herhangi bir Diffusers modelinde LoRA adaptörünü model düzeyinde yükler. Adaptör yapılandırmasını oluşturup hazırlar ve ağırlıkları ilgili modüle yükler.

Hedef modülün ("unet" veya "transformer") state dict anahtarlarını filtrelemek için prefix kullanın. Varsayılan değer "transformer" olduğundan, Stable Diffusion ve SDXL prefix="unet" parametresini geçirmek zorundadır.

import torch
from diffusers import AutoPipelineForText2Image

pipeline = AutoPipelineForText2Image.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    dtype=torch.float16
).to("cuda")  # or "mps", "xpu", "cpu"
pipeline.unet.load_lora_adapter(
    "jbilcke-hf/sdxl-cinematic-1",
    weight_name="pytorch_lora_weights.safetensors",
    adapter_name="cinematic",
    prefix="unet"
)
# use cnmt in the prompt to trigger the LoRA
pipeline("A cute cnmt eating a slice of pizza, stunning color scheme, masterpiece, illustration").images[0]

import torch
from diffusers import FluxPipeline

pipeline = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev", dtype=torch.bfloat16
).to("cuda")  # or "mps", "xpu", "cpu"
pipeline.transformer.load_lora_adapter(
    "alvarobartt/ghibli-characters-flux-lora",
    adapter_name="lora",
    prefix="transformer",
)

torch.compile

torch.compile, optimize edilmiş çekirdekleri kullanmak için PyTorch modelini derleyerek çıkarımı hızlandırır. Derlemeden önce, LoRA ağırlıklarının taban modele birleştirilmesi ve ardından boşaltılması gerekir.

import torch
from diffusers import DiffusionPipeline

# load base model and LoRA
pipeline = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    dtype=torch.float16
).to("cuda")  # or "mps", "xpu", "cpu"
pipeline.load_lora_weights(
    "ostris/ikea-instructions-lora-sdxl",
    weight_name="ikea_instructions_xl_v1_5.safetensors",
    adapter_name="ikea"
)

# activate LoRA and set adapter weight
pipeline.set_adapters("ikea", adapter_weights=0.7)

# fuse LoRAs and unload weights
pipeline.fuse_lora(adapter_names=["ikea"], lora_scale=1.0)
pipeline.unload_lora_weights()

Genellikle, pipeline'ın en yoğun hesaplama gerektiren bileşeni olduğu için denoiser'ı derleyin.

pipeline.unet.to(memory_format=torch.channels_last)
pipeline.unet = torch.compile(pipeline.unet, mode="reduce-overhead", fullgraph=True)

pipeline("A bowl of ramen shaped like a cute kawaii bear").images[0]

Flux ve diğer DiT pipeline'ları için bunun yerine pipeline.transformer'ı derleyin.

pipeline.transformer = torch.compile(pipeline.transformer, mode="reduce-overhead", fullgraph=True)

Derlenmiş modeller ve birden fazla LoRA ile çalışırken yeniden derlemeyi nasıl önleyeceğinizi öğrenmek için hotswapping bölümüne bakın.

Ağırlık ölçeği

set_adapters() içindeki adapter_weights parametresini kullanarak bir LoRA'nın ne kadarının uygulanacağını kontrol edebilirsiniz. 0 ağırlığı, yalnızca temel model ağırlıklarının kullanılmasına eşdeğerken 1 ağırlığı, LoRA'nın tamamen kullanılmasına eşdeğerdir.

LoRA'nın ne kadar güçlü uygulandığını kontrol etmek için set_adapters() içinde adapter_weights parametresine bir skaler geçirin.

import torch
from diffusers import AutoPipelineForText2Image

pipeline = AutoPipelineForText2Image.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    dtype=torch.float16
).to("cuda")  # or "mps", "xpu", "cpu"
pipeline.load_lora_weights(
    "ostris/super-cereal-sdxl-lora",
    weight_name="cereal_box_sdxl_v1.safetensors",
    adapter_name="cereal"
)
pipeline.set_adapters("cereal", adapter_weights=1.0)
pipeline("bears, pizza bites").images[0]

Birincil desen olarak set_adapters kullanılır, ancak bazı pipeline'lar dikkat ölçeklemesi için ikincil bir yöntem olarak çağrıda cross_attention_kwargs={"scale": 1.0} parametresini de kabul eder. Cross-attention kullanmayan pipeline'lar genellikle bunun yerine attention_kwargs (veya Flux ve Stable Diffusion 3'te joint_attention_kwargs) parametresini sunar.

set_adapters() yöntemi yalnızca dikkat ağırlıklarını ölçekler. Bir LoRA'da ResNet'ler veya aşağı/aşağı örnekleme birimleri varsa, bu bileşenler 1.0 ölçek değerini korur.

Her metin kodlayıcı veya gürültü azaltıcı bloğunu ölçeklemek için bir sözlük iletin. Sözlük anahtarları, pipeline modüllerini takip eder. Aşağıdaki örnek SDXL'dir (unet ve metin kodlayıcılar). Flux, transformer ve text_encoder kullanır. SD3, transformer ve birden fazla metin kodlayıcı kullanır.

Bu SDXL örneğinde, UNet içindeki "down" bloğu 0.9 ile ölçeklenir ve "up" altında "block_0" ile "block_1" için dikkat bloğu ölçeklerini ayrıca belirleyebilirsiniz. "mid" gibi bir blok belirtilmezse, 1.0 varsayılan değeri kullanılır.

import torch
from diffusers import AutoPipelineForText2Image

pipeline = AutoPipelineForText2Image.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    dtype=torch.float16
).to("cuda")  # or "mps", "xpu", "cpu"
pipeline.load_lora_weights(
    "ostris/super-cereal-sdxl-lora",
    weight_name="cereal_box_sdxl_v1.safetensors",
    adapter_name="cereal"
)
scales = {
    "text_encoder": 0.5,
    "text_encoder_2": 0.5,
    "unet": {
        "down": 0.9,
        "up": {
            "block_0": 0.6,
            "block_1": [0.4, 0.8, 1.0],
        }
    }
}
pipeline.set_adapters("cereal", scales)
pipeline("bears, pizza bites").images[0]

Ölçeklendirme zamanlaması

Örnekleme sırasında LoRA ölçeğini dinamik olarak ayarlamak, belirli adımların artırılmış veya azaltılmış bir ölçekten daha fazla faydalanabileceği için genel kompozisyon ve yerleşim üzerinde daha iyi kontrol sağlar.

Aşağıdaki örnekteki character LoRA, karakter üretimini oluşturmak için daha yüksek bir ölçekle başlar ve ilk 20 adımda kademeli olarak azalır. Sonraki adımlarda, LoRA'nın eğitilmediği görselin diğer kısımlarına LoRA özelliklerinin fazla eklenmemesi için yalnızca 0.2 ölçeği uygulanır.

import torch
from diffusers import FluxPipeline

pipeline = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev", dtype=torch.bfloat16
).to("cuda")  # or "mps", "xpu", "cpu"

pipeline.load_lora_weights("alvarobartt/ghibli-characters-flux-lora", adapter_name="lora")

num_inference_steps = 30
lora_steps = 20
lora_scales = torch.linspace(1.5, 0.7, lora_steps).tolist()
lora_scales += [0.2] * (num_inference_steps - lora_steps + 1)

pipeline.set_adapters("lora", lora_scales[0])

def callback(pipeline: FluxPipeline, step: int, timestep: torch.LongTensor, callback_kwargs: dict):
    pipeline.set_adapters("lora", lora_scales[step + 1])
    return callback_kwargs

prompt = """
Ghibli style The Grinch, a mischievous green creature with a sly grin, peeking out from behind a snow-covered tree while plotting his antics, 
in a quaint snowy village decorated for the holidays, warm light glowing from cozy homes, with playful snowflakes dancing in the air
"""
pipeline(
    prompt=prompt,
    guidance_scale=3.0,
    num_inference_steps=num_inference_steps,
    generator=torch.Generator().manual_seed(42),
    callback_on_step_end=callback,
).images[0]

Hotswapping

LoRA'ların değiştirilmesi (hotswap), birden fazla LoRA ile çalışırken load_lora_weights çağrılarının tekrarlanmasından kaynaklanan bellek birikimini ve model derlenmişse bazı durumlarda yeniden derlemeyi önleyen verimli bir yöntemdir. Bu iş akışı, yeni LoRA ağırlıklarının mevcut yüklü LoRA'nın yerine geçmesi nedeniyle yüklü bir LoRA gerektirir.

import torch
from diffusers import DiffusionPipeline

# load base model and LoRAs
pipeline = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    dtype=torch.float16
).to("cuda")  # or "mps", "xpu", "cpu"
pipeline.load_lora_weights(
    "ostris/ikea-instructions-lora-sdxl",
    weight_name="ikea_instructions_xl_v1_5.safetensors",
    adapter_name="ikea"
)

Metin kodlayıcıyı hedefleyen LoRA'lar için sıcak değiştirme (hotswap) desteklenmez.

İkinci LoRA'yı değiştirmek için load_lora_weights üzerinde hotswap=True ayarlayın. Hangi LoRA'nın değiştirileceğini belirtmek için adapter_name parametresini kullanın. Yükleme sırasında adapter_name parametresini atarsanız, Diffusers adaptörleri default_0, default_1 şeklinde adlandırır. Adlandırılmış adaptörleri açıkça hedeflemek daha kolaydır.

pipeline.load_lora_weights(
    "lordjia/by-feng-zikai",
    hotswap=True,
    adapter_name="ikea"
)

Derlenmiş modeller

Derlenmiş modeller için, LoRA'ların değiştirilmesi sırasında yeniden derlemeyi önlemek için enable_lora_hotswap() kullanın. Bu yöntem, ilk LoRA yüklenmeden önce çağrılmalı ve torch.compile, ilk LoRA yüklendikten sonra çağrılmalıdır.

İkinci LoRA, ilk LoRA ile aynı LoRA derecelerini ve ölçeklerini hedefliyorsa enable_lora_hotswap() yöntemi her zaman gerekli değildir.

enable_lora_hotswap() içinde, yüklemeyi planladığınız adaptörler arasındaki en yüksek rütbe olan değeri target_rank olarak ayarlayın (varsayılan 128).

import torch
from diffusers import DiffusionPipeline

# load base model and LoRAs
pipeline = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    dtype=torch.float16
).to("cuda")  # or "mps", "xpu", "cpu"
# 1. enable_lora_hotswap
pipeline.enable_lora_hotswap(target_rank=128)
pipeline.load_lora_weights(
    "ostris/ikea-instructions-lora-sdxl",
    weight_name="ikea_instructions_xl_v1_5.safetensors",
    adapter_name="ikea"
)
# 2. torch.compile
pipeline.unet = torch.compile(pipeline.unet, mode="reduce-overhead", fullgraph=True)

# 3. hotswap
pipeline.load_lora_weights(
    "lordjia/by-feng-zikai",
    hotswap=True,
    adapter_name="ikea"
)

Bir modelin yeniden derlendiğini tespit etmek için kodunuzu with torch._dynamo.config.patch(error_on_recompile=True) bağlam yöneticisinin içine taşıyın. Yukarıdaki tüm adımlara uyulmasına rağmen bir model yeniden derleniyorsa, lütfen yeniden üretilebilir bir örnekle birlikte bir issue açın.

Bu özellik ile çıkarım sırasında değişken çözünürlükler bekliyorsanız, derleme sırasında dynamic=True değerini ayarladığınızdan emin olun. Daha fazla ayrıntı için dinamik şekil derlemesi bölümüne bakın.

Yine de yeniden derlemenin kaçınılmaz olduğu senaryolar vardır; örneğin, sıcak değiştirilen LoRA, başlangıç adaptöründen daha fazla katmana hedeflendiğinde. En fazla katmana hedeflenen LoRA'yı önce yüklemeye çalışın. Bu kısıtlama hakkında daha fazla ayrıntı için PEFT sıcak değiştirme belgelerine başvurun.

target_rank'in ve yükleme sırasının neden önemli olduğu

enable_lora_hotswap() metodu, LoRA ölçekleme katsayısını float'lardan torch.tensors'a dönüştürür ve ağırlıklardaki veriler değiştirildiğinde tüm özniteliğin yeniden atanmasını önlemek için ağırlıkların şeklini en büyük gerekli şekle kadar doldurur.

Bu nedenle target_rank argümanı önemlidir. Değerler sıfırlarla doldurulsa bile sonuçlar değişmez. Ancak hesaplama, doldurma boyutuna bağlı olarak daha yavaş olabilir.

Yeni LoRA öznitelikleri eklenmediğinden, her sonraki LoRA yalnızca ilk LoRA'nın hedeflediği katmanlara veya bu katmanların bir alt kümesine hedeflenebilir. LoRA yükleme sırasını seçmek önemlidir çünkü LoRA'lar ayrık katmanları hedefliyorsa, tüm hedef katmanların birleşimini hedefleyen sahte bir LoRA oluşturmakla sonuçlanabilirsiniz.

LoRA'nın derlenmiş modellerle hızlı değiştirilmesi hakkında daha fazla bilgi için LoRA fast blog yazısına, uygulama detayları için ise hotswap.py dosyasına göz atın.

Birleştir

Her LoRA’dan gelen ağırlıklar birleştirilerek mevcut birden fazla stilin karışımı elde edilebilir. LoRA’ları birleştirmek için çeşitli yöntemler vardır; bunların her biri, ağırlıkların nasıl birleştirildiği konusunda farklılık gösterir (bu, üretim kalitesini etkileyebilir).

set_adapters[[merge]]

set_adapters() yöntemi, ağırlıklı matrislerini birleştirerek LoRA'ları birleştirir. LoRA adlarını set_adapters() parametresine iletin ve her bir LoRA'nın ölçeklemesini kontrol etmek için adapter_weights parametresini kullanın. Örneğin, adapter_weights=[0.5, 0.5] ise çıktı, her iki LoRA'nın ortalamasıdır.

Birleşik LoRA'ların her birinin ne kadarının uygulanacağını kontrol etmek için set_adapters() içinde adapter_weights'i tercih edin. Daha fazla ayrıntı için Ağırlık ölçeği bölümüne bakın.

import torch
from diffusers import DiffusionPipeline

pipeline = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    dtype=torch.float16
).to("cuda")  # or "mps", "xpu", "cpu"
pipeline.load_lora_weights(
    "ostris/ikea-instructions-lora-sdxl",
    weight_name="ikea_instructions_xl_v1_5.safetensors",
    adapter_name="ikea"
)
pipeline.load_lora_weights(
    "lordjia/by-feng-zikai",
    weight_name="fengzikai_v1.0_XL.safetensors",
    adapter_name="feng"
)
pipeline.set_adapters(["ikea", "feng"], adapter_weights=[0.7, 0.8])
# use by Feng Zikai to activate the lordjia/by-feng-zikai LoRA
pipeline("A bowl of ramen shaped like a cute kawaii bear, by Feng Zikai").images[0]

add_weighted_adapter

Bu deneysel bir yöntemdir ve daha fazla ayrıntı için PEFT'nin Model birleştirme bölümüne başvurabilirsiniz. Bu entegrasyonun arkasındaki motivasyon ve tasarıma ilgi duyuyorsanız bu konuya göz atın.

add_weighted_adapter metodu, TIES veya DARE gibi daha verimli birleştirme yöntemlerini mümkün kılar. Bu birleştirme yöntemleri, birleştirilmiş modellerden gereksiz ve potansiyel olarak çelişen parametreleri kaldırır. Birleştirilebilmeleri için LoRA derecelerinin (ranks) aynı olması gerektiğini unutmayın. Aşağıdaki anlatım, SDXL'in UNet'ini kullanır.

Diffusers ve PEFT'in en son kararlı sürümünün yüklendiğinden emin olun.

pip install -U -q diffusers peft

LoRA UNet'ine karşılık gelen bir UNet yükleyin.

import copy
import torch
from diffusers import AutoModel, DiffusionPipeline
from peft import get_peft_model, LoraConfig, PeftModel

unet = AutoModel.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    dtype=torch.float16,
    use_safetensors=True,
    variant="fp16",
    subfolder="unet",
).to("cuda")  # or "mps", "xpu", "cpu"

Bir pipeline yükleyin, UNet'i ona iletin ve bir LoRA yükleyin.

pipeline = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    variant="fp16",
    dtype=torch.float16,
    unet=unet
).to("cuda")  # or "mps", "xpu", "cpu"
pipeline.load_lora_weights(
    "ostris/ikea-instructions-lora-sdxl",
    weight_name="ikea_instructions_xl_v1_5.safetensors",
    adapter_name="ikea"
)

Yüklediğiniz ilk UNet ile pipeline'daki LoRA UNet'i birleştirerek LoRA checkpoint'inden bir PeftModel oluşturun.

sdxl_unet = copy.deepcopy(unet)
ikea_peft_model = get_peft_model(
    sdxl_unet,
    pipeline.unet.peft_config["ikea"],
    adapter_name="ikea"
)

original_state_dict = {f"base_model.model.{k}": v for k, v in pipeline.unet.state_dict().items()}
ikea_peft_model.load_state_dict(original_state_dict, strict=True)

Aşağıda gösterildiği gibi ikea_peft_model öğesini Hub'a göndererek kaydedebilir ve yeniden kullanabilirsiniz.

ikea_peft_model.push_to_hub("ikea_peft_model", token=TOKEN)

Bu işlemi tekrarlayın ve ikinci LoRA için bir PeftModel oluşturun.

pipeline.delete_adapters("ikea")
sdxl_unet.delete_adapters("ikea")

pipeline.load_lora_weights(
    "lordjia/by-feng-zikai",
    weight_name="fengzikai_v1.0_XL.safetensors",
    adapter_name="feng"
)
pipeline.set_adapters(adapter_names="feng")

feng_peft_model = get_peft_model(
    sdxl_unet,
    pipeline.unet.peft_config["feng"],
    adapter_name="feng"
)

original_state_dict = {f"base_model.model.{k}": v for k, v in pipeline.unet.state_dict().items()}
feng_peft_model.load_state_dict(original_state_dict, strict=True)

Bir taban UNet modeli yükleyin ve adaptörleri yükleyin.

base_unet = AutoModel.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    dtype=torch.float16,
    use_safetensors=True,
    variant="fp16",
    subfolder="unet",
).to("cuda")  # or "mps", "xpu", "cpu"

model = PeftModel.from_pretrained(
    base_unet,
    "stevhliu/ikea_peft_model",
    use_safetensors=True,
    subfolder="ikea",
    adapter_name="ikea"
)
model.load_adapter(
    "stevhliu/feng_peft_model",
    use_safetensors=True,
    subfolder="feng",
    adapter_name="feng"
)

LoRAları add_weighted_adapter ile birleştirin ve combination_type parametresiyle nasıl birleştirileceklerini belirtin. Aşağıdaki örnek, "dare_linear" yöntemini kullanır (bu birleştirme yöntemleri hakkında daha fazla bilgi için bu blog yazısına bakın); bu yöntem, bazı ağırlıkları rastgele budar ve ardından weights içindeki her LoRA için belirlenen ağırlıklara göre tensörlerin ağırlıklı toplamını yapar.

Birleştirilmiş LoRA'ları set_adapters() ile etkinleştirin.

model.add_weighted_adapter(
    adapters=["ikea", "feng"],
    combination_type="dare_linear",
    weights=[1.0, 1.0],
    adapter_name="ikea-feng"
)
model.set_adapters("ikea-feng")

pipeline = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    unet=model,
    variant="fp16",
    dtype=torch.float16,
).to("cuda")  # or "mps", "xpu", "cpu"
pipeline("A bowl of ramen shaped like a cute kawaii bear, by Feng Zikai").images[0]

fuse_lora

fuse_lora() metodu, LoRA ağırlıklarını alttaki modelin orijinal denoiser (UNet veya transformer) ve metin kodlayıcı ağırlıklarıyla doğrudan birleştirir. Bu, her LoRA için alttaki modelin yüklenme yükünü azaltır çünkü model yalnızca bir kez yüklenir; bu da bellek kullanımını düşürür ve çıkarım hızını artırır.

import torch
from diffusers import DiffusionPipeline

pipeline = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    dtype=torch.float16
).to("cuda")  # or "mps", "xpu", "cpu"
pipeline.load_lora_weights(
    "ostris/ikea-instructions-lora-sdxl",
    weight_name="ikea_instructions_xl_v1_5.safetensors",
    adapter_name="ikea"
)
pipeline.load_lora_weights(
    "lordjia/by-feng-zikai",
    weight_name="fengzikai_v1.0_XL.safetensors",
    adapter_name="feng"
)
pipeline.set_adapters(["ikea", "feng"], adapter_weights=[0.7, 0.8])

Onları birleştirmek için fuse_lora() çağrın. lora_scale parametresi, LoRA ağırlıklarıyla çıktıyı ne kadar ölçekleyeceğinizi kontrol eder. Bu ayarlamayı şimdi yapmanız önemlidir çünkü scale'i cross_attention_kwargs'ya geçirmek pipeline'da çalışmaz.

pipeline.fuse_lora(adapter_names=["ikea", "feng"], lora_scale=1.0)

LoRA ağırlıkları, alttaki modelle zaten birleştirildiği için bunları boşaltın. Birleştirilmiş hattı, yerel olarak kaydetmek için save_pretrained() veya Hub'a kaydetmek için ~PushToHubMixin.push_to_hub ile kaydedin.

pipeline.unload_lora_weights()
pipeline.save_pretrained("path/to/fused-pipeline")

pipeline.unload_lora_weights()
pipeline.push_to_hub("fused-ikea-feng")

Birleştirilmiş pipeline, artık her LoRA'nın ayrı ayrı yüklenmesine gerek kalmadan çıkarım için hızla yüklenebilir.

pipeline = DiffusionPipeline.from_pretrained(
    "username/fused-ikea-feng", dtype=torch.float16,
).to("cuda")  # or "mps", "xpu", "cpu"
pipeline("A bowl of ramen shaped like a cute kawaii bear, by Feng Zikai").images[0]

Altta yatan modelin ağırlıklarını geri yüklemek için unfuse_lora() kullanın; örneğin farklı bir lora_scale değeri kullanmak istediğinizde. Yalnızca tek bir LoRA füzyonu varsa bu işlemi gerçekleştirebilirsiniz. Örneğin, yukarıdaki pipeline birden fazla füzyonlu LoRA içerdiği için bu işlem çalışmaz. Bu durumlarda tüm modeli yeniden yüklemeniz gerekir.

pipeline.unfuse_lora()

Yönet

Diffusers, LoRA'larla çalışmayı yönetmenize yardımcı olmak için çeşitli yöntemler sunar. Birden fazla LoRA ile çalışıyorsanız bu yöntemler özellikle faydalı olabilir.

set_adapters[[manage]]

set_adapters(), birden fazla etkin LoRA varsa kullanılacak olan mevcut LoRA'yı da etkinleştirir. Bu sayede, adlarını belirterek farklı LoRA'lar arasında geçiş yapabilirsiniz.

import torch
from diffusers import DiffusionPipeline

pipeline = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    dtype=torch.float16
).to("cuda")  # or "mps", "xpu", "cpu"
pipeline.load_lora_weights(
    "ostris/ikea-instructions-lora-sdxl",
    weight_name="ikea_instructions_xl_v1_5.safetensors",
    adapter_name="ikea"
)
pipeline.load_lora_weights(
    "lordjia/by-feng-zikai",
    weight_name="fengzikai_v1.0_XL.safetensors",
    adapter_name="feng"
)
# activates the feng LoRA instead of the ikea LoRA
pipeline.set_adapters("feng")

save_lora_adapter

Bir adaptörü, yüklediğiniz aynı modülde (pipeline.unet veya pipeline.transformer) save_lora_adapter() ile kaydedin.

import torch
from diffusers import AutoPipelineForText2Image

pipeline = AutoPipelineForText2Image.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    dtype=torch.float16
).to("cuda")  # or "mps", "xpu", "cpu"
pipeline.unet.load_lora_adapter(
    "jbilcke-hf/sdxl-cinematic-1",
    weight_name="pytorch_lora_weights.safetensors",
    adapter_name="cinematic",
    prefix="unet"
)
pipeline.unet.save_lora_adapter("path/to/save", adapter_name="cinematic")

unload_lora_weights

unload_lora_weights() yöntemi, alttaki model ağırlıklarını geri yüklemek için pipeline içindeki tüm LoRA ağırlıklarını boşaltır.

pipeline.unload_lora_weights()

disable_lora

disable_lora() yöntemi tüm LoRA'ları devre dışı bırakır (ancak bunlar pipeline üzerinde tutulmaya devam eder) ve pipeline'ı alttaki model ağırlıklarına geri yükler.

pipeline.disable_lora()

get_active_adapters

get_active_adapters() yöntemi, bir pipeline'a bağlı etkin LoRA'ların listesini döndürür.

pipeline.get_active_adapters()
# ["cereal", "ikea"]

get_list_adapters

get_list_adapters() yöntemi, hattaki her bileşen için yüklenen tüm LoRA'ları döndürür. Sözlük anahtarları, unet veya transformer gibi yüklenen modüllerle ve herhangi bir metin kodlayıcıyla eşleşir.

pipeline.get_list_adapters()
# {"unet": ["cereal", "ikea"], "text_encoder_2": ["cereal"]}

delete_adapters

delete_adapters() yöntemi, bir LoRA'yı ve katmanlarını modelden tamamen kaldırır.

pipeline.delete_adapters("ikea")

Sonraki adımlar

• Farklı LoRA'ları kullanmak için LoRA Studio'yu gezin veya favori LoRA'larınızı aşağıdaki Space ile Civitai'den Hub'a yükleyebilirsiniz.