hcpdiff 0.9.1__py3-none-any.whl → 2.1__py3-none-any.whl

hcpdiff/visualizer.py

@@ -1,265 +0,0 @@
-import argparse
-import os
-import random
-from typing import List
-
-import hydra
-import torch
-from PIL import Image
-from accelerate import infer_auto_device_map, dispatch_model
-from diffusers.utils.import_utils import is_xformers_available
-from hcpdiff.models import TokenizerHook, LoraBlock
-from hcpdiff.models.compose import ComposeTEEXHook, ComposeEmbPTHook, ComposeTextEncoder
-from hcpdiff.utils.cfg_net_tools import HCPModelLoader, make_plugin
-from hcpdiff.utils.net_utils import to_cpu, to_cuda, auto_tokenizer, auto_text_encoder
-from hcpdiff.utils.pipe_hook import HookPipe_T2I, HookPipe_I2I, HookPipe_Inpaint
-from hcpdiff.utils.utils import load_config_with_cli, load_config, size_to_int, int_to_size, prepare_seed, is_list, pad_attn_bias
-from hcpdiff.deprecated.cfg_converter import InferCFGConverter
-from omegaconf import OmegaConf
-from torch.cuda.amp import autocast
-
-class Visualizer:
-    dtype_dict = {'fp32':torch.float32, 'fp16':torch.float16, 'bf16':torch.bfloat16}
-
-    def __init__(self, cfgs):
-        self.cfgs_raw = cfgs
-        self.cfgs = hydra.utils.instantiate(self.cfgs_raw)
-        self.cfg_merge = self.cfgs.merge
-        self.offload = 'offload' in self.cfgs and self.cfgs.offload is not None
-        self.dtype = self.dtype_dict[self.cfgs.dtype]
-
-        self.need_inter_imgs = any(item.need_inter_imgs for item in self.cfgs.interface)
-
-        self.pipe = self.load_model(self.cfgs.pretrained_model)
-
-        if self.cfg_merge:
-            self.merge_model()
-
-        self.pipe = self.pipe.to(torch_dtype=self.dtype)
-
-        if isinstance(self.pipe.text_encoder, ComposeTextEncoder):
-            self.pipe.vae = self.pipe.vae.to(dtype=torch.float32)
-
-        if 'save_model' in self.cfgs and self.cfgs.save_model is not None:
-            self.save_model(self.cfgs.save_model)
-            os._exit(0)
-
-        self.build_optimize()
-
-    def load_model(self, pretrained_model):
-        pipeline = self.get_pipeline()
-        te = auto_text_encoder(pretrained_model, subfolder="text_encoder", torch_dtype=self.dtype, resume_download=True)
-        tokenizer = auto_tokenizer(pretrained_model, subfolder="tokenizer", use_fast=False)
-
-        return pipeline.from_pretrained(pretrained_model, safety_checker=None, requires_safety_checker=False,
-                                        text_encoder=te, tokenizer=tokenizer, resume_download=True,
-                                        torch_dtype=self.dtype, **self.cfgs.new_components)
-
-    def build_optimize(self):
-        if self.offload:
-            self.build_offload(self.cfgs.offload)
-        else:
-            self.pipe.unet.to('cuda')
-        self.build_vae_offload()
-
-        if getattr(self.cfgs, 'vae_optimize', None) is not None:
-            if self.cfgs.vae_optimize.tiling:
-                self.pipe.vae.enable_tiling()
-            if self.cfgs.vae_optimize.slicing:
-                self.pipe.vae.enable_slicing()
-
-        self.emb_hook, _ = ComposeEmbPTHook.hook_from_dir(self.cfgs.emb_dir, self.pipe.tokenizer, self.pipe.text_encoder,
-                                                          N_repeats=self.cfgs.N_repeats)
-        self.te_hook = ComposeTEEXHook.hook_pipe(self.pipe, N_repeats=self.cfgs.N_repeats, clip_skip=self.cfgs.clip_skip,
-                                                 clip_final_norm=self.cfgs.clip_final_norm, use_attention_mask=self.cfgs.encoder_attention_mask)
-        self.token_ex = TokenizerHook(self.pipe.tokenizer)
-
-        if is_xformers_available():
-            self.pipe.unet.enable_xformers_memory_efficient_attention()
-            # self.te_hook.enable_xformers()
-
-    def save_model(self, save_cfg):
-        for k, v in self.pipe.unet.named_modules():
-            if isinstance(v, LoraBlock):
-                v.reparameterization_to_host()
-                v.remove()
-        for k, v in self.pipe.text_encoder.named_modules():
-            if isinstance(v, LoraBlock):
-                v.reparameterization_to_host()
-                v.remove()
-
-        if save_cfg.path.endswith('.ckpt'):
-            from hcpdiff.tools.diffusers2sd import save_state_dict
-            save_state_dict(save_cfg.path, self.pipe.unet.state_dict(), self.pipe.vae.state_dict(), self.pipe.text_encoder.state_dict(),
-                            use_safetensors=save_cfg.to_safetensors)
-
-        else:
-            self.pipe.save_pretrained(save_cfg.path, safe_serialization=save_cfg.to_safetensors)
-
-    def get_pipeline(self):
-        if self.cfgs.condition is None:
-            pipe_cls = HookPipe_T2I
-        else:
-            if self.cfgs.condition.type == 'i2i':
-                pipe_cls = HookPipe_I2I
-            elif self.cfgs.condition.type == 'inpaint':
-                pipe_cls = HookPipe_Inpaint
-            else:
-                raise NotImplementedError(f'No condition type named {self.cfgs.condition.type}')
-
-        return pipe_cls
-
-    def build_offload(self, offload_cfg):
-        vram = size_to_int(offload_cfg.max_VRAM)
-        device_map = infer_auto_device_map(self.pipe.unet, max_memory={0:int_to_size(vram >> 1), "cpu":offload_cfg.max_RAM}, dtype=self.dtype)
-        self.pipe.unet = dispatch_model(self.pipe.unet, device_map)
-        if not offload_cfg.vae_cpu:
-            device_map = infer_auto_device_map(self.pipe.vae, max_memory={0:int_to_size(vram >> 5), "cpu":offload_cfg.max_RAM}, dtype=self.dtype)
-            self.pipe.vae = dispatch_model(self.pipe.vae, device_map)
-
-    def build_vae_offload(self):
-        def vae_decode_offload(latents, return_dict=True, decode_raw=self.pipe.vae.decode):
-            if self.need_inter_imgs:
-                to_cuda(self.pipe.vae)
-                res = decode_raw(latents, return_dict=return_dict)
-            else:
-                to_cpu(self.pipe.unet)
-
-                if self.offload and self.cfgs.offload.vae_cpu:
-                    self.pipe.vae.to(dtype=torch.float32)
-                    res = decode_raw(latents.cpu().to(dtype=torch.float32), return_dict=return_dict)
-                else:
-                    to_cuda(self.pipe.vae)
-                    res = decode_raw(latents.to(dtype=self.pipe.vae.dtype), return_dict=return_dict)
-
-                to_cpu(self.pipe.vae)
-                to_cuda(self.pipe.unet)
-            return res
-
-        self.pipe.vae.decode = vae_decode_offload
-
-        def vae_encode_offload(x, return_dict=True, encode_raw=self.pipe.vae.encode):
-            to_cuda(self.pipe.vae)
-            res = encode_raw(x.to(dtype=self.pipe.vae.dtype), return_dict=return_dict)
-            to_cpu(self.pipe.vae)
-            return res
-
-        self.pipe.vae.encode = vae_encode_offload
-
-    def merge_model(self):
-        if 'plugin_cfg' in self.cfg_merge:  # Build plugins
-            if isinstance(self.cfg_merge.plugin_cfg, str):
-                plugin_cfg = load_config(self.cfg_merge.plugin_cfg)
-                plugin_cfg = {'plugin_unet': hydra.utils.instantiate(plugin_cfg['plugin_unet']),
-                              'plugin_TE': hydra.utils.instantiate(plugin_cfg['plugin_TE'])}
-            else:
-                plugin_cfg = self.cfg_merge.plugin_cfg
-            make_plugin(self.pipe.unet, plugin_cfg['plugin_unet'])
-            make_plugin(self.pipe.text_encoder, plugin_cfg['plugin_TE'])
-
-        load_ema = self.cfg_merge.get('load_ema', False)
-        for cfg_group in self.cfg_merge.values():
-            if hasattr(cfg_group, 'type'):
-                if cfg_group.type == 'unet':
-                    HCPModelLoader(self.pipe.unet).load_all(cfg_group, load_ema=load_ema)
-                elif cfg_group.type == 'TE':
-                    HCPModelLoader(self.pipe.text_encoder).load_all(cfg_group, load_ema=load_ema)
-
-    def set_scheduler(self, scheduler):
-        self.pipe.scheduler = scheduler
-
-    def get_ex_input(self):
-        ex_input_dict, pipe_input_dict = {}, {}
-        if self.cfgs.condition is not None:
-            if self.cfgs.condition.type == 'i2i':
-                pipe_input_dict['image'] = Image.open(self.cfgs.condition.image).convert('RGB')
-            elif self.cfgs.condition.type == 'inpaint':
-                pipe_input_dict['image'] = Image.open(self.cfgs.condition.image).convert('RGB')
-                pipe_input_dict['mask_image'] = Image.open(self.cfgs.condition.mask).convert('L')
-
-        if getattr(self.cfgs, 'ex_input', None) is not None:
-            for key, processor in self.cfgs.ex_input.items():
-                ex_input_dict[key] = processor(self.cfgs.infer_args.width, self.cfgs.infer_args.height, self.cfgs.bs*2, 'cuda', self.dtype)
-        return ex_input_dict, pipe_input_dict
-
-    @torch.no_grad()
-    def vis_images(self, prompt, negative_prompt='', seeds: List[int] = None, **kwargs):
-        G = prepare_seed(seeds or [None]*len(prompt))
-
-        ex_input_dict, pipe_input_dict = self.get_ex_input()
-        kwargs.update(pipe_input_dict)
-
-        to_cuda(self.pipe.text_encoder)
-
-        mult_p, clean_text_p = self.token_ex.parse_attn_mult(prompt)
-        mult_n, clean_text_n = self.token_ex.parse_attn_mult(negative_prompt)
-        with autocast(enabled=self.cfgs.amp, dtype=self.dtype):
-            if hasattr(self.pipe.text_encoder, 'input_feeder'):
-                for feeder in self.pipe.text_encoder.input_feeder:
-                    feeder(ex_input_dict)
-
-            emb, pooled_output, attention_mask = self.te_hook.encode_prompt_to_emb(clean_text_n+clean_text_p)
-            if self.cfgs.encoder_attention_mask:
-                emb, attention_mask = pad_attn_bias(emb, attention_mask)
-            else:
-                attention_mask = None
-            emb_n, emb_p = emb.chunk(2)
-            emb_p = self.te_hook.mult_attn(emb_p, mult_p)
-            emb_n = self.te_hook.mult_attn(emb_n, mult_n)
-
-            to_cpu(self.pipe.text_encoder)
-            to_cuda(self.pipe.unet)
-
-            if hasattr(self.pipe.unet, 'input_feeder'):
-                for feeder in self.pipe.unet.input_feeder:
-                    feeder(ex_input_dict)
-
-            images = self.pipe(prompt_embeds=emb_p, negative_prompt_embeds=emb_n, callback=self.inter_callback, generator=G,
-                               pooled_output=pooled_output[-1], encoder_attention_mask=attention_mask, **kwargs).images
-        return images
-
-    def inter_callback(self, i, t, num_t, latents_x0, latents):
-        images = None
-        interrupt = False
-        for interface in self.cfgs.interface:
-            if interface.show_steps>0 and i%interface.show_steps == 0:
-                if self.need_inter_imgs and images is None:
-                    images = self.pipe.decode_latents(latents_x0)
-                    images = self.pipe.numpy_to_pil(images)
-                feed_back = interface.on_inter_step(i, num_t, t, latents_x0, images)
-                interrupt |= bool(feed_back)
-        return None if interrupt else latents
-
-    def save_images(self, images, prompt, negative_prompt='', seeds: List[int] = None):
-        for interface in self.cfgs.interface:
-            interface.on_infer_finish(images, prompt, negative_prompt, self.cfgs_raw, seeds=seeds)
-
-    def vis_to_dir(self, prompt, negative_prompt='', seeds: List[int] = None, **kwargs):
-        seeds = [s or random.randint(0, 1 << 30) for s in seeds]
-
-        images = self.vis_images(prompt, negative_prompt, seeds=seeds, **kwargs)
-        self.save_images(images, prompt, negative_prompt, seeds=seeds)
-
-if __name__ == '__main__':
-    parser = argparse.ArgumentParser(description='HCP Diffusion Inference')
-    parser.add_argument('--cfg', type=str, default='')
-    args, cfg_args = parser.parse_known_args()
-    cfgs = load_config_with_cli(args.cfg, args_list=cfg_args)  # skip --cfg
-
-    cfgs = InferCFGConverter().convert(cfgs) # support old cfgs format
-
-    if cfgs.seed is not None:
-        if is_list(cfgs.seed):
-            assert len(cfgs.seed) == cfgs.num*cfgs.bs, 'seed list length should be equal to num*bs'
-            seeds = list(cfgs.seed)
-        else:
-            seeds = list(range(cfgs.seed, cfgs.seed+cfgs.num*cfgs.bs))
-    else:
-        seeds = [None]*(cfgs.num*cfgs.bs)
-
-    viser = Visualizer(cfgs)
-    for i in range(cfgs.num):
-        prompt = cfgs.prompt[i*cfgs.bs:(i+1)*cfgs.bs] if is_list(cfgs.prompt) else [cfgs.prompt]*cfgs.bs
-        negative_prompt = cfgs.neg_prompt[i*cfgs.bs:(i+1)*cfgs.bs] if is_list(cfgs.neg_prompt) else [cfgs.neg_prompt]*cfgs.bs
-        viser.vis_to_dir(prompt=prompt, negative_prompt=negative_prompt,
-                         seeds=seeds[i*cfgs.bs:(i+1)*cfgs.bs], save_cfg=cfgs.save.save_cfg, **cfgs.infer_args)

