Helios/helios/utils/create_ema_zero3_lora.py

import copy
import json
import os
import time

import deepspeed
import torch
from peft import LoraConfig, set_peft_model_state_dict
from peft.utils import get_peft_model_state_dict

from diffusers.training_utils import _collate_lora_metadata, free_memory
from diffusers.utils import convert_unet_state_dict_to_peft

from ..pipelines.pipeline_helios import HeliosPipeline
from ..utils.create_ema_zero3 import EMAModel_Zero3, _z3_params_to_fetch
from ..utils.utils_base import NORM_LAYER_PREFIXES, load_extra_components, save_extra_components


GB = 1024 * 1024 * 1024


# Adapted from diffusers-style ema https://github.com/huggingface/diffusers/blob/main/src/diffusers/training_utils.py#L263
class EMAModel_Zero3_LoRA(EMAModel_Zero3):
    """
    Exponential Moving Average of models weights
    """

    def __init__(
        self,
        *args,
        **kwargs,
    ):
        super().__init__(*args, **kwargs)

    @classmethod
    def from_pretrained(
        cls, args, path, model_cls, lora_config, transformer_additional_kwargs={}
    ) -> "EMAModel_Zero3_LoRA":
        model = model_cls.from_pretrained(
            args.model_config.transformer_model_name_or_path,
            subfolder=args.model_config.subfolder or "transformer",
            transformer_additional_kwargs=transformer_additional_kwargs,
        )
        model.add_adapter(lora_config)

        # ------------- load lora -------------
        lora_state_dict = HeliosPipeline.lora_state_dict(path)
        model_state_dict = {
            f"{k.replace('transformer.', '')}": v for k, v in lora_state_dict.items() if k.startswith("transformer.")
        }
        model_state_dict = convert_unet_state_dict_to_peft(model_state_dict)
        incompatible_keys = set_peft_model_state_dict(model, model_state_dict, adapter_name="default")
        if incompatible_keys is not None:
            # check only for unexpected keys
            unexpected_keys = getattr(incompatible_keys, "unexpected_keys", None)
            if unexpected_keys:
                accelerator.print(
                    f"Loading adapter weights from state_dict led to unexpected keys not found in the model: "
                    f" {unexpected_keys}. "
                )

        if args.model_config.train_norm_layers:
            model_norm_state_dict = {
                k: v
                for k, v in lora_state_dict.items()
                if k.startswith("transformer.") and any(norm_k in k for norm_k in NORM_LAYER_PREFIXES)
            }
            model._transformer_norm_layers = HeliosPipeline._load_norm_into_transformer(
                model_norm_state_dict,
                transformer=model,
                discard_original_layers=False,
            )
        # ------------- load lora -------------

        # ------------- load extra components -------------
        load_extra_components(args, model, os.path.join(path, "transformer_partial.pth"))
        # ------------- load extra components -------------

        ema_model = cls(model, model_cls=model_cls, model_config=model.config)

        with open(os.path.join(path, "ema_kwargs.json"), "r") as f:
            ema_kwargs = json.load(f)
        ema_model.load_state_dict(ema_kwargs)

        return ema_model

    def save_pretrained(
        self, args, path, pretrained_name_or_path, lora_config, transformer_additional_kwargs={}, transformer_cpu=None
    ):
        if self.model_cls is None:
            raise ValueError("`save_pretrained` can only be used if `model_cls` was defined at __init__.")

        if self.model_config is None:
            raise ValueError("`save_pretrained` can only be used if `model_config` was defined at __init__.")

        rank = int(os.getenv("RANK", "0"))

        model_to_save = self.model.module if hasattr(self.model, "module") else self.model
        model_state_dict = {}
        for k, v in model_to_save.named_parameters():
            # only gather z3 params
            params_to_fetch = _z3_params_to_fetch([v])
            with deepspeed.zero.GatheredParameters(params_to_fetch, enabled=len(params_to_fetch) > 0):
                if rank == 0:
                    model_state_dict[k] = v.data.cpu().clone()

        if rank == 0:
            state_dict = self.state_dict()
            state_dict.pop("model")

            os.makedirs(path, exist_ok=True)
            print(f"state_dict, {state_dict.keys()}")
            t_start = time.perf_counter()
            print(f"[{t_start:.4f}] self.model_cls.from_pretrained")

            print("self.model_cls", self.model_cls)
            if transformer_cpu is None:
                model = self.model_cls.from_pretrained(
                    pretrained_name_or_path,
                    subfolder=args.model_config.subfolder or "transformer",
                    transformer_additional_kwargs=transformer_additional_kwargs,
                )
                model.add_adapter(lora_config)
            else:
                model = transformer_cpu
            t1 = time.perf_counter()
            print(f"[{t1:.4f}] after self.model_cls.from_pretrained (耗时 {t1 - t_start:.4f} 秒)")

            miss, unexp = model.load_state_dict(model_state_dict, strict=False)
            assert len(unexp) == 0, f"miss: {miss}; unexp: {unexp}"

            # ------------- only save lora -------------
            config_dict = model.config if hasattr(model, "config") else self.model_config
            with open(os.path.join(path, "config.json"), "w") as f:
                json.dump(config_dict, f, indent=2)

            modules_to_save = {}
            transformer_lora_layers_to_save = get_peft_model_state_dict(model)
            if args.model_config.train_norm_layers:
                transformer_norm_layers_to_save = {
                    f"transformer.{name}": param
                    for name, param in model.named_parameters()
                    if any(k in name for k in NORM_LAYER_PREFIXES)
                }
                transformer_lora_layers_to_save = {
                    **transformer_lora_layers_to_save,
                    **transformer_norm_layers_to_save,
                }
            modules_to_save["transformer"] = model
            HeliosPipeline.save_lora_weights(
                path,
                transformer_lora_layers=transformer_lora_layers_to_save,
                **_collate_lora_metadata(modules_to_save),
            )
            # ------------- only save lora -------------

            # ------------- only save extra components -------------
            save_extra_components(args, model_state_dict=model_state_dict, output_dir=path)
            # ------------- only save extra components -------------

            t2 = time.perf_counter()
            print(f"[{t2:.4f}] after save_pretrained (耗时 {t2 - t1:.4f} 秒)")

            print(f"[{t2:.4f}] 总耗时 {t2 - t_start:.4f} 秒")

            with open(os.path.join(path, "ema_kwargs.json"), "w") as f:
                json.dump(state_dict, f, indent=2)

        model = None
        transformer_cpu = None
        params_to_fetch = None
        state_dict = None
        model_state_dict = None
        transformer_lora_layers_to_save = None
        transformer_norm_layers_to_save = None
        modules_to_save = None
        del model
        del transformer_cpu
        del params_to_fetch
        del state_dict
        del model_state_dict
        del transformer_lora_layers_to_save
        del transformer_norm_layers_to_save
        del modules_to_save
        free_memory()

        print(f"rank {rank} done saved ema!")


