From 5ff3d4eb3a91d1e66d35a919dd38c02b4652e96a Mon Sep 17 00:00:00 2001 From: Chenlei Hu Date: Thu, 27 Jun 2024 09:13:52 -0400 Subject: [PATCH 01/94] Fix audio upload when no audio in input dir (#3891) --- web/extensions/core/uploadAudio.js | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/web/extensions/core/uploadAudio.js b/web/extensions/core/uploadAudio.js index d3dfef4a7e80..12a2a196b495 100644 --- a/web/extensions/core/uploadAudio.js +++ b/web/extensions/core/uploadAudio.js @@ -145,7 +145,9 @@ app.registerExtension({ ) } // Initially load default audio file to audioUIWidget. - onAudioWidgetUpdate() + if (audioWidget.value) { + onAudioWidgetUpdate() + } audioWidget.callback = onAudioWidgetUpdate const fileInput = document.createElement("input") From 8ceb5a02a3182e6551690d9e56934bdca1cebcca Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Thu, 27 Jun 2024 11:06:52 -0400 Subject: [PATCH 02/94] Support saving stable audio checkpoint that can be loaded back. --- comfy/model_base.py | 9 +++++++++ comfy/sd.py | 2 +- comfy/supported_models.py | 5 ++++- 3 files changed, 14 insertions(+), 2 deletions(-) diff --git a/comfy/model_base.py b/comfy/model_base.py index f45b375dee5a..80f6667ec816 100644 --- a/comfy/model_base.py +++ b/comfy/model_base.py @@ -627,3 +627,12 @@ def extra_conds(self, **kwargs): cross_attn = torch.cat([cross_attn.to(device), seconds_start_embed.repeat((cross_attn.shape[0], 1, 1)), seconds_total_embed.repeat((cross_attn.shape[0], 1, 1))], dim=1) out['c_crossattn'] = comfy.conds.CONDRegular(cross_attn) return out + + def state_dict_for_saving(self, clip_state_dict=None, vae_state_dict=None, clip_vision_state_dict=None): + sd = super().state_dict_for_saving(clip_state_dict=clip_state_dict, vae_state_dict=vae_state_dict, clip_vision_state_dict=clip_vision_state_dict) + d = {"conditioner.conditioners.seconds_start.": self.seconds_start_embedder.state_dict(), "conditioner.conditioners.seconds_total.": self.seconds_total_embedder.state_dict()} + for k in d: + s = d[k] + for l in s: + sd["{}{}".format(k, l)] = s[l] + return sd diff --git a/comfy/sd.py b/comfy/sd.py index ea6e9b663a39..dda0887ba699 100644 --- a/comfy/sd.py +++ b/comfy/sd.py @@ -236,7 +236,7 @@ def __init__(self, sd=None, device=None, config=None, dtype=None): self.first_stage_model = AutoencodingEngine(regularizer_config={'target': "comfy.ldm.models.autoencoder.DiagonalGaussianRegularizer"}, encoder_config={'target': "comfy.ldm.modules.diffusionmodules.model.Encoder", 'params': ddconfig}, decoder_config={'target': "comfy.ldm.modules.diffusionmodules.model.Decoder", 'params': ddconfig}) - elif "decoder.layers.0.weight_v" in sd: + elif "decoder.layers.1.layers.0.beta" in sd: self.first_stage_model = AudioOobleckVAE() self.memory_used_encode = lambda shape, dtype: (1000 * shape[2]) * model_management.dtype_size(dtype) self.memory_used_decode = lambda shape, dtype: (1000 * shape[2] * 2048) * model_management.dtype_size(dtype) diff --git a/comfy/supported_models.py b/comfy/supported_models.py index 761498dbc9e5..21fdb7ec758b 100644 --- a/comfy/supported_models.py +++ b/comfy/supported_models.py @@ -543,13 +543,16 @@ def get_model(self, state_dict, prefix="", device=None): seconds_total_sd = utils.state_dict_prefix_replace(state_dict, {"conditioner.conditioners.seconds_total.": ""}, filter_keys=True) return model_base.StableAudio1(self, seconds_start_embedder_weights=seconds_start_sd, seconds_total_embedder_weights=seconds_total_sd, device=device) - def process_unet_state_dict(self, state_dict): for k in list(state_dict.keys()): if k.endswith(".cross_attend_norm.beta") or k.endswith(".ff_norm.beta") or k.endswith(".pre_norm.beta"): #These weights are all zero state_dict.pop(k) return state_dict + def process_unet_state_dict_for_saving(self, state_dict): + replace_prefix = {"": "model.model."} + return utils.state_dict_prefix_replace(state_dict, replace_prefix) + def clip_target(self, state_dict={}): return supported_models_base.ClipTarget(sa_t5.SAT5Tokenizer, sa_t5.SAT5Model) From 449bf52923896236ed645da2ff05aadbf2b0d536 Mon Sep 17 00:00:00 2001 From: Robin Huang Date: Thu, 27 Jun 2024 13:08:26 -0700 Subject: [PATCH 03/94] Add integration test for Linux with Nvidia GPU. #3884 (#3895) * Add linux integration test. * Fix directory path. * Add paths ignore. * Fix conda env directory path. --- .../conda-environments/linux-environment.yml | 28 +++++++++++ .github/workflows/linux-integration-test.yml | 50 +++++++++++++++++++ 2 files changed, 78 insertions(+) create mode 100644 .github/conda-environments/linux-environment.yml create mode 100644 .github/workflows/linux-integration-test.yml diff --git a/.github/conda-environments/linux-environment.yml b/.github/conda-environments/linux-environment.yml new file mode 100644 index 000000000000..c9ebd640616b --- /dev/null +++ b/.github/conda-environments/linux-environment.yml @@ -0,0 +1,28 @@ +name: comfyui +channels: + - pytorch + - nvidia + - defaults +dependencies: + - python>=3.9 + - pip + - pytorch + - torchvision + - torchaudio + - pytorch-cuda=12.1 + - pip: + # comfyui requirements + - einops + - transformers>=4.25.1 + - safetensors>=0.4.2 + - aiohttp + - pyyaml + - Pillow + - scipy + - tqdm + - psutil + # comfy-action requirements + - requests + - google-cloud-storage + - comfy-cli + - charset-normalizer \ No newline at end of file diff --git a/.github/workflows/linux-integration-test.yml b/.github/workflows/linux-integration-test.yml new file mode 100644 index 000000000000..eed84a77c26d --- /dev/null +++ b/.github/workflows/linux-integration-test.yml @@ -0,0 +1,50 @@ +name: (Linux) ComfyUI Integration Tests +on: + push: + branches: + - master + paths-ignore: + - 'app/**' + - 'input/**' + - 'output/**' + - 'model/**' + - 'notebook/**' + - 'script_example/**' + - 'tests/**' + - 'tests-ui/**' + - '.github/**' + - '.ci/**' + - 'web/**' + workflow_dispatch: + pull_request: + branches: + - master + paths-ignore: + - 'app/**' + - 'input/**' + - 'output/**' + - 'model/**' + - 'notebook/**' + - 'script_example/**' + - 'tests/**' + - 'tests-ui/**' + - '.github/**' + - '.ci/**' + - 'web/**' + +jobs: + test-workflows: + runs-on: [self-hosted, Linux, t4] + steps: + - name: Test ComfyUI Workflows + uses: comfy-org/comfy-action@main + with: + os: linux + cuda_version: 12.1 + models-json: '{"v1-5-pruned-emaonly.ckpt": {"url": "https://huggingface.co/runwayml/stable-diffusion-v1-5/resolve/main/v1-5-pruned-emaonly.ckpt", "directory": "checkpoints"}}' + workflow_filenames: "default.json" + gcs_bucket_name: 'comfy-ci-results' + google_credentials: ${{ secrets.GCS_SERVICE_ACCOUNT_JSON }} + output_prefix: 'ComfyUI' + conda_env_file: '.github/conda-environments/linux-environment.yml' + timeout: 50 From 97b409cd486b1a3b1114ae204802c81f3727d1a2 Mon Sep 17 00:00:00 2001 From: Robin Huang Date: Thu, 27 Jun 2024 13:10:16 -0700 Subject: [PATCH 04/94] Add macOs integration test for default workflow. (#3898) --- .../conda-environments/mac-environment.yml | 26 ++++++++++ .github/workflows/mac-integration-test.yml | 50 +++++++++++++++++++ 2 files changed, 76 insertions(+) create mode 100644 .github/conda-environments/mac-environment.yml create mode 100644 .github/workflows/mac-integration-test.yml diff --git a/.github/conda-environments/mac-environment.yml b/.github/conda-environments/mac-environment.yml new file mode 100644 index 000000000000..33832b854227 --- /dev/null +++ b/.github/conda-environments/mac-environment.yml @@ -0,0 +1,26 @@ +name: comfyui +channels: + - pytorch-nightly + - defaults +dependencies: + - python>=3.9 + - pytorch-nightly::pytorch + - torchvision + - torchaudio + - pip: + - pip + # comfyui requirements + - einops + - transformers>=4.25.1 + - safetensors>=0.4.2 + - aiohttp + - pyyaml + - Pillow + - scipy + - tqdm + - psutil + # comfy-action requirements + - requests + - google-cloud-storage + - comfy-cli + - charset-normalizer diff --git a/.github/workflows/mac-integration-test.yml b/.github/workflows/mac-integration-test.yml new file mode 100644 index 000000000000..6a0482b1b3eb --- /dev/null +++ b/.github/workflows/mac-integration-test.yml @@ -0,0 +1,50 @@ +name: (macOS) ComfyUI Integration Tests +on: + push: + branches: + - master + paths-ignore: + - 'app/**' + - 'input/**' + - 'output/**' + - 'model/**' + - 'notebook/**' + - 'script_example/**' + - 'tests/**' + - 'tests-ui/**' + - '.github/**' + - '.ci/**' + - 'web/**' + workflow_dispatch: + pull_request: + branches: + - master + paths-ignore: + - 'app/**' + - 'input/**' + - 'output/**' + - 'model/**' + - 'notebook/**' + - 'script_example/**' + - 'tests/**' + - 'tests-ui/**' + - '.github/**' + - '.ci/**' + - 'web/**' + +jobs: + test-workflows: + runs-on: [self-hosted, m2] + steps: + - name: Test ComfyUI Workflows + uses: comfy-org/comfy-action@main + with: + os: mac + models-json: '{"v1-5-pruned-emaonly.ckpt": {"url": "https://huggingface.co/runwayml/stable-diffusion-v1-5/resolve/main/v1-5-pruned-emaonly.ckpt", "directory": "checkpoints"}}' + workflow_filenames: "default.json" + gcs_bucket_name: 'comfy-ci-results' + google_credentials: ${{ secrets.GCS_SERVICE_ACCOUNT_JSON }} + output_prefix: 'ComfyUI' + conda_env_file: '.github/conda-environments/mac-environment.yml' + timeout: 50 + From 66aaa14001be9f7cf2b52f84c0dff588e36aabbf Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Tue, 25 Jun 2024 17:02:05 -0400 Subject: [PATCH 05/94] Controlnet refactor. --- comfy/cldm/cldm.py | 9 +++++---- comfy/controlnet.py | 35 ++++++++++----------------------- comfy/ldm/cascade/controlnet.py | 2 +- comfy/t2i_adapter/adapter.py | 10 ++++++++-- 4 files changed, 24 insertions(+), 32 deletions(-) diff --git a/comfy/cldm/cldm.py b/comfy/cldm/cldm.py index 28076dd9251e..f8a161594521 100644 --- a/comfy/cldm/cldm.py +++ b/comfy/cldm/cldm.py @@ -289,7 +289,8 @@ def forward(self, x, hint, timesteps, context, y=None, **kwargs): guided_hint = self.input_hint_block(hint, emb, context) - outs = [] + out_output = [] + out_middle = [] hs = [] if self.num_classes is not None: @@ -304,10 +305,10 @@ def forward(self, x, hint, timesteps, context, y=None, **kwargs): guided_hint = None else: h = module(h, emb, context) - outs.append(zero_conv(h, emb, context)) + out_output.append(zero_conv(h, emb, context)) h = self.middle_block(h, emb, context) - outs.append(self.middle_block_out(h, emb, context)) + out_middle.append(self.middle_block_out(h, emb, context)) - return outs + return {"middle": out_middle, "output": out_output} diff --git a/comfy/controlnet.py b/comfy/controlnet.py index 8cf4a61a6833..f50df68357de 100644 --- a/comfy/controlnet.py +++ b/comfy/controlnet.py @@ -89,27 +89,12 @@ def inference_memory_requirements(self, dtype): return self.previous_controlnet.inference_memory_requirements(dtype) return 0 - def control_merge(self, control_input, control_output, control_prev, output_dtype): + def control_merge(self, control, control_prev, output_dtype): out = {'input':[], 'middle':[], 'output': []} - if control_input is not None: - for i in range(len(control_input)): - key = 'input' - x = control_input[i] - if x is not None: - x *= self.strength - if x.dtype != output_dtype: - x = x.to(output_dtype) - out[key].insert(0, x) - - if control_output is not None: + for key in control: + control_output = control[key] for i in range(len(control_output)): - if i == (len(control_output) - 1): - key = 'middle' - index = 0 - else: - key = 'output' - index = i x = control_output[i] if x is not None: if self.global_average_pooling: @@ -120,6 +105,7 @@ def control_merge(self, control_input, control_output, control_prev, output_dtyp x = x.to(output_dtype) out[key].append(x) + if control_prev is not None: for x in ['input', 'middle', 'output']: o = out[x] @@ -182,7 +168,7 @@ def get_control(self, x_noisy, t, cond, batched_number): x_noisy = self.model_sampling_current.calculate_input(t, x_noisy) control = self.control_model(x=x_noisy.to(dtype), hint=self.cond_hint, timesteps=timestep.float(), context=context.to(dtype), y=y) - return self.control_merge(None, control, control_prev, output_dtype) + return self.control_merge(control, control_prev, output_dtype) def copy(self): c = ControlNet(None, global_average_pooling=self.global_average_pooling, load_device=self.load_device, manual_cast_dtype=self.manual_cast_dtype) @@ -490,12 +476,11 @@ def get_control(self, x_noisy, t, cond, batched_number): self.control_input = self.t2i_model(self.cond_hint.to(x_noisy.dtype)) self.t2i_model.cpu() - control_input = list(map(lambda a: None if a is None else a.clone(), self.control_input)) - mid = None - if self.t2i_model.xl == True: - mid = control_input[-1:] - control_input = control_input[:-1] - return self.control_merge(control_input, mid, control_prev, x_noisy.dtype) + control_input = {} + for k in self.control_input: + control_input[k] = list(map(lambda a: None if a is None else a.clone(), self.control_input[k])) + + return self.control_merge(control_input, control_prev, x_noisy.dtype) def copy(self): c = T2IAdapter(self.t2i_model, self.channels_in, self.compression_ratio, self.upscale_algorithm) diff --git a/comfy/ldm/cascade/controlnet.py b/comfy/ldm/cascade/controlnet.py index 5dac5939409a..7a52c3c263f9 100644 --- a/comfy/ldm/cascade/controlnet.py +++ b/comfy/ldm/cascade/controlnet.py @@ -90,4 +90,4 @@ def forward(self, x): proj_outputs = [None for _ in range(max(self.proj_blocks) + 1)] for i, idx in enumerate(self.proj_blocks): proj_outputs[idx] = self.projections[i](x) - return proj_outputs + return {"input": proj_outputs[::-1]} diff --git a/comfy/t2i_adapter/adapter.py b/comfy/t2i_adapter/adapter.py index e9a606b1cd67..10ea18e32669 100644 --- a/comfy/t2i_adapter/adapter.py +++ b/comfy/t2i_adapter/adapter.py @@ -153,7 +153,13 @@ def forward(self, x): features.append(None) features.append(x) - return features + features = features[::-1] + + if self.xl: + return {"input": features[1:], "middle": features[:1]} + else: + return {"input": features} + class LayerNorm(nn.LayerNorm): @@ -290,4 +296,4 @@ def forward(self, x): features.append(None) features.append(x) - return features + return {"input": features[::-1]} From f8f7568d031a61f5d21ca0ed56ff56d7d83c9115 Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Tue, 25 Jun 2024 23:40:44 -0400 Subject: [PATCH 06/94] Basic SD3 controlnet implementation. Still missing the node to properly use it. --- comfy/cldm/mmdit.py | 91 +++++++++++++++++++++ comfy/controlnet.py | 45 +++++++++- comfy/ldm/modules/diffusionmodules/mmdit.py | 30 +++++-- comfy/model_detection.py | 11 ++- comfy/utils.py | 3 +- 5 files changed, 165 insertions(+), 15 deletions(-) create mode 100644 comfy/cldm/mmdit.py diff --git a/comfy/cldm/mmdit.py b/comfy/cldm/mmdit.py new file mode 100644 index 000000000000..6e72474ce903 --- /dev/null +++ b/comfy/cldm/mmdit.py @@ -0,0 +1,91 @@ +import torch +from typing import Dict, Optional +import comfy.ldm.modules.diffusionmodules.mmdit +import comfy.latent_formats + +class ControlNet(comfy.ldm.modules.diffusionmodules.mmdit.MMDiT): + def __init__( + self, + num_blocks = None, + dtype = None, + device = None, + operations = None, + **kwargs, + ): + super().__init__(dtype=dtype, device=device, operations=operations, final_layer=False, num_blocks=num_blocks, **kwargs) + # controlnet_blocks + self.controlnet_blocks = torch.nn.ModuleList([]) + for _ in range(len(self.joint_blocks)): + self.controlnet_blocks.append(operations.Linear(self.hidden_size, self.hidden_size, device=device, dtype=dtype)) + + self.pos_embed_input = comfy.ldm.modules.diffusionmodules.mmdit.PatchEmbed( + None, + self.patch_size, + self.in_channels, + self.hidden_size, + bias=True, + strict_img_size=False, + dtype=dtype, + device=device, + operations=operations + ) + + self.latent_format = comfy.latent_formats.SD3() + + def forward( + self, + x: torch.Tensor, + timesteps: torch.Tensor, + y: Optional[torch.Tensor] = None, + context: Optional[torch.Tensor] = None, + hint = None, + ) -> torch.Tensor: + + #weird sd3 controlnet specific stuff + hint = hint * self.latent_format.scale_factor # self.latent_format.process_in(hint) + y = torch.zeros_like(y) + + + if self.context_processor is not None: + context = self.context_processor(context) + + hw = x.shape[-2:] + x = self.x_embedder(x) + self.cropped_pos_embed(hw, device=x.device).to(dtype=x.dtype, device=x.device) + x += self.pos_embed_input(hint) + + c = self.t_embedder(timesteps, dtype=x.dtype) + if y is not None and self.y_embedder is not None: + y = self.y_embedder(y) + c = c + y + + if context is not None: + context = self.context_embedder(context) + + if self.register_length > 0: + context = torch.cat( + ( + repeat(self.register, "1 ... -> b ...", b=x.shape[0]), + default(context, torch.Tensor([]).type_as(x)), + ), + 1, + ) + + output = [] + + blocks = len(self.joint_blocks) + for i in range(blocks): + context, x = self.joint_blocks[i]( + context, + x, + c=c, + use_checkpoint=self.use_checkpoint, + ) + + out = self.controlnet_blocks[i](x) + count = self.depth // blocks + if i == blocks - 1: + count -= 1 + for j in range(count): + output.append(out) + + return {"output": output} diff --git a/comfy/controlnet.py b/comfy/controlnet.py index f50df68357de..9202c31944f1 100644 --- a/comfy/controlnet.py +++ b/comfy/controlnet.py @@ -11,6 +11,7 @@ import comfy.cldm.cldm import comfy.t2i_adapter.adapter import comfy.ldm.cascade.controlnet +import comfy.cldm.mmdit def broadcast_image_to(tensor, target_batch_size, batched_number): @@ -94,13 +95,17 @@ def control_merge(self, control, control_prev, output_dtype): for key in control: control_output = control[key] + applied_to = set() for i in range(len(control_output)): x = control_output[i] if x is not None: if self.global_average_pooling: x = torch.mean(x, dim=(2, 3), keepdim=True).repeat(1, 1, x.shape[2], x.shape[3]) - x *= self.strength + if x not in applied_to: #memory saving strategy, allow shared tensors and only apply strength to shared tensors once + applied_to.add(x) + x *= self.strength + if x.dtype != output_dtype: x = x.to(output_dtype) @@ -120,17 +125,18 @@ def control_merge(self, control, control_prev, output_dtype): if o[i].shape[0] < prev_val.shape[0]: o[i] = prev_val + o[i] else: - o[i] += prev_val + o[i] = prev_val + o[i] #TODO: change back to inplace add if shared tensors stop being an issue return out class ControlNet(ControlBase): - def __init__(self, control_model=None, global_average_pooling=False, device=None, load_device=None, manual_cast_dtype=None): + def __init__(self, control_model=None, global_average_pooling=False, compression_ratio=8, device=None, load_device=None, manual_cast_dtype=None): super().__init__(device) self.control_model = control_model self.load_device = load_device if control_model is not None: self.control_model_wrapped = comfy.model_patcher.ModelPatcher(self.control_model, load_device=load_device, offload_device=comfy.model_management.unet_offload_device()) + self.compression_ratio = compression_ratio self.global_average_pooling = global_average_pooling self.model_sampling_current = None self.manual_cast_dtype = manual_cast_dtype @@ -308,6 +314,37 @@ def get_models(self): def inference_memory_requirements(self, dtype): return comfy.utils.calculate_parameters(self.control_weights) * comfy.model_management.dtype_size(dtype) + ControlBase.inference_memory_requirements(self, dtype) +def load_controlnet_mmdit(sd): + new_sd = comfy.model_detection.convert_diffusers_mmdit(sd, "") + model_config = comfy.model_detection.model_config_from_unet(new_sd, "", True) + num_blocks = comfy.model_detection.count_blocks(new_sd, 'joint_blocks.{}.') + for k in sd: + new_sd[k] = sd[k] + + supported_inference_dtypes = model_config.supported_inference_dtypes + + controlnet_config = model_config.unet_config + unet_dtype = comfy.model_management.unet_dtype(supported_dtypes=supported_inference_dtypes) + load_device = comfy.model_management.get_torch_device() + manual_cast_dtype = comfy.model_management.unet_manual_cast(unet_dtype, load_device) + if manual_cast_dtype is not None: + operations = comfy.ops.manual_cast + else: + operations = comfy.ops.disable_weight_init + + control_model = comfy.cldm.mmdit.ControlNet(num_blocks=num_blocks, operations=operations, device=load_device, dtype=unet_dtype, **controlnet_config) + missing, unexpected = control_model.load_state_dict(new_sd, strict=False) + + if len(missing) > 0: + logging.warning("missing controlnet keys: {}".format(missing)) + + if len(unexpected) > 0: + logging.debug("unexpected controlnet keys: {}".format(unexpected)) + + control = ControlNet(control_model, compression_ratio=1, load_device=load_device, manual_cast_dtype=manual_cast_dtype) + return control + + def load_controlnet(ckpt_path, model=None): controlnet_data = comfy.utils.load_torch_file(ckpt_path, safe_load=True) if "lora_controlnet" in controlnet_data: @@ -360,6 +397,8 @@ def load_controlnet(ckpt_path, model=None): if len(leftover_keys) > 0: logging.warning("leftover keys: {}".format(leftover_keys)) controlnet_data = new_sd + elif "controlnet_blocks.0.weight" in controlnet_data: #SD3 diffusers format + return load_controlnet_mmdit(controlnet_data) pth_key = 'control_model.zero_convs.0.0.weight' pth = False diff --git a/comfy/ldm/modules/diffusionmodules/mmdit.py b/comfy/ldm/modules/diffusionmodules/mmdit.py index 20d3a321a02a..927451534d7e 100644 --- a/comfy/ldm/modules/diffusionmodules/mmdit.py +++ b/comfy/ldm/modules/diffusionmodules/mmdit.py @@ -745,6 +745,8 @@ def __init__( qkv_bias: bool = True, context_processor_layers = None, context_size = 4096, + num_blocks = None, + final_layer = True, dtype = None, #TODO device = None, operations = None, @@ -766,7 +768,10 @@ def __init__( # apply magic --> this defines a head_size of 64 self.hidden_size = 64 * depth num_heads = depth + if num_blocks is None: + num_blocks = depth + self.depth = depth self.num_heads = num_heads self.x_embedder = PatchEmbed( @@ -821,7 +826,7 @@ def __init__( mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, attn_mode=attn_mode, - pre_only=i == depth - 1, + pre_only=(i == num_blocks - 1) and final_layer, rmsnorm=rmsnorm, scale_mod_only=scale_mod_only, swiglu=swiglu, @@ -830,11 +835,12 @@ def __init__( device=device, operations=operations ) - for i in range(depth) + for i in range(num_blocks) ] ) - self.final_layer = FinalLayer(self.hidden_size, patch_size, self.out_channels, dtype=dtype, device=device, operations=operations) + if final_layer: + self.final_layer = FinalLayer(self.hidden_size, patch_size, self.out_channels, dtype=dtype, device=device, operations=operations) if compile_core: assert False @@ -893,6 +899,7 @@ def forward_core_with_concat( x: torch.Tensor, c_mod: torch.Tensor, context: Optional[torch.Tensor] = None, + control = None, ) -> torch.Tensor: if self.register_length > 0: context = torch.cat( @@ -905,13 +912,20 @@ def forward_core_with_concat( # context is B, L', D # x is B, L, D - for block in self.joint_blocks: - context, x = block( + blocks = len(self.joint_blocks) + for i in range(blocks): + context, x = self.joint_blocks[i]( context, x, c=c_mod, use_checkpoint=self.use_checkpoint, ) + if control is not None: + control_o = control.get("output") + if i < len(control_o): + add = control_o[i] + if add is not None: + x += add x = self.final_layer(x, c_mod) # (N, T, patch_size ** 2 * out_channels) return x @@ -922,6 +936,7 @@ def forward( t: torch.Tensor, y: Optional[torch.Tensor] = None, context: Optional[torch.Tensor] = None, + control = None, ) -> torch.Tensor: """ Forward pass of DiT. @@ -943,7 +958,7 @@ def forward( if context is not None: context = self.context_embedder(context) - x = self.forward_core_with_concat(x, c, context) + x = self.forward_core_with_concat(x, c, context, control) x = self.unpatchify(x, hw=hw) # (N, out_channels, H, W) return x[:,:,:hw[-2],:hw[-1]] @@ -956,7 +971,8 @@ def forward( timesteps: torch.Tensor, context: Optional[torch.Tensor] = None, y: Optional[torch.Tensor] = None, + control = None, **kwargs, ) -> torch.Tensor: - return super().forward(x, timesteps, context=context, y=y) + return super().forward(x, timesteps, context=context, y=y, control=control) diff --git a/comfy/model_detection.py b/comfy/model_detection.py index e09dd381ad95..0b678480f19b 100644 --- a/comfy/model_detection.py +++ b/comfy/model_detection.py @@ -41,7 +41,9 @@ def detect_unet_config(state_dict, key_prefix): unet_config["in_channels"] = state_dict['{}x_embedder.proj.weight'.format(key_prefix)].shape[1] patch_size = state_dict['{}x_embedder.proj.weight'.format(key_prefix)].shape[2] unet_config["patch_size"] = patch_size - unet_config["out_channels"] = state_dict['{}final_layer.linear.weight'.format(key_prefix)].shape[0] // (patch_size * patch_size) + final_layer = '{}final_layer.linear.weight'.format(key_prefix) + if final_layer in state_dict: + unet_config["out_channels"] = state_dict[final_layer].shape[0] // (patch_size * patch_size) unet_config["depth"] = state_dict['{}x_embedder.proj.weight'.format(key_prefix)].shape[0] // 64 unet_config["input_size"] = None @@ -435,10 +437,11 @@ def model_config_from_diffusers_unet(state_dict): return None def convert_diffusers_mmdit(state_dict, output_prefix=""): - depth = count_blocks(state_dict, 'transformer_blocks.{}.') - if depth > 0: + num_blocks = count_blocks(state_dict, 'transformer_blocks.{}.') + if num_blocks > 0: + depth = state_dict["pos_embed.proj.weight"].shape[0] // 64 out_sd = {} - sd_map = comfy.utils.mmdit_to_diffusers({"depth": depth}, output_prefix=output_prefix) + sd_map = comfy.utils.mmdit_to_diffusers({"depth": depth, "num_blocks": num_blocks}, output_prefix=output_prefix) for k in sd_map: weight = state_dict.get(k, None) if weight is not None: diff --git a/comfy/utils.py b/comfy/utils.py index ed6c58a64e7e..48618e076169 100644 --- a/comfy/utils.py +++ b/comfy/utils.py @@ -298,7 +298,8 @@ def mmdit_to_diffusers(mmdit_config, output_prefix=""): key_map = {} depth = mmdit_config.get("depth", 0) - for i in range(depth): + num_blocks = mmdit_config.get("num_blocks", depth) + for i in range(num_blocks): block_from = "transformer_blocks.{}".format(i) block_to = "{}joint_blocks.{}".format(output_prefix, i) From 264caca20e1e051f3bcbec59d7209513ea99d4ed Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Wed, 26 Jun 2024 16:14:47 -0400 Subject: [PATCH 07/94] ControlNetApplySD3 node can now be used to use SD3 controlnets. --- comfy/cldm/mmdit.py | 5 ----- comfy/controlnet.py | 28 ++++++++++++++++++++++++---- comfy_extras/nodes_sd3.py | 15 +++++++++++++++ nodes.py | 4 ++-- 4 files changed, 41 insertions(+), 11 deletions(-) diff --git a/comfy/cldm/mmdit.py b/comfy/cldm/mmdit.py index 6e72474ce903..ee0282bc7269 100644 --- a/comfy/cldm/mmdit.py +++ b/comfy/cldm/mmdit.py @@ -1,7 +1,6 @@ import torch from typing import Dict, Optional import comfy.ldm.modules.diffusionmodules.mmdit -import comfy.latent_formats class ControlNet(comfy.ldm.modules.diffusionmodules.mmdit.MMDiT): def __init__( @@ -30,8 +29,6 @@ def __init__( operations=operations ) - self.latent_format = comfy.latent_formats.SD3() - def forward( self, x: torch.Tensor, @@ -42,10 +39,8 @@ def forward( ) -> torch.Tensor: #weird sd3 controlnet specific stuff - hint = hint * self.latent_format.scale_factor # self.latent_format.process_in(hint) y = torch.zeros_like(y) - if self.context_processor is not None: context = self.context_processor(context) diff --git a/comfy/controlnet.py b/comfy/controlnet.py index 9202c31944f1..d0039513968f 100644 --- a/comfy/controlnet.py +++ b/comfy/controlnet.py @@ -7,6 +7,7 @@ import comfy.model_detection import comfy.model_patcher import comfy.ops +import comfy.latent_formats import comfy.cldm.cldm import comfy.t2i_adapter.adapter @@ -38,6 +39,8 @@ def __init__(self, device=None): self.cond_hint = None self.strength = 1.0 self.timestep_percent_range = (0.0, 1.0) + self.latent_format = None + self.vae = None self.global_average_pooling = False self.timestep_range = None self.compression_ratio = 8 @@ -48,10 +51,12 @@ def __init__(self, device=None): self.device = device self.previous_controlnet = None - def set_cond_hint(self, cond_hint, strength=1.0, timestep_percent_range=(0.0, 1.0)): + def set_cond_hint(self, cond_hint, strength=1.0, timestep_percent_range=(0.0, 1.0), vae=None): self.cond_hint_original = cond_hint self.strength = strength self.timestep_percent_range = timestep_percent_range + if self.latent_format is not None: + self.vae = vae return self def pre_run(self, model, percent_to_timestep_function): @@ -84,6 +89,8 @@ def copy_to(self, c): c.global_average_pooling = self.global_average_pooling c.compression_ratio = self.compression_ratio c.upscale_algorithm = self.upscale_algorithm + c.latent_format = self.latent_format + c.vae = self.vae def inference_memory_requirements(self, dtype): if self.previous_controlnet is not None: @@ -129,7 +136,7 @@ def control_merge(self, control, control_prev, output_dtype): return out class ControlNet(ControlBase): - def __init__(self, control_model=None, global_average_pooling=False, compression_ratio=8, device=None, load_device=None, manual_cast_dtype=None): + def __init__(self, control_model=None, global_average_pooling=False, compression_ratio=8, latent_format=None, device=None, load_device=None, manual_cast_dtype=None): super().__init__(device) self.control_model = control_model self.load_device = load_device @@ -140,6 +147,7 @@ def __init__(self, control_model=None, global_average_pooling=False, compression self.global_average_pooling = global_average_pooling self.model_sampling_current = None self.manual_cast_dtype = manual_cast_dtype + self.latent_format = latent_format def get_control(self, x_noisy, t, cond, batched_number): control_prev = None @@ -162,7 +170,17 @@ def get_control(self, x_noisy, t, cond, batched_number): if self.cond_hint is not None: del self.cond_hint self.cond_hint = None - self.cond_hint = comfy.utils.common_upscale(self.cond_hint_original, x_noisy.shape[3] * self.compression_ratio, x_noisy.shape[2] * self.compression_ratio, self.upscale_algorithm, "center").to(dtype).to(self.device) + compression_ratio = self.compression_ratio + if self.vae is not None: + compression_ratio *= self.vae.downscale_ratio + self.cond_hint = comfy.utils.common_upscale(self.cond_hint_original, x_noisy.shape[3] * compression_ratio, x_noisy.shape[2] * compression_ratio, self.upscale_algorithm, "center") + if self.vae is not None: + loaded_models = comfy.model_management.loaded_models(only_currently_used=True) + self.cond_hint = self.vae.encode(self.cond_hint.movedim(1, -1)) + comfy.model_management.load_models_gpu(loaded_models) + if self.latent_format is not None: + self.cond_hint = self.latent_format.process_in(self.cond_hint) + self.cond_hint = self.cond_hint.to(device=self.device, dtype=dtype) if x_noisy.shape[0] != self.cond_hint.shape[0]: self.cond_hint = broadcast_image_to(self.cond_hint, x_noisy.shape[0], batched_number) @@ -341,7 +359,9 @@ def load_controlnet_mmdit(sd): if len(unexpected) > 0: logging.debug("unexpected controlnet keys: {}".format(unexpected)) - control = ControlNet(control_model, compression_ratio=1, load_device=load_device, manual_cast_dtype=manual_cast_dtype) + latent_format = comfy.latent_formats.SD3() + latent_format.shift_factor = 0 #SD3 controlnet weirdness + control = ControlNet(control_model, compression_ratio=1, latent_format=latent_format, load_device=load_device, manual_cast_dtype=manual_cast_dtype) return control diff --git a/comfy_extras/nodes_sd3.py b/comfy_extras/nodes_sd3.py index d0303aec58fe..548b1ad6a20c 100644 --- a/comfy_extras/nodes_sd3.py +++ b/comfy_extras/nodes_sd3.py @@ -80,8 +80,23 @@ def encode(self, clip, clip_l, clip_g, t5xxl, empty_padding): return ([[cond, {"pooled_output": pooled}]], ) +class ControlNetApplySD3(nodes.ControlNetApplyAdvanced): + @classmethod + def INPUT_TYPES(s): + return {"required": {"positive": ("CONDITIONING", ), + "negative": ("CONDITIONING", ), + "control_net": ("CONTROL_NET", ), + "vae": ("VAE", ), + "image": ("IMAGE", ), + "strength": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 10.0, "step": 0.01}), + "start_percent": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.001}), + "end_percent": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.001}) + }} + CATEGORY = "_for_testing/sd3" + NODE_CLASS_MAPPINGS = { "TripleCLIPLoader": TripleCLIPLoader, "EmptySD3LatentImage": EmptySD3LatentImage, "CLIPTextEncodeSD3": CLIPTextEncodeSD3, + "ControlNetApplySD3": ControlNetApplySD3, } diff --git a/nodes.py b/nodes.py index 99645b81c367..04775d2906f3 100644 --- a/nodes.py +++ b/nodes.py @@ -783,7 +783,7 @@ def INPUT_TYPES(s): CATEGORY = "conditioning" - def apply_controlnet(self, positive, negative, control_net, image, strength, start_percent, end_percent): + def apply_controlnet(self, positive, negative, control_net, image, strength, start_percent, end_percent, vae=None): if strength == 0: return (positive, negative) @@ -800,7 +800,7 @@ def apply_controlnet(self, positive, negative, control_net, image, strength, sta if prev_cnet in cnets: c_net = cnets[prev_cnet] else: - c_net = control_net.copy().set_cond_hint(control_hint, strength, (start_percent, end_percent)) + c_net = control_net.copy().set_cond_hint(control_hint, strength, (start_percent, end_percent), vae) c_net.set_previous_controlnet(prev_cnet) cnets[prev_cnet] = c_net From 0d9009c96ea5a1922a1c187deef27c7f133ee946 Mon Sep 17 00:00:00 2001 From: pythongosssss <125205205+pythongosssss@users.noreply.github.com> Date: Fri, 28 Jun 2024 06:07:19 +0100 Subject: [PATCH 08/94] New menu/workflows fixes (#3900) * Fix auto queue * Detect added nodes via search * Fix loading workflows * Add button click style --- web/scripts/changeTracker.js | 12 +++++++++++- web/scripts/ui/menu/menu.css | 4 ++++ web/scripts/ui/menu/queueButton.js | 4 ++-- web/scripts/workflows.js | 4 ++-- 4 files changed, 19 insertions(+), 5 deletions(-) diff --git a/web/scripts/changeTracker.js b/web/scripts/changeTracker.js index 59901d5fcd1c..041c83122e0d 100644 --- a/web/scripts/changeTracker.js +++ b/web/scripts/changeTracker.js @@ -3,7 +3,6 @@ import { api } from "./api.js"; import { clone } from "./utils.js"; - export class ChangeTracker { static MAX_HISTORY = 50; #app; @@ -170,6 +169,17 @@ export class ChangeTracker { return v; }; + // Detects nodes being added via the node search dialog + const onNodeAdded = LiteGraph.LGraph.prototype.onNodeAdded; + LiteGraph.LGraph.prototype.onNodeAdded = function () { + const v = onNodeAdded?.apply(this, arguments); + const ct = changeTracker(); + if (!ct.isOurLoad) { + ct.checkState(); + } + return v; + }; + // Store node outputs api.addEventListener("executed", ({ detail }) => { const prompt = app.workflowManager.queuedPrompts[detail.prompt_id]; diff --git a/web/scripts/ui/menu/menu.css b/web/scripts/ui/menu/menu.css index 20eeab2cf576..afaed3fb0fb5 100644 --- a/web/scripts/ui/menu/menu.css +++ b/web/scripts/ui/menu/menu.css @@ -19,8 +19,12 @@ padding: 4px 8px; box-sizing: border-box; margin: 0; + transition: box-shadow 0.1s; } +.comfyui-button:active { + box-shadow: inset 1px 1px 10px rgba(0, 0, 0, 0.5); +} .comfyui-button:disabled { opacity: 0.5; cursor: not-allowed; diff --git a/web/scripts/ui/menu/queueButton.js b/web/scripts/ui/menu/queueButton.js index 3c29ab090c03..608f4cc9b00c 100644 --- a/web/scripts/ui/menu/queueButton.js +++ b/web/scripts/ui/menu/queueButton.js @@ -13,8 +13,8 @@ export class ComfyQueueButton { queuePrompt = async (e) => { this.#internalQueueSize += this.queueOptions.batchCount; - // Hold shift to queue front - await this.app.queuePrompt(-e.shiftKey, this.queueOptions.batchCount); + // Hold shift to queue front, event is undefined when auto-queue is enabled + await this.app.queuePrompt(e?.shiftKey ? -1 : 0, this.queueOptions.batchCount); }; constructor(app) { diff --git a/web/scripts/workflows.js b/web/scripts/workflows.js index 16bbc9976337..d38b6f5fc0a6 100644 --- a/web/scripts/workflows.js +++ b/web/scripts/workflows.js @@ -301,11 +301,11 @@ export class ComfyWorkflow { load = async () => { if (this.isOpen) { - await this.manager.app.loadGraphData(this.changeTracker.activeState, true, this); + await this.manager.app.loadGraphData(this.changeTracker.activeState, true, true, this); } else { const data = await this.getWorkflowData(); if (!data) return; - await this.manager.app.loadGraphData(data, true, this); + await this.manager.app.loadGraphData(data, true, true, this); } }; From 7ecb2ec1699dc988f93188c04733eeb8a41e8196 Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Fri, 28 Jun 2024 02:55:36 -0400 Subject: [PATCH 09/94] Audio second setting in EmptyLatentAudio. --- comfy_extras/nodes_audio.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/comfy_extras/nodes_audio.py b/comfy_extras/nodes_audio.py index 34bcfa96d45c..6481ed3ba831 100644 --- a/comfy_extras/nodes_audio.py +++ b/comfy_extras/nodes_audio.py @@ -14,15 +14,16 @@ def __init__(self): @classmethod def INPUT_TYPES(s): - return {"required": {}} + return {"required": {"seconds": ("FLOAT", {"default": 47.6, "min": 1.0, "max": 1000.0, "step": 0.1})}} RETURN_TYPES = ("LATENT",) FUNCTION = "generate" CATEGORY = "_for_testing/audio" - def generate(self): + def generate(self, seconds): batch_size = 1 - latent = torch.zeros([batch_size, 64, 1024], device=self.device) + length = round((seconds * 44100 / 2048) / 2) * 2 + latent = torch.zeros([batch_size, 64, length], device=self.device) return ({"samples":latent, "type": "audio"}, ) class VAEEncodeAudio: From 02cac1d48783725d5994d37ed03e9f3dc32ec504 Mon Sep 17 00:00:00 2001 From: Robin Huang Date: Fri, 28 Jun 2024 13:09:39 -0700 Subject: [PATCH 10/94] Revert "Add macOs integration test for default workflow. (#3898)" (#3904) This reverts commit 97b409cd486b1a3b1114ae204802c81f3727d1a2. --- .../conda-environments/mac-environment.yml | 26 ---------- .github/workflows/mac-integration-test.yml | 50 ------------------- 2 files changed, 76 deletions(-) delete mode 100644 .github/conda-environments/mac-environment.yml delete mode 100644 .github/workflows/mac-integration-test.yml diff --git a/.github/conda-environments/mac-environment.yml b/.github/conda-environments/mac-environment.yml deleted file mode 100644 index 33832b854227..000000000000 --- a/.github/conda-environments/mac-environment.yml +++ /dev/null @@ -1,26 +0,0 @@ -name: comfyui -channels: - - pytorch-nightly - - defaults -dependencies: - - python>=3.9 - - pytorch-nightly::pytorch - - torchvision - - torchaudio - - pip: - - pip - # comfyui requirements - - einops - - transformers>=4.25.1 - - safetensors>=0.4.2 - - aiohttp - - pyyaml - - Pillow - - scipy - - tqdm - - psutil - # comfy-action requirements - - requests - - google-cloud-storage - - comfy-cli - - charset-normalizer diff --git a/.github/workflows/mac-integration-test.yml b/.github/workflows/mac-integration-test.yml deleted file mode 100644 index 6a0482b1b3eb..000000000000 --- a/.github/workflows/mac-integration-test.yml +++ /dev/null @@ -1,50 +0,0 @@ -name: (macOS) ComfyUI Integration Tests -on: - push: - branches: - - master - paths-ignore: - - 'app/**' - - 'input/**' - - 'output/**' - - 'model/**' - - 'notebook/**' - - 'script_example/**' - - 'tests/**' - - 'tests-ui/**' - - '.github/**' - - '.ci/**' - - 'web/**' - workflow_dispatch: - pull_request: - branches: - - master - paths-ignore: - - 'app/**' - - 'input/**' - - 'output/**' - - 'model/**' - - 'notebook/**' - - 'script_example/**' - - 'tests/**' - - 'tests-ui/**' - - '.github/**' - - '.ci/**' - - 'web/**' - -jobs: - test-workflows: - runs-on: [self-hosted, m2] - steps: - - name: Test ComfyUI Workflows - uses: comfy-org/comfy-action@main - with: - os: mac - models-json: '{"v1-5-pruned-emaonly.ckpt": {"url": "https://huggingface.co/runwayml/stable-diffusion-v1-5/resolve/main/v1-5-pruned-emaonly.ckpt", "directory": "checkpoints"}}' - workflow_filenames: "default.json" - gcs_bucket_name: 'comfy-ci-results' - google_credentials: ${{ secrets.GCS_SERVICE_ACCOUNT_JSON }} - output_prefix: 'ComfyUI' - conda_env_file: '.github/conda-environments/mac-environment.yml' - timeout: 50 - From c39cf7fff09c728d573835a48106e2133c446e11 Mon Sep 17 00:00:00 2001 From: Robin Huang Date: Fri, 28 Jun 2024 13:09:55 -0700 Subject: [PATCH 11/94] Revert "Add integration test for Linux with Nvidia GPU. #3884 (#3895)" (#3905) This reverts commit 449bf52923896236ed645da2ff05aadbf2b0d536. --- .../conda-environments/linux-environment.yml | 28 ----------- .github/workflows/linux-integration-test.yml | 50 ------------------- 2 files changed, 78 deletions(-) delete mode 100644 .github/conda-environments/linux-environment.yml delete mode 100644 .github/workflows/linux-integration-test.yml diff --git a/.github/conda-environments/linux-environment.yml b/.github/conda-environments/linux-environment.yml deleted file mode 100644 index c9ebd640616b..000000000000 --- a/.github/conda-environments/linux-environment.yml +++ /dev/null @@ -1,28 +0,0 @@ -name: comfyui -channels: - - pytorch - - nvidia - - defaults -dependencies: - - python>=3.9 - - pip - - pytorch - - torchvision - - torchaudio - - pytorch-cuda=12.1 - - pip: - # comfyui requirements - - einops - - transformers>=4.25.1 - - safetensors>=0.4.2 - - aiohttp - - pyyaml - - Pillow - - scipy - - tqdm - - psutil - # comfy-action requirements - - requests - - google-cloud-storage - - comfy-cli - - charset-normalizer \ No newline at end of file diff --git a/.github/workflows/linux-integration-test.yml b/.github/workflows/linux-integration-test.yml deleted file mode 100644 index eed84a77c26d..000000000000 --- a/.github/workflows/linux-integration-test.yml +++ /dev/null @@ -1,50 +0,0 @@ -name: (Linux) ComfyUI Integration Tests -on: - push: - branches: - - master - paths-ignore: - - 'app/**' - - 'input/**' - - 'output/**' - - 'model/**' - - 'notebook/**' - - 'script_example/**' - - 'tests/**' - - 'tests-ui/**' - - '.github/**' - - '.ci/**' - - 'web/**' - workflow_dispatch: - pull_request: - branches: - - master - paths-ignore: - - 'app/**' - - 'input/**' - - 'output/**' - - 'model/**' - - 'notebook/**' - - 'script_example/**' - - 'tests/**' - - 'tests-ui/**' - - '.github/**' - - '.ci/**' - - 'web/**' - -jobs: - test-workflows: - runs-on: [self-hosted, Linux, t4] - steps: - - name: Test ComfyUI Workflows - uses: comfy-org/comfy-action@main - with: - os: linux - cuda_version: 12.1 - models-json: '{"v1-5-pruned-emaonly.ckpt": {"url": "https://huggingface.co/runwayml/stable-diffusion-v1-5/resolve/main/v1-5-pruned-emaonly.ckpt", "directory": "checkpoints"}}' - workflow_filenames: "default.json" - gcs_bucket_name: 'comfy-ci-results' - google_credentials: ${{ secrets.GCS_SERVICE_ACCOUNT_JSON }} - output_prefix: 'ComfyUI' - conda_env_file: '.github/conda-environments/linux-environment.yml' - timeout: 50 From fbb7a1f1b663b170d49718590aa1cb4093586f20 Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Sat, 29 Jun 2024 01:33:22 -0400 Subject: [PATCH 12/94] PreviewAudio node. --- comfy_extras/nodes_audio.py | 16 +++++++++++++++- web/extensions/core/uploadAudio.js | 6 +++--- 2 files changed, 18 insertions(+), 4 deletions(-) diff --git a/comfy_extras/nodes_audio.py b/comfy_extras/nodes_audio.py index 6481ed3ba831..9950d58ed005 100644 --- a/comfy_extras/nodes_audio.py +++ b/comfy_extras/nodes_audio.py @@ -6,6 +6,7 @@ import io import json import struct +import random from comfy.cli_args import args class EmptyLatentAudio: @@ -118,7 +119,6 @@ def __init__(self): self.output_dir = folder_paths.get_output_directory() self.type = "output" self.prefix_append = "" - self.compress_level = 4 @classmethod def INPUT_TYPES(s): @@ -168,6 +168,19 @@ def save_audio(self, audio, filename_prefix="ComfyUI", prompt=None, extra_pnginf return { "ui": { "audio": results } } +class PreviewAudio(SaveAudio): + def __init__(self): + self.output_dir = folder_paths.get_temp_directory() + self.type = "temp" + self.prefix_append = "_temp_" + ''.join(random.choice("abcdefghijklmnopqrstupvxyz") for x in range(5)) + + @classmethod + def INPUT_TYPES(s): + return {"required": + {"audio": ("AUDIO", ), }, + "hidden": {"prompt": "PROMPT", "extra_pnginfo": "EXTRA_PNGINFO"}, + } + class LoadAudio: SUPPORTED_FORMATS = ('.wav', '.mp3', '.ogg', '.flac', '.aiff', '.aif') @@ -214,4 +227,5 @@ def VALIDATE_INPUTS(s, audio): "VAEDecodeAudio": VAEDecodeAudio, "SaveAudio": SaveAudio, "LoadAudio": LoadAudio, + "PreviewAudio": PreviewAudio, } diff --git a/web/extensions/core/uploadAudio.js b/web/extensions/core/uploadAudio.js index 12a2a196b495..0ac9cb807f08 100644 --- a/web/extensions/core/uploadAudio.js +++ b/web/extensions/core/uploadAudio.js @@ -70,7 +70,7 @@ async function uploadFile( app.registerExtension({ name: "Comfy.AudioWidget", async beforeRegisterNodeDef(nodeType, nodeData) { - if (["LoadAudio", "SaveAudio"].includes(nodeType.comfyClass)) { + if (["LoadAudio", "SaveAudio", "PreviewAudio"].includes(nodeType.comfyClass)) { nodeData.input.required.audioUI = ["AUDIO_UI"] } }, @@ -103,7 +103,7 @@ app.registerExtension({ if (!audios) return const audio = audios[0] audioUIWidget.element.src = api.apiURL( - getResourceURL(audio.subfolder, audio.filename, "output") + getResourceURL(audio.subfolder, audio.filename, audio.type) ) audioUIWidget.element.classList.remove("empty-audio-widget") } @@ -118,7 +118,7 @@ app.registerExtension({ if ("audio" in output) { const audioUIWidget = node.widgets.find((w) => w.name === "audioUI"); const audio = output.audio[0]; - audioUIWidget.element.src = api.apiURL(getResourceURL(audio.subfolder, audio.filename, "output")); + audioUIWidget.element.src = api.apiURL(getResourceURL(audio.subfolder, audio.filename, audio.type)); audioUIWidget.element.classList.remove("empty-audio-widget"); } } From 05e831697a03984032863b2aa5d6443e422713e6 Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Sat, 29 Jun 2024 11:59:48 -0400 Subject: [PATCH 13/94] Switch to the real cfg++ method in the samplers. The old _pp ones will be updated automatically to the regular ones with 2x the cfg. My fault for not checking what the "_pp" samplers actually did. --- comfy/k_diffusion/sampling.py | 12 ++++++------ comfy/samplers.py | 2 +- web/scripts/app.js | 8 ++++++++ 3 files changed, 15 insertions(+), 7 deletions(-) diff --git a/comfy/k_diffusion/sampling.py b/comfy/k_diffusion/sampling.py index f8091bb3fc18..763d8cc78d3d 100644 --- a/comfy/k_diffusion/sampling.py +++ b/comfy/k_diffusion/sampling.py @@ -998,7 +998,7 @@ def sample_deis(model, x, sigmas, extra_args=None, callback=None, disable=None, return x_next @torch.no_grad() -def sample_euler_pp(model, x, sigmas, extra_args=None, callback=None, disable=None): +def sample_euler_cfg_pp(model, x, sigmas, extra_args=None, callback=None, disable=None): extra_args = {} if extra_args is None else extra_args temp = [0] @@ -1013,16 +1013,16 @@ def post_cfg_function(args): for i in trange(len(sigmas) - 1, disable=disable): sigma_hat = sigmas[i] denoised = model(x, sigma_hat * s_in, **extra_args) - d = to_d(x - denoised + temp[0], sigma_hat, denoised) + d = to_d(x, sigma_hat, temp[0]) if callback is not None: callback({'x': x, 'i': i, 'sigma': sigmas[i], 'sigma_hat': sigma_hat, 'denoised': denoised}) dt = sigmas[i + 1] - sigma_hat # Euler method - x = x + d * dt + x = denoised + d * sigmas[i + 1] return x @torch.no_grad() -def sample_euler_ancestral_pp(model, x, sigmas, extra_args=None, callback=None, disable=None, eta=1., s_noise=1., noise_sampler=None): +def sample_euler_ancestral_cfg_pp(model, x, sigmas, extra_args=None, callback=None, disable=None, eta=1., s_noise=1., noise_sampler=None): """Ancestral sampling with Euler method steps.""" extra_args = {} if extra_args is None else extra_args noise_sampler = default_noise_sampler(x) if noise_sampler is None else noise_sampler @@ -1041,10 +1041,10 @@ def post_cfg_function(args): sigma_down, sigma_up = get_ancestral_step(sigmas[i], sigmas[i + 1], eta=eta) if callback is not None: callback({'x': x, 'i': i, 'sigma': sigmas[i], 'sigma_hat': sigmas[i], 'denoised': denoised}) - d = to_d(x - denoised + temp[0], sigmas[i], denoised) + d = to_d(x, sigmas[i], temp[0]) # Euler method dt = sigma_down - sigmas[i] - x = x + d * dt + x = denoised + d * sigma_down if sigmas[i + 1] > 0: x = x + noise_sampler(sigmas[i], sigmas[i + 1]) * s_noise * sigma_up return x diff --git a/comfy/samplers.py b/comfy/samplers.py index 7f7114dbb19f..c0aa12916d3d 100644 --- a/comfy/samplers.py +++ b/comfy/samplers.py @@ -537,7 +537,7 @@ def max_denoise(self, model_wrap, sigmas): sigma = float(sigmas[0]) return math.isclose(max_sigma, sigma, rel_tol=1e-05) or sigma > max_sigma -KSAMPLER_NAMES = ["euler", "euler_pp", "euler_ancestral", "euler_ancestral_pp", "heun", "heunpp2","dpm_2", "dpm_2_ancestral", +KSAMPLER_NAMES = ["euler", "euler_cfg_pp", "euler_ancestral", "euler_ancestral_cfg_pp", "heun", "heunpp2","dpm_2", "dpm_2_ancestral", "lms", "dpm_fast", "dpm_adaptive", "dpmpp_2s_ancestral", "dpmpp_sde", "dpmpp_sde_gpu", "dpmpp_2m", "dpmpp_2m_sde", "dpmpp_2m_sde_gpu", "dpmpp_3m_sde", "dpmpp_3m_sde_gpu", "ddpm", "lcm", "ipndm", "ipndm_v", "deis"] diff --git a/web/scripts/app.js b/web/scripts/app.js index 43df610657dd..3a91aa2396ee 100644 --- a/web/scripts/app.js +++ b/web/scripts/app.js @@ -1966,6 +1966,14 @@ export class ComfyApp { if (widget.value.startsWith("sample_")) { widget.value = widget.value.slice(7); } + if (widget.value === "euler_pp" || widget.value === "euler_ancestral_pp") { + widget.value = widget.value.slice(0, -3); + for (let w of node.widgets) { + if (w.name == "cfg") { + w.value *= 2.0; + } + } + } } } if (node.type == "KSampler" || node.type == "KSamplerAdvanced" || node.type == "PrimitiveNode") { From dbb7dd3b5eb6672e1141a5fc7006d3bee08b0d21 Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Sun, 30 Jun 2024 00:15:49 -0400 Subject: [PATCH 14/94] Add to readme that Stable Audio is supported. --- README.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index a40dd07dd472..2ce7c3e6b3a1 100644 --- a/README.md +++ b/README.md @@ -11,16 +11,16 @@ This ui will let you design and execute advanced stable diffusion pipelines usin ## Features - Nodes/graph/flowchart interface to experiment and create complex Stable Diffusion workflows without needing to code anything. -- Fully supports SD1.x, SD2.x, [SDXL](https://comfyanonymous.github.io/ComfyUI_examples/sdxl/), [Stable Video Diffusion](https://comfyanonymous.github.io/ComfyUI_examples/video/), [Stable Cascade](https://comfyanonymous.github.io/ComfyUI_examples/stable_cascade/) and [SD3](https://comfyanonymous.github.io/ComfyUI_examples/sd3/) +- Fully supports SD1.x, SD2.x, [SDXL](https://comfyanonymous.github.io/ComfyUI_examples/sdxl/), [Stable Video Diffusion](https://comfyanonymous.github.io/ComfyUI_examples/video/), [Stable Cascade](https://comfyanonymous.github.io/ComfyUI_examples/stable_cascade/), [SD3](https://comfyanonymous.github.io/ComfyUI_examples/sd3/) and [Stable Audio](https://comfyanonymous.github.io/ComfyUI_examples/audio/) - Asynchronous Queue system - Many optimizations: Only re-executes the parts of the workflow that changes between executions. -- Command line option: ```--lowvram``` to make it work on GPUs with less than 3GB vram (enabled automatically on GPUs with low vram) +- Smart memory management: can automatically run models on GPUs with as low as 1GB vram. - Works even if you don't have a GPU with: ```--cpu``` (slow) - Can load ckpt, safetensors and diffusers models/checkpoints. Standalone VAEs and CLIP models. - Embeddings/Textual inversion - [Loras (regular, locon and loha)](https://comfyanonymous.github.io/ComfyUI_examples/lora/) - [Hypernetworks](https://comfyanonymous.github.io/ComfyUI_examples/hypernetworks/) -- Loading full workflows (with seeds) from generated PNG files. +- Loading full workflows (with seeds) from generated PNG, WebP and FLAC files. - Saving/Loading workflows as Json files. - Nodes interface can be used to create complex workflows like one for [Hires fix](https://comfyanonymous.github.io/ComfyUI_examples/2_pass_txt2img/) or much more advanced ones. - [Area Composition](https://comfyanonymous.github.io/ComfyUI_examples/area_composition/) From 521421f53ee1ba74304dfaa138b0f851093e1595 Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Sun, 30 Jun 2024 15:51:54 -0400 Subject: [PATCH 15/94] Fix workflow not importing from flac files on some systems. --- web/scripts/app.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/web/scripts/app.js b/web/scripts/app.js index 3a91aa2396ee..776fc197a6d1 100644 --- a/web/scripts/app.js +++ b/web/scripts/app.js @@ -2292,7 +2292,7 @@ export class ComfyApp { } else { this.showErrorOnFileLoad(file); } - } else if (file.type === "audio/flac") { + } else if (file.type === "audio/flac" || file.type === "audio/x-flac") { const pngInfo = await getFlacMetadata(file); // Support loading workflows from that webp custom node. const workflow = pngInfo?.workflow; From 7c5fa7f4a2046c1f4bb77ed5e480918ffb8a10aa Mon Sep 17 00:00:00 2001 From: Chenlei Hu Date: Mon, 1 Jul 2024 12:10:44 -0400 Subject: [PATCH 16/94] Fix loadGraphData func call (#3918) --- web/scripts/app.js | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/web/scripts/app.js b/web/scripts/app.js index 776fc197a6d1..b8889a4cf292 100644 --- a/web/scripts/app.js +++ b/web/scripts/app.js @@ -2314,14 +2314,14 @@ export class ComfyApp { } else if(this.isApiJson(jsonContent)) { this.loadApiJson(jsonContent, fileName); } else { - await this.loadGraphData(jsonContent, true, fileName); + await this.loadGraphData(jsonContent, true, true, fileName); } }; reader.readAsText(file); } else if (file.name?.endsWith(".latent") || file.name?.endsWith(".safetensors")) { const info = await getLatentMetadata(file); if (info.workflow) { - await this.loadGraphData(JSON.parse(info.workflow), true, fileName); + await this.loadGraphData(JSON.parse(info.workflow), true, true, fileName); } else if (info.prompt) { this.loadApiJson(JSON.parse(info.prompt)); } else { From e53b1592ba8426e2c01cd9278bc19c2e4264065b Mon Sep 17 00:00:00 2001 From: ruucm Date: Mon, 1 Jul 2024 10:45:34 -0700 Subject: [PATCH 17/94] enable cmd shortcuts for mac (mute & bypass) (#3792) --- web/scripts/app.js | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/web/scripts/app.js b/web/scripts/app.js index b8889a4cf292..67e488bf927a 100644 --- a/web/scripts/app.js +++ b/web/scripts/app.js @@ -1084,7 +1084,7 @@ export class ComfyApp { if (e.type == "keydown" && !e.repeat) { // Ctrl + M mute/unmute - if (e.key === 'm' && e.ctrlKey) { + if (e.key === 'm' && (e.metaKey || e.ctrlKey)) { if (this.selected_nodes) { for (var i in this.selected_nodes) { if (this.selected_nodes[i].mode === 2) { // never @@ -1098,7 +1098,7 @@ export class ComfyApp { } // Ctrl + B bypass - if (e.key === 'b' && e.ctrlKey) { + if (e.key === 'b' && (e.metaKey || e.ctrlKey)) { if (this.selected_nodes) { for (var i in this.selected_nodes) { if (this.selected_nodes[i].mode === 4) { // never From 601b4b63e1c0af2deef8630449497b9e84aa00f8 Mon Sep 17 00:00:00 2001 From: Robin Huang Date: Mon, 1 Jul 2024 10:51:00 -0700 Subject: [PATCH 18/94] Add CONTRIBUTING.md (#3910) * Create CONTRIBUTING.md * Add feature-request channel link. * Remove discord links for channels. --- CONTRIBUTING.md | 41 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 41 insertions(+) create mode 100644 CONTRIBUTING.md diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 000000000000..048f127e72dd --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1,41 @@ +# Contributing to ComfyUI + +Welcome, and thank you for your interest in contributing to ComfyUI! + +There are several ways in which you can contribute, beyond writing code. The goal of this document is to provide a high-level overview of how you can get involved. + +## Asking Questions + +Have a question? Instead of opening an issue, please ask on [Discord](https://comfy.org/discord) or [Matrix](https://app.element.io/#/room/%23comfyui_space%3Amatrix.org) channels. Our team and the community will help you. + +## Providing Feedback + +Your comments and feedback are welcome, and the development team is available via a handful of different channels. + +See the `#bug-report`, `#feature-request` and `#feedback` channels on Discord. + +## Reporting Issues + +Have you identified a reproducible problem in ComfyUI? Do you have a feature request? We want to hear about it! Here's how you can report your issue as effectively as possible. + + +### Look For an Existing Issue + +Before you create a new issue, please do a search in [open issues](https://github.com/comfyanonymous/ComfyUI/issues) to see if the issue or feature request has already been filed. + +If you find your issue already exists, make relevant comments and add your [reaction](https://github.com/blog/2119-add-reactions-to-pull-requests-issues-and-comments). Use a reaction in place of a "+1" comment: + +* 👍 - upvote +* 👎 - downvote + +If you cannot find an existing issue that describes your bug or feature, create a new issue. We have an issue template in place to organize new issues. + + +### Creating Pull Requests + +* Please refer to the article on [creating pull requests](https://github.com/comfyanonymous/ComfyUI/wiki/How-to-Contribute-Code) and contributing to this project. + + +## Thank You + +Your contributions to open source, large or small, make great projects like this possible. Thank you for taking the time to contribute. From 0cd4a6a5e5101172a1496c337e67f15ad266fb98 Mon Sep 17 00:00:00 2001 From: YAN Wenkun Date: Tue, 2 Jul 2024 05:15:49 +0800 Subject: [PATCH 19/94] Fine-tuning GitHub Actions (#3169) * Bumping GitHub Actions versions * Using LZMA2 for 7zip compression in Windows packaging --- .github/workflows/windows_release_dependencies.yml | 6 +++--- .github/workflows/windows_release_nightly_pytorch.yml | 4 ++-- .github/workflows/windows_release_package.yml | 6 +++--- 3 files changed, 8 insertions(+), 8 deletions(-) diff --git a/.github/workflows/windows_release_dependencies.yml b/.github/workflows/windows_release_dependencies.yml index ffd3e2216e57..5aa57e7d7614 100644 --- a/.github/workflows/windows_release_dependencies.yml +++ b/.github/workflows/windows_release_dependencies.yml @@ -33,8 +33,8 @@ jobs: build_dependencies: runs-on: windows-latest steps: - - uses: actions/checkout@v3 - - uses: actions/setup-python@v4 + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 with: python-version: 3.${{ inputs.python_minor }}.${{ inputs.python_patch }} @@ -58,7 +58,7 @@ jobs: mv temp_wheel_dir cu${{ inputs.cu }}_python_deps tar cf cu${{ inputs.cu }}_python_deps.tar cu${{ inputs.cu }}_python_deps - - uses: actions/cache/save@v3 + - uses: actions/cache/save@v4 with: path: | cu${{ inputs.cu }}_python_deps.tar diff --git a/.github/workflows/windows_release_nightly_pytorch.yml b/.github/workflows/windows_release_nightly_pytorch.yml index fa24a985c7fa..d27c56b3061d 100644 --- a/.github/workflows/windows_release_nightly_pytorch.yml +++ b/.github/workflows/windows_release_nightly_pytorch.yml @@ -32,11 +32,11 @@ jobs: pull-requests: "read" runs-on: windows-latest steps: - - uses: actions/checkout@v3 + - uses: actions/checkout@v4 with: fetch-depth: 0 persist-credentials: false - - uses: actions/setup-python@v4 + - uses: actions/setup-python@v5 with: python-version: 3.${{ inputs.python_minor }}.${{ inputs.python_patch }} - shell: bash diff --git a/.github/workflows/windows_release_package.yml b/.github/workflows/windows_release_package.yml index 4e3cdabd2d57..020741c411f9 100644 --- a/.github/workflows/windows_release_package.yml +++ b/.github/workflows/windows_release_package.yml @@ -32,7 +32,7 @@ jobs: pull-requests: "read" runs-on: windows-latest steps: - - uses: actions/cache/restore@v3 + - uses: actions/cache/restore@v4 id: cache with: path: | @@ -48,7 +48,7 @@ jobs: pwd ls - - uses: actions/checkout@v3 + - uses: actions/checkout@v4 with: fetch-depth: 0 persist-credentials: false @@ -82,7 +82,7 @@ jobs: cd .. - "C:\Program Files\7-Zip\7z.exe" a -t7z -m0=lzma -mx=8 -mfb=64 -md=32m -ms=on -mf=BCJ2 ComfyUI_windows_portable.7z ComfyUI_windows_portable + "C:\Program Files\7-Zip\7z.exe" a -t7z -m0=lzma2 -mx=8 -mfb=64 -md=32m -ms=on -mf=BCJ2 ComfyUI_windows_portable.7z ComfyUI_windows_portable mv ComfyUI_windows_portable.7z ComfyUI/new_ComfyUI_windows_portable_nvidia_cu${{ inputs.cu }}_or_cpu.7z cd ComfyUI_windows_portable From 5dccfefe8d4ca9b33dfe6dfabcc6c666853c73b9 Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Mon, 1 Jul 2024 17:17:25 -0400 Subject: [PATCH 20/94] Switch nightly pytorch standalone package to lzma2. --- .github/workflows/windows_release_nightly_pytorch.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/windows_release_nightly_pytorch.yml b/.github/workflows/windows_release_nightly_pytorch.yml index d27c56b3061d..e68011b64e4d 100644 --- a/.github/workflows/windows_release_nightly_pytorch.yml +++ b/.github/workflows/windows_release_nightly_pytorch.yml @@ -73,7 +73,7 @@ jobs: pause" > ./update/update_comfyui_and_python_dependencies.bat cd .. - "C:\Program Files\7-Zip\7z.exe" a -t7z -m0=lzma -mx=8 -mfb=64 -md=32m -ms=on -mf=BCJ2 ComfyUI_windows_portable_nightly_pytorch.7z ComfyUI_windows_portable_nightly_pytorch + "C:\Program Files\7-Zip\7z.exe" a -t7z -m0=lzma2 -mx=8 -mfb=64 -md=32m -ms=on -mf=BCJ2 ComfyUI_windows_portable_nightly_pytorch.7z ComfyUI_windows_portable_nightly_pytorch mv ComfyUI_windows_portable_nightly_pytorch.7z ComfyUI/ComfyUI_windows_portable_nvidia_or_cpu_nightly_pytorch.7z cd ComfyUI_windows_portable_nightly_pytorch From 755c48d78ea2381b3554de729e36acfb381ebc67 Mon Sep 17 00:00:00 2001 From: Hayden Reeve <39004735+HaydenReeve@users.noreply.github.com> Date: Tue, 2 Jul 2024 05:21:12 +0800 Subject: [PATCH 21/94] Fix several typos in example_node.py.example (#3204) This change includes corrections for several spelling errors in the documentation of example_node.py.example file. These were previously raised by #3157, but they missed a few. --- custom_nodes/example_node.py.example | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/custom_nodes/example_node.py.example b/custom_nodes/example_node.py.example index f066325930d9..57c9cbedf655 100644 --- a/custom_nodes/example_node.py.example +++ b/custom_nodes/example_node.py.example @@ -12,9 +12,9 @@ class Example: Attributes ---------- RETURN_TYPES (`tuple`): - The type of each element in the output tulple. + The type of each element in the output tuple. RETURN_NAMES (`tuple`): - Optional: The name of each output in the output tulple. + Optional: The name of each output in the output tuple. FUNCTION (`str`): The name of the entry-point method. For example, if `FUNCTION = "execute"` then it will run Example().execute() OUTPUT_NODE ([`bool`]): @@ -44,7 +44,7 @@ class Example: * Key field_name (`string`): Name of a entry-point method's argument * Value field_config (`tuple`): + First value is a string indicate the type of field or a list for selection. - + Secound value is a config for type "INT", "STRING" or "FLOAT". + + Second value is a config for type "INT", "STRING" or "FLOAT". """ return { "required": { @@ -61,7 +61,7 @@ class Example: "min": 0.0, "max": 10.0, "step": 0.01, - "round": 0.001, #The value represeting the precision to round to, will be set to the step value by default. Can be set to False to disable rounding. + "round": 0.001, #The value representing the precision to round to, will be set to the step value by default. Can be set to False to disable rounding. "display": "number"}), "print_to_screen": (["enable", "disable"],), "string_field": ("STRING", { From b82d67d5bfa9a1f8c6d0167bf871cbd151c1005f Mon Sep 17 00:00:00 2001 From: Peter Crabtree Date: Mon, 1 Jul 2024 17:42:17 -0400 Subject: [PATCH 22/94] Add SamplerEulerAncestralCFG++ custom sampler node (#3901) (for eta and s_noise) --- comfy_extras/nodes_custom_sampler.py | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/comfy_extras/nodes_custom_sampler.py b/comfy_extras/nodes_custom_sampler.py index 69f1b94181ac..64a8c06312c7 100644 --- a/comfy_extras/nodes_custom_sampler.py +++ b/comfy_extras/nodes_custom_sampler.py @@ -293,6 +293,25 @@ def get_sampler(self, eta, s_noise): sampler = comfy.samplers.ksampler("euler_ancestral", {"eta": eta, "s_noise": s_noise}) return (sampler, ) +class SamplerEulerAncestralCFGPP: + @classmethod + def INPUT_TYPES(s): + return { + "required": { + "eta": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step":0.01, "round": False}), + "s_noise": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 10.0, "step":0.01, "round": False}), + }} + RETURN_TYPES = ("SAMPLER",) + CATEGORY = "sampling/custom_sampling/samplers" + + FUNCTION = "get_sampler" + + def get_sampler(self, eta, s_noise): + sampler = comfy.samplers.ksampler( + "euler_ancestral_cfg_pp", + {"eta": eta, "s_noise": s_noise}) + return (sampler, ) + class SamplerLMS: @classmethod def INPUT_TYPES(s): @@ -622,6 +641,7 @@ def add_noise(self, model, noise, sigmas, latent_image): "SDTurboScheduler": SDTurboScheduler, "KSamplerSelect": KSamplerSelect, "SamplerEulerAncestral": SamplerEulerAncestral, + "SamplerEulerAncestralCFGPP": SamplerEulerAncestralCFGPP, "SamplerLMS": SamplerLMS, "SamplerDPMPP_3M_SDE": SamplerDPMPP_3M_SDE, "SamplerDPMPP_2M_SDE": SamplerDPMPP_2M_SDE, @@ -639,3 +659,7 @@ def add_noise(self, model, noise, sigmas, latent_image): "AddNoise": AddNoise, "SamplerCustomAdvanced": SamplerCustomAdvanced, } + +NODE_DISPLAY_NAME_MAPPINGS = { + "SamplerEulerAncestralCFGPP": "SamplerEulerAncestralCFG++", +} \ No newline at end of file From 9dd549e253f0e2c5e6360f9349b0872af18d8962 Mon Sep 17 00:00:00 2001 From: Chenlei Hu Date: Mon, 1 Jul 2024 17:54:03 -0400 Subject: [PATCH 23/94] Add `--no-custom-node` cmd flag (#3903) * Add --no-custom-node cmd flag * nit --- comfy/cli_args.py | 1 + folder_paths.py | 8 +++++--- main.py | 13 +++++++++++-- nodes.py | 24 ++++++++++++++++++++---- 4 files changed, 37 insertions(+), 9 deletions(-) diff --git a/comfy/cli_args.py b/comfy/cli_args.py index fb0d37ce7508..b72bf3998ae0 100644 --- a/comfy/cli_args.py +++ b/comfy/cli_args.py @@ -118,6 +118,7 @@ class LatentPreviewMethod(enum.Enum): parser.add_argument("--windows-standalone-build", action="store_true", help="Windows standalone build: Enable convenient things that most people using the standalone windows build will probably enjoy (like auto opening the page on startup).") parser.add_argument("--disable-metadata", action="store_true", help="Disable saving prompt metadata in files.") +parser.add_argument("--disable-all-custom-nodes", action="store_true", help="Disable loading all custom nodes.") parser.add_argument("--multi-user", action="store_true", help="Enables per-user storage.") diff --git a/folder_paths.py b/folder_paths.py index 234b734095e5..2cf45f12a34d 100644 --- a/folder_paths.py +++ b/folder_paths.py @@ -2,9 +2,11 @@ import time import logging -supported_pt_extensions = set(['.ckpt', '.pt', '.bin', '.pth', '.safetensors', '.pkl']) +supported_pt_extensions: set[str] = set(['.ckpt', '.pt', '.bin', '.pth', '.safetensors', '.pkl']) -folder_names_and_paths = {} +SupportedFileExtensionsType = set[str] +ScanPathType = list[str] +folder_names_and_paths: dict[str, tuple[ScanPathType, SupportedFileExtensionsType]] = {} base_path = os.path.dirname(os.path.realpath(__file__)) models_dir = os.path.join(base_path, "models") @@ -26,7 +28,7 @@ folder_names_and_paths["upscale_models"] = ([os.path.join(models_dir, "upscale_models")], supported_pt_extensions) -folder_names_and_paths["custom_nodes"] = ([os.path.join(base_path, "custom_nodes")], []) +folder_names_and_paths["custom_nodes"] = ([os.path.join(base_path, "custom_nodes")], set()) folder_names_and_paths["hypernetworks"] = ([os.path.join(models_dir, "hypernetworks")], supported_pt_extensions) diff --git a/main.py b/main.py index a374f2b124a7..2957dd2ffd68 100644 --- a/main.py +++ b/main.py @@ -5,6 +5,8 @@ import importlib.util import folder_paths import time +from comfy.cli_args import args + def execute_prestartup_script(): def execute_script(script_path): @@ -18,6 +20,9 @@ def execute_script(script_path): print(f"Failed to execute startup-script: {script_path} / {e}") return False + if args.disable_all_custom_nodes: + return + node_paths = folder_paths.get_folder_paths("custom_nodes") for custom_node_path in node_paths: possible_modules = os.listdir(custom_node_path) @@ -76,7 +81,7 @@ def execute_script(script_path): import execution import server from server import BinaryEventTypes -from nodes import init_custom_nodes +from nodes import init_builtin_extra_nodes, init_external_custom_nodes import comfy.model_management def cuda_malloc_warning(): @@ -214,7 +219,11 @@ def load_extra_path_config(yaml_path): for config_path in itertools.chain(*args.extra_model_paths_config): load_extra_path_config(config_path) - init_custom_nodes() + init_builtin_extra_nodes() + if not args.disable_all_custom_nodes: + init_external_custom_nodes() + else: + logging.info("Skipping loading of custom nodes") cuda_malloc_warning() diff --git a/nodes.py b/nodes.py index 04775d2906f3..a0d2178f463b 100644 --- a/nodes.py +++ b/nodes.py @@ -1925,7 +1925,16 @@ def load_custom_node(module_path, ignore=set()): logging.warning(f"Cannot import {module_path} module for custom nodes: {e}") return False -def load_custom_nodes(): +def init_external_custom_nodes(): + """ + Initializes the external custom nodes. + + This function loads custom nodes from the specified folder paths and imports them into the application. + It measures the import times for each custom node and logs the results. + + Returns: + None + """ base_node_names = set(NODE_CLASS_MAPPINGS.keys()) node_paths = folder_paths.get_folder_paths("custom_nodes") node_import_times = [] @@ -1952,7 +1961,16 @@ def load_custom_nodes(): logging.info("{:6.1f} seconds{}: {}".format(n[0], import_message, n[1])) logging.info("") -def init_custom_nodes(): +def init_builtin_extra_nodes(): + """ + Initializes the built-in extra nodes in ComfyUI. + + This function loads the extra node files located in the "comfy_extras" directory and imports them into ComfyUI. + If any of the extra node files fail to import, a warning message is logged. + + Returns: + None + """ extras_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), "comfy_extras") extras_files = [ "nodes_latent.py", @@ -1999,8 +2017,6 @@ def init_custom_nodes(): if not load_custom_node(os.path.join(extras_dir, node_file)): import_failed.append(node_file) - load_custom_nodes() - if len(import_failed) > 0: logging.warning("WARNING: some comfy_extras/ nodes did not import correctly. This may be because they are missing some dependencies.\n") for node in import_failed: From 1ef66b095586981633cd11906e6d2e555deab9f6 Mon Sep 17 00:00:00 2001 From: Bob Du Date: Tue, 2 Jul 2024 06:02:42 +0800 Subject: [PATCH 24/94] Add example for how to add custom API routes (#3597) --- custom_nodes/example_node.py.example | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/custom_nodes/example_node.py.example b/custom_nodes/example_node.py.example index 57c9cbedf655..72ca3688c65f 100644 --- a/custom_nodes/example_node.py.example +++ b/custom_nodes/example_node.py.example @@ -106,6 +106,16 @@ class Example: # Set the web directory, any .js file in that directory will be loaded by the frontend as a frontend extension # WEB_DIRECTORY = "./somejs" + +# Add custom API routes, using router +from aiohttp import web +from server import PromptServer + +@PromptServer.instance.routes.get("/hello") +async def get_hello(request): + return web.json_response("hello") + + # A dictionary that contains all nodes you want to export with their names # NOTE: names should be globally unique NODE_CLASS_MAPPINGS = { From 52aaee251fcd87b7c554f4e9c1386b184236f81f Mon Sep 17 00:00:00 2001 From: shawnington <88048838+shawnington@users.noreply.github.com> Date: Tue, 2 Jul 2024 01:30:33 -0400 Subject: [PATCH 25/94] Fix to #3465. Prevent, resaving of duplicate images if overwrite not specified (#3472) * Fix to #3465. Prevent the, resaving of duplicate images if overwrite not specified This is a fix to #3465 Adds function compare_image_hash to do a sha256 hash comparison between an uploaded image and existing images with matching file names. This changes the behavior so that only images having the same filename that are actually different are saved to input, existing images are instead now opened instead of resaved with increment. Currently, exact duplicates with the same filename are resave saved with an incremented filename in the format: (n).ext with the code: ``` while os.path.exists(filepath): filename = f"{split[0]} ({i}){split[1]}" filepath = os.path.join(full_output_folder, filename) i += 1 ``` This commit changes this to: ``` while os.path.exists(filepath): if compare_image_hash(filepath, image): image_is_duplicate = True break filename = f"{split[0]} ({i}){split[1]}" filepath = os.path.join(full_output_folder, filename) i += 1 ``` a check for if image_is_duplicate = False is done before saving the file. Currently, if you load the same image of a cat named cat.jpg into the LoadImage node 3 times, you will get 3 new files in your input folder with incremented file names. With this change, you will now only have the single copy of cat.jpg, that will be re-opened instead of re-saved. However if you load 3 different images of cats named cat.jpg, you will get the expected behavior of having: cat.jpg cat (1).jpg cat (2).jpg This saves space and clutter. After checking my own input folder, I have 800+ images that are duplicates that were resaved with incremented file names amounting to more than 5GB of duplicated data. * fixed typo in expression --- server.py | 31 +++++++++++++++++++++++++------ 1 file changed, 25 insertions(+), 6 deletions(-) diff --git a/server.py b/server.py index 30ea90c6c91c..5b98620ad380 100644 --- a/server.py +++ b/server.py @@ -12,6 +12,7 @@ import glob import struct import ssl +import hashlib from PIL import Image, ImageOps from PIL.PngImagePlugin import PngInfo from io import BytesIO @@ -153,10 +154,24 @@ def get_dir_by_type(dir_type): type_dir = folder_paths.get_output_directory() return type_dir, dir_type - + + def compare_image_hash(filepath, image): + # function to compare hashes of two images to see if it already exists, fix to #3465 + if os.path.exists(filepath): + a = hashlib.sha256() + b = hashlib.sha256() + with open(filepath, "rb") as f: + a.update(f.read()) + b.update(image.file.read()) + image.file.seek(0) + f.close() + return a.hexdigest() == b.hexdigest() + return False + def image_upload(post, image_save_function=None): image = post.get("image") overwrite = post.get("overwrite") + image_is_duplicate = False image_upload_type = post.get("type") upload_dir, image_upload_type = get_dir_by_type(image_upload_type) @@ -183,15 +198,19 @@ def image_upload(post, image_save_function=None): else: i = 1 while os.path.exists(filepath): + if compare_image_hash(filepath, image): #compare hash to prevent saving of duplicates with same name, fix for #3465 + image_is_duplicate = True + break filename = f"{split[0]} ({i}){split[1]}" filepath = os.path.join(full_output_folder, filename) i += 1 - if image_save_function is not None: - image_save_function(image, post, filepath) - else: - with open(filepath, "wb") as f: - f.write(image.file.read()) + if not image_is_duplicate: + if image_save_function is not None: + image_save_function(image, post, filepath) + else: + with open(filepath, "wb") as f: + f.write(image.file.read()) return web.json_response({"name" : filename, "subfolder": subfolder, "type": image_upload_type}) else: From 2f03201690e0fb8a3ec551a125b20d89c9019a02 Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Tue, 2 Jul 2024 01:32:23 -0400 Subject: [PATCH 26/94] Remove some empty lines. --- server.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/server.py b/server.py index 5b98620ad380..38b1bab80f0d 100644 --- a/server.py +++ b/server.py @@ -111,7 +111,7 @@ async def websocket_handler(request): # On reconnect if we are the currently executing client send the current node if self.client_id == sid and self.last_node_id is not None: await self.send("executing", { "node": self.last_node_id }, sid) - + async for msg in ws: if msg.type == aiohttp.WSMsgType.ERROR: logging.warning('ws connection closed with exception %s' % ws.exception()) @@ -132,9 +132,9 @@ def get_embeddings(self): async def get_extensions(request): files = glob.glob(os.path.join( glob.escape(self.web_root), 'extensions/**/*.js'), recursive=True) - + extensions = list(map(lambda f: "/" + os.path.relpath(f, self.web_root).replace("\\", "/"), files)) - + for name, dir in nodes.EXTENSION_WEB_DIRS.items(): files = glob.glob(os.path.join(glob.escape(dir), '**/*.js'), recursive=True) extensions.extend(list(map(lambda f: "/extensions/" + urllib.parse.quote( @@ -154,7 +154,7 @@ def get_dir_by_type(dir_type): type_dir = folder_paths.get_output_directory() return type_dir, dir_type - + def compare_image_hash(filepath, image): # function to compare hashes of two images to see if it already exists, fix to #3465 if os.path.exists(filepath): @@ -167,7 +167,7 @@ def compare_image_hash(filepath, image): f.close() return a.hexdigest() == b.hexdigest() return False - + def image_upload(post, image_save_function=None): image = post.get("image") overwrite = post.get("overwrite") @@ -205,7 +205,7 @@ def image_upload(post, image_save_function=None): filepath = os.path.join(full_output_folder, filename) i += 1 - if not image_is_duplicate: + if not image_is_duplicate: if image_save_function is not None: image_save_function(image, post, filepath) else: From 01991f72ce1bdce31ff4bd6fc2fa64454b1526ad Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Tue, 2 Jul 2024 12:21:08 -0400 Subject: [PATCH 27/94] Fix SamplerEulerCFGpp node. --- comfy_extras/nodes_advanced_samplers.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/comfy_extras/nodes_advanced_samplers.py b/comfy_extras/nodes_advanced_samplers.py index cee3a10c46ee..820c250ef3aa 100644 --- a/comfy_extras/nodes_advanced_samplers.py +++ b/comfy_extras/nodes_advanced_samplers.py @@ -60,7 +60,7 @@ def get_sampler(self, scale_ratio, scale_steps, upscale_method): import comfy.model_patcher @torch.no_grad() -def sample_euler_cfgpp(model, x, sigmas, extra_args=None, callback=None, disable=None): +def sample_euler_pp(model, x, sigmas, extra_args=None, callback=None, disable=None): extra_args = {} if extra_args is None else extra_args temp = [0] @@ -75,11 +75,11 @@ def post_cfg_function(args): for i in trange(len(sigmas) - 1, disable=disable): sigma_hat = sigmas[i] denoised = model(x, sigma_hat * s_in, **extra_args) - d = to_d(x, sigma_hat, temp[0]) + d = to_d(x - denoised + temp[0], sigmas[i], denoised) if callback is not None: callback({'x': x, 'i': i, 'sigma': sigmas[i], 'sigma_hat': sigma_hat, 'denoised': denoised}) dt = sigmas[i + 1] - sigma_hat - x = denoised + sigmas[i + 1] * d + x = x + d * dt return x @@ -96,10 +96,10 @@ def INPUT_TYPES(s): FUNCTION = "get_sampler" def get_sampler(self, version): - if version == "regular": - sampler = comfy.samplers.KSAMPLER(sample_euler_cfgpp) + if version == "alternative": + sampler = comfy.samplers.KSAMPLER(sample_euler_pp) else: - sampler = comfy.samplers.ksampler("euler_pp") + sampler = comfy.samplers.ksampler("euler_cfg_pp") return (sampler, ) NODE_CLASS_MAPPINGS = { From 3f46362d227fa0ca578a69aeb194951b9f87aea0 Mon Sep 17 00:00:00 2001 From: "Alex \"mcmonkey\" Goodwin" <4000772+mcmonkey4eva@users.noreply.github.com> Date: Tue, 2 Jul 2024 17:16:33 -0700 Subject: [PATCH 28/94] fix non-contiguous tensor saving (from channels-last) (#3932) --- comfy/sd.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/comfy/sd.py b/comfy/sd.py index dda0887ba699..b28bfe358517 100644 --- a/comfy/sd.py +++ b/comfy/sd.py @@ -627,5 +627,7 @@ def save_checkpoint(output_path, model, clip=None, vae=None, clip_vision=None, m sd = model.model.state_dict_for_saving(clip_sd, vae.get_sd(), clip_vision_sd) for k in extra_keys: sd[k] = extra_keys[k] + for k in sd: + sd[k] = sd[k].contiguous() comfy.utils.save_torch_file(sd, output_path, metadata=metadata) From 537f35c7bc76e611b53102d3b5a2926e46ec7362 Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Tue, 2 Jul 2024 20:21:51 -0400 Subject: [PATCH 29/94] Don't update dict if contiguous. --- comfy/sd.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/comfy/sd.py b/comfy/sd.py index b28bfe358517..4ba00a62ce53 100644 --- a/comfy/sd.py +++ b/comfy/sd.py @@ -627,7 +627,10 @@ def save_checkpoint(output_path, model, clip=None, vae=None, clip_vision=None, m sd = model.model.state_dict_for_saving(clip_sd, vae.get_sd(), clip_vision_sd) for k in extra_keys: sd[k] = extra_keys[k] + for k in sd: - sd[k] = sd[k].contiguous() + t = sd[k] + if not t.is_contiguous(): + sd[k] = t.contiguous() comfy.utils.save_torch_file(sd, output_path, metadata=metadata) From d7484ef30c97c077dde1c7ae07a16689bec86dd3 Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Wed, 3 Jul 2024 11:34:32 -0400 Subject: [PATCH 30/94] Support loading checkpoints with the UNETLoader node. --- comfy/sd.py | 24 ++++++++++++++++-------- 1 file changed, 16 insertions(+), 8 deletions(-) diff --git a/comfy/sd.py b/comfy/sd.py index 4ba00a62ce53..e343e1fa8ebf 100644 --- a/comfy/sd.py +++ b/comfy/sd.py @@ -563,24 +563,32 @@ def load_checkpoint_guess_config(ckpt_path, output_vae=True, output_clip=True, o return (model_patcher, clip, vae, clipvision) -def load_unet_state_dict(sd): #load unet in diffusers format +def load_unet_state_dict(sd): #load unet in diffusers or regular format + + #Allow loading unets from checkpoint files + checkpoint = False + diffusion_model_prefix = model_detection.unet_prefix_from_state_dict(sd) + temp_sd = comfy.utils.state_dict_prefix_replace(sd, {diffusion_model_prefix: ""}, filter_keys=True) + if len(temp_sd) > 0: + sd = temp_sd + checkpoint = True + parameters = comfy.utils.calculate_parameters(sd) unet_dtype = model_management.unet_dtype(model_params=parameters) load_device = model_management.get_torch_device() - if 'transformer_blocks.0.attn.add_q_proj.weight' in sd: #MMDIT SD3 + if checkpoint or "input_blocks.0.0.weight" in sd or 'clf.1.weight' in sd: #ldm or stable cascade + model_config = model_detection.model_config_from_unet(sd, "") + if model_config is None: + return None + new_sd = sd + elif 'transformer_blocks.0.attn.add_q_proj.weight' in sd: #MMDIT SD3 new_sd = model_detection.convert_diffusers_mmdit(sd, "") if new_sd is None: return None model_config = model_detection.model_config_from_unet(new_sd, "") if model_config is None: return None - elif "input_blocks.0.0.weight" in sd or 'clf.1.weight' in sd: #ldm or stable cascade - model_config = model_detection.model_config_from_unet(sd, "") - if model_config is None: - return None - new_sd = sd - else: #diffusers model_config = model_detection.model_config_from_diffusers_unet(sd) if model_config is None: From 086ac75228af3fea96be58ec45c2f6c17286e75d Mon Sep 17 00:00:00 2001 From: Chenlei Hu Date: Wed, 3 Jul 2024 19:31:46 -0400 Subject: [PATCH 31/94] 3.8 Compatible type annotation (#3938) --- folder_paths.py | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/folder_paths.py b/folder_paths.py index 2cf45f12a34d..2baf8ce1c9f2 100644 --- a/folder_paths.py +++ b/folder_paths.py @@ -1,12 +1,13 @@ import os import time import logging +from typing import Set, List, Dict, Tuple -supported_pt_extensions: set[str] = set(['.ckpt', '.pt', '.bin', '.pth', '.safetensors', '.pkl']) +supported_pt_extensions: Set[str] = set(['.ckpt', '.pt', '.bin', '.pth', '.safetensors', '.pkl']) -SupportedFileExtensionsType = set[str] -ScanPathType = list[str] -folder_names_and_paths: dict[str, tuple[ScanPathType, SupportedFileExtensionsType]] = {} +SupportedFileExtensionsType = Set[str] +ScanPathType = List[str] +folder_names_and_paths: Dict[str, Tuple[ScanPathType, SupportedFileExtensionsType]] = {} base_path = os.path.dirname(os.path.realpath(__file__)) models_dir = os.path.join(base_path, "models") From 24b969d3dace581ed3fb547eedfbdf502ad0f7e9 Mon Sep 17 00:00:00 2001 From: bymyself Date: Wed, 3 Jul 2024 17:30:07 -0700 Subject: [PATCH 32/94] Skip state check hook on first load (#3915) --- web/scripts/changeTracker.js | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/web/scripts/changeTracker.js b/web/scripts/changeTracker.js index 041c83122e0d..39bc4a8104b1 100644 --- a/web/scripts/changeTracker.js +++ b/web/scripts/changeTracker.js @@ -173,9 +173,11 @@ export class ChangeTracker { const onNodeAdded = LiteGraph.LGraph.prototype.onNodeAdded; LiteGraph.LGraph.prototype.onNodeAdded = function () { const v = onNodeAdded?.apply(this, arguments); - const ct = changeTracker(); - if (!ct.isOurLoad) { - ct.checkState(); + if (!app?.configuringGraph) { + const ct = changeTracker(); + if (!ct.isOurLoad) { + ct.checkState(); + } } return v; }; From 739b76630e0298561c39d0d3341bc2856e55d995 Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Thu, 4 Jul 2024 15:14:13 -0400 Subject: [PATCH 33/94] Remove useless code. --- comfy/cldm/mmdit.py | 9 --------- 1 file changed, 9 deletions(-) diff --git a/comfy/cldm/mmdit.py b/comfy/cldm/mmdit.py index ee0282bc7269..025c2fb5dff3 100644 --- a/comfy/cldm/mmdit.py +++ b/comfy/cldm/mmdit.py @@ -56,15 +56,6 @@ def forward( if context is not None: context = self.context_embedder(context) - if self.register_length > 0: - context = torch.cat( - ( - repeat(self.register, "1 ... -> b ...", b=x.shape[0]), - default(context, torch.Tensor([]).type_as(x)), - ), - 1, - ) - output = [] blocks = len(self.joint_blocks) From 0e3dfd9e343d4aee7826fbc188e2af8ceb1bdde9 Mon Sep 17 00:00:00 2001 From: Chenlei Hu Date: Thu, 4 Jul 2024 20:49:07 -0400 Subject: [PATCH 34/94] Use relative path for custom/extra node module name (#3944) * Fix module name for comfy extra nodes * Use module name relative to root dir --- nodes.py | 30 ++++++++++++++++++++++++++---- 1 file changed, 26 insertions(+), 4 deletions(-) diff --git a/nodes.py b/nodes.py index a0d2178f463b..81efecf6596f 100644 --- a/nodes.py +++ b/nodes.py @@ -1887,11 +1887,33 @@ def expand_image(self, image, left, top, right, bottom, feathering): EXTENSION_WEB_DIRS = {} -def load_custom_node(module_path, ignore=set()): - module_name = os.path.basename(module_path) + +def get_module_name(module_path: str) -> str: + """ + Returns the module name based on the given module path. + Examples: + get_module_name("C:/Users/username/ComfyUI/custom_nodes/my_custom_node.py") -> "custom_nodes.my_custom_node" + get_module_name("C:/Users/username/ComfyUI/custom_nodes/my_custom_node") -> "custom_nodes.my_custom_node" + get_module_name("C:/Users/username/ComfyUI/custom_nodes/my_custom_node/") -> "custom_nodes.my_custom_node" + get_module_name("C:/Users/username/ComfyUI/custom_nodes/my_custom_node/__init__.py") -> "custom_nodes.my_custom_node" + get_module_name("C:/Users/username/ComfyUI/custom_nodes/my_custom_node/__init__") -> "custom_nodes.my_custom_node" + get_module_name("C:/Users/username/ComfyUI/custom_nodes/my_custom_node/__init__/") -> "custom_nodes.my_custom_node" + get_module_name("C:/Users/username/ComfyUI/custom_nodes/my_custom_node.disabled") -> "custom_nodes.my + + Args: + module_path (str): The path of the module. + + Returns: + str: The module name. + """ + relative_path = os.path.relpath(module_path, folder_paths.base_path) if os.path.isfile(module_path): - sp = os.path.splitext(module_path) - module_name = sp[0] + relative_path = os.path.splitext(relative_path)[0] + return relative_path.replace(os.sep, '.') + + +def load_custom_node(module_path, ignore=set()): + module_name = get_module_name(module_path) try: logging.debug("Trying to load custom node {}".format(module_path)) if os.path.isfile(module_path): From 720b17442d39b5991e1d3c336f9d16a0f75c929c Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Thu, 4 Jul 2024 21:09:05 -0400 Subject: [PATCH 35/94] Temporary revert. --- nodes.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/nodes.py b/nodes.py index 81efecf6596f..03544be02c2b 100644 --- a/nodes.py +++ b/nodes.py @@ -1913,7 +1913,7 @@ def get_module_name(module_path: str) -> str: def load_custom_node(module_path, ignore=set()): - module_name = get_module_name(module_path) + module_name = os.path.basename(module_path) try: logging.debug("Trying to load custom node {}".format(module_path)) if os.path.isfile(module_path): From bd2d3e27d786b89e9ef89d6eb083e94172126306 Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Thu, 4 Jul 2024 21:43:23 -0400 Subject: [PATCH 36/94] Show comfy_extras warning at the end. Remove code. --- main.py | 8 ++------ nodes.py | 35 +++++++++++------------------------ 2 files changed, 13 insertions(+), 30 deletions(-) diff --git a/main.py b/main.py index 2957dd2ffd68..9650703a8fb0 100644 --- a/main.py +++ b/main.py @@ -81,7 +81,7 @@ def execute_script(script_path): import execution import server from server import BinaryEventTypes -from nodes import init_builtin_extra_nodes, init_external_custom_nodes +import nodes import comfy.model_management def cuda_malloc_warning(): @@ -219,11 +219,7 @@ def load_extra_path_config(yaml_path): for config_path in itertools.chain(*args.extra_model_paths_config): load_extra_path_config(config_path) - init_builtin_extra_nodes() - if not args.disable_all_custom_nodes: - init_external_custom_nodes() - else: - logging.info("Skipping loading of custom nodes") + nodes.init_extra_nodes(init_custom_nodes=not args.disable_all_custom_nodes) cuda_malloc_warning() diff --git a/nodes.py b/nodes.py index 03544be02c2b..8f8abb4947ef 100644 --- a/nodes.py +++ b/nodes.py @@ -1888,30 +1888,6 @@ def expand_image(self, image, left, top, right, bottom, feathering): EXTENSION_WEB_DIRS = {} -def get_module_name(module_path: str) -> str: - """ - Returns the module name based on the given module path. - Examples: - get_module_name("C:/Users/username/ComfyUI/custom_nodes/my_custom_node.py") -> "custom_nodes.my_custom_node" - get_module_name("C:/Users/username/ComfyUI/custom_nodes/my_custom_node") -> "custom_nodes.my_custom_node" - get_module_name("C:/Users/username/ComfyUI/custom_nodes/my_custom_node/") -> "custom_nodes.my_custom_node" - get_module_name("C:/Users/username/ComfyUI/custom_nodes/my_custom_node/__init__.py") -> "custom_nodes.my_custom_node" - get_module_name("C:/Users/username/ComfyUI/custom_nodes/my_custom_node/__init__") -> "custom_nodes.my_custom_node" - get_module_name("C:/Users/username/ComfyUI/custom_nodes/my_custom_node/__init__/") -> "custom_nodes.my_custom_node" - get_module_name("C:/Users/username/ComfyUI/custom_nodes/my_custom_node.disabled") -> "custom_nodes.my - - Args: - module_path (str): The path of the module. - - Returns: - str: The module name. - """ - relative_path = os.path.relpath(module_path, folder_paths.base_path) - if os.path.isfile(module_path): - relative_path = os.path.splitext(relative_path)[0] - return relative_path.replace(os.sep, '.') - - def load_custom_node(module_path, ignore=set()): module_name = os.path.basename(module_path) try: @@ -2039,6 +2015,17 @@ def init_builtin_extra_nodes(): if not load_custom_node(os.path.join(extras_dir, node_file)): import_failed.append(node_file) + return import_failed + + +def init_extra_nodes(init_custom_nodes=True): + import_failed = init_external_custom_nodes() + + if init_custom_nodes: + init_external_custom_nodes() + else: + logging.info("Skipping loading of custom nodes") + if len(import_failed) > 0: logging.warning("WARNING: some comfy_extras/ nodes did not import correctly. This may be because they are missing some dependencies.\n") for node in import_failed: From cedbc94cc0551cfdeae01c48b922d546c816f898 Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Thu, 4 Jul 2024 21:49:50 -0400 Subject: [PATCH 37/94] Forgot this in last commit. --- nodes.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/nodes.py b/nodes.py index 8f8abb4947ef..9c541eba8779 100644 --- a/nodes.py +++ b/nodes.py @@ -1890,6 +1890,9 @@ def expand_image(self, image, left, top, right, bottom, feathering): def load_custom_node(module_path, ignore=set()): module_name = os.path.basename(module_path) + if os.path.isfile(module_path): + sp = os.path.splitext(module_path) + module_name = sp[0] try: logging.debug("Trying to load custom node {}".format(module_path)) if os.path.isfile(module_path): @@ -2019,7 +2022,7 @@ def init_builtin_extra_nodes(): def init_extra_nodes(init_custom_nodes=True): - import_failed = init_external_custom_nodes() + import_failed = init_builtin_extra_nodes() if init_custom_nodes: init_external_custom_nodes() From 1dc87df4c5f4925f8eb286236e71c9dd38941dd6 Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Thu, 4 Jul 2024 22:03:37 -0400 Subject: [PATCH 38/94] Readme changes. --- README.md | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/README.md b/README.md index 2ce7c3e6b3a1..35e3238a1da2 100644 --- a/README.md +++ b/README.md @@ -225,12 +225,11 @@ Use `--tls-keyfile key.pem --tls-certfile cert.pem` to enable TLS/SSL, the app w [Matrix space: #comfyui_space:matrix.org](https://app.element.io/#/room/%23comfyui_space%3Amatrix.org) (it's like discord but open source). -# QA +See also: [https://www.comfy.org/](https://www.comfy.org/) -### Why did you make this? +# QA -I wanted to learn how Stable Diffusion worked in detail. I also wanted something clean and powerful that would let me experiment with SD without restrictions. +### Which GPU should I buy for this? -### Who is this for? +[See this page for some recommendations](https://github.com/comfyanonymous/ComfyUI/wiki/Which-GPU-should-I-buy-for-ComfyUI) -This is for anyone that wants to make complex workflows with SD or that wants to learn more how SD works. The interface follows closely how SD works and the code should be much more simple to understand than other SD UIs. From b4c2d03d476f97d9d91c0d7d0af7fde382084385 Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Fri, 5 Jul 2024 12:10:22 -0400 Subject: [PATCH 39/94] Remove duplicate import. --- main.py | 1 - 1 file changed, 1 deletion(-) diff --git a/main.py b/main.py index 9650703a8fb0..196351a3d2cb 100644 --- a/main.py +++ b/main.py @@ -58,7 +58,6 @@ def execute_script(script_path): import threading import gc -from comfy.cli_args import args import logging if os.name == "nt": From ce649d61c05ab0e905155b4a010d4f0459a0db8d Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Fri, 5 Jul 2024 23:48:17 -0400 Subject: [PATCH 40/94] Allow zeroing out of embeds with unused attention mask. --- comfy/sd1_clip.py | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/comfy/sd1_clip.py b/comfy/sd1_clip.py index 78e556b568f7..3b812b44c148 100644 --- a/comfy/sd1_clip.py +++ b/comfy/sd1_clip.py @@ -169,7 +169,7 @@ def forward(self, tokens): tokens = torch.LongTensor(tokens).to(device) attention_mask = None - if self.enable_attention_masks: + if self.enable_attention_masks or self.zero_out_masked: attention_mask = torch.zeros_like(tokens) end_token = self.special_tokens.get("end", -1) for x in range(attention_mask.shape[0]): @@ -178,7 +178,11 @@ def forward(self, tokens): if tokens[x, y] == end_token: break - outputs = self.transformer(tokens, attention_mask, intermediate_output=self.layer_idx, final_layer_norm_intermediate=self.layer_norm_hidden_state) + attention_mask_model = None + if self.enable_attention_masks: + attention_mask_model = attention_mask + + outputs = self.transformer(tokens, attention_mask_model, intermediate_output=self.layer_idx, final_layer_norm_intermediate=self.layer_norm_hidden_state) self.transformer.set_input_embeddings(backup_embeds) if self.layer == "last": @@ -186,7 +190,7 @@ def forward(self, tokens): else: z = outputs[1].float() - if self.zero_out_masked and attention_mask is not None: + if self.zero_out_masked: z *= attention_mask.unsqueeze(-1).float() pooled_output = None From 80c45909985aa37e6803ed59b6753fc289ee365f Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Sat, 6 Jul 2024 00:06:49 -0400 Subject: [PATCH 41/94] Allow specifying the padding token for the tokenizer. --- comfy/sd1_clip.py | 20 ++++++++++++-------- 1 file changed, 12 insertions(+), 8 deletions(-) diff --git a/comfy/sd1_clip.py b/comfy/sd1_clip.py index 3b812b44c148..ed3dc2298ced 100644 --- a/comfy/sd1_clip.py +++ b/comfy/sd1_clip.py @@ -364,7 +364,7 @@ def load_embed(embedding_name, embedding_directory, embedding_size, embed_key=No return embed_out class SDTokenizer: - def __init__(self, tokenizer_path=None, max_length=77, pad_with_end=True, embedding_directory=None, embedding_size=768, embedding_key='clip_l', tokenizer_class=CLIPTokenizer, has_start_token=True, pad_to_max_length=True, min_length=None): + def __init__(self, tokenizer_path=None, max_length=77, pad_with_end=True, embedding_directory=None, embedding_size=768, embedding_key='clip_l', tokenizer_class=CLIPTokenizer, has_start_token=True, pad_to_max_length=True, min_length=None, pad_token=None): if tokenizer_path is None: tokenizer_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), "sd1_tokenizer") self.tokenizer = tokenizer_class.from_pretrained(tokenizer_path) @@ -380,6 +380,14 @@ def __init__(self, tokenizer_path=None, max_length=77, pad_with_end=True, embedd self.tokens_start = 0 self.start_token = None self.end_token = empty[0] + + if pad_token is not None: + self.pad_token = pad_token + elif pad_with_end: + self.pad_token = self.end_token + else: + self.pad_token = 0 + self.pad_with_end = pad_with_end self.pad_to_max_length = pad_to_max_length @@ -412,10 +420,6 @@ def tokenize_with_weights(self, text:str, return_word_ids=False): Word id values are unique per word and embedding, where the id 0 is reserved for non word tokens. Returned list has the dimensions NxM where M is the input size of CLIP ''' - if self.pad_with_end: - pad_token = self.end_token - else: - pad_token = 0 text = escape_important(text) parsed_weights = token_weights(text, 1.0) @@ -467,7 +471,7 @@ def tokenize_with_weights(self, text:str, return_word_ids=False): else: batch.append((self.end_token, 1.0, 0)) if self.pad_to_max_length: - batch.extend([(pad_token, 1.0, 0)] * (remaining_length)) + batch.extend([(self.pad_token, 1.0, 0)] * (remaining_length)) #start new batch batch = [] if self.start_token is not None: @@ -480,9 +484,9 @@ def tokenize_with_weights(self, text:str, return_word_ids=False): #fill last batch batch.append((self.end_token, 1.0, 0)) if self.pad_to_max_length: - batch.extend([(pad_token, 1.0, 0)] * (self.max_length - len(batch))) + batch.extend([(self.pad_token, 1.0, 0)] * (self.max_length - len(batch))) if self.min_length is not None and len(batch) < self.min_length: - batch.extend([(pad_token, 1.0, 0)] * (self.min_length - len(batch))) + batch.extend([(self.pad_token, 1.0, 0)] * (self.min_length - len(batch))) if not return_word_ids: batched_tokens = [[(t, w) for t, w,_ in x] for x in batched_tokens] From b8e58a939463be85877c1244ee00763368723c07 Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Sat, 6 Jul 2024 00:33:25 -0400 Subject: [PATCH 42/94] Cleanup T5 code a bit. --- comfy/t5.py | 35 +++++++++++++++++++++-------------- comfy/t5_config_base.json | 1 + comfy/t5_config_xxl.json | 1 + 3 files changed, 23 insertions(+), 14 deletions(-) diff --git a/comfy/t5.py b/comfy/t5.py index 06dfe47668e6..d00b560a3b95 100644 --- a/comfy/t5.py +++ b/comfy/t5.py @@ -13,29 +13,36 @@ def forward(self, x): x = x * torch.rsqrt(variance + self.variance_epsilon) return self.weight.to(device=x.device, dtype=x.dtype) * x +activations = { + "gelu_pytorch_tanh": lambda a: torch.nn.functional.gelu(a, approximate="tanh"), + "relu": torch.nn.functional.relu, +} + class T5DenseActDense(torch.nn.Module): - def __init__(self, model_dim, ff_dim, dtype, device, operations): + def __init__(self, model_dim, ff_dim, ff_activation, dtype, device, operations): super().__init__() self.wi = operations.Linear(model_dim, ff_dim, bias=False, dtype=dtype, device=device) self.wo = operations.Linear(ff_dim, model_dim, bias=False, dtype=dtype, device=device) # self.dropout = nn.Dropout(config.dropout_rate) + self.act = activations[ff_activation] def forward(self, x): - x = torch.nn.functional.relu(self.wi(x)) + x = self.act(self.wi(x)) # x = self.dropout(x) x = self.wo(x) return x class T5DenseGatedActDense(torch.nn.Module): - def __init__(self, model_dim, ff_dim, dtype, device, operations): + def __init__(self, model_dim, ff_dim, ff_activation, dtype, device, operations): super().__init__() self.wi_0 = operations.Linear(model_dim, ff_dim, bias=False, dtype=dtype, device=device) self.wi_1 = operations.Linear(model_dim, ff_dim, bias=False, dtype=dtype, device=device) self.wo = operations.Linear(ff_dim, model_dim, bias=False, dtype=dtype, device=device) # self.dropout = nn.Dropout(config.dropout_rate) + self.act = activations[ff_activation] def forward(self, x): - hidden_gelu = torch.nn.functional.gelu(self.wi_0(x), approximate="tanh") + hidden_gelu = self.act(self.wi_0(x)) hidden_linear = self.wi_1(x) x = hidden_gelu * hidden_linear # x = self.dropout(x) @@ -43,12 +50,12 @@ def forward(self, x): return x class T5LayerFF(torch.nn.Module): - def __init__(self, model_dim, ff_dim, ff_activation, dtype, device, operations): + def __init__(self, model_dim, ff_dim, ff_activation, gated_act, dtype, device, operations): super().__init__() - if ff_activation == "gelu_pytorch_tanh": - self.DenseReluDense = T5DenseGatedActDense(model_dim, ff_dim, dtype, device, operations) - elif ff_activation == "relu": - self.DenseReluDense = T5DenseActDense(model_dim, ff_dim, dtype, device, operations) + if gated_act: + self.DenseReluDense = T5DenseGatedActDense(model_dim, ff_dim, ff_activation, dtype, device, operations) + else: + self.DenseReluDense = T5DenseActDense(model_dim, ff_dim, ff_activation, dtype, device, operations) self.layer_norm = T5LayerNorm(model_dim, dtype=dtype, device=device, operations=operations) # self.dropout = nn.Dropout(config.dropout_rate) @@ -171,11 +178,11 @@ def forward(self, x, mask=None, past_bias=None, optimized_attention=None): return x, past_bias class T5Block(torch.nn.Module): - def __init__(self, model_dim, inner_dim, ff_dim, ff_activation, num_heads, relative_attention_bias, dtype, device, operations): + def __init__(self, model_dim, inner_dim, ff_dim, ff_activation, gated_act, num_heads, relative_attention_bias, dtype, device, operations): super().__init__() self.layer = torch.nn.ModuleList() self.layer.append(T5LayerSelfAttention(model_dim, inner_dim, ff_dim, num_heads, relative_attention_bias, dtype, device, operations)) - self.layer.append(T5LayerFF(model_dim, ff_dim, ff_activation, dtype, device, operations)) + self.layer.append(T5LayerFF(model_dim, ff_dim, ff_activation, gated_act, dtype, device, operations)) def forward(self, x, mask=None, past_bias=None, optimized_attention=None): x, past_bias = self.layer[0](x, mask, past_bias, optimized_attention) @@ -183,11 +190,11 @@ def forward(self, x, mask=None, past_bias=None, optimized_attention=None): return x, past_bias class T5Stack(torch.nn.Module): - def __init__(self, num_layers, model_dim, inner_dim, ff_dim, ff_activation, num_heads, dtype, device, operations): + def __init__(self, num_layers, model_dim, inner_dim, ff_dim, ff_activation, gated_act, num_heads, dtype, device, operations): super().__init__() self.block = torch.nn.ModuleList( - [T5Block(model_dim, inner_dim, ff_dim, ff_activation, num_heads, relative_attention_bias=(i == 0), dtype=dtype, device=device, operations=operations) for i in range(num_layers)] + [T5Block(model_dim, inner_dim, ff_dim, ff_activation, gated_act, num_heads, relative_attention_bias=(i == 0), dtype=dtype, device=device, operations=operations) for i in range(num_layers)] ) self.final_layer_norm = T5LayerNorm(model_dim, dtype=dtype, device=device, operations=operations) # self.dropout = nn.Dropout(config.dropout_rate) @@ -216,7 +223,7 @@ def __init__(self, config_dict, dtype, device, operations): self.num_layers = config_dict["num_layers"] model_dim = config_dict["d_model"] - self.encoder = T5Stack(self.num_layers, model_dim, model_dim, config_dict["d_ff"], config_dict["dense_act_fn"], config_dict["num_heads"], dtype, device, operations) + self.encoder = T5Stack(self.num_layers, model_dim, model_dim, config_dict["d_ff"], config_dict["dense_act_fn"], config_dict["is_gated_act"], config_dict["num_heads"], dtype, device, operations) self.dtype = dtype self.shared = torch.nn.Embedding(config_dict["vocab_size"], model_dim, device=device) diff --git a/comfy/t5_config_base.json b/comfy/t5_config_base.json index facd85ef3a9c..71f68327c272 100644 --- a/comfy/t5_config_base.json +++ b/comfy/t5_config_base.json @@ -8,6 +8,7 @@ "dense_act_fn": "relu", "initializer_factor": 1.0, "is_encoder_decoder": true, + "is_gated_act": false, "layer_norm_epsilon": 1e-06, "model_type": "t5", "num_decoder_layers": 12, diff --git a/comfy/t5_config_xxl.json b/comfy/t5_config_xxl.json index bf4feadcf501..28283b51a11b 100644 --- a/comfy/t5_config_xxl.json +++ b/comfy/t5_config_xxl.json @@ -8,6 +8,7 @@ "dense_act_fn": "gelu_pytorch_tanh", "initializer_factor": 1.0, "is_encoder_decoder": true, + "is_gated_act": true, "layer_norm_epsilon": 1e-06, "model_type": "t5", "num_decoder_layers": 24, From 404049114913f1a134656769a538779d7c927249 Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Sat, 6 Jul 2024 00:53:33 -0400 Subject: [PATCH 43/94] Better T5xxl detection. --- comfy/sd.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/comfy/sd.py b/comfy/sd.py index e343e1fa8ebf..b39230bd796e 100644 --- a/comfy/sd.py +++ b/comfy/sd.py @@ -432,9 +432,11 @@ class EmptyClass: clip_target.clip = sd2_clip.SD2ClipModel clip_target.tokenizer = sd2_clip.SD2Tokenizer elif "encoder.block.23.layer.1.DenseReluDense.wi_1.weight" in clip_data[0]: - dtype_t5 = clip_data[0]["encoder.block.23.layer.1.DenseReluDense.wi_1.weight"].dtype - clip_target.clip = sd3_clip.sd3_clip(clip_l=False, clip_g=False, t5=True, dtype_t5=dtype_t5) - clip_target.tokenizer = sd3_clip.SD3Tokenizer + weight = clip_data[0]["encoder.block.23.layer.1.DenseReluDense.wi_1.weight"] + dtype_t5 = weight.dtype + if weight.shape[-1] == 4096: + clip_target.clip = sd3_clip.sd3_clip(clip_l=False, clip_g=False, t5=True, dtype_t5=dtype_t5) + clip_target.tokenizer = sd3_clip.SD3Tokenizer elif "encoder.block.0.layer.0.SelfAttention.k.weight" in clip_data[0]: clip_target.clip = sa_t5.SAT5Model clip_target.tokenizer = sa_t5.SAT5Tokenizer From ff63893d103d9c3168eaf9101fb3cebbc2abd8fa Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Sat, 6 Jul 2024 02:42:53 -0400 Subject: [PATCH 44/94] Support other types of T5 models. --- comfy/t5.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/comfy/t5.py b/comfy/t5.py index d00b560a3b95..448c5aad3e0d 100644 --- a/comfy/t5.py +++ b/comfy/t5.py @@ -190,11 +190,11 @@ def forward(self, x, mask=None, past_bias=None, optimized_attention=None): return x, past_bias class T5Stack(torch.nn.Module): - def __init__(self, num_layers, model_dim, inner_dim, ff_dim, ff_activation, gated_act, num_heads, dtype, device, operations): + def __init__(self, num_layers, model_dim, inner_dim, ff_dim, ff_activation, gated_act, num_heads, relative_attention, dtype, device, operations): super().__init__() self.block = torch.nn.ModuleList( - [T5Block(model_dim, inner_dim, ff_dim, ff_activation, gated_act, num_heads, relative_attention_bias=(i == 0), dtype=dtype, device=device, operations=operations) for i in range(num_layers)] + [T5Block(model_dim, inner_dim, ff_dim, ff_activation, gated_act, num_heads, relative_attention_bias=((not relative_attention) or (i == 0)), dtype=dtype, device=device, operations=operations) for i in range(num_layers)] ) self.final_layer_norm = T5LayerNorm(model_dim, dtype=dtype, device=device, operations=operations) # self.dropout = nn.Dropout(config.dropout_rate) @@ -223,7 +223,7 @@ def __init__(self, config_dict, dtype, device, operations): self.num_layers = config_dict["num_layers"] model_dim = config_dict["d_model"] - self.encoder = T5Stack(self.num_layers, model_dim, model_dim, config_dict["d_ff"], config_dict["dense_act_fn"], config_dict["is_gated_act"], config_dict["num_heads"], dtype, device, operations) + self.encoder = T5Stack(self.num_layers, model_dim, model_dim, config_dict["d_ff"], config_dict["dense_act_fn"], config_dict["is_gated_act"], config_dict["num_heads"], config_dict["model_type"] == "t5", dtype, device, operations) self.dtype = dtype self.shared = torch.nn.Embedding(config_dict["vocab_size"], model_dim, device=device) From 2dc84d14447782683862616eaf8c19c0c1feacf3 Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Sat, 6 Jul 2024 04:06:03 -0400 Subject: [PATCH 45/94] Add a way to set the timestep multiplier in the flow sampling. --- comfy/model_sampling.py | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/comfy/model_sampling.py b/comfy/model_sampling.py index 6bd3a5d79a5a..2d95a83dc84f 100644 --- a/comfy/model_sampling.py +++ b/comfy/model_sampling.py @@ -190,11 +190,12 @@ def __init__(self, model_config=None): else: sampling_settings = {} - self.set_parameters(shift=sampling_settings.get("shift", 1.0)) + self.set_parameters(shift=sampling_settings.get("shift", 1.0), multiplier=sampling_settings.get("multiplier", 1000)) - def set_parameters(self, shift=1.0, timesteps=1000): + def set_parameters(self, shift=1.0, timesteps=1000, multiplier=1000): self.shift = shift - ts = self.sigma(torch.arange(1, timesteps + 1, 1)) + self.multiplier = multiplier + ts = self.sigma((torch.arange(1, timesteps + 1, 1) / timesteps) * multiplier) self.register_buffer('sigmas', ts) @property @@ -206,10 +207,10 @@ def sigma_max(self): return self.sigmas[-1] def timestep(self, sigma): - return sigma * 1000 + return sigma * self.multiplier def sigma(self, timestep): - return time_snr_shift(self.shift, timestep / 1000) + return time_snr_shift(self.shift, timestep / self.multiplier) def percent_to_sigma(self, percent): if percent <= 0.0: From 628f0b8ebc2c9a51205e5e5a9973f8db348a310f Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Sun, 7 Jul 2024 09:22:32 -0400 Subject: [PATCH 46/94] Move audio nodes out of _for_testing. --- comfy_extras/nodes_audio.py | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/comfy_extras/nodes_audio.py b/comfy_extras/nodes_audio.py index 9950d58ed005..64d241e988ae 100644 --- a/comfy_extras/nodes_audio.py +++ b/comfy_extras/nodes_audio.py @@ -19,7 +19,7 @@ def INPUT_TYPES(s): RETURN_TYPES = ("LATENT",) FUNCTION = "generate" - CATEGORY = "_for_testing/audio" + CATEGORY = "latent/audio" def generate(self, seconds): batch_size = 1 @@ -34,7 +34,7 @@ def INPUT_TYPES(s): RETURN_TYPES = ("LATENT",) FUNCTION = "encode" - CATEGORY = "_for_testing/audio" + CATEGORY = "latent/audio" def encode(self, vae, audio): sample_rate = audio["sample_rate"] @@ -53,7 +53,7 @@ def INPUT_TYPES(s): RETURN_TYPES = ("AUDIO",) FUNCTION = "decode" - CATEGORY = "_for_testing/audio" + CATEGORY = "latent/audio" def decode(self, vae, samples): audio = vae.decode(samples["samples"]).movedim(-1, 1) @@ -132,7 +132,7 @@ def INPUT_TYPES(s): OUTPUT_NODE = True - CATEGORY = "_for_testing/audio" + CATEGORY = "audio" def save_audio(self, audio, filename_prefix="ComfyUI", prompt=None, extra_pnginfo=None): filename_prefix += self.prefix_append @@ -195,7 +195,7 @@ def INPUT_TYPES(s): ] return {"required": {"audio": (sorted(files), {"audio_upload": True})}} - CATEGORY = "_for_testing/audio" + CATEGORY = "audio" RETURN_TYPES = ("AUDIO", ) FUNCTION = "load" @@ -203,7 +203,6 @@ def INPUT_TYPES(s): def load(self, audio): audio_path = folder_paths.get_annotated_filepath(audio) waveform, sample_rate = torchaudio.load(audio_path) - multiplier = 1.0 audio = {"waveform": waveform.unsqueeze(0), "sample_rate": sample_rate} return (audio, ) From bb663bcd6c81a4395100c5f8527a221037d366f8 Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Mon, 8 Jul 2024 08:48:38 -0400 Subject: [PATCH 47/94] Rename clip_t5base to t5base for stable audio text encoder. --- comfy/sa_t5.py | 2 +- comfy/sd1_clip.py | 12 +++++++++--- 2 files changed, 10 insertions(+), 4 deletions(-) diff --git a/comfy/sa_t5.py b/comfy/sa_t5.py index 37be5287e22d..acc302f67e61 100644 --- a/comfy/sa_t5.py +++ b/comfy/sa_t5.py @@ -19,4 +19,4 @@ def __init__(self, embedding_directory=None): class SAT5Model(sd1_clip.SD1ClipModel): def __init__(self, device="cpu", dtype=None, **kwargs): - super().__init__(device=device, dtype=dtype, clip_name="t5base", clip_model=T5BaseModel, **kwargs) + super().__init__(device=device, dtype=dtype, name="t5base", clip_model=T5BaseModel, **kwargs) diff --git a/comfy/sd1_clip.py b/comfy/sd1_clip.py index ed3dc2298ced..0fe1f1d13a0d 100644 --- a/comfy/sd1_clip.py +++ b/comfy/sd1_clip.py @@ -514,10 +514,16 @@ def untokenize(self, token_weight_pair): class SD1ClipModel(torch.nn.Module): - def __init__(self, device="cpu", dtype=None, clip_name="l", clip_model=SDClipModel, **kwargs): + def __init__(self, device="cpu", dtype=None, clip_name="l", clip_model=SDClipModel, name=None, **kwargs): super().__init__() - self.clip_name = clip_name - self.clip = "clip_{}".format(self.clip_name) + + if name is not None: + self.clip_name = name + self.clip = "{}".format(self.clip_name) + else: + self.clip_name = clip_name + self.clip = "clip_{}".format(self.clip_name) + setattr(self, self.clip, clip_model(device=device, dtype=dtype, **kwargs)) self.dtypes = set() From faa57430b0ff882275b1afcf6610e8e9f8a5929b Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Mon, 8 Jul 2024 23:26:34 -0400 Subject: [PATCH 48/94] Controlnet union model basic implementation. This is only the model code itself, it currently defaults to an empty embedding [0] * 6 which seems to work better than treating it like a regular controlnet. TODO: Add nodes to select the image type. --- comfy/cldm/cldm.py | 113 +++++++++++++++++++++++++++++++++++++++++++- comfy/controlnet.py | 6 +++ 2 files changed, 118 insertions(+), 1 deletion(-) diff --git a/comfy/cldm/cldm.py b/comfy/cldm/cldm.py index f8a161594521..3feb9bab0cde 100644 --- a/comfy/cldm/cldm.py +++ b/comfy/cldm/cldm.py @@ -13,7 +13,47 @@ from ..ldm.modules.attention import SpatialTransformer from ..ldm.modules.diffusionmodules.openaimodel import UNetModel, TimestepEmbedSequential, ResBlock, Downsample from ..ldm.util import exists +from ..ldm.cascade.common import OptimizedAttention +from collections import OrderedDict import comfy.ops +from comfy.ldm.modules.attention import optimized_attention + +class OptimizedAttention(nn.Module): + def __init__(self, c, nhead, dropout=0.0, dtype=None, device=None, operations=None): + super().__init__() + self.heads = nhead + self.c = c + + self.in_proj = operations.Linear(c, c * 3, bias=True, dtype=dtype, device=device) + self.out_proj = operations.Linear(c, c, bias=True, dtype=dtype, device=device) + + def forward(self, x): + x = self.in_proj(x) + q, k, v = x.split(self.c, dim=2) + out = optimized_attention(q, k, v, self.heads) + return self.out_proj(out) + +class QuickGELU(nn.Module): + def forward(self, x: torch.Tensor): + return x * torch.sigmoid(1.702 * x) + +class ResBlockUnionControlnet(nn.Module): + def __init__(self, dim, nhead, dtype=None, device=None, operations=None): + super().__init__() + self.attn = OptimizedAttention(dim, nhead, dtype=dtype, device=device, operations=operations) + self.ln_1 = operations.LayerNorm(dim, dtype=dtype, device=device) + self.mlp = nn.Sequential( + OrderedDict([("c_fc", operations.Linear(dim, dim * 4, dtype=dtype, device=device)), ("gelu", QuickGELU()), + ("c_proj", operations.Linear(dim * 4, dim, dtype=dtype, device=device))])) + self.ln_2 = operations.LayerNorm(dim, dtype=dtype, device=device) + + def attention(self, x: torch.Tensor): + return self.attn(x) + + def forward(self, x: torch.Tensor): + x = x + self.attention(self.ln_1(x)) + x = x + self.mlp(self.ln_2(x)) + return x class ControlledUnetModel(UNetModel): #implemented in the ldm unet @@ -53,6 +93,7 @@ def __init__( transformer_depth_middle=None, transformer_depth_output=None, attn_precision=None, + union_controlnet=False, device=None, operations=comfy.ops.disable_weight_init, **kwargs, @@ -280,6 +321,65 @@ def __init__( self.middle_block_out = self.make_zero_conv(ch, operations=operations, dtype=self.dtype, device=device) self._feature_size += ch + if union_controlnet: + self.num_control_type = 6 + num_trans_channel = 320 + num_trans_head = 8 + num_trans_layer = 1 + num_proj_channel = 320 + # task_scale_factor = num_trans_channel ** 0.5 + self.task_embedding = nn.Parameter(torch.empty(self.num_control_type, num_trans_channel, dtype=self.dtype, device=device)) + + self.transformer_layes = nn.Sequential(*[ResBlockUnionControlnet(num_trans_channel, num_trans_head, dtype=self.dtype, device=device, operations=operations) for _ in range(num_trans_layer)]) + self.spatial_ch_projs = operations.Linear(num_trans_channel, num_proj_channel, dtype=self.dtype, device=device) + #----------------------------------------------------------------------------------------------------- + + control_add_embed_dim = 256 + class ControlAddEmbedding(nn.Module): + def __init__(self, in_dim, out_dim, num_control_type, dtype=None, device=None, operations=None): + super().__init__() + self.num_control_type = num_control_type + self.in_dim = in_dim + self.linear_1 = operations.Linear(in_dim * num_control_type, out_dim, dtype=dtype, device=device) + self.linear_2 = operations.Linear(out_dim, out_dim, dtype=dtype, device=device) + def forward(self, control_type, dtype, device): + c_type = torch.zeros((self.num_control_type,), device=device) + c_type[control_type] = 1.0 + c_type = timestep_embedding(c_type.flatten(), self.in_dim, repeat_only=False).to(dtype).reshape((-1, self.num_control_type * self.in_dim)) + return self.linear_2(torch.nn.functional.silu(self.linear_1(c_type))) + + self.control_add_embedding = ControlAddEmbedding(control_add_embed_dim, time_embed_dim, self.num_control_type, dtype=self.dtype, device=device, operations=operations) + else: + self.task_embedding = None + self.control_add_embedding = None + + def union_controlnet_merge(self, hint, control_type, emb, context): + # Equivalent to: https://github.com/xinsir6/ControlNetPlus/tree/main + inputs = [] + condition_list = [] + + for idx in range(min(1, len(control_type))): + controlnet_cond = self.input_hint_block(hint[idx], emb, context) + feat_seq = torch.mean(controlnet_cond, dim=(2, 3)) + if idx < len(control_type): + feat_seq += self.task_embedding[control_type[idx]] + + inputs.append(feat_seq.unsqueeze(1)) + condition_list.append(controlnet_cond) + + x = torch.cat(inputs, dim=1) + x = self.transformer_layes(x) + controlnet_cond_fuser = None + for idx in range(len(control_type)): + alpha = self.spatial_ch_projs(x[:, idx]) + alpha = alpha.unsqueeze(-1).unsqueeze(-1) + o = condition_list[idx] + alpha + if controlnet_cond_fuser is None: + controlnet_cond_fuser = o + else: + controlnet_cond_fuser += o + return controlnet_cond_fuser + def make_zero_conv(self, channels, operations=None, dtype=None, device=None): return TimestepEmbedSequential(operations.conv_nd(self.dims, channels, channels, 1, padding=0, dtype=dtype, device=device)) @@ -287,7 +387,18 @@ def forward(self, x, hint, timesteps, context, y=None, **kwargs): t_emb = timestep_embedding(timesteps, self.model_channels, repeat_only=False).to(x.dtype) emb = self.time_embed(t_emb) - guided_hint = self.input_hint_block(hint, emb, context) + guided_hint = None + if self.control_add_embedding is not None: + control_type = kwargs.get("control_type", []) + + emb += self.control_add_embedding(control_type, emb.dtype, emb.device) + if len(control_type) > 0: + if len(hint.shape) < 5: + hint = hint.unsqueeze(dim=0) + guided_hint = self.union_controlnet_merge(hint, control_type, emb, context) + + if guided_hint is None: + guided_hint = self.input_hint_block(hint, emb, context) out_output = [] out_middle = [] diff --git a/comfy/controlnet.py b/comfy/controlnet.py index d0039513968f..84286f1fac76 100644 --- a/comfy/controlnet.py +++ b/comfy/controlnet.py @@ -413,6 +413,12 @@ def load_controlnet(ckpt_path, model=None): if k in controlnet_data: new_sd[diffusers_keys[k]] = controlnet_data.pop(k) + if "control_add_embedding.linear_1.bias" in controlnet_data: #Union Controlnet + controlnet_config["union_controlnet"] = True + for k in list(controlnet_data.keys()): + new_k = k.replace('.attn.in_proj_', '.attn.in_proj.') + new_sd[new_k] = controlnet_data.pop(k) + leftover_keys = controlnet_data.keys() if len(leftover_keys) > 0: logging.warning("leftover keys: {}".format(leftover_keys)) From ade7aa1b0ce7944f50f66af5d8742299ac49d07f Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Tue, 9 Jul 2024 11:05:05 -0400 Subject: [PATCH 49/94] Remove useless import. --- comfy/cldm/cldm.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/comfy/cldm/cldm.py b/comfy/cldm/cldm.py index 3feb9bab0cde..d4d32b87ec92 100644 --- a/comfy/cldm/cldm.py +++ b/comfy/cldm/cldm.py @@ -13,7 +13,6 @@ from ..ldm.modules.attention import SpatialTransformer from ..ldm.modules.diffusionmodules.openaimodel import UNetModel, TimestepEmbedSequential, ResBlock, Downsample from ..ldm.util import exists -from ..ldm.cascade.common import OptimizedAttention from collections import OrderedDict import comfy.ops from comfy.ldm.modules.attention import optimized_attention @@ -388,7 +387,7 @@ def forward(self, x, hint, timesteps, context, y=None, **kwargs): emb = self.time_embed(t_emb) guided_hint = None - if self.control_add_embedding is not None: + if self.control_add_embedding is not None: #Union Controlnet control_type = kwargs.get("control_type", []) emb += self.control_add_embedding(control_type, emb.dtype, emb.device) From d160073829b836fce97046ebb5f145fa1c677ae3 Mon Sep 17 00:00:00 2001 From: bymyself Date: Tue, 9 Jul 2024 08:23:26 -0700 Subject: [PATCH 50/94] Fix loadGraphData call during restore (#3976) --- web/scripts/app.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/web/scripts/app.js b/web/scripts/app.js index 67e488bf927a..8b4478a322a1 100644 --- a/web/scripts/app.js +++ b/web/scripts/app.js @@ -1599,7 +1599,7 @@ export class ComfyApp { if (json) { const workflow = JSON.parse(json); const workflowName = getStorageValue("Comfy.PreviousWorkflow"); - await this.loadGraphData(workflow, true, workflowName); + await this.loadGraphData(workflow, true, true, workflowName); return true; } }; From c3db344746163f9ab942591020043d47ca34e4f0 Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Tue, 9 Jul 2024 11:52:31 -0400 Subject: [PATCH 51/94] Fix ConditioningZeroOut when there is no pooled output. --- nodes.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/nodes.py b/nodes.py index 9c541eba8779..a230f725b84d 100644 --- a/nodes.py +++ b/nodes.py @@ -232,8 +232,9 @@ def zero_out(self, conditioning): c = [] for t in conditioning: d = t[1].copy() - if "pooled_output" in d: - d["pooled_output"] = torch.zeros_like(d["pooled_output"]) + pooled_output = d.get("pooled_output", None) + if pooled_output is not None: + d["pooled_output"] = torch.zeros_like(pooled_output) n = [torch.zeros_like(t[0]), d] c.append(n) return (c, ) From f1a01c2c7e2678f34c72212d2a8640237f31fa43 Mon Sep 17 00:00:00 2001 From: Extraltodeus Date: Tue, 9 Jul 2024 22:20:49 +0200 Subject: [PATCH 52/94] Add sampler_pre_cfg_function (#3979) * Update samplers.py * Update model_patcher.py --- comfy/model_patcher.py | 9 +++++++++ comfy/samplers.py | 6 ++++++ 2 files changed, 15 insertions(+) diff --git a/comfy/model_patcher.py b/comfy/model_patcher.py index b949031e9986..efac251ca90a 100644 --- a/comfy/model_patcher.py +++ b/comfy/model_patcher.py @@ -57,6 +57,12 @@ def set_model_options_post_cfg_function(model_options, post_cfg_function, disabl model_options["disable_cfg1_optimization"] = True return model_options +def set_model_options_pre_cfg_function(model_options, pre_cfg_function, disable_cfg1_optimization=False): + model_options["sampler_pre_cfg_function"] = model_options.get("sampler_pre_cfg_function", []) + [pre_cfg_function] + if disable_cfg1_optimization: + model_options["disable_cfg1_optimization"] = True + return model_options + class ModelPatcher: def __init__(self, model, load_device, offload_device, size=0, current_device=None, weight_inplace_update=False): self.size = size @@ -130,6 +136,9 @@ def set_model_sampler_cfg_function(self, sampler_cfg_function, disable_cfg1_opti def set_model_sampler_post_cfg_function(self, post_cfg_function, disable_cfg1_optimization=False): self.model_options = set_model_options_post_cfg_function(self.model_options, post_cfg_function, disable_cfg1_optimization) + def set_model_sampler_pre_cfg_function(self, pre_cfg_function, disable_cfg1_optimization=False): + self.model_options = set_model_options_pre_cfg_function(self.model_options, pre_cfg_function, disable_cfg1_optimization) + def set_model_unet_function_wrapper(self, unet_wrapper_function: UnetWrapperFunction): self.model_options["model_function_wrapper"] = unet_wrapper_function diff --git a/comfy/samplers.py b/comfy/samplers.py index c0aa12916d3d..bbf9219f7eef 100644 --- a/comfy/samplers.py +++ b/comfy/samplers.py @@ -275,6 +275,12 @@ def sampling_function(model, x, timestep, uncond, cond, cond_scale, model_option conds = [cond, uncond_] out = calc_cond_batch(model, conds, x, timestep, model_options) + + for fn in model_options.get("sampler_pre_cfg_function", []): + args = {"conds":conds, "conds_out": out, "cond_scale": cond_scale, "timestep": timestep, + "input": x, "sigma": timestep, "model": model, "model_options": model_options} + out = fn(args) + return cfg_function(model, out[0], out[1], cond_scale, x, timestep, model_options=model_options, cond=cond, uncond=uncond_) From 83f70a88fbc4866050dae90d78ec66aebe8e341a Mon Sep 17 00:00:00 2001 From: Chenlei Hu Date: Tue, 9 Jul 2024 17:07:15 -0400 Subject: [PATCH 53/94] Add __module__ to node info (#3936) Use more explicit name 'python_module' Parse abs ath Move parse to nodes.py --- nodes.py | 29 ++++++++++++++++++++++++++--- server.py | 1 + 2 files changed, 27 insertions(+), 3 deletions(-) diff --git a/nodes.py b/nodes.py index a230f725b84d..8d8b153f8a39 100644 --- a/nodes.py +++ b/nodes.py @@ -1889,7 +1889,29 @@ def expand_image(self, image, left, top, right, bottom, feathering): EXTENSION_WEB_DIRS = {} -def load_custom_node(module_path, ignore=set()): +def get_relative_module_name(module_path: str) -> str: + """ + Returns the module name based on the given module path. + Examples: + get_module_name("C:/Users/username/ComfyUI/custom_nodes/my_custom_node.py") -> "custom_nodes.my_custom_node" + get_module_name("C:/Users/username/ComfyUI/custom_nodes/my_custom_node") -> "custom_nodes.my_custom_node" + get_module_name("C:/Users/username/ComfyUI/custom_nodes/my_custom_node/") -> "custom_nodes.my_custom_node" + get_module_name("C:/Users/username/ComfyUI/custom_nodes/my_custom_node/__init__.py") -> "custom_nodes.my_custom_node" + get_module_name("C:/Users/username/ComfyUI/custom_nodes/my_custom_node/__init__") -> "custom_nodes.my_custom_node" + get_module_name("C:/Users/username/ComfyUI/custom_nodes/my_custom_node/__init__/") -> "custom_nodes.my_custom_node" + get_module_name("C:/Users/username/ComfyUI/custom_nodes/my_custom_node.disabled") -> "custom_nodes.my + Args: + module_path (str): The path of the module. + Returns: + str: The module name. + """ + relative_path = os.path.relpath(module_path, folder_paths.base_path) + if os.path.isfile(module_path): + relative_path = os.path.splitext(relative_path)[0] + return relative_path.replace(os.sep, '.') + + +def load_custom_node(module_path: str, ignore=set()) -> bool: module_name = os.path.basename(module_path) if os.path.isfile(module_path): sp = os.path.splitext(module_path) @@ -1913,9 +1935,10 @@ def load_custom_node(module_path, ignore=set()): EXTENSION_WEB_DIRS[module_name] = web_dir if hasattr(module, "NODE_CLASS_MAPPINGS") and getattr(module, "NODE_CLASS_MAPPINGS") is not None: - for name in module.NODE_CLASS_MAPPINGS: + for name, node_cls in module.NODE_CLASS_MAPPINGS.items(): if name not in ignore: - NODE_CLASS_MAPPINGS[name] = module.NODE_CLASS_MAPPINGS[name] + NODE_CLASS_MAPPINGS[name] = node_cls + node_cls.RELATIVE_PYTHON_MODULE = get_relative_module_name(module_path) if hasattr(module, "NODE_DISPLAY_NAME_MAPPINGS") and getattr(module, "NODE_DISPLAY_NAME_MAPPINGS") is not None: NODE_DISPLAY_NAME_MAPPINGS.update(module.NODE_DISPLAY_NAME_MAPPINGS) return True diff --git a/server.py b/server.py index 38b1bab80f0d..ce7c7532dabd 100644 --- a/server.py +++ b/server.py @@ -416,6 +416,7 @@ def node_info(node_class): info['name'] = node_class info['display_name'] = nodes.NODE_DISPLAY_NAME_MAPPINGS[node_class] if node_class in nodes.NODE_DISPLAY_NAME_MAPPINGS.keys() else node_class info['description'] = obj_class.DESCRIPTION if hasattr(obj_class,'DESCRIPTION') else '' + info['python_module'] = getattr(obj_class, "RELATIVE_PYTHON_MODULE", "nodes") info['category'] = 'sd' if hasattr(obj_class, 'OUTPUT_NODE') and obj_class.OUTPUT_NODE == True: info['output_node'] = True From 8d3f979b633dab9824c59bf8a06c748a533eec0b Mon Sep 17 00:00:00 2001 From: Chenlei Hu Date: Tue, 9 Jul 2024 17:12:57 -0400 Subject: [PATCH 54/94] Check unhandled exception in test log in test action (#3987) * Upload console logs * Check unhandled exception --- .github/workflows/test-browser.yml | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) diff --git a/.github/workflows/test-browser.yml b/.github/workflows/test-browser.yml index 65483b00f28d..7beb0c696469 100644 --- a/.github/workflows/test-browser.yml +++ b/.github/workflows/test-browser.yml @@ -42,7 +42,7 @@ jobs: working-directory: ComfyUI - name: Start ComfyUI server run: | - python main.py --cpu & + python main.py --cpu 2>&1 | tee console_output.log & wait-for-it --service 127.0.0.1:8188 -t 600 working-directory: ComfyUI - name: Install ComfyUI_frontend dependencies @@ -55,9 +55,22 @@ jobs: - name: Run Playwright tests run: npx playwright test working-directory: ComfyUI_frontend + - name: Check for unhandled exceptions in server log + run: | + if grep -qE "Exception|Error" console_output.log; then + echo "Unhandled exception/error found in server log." + exit 1 + fi + working-directory: ComfyUI - uses: actions/upload-artifact@v4 if: always() with: name: playwright-report path: ComfyUI_frontend/playwright-report/ retention-days: 30 + - uses: actions/upload-artifact@v4 + if: always() + with: + name: console-output + path: ComfyUI/console_output.log + retention-days: 30 From 90389b3b8a69c08c3ed0bcc9d87a92246578a8e3 Mon Sep 17 00:00:00 2001 From: Chenlei Hu Date: Wed, 10 Jul 2024 11:28:15 -0400 Subject: [PATCH 55/94] Update bug issue template (#3996) * Update issue template * nit --- .github/ISSUE_TEMPLATE/bug-report.yml | 83 ++++++++++++++------------- 1 file changed, 43 insertions(+), 40 deletions(-) diff --git a/.github/ISSUE_TEMPLATE/bug-report.yml b/.github/ISSUE_TEMPLATE/bug-report.yml index 87bef368189b..39d1992d7623 100644 --- a/.github/ISSUE_TEMPLATE/bug-report.yml +++ b/.github/ISSUE_TEMPLATE/bug-report.yml @@ -1,45 +1,48 @@ name: Bug Report description: "Something is broken inside of ComfyUI. (Do not use this if you're just having issues and need help, or if the issue relates to a custom node)" -labels: [ "Potential Bug" ] +labels: ["Potential Bug"] body: - - type: markdown - attributes: - value: | - Before submitting a **Bug Report**, please ensure the following: + - type: markdown + attributes: + value: | + Before submitting a **Bug Report**, please ensure the following: - **1:** You are running the latest version of ComfyUI. - **2:** You have looked at the existing bug reports and made sure this isn't already reported. - **3:** This is an actual bug in ComfyUI, not just a support question and not caused by an custom node. A bug is when you can specify exact steps to replicate what went wrong and others will be able to repeat your steps and see the same issue happen. + - **1:** You are running the latest version of ComfyUI. + - **2:** You have looked at the existing bug reports and made sure this isn't already reported. + - **3:** You confirmed that the bug is not caused by a custom node. You can disable all custom nodes by passing + `--disable-all-custom-nodes` command line argument. + - **4:** This is an actual bug in ComfyUI, not just a support question. A bug is when you can specify exact + steps to replicate what went wrong and others will be able to repeat your steps and see the same issue happen. - If unsure, ask on the [ComfyUI Matrix Space](https://app.element.io/#/room/%23comfyui_space%3Amatrix.org) or the [Comfy Org Discord](https://discord.gg/comfyorg) first. - - type: textarea - attributes: - label: Expected Behavior - description: "What you expected to happen." - validations: - required: true - - type: textarea - attributes: - label: Actual Behavior - description: "What actually happened. Please include a screenshot of the issue if possible." - validations: - required: true - - type: textarea - attributes: - label: Steps to Reproduce - description: "Describe how to reproduce the issue. Please be sure to attach a workflow JSON or PNG, ideally one that doesn't require custom nodes to test. If the bug open happens when certain custom nodes are used, most likely that custom node is what has the bug rather than ComfyUI, in which case it should be reported to the node's author." - validations: - required: true - - type: textarea - attributes: - label: Debug Logs - description: "Please copy the output from your terminal logs here." - render: powershell - validations: - required: true - - type: textarea - attributes: - label: Other - description: "Any other additional information you think might be helpful." - validations: - required: false + If unsure, ask on the [ComfyUI Matrix Space](https://app.element.io/#/room/%23comfyui_space%3Amatrix.org) or the [Comfy Org Discord](https://discord.gg/comfyorg) first. + - type: textarea + attributes: + label: Expected Behavior + description: "What you expected to happen." + validations: + required: true + - type: textarea + attributes: + label: Actual Behavior + description: "What actually happened. Please include a screenshot of the issue if possible." + validations: + required: true + - type: textarea + attributes: + label: Steps to Reproduce + description: "Describe how to reproduce the issue. Please be sure to attach a workflow JSON or PNG, ideally one that doesn't require custom nodes to test. If the bug open happens when certain custom nodes are used, most likely that custom node is what has the bug rather than ComfyUI, in which case it should be reported to the node's author." + validations: + required: true + - type: textarea + attributes: + label: Debug Logs + description: "Please copy the output from your terminal logs here." + render: powershell + validations: + required: true + - type: textarea + attributes: + label: Other + description: "Any other additional information you think might be helpful." + validations: + required: false From e44fa5667fd0a5469b1b5efa08187282779f4d44 Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Wed, 10 Jul 2024 19:31:22 -0400 Subject: [PATCH 56/94] Support returning text encoder attention masks. --- comfy/sd1_clip.py | 19 ++++++++++++++----- 1 file changed, 14 insertions(+), 5 deletions(-) diff --git a/comfy/sd1_clip.py b/comfy/sd1_clip.py index 0fe1f1d13a0d..4da2b46fde16 100644 --- a/comfy/sd1_clip.py +++ b/comfy/sd1_clip.py @@ -38,7 +38,9 @@ def encode_token_weights(self, token_weight_pairs): if has_weights or sections == 0: to_encode.append(gen_empty_tokens(self.special_tokens, max_token_len)) - out, pooled = self.encode(to_encode) + o = self.encode(to_encode) + out, pooled = o[:2] + if pooled is not None: first_pooled = pooled[0:1].to(model_management.intermediate_device()) else: @@ -57,8 +59,11 @@ def encode_token_weights(self, token_weight_pairs): output.append(z) if (len(output) == 0): - return out[-1:].to(model_management.intermediate_device()), first_pooled - return torch.cat(output, dim=-2).to(model_management.intermediate_device()), first_pooled + r = (out[-1:].to(model_management.intermediate_device()), first_pooled) + else: + r = (torch.cat(output, dim=-2).to(model_management.intermediate_device()), first_pooled) + r = r + tuple(map(lambda a: a[:sections].flatten().unsqueeze(dim=0).to(model_management.intermediate_device()), o[2:])) + return r class SDClipModel(torch.nn.Module, ClipTokenWeightEncoder): """Uses the CLIP transformer encoder for text (from huggingface)""" @@ -70,7 +75,7 @@ class SDClipModel(torch.nn.Module, ClipTokenWeightEncoder): def __init__(self, version="openai/clip-vit-large-patch14", device="cpu", max_length=77, freeze=True, layer="last", layer_idx=None, textmodel_json_config=None, dtype=None, model_class=comfy.clip_model.CLIPTextModel, special_tokens={"start": 49406, "end": 49407, "pad": 49407}, layer_norm_hidden_state=True, enable_attention_masks=False, zero_out_masked=False, - return_projected_pooled=True): # clip-vit-base-patch32 + return_projected_pooled=True, return_attention_masks=False): # clip-vit-base-patch32 super().__init__() assert layer in self.LAYERS @@ -96,6 +101,7 @@ def __init__(self, version="openai/clip-vit-large-patch14", device="cpu", max_le self.layer_norm_hidden_state = layer_norm_hidden_state self.return_projected_pooled = return_projected_pooled + self.return_attention_masks = return_attention_masks if layer == "hidden": assert layer_idx is not None @@ -169,7 +175,7 @@ def forward(self, tokens): tokens = torch.LongTensor(tokens).to(device) attention_mask = None - if self.enable_attention_masks or self.zero_out_masked: + if self.enable_attention_masks or self.zero_out_masked or self.return_attention_masks: attention_mask = torch.zeros_like(tokens) end_token = self.special_tokens.get("end", -1) for x in range(attention_mask.shape[0]): @@ -200,6 +206,9 @@ def forward(self, tokens): elif outputs[2] is not None: pooled_output = outputs[2].float() + if self.return_attention_masks: + return z, pooled_output, attention_mask + return z, pooled_output def encode(self, tokens): From 391c1046cff8a3877a2ba343057579ab4278c5b1 Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Wed, 10 Jul 2024 20:06:50 -0400 Subject: [PATCH 57/94] More flexibility with text encoder return values. Text encoders can now return other values to the CONDITIONING than the cond and pooled output. --- comfy/sd.py | 12 ++++++++++-- comfy/sd1_clip.py | 21 +++++++++++++++++---- nodes.py | 5 +++-- 3 files changed, 30 insertions(+), 8 deletions(-) diff --git a/comfy/sd.py b/comfy/sd.py index b39230bd796e..25454f836bf3 100644 --- a/comfy/sd.py +++ b/comfy/sd.py @@ -130,7 +130,7 @@ def clip_layer(self, layer_idx): def tokenize(self, text, return_word_ids=False): return self.tokenizer.tokenize_with_weights(text, return_word_ids) - def encode_from_tokens(self, tokens, return_pooled=False): + def encode_from_tokens(self, tokens, return_pooled=False, return_dict=False): self.cond_stage_model.reset_clip_options() if self.layer_idx is not None: @@ -140,7 +140,15 @@ def encode_from_tokens(self, tokens, return_pooled=False): self.cond_stage_model.set_clip_options({"projected_pooled": False}) self.load_model() - cond, pooled = self.cond_stage_model.encode_token_weights(tokens) + o = self.cond_stage_model.encode_token_weights(tokens) + cond, pooled = o[:2] + if return_dict: + out = {"cond": cond, "pooled_output": pooled} + if len(o) > 2: + for k in o[2]: + out[k] = o[2][k] + return out + if return_pooled: return cond, pooled return cond diff --git a/comfy/sd1_clip.py b/comfy/sd1_clip.py index 4da2b46fde16..565ad69dade6 100644 --- a/comfy/sd1_clip.py +++ b/comfy/sd1_clip.py @@ -62,7 +62,16 @@ def encode_token_weights(self, token_weight_pairs): r = (out[-1:].to(model_management.intermediate_device()), first_pooled) else: r = (torch.cat(output, dim=-2).to(model_management.intermediate_device()), first_pooled) - r = r + tuple(map(lambda a: a[:sections].flatten().unsqueeze(dim=0).to(model_management.intermediate_device()), o[2:])) + + if len(o) > 2: + extra = {} + for k in o[2]: + v = o[2][k] + if k == "attention_mask": + v = v[:sections].flatten().unsqueeze(dim=0).to(model_management.intermediate_device()) + extra[k] = v + + r = r + (extra,) return r class SDClipModel(torch.nn.Module, ClipTokenWeightEncoder): @@ -206,8 +215,12 @@ def forward(self, tokens): elif outputs[2] is not None: pooled_output = outputs[2].float() + extra = {} if self.return_attention_masks: - return z, pooled_output, attention_mask + extra["attention_mask"] = attention_mask + + if len(extra) > 0: + return z, pooled_output, extra return z, pooled_output @@ -547,8 +560,8 @@ def reset_clip_options(self): def encode_token_weights(self, token_weight_pairs): token_weight_pairs = token_weight_pairs[self.clip_name] - out, pooled = getattr(self, self.clip).encode_token_weights(token_weight_pairs) - return out, pooled + out = getattr(self, self.clip).encode_token_weights(token_weight_pairs) + return out def load_sd(self, sd): return getattr(self, self.clip).load_sd(sd) diff --git a/nodes.py b/nodes.py index 8d8b153f8a39..5778f060949d 100644 --- a/nodes.py +++ b/nodes.py @@ -55,8 +55,9 @@ def INPUT_TYPES(s): def encode(self, clip, text): tokens = clip.tokenize(text) - cond, pooled = clip.encode_from_tokens(tokens, return_pooled=True) - return ([[cond, {"pooled_output": pooled}]], ) + output = clip.encode_from_tokens(tokens, return_pooled=True, return_dict=True) + cond = output.pop("cond") + return ([[cond, output]], ) class ConditioningCombine: @classmethod From ffe0bb0a33a8a8d9a999dafb540558646127d443 Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Wed, 10 Jul 2024 20:33:12 -0400 Subject: [PATCH 58/94] Remove useless code. --- comfy/sd.py | 30 ------------------------------ 1 file changed, 30 deletions(-) diff --git a/comfy/sd.py b/comfy/sd.py index 25454f836bf3..d0832ad3a960 100644 --- a/comfy/sd.py +++ b/comfy/sd.py @@ -28,36 +28,6 @@ import comfy.supported_models_base import comfy.taesd.taesd -def load_model_weights(model, sd): - m, u = model.load_state_dict(sd, strict=False) - m = set(m) - unexpected_keys = set(u) - - k = list(sd.keys()) - for x in k: - if x not in unexpected_keys: - w = sd.pop(x) - del w - if len(m) > 0: - logging.warning("missing {}".format(m)) - return model - -def load_clip_weights(model, sd): - k = list(sd.keys()) - for x in k: - if x.startswith("cond_stage_model.transformer.") and not x.startswith("cond_stage_model.transformer.text_model."): - y = x.replace("cond_stage_model.transformer.", "cond_stage_model.transformer.text_model.") - sd[y] = sd.pop(x) - - if 'cond_stage_model.transformer.text_model.embeddings.position_ids' in sd: - ids = sd['cond_stage_model.transformer.text_model.embeddings.position_ids'] - if ids.dtype == torch.float32: - sd['cond_stage_model.transformer.text_model.embeddings.position_ids'] = ids.round() - - sd = comfy.utils.clip_text_transformers_convert(sd, "cond_stage_model.model.", "cond_stage_model.transformer.") - return load_model_weights(model, sd) - - def load_lora_for_models(model, clip, lora, strength_model, strength_clip): key_map = {} if model is not None: From 5e1fced6392ca4fef404e01094fbcbec77bdd31f Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Thu, 11 Jul 2024 11:37:31 -0400 Subject: [PATCH 59/94] Cleaner support for loading different diffusion model types. --- comfy/model_detection.py | 5 +++++ comfy/sd.py | 8 ++------ 2 files changed, 7 insertions(+), 6 deletions(-) diff --git a/comfy/model_detection.py b/comfy/model_detection.py index 0b678480f19b..783a03eb7fc5 100644 --- a/comfy/model_detection.py +++ b/comfy/model_detection.py @@ -105,6 +105,9 @@ def detect_unet_config(state_dict, key_prefix): unet_config["audio_model"] = "dit1.0" return unet_config + if '{}input_blocks.0.0.weight'.format(key_prefix) not in state_dict_keys: + return None + unet_config = { "use_checkpoint": False, "image_size": 32, @@ -239,6 +242,8 @@ def model_config_from_unet_config(unet_config, state_dict=None): def model_config_from_unet(state_dict, unet_key_prefix, use_base_if_no_match=False): unet_config = detect_unet_config(state_dict, unet_key_prefix) + if unet_config is None: + return None model_config = model_config_from_unet_config(unet_config, state_dict) if model_config is None and use_base_if_no_match: return comfy.supported_models_base.BASE(unet_config) diff --git a/comfy/sd.py b/comfy/sd.py index d0832ad3a960..66033b63e19e 100644 --- a/comfy/sd.py +++ b/comfy/sd.py @@ -546,21 +546,17 @@ def load_checkpoint_guess_config(ckpt_path, output_vae=True, output_clip=True, o def load_unet_state_dict(sd): #load unet in diffusers or regular format #Allow loading unets from checkpoint files - checkpoint = False diffusion_model_prefix = model_detection.unet_prefix_from_state_dict(sd) temp_sd = comfy.utils.state_dict_prefix_replace(sd, {diffusion_model_prefix: ""}, filter_keys=True) if len(temp_sd) > 0: sd = temp_sd - checkpoint = True parameters = comfy.utils.calculate_parameters(sd) unet_dtype = model_management.unet_dtype(model_params=parameters) load_device = model_management.get_torch_device() + model_config = model_detection.model_config_from_unet(sd, "") - if checkpoint or "input_blocks.0.0.weight" in sd or 'clf.1.weight' in sd: #ldm or stable cascade - model_config = model_detection.model_config_from_unet(sd, "") - if model_config is None: - return None + if model_config is not None: new_sd = sd elif 'transformer_blocks.0.attn.add_q_proj.weight' in sd: #MMDIT SD3 new_sd = model_detection.convert_diffusers_mmdit(sd, "") From f45157e3acbef1c0edf7d31fc73ee83e7913a994 Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Thu, 11 Jul 2024 11:46:51 -0400 Subject: [PATCH 60/94] Fix error message never being shown. --- comfy/sd.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/comfy/sd.py b/comfy/sd.py index 66033b63e19e..eeffa423ab82 100644 --- a/comfy/sd.py +++ b/comfy/sd.py @@ -489,13 +489,13 @@ def load_checkpoint_guess_config(ckpt_path, output_vae=True, output_clip=True, o load_device = model_management.get_torch_device() model_config = model_detection.model_config_from_unet(sd, diffusion_model_prefix) + if model_config is None: + raise RuntimeError("ERROR: Could not detect model type of: {}".format(ckpt_path)) + unet_dtype = model_management.unet_dtype(model_params=parameters, supported_dtypes=model_config.supported_inference_dtypes) manual_cast_dtype = model_management.unet_manual_cast(unet_dtype, load_device, model_config.supported_inference_dtypes) model_config.set_inference_dtype(unet_dtype, manual_cast_dtype) - if model_config is None: - raise RuntimeError("ERROR: Could not detect model type of: {}".format(ckpt_path)) - if model_config.clip_vision_prefix is not None: if output_clipvision: clipvision = clip_vision.load_clipvision_from_sd(sd, model_config.clip_vision_prefix, True) From 9f291d75b344d7f7e83b7bd18447f430c99fcb28 Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Thu, 11 Jul 2024 16:51:06 -0400 Subject: [PATCH 61/94] AuraFlow model implementation. --- comfy/ldm/aura/mmdit.py | 479 +++++++++ comfy/model_base.py | 12 + comfy/model_detection.py | 8 + comfy/sd.py | 4 + comfy/supported_models.py | 24 +- comfy/text_encoders/aura_t5.py | 22 + comfy/text_encoders/t5_pile_config_xl.json | 22 + .../t5_pile_tokenizer/added_tokens.json | 102 ++ .../t5_pile_tokenizer/special_tokens_map.json | 125 +++ .../t5_pile_tokenizer/tokenizer.model | Bin 0 -> 499723 bytes .../t5_pile_tokenizer/tokenizer_config.json | 945 ++++++++++++++++++ requirements.txt | 3 +- 12 files changed, 1744 insertions(+), 2 deletions(-) create mode 100644 comfy/ldm/aura/mmdit.py create mode 100644 comfy/text_encoders/aura_t5.py create mode 100644 comfy/text_encoders/t5_pile_config_xl.json create mode 100644 comfy/text_encoders/t5_pile_tokenizer/added_tokens.json create mode 100644 comfy/text_encoders/t5_pile_tokenizer/special_tokens_map.json create mode 100644 comfy/text_encoders/t5_pile_tokenizer/tokenizer.model create mode 100644 comfy/text_encoders/t5_pile_tokenizer/tokenizer_config.json diff --git a/comfy/ldm/aura/mmdit.py b/comfy/ldm/aura/mmdit.py new file mode 100644 index 000000000000..c465619bd0aa --- /dev/null +++ b/comfy/ldm/aura/mmdit.py @@ -0,0 +1,479 @@ +#AuraFlow MMDiT +#Originally written by the AuraFlow Authors + +import math + +import torch +import torch.nn as nn +import torch.nn.functional as F + +from comfy.ldm.modules.attention import optimized_attention + +def modulate(x, shift, scale): + return x * (1 + scale.unsqueeze(1)) + shift.unsqueeze(1) + + +def find_multiple(n: int, k: int) -> int: + if n % k == 0: + return n + return n + k - (n % k) + + +class MLP(nn.Module): + def __init__(self, dim, hidden_dim=None, dtype=None, device=None, operations=None) -> None: + super().__init__() + if hidden_dim is None: + hidden_dim = 4 * dim + + n_hidden = int(2 * hidden_dim / 3) + n_hidden = find_multiple(n_hidden, 256) + + self.c_fc1 = operations.Linear(dim, n_hidden, bias=False, dtype=dtype, device=device) + self.c_fc2 = operations.Linear(dim, n_hidden, bias=False, dtype=dtype, device=device) + self.c_proj = operations.Linear(n_hidden, dim, bias=False, dtype=dtype, device=device) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + x = F.silu(self.c_fc1(x)) * self.c_fc2(x) + x = self.c_proj(x) + return x + + +class MultiHeadLayerNorm(nn.Module): + def __init__(self, hidden_size=None, eps=1e-5, dtype=None, device=None): + # Copy pasta from https://github.com/huggingface/transformers/blob/e5f71ecaae50ea476d1e12351003790273c4b2ed/src/transformers/models/cohere/modeling_cohere.py#L78 + + super().__init__() + self.weight = nn.Parameter(torch.empty(hidden_size, dtype=dtype, device=device)) + self.variance_epsilon = eps + + def forward(self, hidden_states): + input_dtype = hidden_states.dtype + hidden_states = hidden_states.to(torch.float32) + mean = hidden_states.mean(-1, keepdim=True) + variance = (hidden_states - mean).pow(2).mean(-1, keepdim=True) + hidden_states = (hidden_states - mean) * torch.rsqrt( + variance + self.variance_epsilon + ) + hidden_states = self.weight.to(torch.float32) * hidden_states + return hidden_states.to(input_dtype) + +class SingleAttention(nn.Module): + def __init__(self, dim, n_heads, mh_qknorm=False, dtype=None, device=None, operations=None): + super().__init__() + + self.n_heads = n_heads + self.head_dim = dim // n_heads + + # this is for cond + self.w1q = operations.Linear(dim, dim, bias=False, dtype=dtype, device=device) + self.w1k = operations.Linear(dim, dim, bias=False, dtype=dtype, device=device) + self.w1v = operations.Linear(dim, dim, bias=False, dtype=dtype, device=device) + self.w1o = operations.Linear(dim, dim, bias=False, dtype=dtype, device=device) + + self.q_norm1 = ( + MultiHeadLayerNorm((self.n_heads, self.head_dim), dtype=dtype, device=device) + if mh_qknorm + else operations.LayerNorm(self.head_dim, elementwise_affine=False, dtype=dtype, device=device) + ) + self.k_norm1 = ( + MultiHeadLayerNorm((self.n_heads, self.head_dim), dtype=dtype, device=device) + if mh_qknorm + else operations.LayerNorm(self.head_dim, elementwise_affine=False, dtype=dtype, device=device) + ) + + #@torch.compile() + def forward(self, c): + + bsz, seqlen1, _ = c.shape + + q, k, v = self.w1q(c), self.w1k(c), self.w1v(c) + q = q.view(bsz, seqlen1, self.n_heads, self.head_dim) + k = k.view(bsz, seqlen1, self.n_heads, self.head_dim) + v = v.view(bsz, seqlen1, self.n_heads, self.head_dim) + q, k = self.q_norm1(q), self.k_norm1(k) + + output = optimized_attention(q.permute(0, 2, 1, 3), k.permute(0, 2, 1, 3), v.permute(0, 2, 1, 3), self.n_heads, skip_reshape=True) + c = self.w1o(output) + return c + + + +class DoubleAttention(nn.Module): + def __init__(self, dim, n_heads, mh_qknorm=False, dtype=None, device=None, operations=None): + super().__init__() + + self.n_heads = n_heads + self.head_dim = dim // n_heads + + # this is for cond + self.w1q = operations.Linear(dim, dim, bias=False, dtype=dtype, device=device) + self.w1k = operations.Linear(dim, dim, bias=False, dtype=dtype, device=device) + self.w1v = operations.Linear(dim, dim, bias=False, dtype=dtype, device=device) + self.w1o = operations.Linear(dim, dim, bias=False, dtype=dtype, device=device) + + # this is for x + self.w2q = operations.Linear(dim, dim, bias=False, dtype=dtype, device=device) + self.w2k = operations.Linear(dim, dim, bias=False, dtype=dtype, device=device) + self.w2v = operations.Linear(dim, dim, bias=False, dtype=dtype, device=device) + self.w2o = operations.Linear(dim, dim, bias=False, dtype=dtype, device=device) + + self.q_norm1 = ( + MultiHeadLayerNorm((self.n_heads, self.head_dim), dtype=dtype, device=device) + if mh_qknorm + else operations.LayerNorm(self.head_dim, elementwise_affine=False, dtype=dtype, device=device) + ) + self.k_norm1 = ( + MultiHeadLayerNorm((self.n_heads, self.head_dim), dtype=dtype, device=device) + if mh_qknorm + else operations.LayerNorm(self.head_dim, elementwise_affine=False, dtype=dtype, device=device) + ) + + self.q_norm2 = ( + MultiHeadLayerNorm((self.n_heads, self.head_dim), dtype=dtype, device=device) + if mh_qknorm + else operations.LayerNorm(self.head_dim, elementwise_affine=False, dtype=dtype, device=device) + ) + self.k_norm2 = ( + MultiHeadLayerNorm((self.n_heads, self.head_dim), dtype=dtype, device=device) + if mh_qknorm + else operations.LayerNorm(self.head_dim, elementwise_affine=False, dtype=dtype, device=device) + ) + + + #@torch.compile() + def forward(self, c, x): + + bsz, seqlen1, _ = c.shape + bsz, seqlen2, _ = x.shape + seqlen = seqlen1 + seqlen2 + + cq, ck, cv = self.w1q(c), self.w1k(c), self.w1v(c) + cq = cq.view(bsz, seqlen1, self.n_heads, self.head_dim) + ck = ck.view(bsz, seqlen1, self.n_heads, self.head_dim) + cv = cv.view(bsz, seqlen1, self.n_heads, self.head_dim) + cq, ck = self.q_norm1(cq), self.k_norm1(ck) + + xq, xk, xv = self.w2q(x), self.w2k(x), self.w2v(x) + xq = xq.view(bsz, seqlen2, self.n_heads, self.head_dim) + xk = xk.view(bsz, seqlen2, self.n_heads, self.head_dim) + xv = xv.view(bsz, seqlen2, self.n_heads, self.head_dim) + xq, xk = self.q_norm2(xq), self.k_norm2(xk) + + # concat all + q, k, v = ( + torch.cat([cq, xq], dim=1), + torch.cat([ck, xk], dim=1), + torch.cat([cv, xv], dim=1), + ) + + output = optimized_attention(q.permute(0, 2, 1, 3), k.permute(0, 2, 1, 3), v.permute(0, 2, 1, 3), self.n_heads, skip_reshape=True) + + c, x = output.split([seqlen1, seqlen2], dim=1) + c = self.w1o(c) + x = self.w2o(x) + + return c, x + + +class MMDiTBlock(nn.Module): + def __init__(self, dim, heads=8, global_conddim=1024, is_last=False, dtype=None, device=None, operations=None): + super().__init__() + + self.normC1 = operations.LayerNorm(dim, elementwise_affine=False, dtype=dtype, device=device) + self.normC2 = operations.LayerNorm(dim, elementwise_affine=False, dtype=dtype, device=device) + if not is_last: + self.mlpC = MLP(dim, hidden_dim=dim * 4, dtype=dtype, device=device, operations=operations) + self.modC = nn.Sequential( + nn.SiLU(), + operations.Linear(global_conddim, 6 * dim, bias=False, dtype=dtype, device=device), + ) + else: + self.modC = nn.Sequential( + nn.SiLU(), + operations.Linear(global_conddim, 2 * dim, bias=False, dtype=dtype, device=device), + ) + + self.normX1 = operations.LayerNorm(dim, elementwise_affine=False, dtype=dtype, device=device) + self.normX2 = operations.LayerNorm(dim, elementwise_affine=False, dtype=dtype, device=device) + self.mlpX = MLP(dim, hidden_dim=dim * 4, dtype=dtype, device=device, operations=operations) + self.modX = nn.Sequential( + nn.SiLU(), + operations.Linear(global_conddim, 6 * dim, bias=False, dtype=dtype, device=device), + ) + + self.attn = DoubleAttention(dim, heads, dtype=dtype, device=device, operations=operations) + self.is_last = is_last + + #@torch.compile() + def forward(self, c, x, global_cond, **kwargs): + + cres, xres = c, x + + cshift_msa, cscale_msa, cgate_msa, cshift_mlp, cscale_mlp, cgate_mlp = ( + self.modC(global_cond).chunk(6, dim=1) + ) + + c = modulate(self.normC1(c), cshift_msa, cscale_msa) + + # xpath + xshift_msa, xscale_msa, xgate_msa, xshift_mlp, xscale_mlp, xgate_mlp = ( + self.modX(global_cond).chunk(6, dim=1) + ) + + x = modulate(self.normX1(x), xshift_msa, xscale_msa) + + # attention + c, x = self.attn(c, x) + + + c = self.normC2(cres + cgate_msa.unsqueeze(1) * c) + c = cgate_mlp.unsqueeze(1) * self.mlpC(modulate(c, cshift_mlp, cscale_mlp)) + c = cres + c + + x = self.normX2(xres + xgate_msa.unsqueeze(1) * x) + x = xgate_mlp.unsqueeze(1) * self.mlpX(modulate(x, xshift_mlp, xscale_mlp)) + x = xres + x + + return c, x + +class DiTBlock(nn.Module): + # like MMDiTBlock, but it only has X + def __init__(self, dim, heads=8, global_conddim=1024, dtype=None, device=None, operations=None): + super().__init__() + + self.norm1 = operations.LayerNorm(dim, elementwise_affine=False, dtype=dtype, device=device) + self.norm2 = operations.LayerNorm(dim, elementwise_affine=False, dtype=dtype, device=device) + + self.modCX = nn.Sequential( + nn.SiLU(), + operations.Linear(global_conddim, 6 * dim, bias=False, dtype=dtype, device=device), + ) + + self.attn = SingleAttention(dim, heads, dtype=dtype, device=device, operations=operations) + self.mlp = MLP(dim, hidden_dim=dim * 4, dtype=dtype, device=device, operations=operations) + + #@torch.compile() + def forward(self, cx, global_cond, **kwargs): + cxres = cx + shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = self.modCX( + global_cond + ).chunk(6, dim=1) + cx = modulate(self.norm1(cx), shift_msa, scale_msa) + cx = self.attn(cx) + cx = self.norm2(cxres + gate_msa.unsqueeze(1) * cx) + mlpout = self.mlp(modulate(cx, shift_mlp, scale_mlp)) + cx = gate_mlp.unsqueeze(1) * mlpout + + cx = cxres + cx + + return cx + + + +class TimestepEmbedder(nn.Module): + def __init__(self, hidden_size, frequency_embedding_size=256, dtype=None, device=None, operations=None): + super().__init__() + self.mlp = nn.Sequential( + operations.Linear(frequency_embedding_size, hidden_size, dtype=dtype, device=device), + nn.SiLU(), + operations.Linear(hidden_size, hidden_size, dtype=dtype, device=device), + ) + self.frequency_embedding_size = frequency_embedding_size + + @staticmethod + def timestep_embedding(t, dim, max_period=10000): + half = dim // 2 + freqs = 1000 * torch.exp( + -math.log(max_period) * torch.arange(start=0, end=half) / half + ).to(t.device) + args = t[:, None] * freqs[None] + embedding = torch.cat([torch.cos(args), torch.sin(args)], dim=-1) + if dim % 2: + embedding = torch.cat( + [embedding, torch.zeros_like(embedding[:, :1])], dim=-1 + ) + return embedding + + #@torch.compile() + def forward(self, t, dtype): + t_freq = self.timestep_embedding(t, self.frequency_embedding_size).to(dtype) + t_emb = self.mlp(t_freq) + return t_emb + + +class MMDiT(nn.Module): + def __init__( + self, + in_channels=4, + out_channels=4, + patch_size=2, + dim=3072, + n_layers=36, + n_double_layers=4, + n_heads=12, + global_conddim=3072, + cond_seq_dim=2048, + max_seq=32 * 32, + device=None, + dtype=None, + operations=None, + ): + super().__init__() + self.dtype = dtype + + self.t_embedder = TimestepEmbedder(global_conddim, dtype=dtype, device=device, operations=operations) + + self.cond_seq_linear = operations.Linear( + cond_seq_dim, dim, bias=False, dtype=dtype, device=device + ) # linear for something like text sequence. + self.init_x_linear = operations.Linear( + patch_size * patch_size * in_channels, dim, dtype=dtype, device=device + ) # init linear for patchified image. + + self.positional_encoding = nn.Parameter(torch.empty(1, max_seq, dim, dtype=dtype, device=device)) + self.register_tokens = nn.Parameter(torch.empty(1, 8, dim, dtype=dtype, device=device)) + + self.double_layers = nn.ModuleList([]) + self.single_layers = nn.ModuleList([]) + + + for idx in range(n_double_layers): + self.double_layers.append( + MMDiTBlock(dim, n_heads, global_conddim, is_last=(idx == n_layers - 1), dtype=dtype, device=device, operations=operations) + ) + + for idx in range(n_double_layers, n_layers): + self.single_layers.append( + DiTBlock(dim, n_heads, global_conddim, dtype=dtype, device=device, operations=operations) + ) + + + self.final_linear = operations.Linear( + dim, patch_size * patch_size * out_channels, bias=False, dtype=dtype, device=device + ) + + self.modF = nn.Sequential( + nn.SiLU(), + operations.Linear(global_conddim, 2 * dim, bias=False, dtype=dtype, device=device), + ) + + self.out_channels = out_channels + self.patch_size = patch_size + self.n_double_layers = n_double_layers + self.n_layers = n_layers + + self.h_max = round(max_seq**0.5) + self.w_max = round(max_seq**0.5) + + @torch.no_grad() + def extend_pe(self, init_dim=(16, 16), target_dim=(64, 64)): + # extend pe + pe_data = self.positional_encoding.data.squeeze(0)[: init_dim[0] * init_dim[1]] + + pe_as_2d = pe_data.view(init_dim[0], init_dim[1], -1).permute(2, 0, 1) + + # now we need to extend this to target_dim. for this we will use interpolation. + # we will use torch.nn.functional.interpolate + pe_as_2d = F.interpolate( + pe_as_2d.unsqueeze(0), size=target_dim, mode="bilinear" + ) + pe_new = pe_as_2d.squeeze(0).permute(1, 2, 0).flatten(0, 1) + self.positional_encoding.data = pe_new.unsqueeze(0).contiguous() + self.h_max, self.w_max = target_dim + print("PE extended to", target_dim) + + def pe_selection_index_based_on_dim(self, h, w): + h_p, w_p = h // self.patch_size, w // self.patch_size + original_pe_indexes = torch.arange(self.positional_encoding.shape[1]) + original_pe_indexes = original_pe_indexes.view(self.h_max, self.w_max) + starth = self.h_max // 2 - h_p // 2 + endh =starth + h_p + startw = self.w_max // 2 - w_p // 2 + endw = startw + w_p + original_pe_indexes = original_pe_indexes[ + starth:endh, startw:endw + ] + return original_pe_indexes.flatten() + + def unpatchify(self, x, h, w): + c = self.out_channels + p = self.patch_size + + x = x.reshape(shape=(x.shape[0], h, w, p, p, c)) + x = torch.einsum("nhwpqc->nchpwq", x) + imgs = x.reshape(shape=(x.shape[0], c, h * p, w * p)) + return imgs + + def patchify(self, x): + B, C, H, W = x.size() + pad_h = (self.patch_size - H % self.patch_size) % self.patch_size + pad_w = (self.patch_size - W % self.patch_size) % self.patch_size + + x = torch.nn.functional.pad(x, (0, pad_w, 0, pad_h), mode='reflect') + x = x.view( + B, + C, + (H + 1) // self.patch_size, + self.patch_size, + (W + 1) // self.patch_size, + self.patch_size, + ) + x = x.permute(0, 2, 4, 1, 3, 5).flatten(-3).flatten(1, 2) + return x + + def apply_pos_embeds(self, x, h, w): + h = (h + 1) // self.patch_size + w = (w + 1) // self.patch_size + max_dim = max(h, w) + + cur_dim = self.h_max + pos_encoding = self.positional_encoding.reshape(1, cur_dim, cur_dim, -1).to(device=x.device, dtype=x.dtype) + + if max_dim > cur_dim: + pos_encoding = F.interpolate(pos_encoding.movedim(-1, 1), (max_dim, max_dim), mode="bilinear").movedim(1, -1) + cur_dim = max_dim + + from_h = (cur_dim - h) // 2 + from_w = (cur_dim - w) // 2 + pos_encoding = pos_encoding[:,from_h:from_h+h,from_w:from_w+w] + return x + pos_encoding.reshape(1, -1, self.positional_encoding.shape[-1]) + + def forward(self, x, timestep, context, **kwargs): + # patchify x, add PE + b, c, h, w = x.shape + + # pe_indexes = self.pe_selection_index_based_on_dim(h, w) + # print(pe_indexes, pe_indexes.shape) + + x = self.init_x_linear(self.patchify(x)) # B, T_x, D + x = self.apply_pos_embeds(x, h, w) + # x = x + self.positional_encoding[:, : x.size(1)].to(device=x.device, dtype=x.dtype) + # x = x + self.positional_encoding[:, pe_indexes].to(device=x.device, dtype=x.dtype) + + # process conditions for MMDiT Blocks + c_seq = context # B, T_c, D_c + t = timestep + + c = self.cond_seq_linear(c_seq) # B, T_c, D + c = torch.cat([self.register_tokens.to(device=c.device, dtype=c.dtype).repeat(c.size(0), 1, 1), c], dim=1) + + global_cond = self.t_embedder(t, x.dtype) # B, D + + if len(self.double_layers) > 0: + for layer in self.double_layers: + c, x = layer(c, x, global_cond, **kwargs) + + if len(self.single_layers) > 0: + c_len = c.size(1) + cx = torch.cat([c, x], dim=1) + for layer in self.single_layers: + cx = layer(cx, global_cond, **kwargs) + + x = cx[:, c_len:] + + fshift, fscale = self.modF(global_cond).chunk(2, dim=1) + + x = modulate(x, fshift, fscale) + x = self.final_linear(x) + x = self.unpatchify(x, (h + 1) // self.patch_size, (w + 1) // self.patch_size)[:,:,:h,:w] + return x diff --git a/comfy/model_base.py b/comfy/model_base.py index 80f6667ec816..0e0e69d3ba32 100644 --- a/comfy/model_base.py +++ b/comfy/model_base.py @@ -6,6 +6,7 @@ from comfy.ldm.modules.encoders.noise_aug_modules import CLIPEmbeddingNoiseAugmentation from comfy.ldm.modules.diffusionmodules.upscaling import ImageConcatWithNoiseAugmentation from comfy.ldm.modules.diffusionmodules.mmdit import OpenAISignatureMMDITWrapper +import comfy.ldm.aura.mmdit import comfy.ldm.audio.dit import comfy.ldm.audio.embedders import comfy.model_management @@ -598,6 +599,17 @@ def memory_required(self, input_shape): area = input_shape[0] * input_shape[2] * input_shape[3] return (area * 0.3) * (1024 * 1024) +class AuraFlow(BaseModel): + def __init__(self, model_config, model_type=ModelType.FLOW, device=None): + super().__init__(model_config, model_type, device=device, unet_model=comfy.ldm.aura.mmdit.MMDiT) + + def extra_conds(self, **kwargs): + out = super().extra_conds(**kwargs) + cross_attn = kwargs.get("cross_attn", None) + if cross_attn is not None: + out['c_crossattn'] = comfy.conds.CONDRegular(cross_attn) + return out + class StableAudio1(BaseModel): def __init__(self, model_config, seconds_start_embedder_weights, seconds_total_embedder_weights, model_type=ModelType.V_PREDICTION_CONTINUOUS, device=None): diff --git a/comfy/model_detection.py b/comfy/model_detection.py index 783a03eb7fc5..dd5bff82acf1 100644 --- a/comfy/model_detection.py +++ b/comfy/model_detection.py @@ -105,6 +105,12 @@ def detect_unet_config(state_dict, key_prefix): unet_config["audio_model"] = "dit1.0" return unet_config + if '{}double_layers.0.attn.w1q.weight'.format(key_prefix) in state_dict_keys: #aura flow dit + unet_config = {} + unet_config["max_seq"] = state_dict['{}positional_encoding'.format(key_prefix)].shape[1] + unet_config["cond_seq_dim"] = state_dict['{}cond_seq_linear.weight'.format(key_prefix)].shape[1] + return unet_config + if '{}input_blocks.0.0.weight'.format(key_prefix) not in state_dict_keys: return None @@ -253,6 +259,8 @@ def model_config_from_unet(state_dict, unet_key_prefix, use_base_if_no_match=Fal def unet_prefix_from_state_dict(state_dict): if "model.model.postprocess_conv.weight" in state_dict: #audio models unet_key_prefix = "model.model." + elif "model.double_layers.0.attn.w1q.weight" in state_dict: #aura flow + unet_key_prefix = "model." else: unet_key_prefix = "model.diffusion_model." return unet_key_prefix diff --git a/comfy/sd.py b/comfy/sd.py index eeffa423ab82..6028029d67db 100644 --- a/comfy/sd.py +++ b/comfy/sd.py @@ -21,6 +21,7 @@ from . import sdxl_clip from . import sd3_clip from . import sa_t5 +import comfy.text_encoders.aura_t5 import comfy.model_patcher import comfy.lora @@ -415,6 +416,9 @@ class EmptyClass: if weight.shape[-1] == 4096: clip_target.clip = sd3_clip.sd3_clip(clip_l=False, clip_g=False, t5=True, dtype_t5=dtype_t5) clip_target.tokenizer = sd3_clip.SD3Tokenizer + elif weight.shape[-1] == 2048: + clip_target.clip = comfy.text_encoders.aura_t5.AuraT5Model + clip_target.tokenizer = comfy.text_encoders.aura_t5.AuraT5Tokenizer elif "encoder.block.0.layer.0.SelfAttention.k.weight" in clip_data[0]: clip_target.clip = sa_t5.SAT5Model clip_target.tokenizer = sa_t5.SAT5Tokenizer diff --git a/comfy/supported_models.py b/comfy/supported_models.py index 21fdb7ec758b..ccf8c333e45f 100644 --- a/comfy/supported_models.py +++ b/comfy/supported_models.py @@ -7,6 +7,7 @@ from . import sdxl_clip from . import sd3_clip from . import sa_t5 +import comfy.text_encoders.aura_t5 from . import supported_models_base from . import latent_formats @@ -556,7 +557,28 @@ def process_unet_state_dict_for_saving(self, state_dict): def clip_target(self, state_dict={}): return supported_models_base.ClipTarget(sa_t5.SAT5Tokenizer, sa_t5.SAT5Model) +class AuraFlow(supported_models_base.BASE): + unet_config = { + "cond_seq_dim": 2048, + } + + sampling_settings = { + "multiplier": 1.0, + } + + unet_extra_config = {} + latent_format = latent_formats.SDXL + + vae_key_prefix = ["vae."] + text_encoder_key_prefix = ["text_encoders."] + + def get_model(self, state_dict, prefix="", device=None): + out = model_base.AuraFlow(self, device=device) + return out + + def clip_target(self, state_dict={}): + return supported_models_base.ClipTarget(comfy.text_encoders.aura_t5.AuraT5Tokenizer, comfy.text_encoders.aura_t5.AuraT5Model) -models = [Stable_Zero123, SD15_instructpix2pix, SD15, SD20, SD21UnclipL, SD21UnclipH, SDXL_instructpix2pix, SDXLRefiner, SDXL, SSD1B, KOALA_700M, KOALA_1B, Segmind_Vega, SD_X4Upscaler, Stable_Cascade_C, Stable_Cascade_B, SV3D_u, SV3D_p, SD3, StableAudio] +models = [Stable_Zero123, SD15_instructpix2pix, SD15, SD20, SD21UnclipL, SD21UnclipH, SDXL_instructpix2pix, SDXLRefiner, SDXL, SSD1B, KOALA_700M, KOALA_1B, Segmind_Vega, SD_X4Upscaler, Stable_Cascade_C, Stable_Cascade_B, SV3D_u, SV3D_p, SD3, StableAudio, AuraFlow] models += [SVD_img2vid] diff --git a/comfy/text_encoders/aura_t5.py b/comfy/text_encoders/aura_t5.py new file mode 100644 index 000000000000..0e84189aa13b --- /dev/null +++ b/comfy/text_encoders/aura_t5.py @@ -0,0 +1,22 @@ +from comfy import sd1_clip +from transformers import LlamaTokenizerFast +import comfy.t5 +import os + +class PT5XlModel(sd1_clip.SDClipModel): + def __init__(self, device="cpu", layer="last", layer_idx=None, dtype=None): + textmodel_json_config = os.path.join(os.path.dirname(os.path.realpath(__file__)), "t5_pile_config_xl.json") + super().__init__(device=device, layer=layer, layer_idx=layer_idx, textmodel_json_config=textmodel_json_config, dtype=dtype, special_tokens={"end": 2, "pad": 1}, model_class=comfy.t5.T5, enable_attention_masks=True, zero_out_masked=True) + +class PT5XlTokenizer(sd1_clip.SDTokenizer): + def __init__(self, embedding_directory=None): + tokenizer_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), "t5_pile_tokenizer") + super().__init__(tokenizer_path, pad_with_end=False, embedding_size=2048, embedding_key='pile_t5xl', tokenizer_class=LlamaTokenizerFast, has_start_token=False, pad_to_max_length=False, max_length=99999999, min_length=256, pad_token=1) + +class AuraT5Tokenizer(sd1_clip.SD1Tokenizer): + def __init__(self, embedding_directory=None): + super().__init__(embedding_directory=embedding_directory, clip_name="pile_t5xl", tokenizer=PT5XlTokenizer) + +class AuraT5Model(sd1_clip.SD1ClipModel): + def __init__(self, device="cpu", dtype=None, **kwargs): + super().__init__(device=device, dtype=dtype, name="pile_t5xl", clip_model=PT5XlModel, **kwargs) diff --git a/comfy/text_encoders/t5_pile_config_xl.json b/comfy/text_encoders/t5_pile_config_xl.json new file mode 100644 index 000000000000..ee4e03f97a5b --- /dev/null +++ b/comfy/text_encoders/t5_pile_config_xl.json @@ -0,0 +1,22 @@ +{ + "d_ff": 5120, + "d_kv": 64, + "d_model": 2048, + "decoder_start_token_id": 0, + "dropout_rate": 0.1, + "eos_token_id": 2, + "dense_act_fn": "gelu_pytorch_tanh", + "initializer_factor": 1.0, + "is_encoder_decoder": true, + "is_gated_act": true, + "layer_norm_epsilon": 1e-06, + "model_type": "umt5", + "num_decoder_layers": 24, + "num_heads": 32, + "num_layers": 24, + "output_past": true, + "pad_token_id": 1, + "relative_attention_num_buckets": 32, + "tie_word_embeddings": false, + "vocab_size": 32128 +} diff --git a/comfy/text_encoders/t5_pile_tokenizer/added_tokens.json b/comfy/text_encoders/t5_pile_tokenizer/added_tokens.json new file mode 100644 index 000000000000..3f5132007c4f --- /dev/null +++ b/comfy/text_encoders/t5_pile_tokenizer/added_tokens.json @@ -0,0 +1,102 @@ +{ + "": 32099, + "": 32089, + "": 32088, + "": 32087, + "": 32086, + "": 32085, + "": 32084, + "": 32083, + "": 32082, + "": 32081, + "": 32080, + "": 32098, + "": 32079, + "": 32078, + "": 32077, + "": 32076, + "": 32075, + "": 32074, + "": 32073, + "": 32072, + "": 32071, + "": 32070, + "": 32097, + "": 32069, + "": 32068, + "": 32067, + "": 32066, + "": 32065, + "": 32064, + "": 32063, + "": 32062, + "": 32061, + "": 32060, + "": 32096, + "": 32059, + "": 32058, + "": 32057, + "": 32056, + "": 32055, + "": 32054, + "": 32053, + "": 32052, + "": 32051, + "": 32050, + "": 32095, + "": 32049, + "": 32048, + "": 32047, + "": 32046, + "": 32045, + "": 32044, + "": 32043, + "": 32042, + "": 32041, + "": 32040, + "": 32094, + "": 32039, + "": 32038, + "": 32037, + "": 32036, + "": 32035, + "": 32034, + "": 32033, + "": 32032, + "": 32031, + "": 32030, + "": 32093, + "": 32029, + "": 32028, + "": 32027, + "": 32026, + "": 32025, + "": 32024, + "": 32023, + "": 32022, + "": 32021, + "": 32020, + "": 32092, + "": 32019, + "": 32018, + "": 32017, + "": 32016, + "": 32015, + "": 32014, + "": 32013, + "": 32012, + "": 32011, + "": 32010, + "": 32091, + "": 32009, + "": 32008, + "": 32007, + "": 32006, + "": 32005, + "": 32004, + "": 32003, + "": 32002, + "": 32001, + "": 32000, + "": 32090 +} diff --git a/comfy/text_encoders/t5_pile_tokenizer/special_tokens_map.json b/comfy/text_encoders/t5_pile_tokenizer/special_tokens_map.json new file mode 100644 index 000000000000..19fb1d5f4f71 --- /dev/null +++ b/comfy/text_encoders/t5_pile_tokenizer/special_tokens_map.json @@ -0,0 +1,125 @@ +{ + "additional_special_tokens": [ + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + ], + "bos_token": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false + }, + "eos_token": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false + }, + "unk_token": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false + } +} diff --git a/comfy/text_encoders/t5_pile_tokenizer/tokenizer.model b/comfy/text_encoders/t5_pile_tokenizer/tokenizer.model new file mode 100644 index 0000000000000000000000000000000000000000..22bccbcb41ec929cf0c9dbe8f41036db82e5e773 GIT binary patch literal 499723 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
6chr$CNJq|oX{wwE3<`zH)AeR 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�@n8 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%0D!p`_bR0&8x9U*M!WQD@nH={ho@j0@kblDh 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", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "1": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "2": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32000": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32001": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32002": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32003": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32004": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32005": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32006": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32007": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32008": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32009": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32010": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32011": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32012": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32013": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32014": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32015": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32016": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32017": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32018": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32019": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32020": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32021": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32022": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32023": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32024": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32025": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32026": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32027": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32028": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32029": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32030": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32031": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32032": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32033": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32034": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32035": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32036": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32037": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32038": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32039": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32040": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32041": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32042": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32043": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32044": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32045": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32046": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32047": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32048": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32049": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32050": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32051": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32052": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32053": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32054": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32055": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32056": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32057": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32058": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32059": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32060": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32061": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32062": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32063": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32064": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32065": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32066": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32067": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32068": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32069": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32070": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32071": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32072": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32073": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32074": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32075": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32076": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32077": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32078": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32079": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32080": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32081": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32082": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32083": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32084": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32085": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32086": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32087": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32088": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32089": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32090": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32091": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32092": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32093": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32094": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32095": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32096": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32097": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32098": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "32099": { + "content": "", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + } + }, + "additional_special_tokens": [ + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + ], + "bos_token": "", + "clean_up_tokenization_spaces": false, + "eos_token": "", + "legacy": false, + "model_max_length": 512, + "pad_token": null, + "padding_side": "right", + "sp_model_kwargs": {}, + "spaces_between_special_tokens": false, + "tokenizer_class": "LlamaTokenizer", + "unk_token": "", + "use_default_system_prompt": false +} diff --git a/requirements.txt b/requirements.txt index 108958d2f435..6febc3d68910 100644 --- a/requirements.txt +++ b/requirements.txt @@ -3,7 +3,8 @@ torchsde torchvision torchaudio einops -transformers>=4.25.1 +transformers>=4.28.1 +tokenizers>=0.13.3 safetensors>=0.4.2 aiohttp pyyaml From 8e012043a9d0af3979bbe2cea8dc1ec7768f9d88 Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Thu, 11 Jul 2024 17:51:56 -0400 Subject: [PATCH 62/94] Add a ModelSamplingAuraFlow node to change the shift value. Set the default AuraFlow shift value to 1.73 (sqrt(3)). --- comfy/supported_models.py | 1 + comfy_extras/nodes_model_advanced.py | 17 +++++++++++++++-- 2 files changed, 16 insertions(+), 2 deletions(-) diff --git a/comfy/supported_models.py b/comfy/supported_models.py index ccf8c333e45f..a030f6229f38 100644 --- a/comfy/supported_models.py +++ b/comfy/supported_models.py @@ -564,6 +564,7 @@ class AuraFlow(supported_models_base.BASE): sampling_settings = { "multiplier": 1.0, + "shift": 1.73, } unet_extra_config = {} diff --git a/comfy_extras/nodes_model_advanced.py b/comfy_extras/nodes_model_advanced.py index 97559cf56e35..22ba9547b897 100644 --- a/comfy_extras/nodes_model_advanced.py +++ b/comfy_extras/nodes_model_advanced.py @@ -144,7 +144,7 @@ def INPUT_TYPES(s): CATEGORY = "advanced/model" - def patch(self, model, shift): + def patch(self, model, shift, multiplier=1000): m = model.clone() sampling_base = comfy.model_sampling.ModelSamplingDiscreteFlow @@ -154,10 +154,22 @@ class ModelSamplingAdvanced(sampling_base, sampling_type): pass model_sampling = ModelSamplingAdvanced(model.model.model_config) - model_sampling.set_parameters(shift=shift) + model_sampling.set_parameters(shift=shift, multiplier=multiplier) m.add_object_patch("model_sampling", model_sampling) return (m, ) +class ModelSamplingAuraFlow(ModelSamplingSD3): + @classmethod + def INPUT_TYPES(s): + return {"required": { "model": ("MODEL",), + "shift": ("FLOAT", {"default": 1.73, "min": 0.0, "max": 100.0, "step":0.01}), + }} + + FUNCTION = "patch_aura" + + def patch_aura(self, model, shift): + return self.patch(model, shift, multiplier=1.0) + class ModelSamplingContinuousEDM: @classmethod def INPUT_TYPES(s): @@ -271,5 +283,6 @@ def rescale_cfg(args): "ModelSamplingContinuousV": ModelSamplingContinuousV, "ModelSamplingStableCascade": ModelSamplingStableCascade, "ModelSamplingSD3": ModelSamplingSD3, + "ModelSamplingAuraFlow": ModelSamplingAuraFlow, "RescaleCFG": RescaleCFG, } From b6f09cf649a8e06783f148a0f5824405ed460003 Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Thu, 11 Jul 2024 22:58:03 -0400 Subject: [PATCH 63/94] Add sentencepiece dependency. --- requirements.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/requirements.txt b/requirements.txt index 6febc3d68910..4c2c0b2b2215 100644 --- a/requirements.txt +++ b/requirements.txt @@ -5,6 +5,7 @@ torchaudio einops transformers>=4.28.1 tokenizers>=0.13.3 +sentencepiece safetensors>=0.4.2 aiohttp pyyaml From 29c2e26724d4982a3e33114eb9064f1a11f4f4ed Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Fri, 12 Jul 2024 01:08:45 -0400 Subject: [PATCH 64/94] Better tokenizing code for AuraFlow. --- comfy/text_encoders/aura_t5.py | 6 +- comfy/text_encoders/llama_tokenizer.py | 22 + .../t5_pile_tokenizer/added_tokens.json | 102 -- .../t5_pile_tokenizer/special_tokens_map.json | 125 --- .../t5_pile_tokenizer/tokenizer_config.json | 945 ------------------ 5 files changed, 25 insertions(+), 1175 deletions(-) create mode 100644 comfy/text_encoders/llama_tokenizer.py delete mode 100644 comfy/text_encoders/t5_pile_tokenizer/added_tokens.json delete mode 100644 comfy/text_encoders/t5_pile_tokenizer/special_tokens_map.json delete mode 100644 comfy/text_encoders/t5_pile_tokenizer/tokenizer_config.json diff --git a/comfy/text_encoders/aura_t5.py b/comfy/text_encoders/aura_t5.py index 0e84189aa13b..95f942ef5784 100644 --- a/comfy/text_encoders/aura_t5.py +++ b/comfy/text_encoders/aura_t5.py @@ -1,5 +1,5 @@ from comfy import sd1_clip -from transformers import LlamaTokenizerFast +from .llama_tokenizer import LLAMATokenizer import comfy.t5 import os @@ -10,8 +10,8 @@ def __init__(self, device="cpu", layer="last", layer_idx=None, dtype=None): class PT5XlTokenizer(sd1_clip.SDTokenizer): def __init__(self, embedding_directory=None): - tokenizer_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), "t5_pile_tokenizer") - super().__init__(tokenizer_path, pad_with_end=False, embedding_size=2048, embedding_key='pile_t5xl', tokenizer_class=LlamaTokenizerFast, has_start_token=False, pad_to_max_length=False, max_length=99999999, min_length=256, pad_token=1) + tokenizer_path = os.path.join(os.path.join(os.path.dirname(os.path.realpath(__file__)), "t5_pile_tokenizer"), "tokenizer.model") + super().__init__(tokenizer_path, pad_with_end=False, embedding_size=2048, embedding_key='pile_t5xl', tokenizer_class=LLAMATokenizer, has_start_token=False, pad_to_max_length=False, max_length=99999999, min_length=256, pad_token=1) class AuraT5Tokenizer(sd1_clip.SD1Tokenizer): def __init__(self, embedding_directory=None): diff --git a/comfy/text_encoders/llama_tokenizer.py b/comfy/text_encoders/llama_tokenizer.py new file mode 100644 index 000000000000..a6db1da629cf --- /dev/null +++ b/comfy/text_encoders/llama_tokenizer.py @@ -0,0 +1,22 @@ +import os + +class LLAMATokenizer: + @staticmethod + def from_pretrained(path): + return LLAMATokenizer(path) + + def __init__(self, tokenizer_path): + import sentencepiece + self.tokenizer = sentencepiece.SentencePieceProcessor(model_file=tokenizer_path) + self.end = self.tokenizer.eos_id() + + def get_vocab(self): + out = {} + for i in range(self.tokenizer.get_piece_size()): + out[self.tokenizer.id_to_piece(i)] = i + return out + + def __call__(self, string): + out = self.tokenizer.encode(string) + out += [self.end] + return {"input_ids": out} diff --git a/comfy/text_encoders/t5_pile_tokenizer/added_tokens.json b/comfy/text_encoders/t5_pile_tokenizer/added_tokens.json deleted file mode 100644 index 3f5132007c4f..000000000000 --- a/comfy/text_encoders/t5_pile_tokenizer/added_tokens.json +++ /dev/null @@ -1,102 +0,0 @@ -{ - "": 32099, - "": 32089, - "": 32088, - "": 32087, - "": 32086, - "": 32085, - "": 32084, - "": 32083, - "": 32082, - "": 32081, - "": 32080, - "": 32098, - "": 32079, - "": 32078, - "": 32077, - "": 32076, - "": 32075, - "": 32074, - "": 32073, - "": 32072, - "": 32071, - "": 32070, - "": 32097, - "": 32069, - "": 32068, - "": 32067, - "": 32066, - "": 32065, - "": 32064, - "": 32063, - "": 32062, - "": 32061, - "": 32060, - "": 32096, - "": 32059, - "": 32058, - "": 32057, - "": 32056, - "": 32055, - "": 32054, - "": 32053, - "": 32052, - "": 32051, - "": 32050, - "": 32095, - "": 32049, - "": 32048, - "": 32047, - "": 32046, - "": 32045, - "": 32044, - "": 32043, - "": 32042, - "": 32041, - "": 32040, - "": 32094, - "": 32039, - "": 32038, - "": 32037, - "": 32036, - "": 32035, - "": 32034, - "": 32033, - "": 32032, - "": 32031, - "": 32030, - "": 32093, - "": 32029, - "": 32028, - "": 32027, - "": 32026, - "": 32025, - "": 32024, - "": 32023, - "": 32022, - "": 32021, - "": 32020, - "": 32092, - "": 32019, - "": 32018, - "": 32017, - "": 32016, - "": 32015, - "": 32014, - "": 32013, - "": 32012, - "": 32011, - "": 32010, - "": 32091, - "": 32009, - "": 32008, - "": 32007, - "": 32006, - "": 32005, - "": 32004, - "": 32003, - "": 32002, - "": 32001, - "": 32000, - "": 32090 -} diff --git a/comfy/text_encoders/t5_pile_tokenizer/special_tokens_map.json b/comfy/text_encoders/t5_pile_tokenizer/special_tokens_map.json deleted file mode 100644 index 19fb1d5f4f71..000000000000 --- a/comfy/text_encoders/t5_pile_tokenizer/special_tokens_map.json +++ /dev/null @@ -1,125 +0,0 @@ -{ - "additional_special_tokens": [ - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "" - ], - "bos_token": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false - }, - "eos_token": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false - }, - "unk_token": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false - } -} diff --git a/comfy/text_encoders/t5_pile_tokenizer/tokenizer_config.json b/comfy/text_encoders/t5_pile_tokenizer/tokenizer_config.json deleted file mode 100644 index 81f8e11e9cd7..000000000000 --- a/comfy/text_encoders/t5_pile_tokenizer/tokenizer_config.json +++ /dev/null @@ -1,945 +0,0 @@ -{ - "add_bos_token": false, - "add_eos_token": true, - "add_prefix_space": true, - "added_tokens_decoder": { - "0": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "1": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "2": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32000": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32001": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32002": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32003": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32004": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32005": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32006": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32007": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32008": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32009": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32010": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32011": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32012": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32013": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32014": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32015": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32016": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32017": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32018": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32019": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32020": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32021": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32022": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32023": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32024": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32025": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32026": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32027": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32028": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32029": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32030": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32031": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32032": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32033": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32034": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32035": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32036": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32037": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32038": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32039": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32040": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32041": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32042": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32043": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32044": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32045": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32046": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32047": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32048": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32049": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32050": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32051": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32052": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32053": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32054": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32055": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32056": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32057": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32058": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32059": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32060": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32061": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32062": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32063": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32064": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32065": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32066": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32067": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32068": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32069": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32070": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32071": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32072": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32073": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32074": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32075": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32076": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32077": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32078": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32079": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32080": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32081": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32082": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32083": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32084": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32085": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32086": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32087": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32088": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32089": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32090": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32091": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32092": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32093": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32094": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32095": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32096": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32097": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32098": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - }, - "32099": { - "content": "", - "lstrip": false, - "normalized": false, - "rstrip": false, - "single_word": false, - "special": true - } - }, - "additional_special_tokens": [ - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "" - ], - "bos_token": "", - "clean_up_tokenization_spaces": false, - "eos_token": "", - "legacy": false, - "model_max_length": 512, - "pad_token": null, - "padding_side": "right", - "sp_model_kwargs": {}, - "spaces_between_special_tokens": false, - "tokenizer_class": "LlamaTokenizer", - "unk_token": "", - "use_default_system_prompt": false -} From 4ca9b9cc29fefaa899cba67d61a8252ae9f16c0d Mon Sep 17 00:00:00 2001 From: Robin Huang Date: Fri, 12 Jul 2024 10:33:57 -0700 Subject: [PATCH 65/94] Add Github Workflow for releasing stable versions and standalone bundle. (#3949) * Add stable release. * Only build CUDA 12.1 + 3.11 Python. * Upgrade checkout and setup-python to latest version. * lzma2 * Update artifact name to be ComfyUI_windows_portable_nvidia.7z --- .github/workflows/stable-release.yml | 109 +++++++++++++++++++++++++++ 1 file changed, 109 insertions(+) create mode 100644 .github/workflows/stable-release.yml diff --git a/.github/workflows/stable-release.yml b/.github/workflows/stable-release.yml new file mode 100644 index 000000000000..1fd76b53038b --- /dev/null +++ b/.github/workflows/stable-release.yml @@ -0,0 +1,109 @@ + +name: "Release Stable Version" + +on: + push: + tags: + - 'v*' + +jobs: + package_comfy_windows: + permissions: + contents: "write" + packages: "write" + pull-requests: "read" + runs-on: windows-latest + strategy: + matrix: + python_version: [3.11.8] + cuda_version: [121] + steps: + - name: Calculate Minor Version + shell: bash + run: | + # Extract the minor version from the Python version + MINOR_VERSION=$(echo "${{ matrix.python_version }}" | cut -d'.' -f2) + echo "MINOR_VERSION=$MINOR_VERSION" >> $GITHUB_ENV + - name: Setup Python + uses: actions/setup-python@v5 + with: + python-version: ${{ matrix.python_version }} + + - uses: actions/checkout@v4 + with: + fetch-depth: 0 + persist-credentials: false + - shell: bash + run: | + echo "@echo off + call update_comfyui.bat nopause + echo - + echo This will try to update pytorch and all python dependencies. + echo - + echo If you just want to update normally, close this and run update_comfyui.bat instead. + echo - + pause + ..\python_embeded\python.exe -s -m pip install --upgrade torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu${{ matrix.cuda_version }} -r ../ComfyUI/requirements.txt pygit2 + pause" > update_comfyui_and_python_dependencies.bat + + python -m pip wheel --no-cache-dir torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu${{ matrix.cuda_version }} -r requirements.txt pygit2 -w ./temp_wheel_dir + python -m pip install --no-cache-dir ./temp_wheel_dir/* + echo installed basic + ls -lah temp_wheel_dir + mv temp_wheel_dir cu${{ matrix.cuda_version }}_python_deps + mv cu${{ matrix.cuda_version }}_python_deps ../ + mv update_comfyui_and_python_dependencies.bat ../ + cd .. + pwd + ls + + cp -r ComfyUI ComfyUI_copy + curl https://www.python.org/ftp/python/${{ matrix.python_version }}/python-${{ matrix.python_version }}-embed-amd64.zip -o python_embeded.zip + unzip python_embeded.zip -d python_embeded + cd python_embeded + echo ${{ env.MINOR_VERSION }} + echo 'import site' >> ./python3${{ env.MINOR_VERSION }}._pth + curl https://bootstrap.pypa.io/get-pip.py -o get-pip.py + ./python.exe get-pip.py + ./python.exe --version + echo "Pip version:" + ./python.exe -m pip --version + + set PATH=$PWD/Scripts:$PATH + echo $PATH + ./python.exe -s -m pip install ../cu${{ matrix.cuda_version }}_python_deps/* + sed -i '1i../ComfyUI' ./python3${{ env.MINOR_VERSION }}._pth + cd .. + + git clone https://github.com/comfyanonymous/taesd + cp taesd/*.pth ./ComfyUI_copy/models/vae_approx/ + + mkdir ComfyUI_windows_portable + mv python_embeded ComfyUI_windows_portable + mv ComfyUI_copy ComfyUI_windows_portable/ComfyUI + + cd ComfyUI_windows_portable + + mkdir update + cp -r ComfyUI/.ci/update_windows/* ./update/ + cp -r ComfyUI/.ci/windows_base_files/* ./ + cp ../update_comfyui_and_python_dependencies.bat ./update/ + + cd .. + + "C:\Program Files\7-Zip\7z.exe" a -t7z -m0=lzma2 -mx=8 -mfb=64 -md=32m -ms=on -mf=BCJ2 ComfyUI_windows_portable.7z ComfyUI_windows_portable + mv ComfyUI_windows_portable.7z ComfyUI/ComfyUI_windows_portable_nvidia.7z + + cd ComfyUI_windows_portable + python_embeded/python.exe -s ComfyUI/main.py --quick-test-for-ci --cpu + + ls + + - name: Upload binaries to release + uses: svenstaro/upload-release-action@v2 + with: + repo_token: ${{ secrets.GITHUB_TOKEN }} + file: ComfyUI_windows_portable_nvidia.7z + tag: ${{ github.ref }} + overwrite: true + From ce2473bb016748a4d98e9bce02d675b4fc22f4ac Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Fri, 12 Jul 2024 15:25:07 -0400 Subject: [PATCH 66/94] Add link to AuraFlow example in Readme. --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 35e3238a1da2..5f747321fa02 100644 --- a/README.md +++ b/README.md @@ -32,6 +32,7 @@ This ui will let you design and execute advanced stable diffusion pipelines usin - [Model Merging](https://comfyanonymous.github.io/ComfyUI_examples/model_merging/) - [LCM models and Loras](https://comfyanonymous.github.io/ComfyUI_examples/lcm/) - [SDXL Turbo](https://comfyanonymous.github.io/ComfyUI_examples/sdturbo/) +- [AuraFlow](https://comfyanonymous.github.io/ComfyUI_examples/aura_flow/) - Latent previews with [TAESD](#how-to-show-high-quality-previews) - Starts up very fast. - Works fully offline: will never download anything. From a3dffc447a7b9f4948037a988fd143eeffd87bd1 Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Sat, 13 Jul 2024 13:51:40 -0400 Subject: [PATCH 67/94] Support AuraFlow Lora and loading model weights in diffusers format. You can load model weights in diffusers format using the UNETLoader node. --- comfy/lora.py | 8 +++++ comfy/model_detection.py | 70 +++++++++++++++++++++++----------------- comfy/sd.py | 37 +++++++++++---------- comfy/utils.py | 70 ++++++++++++++++++++++++++++++++++++++++ 4 files changed, 137 insertions(+), 48 deletions(-) diff --git a/comfy/lora.py b/comfy/lora.py index 0374317756b4..e36b354f04fd 100644 --- a/comfy/lora.py +++ b/comfy/lora.py @@ -274,4 +274,12 @@ def model_lora_keys_unet(model, key_map={}): key_lora = "lora_transformer_{}".format(k[:-len(".weight")].replace(".", "_")) #OneTrainer lora key_map[key_lora] = to + if isinstance(model, comfy.model_base.AuraFlow): #Diffusers lora AuraFlow + diffusers_keys = comfy.utils.auraflow_to_diffusers(model.model_config.unet_config, output_prefix="diffusion_model.") + for k in diffusers_keys: + if k.endswith(".weight"): + to = diffusers_keys[k] + key_lora = "transformer.{}".format(k[:-len(".weight")]) #simpletrainer and probably regular diffusers lora format + key_map[key_lora] = to + return key_map diff --git a/comfy/model_detection.py b/comfy/model_detection.py index dd5bff82acf1..c62e2b822d5c 100644 --- a/comfy/model_detection.py +++ b/comfy/model_detection.py @@ -109,6 +109,10 @@ def detect_unet_config(state_dict, key_prefix): unet_config = {} unet_config["max_seq"] = state_dict['{}positional_encoding'.format(key_prefix)].shape[1] unet_config["cond_seq_dim"] = state_dict['{}cond_seq_linear.weight'.format(key_prefix)].shape[1] + double_layers = count_blocks(state_dict_keys, '{}double_layers.'.format(key_prefix) + '{}.') + single_layers = count_blocks(state_dict_keys, '{}single_layers.'.format(key_prefix) + '{}.') + unet_config["n_double_layers"] = double_layers + unet_config["n_layers"] = double_layers + single_layers return unet_config if '{}input_blocks.0.0.weight'.format(key_prefix) not in state_dict_keys: @@ -450,37 +454,45 @@ def model_config_from_diffusers_unet(state_dict): return None def convert_diffusers_mmdit(state_dict, output_prefix=""): - num_blocks = count_blocks(state_dict, 'transformer_blocks.{}.') - if num_blocks > 0: + out_sd = {} + + if 'transformer_blocks.0.attn.add_q_proj.weight' in state_dict: #SD3 + num_blocks = count_blocks(state_dict, 'transformer_blocks.{}.') depth = state_dict["pos_embed.proj.weight"].shape[0] // 64 - out_sd = {} sd_map = comfy.utils.mmdit_to_diffusers({"depth": depth, "num_blocks": num_blocks}, output_prefix=output_prefix) - for k in sd_map: - weight = state_dict.get(k, None) - if weight is not None: - t = sd_map[k] - - if not isinstance(t, str): - if len(t) > 2: - fun = t[2] - else: - fun = lambda a: a - offset = t[1] - if offset is not None: - old_weight = out_sd.get(t[0], None) - if old_weight is None: - old_weight = torch.empty_like(weight) - old_weight = old_weight.repeat([3] + [1] * (len(old_weight.shape) - 1)) - - w = old_weight.narrow(offset[0], offset[1], offset[2]) - else: - old_weight = weight - w = weight - w[:] = fun(weight) - t = t[0] - out_sd[t] = old_weight + elif 'joint_transformer_blocks.0.attn.add_k_proj.weight' in state_dict: #AuraFlow + num_joint = count_blocks(state_dict, 'joint_transformer_blocks.{}.') + num_single = count_blocks(state_dict, 'single_transformer_blocks.{}.') + sd_map = comfy.utils.auraflow_to_diffusers({"n_double_layers": num_joint, "n_layers": num_joint + num_single}, output_prefix=output_prefix) + else: + return None + + for k in sd_map: + weight = state_dict.get(k, None) + if weight is not None: + t = sd_map[k] + + if not isinstance(t, str): + if len(t) > 2: + fun = t[2] + else: + fun = lambda a: a + offset = t[1] + if offset is not None: + old_weight = out_sd.get(t[0], None) + if old_weight is None: + old_weight = torch.empty_like(weight) + old_weight = old_weight.repeat([3] + [1] * (len(old_weight.shape) - 1)) + + w = old_weight.narrow(offset[0], offset[1], offset[2]) else: - out_sd[t] = weight - state_dict.pop(k) + old_weight = weight + w = weight + w[:] = fun(weight) + t = t[0] + out_sd[t] = old_weight + else: + out_sd[t] = weight + state_dict.pop(k) return out_sd diff --git a/comfy/sd.py b/comfy/sd.py index 6028029d67db..b5bbcef61bf9 100644 --- a/comfy/sd.py +++ b/comfy/sd.py @@ -562,26 +562,25 @@ def load_unet_state_dict(sd): #load unet in diffusers or regular format if model_config is not None: new_sd = sd - elif 'transformer_blocks.0.attn.add_q_proj.weight' in sd: #MMDIT SD3 + else: new_sd = model_detection.convert_diffusers_mmdit(sd, "") - if new_sd is None: - return None - model_config = model_detection.model_config_from_unet(new_sd, "") - if model_config is None: - return None - else: #diffusers - model_config = model_detection.model_config_from_diffusers_unet(sd) - if model_config is None: - return None - - diffusers_keys = comfy.utils.unet_to_diffusers(model_config.unet_config) - - new_sd = {} - for k in diffusers_keys: - if k in sd: - new_sd[diffusers_keys[k]] = sd.pop(k) - else: - logging.warning("{} {}".format(diffusers_keys[k], k)) + if new_sd is not None: #diffusers mmdit + model_config = model_detection.model_config_from_unet(new_sd, "") + if model_config is None: + return None + else: #diffusers unet + model_config = model_detection.model_config_from_diffusers_unet(sd) + if model_config is None: + return None + + diffusers_keys = comfy.utils.unet_to_diffusers(model_config.unet_config) + + new_sd = {} + for k in diffusers_keys: + if k in sd: + new_sd[diffusers_keys[k]] = sd.pop(k) + else: + logging.warning("{} {}".format(diffusers_keys[k], k)) offload_device = model_management.unet_offload_device() unet_dtype = model_management.unet_dtype(model_params=parameters, supported_dtypes=model_config.supported_inference_dtypes) diff --git a/comfy/utils.py b/comfy/utils.py index 48618e076169..1e4b5ef882d2 100644 --- a/comfy/utils.py +++ b/comfy/utils.py @@ -332,6 +332,76 @@ def mmdit_to_diffusers(mmdit_config, output_prefix=""): return key_map + +def auraflow_to_diffusers(mmdit_config, output_prefix=""): + n_double_layers = mmdit_config.get("n_double_layers", 0) + n_layers = mmdit_config.get("n_layers", 0) + + key_map = {} + for i in range(n_layers): + if i < n_double_layers: + index = i + prefix_from = "joint_transformer_blocks" + prefix_to = "{}double_layers".format(output_prefix) + block_map = { + "attn.to_q.weight": "attn.w2q.weight", + "attn.to_k.weight": "attn.w2k.weight", + "attn.to_v.weight": "attn.w2v.weight", + "attn.to_out.0.weight": "attn.w2o.weight", + "attn.add_q_proj.weight": "attn.w1q.weight", + "attn.add_k_proj.weight": "attn.w1k.weight", + "attn.add_v_proj.weight": "attn.w1v.weight", + "attn.to_add_out.weight": "attn.w1o.weight", + "ff.linear_1.weight": "mlpX.c_fc1.weight", + "ff.linear_2.weight": "mlpX.c_fc2.weight", + "ff.out_projection.weight": "mlpX.c_proj.weight", + "ff_context.linear_1.weight": "mlpC.c_fc1.weight", + "ff_context.linear_2.weight": "mlpC.c_fc2.weight", + "ff_context.out_projection.weight": "mlpC.c_proj.weight", + "norm1.linear.weight": "modX.1.weight", + "norm1_context.linear.weight": "modC.1.weight", + } + else: + index = i - n_double_layers + prefix_from = "single_transformer_blocks" + prefix_to = "{}single_layers".format(output_prefix) + + block_map = { + "attn.to_q.weight": "attn.w1q.weight", + "attn.to_k.weight": "attn.w1k.weight", + "attn.to_v.weight": "attn.w1v.weight", + "attn.to_out.0.weight": "attn.w1o.weight", + "norm1.linear.weight": "modCX.1.weight", + "ff.linear_1.weight": "mlp.c_fc1.weight", + "ff.linear_2.weight": "mlp.c_fc2.weight", + "ff.out_projection.weight": "mlp.c_proj.weight" + } + + for k in block_map: + key_map["{}.{}.{}".format(prefix_from, index, k)] = "{}.{}.{}".format(prefix_to, index, block_map[k]) + + MAP_BASIC = { + ("positional_encoding", "pos_embed.pos_embed"), + ("register_tokens", "register_tokens"), + ("t_embedder.mlp.0.weight", "time_step_proj.linear_1.weight"), + ("t_embedder.mlp.0.bias", "time_step_proj.linear_1.bias"), + ("t_embedder.mlp.2.weight", "time_step_proj.linear_2.weight"), + ("t_embedder.mlp.2.bias", "time_step_proj.linear_2.bias"), + ("cond_seq_linear.weight", "context_embedder.weight"), + ("init_x_linear.weight", "pos_embed.proj.weight"), + ("init_x_linear.bias", "pos_embed.proj.bias"), + ("final_linear.weight", "proj_out.weight"), + ("modF.1.weight", "norm_out.linear.weight", swap_scale_shift), + } + + for k in MAP_BASIC: + if len(k) > 2: + key_map[k[1]] = ("{}{}".format(output_prefix, k[0]), None, k[2]) + else: + key_map[k[1]] = "{}{}".format(output_prefix, k[0]) + + return key_map + def repeat_to_batch_size(tensor, batch_size, dim=0): if tensor.shape[dim] > batch_size: return tensor.narrow(dim, 0, batch_size) From 79547efb65ebb41a964ce7686170c4e6c3641eb2 Mon Sep 17 00:00:00 2001 From: pythongosssss <125205205+pythongosssss@users.noreply.github.com> Date: Sun, 14 Jul 2024 07:04:40 +0100 Subject: [PATCH 68/94] New menu fixes - fix send to workflow (#3909) * Fix send to workflow Fix center align of close workflow dialog Better support for elements around canvas * More resilent to extra elements added to body --- web/scripts/ui/menu/workflows.js | 8 +++++++- web/style.css | 25 +++++++++++++++++-------- 2 files changed, 24 insertions(+), 9 deletions(-) diff --git a/web/scripts/ui/menu/workflows.js b/web/scripts/ui/menu/workflows.js index afdff538a221..3b904fb4bbf8 100644 --- a/web/scripts/ui/menu/workflows.js +++ b/web/scripts/ui/menu/workflows.js @@ -182,6 +182,11 @@ export class ComfyWorkflowsMenu { * @param {ComfyWorkflow} workflow */ async function sendToWorkflow(img, workflow) { + const openWorkflow = app.workflowManager.openWorkflows.find((w) => w.path === workflow.path); + if (openWorkflow) { + workflow = openWorkflow; + } + await workflow.load(); let options = []; const nodes = app.graph.computeExecutionOrder(false); @@ -214,7 +219,8 @@ export class ComfyWorkflowsMenu { nodeType.prototype["getExtraMenuOptions"] = function (_, options) { const r = getExtraMenuOptions?.apply?.(this, arguments); - if (app.ui.settings.getSettingValue("Comfy.UseNewMenu", false) === true) { + const setting = app.ui.settings.getSettingValue("Comfy.UseNewMenu", false); + if (setting && setting != "Disabled") { const t = /** @type { {imageIndex?: number, overIndex?: number, imgs: string[]} } */ /** @type {any} */ (this); let img; if (t.imageIndex != null) { diff --git a/web/style.css b/web/style.css index e983b652a713..8ef1d0dd101a 100644 --- a/web/style.css +++ b/web/style.css @@ -41,7 +41,7 @@ body { background-color: var(--bg-color); color: var(--fg-color); grid-template-columns: auto 1fr auto; - grid-template-rows: auto auto 1fr auto; + grid-template-rows: auto 1fr auto; min-height: -webkit-fill-available; max-height: -webkit-fill-available; min-width: -webkit-fill-available; @@ -49,32 +49,37 @@ body { } .comfyui-body-top { - order: 0; + order: -5; grid-column: 1/-1; z-index: 10; + display: flex; + flex-direction: column; } .comfyui-body-left { - order: 1; + order: -4; z-index: 10; + display: flex; } #graph-canvas { width: 100%; height: 100%; - order: 2; - grid-column: 1/-1; + order: -3; } .comfyui-body-right { - order: 3; + order: -2; z-index: 10; + display: flex; } .comfyui-body-bottom { - order: 4; + order: -1; grid-column: 1/-1; z-index: 10; + display: flex; + flex-direction: column; } .comfy-multiline-input { @@ -408,8 +413,12 @@ dialog::backdrop { background: rgba(0, 0, 0, 0.5); } -.comfy-dialog.comfyui-dialog { +.comfy-dialog.comfyui-dialog.comfy-modal { top: 0; + left: 0; + right: 0; + bottom: 0; + transform: none; } .comfy-dialog.comfy-modal { From 7914c47d5afb1c5ffab49d665f9a1ac86a458821 Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Sun, 14 Jul 2024 10:07:36 -0400 Subject: [PATCH 69/94] Quick fix for the promax controlnet. --- comfy/cldm/cldm.py | 6 +++--- comfy/controlnet.py | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/comfy/cldm/cldm.py b/comfy/cldm/cldm.py index d4d32b87ec92..4a58c823f5f1 100644 --- a/comfy/cldm/cldm.py +++ b/comfy/cldm/cldm.py @@ -92,7 +92,7 @@ def __init__( transformer_depth_middle=None, transformer_depth_output=None, attn_precision=None, - union_controlnet=False, + union_controlnet_num_control_type=None, device=None, operations=comfy.ops.disable_weight_init, **kwargs, @@ -320,8 +320,8 @@ def __init__( self.middle_block_out = self.make_zero_conv(ch, operations=operations, dtype=self.dtype, device=device) self._feature_size += ch - if union_controlnet: - self.num_control_type = 6 + if union_controlnet_num_control_type is not None: + self.num_control_type = union_controlnet_num_control_type num_trans_channel = 320 num_trans_head = 8 num_trans_layer = 1 diff --git a/comfy/controlnet.py b/comfy/controlnet.py index 84286f1fac76..b8e27c71f8cd 100644 --- a/comfy/controlnet.py +++ b/comfy/controlnet.py @@ -414,7 +414,7 @@ def load_controlnet(ckpt_path, model=None): new_sd[diffusers_keys[k]] = controlnet_data.pop(k) if "control_add_embedding.linear_1.bias" in controlnet_data: #Union Controlnet - controlnet_config["union_controlnet"] = True + controlnet_config["union_controlnet_num_control_type"] = controlnet_data["task_embedding"].shape[0] for k in list(controlnet_data.keys()): new_k = k.replace('.attn.in_proj_', '.attn.in_proj.') new_sd[new_k] = controlnet_data.pop(k) From 1305fb294ca69d0a44d88c5bf7ce8c682abd0c8a Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Mon, 15 Jul 2024 17:36:24 -0400 Subject: [PATCH 70/94] Refactor: Move some code to the comfy/text_encoders folder. --- comfy/sd.py | 20 +++++++++---------- comfy/supported_models.py | 8 ++++---- comfy/text_encoders/aura_t5.py | 4 ++-- comfy/{ => text_encoders}/sa_t5.py | 4 ++-- comfy/{ => text_encoders}/sd3_clip.py | 4 ++-- comfy/{ => text_encoders}/t5.py | 0 comfy/{ => text_encoders}/t5_config_base.json | 0 comfy/{ => text_encoders}/t5_config_xxl.json | 0 .../t5_tokenizer/special_tokens_map.json | 0 .../t5_tokenizer/tokenizer.json | 0 .../t5_tokenizer/tokenizer_config.json | 0 11 files changed, 20 insertions(+), 20 deletions(-) rename comfy/{ => text_encoders}/sa_t5.py (88%) rename comfy/{ => text_encoders}/sd3_clip.py (98%) rename comfy/{ => text_encoders}/t5.py (100%) rename comfy/{ => text_encoders}/t5_config_base.json (100%) rename comfy/{ => text_encoders}/t5_config_xxl.json (100%) rename comfy/{ => text_encoders}/t5_tokenizer/special_tokens_map.json (100%) rename comfy/{ => text_encoders}/t5_tokenizer/tokenizer.json (100%) rename comfy/{ => text_encoders}/t5_tokenizer/tokenizer_config.json (100%) diff --git a/comfy/sd.py b/comfy/sd.py index b5bbcef61bf9..17df5faffc63 100644 --- a/comfy/sd.py +++ b/comfy/sd.py @@ -19,8 +19,8 @@ from . import sd1_clip from . import sd2_clip from . import sdxl_clip -from . import sd3_clip -from . import sa_t5 +import comfy.text_encoders.sd3_clip +import comfy.text_encoders.sa_t5 import comfy.text_encoders.aura_t5 import comfy.model_patcher @@ -414,27 +414,27 @@ class EmptyClass: weight = clip_data[0]["encoder.block.23.layer.1.DenseReluDense.wi_1.weight"] dtype_t5 = weight.dtype if weight.shape[-1] == 4096: - clip_target.clip = sd3_clip.sd3_clip(clip_l=False, clip_g=False, t5=True, dtype_t5=dtype_t5) - clip_target.tokenizer = sd3_clip.SD3Tokenizer + clip_target.clip = comfy.text_encoders.sd3_clip.sd3_clip(clip_l=False, clip_g=False, t5=True, dtype_t5=dtype_t5) + clip_target.tokenizer = comfy.text_encoders.sd3_clip.SD3Tokenizer elif weight.shape[-1] == 2048: clip_target.clip = comfy.text_encoders.aura_t5.AuraT5Model clip_target.tokenizer = comfy.text_encoders.aura_t5.AuraT5Tokenizer elif "encoder.block.0.layer.0.SelfAttention.k.weight" in clip_data[0]: - clip_target.clip = sa_t5.SAT5Model - clip_target.tokenizer = sa_t5.SAT5Tokenizer + clip_target.clip = comfy.text_encoders.sa_t5.SAT5Model + clip_target.tokenizer = comfy.text_encoders.sa_t5.SAT5Tokenizer else: clip_target.clip = sd1_clip.SD1ClipModel clip_target.tokenizer = sd1_clip.SD1Tokenizer elif len(clip_data) == 2: if clip_type == CLIPType.SD3: - clip_target.clip = sd3_clip.sd3_clip(clip_l=True, clip_g=True, t5=False) - clip_target.tokenizer = sd3_clip.SD3Tokenizer + clip_target.clip = comfy.text_encoders.sd3_clip.sd3_clip(clip_l=True, clip_g=True, t5=False) + clip_target.tokenizer = comfy.text_encoders.sd3_clip.SD3Tokenizer else: clip_target.clip = sdxl_clip.SDXLClipModel clip_target.tokenizer = sdxl_clip.SDXLTokenizer elif len(clip_data) == 3: - clip_target.clip = sd3_clip.SD3ClipModel - clip_target.tokenizer = sd3_clip.SD3Tokenizer + clip_target.clip = comfy.text_encoders.sd3_clip.SD3ClipModel + clip_target.tokenizer = comfy.text_encoders.sd3_clip.SD3Tokenizer clip = CLIP(clip_target, embedding_directory=embedding_directory) for c in clip_data: diff --git a/comfy/supported_models.py b/comfy/supported_models.py index a030f6229f38..b4d1059ef3f8 100644 --- a/comfy/supported_models.py +++ b/comfy/supported_models.py @@ -5,8 +5,8 @@ from . import sd1_clip from . import sd2_clip from . import sdxl_clip -from . import sd3_clip -from . import sa_t5 +import comfy.text_encoders.sd3_clip +import comfy.text_encoders.sa_t5 import comfy.text_encoders.aura_t5 from . import supported_models_base @@ -524,7 +524,7 @@ def clip_target(self, state_dict={}): t5 = True dtype_t5 = state_dict[t5_key].dtype - return supported_models_base.ClipTarget(sd3_clip.SD3Tokenizer, sd3_clip.sd3_clip(clip_l=clip_l, clip_g=clip_g, t5=t5, dtype_t5=dtype_t5)) + return supported_models_base.ClipTarget(comfy.text_encoders.sd3_clip.SD3Tokenizer, comfy.text_encoders.sd3_clip.sd3_clip(clip_l=clip_l, clip_g=clip_g, t5=t5, dtype_t5=dtype_t5)) class StableAudio(supported_models_base.BASE): unet_config = { @@ -555,7 +555,7 @@ def process_unet_state_dict_for_saving(self, state_dict): return utils.state_dict_prefix_replace(state_dict, replace_prefix) def clip_target(self, state_dict={}): - return supported_models_base.ClipTarget(sa_t5.SAT5Tokenizer, sa_t5.SAT5Model) + return supported_models_base.ClipTarget(comfy.text_encoders.sa_t5.SAT5Tokenizer, comfy.text_encoders.sa_t5.SAT5Model) class AuraFlow(supported_models_base.BASE): unet_config = { diff --git a/comfy/text_encoders/aura_t5.py b/comfy/text_encoders/aura_t5.py index 95f942ef5784..6b9e4fe537ca 100644 --- a/comfy/text_encoders/aura_t5.py +++ b/comfy/text_encoders/aura_t5.py @@ -1,12 +1,12 @@ from comfy import sd1_clip from .llama_tokenizer import LLAMATokenizer -import comfy.t5 +import comfy.text_encoders.t5 import os class PT5XlModel(sd1_clip.SDClipModel): def __init__(self, device="cpu", layer="last", layer_idx=None, dtype=None): textmodel_json_config = os.path.join(os.path.dirname(os.path.realpath(__file__)), "t5_pile_config_xl.json") - super().__init__(device=device, layer=layer, layer_idx=layer_idx, textmodel_json_config=textmodel_json_config, dtype=dtype, special_tokens={"end": 2, "pad": 1}, model_class=comfy.t5.T5, enable_attention_masks=True, zero_out_masked=True) + super().__init__(device=device, layer=layer, layer_idx=layer_idx, textmodel_json_config=textmodel_json_config, dtype=dtype, special_tokens={"end": 2, "pad": 1}, model_class=comfy.text_encoders.t5.T5, enable_attention_masks=True, zero_out_masked=True) class PT5XlTokenizer(sd1_clip.SDTokenizer): def __init__(self, embedding_directory=None): diff --git a/comfy/sa_t5.py b/comfy/text_encoders/sa_t5.py similarity index 88% rename from comfy/sa_t5.py rename to comfy/text_encoders/sa_t5.py index acc302f67e61..038558e7aa5a 100644 --- a/comfy/sa_t5.py +++ b/comfy/text_encoders/sa_t5.py @@ -1,12 +1,12 @@ from comfy import sd1_clip from transformers import T5TokenizerFast -import comfy.t5 +import comfy.text_encoders.t5 import os class T5BaseModel(sd1_clip.SDClipModel): def __init__(self, device="cpu", layer="last", layer_idx=None, dtype=None): textmodel_json_config = os.path.join(os.path.dirname(os.path.realpath(__file__)), "t5_config_base.json") - super().__init__(device=device, layer=layer, layer_idx=layer_idx, textmodel_json_config=textmodel_json_config, dtype=dtype, special_tokens={"end": 1, "pad": 0}, model_class=comfy.t5.T5, enable_attention_masks=True, zero_out_masked=True) + super().__init__(device=device, layer=layer, layer_idx=layer_idx, textmodel_json_config=textmodel_json_config, dtype=dtype, special_tokens={"end": 1, "pad": 0}, model_class=comfy.text_encoders.t5.T5, enable_attention_masks=True, zero_out_masked=True) class T5BaseTokenizer(sd1_clip.SDTokenizer): def __init__(self, embedding_directory=None): diff --git a/comfy/sd3_clip.py b/comfy/text_encoders/sd3_clip.py similarity index 98% rename from comfy/sd3_clip.py rename to comfy/text_encoders/sd3_clip.py index 0713eb285294..70127e50975e 100644 --- a/comfy/sd3_clip.py +++ b/comfy/text_encoders/sd3_clip.py @@ -1,7 +1,7 @@ from comfy import sd1_clip from comfy import sdxl_clip from transformers import T5TokenizerFast -import comfy.t5 +import comfy.text_encoders.t5 import torch import os import comfy.model_management @@ -10,7 +10,7 @@ class T5XXLModel(sd1_clip.SDClipModel): def __init__(self, device="cpu", layer="last", layer_idx=None, dtype=None): textmodel_json_config = os.path.join(os.path.dirname(os.path.realpath(__file__)), "t5_config_xxl.json") - super().__init__(device=device, layer=layer, layer_idx=layer_idx, textmodel_json_config=textmodel_json_config, dtype=dtype, special_tokens={"end": 1, "pad": 0}, model_class=comfy.t5.T5) + super().__init__(device=device, layer=layer, layer_idx=layer_idx, textmodel_json_config=textmodel_json_config, dtype=dtype, special_tokens={"end": 1, "pad": 0}, model_class=comfy.text_encoders.t5.T5) class T5XXLTokenizer(sd1_clip.SDTokenizer): def __init__(self, embedding_directory=None): diff --git a/comfy/t5.py b/comfy/text_encoders/t5.py similarity index 100% rename from comfy/t5.py rename to comfy/text_encoders/t5.py diff --git a/comfy/t5_config_base.json b/comfy/text_encoders/t5_config_base.json similarity index 100% rename from comfy/t5_config_base.json rename to comfy/text_encoders/t5_config_base.json diff --git a/comfy/t5_config_xxl.json b/comfy/text_encoders/t5_config_xxl.json similarity index 100% rename from comfy/t5_config_xxl.json rename to comfy/text_encoders/t5_config_xxl.json diff --git a/comfy/t5_tokenizer/special_tokens_map.json b/comfy/text_encoders/t5_tokenizer/special_tokens_map.json similarity index 100% rename from comfy/t5_tokenizer/special_tokens_map.json rename to comfy/text_encoders/t5_tokenizer/special_tokens_map.json diff --git a/comfy/t5_tokenizer/tokenizer.json b/comfy/text_encoders/t5_tokenizer/tokenizer.json similarity index 100% rename from comfy/t5_tokenizer/tokenizer.json rename to comfy/text_encoders/t5_tokenizer/tokenizer.json diff --git a/comfy/t5_tokenizer/tokenizer_config.json b/comfy/text_encoders/t5_tokenizer/tokenizer_config.json similarity index 100% rename from comfy/t5_tokenizer/tokenizer_config.json rename to comfy/text_encoders/t5_tokenizer/tokenizer_config.json From 136c93cb477e4c5c308791746583499805ab29aa Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Mon, 15 Jul 2024 20:01:49 -0400 Subject: [PATCH 71/94] Fix bug with workflow not registering change. There was an issue when only the class type of a node changed with all the inputs staying the same. --- execution.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/execution.py b/execution.py index 76225a9623d0..8b3d116c698c 100644 --- a/execution.py +++ b/execution.py @@ -247,6 +247,8 @@ def recursive_output_delete_if_changed(prompt, old_prompt, outputs, current_item to_delete = True elif unique_id not in old_prompt: to_delete = True + elif class_type != old_prompt[unique_id]['class_type']: + to_delete = True elif inputs == old_prompt[unique_id]['inputs']: for x in inputs: input_data = inputs[x] From 33346fd9b8856942187ad8c818498a080a2027b5 Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Mon, 15 Jul 2024 20:36:03 -0400 Subject: [PATCH 72/94] Fix bug with custom nodes on other drives. --- nodes.py | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/nodes.py b/nodes.py index 5778f060949d..998b316b7c1a 100644 --- a/nodes.py +++ b/nodes.py @@ -1890,29 +1890,29 @@ def expand_image(self, image, left, top, right, bottom, feathering): EXTENSION_WEB_DIRS = {} -def get_relative_module_name(module_path: str) -> str: +def get_module_name(module_path: str) -> str: """ Returns the module name based on the given module path. Examples: - get_module_name("C:/Users/username/ComfyUI/custom_nodes/my_custom_node.py") -> "custom_nodes.my_custom_node" - get_module_name("C:/Users/username/ComfyUI/custom_nodes/my_custom_node") -> "custom_nodes.my_custom_node" - get_module_name("C:/Users/username/ComfyUI/custom_nodes/my_custom_node/") -> "custom_nodes.my_custom_node" - get_module_name("C:/Users/username/ComfyUI/custom_nodes/my_custom_node/__init__.py") -> "custom_nodes.my_custom_node" - get_module_name("C:/Users/username/ComfyUI/custom_nodes/my_custom_node/__init__") -> "custom_nodes.my_custom_node" - get_module_name("C:/Users/username/ComfyUI/custom_nodes/my_custom_node/__init__/") -> "custom_nodes.my_custom_node" - get_module_name("C:/Users/username/ComfyUI/custom_nodes/my_custom_node.disabled") -> "custom_nodes.my + get_module_name("C:/Users/username/ComfyUI/custom_nodes/my_custom_node.py") -> "my_custom_node" + get_module_name("C:/Users/username/ComfyUI/custom_nodes/my_custom_node") -> "my_custom_node" + get_module_name("C:/Users/username/ComfyUI/custom_nodes/my_custom_node/") -> "my_custom_node" + get_module_name("C:/Users/username/ComfyUI/custom_nodes/my_custom_node/__init__.py") -> "my_custom_node" + get_module_name("C:/Users/username/ComfyUI/custom_nodes/my_custom_node/__init__") -> "my_custom_node" + get_module_name("C:/Users/username/ComfyUI/custom_nodes/my_custom_node/__init__/") -> "my_custom_node" + get_module_name("C:/Users/username/ComfyUI/custom_nodes/my_custom_node.disabled") -> "custom_nodes Args: module_path (str): The path of the module. Returns: str: The module name. """ - relative_path = os.path.relpath(module_path, folder_paths.base_path) + base_path = os.path.basename(module_path) if os.path.isfile(module_path): - relative_path = os.path.splitext(relative_path)[0] - return relative_path.replace(os.sep, '.') + base_path = os.path.splitext(base_path)[0] + return base_path -def load_custom_node(module_path: str, ignore=set()) -> bool: +def load_custom_node(module_path: str, ignore=set(), module_parent="custom_nodes") -> bool: module_name = os.path.basename(module_path) if os.path.isfile(module_path): sp = os.path.splitext(module_path) @@ -1939,7 +1939,7 @@ def load_custom_node(module_path: str, ignore=set()) -> bool: for name, node_cls in module.NODE_CLASS_MAPPINGS.items(): if name not in ignore: NODE_CLASS_MAPPINGS[name] = node_cls - node_cls.RELATIVE_PYTHON_MODULE = get_relative_module_name(module_path) + node_cls.RELATIVE_PYTHON_MODULE = "{}.{}".format(module_parent, get_module_name(module_path)) if hasattr(module, "NODE_DISPLAY_NAME_MAPPINGS") and getattr(module, "NODE_DISPLAY_NAME_MAPPINGS") is not None: NODE_DISPLAY_NAME_MAPPINGS.update(module.NODE_DISPLAY_NAME_MAPPINGS) return True @@ -1974,7 +1974,7 @@ def init_external_custom_nodes(): if os.path.isfile(module_path) and os.path.splitext(module_path)[1] != ".py": continue if module_path.endswith(".disabled"): continue time_before = time.perf_counter() - success = load_custom_node(module_path, base_node_names) + success = load_custom_node(module_path, base_node_names, module_parent="custom_nodes") node_import_times.append((time.perf_counter() - time_before, module_path, success)) if len(node_import_times) > 0: @@ -2040,7 +2040,7 @@ def init_builtin_extra_nodes(): import_failed = [] for node_file in extras_files: - if not load_custom_node(os.path.join(extras_dir, node_file)): + if not load_custom_node(os.path.join(extras_dir, node_file), module_parent="comfy_extras"): import_failed.append(node_file) return import_failed From 99458e8aca3c48c7b2de3c404f66536991c37182 Mon Sep 17 00:00:00 2001 From: Chenlei Hu Date: Tue, 16 Jul 2024 11:26:11 -0400 Subject: [PATCH 73/94] Add `FrontendManager` to manage non-default front-end impl (#3897) * Add frontend manager * Add tests * nit * Add unit test to github CI * Fix path * nit * ignore * Add logging * Install test deps * Remove 'stable' keyword support * Update test * Add web-root arg * Rename web-root to front-end-root * Add test on non-exist version number * Use repo owner/name to replace hard coded provider list * Inline cmd args * nit * Fix unit test --- .github/workflows/test-ui.yaml | 4 + .gitignore | 3 +- app/__init__.py | 0 app/frontend_management.py | 187 +++++++++++++++++++ comfy/cli_args.py | 35 ++++ pytest.ini | 7 +- server.py | 11 +- tests-unit/README.md | 8 + tests-unit/app_test/__init__.py | 0 tests-unit/app_test/frontend_manager_test.py | 100 ++++++++++ tests-unit/requirements.txt | 1 + 11 files changed, 350 insertions(+), 6 deletions(-) create mode 100644 app/__init__.py create mode 100644 app/frontend_management.py create mode 100644 tests-unit/README.md create mode 100644 tests-unit/app_test/__init__.py create mode 100644 tests-unit/app_test/frontend_manager_test.py create mode 100644 tests-unit/requirements.txt diff --git a/.github/workflows/test-ui.yaml b/.github/workflows/test-ui.yaml index 4b8b9793479c..d947e9d5fc63 100644 --- a/.github/workflows/test-ui.yaml +++ b/.github/workflows/test-ui.yaml @@ -24,3 +24,7 @@ jobs: npm run test:generate npm test -- --verbose working-directory: ./tests-ui + - name: Run Unit Tests + run: | + pip install -r tests-unit/requirements.txt + python -m pytest tests-unit diff --git a/.gitignore b/.gitignore index a9beebe73a73..5092c98f4631 100644 --- a/.gitignore +++ b/.gitignore @@ -17,4 +17,5 @@ venv/ !/web/extensions/core/ /tests-ui/data/object_info.json /user/ -*.log \ No newline at end of file +*.log +web_custom_versions/ \ No newline at end of file diff --git a/app/__init__.py b/app/__init__.py new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/app/frontend_management.py b/app/frontend_management.py new file mode 100644 index 000000000000..0855f4160f02 --- /dev/null +++ b/app/frontend_management.py @@ -0,0 +1,187 @@ +import argparse +import logging +import os +import re +import tempfile +import zipfile +from dataclasses import dataclass +from functools import cached_property +from pathlib import Path +from typing import TypedDict + +import requests +from typing_extensions import NotRequired +from comfy.cli_args import DEFAULT_VERSION_STRING + + +REQUEST_TIMEOUT = 10 # seconds + + +class Asset(TypedDict): + url: str + + +class Release(TypedDict): + id: int + tag_name: str + name: str + prerelease: bool + created_at: str + published_at: str + body: str + assets: NotRequired[list[Asset]] + + +@dataclass +class FrontEndProvider: + owner: str + repo: str + + @property + def folder_name(self) -> str: + return f"{self.owner}_{self.repo}" + + @property + def release_url(self) -> str: + return f"https://api.github.com/repos/{self.owner}/{self.repo}/releases" + + @cached_property + def all_releases(self) -> list[Release]: + releases = [] + api_url = self.release_url + while api_url: + response = requests.get(api_url, timeout=REQUEST_TIMEOUT) + response.raise_for_status() # Raises an HTTPError if the response was an error + releases.extend(response.json()) + # GitHub uses the Link header to provide pagination links. Check if it exists and update api_url accordingly. + if "next" in response.links: + api_url = response.links["next"]["url"] + else: + api_url = None + return releases + + @cached_property + def latest_release(self) -> Release: + latest_release_url = f"{self.release_url}/latest" + response = requests.get(latest_release_url, timeout=REQUEST_TIMEOUT) + response.raise_for_status() # Raises an HTTPError if the response was an error + return response.json() + + def get_release(self, version: str) -> Release: + if version == "latest": + return self.latest_release + else: + for release in self.all_releases: + if release["tag_name"] in [version, f"v{version}"]: + return release + raise ValueError(f"Version {version} not found in releases") + + +def download_release_asset_zip(release: Release, destination_path: str) -> None: + """Download dist.zip from github release.""" + asset_url = None + for asset in release.get("assets", []): + if asset["name"] == "dist.zip": + asset_url = asset["url"] + break + + if not asset_url: + raise ValueError("dist.zip not found in the release assets") + + # Use a temporary file to download the zip content + with tempfile.TemporaryFile() as tmp_file: + headers = {"Accept": "application/octet-stream"} + response = requests.get( + asset_url, headers=headers, allow_redirects=True, timeout=REQUEST_TIMEOUT + ) + response.raise_for_status() # Ensure we got a successful response + + # Write the content to the temporary file + tmp_file.write(response.content) + + # Go back to the beginning of the temporary file + tmp_file.seek(0) + + # Extract the zip file content to the destination path + with zipfile.ZipFile(tmp_file, "r") as zip_ref: + zip_ref.extractall(destination_path) + + +class FrontendManager: + DEFAULT_FRONTEND_PATH = str(Path(__file__).parents[1] / "web") + CUSTOM_FRONTENDS_ROOT = str(Path(__file__).parents[1] / "web_custom_versions") + + @classmethod + def parse_version_string(cls, value: str) -> tuple[str, str, str]: + """ + Args: + value (str): The version string to parse. + + Returns: + tuple[str, str]: A tuple containing provider name and version. + + Raises: + argparse.ArgumentTypeError: If the version string is invalid. + """ + VERSION_PATTERN = r"^([a-zA-Z0-9][a-zA-Z0-9-]{0,38})/([a-zA-Z0-9_.-]+)@(\d+\.\d+\.\d+|latest)$" + match_result = re.match(VERSION_PATTERN, value) + if match_result is None: + raise argparse.ArgumentTypeError(f"Invalid version string: {value}") + + return match_result.group(1), match_result.group(2), match_result.group(3) + + @classmethod + def init_frontend_unsafe(cls, version_string: str) -> str: + """ + Initializes the frontend for the specified version. + + Args: + version_string (str): The version string. + + Returns: + str: The path to the initialized frontend. + + Raises: + Exception: If there is an error during the initialization process. + main error source might be request timeout or invalid URL. + """ + if version_string == DEFAULT_VERSION_STRING: + return cls.DEFAULT_FRONTEND_PATH + + repo_owner, repo_name, version = cls.parse_version_string(version_string) + provider = FrontEndProvider(repo_owner, repo_name) + release = provider.get_release(version) + + semantic_version = release["tag_name"].lstrip("v") + web_root = str( + Path(cls.CUSTOM_FRONTENDS_ROOT) / provider.folder_name / semantic_version + ) + if not os.path.exists(web_root): + os.makedirs(web_root, exist_ok=True) + logging.info( + "Downloading frontend(%s) version(%s) to (%s)", + provider.folder_name, + semantic_version, + web_root, + ) + logging.debug(release) + download_release_asset_zip(release, destination_path=web_root) + return web_root + + @classmethod + def init_frontend(cls, version_string: str) -> str: + """ + Initializes the frontend with the specified version string. + + Args: + version_string (str): The version string to initialize the frontend with. + + Returns: + str: The path of the initialized frontend. + """ + try: + return cls.init_frontend_unsafe(version_string) + except Exception as e: + logging.error("Failed to initialize frontend: %s", e) + logging.info("Falling back to the default frontend.") + return cls.DEFAULT_FRONTEND_PATH diff --git a/comfy/cli_args.py b/comfy/cli_args.py index b72bf3998ae0..6251e3d28fc2 100644 --- a/comfy/cli_args.py +++ b/comfy/cli_args.py @@ -1,7 +1,10 @@ import argparse import enum +import os +from typing import Optional import comfy.options + class EnumAction(argparse.Action): """ Argparse action for handling Enums @@ -124,6 +127,38 @@ class LatentPreviewMethod(enum.Enum): parser.add_argument("--verbose", action="store_true", help="Enables more debug prints.") +# The default built-in provider hosted under web/ +DEFAULT_VERSION_STRING = "comfyanonymous/ComfyUI@latest" + +parser.add_argument( + "--front-end-version", + type=str, + default=DEFAULT_VERSION_STRING, + help=""" + Specifies the version of the frontend to be used. This command needs internet connectivity to query and + download available frontend implementations from GitHub releases. + + The version string should be in the format of: + [repoOwner]/[repoName]@[version] + where version is one of: "latest" or a valid version number (e.g. "1.0.0") + """, +) + +def is_valid_directory(path: Optional[str]) -> Optional[str]: + """Validate if the given path is a directory.""" + if path is None: + return None + + if not os.path.isdir(path): + raise argparse.ArgumentTypeError(f"{path} is not a valid directory.") + return path + +parser.add_argument( + "--front-end-root", + type=is_valid_directory, + default=None, + help="The local filesystem path to the directory where the frontend is located. Overrides --front-end-version.", +) if comfy.options.args_parsing: args = parser.parse_args() diff --git a/pytest.ini b/pytest.ini index b5a68e0f12fe..8b7a747e7603 100644 --- a/pytest.ini +++ b/pytest.ini @@ -1,5 +1,8 @@ [pytest] markers = inference: mark as inference test (deselect with '-m "not inference"') -testpaths = tests -addopts = -s \ No newline at end of file +testpaths = + tests + tests-unit +addopts = -s +pythonpath = . diff --git a/server.py b/server.py index ce7c7532dabd..03c4c421906f 100644 --- a/server.py +++ b/server.py @@ -25,9 +25,10 @@ from comfy.cli_args import args import comfy.utils import comfy.model_management - +from app.frontend_management import FrontendManager from app.user_manager import UserManager + class BinaryEventTypes: PREVIEW_IMAGE = 1 UNENCODED_PREVIEW_IMAGE = 2 @@ -83,8 +84,12 @@ def __init__(self, loop): max_upload_size = round(args.max_upload_size * 1024 * 1024) self.app = web.Application(client_max_size=max_upload_size, middlewares=middlewares) self.sockets = dict() - self.web_root = os.path.join(os.path.dirname( - os.path.realpath(__file__)), "web") + self.web_root = ( + FrontendManager.init_frontend(args.front_end_version) + if args.front_end_root is None + else args.front_end_root + ) + logging.info(f"[Prompt Server] web root: {self.web_root}") routes = web.RouteTableDef() self.routes = routes self.last_node_id = None diff --git a/tests-unit/README.md b/tests-unit/README.md new file mode 100644 index 000000000000..94abd9853468 --- /dev/null +++ b/tests-unit/README.md @@ -0,0 +1,8 @@ +# Pytest Unit Tests + +## Install test dependencies + +`pip install -r tests-units/requirements.txt` + +## Run tests +`pytest tests-units/` diff --git a/tests-unit/app_test/__init__.py b/tests-unit/app_test/__init__.py new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/tests-unit/app_test/frontend_manager_test.py b/tests-unit/app_test/frontend_manager_test.py new file mode 100644 index 000000000000..637869cfbf55 --- /dev/null +++ b/tests-unit/app_test/frontend_manager_test.py @@ -0,0 +1,100 @@ +import argparse +import pytest +from requests.exceptions import HTTPError + +from app.frontend_management import ( + FrontendManager, + FrontEndProvider, + Release, +) +from comfy.cli_args import DEFAULT_VERSION_STRING + + +@pytest.fixture +def mock_releases(): + return [ + Release( + id=1, + tag_name="1.0.0", + name="Release 1.0.0", + prerelease=False, + created_at="2022-01-01T00:00:00Z", + published_at="2022-01-01T00:00:00Z", + body="Release notes for 1.0.0", + assets=[{"name": "dist.zip", "url": "https://example.com/dist.zip"}], + ), + Release( + id=2, + tag_name="2.0.0", + name="Release 2.0.0", + prerelease=False, + created_at="2022-02-01T00:00:00Z", + published_at="2022-02-01T00:00:00Z", + body="Release notes for 2.0.0", + assets=[{"name": "dist.zip", "url": "https://example.com/dist.zip"}], + ), + ] + + +@pytest.fixture +def mock_provider(mock_releases): + provider = FrontEndProvider( + owner="test-owner", + repo="test-repo", + ) + provider.all_releases = mock_releases + provider.latest_release = mock_releases[1] + FrontendManager.PROVIDERS = [provider] + return provider + + +def test_get_release(mock_provider, mock_releases): + version = "1.0.0" + release = mock_provider.get_release(version) + assert release == mock_releases[0] + + +def test_get_release_latest(mock_provider, mock_releases): + version = "latest" + release = mock_provider.get_release(version) + assert release == mock_releases[1] + + +def test_get_release_invalid_version(mock_provider): + version = "invalid" + with pytest.raises(ValueError): + mock_provider.get_release(version) + + +def test_init_frontend_default(): + version_string = DEFAULT_VERSION_STRING + frontend_path = FrontendManager.init_frontend(version_string) + assert frontend_path == FrontendManager.DEFAULT_FRONTEND_PATH + + +def test_init_frontend_invalid_version(): + version_string = "test-owner/test-repo@1.100.99" + with pytest.raises(HTTPError): + FrontendManager.init_frontend_unsafe(version_string) + + +def test_init_frontend_invalid_provider(): + version_string = "invalid/invalid@latest" + with pytest.raises(HTTPError): + FrontendManager.init_frontend_unsafe(version_string) + + +def test_parse_version_string(): + version_string = "owner/repo@1.0.0" + repo_owner, repo_name, version = FrontendManager.parse_version_string( + version_string + ) + assert repo_owner == "owner" + assert repo_name == "repo" + assert version == "1.0.0" + + +def test_parse_version_string_invalid(): + version_string = "invalid" + with pytest.raises(argparse.ArgumentTypeError): + FrontendManager.parse_version_string(version_string) diff --git a/tests-unit/requirements.txt b/tests-unit/requirements.txt new file mode 100644 index 000000000000..0587502f877a --- /dev/null +++ b/tests-unit/requirements.txt @@ -0,0 +1 @@ +pytest>=7.8.0 From e1630391d6d190c3dd9ef4609f0c84af72be54af Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Tue, 16 Jul 2024 11:29:38 -0400 Subject: [PATCH 74/94] Allow version names like v0.0.1 for the FrontendManager. --- app/frontend_management.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/app/frontend_management.py b/app/frontend_management.py index 0855f4160f02..5452f6e114a0 100644 --- a/app/frontend_management.py +++ b/app/frontend_management.py @@ -123,7 +123,7 @@ def parse_version_string(cls, value: str) -> tuple[str, str, str]: Raises: argparse.ArgumentTypeError: If the version string is invalid. """ - VERSION_PATTERN = r"^([a-zA-Z0-9][a-zA-Z0-9-]{0,38})/([a-zA-Z0-9_.-]+)@(\d+\.\d+\.\d+|latest)$" + VERSION_PATTERN = r"^([a-zA-Z0-9][a-zA-Z0-9-]{0,38})/([a-zA-Z0-9_.-]+)@(v?\d+\.\d+\.\d+|latest)$" match_result = re.match(VERSION_PATTERN, value) if match_result is None: raise argparse.ArgumentTypeError(f"Invalid version string: {value}") From 821f93872ecf3f1769b8abebd640a804839f4ab9 Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Tue, 16 Jul 2024 15:18:24 -0400 Subject: [PATCH 75/94] Allow model sampling to set number of timesteps. --- comfy/model_sampling.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/comfy/model_sampling.py b/comfy/model_sampling.py index 2d95a83dc84f..25bb7e043b62 100644 --- a/comfy/model_sampling.py +++ b/comfy/model_sampling.py @@ -59,8 +59,9 @@ def __init__(self, model_config=None): beta_schedule = sampling_settings.get("beta_schedule", "linear") linear_start = sampling_settings.get("linear_start", 0.00085) linear_end = sampling_settings.get("linear_end", 0.012) + timesteps = sampling_settings.get("timesteps", 1000) - self._register_schedule(given_betas=None, beta_schedule=beta_schedule, timesteps=1000, linear_start=linear_start, linear_end=linear_end, cosine_s=8e-3) + self._register_schedule(given_betas=None, beta_schedule=beta_schedule, timesteps=timesteps, linear_start=linear_start, linear_end=linear_end, cosine_s=8e-3) self.sigma_data = 1.0 def _register_schedule(self, given_betas=None, beta_schedule="linear", timesteps=1000, From 8270c625301034767c77b7d7b1e5a135172d1ebb Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Tue, 16 Jul 2024 17:01:40 -0400 Subject: [PATCH 76/94] Add SetUnionControlNetType to set the type of the union controlnet model. --- comfy/controlnet.py | 8 ++++++- comfy_extras/nodes_controlnet.py | 37 ++++++++++++++++++++++++++++++++ nodes.py | 1 + 3 files changed, 45 insertions(+), 1 deletion(-) create mode 100644 comfy_extras/nodes_controlnet.py diff --git a/comfy/controlnet.py b/comfy/controlnet.py index b8e27c71f8cd..12e5f16c88e5 100644 --- a/comfy/controlnet.py +++ b/comfy/controlnet.py @@ -45,6 +45,7 @@ def __init__(self, device=None): self.timestep_range = None self.compression_ratio = 8 self.upscale_algorithm = 'nearest-exact' + self.extra_args = {} if device is None: device = comfy.model_management.get_torch_device() @@ -90,6 +91,7 @@ def copy_to(self, c): c.compression_ratio = self.compression_ratio c.upscale_algorithm = self.upscale_algorithm c.latent_format = self.latent_format + c.extra_args = self.extra_args.copy() c.vae = self.vae def inference_memory_requirements(self, dtype): @@ -135,6 +137,10 @@ def control_merge(self, control, control_prev, output_dtype): o[i] = prev_val + o[i] #TODO: change back to inplace add if shared tensors stop being an issue return out + def set_extra_arg(self, argument, value=None): + self.extra_args[argument] = value + + class ControlNet(ControlBase): def __init__(self, control_model=None, global_average_pooling=False, compression_ratio=8, latent_format=None, device=None, load_device=None, manual_cast_dtype=None): super().__init__(device) @@ -191,7 +197,7 @@ def get_control(self, x_noisy, t, cond, batched_number): timestep = self.model_sampling_current.timestep(t) x_noisy = self.model_sampling_current.calculate_input(t, x_noisy) - control = self.control_model(x=x_noisy.to(dtype), hint=self.cond_hint, timesteps=timestep.float(), context=context.to(dtype), y=y) + control = self.control_model(x=x_noisy.to(dtype), hint=self.cond_hint, timesteps=timestep.float(), context=context.to(dtype), y=y, **self.extra_args) return self.control_merge(control, control_prev, output_dtype) def copy(self): diff --git a/comfy_extras/nodes_controlnet.py b/comfy_extras/nodes_controlnet.py new file mode 100644 index 000000000000..e550436b0049 --- /dev/null +++ b/comfy_extras/nodes_controlnet.py @@ -0,0 +1,37 @@ + +UNION_CONTROLNET_TYPES = {"auto": -1, + "openpose": 0, + "depth": 1, + "hed/pidi/scribble/ted": 2, + "canny/lineart/anime_lineart/mlsd": 3, + "normal": 4, + "segment": 5, + "tile": 6, + "repaint": 7, + } + +class SetUnionControlNetType: + @classmethod + def INPUT_TYPES(s): + return {"required": {"control_net": ("CONTROL_NET", ), + "type": (list(UNION_CONTROLNET_TYPES.keys()),) + }} + + CATEGORY = "conditioning" + RETURN_TYPES = ("CONTROL_NET",) + + FUNCTION = "set_controlnet_type" + + def set_controlnet_type(self, control_net, type): + control_net = control_net.copy() + type_number = UNION_CONTROLNET_TYPES[type] + if type_number >= 0: + control_net.set_extra_arg("control_type", [type_number]) + else: + control_net.set_extra_arg("control_type", []) + + return (control_net,) + +NODE_CLASS_MAPPINGS = { + "SetUnionControlNetType": SetUnionControlNetType, +} diff --git a/nodes.py b/nodes.py index 998b316b7c1a..89a2f21d2594 100644 --- a/nodes.py +++ b/nodes.py @@ -2036,6 +2036,7 @@ def init_builtin_extra_nodes(): "nodes_audio.py", "nodes_sd3.py", "nodes_gits.py", + "nodes_controlnet.py", ] import_failed = [] From 60383f3b64aa4477edfea325879bb04d3695161c Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Tue, 16 Jul 2024 17:08:25 -0400 Subject: [PATCH 77/94] Move controlnet nodes to conditioning/controlnet. --- comfy_extras/nodes_controlnet.py | 2 +- comfy_extras/nodes_sd3.py | 2 +- nodes.py | 4 ++-- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/comfy_extras/nodes_controlnet.py b/comfy_extras/nodes_controlnet.py index e550436b0049..ef7cfc6ab49c 100644 --- a/comfy_extras/nodes_controlnet.py +++ b/comfy_extras/nodes_controlnet.py @@ -17,7 +17,7 @@ def INPUT_TYPES(s): "type": (list(UNION_CONTROLNET_TYPES.keys()),) }} - CATEGORY = "conditioning" + CATEGORY = "conditioning/controlnet" RETURN_TYPES = ("CONTROL_NET",) FUNCTION = "set_controlnet_type" diff --git a/comfy_extras/nodes_sd3.py b/comfy_extras/nodes_sd3.py index 548b1ad6a20c..0aafa2426097 100644 --- a/comfy_extras/nodes_sd3.py +++ b/comfy_extras/nodes_sd3.py @@ -92,7 +92,7 @@ def INPUT_TYPES(s): "start_percent": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.001}), "end_percent": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.001}) }} - CATEGORY = "_for_testing/sd3" + CATEGORY = "conditioning/controlnet" NODE_CLASS_MAPPINGS = { "TripleCLIPLoader": TripleCLIPLoader, diff --git a/nodes.py b/nodes.py index 89a2f21d2594..fbdcb6c91aca 100644 --- a/nodes.py +++ b/nodes.py @@ -748,7 +748,7 @@ def INPUT_TYPES(s): RETURN_TYPES = ("CONDITIONING",) FUNCTION = "apply_controlnet" - CATEGORY = "conditioning" + CATEGORY = "conditioning/controlnet" def apply_controlnet(self, conditioning, control_net, image, strength): if strength == 0: @@ -783,7 +783,7 @@ def INPUT_TYPES(s): RETURN_NAMES = ("positive", "negative") FUNCTION = "apply_controlnet" - CATEGORY = "conditioning" + CATEGORY = "conditioning/controlnet" def apply_controlnet(self, positive, negative, control_net, image, strength, start_percent, end_percent, vae=None): if strength == 0: From f2298799ba58e915a1f22fec336d455c0913f409 Mon Sep 17 00:00:00 2001 From: Chenlei Hu Date: Tue, 16 Jul 2024 18:20:39 -0400 Subject: [PATCH 78/94] Fix annotation (#4035) --- app/frontend_management.py | 1 + 1 file changed, 1 insertion(+) diff --git a/app/frontend_management.py b/app/frontend_management.py index 5452f6e114a0..fb57b23f383d 100644 --- a/app/frontend_management.py +++ b/app/frontend_management.py @@ -1,3 +1,4 @@ +from __future__ import annotations import argparse import logging import os From c5a48b15bddab089f0054af0ed72eea868263ef6 Mon Sep 17 00:00:00 2001 From: Thomas Ward Date: Tue, 16 Jul 2024 18:27:09 -0400 Subject: [PATCH 79/94] Make default hash lib configurable without code changes via CLI argument (#3947) * cli_args: Add --duplicate-check-hash-function. * server.py: compare_image_hash configurable hash function Uses an argument added in cli_args to specify the type of hashing to default to for duplicate hash checking. Uses an `eval()` to identify the specific hashlib class to utilize, but ultimately safely operates because we have specific options and only those options/choices in the arg parser. So we don't have any unsafe input there. * Add hasher() to node_helpers * hashlib selection moved to node_helpers * default-hashing-function instead of dupe checking hasher This makes a default-hashing-function option instead of previous selected option. * Use args.default_hashing_function * Use safer handling for node_helpers.hasher() Uses a safer handling method than `eval` to evaluate default hashing function. * Stray parentheses are evil. * Indentation fix. Somehow when I hit save I didn't notice I missed a space to make indentation work proper. Oops! --- comfy/cli_args.py | 1 + node_helpers.py | 13 +++++++++++++ server.py | 7 +++++-- 3 files changed, 19 insertions(+), 2 deletions(-) diff --git a/comfy/cli_args.py b/comfy/cli_args.py index 6251e3d28fc2..2397de3d624a 100644 --- a/comfy/cli_args.py +++ b/comfy/cli_args.py @@ -112,6 +112,7 @@ class LatentPreviewMethod(enum.Enum): vram_group.add_argument("--novram", action="store_true", help="When lowvram isn't enough.") vram_group.add_argument("--cpu", action="store_true", help="To use the CPU for everything (slow).") +parser.add_argument("--default-hashing-function", type=str, choices=['md5', 'sha1', 'sha256', 'sha512'], default='sha256', help="Allows you to choose the hash function to use for duplicate filename / contents comparison. Default is sha256.") parser.add_argument("--disable-smart-memory", action="store_true", help="Force ComfyUI to agressively offload to regular ram instead of keeping models in vram when it can.") parser.add_argument("--deterministic", action="store_true", help="Make pytorch use slower deterministic algorithms when it can. Note that this might not make images deterministic in all cases.") diff --git a/node_helpers.py b/node_helpers.py index 43b9e829f599..fee6287901bf 100644 --- a/node_helpers.py +++ b/node_helpers.py @@ -1,3 +1,7 @@ +import hashlib + +from comfy.cli_args import args + from PIL import ImageFile, UnidentifiedImageError def conditioning_set_values(conditioning, values={}): @@ -22,3 +26,12 @@ def pillow(fn, arg): if prev_value is not None: ImageFile.LOAD_TRUNCATED_IMAGES = prev_value return x + +def hasher(): + hashfuncs = { + "md5": hashlib.md5, + "sha1": hashlib.sha1, + "sha256": hashlib.sha256, + "sha512": hashlib.sha512 + } + return hashfuncs[args.default_hashing_function] diff --git a/server.py b/server.py index 03c4c421906f..23ca2fd33334 100644 --- a/server.py +++ b/server.py @@ -25,6 +25,7 @@ from comfy.cli_args import args import comfy.utils import comfy.model_management +import node_helpers from app.frontend_management import FrontendManager from app.user_manager import UserManager @@ -161,10 +162,12 @@ def get_dir_by_type(dir_type): return type_dir, dir_type def compare_image_hash(filepath, image): + hasher = node_helpers.hasher() + # function to compare hashes of two images to see if it already exists, fix to #3465 if os.path.exists(filepath): - a = hashlib.sha256() - b = hashlib.sha256() + a = hasher() + b = hasher() with open(filepath, "rb") as f: a.update(f.read()) b.update(image.file.read()) From 1cde6b2eff5721175725e9cc5f80191d8276e1e8 Mon Sep 17 00:00:00 2001 From: Chenlei Hu Date: Tue, 16 Jul 2024 21:15:08 -0400 Subject: [PATCH 80/94] Disallow use of eval with pylint (#4033) --- .github/workflows/pylint.yml | 23 +++++++++++++++++++++++ .pylintrc | 3 +++ 2 files changed, 26 insertions(+) create mode 100644 .github/workflows/pylint.yml create mode 100644 .pylintrc diff --git a/.github/workflows/pylint.yml b/.github/workflows/pylint.yml new file mode 100644 index 000000000000..5effbea35fc7 --- /dev/null +++ b/.github/workflows/pylint.yml @@ -0,0 +1,23 @@ +name: Python Linting + +on: [push, pull_request] + +jobs: + pylint: + name: Run Pylint + runs-on: ubuntu-latest + + steps: + - name: Checkout repository + uses: actions/checkout@v4 + + - name: Set up Python + uses: actions/setup-python@v2 + with: + python-version: 3.x + + - name: Install Pylint + run: pip install pylint + + - name: Run Pylint + run: pylint --rcfile=.pylintrc $(find . -type f -name "*.py") diff --git a/.pylintrc b/.pylintrc new file mode 100644 index 000000000000..a5da56e57ca4 --- /dev/null +++ b/.pylintrc @@ -0,0 +1,3 @@ +[MESSAGES CONTROL] +disable=all +enable=eval-used From 281ad42df4fae74ed11c1e7ff14cff6b7db6498c Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Wed, 17 Jul 2024 10:16:31 -0400 Subject: [PATCH 81/94] Fix lowvram union controlnet bug. --- comfy/cldm/cldm.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/comfy/cldm/cldm.py b/comfy/cldm/cldm.py index 4a58c823f5f1..1d7294bd63de 100644 --- a/comfy/cldm/cldm.py +++ b/comfy/cldm/cldm.py @@ -361,7 +361,7 @@ def union_controlnet_merge(self, hint, control_type, emb, context): controlnet_cond = self.input_hint_block(hint[idx], emb, context) feat_seq = torch.mean(controlnet_cond, dim=(2, 3)) if idx < len(control_type): - feat_seq += self.task_embedding[control_type[idx]] + feat_seq += self.task_embedding[control_type[idx]].to(dtype=feat_seq.dtype, device=feat_seq.device) inputs.append(feat_seq.unsqueeze(1)) condition_list.append(controlnet_cond) From 6f7869f365ca4ec34b017f9002b9dcb9bce56b1a Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Wed, 17 Jul 2024 13:05:38 -0400 Subject: [PATCH 82/94] Get clip vision image size from config. --- comfy/clip_vision.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/comfy/clip_vision.py b/comfy/clip_vision.py index acc86be85566..ac39c62279da 100644 --- a/comfy/clip_vision.py +++ b/comfy/clip_vision.py @@ -34,6 +34,7 @@ def __init__(self, json_config): with open(json_config) as f: config = json.load(f) + self.image_size = config.get("image_size", 224) self.load_device = comfy.model_management.text_encoder_device() offload_device = comfy.model_management.text_encoder_offload_device() self.dtype = comfy.model_management.text_encoder_dtype(self.load_device) @@ -50,7 +51,7 @@ def get_sd(self): def encode_image(self, image): comfy.model_management.load_model_gpu(self.patcher) - pixel_values = clip_preprocess(image.to(self.load_device)).float() + pixel_values = clip_preprocess(image.to(self.load_device), size=self.image_size).float() out = self.model(pixel_values=pixel_values, intermediate_output=-2) outputs = Output() From 855789403b346c7d7772e2c7ed0a6a327f56047f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=96=B5=E5=93=A9=E4=B8=AA=E5=92=AA?= Date: Thu, 18 Jul 2024 01:12:50 +0800 Subject: [PATCH 83/94] support clip-vit-large-patch14-336 (#4042) * support clip-vit-large-patch14-336 * support clip-vit-large-patch14-336 --- comfy/clip_vision.py | 5 ++++- comfy/clip_vision_config_vitl_336.json | 18 ++++++++++++++++++ 2 files changed, 22 insertions(+), 1 deletion(-) create mode 100644 comfy/clip_vision_config_vitl_336.json diff --git a/comfy/clip_vision.py b/comfy/clip_vision.py index ac39c62279da..20dc3345d0fe 100644 --- a/comfy/clip_vision.py +++ b/comfy/clip_vision.py @@ -94,7 +94,10 @@ def load_clipvision_from_sd(sd, prefix="", convert_keys=False): elif "vision_model.encoder.layers.30.layer_norm1.weight" in sd: json_config = os.path.join(os.path.dirname(os.path.realpath(__file__)), "clip_vision_config_h.json") elif "vision_model.encoder.layers.22.layer_norm1.weight" in sd: - json_config = os.path.join(os.path.dirname(os.path.realpath(__file__)), "clip_vision_config_vitl.json") + if sd["vision_model.embeddings.position_embedding.weight"].shape[0] == 577: + json_config = os.path.join(os.path.dirname(os.path.realpath(__file__)), "clip_vision_config_vitl_336.json") + else: + json_config = os.path.join(os.path.dirname(os.path.realpath(__file__)), "clip_vision_config_vitl.json") else: return None diff --git a/comfy/clip_vision_config_vitl_336.json b/comfy/clip_vision_config_vitl_336.json new file mode 100644 index 000000000000..f26945273d99 --- /dev/null +++ b/comfy/clip_vision_config_vitl_336.json @@ -0,0 +1,18 @@ +{ + "attention_dropout": 0.0, + "dropout": 0.0, + "hidden_act": "quick_gelu", + "hidden_size": 1024, + "image_size": 336, + "initializer_factor": 1.0, + "initializer_range": 0.02, + "intermediate_size": 4096, + "layer_norm_eps": 1e-5, + "model_type": "clip_vision_model", + "num_attention_heads": 16, + "num_channels": 3, + "num_hidden_layers": 24, + "patch_size": 14, + "projection_dim": 768, + "torch_dtype": "float32" +} From 374e093e09c94b528d7c9dfc337c65cc5c433ee3 Mon Sep 17 00:00:00 2001 From: bymyself Date: Wed, 17 Jul 2024 13:11:10 -0700 Subject: [PATCH 84/94] Disable audio widget trying to get previews (#4044) --- web/extensions/core/uploadAudio.js | 1 - 1 file changed, 1 deletion(-) diff --git a/web/extensions/core/uploadAudio.js b/web/extensions/core/uploadAudio.js index 0ac9cb807f08..6cc3863a145d 100644 --- a/web/extensions/core/uploadAudio.js +++ b/web/extensions/core/uploadAudio.js @@ -17,7 +17,6 @@ function getResourceURL(subfolder, filename, type = "input") { "filename=" + encodeURIComponent(filename), "type=" + type, "subfolder=" + subfolder, - app.getPreviewFormatParam().substring(1), app.getRandParam().substring(1) ].join("&") From ff6ca2a892c25c5c6edb25c0c674445a7fe6b562 Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Thu, 18 Jul 2024 17:20:05 -0400 Subject: [PATCH 85/94] Move PAG to model_patches/unet section. Move other unet model_patches nodes to model_patches/unet section. --- comfy_extras/nodes_freelunch.py | 4 ++-- comfy_extras/nodes_hypertile.py | 2 +- comfy_extras/nodes_pag.py | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/comfy_extras/nodes_freelunch.py b/comfy_extras/nodes_freelunch.py index c5ebcf26fd63..e3ac58447b29 100644 --- a/comfy_extras/nodes_freelunch.py +++ b/comfy_extras/nodes_freelunch.py @@ -34,7 +34,7 @@ def INPUT_TYPES(s): RETURN_TYPES = ("MODEL",) FUNCTION = "patch" - CATEGORY = "model_patches" + CATEGORY = "model_patches/unet" def patch(self, model, b1, b2, s1, s2): model_channels = model.model.model_config.unet_config["model_channels"] @@ -73,7 +73,7 @@ def INPUT_TYPES(s): RETURN_TYPES = ("MODEL",) FUNCTION = "patch" - CATEGORY = "model_patches" + CATEGORY = "model_patches/unet" def patch(self, model, b1, b2, s1, s2): model_channels = model.model.model_config.unet_config["model_channels"] diff --git a/comfy_extras/nodes_hypertile.py b/comfy_extras/nodes_hypertile.py index ae55d23dd06d..227133f3978e 100644 --- a/comfy_extras/nodes_hypertile.py +++ b/comfy_extras/nodes_hypertile.py @@ -32,7 +32,7 @@ def INPUT_TYPES(s): RETURN_TYPES = ("MODEL",) FUNCTION = "patch" - CATEGORY = "model_patches" + CATEGORY = "model_patches/unet" def patch(self, model, tile_size, swap_size, max_depth, scale_depth): model_channels = model.model.model_config.unet_config["model_channels"] diff --git a/comfy_extras/nodes_pag.py b/comfy_extras/nodes_pag.py index 63f43fd626b1..aec78bd8a9da 100644 --- a/comfy_extras/nodes_pag.py +++ b/comfy_extras/nodes_pag.py @@ -19,7 +19,7 @@ def INPUT_TYPES(s): RETURN_TYPES = ("MODEL",) FUNCTION = "patch" - CATEGORY = "_for_testing" + CATEGORY = "model_patches/unet" def patch(self, model, scale): unet_block = "middle" From 011b11d8d767da3355555fe1253b162f55e985c5 Mon Sep 17 00:00:00 2001 From: bymyself Date: Thu, 18 Jul 2024 18:59:18 -0700 Subject: [PATCH 86/94] LoadAudio restores file value from workflow (#4043) * LoadAudio restores file value from workflow * use onAfterGraphConfigured * Don't use anonnymous function --- web/extensions/core/uploadAudio.js | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/web/extensions/core/uploadAudio.js b/web/extensions/core/uploadAudio.js index 6cc3863a145d..9dfa029bf681 100644 --- a/web/extensions/core/uploadAudio.js +++ b/web/extensions/core/uploadAudio.js @@ -149,6 +149,15 @@ app.registerExtension({ } audioWidget.callback = onAudioWidgetUpdate + // Load saved audio file widget values if restoring from workflow + const onGraphConfigured = node.onGraphConfigured; + node.onGraphConfigured = function() { + onGraphConfigured?.apply(this, arguments) + if (audioWidget.value) { + onAudioWidgetUpdate() + } + } + const fileInput = document.createElement("input") fileInput.type = "file" fileInput.accept = "audio/*" From 6ab8cad22ee376c0a9a506924cca278bb650afcc Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Fri, 19 Jul 2024 17:44:56 -0400 Subject: [PATCH 87/94] Implement beta sampling scheduler. It is based on: https://arxiv.org/abs/2407.12173 Add "beta" to the list of schedulers and the BetaSamplingScheduler node. --- comfy/samplers.py | 18 +++++++++++++++++- comfy_extras/nodes_custom_sampler.py | 20 ++++++++++++++++++++ 2 files changed, 37 insertions(+), 1 deletion(-) diff --git a/comfy/samplers.py b/comfy/samplers.py index bbf9219f7eef..0ab08a4cd9f6 100644 --- a/comfy/samplers.py +++ b/comfy/samplers.py @@ -6,6 +6,8 @@ import math import logging import comfy.sampler_helpers +import scipy +import numpy def get_area_and_mult(conds, x_in, timestep_in): dims = tuple(x_in.shape[2:]) @@ -337,6 +339,18 @@ def normal_scheduler(model_sampling, steps, sgm=False, floor=False): sigs += [0.0] return torch.FloatTensor(sigs) +# Implemented based on: https://arxiv.org/abs/2407.12173 +def beta_scheduler(model_sampling, steps, alpha=0.6, beta=0.6): + total_timesteps = (len(model_sampling.sigmas) - 1) + ts = 1 - numpy.linspace(0, 1, steps, endpoint=False) + ts = numpy.rint(scipy.stats.beta.ppf(ts, alpha, beta) * total_timesteps) + + sigs = [] + for t in ts: + sigs += [float(model_sampling.sigmas[int(t)])] + sigs += [0.0] + return torch.FloatTensor(sigs) + def get_mask_aabb(masks): if masks.numel() == 0: return torch.zeros((0, 4), device=masks.device, dtype=torch.int) @@ -703,7 +717,7 @@ def sample(model, noise, positive, negative, cfg, device, sampler, sigmas, model return cfg_guider.sample(noise, latent_image, sampler, sigmas, denoise_mask, callback, disable_pbar, seed) -SCHEDULER_NAMES = ["normal", "karras", "exponential", "sgm_uniform", "simple", "ddim_uniform"] +SCHEDULER_NAMES = ["normal", "karras", "exponential", "sgm_uniform", "simple", "ddim_uniform", "beta"] SAMPLER_NAMES = KSAMPLER_NAMES + ["ddim", "uni_pc", "uni_pc_bh2"] def calculate_sigmas(model_sampling, scheduler_name, steps): @@ -719,6 +733,8 @@ def calculate_sigmas(model_sampling, scheduler_name, steps): sigmas = ddim_scheduler(model_sampling, steps) elif scheduler_name == "sgm_uniform": sigmas = normal_scheduler(model_sampling, steps, sgm=True) + elif scheduler_name == "beta": + sigmas = beta_scheduler(model_sampling, steps) else: logging.error("error invalid scheduler {}".format(scheduler_name)) return sigmas diff --git a/comfy_extras/nodes_custom_sampler.py b/comfy_extras/nodes_custom_sampler.py index 64a8c06312c7..b7ab88c27cc5 100644 --- a/comfy_extras/nodes_custom_sampler.py +++ b/comfy_extras/nodes_custom_sampler.py @@ -111,6 +111,25 @@ def get_sigmas(self, model, steps, denoise): sigmas = torch.cat([sigmas, sigmas.new_zeros([1])]) return (sigmas, ) +class BetaSamplingScheduler: + @classmethod + def INPUT_TYPES(s): + return {"required": + {"model": ("MODEL",), + "steps": ("INT", {"default": 20, "min": 1, "max": 10000}), + "alpha": ("FLOAT", {"default": 0.6, "min": 0.0, "max": 50.0, "step":0.01, "round": False}), + "beta": ("FLOAT", {"default": 0.6, "min": 0.0, "max": 50.0, "step":0.01, "round": False}), + } + } + RETURN_TYPES = ("SIGMAS",) + CATEGORY = "sampling/custom_sampling/schedulers" + + FUNCTION = "get_sigmas" + + def get_sigmas(self, model, steps, alpha, beta): + sigmas = comfy.samplers.beta_scheduler(model.get_model_object("model_sampling"), steps, alpha=alpha, beta=beta) + return (sigmas, ) + class VPScheduler: @classmethod def INPUT_TYPES(s): @@ -638,6 +657,7 @@ def add_noise(self, model, noise, sigmas, latent_image): "ExponentialScheduler": ExponentialScheduler, "PolyexponentialScheduler": PolyexponentialScheduler, "VPScheduler": VPScheduler, + "BetaSamplingScheduler": BetaSamplingScheduler, "SDTurboScheduler": SDTurboScheduler, "KSamplerSelect": KSamplerSelect, "SamplerEulerAncestral": SamplerEulerAncestral, From 11b74147ee67944c1707b4cc0b4db1cedc73aacc Mon Sep 17 00:00:00 2001 From: Greg Wainer Date: Fri, 19 Jul 2024 17:39:04 -0500 Subject: [PATCH 88/94] Fix/webp exif little endian (#4061) * Fix for isLittleEndian flag in parseExifData. * Add break after reading first exif chunk in getWebpMetadata. --- web/scripts/pnginfo.js | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/web/scripts/pnginfo.js b/web/scripts/pnginfo.js index 2c03cf74a4e3..8b1b2c61c411 100644 --- a/web/scripts/pnginfo.js +++ b/web/scripts/pnginfo.js @@ -49,7 +49,7 @@ export function getPngMetadata(file) { function parseExifData(exifData) { // Check for the correct TIFF header (0x4949 for little-endian or 0x4D4D for big-endian) - const isLittleEndian = new Uint16Array(exifData.slice(0, 2))[0] === 0x4949; + const isLittleEndian = String.fromCharCode(...exifData.slice(0, 2)) === "II"; // Function to read 16-bit and 32-bit integers from binary data function readInt(offset, isLittleEndian, length) { @@ -134,6 +134,7 @@ export function getWebpMetadata(file) { let index = value.indexOf(':'); txt_chunks[value.slice(0, index)] = value.slice(index + 1); } + break; } offset += 8 + chunk_length; From 95fa9545f167ccf4010849c70045a67a8800aa31 Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Sat, 20 Jul 2024 12:27:42 -0400 Subject: [PATCH 89/94] Only append zero to noise schedule if last sigma isn't zero. --- comfy/samplers.py | 20 ++++++++++++++++---- 1 file changed, 16 insertions(+), 4 deletions(-) diff --git a/comfy/samplers.py b/comfy/samplers.py index 0ab08a4cd9f6..3f763381412e 100644 --- a/comfy/samplers.py +++ b/comfy/samplers.py @@ -313,13 +313,18 @@ def simple_scheduler(model_sampling, steps): def ddim_scheduler(model_sampling, steps): s = model_sampling sigs = [] - ss = max(len(s.sigmas) // steps, 1) x = 1 + if math.isclose(float(s.sigmas[x]), 0, abs_tol=0.00001): + steps += 1 + sigs = [] + else: + sigs = [0.0] + + ss = max(len(s.sigmas) // steps, 1) while x < len(s.sigmas): sigs += [float(s.sigmas[x])] x += ss sigs = sigs[::-1] - sigs += [0.0] return torch.FloatTensor(sigs) def normal_scheduler(model_sampling, steps, sgm=False, floor=False): @@ -327,16 +332,23 @@ def normal_scheduler(model_sampling, steps, sgm=False, floor=False): start = s.timestep(s.sigma_max) end = s.timestep(s.sigma_min) + append_zero = True if sgm: timesteps = torch.linspace(start, end, steps + 1)[:-1] else: + if math.isclose(float(s.sigma(end)), 0, abs_tol=0.00001): + steps += 1 + append_zero = False timesteps = torch.linspace(start, end, steps) sigs = [] for x in range(len(timesteps)): ts = timesteps[x] - sigs.append(s.sigma(ts)) - sigs += [0.0] + sigs.append(float(s.sigma(ts))) + + if append_zero: + sigs += [0.0] + return torch.FloatTensor(sigs) # Implemented based on: https://arxiv.org/abs/2407.12173 From 5b69cfe7c343e8672fc350ec35e17f0d046297ca Mon Sep 17 00:00:00 2001 From: Chenlei Hu Date: Sun, 21 Jul 2024 15:29:10 -0400 Subject: [PATCH 90/94] Add timestamp to execution messages (#4076) * Add timestamp to execution messages * Add execution_end message * Rename to execution_success --- execution.py | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/execution.py b/execution.py index 8b3d116c698c..0a2e62e7ec47 100644 --- a/execution.py +++ b/execution.py @@ -3,6 +3,7 @@ import logging import threading import heapq +import time import traceback import inspect from typing import List, Literal, NamedTuple, Optional @@ -283,7 +284,11 @@ def reset(self): self.success = True self.old_prompt = {} - def add_message(self, event, data, broadcast: bool): + def add_message(self, event, data: dict, broadcast: bool): + data = { + **data, + "timestamp": int(time.time() * 1000), + } self.status_messages.append((event, data)) if self.server.client_id is not None or broadcast: self.server.send_sync(event, data, self.server.client_id) @@ -394,6 +399,9 @@ def execute(self, prompt, prompt_id, extra_data={}, execute_outputs=[]): if self.success is not True: self.handle_execution_error(prompt_id, prompt, current_outputs, executed, error, ex) break + else: + # Only execute when the while-loop ends without break + self.add_message("execution_success", { "prompt_id": prompt_id }, broadcast=False) for x in executed: self.old_prompt[x] = copy.deepcopy(prompt[x]) From f836e69346844c65dcf2418346db9a9a9b32a445 Mon Sep 17 00:00:00 2001 From: comfyanonymous Date: Sun, 21 Jul 2024 16:16:45 -0400 Subject: [PATCH 91/94] Fix bug with SaveAudio node with --gpu-only --- comfy_extras/nodes_audio.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/comfy_extras/nodes_audio.py b/comfy_extras/nodes_audio.py index 64d241e988ae..6f0e26365304 100644 --- a/comfy_extras/nodes_audio.py +++ b/comfy_extras/nodes_audio.py @@ -147,7 +147,7 @@ def save_audio(self, audio, filename_prefix="ComfyUI", prompt=None, extra_pnginf for x in extra_pnginfo: metadata[x] = json.dumps(extra_pnginfo[x]) - for (batch_number, waveform) in enumerate(audio["waveform"]): + for (batch_number, waveform) in enumerate(audio["waveform"].cpu()): filename_with_batch_num = filename.replace("%batch_num%", str(batch_number)) file = f"{filename_with_batch_num}_{counter:05}_.flac" From 6045ed31f898e278e4693f2a4e210393fc9153d0 Mon Sep 17 00:00:00 2001 From: Chenlei Hu Date: Sun, 21 Jul 2024 21:15:01 -0400 Subject: [PATCH 92/94] Supress frontend exception on unhandled message type (#4078) * Supress frontend exception on unhandled message type * nit --- web/scripts/api.js | 3 +++ 1 file changed, 3 insertions(+) diff --git a/web/scripts/api.js b/web/scripts/api.js index 39f0a9bb27e7..03c3fb607ec1 100644 --- a/web/scripts/api.js +++ b/web/scripts/api.js @@ -136,6 +136,9 @@ class ComfyApi extends EventTarget { case "execution_start": this.dispatchEvent(new CustomEvent("execution_start", { detail: msg.data })); break; + case "execution_success": + this.dispatchEvent(new CustomEvent("execution_success", { detail: msg.data })); + break; case "execution_error": this.dispatchEvent(new CustomEvent("execution_error", { detail: msg.data })); break; From cf25dc5d2d3658f49286cd1bc0a46bb021d94ae5 Mon Sep 17 00:00:00 2001 From: jsonBackup Date: Wed, 3 Apr 2024 15:56:12 +0200 Subject: [PATCH 93/94] Add safety filter nodes --- .gitignore | 1 - Notebok_workflow_latent_safety.ipynb | 524 ++++++++++++++++++++ Notebok_workflow_safety.ipynb | 391 +++++++++++++++ comfy/clip_model.py | 2 +- custom_nodes/latent_safety_filter.py | 173 +++++++ custom_nodes/safety_filter.py | 155 ++++++ workflow.json | 708 +++++++++++++++++++++++++++ 7 files changed, 1952 insertions(+), 2 deletions(-) create mode 100644 Notebok_workflow_latent_safety.ipynb create mode 100644 Notebok_workflow_safety.ipynb create mode 100644 custom_nodes/latent_safety_filter.py create mode 100644 custom_nodes/safety_filter.py create mode 100644 workflow.json diff --git a/.gitignore b/.gitignore index 5092c98f4631..e479c9ec3abe 100644 --- a/.gitignore +++ b/.gitignore @@ -5,7 +5,6 @@ __pycache__/ !/input/example.png /models/ /temp/ -/custom_nodes/ !custom_nodes/example_node.py.example extra_model_paths.yaml /.vs diff --git a/Notebok_workflow_latent_safety.ipynb b/Notebok_workflow_latent_safety.ipynb new file mode 100644 index 000000000000..b92f584be517 --- /dev/null +++ b/Notebok_workflow_latent_safety.ipynb @@ -0,0 +1,524 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "2f86b673-a26f-48fd-a04f-c0ff2bc385b7", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Total VRAM 40337 MB, total RAM 515700 MB\n", + "Set vram state to: NORMAL_VRAM\n", + "Device: cuda:0 NVIDIA A100-SXM4-40GB : native\n", + "VAE dtype: torch.bfloat16\n", + "Using pytorch cross attention\n" + ] + } + ], + "source": [ + "import os\n", + "import nodes\n", + "import torch\n", + "import random\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from comfy import sd\n", + "from PIL import Image\n", + "\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "b470182c-87d2-44b4-bfe7-0f76ca96b2f9", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "model_type EPS\n", + "Using pytorch attention in VAE\n", + "Using pytorch attention in VAE\n", + "clip missing: ['clip_l.logit_scale', 'clip_l.transformer.text_projection.weight']\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(, , , None)\n", + "None\n", + "(, , , None)\n", + "\n" + ] + } + ], + "source": [ + "#CheckpointLoader\n", + "\n", + "ckpt_path = \"/dlabscratch1/wendler/models/sdxl-turbo/sd_xl_turbo_1.0_fp16.safetensors\"#folder_paths.get_full_path(\"checkpoints\", ckpt_name)\n", + "out = sd.load_checkpoint_guess_config(ckpt_path, output_vae=True, output_clip=True, output_clipvision=True, embedding_directory=\"./embeddings\")\n", + "(model, clip, vae, clip_vision) = out\n", + "\n", + "print(out)\n", + "print(clip_vision)\n", + "print(out)\n", + "print(model)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "05848252-f0cf-424d-b71f-32c055eab33f", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Requested to load SDXLClipModel\n", + "Loading 1 new model\n" + ] + } + ], + "source": [ + "# CLIP Text Encode\n", + "\n", + "text = \"dog\"\n", + "tokens = clip.tokenize(text)\n", + "cond, pooled = clip.encode_from_tokens(tokens, return_pooled=True)\n", + "positive = [[cond, {\"pooled_output\": pooled}]]\n", + "\n", + "text = \"text, watermark\"\n", + "tokens = clip.tokenize(text)\n", + "cond, pooled = clip.encode_from_tokens(tokens, return_pooled=True)\n", + "negative = [[cond, {\"pooled_output\": pooled}]]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "86b23ca2-adff-4b96-97e2-6be243988ce7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([1, 1280])\n", + "torch.Size([1, 77, 2048])\n" + ] + } + ], + "source": [ + "print(pooled.shape)\n", + "print(cond.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "4e48771d-b95c-4f7c-b78e-6ecf336981cf", + "metadata": {}, + "outputs": [], + "source": [ + "# Empty Latent Image\n", + "\n", + "batch_size = 2\n", + "height, width = 512, 512\n", + "\n", + "latent = torch.zeros([batch_size, 4, height // 8, width // 8], device=device)\n", + "latent_image = {\"samples\":latent}" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "8c7fba7c-2d8c-4415-b05b-3af4104f577f", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Requested to load SDXL\n", + "Loading 1 new model\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "06efdf75794b48888eb0665a7c3baa7c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/30 [00:00)\n", + "torch.Size([2, 640])\n", + "Similarity (text, watermark):\t[[0.16905537 0.1504263 ]\n", + " [0.15587994 0.13815394]]\n" + ] + } + ], + "source": [ + "image_features = model_latent.encode_image(samples[\"samples\"])\n", + "\n", + "sensitive_word = \"cat\"\n", + "text_features = model_latent.encode_text(tokenizer_latent([f\"an image of {sensitive_word}\", f\"an image of no {sensitive_word}\"]))\n", + "print(image_features.shape)\n", + "image_features /= image_features.norm(dim=-1, keepdim=True)\n", + "text_features /= text_features.norm(dim=-1, keepdim=True)\n", + "\n", + "text_probs = (100.0 * image_features @ text_features.T).softmax(dim=-1)\n", + "\n", + "print(text_probs[0][0].item())\n", + "print(text_probs)\n", + "#text_features = model_latent.encode_text(captions.cuda())\n", + "print(image_features.shape)\n", + "image_features_np = image_features.detach().numpy()\n", + "text_features_np = text_features.detach().numpy()\n", + "\n", + "similarity_score = cosine_similarity(image_features_np, text_features_np)\n", + "print(f\"Similarity ({text}):\\t{similarity_score}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "34a80f73-1a07-42f7-826d-1497ddf28d19", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Requested to load AutoencoderKL\n", + "Loading 1 new model\n" + ] + } + ], + "source": [ + "# VAE Decode\n", + "\n", + "images = vae.decode(samples[\"samples\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "6618356a-7836-4855-99c2-5f4d3f585afa", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Save Image\n", + "\n", + "#filename_prefix += self.prefix_append\n", + "#full_output_folder, filename, counter, subfolder, filename_prefix = folder_paths.get_save_image_path(filename_prefix, self.output_dir, images[0].shape[1], images[0].shape[0])\n", + "results = list()\n", + "for (batch_number, image) in enumerate(images):\n", + " i = 255. * image.detach().numpy()\n", + " img = Image.fromarray(np.clip(i, 0, 255).astype(np.uint8))\n", + " metadata = None\n", + " \"\"\"\n", + " if not args.disable_metadata:\n", + " metadata = PngInfo()\n", + " if prompt is not None:\n", + " metadata.add_text(\"prompt\", json.dumps(prompt))\n", + " if extra_pnginfo is not None:\n", + " for x in extra_pnginfo:\n", + " metadata.add_text(x, json.dumps(extra_pnginfo[x]))\n", + " filename_with_batch_num = filename.replace(\"%batch_num%\", str(batch_number))\n", + " file = f\"{filename_with_batch_num}_{counter:05}_.png\"\n", + " img.save(os.path.join(full_output_folder, file), pnginfo=metadata, compress_level=self.compress_level)\n", + " results.append({\n", + " \"filename\": file,\n", + " \"subfolder\": subfolder,\n", + " \"type\": self.type\n", + " })\n", + " counter += 1\n", + " \"\"\"\n", + " plt.imshow(img)\n", + " plt.axis('off') # Turn off axis\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "01cda7fe-7b66-4810-9d9c-baccec11d497", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Similarity (cat):\t0.12320650368928909\n", + "Similarity (no cat):\t0.1302909255027771\n", + "tensor([[1.]], device='cuda:0', grad_fn=)\n", + "tensor([[12.3207]], device='cuda:0', grad_fn=)\n" + ] + } + ], + "source": [ + "# Safety Filter\n", + "\n", + "import requests\n", + "from transformers import CLIPProcessor, CLIPModel, CLIPTokenizer\n", + "from sklearn.metrics.pairwise import cosine_similarity\n", + "\n", + "def get_model_info(model_ID, device):\n", + "\tmodel = CLIPModel.from_pretrained(model_ID).to(device)\n", + "\tprocessor = CLIPProcessor.from_pretrained(model_ID)\n", + "\ttokenizer = CLIPTokenizer.from_pretrained(model_ID)\n", + "\treturn model, processor, tokenizer\n", + "\n", + "def get_single_text_embedding(text): \n", + " inputs = tokenizer(text, return_tensors = \"pt\").to(device)\n", + " text_embeddings = model_clip.get_text_features(**inputs)\n", + " embedding_as_np = text_embeddings.cpu().detach().numpy()\n", + " return embedding_as_np\n", + "\n", + "def get_single_image_embedding(my_image):\n", + " image = processor(\n", + " \t\ttext = None,\n", + " \t\timages = my_image,\n", + " \t\treturn_tensors=\"pt\"\n", + " \t\t)[\"pixel_values\"].to(device)\n", + " embedding = model_clip.get_image_features(image)\n", + " embedding_as_np = embedding.cpu().detach().numpy()\n", + " return embedding_as_np\n", + " \n", + "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "\n", + "model_IDs = [\"openai/clip-vit-base-patch32\", \"openai/clip-vit-large-patch14\"]\n", + "model_ID = model_IDs[1]\n", + "model_clip, processor, tokenizer = get_model_info(model_ID, device)\n", + "\n", + "#url = \"http://images.cocodataset.org/val2017/000000039769.jpg\"\n", + "image = img #Image.open(requests.get(url, stream=True).raw)\n", + "image_embedding = get_single_image_embedding(image)\n", + "\n", + "texts=[\"cat\", \"no cat\"]\n", + "\n", + "for text in texts:\n", + " text_embedding = get_single_text_embedding(text)\n", + " similarity_score = cosine_similarity(image_embedding, text_embedding)[0][0]\n", + " print(f\"Similarity ({text}):\\t{similarity_score}\")\n", + "\n", + "inputs = processor(text=\"cat\", images=image, return_tensors=\"pt\", padding=True).to(device)\n", + "outputs = model_clip(**inputs)\n", + "\n", + "logits_per_image = outputs.logits_per_image # this is the image-text similarity score\n", + "probs = logits_per_image.softmax(dim=1) # we can take the softmax to get the label probabilities\n", + "\n", + "print(probs)\n", + "print(logits_per_image)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "8eecba77-0617-4e9b-8f65-7e16b78782b1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "12.32065200805664" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "logits_per_image.item()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "ca4d6d49-bfeb-4275-a573-7eccc8ac6bf0", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/dlabscratch1/jabecker/conda/envs/test_env/lib/python3.11/site-packages/diffusers/utils/outputs.py:63: UserWarning: torch.utils._pytree._register_pytree_node is deprecated. Please use torch.utils._pytree.register_pytree_node instead.\n", + " torch.utils._pytree._register_pytree_node(\n", + "/dlabscratch1/jabecker/conda/envs/test_env/lib/python3.11/site-packages/diffusers/pipelines/pipeline_utils.py:761: FutureWarning: `torch_dtype` is deprecated and will be removed in version 0.25.0. \n", + " deprecate(\"torch_dtype\", \"0.25.0\", \"\")\n" + ] + }, + { + "ename": "OutOfMemoryError", + "evalue": "CUDA out of memory. Tried to allocate 20.00 MiB. GPU 0 has a total capacity of 39.39 GiB of which 81.50 MiB is free. Process 2457010 has 19.18 GiB memory in use. Process 2464208 has 20.13 GiB memory in use. Of the allocated memory 19.37 GiB is allocated by PyTorch, and 246.71 MiB is reserved by PyTorch but unallocated. If reserved but unallocated memory is large try setting PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True to avoid fragmentation. See documentation for Memory Management (https://pytorch.org/docs/stable/notes/cuda.html#environment-variables)", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mOutOfMemoryError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[13], line 7\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mtorch\u001b[39;00m\n\u001b[1;32m 4\u001b[0m pipeline \u001b[38;5;241m=\u001b[39m StableDiffusionXLPipeline\u001b[38;5;241m.\u001b[39mfrom_single_file(\n\u001b[1;32m 5\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m/dlabscratch1/wendler/models/sdxl-turbo/sd_xl_turbo_1.0.safetensors\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[1;32m 6\u001b[0m torch_dtype\u001b[38;5;241m=\u001b[39mtorch\u001b[38;5;241m.\u001b[39mfloat16, variant\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mfp16\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m----> 7\u001b[0m pipeline \u001b[38;5;241m=\u001b[39m pipeline\u001b[38;5;241m.\u001b[39mto(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcuda\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 8\u001b[0m pipeline\u001b[38;5;241m.\u001b[39mscheduler \u001b[38;5;241m=\u001b[39m EulerAncestralDiscreteScheduler\u001b[38;5;241m.\u001b[39mfrom_config(pipeline\u001b[38;5;241m.\u001b[39mscheduler\u001b[38;5;241m.\u001b[39mconfig, timestep_spacing\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mtrailing\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", + "File \u001b[0;32m/dlabscratch1/jabecker/conda/envs/test_env/lib/python3.11/site-packages/diffusers/pipelines/pipeline_utils.py:864\u001b[0m, in \u001b[0;36mDiffusionPipeline.to\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 860\u001b[0m logger\u001b[38;5;241m.\u001b[39mwarning(\n\u001b[1;32m 861\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mThe module \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mmodule\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__class__\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__name__\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m has been loaded in 8bit and moving it to \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mtorch_dtype\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m via `.to()` is not yet supported. Module is still on \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mmodule\u001b[38;5;241m.\u001b[39mdevice\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 862\u001b[0m )\n\u001b[1;32m 863\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 864\u001b[0m module\u001b[38;5;241m.\u001b[39mto(device, dtype)\n\u001b[1;32m 866\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m (\n\u001b[1;32m 867\u001b[0m module\u001b[38;5;241m.\u001b[39mdtype \u001b[38;5;241m==\u001b[39m torch\u001b[38;5;241m.\u001b[39mfloat16\n\u001b[1;32m 868\u001b[0m \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mstr\u001b[39m(device) \u001b[38;5;129;01min\u001b[39;00m [\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcpu\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n\u001b[1;32m 869\u001b[0m \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m silence_dtype_warnings\n\u001b[1;32m 870\u001b[0m \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m is_offloaded\n\u001b[1;32m 871\u001b[0m ):\n\u001b[1;32m 872\u001b[0m logger\u001b[38;5;241m.\u001b[39mwarning(\n\u001b[1;32m 873\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mPipelines loaded with `dtype=torch.float16` cannot run with `cpu` device. It\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 874\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m is not recommended to move them to `cpu` as running them will fail. Please make\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 877\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m `torch_dtype=torch.float16` argument, or use another device for inference.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 878\u001b[0m )\n", + "File \u001b[0;32m/dlabscratch1/jabecker/conda/envs/test_env/lib/python3.11/site-packages/torch/nn/modules/module.py:1152\u001b[0m, in \u001b[0;36mModule.to\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1148\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m t\u001b[38;5;241m.\u001b[39mto(device, dtype \u001b[38;5;28;01mif\u001b[39;00m t\u001b[38;5;241m.\u001b[39mis_floating_point() \u001b[38;5;129;01mor\u001b[39;00m t\u001b[38;5;241m.\u001b[39mis_complex() \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[1;32m 1149\u001b[0m non_blocking, memory_format\u001b[38;5;241m=\u001b[39mconvert_to_format)\n\u001b[1;32m 1150\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m t\u001b[38;5;241m.\u001b[39mto(device, dtype \u001b[38;5;28;01mif\u001b[39;00m t\u001b[38;5;241m.\u001b[39mis_floating_point() \u001b[38;5;129;01mor\u001b[39;00m t\u001b[38;5;241m.\u001b[39mis_complex() \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m, non_blocking)\n\u001b[0;32m-> 1152\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_apply(convert)\n", + "File \u001b[0;32m/dlabscratch1/jabecker/conda/envs/test_env/lib/python3.11/site-packages/torch/nn/modules/module.py:802\u001b[0m, in \u001b[0;36mModule._apply\u001b[0;34m(self, fn, recurse)\u001b[0m\n\u001b[1;32m 800\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m recurse:\n\u001b[1;32m 801\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m module \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mchildren():\n\u001b[0;32m--> 802\u001b[0m module\u001b[38;5;241m.\u001b[39m_apply(fn)\n\u001b[1;32m 804\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcompute_should_use_set_data\u001b[39m(tensor, tensor_applied):\n\u001b[1;32m 805\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m torch\u001b[38;5;241m.\u001b[39m_has_compatible_shallow_copy_type(tensor, tensor_applied):\n\u001b[1;32m 806\u001b[0m \u001b[38;5;66;03m# If the new tensor has compatible tensor type as the existing tensor,\u001b[39;00m\n\u001b[1;32m 807\u001b[0m \u001b[38;5;66;03m# the current behavior is to change the tensor in-place using `.data =`,\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 812\u001b[0m \u001b[38;5;66;03m# global flag to let the user control whether they want the future\u001b[39;00m\n\u001b[1;32m 813\u001b[0m \u001b[38;5;66;03m# behavior of overwriting the existing tensor or not.\u001b[39;00m\n", + "File \u001b[0;32m/dlabscratch1/jabecker/conda/envs/test_env/lib/python3.11/site-packages/torch/nn/modules/module.py:802\u001b[0m, in \u001b[0;36mModule._apply\u001b[0;34m(self, fn, recurse)\u001b[0m\n\u001b[1;32m 800\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m recurse:\n\u001b[1;32m 801\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m module \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mchildren():\n\u001b[0;32m--> 802\u001b[0m module\u001b[38;5;241m.\u001b[39m_apply(fn)\n\u001b[1;32m 804\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcompute_should_use_set_data\u001b[39m(tensor, tensor_applied):\n\u001b[1;32m 805\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m torch\u001b[38;5;241m.\u001b[39m_has_compatible_shallow_copy_type(tensor, tensor_applied):\n\u001b[1;32m 806\u001b[0m \u001b[38;5;66;03m# If the new tensor has compatible tensor type as the existing tensor,\u001b[39;00m\n\u001b[1;32m 807\u001b[0m \u001b[38;5;66;03m# the current behavior is to change the tensor in-place using `.data =`,\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 812\u001b[0m \u001b[38;5;66;03m# global flag to let the user control whether they want the future\u001b[39;00m\n\u001b[1;32m 813\u001b[0m \u001b[38;5;66;03m# behavior of overwriting the existing tensor or not.\u001b[39;00m\n", + " \u001b[0;31m[... skipping similar frames: Module._apply at line 802 (6 times)]\u001b[0m\n", + "File \u001b[0;32m/dlabscratch1/jabecker/conda/envs/test_env/lib/python3.11/site-packages/torch/nn/modules/module.py:802\u001b[0m, in \u001b[0;36mModule._apply\u001b[0;34m(self, fn, recurse)\u001b[0m\n\u001b[1;32m 800\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m recurse:\n\u001b[1;32m 801\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m module \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mchildren():\n\u001b[0;32m--> 802\u001b[0m module\u001b[38;5;241m.\u001b[39m_apply(fn)\n\u001b[1;32m 804\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcompute_should_use_set_data\u001b[39m(tensor, tensor_applied):\n\u001b[1;32m 805\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m torch\u001b[38;5;241m.\u001b[39m_has_compatible_shallow_copy_type(tensor, tensor_applied):\n\u001b[1;32m 806\u001b[0m \u001b[38;5;66;03m# If the new tensor has compatible tensor type as the existing tensor,\u001b[39;00m\n\u001b[1;32m 807\u001b[0m \u001b[38;5;66;03m# the current behavior is to change the tensor in-place using `.data =`,\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 812\u001b[0m \u001b[38;5;66;03m# global flag to let the user control whether they want the future\u001b[39;00m\n\u001b[1;32m 813\u001b[0m \u001b[38;5;66;03m# behavior of overwriting the existing tensor or not.\u001b[39;00m\n", + "File \u001b[0;32m/dlabscratch1/jabecker/conda/envs/test_env/lib/python3.11/site-packages/torch/nn/modules/module.py:825\u001b[0m, in \u001b[0;36mModule._apply\u001b[0;34m(self, fn, recurse)\u001b[0m\n\u001b[1;32m 821\u001b[0m \u001b[38;5;66;03m# Tensors stored in modules are graph leaves, and we don't want to\u001b[39;00m\n\u001b[1;32m 822\u001b[0m \u001b[38;5;66;03m# track autograd history of `param_applied`, so we have to use\u001b[39;00m\n\u001b[1;32m 823\u001b[0m \u001b[38;5;66;03m# `with torch.no_grad():`\u001b[39;00m\n\u001b[1;32m 824\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m torch\u001b[38;5;241m.\u001b[39mno_grad():\n\u001b[0;32m--> 825\u001b[0m param_applied \u001b[38;5;241m=\u001b[39m fn(param)\n\u001b[1;32m 826\u001b[0m should_use_set_data \u001b[38;5;241m=\u001b[39m compute_should_use_set_data(param, param_applied)\n\u001b[1;32m 827\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m should_use_set_data:\n", + "File \u001b[0;32m/dlabscratch1/jabecker/conda/envs/test_env/lib/python3.11/site-packages/torch/nn/modules/module.py:1150\u001b[0m, in \u001b[0;36mModule.to..convert\u001b[0;34m(t)\u001b[0m\n\u001b[1;32m 1147\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m convert_to_format \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mand\u001b[39;00m t\u001b[38;5;241m.\u001b[39mdim() \u001b[38;5;129;01min\u001b[39;00m (\u001b[38;5;241m4\u001b[39m, \u001b[38;5;241m5\u001b[39m):\n\u001b[1;32m 1148\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m t\u001b[38;5;241m.\u001b[39mto(device, dtype \u001b[38;5;28;01mif\u001b[39;00m t\u001b[38;5;241m.\u001b[39mis_floating_point() \u001b[38;5;129;01mor\u001b[39;00m t\u001b[38;5;241m.\u001b[39mis_complex() \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[1;32m 1149\u001b[0m non_blocking, memory_format\u001b[38;5;241m=\u001b[39mconvert_to_format)\n\u001b[0;32m-> 1150\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m t\u001b[38;5;241m.\u001b[39mto(device, dtype \u001b[38;5;28;01mif\u001b[39;00m t\u001b[38;5;241m.\u001b[39mis_floating_point() \u001b[38;5;129;01mor\u001b[39;00m t\u001b[38;5;241m.\u001b[39mis_complex() \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m, non_blocking)\n", + "\u001b[0;31mOutOfMemoryError\u001b[0m: CUDA out of memory. Tried to allocate 20.00 MiB. GPU 0 has a total capacity of 39.39 GiB of which 81.50 MiB is free. Process 2457010 has 19.18 GiB memory in use. Process 2464208 has 20.13 GiB memory in use. Of the allocated memory 19.37 GiB is allocated by PyTorch, and 246.71 MiB is reserved by PyTorch but unallocated. If reserved but unallocated memory is large try setting PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True to avoid fragmentation. See documentation for Memory Management (https://pytorch.org/docs/stable/notes/cuda.html#environment-variables)" + ] + } + ], + "source": [ + "from diffusers import StableDiffusionXLPipeline, EulerAncestralDiscreteScheduler\n", + "import torch\n", + "\n", + "pipeline = StableDiffusionXLPipeline.from_single_file(\n", + " \"/dlabscratch1/wendler/models/sdxl-turbo/sd_xl_turbo_1.0.safetensors\",\n", + " torch_dtype=torch.float16, variant=\"fp16\")\n", + "pipeline = pipeline.to(\"cuda\")\n", + "pipeline.scheduler = EulerAncestralDiscreteScheduler.from_config(pipeline.scheduler.config, timestep_spacing=\"trailing\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3e4bae4d-e5a3-49af-ad58-a461d8e9f59c", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Notebok_workflow_safety.ipynb b/Notebok_workflow_safety.ipynb new file mode 100644 index 000000000000..abdf3178f682 --- /dev/null +++ b/Notebok_workflow_safety.ipynb @@ -0,0 +1,391 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "2f86b673-a26f-48fd-a04f-c0ff2bc385b7", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Total VRAM 40337 MB, total RAM 515700 MB\n", + "Set vram state to: NORMAL_VRAM\n", + "Device: cuda:0 NVIDIA A100-SXM4-40GB : native\n", + "VAE dtype: torch.bfloat16\n", + "Using pytorch cross attention\n" + ] + } + ], + "source": [ + "import os\n", + "import nodes\n", + "import torch\n", + "import random\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from comfy import sd\n", + "from PIL import Image\n", + "\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "b470182c-87d2-44b4-bfe7-0f76ca96b2f9", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "model_type EPS\n", + "Using pytorch attention in VAE\n", + "Using pytorch attention in VAE\n", + "clip missing: ['clip_l.logit_scale', 'clip_l.transformer.text_projection.weight']\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(, , , None)\n", + "None\n", + "(, , , None)\n", + "\n" + ] + } + ], + "source": [ + "ckpt_path = \"/dlabscratch1/wendler/models/sdxl-turbo/sd_xl_turbo_1.0_fp16.safetensors\"#folder_paths.get_full_path(\"checkpoints\", ckpt_name)\n", + "out = sd.load_checkpoint_guess_config(ckpt_path, output_vae=True, output_clip=True, output_clipvision=True, embedding_directory=\"./embeddings\")\n", + "(model, clip, vae, clip_vision) = out\n", + "\n", + "print(out)\n", + "print(clip_vision)\n", + "print(out)\n", + "print(model)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "05848252-f0cf-424d-b71f-32c055eab33f", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Requested to load SDXLClipModel\n", + "Loading 1 new model\n" + ] + } + ], + "source": [ + "text = \"cat\"\n", + "tokens = clip.tokenize(text)\n", + "cond, pooled = clip.encode_from_tokens(tokens, return_pooled=True)\n", + "positive = [[cond, {\"pooled_output\": pooled}]]\n", + "\n", + "text = \"text, watermark\"\n", + "tokens = clip.tokenize(text)\n", + "cond, pooled = clip.encode_from_tokens(tokens, return_pooled=True)\n", + "negative = [[cond, {\"pooled_output\": pooled}]]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "86b23ca2-adff-4b96-97e2-6be243988ce7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([1, 1280])\n", + "torch.Size([1, 77, 2048])\n" + ] + } + ], + "source": [ + "print(pooled.shape)\n", + "print(cond.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "4e48771d-b95c-4f7c-b78e-6ecf336981cf", + "metadata": {}, + "outputs": [], + "source": [ + "batch_size = 1\n", + "height, width = 512, 512\n", + "\n", + "latent = torch.zeros([batch_size, 4, height // 8, width // 8], device=device)\n", + "latent_image = {\"samples\":latent}" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "8c7fba7c-2d8c-4415-b05b-3af4104f577f", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Requested to load SDXL\n", + "Loading 1 new model\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "bb36109d812e403eb9642ed558c7698c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/30 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#filename_prefix += self.prefix_append\n", + "#full_output_folder, filename, counter, subfolder, filename_prefix = folder_paths.get_save_image_path(filename_prefix, self.output_dir, images[0].shape[1], images[0].shape[0])\n", + "results = list()\n", + "for (batch_number, image) in enumerate(images):\n", + " i = 255. * image.detach().numpy()\n", + " img = Image.fromarray(np.clip(i, 0, 255).astype(np.uint8))\n", + " metadata = None\n", + " \"\"\"\n", + " if not args.disable_metadata:\n", + " metadata = PngInfo()\n", + " if prompt is not None:\n", + " metadata.add_text(\"prompt\", json.dumps(prompt))\n", + " if extra_pnginfo is not None:\n", + " for x in extra_pnginfo:\n", + " metadata.add_text(x, json.dumps(extra_pnginfo[x]))\n", + " filename_with_batch_num = filename.replace(\"%batch_num%\", str(batch_number))\n", + " file = f\"{filename_with_batch_num}_{counter:05}_.png\"\n", + " img.save(os.path.join(full_output_folder, file), pnginfo=metadata, compress_level=self.compress_level)\n", + " results.append({\n", + " \"filename\": file,\n", + " \"subfolder\": subfolder,\n", + " \"type\": self.type\n", + " })\n", + " counter += 1\n", + " \"\"\"\n", + " plt.imshow(img)\n", + " plt.axis('off') # Turn off axis\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "01cda7fe-7b66-4810-9d9c-baccec11d497", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Similarity (cat):\t0.19083161652088165\n", + "Similarity (no cat):\t0.176759272813797\n", + "tensor([[1.]], device='cuda:0', grad_fn=)\n", + "tensor([[19.0832]], device='cuda:0', grad_fn=)\n" + ] + } + ], + "source": [ + "import requests\n", + "from transformers import CLIPProcessor, CLIPModel, CLIPTokenizer\n", + "from sklearn.metrics.pairwise import cosine_similarity\n", + "\n", + "def get_model_info(model_ID, device):\n", + "\tmodel = CLIPModel.from_pretrained(model_ID).to(device)\n", + "\tprocessor = CLIPProcessor.from_pretrained(model_ID)\n", + "\ttokenizer = CLIPTokenizer.from_pretrained(model_ID)\n", + "\treturn model, processor, tokenizer\n", + "\n", + "def get_single_text_embedding(text): \n", + " inputs = tokenizer(text, return_tensors = \"pt\").to(device)\n", + " text_embeddings = model_clip.get_text_features(**inputs)\n", + " embedding_as_np = text_embeddings.cpu().detach().numpy()\n", + " return embedding_as_np\n", + "\n", + "def get_single_image_embedding(my_image):\n", + " image = processor(\n", + " \t\ttext = None,\n", + " \t\timages = my_image,\n", + " \t\treturn_tensors=\"pt\"\n", + " \t\t)[\"pixel_values\"].to(device)\n", + " embedding = model_clip.get_image_features(image)\n", + " embedding_as_np = embedding.cpu().detach().numpy()\n", + " return embedding_as_np\n", + " \n", + "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "\n", + "model_IDs = [\"openai/clip-vit-base-patch32\", \"openai/clip-vit-large-patch14\"]\n", + "model_ID = model_IDs[1]\n", + "model_clip, processor, tokenizer = get_model_info(model_ID, device)\n", + "\n", + "#url = \"http://images.cocodataset.org/val2017/000000039769.jpg\"\n", + "image = img #Image.open(requests.get(url, stream=True).raw)\n", + "image_embedding = get_single_image_embedding(image)\n", + "\n", + "texts=[\"cat\", \"no cat\"]\n", + "\n", + "for text in texts:\n", + " text_embedding = get_single_text_embedding(text)\n", + " similarity_score = cosine_similarity(image_embedding, text_embedding)[0][0]\n", + " print(f\"Similarity ({text}):\\t{similarity_score}\")\n", + "\n", + "\n", + "inputs = processor(text=\"cat\", images=image, return_tensors=\"pt\", padding=True).to(device)\n", + "outputs = model_clip(**inputs)\n", + "\n", + "logits_per_image = outputs.logits_per_image # this is the image-text similarity score\n", + "probs = logits_per_image.softmax(dim=1) # we can take the softmax to get the label probabilities\n", + "\n", + "print(probs)\n", + "print(logits_per_image)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "8eecba77-0617-4e9b-8f65-7e16b78782b1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "19.083162307739258" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "logits_per_image.item()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "ca4d6d49-bfeb-4275-a573-7eccc8ac6bf0", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/dlabscratch1/jabecker/conda/envs/test_env/lib/python3.11/site-packages/diffusers/utils/outputs.py:63: UserWarning: torch.utils._pytree._register_pytree_node is deprecated. Please use torch.utils._pytree.register_pytree_node instead.\n", + " torch.utils._pytree._register_pytree_node(\n", + "/dlabscratch1/jabecker/conda/envs/test_env/lib/python3.11/site-packages/diffusers/pipelines/pipeline_utils.py:761: FutureWarning: `torch_dtype` is deprecated and will be removed in version 0.25.0. \n", + " deprecate(\"torch_dtype\", \"0.25.0\", \"\")\n" + ] + } + ], + "source": [ + "from diffusers import StableDiffusionXLPipeline, EulerAncestralDiscreteScheduler\n", + "import torch\n", + "\n", + "pipeline = StableDiffusionXLPipeline.from_single_file(\n", + " \"/dlabscratch1/wendler/models/sdxl-turbo/sd_xl_turbo_1.0.safetensors\",\n", + " torch_dtype=torch.float16, variant=\"fp16\")\n", + "pipeline = pipeline.to(\"cuda\")\n", + "pipeline.scheduler = EulerAncestralDiscreteScheduler.from_config(pipeline.scheduler.config, timestep_spacing=\"trailing\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3e4bae4d-e5a3-49af-ad58-a461d8e9f59c", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/comfy/clip_model.py b/comfy/clip_model.py index 14f43c5687cb..8bfe504f2900 100644 --- a/comfy/clip_model.py +++ b/comfy/clip_model.py @@ -121,7 +121,7 @@ def __init__(self, config_dict, dtype, device, operations): self.text_model = CLIPTextModel_(config_dict, dtype, device, operations) embed_dim = config_dict["hidden_size"] self.text_projection = operations.Linear(embed_dim, embed_dim, bias=False, dtype=dtype, device=device) - self.text_projection.weight.copy_(torch.eye(embed_dim)) + self.text_projection.weight.data.copy_(torch.eye(embed_dim)) self.dtype = dtype def get_input_embeddings(self): diff --git a/custom_nodes/latent_safety_filter.py b/custom_nodes/latent_safety_filter.py new file mode 100644 index 000000000000..26b05028e22e --- /dev/null +++ b/custom_nodes/latent_safety_filter.py @@ -0,0 +1,173 @@ +from transformers import CLIPProcessor, CLIPModel, CLIPTokenizer +from sklearn.metrics.pairwise import cosine_similarity +import torch +import open_clip + +class LatentSafetyFilter: + """ + A example node + + Class methods + ------------- + INPUT_TYPES (dict): + Tell the main program input parameters of nodes. + IS_CHANGED: + optional method to control when the node is re executed. + + Attributes + ---------- + RETURN_TYPES (`tuple`): + The type of each element in the output tulple. + RETURN_NAMES (`tuple`): + Optional: The name of each output in the output tulple. + FUNCTION (`str`): + The name of the entry-point method. For example, if `FUNCTION = "execute"` then it will run Example().execute() + OUTPUT_NODE ([`bool`]): + If this node is an output node that outputs a result/image from the graph. The SaveImage node is an example. + The backend iterates on these output nodes and tries to execute all their parents if their parent graph is properly connected. + Assumed to be False if not present. + CATEGORY (`str`): + The category the node should appear in the UI. + execute(s) -> tuple || None: + The entry point method. The name of this method must be the same as the value of property `FUNCTION`. + For example, if `FUNCTION = "execute"` then this method's name must be `execute`, if `FUNCTION = "foo"` then it must be `foo`. + """ + def __init__(self): + pass + + @classmethod + def INPUT_TYPES(s): + """ + Return a dictionary which contains config for all input fields. + Some types (string): "MODEL", "VAE", "CLIP", "CONDITIONING", "LATENT", "IMAGE", "INT", "STRING", "FLOAT". + Input types "INT", "STRING" or "FLOAT" are special values for fields on the node. + The type can be a list for selection. + + Returns: `dict`: + - Key input_fields_group (`string`): Can be either required, hidden or optional. A node class must have property `required` + - Value input_fields (`dict`): Contains input fields config: + * Key field_name (`string`): Name of a entry-point method's argument + * Value field_config (`tuple`): + + First value is a string indicate the type of field or a list for selection. + + Secound value is a config for type "INT", "STRING" or "FLOAT". + """ + return { + "required": { + "samples": ("LATENT", ), + "safety_filter": ("STRING", { + "multiline": False, #True if you want the field to look like the one on the ClipTextEncode node + "default": "nsfw" + }), + "threshold": ("FLOAT", { + "default": 0.2, + "min": 0.0, + "max": 1.0, + "step": 0.01, + "round": 0.001, #The value represeting the precision to round to, will be set to the step value by default. Can be set to False to disable rounding. + "display": "number"}), + "int_field": ("INT", { + "default": 0, + "min": 0, #Minimum value + "max": 4096, #Maximum value + "step": 64, #Slider's step + "display": "number" # Cosmetic only: display as "number" or "slider" + }), + "print_to_screen": (["enable", "disable"],), + }, + } + + RETURN_TYPES = ("LATENT",) + #RETURN_NAMES = ("image_output_name",) + + FUNCTION = "test" + + #OUTPUT_NODE = False + + CATEGORY = "Safety" + + def get_model_info(self, model_ID, device): + model = CLIPModel.from_pretrained(model_ID).to(device) + processor = CLIPProcessor.from_pretrained(model_ID) + tokenizer = CLIPTokenizer.from_pretrained(model_ID) + return model, processor, tokenizer + + def test(self, samples, safety_filter, int_field, threshold, print_to_screen): + models = {'B-8': {'model_name':'Latent-ViT-B-8-512', + 'pretrained':'/dlabdata1/wendler/models/latent-clip-b-8.pt'}, + 'B-4-plus':{'model_name':'Latent-ViT-B-4-512-plus', + 'pretrained':'/dlabdata1/wendler/models/latent-clip-b-4-plus.pt'}} + size = 'B-4-plus' + model_name = models[size]['model_name'] + pretrained = models[size]['pretrained'] + model_latent, _, preprocess = open_clip.create_model_and_transforms(model_name, pretrained=pretrained) + tokenizer_latent = open_clip.get_tokenizer(model_name) + + image_features = model_latent.encode_image(samples["samples"]) + text_features = model_latent.encode_text(tokenizer_latent([f"an image of {safety_filter}", f"an image of no {safety_filter}"])) + + image_features /= image_features.norm(dim=-1, keepdim=True) + text_features /= text_features.norm(dim=-1, keepdim=True) + + text_probs = (100.0 * image_features @ text_features.T).softmax(dim=-1) + print(text_probs) + + for i, sample in enumerate(samples["samples"]): + + + if text_probs[i][0].item() > threshold: + samples["samples"][i].zero_() + print("Sample", i, "processed: Set to zero") + else: + print("Sample", i, "processed: Not set to zero") + + print("Probability:", text_probs[0][0].item()) + print("Threshold:", threshold) + #print("Safety Filter:", safety_filters[i]) + + return (samples,) + if text_probs[0][0].item() > threshold: + samples["samples"].zero_() + print("THIS") + else: + print("NOT THIS") + print(text_probs[0][0].item()) + print(threshold) + print(safety_filter) + return (samples, ) + #text_features = model_latent.encode_text(captions.cuda()) + print(image_features.shape) + image_features_np = image_features.detach().numpy() + text_features_np = text_features.detach().numpy() + + similarity_score = cosine_similarity(image_features_np, text_features_np) + print(f"Similarity ({text}):\t{similarity_score}") + + + + + """ + The node will always be re executed if any of the inputs change but + this method can be used to force the node to execute again even when the inputs don't change. + You can make this node return a number or a string. This value will be compared to the one returned the last time the node was + executed, if it is different the node will be executed again. + This method is used in the core repo for the LoadImage node where they return the image hash as a string, if the image hash + changes between executions the LoadImage node is executed again. + """ + #@classmethod + #def IS_CHANGED(s, image, string_field, int_field, float_field, print_to_screen): + # return "" + +# Set the web directory, any .js file in that directory will be loaded by the frontend as a frontend extension +# WEB_DIRECTORY = "./somejs" + +# A dictionary that contains all nodes you want to export with their names +# NOTE: names should be globally unique +NODE_CLASS_MAPPINGS = { + "LatentSafetyFilter": LatentSafetyFilter + +} + +# A dictionary that contains the friendly/humanly readable titles for the nodes +NODE_DISPLAY_NAME_MAPPINGS = { + "LatentSafetyFilter": "Latent Safety Filter" +} diff --git a/custom_nodes/safety_filter.py b/custom_nodes/safety_filter.py new file mode 100644 index 000000000000..1905d331dd75 --- /dev/null +++ b/custom_nodes/safety_filter.py @@ -0,0 +1,155 @@ +from transformers import CLIPProcessor, CLIPModel, CLIPTokenizer +from sklearn.metrics.pairwise import cosine_similarity +import torch + +class SafetyFilter: + """ + A example node + + Class methods + ------------- + INPUT_TYPES (dict): + Tell the main program input parameters of nodes. + IS_CHANGED: + optional method to control when the node is re executed. + + Attributes + ---------- + RETURN_TYPES (`tuple`): + The type of each element in the output tulple. + RETURN_NAMES (`tuple`): + Optional: The name of each output in the output tulple. + FUNCTION (`str`): + The name of the entry-point method. For example, if `FUNCTION = "execute"` then it will run Example().execute() + OUTPUT_NODE ([`bool`]): + If this node is an output node that outputs a result/image from the graph. The SaveImage node is an example. + The backend iterates on these output nodes and tries to execute all their parents if their parent graph is properly connected. + Assumed to be False if not present. + CATEGORY (`str`): + The category the node should appear in the UI. + execute(s) -> tuple || None: + The entry point method. The name of this method must be the same as the value of property `FUNCTION`. + For example, if `FUNCTION = "execute"` then this method's name must be `execute`, if `FUNCTION = "foo"` then it must be `foo`. + """ + def __init__(self): + pass + + @classmethod + def INPUT_TYPES(s): + """ + Return a dictionary which contains config for all input fields. + Some types (string): "MODEL", "VAE", "CLIP", "CONDITIONING", "LATENT", "IMAGE", "INT", "STRING", "FLOAT". + Input types "INT", "STRING" or "FLOAT" are special values for fields on the node. + The type can be a list for selection. + + Returns: `dict`: + - Key input_fields_group (`string`): Can be either required, hidden or optional. A node class must have property `required` + - Value input_fields (`dict`): Contains input fields config: + * Key field_name (`string`): Name of a entry-point method's argument + * Value field_config (`tuple`): + + First value is a string indicate the type of field or a list for selection. + + Secound value is a config for type "INT", "STRING" or "FLOAT". + """ + return { + "required": { + "image": ("IMAGE",), + "safety_filter": ("STRING", { + "multiline": False, #True if you want the field to look like the one on the ClipTextEncode node + "default": "nsfw" + }), + "threshold": ("FLOAT", { + "default": 0.2, + "min": 0.0, + "max": 1.0, + "step": 0.01, + "round": 0.001, #The value represeting the precision to round to, will be set to the step value by default. Can be set to False to disable rounding. + "display": "number"}), + "int_field": ("INT", { + "default": 0, + "min": 0, #Minimum value + "max": 4096, #Maximum value + "step": 64, #Slider's step + "display": "number" # Cosmetic only: display as "number" or "slider" + }), + "print_to_screen": (["enable", "disable"],), + }, + } + + RETURN_TYPES = ("IMAGE",) + #RETURN_NAMES = ("image_output_name",) + + FUNCTION = "test" + + #OUTPUT_NODE = False + + CATEGORY = "Safety" + + def get_model_info(self, model_ID, device): + model = CLIPModel.from_pretrained(model_ID).to(device) + processor = CLIPProcessor.from_pretrained(model_ID) + tokenizer = CLIPTokenizer.from_pretrained(model_ID) + return model, processor, tokenizer + + def test(self, image, safety_filter, int_field, threshold, print_to_screen): + device = "cuda" if torch.cuda.is_available() else "cpu" + + model_IDs = ["openai/clip-vit-base-patch32", "openai/clip-vit-large-patch14"] + model_ID = model_IDs[1] + model_clip, processor, tokenizer = self.get_model_info(model_ID, device) + + #url = "http://images.cocodataset.org/val2017/000000039769.jpg" + + + inputs = processor(text=safety_filter, images=image, return_tensors="pt", padding=True).to(device) + outputs = model_clip(**inputs) + + logits_per_image = outputs.logits_per_image # this is the image-text similarity score + probs = logits_per_image.softmax(dim=1) # we can take the softmax to get the label probabilities + + print(probs) + print(logits_per_image) + + processed_images = [] + for i, logits_per_image1 in enumerate(logits_per_image): + # Do some processing on the image, in this example I just invert it + if (logits_per_image1 / 100.0 > threshold): + image[i] = 0.0 * image[i] + + processed_images.append(image[i]) + return (processed_images, i) + if print_to_screen == "enable": + print(f"""Your input contains: + string_field aka input text: {safety_filter} + int_field: {int_field} + float_field: {threshold} + """) + #do some processing on the image, in this example I just invert it + if (logits_per_image.item() /100.0 > threshold): + image = 0.0 * image + return (image,) + + """ + The node will always be re executed if any of the inputs change but + this method can be used to force the node to execute again even when the inputs don't change. + You can make this node return a number or a string. This value will be compared to the one returned the last time the node was + executed, if it is different the node will be executed again. + This method is used in the core repo for the LoadImage node where they return the image hash as a string, if the image hash + changes between executions the LoadImage node is executed again. + """ + #@classmethod + #def IS_CHANGED(s, image, string_field, int_field, float_field, print_to_screen): + # return "" + +# Set the web directory, any .js file in that directory will be loaded by the frontend as a frontend extension +# WEB_DIRECTORY = "./somejs" + +# A dictionary that contains all nodes you want to export with their names +# NOTE: names should be globally unique +NODE_CLASS_MAPPINGS = { + "SafetyFilter": SafetyFilter +} + +# A dictionary that contains the friendly/humanly readable titles for the nodes +NODE_DISPLAY_NAME_MAPPINGS = { + "SafetyFilter": "Safety Filter" +} diff --git a/workflow.json b/workflow.json new file mode 100644 index 000000000000..4fc3ee38bc8b --- /dev/null +++ b/workflow.json @@ -0,0 +1,708 @@ +{ + "last_node_id": 24, + "last_link_id": 24, + "nodes": [ + { + "id": 7, + "type": "CLIPTextEncode", + "pos": [ + 413, + 389 + ], + "size": { + "0": 425.27801513671875, + "1": 180.6060791015625 + }, + "flags": {}, + "order": 4, + "mode": 0, + "inputs": [ + { + "name": "clip", + "type": "CLIP", + "link": 14, + "slot_index": 0 + } + ], + "outputs": [ + { + "name": "CONDITIONING", + "type": "CONDITIONING", + "links": [ + 6 + ], + "slot_index": 0 + } + ], + "properties": { + "Node name for S&R": "CLIPTextEncode" + }, + "widgets_values": [ + "text, watermark" + ] + }, + { + "id": 4, + "type": "CheckpointLoaderSimple", + "pos": [ + 26, + 474 + ], + "size": { + "0": 315, + "1": 98 + }, + "flags": {}, + "order": 0, + "mode": 0, + "outputs": [ + { + "name": "MODEL", + "type": "MODEL", + "links": [], + "slot_index": 0 + }, + { + "name": "CLIP", + "type": "CLIP", + "links": [], + "slot_index": 1 + }, + { + "name": "VAE", + "type": "VAE", + "links": [], + "slot_index": 2 + } + ], + "properties": { + "Node name for S&R": "CheckpointLoaderSimple" + }, + "widgets_values": [ + "sd_xl_turbo_1.0.safetensors" + ] + }, + { + "id": 15, + "type": "CLIPVisionEncode", + "pos": [ + 500, + 35 + ], + "size": { + "0": 380.4000244140625, + "1": 46 + }, + "flags": {}, + "order": 9, + "mode": 0, + "inputs": [ + { + "name": "clip_vision", + "type": "CLIP_VISION", + "link": 17 + }, + { + "name": "image", + "type": "IMAGE", + "link": 18 + } + ], + "outputs": [ + { + "name": "CLIP_VISION_OUTPUT", + "type": "CLIP_VISION_OUTPUT", + "links": null, + "shape": 3, + "slot_index": 0 + } + ], + "properties": { + "Node name for S&R": "CLIPVisionEncode" + } + }, + { + "id": 18, + "type": "SaveImage", + "pos": [ + 1612, + 478 + ], + "size": { + "0": 210, + "1": 270 + }, + "flags": {}, + "order": 12, + "mode": 0, + "inputs": [ + { + "name": "images", + "type": "IMAGE", + "link": 20, + "slot_index": 0 + } + ], + "properties": {}, + "widgets_values": [ + "ComfyUI" + ] + }, + { + "id": 3, + "type": "KSampler", + "pos": [ + 863, + 186 + ], + "size": { + "0": 315, + "1": 262 + }, + "flags": {}, + "order": 5, + "mode": 0, + "inputs": [ + { + "name": "model", + "type": "MODEL", + "link": 15, + "slot_index": 0 + }, + { + "name": "positive", + "type": "CONDITIONING", + "link": 4 + }, + { + "name": "negative", + "type": "CONDITIONING", + "link": 6 + }, + { + "name": "latent_image", + "type": "LATENT", + "link": 2 + } + ], + "outputs": [ + { + "name": "LATENT", + "type": "LATENT", + "links": [ + 7, + 21 + ], + "slot_index": 0 + } + ], + "properties": { + "Node name for S&R": "KSampler" + }, + "widgets_values": [ + 228380521887091, + "randomize", + 20, + 8, + "euler", + "normal", + 1 + ] + }, + { + "id": 8, + "type": "VAEDecode", + "pos": [ + 1209, + 188 + ], + "size": { + "0": 210, + "1": 46 + }, + "flags": {}, + "order": 6, + "mode": 0, + "inputs": [ + { + "name": "samples", + "type": "LATENT", + "link": 7 + }, + { + "name": "vae", + "type": "VAE", + "link": 16, + "slot_index": 1 + } + ], + "outputs": [ + { + "name": "IMAGE", + "type": "IMAGE", + "links": [ + 12, + 18, + 19 + ], + "slot_index": 0 + } + ], + "properties": { + "Node name for S&R": "VAEDecode" + } + }, + { + "id": 14, + "type": "unCLIPCheckpointLoader", + "pos": [ + 12, + 134 + ], + "size": { + "0": 315, + "1": 118 + }, + "flags": {}, + "order": 1, + "mode": 0, + "outputs": [ + { + "name": "MODEL", + "type": "MODEL", + "links": [ + 15 + ], + "shape": 3 + }, + { + "name": "CLIP", + "type": "CLIP", + "links": [ + 13, + 14 + ], + "shape": 3 + }, + { + "name": "VAE", + "type": "VAE", + "links": [ + 16, + 23 + ], + "shape": 3, + "slot_index": 2 + }, + { + "name": "CLIP_VISION", + "type": "CLIP_VISION", + "links": [ + 17 + ], + "shape": 3, + "slot_index": 3 + } + ], + "properties": { + "Node name for S&R": "unCLIPCheckpointLoader" + }, + "widgets_values": [ + "sd_xl_turbo_1.0.safetensors" + ] + }, + { + "id": 23, + "type": "VAEDecode", + "pos": [ + 846, + 826 + ], + "size": { + "0": 210, + "1": 46 + }, + "flags": {}, + "order": 11, + "mode": 0, + "inputs": [ + { + "name": "samples", + "type": "LATENT", + "link": 22 + }, + { + "name": "vae", + "type": "VAE", + "link": 23, + "slot_index": 1 + } + ], + "outputs": [ + { + "name": "IMAGE", + "type": "IMAGE", + "links": [ + 24 + ], + "slot_index": 0 + } + ], + "properties": { + "Node name for S&R": "VAEDecode" + } + }, + { + "id": 9, + "type": "SaveImage", + "pos": [ + 1600, + 86 + ], + "size": { + "0": 210, + "1": 270 + }, + "flags": {}, + "order": 8, + "mode": 0, + "inputs": [ + { + "name": "images", + "type": "IMAGE", + "link": 12, + "slot_index": 0 + } + ], + "properties": {}, + "widgets_values": [ + "ComfyUI" + ] + }, + { + "id": 24, + "type": "SaveImage", + "pos": [ + 1346, + 579 + ], + "size": { + "0": 210, + "1": 270 + }, + "flags": {}, + "order": 13, + "mode": 0, + "inputs": [ + { + "name": "images", + "type": "IMAGE", + "link": 24, + "slot_index": 0 + } + ], + "properties": {}, + "widgets_values": [ + "ComfyUI" + ] + }, + { + "id": 5, + "type": "EmptyLatentImage", + "pos": [ + 473, + 609 + ], + "size": { + "0": 315, + "1": 106 + }, + "flags": {}, + "order": 2, + "mode": 0, + "outputs": [ + { + "name": "LATENT", + "type": "LATENT", + "links": [ + 2 + ], + "slot_index": 0 + } + ], + "properties": { + "Node name for S&R": "EmptyLatentImage" + }, + "widgets_values": [ + 512, + 512, + 9 + ] + }, + { + "id": 6, + "type": "CLIPTextEncode", + "pos": [ + 415, + 186 + ], + "size": { + "0": 422.84503173828125, + "1": 164.31304931640625 + }, + "flags": {}, + "order": 3, + "mode": 0, + "inputs": [ + { + "name": "clip", + "type": "CLIP", + "link": 13, + "slot_index": 0 + } + ], + "outputs": [ + { + "name": "CONDITIONING", + "type": "CONDITIONING", + "links": [ + 4 + ], + "slot_index": 0 + } + ], + "properties": { + "Node name for S&R": "CLIPTextEncode" + }, + "widgets_values": [ + "pizza" + ] + }, + { + "id": 17, + "type": "SafetyFilter", + "pos": [ + 1229, + 351 + ], + "size": { + "0": 315, + "1": 130 + }, + "flags": {}, + "order": 10, + "mode": 0, + "inputs": [ + { + "name": "image", + "type": "IMAGE", + "link": 19 + } + ], + "outputs": [ + { + "name": "IMAGE", + "type": "IMAGE", + "links": [ + 20 + ], + "shape": 3, + "slot_index": 0 + } + ], + "properties": { + "Node name for S&R": "SafetyFilter" + }, + "widgets_values": [ + "food", + 0.17, + 0, + "enable" + ] + }, + { + "id": 22, + "type": "LatentSafetyFilter", + "pos": [ + 964, + 540 + ], + "size": { + "0": 315, + "1": 130 + }, + "flags": {}, + "order": 7, + "mode": 0, + "inputs": [ + { + "name": "samples", + "type": "LATENT", + "link": 21 + } + ], + "outputs": [ + { + "name": "LATENT", + "type": "LATENT", + "links": [ + 22 + ], + "shape": 3, + "slot_index": 0 + } + ], + "properties": { + "Node name for S&R": "LatentSafetyFilter" + }, + "widgets_values": [ + "food", + 0.667, + 0, + "enable" + ] + } + ], + "links": [ + [ + 2, + 5, + 0, + 3, + 3, + "LATENT" + ], + [ + 4, + 6, + 0, + 3, + 1, + "CONDITIONING" + ], + [ + 6, + 7, + 0, + 3, + 2, + "CONDITIONING" + ], + [ + 7, + 3, + 0, + 8, + 0, + "LATENT" + ], + [ + 12, + 8, + 0, + 9, + 0, + "IMAGE" + ], + [ + 13, + 14, + 1, + 6, + 0, + "CLIP" + ], + [ + 14, + 14, + 1, + 7, + 0, + "CLIP" + ], + [ + 15, + 14, + 0, + 3, + 0, + "MODEL" + ], + [ + 16, + 14, + 2, + 8, + 1, + "VAE" + ], + [ + 17, + 14, + 3, + 15, + 0, + "CLIP_VISION" + ], + [ + 18, + 8, + 0, + 15, + 1, + "IMAGE" + ], + [ + 19, + 8, + 0, + 17, + 0, + "IMAGE" + ], + [ + 20, + 17, + 0, + 18, + 0, + "IMAGE" + ], + [ + 21, + 3, + 0, + 22, + 0, + "LATENT" + ], + [ + 22, + 22, + 0, + 23, + 0, + "LATENT" + ], + [ + 23, + 14, + 2, + 23, + 1, + "VAE" + ], + [ + 24, + 23, + 0, + 24, + 0, + "IMAGE" + ] + ], + "groups": [], + "config": {}, + "extra": {}, + "version": 0.4 + } \ No newline at end of file From 5b76e6c0b48bc679416173530394bffe75ea86e3 Mon Sep 17 00:00:00 2001 From: jsonBackup Date: Wed, 3 Apr 2024 16:03:07 +0200 Subject: [PATCH 94/94] Add extra model paths --- .gitignore | 1 - extra_model_paths.yaml | 43 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 43 insertions(+), 1 deletion(-) create mode 100644 extra_model_paths.yaml diff --git a/.gitignore b/.gitignore index e479c9ec3abe..598e968c8afb 100644 --- a/.gitignore +++ b/.gitignore @@ -6,7 +6,6 @@ __pycache__/ /models/ /temp/ !custom_nodes/example_node.py.example -extra_model_paths.yaml /.vs .vscode/ .idea/ diff --git a/extra_model_paths.yaml b/extra_model_paths.yaml new file mode 100644 index 000000000000..74c4f53ab564 --- /dev/null +++ b/extra_model_paths.yaml @@ -0,0 +1,43 @@ +#Rename this to extra_model_paths.yaml and ComfyUI will load it + + +#config for a1111 ui +#all you have to do is change the base_path to where yours is installed +a111: + base_path: path/to/stable-diffusion-webui/ + + checkpoints: models/Stable-diffusion + configs: models/Stable-diffusion + vae: models/VAE + loras: | + models/Lora + models/LyCORIS + upscale_models: | + models/ESRGAN + models/RealESRGAN + models/SwinIR + embeddings: embeddings + hypernetworks: models/hypernetworks + controlnet: models/ControlNet + +#config for comfyui +#your base path should be either an existing comfy install or a central folder where you store all of your models, loras, etc. + +#comfyui: +# base_path: path/to/comfyui/ +# checkpoints: models/checkpoints/ +# clip: models/clip/ +# clip_vision: models/clip_vision/ +# configs: models/configs/ +# controlnet: models/controlnet/ +# embeddings: models/embeddings/ +# loras: models/loras/ +# upscale_models: models/upscale_models/ +# vae: models/vae/ + +other_ui: + base_path: /dlabscratch1/wendler/models/sdxl-turbo + checkpoints: ./ + #vae: models/vae + #gligen: models/gligen + #custom_nodes: path/custom_nodes