The most powerful and modular diffusion model GUI, api and backend with a graph/nodes interface. The fastest local inference engine in the world.
Make nodes map over input lists (#579)
BlenderNeko1201d2eae582
diff --git a/comfy/sample.py b/comfy/sample.pyindex bd38585ac..284efca61 100644--- a/comfy/sample.py+++ b/comfy/sample.py@@ -2,17 +2,26 @@ import torchimport comfy.model_managementimport comfy.samplersimport math+import numpy as np-def prepare_noise(latent_image, seed, skip=0):+def prepare_noise(latent_image, seed, noise_inds=None):"""creates random noise given a latent image and a seed.optional arg skip can be used to skip and discard x number of noise generations for a given seed"""generator = torch.manual_seed(seed)- for _ in range(skip):+ if noise_inds is None:+ return torch.randn(latent_image.size(), dtype=latent_image.dtype, layout=latent_image.layout, generator=generator, device="cpu")++ unique_inds, inverse = np.unique(noise_inds, return_inverse=True)+ noises = []+ for i in range(unique_inds[-1]+1):noise = torch.randn([1] + list(latent_image.size())[1:], dtype=latent_image.dtype, layout=latent_image.layout, generator=generator, device="cpu")- noise = torch.randn(latent_image.size(), dtype=latent_image.dtype, layout=latent_image.layout, generator=generator, device="cpu")- return noise+ if i in unique_inds:+ noises.append(noise)+ noises = [noises[i] for i in inverse]+ noises = torch.cat(noises, axis=0)+ return noisesdef prepare_mask(noise_mask, shape, device):"""ensures noise mask is of proper dimensions"""diff --git a/comfy_extras/nodes_rebatch.py b/comfy_extras/nodes_rebatch.pynew file mode 100644index 000000000..0a9daf272--- /dev/null+++ b/comfy_extras/nodes_rebatch.py@@ -0,0 +1,108 @@+import torch++class LatentRebatch:+ @classmethod+ def INPUT_TYPES(s):+ return {"required": { "latents": ("LATENT",),+ "batch_size": ("INT", {"default": 1, "min": 1, "max": 64}),+ }}+ RETURN_TYPES = ("LATENT",)+ INPUT_IS_LIST = True+ OUTPUT_IS_LIST = (True, )++ FUNCTION = "rebatch"++ CATEGORY = "latent/batch"++ @staticmethod+ def get_batch(latents, list_ind, offset):+ '''prepare a batch out of the list of latents'''+ samples = latents[list_ind]['samples']+ shape = samples.shape+ mask = latents[list_ind]['noise_mask'] if 'noise_mask' in latents[list_ind] else torch.ones((shape[0], 1, shape[2]*8, shape[3]*8), device='cpu')+ if mask.shape[-1] != shape[-1] * 8 or mask.shape[-2] != shape[-2]:+ torch.nn.functional.interpolate(mask.reshape((-1, 1, mask.shape[-2], mask.shape[-1])), size=(shape[-2]*8, shape[-1]*8), mode="bilinear")+ if mask.shape[0] < samples.shape[0]:+ mask = mask.repeat((shape[0] - 1) // mask.shape[0] + 1, 1, 1, 1)[:shape[0]]+ if 'batch_index' in latents[list_ind]:+ batch_inds = latents[list_ind]['batch_index']+ else:+ batch_inds = [x+offset for x in range(shape[0])]+ return samples, mask, batch_inds++ @staticmethod+ def get_slices(indexable, num, batch_size):+ '''divides an indexable object into num slices of length batch_size, and a remainder'''+ slices = []+ for i in range(num):+ slices.append(indexable[i*batch_size:(i+1)*batch_size])+ if num * batch_size < len(indexable):+ return slices, indexable[num * batch_size:]+ else:+ return slices, None++ @staticmethod+ def slice_batch(batch, num, batch_size):+ result = [LatentRebatch.get_slices(x, num, batch_size) for x in batch]+ return list(zip(*result))++ @staticmethod+ def cat_batch(batch1, batch2):+ if batch1[0] is None:+ return batch2+ result = [torch.cat((b1, b2)) if torch.is_tensor(b1) else b1 + b2 for b1, b2 in zip(batch1, batch2)]+ return result++ def rebatch(self, latents, batch_size):+ batch_size = batch_size[0]++ output_list = []+ current_batch = (None, None, None)+ processed = 0++ for i in range(len(latents)):+ # fetch new entry of list+ #samples, masks, indices = self.get_batch(latents, i)+ next_batch = self.get_batch(latents, i, processed)+ processed += len(next_batch[2])+ # set to current if current is None+ if current_batch[0] is None:+ current_batch = next_batch+ # add previous to list if dimensions do not match+ elif next_batch[0].shape[-1] != current_batch[0].shape[-1] or next_batch[0].shape[-2] != current_batch[0].shape[-2]:+ sliced, _ = self.slice_batch(current_batch, 1, batch_size)+ output_list.append({'samples': sliced[0][0], 'noise_mask': sliced[1][0], 'batch_index': sliced[2][0]})+ current_batch = next_batch+ # cat if everything checks out+ else:+ current_batch = self.cat_batch(current_batch, next_batch)++ # add to list if dimensions gone above target batch size+ if current_batch[0].shape[0] > batch_size:+ num = current_batch[0].shape[0] // batch_size+ sliced, remainder = self.slice_batch(current_batch, num, batch_size)++ for i in range(num):+ output_list.append({'samples': sliced[0][i], 'noise_mask': sliced[1][i], 'batch_index': sliced[2][i]})++ current_batch = remainder++ #add remainder+ if current_batch[0] is not None:+ sliced, _ = self.slice_batch(current_batch, 1, batch_size)+ output_list.append({'samples': sliced[0][0], 'noise_mask': sliced[1][0], 'batch_index': sliced[2][0]})++ #get rid of empty masks+ for s in output_list:+ if s['noise_mask'].mean() == 1.0:+ del s['noise_mask']++ return (output_list,)++NODE_CLASS_MAPPINGS = {+ "RebatchLatents": LatentRebatch,+}++NODE_DISPLAY_NAME_MAPPINGS = {+ "RebatchLatents": "Rebatch Latents",+}\ No newline at end of filediff --git a/execution.py b/execution.pyindex 0ac4d462c..cf2e5ea71 100644--- a/execution.py+++ b/execution.py@@ -26,20 +26,81 @@ def get_input_data(inputs, class_def, unique_id, outputs={}, prompt={}, extra_dainput_data_all[x] = objelse:if ("required" in valid_inputs and x in valid_inputs["required"]) or ("optional" in valid_inputs and x in valid_inputs["optional"]):- input_data_all[x] = input_data+ input_data_all[x] = [input_data]if "hidden" in valid_inputs:h = valid_inputs["hidden"]for x in h:if h[x] == "PROMPT":- input_data_all[x] = prompt+ input_data_all[x] = [prompt]if h[x] == "EXTRA_PNGINFO":if "extra_pnginfo" in extra_data:- input_data_all[x] = extra_data['extra_pnginfo']+ input_data_all[x] = [extra_data['extra_pnginfo']]if h[x] == "UNIQUE_ID":- input_data_all[x] = unique_id+ input_data_all[x] = [unique_id]return input_data_all+def map_node_over_list(obj, input_data_all, func, allow_interrupt=False):+ # check if node wants the lists+ intput_is_list = False+ if hasattr(obj, "INPUT_IS_LIST"):+ intput_is_list = obj.INPUT_IS_LIST++ max_len_input = max([len(x) for x in input_data_all.values()])++ # get a slice of inputs, repeat last input when list isn't long enough+ def slice_dict(d, i):+ d_new = dict()+ for k,v in d.items():+ d_new[k] = v[i if len(v) > i else -1]+ return d_new++ results = []+ if intput_is_list:+ if allow_interrupt:+ nodes.before_node_execution()+ results.append(getattr(obj, func)(**input_data_all))+ else:+ for i in range(max_len_input):+ if allow_interrupt:+ nodes.before_node_execution()+ results.append(getattr(obj, func)(**slice_dict(input_data_all, i)))+ return results++def get_output_data(obj, input_data_all):++ results = []+ uis = []+ return_values = map_node_over_list(obj, input_data_all, obj.FUNCTION, allow_interrupt=True)++ for r in return_values:+ if isinstance(r, dict):+ if 'ui' in r:+ uis.append(r['ui'])+ if 'result' in r:+ results.append(r['result'])+ else:+ results.append(r)++ output = []+ if len(results) > 0:+ # check which outputs need concatenating+ output_is_list = [False] * len(results[0])+ if hasattr(obj, "OUTPUT_IS_LIST"):+ output_is_list = obj.OUTPUT_IS_LIST++ # merge node execution results+ for i, is_list in zip(range(len(results[0])), output_is_list):+ if is_list:+ output.append([x for o in results for x in o[i]])+ else:+ output.append([o[i] for o in results])++ ui = dict()+ if len(uis) > 0:+ ui = {k: [y for x in uis for y in x[k]] for k in uis[0].keys()}+ return output, ui+def recursive_execute(server, prompt, outputs, current_item, extra_data, executed):unique_id = current_iteminputs = prompt[unique_id]['inputs']@@ -63,13 +124,11 @@ def recursive_execute(server, prompt, outputs, current_item, extra_data, executeserver.send_sync("executing", { "node": unique_id }, server.client_id)obj = class_def()- nodes.before_node_execution()- outputs[unique_id] = getattr(obj, obj.FUNCTION)(**input_data_all)- if "ui" in outputs[unique_id]:+ output_data, output_ui = get_output_data(obj, input_data_all)+ outputs[unique_id] = output_data+ if len(output_ui) > 0:if server.client_id is not None:- server.send_sync("executed", { "node": unique_id, "output": outputs[unique_id]["ui"] }, server.client_id)- if "result" in outputs[unique_id]:- outputs[unique_id] = outputs[unique_id]["result"]+ server.send_sync("executed", { "node": unique_id, "output": output_ui }, server.client_id)executed.add(unique_id)def recursive_will_execute(prompt, outputs, current_item):@@ -105,7 +164,8 @@ def recursive_output_delete_if_changed(prompt, old_prompt, outputs, current_iteminput_data_all = get_input_data(inputs, class_def, unique_id, outputs)if input_data_all is not None:try:- is_changed = class_def.IS_CHANGED(**input_data_all)+ #is_changed = class_def.IS_CHANGED(**input_data_all)+ is_changed = map_node_over_list(class_def, input_data_all, "IS_CHANGED")prompt[unique_id]['is_changed'] = is_changedexcept:to_delete = True@@ -261,9 +321,11 @@ def validate_inputs(prompt, item, validated):if hasattr(obj_class, "VALIDATE_INPUTS"):input_data_all = get_input_data(inputs, obj_class, unique_id)- ret = obj_class.VALIDATE_INPUTS(**input_data_all)- if ret != True:- return (False, "{}, {}".format(class_type, ret))+ #ret = obj_class.VALIDATE_INPUTS(**input_data_all)+ ret = map_node_over_list(obj_class, input_data_all, "VALIDATE_INPUTS")+ for r in ret:+ if r != True:+ return (False, "{}, {}".format(class_type, r))else:if isinstance(type_input, list):if val not in type_input:diff --git a/nodes.py b/nodes.pyindex c2201dafc..509dc0697 100644--- a/nodes.py+++ b/nodes.py@@ -629,18 +629,57 @@ class LatentFromBatch:def INPUT_TYPES(s):return {"required": { "samples": ("LATENT",),"batch_index": ("INT", {"default": 0, "min": 0, "max": 63}),+ "length": ("INT", {"default": 1, "min": 1, "max": 64}),}}RETURN_TYPES = ("LATENT",)- FUNCTION = "rotate"+ FUNCTION = "frombatch"- CATEGORY = "latent"+ CATEGORY = "latent/batch"- def rotate(self, samples, batch_index):+ def frombatch(self, samples, batch_index, length):s = samples.copy()s_in = samples["samples"]batch_index = min(s_in.shape[0] - 1, batch_index)- s["samples"] = s_in[batch_index:batch_index + 1].clone()- s["batch_index"] = batch_index+ length = min(s_in.shape[0] - batch_index, length)+ s["samples"] = s_in[batch_index:batch_index + length].clone()+ if "noise_mask" in samples:+ masks = samples["noise_mask"]+ if masks.shape[0] == 1:+ s["noise_mask"] = masks.clone()+ else:+ if masks.shape[0] < s_in.shape[0]:+ masks = masks.repeat(math.ceil(s_in.shape[0] / masks.shape[0]), 1, 1, 1)[:s_in.shape[0]]+ s["noise_mask"] = masks[batch_index:batch_index + length].clone()+ if "batch_index" not in s:+ s["batch_index"] = [x for x in range(batch_index, batch_index+length)]+ else:+ s["batch_index"] = samples["batch_index"][batch_index:batch_index + length]+ return (s,)++class RepeatLatentBatch:+ @classmethod+ def INPUT_TYPES(s):+ return {"required": { "samples": ("LATENT",),+ "amount": ("INT", {"default": 1, "min": 1, "max": 64}),+ }}+ RETURN_TYPES = ("LATENT",)+ FUNCTION = "repeat"++ CATEGORY = "latent/batch"++ def repeat(self, samples, amount):+ s = samples.copy()+ s_in = samples["samples"]++ s["samples"] = s_in.repeat((amount, 1,1,1))+ if "noise_mask" in samples and samples["noise_mask"].shape[0] > 1:+ masks = samples["noise_mask"]+ if masks.shape[0] < s_in.shape[0]:+ masks = masks.repeat(math.ceil(s_in.shape[0] / masks.shape[0]), 1, 1, 1)[:s_in.shape[0]]+ s["noise_mask"] = samples["noise_mask"].repeat((amount, 1,1,1))+ if "batch_index" in s:+ offset = max(s["batch_index"]) - min(s["batch_index"]) + 1+ s["batch_index"] = s["batch_index"] + [x + (i * offset) for i in range(1, amount) for x in s["batch_index"]]return (s,)class LatentUpscale:@@ -805,8 +844,8 @@ def common_ksampler(model, seed, steps, cfg, sampler_name, scheduler, positive,if disable_noise:noise = torch.zeros(latent_image.size(), dtype=latent_image.dtype, layout=latent_image.layout, device="cpu")else:- skip = latent["batch_index"] if "batch_index" in latent else 0- noise = comfy.sample.prepare_noise(latent_image, seed, skip)+ batch_inds = latent["batch_index"] if "batch_index" in latent else None+ noise = comfy.sample.prepare_noise(latent_image, seed, batch_inds)noise_mask = Noneif "noise_mask" in latent:@@ -1170,6 +1209,7 @@ NODE_CLASS_MAPPINGS = {"EmptyLatentImage": EmptyLatentImage,"LatentUpscale": LatentUpscale,"LatentFromBatch": LatentFromBatch,+ "RepeatLatentBatch": RepeatLatentBatch,"SaveImage": SaveImage,"PreviewImage": PreviewImage,"LoadImage": LoadImage,@@ -1244,6 +1284,8 @@ NODE_DISPLAY_NAME_MAPPINGS = {"EmptyLatentImage": "Empty Latent Image","LatentUpscale": "Upscale Latent","LatentComposite": "Latent Composite",+ "LatentFromBatch" : "Latent From Batch",+ "RepeatLatentBatch": "Repeat Latent Batch",# Image"SaveImage": "Save Image","PreviewImage": "Preview Image",@@ -1299,3 +1341,4 @@ def init_custom_nodes():load_custom_node(os.path.join(os.path.join(os.path.dirname(os.path.realpath(__file__)), "comfy_extras"), "nodes_upscale_model.py"))load_custom_node(os.path.join(os.path.join(os.path.dirname(os.path.realpath(__file__)), "comfy_extras"), "nodes_post_processing.py"))load_custom_node(os.path.join(os.path.join(os.path.dirname(os.path.realpath(__file__)), "comfy_extras"), "nodes_mask.py"))+ load_custom_node(os.path.join(os.path.join(os.path.dirname(os.path.realpath(__file__)), "comfy_extras"), "nodes_rebatch.py"))diff --git a/server.py b/server.pyindex 8435d091b..cb66cc618 100644--- a/server.py+++ b/server.py@@ -268,6 +268,7 @@ class PromptServer():info = {}info['input'] = obj_class.INPUT_TYPES()info['output'] = obj_class.RETURN_TYPES+ info['output_is_list'] = obj_class.OUTPUT_IS_LIST if hasattr(obj_class, 'OUTPUT_IS_LIST') else [False] * len(obj_class.RETURN_TYPES)info['output_name'] = obj_class.RETURN_NAMES if hasattr(obj_class, 'RETURN_NAMES') else info['output']info['name'] = xinfo['display_name'] = nodes.NODE_DISPLAY_NAME_MAPPINGS[x] if x in nodes.NODE_DISPLAY_NAME_MAPPINGS.keys() else xdiff --git a/web/scripts/app.js b/web/scripts/app.jsindex 2da1b5581..1a4a18b94 100644--- a/web/scripts/app.js+++ b/web/scripts/app.js@@ -976,7 +976,8 @@ export class ComfyApp {for (const o in nodeData["output"]) {const output = nodeData["output"][o];const outputName = nodeData["output_name"][o] || output;- this.addOutput(outputName, output);+ const outputShape = nodeData["output_is_list"][o] ? LiteGraph.GRID_SHAPE : LiteGraph.CIRCLE_SHAPE ;+ this.addOutput(outputName, output, { shape: outputShape });}const s = this.computeSize();