def gather_zero3ema(accelerator, ema_model):
    model_to_save = ema_model.model.module if hasattr(ema_model.model, "module") else ema_model.model
    model_state_dict = {}
    for k, v in model_to_save.named_parameters():
        # only gather z3 params
        params_to_fetch = _z3_params_to_fetch([v])
        with deepspeed.zero.GatheredParameters(params_to_fetch, enabled=len(params_to_fetch) > 0):
            # if accelerator.process_index == 0:
            model_state_dict[k] = v.data.cpu().clone()
    return model_state_dict


def create_ema_model(
    accelerator,
    args,
    transformer,
    resume_checkpoint_path,
    model_cls,
    model_config,
    ds_config=None,
    lora_config=None,
    update_after_step=0,
    transformer_additional_kwargs={},
):
    ds_config["train_micro_batch_size_per_gpu"] = args.training_config.train_batch_size
    ds_config["fp16"]["enabled"] = False
    ds_config["bf16"]["enabled"] = False
    ds_config["gradient_accumulation_steps"] = args.training_config.gradient_accumulation_steps
    ds_config["train_batch_size"] = (
        args.training_config.train_batch_size
        * args.training_config.gradient_accumulation_steps
        * accelerator.num_processes
    )
    accelerator.print(f"EMA deepspeed config {ds_config}")

    if resume_checkpoint_path:
        ema_model = EMAModel_Zero3_LoRA.from_pretrained(
            args=args,
            path=resume_checkpoint_path,
            model_cls=model_cls,
            lora_config=lora_config,
            transformer_additional_kwargs=transformer_additional_kwargs,
        )
        accelerator.print(f"Successully resume EMAModel_Zero3 from {resume_checkpoint_path}")
    else:
        ema_model = EMAModel_Zero3_LoRA(
            copy.deepcopy(transformer),
            decay=args.training_config.ema_decay,
            model_cls=model_cls,
            model_config=model_config,
            update_after_step=update_after_step,
        )
        accelerator.print(f"EMAModel_Zero3 finish, memory_allocated: {torch.cuda.memory_allocated() / GB:.2f} GB")
        accelerator.print("Successully deepcopy EMAModel_Zero3 from model")
    ema_model.model, _, _, _ = deepspeed.initialize(
        model=ema_model.model, config_params=ds_config, distributed_port=args.training_config.ema_zero3_port
    )
    return ema_model