hcpdiff/visualizer_reloadable.py

@@ -1,237 +0,0 @@
-from hcpdiff.visualizer import Visualizer
-import accelerate.hooks
-from omegaconf import OmegaConf
-from hcpdiff.models import EmbeddingPTHook
-import hydra
-from diffusers import AutoencoderKL, PNDMScheduler
-import torch
-from hcpdiff.utils.cfg_net_tools import HCPModelLoader, make_plugin
-from hcpdiff.utils import load_config, hash_str
-from copy import deepcopy
-
-class VisualizerReloadable(Visualizer):
-    def __init__(self, cfgs):
-        self.lora_dict = {}
-        self.part_plugin_cfg_set = set()
-        super().__init__(cfgs)
-
-    def _merge_model(self, cfg_merge):
-        if 'plugin_cfg' in cfg_merge:  # Build plugins
-            plugin_cfg = hydra.utils.instantiate(load_config(cfg_merge.plugin_cfg))
-            make_plugin(self.pipe.unet, plugin_cfg.plugin_unet)
-            make_plugin(self.pipe.text_encoder, plugin_cfg.plugin_TE)
-
-        for cfg_group in cfg_merge.values():
-            if hasattr(cfg_group, 'type'):
-                if cfg_group.type == 'unet':
-                    lora_group = HCPModelLoader(self.pipe.unet).load_all(cfg_group)
-                elif cfg_group.type == 'TE':
-                    lora_group = HCPModelLoader(self.pipe.text_encoder).load_all(cfg_group)
-                else:
-                    raise ValueError(f'no host model type named {cfg_group.type}')
-
-                # record all lora plugin with its config hash
-                if not lora_group.empty():
-                    for cfg_lora, lora_plugin in zip(cfg_group.lora, lora_group.plugin_dict.values()):
-                        self.lora_dict[hash_str(OmegaConf.to_yaml(cfg_lora, resolve=True))] = lora_plugin
-
-                # record all part and plugin config hash
-                for cfg_part in getattr(cfg_group, "part", None) or []:
-                    self.part_plugin_cfg_set.add(hash_str(OmegaConf.to_yaml(cfg_part, resolve=True)))
-                for cfg_plugin in getattr(cfg_group, "plugin", None) or []:
-                    self.part_plugin_cfg_set.add(hash_str(OmegaConf.to_yaml(cfg_plugin, resolve=True)))
-
-    def merge_model(self):
-        self.part_plugin_cfg_set.clear()
-        self.lora_dict.clear()
-        self._merge_model(self.cfg_merge)
-
-    def part_plugin_changed(self):
-        if not self.cfg_merge:
-            return not self.cfg_same(self.cfg_merge, self.cfgs_old.merge)
-        part_plugin_cfg_set_new = set()
-        for cfg_group in self.cfg_merge.values():
-            for cfg_part in getattr(cfg_group, "part", None) or []:
-                part_plugin_cfg_set_new.add(hash_str(OmegaConf.to_yaml(cfg_part, resolve=True)))
-            for cfg_plugin in getattr(cfg_group, "plugin", None) or []:
-                part_plugin_cfg_set_new.add(hash_str(OmegaConf.to_yaml(cfg_plugin, resolve=True)))
-        return part_plugin_cfg_set_new !=  self.part_plugin_cfg_set
-
-    @staticmethod
-    def cfg_same(cfg1, cfg2):
-        if cfg1 is None:
-            return cfg2 is None
-        elif cfg2 is None:
-            return cfg1 is None
-        else:
-            return OmegaConf.to_yaml(cfg1) == OmegaConf.to_yaml(cfg2)
-
-    def reload_offload(self) -> bool:
-        if not self.cfg_same(self.cfgs_raw.offload, self.cfgs_raw_old.offload):
-            if self.offload_old:
-                # remove offload hooks
-                accelerate.hooks.remove_hook_from_module(self.pipe.unet, recurse=True)
-                accelerate.hooks.remove_hook_from_module(self.pipe.vae, recurse=True)
-        else:
-            return False
-
-        if self.offload:
-            self.pipe.unet.to('cpu')
-            self.pipe.vae.to('cpu')
-            torch.cuda.empty_cache()
-            torch.cuda.synchronize()
-            self.build_offload(self.cfgs.offload)
-        else:
-            self.pipe.unet.to('cuda')
-        return True
-
-    def reload_emb_hook(self) -> bool:
-        if self.cfgs.emb_dir!=self.cfgs_old.emb_dir or self.cfgs.N_repeats!=self.cfgs_old.N_repeats:
-            self.emb_hook.remove()
-            self.emb_hook, _ = EmbeddingPTHook.hook_from_dir(self.cfgs.emb_dir, self.pipe.tokenizer, self.pipe.text_encoder,
-                                                         N_repeats=self.cfgs.N_repeats)
-            return True
-        return False
-
-    def reload_te_hook(self) -> bool:
-        if self.cfgs.clip_skip != self.cfgs_old.clip_skip or self.cfgs.N_repeats != self.cfgs_old.N_repeats:
-            self.te_hook.N_repeats = self.cfgs.N_repeats
-            self.te_hook.clip_skip = self.cfgs.clip_skip
-            return True
-        return False
-
-    def reload_model(self) -> bool:
-        pipeline = self.get_pipeline()
-        if self.cfgs.pretrained_model!=self.cfgs_old.pretrained_model or self.part_plugin_changed():
-            comp = pipeline.from_pretrained(self.cfgs.pretrained_model, safety_checker=None, requires_safety_checker=False,
-                                        torch_dtype=self.dtype).components
-            if 'vae' in self.cfgs.new_components:
-                self.cfgs.new_components.vae = hydra.utils.instantiate(self.cfgs.new_components.vae)
-            comp.update(self.cfgs.new_components)
-            self.pipe = pipeline(**comp)
-            if self.cfg_merge:
-                self.merge_model()
-            self.pipe = self.pipe.to(torch_dtype=self.dtype)
-            self.build_optimize()
-            return True
-        return False
-
-    def reload_pipe(self) -> bool:
-        pipeline = self.get_pipeline()
-        if type(self.pipe)!=pipeline:
-            self.pipe = pipeline(**self.pipe.components)
-            return True
-        return False
-
-
-    def reload_scheduler(self) -> bool:
-        if 'scheduler' in self.cfgs_raw_old.new_components and 'scheduler' not in self.cfgs_raw.new_components:
-            # load default scheduler
-            self.pipe.scheduler = PNDMScheduler.from_pretrained(self.cfgs.pretrained_model, subfolder='scheduler', torch_dtype=self.dtype)
-            return True
-        elif not self.cfg_same(getattr(self.cfgs_raw_old.new_components, 'scheduler', {}), getattr(self.cfgs_raw.new_components, 'scheduler', {})):
-            self.pipe.scheduler = self.cfgs.new_components.scheduler
-            return True
-        return False
-
-    def reload_vae(self) -> bool:
-        if 'vae' in self.cfgs_raw_old.new_components and 'vae' not in self.cfgs_raw.new_components:
-            # load default VAE
-            self.cfgs.new_components.vae = AutoencoderKL.from_pretrained(self.cfgs.pretrained_model, subfolder='vae', torch_dtype=self.dtype)
-            return True
-        elif not self.cfg_same(getattr(self.cfgs_raw_old.new_components, 'vae', {}), getattr(self.cfgs_raw.new_components, 'vae', {})):
-            # VAE config changed, need reload
-            if 'vae' in self.cfgs_old.new_components:
-                del self.cfgs_old.new_components.vae
-                torch.cuda.empty_cache()
-            self.cfgs.new_components.vae = hydra.utils.instantiate(self.cfgs.new_components.vae)
-            self.pipe.vae = self.cfgs.new_components.vae
-            return True
-        return False
-
-    def reload_lora(self):
-        if self.cfg_merge is None:
-            if self.cfgs_old.merge is None:
-                return False
-            else:
-                for lora in self.lora_dict.values():
-                    lora.remove()
-                self.lora_dict.clear()
-                return True
-
-        cfg_merge = deepcopy(self.cfg_merge)
-        all_lora_hash = set()
-        for k, cfg_group in self.cfg_merge.items():
-            if 'part' in cfg_merge[k]:
-                del cfg_merge[k].part
-            if 'plugin' in cfg_merge[k]:
-                del cfg_merge[k].plugin
-
-            lora_add = []
-            for cfg_lora in getattr(cfg_group, "lora", None) or []:
-                cfg_hash = hash_str(OmegaConf.to_yaml(cfg_lora, resolve=True))
-                if cfg_hash not in self.lora_dict:
-                    lora_add.append(cfg_lora)
-                    all_lora_hash.add(cfg_hash)
-            cfg_merge[k].lora = OmegaConf.create(lora_add)
-
-        lora_rm_set = set(self.lora_dict.keys())-all_lora_hash
-        for cfg_hash in lora_rm_set:
-            self.lora_dict[cfg_hash].remove()
-        for cfg_hash in lora_rm_set:
-            del self.lora_dict[cfg_hash]
-
-        self._merge_model(cfg_merge)
-
-    def check_reload(self, cfgs):
-        '''
-        Reload and modify each module based on the changes of configuration file.
-        '''
-        self.cfgs_raw_old = self.cfgs_raw
-        self.cfgs_old = self.cfgs
-        self.offload_old = self.offload
-
-        self.cfgs_raw = cfgs
-
-        # Reload vae only when vae config changes
-        if 'vae' in self.cfgs_raw.new_components:
-            vae_cfg = self.cfgs_raw.new_components.vae
-            self.cfgs_raw.new_components.vae = None
-            self.cfgs = hydra.utils.instantiate(self.cfgs_raw)
-            self.cfgs_raw.new_components.vae = vae_cfg
-            self.cfgs.new_components.vae = vae_cfg
-        else:
-            self.cfgs = hydra.utils.instantiate(self.cfgs_raw)
-
-        self.cfg_merge = self.cfgs.merge
-        self.offload = 'offload' in self.cfgs and self.cfgs.offload is not None
-        self.dtype = self.dtype_dict[self.cfgs.dtype]
-
-        self.need_inter_imgs = any(item.need_inter_imgs for item in self.cfgs.interface)
-
-        is_model_reload = self.reload_model()
-        if not is_model_reload:
-            is_vae_reload = self.reload_vae()
-            if is_vae_reload:
-                self.build_vae_offload()
-            self.reload_lora()
-            self.reload_scheduler()
-            self.reload_offload()
-            self.reload_emb_hook()
-            self.reload_te_hook()
-            self.reload_pipe()
-
-        if getattr(self.cfgs, 'vae_optimize', None) is not None:
-            if self.cfgs.vae_optimize.tiling:
-                self.pipe.vae.enable_tiling()
-            else:
-                self.pipe.vae.disable_tiling()
-
-            if self.cfgs.vae_optimize.slicing:
-                self.pipe.vae.enable_slicing()
-            else:
-                self.pipe.vae.disable_slicing()
-
-        del self.cfgs_raw_old
-        del self.cfgs_old
-

