Buckets:
LoRA
LoRA là phương pháp huấn luyện nhanh và nhẹ, chèn và huấn luyện một số lượng tham số nhỏ hơn đáng kể thay vì toàn bộ tham số của mô hình. Điều này tạo ra tệp nhỏ hơn (~100 MB) và giúp việc huấn luyện nhanh chóng một mô hình để học một khái niệm mới trở nên dễ dàng hơn. Trọng số LoRA thường được nạp vào denoiser, text encoder hoặc cả hai. Denoiser thường tương ứng với một UNet (ví dụ UNet2DConditionModel) hoặc một Transformer (ví dụ SD3Transformer2DModel). Có một số lớp để nạp trọng số LoRA:
StableDiffusionLoraLoaderMixincung cấp các hàm để nạp và gỡ, hợp nhất và tách, bật và tắt, cùng nhiều hàm khác để quản lý trọng số LoRA. Lớp này có thể được sử dụng với bất kỳ mô hình nào.StableDiffusionXLLoraLoaderMixinlà phiên bản Stable Diffusion (SDXL) của lớpStableDiffusionLoraLoaderMixinđể tải và lưu trữ trọng số LoRA. Nó chỉ có thể được sử dụng với mô hình SDXL.SD3LoraLoaderMixincung cấp các chức năng tương tự cho Stable Diffusion 3.FluxLoraLoaderMixincung cấp các chức năng tương tự cho Flux.CogVideoXLoraLoaderMixincung cấp các chức năng tương tự cho CogVideoX.Mochi1LoraLoaderMixincung cấp các chức năng tương tự cho Mochi.AuraFlowLoraLoaderMixincung cấp các chức năng tương tự cho AuraFlow.LTXVideoLoraLoaderMixincung cấp các chức năng tương tự cho LTX-Video.SanaLoraLoaderMixincung cấp các chức năng tương tự cho Sana.HeliosLoraLoaderMixincung cấp các chức năng tương tự cho HunyuanVideo.HunyuanVideoLoraLoaderMixincung cấp các chức năng tương tự cho HunyuanVideo.Lumina2LoraLoaderMixincung cấp các chức năng tương tự cho Lumina2.WanLoraLoaderMixincung cấp các chức năng tương tự cho Wan.SkyReelsV2LoraLoaderMixincung cấp các chức năng tương tự cho SkyReels-V2.CogView4LoraLoaderMixincung cấp các chức năng tương tự cho CogView4.AmusedLoraLoaderMixindành choAmusedPipeline.AnimaLoraLoaderMixincung cấp các chức năng tương tự cho Anima.AceStepLoraLoaderMixincung cấp các chức năng tương tự cho ACE-Step.HiDreamImageLoraLoaderMixincung cấp các chức năng tương tự cho HiDream ImageQwenImageLoraLoaderMixincung cấp các chức năng tương tự cho Qwen Image.ZImageLoraLoaderMixincung cấp các chức năng tương tự cho Z-Image.Flux2LoraLoaderMixincung cấp các chức năng tương tự cho Flux2.ErnieImageLoraLoaderMixincung cấp các chức năng tương tự cho Ernie-Image.LTX2LoraLoaderMixincung cấp các chức năng tương tự cho Flux2.MiniMaxH3LoraLoaderMixincung cấp các chức năng tương tự cho MiniMax-H3.PikaH3FlexLoraLoaderMixincung cấp các chức năng tương tự cho Pika H3 Flex.RFD4ProteinaLoraLoaderMixincung cấp các chức năng tương tự cho RFD4-Proteína.BriaFibo2LoraLoaderMixincung cấp các chức năng tương tự cho fibo-2.LoraBaseMixincung cấp một lớp cơ sở với một số phương tiện tiện ích để hợp nhất, tách, gỡ bỏ, LoRAs và nhiều hơn nữa.
Để tìm hiểu thêm về cách tải trọng số LoRA, hãy xem hướng dẫn tải LoRA.
RFD4ProteinaLoraLoaderMixin[[diffusers.loaders.RFD4ProteinaLoraLoaderMixin]]
diffusers.loaders.RFD4ProteinaLoraLoaderMixin[[diffusers.loaders.RFD4ProteinaLoraLoaderMixin]]
diffusers.loaders.RFD4ProteinaLoraLoaderMixin()
Nạp các lớp LoRA vào RFD4ProteinaTransformer.
Autoencoder được ghép nối với checkpoint của denoiser và không được điều chỉnh, do đó transformer là module duy nhất có thể tải được.
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)
Xem fuse_lora() để biết thêm chi tiết.
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)
Xem load_lora_into_unet() để biết thêm chi tiết.
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)
Xem load_lora_weights() để biết thêm chi tiết.
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)
Xem lora_state_dict() để biết thêm chi tiết.
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)
Xem save_lora_weights() để biết thêm thông tin.
unfuse_lora[[diffusers.loaders.RFD4ProteinaLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Xem unfuse_lora() để biết thêm chi tiết.
LoraBaseMixin[[diffusers.loaders.lora_base.LoraBaseMixin]]
diffusers.loaders.lora_base.LoraBaseMixin[[diffusers.loaders.lora_base.LoraBaseMixin]]
diffusers.loaders.lora_base.LoraBaseMixin()
Lớp tiện ích để xử lý LoRA.
delete_adapters[[diffusers.loaders.lora_base.LoraBaseMixin.delete_adapters]]
delete_adapters(adapter_names: list[str] | str)
Tham số:
adapter_names (list[str, str]) : Tên của các adapter cần xóa.
Xóa các lớp LoRA của adapter khỏi pipeline.
Ví dụ:
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()
Tắt các lớp LoRA đang hoạt động của pipeline.
Ví dụ:
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()
Bật các lớp LoRA đang hoạt động của pipeline.
Ví dụ:
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)
Tham số:
target_rank (int) : Bậc cao nhất trong số tất cả các adapter sẽ được nạp.
check_compiled (str, tùy chọn, mặc định là "error") : Cách xử lý một model đã được biên dịch. Việc kiểm tra có thể trả về các thông báo sau: - "error" (mặc định): ném ra một lỗi - "warn": phát ra một cảnh báo - "ignore": không làm gì
Nóng thay thế các adapter mà không kích hoạt việc biên dịch lại mô hình hoặc khi các bậc của các adapter được nạp khác nhau.
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)
Tham số:
components : (list[str]): danh sách các thành phần có thể tiêm LoRA để hợp nhất các LoRA vào.
lora_scale (float, mặc định là 1.0) : Kiểm soát mức độ ảnh hưởng của các tham số LoRA đến đầu ra.
safe_fusing (bool, mặc định là False) : Có kiểm tra các trọng số đã hợp nhất (fused) xem có chứa giá trị NaN trước khi hợp nhất hay không, và nếu giá trị là NaN thì không thực hiện hợp nhất.
adapter_names (list[str], tùy chọn) : Các tên adapter sẽ được sử dụng để hợp nhất. Nếu không truyền gì, tất cả các adapter đang hoạt động sẽ được hợp nhất.
Trộn các tham số LoRA vào các tham số gốc của các khối tương ứng.
Ví dụ:
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()
Lấy danh sách các adapter đang hoạt động hiện tại.
Ví dụ:
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()
Lấy danh sách hiện tại của tất cả các adapter khả dụng trong 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)
Tham số:
adapter_names (list[str] hoặc str) : Tên của các adapter cần sử dụng.
adapter_weights (float, dict hoặc list, tùy chọn) : Trọng số cho các adapter. Một giá trị vô hướng sẽ nhân lên tất cả các thành phần tương thích với LoRA. Một từ điển ánh xạ tên thành phần (ví dụ "unet", "transformer" hoặc "text_encoder") tới trọng số; trọng số của một thành phần UNet cũng có thể là một từ điển lồng nhau chứa các thang đo khối. Một giá trị vô hướng hoặc từ điển đơn lẻ được áp dụng cho mọi adapter. Một danh sách phải chứa một giá trị vô hướng, từ điển hoặc None cho mỗi adapter, theo thứ tự của adapter_names. None mặc định là 1.0, bao gồm cả các mục trong danh sách và trọng số của các thành phần. Các thành phần không được chỉ định và các khối UNet cũng mặc định là 1.0.
Đặt các adapter đang hoạt động hiện tại để sử dụng trong pipeline.
Ví dụ:
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)
Tham số:
adapter_names (list[str]) : danh sách các adapter để gửi thiết bị đến.
device (torch.device | str | int) : Thiết bị để gửi các adapter đến. Có thể là một thiết bị torch, một str hoặc một số nguyên.
Chuyển các LoRA được liệt kê trong adapter_names sang thiết bị đích. Hữu ích để offload LoRA sang CPU trong trường hợp bạn muốn nạp nhiều adapter và giải phóng một phần bộ nhớ GPU.
Sau khi offload các adapter LoRA sang CPU, miễn là phần còn lại của mô hình vẫn nằm trên GPU, các adapter LoRA sẽ không thể được sử dụng để suy luận (inference) nữa, vì điều đó sẽ gây ra sự không khớp về thiết bị (device mismatch). Hãy nhớ đặt lại thiết bị về GPU trước khi sử dụng các adapter LoRA đó để suy luận.
>>> 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)
Tham số:
components (list[str]) : danh sách các thành phần có thể tiêm LoRA để tách LoRA ra.
unfuse_unet (bool, mặc định là True) : Có nên tách các tham số LoRA của UNet hay không.
unfuse_text_encoder (bool, mặc định là True) : Xác định có tách các tham số LoRA của text encoder hay không. Nếu text encoder không được monkey-patch với các tham số LoRA thì sẽ không có tác dụng.
Đảo ngược tác dụng của pipe.fuse_lora().
unload_lora_weights[[diffusers.loaders.lora_base.LoraBaseMixin.unload_lora_weights]]
unload_lora_weights()
Gỡ bỏ các tham số LoRA.
Ví dụ:
>>> # 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)
Viết state dict của các lớp LoRA (tùy chọn kèm metadata) ra đĩa.
StableDiffusionLoraLoaderMixin[[diffusers.loaders.StableDiffusionLoraLoaderMixin]]
diffusers.loaders.StableDiffusionLoraLoaderMixin[[diffusers.loaders.StableDiffusionLoraLoaderMixin]]
diffusers.loaders.StableDiffusionLoraLoaderMixin()
Nạp các lớp LoRA vào UNet2DConditionModel và CLIPTextModel của 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)
Tham số:
state_dict (dict) : Một state dict chuẩn chứa các tham số của lớp lora. Khóa nên được thêm tiền tố text_encoder để phân biệt với các lớp lora của unet.
network_alphas (dict[str, float]) : Giá trị của network alpha được sử dụng cho việc học ổn định và ngăn ngừa underflow. Giá trị này có cùng ý nghĩa với tùy chọn --network_alpha trong script trainer của kohya-ss. Xem liên kết này.
text_encoder (CLIPTextModel) : Mô hình mã hóa văn bản để nạp các lớp LoRA vào.
prefix (str) : Tiền tố mong đợi của text_encoder trong state_dict.
lora_scale (float) : Mức độ nhân (scale) đầu ra của lớp tuyến tính lora trước khi nó được cộng với đầu ra của lớp lora thông thường.
adapter_name (str, tùy chọn) : Tên adapter sẽ được sử dụng để tham chiếu mô hình adapter đã tải. Nếu không được chỉ định, hệ thống sẽ sử dụng default_{i}, trong đó i là tổng số adapter đang được tải.
low_cpu_mem_usage (bool, tùy chọn) : Tăng tốc độ tải mô hình bằng cách chỉ tải trọng số LoRA được huấn luyện trước và không khởi tạo các trọng số ngẫu nhiên.
hotswap (bool, tùy chọn) : Xem load_lora_weights().
metadata (dict) : Metadata tùy chọn của bộ thích ứng LoRA. Khi được cung cấp, các đối số LoraConfig của peft sẽ không được suy ra từ state dict.
Điều này sẽ nạp các lớp LoRA được chỉ định trong state_dict vào 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)
Tham số:
state_dict (dict) : Một state dict chuẩn chứa các tham số của lớp lora. Các key có thể được chỉ định trực tiếp vào unet hoặc được thêm tiền tố unet để phân biệt với các lớp lora của text encoder.
network_alphas (dict[str, float]) : Giá trị của network alpha được sử dụng cho việc học ổn định và ngăn ngừa underflow. Giá trị này có cùng ý nghĩa với tùy chọn --network_alpha trong script trainer của kohya-ss. Xem liên kết này.
unet (UNet2DConditionModel) : Mô hình UNet để nạp các lớp LoRA vào.
adapter_name (str, tùy chọn) : Tên adapter sẽ được sử dụng để tham chiếu mô hình adapter đã tải. Nếu không được chỉ định, hệ thống sẽ sử dụng default_{i}, trong đó i là tổng số adapter đang được tải.
low_cpu_mem_usage (bool, tùy chọn) : Tăng tốc độ tải mô hình bằng cách chỉ tải trọng số LoRA được huấn luyện trước và không khởi tạo các trọng số ngẫu nhiên.
hotswap (bool, tùy chọn) : Xem load_lora_weights().
metadata (dict) : Metadata tùy chọn của bộ thích ứng LoRA. Khi được cung cấp, các đối số LoraConfig của peft sẽ không được suy ra từ state dict.
Điều này sẽ nạp các lớp LoRA được chỉ định trong state_dict vào 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)
Tham số:
pretrained_model_name_or_path_or_dict (str hoặc os.PathLike hoặc dict) : Xem lora_state_dict().
adapter_name (str, tùy chọn) : Tên adapter sẽ được sử dụng để tham chiếu mô hình adapter đã tải. Nếu không được chỉ định, hệ thống sẽ sử dụng default_{i}, trong đó i là tổng số adapter đang được tải.
low_cpu_mem_usage (bool, tùy chọn) : Tăng tốc độ tải mô hình bằng cách chỉ tải trọng số LoRA được huấn luyện trước và không khởi tạo các trọng số ngẫu nhiên.
hotswap (bool, tuỳ chọn) : Mặc định là False. Xác định có thay thế adapter (LoRA) hiện có bằng adapter mới được nạp tại chỗ hay không. Điều này có nghĩa là, thay vì nạp thêm một adapter, phương thức này sẽ lấy trọng số của adapter hiện có và thay thế chúng bằng trọng số của adapter mới. Cách này có thể nhanh hơn và tiết kiệm bộ nhớ hơn. Tuy nhiên, lợi ích chính của hotswapping là khi mô hình được biên dịch bằng torch.compile, việc nạp adapter mới không yêu cầu biên dịch lại mô hình. Khi sử dụng hotswapping, adapter_name được truyền vào phải là tên của một adapter đã được nạp. Nếu adapter mới và adapter cũ có rank và/hoặc LoRA alphas (tức là hệ số scale) khác nhau, bạn cần gọi thêm một phương thức trước khi nạp 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 Lưu ý rằng việc hotswap adapter của text encoder hiện chưa được hỗ trợ. Kỹ thuật này có một số hạn chế khác, được tài liệu hóa tại đây: https://huggingface.co/docs/peft/main/en/package_reference/hotswap
kwargs (dict, tùy chọn) : Xem lora_state_dict().
Tải trọng số LoRA được chỉ định trong pretrained_model_name_or_path_or_dict vào self.unet và self.text_encoder.
Tất cả các kwargs được chuyển tiếp đến self.lora_state_dict.
Xem lora_state_dict() để biết thêm chi tiết về cách nạp state dict.
Xem load_lora_into_unet() để biết thêm chi tiết về cách state dict được nạp vào self.unet.
Xem load_lora_into_text_encoder() để biết thêm chi tiết về cách state dict được nạp vào 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)
Tham số:
pretrained_model_name_or_path_or_dict (str hoặc os.PathLike hoặc dict) : Có thể là: - Một chuỗi, model id (ví dụ google/ddpm-celebahq-256) của một model được huấn luyện trước lưu trữ trên Hub. - Một đường dẫn đến thư mục (ví dụ ./my_model_directory) chứa các trọng số model được lưu bằng ModelMixin.save_pretrained(). - Một torch state dict.
cache_dir (str | os.PathLike, tùy chọn) : Đường dẫn đến thư mục nơi cấu hình mô hình được huấn luyện trước đã tải xuống được lưu đệm nếu không sử dụng bộ lưu đệm tiêu chuẩn.
force_download (bool, tùy chọn, mặc định là False) : Xác định có nên ép buộc tải lại (re-download) trọng số mô hình và các tệp cấu hình hay không, ghi đè lên các phiên bản đã được lưu trong bộ nhớ đệm nếu chúng tồn tại.
proxies (dict[str, str], tùy chọn) : Một từ điển các máy chủ proxy để sử dụng theo giao thức hoặc điểm cuối, ví dụ, {'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}. Các proxy được sử dụng cho mỗi yêu cầu.
local_files_only (bool, tùy chọn, mặc định là False) : Xác định xem có chỉ tải trọng số và tệp cấu hình của mô hình cục bộ hay không. Nếu đặt thành True, mô hình sẽ không được tải xuống từ Hub.
token (str hoặc bool, tùy chọn) : Token được sử dụng làm HTTP bearer authorization cho các tệp từ xa. Nếu là True, token được tạo từ diffusers-cli login (được lưu trong ~/.huggingface) sẽ được sử dụng.
revision (str, tùy chọn, mặc định là "main") : Phiên bản mô hình cụ thể cần sử dụng. Nó có thể là tên nhánh, tên thẻ, id commit, hoặc bất kỳ định danh nào được Git cho phép.
subfolder (str, tùy chọn, mặc định là "") : Vị trí của thư mục con chứa tệp mô hình bên trong một kho lưu trữ mô hình lớn hơn trên Hub hoặc cục bộ.
weight_name (str, tùy chọn, mặc định là None) : Tên của tệp state dict đã được serialize.
return_lora_metadata (bool, tùy chọn, mặc định là False) : Khi được bật, đồng thời trả về các siêu dữ liệu của bộ thích ứng LoRA, thường được tìm thấy trong state dict.
Trả về state dict cho trọng số lora và các alpha của mạng.
> Chúng tôi hỗ trợ nạp các checkpoint LoRA định dạng A1111 ở mức hạn chế. > > Hàm này thực nghiệm và có thể thay đổi trong tương lai.
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)
Tham số:
save_directory (str hoặc os.PathLike) : Thư mục để lưu các tham số LoRA. Thư mục sẽ được tạo nếu chưa tồn tại.
unet_lora_layers (dict[str, torch.nn.Module] hoặc dict[str, torch.Tensor]) : State dict của các lớp LoRA tương ứng với unet.
text_encoder_lora_layers (dict[str, torch.nn.Module] hoặc dict[str, torch.Tensor]) : State dict của các lớp LoRA tương ứng với text_encoder. Phải truyền rõ state dict LoRA của text encoder vì nó đến từ 🤗 Transformers.
is_main_process (bool, tùy chọn, mặc định là True) : Xác định xem tiến trình gọi hàm này có phải là tiến trình chính hay không. Hữu ích trong quá trình huấn luyện phân tán khi bạn cần gọi hàm này trên tất cả các tiến trình. Trong trường hợp này, chỉ đặt is_main_process=True trên tiến trình chính để tránh điều kiện đua.
save_function (Callable) : Hàm được sử dụng để lưu state dictionary. Hữu ích trong quá trình huấn luyện phân tán khi bạn cần thay thế torch.save bằng một phương pháp khác. Có thể được cấu hình bằng biến môi trường DIFFUSERS_SAVE_MODE.
safe_serialization (bool, tùy chọn, mặc định là True) : Có lưu mô hình bằng safetensors hay theo cách truyền thống của PyTorch với pickle hay không.
unet_lora_adapter_metadata : Metadata của adapter LoRA liên quan đến unet sẽ được serialize cùng với state dict.
text_encoder_lora_adapter_metadata : Metadata của adapter LoRA liên quan đến text encoder, sẽ được serialize cùng với state dict.
Lưu các tham số LoRA tương ứng với UNet và text encoder.
StableDiffusionXLLoraLoaderMixin[[diffusers.loaders.StableDiffusionXLLoraLoaderMixin]]
diffusers.loaders.StableDiffusionXLLoraLoaderMixin[[diffusers.loaders.StableDiffusionXLLoraLoaderMixin]]
diffusers.loaders.StableDiffusionXLLoraLoaderMixin()
Nạp các lớp LoRA vào UNet2DConditionModel, CLIPTextModel và CLIPTextModelWithProjection của 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)
Xem fuse_lora() để biết thêm chi tiết.
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)
Tham số:
state_dict (dict) : Một state dict chuẩn chứa các tham số của lớp lora. Khóa nên được thêm tiền tố text_encoder để phân biệt với các lớp lora của unet.
network_alphas (dict[str, float]) : Giá trị của network alpha được sử dụng cho việc học ổn định và ngăn ngừa underflow. Giá trị này có cùng ý nghĩa với tùy chọn --network_alpha trong script trainer của kohya-ss. Xem liên kết này.
text_encoder (CLIPTextModel) : Mô hình mã hóa văn bản để nạp các lớp LoRA vào.
prefix (str) : Tiền tố mong đợi của text_encoder trong state_dict.
lora_scale (float) : Mức độ nhân (scale) đầu ra của lớp tuyến tính lora trước khi nó được cộng với đầu ra của lớp lora thông thường.
adapter_name (str, tùy chọn) : Tên adapter sẽ được sử dụng để tham chiếu mô hình adapter đã tải. Nếu không được chỉ định, hệ thống sẽ sử dụng default_{i}, trong đó i là tổng số adapter đang được tải.
low_cpu_mem_usage (bool, tùy chọn) : Tăng tốc độ tải mô hình bằng cách chỉ tải trọng số LoRA được huấn luyện trước và không khởi tạo các trọng số ngẫu nhiên.
hotswap (bool, tùy chọn) : Xem load_lora_weights().
metadata (dict) : Metadata tùy chọn của bộ thích ứng LoRA. Khi được cung cấp, các đối số LoraConfig của peft sẽ không được suy ra từ state dict.
Điều này sẽ nạp các lớp LoRA được chỉ định trong state_dict vào 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)
Tham số:
state_dict (dict) : Một state dict chuẩn chứa các tham số của lớp lora. Các key có thể được chỉ định trực tiếp vào unet hoặc được thêm tiền tố unet để phân biệt với các lớp lora của text encoder.
network_alphas (dict[str, float]) : Giá trị của network alpha được sử dụng cho việc học ổn định và ngăn ngừa underflow. Giá trị này có cùng ý nghĩa với tùy chọn --network_alpha trong script trainer của kohya-ss. Xem liên kết này.
unet (UNet2DConditionModel) : Mô hình UNet để nạp các lớp LoRA vào.
adapter_name (str, tùy chọn) : Tên adapter sẽ được sử dụng để tham chiếu mô hình adapter đã tải. Nếu không được chỉ định, hệ thống sẽ sử dụng default_{i}, trong đó i là tổng số adapter đang được tải.
low_cpu_mem_usage (bool, tùy chọn) : Tăng tốc độ tải mô hình bằng cách chỉ tải trọng số LoRA được huấn luyện trước và không khởi tạo các trọng số ngẫu nhiên.
hotswap (bool, tùy chọn) : Xem load_lora_weights().
metadata (dict) : Metadata tùy chọn của bộ thích ứng LoRA. Khi được cung cấp, các đối số LoraConfig của peft sẽ không được suy ra từ state dict.
Điều này sẽ nạp các lớp LoRA được chỉ định trong state_dict vào 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)
Xem load_lora_weights() để biết thêm chi tiết.
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)
Tham số:
pretrained_model_name_or_path_or_dict (str hoặc os.PathLike hoặc dict) : Có thể là: - Một chuỗi, model id (ví dụ google/ddpm-celebahq-256) của một model được huấn luyện trước lưu trữ trên Hub. - Một đường dẫn đến thư mục (ví dụ ./my_model_directory) chứa các trọng số model được lưu bằng ModelMixin.save_pretrained(). - Một torch state dict.
cache_dir (str | os.PathLike, tùy chọn) : Đường dẫn đến thư mục nơi cấu hình mô hình được huấn luyện trước đã tải xuống được lưu đệm nếu không sử dụng bộ lưu đệm tiêu chuẩn.
force_download (bool, tùy chọn, mặc định là False) : Xác định có nên ép buộc tải lại (re-download) trọng số mô hình và các tệp cấu hình hay không, ghi đè lên các phiên bản đã được lưu trong bộ nhớ đệm nếu chúng tồn tại.
proxies (dict[str, str], tùy chọn) : Một từ điển các máy chủ proxy để sử dụng theo giao thức hoặc điểm cuối, ví dụ, {'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}. Các proxy được sử dụng cho mỗi yêu cầu.
local_files_only (bool, tùy chọn, mặc định là False) : Xác định xem có chỉ tải trọng số và tệp cấu hình của mô hình cục bộ hay không. Nếu đặt thành True, mô hình sẽ không được tải xuống từ Hub.
token (str hoặc bool, tùy chọn) : Token được sử dụng làm HTTP bearer authorization cho các tệp từ xa. Nếu là True, token được tạo từ diffusers-cli login (được lưu trong ~/.huggingface) sẽ được sử dụng.
revision (str, tùy chọn, mặc định là "main") : Phiên bản mô hình cụ thể cần sử dụng. Nó có thể là tên nhánh, tên thẻ, id commit, hoặc bất kỳ định danh nào được Git cho phép.
subfolder (str, tùy chọn, mặc định là "") : Vị trí của thư mục con chứa tệp mô hình bên trong một kho lưu trữ mô hình lớn hơn trên Hub hoặc cục bộ.
weight_name (str, tùy chọn, mặc định là None) : Tên của tệp state dict đã được serialize.
return_lora_metadata (bool, tùy chọn, mặc định là False) : Khi được bật, đồng thời trả về các siêu dữ liệu của bộ thích ứng LoRA, thường được tìm thấy trong state dict.
Trả về state dict cho trọng số lora và các alpha của mạng.
> Chúng tôi hỗ trợ nạp các checkpoint LoRA định dạng A1111 ở mức hạn chế. > > Hàm này thực nghiệm và có thể thay đổi trong tương lai.
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)
Xem save_lora_weights() để biết thêm thông tin.
unfuse_lora[[diffusers.loaders.StableDiffusionXLLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['unet', 'text_encoder', 'text_encoder_2'], **kwargs)
Xem unfuse_lora() để biết thêm chi tiết.
SD3LoraLoaderMixin[[diffusers.loaders.SD3LoraLoaderMixin]]
diffusers.loaders.SD3LoraLoaderMixin[[diffusers.loaders.SD3LoraLoaderMixin]]
diffusers.loaders.SD3LoraLoaderMixin()
Tải các lớp LoRA vào SD3Transformer2DModel, CLIPTextModel và CLIPTextModelWithProjection.
Đặc thù cho 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)
Xem fuse_lora() để biết thêm chi tiết.
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)
Tham số:
state_dict (dict) : Một state dict chuẩn chứa các tham số của lớp lora. Khóa nên được thêm tiền tố text_encoder để phân biệt với các lớp lora của unet.
network_alphas (dict[str, float]) : Giá trị của network alpha được sử dụng cho việc học ổn định và ngăn ngừa underflow. Giá trị này có cùng ý nghĩa với tùy chọn --network_alpha trong script trainer của kohya-ss. Xem liên kết này.
text_encoder (CLIPTextModel) : Mô hình mã hóa văn bản để nạp các lớp LoRA vào.
prefix (str) : Tiền tố mong đợi của text_encoder trong state_dict.
lora_scale (float) : Mức độ nhân (scale) đầu ra của lớp tuyến tính lora trước khi nó được cộng với đầu ra của lớp lora thông thường.
adapter_name (str, tùy chọn) : Tên adapter sẽ được sử dụng để tham chiếu mô hình adapter đã tải. Nếu không được chỉ định, hệ thống sẽ sử dụng default_{i}, trong đó i là tổng số adapter đang được tải.
low_cpu_mem_usage (bool, tùy chọn) : Tăng tốc độ tải mô hình bằng cách chỉ tải trọng số LoRA được huấn luyện trước và không khởi tạo các trọng số ngẫu nhiên.
hotswap (bool, tùy chọn) : Xem load_lora_weights().
metadata (dict) : Metadata tùy chọn của bộ thích ứng LoRA. Khi được cung cấp, các đối số LoraConfig của peft sẽ không được suy ra từ state dict.
Điều này sẽ nạp các lớp LoRA được chỉ định trong state_dict vào 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)
Xem load_lora_into_unet() để biết thêm chi tiết.
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)
Xem load_lora_weights() để biết thêm chi tiết.
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)
Xem lora_state_dict() để biết thêm chi tiết.
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)
Xem save_lora_weights() để biết thêm thông tin.
unfuse_lora[[diffusers.loaders.SD3LoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer', 'text_encoder', 'text_encoder_2'], **kwargs)
Xem unfuse_lora() để biết thêm chi tiết.
FluxLoraLoaderMixin[[diffusers.loaders.FluxLoraLoaderMixin]]
diffusers.loaders.FluxLoraLoaderMixin[[diffusers.loaders.FluxLoraLoaderMixin]]
diffusers.loaders.FluxLoraLoaderMixin()
Nạp các lớp LoRA vào FluxTransformer2DModel, CLIPTextModel.
Đặc thù của 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)
Xem lora_state_dict() để biết thêm chi tiết.
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)
Tham số:
state_dict (dict) : Một state dict chuẩn chứa các tham số của lớp lora. Khóa nên được thêm tiền tố text_encoder để phân biệt với các lớp lora của unet.
network_alphas (dict[str, float]) : Giá trị của network alpha được sử dụng cho việc học ổn định và ngăn ngừa underflow. Giá trị này có cùng ý nghĩa với tùy chọn --network_alpha trong script trainer của kohya-ss. Xem liên kết này.
text_encoder (CLIPTextModel) : Mô hình mã hóa văn bản để nạp các lớp LoRA vào.
prefix (str) : Tiền tố mong đợi của text_encoder trong state_dict.
lora_scale (float) : Mức độ nhân (scale) đầu ra của lớp tuyến tính lora trước khi nó được cộng với đầu ra của lớp lora thông thường.
adapter_name (str, tùy chọn) : Tên adapter sẽ được sử dụng để tham chiếu mô hình adapter đã tải. Nếu không được chỉ định, hệ thống sẽ sử dụng default_{i}, trong đó i là tổng số adapter đang được tải.
low_cpu_mem_usage (bool, tùy chọn) : Tăng tốc độ tải mô hình bằng cách chỉ tải trọng số LoRA được huấn luyện trước và không khởi tạo các trọng số ngẫu nhiên.
hotswap (bool, tùy chọn) : Xem load_lora_weights().
metadata (dict) : Metadata tùy chọn của bộ thích ứng LoRA. Khi được cung cấp, các đối số LoraConfig của peft sẽ không được suy ra từ state dict.
Điều này sẽ nạp các lớp LoRA được chỉ định trong state_dict vào 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)
Xem load_lora_into_unet() để biết thêm chi tiết.
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)
Xem load_lora_weights() để biết thêm chi tiết.
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)
Xem lora_state_dict() để biết thêm chi tiết.
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)
Tham số:
save_directory (str hoặc os.PathLike) : Thư mục để lưu các tham số LoRA. Thư mục sẽ được tạo nếu chưa tồn tại.
transformer_lora_layers (dict[str, torch.nn.Module] hoặc dict[str, torch.Tensor]) : State dict của các lớp LoRA tương ứng với transformer.
text_encoder_lora_layers (dict[str, torch.nn.Module] hoặc dict[str, torch.Tensor]) : State dict của các lớp LoRA tương ứng với text_encoder. Phải truyền rõ state dict LoRA của text encoder vì nó đến từ 🤗 Transformers.
is_main_process (bool, tùy chọn, mặc định là True) : Xác định xem tiến trình gọi hàm này có phải là tiến trình chính hay không. Hữu ích trong quá trình huấn luyện phân tán khi bạn cần gọi hàm này trên tất cả các tiến trình. Trong trường hợp này, chỉ đặt is_main_process=True trên tiến trình chính để tránh điều kiện đua.
save_function (Callable) : Hàm được sử dụng để lưu state dictionary. Hữu ích trong quá trình huấn luyện phân tán khi bạn cần thay thế torch.save bằng một phương pháp khác. Có thể được cấu hình bằng biến môi trường DIFFUSERS_SAVE_MODE.
safe_serialization (bool, tùy chọn, mặc định là True) : Có lưu mô hình bằng safetensors hay theo cách truyền thống của PyTorch với pickle hay không.
transformer_lora_adapter_metadata : Metadata của adapter LoRA liên quan đến transformer, sẽ được serialize cùng với state dict.
text_encoder_lora_adapter_metadata : Metadata của adapter LoRA liên quan đến text encoder, sẽ được serialize cùng với state dict.
Lưu các tham số LoRA tương ứng với UNet và text encoder.
unfuse_lora[[diffusers.loaders.FluxLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer', 'text_encoder'], **kwargs)
Tham số:
components (list[str]) : danh sách các thành phần có thể tiêm LoRA để tách LoRA ra.
Đảo ngược tác dụng của pipe.fuse_lora().
unload_lora_weights[[diffusers.loaders.FluxLoraLoaderMixin.unload_lora_weights]]
unload_lora_weights(reset_to_overwritten_params = False)
Tham số:
reset_to_overwritten_params (bool, mặc định là False) : Xác định có đặt lại các module đã nạp LoRA về tham số gốc hay không. Tham khảo tài liệu Flux để biết thêm.
Gỡ bỏ các tham số LoRA.
Ví dụ:
>>> # 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()
Tải các lớp LoRA vào Flux2Transformer2DModel. Cụ thể cho 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)
Xem fuse_lora() để biết thêm chi tiết.
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)
Xem load_lora_into_unet() để biết thêm chi tiết.
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)
Xem load_lora_weights() để biết thêm chi tiết.
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)
Xem lora_state_dict() để biết thêm chi tiết.
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)
Xem save_lora_weights() để biết thêm thông tin.
unfuse_lora[[diffusers.loaders.Flux2LoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Xem unfuse_lora() để biết thêm chi tiết.
Flux3LoraLoaderMixin[[diffusers.loaders.Flux3LoraLoaderMixin]]
diffusers.loaders.Flux3LoraLoaderMixin[[diffusers.loaders.Flux3LoraLoaderMixin]]
diffusers.loaders.Flux3LoraLoaderMixin()
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)
Xem fuse_lora() để biết thêm chi tiết.
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)
Xem load_lora_into_unet() để biết thêm chi tiết.
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)
Xem load_lora_weights() để biết thêm chi tiết.
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)
Xem save_lora_weights() để biết thêm thông tin.
unfuse_lora[[diffusers.loaders.Flux3LoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Xem unfuse_lora() để biết thêm chi tiết.
BriaFibo2LoraLoaderMixin[[diffusers.loaders.BriaFibo2LoraLoaderMixin]]
diffusers.loaders.BriaFibo2LoraLoaderMixin[[diffusers.loaders.BriaFibo2LoraLoaderMixin]]
diffusers.loaders.BriaFibo2LoraLoaderMixin()
Nạp các lớp LoRA vào BriaFibo2Transformer2DModel. Cụ thể cho 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)
Xem fuse_lora() để biết thêm chi tiết.
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)
Xem load_lora_into_unet() để biết thêm chi tiết.
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)
Xem load_lora_weights() để biết thêm chi tiết.
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)
Xem lora_state_dict() để biết thêm chi tiết.
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)
Xem save_lora_weights() để biết thêm thông tin.
unfuse_lora[[diffusers.loaders.BriaFibo2LoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Xem unfuse_lora() để biết thêm chi tiết.
ErnieImageLoraLoaderMixin[[diffusers.loaders.ErnieImageLoraLoaderMixin]]
diffusers.loaders.ErnieImageLoraLoaderMixin[[diffusers.loaders.ErnieImageLoraLoaderMixin]]
diffusers.loaders.ErnieImageLoraLoaderMixin()
Tải các lớp LoRA vào ErnieImageTransformer2DModel. Cụ thể cho 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)
Xem fuse_lora() để biết thêm chi tiết.
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)
Xem load_lora_into_unet() để biết thêm chi tiết.
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)
Xem load_lora_weights() để biết thêm chi tiết.
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)
Xem lora_state_dict() để biết thêm chi tiết.
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)
Xem save_lora_weights() để biết thêm thông tin.
unfuse_lora[[diffusers.loaders.ErnieImageLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Xem unfuse_lora() để biết thêm chi tiết.
LTX2LoraLoaderMixin[[diffusers.loaders.LTX2LoraLoaderMixin]]
diffusers.loaders.LTX2LoraLoaderMixin[[diffusers.loaders.LTX2LoraLoaderMixin]]
diffusers.loaders.LTX2LoraLoaderMixin()
Nạp các lớp LoRA vào LTX2VideoTransformer3DModel. Cụ thể cho 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)
Xem fuse_lora() để biết thêm chi tiết.
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')
Xem load_lora_into_unet() để biết thêm chi tiết.
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)
Xem load_lora_weights() để biết thêm chi tiết.
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)
Xem lora_state_dict() để biết thêm chi tiết.
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)
Xem save_lora_weights() để biết thêm thông tin.
unfuse_lora[[diffusers.loaders.LTX2LoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Xem unfuse_lora() để biết thêm chi tiết.
CogVideoXLoraLoaderMixin[[diffusers.loaders.CogVideoXLoraLoaderMixin]]
diffusers.loaders.CogVideoXLoraLoaderMixin[[diffusers.loaders.CogVideoXLoraLoaderMixin]]
diffusers.loaders.CogVideoXLoraLoaderMixin()
Nạp các lớp LoRA vào CogVideoXTransformer3DModel. Cụ thể cho 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)
Xem fuse_lora() để biết thêm chi tiết.
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)
Xem load_lora_into_unet() để biết thêm chi tiết.
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)
Xem load_lora_weights() để biết thêm chi tiết.
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)
Xem lora_state_dict() để biết thêm chi tiết.
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)
Xem save_lora_weights() để biết thêm thông tin.
unfuse_lora[[diffusers.loaders.CogVideoXLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Xem unfuse_lora() để biết thêm chi tiết.
Mochi1LoraLoaderMixin[[diffusers.loaders.Mochi1LoraLoaderMixin]]
diffusers.loaders.Mochi1LoraLoaderMixin[[diffusers.loaders.Mochi1LoraLoaderMixin]]
diffusers.loaders.Mochi1LoraLoaderMixin()
Nạp các lớp LoRA vào MochiTransformer3DModel. Cụ thể cho 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)
Xem fuse_lora() để biết thêm chi tiết.
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)
Xem load_lora_into_unet() để biết thêm chi tiết.
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)
Xem load_lora_weights() để biết thêm chi tiết.
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)
Xem lora_state_dict() để biết thêm chi tiết.
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)
Xem save_lora_weights() để biết thêm thông tin.
unfuse_lora[[diffusers.loaders.Mochi1LoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Xem unfuse_lora() để biết thêm chi tiết.
AuraFlowLoraLoaderMixin[[diffusers.loaders.AuraFlowLoraLoaderMixin]]
diffusers.loaders.AuraFlowLoraLoaderMixin[[diffusers.loaders.AuraFlowLoraLoaderMixin]]
diffusers.loaders.AuraFlowLoraLoaderMixin()
Nạp các lớp LoRA vào AuraFlowTransformer2DModel Cụ thể cho 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)
Xem fuse_lora() để biết thêm chi tiết.
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)
Xem load_lora_into_unet() để biết thêm chi tiết.
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)
Xem load_lora_weights() để biết thêm chi tiết.
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)
Xem lora_state_dict() để biết thêm chi tiết.
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)
Xem save_lora_weights() để biết thêm thông tin.
unfuse_lora[[diffusers.loaders.AuraFlowLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer', 'text_encoder'], **kwargs)
Xem unfuse_lora() để biết thêm chi tiết.
LTXVideoLoraLoaderMixin[[diffusers.loaders.LTXVideoLoraLoaderMixin]]
diffusers.loaders.LTXVideoLoraLoaderMixin[[diffusers.loaders.LTXVideoLoraLoaderMixin]]
diffusers.loaders.LTXVideoLoraLoaderMixin()
Nạp các lớp LoRA vào LTXVideoTransformer3DModel. Cụ thể cho 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)
Xem fuse_lora() để biết thêm chi tiết.
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)
Xem load_lora_into_unet() để biết thêm chi tiết.
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)
Xem load_lora_weights() để biết thêm chi tiết.
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)
Xem lora_state_dict() để biết thêm chi tiết.
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)
Xem save_lora_weights() để biết thêm thông tin.
unfuse_lora[[diffusers.loaders.LTXVideoLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Xem unfuse_lora() để biết thêm chi tiết.
SanaLoraLoaderMixin[[diffusers.loaders.SanaLoraLoaderMixin]]
diffusers.loaders.SanaLoraLoaderMixin[[diffusers.loaders.SanaLoraLoaderMixin]]
diffusers.loaders.SanaLoraLoaderMixin()
Nạp các lớp LoRA vào SanaTransformer2DModel. Cụ thể cho 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)
Xem fuse_lora() để biết thêm chi tiết.
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)
Xem load_lora_into_unet() để biết thêm chi tiết.
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)
Xem load_lora_weights() để biết thêm chi tiết.
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)
Xem lora_state_dict() để biết thêm chi tiết.
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)
Xem save_lora_weights() để biết thêm thông tin.
unfuse_lora[[diffusers.loaders.SanaLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Xem unfuse_lora() để biết thêm chi tiết.
HeliosLoraLoaderMixin[[diffusers.loaders.HeliosLoraLoaderMixin]]
diffusers.loaders.HeliosLoraLoaderMixin[[diffusers.loaders.HeliosLoraLoaderMixin]]
diffusers.loaders.HeliosLoraLoaderMixin()
Nạp các lớp LoRA vào HeliosTransformer3DModel. Cụ thể cho HeliosPipeline và 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)
Xem fuse_lora() để biết thêm chi tiết.
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)
Xem load_lora_into_unet() để biết thêm chi tiết.
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)
Xem load_lora_weights() để biết thêm chi tiết.
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)
Xem lora_state_dict() để biết thêm chi tiết.
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)
Xem save_lora_weights() để biết thêm thông tin.
unfuse_lora[[diffusers.loaders.HeliosLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Xem unfuse_lora() để biết thêm chi tiết.
HunyuanVideoLoraLoaderMixin[[diffusers.loaders.HunyuanVideoLoraLoaderMixin]]
diffusers.loaders.HunyuanVideoLoraLoaderMixin[[diffusers.loaders.HunyuanVideoLoraLoaderMixin]]
diffusers.loaders.HunyuanVideoLoraLoaderMixin()
Nạp các lớp LoRA vào HunyuanVideoTransformer3DModel. Cụ thể cho 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)
Xem fuse_lora() để biết thêm chi tiết.
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)
Xem load_lora_into_unet() để biết thêm chi tiết.
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)
Xem load_lora_weights() để biết thêm chi tiết.
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)
Xem lora_state_dict() để biết thêm chi tiết.
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)
Xem save_lora_weights() để biết thêm thông tin.
unfuse_lora[[diffusers.loaders.HunyuanVideoLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Xem unfuse_lora() để biết thêm chi tiết.
Lumina2LoraLoaderMixin[[diffusers.loaders.Lumina2LoraLoaderMixin]]
diffusers.loaders.Lumina2LoraLoaderMixin[[diffusers.loaders.Lumina2LoraLoaderMixin]]
diffusers.loaders.Lumina2LoraLoaderMixin()
Nạp các lớp LoRA vào Lumina2Transformer2DModel. Cụ thể cho 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)
Xem fuse_lora() để biết thêm chi tiết.
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)
Xem load_lora_into_unet() để biết thêm chi tiết.
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)
Xem load_lora_weights() để biết thêm chi tiết.
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)
Xem lora_state_dict() để biết thêm chi tiết.
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)
Xem save_lora_weights() để biết thêm thông tin.
unfuse_lora[[diffusers.loaders.Lumina2LoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Xem unfuse_lora() để biết thêm chi tiết.
CogView4LoraLoaderMixin[[diffusers.loaders.CogView4LoraLoaderMixin]]
diffusers.loaders.CogView4LoraLoaderMixin[[diffusers.loaders.CogView4LoraLoaderMixin]]
diffusers.loaders.CogView4LoraLoaderMixin()
Nạp các lớp LoRA vào WanTransformer3DModel. Cụ thể cho 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)
Xem fuse_lora() để biết thêm chi tiết.
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)
Xem load_lora_into_unet() để biết thêm chi tiết.
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)
Xem load_lora_weights() để biết thêm chi tiết.
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)
Xem lora_state_dict() để biết thêm chi tiết.
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)
Xem save_lora_weights() để biết thêm thông tin.
unfuse_lora[[diffusers.loaders.CogView4LoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Xem unfuse_lora() để biết thêm chi tiết.
WanLoraLoaderMixin[[diffusers.loaders.WanLoraLoaderMixin]]
diffusers.loaders.WanLoraLoaderMixin[[diffusers.loaders.WanLoraLoaderMixin]]
diffusers.loaders.WanLoraLoaderMixin()
Nạp các lớp LoRA vào WanTransformer3DModel. Cụ thể cho WanPipeline và [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)
Xem fuse_lora() để biết thêm chi tiết.
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)
Xem load_lora_into_unet() để biết thêm chi tiết.
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)
Xem load_lora_weights() để biết thêm chi tiết.
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)
Xem lora_state_dict() để biết thêm chi tiết.
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)
Xem save_lora_weights() để biết thêm thông tin.
unfuse_lora[[diffusers.loaders.WanLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Xem unfuse_lora() để biết thêm chi tiết.
SkyReelsV2LoraLoaderMixin[[diffusers.loaders.SkyReelsV2LoraLoaderMixin]]
diffusers.loaders.SkyReelsV2LoraLoaderMixin[[diffusers.loaders.SkyReelsV2LoraLoaderMixin]]
diffusers.loaders.SkyReelsV2LoraLoaderMixin()
Nạp các lớp LoRA vào 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)
Xem fuse_lora() để biết thêm chi tiết.
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)
Xem load_lora_into_unet() để biết thêm chi tiết.
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)
Xem load_lora_weights() để biết thêm chi tiết.
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)
Xem lora_state_dict() để biết thêm chi tiết.
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)
Xem save_lora_weights() để biết thêm thông tin.
unfuse_lora[[diffusers.loaders.SkyReelsV2LoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Xem unfuse_lora() để biết thêm chi tiết.
AmusedLoraLoaderMixin[[diffusers.loaders.AmusedLoraLoaderMixin]]
diffusers.loaders.AmusedLoraLoaderMixin[[diffusers.loaders.AmusedLoraLoaderMixin]]
diffusers.loaders.AmusedLoraLoaderMixin()
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)
Xem load_lora_into_unet() để biết thêm chi tiết.
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)
Tham số:
save_directory (str hoặc os.PathLike) : Thư mục để lưu các tham số LoRA. Thư mục sẽ được tạo nếu chưa tồn tại.
unet_lora_layers (dict[str, torch.nn.Module] hoặc dict[str, torch.Tensor]) : State dict của các lớp LoRA tương ứng với unet.
text_encoder_lora_layers (dict[str, torch.nn.Module] hoặc dict[str, torch.Tensor]) : State dict của các lớp LoRA tương ứng với text_encoder. Phải truyền rõ state dict LoRA của text encoder vì nó đến từ 🤗 Transformers.
is_main_process (bool, tùy chọn, mặc định là True) : Xác định xem tiến trình gọi hàm này có phải là tiến trình chính hay không. Hữu ích trong quá trình huấn luyện phân tán khi bạn cần gọi hàm này trên tất cả các tiến trình. Trong trường hợp này, chỉ đặt is_main_process=True trên tiến trình chính để tránh điều kiện đua.
save_function (Callable) : Hàm được sử dụng để lưu state dictionary. Hữu ích trong quá trình huấn luyện phân tán khi bạn cần thay thế torch.save bằng một phương pháp khác. Có thể được cấu hình bằng biến môi trường DIFFUSERS_SAVE_MODE.
safe_serialization (bool, tùy chọn, mặc định là True) : Có lưu mô hình bằng safetensors hay theo cách truyền thống của PyTorch với pickle hay không.
Lưu các tham số LoRA tương ứng với UNet và text encoder.
AnimaLoraLoaderMixin[[diffusers.loaders.AnimaLoraLoaderMixin]]
diffusers.loaders.AnimaLoraLoaderMixin[[diffusers.loaders.AnimaLoraLoaderMixin]]
diffusers.loaders.AnimaLoraLoaderMixin()
Nạp các lớp LoRA vào CosmosTransformer3DModel và 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)
Xem fuse_lora() để biết thêm chi tiết.
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)
Xem load_lora_weights() để biết thêm chi tiết.
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)
Xem lora_state_dict() để biết thêm chi tiết.
unfuse_lora[[diffusers.loaders.AnimaLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer', 'text_conditioner'], **kwargs)
Xem unfuse_lora() để biết thêm chi tiết.
AceStepLoraLoaderMixin[[diffusers.loaders.AceStepLoraLoaderMixin]]
diffusers.loaders.AceStepLoraLoaderMixin[[diffusers.loaders.AceStepLoraLoaderMixin]]
diffusers.loaders.AceStepLoraLoaderMixin()
Nạp các lớp LoRA vào AceStepTransformer1DModel. Cụ thể cho 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)
Xem fuse_lora() để biết thêm chi tiết.
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)
Xem load_lora_into_unet() để biết thêm chi tiết.
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)
Xem load_lora_weights() để biết thêm chi tiết.
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)
Xem lora_state_dict() để biết thêm chi tiết.
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)
Xem save_lora_weights() để biết thêm thông tin.
unfuse_lora[[diffusers.loaders.AceStepLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Xem unfuse_lora() để biết thêm chi tiết.
HiDreamImageLoraLoaderMixin[[diffusers.loaders.HiDreamImageLoraLoaderMixin]]
diffusers.loaders.HiDreamImageLoraLoaderMixin[[diffusers.loaders.HiDreamImageLoraLoaderMixin]]
diffusers.loaders.HiDreamImageLoraLoaderMixin()
Nạp các lớp LoRA vào HiDreamImageTransformer2DModel. Cụ thể cho 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)
Xem fuse_lora() để biết thêm chi tiết.
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)
Xem load_lora_into_unet() để biết thêm chi tiết.
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)
Xem load_lora_weights() để biết thêm chi tiết.
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)
Xem lora_state_dict() để biết thêm chi tiết.
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)
Xem save_lora_weights() để biết thêm thông tin.
unfuse_lora[[diffusers.loaders.HiDreamImageLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Xem unfuse_lora() để biết thêm chi tiết.
QwenImageLoraLoaderMixin[[diffusers.loaders.QwenImageLoraLoaderMixin]]
diffusers.loaders.QwenImageLoraLoaderMixin[[diffusers.loaders.QwenImageLoraLoaderMixin]]
diffusers.loaders.QwenImageLoraLoaderMixin()
Nạp các lớp LoRA vào QwenImageTransformer2DModel. Cụ thể cho 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)
Xem fuse_lora() để biết thêm chi tiết.
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)
Xem load_lora_into_unet() để biết thêm chi tiết.
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)
Xem load_lora_weights() để biết thêm chi tiết.
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)
Xem lora_state_dict() để biết thêm chi tiết.
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)
Xem save_lora_weights() để biết thêm thông tin.
unfuse_lora[[diffusers.loaders.QwenImageLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Xem unfuse_lora() để biết thêm chi tiết.
ZImageLoraLoaderMixin[[diffusers.loaders.ZImageLoraLoaderMixin]]
diffusers.loaders.ZImageLoraLoaderMixin[[diffusers.loaders.ZImageLoraLoaderMixin]]
diffusers.loaders.ZImageLoraLoaderMixin()
Nạp các lớp LoRA vào ZImageTransformer2DModel. Cụ thể cho 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)
Xem fuse_lora() để biết thêm chi tiết.
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)
Xem load_lora_into_unet() để biết thêm chi tiết.
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)
Xem load_lora_weights() để biết thêm chi tiết.
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)
Xem lora_state_dict() để biết thêm chi tiết.
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)
Xem save_lora_weights() để biết thêm thông tin.
unfuse_lora[[diffusers.loaders.ZImageLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Xem unfuse_lora() để biết thêm chi tiết.
CosmosLoraLoaderMixin[[diffusers.loaders.CosmosLoraLoaderMixin]]
diffusers.loaders.CosmosLoraLoaderMixin[[diffusers.loaders.CosmosLoraLoaderMixin]]
diffusers.loaders.CosmosLoraLoaderMixin()
Nạp các lớp LoRA vào CosmosTransformer3DModel, dành riêng cho 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)
Xem fuse_lora() để biết thêm chi tiết.
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)
Xem load_lora_into_unet() để biết thêm chi tiết.
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)
Xem load_lora_weights() để biết thêm chi tiết.
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)
Xem lora_state_dict() để biết thêm chi tiết.
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)
Xem save_lora_weights() để biết thêm thông tin.
unfuse_lora[[diffusers.loaders.CosmosLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Xem unfuse_lora() để biết thêm chi tiết.
KandinskyLoraLoaderMixin[[diffusers.loaders.KandinskyLoraLoaderMixin]]
diffusers.loaders.KandinskyLoraLoaderMixin[[diffusers.loaders.KandinskyLoraLoaderMixin]]
diffusers.loaders.KandinskyLoraLoaderMixin()
Nạp các lớp LoRA vào 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)
Xem fuse_lora() để biết thêm chi tiết.
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)
Xem load_lora_into_unet() để biết thêm chi tiết.
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)
Xem load_lora_weights() để biết thêm chi tiết.
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)
Xem lora_state_dict() để biết thêm chi tiết.
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)
Xem save_lora_weights() để biết thêm thông tin.
unfuse_lora[[diffusers.loaders.KandinskyLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Xem unfuse_lora() để biết thêm chi tiết.
Ideogram4LoraLoaderMixin[[diffusers.loaders.Ideogram4LoraLoaderMixin]]
diffusers.loaders.Ideogram4LoraLoaderMixin[[diffusers.loaders.Ideogram4LoraLoaderMixin]]
diffusers.loaders.Ideogram4LoraLoaderMixin()
Nạp các lớp LoRA vào Ideogram4Transformer2DModel. Cụ thể cho 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)
Xem fuse_lora() để biết thêm chi tiết.
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)
Xem load_lora_into_unet() để biết thêm chi tiết.
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)
Xem load_lora_weights() để biết thêm chi tiết.
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)
Xem lora_state_dict() để biết thêm chi tiết.
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)
Xem save_lora_weights() để biết thêm thông tin.
unfuse_lora[[diffusers.loaders.Ideogram4LoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Xem unfuse_lora() để biết thêm chi tiết.
Krea2LoraLoaderMixin[[diffusers.loaders.Krea2LoraLoaderMixin]]
diffusers.loaders.Krea2LoraLoaderMixin[[diffusers.loaders.Krea2LoraLoaderMixin]]
diffusers.loaders.Krea2LoraLoaderMixin()
Nạp các lớp LoRA vào Krea2Transformer2DModel. Cụ thể cho 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)
Xem fuse_lora() để biết thêm chi tiết.
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)
Xem load_lora_into_unet() để biết thêm chi tiết.
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)
Xem load_lora_weights() để biết thêm chi tiết.
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)
Xem lora_state_dict() để biết thêm chi tiết.
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)
Xem save_lora_weights() để biết thêm thông tin.
unfuse_lora[[diffusers.loaders.Krea2LoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Xem unfuse_lora() để biết thêm chi tiết.
MiniMaxH3LoraLoaderMixin[[diffusers.loaders.MiniMaxH3LoraLoaderMixin]]
diffusers.loaders.MiniMaxH3LoraLoaderMixin[[diffusers.loaders.MiniMaxH3LoraLoaderMixin]]
diffusers.loaders.MiniMaxH3LoraLoaderMixin()
Tải các lớp LoRA vào MiniMaxH3Transformer3DModel. Cụ thể cho MiniMaxH3ModularPipeline.
MiniMax-H3 có hai phân vùng DiT độc lập với tên module giống hệt nhau (một LoRA dành cho phân vùng này sẽ được nạp vào phân vùng kia và làm giảm chất lượng đầu ra), do đó việc định tuyến là rõ ràng: các state dict đã chuyển đổi nhắm đến transformer.; truy cập transformer_ref bằng một tệp có tiền tố transformer_ref. hoặc load_into_transformer_ref=True.
LoRA của DiffSynth-Studio (ví dụ DiffSynth-Studio/MiniMax-H3-LoRA-LineartAnime) được huấn luyện dựa trên QKV đã hợp nhất theo kiểu xen kẽ từng đầu (per-head-interleaved) của checkpoint gốc và được tách xen kẽ khi chuyển đổi. Các hệ số fp32 của chúng khiến đường dẫn LoRA chưa hợp nhất tính toán ở fp32; việc gọi .to(torch.bfloat16) trên mô hình sau khi tải sẽ khôi phục ngân sách bộ nhớ bf16.
LoRA được huấn luyện trên checkpoint đã cắt tỉa (các tệp *_pruned_* trong Comfy-Org/MiniMax-H3; joyfox/MiniMax-H3-Turbo là một ví dụ) sẽ gặp lỗi không khớp kích thước. Các tệp không có alpha được nạp với alpha == rank (thang 1.0, quy ước được nêu bởi ví dụ larryvrh/MiniMax-H3-Turbo-Lora); mục alpha trong __metadata__ (ví dụ tệp 8 bước của lightx2v/Minimax-h3-Turbo), nếu có, sẽ được ưu tiên áp dụng.
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)
Xem fuse_lora() để biết thêm chi tiết.
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)
Xem load_lora_into_unet() để biết thêm chi tiết.
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)
Nạp các lớp LoRA vào phân vùng transformer_ref. prefix là tên thành phần mà các key mang theo, cụ thể là transformer_ref đối với tệp có đặt tên cho phân vùng và transformer đối với tệp được định tuyến đến đây bởi load_into_transformer_ref=True. Xem load_lora_into_unet() để biết thêm chi tiết.
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)
Tham số:
load_into_transformer_ref (bool, mặc định là False) : Nạp các lớp có tiền tố transformer. vào phân vùng transformer_ref — phân vùng mà quy trình ref2va dùng để khử nhiễu — thay vì transformer. Chỉ cần thiết khi cả hai phân vùng đều được nạp: một pipeline chỉ giữ transformer_ref sẽ tự động định tuyến đến đó.
Tải các lớp LoRA vào transformer hoặc, với load_into_transformer_ref=True, vào transformer_ref. Xem load_lora_weights() để biết thêm chi tiết.
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)
Xem lora_state_dict() để biết thêm chi tiết.
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)
Lưu các lớp LoRA của một hoặc cả hai phân vùng MiniMax-H3. Việc một LoRA thuộc về phân vùng nào không thể khôi phục từ các khóa của nó, do đó đây là cách duy nhất để công bố một H3 LoRA có ghi lại thông tin này. Xem save_lora_weights() để biết thêm thông tin.
unfuse_lora[[diffusers.loaders.MiniMaxH3LoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer', 'transformer_ref'], **kwargs)
Xem unfuse_lora() để biết thêm chi tiết.
PikaH3FlexLoraLoaderMixin[[diffusers.loaders.PikaH3FlexLoraLoaderMixin]]
diffusers.loaders.PikaH3FlexLoraLoaderMixin[[diffusers.loaders.PikaH3FlexLoraLoaderMixin]]
diffusers.loaders.PikaH3FlexLoraLoaderMixin()
Tải các lớp LoRA vào MiniMaxH3Transformer3DModel. Cụ thể dành cho PikaH3FlexModularPipeline.
Phiên bản Pika H3 Flex là một cặp adapter rank-128 trên hai phân vùng transformer của MiniMax-H3, được phát hành dưới dạng các bản dump PEFT thuần túy theo tên module của diffusers (fl2va/adapter.safetensors cho transformer, ref2va/adapter.safetensors cho transformer_ref). Các tệp không có alpha được nạp với alpha == rank (scale 1.0), đúng theo hợp đồng của chính các adapter, và việc nạp, định tuyến cũng như lưu trữ tuân theo MiniMaxH3LoraLoaderMixin: adapter fl2va được đưa vào transformer, còn adapter ref2va vào transformer_ref — riêng lẻ khi pipeline chỉ giữ phân vùng đó (workflow="ref2va"), hoặc với load_into_transformer_ref=True khi pipeline giữ cả hai.
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()
Lớp tiện ích để xử lý LoRA.
delete_adapters[[diffusers.loaders.lora_base.LoraBaseMixin.delete_adapters]]
delete_adapters(adapter_names: list[str] | str)
Tham số:
adapter_names (list[str, str]) : Tên của các adapter cần xóa.
Xóa các lớp LoRA của adapter khỏi pipeline.
Ví dụ:
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()
Tắt các lớp LoRA đang hoạt động của pipeline.
Ví dụ:
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()
Bật các lớp LoRA đang hoạt động của pipeline.
Ví dụ:
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)
Tham số:
target_rank (int) : Bậc cao nhất trong số tất cả các adapter sẽ được nạp.
check_compiled (str, tùy chọn, mặc định là "error") : Cách xử lý một model đã được biên dịch. Việc kiểm tra có thể trả về các thông báo sau: - "error" (mặc định): ném ra một lỗi - "warn": phát ra một cảnh báo - "ignore": không làm gì
Nóng thay thế các adapter mà không kích hoạt việc biên dịch lại mô hình hoặc khi các bậc của các adapter được nạp khác nhau.
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)
Tham số:
components : (list[str]): danh sách các thành phần có thể tiêm LoRA để hợp nhất các LoRA vào.
lora_scale (float, mặc định là 1.0) : Kiểm soát mức độ ảnh hưởng của các tham số LoRA đến đầu ra.
safe_fusing (bool, mặc định là False) : Có kiểm tra các trọng số đã hợp nhất (fused) xem có chứa giá trị NaN trước khi hợp nhất hay không, và nếu giá trị là NaN thì không thực hiện hợp nhất.
adapter_names (list[str], tùy chọn) : Các tên adapter sẽ được sử dụng để hợp nhất. Nếu không truyền gì, tất cả các adapter đang hoạt động sẽ được hợp nhất.
Trộn các tham số LoRA vào các tham số gốc của các khối tương ứng.
Ví dụ:
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()
Lấy danh sách các adapter đang hoạt động hiện tại.
Ví dụ:
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()
Lấy danh sách hiện tại của tất cả các adapter khả dụng trong 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)
Tham số:
adapter_names (list[str] hoặc str) : Tên của các adapter cần sử dụng.
adapter_weights (float, dict hoặc list, tùy chọn) : Trọng số cho các adapter. Một giá trị vô hướng sẽ nhân lên tất cả các thành phần tương thích với LoRA. Một từ điển ánh xạ tên thành phần (ví dụ "unet", "transformer" hoặc "text_encoder") tới trọng số; trọng số của một thành phần UNet cũng có thể là một từ điển lồng nhau chứa các thang đo khối. Một giá trị vô hướng hoặc từ điển đơn lẻ được áp dụng cho mọi adapter. Một danh sách phải chứa một giá trị vô hướng, từ điển hoặc None cho mỗi adapter, theo thứ tự của adapter_names. None mặc định là 1.0, bao gồm cả các mục trong danh sách và trọng số của các thành phần. Các thành phần không được chỉ định và các khối UNet cũng mặc định là 1.0.
Đặt các adapter đang hoạt động hiện tại để sử dụng trong pipeline.
Ví dụ:
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)
Tham số:
adapter_names (list[str]) : danh sách các adapter để gửi thiết bị đến.
device (torch.device | str | int) : Thiết bị để gửi các adapter đến. Có thể là một thiết bị torch, một str hoặc một số nguyên.
Chuyển các LoRA được liệt kê trong adapter_names sang thiết bị đích. Hữu ích để offload LoRA sang CPU trong trường hợp bạn muốn nạp nhiều adapter và giải phóng một phần bộ nhớ GPU.
Sau khi offload các adapter LoRA sang CPU, miễn là phần còn lại của mô hình vẫn nằm trên GPU, các adapter LoRA sẽ không thể được sử dụng để suy luận (inference) nữa, vì điều đó sẽ gây ra sự không khớp về thiết bị (device mismatch). Hãy nhớ đặt lại thiết bị về GPU trước khi sử dụng các adapter LoRA đó để suy luận.
>>> 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)
Tham số:
components (list[str]) : danh sách các thành phần có thể tiêm LoRA để tách LoRA ra.
unfuse_unet (bool, mặc định là True) : Có nên tách các tham số LoRA của UNet hay không.
unfuse_text_encoder (bool, mặc định là True) : Xác định có tách các tham số LoRA của text encoder hay không. Nếu text encoder không được monkey-patch với các tham số LoRA thì sẽ không có tác dụng.
Đảo ngược tác dụng của pipe.fuse_lora().
unload_lora_weights[[diffusers.loaders.lora_base.LoraBaseMixin.unload_lora_weights]]
unload_lora_weights()
Gỡ bỏ các tham số LoRA.
Ví dụ:
>>> # 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)
Viết state dict của các lớp LoRA (tùy chọn kèm metadata) ra đĩa.
Xet Storage Details
- Size:
- 170 kB
- Xet hash:
- 3469ddfbb67b9b29ed8aa4aaf92fc6bf53d5988721ea3f7d6add0d0ffc760ec3
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.