mirror of
https://github.com/deepseek-ai/DreamCraft3D
synced 2024-12-05 02:25:45 +00:00
1026 lines
36 KiB
Python
1026 lines
36 KiB
Python
import argparse
|
|
import sys
|
|
|
|
import torch
|
|
from diffusers.models import AutoencoderKL, UNet2DConditionModel
|
|
from diffusers.schedulers import DDIMScheduler
|
|
from diffusers.utils import logging
|
|
from transformers import CLIPImageProcessor, CLIPVisionModelWithProjection
|
|
|
|
sys.path.append("extern/")
|
|
from accelerate import init_empty_weights
|
|
from accelerate.utils import set_module_tensor_to_device
|
|
from zero123 import CLIPCameraProjection, Zero123Pipeline
|
|
|
|
logger = logging.get_logger(__name__)
|
|
|
|
|
|
def create_unet_diffusers_config(original_config, image_size: int, controlnet=False):
|
|
"""
|
|
Creates a config for the diffusers based on the config of the LDM model.
|
|
"""
|
|
if controlnet:
|
|
unet_params = original_config.model.params.control_stage_config.params
|
|
else:
|
|
if (
|
|
"unet_config" in original_config.model.params
|
|
and original_config.model.params.unet_config is not None
|
|
):
|
|
unet_params = original_config.model.params.unet_config.params
|
|
else:
|
|
unet_params = original_config.model.params.network_config.params
|
|
|
|
vae_params = original_config.model.params.first_stage_config.params.ddconfig
|
|
|
|
block_out_channels = [
|
|
unet_params.model_channels * mult for mult in unet_params.channel_mult
|
|
]
|
|
|
|
down_block_types = []
|
|
resolution = 1
|
|
for i in range(len(block_out_channels)):
|
|
block_type = (
|
|
"CrossAttnDownBlock2D"
|
|
if resolution in unet_params.attention_resolutions
|
|
else "DownBlock2D"
|
|
)
|
|
down_block_types.append(block_type)
|
|
if i != len(block_out_channels) - 1:
|
|
resolution *= 2
|
|
|
|
up_block_types = []
|
|
for i in range(len(block_out_channels)):
|
|
block_type = (
|
|
"CrossAttnUpBlock2D"
|
|
if resolution in unet_params.attention_resolutions
|
|
else "UpBlock2D"
|
|
)
|
|
up_block_types.append(block_type)
|
|
resolution //= 2
|
|
|
|
if unet_params.transformer_depth is not None:
|
|
transformer_layers_per_block = (
|
|
unet_params.transformer_depth
|
|
if isinstance(unet_params.transformer_depth, int)
|
|
else list(unet_params.transformer_depth)
|
|
)
|
|
else:
|
|
transformer_layers_per_block = 1
|
|
|
|
vae_scale_factor = 2 ** (len(vae_params.ch_mult) - 1)
|
|
|
|
head_dim = unet_params.num_heads if "num_heads" in unet_params else None
|
|
use_linear_projection = (
|
|
unet_params.use_linear_in_transformer
|
|
if "use_linear_in_transformer" in unet_params
|
|
else False
|
|
)
|
|
if use_linear_projection:
|
|
# stable diffusion 2-base-512 and 2-768
|
|
if head_dim is None:
|
|
head_dim_mult = unet_params.model_channels // unet_params.num_head_channels
|
|
head_dim = [head_dim_mult * c for c in list(unet_params.channel_mult)]
|
|
|
|
class_embed_type = None
|
|
addition_embed_type = None
|
|
addition_time_embed_dim = None
|
|
projection_class_embeddings_input_dim = None
|
|
context_dim = None
|
|
|
|
if unet_params.context_dim is not None:
|
|
context_dim = (
|
|
unet_params.context_dim
|
|
if isinstance(unet_params.context_dim, int)
|
|
else unet_params.context_dim[0]
|
|
)
|
|
|
|
if "num_classes" in unet_params:
|
|
if unet_params.num_classes == "sequential":
|
|
if context_dim in [2048, 1280]:
|
|
# SDXL
|
|
addition_embed_type = "text_time"
|
|
addition_time_embed_dim = 256
|
|
else:
|
|
class_embed_type = "projection"
|
|
assert "adm_in_channels" in unet_params
|
|
projection_class_embeddings_input_dim = unet_params.adm_in_channels
|
|
else:
|
|
raise NotImplementedError(
|
|
f"Unknown conditional unet num_classes config: {unet_params.num_classes}"
|
|
)
|
|
|
|
config = {
|
|
"sample_size": image_size // vae_scale_factor,
|
|
"in_channels": unet_params.in_channels,
|
|
"down_block_types": tuple(down_block_types),
|
|
"block_out_channels": tuple(block_out_channels),
|
|
"layers_per_block": unet_params.num_res_blocks,
|
|
"cross_attention_dim": context_dim,
|
|
"attention_head_dim": head_dim,
|
|
"use_linear_projection": use_linear_projection,
|
|
"class_embed_type": class_embed_type,
|
|
"addition_embed_type": addition_embed_type,
|
|
"addition_time_embed_dim": addition_time_embed_dim,
|
|
"projection_class_embeddings_input_dim": projection_class_embeddings_input_dim,
|
|
"transformer_layers_per_block": transformer_layers_per_block,
|
|
}
|
|
|
|
if controlnet:
|
|
config["conditioning_channels"] = unet_params.hint_channels
|
|
else:
|
|
config["out_channels"] = unet_params.out_channels
|
|
config["up_block_types"] = tuple(up_block_types)
|
|
|
|
return config
|
|
|
|
|
|
def assign_to_checkpoint(
|
|
paths,
|
|
checkpoint,
|
|
old_checkpoint,
|
|
attention_paths_to_split=None,
|
|
additional_replacements=None,
|
|
config=None,
|
|
):
|
|
"""
|
|
This does the final conversion step: take locally converted weights and apply a global renaming to them. It splits
|
|
attention layers, and takes into account additional replacements that may arise.
|
|
|
|
Assigns the weights to the new checkpoint.
|
|
"""
|
|
assert isinstance(
|
|
paths, list
|
|
), "Paths should be a list of dicts containing 'old' and 'new' keys."
|
|
|
|
# Splits the attention layers into three variables.
|
|
if attention_paths_to_split is not None:
|
|
for path, path_map in attention_paths_to_split.items():
|
|
old_tensor = old_checkpoint[path]
|
|
channels = old_tensor.shape[0] // 3
|
|
|
|
target_shape = (-1, channels) if len(old_tensor.shape) == 3 else (-1)
|
|
|
|
num_heads = old_tensor.shape[0] // config["num_head_channels"] // 3
|
|
|
|
old_tensor = old_tensor.reshape(
|
|
(num_heads, 3 * channels // num_heads) + old_tensor.shape[1:]
|
|
)
|
|
query, key, value = old_tensor.split(channels // num_heads, dim=1)
|
|
|
|
checkpoint[path_map["query"]] = query.reshape(target_shape)
|
|
checkpoint[path_map["key"]] = key.reshape(target_shape)
|
|
checkpoint[path_map["value"]] = value.reshape(target_shape)
|
|
|
|
for path in paths:
|
|
new_path = path["new"]
|
|
|
|
# These have already been assigned
|
|
if (
|
|
attention_paths_to_split is not None
|
|
and new_path in attention_paths_to_split
|
|
):
|
|
continue
|
|
|
|
# Global renaming happens here
|
|
new_path = new_path.replace("middle_block.0", "mid_block.resnets.0")
|
|
new_path = new_path.replace("middle_block.1", "mid_block.attentions.0")
|
|
new_path = new_path.replace("middle_block.2", "mid_block.resnets.1")
|
|
|
|
if additional_replacements is not None:
|
|
for replacement in additional_replacements:
|
|
new_path = new_path.replace(replacement["old"], replacement["new"])
|
|
|
|
# proj_attn.weight has to be converted from conv 1D to linear
|
|
is_attn_weight = "proj_attn.weight" in new_path or (
|
|
"attentions" in new_path and "to_" in new_path
|
|
)
|
|
shape = old_checkpoint[path["old"]].shape
|
|
if is_attn_weight and len(shape) == 3:
|
|
checkpoint[new_path] = old_checkpoint[path["old"]][:, :, 0]
|
|
elif is_attn_weight and len(shape) == 4:
|
|
checkpoint[new_path] = old_checkpoint[path["old"]][:, :, 0, 0]
|
|
else:
|
|
checkpoint[new_path] = old_checkpoint[path["old"]]
|
|
|
|
|
|
def shave_segments(path, n_shave_prefix_segments=1):
|
|
"""
|
|
Removes segments. Positive values shave the first segments, negative shave the last segments.
|
|
"""
|
|
if n_shave_prefix_segments >= 0:
|
|
return ".".join(path.split(".")[n_shave_prefix_segments:])
|
|
else:
|
|
return ".".join(path.split(".")[:n_shave_prefix_segments])
|
|
|
|
|
|
def renew_resnet_paths(old_list, n_shave_prefix_segments=0):
|
|
"""
|
|
Updates paths inside resnets to the new naming scheme (local renaming)
|
|
"""
|
|
mapping = []
|
|
for old_item in old_list:
|
|
new_item = old_item.replace("in_layers.0", "norm1")
|
|
new_item = new_item.replace("in_layers.2", "conv1")
|
|
|
|
new_item = new_item.replace("out_layers.0", "norm2")
|
|
new_item = new_item.replace("out_layers.3", "conv2")
|
|
|
|
new_item = new_item.replace("emb_layers.1", "time_emb_proj")
|
|
new_item = new_item.replace("skip_connection", "conv_shortcut")
|
|
|
|
new_item = shave_segments(
|
|
new_item, n_shave_prefix_segments=n_shave_prefix_segments
|
|
)
|
|
|
|
mapping.append({"old": old_item, "new": new_item})
|
|
|
|
return mapping
|
|
|
|
|
|
def renew_attention_paths(old_list, n_shave_prefix_segments=0):
|
|
"""
|
|
Updates paths inside attentions to the new naming scheme (local renaming)
|
|
"""
|
|
mapping = []
|
|
for old_item in old_list:
|
|
new_item = old_item
|
|
|
|
# new_item = new_item.replace('norm.weight', 'group_norm.weight')
|
|
# new_item = new_item.replace('norm.bias', 'group_norm.bias')
|
|
|
|
# new_item = new_item.replace('proj_out.weight', 'proj_attn.weight')
|
|
# new_item = new_item.replace('proj_out.bias', 'proj_attn.bias')
|
|
|
|
# new_item = shave_segments(new_item, n_shave_prefix_segments=n_shave_prefix_segments)
|
|
|
|
mapping.append({"old": old_item, "new": new_item})
|
|
|
|
return mapping
|
|
|
|
|
|
def convert_ldm_unet_checkpoint(
|
|
checkpoint,
|
|
config,
|
|
path=None,
|
|
extract_ema=False,
|
|
controlnet=False,
|
|
skip_extract_state_dict=False,
|
|
):
|
|
"""
|
|
Takes a state dict and a config, and returns a converted checkpoint.
|
|
"""
|
|
|
|
if skip_extract_state_dict:
|
|
unet_state_dict = checkpoint
|
|
else:
|
|
# extract state_dict for UNet
|
|
unet_state_dict = {}
|
|
keys = list(checkpoint.keys())
|
|
|
|
if controlnet:
|
|
unet_key = "control_model."
|
|
else:
|
|
unet_key = "model.diffusion_model."
|
|
|
|
# at least a 100 parameters have to start with `model_ema` in order for the checkpoint to be EMA
|
|
if sum(k.startswith("model_ema") for k in keys) > 100 and extract_ema:
|
|
logger.warning(f"Checkpoint {path} has both EMA and non-EMA weights.")
|
|
logger.warning(
|
|
"In this conversion only the EMA weights are extracted. If you want to instead extract the non-EMA"
|
|
" weights (useful to continue fine-tuning), please make sure to remove the `--extract_ema` flag."
|
|
)
|
|
for key in keys:
|
|
if key.startswith("model.diffusion_model"):
|
|
flat_ema_key = "model_ema." + "".join(key.split(".")[1:])
|
|
unet_state_dict[key.replace(unet_key, "")] = checkpoint[
|
|
flat_ema_key
|
|
]
|
|
else:
|
|
if sum(k.startswith("model_ema") for k in keys) > 100:
|
|
logger.warning(
|
|
"In this conversion only the non-EMA weights are extracted. If you want to instead extract the EMA"
|
|
" weights (usually better for inference), please make sure to add the `--extract_ema` flag."
|
|
)
|
|
|
|
for key in keys:
|
|
if key.startswith(unet_key):
|
|
unet_state_dict[key.replace(unet_key, "")] = checkpoint[key]
|
|
|
|
new_checkpoint = {}
|
|
|
|
new_checkpoint["time_embedding.linear_1.weight"] = unet_state_dict[
|
|
"time_embed.0.weight"
|
|
]
|
|
new_checkpoint["time_embedding.linear_1.bias"] = unet_state_dict[
|
|
"time_embed.0.bias"
|
|
]
|
|
new_checkpoint["time_embedding.linear_2.weight"] = unet_state_dict[
|
|
"time_embed.2.weight"
|
|
]
|
|
new_checkpoint["time_embedding.linear_2.bias"] = unet_state_dict[
|
|
"time_embed.2.bias"
|
|
]
|
|
|
|
if config["class_embed_type"] is None:
|
|
# No parameters to port
|
|
...
|
|
elif (
|
|
config["class_embed_type"] == "timestep"
|
|
or config["class_embed_type"] == "projection"
|
|
):
|
|
new_checkpoint["class_embedding.linear_1.weight"] = unet_state_dict[
|
|
"label_emb.0.0.weight"
|
|
]
|
|
new_checkpoint["class_embedding.linear_1.bias"] = unet_state_dict[
|
|
"label_emb.0.0.bias"
|
|
]
|
|
new_checkpoint["class_embedding.linear_2.weight"] = unet_state_dict[
|
|
"label_emb.0.2.weight"
|
|
]
|
|
new_checkpoint["class_embedding.linear_2.bias"] = unet_state_dict[
|
|
"label_emb.0.2.bias"
|
|
]
|
|
else:
|
|
raise NotImplementedError(
|
|
f"Not implemented `class_embed_type`: {config['class_embed_type']}"
|
|
)
|
|
|
|
if config["addition_embed_type"] == "text_time":
|
|
new_checkpoint["add_embedding.linear_1.weight"] = unet_state_dict[
|
|
"label_emb.0.0.weight"
|
|
]
|
|
new_checkpoint["add_embedding.linear_1.bias"] = unet_state_dict[
|
|
"label_emb.0.0.bias"
|
|
]
|
|
new_checkpoint["add_embedding.linear_2.weight"] = unet_state_dict[
|
|
"label_emb.0.2.weight"
|
|
]
|
|
new_checkpoint["add_embedding.linear_2.bias"] = unet_state_dict[
|
|
"label_emb.0.2.bias"
|
|
]
|
|
|
|
new_checkpoint["conv_in.weight"] = unet_state_dict["input_blocks.0.0.weight"]
|
|
new_checkpoint["conv_in.bias"] = unet_state_dict["input_blocks.0.0.bias"]
|
|
|
|
if not controlnet:
|
|
new_checkpoint["conv_norm_out.weight"] = unet_state_dict["out.0.weight"]
|
|
new_checkpoint["conv_norm_out.bias"] = unet_state_dict["out.0.bias"]
|
|
new_checkpoint["conv_out.weight"] = unet_state_dict["out.2.weight"]
|
|
new_checkpoint["conv_out.bias"] = unet_state_dict["out.2.bias"]
|
|
|
|
# Retrieves the keys for the input blocks only
|
|
num_input_blocks = len(
|
|
{
|
|
".".join(layer.split(".")[:2])
|
|
for layer in unet_state_dict
|
|
if "input_blocks" in layer
|
|
}
|
|
)
|
|
input_blocks = {
|
|
layer_id: [key for key in unet_state_dict if f"input_blocks.{layer_id}" in key]
|
|
for layer_id in range(num_input_blocks)
|
|
}
|
|
|
|
# Retrieves the keys for the middle blocks only
|
|
num_middle_blocks = len(
|
|
{
|
|
".".join(layer.split(".")[:2])
|
|
for layer in unet_state_dict
|
|
if "middle_block" in layer
|
|
}
|
|
)
|
|
middle_blocks = {
|
|
layer_id: [key for key in unet_state_dict if f"middle_block.{layer_id}" in key]
|
|
for layer_id in range(num_middle_blocks)
|
|
}
|
|
|
|
# Retrieves the keys for the output blocks only
|
|
num_output_blocks = len(
|
|
{
|
|
".".join(layer.split(".")[:2])
|
|
for layer in unet_state_dict
|
|
if "output_blocks" in layer
|
|
}
|
|
)
|
|
output_blocks = {
|
|
layer_id: [key for key in unet_state_dict if f"output_blocks.{layer_id}" in key]
|
|
for layer_id in range(num_output_blocks)
|
|
}
|
|
|
|
for i in range(1, num_input_blocks):
|
|
block_id = (i - 1) // (config["layers_per_block"] + 1)
|
|
layer_in_block_id = (i - 1) % (config["layers_per_block"] + 1)
|
|
|
|
resnets = [
|
|
key
|
|
for key in input_blocks[i]
|
|
if f"input_blocks.{i}.0" in key and f"input_blocks.{i}.0.op" not in key
|
|
]
|
|
attentions = [key for key in input_blocks[i] if f"input_blocks.{i}.1" in key]
|
|
|
|
if f"input_blocks.{i}.0.op.weight" in unet_state_dict:
|
|
new_checkpoint[
|
|
f"down_blocks.{block_id}.downsamplers.0.conv.weight"
|
|
] = unet_state_dict.pop(f"input_blocks.{i}.0.op.weight")
|
|
new_checkpoint[
|
|
f"down_blocks.{block_id}.downsamplers.0.conv.bias"
|
|
] = unet_state_dict.pop(f"input_blocks.{i}.0.op.bias")
|
|
|
|
paths = renew_resnet_paths(resnets)
|
|
meta_path = {
|
|
"old": f"input_blocks.{i}.0",
|
|
"new": f"down_blocks.{block_id}.resnets.{layer_in_block_id}",
|
|
}
|
|
assign_to_checkpoint(
|
|
paths,
|
|
new_checkpoint,
|
|
unet_state_dict,
|
|
additional_replacements=[meta_path],
|
|
config=config,
|
|
)
|
|
|
|
if len(attentions):
|
|
paths = renew_attention_paths(attentions)
|
|
meta_path = {
|
|
"old": f"input_blocks.{i}.1",
|
|
"new": f"down_blocks.{block_id}.attentions.{layer_in_block_id}",
|
|
}
|
|
assign_to_checkpoint(
|
|
paths,
|
|
new_checkpoint,
|
|
unet_state_dict,
|
|
additional_replacements=[meta_path],
|
|
config=config,
|
|
)
|
|
|
|
resnet_0 = middle_blocks[0]
|
|
attentions = middle_blocks[1]
|
|
resnet_1 = middle_blocks[2]
|
|
|
|
resnet_0_paths = renew_resnet_paths(resnet_0)
|
|
assign_to_checkpoint(resnet_0_paths, new_checkpoint, unet_state_dict, config=config)
|
|
|
|
resnet_1_paths = renew_resnet_paths(resnet_1)
|
|
assign_to_checkpoint(resnet_1_paths, new_checkpoint, unet_state_dict, config=config)
|
|
|
|
attentions_paths = renew_attention_paths(attentions)
|
|
meta_path = {"old": "middle_block.1", "new": "mid_block.attentions.0"}
|
|
assign_to_checkpoint(
|
|
attentions_paths,
|
|
new_checkpoint,
|
|
unet_state_dict,
|
|
additional_replacements=[meta_path],
|
|
config=config,
|
|
)
|
|
|
|
for i in range(num_output_blocks):
|
|
block_id = i // (config["layers_per_block"] + 1)
|
|
layer_in_block_id = i % (config["layers_per_block"] + 1)
|
|
output_block_layers = [shave_segments(name, 2) for name in output_blocks[i]]
|
|
output_block_list = {}
|
|
|
|
for layer in output_block_layers:
|
|
layer_id, layer_name = layer.split(".")[0], shave_segments(layer, 1)
|
|
if layer_id in output_block_list:
|
|
output_block_list[layer_id].append(layer_name)
|
|
else:
|
|
output_block_list[layer_id] = [layer_name]
|
|
|
|
if len(output_block_list) > 1:
|
|
resnets = [key for key in output_blocks[i] if f"output_blocks.{i}.0" in key]
|
|
attentions = [
|
|
key for key in output_blocks[i] if f"output_blocks.{i}.1" in key
|
|
]
|
|
|
|
resnet_0_paths = renew_resnet_paths(resnets)
|
|
paths = renew_resnet_paths(resnets)
|
|
|
|
meta_path = {
|
|
"old": f"output_blocks.{i}.0",
|
|
"new": f"up_blocks.{block_id}.resnets.{layer_in_block_id}",
|
|
}
|
|
assign_to_checkpoint(
|
|
paths,
|
|
new_checkpoint,
|
|
unet_state_dict,
|
|
additional_replacements=[meta_path],
|
|
config=config,
|
|
)
|
|
|
|
output_block_list = {k: sorted(v) for k, v in output_block_list.items()}
|
|
if ["conv.bias", "conv.weight"] in output_block_list.values():
|
|
index = list(output_block_list.values()).index(
|
|
["conv.bias", "conv.weight"]
|
|
)
|
|
new_checkpoint[
|
|
f"up_blocks.{block_id}.upsamplers.0.conv.weight"
|
|
] = unet_state_dict[f"output_blocks.{i}.{index}.conv.weight"]
|
|
new_checkpoint[
|
|
f"up_blocks.{block_id}.upsamplers.0.conv.bias"
|
|
] = unet_state_dict[f"output_blocks.{i}.{index}.conv.bias"]
|
|
|
|
# Clear attentions as they have been attributed above.
|
|
if len(attentions) == 2:
|
|
attentions = []
|
|
|
|
if len(attentions):
|
|
paths = renew_attention_paths(attentions)
|
|
meta_path = {
|
|
"old": f"output_blocks.{i}.1",
|
|
"new": f"up_blocks.{block_id}.attentions.{layer_in_block_id}",
|
|
}
|
|
assign_to_checkpoint(
|
|
paths,
|
|
new_checkpoint,
|
|
unet_state_dict,
|
|
additional_replacements=[meta_path],
|
|
config=config,
|
|
)
|
|
else:
|
|
resnet_0_paths = renew_resnet_paths(
|
|
output_block_layers, n_shave_prefix_segments=1
|
|
)
|
|
for path in resnet_0_paths:
|
|
old_path = ".".join(["output_blocks", str(i), path["old"]])
|
|
new_path = ".".join(
|
|
[
|
|
"up_blocks",
|
|
str(block_id),
|
|
"resnets",
|
|
str(layer_in_block_id),
|
|
path["new"],
|
|
]
|
|
)
|
|
|
|
new_checkpoint[new_path] = unet_state_dict[old_path]
|
|
|
|
if controlnet:
|
|
# conditioning embedding
|
|
|
|
orig_index = 0
|
|
|
|
new_checkpoint[
|
|
"controlnet_cond_embedding.conv_in.weight"
|
|
] = unet_state_dict.pop(f"input_hint_block.{orig_index}.weight")
|
|
new_checkpoint["controlnet_cond_embedding.conv_in.bias"] = unet_state_dict.pop(
|
|
f"input_hint_block.{orig_index}.bias"
|
|
)
|
|
|
|
orig_index += 2
|
|
|
|
diffusers_index = 0
|
|
|
|
while diffusers_index < 6:
|
|
new_checkpoint[
|
|
f"controlnet_cond_embedding.blocks.{diffusers_index}.weight"
|
|
] = unet_state_dict.pop(f"input_hint_block.{orig_index}.weight")
|
|
new_checkpoint[
|
|
f"controlnet_cond_embedding.blocks.{diffusers_index}.bias"
|
|
] = unet_state_dict.pop(f"input_hint_block.{orig_index}.bias")
|
|
diffusers_index += 1
|
|
orig_index += 2
|
|
|
|
new_checkpoint[
|
|
"controlnet_cond_embedding.conv_out.weight"
|
|
] = unet_state_dict.pop(f"input_hint_block.{orig_index}.weight")
|
|
new_checkpoint["controlnet_cond_embedding.conv_out.bias"] = unet_state_dict.pop(
|
|
f"input_hint_block.{orig_index}.bias"
|
|
)
|
|
|
|
# down blocks
|
|
for i in range(num_input_blocks):
|
|
new_checkpoint[f"controlnet_down_blocks.{i}.weight"] = unet_state_dict.pop(
|
|
f"zero_convs.{i}.0.weight"
|
|
)
|
|
new_checkpoint[f"controlnet_down_blocks.{i}.bias"] = unet_state_dict.pop(
|
|
f"zero_convs.{i}.0.bias"
|
|
)
|
|
|
|
# mid block
|
|
new_checkpoint["controlnet_mid_block.weight"] = unet_state_dict.pop(
|
|
"middle_block_out.0.weight"
|
|
)
|
|
new_checkpoint["controlnet_mid_block.bias"] = unet_state_dict.pop(
|
|
"middle_block_out.0.bias"
|
|
)
|
|
|
|
return new_checkpoint
|
|
|
|
|
|
def create_vae_diffusers_config(original_config, image_size: int):
|
|
"""
|
|
Creates a config for the diffusers based on the config of the LDM model.
|
|
"""
|
|
vae_params = original_config.model.params.first_stage_config.params.ddconfig
|
|
_ = original_config.model.params.first_stage_config.params.embed_dim
|
|
|
|
block_out_channels = [vae_params.ch * mult for mult in vae_params.ch_mult]
|
|
down_block_types = ["DownEncoderBlock2D"] * len(block_out_channels)
|
|
up_block_types = ["UpDecoderBlock2D"] * len(block_out_channels)
|
|
|
|
config = {
|
|
"sample_size": image_size,
|
|
"in_channels": vae_params.in_channels,
|
|
"out_channels": vae_params.out_ch,
|
|
"down_block_types": tuple(down_block_types),
|
|
"up_block_types": tuple(up_block_types),
|
|
"block_out_channels": tuple(block_out_channels),
|
|
"latent_channels": vae_params.z_channels,
|
|
"layers_per_block": vae_params.num_res_blocks,
|
|
}
|
|
return config
|
|
|
|
|
|
def convert_ldm_vae_checkpoint(checkpoint, config):
|
|
# extract state dict for VAE
|
|
vae_state_dict = {}
|
|
vae_key = "first_stage_model."
|
|
keys = list(checkpoint.keys())
|
|
for key in keys:
|
|
if key.startswith(vae_key):
|
|
vae_state_dict[key.replace(vae_key, "")] = checkpoint.get(key)
|
|
|
|
new_checkpoint = {}
|
|
|
|
new_checkpoint["encoder.conv_in.weight"] = vae_state_dict["encoder.conv_in.weight"]
|
|
new_checkpoint["encoder.conv_in.bias"] = vae_state_dict["encoder.conv_in.bias"]
|
|
new_checkpoint["encoder.conv_out.weight"] = vae_state_dict[
|
|
"encoder.conv_out.weight"
|
|
]
|
|
new_checkpoint["encoder.conv_out.bias"] = vae_state_dict["encoder.conv_out.bias"]
|
|
new_checkpoint["encoder.conv_norm_out.weight"] = vae_state_dict[
|
|
"encoder.norm_out.weight"
|
|
]
|
|
new_checkpoint["encoder.conv_norm_out.bias"] = vae_state_dict[
|
|
"encoder.norm_out.bias"
|
|
]
|
|
|
|
new_checkpoint["decoder.conv_in.weight"] = vae_state_dict["decoder.conv_in.weight"]
|
|
new_checkpoint["decoder.conv_in.bias"] = vae_state_dict["decoder.conv_in.bias"]
|
|
new_checkpoint["decoder.conv_out.weight"] = vae_state_dict[
|
|
"decoder.conv_out.weight"
|
|
]
|
|
new_checkpoint["decoder.conv_out.bias"] = vae_state_dict["decoder.conv_out.bias"]
|
|
new_checkpoint["decoder.conv_norm_out.weight"] = vae_state_dict[
|
|
"decoder.norm_out.weight"
|
|
]
|
|
new_checkpoint["decoder.conv_norm_out.bias"] = vae_state_dict[
|
|
"decoder.norm_out.bias"
|
|
]
|
|
|
|
new_checkpoint["quant_conv.weight"] = vae_state_dict["quant_conv.weight"]
|
|
new_checkpoint["quant_conv.bias"] = vae_state_dict["quant_conv.bias"]
|
|
new_checkpoint["post_quant_conv.weight"] = vae_state_dict["post_quant_conv.weight"]
|
|
new_checkpoint["post_quant_conv.bias"] = vae_state_dict["post_quant_conv.bias"]
|
|
|
|
# Retrieves the keys for the encoder down blocks only
|
|
num_down_blocks = len(
|
|
{
|
|
".".join(layer.split(".")[:3])
|
|
for layer in vae_state_dict
|
|
if "encoder.down" in layer
|
|
}
|
|
)
|
|
down_blocks = {
|
|
layer_id: [key for key in vae_state_dict if f"down.{layer_id}" in key]
|
|
for layer_id in range(num_down_blocks)
|
|
}
|
|
|
|
# Retrieves the keys for the decoder up blocks only
|
|
num_up_blocks = len(
|
|
{
|
|
".".join(layer.split(".")[:3])
|
|
for layer in vae_state_dict
|
|
if "decoder.up" in layer
|
|
}
|
|
)
|
|
up_blocks = {
|
|
layer_id: [key for key in vae_state_dict if f"up.{layer_id}" in key]
|
|
for layer_id in range(num_up_blocks)
|
|
}
|
|
|
|
for i in range(num_down_blocks):
|
|
resnets = [
|
|
key
|
|
for key in down_blocks[i]
|
|
if f"down.{i}" in key and f"down.{i}.downsample" not in key
|
|
]
|
|
|
|
if f"encoder.down.{i}.downsample.conv.weight" in vae_state_dict:
|
|
new_checkpoint[
|
|
f"encoder.down_blocks.{i}.downsamplers.0.conv.weight"
|
|
] = vae_state_dict.pop(f"encoder.down.{i}.downsample.conv.weight")
|
|
new_checkpoint[
|
|
f"encoder.down_blocks.{i}.downsamplers.0.conv.bias"
|
|
] = vae_state_dict.pop(f"encoder.down.{i}.downsample.conv.bias")
|
|
|
|
paths = renew_vae_resnet_paths(resnets)
|
|
meta_path = {"old": f"down.{i}.block", "new": f"down_blocks.{i}.resnets"}
|
|
assign_to_checkpoint(
|
|
paths,
|
|
new_checkpoint,
|
|
vae_state_dict,
|
|
additional_replacements=[meta_path],
|
|
config=config,
|
|
)
|
|
|
|
mid_resnets = [key for key in vae_state_dict if "encoder.mid.block" in key]
|
|
num_mid_res_blocks = 2
|
|
for i in range(1, num_mid_res_blocks + 1):
|
|
resnets = [key for key in mid_resnets if f"encoder.mid.block_{i}" in key]
|
|
|
|
paths = renew_vae_resnet_paths(resnets)
|
|
meta_path = {"old": f"mid.block_{i}", "new": f"mid_block.resnets.{i - 1}"}
|
|
assign_to_checkpoint(
|
|
paths,
|
|
new_checkpoint,
|
|
vae_state_dict,
|
|
additional_replacements=[meta_path],
|
|
config=config,
|
|
)
|
|
|
|
mid_attentions = [key for key in vae_state_dict if "encoder.mid.attn" in key]
|
|
paths = renew_vae_attention_paths(mid_attentions)
|
|
meta_path = {"old": "mid.attn_1", "new": "mid_block.attentions.0"}
|
|
assign_to_checkpoint(
|
|
paths,
|
|
new_checkpoint,
|
|
vae_state_dict,
|
|
additional_replacements=[meta_path],
|
|
config=config,
|
|
)
|
|
conv_attn_to_linear(new_checkpoint)
|
|
|
|
for i in range(num_up_blocks):
|
|
block_id = num_up_blocks - 1 - i
|
|
resnets = [
|
|
key
|
|
for key in up_blocks[block_id]
|
|
if f"up.{block_id}" in key and f"up.{block_id}.upsample" not in key
|
|
]
|
|
|
|
if f"decoder.up.{block_id}.upsample.conv.weight" in vae_state_dict:
|
|
new_checkpoint[
|
|
f"decoder.up_blocks.{i}.upsamplers.0.conv.weight"
|
|
] = vae_state_dict[f"decoder.up.{block_id}.upsample.conv.weight"]
|
|
new_checkpoint[
|
|
f"decoder.up_blocks.{i}.upsamplers.0.conv.bias"
|
|
] = vae_state_dict[f"decoder.up.{block_id}.upsample.conv.bias"]
|
|
|
|
paths = renew_vae_resnet_paths(resnets)
|
|
meta_path = {"old": f"up.{block_id}.block", "new": f"up_blocks.{i}.resnets"}
|
|
assign_to_checkpoint(
|
|
paths,
|
|
new_checkpoint,
|
|
vae_state_dict,
|
|
additional_replacements=[meta_path],
|
|
config=config,
|
|
)
|
|
|
|
mid_resnets = [key for key in vae_state_dict if "decoder.mid.block" in key]
|
|
num_mid_res_blocks = 2
|
|
for i in range(1, num_mid_res_blocks + 1):
|
|
resnets = [key for key in mid_resnets if f"decoder.mid.block_{i}" in key]
|
|
|
|
paths = renew_vae_resnet_paths(resnets)
|
|
meta_path = {"old": f"mid.block_{i}", "new": f"mid_block.resnets.{i - 1}"}
|
|
assign_to_checkpoint(
|
|
paths,
|
|
new_checkpoint,
|
|
vae_state_dict,
|
|
additional_replacements=[meta_path],
|
|
config=config,
|
|
)
|
|
|
|
mid_attentions = [key for key in vae_state_dict if "decoder.mid.attn" in key]
|
|
paths = renew_vae_attention_paths(mid_attentions)
|
|
meta_path = {"old": "mid.attn_1", "new": "mid_block.attentions.0"}
|
|
assign_to_checkpoint(
|
|
paths,
|
|
new_checkpoint,
|
|
vae_state_dict,
|
|
additional_replacements=[meta_path],
|
|
config=config,
|
|
)
|
|
conv_attn_to_linear(new_checkpoint)
|
|
return new_checkpoint
|
|
|
|
|
|
def renew_vae_resnet_paths(old_list, n_shave_prefix_segments=0):
|
|
"""
|
|
Updates paths inside resnets to the new naming scheme (local renaming)
|
|
"""
|
|
mapping = []
|
|
for old_item in old_list:
|
|
new_item = old_item
|
|
|
|
new_item = new_item.replace("nin_shortcut", "conv_shortcut")
|
|
new_item = shave_segments(
|
|
new_item, n_shave_prefix_segments=n_shave_prefix_segments
|
|
)
|
|
|
|
mapping.append({"old": old_item, "new": new_item})
|
|
|
|
return mapping
|
|
|
|
|
|
def renew_vae_attention_paths(old_list, n_shave_prefix_segments=0):
|
|
"""
|
|
Updates paths inside attentions to the new naming scheme (local renaming)
|
|
"""
|
|
mapping = []
|
|
for old_item in old_list:
|
|
new_item = old_item
|
|
|
|
new_item = new_item.replace("norm.weight", "group_norm.weight")
|
|
new_item = new_item.replace("norm.bias", "group_norm.bias")
|
|
|
|
new_item = new_item.replace("q.weight", "to_q.weight")
|
|
new_item = new_item.replace("q.bias", "to_q.bias")
|
|
|
|
new_item = new_item.replace("k.weight", "to_k.weight")
|
|
new_item = new_item.replace("k.bias", "to_k.bias")
|
|
|
|
new_item = new_item.replace("v.weight", "to_v.weight")
|
|
new_item = new_item.replace("v.bias", "to_v.bias")
|
|
|
|
new_item = new_item.replace("proj_out.weight", "to_out.0.weight")
|
|
new_item = new_item.replace("proj_out.bias", "to_out.0.bias")
|
|
|
|
new_item = shave_segments(
|
|
new_item, n_shave_prefix_segments=n_shave_prefix_segments
|
|
)
|
|
|
|
mapping.append({"old": old_item, "new": new_item})
|
|
|
|
return mapping
|
|
|
|
|
|
def conv_attn_to_linear(checkpoint):
|
|
keys = list(checkpoint.keys())
|
|
attn_keys = ["query.weight", "key.weight", "value.weight"]
|
|
for key in keys:
|
|
if ".".join(key.split(".")[-2:]) in attn_keys:
|
|
if checkpoint[key].ndim > 2:
|
|
checkpoint[key] = checkpoint[key][:, :, 0, 0]
|
|
elif "proj_attn.weight" in key:
|
|
if checkpoint[key].ndim > 2:
|
|
checkpoint[key] = checkpoint[key][:, :, 0]
|
|
|
|
|
|
def convert_from_original_zero123_ckpt(
|
|
checkpoint_path, original_config_file, extract_ema, device
|
|
):
|
|
ckpt = torch.load(checkpoint_path, map_location=device)
|
|
global_step = ckpt["global_step"]
|
|
checkpoint = ckpt["state_dict"]
|
|
del ckpt
|
|
torch.cuda.empty_cache()
|
|
|
|
from omegaconf import OmegaConf
|
|
|
|
original_config = OmegaConf.load(original_config_file)
|
|
model_type = original_config.model.params.cond_stage_config.target.split(".")[-1]
|
|
num_in_channels = 8
|
|
original_config["model"]["params"]["unet_config"]["params"][
|
|
"in_channels"
|
|
] = num_in_channels
|
|
prediction_type = "epsilon"
|
|
image_size = 256
|
|
num_train_timesteps = (
|
|
getattr(original_config.model.params, "timesteps", None) or 1000
|
|
)
|
|
|
|
beta_start = getattr(original_config.model.params, "linear_start", None) or 0.02
|
|
beta_end = getattr(original_config.model.params, "linear_end", None) or 0.085
|
|
scheduler = DDIMScheduler(
|
|
beta_end=beta_end,
|
|
beta_schedule="scaled_linear",
|
|
beta_start=beta_start,
|
|
num_train_timesteps=num_train_timesteps,
|
|
steps_offset=1,
|
|
clip_sample=False,
|
|
set_alpha_to_one=False,
|
|
prediction_type=prediction_type,
|
|
)
|
|
scheduler.register_to_config(clip_sample=False)
|
|
|
|
# Convert the UNet2DConditionModel model.
|
|
upcast_attention = None
|
|
unet_config = create_unet_diffusers_config(original_config, image_size=image_size)
|
|
unet_config["upcast_attention"] = upcast_attention
|
|
with init_empty_weights():
|
|
unet = UNet2DConditionModel(**unet_config)
|
|
converted_unet_checkpoint = convert_ldm_unet_checkpoint(
|
|
checkpoint, unet_config, path=None, extract_ema=extract_ema
|
|
)
|
|
for param_name, param in converted_unet_checkpoint.items():
|
|
set_module_tensor_to_device(unet, param_name, "cpu", value=param)
|
|
|
|
# Convert the VAE model.
|
|
vae_config = create_vae_diffusers_config(original_config, image_size=image_size)
|
|
converted_vae_checkpoint = convert_ldm_vae_checkpoint(checkpoint, vae_config)
|
|
|
|
if (
|
|
"model" in original_config
|
|
and "params" in original_config.model
|
|
and "scale_factor" in original_config.model.params
|
|
):
|
|
vae_scaling_factor = original_config.model.params.scale_factor
|
|
else:
|
|
vae_scaling_factor = 0.18215 # default SD scaling factor
|
|
|
|
vae_config["scaling_factor"] = vae_scaling_factor
|
|
|
|
with init_empty_weights():
|
|
vae = AutoencoderKL(**vae_config)
|
|
|
|
for param_name, param in converted_vae_checkpoint.items():
|
|
set_module_tensor_to_device(vae, param_name, "cpu", value=param)
|
|
|
|
feature_extractor = CLIPImageProcessor.from_pretrained(
|
|
"lambdalabs/sd-image-variations-diffusers", subfolder="feature_extractor"
|
|
)
|
|
image_encoder = CLIPVisionModelWithProjection.from_pretrained(
|
|
"lambdalabs/sd-image-variations-diffusers", subfolder="image_encoder"
|
|
)
|
|
|
|
clip_camera_projection = CLIPCameraProjection(additional_embeddings=4)
|
|
clip_camera_projection.load_state_dict(
|
|
{
|
|
"proj.weight": checkpoint["cc_projection.weight"].cpu(),
|
|
"proj.bias": checkpoint["cc_projection.bias"].cpu(),
|
|
}
|
|
)
|
|
|
|
pipe = Zero123Pipeline(
|
|
vae,
|
|
image_encoder,
|
|
unet,
|
|
scheduler,
|
|
None,
|
|
feature_extractor,
|
|
clip_camera_projection,
|
|
requires_safety_checker=False,
|
|
)
|
|
|
|
return pipe
|
|
|
|
|
|
if __name__ == "__main__":
|
|
parser = argparse.ArgumentParser()
|
|
|
|
parser.add_argument(
|
|
"--checkpoint_path",
|
|
default=None,
|
|
type=str,
|
|
required=True,
|
|
help="Path to the checkpoint to convert.",
|
|
)
|
|
parser.add_argument(
|
|
"--original_config_file",
|
|
default=None,
|
|
type=str,
|
|
help="The YAML config file corresponding to the original architecture.",
|
|
)
|
|
parser.add_argument(
|
|
"--extract_ema",
|
|
action="store_true",
|
|
help=(
|
|
"Only relevant for checkpoints that have both EMA and non-EMA weights. Whether to extract the EMA weights"
|
|
" or not. Defaults to `False`. Add `--extract_ema` to extract the EMA weights. EMA weights usually yield"
|
|
" higher quality images for inference. Non-EMA weights are usually better to continue fine-tuning."
|
|
),
|
|
)
|
|
parser.add_argument(
|
|
"--to_safetensors",
|
|
action="store_true",
|
|
help="Whether to store pipeline in safetensors format or not.",
|
|
)
|
|
parser.add_argument(
|
|
"--half", action="store_true", help="Save weights in half precision."
|
|
)
|
|
parser.add_argument(
|
|
"--dump_path",
|
|
default=None,
|
|
type=str,
|
|
required=True,
|
|
help="Path to the output model.",
|
|
)
|
|
parser.add_argument(
|
|
"--device", type=str, help="Device to use (e.g. cpu, cuda:0, cuda:1, etc.)"
|
|
)
|
|
args = parser.parse_args()
|
|
|
|
pipe = convert_from_original_zero123_ckpt(
|
|
checkpoint_path=args.checkpoint_path,
|
|
original_config_file=args.original_config_file,
|
|
extract_ema=args.extract_ema,
|
|
device=args.device,
|
|
)
|
|
|
|
if args.half:
|
|
pipe.to(torch_dtype=torch.float16)
|
|
|
|
pipe.save_pretrained(args.dump_path, safe_serialization=args.to_safetensors)
|