diffusers/main/id/api/loaders/lora.md

LoRA

LoRA adalah metode pelatihan yang cepat dan ringan, yang menyisipkan dan melatih jumlah parameter yang jauh lebih sedikit dibandingkan seluruh parameter model. Hal ini menghasilkan file yang lebih kecil (~100 MB) dan memudahkan pelatihan model dengan cepat untuk mempelajari konsep baru. Bobot LoRA biasanya dimuat ke dalam denoiser, text encoder, atau keduanya. Denoiser biasanya merujuk pada UNet (misalnya UNet2DConditionModel) atau Transformer (misalnya SD3Transformer2DModel). Terdapat beberapa kelas untuk memuat bobot LoRA:

• StableDiffusionLoraLoaderMixin menyediakan fungsi untuk memuat dan melepas, menggabungkan dan memisahkan, mengaktifkan dan menonaktifkan, serta fungsi lain untuk mengelola bobot LoRA. Kelas ini dapat digunakan dengan model apa pun.
• StableDiffusionXLLoraLoaderMixin adalah versi Stable Diffusion (SDXL) dari kelas StableDiffusionLoraLoaderMixin untuk memuat dan menyimpan bobot LoRA. Kelas ini hanya dapat digunakan dengan model SDXL.
• SD3LoraLoaderMixin menyediakan fungsi serupa untuk Stable Diffusion 3.
• FluxLoraLoaderMixin menyediakan fungsi serupa untuk Flux.
• CogVideoXLoraLoaderMixin menyediakan fungsi serupa untuk CogVideoX.
• Mochi1LoraLoaderMixin menyediakan fungsi serupa untuk Mochi.
• AuraFlowLoraLoaderMixin menyediakan fungsi serupa untuk AuraFlow.
• LTXVideoLoraLoaderMixin menyediakan fungsi serupa untuk LTX-Video.
• SanaLoraLoaderMixin menyediakan fungsi serupa untuk Sana.
• HeliosLoraLoaderMixin menyediakan fungsi serupa untuk HunyuanVideo.
• HunyuanVideoLoraLoaderMixin menyediakan fungsi serupa untuk HunyuanVideo.
• Lumina2LoraLoaderMixin menyediakan fungsi serupa untuk Lumina2.
• WanLoraLoaderMixin menyediakan fungsi serupa untuk Wan.
• SkyReelsV2LoraLoaderMixin menyediakan fungsi serupa untuk SkyReels-V2.
• CogView4LoraLoaderMixin menyediakan fungsi serupa untuk CogView4.
• AmusedLoraLoaderMixin adalah untuk AmusedPipeline.
• AnimaLoraLoaderMixin menyediakan fungsi serupa untuk Anima.
• AceStepLoraLoaderMixin menyediakan fungsi serupa untuk ACE-Step.
• HiDreamImageLoraLoaderMixin menyediakan fungsi serupa untuk HiDream Image
• QwenImageLoraLoaderMixin menyediakan fungsi serupa untuk Qwen Image.
• ZImageLoraLoaderMixin menyediakan fungsi serupa untuk Z-Image.
• Flux2LoraLoaderMixin menyediakan fungsi serupa untuk Flux2.
• ErnieImageLoraLoaderMixin menyediakan fungsi serupa untuk Ernie-Image.
• LTX2LoraLoaderMixin menyediakan fungsi serupa untuk Flux2.
• MiniMaxH3LoraLoaderMixin menyediakan fungsi serupa untuk MiniMax-H3.
• PikaH3FlexLoraLoaderMixin menyediakan fungsi serupa untuk Pika H3 Flex.
• RFD4ProteinaLoraLoaderMixin menyediakan fungsi serupa untuk RFD4-Proteína.
• BriaFibo2LoraLoaderMixin menyediakan fungsi serupa untuk fibo-2.
• LoraBaseMixin menyediakan kelas dasar dengan beberapa metode utilitas untuk menggabungkan, memisahkan, memuat ulang, LoRA, dan lainnya.

Untuk mempelajari lebih lanjut tentang cara memuat bobot LoRA, lihat panduan pemuatan LoRA.

RFD4ProteinaLoraLoaderMixin[[diffusers.loaders.RFD4ProteinaLoraLoaderMixin]]

diffusers.loaders.RFD4ProteinaLoraLoaderMixin[[diffusers.loaders.RFD4ProteinaLoraLoaderMixin]]

diffusers.loaders.RFD4ProteinaLoraLoaderMixin()

Sumber

Muat lapisan LoRA ke dalam RFD4ProteinaTransformer.

Autoencoder dipasangkan dengan checkpoint denoiser dan tidak diadaptasi, sehingga transformer adalah satu-satunya modul yang dapat dimuat.

fuse_lora[[diffusers.loaders.RFD4ProteinaLoraLoaderMixin.fuse_lora]]

fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)

Sumber

Lihat fuse_lora() untuk detail lebih lanjut.

load_lora_into_transformer[[diffusers.loaders.RFD4ProteinaLoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Sumber

Lihat load_lora_into_unet() untuk detail lebih lanjut.

load_lora_weights[[diffusers.loaders.RFD4ProteinaLoraLoaderMixin.load_lora_weights]]

load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)

Sumber

Lihat load_lora_weights() untuk detail lebih lanjut.

lora_state_dict[[diffusers.loaders.RFD4ProteinaLoraLoaderMixin.lora_state_dict]]

lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)

Sumber

Lihat lora_state_dict() untuk detail lebih lanjut.

save_lora_weights[[diffusers.loaders.RFD4ProteinaLoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata: dict | None = None)

Sumber

Lihat save_lora_weights() untuk informasi lebih lanjut.

unfuse_lora[[diffusers.loaders.RFD4ProteinaLoraLoaderMixin.unfuse_lora]]

unfuse_lora(components: list[str] = ['transformer'], **kwargs)

Sumber

Lihat unfuse_lora() untuk detail lebih lanjut.

LoraBaseMixin[[diffusers.loaders.lora_base.LoraBaseMixin]]

diffusers.loaders.lora_base.LoraBaseMixin[[diffusers.loaders.lora_base.LoraBaseMixin]]

diffusers.loaders.lora_base.LoraBaseMixin()

Sumber

Kelas utilitas untuk menangani LoRA.

delete_adapters[[diffusers.loaders.lora_base.LoraBaseMixin.delete_adapters]]

delete_adapters(adapter_names: list[str] | str)

Sumber

Parameter:

adapter_names (list[str, str]) : Nama-nama adapter yang akan dihapus.

Hapus lapisan LoRA dari adapter di pipeline.

Contoh:

from diffusers import AutoPipelineForText2Image
import torch

pipeline = AutoPipelineForText2Image.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float16
).to("cuda")
pipeline.load_lora_weights(
    "jbilcke-hf/sdxl-cinematic-1", weight_name="pytorch_lora_weights.safetensors", adapter_names="cinematic"
)
pipeline.delete_adapters("cinematic")

disable_lora[[diffusers.loaders.lora_base.LoraBaseMixin.disable_lora]]

disable_lora()

Sumber

Menonaktifkan lapisan LoRA aktif dari pipeline.

Contoh:

from diffusers import AutoPipelineForText2Image
import torch

pipeline = AutoPipelineForText2Image.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float16
).to("cuda")
pipeline.load_lora_weights(
    "jbilcke-hf/sdxl-cinematic-1", weight_name="pytorch_lora_weights.safetensors", adapter_name="cinematic"
)
pipeline.disable_lora()

enable_lora[[diffusers.loaders.lora_base.LoraBaseMixin.enable_lora]]

enable_lora()

Sumber

Mengaktifkan lapisan LoRA aktif dari pipeline.

Contoh:

from diffusers import AutoPipelineForText2Image
import torch

pipeline = AutoPipelineForText2Image.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float16
).to("cuda")
pipeline.load_lora_weights(
    "jbilcke-hf/sdxl-cinematic-1", weight_name="pytorch_lora_weights.safetensors", adapter_name="cinematic"
)
pipeline.enable_lora()

enable_lora_hotswap[[diffusers.loaders.lora_base.LoraBaseMixin.enable_lora_hotswap]]

enable_lora_hotswap(**kwargs)

Sumber

Parameter:

target_rank (int) : Pangkat tertinggi di antara semua adapter yang akan dimuat.

check_compiled (str, opsional, defaultnya "error") : Cara menangani model yang sudah dikompilasi. Pengecekan dapat mengembalikan pesan berikut: - "error" (default): lempar error - "warn": terbitkan peringatan - "ignore": tidak melakukan apa pun

Hotswap adapter tanpa memicu kompilasi ulang model atau jika rank dari adapter yang dimuat berbeda.

fuse_lora[[diffusers.loaders.lora_base.LoraBaseMixin.fuse_lora]]

fuse_lora(components: list[str] | None = None, lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)

Sumber

Parameter:

components : (list[str]): daftar komponen yang dapat diinjeksi LoRA untuk menggabungkan LoRA ke dalamnya.

lora_scale (float, defaultnya 1.0) : Mengontrol seberapa besar pengaruh parameter LoRA terhadap output.

safe_fusing (bool, defaultnya False) : Apakah akan memeriksa bobot yang sudah digabungkan (fused) untuk nilai NaN sebelum penggabungan, dan jika nilainya NaN, tidak melakukan penggabungan.

adapter_names (list[str], opsional) : Nama-nama adapter yang akan digunakan untuk fusi. Jika tidak ada yang diteruskan, semua adapter aktif akan difusi.

Menggabungkan parameter LoRA ke dalam parameter asli dari blok yang sesuai.

Contoh:

from diffusers import DiffusionPipeline
import torch

pipeline = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float16
).to("cuda")
pipeline.load_lora_weights("nerijs/pixel-art-xl", weight_name="pixel-art-xl.safetensors", adapter_name="pixel")
pipeline.fuse_lora(lora_scale=0.7)

get_active_adapters[[diffusers.loaders.lora_base.LoraBaseMixin.get_active_adapters]]

get_active_adapters()

Sumber

Mendapatkan daftar adapter aktif saat ini.

Contoh:

from diffusers import DiffusionPipeline

pipeline = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
).to("cuda")
pipeline.load_lora_weights("CiroN2022/toy-face", weight_name="toy_face_sdxl.safetensors", adapter_name="toy")
pipeline.get_active_adapters()

get_list_adapters[[diffusers.loaders.lora_base.LoraBaseMixin.get_list_adapters]]

get_list_adapters()

Sumber

Mendapatkan daftar saat ini dari semua adapter yang tersedia di pipeline.

set_adapters[[diffusers.loaders.lora_base.LoraBaseMixin.set_adapters]]

set_adapters(adapter_names: list[str] | str, adapter_weights: float | dict[str, float | dict | None] | list[float | dict[str, float | dict | None] | None] | None = None)

Sumber

Parameter:

adapter_names (list[str] atau str) : Nama-nama adapter yang akan digunakan.

adapter_weights (float, dict atau list, opsional) : Bobot untuk adapter. Skalar menskalakan semua komponen yang kompatibel dengan LoRA. Kamus memetakan nama komponen (misalnya "unet", "transformer" atau "text_encoder") ke bobot; bobot komponen UNet juga dapat berupa kamus bersarang dari skala blok. Skalar atau kamus tunggal diterapkan ke setiap adapter. Daftar harus berisi satu skalar, kamus, atau None per adapter, sesuai urutan adapter_names. None secara default menjadi 1.0, termasuk entri daftar dan bobot komponen. Komponen yang tidak ditentukan dan blok UNet juga secara default menjadi 1.0.

Atur adapter yang saat ini aktif untuk digunakan dalam pipeline.

Contoh:

from diffusers import AutoPipelineForText2Image
import torch

pipeline = AutoPipelineForText2Image.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float16
).to("cuda")
pipeline.load_lora_weights(
    "jbilcke-hf/sdxl-cinematic-1", weight_name="pytorch_lora_weights.safetensors", adapter_name="cinematic"
)
pipeline.load_lora_weights(
    "troveski/sdxl-lora", weight_name="pytorch_lora_weights.safetensors", adapter_name="illustration"
)
pipeline.set_adapters(["cinematic", "illustration"], adapter_weights=[0.5, 0.5])
pipeline.set_adapters(
    ["cinematic", "illustration"],
    adapter_weights=[{"unet": 0.5}, {"unet": 0.8, "text_encoder": 0.6}],
)

set_lora_device[[diffusers.loaders.lora_base.LoraBaseMixin.set_lora_device]]

set_lora_device(adapter_names: list[str], device: torch.device | str | int)