hcpdiff/workflow/base.py

@@ -1,59 +0,0 @@
-from typing import List, Dict
-from tqdm.auto import tqdm
-
-class from_memory:
-    #TODO: add memory for all from_memory in cfg
-    def __init__(self, memory, mem_name):
-        self.mem_name = mem_name
-        self.memory = memory
-
-    def __call__(self):
-        memory = self.memory # use in eval
-        return eval(f'memory.{self.mem_name}')
-
-def from_memory_context(fun):
-    def f(*args, **kwargs):
-        filter_kwargs = {k: (v() if isinstance(v, from_memory) else v) for k,v in kwargs.items()}
-        return fun(*args, **filter_kwargs)
-    return f
-
-class BasicAction:
-    def __init__(self):
-        pass
-
-    def __call__(self, *args, **kwargs):
-        return self.forward(*args, **kwargs)
-
-    def forward(self, *args, **kwargs):
-        raise NotImplementedError()
-
-class MemoryMixin:
-    pass
-
-class ExecAction(BasicAction, MemoryMixin):
-    def __init__(self, prog:str):
-        self.prog = prog
-
-    def forward(self, memory, **states):
-        exec(self.prog)
-        return states
-
-class LoopAction(BasicAction, MemoryMixin):
-    def __init__(self, loop_value:Dict[str, str], actions:List[BasicAction]):
-        self.loop_value = loop_value
-        self.actions = actions
-
-    def forward(self, memory, **states):
-        loop_data = [states.pop(k) for k in self.loop_value.keys()]
-        pbar = tqdm(zip(*loop_data), total=len(loop_data[0]))
-        N_steps = len(self.actions)
-        for data in pbar:
-            feed_data = {k:v for k,v in zip(self.loop_value.values(), data)}
-            states.update(feed_data)
-            for step, act in enumerate(self.actions):
-                pbar.set_description(f'[{step+1}/{N_steps}] action: {type(act).__name__}')
-                if isinstance(act, MemoryMixin):
-                    states = act(memory=memory, **states)
-                else:
-                    states = act(**states)
-        return states

