| | import os |
| | import torch |
| | from ldm_patched.modules.controlnet import ControlLora, ControlNet, load_t2i_adapter, ControlBase |
| | from ldm_patched.modules.model_patcher import ModelPatcher |
| | from ldm_patched.modules import model_management, utils, ops, model_detection |
| | from ldm_patched.controlnet import cldm |
| | from ldm_patched.modules.ops import manual_cast |
| | from modules_forge.controlnet import apply_controlnet_advanced |
| | from modules_forge.shared import add_supported_control_model |
| |
|
| |
|
| | class ControlModelPatcher: |
| | @staticmethod |
| | def try_build_from_state_dict(state_dict, ckpt_path): |
| | return None |
| |
|
| | def __init__(self, model_patcher=None): |
| | self.model_patcher = model_patcher |
| | self.strength = 1.0 |
| | self.start_percent = 0.0 |
| | self.end_percent = 1.0 |
| | self.positive_advanced_weighting = None |
| | self.negative_advanced_weighting = None |
| | self.advanced_frame_weighting = None |
| | self.advanced_sigma_weighting = None |
| | self.advanced_mask_weighting = None |
| |
|
| | def process_after_running_preprocessors(self, process, params, *args, **kwargs): |
| | return |
| |
|
| | def process_before_every_sampling(self, process, cond, mask, *args, **kwargs): |
| | return |
| |
|
| | def process_after_every_sampling(self, process, params, *args, **kwargs): |
| | return |
| |
|
| | class ControlNetPatcher(ControlModelPatcher): |
| | @staticmethod |
| | def try_build_from_state_dict(controlnet_data, ckpt_path): |
| | if "lora_controlnet" in controlnet_data: |
| | return ControlNetPatcher(ControlLora(controlnet_data)) |
| |
|
| | controlnet_config = None |
| | if "controlnet_cond_embedding.conv_in.weight" in controlnet_data: |
| | unet_dtype = model_management.unet_dtype() |
| | controlnet_config = model_detection.unet_config_from_diffusers_unet(controlnet_data, unet_dtype) |
| | diffusers_keys = utils.unet_to_diffusers(controlnet_config) |
| | diffusers_keys["controlnet_mid_block.weight"] = "middle_block_out.0.weight" |
| | diffusers_keys["controlnet_mid_block.bias"] = "middle_block_out.0.bias" |
| | count = 0 |
| | loop = True |
| | while loop: |
| | suffix = [".weight", ".bias"] |
| | for s in suffix: |
| | k_in = "controlnet_down_blocks.{}{}".format(count, s) |
| | k_out = "zero_convs.{}.0{}".format(count, s) |
| | if k_in not in controlnet_data: |
| | loop = False |
| | break |
| | diffusers_keys[k_in] = k_out |
| | count += 1 |
| | count = 0 |
| | loop = True |
| | while loop: |
| | suffix = [".weight", ".bias"] |
| | for s in suffix: |
| | if count == 0: |
| | k_in = "controlnet_cond_embedding.conv_in{}".format(s) |
| | else: |
| | k_in = "controlnet_cond_embedding.blocks.{}{}".format(count - 1, s) |
| | k_out = "input_hint_block.{}{}".format(count * 2, s) |
| | if k_in not in controlnet_data: |
| | k_in = "controlnet_cond_embedding.conv_out{}".format(s) |
| | loop = False |
| | diffusers_keys[k_in] = k_out |
| | count += 1 |
| | new_sd = {} |
| | for k in diffusers_keys: |
| | if k in controlnet_data: |
| | new_sd[diffusers_keys[k]] = controlnet_data.pop(k) |
| | leftover_keys = controlnet_data.keys() |
| | if len(leftover_keys) > 0: |
| | print("leftover keys:", leftover_keys) |
| | controlnet_data = new_sd |
| |
|
| | pth_key = 'control_model.zero_convs.0.0.weight' |
| | pth = False |
| | key = 'zero_convs.0.0.weight' |
| | if pth_key in controlnet_data: |
| | pth = True |
| | key = pth_key |
| | prefix = "control_model." |
| | elif key in controlnet_data: |
| | prefix = "" |
| | else: |
| | net = load_t2i_adapter(controlnet_data) |
| | if net is None: |
| | return None |
| | return ControlNetPatcher(net) |
| |
|
| | if controlnet_config is None: |
| | unet_dtype = model_management.unet_dtype() |
| | controlnet_config = model_detection.model_config_from_unet(controlnet_data, prefix, True).unet_config |
| | controlnet_config['dtype'] = unet_dtype |
| |
|
| | load_device = model_management.get_torch_device() |
| | manual_cast_dtype = model_management.unet_manual_cast(unet_dtype, load_device) |
| | if manual_cast_dtype is not None: |
| | controlnet_config["operations"] = manual_cast |
| |
|
| | controlnet_config.pop("out_channels") |
| | controlnet_config["hint_channels"] = controlnet_data["{}input_hint_block.0.weight".format(prefix)].shape[1] |
| | control_model = cldm.ControlNet(**controlnet_config) |
| |
|
| | if pth: |
| | if 'difference' in controlnet_data: |
| | print("WARNING: Your controlnet model is diff version rather than official float16 model. " |
| | "Please use an official float16/float32 model for robust performance.") |
| | class WeightsLoader(torch.nn.Module): |
| | pass |
| | w = WeightsLoader() |
| | w.control_model = control_model |
| | missing, unexpected = w.load_state_dict(controlnet_data, strict=False) |
| | else: |
| | missing, unexpected = control_model.load_state_dict(controlnet_data, strict=False) |
| | print(missing, unexpected) |
| |
|
| | global_average_pooling = False |
| | filename = os.path.splitext(ckpt_path)[0] |
| | if filename.endswith("_shuffle") or filename.endswith("_shuffle_fp16"): |
| | global_average_pooling = True |
| |
|
| | control = ControlNet(control_model, global_average_pooling=global_average_pooling, load_device=load_device, |
| | manual_cast_dtype=manual_cast_dtype) |
| | return ControlNetPatcher(control) |
| |
|
| | def __init__(self, model_patcher): |
| | super().__init__(model_patcher) |
| | self.strength = 1.0 |
| | self.start_percent = 0.0 |
| | self.end_percent = 1.0 |
| | self.positive_advanced_weighting = None |
| | self.negative_advanced_weighting = None |
| | self.advanced_frame_weighting = None |
| | self.advanced_sigma_weighting = None |
| | self.advanced_mask_weighting = None |
| |
|
| | def process_before_every_sampling(self, process, cond, mask, *args, **kwargs): |
| | unet = process.sd_model.forge_objects.unet |
| | unet = apply_controlnet_advanced( |
| | unet=unet, |
| | controlnet=self.model_patcher, |
| | image_bchw=cond, |
| | strength=self.strength, |
| | start_percent=self.start_percent, |
| | end_percent=self.end_percent, |
| | positive_advanced_weighting=self.positive_advanced_weighting, |
| | negative_advanced_weighting=self.negative_advanced_weighting, |
| | advanced_frame_weighting=self.advanced_frame_weighting, |
| | advanced_sigma_weighting=self.advanced_sigma_weighting, |
| | advanced_mask_weighting=self.advanced_mask_weighting |
| | ) |
| | process.sd_model.forge_objects.unet = unet |
| | return |
| |
|
| | def process_after_every_sampling(self, process, params, *args, **kwargs): |
| | return |
| |
|
| | def process_after_running_preprocessors(self, process, params, *args, **kwargs): |
| | return |
| | |
| | add_supported_control_model(ControlNetPatcher) |
| |
|