Sumber

Parameter:

adapter_names (list[str]) : daftar adapter untuk dikirim ke perangkat.

device (torch.device | str | int) : Perangkat untuk mengirim adapter. Bisa berupa perangkat torch, str, atau integer.

Memindahkan LoRA yang tercantum dalam adapter_names ke perangkat target. Berguna untuk offloading LoRA ke CPU jika Anda ingin memuat beberapa adapter dan membebaskan sebagian memori GPU.

Setelah meng-offload adapter LoRA ke CPU, selama bagian lain dari model masih berada di GPU, adapter LoRA tidak dapat lagi digunakan untuk inferensi, karena hal itu akan menyebabkan ketidakcocokan perangkat. Ingatlah untuk mengatur perangkat kembali ke GPU sebelum menggunakan adapter LoRA tersebut untuk inferensi.

>>> pipe.load_lora_weights(path_1, adapter_name="adapter-1")
>>> pipe.load_lora_weights(path_2, adapter_name="adapter-2")
>>> pipe.set_adapters("adapter-1")
>>> image_1 = pipe(**kwargs)
>>> # switch to adapter-2, offload adapter-1
>>> pipeline.set_lora_device(adapter_names=["adapter-1"], device="cpu")
>>> pipeline.set_lora_device(adapter_names=["adapter-2"], device="cuda:0")
>>> pipe.set_adapters("adapter-2")
>>> image_2 = pipe(**kwargs)
>>> # switch back to adapter-1, offload adapter-2
>>> pipeline.set_lora_device(adapter_names=["adapter-2"], device="cpu")
>>> pipeline.set_lora_device(adapter_names=["adapter-1"], device="cuda:0")
>>> pipe.set_adapters("adapter-1")
>>> ...

unfuse_lora[[diffusers.loaders.lora_base.LoraBaseMixin.unfuse_lora]]

unfuse_lora(components: list[str] | None = None, **kwargs)

Sumber

Parameter:

components (list[str]) : daftar komponen yang dapat diinjeksi LoRA untuk melepas fusi LoRA.

unfuse_unet (bool, defaultnya True) : Apakah akan memisahkan parameter LoRA dari UNet.

unfuse_text_encoder (bool, defaultnya True) : Apakah akan memisahkan (unfuse) parameter LoRA dari text encoder. Jika text encoder tidak di-patch secara monkey dengan parameter LoRA, maka tidak akan ada efeknya.

Membalikkan efek dari pipe.fuse_lora().

unload_lora_weights[[diffusers.loaders.lora_base.LoraBaseMixin.unload_lora_weights]]

unload_lora_weights()

Sumber

Memuat ulang parameter LoRA.

Contoh:

>>> # Assuming `pipeline` is already loaded with the LoRA parameters.
>>> pipeline.unload_lora_weights()
>>> ...

write_lora_layers[[diffusers.loaders.lora_base.LoraBaseMixin.write_lora_layers]]

write_lora_layers(state_dict: dict[str, torch.Tensor], save_directory: str, is_main_process: bool, weight_name: str, save_function: Callable, safe_serialization: bool, lora_adapter_metadata: dict | None = None)

Sumber

Menulis state dict dari lapisan LoRA (opsional dengan metadata) ke disk.

StableDiffusionLoraLoaderMixin[[diffusers.loaders.StableDiffusionLoraLoaderMixin]]

diffusers.loaders.StableDiffusionLoraLoaderMixin[[diffusers.loaders.StableDiffusionLoraLoaderMixin]]

diffusers.loaders.StableDiffusionLoraLoaderMixin()

Sumber

Muat lapisan LoRA ke dalam UNet2DConditionModel dan CLIPTextModel Stable Diffusion.

load_lora_into_text_encoder[[diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_text_encoder]]

load_lora_into_text_encoder(state_dict, network_alphas, text_encoder, prefix = None, lora_scale = 1.0, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Sumber

Parameter:

state_dict (dict) : state dict standar yang berisi parameter lapisan lora. Kuncinya harus diberi awalan tambahan text_encoder untuk membedakan lapisan lora unet.

network_alphas (dict[str, float]) : Nilai network alpha yang digunakan untuk pembelajaran yang stabil dan mencegah underflow. Nilai ini memiliki arti yang sama dengan opsi --network_alpha dalam skrip trainer kohya-ss. Lihat tautan ini.

text_encoder (CLIPTextModel) : Model encoder teks untuk memuat lapisan LoRA.

prefix (str) : Prefiks yang diharapkan dari text_encoder di dalam state_dict.

lora_scale (float) : Berapa skala yang diterapkan pada output dari lora linear layer sebelum ditambahkan dengan output dari lora layer reguler.

adapter_name (str, opsional) : Nama adapter yang akan digunakan untuk merujuk model adapter yang dimuat. Jika tidak ditentukan, akan digunakan default_{i} di mana i adalah total jumlah adapter yang dimuat.

low_cpu_mem_usage (bool, opsional) : Mempercepat pemuatan model dengan hanya memuat bobot LoRA pretrained dan tidak menginisialisasi bobot acak.

hotswap (bool, opsional) : Lihat load_lora_weights().

metadata (dict) : Metadata adapter LoRA opsional. Jika diberikan, argumen LoraConfig dari peft tidak akan diturunkan dari state dict.

Ini akan memuat lapisan LoRA yang ditentukan dalam state_dict ke dalam text_encoder

load_lora_into_unet[[diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet]]

load_lora_into_unet(state_dict, network_alphas, unet, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Sumber

Parameter:

state_dict (dict) : state dict standar yang berisi parameter lapisan lora. Kunci-kuncinya dapat diindeks langsung ke unet atau diberi awalan tambahan unet yang dapat digunakan untuk membedakan lapisan lora text encoder.

network_alphas (dict[str, float]) : Nilai network alpha yang digunakan untuk pembelajaran yang stabil dan mencegah underflow. Nilai ini memiliki arti yang sama dengan opsi --network_alpha dalam skrip trainer kohya-ss. Lihat tautan ini.

unet (UNet2DConditionModel) : Model UNet untuk memuat lapisan LoRA.

adapter_name (str, opsional) : Nama adapter yang akan digunakan untuk merujuk model adapter yang dimuat. Jika tidak ditentukan, akan digunakan default_{i} di mana i adalah total jumlah adapter yang dimuat.

low_cpu_mem_usage (bool, opsional) : Mempercepat pemuatan model dengan hanya memuat bobot LoRA pretrained dan tidak menginisialisasi bobot acak.

hotswap (bool, opsional) : Lihat load_lora_weights().

metadata (dict) : Metadata adapter LoRA opsional. Jika diberikan, argumen LoraConfig dari peft tidak akan diturunkan dari state dict.

Ini akan memuat lapisan LoRA yang ditentukan dalam state_dict ke dalam unet.

load_lora_weights[[diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights]]

load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)

Sumber

Parameter:

pretrained_model_name_or_path_or_dict (str atau os.PathLike atau dict) : Lihat lora_state_dict().

adapter_name (str, opsional) : Nama adapter yang akan digunakan untuk merujuk model adapter yang dimuat. Jika tidak ditentukan, akan digunakan default_{i} di mana i adalah total jumlah adapter yang dimuat.

low_cpu_mem_usage (bool, opsional) : Mempercepat pemuatan model dengan hanya memuat bobot LoRA pretrained dan tidak menginisialisasi bobot acak.

hotswap (bool, opsional) : Bawaan adalah False. Apakah akan mengganti adapter (LoRA) yang sudah ada dengan adapter yang baru dimuat secara in-place. Artinya, alih-alih memuat adapter tambahan, proses ini akan mengambil bobot adapter yang ada dan menggantinya dengan bobot dari adapter baru. Hal ini bisa lebih cepat dan lebih efisien dalam penggunaan memori. Namun, keunggulan utama dari hotswapping adalah ketika model dikompilasi dengan torch.compile, pemuatan adapter baru tidak memerlukan kompilasi ulang model. Saat menggunakan hotswapping, adapter_name yang diberikan harus berupa nama dari adapter yang sudah dimuat. Jika adapter baru dan adapter lama memiliki rank dan/atau LoRA alphas (yaitu scaling) yang berbeda, Anda perlu memanggil metode tambahan sebelum memuat adapter: py pipeline = ... # load diffusers pipeline max_rank = ... # the highest rank among all LoRAs that you want to load # call *before* compiling and loading the LoRA adapter pipeline.enable_lora_hotswap(target_rank=max_rank) pipeline.load_lora_weights(file_name) # optionally compile the model now Perhatikan bahwa hotswapping adapter untuk text encoder belum didukung. Ada beberapa keterbatasan lain untuk teknik ini, yang didokumentasikan di sini: https://huggingface.co/docs/peft/main/en/package_reference/hotswap

kwargs (dict, opsional) : Lihat lora_state_dict().

Muat bobot LoRA yang ditentukan dalam pretrained_model_name_or_path_or_dict ke self.unet dan self.text_encoder.

Semua kwargs diteruskan ke self.lora_state_dict.

Lihat lora_state_dict() untuk detail lebih lanjut tentang cara state dict dimuat.

Lihat load_lora_into_unet() untuk detail lebih lanjut tentang bagaimana state dict dimuat ke dalam self.unet.

Lihat load_lora_into_text_encoder() untuk detail lebih lanjut tentang bagaimana state dict dimuat ke dalam self.text_encoder.

lora_state_dict[[diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict]]

lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)

Sumber

Parameter:

pretrained_model_name_or_path_or_dict (str atau os.PathLike atau dict) : Bisa berupa: - String, model id (misalnya google/ddpm-celebahq-256) dari model pretrained yang dihosting di Hub. - Path ke directory (misalnya ./my_model_directory) yang berisi bobot model yang disimpan dengan ModelMixin.save_pretrained(). - torch state dict.

cache_dir (str | os.PathLike, opsional) : Path ke direktori tempat konfigurasi model pretrained yang diunduh di-cache jika cache standar tidak digunakan.

force_download (bool, opsional, defaultnya False) : Apakah akan memaksa (mengunduh ulang) bobot model dan file konfigurasi, menimpa versi yang di-cache jika ada.

