import argparse import torch from safetensors.torch import load_file, save_file from safetensors import safe_open from musubi_tuner.utils import model_utils import logging logger = logging.getLogger(__name__) logging.basicConfig(level=logging.INFO) # keys of Qwen-Image state dict QWEN_IMAGE_KEYS = [ "time_text_embed.timestep_embedder.linear_1", "time_text_embed.timestep_embedder.linear_2", "txt_norm", "img_in", "txt_in", "transformer_blocks.*.img_mod.1", "transformer_blocks.*.attn.norm_q", "transformer_blocks.*.attn.norm_k", "transformer_blocks.*.attn.to_q", "transformer_blocks.*.attn.to_k", "transformer_blocks.*.attn.to_v", "transformer_blocks.*.attn.add_k_proj", "transformer_blocks.*.attn.add_v_proj", "transformer_blocks.*.attn.add_q_proj", "transformer_blocks.*.attn.to_out.0", "transformer_blocks.*.attn.to_add_out", "transformer_blocks.*.attn.norm_added_q", "transformer_blocks.*.attn.norm_added_k", "transformer_blocks.*.img_mlp.net.0.proj", "transformer_blocks.*.img_mlp.net.2", "transformer_blocks.*.txt_mod.1", "transformer_blocks.*.txt_mlp.net.0.proj", "transformer_blocks.*.txt_mlp.net.2", "norm_out.linear", "proj_out", ] def convert_from_diffusers(prefix, weights_sd): # convert from diffusers(?) to default LoRA # Diffusers format: {"diffusion_model.module.name.lora_A.weight": weight, "diffusion_model.module.name.lora_B.weight": weight, ...} # default LoRA format: {"prefix_module_name.lora_down.weight": weight, "prefix_module_name.lora_up.weight": weight, ...} # note: Diffusers has no alpha, so alpha is set to rank new_weights_sd = {} lora_dims = {} for key, weight in weights_sd.items(): diffusers_prefix, key_body = key.split(".", 1) if diffusers_prefix != "diffusion_model" and diffusers_prefix != "transformer": logger.warning(f"unexpected key: {key} in diffusers format") continue new_key = f"{prefix}{key_body}".replace(".", "_") if "_lora_" in new_key: # LoRA new_key = new_key.replace("_lora_A_", ".lora_down.").replace("_lora_B_", ".lora_up.") # support unknown format: do not replace dots but uses lora_down/lora_up/alpha new_key = new_key.replace("_lora_down_", ".lora_down.").replace("_lora_up_", ".lora_up.") else: # LoHa or LoKr new_key = new_key.replace("_hada_", ".hada_").replace("_lokr_", ".lokr_") if new_key.endswith("_alpha"): new_key = new_key.replace("_alpha", ".alpha") new_weights_sd[new_key] = weight lora_name = new_key.split(".")[0] # before first dot if lora_name not in lora_dims and "lora_down" in new_key: lora_dims[lora_name] = weight.shape[0] # add alpha with rank for lora_name, dim in lora_dims.items(): alpha_key = f"{lora_name}.alpha" if alpha_key not in new_weights_sd: new_weights_sd[f"{lora_name}.alpha"] = torch.tensor(dim) return new_weights_sd def convert_to_diffusers(prefix, diffusers_prefix, weights_sd): # convert from default LoRA to diffusers if diffusers_prefix is None: diffusers_prefix = "diffusion_model" # make reverse map from LoRA name to base model module name lora_name_to_module_name = {} for key in QWEN_IMAGE_KEYS: if "*" not in key: lora_name = prefix + key.replace(".", "_") lora_name_to_module_name[lora_name] = key else: lora_name = prefix + key.replace(".", "_") for i in range(100): # assume at most 100 transformer blocks lora_name_to_module_name[lora_name.replace("*", str(i))] = key.replace("*", str(i)) # get alphas lora_alphas = {} for key, weight in weights_sd.items(): if key.startswith(prefix): lora_name = key.split(".", 1)[0] # before first dot if lora_name not in lora_alphas and "alpha" in key: lora_alphas[lora_name] = weight new_weights_sd = {} estimated_type = None for key, weight in weights_sd.items(): if key.startswith(prefix): if "alpha" in key: continue lora_name, weight_name = key.split(".", 1) if lora_name in lora_name_to_module_name: module_name = lora_name_to_module_name[lora_name] else: module_name = lora_name[len(prefix) :] # remove "lora_unet_" module_name = module_name.replace("_", ".") # replace "_" with "." if ".cross.attn." in module_name or ".self.attn." in module_name: # Wan2.1 lora name to module name: ugly but works module_name = module_name.replace("cross.attn", "cross_attn") # fix cross attn module_name = module_name.replace("self.attn", "self_attn") # fix self attn module_name = module_name.replace("k.img", "k_img") # fix k img module_name = module_name.replace("v.img", "v_img") # fix v img elif ".attention.to." in module_name or ".feed.forward." in module_name: # Z-Image lora name to module name: ugly but works module_name = module_name.replace("to.q", "to_q") # fix to q module_name = module_name.replace("to.k", "to_k") # fix to k module_name = module_name.replace("to.v", "to_v") # fix to v module_name = module_name.replace("to.out", "to_out") # fix to out module_name = module_name.replace("feed.forward", "feed_forward") # fix feed forward elif "double.blocks." in module_name or "single.blocks." in module_name: # HunyuanVideo and FLUX lora name to module name: ugly but works module_name = module_name.replace("double.blocks.", "double_blocks.") # fix double blocks module_name = module_name.replace("single.blocks.", "single_blocks.") # fix single blocks module_name = module_name.replace("img.", "img_") # fix img module_name = module_name.replace("txt.", "txt_") # fix txt module_name = module_name.replace("attn.", "attn_") # fix attn dim = None # None means LoHa or LoKr, otherwise it's LoRA with alpha and dim is used for scaling if "lora_down" in key: new_key = f"{diffusers_prefix}.{module_name}.lora_A.weight" dim = weight.shape[0] elif "lora_up" in key: new_key = f"{diffusers_prefix}.{module_name}.lora_B.weight" dim = weight.shape[1] elif "hada" in key or "lokr" in key: # LoHa or LoKr new_key = f"{diffusers_prefix}.{module_name}.{weight_name}" if "hada" in key: estimated_type = "LoHa" elif "lokr" in key: estimated_type = "LoKr" else: logger.warning(f"unexpected key: {key} in default LoRA format") continue if dim is not None: estimated_type = "LoRA" # scale weight by alpha for LoRA with alpha (e.g., LyCORIS), to match Diffusers format which has no alpha (alpha is effectively 1) if lora_name in lora_alphas and dim is not None: # we scale both down and up, so scale is sqrt scale = lora_alphas[lora_name] / dim scale = scale.sqrt() weight = weight * scale else: if dim is not None: logger.warning(f"missing alpha for {lora_name}") else: # for LoHa or LoKr, we copy alpha if exists if lora_name in lora_alphas: new_weights_sd[f"{diffusers_prefix}.{module_name}.alpha"] = lora_alphas[lora_name] new_weights_sd[new_key] = weight logger.info(f"estimated type: {estimated_type}") return new_weights_sd def convert(input_file, output_file, target_format, diffusers_prefix): logger.info(f"loading {input_file}") weights_sd = load_file(input_file) with safe_open(input_file, framework="pt") as f: metadata = f.metadata() logger.info(f"converting to {target_format}") prefix = "lora_unet_" if target_format == "default": new_weights_sd = convert_from_diffusers(prefix, weights_sd) metadata = metadata or {} model_utils.precalculate_safetensors_hashes(new_weights_sd, metadata) elif target_format == "other": new_weights_sd = convert_to_diffusers(prefix, diffusers_prefix, weights_sd) else: raise ValueError(f"unknown target format: {target_format}") logger.info(f"saving to {output_file}") save_file(new_weights_sd, output_file, metadata=metadata) logger.info("done") def parse_args(): parser = argparse.ArgumentParser(description="Convert LoRA/LoHa/LoKr weights between default and other formats") parser.add_argument("--input", type=str, required=True, help="input model file") parser.add_argument("--output", type=str, required=True, help="output model file") parser.add_argument("--target", type=str, required=True, choices=["other", "default"], help="target format") parser.add_argument( "--diffusers_prefix", type=str, default=None, help="prefix for Diffusers weights, default is None (use `diffusion_model`)" ) args = parser.parse_args() return args def main(): args = parse_args() convert(args.input, args.output, args.target, args.diffusers_prefix) if __name__ == "__main__": main()