hcpdiff-0.9.1.data/data/hcpdiff/cfgs/infer/anime/text2img_anime.yaml

@@ -1,21 +0,0 @@
-_base_: [cfgs/infer/text2img.yaml]
-
-pretrained_model: 'deepghs/animefull-latest'  # animefull-latest model
-prompt: 'masterpiece, best quality, 1girl, solo, tohsaka rin'  # image of 远坂凛(tohsaka rin)
-neg_prompt: 'lowres, bad anatomy, bad hands, text, error, missing fingers, extra digit, fewer digits, cropped, worst quality, low quality, normal quality, jpeg artifacts, signature, watermark, username, blurry'
-
-clip_skip: 1 #动漫模型通常会跳过一个CLIP层
-
-infer_args:
-  width: 512
-  height: 768  # image size
-  guidance_scale: 7.5  # scale, when higher, the images will tend to be more similar
-  num_inference_steps: 30  # how many steps
-
-new_components:
-  scheduler:
-    _target_: diffusers.EulerAncestralDiscreteScheduler # change Sampler
-    beta_start: 0.00085
-    beta_end: 0.012
-    beta_schedule: 'scaled_linear'
-

hcpdiff-0.9.1.data/data/hcpdiff/cfgs/infer/anime/text2img_anime_lora.yaml