proxies (dict[str, str], opsional) : Kamus server proxy yang akan digunakan berdasarkan protokol atau endpoint, misalnya {'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}. Proxy digunakan pada setiap permintaan.

local_files_only (bool, opsional, defaultnya False) : Apakah hanya memuat bobot model dan file konfigurasi lokal atau tidak. Jika diatur ke True, model tidak akan diunduh dari Hub.

token (str atau bool, opsional) : Token yang digunakan sebagai otorisasi bearer HTTP untuk file jarak jauh. Jika True, token yang dihasilkan dari diffusers-cli login (disimpan di ~/.huggingface) akan digunakan.

revision (str, opsional, defaultnya "main") : Versi model spesifik yang akan digunakan. Bisa berupa nama branch, nama tag, id commit, atau identifikasi apa pun yang diizinkan oleh Git.

subfolder (str, opsional, defaultnya "") : Lokasi subfolder dari file model di dalam repositori model yang lebih besar di Hub atau secara lokal.

weight_name (str, opsional, defaultnya None) : Nama file state dict yang diserialisasi.

return_lora_metadata (bool, opsional, defaultnya False) : Jika diaktifkan, kembalikan juga metadata adapter LoRA, yang biasanya ditemukan dalam state dict.

Kembalikan state dict untuk bobot lora dan alfa jaringan.

> Kami mendukung pemuatan checkpoint LoRA berformat A1111 dengan kapasitas terbatas. > > Fungsi ini eksperimental dan mungkin berubah di masa depan.

save_lora_weights[[diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, unet_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, text_encoder_lora_layers: dict[str, torch.nn.Module] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, unet_lora_adapter_metadata = None, text_encoder_lora_adapter_metadata = None)

Sumber

Parameter:

save_directory (str atau os.PathLike) : Direktori untuk menyimpan parameter LoRA. Akan dibuat jika belum ada.

unet_lora_layers (dict[str, torch.nn.Module] atau dict[str, torch.Tensor]) : State dict dari lapisan LoRA yang sesuai dengan unet.

text_encoder_lora_layers (dict[str, torch.nn.Module] atau dict[str, torch.Tensor]) : State dict dari lapisan LoRA yang sesuai dengan text_encoder. Anda harus secara eksplisit meneruskan state dict LoRA untuk text encoder karena berasal dari 🤗 Transformers.

is_main_process (bool, opsional, defaultnya True) : Apakah proses yang memanggil ini adalah proses utama atau tidak. Berguna selama pelatihan terdistribusi dan Anda perlu memanggil fungsi ini di semua proses. Dalam kasus ini, atur is_main_process=True hanya pada proses utama untuk menghindari kondisi balapan.

save_function (Callable) : Fungsi yang digunakan untuk menyimpan state dictionary. Berguna selama pelatihan terdistribusi ketika Anda perlu mengganti torch.save dengan metode lain. Dapat dikonfigurasi dengan variabel lingkungan DIFFUSERS_SAVE_MODE.

safe_serialization (bool, opsional, defaultnya True) : Apakah model disimpan menggunakan safetensors atau cara tradisional PyTorch dengan pickle.

unet_lora_adapter_metadata : Metadata adapter LoRA yang terkait dengan unet untuk diserialisasi bersama state dict.

text_encoder_lora_adapter_metadata : Metadata adapter LoRA yang terkait dengan text encoder untuk diserialisasi bersama state dict.

Simpan parameter LoRA yang sesuai dengan UNet dan text encoder.

StableDiffusionXLLoraLoaderMixin[[diffusers.loaders.StableDiffusionXLLoraLoaderMixin]]

diffusers.loaders.StableDiffusionXLLoraLoaderMixin[[diffusers.loaders.StableDiffusionXLLoraLoaderMixin]]

diffusers.loaders.StableDiffusionXLLoraLoaderMixin()

Sumber

Muat lapisan LoRA ke dalam UNet2DConditionModel, CLIPTextModel, dan CLIPTextModelWithProjection Stable Diffusion XL.

fuse_lora[[diffusers.loaders.StableDiffusionXLLoraLoaderMixin.fuse_lora]]

fuse_lora(components: list[str] = ['unet', 'text_encoder', 'text_encoder_2'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)

Sumber

Lihat fuse_lora() untuk detail lebih lanjut.

load_lora_into_text_encoder[[diffusers.loaders.StableDiffusionXLLoraLoaderMixin.load_lora_into_text_encoder]]

load_lora_into_text_encoder(state_dict, network_alphas, text_encoder, prefix = None, lora_scale = 1.0, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Sumber

Parameter:

state_dict (dict) : state dict standar yang berisi parameter lapisan lora. Kuncinya harus diberi awalan tambahan text_encoder untuk membedakan lapisan lora unet.

network_alphas (dict[str, float]) : Nilai network alpha yang digunakan untuk pembelajaran yang stabil dan mencegah underflow. Nilai ini memiliki arti yang sama dengan opsi --network_alpha dalam skrip trainer kohya-ss. Lihat tautan ini.

text_encoder (CLIPTextModel) : Model encoder teks untuk memuat lapisan LoRA.

prefix (str) : Prefiks yang diharapkan dari text_encoder di dalam state_dict.

lora_scale (float) : Berapa skala yang diterapkan pada output dari lora linear layer sebelum ditambahkan dengan output dari lora layer reguler.

adapter_name (str, opsional) : Nama adapter yang akan digunakan untuk merujuk model adapter yang dimuat. Jika tidak ditentukan, akan digunakan default_{i} di mana i adalah total jumlah adapter yang dimuat.

low_cpu_mem_usage (bool, opsional) : Mempercepat pemuatan model dengan hanya memuat bobot LoRA pretrained dan tidak menginisialisasi bobot acak.

hotswap (bool, opsional) : Lihat load_lora_weights().

metadata (dict) : Metadata adapter LoRA opsional. Jika diberikan, argumen LoraConfig dari peft tidak akan diturunkan dari state dict.

Ini akan memuat lapisan LoRA yang ditentukan dalam state_dict ke dalam text_encoder

load_lora_into_unet[[diffusers.loaders.StableDiffusionXLLoraLoaderMixin.load_lora_into_unet]]

load_lora_into_unet(state_dict, network_alphas, unet, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Sumber

Parameter:

state_dict (dict) : state dict standar yang berisi parameter lapisan lora. Kunci-kuncinya dapat diindeks langsung ke unet atau diberi awalan tambahan unet yang dapat digunakan untuk membedakan lapisan lora text encoder.

network_alphas (dict[str, float]) : Nilai network alpha yang digunakan untuk pembelajaran yang stabil dan mencegah underflow. Nilai ini memiliki arti yang sama dengan opsi --network_alpha dalam skrip trainer kohya-ss. Lihat tautan ini.

unet (UNet2DConditionModel) : Model UNet untuk memuat lapisan LoRA.

adapter_name (str, opsional) : Nama adapter yang akan digunakan untuk merujuk model adapter yang dimuat. Jika tidak ditentukan, akan digunakan default_{i} di mana i adalah total jumlah adapter yang dimuat.

low_cpu_mem_usage (bool, opsional) : Mempercepat pemuatan model dengan hanya memuat bobot LoRA pretrained dan tidak menginisialisasi bobot acak.

hotswap (bool, opsional) : Lihat load_lora_weights().

metadata (dict) : Metadata adapter LoRA opsional. Jika diberikan, argumen LoraConfig dari peft tidak akan diturunkan dari state dict.

Ini akan memuat lapisan LoRA yang ditentukan dalam state_dict ke dalam unet.

load_lora_weights[[diffusers.loaders.StableDiffusionXLLoraLoaderMixin.load_lora_weights]]

load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)

Sumber

Lihat load_lora_weights() untuk detail lebih lanjut.

lora_state_dict[[diffusers.loaders.StableDiffusionXLLoraLoaderMixin.lora_state_dict]]

lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)

Sumber

Parameter:

pretrained_model_name_or_path_or_dict (str atau os.PathLike atau dict) : Bisa berupa: - String, model id (misalnya google/ddpm-celebahq-256) dari model pretrained yang dihosting di Hub. - Path ke directory (misalnya ./my_model_directory) yang berisi bobot model yang disimpan dengan ModelMixin.save_pretrained(). - torch state dict.

cache_dir (str | os.PathLike, opsional) : Path ke direktori tempat konfigurasi model pretrained yang diunduh di-cache jika cache standar tidak digunakan.

force_download (bool, opsional, defaultnya False) : Apakah akan memaksa (mengunduh ulang) bobot model dan file konfigurasi, menimpa versi yang di-cache jika ada.

proxies (dict[str, str], opsional) : Kamus server proxy yang akan digunakan berdasarkan protokol atau endpoint, misalnya {'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}. Proxy digunakan pada setiap permintaan.

local_files_only (bool, opsional, defaultnya False) : Apakah hanya memuat bobot model dan file konfigurasi lokal atau tidak. Jika diatur ke True, model tidak akan diunduh dari Hub.

token (str atau bool, opsional) : Token yang digunakan sebagai otorisasi bearer HTTP untuk file jarak jauh. Jika True, token yang dihasilkan dari diffusers-cli login (disimpan di ~/.huggingface) akan digunakan.

revision (str, opsional, defaultnya "main") : Versi model spesifik yang akan digunakan. Bisa berupa nama branch, nama tag, id commit, atau identifikasi apa pun yang diizinkan oleh Git.

subfolder (str, opsional, defaultnya "") : Lokasi subfolder dari file model di dalam repositori model yang lebih besar di Hub atau secara lokal.

weight_name (str, opsional, defaultnya None) : Nama file state dict yang diserialisasi.

return_lora_metadata (bool, opsional, defaultnya False) : Jika diaktifkan, kembalikan juga metadata adapter LoRA, yang biasanya ditemukan dalam state dict.

Kembalikan state dict untuk bobot lora dan alfa jaringan.

> Kami mendukung pemuatan checkpoint LoRA berformat A1111 dengan kapasitas terbatas. > > Fungsi ini eksperimental dan mungkin berubah di masa depan.

save_lora_weights[[diffusers.loaders.StableDiffusionXLLoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, unet_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, text_encoder_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, text_encoder_2_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, unet_lora_adapter_metadata = None, text_encoder_lora_adapter_metadata = None, text_encoder_2_lora_adapter_metadata = None)

Sumber

Lihat save_lora_weights() untuk informasi lebih lanjut.

unfuse_lora[[diffusers.loaders.StableDiffusionXLLoraLoaderMixin.unfuse_lora]]

unfuse_lora(components: list[str] = ['unet', 'text_encoder', 'text_encoder_2'], **kwargs)

Sumber

Lihat unfuse_lora() untuk detail lebih lanjut.

SD3LoraLoaderMixin[[diffusers.loaders.SD3LoraLoaderMixin]]

diffusers.loaders.SD3LoraLoaderMixin[[diffusers.loaders.SD3LoraLoaderMixin]]

diffusers.loaders.SD3LoraLoaderMixin()

Sumber

Muat lapisan LoRA ke dalam SD3Transformer2DModel, CLIPTextModel, dan CLIPTextModelWithProjection.

Khusus untuk StableDiffusion3Pipeline.

fuse_lora[[diffusers.loaders.SD3LoraLoaderMixin.fuse_lora]]

fuse_lora(components: list[str] = ['transformer', 'text_encoder', 'text_encoder_2'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)

Sumber

Lihat fuse_lora() untuk detail lebih lanjut.

load_lora_into_text_encoder[[diffusers.loaders.SD3LoraLoaderMixin.load_lora_into_text_encoder]]

load_lora_into_text_encoder(state_dict, network_alphas, text_encoder, prefix = None, lora_scale = 1.0, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Sumber

Parameter:

state_dict (dict) : state dict standar yang berisi parameter lapisan lora. Kuncinya harus diberi awalan tambahan text_encoder untuk membedakan lapisan lora unet.

network_alphas (dict[str, float]) : Nilai network alpha yang digunakan untuk pembelajaran yang stabil dan mencegah underflow. Nilai ini memiliki arti yang sama dengan opsi --network_alpha dalam skrip trainer kohya-ss. Lihat tautan ini.

text_encoder (CLIPTextModel) : Model encoder teks untuk memuat lapisan LoRA.

prefix (str) : Prefiks yang diharapkan dari text_encoder di dalam state_dict.

lora_scale (float) : Berapa skala yang diterapkan pada output dari lora linear layer sebelum ditambahkan dengan output dari lora layer reguler.

adapter_name (str, opsional) : Nama adapter yang akan digunakan untuk merujuk model adapter yang dimuat. Jika tidak ditentukan, akan digunakan default_{i} di mana i adalah total jumlah adapter yang dimuat.

low_cpu_mem_usage (bool, opsional) : Mempercepat pemuatan model dengan hanya memuat bobot LoRA pretrained dan tidak menginisialisasi bobot acak.

hotswap (bool, opsional) : Lihat load_lora_weights().

metadata (dict) : Metadata adapter LoRA opsional. Jika diberikan, argumen LoraConfig dari peft tidak akan diturunkan dari state dict.

Ini akan memuat lapisan LoRA yang ditentukan dalam state_dict ke dalam text_encoder

load_lora_into_transformer[[diffusers.loaders.SD3LoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Sumber

Lihat load_lora_into_unet() untuk detail lebih lanjut.

load_lora_weights[[diffusers.loaders.SD3LoraLoaderMixin.load_lora_weights]]

load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name = None, hotswap: bool = False, **kwargs)

Sumber

Lihat load_lora_weights() untuk detail lebih lanjut.

lora_state_dict[[diffusers.loaders.SD3LoraLoaderMixin.lora_state_dict]]

lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)

Sumber

Lihat lora_state_dict() untuk detail lebih lanjut.

save_lora_weights[[diffusers.loaders.SD3LoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, text_encoder_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, text_encoder_2_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata = None, text_encoder_lora_adapter_metadata = None, text_encoder_2_lora_adapter_metadata = None)

Sumber

Lihat save_lora_weights() untuk informasi lebih lanjut.

unfuse_lora[[diffusers.loaders.SD3LoraLoaderMixin.unfuse_lora]]

unfuse_lora(components: list[str] = ['transformer', 'text_encoder', 'text_encoder_2'], **kwargs)

Sumber

Lihat unfuse_lora() untuk detail lebih lanjut.

FluxLoraLoaderMixin[[diffusers.loaders.FluxLoraLoaderMixin]]

diffusers.loaders.FluxLoraLoaderMixin[[diffusers.loaders.FluxLoraLoaderMixin]]

diffusers.loaders.FluxLoraLoaderMixin()

Sumber

Muat lapisan LoRA ke dalam FluxTransformer2DModel, CLIPTextModel.

Khusus untuk FluxPipeline.

fuse_lora[[diffusers.loaders.FluxLoraLoaderMixin.fuse_lora]]

fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)

Sumber

Lihat lora_state_dict() untuk detail lebih lanjut.

load_lora_into_text_encoder[[diffusers.loaders.FluxLoraLoaderMixin.load_lora_into_text_encoder]]

load_lora_into_text_encoder(state_dict, network_alphas, text_encoder, prefix = None, lora_scale = 1.0, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Sumber

Parameter:

state_dict (dict) : state dict standar yang berisi parameter lapisan lora. Kuncinya harus diberi awalan tambahan text_encoder untuk membedakan lapisan lora unet.

network_alphas (dict[str, float]) : Nilai network alpha yang digunakan untuk pembelajaran yang stabil dan mencegah underflow. Nilai ini memiliki arti yang sama dengan opsi --network_alpha dalam skrip trainer kohya-ss. Lihat tautan ini.

text_encoder (CLIPTextModel) : Model encoder teks untuk memuat lapisan LoRA.

prefix (str) : Prefiks yang diharapkan dari text_encoder di dalam state_dict.

lora_scale (float) : Berapa skala yang diterapkan pada output dari lora linear layer sebelum ditambahkan dengan output dari lora layer reguler.

adapter_name (str, opsional) : Nama adapter yang akan digunakan untuk merujuk model adapter yang dimuat. Jika tidak ditentukan, akan digunakan default_{i} di mana i adalah total jumlah adapter yang dimuat.

low_cpu_mem_usage (bool, opsional) : Mempercepat pemuatan model dengan hanya memuat bobot LoRA pretrained dan tidak menginisialisasi bobot acak.

hotswap (bool, opsional) : Lihat load_lora_weights().

metadata (dict) : Metadata adapter LoRA opsional. Jika diberikan, argumen LoraConfig dari peft tidak akan diturunkan dari state dict.

Ini akan memuat lapisan LoRA yang ditentukan dalam state_dict ke dalam text_encoder

load_lora_into_transformer[[diffusers.loaders.FluxLoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, network_alphas, transformer, adapter_name = None, metadata = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False)

Sumber

Lihat load_lora_into_unet() untuk detail lebih lanjut.

load_lora_weights[[diffusers.loaders.FluxLoraLoaderMixin.load_lora_weights]]

load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)

Sumber

Lihat load_lora_weights() untuk detail lebih lanjut.

lora_state_dict[[diffusers.loaders.FluxLoraLoaderMixin.lora_state_dict]]

lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], return_alphas: bool = False, **kwargs)

Sumber

Lihat lora_state_dict() untuk detail lebih lanjut.

save_lora_weights[[diffusers.loaders.FluxLoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, text_encoder_lora_layers: dict[str, torch.nn.Module] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata = None, text_encoder_lora_adapter_metadata = None)

Sumber

Parameter:

save_directory (str atau os.PathLike) : Direktori untuk menyimpan parameter LoRA. Akan dibuat jika belum ada.

transformer_lora_layers (dict[str, torch.nn.Module] atau dict[str, torch.Tensor]) : State dict dari lapisan LoRA yang sesuai dengan transformer.

text_encoder_lora_layers (dict[str, torch.nn.Module] atau dict[str, torch.Tensor]) : State dict dari lapisan LoRA yang sesuai dengan text_encoder. Anda harus secara eksplisit meneruskan state dict LoRA untuk text encoder karena berasal dari 🤗 Transformers.

is_main_process (bool, opsional, defaultnya True) : Apakah proses yang memanggil ini adalah proses utama atau tidak. Berguna selama pelatihan terdistribusi dan Anda perlu memanggil fungsi ini di semua proses. Dalam kasus ini, atur is_main_process=True hanya pada proses utama untuk menghindari kondisi balapan.

save_function (Callable) : Fungsi yang digunakan untuk menyimpan state dictionary. Berguna selama pelatihan terdistribusi ketika Anda perlu mengganti torch.save dengan metode lain. Dapat dikonfigurasi dengan variabel lingkungan DIFFUSERS_SAVE_MODE.

safe_serialization (bool, opsional, defaultnya True) : Apakah model disimpan menggunakan safetensors atau cara tradisional PyTorch dengan pickle.

transformer_lora_adapter_metadata : Metadata adapter LoRA yang terkait dengan transformer untuk diserialisasi bersama state dict.

text_encoder_lora_adapter_metadata : Metadata adapter LoRA yang terkait dengan text encoder untuk diserialisasi bersama state dict.

Simpan parameter LoRA yang sesuai dengan UNet dan text encoder.

unfuse_lora[[diffusers.loaders.FluxLoraLoaderMixin.unfuse_lora]]

unfuse_lora(components: list[str] = ['transformer', 'text_encoder'], **kwargs)

Sumber

Parameter:

components (list[str]) : daftar komponen yang dapat diinjeksi LoRA untuk melepas fusi LoRA.

Membalikkan efek dari pipe.fuse_lora().

unload_lora_weights[[diffusers.loaders.FluxLoraLoaderMixin.unload_lora_weights]]

unload_lora_weights(reset_to_overwritten_params = False)

Sumber

Parameter:

reset_to_overwritten_params (bool, defaultnya False) : Apakah modul yang dimuat LoRA akan direset ke parameter aslinya. Lihat dokumentasi Flux untuk mempelajari lebih lanjut.

Memuat ulang parameter LoRA.

Contoh:

>>> # Assuming `pipeline` is already loaded with the LoRA parameters.
>>> pipeline.unload_lora_weights()
>>> ...

Flux2LoraLoaderMixin[[diffusers.loaders.Flux2LoraLoaderMixin]]

diffusers.loaders.Flux2LoraLoaderMixin[[diffusers.loaders.Flux2LoraLoaderMixin]]

diffusers.loaders.Flux2LoraLoaderMixin()

Sumber

Muat lapisan LoRA ke dalam Flux2Transformer2DModel. Khusus untuk Flux2Pipeline.

fuse_lora[[diffusers.loaders.Flux2LoraLoaderMixin.fuse_lora]]

fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)

Sumber

Lihat fuse_lora() untuk detail lebih lanjut.

load_lora_into_transformer[[diffusers.loaders.Flux2LoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Sumber

Lihat load_lora_into_unet() untuk detail lebih lanjut.

load_lora_weights[[diffusers.loaders.Flux2LoraLoaderMixin.load_lora_weights]]

load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)

Sumber

Lihat load_lora_weights() untuk detail lebih lanjut.

lora_state_dict[[diffusers.loaders.Flux2LoraLoaderMixin.lora_state_dict]]

lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)

Sumber

Lihat lora_state_dict() untuk detail lebih lanjut.

save_lora_weights[[diffusers.loaders.Flux2LoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata: dict | None = None)

Sumber

Lihat save_lora_weights() untuk informasi lebih lanjut.

unfuse_lora[[diffusers.loaders.Flux2LoraLoaderMixin.unfuse_lora]]

unfuse_lora(components: list[str] = ['transformer'], **kwargs)

Sumber

Lihat unfuse_lora() untuk detail lebih lanjut.

Flux3LoraLoaderMixin[[diffusers.loaders.Flux3LoraLoaderMixin]]

diffusers.loaders.Flux3LoraLoaderMixin[[diffusers.loaders.Flux3LoraLoaderMixin]]

diffusers.loaders.Flux3LoraLoaderMixin()

Sumber

fuse_lora[[diffusers.loaders.Flux3LoraLoaderMixin.fuse_lora]]

fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)

Sumber

Lihat fuse_lora() untuk detail lebih lanjut.

load_lora_into_transformer[[diffusers.loaders.Flux3LoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Sumber

Lihat load_lora_into_unet() untuk detail lebih lanjut.

load_lora_weights[[diffusers.loaders.Flux3LoraLoaderMixin.load_lora_weights]]

load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)

Sumber

Lihat load_lora_weights() untuk detail lebih lanjut.

save_lora_weights[[diffusers.loaders.Flux3LoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata: dict | None = None)

Sumber

Lihat save_lora_weights() untuk informasi lebih lanjut.

unfuse_lora[[diffusers.loaders.Flux3LoraLoaderMixin.unfuse_lora]]

unfuse_lora(components: list[str] = ['transformer'], **kwargs)

Sumber

Lihat unfuse_lora() untuk detail lebih lanjut.

BriaFibo2LoraLoaderMixin[[diffusers.loaders.BriaFibo2LoraLoaderMixin]]

diffusers.loaders.BriaFibo2LoraLoaderMixin[[diffusers.loaders.BriaFibo2LoraLoaderMixin]]

diffusers.loaders.BriaFibo2LoraLoaderMixin()

Sumber

Muat lapisan LoRA ke dalam BriaFibo2Transformer2DModel. Khusus untuk BriaFibo2Pipeline.

fuse_lora[[diffusers.loaders.BriaFibo2LoraLoaderMixin.fuse_lora]]

fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)

Sumber

Lihat fuse_lora() untuk detail lebih lanjut.

load_lora_into_transformer[[diffusers.loaders.BriaFibo2LoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Sumber

Lihat load_lora_into_unet() untuk detail lebih lanjut.

load_lora_weights[[diffusers.loaders.BriaFibo2LoraLoaderMixin.load_lora_weights]]

load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)

Sumber

Lihat load_lora_weights() untuk detail lebih lanjut.

lora_state_dict[[diffusers.loaders.BriaFibo2LoraLoaderMixin.lora_state_dict]]

lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)

Sumber

Lihat lora_state_dict() untuk detail lebih lanjut.

save_lora_weights[[diffusers.loaders.BriaFibo2LoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata: dict | None = None)

Sumber

Lihat save_lora_weights() untuk informasi lebih lanjut.

unfuse_lora[[diffusers.loaders.BriaFibo2LoraLoaderMixin.unfuse_lora]]

unfuse_lora(components: list[str] = ['transformer'], **kwargs)

Sumber

Lihat unfuse_lora() untuk detail lebih lanjut.

ErnieImageLoraLoaderMixin[[diffusers.loaders.ErnieImageLoraLoaderMixin]]

diffusers.loaders.ErnieImageLoraLoaderMixin[[diffusers.loaders.ErnieImageLoraLoaderMixin]]

diffusers.loaders.ErnieImageLoraLoaderMixin()

Sumber

Muat lapisan LoRA ke dalam ErnieImageTransformer2DModel. Khusus untuk ErnieImagePipeline.

fuse_lora[[diffusers.loaders.ErnieImageLoraLoaderMixin.fuse_lora]]

fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)

Sumber

Lihat fuse_lora() untuk detail lebih lanjut.

load_lora_into_transformer[[diffusers.loaders.ErnieImageLoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Sumber

Lihat load_lora_into_unet() untuk detail lebih lanjut.

load_lora_weights[[diffusers.loaders.ErnieImageLoraLoaderMixin.load_lora_weights]]

load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)

Sumber

Lihat load_lora_weights() untuk detail lebih lanjut.

lora_state_dict[[diffusers.loaders.ErnieImageLoraLoaderMixin.lora_state_dict]]

lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)

Sumber

Lihat lora_state_dict() untuk detail lebih lanjut.

save_lora_weights[[diffusers.loaders.ErnieImageLoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata: dict | None = None)

Sumber

Lihat save_lora_weights() untuk informasi lebih lanjut.

unfuse_lora[[diffusers.loaders.ErnieImageLoraLoaderMixin.unfuse_lora]]

unfuse_lora(components: list[str] = ['transformer'], **kwargs)

Sumber

Lihat unfuse_lora() untuk detail lebih lanjut.

LTX2LoraLoaderMixin[[diffusers.loaders.LTX2LoraLoaderMixin]]

diffusers.loaders.LTX2LoraLoaderMixin[[diffusers.loaders.LTX2LoraLoaderMixin]]

diffusers.loaders.LTX2LoraLoaderMixin()

Sumber

Muat lapisan LoRA ke dalam LTX2VideoTransformer3DModel. Khusus untuk LTX2Pipeline.

fuse_lora[[diffusers.loaders.LTX2LoraLoaderMixin.fuse_lora]]

fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)

Sumber

Lihat fuse_lora() untuk detail lebih lanjut.

load_lora_into_transformer[[diffusers.loaders.LTX2LoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None, prefix: str = 'transformer')

Sumber

Lihat load_lora_into_unet() untuk detail lebih lanjut.

load_lora_weights[[diffusers.loaders.LTX2LoraLoaderMixin.load_lora_weights]]

load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)

Sumber

Lihat load_lora_weights() untuk detail lebih lanjut.

lora_state_dict[[diffusers.loaders.LTX2LoraLoaderMixin.lora_state_dict]]

lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)

Sumber

Lihat lora_state_dict() untuk detail lebih lanjut.

save_lora_weights[[diffusers.loaders.LTX2LoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata: dict | None = None)

Sumber

Lihat save_lora_weights() untuk informasi lebih lanjut.

unfuse_lora[[diffusers.loaders.LTX2LoraLoaderMixin.unfuse_lora]]

unfuse_lora(components: list[str] = ['transformer'], **kwargs)

Sumber

Lihat unfuse_lora() untuk detail lebih lanjut.

CogVideoXLoraLoaderMixin[[diffusers.loaders.CogVideoXLoraLoaderMixin]]

diffusers.loaders.CogVideoXLoraLoaderMixin[[diffusers.loaders.CogVideoXLoraLoaderMixin]]

diffusers.loaders.CogVideoXLoraLoaderMixin()

Sumber

Muat lapisan LoRA ke dalam CogVideoXTransformer3DModel. Khusus untuk CogVideoXPipeline.

fuse_lora[[diffusers.loaders.CogVideoXLoraLoaderMixin.fuse_lora]]

fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)

Sumber

Lihat fuse_lora() untuk detail lebih lanjut.

load_lora_into_transformer[[diffusers.loaders.CogVideoXLoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Sumber

Lihat load_lora_into_unet() untuk detail lebih lanjut.

load_lora_weights[[diffusers.loaders.CogVideoXLoraLoaderMixin.load_lora_weights]]

load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)

Sumber

Lihat load_lora_weights() untuk detail lebih lanjut.

lora_state_dict[[diffusers.loaders.CogVideoXLoraLoaderMixin.lora_state_dict]]

lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)

Sumber

Lihat lora_state_dict() untuk detail lebih lanjut.

save_lora_weights[[diffusers.loaders.CogVideoXLoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata: dict | None = None)

Sumber

Lihat save_lora_weights() untuk informasi lebih lanjut.

unfuse_lora[[diffusers.loaders.CogVideoXLoraLoaderMixin.unfuse_lora]]

unfuse_lora(components: list[str] = ['transformer'], **kwargs)

Sumber

Lihat unfuse_lora() untuk detail lebih lanjut.

Mochi1LoraLoaderMixin[[diffusers.loaders.Mochi1LoraLoaderMixin]]

diffusers.loaders.Mochi1LoraLoaderMixin[[diffusers.loaders.Mochi1LoraLoaderMixin]]

diffusers.loaders.Mochi1LoraLoaderMixin()

Sumber

Muat lapisan LoRA ke dalam MochiTransformer3DModel. Khusus untuk MochiPipeline.

fuse_lora[[diffusers.loaders.Mochi1LoraLoaderMixin.fuse_lora]]

fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)

Sumber

Lihat fuse_lora() untuk detail lebih lanjut.

load_lora_into_transformer[[diffusers.loaders.Mochi1LoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Sumber

Lihat load_lora_into_unet() untuk detail lebih lanjut.

load_lora_weights[[diffusers.loaders.Mochi1LoraLoaderMixin.load_lora_weights]]

load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)

Sumber

Lihat load_lora_weights() untuk detail lebih lanjut.

lora_state_dict[[diffusers.loaders.Mochi1LoraLoaderMixin.lora_state_dict]]

lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)

Sumber

Lihat lora_state_dict() untuk detail lebih lanjut.

save_lora_weights[[diffusers.loaders.Mochi1LoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata: dict | None = None)

Sumber

Lihat save_lora_weights() untuk informasi lebih lanjut.

unfuse_lora[[diffusers.loaders.Mochi1LoraLoaderMixin.unfuse_lora]]

unfuse_lora(components: list[str] = ['transformer'], **kwargs)

Sumber

Lihat unfuse_lora() untuk detail lebih lanjut.

AuraFlowLoraLoaderMixin[[diffusers.loaders.AuraFlowLoraLoaderMixin]]

diffusers.loaders.AuraFlowLoraLoaderMixin[[diffusers.loaders.AuraFlowLoraLoaderMixin]]

diffusers.loaders.AuraFlowLoraLoaderMixin()

Sumber

Muat lapisan LoRA ke dalam AuraFlowTransformer2DModel Khusus untuk AuraFlowPipeline.

fuse_lora[[diffusers.loaders.AuraFlowLoraLoaderMixin.fuse_lora]]

fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)

Sumber

Lihat fuse_lora() untuk detail lebih lanjut.

load_lora_into_transformer[[diffusers.loaders.AuraFlowLoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Sumber

Lihat load_lora_into_unet() untuk detail lebih lanjut.

load_lora_weights[[diffusers.loaders.AuraFlowLoraLoaderMixin.load_lora_weights]]

load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)

Sumber

Lihat load_lora_weights() untuk detail lebih lanjut.

lora_state_dict[[diffusers.loaders.AuraFlowLoraLoaderMixin.lora_state_dict]]

lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)

Sumber

Lihat lora_state_dict() untuk detail lebih lanjut.

save_lora_weights[[diffusers.loaders.AuraFlowLoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata: dict | None = None)

Sumber

Lihat save_lora_weights() untuk informasi lebih lanjut.

unfuse_lora[[diffusers.loaders.AuraFlowLoraLoaderMixin.unfuse_lora]]

unfuse_lora(components: list[str] = ['transformer', 'text_encoder'], **kwargs)

Sumber

Lihat unfuse_lora() untuk detail lebih lanjut.

LTXVideoLoraLoaderMixin[[diffusers.loaders.LTXVideoLoraLoaderMixin]]

diffusers.loaders.LTXVideoLoraLoaderMixin[[diffusers.loaders.LTXVideoLoraLoaderMixin]]

diffusers.loaders.LTXVideoLoraLoaderMixin()

Sumber

Muat lapisan LoRA ke dalam LTXVideoTransformer3DModel. Khusus untuk LTXPipeline.

fuse_lora[[diffusers.loaders.LTXVideoLoraLoaderMixin.fuse_lora]]

fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)

Sumber

Lihat fuse_lora() untuk detail lebih lanjut.

load_lora_into_transformer[[diffusers.loaders.LTXVideoLoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Sumber

Lihat load_lora_into_unet() untuk detail lebih lanjut.

load_lora_weights[[diffusers.loaders.LTXVideoLoraLoaderMixin.load_lora_weights]]

load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)

Sumber

Lihat load_lora_weights() untuk detail lebih lanjut.

lora_state_dict[[diffusers.loaders.LTXVideoLoraLoaderMixin.lora_state_dict]]

lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)

Sumber

Lihat lora_state_dict() untuk detail lebih lanjut.

save_lora_weights[[diffusers.loaders.LTXVideoLoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata: dict | None = None)

Sumber

Lihat save_lora_weights() untuk informasi lebih lanjut.

unfuse_lora[[diffusers.loaders.LTXVideoLoraLoaderMixin.unfuse_lora]]

unfuse_lora(components: list[str] = ['transformer'], **kwargs)

Sumber

Lihat unfuse_lora() untuk detail lebih lanjut.

SanaLoraLoaderMixin[[diffusers.loaders.SanaLoraLoaderMixin]]

diffusers.loaders.SanaLoraLoaderMixin[[diffusers.loaders.SanaLoraLoaderMixin]]

diffusers.loaders.SanaLoraLoaderMixin()

Sumber

Muat lapisan LoRA ke dalam SanaTransformer2DModel. Khusus untuk SanaPipeline.

fuse_lora[[diffusers.loaders.SanaLoraLoaderMixin.fuse_lora]]

fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)

Sumber

Lihat fuse_lora() untuk detail lebih lanjut.

load_lora_into_transformer[[diffusers.loaders.SanaLoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Sumber

Lihat load_lora_into_unet() untuk detail lebih lanjut.

load_lora_weights[[diffusers.loaders.SanaLoraLoaderMixin.load_lora_weights]]

load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)

Sumber

Lihat load_lora_weights() untuk detail lebih lanjut.

lora_state_dict[[diffusers.loaders.SanaLoraLoaderMixin.lora_state_dict]]

lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)

Sumber

Lihat lora_state_dict() untuk detail lebih lanjut.

save_lora_weights[[diffusers.loaders.SanaLoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata: dict | None = None)

Sumber

Lihat save_lora_weights() untuk informasi lebih lanjut.

unfuse_lora[[diffusers.loaders.SanaLoraLoaderMixin.unfuse_lora]]

unfuse_lora(components: list[str] = ['transformer'], **kwargs)

Sumber

Lihat unfuse_lora() untuk detail lebih lanjut.

HeliosLoraLoaderMixin[[diffusers.loaders.HeliosLoraLoaderMixin]]

diffusers.loaders.HeliosLoraLoaderMixin[[diffusers.loaders.HeliosLoraLoaderMixin]]

diffusers.loaders.HeliosLoraLoaderMixin()

Sumber

Muat lapisan LoRA ke dalam HeliosTransformer3DModel. Khusus untuk HeliosPipeline dan HeliosPyramidPipeline.

fuse_lora[[diffusers.loaders.HeliosLoraLoaderMixin.fuse_lora]]

fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)

Sumber

Lihat fuse_lora() untuk detail lebih lanjut.

load_lora_into_transformer[[diffusers.loaders.HeliosLoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Sumber

Lihat load_lora_into_unet() untuk detail lebih lanjut.

load_lora_weights[[diffusers.loaders.HeliosLoraLoaderMixin.load_lora_weights]]

load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)

Sumber

Lihat load_lora_weights() untuk detail lebih lanjut.

lora_state_dict[[diffusers.loaders.HeliosLoraLoaderMixin.lora_state_dict]]

lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)

Sumber

Lihat lora_state_dict() untuk detail lebih lanjut.

save_lora_weights[[diffusers.loaders.HeliosLoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata: dict | None = None)

Sumber

Lihat save_lora_weights() untuk informasi lebih lanjut.

unfuse_lora[[diffusers.loaders.HeliosLoraLoaderMixin.unfuse_lora]]

unfuse_lora(components: list[str] = ['transformer'], **kwargs)

Sumber

Lihat unfuse_lora() untuk detail lebih lanjut.

HunyuanVideoLoraLoaderMixin[[diffusers.loaders.HunyuanVideoLoraLoaderMixin]]

diffusers.loaders.HunyuanVideoLoraLoaderMixin[[diffusers.loaders.HunyuanVideoLoraLoaderMixin]]

diffusers.loaders.HunyuanVideoLoraLoaderMixin()

Sumber

Muat lapisan LoRA ke dalam HunyuanVideoTransformer3DModel. Khusus untuk HunyuanVideoPipeline.

fuse_lora[[diffusers.loaders.HunyuanVideoLoraLoaderMixin.fuse_lora]]

fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)

Sumber

Lihat fuse_lora() untuk detail lebih lanjut.

load_lora_into_transformer[[diffusers.loaders.HunyuanVideoLoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Sumber

Lihat load_lora_into_unet() untuk detail lebih lanjut.

load_lora_weights[[diffusers.loaders.HunyuanVideoLoraLoaderMixin.load_lora_weights]]

load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)

Sumber

Lihat load_lora_weights() untuk detail lebih lanjut.

lora_state_dict[[diffusers.loaders.HunyuanVideoLoraLoaderMixin.lora_state_dict]]

lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)

Sumber

Lihat lora_state_dict() untuk detail lebih lanjut.

save_lora_weights[[diffusers.loaders.HunyuanVideoLoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata: dict | None = None)

Sumber

Lihat save_lora_weights() untuk informasi lebih lanjut.

unfuse_lora[[diffusers.loaders.HunyuanVideoLoraLoaderMixin.unfuse_lora]]

unfuse_lora(components: list[str] = ['transformer'], **kwargs)

Sumber

Lihat unfuse_lora() untuk detail lebih lanjut.

Lumina2LoraLoaderMixin[[diffusers.loaders.Lumina2LoraLoaderMixin]]

diffusers.loaders.Lumina2LoraLoaderMixin[[diffusers.loaders.Lumina2LoraLoaderMixin]]

diffusers.loaders.Lumina2LoraLoaderMixin()

Sumber

Muat lapisan LoRA ke dalam Lumina2Transformer2DModel. Khusus untuk Lumina2Pipeline.

fuse_lora[[diffusers.loaders.Lumina2LoraLoaderMixin.fuse_lora]]

fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)

Sumber

Lihat fuse_lora() untuk detail lebih lanjut.

load_lora_into_transformer[[diffusers.loaders.Lumina2LoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Sumber

Lihat load_lora_into_unet() untuk detail lebih lanjut.

load_lora_weights[[diffusers.loaders.Lumina2LoraLoaderMixin.load_lora_weights]]

load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)

Sumber

Lihat load_lora_weights() untuk detail lebih lanjut.

lora_state_dict[[diffusers.loaders.Lumina2LoraLoaderMixin.lora_state_dict]]

lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)

Sumber

Lihat lora_state_dict() untuk detail lebih lanjut.

save_lora_weights[[diffusers.loaders.Lumina2LoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata: dict | None = None)

Sumber

Lihat save_lora_weights() untuk informasi lebih lanjut.

unfuse_lora[[diffusers.loaders.Lumina2LoraLoaderMixin.unfuse_lora]]

unfuse_lora(components: list[str] = ['transformer'], **kwargs)

Sumber

Lihat unfuse_lora() untuk detail lebih lanjut.

CogView4LoraLoaderMixin[[diffusers.loaders.CogView4LoraLoaderMixin]]

diffusers.loaders.CogView4LoraLoaderMixin[[diffusers.loaders.CogView4LoraLoaderMixin]]

diffusers.loaders.CogView4LoraLoaderMixin()

Sumber

Muat lapisan LoRA ke dalam WanTransformer3DModel. Khusus untuk CogView4Pipeline.

fuse_lora[[diffusers.loaders.CogView4LoraLoaderMixin.fuse_lora]]

fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)

Sumber

Lihat fuse_lora() untuk detail lebih lanjut.

load_lora_into_transformer[[diffusers.loaders.CogView4LoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Sumber

Lihat load_lora_into_unet() untuk detail lebih lanjut.

load_lora_weights[[diffusers.loaders.CogView4LoraLoaderMixin.load_lora_weights]]

load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)

Sumber

Lihat load_lora_weights() untuk detail lebih lanjut.

lora_state_dict[[diffusers.loaders.CogView4LoraLoaderMixin.lora_state_dict]]

lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)

Sumber

Lihat lora_state_dict() untuk detail lebih lanjut.

save_lora_weights[[diffusers.loaders.CogView4LoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata: dict | None = None)

Sumber

Lihat save_lora_weights() untuk informasi lebih lanjut.

unfuse_lora[[diffusers.loaders.CogView4LoraLoaderMixin.unfuse_lora]]

unfuse_lora(components: list[str] = ['transformer'], **kwargs)

Sumber

Lihat unfuse_lora() untuk detail lebih lanjut.

WanLoraLoaderMixin[[diffusers.loaders.WanLoraLoaderMixin]]

diffusers.loaders.WanLoraLoaderMixin[[diffusers.loaders.WanLoraLoaderMixin]]

diffusers.loaders.WanLoraLoaderMixin()

Sumber

Muat lapisan LoRA ke dalam WanTransformer3DModel. Khusus untuk WanPipeline dan [WanImageToVideoPipeline].

fuse_lora[[diffusers.loaders.WanLoraLoaderMixin.fuse_lora]]

fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)

Sumber

Lihat fuse_lora() untuk detail lebih lanjut.

load_lora_into_transformer[[diffusers.loaders.WanLoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Sumber

Lihat load_lora_into_unet() untuk detail lebih lanjut.

load_lora_weights[[diffusers.loaders.WanLoraLoaderMixin.load_lora_weights]]

load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)

Sumber

Lihat load_lora_weights() untuk detail lebih lanjut.

lora_state_dict[[diffusers.loaders.WanLoraLoaderMixin.lora_state_dict]]

lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)

Sumber

Lihat lora_state_dict() untuk detail lebih lanjut.

save_lora_weights[[diffusers.loaders.WanLoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata: dict | None = None)

Sumber

Lihat save_lora_weights() untuk informasi lebih lanjut.

unfuse_lora[[diffusers.loaders.WanLoraLoaderMixin.unfuse_lora]]

unfuse_lora(components: list[str] = ['transformer'], **kwargs)

Sumber

Lihat unfuse_lora() untuk detail lebih lanjut.

SkyReelsV2LoraLoaderMixin[[diffusers.loaders.SkyReelsV2LoraLoaderMixin]]

diffusers.loaders.SkyReelsV2LoraLoaderMixin[[diffusers.loaders.SkyReelsV2LoraLoaderMixin]]

diffusers.loaders.SkyReelsV2LoraLoaderMixin()

Sumber

Muat lapisan LoRA ke dalam SkyReelsV2Transformer3DModel.

fuse_lora[[diffusers.loaders.SkyReelsV2LoraLoaderMixin.fuse_lora]]

fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)

Sumber

Lihat fuse_lora() untuk detail lebih lanjut.

load_lora_into_transformer[[diffusers.loaders.SkyReelsV2LoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Sumber

Lihat load_lora_into_unet() untuk detail lebih lanjut.

load_lora_weights[[diffusers.loaders.SkyReelsV2LoraLoaderMixin.load_lora_weights]]

load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)

Sumber

Lihat load_lora_weights() untuk detail lebih lanjut.

lora_state_dict[[diffusers.loaders.SkyReelsV2LoraLoaderMixin.lora_state_dict]]

lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)

Sumber

Lihat lora_state_dict() untuk detail lebih lanjut.

save_lora_weights[[diffusers.loaders.SkyReelsV2LoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata: dict | None = None)

Sumber

Lihat save_lora_weights() untuk informasi lebih lanjut.

unfuse_lora[[diffusers.loaders.SkyReelsV2LoraLoaderMixin.unfuse_lora]]

unfuse_lora(components: list[str] = ['transformer'], **kwargs)

Sumber

Lihat unfuse_lora() untuk detail lebih lanjut.

AmusedLoraLoaderMixin[[diffusers.loaders.AmusedLoraLoaderMixin]]

diffusers.loaders.AmusedLoraLoaderMixin[[diffusers.loaders.AmusedLoraLoaderMixin]]

diffusers.loaders.AmusedLoraLoaderMixin()

Sumber

load_lora_into_transformer[[diffusers.loaders.AmusedLoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, network_alphas, transformer, adapter_name = None, metadata = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False)

Sumber

Lihat load_lora_into_unet() untuk detail lebih lanjut.

save_lora_weights[[diffusers.loaders.AmusedLoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, text_encoder_lora_layers: dict[str, torch.nn.Module] = None, transformer_lora_layers: dict[str, torch.nn.Module] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True)

Sumber

Parameter:

save_directory (str atau os.PathLike) : Direktori untuk menyimpan parameter LoRA. Akan dibuat jika belum ada.

unet_lora_layers (dict[str, torch.nn.Module] atau dict[str, torch.Tensor]) : State dict dari lapisan LoRA yang sesuai dengan unet.

text_encoder_lora_layers (dict[str, torch.nn.Module] atau dict[str, torch.Tensor]) : State dict dari lapisan LoRA yang sesuai dengan text_encoder. Anda harus secara eksplisit meneruskan state dict LoRA untuk text encoder karena berasal dari 🤗 Transformers.

is_main_process (bool, opsional, defaultnya True) : Apakah proses yang memanggil ini adalah proses utama atau tidak. Berguna selama pelatihan terdistribusi dan Anda perlu memanggil fungsi ini di semua proses. Dalam kasus ini, atur is_main_process=True hanya pada proses utama untuk menghindari kondisi balapan.

save_function (Callable) : Fungsi yang digunakan untuk menyimpan state dictionary. Berguna selama pelatihan terdistribusi ketika Anda perlu mengganti torch.save dengan metode lain. Dapat dikonfigurasi dengan variabel lingkungan DIFFUSERS_SAVE_MODE.

safe_serialization (bool, opsional, defaultnya True) : Apakah model disimpan menggunakan safetensors atau cara tradisional PyTorch dengan pickle.

Simpan parameter LoRA yang sesuai dengan UNet dan text encoder.

AnimaLoraLoaderMixin[[diffusers.loaders.AnimaLoraLoaderMixin]]

diffusers.loaders.AnimaLoraLoaderMixin[[diffusers.loaders.AnimaLoraLoaderMixin]]

diffusers.loaders.AnimaLoraLoaderMixin()

Sumber

Muat lapisan LoRA ke dalam CosmosTransformer3DModel dan AnimaTextConditioner.

fuse_lora[[diffusers.loaders.AnimaLoraLoaderMixin.fuse_lora]]

fuse_lora(components: list[str] = ['transformer', 'text_conditioner'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)

Sumber

Lihat fuse_lora() untuk detail lebih lanjut.

load_lora_weights[[diffusers.loaders.AnimaLoraLoaderMixin.load_lora_weights]]

load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)

Sumber

Lihat load_lora_weights() untuk detail lebih lanjut.

lora_state_dict[[diffusers.loaders.AnimaLoraLoaderMixin.lora_state_dict]]

lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)

Sumber

Lihat lora_state_dict() untuk detail lebih lanjut.

unfuse_lora[[diffusers.loaders.AnimaLoraLoaderMixin.unfuse_lora]]

unfuse_lora(components: list[str] = ['transformer', 'text_conditioner'], **kwargs)

Sumber

Lihat unfuse_lora() untuk detail lebih lanjut.

AceStepLoraLoaderMixin[[diffusers.loaders.AceStepLoraLoaderMixin]]

diffusers.loaders.AceStepLoraLoaderMixin[[diffusers.loaders.AceStepLoraLoaderMixin]]

diffusers.loaders.AceStepLoraLoaderMixin()

Sumber

Muat lapisan LoRA ke dalam AceStepTransformer1DModel. Khusus untuk AceStepPipeline.

fuse_lora[[diffusers.loaders.AceStepLoraLoaderMixin.fuse_lora]]

fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)

Sumber

Lihat fuse_lora() untuk detail lebih lanjut.

load_lora_into_transformer[[diffusers.loaders.AceStepLoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Sumber

Lihat load_lora_into_unet() untuk detail lebih lanjut.

load_lora_weights[[diffusers.loaders.AceStepLoraLoaderMixin.load_lora_weights]]

load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)

Sumber

Lihat load_lora_weights() untuk detail lebih lanjut.

lora_state_dict[[diffusers.loaders.AceStepLoraLoaderMixin.lora_state_dict]]

lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)

Sumber

Lihat lora_state_dict() untuk detail lebih lanjut.

save_lora_weights[[diffusers.loaders.AceStepLoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata: dict | None = None)

Sumber

Lihat save_lora_weights() untuk informasi lebih lanjut.

unfuse_lora[[diffusers.loaders.AceStepLoraLoaderMixin.unfuse_lora]]

unfuse_lora(components: list[str] = ['transformer'], **kwargs)

Sumber

Lihat unfuse_lora() untuk detail lebih lanjut.

HiDreamImageLoraLoaderMixin[[diffusers.loaders.HiDreamImageLoraLoaderMixin]]

diffusers.loaders.HiDreamImageLoraLoaderMixin[[diffusers.loaders.HiDreamImageLoraLoaderMixin]]

diffusers.loaders.HiDreamImageLoraLoaderMixin()

Sumber

Muat lapisan LoRA ke dalam HiDreamImageTransformer2DModel. Khusus untuk HiDreamImagePipeline.

fuse_lora[[diffusers.loaders.HiDreamImageLoraLoaderMixin.fuse_lora]]

fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)

Sumber

Lihat fuse_lora() untuk detail lebih lanjut.

load_lora_into_transformer[[diffusers.loaders.HiDreamImageLoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Sumber

Lihat load_lora_into_unet() untuk detail lebih lanjut.

load_lora_weights[[diffusers.loaders.HiDreamImageLoraLoaderMixin.load_lora_weights]]

load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)

Sumber

Lihat load_lora_weights() untuk detail lebih lanjut.

lora_state_dict[[diffusers.loaders.HiDreamImageLoraLoaderMixin.lora_state_dict]]

lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)

Sumber

Lihat lora_state_dict() untuk detail lebih lanjut.

save_lora_weights[[diffusers.loaders.HiDreamImageLoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata: dict | None = None)

Sumber

Lihat save_lora_weights() untuk informasi lebih lanjut.

unfuse_lora[[diffusers.loaders.HiDreamImageLoraLoaderMixin.unfuse_lora]]

unfuse_lora(components: list[str] = ['transformer'], **kwargs)

Sumber

Lihat unfuse_lora() untuk detail lebih lanjut.

QwenImageLoraLoaderMixin[[diffusers.loaders.QwenImageLoraLoaderMixin]]

diffusers.loaders.QwenImageLoraLoaderMixin[[diffusers.loaders.QwenImageLoraLoaderMixin]]

diffusers.loaders.QwenImageLoraLoaderMixin()

Sumber

Muat lapisan LoRA ke dalam QwenImageTransformer2DModel. Khusus untuk QwenImagePipeline.

fuse_lora[[diffusers.loaders.QwenImageLoraLoaderMixin.fuse_lora]]

fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)

Sumber

Lihat fuse_lora() untuk detail lebih lanjut.

load_lora_into_transformer[[diffusers.loaders.QwenImageLoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Sumber

Lihat load_lora_into_unet() untuk detail lebih lanjut.

load_lora_weights[[diffusers.loaders.QwenImageLoraLoaderMixin.load_lora_weights]]

load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)

Sumber

Lihat load_lora_weights() untuk detail lebih lanjut.

lora_state_dict[[diffusers.loaders.QwenImageLoraLoaderMixin.lora_state_dict]]

lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)

Sumber

Lihat lora_state_dict() untuk detail lebih lanjut.

save_lora_weights[[diffusers.loaders.QwenImageLoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata: dict | None = None)

Sumber

Lihat save_lora_weights() untuk informasi lebih lanjut.

unfuse_lora[[diffusers.loaders.QwenImageLoraLoaderMixin.unfuse_lora]]

unfuse_lora(components: list[str] = ['transformer'], **kwargs)

Sumber

Lihat unfuse_lora() untuk detail lebih lanjut.

ZImageLoraLoaderMixin[[diffusers.loaders.ZImageLoraLoaderMixin]]

diffusers.loaders.ZImageLoraLoaderMixin[[diffusers.loaders.ZImageLoraLoaderMixin]]

diffusers.loaders.ZImageLoraLoaderMixin()

Sumber

Muat lapisan LoRA ke dalam ZImageTransformer2DModel. Khusus untuk ZImagePipeline.

fuse_lora[[diffusers.loaders.ZImageLoraLoaderMixin.fuse_lora]]

fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)

Sumber

Lihat fuse_lora() untuk detail lebih lanjut.

load_lora_into_transformer[[diffusers.loaders.ZImageLoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Sumber

Lihat load_lora_into_unet() untuk detail lebih lanjut.

load_lora_weights[[diffusers.loaders.ZImageLoraLoaderMixin.load_lora_weights]]

load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)

Sumber

Lihat load_lora_weights() untuk detail lebih lanjut.

lora_state_dict[[diffusers.loaders.ZImageLoraLoaderMixin.lora_state_dict]]

lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)

Sumber

Lihat lora_state_dict() untuk detail lebih lanjut.

save_lora_weights[[diffusers.loaders.ZImageLoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata: dict | None = None)

Sumber

Lihat save_lora_weights() untuk informasi lebih lanjut.

unfuse_lora[[diffusers.loaders.ZImageLoraLoaderMixin.unfuse_lora]]

unfuse_lora(components: list[str] = ['transformer'], **kwargs)

Sumber

Lihat unfuse_lora() untuk detail lebih lanjut.

CosmosLoraLoaderMixin[[diffusers.loaders.CosmosLoraLoaderMixin]]

diffusers.loaders.CosmosLoraLoaderMixin[[diffusers.loaders.CosmosLoraLoaderMixin]]

diffusers.loaders.CosmosLoraLoaderMixin()

Sumber

Muat lapisan LoRA ke dalam CosmosTransformer3DModel, Khusus untuk Cosmos2_5_PredictBasePipeline.

fuse_lora[[diffusers.loaders.CosmosLoraLoaderMixin.fuse_lora]]

fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)

Sumber

Lihat fuse_lora() untuk detail lebih lanjut.

load_lora_into_transformer[[diffusers.loaders.CosmosLoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Sumber

Lihat load_lora_into_unet() untuk detail lebih lanjut.

load_lora_weights[[diffusers.loaders.CosmosLoraLoaderMixin.load_lora_weights]]

load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)

Sumber

Lihat load_lora_weights() untuk detail lebih lanjut.

lora_state_dict[[diffusers.loaders.CosmosLoraLoaderMixin.lora_state_dict]]

lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)

Sumber

Lihat lora_state_dict() untuk detail lebih lanjut.

save_lora_weights[[diffusers.loaders.CosmosLoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata: dict | None = None)

Sumber

Lihat save_lora_weights() untuk informasi lebih lanjut.

unfuse_lora[[diffusers.loaders.CosmosLoraLoaderMixin.unfuse_lora]]

unfuse_lora(components: list[str] = ['transformer'], **kwargs)

Sumber

Lihat unfuse_lora() untuk detail lebih lanjut.

KandinskyLoraLoaderMixin[[diffusers.loaders.KandinskyLoraLoaderMixin]]

diffusers.loaders.KandinskyLoraLoaderMixin[[diffusers.loaders.KandinskyLoraLoaderMixin]]

diffusers.loaders.KandinskyLoraLoaderMixin()

Sumber

Muat lapisan LoRA ke dalam Kandinsky5Transformer3DModel,

fuse_lora[[diffusers.loaders.KandinskyLoraLoaderMixin.fuse_lora]]

fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)

Sumber

Lihat fuse_lora() untuk detail lebih lanjut.

load_lora_into_transformer[[diffusers.loaders.KandinskyLoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Sumber

Lihat load_lora_into_unet() untuk detail lebih lanjut.

load_lora_weights[[diffusers.loaders.KandinskyLoraLoaderMixin.load_lora_weights]]

load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)

Sumber

Lihat load_lora_weights() untuk detail lebih lanjut.

lora_state_dict[[diffusers.loaders.KandinskyLoraLoaderMixin.lora_state_dict]]

lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)

Sumber

Lihat lora_state_dict() untuk detail lebih lanjut.

save_lora_weights[[diffusers.loaders.KandinskyLoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata: dict | None = None)

Sumber

Lihat save_lora_weights() untuk informasi lebih lanjut.

unfuse_lora[[diffusers.loaders.KandinskyLoraLoaderMixin.unfuse_lora]]

unfuse_lora(components: list[str] = ['transformer'], **kwargs)

Sumber

Lihat unfuse_lora() untuk detail lebih lanjut.

Ideogram4LoraLoaderMixin[[diffusers.loaders.Ideogram4LoraLoaderMixin]]

diffusers.loaders.Ideogram4LoraLoaderMixin[[diffusers.loaders.Ideogram4LoraLoaderMixin]]

diffusers.loaders.Ideogram4LoraLoaderMixin()

Sumber

Muat lapisan LoRA ke dalam Ideogram4Transformer2DModel. Khusus untuk Ideogram4Pipeline.

fuse_lora[[diffusers.loaders.Ideogram4LoraLoaderMixin.fuse_lora]]

fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)

Sumber

Lihat fuse_lora() untuk detail lebih lanjut.

load_lora_into_transformer[[diffusers.loaders.Ideogram4LoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Sumber

Lihat load_lora_into_unet() untuk detail lebih lanjut.

load_lora_weights[[diffusers.loaders.Ideogram4LoraLoaderMixin.load_lora_weights]]

load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)

Sumber

Lihat load_lora_weights() untuk detail lebih lanjut.

lora_state_dict[[diffusers.loaders.Ideogram4LoraLoaderMixin.lora_state_dict]]

lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)

Sumber

Lihat lora_state_dict() untuk detail lebih lanjut.

save_lora_weights[[diffusers.loaders.Ideogram4LoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata: dict | None = None)

Sumber

Lihat save_lora_weights() untuk informasi lebih lanjut.

unfuse_lora[[diffusers.loaders.Ideogram4LoraLoaderMixin.unfuse_lora]]

unfuse_lora(components: list[str] = ['transformer'], **kwargs)

Sumber

Lihat unfuse_lora() untuk detail lebih lanjut.

Krea2LoraLoaderMixin[[diffusers.loaders.Krea2LoraLoaderMixin]]

diffusers.loaders.Krea2LoraLoaderMixin[[diffusers.loaders.Krea2LoraLoaderMixin]]

diffusers.loaders.Krea2LoraLoaderMixin()

Sumber

Muat lapisan LoRA ke dalam Krea2Transformer2DModel. Khusus untuk Krea2Pipeline.

fuse_lora[[diffusers.loaders.Krea2LoraLoaderMixin.fuse_lora]]

fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)

Sumber

Lihat fuse_lora() untuk detail lebih lanjut.

load_lora_into_transformer[[diffusers.loaders.Krea2LoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Sumber

Lihat load_lora_into_unet() untuk detail lebih lanjut.

load_lora_weights[[diffusers.loaders.Krea2LoraLoaderMixin.load_lora_weights]]

load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)

Sumber

Lihat load_lora_weights() untuk detail lebih lanjut.

lora_state_dict[[diffusers.loaders.Krea2LoraLoaderMixin.lora_state_dict]]

lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)

Sumber

Lihat lora_state_dict() untuk detail lebih lanjut.

save_lora_weights[[diffusers.loaders.Krea2LoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata: dict | None = None)

Sumber

Lihat save_lora_weights() untuk informasi lebih lanjut.

unfuse_lora[[diffusers.loaders.Krea2LoraLoaderMixin.unfuse_lora]]

unfuse_lora(components: list[str] = ['transformer'], **kwargs)

Sumber

Lihat unfuse_lora() untuk detail lebih lanjut.

MiniMaxH3LoraLoaderMixin[[diffusers.loaders.MiniMaxH3LoraLoaderMixin]]

diffusers.loaders.MiniMaxH3LoraLoaderMixin[[diffusers.loaders.MiniMaxH3LoraLoaderMixin]]

diffusers.loaders.MiniMaxH3LoraLoaderMixin()

Sumber

Muat lapisan LoRA ke dalam MiniMaxH3Transformer3DModel. Khusus untuk MiniMaxH3ModularPipeline.

MiniMax-H3 menyediakan dua partisi DiT independen dengan nama modul yang identik (LoRA untuk satu partisi akan dimuat ke partisi lainnya dan menurunkan kualitas output), sehingga routing dilakukan secara eksplisit: state dict yang dikonversi menargetkan transformer.; akses ke transformer_ref dilakukan dengan file berawalan transformer_ref. atau load_into_transformer_ref=True.

LoRA dari DiffSynth-Studio (misalnya DiffSynth-Studio/MiniMax-H3-LoRA-LineartAnime) dilatih terhadap QKV fused per-head-interleaved dari checkpoint mentah dan di-de-interleave saat konversi. Faktor fp32-nya membuat jalur LoRA yang tidak ter-fuse menghitung dalam fp32; .to(torch.bfloat16) pada model setelah dimuat memulihkan anggaran memori bf16.

LoRA yang dilatih terhadap checkpoint yang dipangkas (file *_pruned_* di Comfy-Org/MiniMax-H3; joyfox/MiniMax-H3-Turbo adalah salah satunya) gagal dengan kesalahan ukuran yang tidak cocok. File tanpa alpha dimuat pada alpha == rank (skala 1.0, konvensi yang dinyatakan oleh misalnya larryvrh/MiniMax-H3-Turbo-Lora); entri alpha dalam __metadata__ (misalnya file 8-langkah dari lightx2v/Minimax-h3-Turbo), jika ada, akan dihormati sebagai gantinya.

fuse_lora[[diffusers.loaders.MiniMaxH3LoraLoaderMixin.fuse_lora]]

fuse_lora(components: list[str] = ['transformer', 'transformer_ref'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)

Sumber

Lihat fuse_lora() untuk detail lebih lanjut.

load_lora_into_transformer[[diffusers.loaders.MiniMaxH3LoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Sumber

Lihat load_lora_into_unet() untuk detail lebih lanjut.

load_lora_into_transformer_ref[[diffusers.loaders.MiniMaxH3LoraLoaderMixin.load_lora_into_transformer_ref]]

load_lora_into_transformer_ref(state_dict, transformer_ref, prefix, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Sumber

Muat lapisan LoRA ke partisi transformer_ref. prefix adalah nama komponen yang dibawa oleh kunci, yaitu transformer_ref untuk file yang menamai partisi dan transformer untuk file yang diarahkan ke sini oleh load_into_transformer_ref=True. Lihat load_lora_into_unet() untuk detail lebih lanjut.

load_lora_weights[[diffusers.loaders.MiniMaxH3LoraLoaderMixin.load_lora_weights]]

load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, load_into_transformer_ref: bool = False, **kwargs)

Sumber

Parameter:

load_into_transformer_ref (bool, defaultnya False) : Muat lapisan berawalan transformer. ke partisi transformer_ref — yang digunakan oleh alur kerja ref2va untuk denoising — alih-alih transformer. Hanya diperlukan ketika kedua partisi dimuat: pipeline yang hanya memegang transformer_ref akan mengarah ke sana secara otomatis.

Muat lapisan LoRA ke dalam transformer atau, dengan load_into_transformer_ref=True, ke dalam transformer_ref. Lihat load_lora_weights() untuk detail lebih lanjut.

lora_state_dict[[diffusers.loaders.MiniMaxH3LoraLoaderMixin.lora_state_dict]]

lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)

Sumber

Lihat lora_state_dict() untuk detail lebih lanjut.

save_lora_weights[[diffusers.loaders.MiniMaxH3LoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, transformer_ref_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata: dict | None = None, transformer_ref_lora_adapter_metadata: dict | None = None)

Sumber

Simpan lapisan LoRA dari satu atau kedua partisi MiniMax-H3. Partisi mana yang dimiliki oleh sebuah LoRA tidak dapat dipulihkan dari kuncinya, sehingga ini adalah satu-satunya cara untuk menerbitkan LoRA H3 yang mencatatnya. Lihat save_lora_weights() untuk informasi lebih lanjut.

unfuse_lora[[diffusers.loaders.MiniMaxH3LoraLoaderMixin.unfuse_lora]]

unfuse_lora(components: list[str] = ['transformer', 'transformer_ref'], **kwargs)

Sumber

Lihat unfuse_lora() untuk detail lebih lanjut.

PikaH3FlexLoraLoaderMixin[[diffusers.loaders.PikaH3FlexLoraLoaderMixin]]

diffusers.loaders.PikaH3FlexLoraLoaderMixin[[diffusers.loaders.PikaH3FlexLoraLoaderMixin]]

diffusers.loaders.PikaH3FlexLoraLoaderMixin()

Sumber

Muat lapisan LoRA ke dalam MiniMaxH3Transformer3DModel. Khusus untuk PikaH3FlexModularPipeline.

Rilis Pika H3 Flex adalah sepasang adapter rank-128 di atas dua partisi transformer MiniMax-H3, diterbitkan sebagai dump PEFT polos dari nama modul diffusers (fl2va/adapter.safetensors untuk transformer, ref2va/adapter.safetensors untuk transformer_ref). File tanpa alpha dimuat pada alpha == rank (skala 1.0), kontrak bawaan adapter, dan proses pemuatan, routing, serta penyimpanan mengikuti MiniMaxH3LoraLoaderMixin: adapter fl2va masuk ke transformer, dan adapter ref2va ke transformer_ref — secara mandiri ketika pipeline hanya memegang partisi tersebut (workflow="ref2va"), atau dengan load_into_transformer_ref=True ketika pipeline memegang keduanya.

pipe.load_lora_weights("Pika-Labs/Pika-H3-Flex", weight_name="fl2va/adapter.safetensors")

LoraBaseMixin[[diffusers.loaders.lora_base.LoraBaseMixin]]

diffusers.loaders.lora_base.LoraBaseMixin[[diffusers.loaders.lora_base.LoraBaseMixin]]

diffusers.loaders.lora_base.LoraBaseMixin()

Sumber

Kelas utilitas untuk menangani LoRA.

delete_adapters[[diffusers.loaders.lora_base.LoraBaseMixin.delete_adapters]]

delete_adapters(adapter_names: list[str] | str)

Sumber

Parameter:

adapter_names (list[str, str]) : Nama-nama adapter yang akan dihapus.

Hapus lapisan LoRA dari adapter di pipeline.

Contoh:

from diffusers import AutoPipelineForText2Image
import torch

pipeline = AutoPipelineForText2Image.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float16
).to("cuda")
pipeline.load_lora_weights(
    "jbilcke-hf/sdxl-cinematic-1", weight_name="pytorch_lora_weights.safetensors", adapter_names="cinematic"
)
pipeline.delete_adapters("cinematic")

disable_lora[[diffusers.loaders.lora_base.LoraBaseMixin.disable_lora]]

disable_lora()

Sumber

Menonaktifkan lapisan LoRA aktif dari pipeline.

Contoh:

from diffusers import AutoPipelineForText2Image
import torch

pipeline = AutoPipelineForText2Image.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float16
).to("cuda")
pipeline.load_lora_weights(
    "jbilcke-hf/sdxl-cinematic-1", weight_name="pytorch_lora_weights.safetensors", adapter_name="cinematic"
)
pipeline.disable_lora()

enable_lora[[diffusers.loaders.lora_base.LoraBaseMixin.enable_lora]]

enable_lora()

Sumber

Mengaktifkan lapisan LoRA aktif dari pipeline.

Contoh:

from diffusers import AutoPipelineForText2Image
import torch

pipeline = AutoPipelineForText2Image.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float16
).to("cuda")
pipeline.load_lora_weights(
    "jbilcke-hf/sdxl-cinematic-1", weight_name="pytorch_lora_weights.safetensors", adapter_name="cinematic"
)
pipeline.enable_lora()

enable_lora_hotswap[[diffusers.loaders.lora_base.LoraBaseMixin.enable_lora_hotswap]]

enable_lora_hotswap(**kwargs)

Sumber

Parameter:

target_rank (int) : Pangkat tertinggi di antara semua adapter yang akan dimuat.

check_compiled (str, opsional, defaultnya "error") : Cara menangani model yang sudah dikompilasi. Pengecekan dapat mengembalikan pesan berikut: - "error" (default): lempar error - "warn": terbitkan peringatan - "ignore": tidak melakukan apa pun

Hotswap adapter tanpa memicu kompilasi ulang model atau jika rank dari adapter yang dimuat berbeda.

fuse_lora[[diffusers.loaders.lora_base.LoraBaseMixin.fuse_lora]]

fuse_lora(components: list[str] | None = None, lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)

Sumber

Parameter:

components : (list[str]): daftar komponen yang dapat diinjeksi LoRA untuk menggabungkan LoRA ke dalamnya.

lora_scale (float, defaultnya 1.0) : Mengontrol seberapa besar pengaruh parameter LoRA terhadap output.

safe_fusing (bool, defaultnya False) : Apakah akan memeriksa bobot yang sudah digabungkan (fused) untuk nilai NaN sebelum penggabungan, dan jika nilainya NaN, tidak melakukan penggabungan.

adapter_names (list[str], opsional) : Nama-nama adapter yang akan digunakan untuk fusi. Jika tidak ada yang diteruskan, semua adapter aktif akan difusi.

Menggabungkan parameter LoRA ke dalam parameter asli dari blok yang sesuai.

Contoh:

from diffusers import DiffusionPipeline
import torch

pipeline = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float16
).to("cuda")
pipeline.load_lora_weights("nerijs/pixel-art-xl", weight_name="pixel-art-xl.safetensors", adapter_name="pixel")
pipeline.fuse_lora(lora_scale=0.7)

get_active_adapters[[diffusers.loaders.lora_base.LoraBaseMixin.get_active_adapters]]

get_active_adapters()

Sumber

Mendapatkan daftar adapter aktif saat ini.

Contoh:

from diffusers import DiffusionPipeline

pipeline = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
).to("cuda")
pipeline.load_lora_weights("CiroN2022/toy-face", weight_name="toy_face_sdxl.safetensors", adapter_name="toy")
pipeline.get_active_adapters()

get_list_adapters[[diffusers.loaders.lora_base.LoraBaseMixin.get_list_adapters]]

get_list_adapters()

Sumber

Mendapatkan daftar saat ini dari semua adapter yang tersedia di pipeline.

set_adapters[[diffusers.loaders.lora_base.LoraBaseMixin.set_adapters]]

set_adapters(adapter_names: list[str] | str, adapter_weights: float | dict[str, float | dict | None] | list[float | dict[str, float | dict | None] | None] | None = None)

Sumber

Parameter:

adapter_names (list[str] atau str) : Nama-nama adapter yang akan digunakan.

adapter_weights (float, dict atau list, opsional) : Bobot untuk adapter. Skalar menskalakan semua komponen yang kompatibel dengan LoRA. Kamus memetakan nama komponen (misalnya "unet", "transformer" atau "text_encoder") ke bobot; bobot komponen UNet juga dapat berupa kamus bersarang dari skala blok. Skalar atau kamus tunggal diterapkan ke setiap adapter. Daftar harus berisi satu skalar, kamus, atau None per adapter, sesuai urutan adapter_names. None secara default menjadi 1.0, termasuk entri daftar dan bobot komponen. Komponen yang tidak ditentukan dan blok UNet juga secara default menjadi 1.0.

Atur adapter yang saat ini aktif untuk digunakan dalam pipeline.

Contoh:

from diffusers import AutoPipelineForText2Image
import torch

pipeline = AutoPipelineForText2Image.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float16
).to("cuda")
pipeline.load_lora_weights(
    "jbilcke-hf/sdxl-cinematic-1", weight_name="pytorch_lora_weights.safetensors", adapter_name="cinematic"
)
pipeline.load_lora_weights(
    "troveski/sdxl-lora", weight_name="pytorch_lora_weights.safetensors", adapter_name="illustration"
)
pipeline.set_adapters(["cinematic", "illustration"], adapter_weights=[0.5, 0.5])
pipeline.set_adapters(
    ["cinematic", "illustration"],
    adapter_weights=[{"unet": 0.5}, {"unet": 0.8, "text_encoder": 0.6}],
)

set_lora_device[[diffusers.loaders.lora_base.LoraBaseMixin.set_lora_device]]

set_lora_device(adapter_names: list[str], device: torch.device | str | int)

Sumber

Parameter:

adapter_names (list[str]) : daftar adapter untuk dikirim ke perangkat.

device (torch.device | str | int) : Perangkat untuk mengirim adapter. Bisa berupa perangkat torch, str, atau integer.

Memindahkan LoRA yang tercantum dalam adapter_names ke perangkat target. Berguna untuk offloading LoRA ke CPU jika Anda ingin memuat beberapa adapter dan membebaskan sebagian memori GPU.

Setelah meng-offload adapter LoRA ke CPU, selama bagian lain dari model masih berada di GPU, adapter LoRA tidak dapat lagi digunakan untuk inferensi, karena hal itu akan menyebabkan ketidakcocokan perangkat. Ingatlah untuk mengatur perangkat kembali ke GPU sebelum menggunakan adapter LoRA tersebut untuk inferensi.

>>> pipe.load_lora_weights(path_1, adapter_name="adapter-1")
>>> pipe.load_lora_weights(path_2, adapter_name="adapter-2")
>>> pipe.set_adapters("adapter-1")
>>> image_1 = pipe(**kwargs)
>>> # switch to adapter-2, offload adapter-1
>>> pipeline.set_lora_device(adapter_names=["adapter-1"], device="cpu")
>>> pipeline.set_lora_device(adapter_names=["adapter-2"], device="cuda:0")
>>> pipe.set_adapters("adapter-2")
>>> image_2 = pipe(**kwargs)
>>> # switch back to adapter-1, offload adapter-2
>>> pipeline.set_lora_device(adapter_names=["adapter-2"], device="cpu")
>>> pipeline.set_lora_device(adapter_names=["adapter-1"], device="cuda:0")
>>> pipe.set_adapters("adapter-1")
>>> ...

unfuse_lora[[diffusers.loaders.lora_base.LoraBaseMixin.unfuse_lora]]

unfuse_lora(components: list[str] | None = None, **kwargs)

Sumber

Parameter:

components (list[str]) : daftar komponen yang dapat diinjeksi LoRA untuk melepas fusi LoRA.

unfuse_unet (bool, defaultnya True) : Apakah akan memisahkan parameter LoRA dari UNet.

unfuse_text_encoder (bool, defaultnya True) : Apakah akan memisahkan (unfuse) parameter LoRA dari text encoder. Jika text encoder tidak di-patch secara monkey dengan parameter LoRA, maka tidak akan ada efeknya.

Membalikkan efek dari pipe.fuse_lora().

unload_lora_weights[[diffusers.loaders.lora_base.LoraBaseMixin.unload_lora_weights]]

unload_lora_weights()

Sumber

Memuat ulang parameter LoRA.

Contoh:

>>> # Assuming `pipeline` is already loaded with the LoRA parameters.
>>> pipeline.unload_lora_weights()
>>> ...

write_lora_layers[[diffusers.loaders.lora_base.LoraBaseMixin.write_lora_layers]]

write_lora_layers(state_dict: dict[str, torch.Tensor], save_directory: str, is_main_process: bool, weight_name: str, save_function: Callable, safe_serialization: bool, lora_adapter_metadata: dict | None = None)

Sumber

Menulis state dict dari lapisan LoRA (opsional dengan metadata) ke disk.