def create_ema_final(
    accelerator,
    args,
    transformer_cpu,
    model_cls,
    ds_config,
    transformer_lora_config,
    update_after_step=0,
    resume_checkpoint_path=None,
    transformer_additional_kwargs=None,
):
    ema_transformer = create_ema_model(
        accelerator,
        args=args,
        transformer=transformer_cpu,
        resume_checkpoint_path=resume_checkpoint_path,
        model_cls=model_cls,
        model_config=transformer_cpu.config,
        ds_config=ds_config,
        lora_config=transformer_lora_config,
        update_after_step=update_after_step,
        transformer_additional_kwargs=transformer_additional_kwargs,
    )
    free_memory()
    return ema_transformer


if __name__ == "__main__":
    import json
    import sys
    from argparse import Namespace

    import deepspeed
    from accelerate import Accelerator

    sys.path.append("../../")
    from helios.modules.transformer_helios import HeliosTransformer3DModel

    args = Namespace()
    args.data_config = Namespace()
    args.training_config = Namespace()
    args.model_config = Namespace()
    args.training_config.train_batch_size = 1
    args.training_config.gradient_accumulation_steps = 1
    args.training_config.ema_decay = 0.999
    args.training_config.ema_zero3_port = 10543
    args.model_config.train_norm_layers = False
    args.model_config.transformer_model_name_or_path = "Wan-AI/Wan2.1-T2V-1.3B-Diffusers"
    args.training_config.ema_deepspeed_config_file = "../../scripts/accelerate_configs/zero3.json"
    resume_checkpoint_path = None

    output_dir = "temp"
    accelerator = Accelerator()

    model_cls = HeliosTransformer3DModel
    transformer = model_cls.from_pretrained(
        args.model_config.transformer_model_name_or_path, subfolder="transformer", torch_dtype=torch.bfloat16
    )
    target_modules = set()
    for name, module in transformer.named_modules():
        if isinstance(module, torch.nn.Linear):
            target_modules.add(name)
    target_modules = list(target_modules)
    lora_config = LoraConfig(
        r=256,
        lora_alpha=256,
        # target_modules=["to_k", "to_v", "to_q", "to_out.0"],
        target_modules=target_modules,
        lora_dropout=0.0,
    )
    transformer.add_adapter(lora_config)

    transformer_cpu = copy.deepcopy(transformer)
    transformer.to(device=accelerator.device, dtype=torch.bfloat16)
    accelerator.print(f"Load model finish, memory_allocated: {torch.cuda.memory_allocated() / GB:.2f} GB")

    with open(args.training_config.ema_deepspeed_config_file, "r") as f:
        ds_config = json.load(f)

    ema_transformer = create_ema_final(
        accelerator=accelerator,
        args=args,
        transformer_cpu=transformer_cpu,
        model_cls=model_cls,
        ds_config=ds_config,
        transformer_lora_config=lora_config,
    )