@@ -1,58 +0,0 @@
-_base_: 
-  - cfgs/infer/anime/text2img_anime.yaml
-
-pretrained_model: 'stablediffusionapi/anything-v5'  # better generic anime model
-
-# safe prompt
-prompt: 'masterpiece, best quality, highres, game cg, 1girl, solo, {night}, {starry sky}, beach, beautiful detailed sky, {extremely detailed background:1.2}, mature, {surtr_arknights-${model_steps}:1.2}, red_hair, horns, long_hair, purple_eyes, bangs, looking_at_viewer, bare_shoulders, hair_between_eyes, cleavage, {standing}, looking at viewer, {bikini:1.3}, light smile'
-
-# r18 prompt
-# prompt: 'nsfw, masterpiece, best quality, highres, 1girl, solo, {lyging on bed}, {extremely detailed background:1.2}, {nude:1.4}, {spread legs}, {arms up}, mature, {surtr_arknights-1000:1.2}, red_hair, horns, long_hair, purple_eyes, bangs, looking_at_viewer, bare_shoulders, hair_between_eyes, cleavage, nipples, {pussy:1.15}, {pussy juice:1.3}, looking at viewer, {embarrassed}, endured face, feet out of frame'
-
-# negative prompt
-neg_prompt: 'lowres, bad anatomy, bad hands, text, error, missing fingers, extra digit, fewer digits, cropped, worst quality, low quality, normal quality, jpeg artifacts, signature, watermark, username, blurry, white border'
-N_repeats: 2  # if prompt or neg_prompt is too long, increase this number
-
-bs: 1
-num: 1
-
-# when seed is not set, random seed will be used
-# seed: 758691538  # seed for safe
-# seed: 465191133  # seed for r18
-
-infer_args:
-  width: 512
-  height: 768  # image size
-  guidance_scale: 7.5  # scale, when higher, the images will tend to be more similar
-  num_inference_steps: 30  # how many steps
-
-exp_dir: 'exps/2023-07-26-01-05-35'  # experiment directory
-model_steps: 1000  # steps of selected model
-emb_dir: '${exp_dir}/ckpts/'
-output_dir: 'output/'
-
-merge:
-  alpha: 0.85 # lora权重, default: 0.85
-
-  group1:
-    type: 'unet'
-    base_model_alpha: 1.0 # base model weight to merge with lora or part
-    lora:
-      - path: '${.....exp_dir}/ckpts/unet-${.....model_steps}.safetensors'
-        alpha: ${....alpha}
-        layers: 'all'
-    part: null
-
-  group2:
-    type: 'TE'
-    base_model_alpha: 1.0 # base model weight to merge with lora or part
-    lora:
-      - path: '${.....exp_dir}/ckpts/text_encoder-${.....model_steps}.safetensors'
-        alpha: ${....alpha}
-        layers: 'all'
-    part: null
-
-interface:
-  - _target_: hcpdiff.vis.DiskInterface
-    show_steps: 0
-    save_root: '${output_dir}'

hcpdiff-0.9.1.data/data/hcpdiff/cfgs/infer/change_vae.yaml

@@ -1,6 +0,0 @@
-_base_: [cfgs/infer/text2img.yaml]
-
-new_components:
-  vae:
-    _target_: diffusers.AutoencoderKL.from_pretrained
-    pretrained_model_name_or_path: 'any3.0/vae' # path to vae model

hcpdiff-0.9.1.data/data/hcpdiff/cfgs/infer/euler_a.yaml

@@ -1,8 +0,0 @@
-_base_: [cfgs/infer/text2img.yaml]
-
-new_components:
-  scheduler:
-    _target_: diffusers.EulerAncestralDiscreteScheduler # change Sampler
-    beta_start: 0.00085
-    beta_end: 0.012
-    beta_schedule: 'scaled_linear'

hcpdiff-0.9.1.data/data/hcpdiff/cfgs/infer/img2img.yaml

@@ -1,10 +0,0 @@
-_base_: [cfgs/infer/text2img.yaml]
-
-condition:
-  type: i2i
-  image: 'cond_img.png'
-
-infer_args:
-  guidance_scale: 7.5
-  num_inference_steps: 50
-  strength: 0.75