From 09d1d398b555f7ec7c5f780dca6f6648bbc26c13 Mon Sep 17 00:00:00 2001 From: jesenzhang Date: Fri, 29 Dec 2023 17:26:23 +0800 Subject: [PATCH] delete delete no need functions --- nodes.py | 309 ------------------------------------------------------ single.py | 70 ------------- 2 files changed, 379 deletions(-) delete mode 100644 single.py diff --git a/nodes.py b/nodes.py index 05a6505..d499d1b 100644 --- a/nodes.py +++ b/nodes.py @@ -49,58 +49,6 @@ def get_async_loop(): return loop -class StreamDiffusion_LoRA_Stacker: - modes = ["simple", "advanced"] - - @classmethod - def INPUT_TYPES(cls): - loras = ["None"] + folder_paths.get_filename_list("loras") - inputs = { - "required": { - "input_mode": (cls.modes,), - "lora_count": ("INT", {"default": 3, "min": 0, "max": 50, "step": 1}), - } - } - - for i in range(1, 50): - inputs["required"][f"lora_name_{i}"] = (loras,) - inputs["required"][f"lora_wt_{i}"] = ("FLOAT", {"default": 1.0, "min": -10.0, "max": 10.0, "step": 0.01}) - inputs["required"][f"model_str_{i}"] = ("FLOAT", {"default": 1.0, "min": -10.0, "max": 10.0, "step": 0.01}) - inputs["required"][f"clip_str_{i}"] = ("FLOAT", {"default": 1.0, "min": -10.0, "max": 10.0, "step": 0.01}) - - inputs["optional"] = { - "lora_stack": ("LORA_STACK",) - } - return inputs - - RETURN_TYPES = ("LORA_STACK",) - RETURN_NAMES = ("LORA_STACK",) - FUNCTION = "lora_stacker" - CATEGORY = "StreamDiffusion/Stackers" - - def lora_stacker(self, input_mode, lora_count, lora_stack=None, **kwargs): - - # Extract values from kwargs - loras = [kwargs.get(f"lora_name_{i}") for i in range(1, lora_count + 1)] - - # Create a list of tuples using provided parameters, exclude tuples with lora_name as "None" - if input_mode == "simple": - weights = [kwargs.get(f"lora_wt_{i}") for i in range(1, lora_count + 1)] - loras = [(lora_name, lora_weight, lora_weight) for lora_name, lora_weight in zip(loras, weights) if - lora_name != "None"] - else: - model_strs = [kwargs.get(f"model_str_{i}") for i in range(1, lora_count + 1)] - clip_strs = [kwargs.get(f"clip_str_{i}") for i in range(1, lora_count + 1)] - loras = [(lora_name, model_str, clip_str) for lora_name, model_str, clip_str in - zip(loras, model_strs, clip_strs) if lora_name != "None"] - - # If lora_stack is not None, extend the loras list with lora_stack - if lora_stack is not None: - loras.extend([l for l in lora_stack if l[0] != "None"]) - - return (loras,) - - class StreamDiffusion_Loader: @classmethod def INPUT_TYPES(s): @@ -286,270 +234,13 @@ class StreamDiffusion_Sampler: return (output,) - -def original( - output: str = r"G:\Workspace\AI\ComfyUI\output\output.png", - model_id_or_path: str = "KBlueLeaf/kohaku-v2.1", - lora_dict: Optional[Dict[str, float]] = None, - prompt: str = "a dog is running in the garden", - width: int = 512, - height: int = 512, - acceleration: Literal["none", "xformers", "tensorrt"] = "xformers", - use_denoising_batch: bool = False, - seed: int = 2, -): - - """ - Process for generating images based on a prompt using a specified model. - - Parameters - ---------- - output : str, optional - The output image file to save images to. - model_id_or_path : str - The name of the model to use for image generation. - lora_dict : Optional[Dict[str, float]], optional - The lora_dict to load, by default None. - Keys are the LoRA names and values are the LoRA scales. - Example: {'LoRA_1' : 0.5 , 'LoRA_2' : 0.7 ,...} - prompt : str - The prompt to generate images from. - width : int, optional - The width of the image, by default 512. - height : int, optional - The height of the image, by default 512. - acceleration : Literal["none", "xformers", "tensorrt"] - The type of acceleration to use for image generation. - use_denoising_batch : bool, optional - Whether to use denoising batch or not, by default False. - seed : int, optional - The seed, by default 2. if -1, use random seed. - """ - - stream = StreamDiffusionWrapper( - model_id_or_path=model_id_or_path, - lora_dict=lora_dict, - t_index_list=[0, 16, 32, 45], - frame_buffer_size=1, - width=width, - height=height, - warmup=10, - acceleration=acceleration, - mode="txt2img", - use_denoising_batch=use_denoising_batch, - cfg_type="none", - seed=seed, - ) - - stream.prepare( - prompt=prompt, - num_inference_steps=50, - ) - - for _ in range(stream.batch_size - 1): - stream() - - output_image = stream() - output_image.save(output) - -class StreamDiffusion_Wrapper: - @classmethod - def INPUT_TYPES(s): - loras = ["None"] + folder_paths.get_filename_list("loras") - - return { - "required":{ - - "ckpt_name": (["Baked ckpt"]+folder_paths.get_filename_list("checkpoints"), ), - "vae_name": (["Baked VAE"] + folder_paths.get_filename_list("vae"),), - "lcm_lora": (loras,), - "acceleration": (["none", "xfomers", "sfast", "tensorrt"],), - - "use_tiny_vae": ("BOOLEAN", { "default": True }), - "use_lcm_lora": ("BOOLEAN", { "default": True }), - - - "positive": ("STRING", {"default": "CLIP_POSITIVE","multiline": True}), - "negative": ("STRING", {"default": "CLIP_NEGATIVE", "multiline": True}), - "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}), - "steps": ("INT", {"default": 50, "min": 1, "max": 10000}), - "cfg": ("FLOAT", {"default": 1.2, "min": 0.0, "max": 100.0}), - "delta": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 100.0}), - - "width": ("INT", {"default": 512, "min": 0, "max": MAX_RESOLUTION, "step": 1}), - "height": ("INT", {"default": 512, "min": 0, "max": MAX_RESOLUTION, "step": 1}), - "batch_size": ("INT", {"default": 1, "min": 1, "max": 10000, "step": 1}),#The frame buffer size for denoising batch, by default 1. - - "index_list": ("STRING", {"default": "32,40,45","multiline": False}), - - "cfg_type": (["none", "full", "self", "initialize"],), - - "add_noise": ("BOOLEAN", { "default": True }), - "use_denoising_batch": ("BOOLEAN", { "default": True }), - "enable_similar_image_filter": ("BOOLEAN", { "default": True }), - "use_safety_checker": ("BOOLEAN", { "default": True }), - - }, - "optional": { - "similar_image_filter_threshold": ("FLOAT", {"default": 0.98, "min": 0.0, "max": 100.0,"step": 0.01}), - "similar_image_filter_max_skip_frame": ("INT", {"default": 10, "min": 0, "max": 100}), - "image": ("IMAGE",), - "lora_stack": ("LORA_STACK", ), - } - } - - RETURN_TYPES = ("IMAGE",) - RETURN_NAMES = ("IMAGE",) - - FUNCTION = "sample" - CATEGORY = "StreamDiffusion/Wrapper" - - @torch.no_grad() - def sample(self,ckpt_name,vae_name,lcm_lora,acceleration,use_tiny_vae,use_lcm_lora,positive,negative,seed,steps,cfg,delta,width,height,batch_size,index_list,cfg_type,add_noise,use_denoising_batch,enable_similar_image_filter=False,use_safety_checker=False,similar_image_filter_threshold= 0.98,similar_image_filter_max_skip_frame=10,image=None,lora_stack=None): - - device = comfy.model_management.get_torch_device() - device_name = comfy.model_management.get_torch_device_name(device) - vae_dtype=comfy.model_management.vae_dtype() - unet_dtype=comfy.model_management.unet_dtype - text_encoder_dtype=comfy.model_management.text_encoder_dtype - output_device = comfy.model_management.intermediate_device() - - if ckpt_name =='Baked ckpt': - ckpt_path="KBlueLeaf/kohaku-v2.1" - else: - ckpt_path = folder_paths.get_full_path("checkpoints", ckpt_name) - - if vae_name=='Baked VAE': - vae_id = None - else: - vae_id=vae_name - - if lcm_lora=='None': - lcm_lora_id=None - else: - lcm_lora_id= folder_paths.get_full_path("loras", lcm_lora) - - lora_dict =None - if lora_stack is not None: - lora_dict={} - for lora_name, lora_scale, strength_clip in lora_stack: - full_lora_name=folder_paths.get_full_path("loras", lora_name) - lora_dict[full_lora_name]=lora_scale - - - t_index_list=[32,40,45] - t_index_list =[int(i) for i in index_list.split(',')] - - if image ==None: - mode = "txt2img" - else: - mode = "img2img" - image = image.movedim(-1,1) - - if cfg <= 1.0: - cfg_type = "none" - - if batch_size>1 and mode=="txt2img": - use_denoising_batch=False - - stream = StreamDiffusionWrapper( - model_id_or_path=ckpt_path, - lora_dict=lora_dict, - t_index_list=t_index_list, - frame_buffer_size=batch_size, - width=width, - height=height, - warmup=10, - acceleration=acceleration, - mode=mode, - use_denoising_batch=use_denoising_batch, - cfg_type=cfg_type, - seed=seed, - use_tiny_vae =use_tiny_vae, - do_add_noise = add_noise, - device=device, - use_lcm_lora = use_lcm_lora, - output_type = 'pt', - dtype = torch.float16, - lcm_lora_id=lcm_lora_id, - vae_id =vae_id, - enable_similar_image_filter = enable_similar_image_filter, - similar_image_filter_threshold =similar_image_filter_threshold, - similar_image_filter_max_skip_frame=similar_image_filter_max_skip_frame, - use_safety_checker = use_safety_checker, - ) - - # stream.set_sampler_param(t_index_list=t_index_list, - # width=width, - # height=height, - # do_add_noise= add_noise=='enable', - # frame_buffer_size=frame_buffer_size, - # use_denoising_batch=use_denoising_batch, - # cfg_type=cfg_type,) - - stream.prepare( - positive, - negative, - num_inference_steps=steps, - guidance_scale=cfg, - delta=delta, - # generator=torch.manual_seed(seed), - # seed=seed, - ) - # latent_image = self.predict_x0_batch( - # torch.randn((stream.batch_size, 4, stream.latent_height, stream.latent_width)).to( - # device=stream.device, dtype=stream.dtype - # ) - # ) - - # if batch_size==1: - # for _ in range(stream.batch_size - 1): - # stream() - - output = stream.sample(image).permute(0, 2, 3, 1) - - # if not isinstance(output,list): - # output_pils=[output] - # else: - # output_pils=output - - # output_images=[] - # output_masks=[] - - # for i in output_pils: - # i = ImageOps.exif_transpose(i) - # image = i.convert("RGB") - # image = np.array(image).astype(np.float32) / 255.0 - # image = torch.from_numpy(image)[None,] - # if 'A' in i.getbands(): - # mask = np.array(i.getchannel('A')).astype(np.float32) / 255.0 - # mask = 1. - torch.from_numpy(mask) - # else: - # mask = torch.zeros((64,64), dtype=torch.float32, device="cpu") - # output_images.append(image) - # output_masks.append(mask.unsqueeze(0)) - - # if len(output_images) > 1: - # output_image = torch.cat(output_images, dim=0) - # output_mask = torch.cat(output_masks, dim=0) - # else: - # output_image = output_images[0] - # output_mask = output_masks[0] - - return (output,) - - NODE_CLASS_MAPPINGS = { "StreamDiffusion_Loader": StreamDiffusion_Loader, "StreamDiffusion_Sampler":StreamDiffusion_Sampler, - "StreamDiffusion_LoRA_Stacker":StreamDiffusion_LoRA_Stacker, - "StreamDiffusion_Wrapper":StreamDiffusion_Wrapper } NODE_DISPLAY_NAME_MAPPINGS = { "StreamDiffusion_Loader": "StreamDiffusion_Loader", "StreamDiffusion_Sampler":"StreamDiffusion_Sampler", - "StreamDiffusion_LoRA_Stacker":"StreamDiffusion_LoRA_Stacker", - "StreamDiffusion_Wrapper":"StreamDiffusion_Wrapper", } \ No newline at end of file diff --git a/single.py b/single.py deleted file mode 100644 index 20b2557..0000000 --- a/single.py +++ /dev/null @@ -1,70 +0,0 @@ -import os -import sys -from typing import Literal, Dict, Optional - -CURRENT_DIR = os.path.dirname(os.path.abspath(__file__)) - -def main( - output: str = os.path.join(CURRENT_DIR, "..", "..", "images", "outputs", "output.png"), - model_id_or_path: str = "KBlueLeaf/kohaku-v2.1", - lora_dict: Optional[Dict[str, float]] = None, - prompt: str = "a dog is running in the garden", - width: int = 512, - height: int = 512, - acceleration: Literal["none", "xformers", "tensorrt"] = "xformers", - use_denoising_batch: bool = False, - seed: int = 2, -): - - """ - Process for generating images based on a prompt using a specified model. - - Parameters - ---------- - output : str, optional - The output image file to save images to. - model_id_or_path : str - The name of the model to use for image generation. - lora_dict : Optional[Dict[str, float]], optional - The lora_dict to load, by default None. - Keys are the LoRA names and values are the LoRA scales. - Example: {'LoRA_1' : 0.5 , 'LoRA_2' : 0.7 ,...} - prompt : str - The prompt to generate images from. - width : int, optional - The width of the image, by default 512. - height : int, optional - The height of the image, by default 512. - acceleration : Literal["none", "xformers", "tensorrt"] - The type of acceleration to use for image generation. - use_denoising_batch : bool, optional - Whether to use denoising batch or not, by default False. - seed : int, optional - The seed, by default 2. if -1, use random seed. - """ - - stream = StreamDiffusionWrapper( - model_id_or_path=model_id_or_path, - lora_dict=lora_dict, - t_index_list=[0, 16, 32, 45], - frame_buffer_size=1, - width=width, - height=height, - warmup=10, - acceleration=acceleration, - mode="txt2img", - use_denoising_batch=use_denoising_batch, - cfg_type="none", - seed=seed, - ) - - stream.prepare( - prompt=prompt, - num_inference_steps=50, - ) - - for _ in range(stream.batch_size - 1): - stream() - - output_image = stream() - output_image.save(output)