Spaces:
Sleeping
Sleeping
| # Modified from https://github.com/open-mmlab/PIA/blob/main/animatediff/utils/convert_from_ckpt.py and | |
| # https://github.com/guoyww/AnimateDiff/blob/main/animatediff/utils/convert_from_ckpt.py | |
| # Copyright 2023 The HuggingFace Inc. team. | |
| # | |
| # Licensed under the Apache License, Version 2.0 (the "License"); | |
| # you may not use this file except in compliance with the License. | |
| # You may obtain a copy of the License at | |
| # | |
| # http://www.apache.org/licenses/LICENSE-2.0 | |
| # | |
| # Unless required by applicable law or agreed to in writing, software | |
| # distributed under the License is distributed on an "AS IS" BASIS, | |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| # See the License for the specific language governing permissions and | |
| # limitations under the License. | |
| """Conversion script for the Stable Diffusion checkpoints.""" | |
| 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_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_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 | |
| 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 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 | |
| if "proj_attn.weight" in new_path: | |
| checkpoint[new_path] = old_checkpoint[path["old"]][:, :, 0] | |
| elif "to_out.0.weight" in new_path: | |
| checkpoint[new_path] = old_checkpoint[path["old"]].squeeze() | |
| elif any(qkv in new_path for qkv in ["to_q", "to_k", "to_v"]): | |
| checkpoint[new_path] = old_checkpoint[path["old"]].squeeze() | |
| else: | |
| checkpoint[new_path] = old_checkpoint[path["old"]] | |
| 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 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: | |
| unet_params = original_config.model.params.unet_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 | |
| 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 = [5, 10, 20, 20] | |
| class_embed_type = None | |
| projection_class_embeddings_input_dim = None | |
| if "num_classes" in unet_params: | |
| if unet_params.num_classes == "sequential": | |
| 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": unet_params.context_dim, | |
| "attention_head_dim": head_dim, | |
| "use_linear_projection": use_linear_projection, | |
| "class_embed_type": class_embed_type, | |
| "projection_class_embeddings_input_dim": projection_class_embeddings_input_dim, | |
| } | |
| if not controlnet: | |
| config["out_channels"] = unet_params.out_channels | |
| config["up_block_types"] = tuple(up_block_types) | |
| return config | |
| def convert_ldm_unet_checkpoint(checkpoint, config, path=None, extract_ema=False, controlnet=False): | |
| """ | |
| Takes a state dict and a config, and returns a converted checkpoint. | |
| """ | |
| # 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: | |
| print(f"Checkpoint {path} has both EMA and non-EMA weights.") | |
| print( | |
| "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.pop(flat_ema_key) | |
| else: | |
| if sum(k.startswith("model_ema") for k in keys) > 100: | |
| print( | |
| "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.pop(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']}") | |
| 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 convert_ldm_vae_checkpoint(checkpoint, config, only_decoder=False, only_encoder=False): | |
| # 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) | |
| if only_decoder: | |
| new_checkpoint = { | |
| k: v for k, v in new_checkpoint.items() if k.startswith("decoder") or k.startswith("post_quant") | |
| } | |
| elif only_encoder: | |
| new_checkpoint = {k: v for k, v in new_checkpoint.items() if k.startswith("encoder") or k.startswith("quant")} | |
| return new_checkpoint | |
| def convert_ldm_clip_checkpoint(checkpoint): | |
| keys = list(checkpoint.keys()) | |
| text_model_dict = {} | |
| for key in keys: | |
| if key.startswith("cond_stage_model.transformer"): | |
| text_model_dict[key[len("cond_stage_model.transformer.") :]] = checkpoint[key] | |
| return text_model_dict | |