Upload 2334 files

.gitattributes

@@ -33,3 +33,33 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+ComfyUI/custom_nodes/comfyui_controlnet_aux/examples/example_mesh_graphormer.png filter=lfs diff=lfs merge=lfs -text
+ComfyUI/custom_nodes/comfyui_controlnet_aux/src/controlnet_aux/mesh_graphormer/hand_landmarker.task filter=lfs diff=lfs merge=lfs -text
+ComfyUI/custom_nodes/ComfyUI-AutomaticCFG/grids_example/Enhanced_details_and_tweaked_attention.png filter=lfs diff=lfs merge=lfs -text
+ComfyUI/custom_nodes/ComfyUI-AutomaticCFG/grids_example/excellent_patch_a.jpg filter=lfs diff=lfs merge=lfs -text
+ComfyUI/custom_nodes/ComfyUI-AutomaticCFG/grids_example/excellent_patch_b.jpg filter=lfs diff=lfs merge=lfs -text
+ComfyUI/custom_nodes/ComfyUI-AutomaticCFG/grids_example/Iris_Lux_v1051_base_image_vanilla_sampling.png filter=lfs diff=lfs merge=lfs -text
+ComfyUI/custom_nodes/ComfyUI-AutomaticCFG/grids_example/presets.jpg filter=lfs diff=lfs merge=lfs -text
+ComfyUI/custom_nodes/ComfyUI-AutomaticCFG/workflows/10[[:space:]]steps[[:space:]]SDXL[[:space:]]AYS[[:space:]]Warp[[:space:]]drive[[:space:]]variation.png filter=lfs diff=lfs merge=lfs -text
+ComfyUI/custom_nodes/ComfyUI-AutomaticCFG/workflows/11728UI_00001_.png filter=lfs diff=lfs merge=lfs -text
+ComfyUI/custom_nodes/ComfyUI-AutomaticCFG/workflows/12[[:space:]]steps[[:space:]]SDXL[[:space:]]AYS[[:space:]]Warp[[:space:]]drive[[:space:]]workflow.png filter=lfs diff=lfs merge=lfs -text
+ComfyUI/custom_nodes/ComfyUI-AutomaticCFG/workflows/12steps.png filter=lfs diff=lfs merge=lfs -text
+ComfyUI/custom_nodes/ComfyUI-AutomaticCFG/workflows/24steps.png filter=lfs diff=lfs merge=lfs -text
+ComfyUI/custom_nodes/ComfyUI-AutomaticCFG/workflows/attention_modifiers_explainations.png filter=lfs diff=lfs merge=lfs -text
+ComfyUI/custom_nodes/ComfyUI-AutomaticCFG/workflows/I'm[[:space:]]just[[:space:]]throwing[[:space:]]a[[:space:]]few[[:space:]]here[[:space:]]that[[:space:]]I[[:space:]]find[[:space:]]nice/00382UI_00001_.png filter=lfs diff=lfs merge=lfs -text
+ComfyUI/custom_nodes/ComfyUI-AutomaticCFG/workflows/I'm[[:space:]]just[[:space:]]throwing[[:space:]]a[[:space:]]few[[:space:]]here[[:space:]]that[[:space:]]I[[:space:]]find[[:space:]]nice/01207UI_00001_.png filter=lfs diff=lfs merge=lfs -text
+ComfyUI/custom_nodes/ComfyUI-AutomaticCFG/workflows/I'm[[:space:]]just[[:space:]]throwing[[:space:]]a[[:space:]]few[[:space:]]here[[:space:]]that[[:space:]]I[[:space:]]find[[:space:]]nice/01217UI_00001_.png filter=lfs diff=lfs merge=lfs -text
+ComfyUI/custom_nodes/ComfyUI-AutomaticCFG/workflows/I'm[[:space:]]just[[:space:]]throwing[[:space:]]a[[:space:]]few[[:space:]]here[[:space:]]that[[:space:]]I[[:space:]]find[[:space:]]nice/a[[:space:]]bad[[:space:]]upscale[[:space:]]looks[[:space:]]like[[:space:]]low[[:space:]]quality[[:space:]]jpeg.png filter=lfs diff=lfs merge=lfs -text
+ComfyUI/custom_nodes/ComfyUI-AutomaticCFG/workflows/I'm[[:space:]]just[[:space:]]throwing[[:space:]]a[[:space:]]few[[:space:]]here[[:space:]]that[[:space:]]I[[:space:]]find[[:space:]]nice/another[[:space:]]bad[[:space:]]upscale[[:space:]]looking[[:space:]]like[[:space:]]jpeg.png filter=lfs diff=lfs merge=lfs -text
+ComfyUI/custom_nodes/ComfyUI-AutomaticCFG/workflows/I'm[[:space:]]just[[:space:]]throwing[[:space:]]a[[:space:]]few[[:space:]]here[[:space:]]that[[:space:]]I[[:space:]]find[[:space:]]nice/intradasting.png filter=lfs diff=lfs merge=lfs -text
+ComfyUI/custom_nodes/ComfyUI-AutomaticCFG/workflows/I'm[[:space:]]just[[:space:]]throwing[[:space:]]a[[:space:]]few[[:space:]]here[[:space:]]that[[:space:]]I[[:space:]]find[[:space:]]nice/laule.png filter=lfs diff=lfs merge=lfs -text
+ComfyUI/custom_nodes/ComfyUI-AutomaticCFG/workflows/I'm[[:space:]]just[[:space:]]throwing[[:space:]]a[[:space:]]few[[:space:]]here[[:space:]]that[[:space:]]I[[:space:]]find[[:space:]]nice/niiiiiice.png filter=lfs diff=lfs merge=lfs -text
+ComfyUI/custom_nodes/ComfyUI-AutomaticCFG/workflows/I'm[[:space:]]just[[:space:]]throwing[[:space:]]a[[:space:]]few[[:space:]]here[[:space:]]that[[:space:]]I[[:space:]]find[[:space:]]nice/special[[:space:]]double[[:space:]]pass.png filter=lfs diff=lfs merge=lfs -text
+ComfyUI/custom_nodes/ComfyUI-AutomaticCFG/workflows/I'm[[:space:]]just[[:space:]]throwing[[:space:]]a[[:space:]]few[[:space:]]here[[:space:]]that[[:space:]]I[[:space:]]find[[:space:]]nice/web.png filter=lfs diff=lfs merge=lfs -text
+ComfyUI/custom_nodes/ComfyUI-AutomaticCFG/workflows/My[[:space:]]current[[:space:]]go-to[[:space:]]settings.png filter=lfs diff=lfs merge=lfs -text
+ComfyUI/custom_nodes/ComfyUI-AutomaticCFG/workflows/potato[[:space:]]attention[[:space:]]guidance.png filter=lfs diff=lfs merge=lfs -text
+ComfyUI/custom_nodes/ComfyUI-AutomaticCFG/workflows/simple[[:space:]]SD[[:space:]]upscale.png filter=lfs diff=lfs merge=lfs -text
+ComfyUI/custom_nodes/ComfyUI-AutomaticCFG/workflows/Start_by_this_one.png filter=lfs diff=lfs merge=lfs -text
+ComfyUI/custom_nodes/was-node-suite-comfyui/repos/SAM/assets/masks1.png filter=lfs diff=lfs merge=lfs -text
+ComfyUI/custom_nodes/was-node-suite-comfyui/repos/SAM/assets/minidemo.gif filter=lfs diff=lfs merge=lfs -text
+ComfyUI/custom_nodes/was-node-suite-comfyui/repos/SAM/assets/notebook2.png filter=lfs diff=lfs merge=lfs -text

ComfyUI/custom_nodes/ComfyMath/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

ComfyUI/custom_nodes/ComfyMath/README.md

@@ -0,0 +1,19 @@
+# ComfyMath
+
+Provides Math Nodes for [ComfyUI](https://github.com/comfyanonymous/ComfyUI)
+
+## Features
+
+Provides nodes for:
+* Boolean Logic
+* Integer Arithmetic
+* Floating Point Arithmetic and Functions
+* Vec2, Vec3, and Vec4 Arithmetic and Functions
+
+## Installation
+
+From the `custom_nodes` directory in your ComfyUI installation, run:
+
+```sh
+git clone https://github.com/evanspearman/ComfyMath.git
+```

ComfyUI/custom_nodes/ComfyMath/__init__.py

@@ -0,0 +1,31 @@
+from .src.comfymath.convert import NODE_CLASS_MAPPINGS as convert_NCM
+from .src.comfymath.bool import NODE_CLASS_MAPPINGS as bool_NCM
+from .src.comfymath.int import NODE_CLASS_MAPPINGS as int_NCM
+from .src.comfymath.float import NODE_CLASS_MAPPINGS as float_NCM
+from .src.comfymath.number import NODE_CLASS_MAPPINGS as number_NCM
+from .src.comfymath.vec import NODE_CLASS_MAPPINGS as vec_NCM
+from .src.comfymath.control import NODE_CLASS_MAPPINGS as control_NCM
+from .src.comfymath.graphics import NODE_CLASS_MAPPINGS as graphics_NCM
+
+
+
+
+NODE_CLASS_MAPPINGS = {
+    **convert_NCM,
+    **bool_NCM,
+    **int_NCM,
+    **float_NCM,
+    **number_NCM,
+    **vec_NCM,
+    **control_NCM,
+    **graphics_NCM,
+}
+
+
+def remove_cm_prefix(node_mapping: str) -> str:
+    if node_mapping.startswith("CM_"):
+        return node_mapping[3:]
+    return node_mapping
+
+
+NODE_DISPLAY_NAME_MAPPINGS = {key: remove_cm_prefix(key) for key in NODE_CLASS_MAPPINGS}

ComfyUI/custom_nodes/ComfyMath/pyproject.toml

@@ -0,0 +1,19 @@
+[tool.poetry]
+name = "comfymath"
+version = "0.1.0"
+description = "Math nodes for ComfyUI"
+authors = ["Evan Spearman <evan@spearman.mb.ca>"]
+license = "Apache-2.0"
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.10"
+numpy = "^1.25.1"
+
+[tool.poetry.group.dev.dependencies]
+mypy = "^1.4.1"
+black = "^23.7.0"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

ComfyUI/custom_nodes/ComfyMath/requirements.txt

@@ -0,0 +1 @@
+numpy

ComfyUI/custom_nodes/ComfyMath/src/comfymath/bool.py

@@ -0,0 +1,59 @@
+from typing import Any, Callable, Mapping
+
+DEFAULT_BOOL = ("BOOL", {"default": False})
+
+
+BOOL_UNARY_OPERATIONS: Mapping[str, Callable[[bool], bool]] = {
+    "Not": lambda a: not a,
+}
+
+BOOL_BINARY_OPERATIONS: Mapping[str, Callable[[bool, bool], bool]] = {
+    "Nor": lambda a, b: not (a or b),
+    "Xor": lambda a, b: a ^ b,
+    "Nand": lambda a, b: not (a and b),
+    "And": lambda a, b: a and b,
+    "Xnor": lambda a, b: not (a ^ b),
+    "Or": lambda a, b: a or b,
+    "Eq": lambda a, b: a == b,
+    "Neq": lambda a, b: a != b,
+}
+
+
+class BoolUnaryOperation:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {
+            "required": {"op": (list(BOOL_UNARY_OPERATIONS.keys()),), "a": DEFAULT_BOOL}
+        }
+
+    RETURN_TYPES = ("BOOL",)
+    FUNCTION = "op"
+    CATEGORY = "math/bool"
+
+    def op(self, op: str, a: bool) -> tuple[bool]:
+        return (BOOL_UNARY_OPERATIONS[op](a),)
+
+
+class BoolBinaryOperation:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {
+            "required": {
+                "op": (list(BOOL_BINARY_OPERATIONS.keys()),),
+                "a": DEFAULT_BOOL,
+                "b": DEFAULT_BOOL,
+            }
+        }
+
+    RETURN_TYPES = ("BOOL",)
+    FUNCTION = "op"
+    CATEGORY = "math/bool"
+
+    def op(self, op: str, a: bool, b: bool) -> tuple[bool]:
+        return (BOOL_BINARY_OPERATIONS[op](a, b),)
+
+
+NODE_CLASS_MAPPINGS = {
+    "CM_BoolUnaryOperation": BoolUnaryOperation,
+    "CM_BoolBinaryOperation": BoolBinaryOperation,
+}

ComfyUI/custom_nodes/ComfyMath/src/comfymath/control.py

@@ -0,0 +1,3 @@
+from typing import Any, Mapping
+
+NODE_CLASS_MAPPINGS: Mapping[str, Any] = {}

ComfyUI/custom_nodes/ComfyMath/src/comfymath/convert.py

@@ -0,0 +1,273 @@
+from typing import Any, Mapping
+
+from .vec import Vec2, VEC2_ZERO, Vec3, VEC3_ZERO, Vec4, VEC4_ZERO
+from .number import number
+
+
+class BoolToInt:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {"required": {"a": ("BOOL", {"default": False})}}
+
+    RETURN_TYPES = ("INT",)
+    FUNCTION = "op"
+    CATEGORY = "math/conversion"
+
+    def op(self, a: bool) -> tuple[int]:
+        return (int(a),)
+
+
+class IntToBool:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {"required": {"a": ("INT", {"default": 0})}}
+
+    RETURN_TYPES = ("BOOL",)
+    FUNCTION = "op"
+    CATEGORY = "math/conversion"
+
+    def op(self, a: int) -> tuple[bool]:
+        return (a != 0,)
+
+
+class FloatToInt:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {"required": {"a": ("FLOAT", {"default": 0.0})}}
+
+    RETURN_TYPES = ("INT",)
+    FUNCTION = "op"
+    CATEGORY = "math/conversion"
+
+    def op(self, a: float) -> tuple[int]:
+        return (int(a),)
+
+
+class IntToFloat:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {"required": {"a": ("INT", {"default": 0})}}
+
+    RETURN_TYPES = ("FLOAT",)
+    FUNCTION = "op"
+    CATEGORY = "math/conversion"
+
+    def op(self, a: int) -> tuple[float]:
+        return (float(a),)
+
+
+class IntToNumber:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {"required": {"a": ("INT", {"default": 0})}}
+
+    RETURN_TYPES = ("NUMBER",)
+    FUNCTION = "op"
+    CATEGORY = "math/conversion"
+
+    def op(self, a: int) -> tuple[number]:
+        return (a,)
+
+
+class NumberToInt:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {"required": {"a": ("NUMBER", {"default": 0.0})}}
+
+    RETURN_TYPES = ("INT",)
+    FUNCTION = "op"
+    CATEGORY = "math/conversion"
+
+    def op(self, a: number) -> tuple[int]:
+        return (int(a),)
+
+
+class FloatToNumber:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {"required": {"a": ("FLOAT", {"default": 0.0})}}
+
+    RETURN_TYPES = ("NUMBER",)
+    FUNCTION = "op"
+    CATEGORY = "math/conversion"
+
+    def op(self, a: float) -> tuple[number]:
+        return (a,)
+
+
+class NumberToFloat:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {"required": {"a": ("NUMBER", {"default": 0.0})}}
+
+    RETURN_TYPES = ("FLOAT",)
+    FUNCTION = "op"
+    CATEGORY = "math/conversion"
+
+    def op(self, a: number) -> tuple[float]:
+        return (float(a),)
+
+
+class ComposeVec2:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {
+            "required": {
+                "x": ("FLOAT", {"default": 0.0}),
+                "y": ("FLOAT", {"default": 0.0}),
+            }
+        }
+
+    RETURN_TYPES = ("VEC2",)
+    FUNCTION = "op"
+    CATEGORY = "math/conversion"
+
+    def op(self, x: float, y: float) -> tuple[Vec2]:
+        return ((x, y),)
+
+
+class FillVec2:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {
+            "required": {
+                "a": ("FLOAT", {"default": 0.0}),
+            }
+        }
+
+    RETURN_TYPES = ("VEC2",)
+    FUNCTION = "op"
+    CATEGORY = "math/conversion"
+
+    def op(self, a: float) -> tuple[Vec2]:
+        return ((a, a),)
+
+
+class BreakoutVec2:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {"required": {"a": ("VEC2", {"default": VEC2_ZERO})}}
+
+    RETURN_TYPES = ("FLOAT", "FLOAT")
+    FUNCTION = "op"
+    CATEGORY = "math/conversion"
+
+    def op(self, a: Vec2) -> tuple[float, float]:
+        return (a[0], a[1])
+
+
+class ComposeVec3:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {
+            "required": {
+                "x": ("FLOAT", {"default": 0.0}),
+                "y": ("FLOAT", {"default": 0.0}),
+                "z": ("FLOAT", {"default": 0.0}),
+            }
+        }
+
+    RETURN_TYPES = ("VEC3",)
+    FUNCTION = "op"
+    CATEGORY = "math/conversion"
+
+    def op(self, x: float, y: float, z: float) -> tuple[Vec3]:
+        return ((x, y, z),)
+
+
+class FillVec3:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {
+            "required": {
+                "a": ("FLOAT", {"default": 0.0}),
+            }
+        }
+
+    RETURN_TYPES = ("VEC3",)
+    FUNCTION = "op"
+    CATEGORY = "math/conversion"
+
+    def op(self, a: float) -> tuple[Vec3]:
+        return ((a, a, a),)
+
+
+class BreakoutVec3:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {"required": {"a": ("VEC3", {"default": VEC3_ZERO})}}
+
+    RETURN_TYPES = ("FLOAT", "FLOAT", "FLOAT")
+    FUNCTION = "op"
+    CATEGORY = "math/conversion"
+
+    def op(self, a: Vec3) -> tuple[float, float, float]:
+        return (a[0], a[1], a[2])
+
+
+class ComposeVec4:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {
+            "required": {
+                "x": ("FLOAT", {"default": 0.0}),
+                "y": ("FLOAT", {"default": 0.0}),
+                "z": ("FLOAT", {"default": 0.0}),
+                "w": ("FLOAT", {"default": 0.0}),
+            }
+        }
+
+    RETURN_TYPES = ("VEC4",)
+    FUNCTION = "op"
+    CATEGORY = "math/conversion"
+
+    def op(self, x: float, y: float, z: float, w: float) -> tuple[Vec4]:
+        return ((x, y, z, w),)
+
+
+class FillVec4:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {
+            "required": {
+                "a": ("FLOAT", {"default": 0.0}),
+            }
+        }
+
+    RETURN_TYPES = ("VEC4",)
+    FUNCTION = "op"
+    CATEGORY = "math/conversion"
+
+    def op(self, a: float) -> tuple[Vec4]:
+        return ((a, a, a, a),)
+
+
+class BreakoutVec4:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {"required": {"a": ("VEC4", {"default": VEC4_ZERO})}}
+
+    RETURN_TYPES = ("FLOAT", "FLOAT", "FLOAT", "FLOAT")
+    FUNCTION = "op"
+    CATEGORY = "math/conversion"
+
+    def op(self, a: Vec4) -> tuple[float, float, float, float]:
+        return (a[0], a[1], a[2], a[3])
+
+
+NODE_CLASS_MAPPINGS = {
+    "CM_BoolToInt": BoolToInt,
+    "CM_IntToBool": IntToBool,
+    "CM_FloatToInt": FloatToInt,
+    "CM_IntToFloat": IntToFloat,
+    "CM_IntToNumber": IntToNumber,
+    "CM_NumberToInt": NumberToInt,
+    "CM_FloatToNumber": FloatToNumber,
+    "CM_NumberToFloat": NumberToFloat,
+    "CM_ComposeVec2": ComposeVec2,
+    "CM_ComposeVec3": ComposeVec3,
+    "CM_ComposeVec4": ComposeVec4,
+    "CM_BreakoutVec2": BreakoutVec2,
+    "CM_BreakoutVec3": BreakoutVec3,
+    "CM_BreakoutVec4": BreakoutVec4,
+}

ComfyUI/custom_nodes/ComfyMath/src/comfymath/float.py

@@ -0,0 +1,159 @@
+import math
+
+from typing import Any, Callable, Mapping
+
+DEFAULT_FLOAT = ("FLOAT", {"default": 0.0})
+
+FLOAT_UNARY_OPERATIONS: Mapping[str, Callable[[float], float]] = {
+    "Neg": lambda a: -a,
+    "Inc": lambda a: a + 1,
+    "Dec": lambda a: a - 1,
+    "Abs": lambda a: abs(a),
+    "Sqr": lambda a: a * a,
+    "Cube": lambda a: a * a * a,
+    "Sqrt": lambda a: math.sqrt(a),
+    "Exp": lambda a: math.exp(a),
+    "Ln": lambda a: math.log(a),
+    "Log10": lambda a: math.log10(a),
+    "Log2": lambda a: math.log2(a),
+    "Sin": lambda a: math.sin(a),
+    "Cos": lambda a: math.cos(a),
+    "Tan": lambda a: math.tan(a),
+    "Asin": lambda a: math.asin(a),
+    "Acos": lambda a: math.acos(a),
+    "Atan": lambda a: math.atan(a),
+    "Sinh": lambda a: math.sinh(a),
+    "Cosh": lambda a: math.cosh(a),
+    "Tanh": lambda a: math.tanh(a),
+    "Asinh": lambda a: math.asinh(a),
+    "Acosh": lambda a: math.acosh(a),
+    "Atanh": lambda a: math.atanh(a),
+    "Round": lambda a: round(a),
+    "Floor": lambda a: math.floor(a),
+    "Ceil": lambda a: math.ceil(a),
+    "Trunc": lambda a: math.trunc(a),
+    "Erf": lambda a: math.erf(a),
+    "Erfc": lambda a: math.erfc(a),
+    "Gamma": lambda a: math.gamma(a),
+    "Radians": lambda a: math.radians(a),
+    "Degrees": lambda a: math.degrees(a),
+}
+
+FLOAT_UNARY_CONDITIONS: Mapping[str, Callable[[float], bool]] = {
+    "IsZero": lambda a: a == 0.0,
+    "IsPositive": lambda a: a > 0.0,
+    "IsNegative": lambda a: a < 0.0,
+    "IsNonZero": lambda a: a != 0.0,
+    "IsPositiveInfinity": lambda a: math.isinf(a) and a > 0.0,
+    "IsNegativeInfinity": lambda a: math.isinf(a) and a < 0.0,
+    "IsNaN": lambda a: math.isnan(a),
+    "IsFinite": lambda a: math.isfinite(a),
+    "IsInfinite": lambda a: math.isinf(a),
+    "IsEven": lambda a: a % 2 == 0.0,
+    "IsOdd": lambda a: a % 2 != 0.0,
+}
+
+FLOAT_BINARY_OPERATIONS: Mapping[str, Callable[[float, float], float]] = {
+    "Add": lambda a, b: a + b,
+    "Sub": lambda a, b: a - b,
+    "Mul": lambda a, b: a * b,
+    "Div": lambda a, b: a / b,
+    "Mod": lambda a, b: a % b,
+    "Pow": lambda a, b: a**b,
+    "FloorDiv": lambda a, b: a // b,
+    "Max": lambda a, b: max(a, b),
+    "Min": lambda a, b: min(a, b),
+    "Log": lambda a, b: math.log(a, b),
+    "Atan2": lambda a, b: math.atan2(a, b),
+}
+
+FLOAT_BINARY_CONDITIONS: Mapping[str, Callable[[float, float], bool]] = {
+    "Eq": lambda a, b: a == b,
+    "Neq": lambda a, b: a != b,
+    "Gt": lambda a, b: a > b,
+    "Gte": lambda a, b: a >= b,
+    "Lt": lambda a, b: a < b,
+    "Lte": lambda a, b: a <= b,
+}
+
+
+class FloatUnaryOperation:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {
+            "required": {
+                "op": (list(FLOAT_UNARY_OPERATIONS.keys()),),
+                "a": DEFAULT_FLOAT,
+            }
+        }
+
+    RETURN_TYPES = ("FLOAT",)
+    FUNCTION = "op"
+    CATEGORY = "math/float"
+
+    def op(self, op: str, a: float) -> tuple[float]:
+        return (FLOAT_UNARY_OPERATIONS[op](a),)
+
+
+class FloatUnaryCondition:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {
+            "required": {
+                "op": (list(FLOAT_UNARY_CONDITIONS.keys()),),
+                "a": DEFAULT_FLOAT,
+            }
+        }
+
+    RETURN_TYPES = ("BOOL",)
+    FUNCTION = "op"
+    CATEGORY = "math/float"
+
+    def op(self, op: str, a: float) -> tuple[bool]:
+        return (FLOAT_UNARY_CONDITIONS[op](a),)
+
+
+class FloatBinaryOperation:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {
+            "required": {
+                "op": (list(FLOAT_BINARY_OPERATIONS.keys()),),
+                "a": DEFAULT_FLOAT,
+                "b": DEFAULT_FLOAT,
+            }
+        }
+
+    RETURN_TYPES = ("FLOAT",)
+    FUNCTION = "op"
+    CATEGORY = "math/float"
+
+    def op(self, op: str, a: float, b: float) -> tuple[float]:
+        return (FLOAT_BINARY_OPERATIONS[op](a, b),)
+
+
+class FloatBinaryCondition:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {
+            "required": {
+                "op": (list(FLOAT_BINARY_CONDITIONS.keys()),),
+                "a": DEFAULT_FLOAT,
+                "b": DEFAULT_FLOAT,
+            }
+        }
+
+    RETURN_TYPES = ("BOOL",)
+    FUNCTION = "op"
+    CATEGORY = "math/float"
+
+    def op(self, op: str, a: float, b: float) -> tuple[bool]:
+        return (FLOAT_BINARY_CONDITIONS[op](a, b),)
+
+
+NODE_CLASS_MAPPINGS = {
+    "CM_FloatUnaryOperation": FloatUnaryOperation,
+    "CM_FloatUnaryCondition": FloatUnaryCondition,
+    "CM_FloatBinaryOperation": FloatBinaryOperation,
+    "CM_FloatBinaryCondition": FloatBinaryCondition,
+}

ComfyUI/custom_nodes/ComfyMath/src/comfymath/graphics.py

@@ -0,0 +1,77 @@
+from typing import Any, Mapping
+
+
+SDXL_SUPPORTED_RESOLUTIONS = [
+    (1024, 1024, 1.0),
+    (1152, 896, 1.2857142857142858),
+    (896, 1152, 0.7777777777777778),
+    (1216, 832, 1.4615384615384615),
+    (832, 1216, 0.6842105263157895),
+    (1344, 768, 1.75),
+    (768, 1344, 0.5714285714285714),
+    (1536, 640, 2.4),
+    (640, 1536, 0.4166666666666667),
+]
+
+
+class SDXLResolution:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {
+            "required": {
+                "resolution": (
+                    [f"{res[0]}x{res[1]}" for res in SDXL_SUPPORTED_RESOLUTIONS],
+                )
+            }
+        }
+
+    RETURN_TYPES = ("INT", "INT")
+    RETURN_NAMES = ("width", "height")
+    FUNCTION = "op"
+    CATEGORY = "math/graphics"
+
+    def op(self, resolution: str) -> tuple[int, int]:
+        width, height = resolution.split("x")
+        return (int(width), int(height))
+
+
+class NearestSDXLResolution:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {"required": {"image": ("IMAGE",)}}
+
+    RETURN_TYPES = ("INT", "INT")
+    RETURN_NAMES = ("width", "height")
+    FUNCTION = "op"
+    CATEGORY = "math/graphics"
+
+    def op(self, image) -> tuple[int, int]:
+        image_width = image.size()[2]
+        image_height = image.size()[1]
+        print(f"Input image resolution: {image_width}x{image_height}")
+        image_ratio = image_width / image_height
+        differences = [
+            (abs(image_ratio - resolution[2]), resolution)
+            for resolution in SDXL_SUPPORTED_RESOLUTIONS
+        ]
+        smallest = None
+        for difference in differences:
+            if smallest is None:
+                smallest = difference
+            else:
+                if difference[0] < smallest[0]:
+                    smallest = difference
+        if smallest is not None:
+            width = smallest[1][0]
+            height = smallest[1][1]
+        else:
+            width = 1024
+            height = 1024
+        print(f"Selected SDXL resolution: {width}x{height}")
+        return (width, height)
+
+
+NODE_CLASS_MAPPINGS = {
+    "CM_SDXLResolution": SDXLResolution,
+    "CM_NearestSDXLResolution": NearestSDXLResolution,
+}

ComfyUI/custom_nodes/ComfyMath/src/comfymath/int.py

@@ -0,0 +1,129 @@
+import math
+
+from typing import Any, Callable, Mapping
+
+DEFAULT_INT = ("INT", {"default": 0})
+
+INT_UNARY_OPERATIONS: Mapping[str, Callable[[int], int]] = {
+    "Abs": lambda a: abs(a),
+    "Neg": lambda a: -a,
+    "Inc": lambda a: a + 1,
+    "Dec": lambda a: a - 1,
+    "Sqr": lambda a: a * a,
+    "Cube": lambda a: a * a * a,
+    "Not": lambda a: ~a,
+    "Factorial": lambda a: math.factorial(a),
+}
+
+INT_UNARY_CONDITIONS: Mapping[str, Callable[[int], bool]] = {
+    "IsZero": lambda a: a == 0,
+    "IsNonZero": lambda a: a != 0,
+    "IsPositive": lambda a: a > 0,
+    "IsNegative": lambda a: a < 0,
+    "IsEven": lambda a: a % 2 == 0,
+    "IsOdd": lambda a: a % 2 == 1,
+}
+
+INT_BINARY_OPERATIONS: Mapping[str, Callable[[int, int], int]] = {
+    "Add": lambda a, b: a + b,
+    "Sub": lambda a, b: a - b,
+    "Mul": lambda a, b: a * b,
+    "Div": lambda a, b: a // b,
+    "Mod": lambda a, b: a % b,
+    "Pow": lambda a, b: a**b,
+    "And": lambda a, b: a & b,
+    "Nand": lambda a, b: ~a & b,
+    "Or": lambda a, b: a | b,
+    "Nor": lambda a, b: ~a & b,
+    "Xor": lambda a, b: a ^ b,
+    "Xnor": lambda a, b: ~a ^ b,
+    "Shl": lambda a, b: a << b,
+    "Shr": lambda a, b: a >> b,
+    "Max": lambda a, b: max(a, b),
+    "Min": lambda a, b: min(a, b),
+}
+
+INT_BINARY_CONDITIONS: Mapping[str, Callable[[int, int], bool]] = {
+    "Eq": lambda a, b: a == b,
+    "Neq": lambda a, b: a != b,
+    "Gt": lambda a, b: a > b,
+    "Lt": lambda a, b: a < b,
+    "Geq": lambda a, b: a >= b,
+    "Leq": lambda a, b: a <= b,
+}
+
+
+class IntUnaryOperation:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {
+            "required": {"op": (list(INT_UNARY_OPERATIONS.keys()),), "a": DEFAULT_INT}
+        }
+
+    RETURN_TYPES = ("INT",)
+    FUNCTION = "op"
+    CATEGORY = "math/int"
+
+    def op(self, op: str, a: int) -> tuple[int]:
+        return (INT_UNARY_OPERATIONS[op](a),)
+
+
+class IntUnaryCondition:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {
+            "required": {"op": (list(INT_UNARY_CONDITIONS.keys()),), "a": DEFAULT_INT}
+        }
+
+    RETURN_TYPES = ("BOOL",)
+    FUNCTION = "op"
+    CATEGORY = "math/int"
+
+    def op(self, op: str, a: int) -> tuple[bool]:
+        return (INT_UNARY_CONDITIONS[op](a),)
+
+
+class IntBinaryOperation:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {
+            "required": {
+                "op": (list(INT_BINARY_OPERATIONS.keys()),),
+                "a": DEFAULT_INT,
+                "b": DEFAULT_INT,
+            }
+        }
+
+    RETURN_TYPES = ("INT",)
+    FUNCTION = "op"
+    CATEGORY = "math/int"
+
+    def op(self, op: str, a: int, b: int) -> tuple[int]:
+        return (INT_BINARY_OPERATIONS[op](a, b),)
+
+
+class IntBinaryCondition:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {
+            "required": {
+                "op": (list(INT_BINARY_CONDITIONS.keys()),),
+                "a": DEFAULT_INT,
+                "b": DEFAULT_INT,
+            }
+        }
+
+    RETURN_TYPES = ("BOOL",)
+    FUNCTION = "op"
+    CATEGORY = "math/int"
+
+    def op(self, op: str, a: int, b: int) -> tuple[bool]:
+        return (INT_BINARY_CONDITIONS[op](a, b),)
+
+
+NODE_CLASS_MAPPINGS = {
+    "CM_IntUnaryOperation": IntUnaryOperation,
+    "CM_IntUnaryCondition": IntUnaryCondition,
+    "CM_IntBinaryOperation": IntBinaryOperation,
+    "CM_IntBinaryCondition": IntBinaryCondition,
+}

ComfyUI/custom_nodes/ComfyMath/src/comfymath/number.py

@@ -0,0 +1,95 @@
+from dataclasses import dataclass
+from typing import Any, Callable, Mapping, TypeAlias
+
+from .float import (
+    FLOAT_UNARY_OPERATIONS,
+    FLOAT_UNARY_CONDITIONS,
+    FLOAT_BINARY_OPERATIONS,
+    FLOAT_BINARY_CONDITIONS,
+)
+
+DEFAULT_NUMBER = ("NUMBER", {"default": 0.0})
+
+number: TypeAlias = int | float
+
+
+class NumberUnaryOperation:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {
+            "required": {
+                "op": (list(FLOAT_UNARY_OPERATIONS.keys()),),
+                "a": DEFAULT_NUMBER,
+            }
+        }
+
+    RETURN_TYPES = ("NUMBER",)
+    FUNCTION = "op"
+    CATEGORY = "math/number"
+
+    def op(self, op: str, a: number) -> tuple[float]:
+        return (FLOAT_UNARY_OPERATIONS[op](float(a)),)
+
+
+class NumberUnaryCondition:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {
+            "required": {
+                "op": (list(FLOAT_UNARY_CONDITIONS.keys()),),
+                "a": DEFAULT_NUMBER,
+            }
+        }
+
+    RETURN_TYPES = ("BOOL",)
+    FUNCTION = "op"
+    CATEGORY = "math/number"
+
+    def op(self, op: str, a: number) -> tuple[bool]:
+        return (FLOAT_UNARY_CONDITIONS[op](float(a)),)
+
+
+class NumberBinaryOperation:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {
+            "required": {
+                "op": (list(FLOAT_BINARY_OPERATIONS.keys()),),
+                "a": DEFAULT_NUMBER,
+                "b": DEFAULT_NUMBER,
+            }
+        }
+
+    RETURN_TYPES = ("NUMBER",)
+    FUNCTION = "op"
+    CATEGORY = "math/number"
+
+    def op(self, op: str, a: number, b: number) -> tuple[float]:
+        return (FLOAT_BINARY_OPERATIONS[op](float(a), float(b)),)
+
+
+class NumberBinaryCondition:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {
+            "required": {
+                "op": (list(FLOAT_BINARY_CONDITIONS.keys()),),
+                "a": DEFAULT_NUMBER,
+                "b": DEFAULT_NUMBER,
+            }
+        }
+
+    RETURN_TYPES = ("BOOL",)
+    FUNCTION = "op"
+    CATEGORY = "math/float"
+
+    def op(self, op: str, a: number, b: number) -> tuple[bool]:
+        return (FLOAT_BINARY_CONDITIONS[op](float(a), float(b)),)
+
+
+NODE_CLASS_MAPPINGS = {
+    "CM_NumberUnaryOperation": NumberUnaryOperation,
+    "CM_NumberUnaryCondition": NumberUnaryCondition,
+    "CM_NumberBinaryOperation": NumberBinaryOperation,
+    "CM_NumberBinaryCondition": NumberBinaryCondition,
+}

ComfyUI/custom_nodes/ComfyMath/src/comfymath/vec.py

@@ -0,0 +1,501 @@
+import numpy
+
+from typing import Any, Callable, Mapping, TypeAlias
+
+Vec2: TypeAlias = tuple[float, float]
+VEC2_ZERO = (0.0, 0.0)
+DEFAULT_VEC2 = ("VEC2", {"default": VEC2_ZERO})
+
+Vec3: TypeAlias = tuple[float, float, float]
+VEC3_ZERO = (0.0, 0.0, 0.0)
+DEFAULT_VEC3 = ("VEC3", {"default": VEC3_ZERO})
+
+Vec4: TypeAlias = tuple[float, float, float, float]
+VEC4_ZERO = (0.0, 0.0, 0.0, 0.0)
+DEFAULT_VEC4 = ("VEC4", {"default": VEC4_ZERO})
+
+VEC_UNARY_OPERATIONS: Mapping[str, Callable[[numpy.ndarray], numpy.ndarray]] = {
+    "Neg": lambda a: -a,
+    "Normalize": lambda a: a / numpy.linalg.norm(a),
+}
+
+VEC_TO_SCALAR_UNARY_OPERATION: Mapping[str, Callable[[numpy.ndarray], float]] = {
+    "Norm": lambda a: numpy.linalg.norm(a).astype(float),
+}
+
+VEC_UNARY_CONDITIONS: Mapping[str, Callable[[numpy.ndarray], bool]] = {
+    "IsZero": lambda a: not numpy.any(a).astype(bool),
+    "IsNotZero": lambda a: numpy.any(a).astype(bool),
+    "IsNormalized": lambda a: numpy.allclose(a, a / numpy.linalg.norm(a)),
+    "IsNotNormalized": lambda a: not numpy.allclose(a, a / numpy.linalg.norm(a)),
+}
+
+VEC_BINARY_OPERATIONS: Mapping[
+    str, Callable[[numpy.ndarray, numpy.ndarray], numpy.ndarray]
+] = {
+    "Add": lambda a, b: a + b,
+    "Sub": lambda a, b: a - b,
+    "Cross": lambda a, b: numpy.cross(a, b),
+}
+
+VEC_TO_SCALAR_BINARY_OPERATION: Mapping[
+    str, Callable[[numpy.ndarray, numpy.ndarray], float]
+] = {
+    "Dot": lambda a, b: numpy.dot(a, b),
+    "Distance": lambda a, b: numpy.linalg.norm(a - b).astype(float),
+}
+
+VEC_BINARY_CONDITIONS: Mapping[str, Callable[[numpy.ndarray, numpy.ndarray], bool]] = {
+    "Eq": lambda a, b: numpy.allclose(a, b),
+    "Neq": lambda a, b: not numpy.allclose(a, b),
+}
+
+VEC_SCALAR_OPERATION: Mapping[str, Callable[[numpy.ndarray, float], numpy.ndarray]] = {
+    "Mul": lambda a, b: a * b,
+    "Div": lambda a, b: a / b,
+}
+
+
+def _vec2_from_numpy(a: numpy.ndarray) -> Vec2:
+    return (
+        float(a[0]),
+        float(a[1]),
+    )
+
+
+def _vec3_from_numpy(a: numpy.ndarray) -> Vec3:
+    return (
+        float(a[0]),
+        float(a[1]),
+        float(a[2]),
+    )
+
+
+def _vec4_from_numpy(a: numpy.ndarray) -> Vec4:
+    return (
+        float(a[0]),
+        float(a[1]),
+        float(a[2]),
+        float(a[3]),
+    )
+
+
+class Vec2UnaryOperation:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {
+            "required": {
+                "op": (list(VEC_UNARY_OPERATIONS.keys()),),
+                "a": DEFAULT_VEC2,
+            }
+        }
+
+    RETURN_TYPES = ("VEC2",)
+    FUNCTION = "op"
+    CATEGORY = "math/vec2"
+
+    def op(self, op: str, a: Vec2) -> tuple[Vec2]:
+        return (_vec2_from_numpy(VEC_UNARY_OPERATIONS[op](numpy.array(a))),)
+
+
+class Vec2ToScalarUnaryOperation:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {
+            "required": {
+                "op": (list(VEC_TO_SCALAR_UNARY_OPERATION.keys()),),
+                "a": DEFAULT_VEC2,
+            }
+        }
+
+    RETURN_TYPES = ("FLOAT",)
+    FUNCTION = "op"
+    CATEGORY = "math/vec2"
+
+    def op(self, op: str, a: Vec2) -> tuple[float]:
+        return (VEC_TO_SCALAR_UNARY_OPERATION[op](numpy.array(a)),)
+
+
+class Vec2UnaryCondition:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {
+            "required": {
+                "op": (list(VEC_UNARY_CONDITIONS.keys()),),
+                "a": DEFAULT_VEC2,
+            }
+        }
+
+    RETURN_TYPES = ("BOOL",)
+    FUNCTION = "op"
+    CATEGORY = "math/vec2"
+
+    def op(self, op: str, a: Vec2) -> tuple[bool]:
+        return (VEC_UNARY_CONDITIONS[op](numpy.array(a)),)
+
+
+class Vec2BinaryOperation:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {
+            "required": {
+                "op": (list(VEC_BINARY_OPERATIONS.keys()),),
+                "a": DEFAULT_VEC2,
+                "b": DEFAULT_VEC2,
+            }
+        }
+
+    RETURN_TYPES = ("VEC2",)
+    FUNCTION = "op"
+    CATEGORY = "math/vec2"
+
+    def op(self, op: str, a: Vec2, b: Vec2) -> tuple[Vec2]:
+        return (
+            _vec2_from_numpy(VEC_BINARY_OPERATIONS[op](numpy.array(a), numpy.array(b))),
+        )
+
+
+class Vec2ToScalarBinaryOperation:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {
+            "required": {
+                "op": (list(VEC_TO_SCALAR_BINARY_OPERATION.keys()),),
+                "a": DEFAULT_VEC2,
+                "b": DEFAULT_VEC2,
+            }
+        }
+
+    RETURN_TYPES = ("FLOAT",)
+    FUNCTION = "op"
+    CATEGORY = "math/vec2"
+
+    def op(self, op: str, a: Vec2, b: Vec2) -> tuple[float]:
+        return (VEC_TO_SCALAR_BINARY_OPERATION[op](numpy.array(a), numpy.array(b)),)
+
+
+class Vec2BinaryCondition:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {
+            "required": {
+                "op": (list(VEC_BINARY_CONDITIONS.keys()),),
+                "a": DEFAULT_VEC2,
+                "b": DEFAULT_VEC2,
+            }
+        }
+
+    RETURN_TYPES = ("BOOL",)
+    FUNCTION = "op"
+    CATEGORY = "math/vec2"
+
+    def op(self, op: str, a: Vec2, b: Vec2) -> tuple[bool]:
+        return (VEC_BINARY_CONDITIONS[op](numpy.array(a), numpy.array(b)),)
+
+
+class Vec2ScalarOperation:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {
+            "required": {
+                "op": (list(VEC_SCALAR_OPERATION.keys()),),
+                "a": DEFAULT_VEC2,
+                "b": ("FLOAT",),
+            }
+        }
+
+    RETURN_TYPES = ("VEC2",)
+    FUNCTION = "op"
+    CATEGORY = "math/vec2"
+
+    def op(self, op: str, a: Vec2, b: float) -> tuple[Vec2]:
+        return (_vec2_from_numpy(VEC_SCALAR_OPERATION[op](numpy.array(a), b)),)
+
+
+class Vec3UnaryOperation:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {
+            "required": {
+                "op": (list(VEC_UNARY_OPERATIONS.keys()),),
+                "a": DEFAULT_VEC3,
+            }
+        }
+
+    RETURN_TYPES = ("VEC3",)
+    FUNCTION = "op"
+    CATEGORY = "math/vec3"
+
+    def op(self, op: str, a: Vec3) -> tuple[Vec3]:
+        return (_vec3_from_numpy(VEC_UNARY_OPERATIONS[op](numpy.array(a))),)
+
+
+class Vec3ToScalarUnaryOperation:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {
+            "required": {
+                "op": (list(VEC_TO_SCALAR_UNARY_OPERATION.keys()),),
+                "a": DEFAULT_VEC3,
+            }
+        }
+
+    RETURN_TYPES = ("FLOAT",)
+    FUNCTION = "op"
+    CATEGORY = "math/vec3"
+
+    def op(self, op: str, a: Vec3) -> tuple[float]:
+        return (VEC_TO_SCALAR_UNARY_OPERATION[op](numpy.array(a)),)
+
+
+class Vec3UnaryCondition:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {
+            "required": {
+                "op": (list(VEC_UNARY_CONDITIONS.keys()),),
+                "a": DEFAULT_VEC3,
+            }
+        }
+
+    RETURN_TYPES = ("BOOL",)
+    FUNCTION = "op"
+    CATEGORY = "math/vec3"
+
+    def op(self, op: str, a: Vec3) -> tuple[bool]:
+        return (VEC_UNARY_CONDITIONS[op](numpy.array(a)),)
+
+
+class Vec3BinaryOperation:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {
+            "required": {
+                "op": (list(VEC_BINARY_OPERATIONS.keys()),),
+                "a": DEFAULT_VEC3,
+                "b": DEFAULT_VEC3,
+            }
+        }
+
+    RETURN_TYPES = ("VEC3",)
+    FUNCTION = "op"
+    CATEGORY = "math/vec3"
+
+    def op(self, op: str, a: Vec3, b: Vec3) -> tuple[Vec3]:
+        return (
+            _vec3_from_numpy(VEC_BINARY_OPERATIONS[op](numpy.array(a), numpy.array(b))),
+        )
+
+
+class Vec3ToScalarBinaryOperation:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {
+            "required": {
+                "op": (list(VEC_TO_SCALAR_BINARY_OPERATION.keys()),),
+                "a": DEFAULT_VEC3,
+                "b": DEFAULT_VEC3,
+            }
+        }
+
+    RETURN_TYPES = ("FLOAT",)
+    FUNCTION = "op"
+    CATEGORY = "math/vec3"
+
+    def op(self, op: str, a: Vec3, b: Vec3) -> tuple[float]:
+        return (VEC_TO_SCALAR_BINARY_OPERATION[op](numpy.array(a), numpy.array(b)),)
+
+
+class Vec3BinaryCondition:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {
+            "required": {
+                "op": (list(VEC_BINARY_CONDITIONS.keys()),),
+                "a": DEFAULT_VEC3,
+                "b": DEFAULT_VEC3,
+            }
+        }
+
+    RETURN_TYPES = ("BOOL",)
+    FUNCTION = "op"
+    CATEGORY = "math/vec3"
+
+    def op(self, op: str, a: Vec3, b: Vec3) -> tuple[bool]:
+        return (VEC_BINARY_CONDITIONS[op](numpy.array(a), numpy.array(b)),)
+
+
+class Vec3ScalarOperation:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {
+            "required": {
+                "op": (list(VEC_SCALAR_OPERATION.keys()),),
+                "a": DEFAULT_VEC3,
+                "b": ("FLOAT",),
+            }
+        }
+
+    RETURN_TYPES = ("VEC3",)
+    FUNCTION = "op"
+    CATEGORY = "math/vec3"
+
+    def op(self, op: str, a: Vec3, b: float) -> tuple[Vec3]:
+        return (_vec3_from_numpy(VEC_SCALAR_OPERATION[op](numpy.array(a), b)),)
+
+
+class Vec4UnaryOperation:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {
+            "required": {
+                "op": (list(VEC_UNARY_OPERATIONS.keys()),),
+                "a": DEFAULT_VEC4,
+            }
+        }
+
+    RETURN_TYPES = ("VEC4",)
+    FUNCTION = "op"
+    CATEGORY = "math/vec4"
+
+    def op(self, op: str, a: Vec4) -> tuple[Vec4]:
+        return (_vec4_from_numpy(VEC_UNARY_OPERATIONS[op](numpy.array(a))),)
+
+
+class Vec4ToScalarUnaryOperation:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {
+            "required": {
+                "op": (list(VEC_TO_SCALAR_UNARY_OPERATION.keys()),),
+                "a": DEFAULT_VEC4,
+            }
+        }
+
+    RETURN_TYPES = ("FLOAT",)
+    FUNCTION = "op"
+    CATEGORY = "math/vec4"
+
+    def op(self, op: str, a: Vec4) -> tuple[float]:
+        return (VEC_TO_SCALAR_UNARY_OPERATION[op](numpy.array(a)),)
+
+
+class Vec4UnaryCondition:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {
+            "required": {
+                "op": (list(VEC_UNARY_CONDITIONS.keys()),),
+                "a": DEFAULT_VEC4,
+            }
+        }
+
+    RETURN_TYPES = ("BOOL",)
+    FUNCTION = "op"
+    CATEGORY = "math/vec4"
+
+    def op(self, op: str, a: Vec4) -> tuple[bool]:
+        return (VEC_UNARY_CONDITIONS[op](numpy.array(a)),)
+
+
+class Vec4BinaryOperation:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {
+            "required": {
+                "op": (list(VEC_BINARY_OPERATIONS.keys()),),
+                "a": DEFAULT_VEC4,
+                "b": DEFAULT_VEC4,
+            }
+        }
+
+    RETURN_TYPES = ("VEC4",)
+    FUNCTION = "op"
+    CATEGORY = "math/vec4"
+
+    def op(self, op: str, a: Vec4, b: Vec4) -> tuple[Vec4]:
+        return (
+            _vec4_from_numpy(VEC_BINARY_OPERATIONS[op](numpy.array(a), numpy.array(b))),
+        )
+
+
+class Vec4ToScalarBinaryOperation:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {
+            "required": {
+                "op": (list(VEC_TO_SCALAR_BINARY_OPERATION.keys()),),
+                "a": DEFAULT_VEC4,
+                "b": DEFAULT_VEC4,
+            }
+        }
+
+    RETURN_TYPES = ("FLOAT",)
+    FUNCTION = "op"
+    CATEGORY = "math/vec4"
+
+    def op(self, op: str, a: Vec4, b: Vec4) -> tuple[float]:
+        return (VEC_TO_SCALAR_BINARY_OPERATION[op](numpy.array(a), numpy.array(b)),)
+
+
+class Vec4BinaryCondition:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {
+            "required": {
+                "op": (list(VEC_BINARY_CONDITIONS.keys()),),
+                "a": DEFAULT_VEC4,
+                "b": DEFAULT_VEC4,
+            }
+        }
+
+    RETURN_TYPES = ("BOOL",)
+    FUNCTION = "op"
+    CATEGORY = "math/vec4"
+
+    def op(self, op: str, a: Vec4, b: Vec4) -> tuple[bool]:
+        return (VEC_BINARY_CONDITIONS[op](numpy.array(a), numpy.array(b)),)
+
+
+class Vec4ScalarOperation:
+    @classmethod
+    def INPUT_TYPES(cls) -> Mapping[str, Any]:
+        return {
+            "required": {
+                "op": (list(VEC_SCALAR_OPERATION.keys()),),
+                "a": DEFAULT_VEC4,
+                "b": ("FLOAT",),
+            }
+        }
+
+    RETURN_TYPES = ("VEC4",)
+    FUNCTION = "op"
+    CATEGORY = "math/vec4"
+
+    def op(self, op: str, a: Vec4, b: float) -> tuple[Vec4]:
+        return (_vec4_from_numpy(VEC_SCALAR_OPERATION[op](numpy.array(a), b)),)
+
+
+NODE_CLASS_MAPPINGS = {
+    "CM_Vec2UnaryOperation": Vec2UnaryOperation,
+    "CM_Vec2UnaryCondition": Vec2UnaryCondition,
+    "CM_Vec2ToScalarUnaryOperation": Vec2ToScalarUnaryOperation,
+    "CM_Vec2BinaryOperation": Vec2BinaryOperation,
+    "CM_Vec2BinaryCondition": Vec2BinaryCondition,
+    "CM_Vec2ToScalarBinaryOperation": Vec2ToScalarBinaryOperation,
+    "CM_Vec2ScalarOperation": Vec2ScalarOperation,
+    "CM_Vec3UnaryOperation": Vec3UnaryOperation,
+    "CM_Vec3UnaryCondition": Vec3UnaryCondition,
+    "CM_Vec3ToScalarUnaryOperation": Vec3ToScalarUnaryOperation,
+    "CM_Vec3BinaryOperation": Vec3BinaryOperation,
+    "CM_Vec3BinaryCondition": Vec3BinaryCondition,
+    "CM_Vec3ToScalarBinaryOperation": Vec3ToScalarBinaryOperation,
+    "CM_Vec3ScalarOperation": Vec3ScalarOperation,
+    "CM_Vec4UnaryOperation": Vec4UnaryOperation,
+    "CM_Vec4UnaryCondition": Vec4UnaryCondition,
+    "CM_Vec4ToScalarUnaryOperation": Vec4ToScalarUnaryOperation,
+    "CM_Vec4BinaryOperation": Vec4BinaryOperation,
+    "CM_Vec4BinaryCondition": Vec4BinaryCondition,
+    "CM_Vec4ToScalarBinaryOperation": Vec4ToScalarBinaryOperation,
+    "CM_Vec4ScalarOperation": Vec4ScalarOperation,
+}

ComfyUI/custom_nodes/ComfyUI-AutomaticCFG/README.md

@@ -0,0 +1,175 @@
+# Abandon this boat and jump on [this one!](https://github.com/Extraltodeus/Skimmed_CFG)
+
+If you liked other functionnalities, I've re-created most in [this](https://github.com/Extraltodeus/pre_cfg_comfy_nodes_for_ComfyUI) repository.
+
+# In short:
+
+My own version "from scratch" of a self-rescaling CFG / anti-burn. It ain't much but it's honest work.
+
+No more burns and 160% faster gens with the warp drive node.
+
+Now includes custom attention modifiers and interesting presets as well as temperature scaling.
+
+Also just tested and it works with pixart sigma.
+
+Works with SD3 for as long as you don't use any boost feature / cutting the uncond (it's the same thing). 20 steps works nicely.
+
+# Note:
+
+The presets are interpreted with eval(). Make sure that you thrust whoever sent a preset to you as it may be used to execute malicious code.
+
+# Update:
+
+- Removed and perfected "Uncond Zero" node and moved it to it's [own repository](https://github.com/Extraltodeus/Uncond-Zero-for-ComfyUI/tree/main)
+- Removed temperature nodes and set a [repository](https://github.com/Extraltodeus/Stable-Diffusion-temperature-settings) for these
+
+# Usage:
+
+![77889aa6-a2f6-48bf-8cde-17c9cbfda5fa](https://github.com/Extraltodeus/ComfyUI-AutomaticCFG/assets/15731540/c725a06c-8966-43de-ab1c-569e2ff5b151)
+
+
+### That's it!
+
+- The "boost" toggle will turn off the negative guidance when the sigmas are near 1. This doubles the inference speed.
+- The negative strength lerp the cond and uncond. Now in normal times the way I do this would burn things to the ground. But since it is initialy an anti-burn it just works. This idea is inspired by the [negative prompt weight](https://github.com/muerrilla/stable-diffusion-NPW) repository.
+- I leave the advanced node for those who are interested. It will not be beneficial to those who do not feel like experimenting.
+
+For 100 steps this is where the sigma are reaching 1:
+
+![image](https://github.com/Extraltodeus/ComfyUI-AutomaticCFG/assets/15731540/525199f1-2857-4027-a96e-105bc4b01860)
+
+Note: the warp drive node improves the speed a lot more. The average speed is 160% the normal one if used with the AYS scheduler (check the workflow images).
+
+There seem to be a slight improvement in quality when using the boost with my other node [CLIP Vector Sculptor text encode](https://github.com/Extraltodeus/Vector_Sculptor_ComfyUI) using the "mean" normalization option.
+
+# Just a note:
+
+Your CFG won't be your CFG anymore. It is turned into a way to guide the CFG/final intensity/brightness/saturation. So don't hesitate to change your habits while trying!
+
+# The rest of the explaination:
+
+While this node is connected, this will turn your sampler's CFG scale into something else.
+This methods works by rescaling the CFG at each step by evaluating the potential average min/max values. Aiming at a desired output intensity (by intensity I mean overall brightness/saturation/sharpness).
+The base intensity has been arbitrarily chosen by me and your sampler's CFG scale will make this target vary.
+I have set the "central" CFG at 8. Meaning that at 4 you will aim at half of the desired range while at 16 it will be doubled. This makes it feel slightly like the usual when you're around the normal values.
+
+The CFG behavior during the sampling being automatically set for each channel makes it behave differently and therefores gives different outputs than the usual.
+From my observations by printing the results while testing, it seems to be going from around 16 at the beginning, to something like 4 near the middle and ends up near ~7. 
+These values might have changed since I've done a thousand tests with different ways but that's to give you an idea, it's just me eyeballing the CLI's output.
+
+I use the upper and lower 25% topk mean value as a reference to have some margin of manoeuver.
+
+It makes the sampling generate overall better quality images. I get much less if not any artifacts anymore and my more creative prompts also tends to give more random, in a good way, different results.
+
+I attribute this more random yet positive behavior to the fact that it seems to be starting high and then since it becomes lower, it self-corrects and improvise, taking advantage of the sampling process a lot more.
+
+It is dead simple to use and made sampling more fun from my perspective :)
+
+You will find it in the model_patches category.
+
+TLDR: set your CFG at 8 to try it. No burned images and artifacts anymore. CFG is also a bit more sensitive because it's a proportion around 8.
+
+Low scale like 4 also gives really nice results since your CFG is not the CFG anymore.
+
+# Updates:
+
+Updated:
+- Up to 28.5% faster generation speed than normal
+- Negative weighting
+
+05.04.24:
+
+- Updated to latest ComfyUI version. If you get an error: update your ComfyUI
+
+15.04.24
+
+- ~~Added "no uncond" node which completely disable the negative and doubles the speed while rescaling the latent space in the post-cfg function up until the sigmas are at 1 (or really, 6.86%). By itself it is not perfect and I'm searching for solutions to improve the final result. It seems to work better with dpmpp3m_sde/exponential if you're not using anything else. If you are using the PAG node then you don't need to care about the sampler but will generate at a normal speed. Result will be simply different (I personally like them).~~ use the warp drive instead
+- To use the [PAG node](https://github.com/pamparamm/sd-perturbed-attention/tree/master) ~~without the complete slow-down (if using the no-uncond node) or at least take advantage of the boost feature:~~
+  ~~- in the "pag_nodes.py" file look for "disable_cfg1_optimization=True"~~
+  ~~- set it to "disable_cfg1_optimization=False".~~ This is not necessary anymore because the dev modified it already :)
+- For the negative lerp function in the other nodes the scale has been divided by two. So if you were using it at 10, set it to 5.
+
+16.04.24
+
+- Added "uncond_start_percentage" as an experimental feature. This allows to start the guidance later as a way to try [Applying Guidance in a Limited Interval Improves
+Sample and Distribution Quality in Diffusion Models](https://arxiv.org/pdf/2404.07724.pdf). A more accurate implementation [can be found here](https://github.com/ericbeyer/guidance_interval) :)
+
+17.04.24
+
+- reworked the advanced node and cleaned up
+- added timing on every options
+- add a post-rescale node which allows to fight deep-frying images a bit more forr some special cases
+- added a tweaked version of the Comfy SAG node with start/end sliders
+- changed start/end sliders, they are related directly to the sigma values and not in percentage anymore. ⚠
+
+01.05.24
+
+- Actually working disabled uncond
+- Added "warp drive" preset to test it out simply.
+
+03.05.24
+
+- Allows unpatch `turn off the negative` by removing or disconnecting the node.
+- added the "Warp drive" node. It uses a new method of my own cooking which uses the previous step to determin a negative. Cutting the generation time by half for approx 3/4 of the steps.
+- added example workflows with 10-12 steps but of course you can do more steps if needed. It is not a goal to do less steps in general but also to show it is compatible.
+
+14.05.24:
+- fix the little mem leak 😀
+- temporarily disabled the timed SAG node because an update broke it.
+- added node: **preset loader**. Can do what the other can and much more like modify the attention mechanisms! Mostly tested on SDXL 😀!
+    - Some presets are slower than others. Just like for the perturbed attention guidance for example. Most are just as fast.
+    - About some of the presets:
+        - For SD 1.5 "crossed conds customized 3" seems amazing!
+        - "Enhanced_details_and_tweaked_attention" works better on creative generations and less on characters.
+        - "Reinforced_style" does not regulates the CFG, gives MUCH MORE importance to your negative prompt, works with 12 steps and is slightly slower.
+        - "The red riding latent" only works with SDXL. It is an almost nonsensical mix of attention tweaks. Best with 12 steps and really nice with creative prompts. Has the tendency to give more red clothings to the characters. Hence the name.
+        - "Excellent_attention" is the default settings for the node described below. Don't delete it or the node won't work. 🙃
+        - "Potato Attention Guidance" is really nice for portraits of happy people...
+        - There are a bunch of others. I've generated examples which you can find in the example grids folder.
+    - Most of these have been tested on SDXL. I have very little idea of the effect on SD 1.5
+    - The presets are .json files and can contain a string which will go through eval(). ⚠
+    - Always check what is inside before running it when it comes from someone else! I hesitated to share a preset which would plan a shutdown in 60 seconds named "actually shut down the computer in one minute" to let you be aware but that would bother more than it would be helfpul.
+- added node: "**Excellent attention**" developped by myself and based on this [astonishingly easy to understand research paper!](https://github.com/Extraltodeus/temp/blob/main/very_science.jpg) But in short:
+   - Just try it. [Do it](https://www.youtube.com/watch?v=ZXsQAXx_ao0).
+   - This node allows to disable the input layer 8 on self and cross attention.
+   - But also to apply a custom modification on cross attention middle layer 0. The "patch_cond" and "patch_uncond" toggles are about this modification.
+   - While the modification is definitely not very ressource costy, the light patch uses less VRAM.
+   - The multiplier influences the cross attention and reinforces prompt-following. But like for real. Works better with the "light patch" toggle ON.
+   - I have ~~only~~ mostly tested it with SDXL.
+   - You can find a grid example of this node's settings in the "grids_example" folder.
+   - For some reason the Juggernaut model does not work with it and I have no idea why.
+- Customizable attention modifiers:
+     - Check the ["attention_modifiers_explainations"](https://github.com/Extraltodeus/ComfyUI-AutomaticCFG/blob/main/workflows/attention_modifiers_explainations.png) in the workflows. 👀 It is basically a tutorial.
+     - Experiment what each layer really do by using what is basically a bruteforcing node! (the Attention modifiers tester node)
+     - This is how you do a [Perturbed Attention Guidance](https://github.com/Extraltodeus/temp/blob/main/PAG.png) for example
+
+
+
+# Examples
+
+### 10 steps with only 2 having the negative enabled. So ~170% faster. 2.5 seconds on a RTX4070
+
+![03640UI_00001_](https://github.com/Extraltodeus/ComfyUI-AutomaticCFG/assets/15731540/673cb47a-095f-4ebb-a186-2f6a49ffd2e1)
+
+### cherry-picked 24 steps uncond fully disabled (these images are also workflows):
+
+
+![03619UI_00001_](https://github.com/Extraltodeus/ComfyUI-AutomaticCFG/assets/15731540/19ee6edc-b039-4472-9ec2-c08ea15dd908)
+
+![03621UI_00001_](https://github.com/Extraltodeus/ComfyUI-AutomaticCFG/assets/15731540/52695e1c-d28e-427f-9109-7ee4e4b3a5f6)
+
+![03604UI_00001_](https://github.com/Extraltodeus/ComfyUI-AutomaticCFG/assets/15731540/ca391b46-f587-43da-98da-a87e4982e4ed)
+
+
+
+# Pro tip:
+
+Did you know that my first activity is to write creative model merging functions?
+
+While the code is too much of a mess to be shared, I do expose and share my models. You can find them in this [gallery](https://github.com/Extraltodeus/shared_models_galleries)! 😁
+
+
+-----
+
+Thanks to ComfyUI for existing and making such things so simple!
+

ComfyUI/custom_nodes/ComfyUI-AutomaticCFG/__init__.py

@@ -0,0 +1,27 @@
+from .nodes import *
+# from .experimental_temperature import ExperimentalTemperaturePatchSDXL,ExperimentalTemperaturePatchSD15,CLIPTemperaturePatch,CLIPTemperaturePatchDual
+# from .nodes_sag_custom import * 
+
+NODE_CLASS_MAPPINGS = {
+    "Automatic CFG": simpleDynamicCFG,
+    "Automatic CFG - Negative": simpleDynamicCFGlerpUncond,
+    "Automatic CFG - Warp Drive": simpleDynamicCFGwarpDrive,
+    "Automatic CFG - Preset Loader": presetLoader,
+    "Automatic CFG - Excellent attention": simpleDynamicCFGExcellentattentionPatch,
+    "Automatic CFG - Advanced": advancedDynamicCFG,
+    "Automatic CFG - Post rescale only": postCFGrescaleOnly,
+    "Automatic CFG - Custom attentions": simpleDynamicCFGCustomAttentionPatch,
+    "Automatic CFG - Attention modifiers": attentionModifierParametersNode,
+    "Automatic CFG - Attention modifiers tester": attentionModifierBruteforceParametersNode,
+    "Automatic CFG - Unpatch function": simpleDynamicCFGunpatch,
+    # "Zero Uncond CFG - standalone patch (incompatible with the others)":uncondZeroNode,
+    # "Temperature settings SDXL": ExperimentalTemperaturePatchSDXL,
+    # "Temperature settings SD 1.5": ExperimentalTemperaturePatchSD15,
+    # "Temperature settings CLIP": CLIPTemperaturePatch,
+    # "Temperature separate settings CLIP SDXL": CLIPTemperaturePatchDual,
+    # "SAG delayed activation": SelfAttentionGuidanceCustom,
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "Automatic CFG - Unpatch function": "Automatic CFG - Unpatch function(Deprecated)",
+}

ComfyUI/custom_nodes/ComfyUI-AutomaticCFG/experimental_temperature.py

@@ -0,0 +1,208 @@
+import torch
+from torch import nn, einsum
+from einops import rearrange, repeat
+import torch.nn.functional as F
+import math
+from comfy import model_management
+import types
+import os
+
+def exists(val):
+    return val is not None
+
+# better than a division by 0 hey
+abs_mean = lambda x: torch.where(torch.isnan(x) | torch.isinf(x), torch.zeros_like(x), x).abs().mean()
+
+class temperature_patcher():
+    def __init__(self, temperature, layer_name="None"):
+        self.temperature = temperature
+        self.layer_name  = layer_name
+    
+    # taken from comfy.ldm.modules
+    def attention_basic_with_temperature(self, q, k, v, extra_options, mask=None, attn_precision=None):
+        if isinstance(extra_options, int):
+            heads = extra_options
+        else:
+            heads = extra_options['n_heads']
+
+        b, _, dim_head = q.shape
+        dim_head //= heads
+        scale = dim_head ** -0.5
+
+        h = heads
+        q, k, v = map(
+            lambda t: t.unsqueeze(3)
+            .reshape(b, -1, heads, dim_head)
+            .permute(0, 2, 1, 3)
+            .reshape(b * heads, -1, dim_head)
+            .contiguous(),
+            (q, k, v),
+        )
+
+        # force cast to fp32 to avoid overflowing
+        if attn_precision == torch.float32:
+            sim = einsum('b i d, b j d -> b i j', q.float(), k.float()) * scale
+        else:
+            sim = einsum('b i d, b j d -> b i j', q, k) * scale
+
+        del q, k
+
+        if exists(mask):
+            if mask.dtype == torch.bool:
+                mask = rearrange(mask, 'b ... -> b (...)')
+                max_neg_value = -torch.finfo(sim.dtype).max
+                mask = repeat(mask, 'b j -> (b h) () j', h=h)
+                sim.masked_fill_(~mask, max_neg_value)
+            else:
+                if len(mask.shape) == 2:
+                    bs = 1
+                else:
+                    bs = mask.shape[0]
+                mask = mask.reshape(bs, -1, mask.shape[-2], mask.shape[-1]).expand(b, heads, -1, -1).reshape(-1, mask.shape[-2], mask.shape[-1])
+                sim.add_(mask)
+
+        # attention, what we cannot get enough of
+        sim = sim.div(self.temperature if self.temperature > 0 else abs_mean(sim)).softmax(dim=-1)
+
+        out = einsum('b i j, b j d -> b i d', sim.to(v.dtype), v)
+        out = (
+            out.unsqueeze(0)
+            .reshape(b, heads, -1, dim_head)
+            .permute(0, 2, 1, 3)
+            .reshape(b, -1, heads * dim_head)
+        )
+        return out
+
+layers_SD15 = {
+    "input":[1,2,4,5,7,8],
+    "middle":[0],
+    "output":[3,4,5,6,7,8,9,10,11],
+}
+
+layers_SDXL = {
+    "input":[4,5,7,8],
+    "middle":[0],
+    "output":[0,1,2,3,4,5],
+}
+
+class ExperimentalTemperaturePatch:
+    @classmethod
+    def INPUT_TYPES(s):
+        required_inputs = {f"{key}_{layer}": ("BOOLEAN", {"default": False}) for key, layers in s.TOGGLES.items() for layer in layers}
+        required_inputs["model"] = ("MODEL",)
+        required_inputs["Temperature"]  = ("FLOAT", {"default": 1.0, "min": 0.0, "max": 10.0, "step": 0.01, "round": 0.01})
+        required_inputs["Attention"]    = (["both","self","cross"],)
+        return {"required": required_inputs}
+    
+    TOGGLES = {}
+    RETURN_TYPES = ("MODEL","STRING",)
+    RETURN_NAMES = ("Model","String",)
+    FUNCTION = "patch"
+
+    CATEGORY = "model_patches/Automatic_CFG/Standalone_temperature_patches"
+
+    def patch(self, model, Temperature, Attention, **kwargs):
+        m = model.clone()
+        levels = ["input","middle","output"]
+        parameters_output = {level:[] for level in levels}
+        for key, toggle_enabled in kwargs.items():
+            current_level = key.split("_")[0]
+            if current_level in levels and toggle_enabled:
+                b_number = int(key.split("_")[1])
+                parameters_output[current_level].append(b_number)
+                patcher = temperature_patcher(Temperature,key)
+
+                if Attention in ["both","self"]:
+                    m.set_model_attn1_replace(patcher.attention_basic_with_temperature, current_level, b_number)
+                if Attention in ["both","cross"]:
+                    m.set_model_attn2_replace(patcher.attention_basic_with_temperature, current_level, b_number)
+
+        parameters_as_string = "\n".join(f"{k}: {','.join(map(str, v))}" for k, v in parameters_output.items())
+        parameters_as_string = f"Temperature: {Temperature}\n{parameters_as_string}\nAttention: {Attention}"
+        return (m, parameters_as_string,)
+    
+ExperimentalTemperaturePatchSDXL = type("ExperimentalTemperaturePatch_SDXL", (ExperimentalTemperaturePatch,), {"TOGGLES": layers_SDXL})
+ExperimentalTemperaturePatchSD15 = type("ExperimentalTemperaturePatch_SD15", (ExperimentalTemperaturePatch,), {"TOGGLES": layers_SD15})
+
+class CLIPTemperaturePatch:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {"required": { "clip": ("CLIP",),
+                              "Temperature": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 10.0, "step": 0.01}),
+                              }}
+    
+    RETURN_TYPES = ("CLIP",)
+    FUNCTION = "patch"
+    CATEGORY = "model_patches/Automatic_CFG/Standalone_temperature_patches"
+    
+    def patch(self, clip, Temperature):
+        def custom_optimized_attention(device, mask=None, small_input=True):
+            return temperature_patcher(Temperature).attention_basic_with_temperature
+        
+        def new_forward(self, x, mask=None, intermediate_output=None):
+            optimized_attention = custom_optimized_attention(x.device, mask=mask is not None, small_input=True)
+
+            if intermediate_output is not None:
+                if intermediate_output < 0:
+                    intermediate_output = len(self.layers) + intermediate_output
+
+            intermediate = None
+            for i, l in enumerate(self.layers):
+                x = l(x, mask, optimized_attention)
+                if i == intermediate_output:
+                    intermediate = x.clone()
+            return x, intermediate
+
+        m = clip.clone()
+
+        clip_encoder_instance = m.cond_stage_model.clip_l.transformer.text_model.encoder
+        clip_encoder_instance.forward = types.MethodType(new_forward, clip_encoder_instance)
+
+        if getattr(m.cond_stage_model, f"clip_g", None) is not None:
+            clip_encoder_instance_g = m.cond_stage_model.clip_g.transformer.text_model.encoder
+            clip_encoder_instance_g.forward = types.MethodType(new_forward, clip_encoder_instance_g)
+        
+        return (m,)
+
+class CLIPTemperaturePatchDual:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {"required": { "clip": ("CLIP",),
+                              "Temperature": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 10.0, "step": 0.01}),
+                              "CLIP_Model": (["clip_g","clip_l","both"],),
+                              }}
+    
+    RETURN_TYPES = ("CLIP",)
+    FUNCTION = "patch"
+    CATEGORY = "model_patches/Automatic_CFG/Standalone_temperature_patches"
+    
+    def patch(self, clip, Temperature, CLIP_Model):
+        def custom_optimized_attention(device, mask=None, small_input=True):
+            return temperature_patcher(Temperature, "CLIP").attention_basic_with_temperature
+        
+        def new_forward(self, x, mask=None, intermediate_output=None):
+            optimized_attention = custom_optimized_attention(x.device, mask=mask is not None, small_input=True)
+
+            if intermediate_output is not None:
+                if intermediate_output < 0:
+                    intermediate_output = len(self.layers) + intermediate_output
+
+            intermediate = None
+            for i, l in enumerate(self.layers):
+                x = l(x, mask, optimized_attention)
+                if i == intermediate_output:
+                    intermediate = x.clone()
+            return x, intermediate
+
+        m = clip.clone()
+
+        if CLIP_Model in ["clip_l","both"]:
+            clip_encoder_instance = m.cond_stage_model.clip_l.transformer.text_model.encoder
+            clip_encoder_instance.forward = types.MethodType(new_forward, clip_encoder_instance)
+
+        if CLIP_Model in ["clip_g","both"]:
+            if getattr(m.cond_stage_model, f"clip_g", None) is not None:
+                clip_encoder_instance_g = m.cond_stage_model.clip_g.transformer.text_model.encoder
+                clip_encoder_instance_g.forward = types.MethodType(new_forward, clip_encoder_instance_g)
+        
+        return (m,)

ComfyUI/custom_nodes/ComfyUI-AutomaticCFG/nodes.py

@@ -0,0 +1,1292 @@
+import math
+from copy import deepcopy
+from torch.nn import Upsample
+import comfy.model_management as model_management
+from comfy.model_patcher import set_model_options_patch_replace
+from comfy.ldm.modules.attention import attention_basic, attention_xformers, attention_pytorch, attention_split, attention_sub_quad, optimized_attention_for_device
+from .experimental_temperature import temperature_patcher
+import comfy.samplers
+import comfy.utils
+import numpy as np
+import torch
+import torch.nn.functional as F
+from colorama import Fore, Style
+import json
+import os
+import random
+import base64
+
+original_sampling_function = None
+current_dir = os.path.dirname(os.path.realpath(__file__))
+json_preset_path = os.path.join(current_dir, 'presets')
+attnfunc = optimized_attention_for_device(model_management.get_torch_device())
+check_string   = "UEFUUkVPTi50eHQ="
+support_string = b'CgoKClRoYW5rIHlvdSBmb3IgdXNpbmcgbXkgbm9kZXMhCgpJZiB5b3UgZW5qb3kgaXQsIHBsZWFzZSBjb25zaWRlciBzdXBwb3J0aW5nIG1lIG9uIFBhdHJlb24gdG8ga2VlcCB0aGUgbWFnaWMgZ29pbmchCgpWaXNpdDoKCmh0dHBzOi8vd3d3LnBhdHJlb24uY29tL2V4dHJhbHRvZGV1cwoKCgo='
+
+def support_function():
+    if base64.b64decode(check_string).decode('utf8') not in os.listdir(current_dir):
+        print(base64.b64decode(check_string).decode('utf8'))
+        print(base64.b64decode(support_string).decode('utf8'))
+
+def sampling_function_patched(model, x, timestep, uncond, cond, cond_scale, model_options={}, seed=None, **kwargs):
+
+    cond_copy   = cond
+    uncond_copy = uncond
+
+    for fn in model_options.get("sampler_patch_model_pre_cfg_function", []):
+        args = {"model": model, "sigma": timestep, "model_options": model_options}
+        model, model_options = fn(args)
+
+    if "sampler_pre_cfg_automatic_cfg_function" in model_options:
+        uncond, cond, cond_scale = model_options["sampler_pre_cfg_automatic_cfg_function"](
+            sigma=timestep, uncond=uncond, cond=cond, cond_scale=cond_scale
+        )
+        
+    if math.isclose(cond_scale, 1.0) and model_options.get("disable_cfg1_optimization", False) == False:
+        uncond_ = None
+    else:
+        uncond_ = uncond
+
+    conds = [cond, uncond_]
+
+    out = comfy.samplers.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)
+
+    cond_pred = out[0]
+    uncond_pred = out[1]
+
+    if "sampler_cfg_function" in model_options:
+        args = {"cond": x - cond_pred, "uncond": x - uncond_pred, "cond_scale": cond_scale, "timestep": timestep, "input": x, "sigma": timestep,
+                "cond_denoised": cond_pred, "uncond_denoised": uncond_pred, "model": model, "model_options": model_options, "cond_pos": cond_copy, "cond_neg": uncond_copy}
+        cfg_result = x - model_options["sampler_cfg_function"](args)
+    else:
+        cfg_result = uncond_pred + (cond_pred - uncond_pred) * cond_scale
+
+    for fn in model_options.get("sampler_post_cfg_function", []):
+        args = {"denoised": cfg_result, "cond": cond_copy, "uncond": uncond_copy, "model": model, "uncond_denoised": uncond_pred, "cond_denoised": cond_pred,
+                "sigma": timestep, "model_options": model_options, "input": x}
+        cfg_result = fn(args)
+        
+    return cfg_result
+
+def monkey_patching_comfy_sampling_function():
+    global original_sampling_function
+
+    if original_sampling_function is None:
+        original_sampling_function = comfy.samplers.sampling_function
+    # Make sure to only patch once
+    if hasattr(comfy.samplers.sampling_function, '_automatic_cfg_decorated'):
+        return
+    comfy.samplers.sampling_function = sampling_function_patched
+    comfy.samplers.sampling_function._automatic_cfg_decorated = True # flag to check monkey patch
+
+def make_sampler_pre_cfg_automatic_cfg_function(minimum_sigma_to_disable_uncond=0, maximum_sigma_to_enable_uncond=1000000, disabled_cond_start=10000,disabled_cond_end=10000):
+    def sampler_pre_cfg_automatic_cfg_function(sigma, uncond, cond, cond_scale, **kwargs):
+        if sigma[0] < minimum_sigma_to_disable_uncond or sigma[0] > maximum_sigma_to_enable_uncond:
+            uncond = None
+        if sigma[0] <= disabled_cond_start and sigma[0] > disabled_cond_end:
+            cond = None
+        return uncond, cond, cond_scale
+    return sampler_pre_cfg_automatic_cfg_function
+
+def get_entropy(tensor):
+    hist = np.histogram(tensor.cpu(), bins=100)[0]
+    hist = hist / hist.sum()
+    hist = hist[hist > 0]
+    return -np.sum(hist * np.log2(hist))
+
+def map_sigma(sigma, sigmax, sigmin):
+    return 1 + ((sigma - sigmax) * (0 - 1)) / (sigmin - sigmax)
+
+def center_latent_mean_values(latent, per_channel, mult):
+    for b in range(len(latent)):
+        if per_channel:
+            for c in range(len(latent[b])):
+                latent[b][c] -= latent[b][c].mean() * mult
+        else:
+            latent[b] -= latent[b].mean() * mult
+    return latent
+
+def get_denoised_ranges(latent, measure="hard", top_k=0.25):
+    chans = []
+    for x in range(len(latent)):
+        max_values = torch.topk(latent[x] - latent[x].mean() if measure == "range" else latent[x], k=int(len(latent[x])*top_k), largest=True).values
+        min_values = torch.topk(latent[x] - latent[x].mean() if measure == "range" else latent[x], k=int(len(latent[x])*top_k), largest=False).values
+        max_val = torch.mean(max_values).item()
+        min_val = abs(torch.mean(min_values).item()) if measure == "soft" else torch.mean(torch.abs(min_values)).item()
+        denoised_range = (max_val + min_val) / 2
+        chans.append(denoised_range**2 if measure == "hard_squared" else denoised_range)
+    return chans
+
+def get_sigmin_sigmax(model):
+    model_sampling = model.model.model_sampling
+    sigmin = model_sampling.sigma(model_sampling.timestep(model_sampling.sigma_min))
+    sigmax = model_sampling.sigma(model_sampling.timestep(model_sampling.sigma_max))
+    return sigmin, sigmax
+
+def gaussian_similarity(x, y, sigma=1.0):
+    diff = (x - y) ** 2
+    return torch.exp(-diff / (2 * sigma ** 2))
+    
+def check_skip(sigma, high_sigma_threshold, low_sigma_threshold):
+    return sigma > high_sigma_threshold or sigma < low_sigma_threshold
+
+def max_abs(tensors):
+    shape = tensors.shape
+    tensors = tensors.reshape(shape[0], -1)
+    tensors_abs = torch.abs(tensors)
+    max_abs_idx = torch.argmax(tensors_abs, dim=0)
+    result = tensors[max_abs_idx, torch.arange(tensors.shape[1])]
+    return result.reshape(shape[1:])
+
+def gaussian_kernel(size: int, sigma: float):
+    x = torch.arange(size) - size // 2
+    gauss = torch.exp(-x**2 / (2 * sigma**2))
+    kernel = gauss / gauss.sum()
+    return kernel.view(1, size) * kernel.view(size, 1)
+
+def blur_tensor(tensor, kernel_size = 9, sigma = 2.0):
+    tensor = tensor.unsqueeze(0)
+    C = tensor.size(1)
+    kernel = gaussian_kernel(kernel_size, sigma)
+    kernel = kernel.expand(C, 1, kernel_size, kernel_size).to(tensor.device).to(dtype=tensor.dtype, device=tensor.device)
+    padding = kernel_size // 2
+    tensor = F.pad(tensor, (padding, padding, padding, padding), mode='reflect')
+    blurred_tensor = F.conv2d(tensor, kernel, groups=C)
+    return blurred_tensor.squeeze(0)
+
+def smallest_distances(tensors):
+    if all(torch.equal(tensors[0], tensor) for tensor in tensors[1:]):
+        return tensors[0]
+    set_device = tensors.device
+    min_val = torch.full(tensors[0].shape, float("inf")).to(set_device)
+    result  = torch.zeros_like(tensors[0])
+    for idx1, t1 in enumerate(tensors):
+        temp_diffs = torch.zeros_like(tensors[0])
+        for idx2, t2 in enumerate(tensors):
+            if idx1 != idx2:
+                temp_diffs += torch.abs(torch.sub(t1, t2))
+        min_val = torch.minimum(min_val, temp_diffs)
+        mask    = torch.eq(min_val,temp_diffs)
+        result[mask] = t1[mask]
+    return result
+
+def rescale(tensor, multiplier=2):
+    batch, seq_length, features = tensor.shape
+    H = W = int(seq_length**0.5)
+    tensor_reshaped = tensor.view(batch, features, H, W)
+    new_H = new_W = int(H * multiplier)
+    resized_tensor = F.interpolate(tensor_reshaped, size=(new_H, new_W), mode='bilinear', align_corners=False)
+    return resized_tensor.view(batch, new_H * new_W, features)
+
+# from  https://discuss.pytorch.org/t/help-regarding-slerp-function-for-generative-model-sampling/32475
+def slerp(high, low, val):
+    dims = low.shape
+
+    #flatten to batches
+    low = low.reshape(dims[0], -1)
+    high = high.reshape(dims[0], -1)
+
+    low_norm = low/torch.norm(low, dim=1, keepdim=True)
+    high_norm = high/torch.norm(high, dim=1, keepdim=True)
+
+    # in case we divide by zero
+    low_norm[low_norm != low_norm] = 0.0
+    high_norm[high_norm != high_norm] = 0.0
+
+    omega = torch.acos((low_norm*high_norm).sum(1))
+    so = torch.sin(omega)
+    res = (torch.sin((1.0-val)*omega)/so).unsqueeze(1)*low + (torch.sin(val*omega)/so).unsqueeze(1) * high
+    return res.reshape(dims)
+
+normalize_tensor = lambda x: x / x.norm()
+
+def random_swap(tensors, proportion=1):
+    num_tensors = tensors.shape[0]
+    if num_tensors < 2: return tensors[0],0
+    tensor_size = tensors[0].numel()
+    if tensor_size < 100: return tensors[0],0
+
+    true_count = int(tensor_size * proportion)
+    mask = torch.cat((torch.ones(true_count, dtype=torch.bool, device=tensors[0].device), 
+                      torch.zeros(tensor_size - true_count, dtype=torch.bool, device=tensors[0].device)))
+    mask = mask[torch.randperm(tensor_size)].reshape(tensors[0].shape)
+    if num_tensors == 2 and proportion < 1:
+        index_tensor = torch.ones_like(tensors[0], dtype=torch.int64, device=tensors[0].device)
+    else:
+        index_tensor = torch.randint(1 if proportion < 1 else 0, num_tensors, tensors[0].shape, device=tensors[0].device)
+    for i, t in enumerate(tensors):
+        if i == 0: continue
+        merge_mask = index_tensor == i & mask
+        tensors[0][merge_mask] = t[merge_mask]
+    return tensors[0]
+
+def multi_tensor_check_mix(tensors):
+    if tensors[0].numel() < 2 or len(tensors) < 2:
+        return tensors[0]
+    ref_tensor_shape = tensors[0].shape
+    sequence_tensor = torch.arange(tensors[0].numel(), device=tensors[0].device) % len(tensors)
+    reshaped_sequence = sequence_tensor.view(ref_tensor_shape)
+    for i in range(len(tensors)):
+        if i == 0: continue
+        mask = reshaped_sequence == i
+        tensors[0][mask] = tensors[i][mask]
+    return tensors[0]
+
+def sspow(input_tensor, p=2):
+    return input_tensor.abs().pow(p) * input_tensor.sign()
+
+def sspown(input_tensor, p=2):
+    abs_t = input_tensor.abs()
+    abs_t = (abs_t - abs_t.min()) / (abs_t.max() - abs_t.min())
+    return abs_t.pow(p) * input_tensor.sign()
+
+def gradient_merge(tensor1, tensor2, start_value=0, dim=0):
+    if torch.numel(tensor1) <= 1: return tensor1
+    if dim >= tensor1.dim(): dim = 0
+    size = tensor1.size(dim)
+    alpha = torch.linspace(start_value, 1-start_value, steps=size, device=tensor1.device).view([-1 if i == dim else 1 for i in range(tensor1.dim())])
+    return tensor1 * alpha + tensor2 * (1 - alpha)
+
+def save_tensor(input_tensor,name):
+    if "rndnum" in name:
+        rndnum = str(random.randint(100000,999999))
+        name = name.replace("rndnum", rndnum)
+    output_directory = os.path.join(current_dir, 'saved_tensors')
+    os.makedirs(output_directory, exist_ok=True)
+    output_file_path = os.path.join(output_directory, f"{name}.pt")
+    torch.save(input_tensor, output_file_path)
+    return input_tensor
+
+def print_and_return(input_tensor, *args):
+    for what_to_print in args:
+        print(" ",what_to_print)
+    return input_tensor
+
+# Experimental testings
+def normal_attention(q, k, v, mask=None):
+    attention_scores = torch.matmul(q, k.transpose(-2, -1))
+    d_k = k.size(-1)
+    attention_scores = attention_scores / torch.sqrt(torch.tensor(d_k, dtype=torch.float32))
+    if mask is not None:
+        attention_scores = attention_scores.masked_fill(mask == 0, float('-inf'))
+    attention_weights = F.softmax(attention_scores, dim=-1)
+    output = torch.matmul(attention_weights, v)
+    return output
+
+def split_heads(x, n_heads):
+    batch_size, seq_length, hidden_dim = x.size()
+    head_dim = hidden_dim // n_heads
+    x = x.view(batch_size, seq_length, n_heads, head_dim)
+    return x.permute(0, 2, 1, 3)
+
+def combine_heads(x, n_heads):
+    batch_size, n_heads, seq_length, head_dim = x.size()
+    hidden_dim = n_heads * head_dim
+    x = x.permute(0, 2, 1, 3).contiguous()
+    return x.view(batch_size, seq_length, hidden_dim)
+
+def sparsemax(logits):
+    logits_sorted, _ = torch.sort(logits, descending=True, dim=-1)
+    cumulative_sum = torch.cumsum(logits_sorted, dim=-1) - 1
+    rho = (logits_sorted > cumulative_sum / (torch.arange(logits.size(-1)) + 1).to(logits.device)).float()
+    tau = (cumulative_sum / rho.sum(dim=-1, keepdim=True)).gather(dim=-1, index=rho.sum(dim=-1, keepdim=True).long() - 1)
+    return torch.max(torch.zeros_like(logits), logits - tau)
+
+def attnfunc_custom(q, k, v, n_heads, eval_string = ""):
+    q = split_heads(q, n_heads)
+    k = split_heads(k, n_heads)
+    v = split_heads(v, n_heads)
+    
+    d_k = q.size(-1)
+
+    scores = torch.matmul(q, k.transpose(-2, -1)) / math.sqrt(d_k)
+
+    if eval_string == "":
+        attn_weights = F.softmax(scores, dim=-1)
+    else:
+        attn_weights = eval(eval_string)
+
+    output = torch.matmul(attn_weights, v)
+    output = combine_heads(output, n_heads)
+    return output
+
+def min_max_norm(t):
+    return (t - t.min()) / (t.max() - t.min())
+
+class attention_modifier():
+    def __init__(self, self_attn_mod_eval, conds = None):
+        self.self_attn_mod_eval = self_attn_mod_eval
+        self.conds = conds
+
+    def modified_attention(self, q, k, v, extra_options, mask=None):
+        
+        """extra_options contains: {'cond_or_uncond': [1, 0], 'sigmas': tensor([14.6146], device='cuda:0'),
+         'original_shape': [2, 4, 128, 128], 'transformer_index': 4, 'block': ('middle', 0),
+         'block_index': 3, 'n_heads': 20, 'dim_head': 64, 'attn_precision': None}"""
+        
+        if "attnbc" in self.self_attn_mod_eval:
+            attnbc = attention_basic(q, k, v, extra_options['n_heads'], mask)
+        if "normattn" in self.self_attn_mod_eval:
+            normattn = normal_attention(q, k, v, mask)
+        if "attnxf" in self.self_attn_mod_eval:
+            attnxf = attention_xformers(q, k, v, extra_options['n_heads'], mask)
+        if "attnpy" in self.self_attn_mod_eval:
+            attnpy = attention_pytorch(q, k, v, extra_options['n_heads'], mask)
+        if "attnsp" in self.self_attn_mod_eval:
+            attnsp = attention_split(q, k, v, extra_options['n_heads'], mask)
+        if "attnsq" in self.self_attn_mod_eval:
+            attnsq = attention_sub_quad(q, k, v, extra_options['n_heads'], mask)
+        if "attnopt" in self.self_attn_mod_eval:
+            attnopt = attnfunc(q, k, v, extra_options['n_heads'], mask)
+        n_heads = extra_options['n_heads']
+        if self.conds is not None:
+            cond_pos_l = self.conds[0][..., :768].cuda()
+            cond_neg_l = self.conds[1][..., :768].cuda()
+            if self.conds[0].shape[-1] > 768:
+                cond_pos_g = self.conds[0][..., 768:2048].cuda()
+                cond_neg_g = self.conds[1][..., 768:2048].cuda()
+        return eval(self.self_attn_mod_eval)
+
+def experimental_functions(cond_input, method, exp_value, exp_normalize, pcp, psi, sigma, sigmax, attention_modifiers_input, args, model_options_copy, eval_string = ""):
+    """
+    There may or may not be an actual reasoning behind each of these methods.
+    Some like the sine value have interesting properties. Enabled for both cond and uncond preds it somehow make them stronger.
+    Note that there is a "normalize" toggle and it may change greatly the end result since some operation will totaly butcher the values.
+    "theDaRkNeSs" for example without normalizing seems to darken if used for cond/uncond (not with the cond as the uncond or something).
+    Maybe just with the positive. I don't remember. I leave it for now if you want to play around.
+
+    The eval_string can be used to create the uncond replacement.
+    I made it so it's split by semicolons and only the last split is the value in used.
+    What is before is added in an array named "v".
+    pcp is previous cond_pred
+    psi is previous sigma
+    args is the CFG function input arguments with the added cond/unconds (like the actual activation conditionings) named respectively "cond_pos" and "cond_neg"
+
+    So if you write:
+
+    pcp if sigma < 7 else -pcp;
+    print("it works too just don't use the output I guess");
+    v[0] if sigma < 14 else torch.zeros_like(cond);
+    v[-1]*2
+    
+    Well the first line becomes v[0], second v[1] etc.
+    The last one becomes the result.
+    Note that it's just an example, I don't see much interest in that one.
+
+    Using comfy.samplers.calc_cond_batch(args["model"], [args["cond_pos"], None], args["input"], args["timestep"], args["model_options"])[0]
+    can work too.
+
+    This whole mess has for initial goal to attempt to find the best way (or have some bruteforcing fun) to replace the uncond pred for as much as possible.
+    Or simply to try things around :)
+    """
+    if method == "cond_pred":
+        return cond_input
+    default_device = cond_input.device
+    # print()
+    # print(get_entropy(cond))
+    cond = cond_input.clone()
+    cond_norm = cond.norm()
+    if method == "amplify":
+        mask = torch.abs(cond) >= 1
+        cond_copy = cond.clone()
+        cond = torch.pow(torch.abs(cond), ( 1 / exp_value)) * cond.sign()
+        cond[mask] = torch.pow(torch.abs(cond_copy[mask]), exp_value) * cond[mask].sign()
+    elif method == "root":
+        cond = torch.pow(torch.abs(cond), ( 1 / exp_value)) * cond.sign()
+    elif method == "power":
+        cond = torch.pow(torch.abs(cond), exp_value) * cond.sign()
+    elif method == "erf":
+        cond = torch.erf(cond)
+    elif method == "exp_erf":
+        cond = torch.pow(torch.erf(cond), exp_value)
+    elif method == "root_erf":
+        cond = torch.erf(cond)
+        cond = torch.pow(torch.abs(cond), 1 / exp_value ) * cond.sign()
+    elif method == "erf_amplify":
+        cond = torch.erf(cond)
+        mask = torch.abs(cond) >= 1
+        cond_copy = cond.clone()
+        cond = torch.pow(torch.abs(cond), 1 / exp_value ) * cond.sign()
+        cond[mask] = torch.pow(torch.abs(cond_copy[mask]), exp_value) * cond[mask].sign()
+    elif method == "sine":
+        cond = torch.sin(torch.abs(cond)) * cond.sign()
+    elif method == "sine_exp":
+        cond = torch.sin(torch.abs(cond)) * cond.sign()
+        cond = torch.pow(torch.abs(cond), exp_value) * cond.sign()
+    elif method == "sine_exp_diff":
+        cond = torch.sin(torch.abs(cond)) * cond.sign()
+        cond = torch.pow(torch.abs(cond_input), exp_value) * cond.sign() - cond
+    elif method == "sine_exp_diff_to_sine":
+        cond = torch.sin(torch.abs(cond)) * cond.sign()
+        cond = torch.pow(torch.abs(cond), exp_value) * cond.sign() - cond
+    elif method == "sine_root":
+        cond = torch.sin(torch.abs(cond)) * cond.sign()
+        cond = torch.pow(torch.abs(cond), ( 1 / exp_value)) * cond.sign()
+    elif method == "sine_root_diff":
+        cond = torch.sin(torch.abs(cond)) * cond.sign()
+        cond = torch.pow(torch.abs(cond_input), 1 / exp_value) * cond.sign() - cond
+    elif method == "sine_root_diff_to_sine":
+        cond = torch.sin(torch.abs(cond)) * cond.sign()
+        cond = torch.pow(torch.abs(cond), 1 / exp_value) * cond.sign() - cond
+    elif method == "theDaRkNeSs":
+        cond = torch.sin(cond)
+        cond = torch.pow(torch.abs(cond), 1 / exp_value) * cond.sign() - cond
+    elif method == "cosine":
+        cond = torch.cos(torch.abs(cond)) * cond.sign()
+    elif method == "sign":
+        cond = cond.sign()
+    elif method == "zero":
+        cond = torch.zeros_like(cond)
+    elif method in ["attention_modifiers_input_using_cond","attention_modifiers_input_using_uncond","subtract_attention_modifiers_input_using_cond","subtract_attention_modifiers_input_using_uncond"]:
+        cond_to_use = args["cond_pos"] if method in ["attention_modifiers_input_using_cond","subtract_attention_modifiers_input_using_cond"] else args["cond_neg"]
+        tmp_model_options = deepcopy(model_options_copy)
+        for atm in attention_modifiers_input:
+            if sigma <= atm['sigma_start'] and sigma > atm['sigma_end']:
+                block_layers = {"input": atm['unet_block_id_input'], "middle": atm['unet_block_id_middle'], "output": atm['unet_block_id_output']}
+                for unet_block in block_layers:
+                    for unet_block_id in block_layers[unet_block].split(","):
+                        if unet_block_id != "":
+                            unet_block_id = int(unet_block_id)
+                            tmp_model_options = set_model_options_patch_replace(tmp_model_options, attention_modifier(atm['self_attn_mod_eval'], [args["cond_pos"][0]["cross_attn"], args["cond_neg"][0]["cross_attn"]]if "cond" in atm['self_attn_mod_eval'] else None).modified_attention, atm['unet_attn'], unet_block, unet_block_id)
+        
+        cond = comfy.samplers.calc_cond_batch(args["model"], [cond_to_use], args["input"], args["timestep"], tmp_model_options)[0]
+        if method in ["subtract_attention_modifiers_input_using_cond","subtract_attention_modifiers_input_using_uncond"]:
+            cond = cond_input + (cond_input - cond) * exp_value
+
+    elif method == "previous_average":
+        if sigma > (sigmax - 1):
+            cond = torch.zeros_like(cond)
+        else:
+            cond = (pcp / psi * sigma + cond) / 2
+    elif method == "eval":
+        if "condmix" in eval_string:
+            def condmix(args, mult=2):
+                cond_pos_tmp = deepcopy(args["cond_pos"])
+                cond_pos_tmp[0]["cross_attn"] += (args["cond_pos"][0]["cross_attn"] - args["cond_neg"][0]["cross_attn"]*-1) * mult
+                return cond_pos_tmp
+        v = []
+        evals_strings = eval_string.split(";")
+        if len(evals_strings) > 1:
+            for i in range(len(evals_strings[:-1])):
+                v.append(eval(evals_strings[i]))
+        cond = eval(evals_strings[-1])
+    if exp_normalize and torch.all(cond != 0):
+        cond = cond * cond_norm / cond.norm()
+    # print(get_entropy(cond))
+    return cond.to(device=default_device)
+
+class advancedDynamicCFG:
+    def __init__(self):
+        self.last_cfg_ht_one = 8
+        self.previous_cond_pred = None
+        
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                                "model": ("MODEL",),
+
+                                "automatic_cfg" : (["None", "soft", "hard", "hard_squared", "range"], {"default": "hard"},),
+
+                                "skip_uncond" : ("BOOLEAN", {"default": True}),
+                                "fake_uncond_start" : ("BOOLEAN", {"default": False}),
+                                "uncond_sigma_start": ("FLOAT", {"default": 1000, "min": 0.0, "max": 10000.0, "step": 0.1, "round": 0.01}),
+                                "uncond_sigma_end":   ("FLOAT", {"default": 1, "min": 0.0, "max": 10000.0, "step": 0.1, "round": 0.01}),
+
+                                "lerp_uncond" : ("BOOLEAN", {"default": False}),
+                                "lerp_uncond_strength":    ("FLOAT", {"default": 2, "min": 0.0, "max": 10.0, "step": 0.1, "round": 0.1}),
+                                "lerp_uncond_sigma_start": ("FLOAT", {"default": 1000,  "min": 0.0, "max": 10000.0, "step": 0.1, "round": 0.01}),
+                                "lerp_uncond_sigma_end":   ("FLOAT", {"default": 1, "min": 0.0, "max": 10000.0, "step": 0.1, "round": 0.01}),
+
+                                "subtract_latent_mean" : ("BOOLEAN", {"default": False}),
+                                "subtract_latent_mean_sigma_start": ("FLOAT", {"default": 1000,  "min": 0.0, "max": 10000.0, "step": 0.1, "round": 0.01}),
+                                "subtract_latent_mean_sigma_end":   ("FLOAT", {"default": 1, "min": 0.0, "max": 10000.0, "step": 0.1, "round": 0.01}),
+
+                                "latent_intensity_rescale"     : ("BOOLEAN", {"default": False}),
+                                "latent_intensity_rescale_method" : (["soft","hard","range"], {"default": "hard"},),
+                                "latent_intensity_rescale_cfg": ("FLOAT", {"default": 8,  "min": 0.0, "max": 100.0, "step": 0.1, "round": 0.1}),
+                                "latent_intensity_rescale_sigma_start": ("FLOAT", {"default": 1000,  "min": 0.0, "max": 10000.0, "step": 0.1, "round": 0.01}),
+                                "latent_intensity_rescale_sigma_end":   ("FLOAT", {"default": 3, "min": 0.0, "max": 10000.0, "step": 0.1, "round": 0.01}),
+
+                                "cond_exp": ("BOOLEAN", {"default": False}),
+                                "cond_exp_normalize": ("BOOLEAN", {"default": False}),
+                                "cond_exp_sigma_start": ("FLOAT", {"default": 1000,  "min": 0.0, "max": 10000.0, "step": 0.1, "round": 0.01}),
+                                "cond_exp_sigma_end":   ("FLOAT", {"default": 1,   "min": 0.0, "max": 10000.0, "step": 0.1, "round": 0.01}),
+                                "cond_exp_method": (["amplify", "root", "power", "erf", "erf_amplify", "exp_erf", "root_erf", "sine", "sine_exp", "sine_exp_diff", "sine_exp_diff_to_sine", "sine_root", "sine_root_diff", "sine_root_diff_to_sine", "theDaRkNeSs", "cosine", "sign", "zero", "previous_average", "eval",
+                                                     "attention_modifiers_input_using_cond","attention_modifiers_input_using_uncond",
+                                                     "subtract_attention_modifiers_input_using_cond","subtract_attention_modifiers_input_using_uncond"],),
+                                "cond_exp_value": ("FLOAT", {"default": 2, "min": 0, "max": 100, "step": 0.1, "round": 0.01}),
+                                
+                                "uncond_exp": ("BOOLEAN", {"default": False}),
+                                "uncond_exp_normalize": ("BOOLEAN", {"default": False}),
+                                "uncond_exp_sigma_start": ("FLOAT", {"default": 1000,  "min": 0.0, "max": 10000.0, "step": 0.1, "round": 0.01}),
+                                "uncond_exp_sigma_end":   ("FLOAT", {"default": 1,   "min": 0.0, "max": 10000.0, "step": 0.1, "round": 0.01}),
+                                "uncond_exp_method": (["amplify", "root", "power", "erf", "erf_amplify", "exp_erf", "root_erf", "sine", "sine_exp", "sine_exp_diff", "sine_exp_diff_to_sine", "sine_root", "sine_root_diff", "sine_root_diff_to_sine", "theDaRkNeSs", "cosine", "sign", "zero", "previous_average", "eval",
+                                                       "subtract_attention_modifiers_input_using_cond","subtract_attention_modifiers_input_using_uncond"],),
+                                "uncond_exp_value": ("FLOAT", {"default": 2, "min": 0, "max": 100, "step": 0.1, "round": 0.01}),
+
+                                "fake_uncond_exp": ("BOOLEAN", {"default": False}),
+                                "fake_uncond_exp_normalize": ("BOOLEAN", {"default": False}),
+                                "fake_uncond_exp_method" : (["cond_pred", "previous_average",
+                                                             "amplify", "root", "power", "erf", "erf_amplify", "exp_erf", "root_erf", "sine", "sine_exp", "sine_exp_diff", "sine_exp_diff_to_sine", "sine_root", "sine_root_diff",
+                                                             "sine_root_diff_to_sine", "theDaRkNeSs", "cosine", "sign", "zero", "eval",
+                                                             "subtract_attention_modifiers_input_using_cond","subtract_attention_modifiers_input_using_uncond",
+                                                             "attention_modifiers_input_using_cond","attention_modifiers_input_using_uncond"],),
+                                "fake_uncond_exp_value": ("FLOAT", {"default": 2, "min": 0, "max": 1000, "step": 0.1, "round": 0.01}),
+                                "fake_uncond_multiplier": ("INT", {"default": 1, "min": -1, "max": 1, "step": 1}),
+                                "fake_uncond_sigma_start": ("FLOAT", {"default": 1000,  "min": 0.0, "max": 10000.0, "step": 0.1, "round": 0.01}),
+                                "fake_uncond_sigma_end": ("FLOAT", {"default": 1,  "min": 0.0, "max": 10000.0, "step": 0.1, "round": 0.01}),
+                                "auto_cfg_topk":    ("FLOAT", {"default": 0.25, "min": 0.0, "max": 0.5, "step": 0.05, "round": 0.01}),
+                                "auto_cfg_ref":    ("FLOAT", {"default": 8, "min": 0.0, "max": 100, "step": 0.5, "round": 0.01}),
+                                "attention_modifiers_global_enabled": ("BOOLEAN", {"default": False}),
+                                "disable_cond": ("BOOLEAN", {"default": False}),
+                                "disable_cond_sigma_start": ("FLOAT", {"default": 1000, "min": 0.0, "max": 10000.0, "step": 0.1, "round": 0.01}),
+                                "disable_cond_sigma_end":   ("FLOAT", {"default": 0, "min": 0.0, "max": 10000.0, "step": 0.1, "round": 0.01}),
+                                "save_as_preset": ("BOOLEAN", {"default": False}),
+                                "preset_name": ("STRING", {"multiline": False}),
+                              },
+                              "optional":{
+                                  "eval_string_cond": ("STRING", {"multiline": True}),
+                                  "eval_string_uncond": ("STRING", {"multiline": True}),
+                                  "eval_string_fake": ("STRING", {"multiline": True}),
+                                  "args_filter": ("STRING", {"multiline": True, "forceInput": True}),
+                                  "attention_modifiers_positive": ("ATTNMOD", {"forceInput": True}),
+                                  "attention_modifiers_negative": ("ATTNMOD", {"forceInput": True}),
+                                  "attention_modifiers_fake_negative": ("ATTNMOD", {"forceInput": True}),
+                                  "attention_modifiers_global": ("ATTNMOD", {"forceInput": True}),
+                              }
+                              }
+    RETURN_TYPES = ("MODEL","STRING",)
+    FUNCTION = "patch"
+
+    CATEGORY = "model_patches/Automatic_CFG"
+
+    def patch(self, model, automatic_cfg = "None",
+              skip_uncond = False, fake_uncond_start = False, uncond_sigma_start = 1000, uncond_sigma_end = 0,
+              lerp_uncond = False, lerp_uncond_strength = 1, lerp_uncond_sigma_start = 1000, lerp_uncond_sigma_end = 1,
+              subtract_latent_mean     = False,   subtract_latent_mean_sigma_start      = 1000, subtract_latent_mean_sigma_end     = 1,
+              latent_intensity_rescale = False,   latent_intensity_rescale_sigma_start  = 1000, latent_intensity_rescale_sigma_end = 1,
+              cond_exp = False, cond_exp_sigma_start  = 1000, cond_exp_sigma_end = 1000, cond_exp_method = "amplify", cond_exp_value = 2, cond_exp_normalize = False,
+              uncond_exp = False, uncond_exp_sigma_start  = 1000, uncond_exp_sigma_end = 1000, uncond_exp_method = "amplify", uncond_exp_value = 2, uncond_exp_normalize = False,
+              fake_uncond_exp = False, fake_uncond_exp_method = "amplify", fake_uncond_exp_value = 2, fake_uncond_exp_normalize = False, fake_uncond_multiplier = 1, fake_uncond_sigma_start = 1000, fake_uncond_sigma_end = 1,
+              latent_intensity_rescale_cfg = 8, latent_intensity_rescale_method = "hard",
+              ignore_pre_cfg_func = False, args_filter = "", auto_cfg_topk = 0.25, auto_cfg_ref = 8,
+              eval_string_cond = "", eval_string_uncond = "", eval_string_fake = "",
+              attention_modifiers_global_enabled = False,
+              attention_modifiers_positive = [], attention_modifiers_negative = [], attention_modifiers_fake_negative = [], attention_modifiers_global = [],
+              disable_cond=False, disable_cond_sigma_start=1000,disable_cond_sigma_end=1000, save_as_preset = False, preset_name = "", **kwargs
+              ):
+        
+        # support_function()
+        model_options_copy = deepcopy(model.model_options)
+        monkey_patching_comfy_sampling_function()
+        if args_filter != "":
+            args_filter = args_filter.split(",")
+        else:
+            args_filter = [k for k, v in locals().items()]
+        not_in_filter = ['self','model','args','args_filter','save_as_preset','preset_name','model_options_copy']
+        if fake_uncond_exp_method != "eval":
+            not_in_filter.append("eval_string")
+
+        if save_as_preset and preset_name != "":
+            preset_parameters = {key: value for key, value in locals().items() if key not in not_in_filter}
+            with open(os.path.join(json_preset_path, preset_name+".json"), 'w', encoding='utf-8') as f:
+                json.dump(preset_parameters, f)
+            print(f"Preset saved with the name: {Fore.GREEN}{preset_name}{Fore.RESET}")
+            print(f"{Fore.RED}Don't forget to turn the save toggle OFF to not overwrite!{Fore.RESET}")
+
+        args_str = '\n'.join(f'{k}: {v}' for k, v in locals().items() if k not in not_in_filter and k in args_filter)
+
+        sigmin, sigmax = get_sigmin_sigmax(model)
+
+        lerp_start, lerp_end          = lerp_uncond_sigma_start, lerp_uncond_sigma_end
+        subtract_start, subtract_end  = subtract_latent_mean_sigma_start, subtract_latent_mean_sigma_end
+        rescale_start, rescale_end    = latent_intensity_rescale_sigma_start, latent_intensity_rescale_sigma_end
+        print(f"Model maximum sigma: {sigmax} / Model minimum sigma: {sigmin}")
+        m = model.clone()
+
+        if skip_uncond or disable_cond:
+            # set model_options sampler_pre_cfg_automatic_cfg_function
+            m.model_options["sampler_pre_cfg_automatic_cfg_function"] = make_sampler_pre_cfg_automatic_cfg_function(uncond_sigma_end if skip_uncond else 0, uncond_sigma_start if skip_uncond else 100000,\
+                                                                                        disable_cond_sigma_start if disable_cond else 100000, disable_cond_sigma_end if disable_cond else 100000)
+            print(f"Sampling function patched. Uncond enabled from {round(uncond_sigma_start,2)} to {round(uncond_sigma_end,2)}")
+        elif not ignore_pre_cfg_func:
+            m.model_options.pop("sampler_pre_cfg_automatic_cfg_function", None)
+            uncond_sigma_start, uncond_sigma_end = 1000000, 0
+
+        top_k = auto_cfg_topk
+        previous_cond_pred = None
+        previous_sigma = None
+        def automatic_cfg_function(args):
+            nonlocal previous_sigma
+            cond_scale = args["cond_scale"]
+            input_x = args["input"]
+            cond_pred = args["cond_denoised"]
+            uncond_pred = args["uncond_denoised"]
+            sigma = args["sigma"][0]
+            model_options = args["model_options"]
+            if self.previous_cond_pred is None:
+                self.previous_cond_pred = cond_pred.clone().detach().to(device=cond_pred.device)
+            if previous_sigma is None:
+                previous_sigma = sigma.item()
+            reference_cfg = auto_cfg_ref if auto_cfg_ref > 0 else cond_scale
+
+            def fake_uncond_step():
+                return fake_uncond_start and skip_uncond and (sigma > uncond_sigma_start or sigma < uncond_sigma_end) and sigma <= fake_uncond_sigma_start and sigma >= fake_uncond_sigma_end
+
+            if fake_uncond_step():
+                uncond_pred = cond_pred.clone().detach().to(device=cond_pred.device) * fake_uncond_multiplier
+
+            if cond_exp and sigma <= cond_exp_sigma_start and sigma >= cond_exp_sigma_end:
+                cond_pred = experimental_functions(cond_pred, cond_exp_method, cond_exp_value, cond_exp_normalize, self.previous_cond_pred, previous_sigma, sigma.item(), sigmax, attention_modifiers_positive, args, model_options_copy, eval_string_cond)
+            if uncond_exp and sigma <= uncond_exp_sigma_start and sigma >= uncond_exp_sigma_end and not fake_uncond_step():
+                uncond_pred = experimental_functions(uncond_pred, uncond_exp_method, uncond_exp_value, uncond_exp_normalize, self.previous_cond_pred, previous_sigma, sigma.item(), sigmax, attention_modifiers_negative, args, model_options_copy, eval_string_uncond)
+            if fake_uncond_step() and fake_uncond_exp:
+                uncond_pred = experimental_functions(uncond_pred, fake_uncond_exp_method, fake_uncond_exp_value, fake_uncond_exp_normalize, self.previous_cond_pred, previous_sigma, sigma.item(), sigmax, attention_modifiers_fake_negative, args, model_options_copy, eval_string_fake)
+            self.previous_cond_pred = cond_pred.clone().detach().to(device=cond_pred.device)
+
+            if sigma >= sigmax or cond_scale > 1:
+                self.last_cfg_ht_one = cond_scale
+            target_intensity = self.last_cfg_ht_one / 10
+
+            if ((check_skip(sigma, uncond_sigma_start, uncond_sigma_end) and skip_uncond) and not fake_uncond_step()) or cond_scale == 1:
+                return input_x - cond_pred
+
+            if lerp_uncond and not check_skip(sigma, lerp_start, lerp_end) and lerp_uncond_strength != 1:
+                uncond_pred_norm = uncond_pred.norm()
+                uncond_pred = torch.lerp(cond_pred, uncond_pred, lerp_uncond_strength)
+                uncond_pred = uncond_pred * uncond_pred_norm / uncond_pred.norm()
+            cond   = input_x - cond_pred
+            uncond = input_x - uncond_pred
+
+            if automatic_cfg == "None":
+                return uncond + cond_scale * (cond - uncond)
+
+            denoised_tmp = input_x - (uncond + reference_cfg * (cond - uncond))
+
+            for b in range(len(denoised_tmp)):
+                denoised_ranges = get_denoised_ranges(denoised_tmp[b], automatic_cfg, top_k)
+                for c in range(len(denoised_tmp[b])):
+                    fixeds_scale = reference_cfg * target_intensity / denoised_ranges[c]
+                    denoised_tmp[b][c] = uncond[b][c] + fixeds_scale * (cond[b][c] - uncond[b][c])
+
+            return denoised_tmp
+
+        def center_mean_latent_post_cfg(args):
+            denoised = args["denoised"]
+            sigma    = args["sigma"][0]
+            if check_skip(sigma, subtract_start, subtract_end):
+                return denoised
+            denoised = center_latent_mean_values(denoised, False, 1)
+            return denoised
+
+        def rescale_post_cfg(args):
+            denoised   = args["denoised"]
+            sigma      = args["sigma"][0]
+
+            if check_skip(sigma, rescale_start, rescale_end):
+                return denoised
+            target_intensity = latent_intensity_rescale_cfg / 10
+            for b in range(len(denoised)):
+                denoised_ranges = get_denoised_ranges(denoised[b], latent_intensity_rescale_method)
+                for c in range(len(denoised[b])):
+                    scale_correction = target_intensity / denoised_ranges[c]
+                    denoised[b][c]   = denoised[b][c] * scale_correction
+            return denoised
+        
+        tmp_model_options = deepcopy(m.model_options)
+        if attention_modifiers_global_enabled:
+            # print(f"{Fore.GREEN}Sigma timings are ignored for global modifiers.{Fore.RESET}")
+            for atm in attention_modifiers_global:
+                block_layers = {"input": atm['unet_block_id_input'], "middle": atm['unet_block_id_middle'], "output": atm['unet_block_id_output']}
+                for unet_block in block_layers:
+                    for unet_block_id in block_layers[unet_block].split(","):
+                        if unet_block_id != "":
+                            unet_block_id = int(unet_block_id)
+                            tmp_model_options = set_model_options_patch_replace(tmp_model_options, attention_modifier(atm['self_attn_mod_eval']).modified_attention, atm['unet_attn'], unet_block, unet_block_id)
+            m.model_options = tmp_model_options
+
+        if not ignore_pre_cfg_func:
+            m.set_model_sampler_cfg_function(automatic_cfg_function, disable_cfg1_optimization = False)
+        if subtract_latent_mean:
+            m.set_model_sampler_post_cfg_function(center_mean_latent_post_cfg)
+        if latent_intensity_rescale:
+            m.set_model_sampler_post_cfg_function(rescale_post_cfg)
+        return (m, args_str, )
+
+class attentionModifierParametersNode:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                                "sigma_start": ("FLOAT", {"default": 1000, "min": 0.0, "max": 10000.0, "step": 0.1, "round": 0.01}),
+                                "sigma_end":   ("FLOAT", {"default":  0, "min": 0.0, "max": 10000.0, "step": 0.1, "round": 0.01}),
+                                "self_attn_mod_eval":   ("STRING", {"multiline": True }, {"default": ""}),
+                                "unet_block_id_input":  ("STRING", {"multiline": False}, {"default": ""}),
+                                "unet_block_id_middle": ("STRING", {"multiline": False}, {"default": ""}),
+                                "unet_block_id_output": ("STRING", {"multiline": False}, {"default": ""}),
+                                "unet_attn": (["attn1","attn2","both"],),
+                              },
+                              "optional":{
+                                  "join_parameters": ("ATTNMOD", {"forceInput": True}),
+                              }}
+    
+    RETURN_TYPES = ("ATTNMOD","STRING",)
+    RETURN_NAMES = ("Attention modifier", "Parameters as string")
+    FUNCTION = "exec"
+    CATEGORY = "model_patches/Automatic_CFG/experimental_attention_modifiers"
+    def exec(self, join_parameters=None, **kwargs):
+        info_string = "\n".join([f"{k}: {v}" for k,v in kwargs.items() if v != ""])
+        if kwargs['unet_attn'] == "both":
+            copy_kwargs = kwargs.copy()
+            kwargs['unet_attn'] = "attn1"
+            copy_kwargs['unet_attn'] = "attn2"
+            out_modifiers = [kwargs, copy_kwargs]
+        else:
+            out_modifiers = [kwargs]
+        return (out_modifiers if join_parameters is None else join_parameters + out_modifiers, info_string, )
+
+class attentionModifierBruteforceParametersNode:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                                "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
+                                "sigma_start": ("FLOAT", {"default": 1000, "min": 0.0, "max": 10000.0, "step": 0.1, "round": 0.01}),
+                                "sigma_end":   ("FLOAT", {"default":  0, "min": 0.0, "max": 10000.0, "step": 0.1, "round": 0.01}),
+                                "self_attn_mod_eval":   ("STRING", {"multiline": True , "default": ""}),
+                                "unet_block_id_input":  ("STRING", {"multiline": False, "default": "4,5,7,8"}),
+                                "unet_block_id_middle": ("STRING", {"multiline": False, "default": "0"}),
+                                "unet_block_id_output": ("STRING", {"multiline": False, "default": "0,1,2,3,4,5"}),
+                                "unet_attn": (["attn1","attn2","both"],),
+                              },
+                              "optional":{
+                                  "join_parameters": ("ATTNMOD", {"forceInput": True}),
+                              }}
+    
+    RETURN_TYPES = ("ATTNMOD","STRING",)
+    RETURN_NAMES = ("Attention modifier", "Parameters as string")
+    FUNCTION = "exec"
+    CATEGORY = "model_patches/Automatic_CFG/experimental_attention_modifiers"
+
+    def create_sequence_parameters(self, input_str, middle_str, output_str):
+        input_values  = input_str.split(",")  if input_str  else []
+        middle_values = middle_str.split(",") if middle_str else []
+        output_values = output_str.split(",") if output_str else []
+        result = []
+        result.extend([{"unet_block_id_input": val, "unet_block_id_middle": "", "unet_block_id_output": ""} for val in input_values])
+        result.extend([{"unet_block_id_input": "", "unet_block_id_middle": val, "unet_block_id_output": ""} for val in middle_values])
+        result.extend([{"unet_block_id_input": "", "unet_block_id_middle": "", "unet_block_id_output": val} for val in output_values])
+        return result
+
+    def exec(self, seed, join_parameters=None, **kwargs):
+        sequence_parameters = self.create_sequence_parameters(kwargs['unet_block_id_input'],kwargs['unet_block_id_middle'],kwargs['unet_block_id_output'])
+        lenseq = len(sequence_parameters)
+        current_index = seed % lenseq
+        current_sequence = sequence_parameters[current_index]
+        kwargs["unet_block_id_input"]  = current_sequence["unet_block_id_input"]
+        kwargs["unet_block_id_middle"] = current_sequence["unet_block_id_middle"]
+        kwargs["unet_block_id_output"] = current_sequence["unet_block_id_output"]
+        if current_sequence["unet_block_id_input"] != "":
+            current_block_string = f"unet_block_id_input: {current_sequence['unet_block_id_input']}"
+        elif current_sequence["unet_block_id_middle"] != "":
+            current_block_string = f"unet_block_id_middle: {current_sequence['unet_block_id_middle']}"
+        elif current_sequence["unet_block_id_output"] != "":
+            current_block_string = f"unet_block_id_output: {current_sequence['unet_block_id_output']}"
+        info_string = f"Progress: {current_index+1}/{lenseq}\n{kwargs['self_attn_mod_eval']}\n{kwargs['unet_attn']} {current_block_string}"
+        if kwargs['unet_attn'] == "both":
+            copy_kwargs = kwargs.copy()
+            kwargs['unet_attn'] = "attn1"
+            copy_kwargs['unet_attn'] = "attn2"
+            out_modifiers = [kwargs, copy_kwargs]
+        else:
+            out_modifiers = [kwargs]
+        return (out_modifiers if join_parameters is None else join_parameters + out_modifiers, info_string, )
+    
+class attentionModifierConcatNode:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                                "parameters_1": ("ATTNMOD", {"forceInput": True}),
+                                "parameters_2": ("ATTNMOD", {"forceInput": True}),
+                              }}
+    
+    RETURN_TYPES = ("ATTNMOD",)
+    FUNCTION = "exec"
+    CATEGORY = "model_patches/Automatic_CFG/experimental_attention_modifiers"
+    def exec(self, parameters_1, parameters_2):
+        output_parms = parameters_1 + parameters_2
+        return (output_parms, )
+
+class simpleDynamicCFG:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                                "model": ("MODEL",),
+                                "hard_mode" : ("BOOLEAN", {"default": True}),
+                                "boost" : ("BOOLEAN", {"default": True}),
+                              }}
+    RETURN_TYPES = ("MODEL",)
+    FUNCTION = "patch"
+
+    CATEGORY = "model_patches/Automatic_CFG/presets"
+
+    def patch(self, model, hard_mode, boost):
+        advcfg = advancedDynamicCFG()
+        m = advcfg.patch(model,
+                         skip_uncond = boost,
+                         uncond_sigma_start = 1000,  uncond_sigma_end = 1,
+                         automatic_cfg = "hard" if hard_mode else "soft"
+                         )[0]
+        return (m, )
+
+class presetLoader:
+    @classmethod
+    def INPUT_TYPES(s):
+        presets_files = [pj.replace(".json","") for pj in os.listdir(json_preset_path) if ".json" in pj and pj not in ["Experimental_temperature.json","do_not_delete.json"]]
+        presets_files = sorted(presets_files, key=str.lower)
+        return {"required": {
+                                "model": ("MODEL",),
+                                "preset" : (presets_files, {"default": "Excellent_attention"}),
+                                "uncond_sigma_end":   ("FLOAT", {"default": 0.0, "min": 0.0, "max": 10000.0, "step": 0.1, "round": 0.01}),
+                                "use_uncond_sigma_end_from_preset" : ("BOOLEAN", {"default": True}),
+                                "automatic_cfg" : (["From preset","None", "soft", "hard", "hard_squared", "range"],),
+                              },
+                              "optional":{
+                                  "join_global_parameters": ("ATTNMOD", {"forceInput": True}),
+                              }}
+    RETURN_TYPES = ("MODEL", "STRING", "STRING",)
+    RETURN_NAMES = ("Model", "Preset name", "Parameters as string",)
+    FUNCTION = "patch"
+
+    CATEGORY = "model_patches/Automatic_CFG"
+
+    def patch(self, model, preset, uncond_sigma_end, use_uncond_sigma_end_from_preset, automatic_cfg, join_global_parameters=None):
+        with open(os.path.join(json_preset_path, preset+".json"), 'r', encoding='utf-8') as f:
+            preset_args = json.load(f)
+        if not use_uncond_sigma_end_from_preset:
+            preset_args["uncond_sigma_end"] = uncond_sigma_end
+            preset_args["fake_uncond_sigma_end"] = uncond_sigma_end
+            preset_args["fake_uncond_exp_sigma_end"] = uncond_sigma_end
+            preset_args["uncond_exp_sigma_end"] = uncond_sigma_end            
+        
+        if join_global_parameters is not None:
+            preset_args["attention_modifiers_global"] = preset_args["attention_modifiers_global"] + join_global_parameters
+            preset_args["attention_modifiers_global_enabled"] = True
+
+        if automatic_cfg != "From preset":
+            preset_args["automatic_cfg"] = automatic_cfg
+        
+        advcfg = advancedDynamicCFG()
+        m = advcfg.patch(model, **preset_args)[0]
+        info_string = ",\n".join([f"\"{k}\": {v}" for k,v in preset_args.items() if v != ""])
+        print(f"Preset {Fore.GREEN}{preset}{Fore.RESET} loaded successfully!")
+        return (m, preset, info_string,)
+
+class simpleDynamicCFGlerpUncond:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                                "model": ("MODEL",),
+                                "boost" : ("BOOLEAN", {"default": True}),
+                                "negative_strength": ("FLOAT", {"default": 1, "min": 0.0, "max": 5.0, "step": 0.1, "round": 0.1}),
+                              }}
+    RETURN_TYPES = ("MODEL",)
+    FUNCTION = "patch"
+
+    CATEGORY = "model_patches/Automatic_CFG/presets"
+
+    def patch(self, model, boost, negative_strength):
+        advcfg = advancedDynamicCFG()
+        m = advcfg.patch(model=model,
+                         automatic_cfg="hard", skip_uncond=boost,
+                         uncond_sigma_start = 15, uncond_sigma_end = 1,
+                         lerp_uncond=negative_strength != 1, lerp_uncond_strength=negative_strength,
+                         lerp_uncond_sigma_start = 15, lerp_uncond_sigma_end = 1
+                         )[0]
+        return (m, )
+
+class postCFGrescaleOnly:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                                "model": ("MODEL",),
+                                "subtract_latent_mean" : ("BOOLEAN", {"default": True}),
+                                "subtract_latent_mean_sigma_start": ("FLOAT", {"default": 1000,  "min": 0.0, "max": 10000.0, "step": 0.1, "round": 0.1}),
+                                "subtract_latent_mean_sigma_end":   ("FLOAT", {"default": 7.5, "min": 0.0, "max": 10000.0, "step": 0.1, "round": 0.1}),
+                                "latent_intensity_rescale"     : ("BOOLEAN", {"default": True}),
+                                "latent_intensity_rescale_method" : (["soft","hard","range"], {"default": "hard"},),
+                                "latent_intensity_rescale_cfg" : ("FLOAT", {"default": 8,  "min": 0.0, "max": 100.0, "step": 0.1, "round": 0.1}),
+                                "latent_intensity_rescale_sigma_start": ("FLOAT", {"default": 1000,  "min": 0.0, "max": 10000.0, "step": 0.1, "round": 0.1}),
+                                "latent_intensity_rescale_sigma_end":   ("FLOAT", {"default": 5, "min": 0.0, "max": 10000.0, "step": 0.1, "round": 0.1}),
+                              }}
+    RETURN_TYPES = ("MODEL",)
+    FUNCTION = "patch"
+
+    CATEGORY = "model_patches/Automatic_CFG/utils"
+
+    def patch(self, model,
+              subtract_latent_mean, subtract_latent_mean_sigma_start, subtract_latent_mean_sigma_end,
+              latent_intensity_rescale, latent_intensity_rescale_method, latent_intensity_rescale_cfg, latent_intensity_rescale_sigma_start, latent_intensity_rescale_sigma_end
+              ):
+        advcfg = advancedDynamicCFG()
+        m = advcfg.patch(model=model, 
+                         subtract_latent_mean = subtract_latent_mean,
+                         subtract_latent_mean_sigma_start = subtract_latent_mean_sigma_start, subtract_latent_mean_sigma_end = subtract_latent_mean_sigma_end,
+                         latent_intensity_rescale = latent_intensity_rescale, latent_intensity_rescale_cfg = latent_intensity_rescale_cfg, latent_intensity_rescale_method = latent_intensity_rescale_method,
+                         latent_intensity_rescale_sigma_start = latent_intensity_rescale_sigma_start, latent_intensity_rescale_sigma_end = latent_intensity_rescale_sigma_end,
+                         ignore_pre_cfg_func = True
+                         )[0]
+        return (m, )
+
+class simpleDynamicCFGHighSpeed:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                                "model": ("MODEL",),
+                              }}
+    RETURN_TYPES = ("MODEL",)
+    FUNCTION = "patch"
+
+    CATEGORY = "model_patches/Automatic_CFG/presets"
+
+    def patch(self, model):
+        advcfg = advancedDynamicCFG()
+        m = advcfg.patch(model=model, automatic_cfg = "hard",
+                         skip_uncond = True, uncond_sigma_start = 7.5, uncond_sigma_end = 1)[0]
+        return (m, )
+
+class simpleDynamicCFGwarpDrive:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                                "model": ("MODEL",),
+                                "uncond_sigma_start": ("FLOAT", {"default": 5.5, "min": 0.0, "max": 10000.0, "step": 0.1, "round": 0.01}),
+                                "uncond_sigma_end":   ("FLOAT", {"default": 1.0, "min": 0.0, "max": 10000.0, "step": 0.1, "round": 0.01}),
+                                "fake_uncond_sigma_end": ("FLOAT", {"default": 1.0,  "min": 0.0, "max": 10000.0, "step": 0.1, "round": 0.01}),
+                              }}
+    RETURN_TYPES = ("MODEL",)
+    FUNCTION = "patch"
+
+    CATEGORY = "model_patches/Automatic_CFG/presets"
+
+    def patch(self, model, uncond_sigma_start, uncond_sigma_end, fake_uncond_sigma_end):
+        advcfg = advancedDynamicCFG()
+        print(f"                                                {Fore.CYAN}WARP DRIVE MODE ENGAGED!{Style.RESET_ALL}\n    Settings suggestions:\n"
+            f"              {Fore.GREEN}1/1/1:   {Fore.YELLOW}Maaaxxxiiimum speeeeeed.{Style.RESET_ALL} {Fore.RED}Uncond disabled.{Style.RESET_ALL} {Fore.MAGENTA}Fasten your seatbelt!{Style.RESET_ALL}\n"
+            f"              {Fore.GREEN}3/1/1:   {Fore.YELLOW}Risky space-time continuum distortion.{Style.RESET_ALL} {Fore.MAGENTA}Awesome for prompts with a clear subject!{Style.RESET_ALL}\n"
+            f"              {Fore.GREEN}5.5/1/1: {Fore.YELLOW}Frameshift Drive Autopilot: {Fore.GREEN}Engaged.{Style.RESET_ALL} {Fore.MAGENTA}Should work with anything but do it better and faster!{Style.RESET_ALL}")
+
+        m = advcfg.patch(model=model, automatic_cfg = "hard",
+                         skip_uncond = True, uncond_sigma_start = uncond_sigma_start, uncond_sigma_end = uncond_sigma_end,
+                         fake_uncond_sigma_end = fake_uncond_sigma_end, fake_uncond_sigma_start = 1000, fake_uncond_start=True,
+                         fake_uncond_exp=True,fake_uncond_exp_normalize=True,fake_uncond_exp_method="previous_average",
+                         cond_exp = False, cond_exp_sigma_start  = 9, cond_exp_sigma_end = uncond_sigma_start, cond_exp_method = "erf", cond_exp_normalize = True,
+                         )[0]
+        return (m, )
+
+class simpleDynamicCFGunpatch:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                                "model": ("MODEL",),
+                              }}
+    RETURN_TYPES = ("MODEL",)
+    FUNCTION = "unpatch"
+
+    CATEGORY = "model_patches/Automatic_CFG/utils"
+
+    def unpatch(self, model):
+        m = model.clone()
+        m.model_options.pop("sampler_pre_cfg_automatic_cfg_function", None)
+        return (m, )
+
+class simpleDynamicCFGExcellentattentionPatch:
+    @classmethod
+    def INPUT_TYPES(s):
+        inputs = {"required": {
+                        "model": ("MODEL",),
+                        "Auto_CFG": ("BOOLEAN", {"default": True}),
+                        "patch_multiplier": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 100.0, "step": 1.0, "round": 0.01}),
+                        "patch_cond":   ("BOOLEAN", {"default": True}),
+                        "patch_uncond": ("BOOLEAN", {"default": True}),
+                        "light_patch":  ("BOOLEAN", {"default": False}),
+                        "mute_self_input_layer_8_cond":    ("BOOLEAN", {"default": False}),
+                        "mute_cross_input_layer_8_cond":   ("BOOLEAN", {"default": False}),
+                        "mute_self_input_layer_8_uncond":  ("BOOLEAN", {"default": True}),
+                        "mute_cross_input_layer_8_uncond": ("BOOLEAN", {"default": False}),
+                        "uncond_sigma_end": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 10000.0, "step": 0.1, "round": 0.01}),
+                        "bypass_layer_8_instead_of_mute": ("BOOLEAN", {"default": False}),
+                        "save_as_preset": ("BOOLEAN", {"default": False}),
+                        "preset_name":    ("STRING",  {"multiline": False}),
+                        },
+                        "optional":{
+                                "attn_mod_for_positive_operation": ("ATTNMOD", {"forceInput": True}),
+                                "attn_mod_for_negative_operation": ("ATTNMOD", {"forceInput": True}),
+                        },
+                    }
+        if "dev_env.txt" in os.listdir(current_dir):
+            inputs['optional'].update({"attn_mod_for_global_operation": ("ATTNMOD", {"forceInput": True})})
+        return inputs
+    
+    RETURN_TYPES = ("MODEL","STRING",)
+    RETURN_NAMES = ("Model", "Parameters as string",)
+    FUNCTION = "patch"
+
+    CATEGORY = "model_patches/Automatic_CFG"
+
+    def patch(self, model, Auto_CFG, patch_multiplier, patch_cond, patch_uncond, light_patch,
+              mute_self_input_layer_8_cond, mute_cross_input_layer_8_cond,
+              mute_self_input_layer_8_uncond, mute_cross_input_layer_8_uncond,
+              uncond_sigma_end,bypass_layer_8_instead_of_mute, save_as_preset, preset_name,
+              attn_mod_for_positive_operation = None, attn_mod_for_negative_operation = None, attn_mod_for_global_operation = None):
+        
+        parameters_as_string = "Excellent attention:\n" + "\n".join([f"{k}: {v}" for k, v in locals().items() if k not in ["self", "model"]])
+        
+        with open(os.path.join(json_preset_path, "Excellent_attention.json"), 'r', encoding='utf-8') as f:
+            patch_parameters = json.load(f)
+
+        attn_patch = {"sigma_start": 1000, "sigma_end": 0,
+                       "self_attn_mod_eval": f"normalize_tensor(q+(q-attention_basic(attnbc, k, v, extra_options['n_heads'])))*attnbc.norm()*{patch_multiplier}",
+                       "unet_block_id_input": "", "unet_block_id_middle": "0", "unet_block_id_output": "", "unet_attn": "attn2"}
+        attn_patch_light = {"sigma_start": 1000, "sigma_end": 0,
+                       "self_attn_mod_eval": f"q*{patch_multiplier}",
+                       "unet_block_id_input": "", "unet_block_id_middle": "0", "unet_block_id_output": "", "unet_attn": "attn2"}
+
+        kill_self_input_8 = {
+            "sigma_start": 1000,
+            "sigma_end": 0,
+            "self_attn_mod_eval": "q" if bypass_layer_8_instead_of_mute else "torch.zeros_like(q)",
+            "unet_block_id_input": "8",
+            "unet_block_id_middle": "",
+            "unet_block_id_output": "",
+            "unet_attn": "attn1"}
+        
+        kill_cross_input_8 = kill_self_input_8.copy()
+        kill_cross_input_8['unet_attn'] = "attn2"
+        
+        attention_modifiers_positive = []
+        attention_modifiers_fake_negative = []
+
+        if patch_cond: attention_modifiers_positive.append(attn_patch) if not light_patch else attention_modifiers_positive.append(attn_patch_light)
+        if mute_self_input_layer_8_cond:  attention_modifiers_positive.append(kill_self_input_8)
+        if mute_cross_input_layer_8_cond: attention_modifiers_positive.append(kill_cross_input_8)
+
+        if patch_uncond: attention_modifiers_fake_negative.append(attn_patch) if not light_patch else attention_modifiers_fake_negative.append(attn_patch_light)
+        if mute_self_input_layer_8_uncond:  attention_modifiers_fake_negative.append(kill_self_input_8)
+        if mute_cross_input_layer_8_uncond: attention_modifiers_fake_negative.append(kill_cross_input_8)
+
+        patch_parameters['attention_modifiers_positive']      = attention_modifiers_positive
+        patch_parameters['attention_modifiers_fake_negative'] = attention_modifiers_fake_negative
+
+        if attn_mod_for_positive_operation is not None:
+            patch_parameters['attention_modifiers_positive'] = patch_parameters['attention_modifiers_positive'] + attn_mod_for_positive_operation
+        if attn_mod_for_negative_operation is not None:
+            patch_parameters['attention_modifiers_fake_negative'] = patch_parameters['attention_modifiers_fake_negative'] + attn_mod_for_negative_operation
+        if attn_mod_for_global_operation is not None:
+            patch_parameters["attention_modifiers_global_enabled"] = True
+            patch_parameters['attention_modifiers_global'] = attn_mod_for_global_operation
+
+        patch_parameters["uncond_sigma_end"]      = uncond_sigma_end
+        patch_parameters["fake_uncond_sigma_end"] = uncond_sigma_end
+        patch_parameters["automatic_cfg"] = "hard" if Auto_CFG else "None"
+
+        if save_as_preset:
+            patch_parameters["save_as_preset"] = save_as_preset
+            patch_parameters["preset_name"] = preset_name
+
+        advcfg = advancedDynamicCFG()
+        m = advcfg.patch(model, **patch_parameters)[0]
+        
+        return (m, parameters_as_string, )
+    
+class simpleDynamicCFGCustomAttentionPatch:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                                "model": ("MODEL",),
+                                "Auto_CFG": ("BOOLEAN", {"default": True}),
+                                "cond_mode" :   (["replace_by_custom","normal+(normal-custom_cond)*multiplier","normal+(normal-custom_uncond)*multiplier"],),
+                                "uncond_mode" : (["replace_by_custom","normal+(normal-custom_cond)*multiplier","normal+(normal-custom_uncond)*multiplier"],),
+                                "cond_diff_multiplier":   ("FLOAT", {"default": 1.0, "min": -100.0, "max": 100.0, "step": 0.1, "round": 0.01}),
+                                "uncond_diff_multiplier": ("FLOAT", {"default": 1.0, "min": -100.0, "max": 100.0, "step": 0.1, "round": 0.01}),
+                                "uncond_sigma_end":       ("FLOAT", {"default": 1.0, "min":    0.0, "max": 10000, "step": 0.1, "round": 0.01}),
+                                "save_as_preset": ("BOOLEAN", {"default": False}),
+                                "preset_name":    ("STRING",  {"multiline": False}),
+                              },
+                              "optional":{
+                                  "attn_mod_for_positive_operation": ("ATTNMOD", {"forceInput": True}),
+                                  "attn_mod_for_negative_operation": ("ATTNMOD", {"forceInput": True}),
+                              }}
+    RETURN_TYPES = ("MODEL",)
+    RETURN_NAMES = ("Model",)
+    FUNCTION = "patch"
+
+    CATEGORY = "model_patches/Automatic_CFG/experimental_attention_modifiers"
+
+    def patch(self, model, Auto_CFG, cond_mode, uncond_mode, cond_diff_multiplier, uncond_diff_multiplier, uncond_sigma_end, save_as_preset, preset_name,
+              attn_mod_for_positive_operation = [], attn_mod_for_negative_operation = []):
+                
+        with open(os.path.join(json_preset_path, "do_not_delete.json"), 'r', encoding='utf-8') as f:
+            patch_parameters = json.load(f)
+        
+        patch_parameters["cond_exp_value"]   = cond_diff_multiplier
+        patch_parameters["uncond_exp_value"] = uncond_diff_multiplier
+
+        if cond_mode != "replace_by_custom":
+            patch_parameters["disable_cond"] = False
+        if cond_mode == "normal+(normal-custom_cond)*multiplier":
+            patch_parameters["cond_exp_method"] = "subtract_attention_modifiers_input_using_cond"
+        elif cond_mode == "normal+(normal-custom_uncond)*multiplier":
+            patch_parameters["cond_exp_method"] = "subtract_attention_modifiers_input_using_uncond"
+
+        if uncond_mode != "replace_by_custom":
+            patch_parameters["uncond_sigma_start"] = 1000.0
+            patch_parameters["fake_uncond_exp"]    = False
+            patch_parameters["uncond_exp"]         = True
+        
+        if uncond_mode == "normal+(normal-custom_cond)*multiplier":
+            patch_parameters["uncond_exp_method"] = "subtract_attention_modifiers_input_using_cond"
+        elif uncond_mode == "normal+(normal-custom_uncond)*multiplier":
+            patch_parameters["uncond_exp_method"] = "subtract_attention_modifiers_input_using_uncond"
+
+        if cond_mode != "replace_by_custom" and attn_mod_for_positive_operation != []:
+            smallest_sigma = min([float(x['sigma_end']) for x in attn_mod_for_positive_operation])
+            patch_parameters["disable_cond_sigma_end"] = smallest_sigma
+            patch_parameters["cond_exp_sigma_end"]     = smallest_sigma
+
+        if uncond_mode != "replace_by_custom" and attn_mod_for_negative_operation != []:
+            smallest_sigma = min([float(x['sigma_end'])   for x in attn_mod_for_negative_operation])
+            patch_parameters["uncond_exp_sigma_end"] = smallest_sigma
+            patch_parameters["fake_uncond_start"]    = False
+        # else:
+        #     biggest_sigma = max([float(x['sigma_start']) for x in attn_mod_for_negative_operation])
+        #     patch_parameters["fake_uncond_sigma_start"] = biggest_sigma
+
+        patch_parameters["automatic_cfg"] = "hard" if Auto_CFG else "None"
+        patch_parameters['attention_modifiers_positive']      = attn_mod_for_positive_operation
+        patch_parameters['attention_modifiers_negative']      = attn_mod_for_negative_operation
+        patch_parameters['attention_modifiers_fake_negative'] = attn_mod_for_negative_operation
+        patch_parameters["uncond_sigma_end"]      = uncond_sigma_end
+        patch_parameters["fake_uncond_sigma_end"] = uncond_sigma_end
+        patch_parameters["save_as_preset"] = save_as_preset
+        patch_parameters["preset_name"]    = preset_name
+        
+        advcfg = advancedDynamicCFG()
+        m = advcfg.patch(model, **patch_parameters)[0]
+        
+        return (m, )
+
+
+
+
+class attentionModifierSingleLayerBypassNode:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                                "sigma_start": ("FLOAT", {"default": 1000, "min": 0.0, "max": 10000.0, "step": 0.1, "round": 0.01}),
+                                "sigma_end":   ("FLOAT", {"default":  0, "min": 0.0, "max": 10000.0, "step": 0.1, "round": 0.01}),
+                                "block_name":  (["input","middle","output"],),
+                                "block_number": ("INT", {"default": 0, "min": 0, "max": 12, "step": 1}),
+                                "unet_attn": (["attn1","attn2","both"],),
+                              },
+                              "optional":{
+                                  "join_parameters": ("ATTNMOD", {"forceInput": True}),
+                              }}
+    
+    RETURN_TYPES = ("ATTNMOD","STRING",)
+    RETURN_NAMES = ("Attention modifier", "Parameters as string")
+    FUNCTION = "exec"
+    CATEGORY = "model_patches/Automatic_CFG/experimental_attention_modifiers"
+
+    def exec(self, sigma_start, sigma_end, block_name, block_number, unet_attn, join_parameters=None):
+        attn_modifier_dict = {
+        "sigma_start": sigma_start, "sigma_end": sigma_end,
+         "self_attn_mod_eval": "q",
+         "unet_block_id_input":  str(block_number) if block_name == "input" else "",
+         "unet_block_id_middle": str(block_number) if block_name == "middle" else "",
+         "unet_block_id_output": str(block_number) if block_name == "output" else "",
+         "unet_attn": f"{unet_attn}"
+         }
+
+        info_string = "\n".join([f"{k}: {v}" for k,v in attn_modifier_dict.items() if v != ""])
+
+        if unet_attn == "both":
+            attn_modifier_dict['unet_attn'] = "attn1"
+            copy_attn_modifier_dict = attn_modifier_dict.copy()
+            copy_attn_modifier_dict['unet_attn'] = "attn2"
+            out_modifiers = [attn_modifier_dict, copy_attn_modifier_dict]
+        else:
+            out_modifiers = [attn_modifier_dict]
+
+        return (out_modifiers if join_parameters is None else join_parameters + out_modifiers, info_string, )
+
+class attentionModifierSingleLayerTemperatureNode:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                                "sigma_start": ("FLOAT", {"default": 1000, "min": 0.0, "max": 10000.0, "step": 0.1, "round": 0.01}),
+                                "sigma_end":   ("FLOAT", {"default":  0, "min": 0.0, "max": 10000.0, "step": 0.1, "round": 0.01}),
+                                "block_name":  (["input","middle","output"],),
+                                "block_number": ("INT", {"default": 0, "min": 0, "max": 12, "step": 1}),
+                                "unet_attn": (["attn1","attn2","both"],),
+                                "temperature": ("FLOAT", {"default":  1, "min": 0.0, "max": 10000.0, "step": 0.01, "round": 0.01}),
+                              },
+                              "optional":{
+                                  "join_parameters": ("ATTNMOD", {"forceInput": True}),
+                              }}
+    
+    RETURN_TYPES = ("ATTNMOD","STRING",)
+    RETURN_NAMES = ("Attention modifier", "Parameters as string")
+    FUNCTION = "exec"
+    CATEGORY = "model_patches/Automatic_CFG/experimental_attention_modifiers"
+
+    def exec(self, sigma_start, sigma_end, block_name, block_number, unet_attn, temperature, join_parameters=None):
+        attn_modifier_dict = {
+        "sigma_start": sigma_start, "sigma_end": sigma_end,
+         "self_attn_mod_eval": f"temperature_patcher({temperature}).attention_basic_with_temperature(q, k, v, extra_options)",
+         "unet_block_id_input":  str(block_number) if block_name == "input" else "",
+         "unet_block_id_middle": str(block_number) if block_name == "middle" else "",
+         "unet_block_id_output": str(block_number) if block_name == "output" else "",
+         "unet_attn": f"{unet_attn}"
+         }
+
+        info_string = "\n".join([f"{k}: {v}" for k,v in attn_modifier_dict.items() if v != ""])
+
+        if unet_attn == "both":
+            attn_modifier_dict['unet_attn'] = "attn1"
+            copy_attn_modifier_dict = attn_modifier_dict.copy()
+            copy_attn_modifier_dict['unet_attn'] = "attn2"
+            out_modifiers = [attn_modifier_dict, copy_attn_modifier_dict]
+        else:
+            out_modifiers = [attn_modifier_dict]
+
+        return (out_modifiers if join_parameters is None else join_parameters + out_modifiers, info_string, )
+
+class uncondZeroNode:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                                "model": ("MODEL",),
+                                "scale": ("FLOAT", {"default": 1.2, "min": 0.0, "max": 10.0, "step": 0.01, "round": 0.01}),
+                              }}
+    RETURN_TYPES = ("MODEL",)
+    FUNCTION = "patch"
+
+    CATEGORY = "model_patches/Automatic_CFG"
+
+    def patch(self, model, scale):
+        def custom_patch(args):
+            cond_pred = args["cond_denoised"]
+            input_x = args["input"]
+            if args["sigma"][0] <= 1:
+                return input_x - cond_pred
+            cond   = input_x - cond_pred
+            uncond = input_x - torch.zeros_like(cond)
+            return uncond + scale * (cond - uncond)
+
+        m = model.clone()
+        m.set_model_sampler_cfg_function(custom_patch)
+        return (m, )

ComfyUI/custom_nodes/ComfyUI-AutomaticCFG/nodes_sag_custom.py

@@ -0,0 +1,190 @@
+import torch
+from torch import einsum
+import torch.nn.functional as F
+import math
+
+from einops import rearrange, repeat
+import os
+from comfy.ldm.modules.attention import optimized_attention, _ATTN_PRECISION
+import comfy.samplers
+
+# from comfy/ldm/modules/attention.py
+# but modified to return attention scores as well as output
+def attention_basic_with_sim(q, k, v, heads, mask=None):
+    b, _, dim_head = q.shape
+    dim_head //= heads
+    scale = dim_head ** -0.5
+
+    h = heads
+    q, k, v = map(
+        lambda t: t.unsqueeze(3)
+        .reshape(b, -1, heads, dim_head)
+        .permute(0, 2, 1, 3)
+        .reshape(b * heads, -1, dim_head)
+        .contiguous(),
+        (q, k, v),
+    )
+
+    # force cast to fp32 to avoid overflowing
+    if _ATTN_PRECISION =="fp32":
+        sim = einsum('b i d, b j d -> b i j', q.float(), k.float()) * scale
+    else:
+        sim = einsum('b i d, b j d -> b i j', q, k) * scale
+
+    del q, k
+
+    if mask is not None:
+        mask = rearrange(mask, 'b ... -> b (...)')
+        max_neg_value = -torch.finfo(sim.dtype).max
+        mask = repeat(mask, 'b j -> (b h) () j', h=h)
+        sim.masked_fill_(~mask, max_neg_value)
+
+    # attention, what we cannot get enough of
+    sim = sim.softmax(dim=-1)
+
+    out = einsum('b i j, b j d -> b i d', sim.to(v.dtype), v)
+    out = (
+        out.unsqueeze(0)
+        .reshape(b, heads, -1, dim_head)
+        .permute(0, 2, 1, 3)
+        .reshape(b, -1, heads * dim_head)
+    )
+    return (out, sim)
+
+def create_blur_map(x0, attn, sigma=3.0, threshold=1.0):
+    # reshape and GAP the attention map
+    _, hw1, hw2 = attn.shape
+    b, _, lh, lw = x0.shape
+    attn = attn.reshape(b, -1, hw1, hw2)
+    # Global Average Pool
+    mask = attn.mean(1, keepdim=False).sum(1, keepdim=False) > threshold
+    ratio = 2**(math.ceil(math.sqrt(lh * lw / hw1)) - 1).bit_length()
+    mid_shape = [math.ceil(lh / ratio), math.ceil(lw / ratio)]
+
+    # Reshape
+    mask = (
+        mask.reshape(b, *mid_shape)
+        .unsqueeze(1)
+        .type(attn.dtype)
+    )
+    # Upsample
+    mask = F.interpolate(mask, (lh, lw))
+
+    blurred = gaussian_blur_2d(x0, kernel_size=9, sigma=sigma)
+    blurred = blurred * mask + x0 * (1 - mask)
+    return blurred
+
+def gaussian_blur_2d(img, kernel_size, sigma):
+    ksize_half = (kernel_size - 1) * 0.5
+
+    x = torch.linspace(-ksize_half, ksize_half, steps=kernel_size)
+
+    pdf = torch.exp(-0.5 * (x / sigma).pow(2))
+
+    x_kernel = pdf / pdf.sum()
+    x_kernel = x_kernel.to(device=img.device, dtype=img.dtype)
+
+    kernel2d = torch.mm(x_kernel[:, None], x_kernel[None, :])
+    kernel2d = kernel2d.expand(img.shape[-3], 1, kernel2d.shape[0], kernel2d.shape[1])
+
+    padding = [kernel_size // 2, kernel_size // 2, kernel_size // 2, kernel_size // 2]
+
+    img = F.pad(img, padding, mode="reflect")
+    img = F.conv2d(img, kernel2d, groups=img.shape[-3])
+    return img
+
+def get_denoised_ranges(latent, measure="hard", top_k=0.25):
+    chans = []
+    for x in range(len(latent)):
+        max_values = torch.topk(latent[x] - latent[x].mean() if measure == "range" else latent[x], k=int(len(latent[x])*top_k), largest=True).values
+        min_values = torch.topk(latent[x] - latent[x].mean() if measure == "range" else latent[x], k=int(len(latent[x])*top_k), largest=False).values
+        max_val = torch.mean(max_values).item()
+        min_val = torch.mean(torch.abs(min_values)).item() if (measure == "hard" or measure == "range") else abs(torch.mean(min_values).item())
+        denoised_range = (max_val + min_val) / 2
+        chans.append(denoised_range)
+    return chans
+
+class SelfAttentionGuidanceCustom:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": { "model": ("MODEL",),
+                             "scale": ("FLOAT", {"default": 0.5, "min": -2.0, "max": 100.0, "step": 0.1}),
+                             "blur_sigma": ("FLOAT", {"default": 2.0, "min": 0.0, "max": 10.0, "step": 0.1}),
+                             "sigma_start": ("FLOAT", {"default": 15.0, "min": 0.0, "max": 1000.0, "step": 0.1, "round": 0.1}),
+                             "sigma_end": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 1000.0, "step": 0.1, "round": 0.1}),
+                             "auto_scale" : ("BOOLEAN", {"default": False}),
+                              }}
+    RETURN_TYPES = ("MODEL",)
+    FUNCTION = "patch"
+
+    CATEGORY = "model_patches"
+
+    def patch(self, model, scale, blur_sigma, sigma_start, sigma_end, auto_scale):
+        m = model.clone()
+        
+        attn_scores = None
+
+        # TODO: make this work properly with chunked batches
+        #       currently, we can only save the attn from one UNet call
+        def attn_and_record(q, k, v, extra_options):
+            nonlocal attn_scores
+            # if uncond, save the attention scores
+            heads = extra_options["n_heads"]
+            cond_or_uncond = extra_options["cond_or_uncond"]
+            b = q.shape[0] // len(cond_or_uncond)
+            if 1 in cond_or_uncond:
+                uncond_index = cond_or_uncond.index(1)
+                # do the entire attention operation, but save the attention scores to attn_scores
+                (out, sim) = attention_basic_with_sim(q, k, v, heads=heads)
+                # when using a higher batch size, I BELIEVE the result batch dimension is [uc1, ... ucn, c1, ... cn]
+                n_slices = heads * b
+                attn_scores = sim[n_slices * uncond_index:n_slices * (uncond_index+1)]
+                return out
+            else:
+                return optimized_attention(q, k, v, heads=heads)
+
+        def post_cfg_function(args):
+            nonlocal attn_scores
+            uncond_attn = attn_scores
+
+            sag_scale = scale
+            sag_sigma = blur_sigma
+            sag_threshold = 1.0
+            model = args["model"]
+            uncond_pred = args["uncond_denoised"]
+            uncond = args["uncond"]
+            cfg_result = args["denoised"]
+            sigma = args["sigma"]
+            model_options = args["model_options"]
+            x = args["input"]
+            if uncond_pred is None or uncond is None or uncond_attn is None:
+                return cfg_result
+            if min(cfg_result.shape[2:]) <= 4: #skip when too small to add padding
+                return cfg_result
+            if sigma[0] > sigma_start or sigma[0] < sigma_end:
+                return cfg_result
+            # create the adversarially blurred image
+            degraded = create_blur_map(uncond_pred, uncond_attn, sag_sigma, sag_threshold)
+            degraded_noised = degraded + x - uncond_pred
+            # call into the UNet
+            (sag, _) = comfy.samplers.calc_cond_batch(model, [uncond, None], degraded_noised, sigma, model_options)
+            # comfy.samplers.calc_cond_uncond_batch(model, uncond, None, degraded_noised, sigma, model_options)
+
+            if auto_scale:
+                denoised_tmp = cfg_result + (degraded - sag) * 8
+                for b in range(len(denoised_tmp)):
+                    denoised_ranges = get_denoised_ranges(denoised_tmp[b])
+                    for c in range(len(denoised_tmp[b])):
+                        fixed_scale = (sag_scale / 10) / denoised_ranges[c]
+                        denoised_tmp[b][c] = cfg_result[b][c] + (degraded[b][c] - sag[b][c]) * fixed_scale
+                return denoised_tmp
+            
+            return cfg_result + (degraded - sag) * sag_scale
+
+        m.set_model_sampler_post_cfg_function(post_cfg_function, disable_cfg1_optimization=False)
+
+        # from diffusers:
+        # unet.mid_block.attentions[0].transformer_blocks[0].attn1.patch
+        m.set_model_attn1_replace(attn_and_record, "middle", 0, 0)
+
+        return (m, )

ComfyUI/custom_nodes/ComfyUI-AutomaticCFG/presets/A subtle touch.json

@@ -0,0 +1 @@
+{"lerp_uncond_sigma_start": 1000.0, "lerp_uncond_sigma_end": 1.0, "subtract_latent_mean": false, "subtract_latent_mean_sigma_start": 1000.0, "subtract_latent_mean_sigma_end": 1.0, "latent_intensity_rescale": false, "latent_intensity_rescale_sigma_start": 1000.0, "latent_intensity_rescale_sigma_end": 3.0, "ignore_pre_cfg_func": false, "auto_cfg_topk": 0.25, "attention_modifiers_global_enabled": true, "attention_modifiers_global": [{"sigma_start": 15, "sigma_end": 0, "self_attn_mod_eval": "q.sin()", "unet_block_id_input": "", "unet_block_id_middle": "0", "unet_block_id_output": "", "unet_attn": "attn2"}], "disable_cond": false, "disable_cond_sigma_start": 1000.0, "disable_cond_sigma_end": 0.0, "kwargs": {}, "model_options_copy": {"transformer_options": {}}, "attention_modifiers_fake_negative": [], "attention_modifiers_negative": [], "attention_modifiers_positive": [], "auto_cfg_ref": 8.0, "automatic_cfg": "hard", "cond_exp": false, "cond_exp_method": "attention_modifiers_input_using_cond", "cond_exp_normalize": false, "cond_exp_sigma_end": 0.0, "cond_exp_sigma_start": 1000.0, "cond_exp_value": 1.0, "eval_string_cond": "", "eval_string_fake": "", "eval_string_uncond": "", "fake_uncond_exp": false, "fake_uncond_exp_method": "attention_modifiers_input_using_uncond", "fake_uncond_exp_normalize": false, "fake_uncond_exp_value": 1.0, "fake_uncond_multiplier": 1, "fake_uncond_sigma_end": 1.0, "fake_uncond_sigma_start": 1000.0, "fake_uncond_start": true, "latent_intensity_rescale_cfg": 8.0, "latent_intensity_rescale_method": "hard", "lerp_uncond": false, "lerp_uncond_strength": 2.0, "not_in_filter": ["self", "model", "args", "args_filter", "save_as_preset", "preset_name", "eval_string"], "skip_uncond": true, "uncond_exp": false, "uncond_exp_method": "subtract_attention_modifiers_input_using_uncond", "uncond_exp_normalize": false, "uncond_exp_sigma_end": 0.0, "uncond_exp_sigma_start": 1000.0, "uncond_exp_value": 1.0, "uncond_sigma_end": 1.0, "uncond_sigma_start": 15.0}

ComfyUI/custom_nodes/ComfyUI-AutomaticCFG/presets/Crossed conds customized 1.json

@@ -0,0 +1 @@
+{"lerp_uncond_sigma_start": 15.0, "lerp_uncond_sigma_end": 1.0, "subtract_latent_mean": false, "subtract_latent_mean_sigma_start": 15.0, "subtract_latent_mean_sigma_end": 1.0, "latent_intensity_rescale": false, "latent_intensity_rescale_sigma_start": 15.0, "latent_intensity_rescale_sigma_end": 3.0, "ignore_pre_cfg_func": false, "auto_cfg_topk": 0.25, "attention_modifiers_global_enabled": true, "attention_modifiers_global": [], "disable_cond": false, "disable_cond_sigma_start": 1000.0, "disable_cond_sigma_end": 0.0, "kwargs": {}, "attention_modifiers_fake_negative": [{"sigma_start": 1000, "sigma_end": 0, "self_attn_mod_eval": "k", "unet_block_id_input": "7,8", "unet_block_id_middle": "", "unet_block_id_output": "0", "unet_attn": "attn1"}, {"sigma_start": 1000, "sigma_end": 0, "self_attn_mod_eval": "v", "unet_block_id_input": "4", "unet_block_id_middle": "0", "unet_block_id_output": "3", "unet_attn": "attn1"}, {"sigma_start": 1000, "sigma_end": 0, "self_attn_mod_eval": "torch.zeros_like(q)", "unet_block_id_input": "8", "unet_block_id_middle": "", "unet_block_id_output": "", "unet_attn": "attn2"}], "attention_modifiers_negative": [{"sigma_start": 1000, "sigma_end": 0, "self_attn_mod_eval": "k", "unet_block_id_input": "7,8", "unet_block_id_middle": "", "unet_block_id_output": "0", "unet_attn": "attn1"}, {"sigma_start": 1000, "sigma_end": 0, "self_attn_mod_eval": "v", "unet_block_id_input": "4", "unet_block_id_middle": "0", "unet_block_id_output": "3", "unet_attn": "attn1"}, {"sigma_start": 1000, "sigma_end": 0, "self_attn_mod_eval": "torch.zeros_like(q)", "unet_block_id_input": "8", "unet_block_id_middle": "", "unet_block_id_output": "", "unet_attn": "attn2"}], "attention_modifiers_positive": [{"sigma_start": 1000, "sigma_end": 0, "self_attn_mod_eval": "k", "unet_block_id_input": "7,8", "unet_block_id_middle": "", "unet_block_id_output": "0", "unet_attn": "attn1"}, {"sigma_start": 1000, "sigma_end": 0, "self_attn_mod_eval": "v", "unet_block_id_input": "4", "unet_block_id_middle": "0", "unet_block_id_output": "3", "unet_attn": "attn1"}, {"sigma_start": 1000, "sigma_end": 0, "self_attn_mod_eval": "torch.zeros_like(q)", "unet_block_id_input": "8", "unet_block_id_middle": "", "unet_block_id_output": "", "unet_attn": "attn2"}], "auto_cfg_ref": 8.0, "automatic_cfg": "hard", "cond_exp": true, "cond_exp_method": "subtract_attention_modifiers_input_using_uncond", "cond_exp_normalize": false, "cond_exp_sigma_end": 1.0, "cond_exp_sigma_start": 1000.0, "cond_exp_value": 0.3333333333333333, "eval_string_cond": "", "eval_string_fake": "", "eval_string_uncond": "", "fake_uncond_exp": false, "fake_uncond_exp_method": "cond_pred", "fake_uncond_exp_normalize": false, "fake_uncond_exp_value": 1.0, "fake_uncond_multiplier": 1, "fake_uncond_sigma_end": 0.0, "fake_uncond_sigma_start": 1000.0, "fake_uncond_start": false, "latent_intensity_rescale_cfg": 8.0, "latent_intensity_rescale_method": "hard", "lerp_uncond": false, "lerp_uncond_strength": 2.0, "not_in_filter": ["self", "model", "args", "args_filter", "save_as_preset", "preset_name", "model_options_copy", "eval_string"], "skip_uncond": true, "uncond_exp": true, "uncond_exp_method": "subtract_attention_modifiers_input_using_cond", "uncond_exp_normalize": false, "uncond_exp_sigma_end": 1.0, "uncond_exp_sigma_start": 1000.0, "uncond_exp_value": 0.3333333333333333, "uncond_sigma_end": 1.0, "uncond_sigma_start": 150.0}

ComfyUI/custom_nodes/ComfyUI-AutomaticCFG/presets/Crossed conds customized 2.json

@@ -0,0 +1 @@
+{"lerp_uncond_sigma_start": 15.0, "lerp_uncond_sigma_end": 1.0, "subtract_latent_mean": false, "subtract_latent_mean_sigma_start": 15.0, "subtract_latent_mean_sigma_end": 1.0, "latent_intensity_rescale": false, "latent_intensity_rescale_sigma_start": 15.0, "latent_intensity_rescale_sigma_end": 3.0, "ignore_pre_cfg_func": false, "auto_cfg_topk": 0.25, "attention_modifiers_global_enabled": true, "attention_modifiers_global": [], "disable_cond": false, "disable_cond_sigma_start": 1000.0, "disable_cond_sigma_end": 0.0, "kwargs": {}, "attention_modifiers_fake_negative": [{"sigma_start": 1000, "sigma_end": 0, "self_attn_mod_eval": "k", "unet_block_id_input": "7,8", "unet_block_id_middle": "", "unet_block_id_output": "0", "unet_attn": "attn1"}, {"sigma_start": 1000, "sigma_end": 0, "self_attn_mod_eval": "v", "unet_block_id_input": "4", "unet_block_id_middle": "0", "unet_block_id_output": "3", "unet_attn": "attn1"}, {"sigma_start": 1000, "sigma_end": 0, "self_attn_mod_eval": "torch.zeros_like(q)", "unet_block_id_input": "8", "unet_block_id_middle": "", "unet_block_id_output": "", "unet_attn": "attn2"}], "attention_modifiers_negative": [{"sigma_start": 1000, "sigma_end": 0, "self_attn_mod_eval": "k", "unet_block_id_input": "7,8", "unet_block_id_middle": "", "unet_block_id_output": "0", "unet_attn": "attn1"}, {"sigma_start": 1000, "sigma_end": 0, "self_attn_mod_eval": "v", "unet_block_id_input": "4", "unet_block_id_middle": "0", "unet_block_id_output": "3", "unet_attn": "attn1"}, {"sigma_start": 1000, "sigma_end": 0, "self_attn_mod_eval": "torch.zeros_like(q)", "unet_block_id_input": "8", "unet_block_id_middle": "", "unet_block_id_output": "", "unet_attn": "attn2"}], "attention_modifiers_positive": [{"sigma_start": 1000, "sigma_end": 0, "self_attn_mod_eval": "k", "unet_block_id_input": "7,8", "unet_block_id_middle": "", "unet_block_id_output": "0", "unet_attn": "attn1"}, {"sigma_start": 1000, "sigma_end": 0, "self_attn_mod_eval": "v", "unet_block_id_input": "4", "unet_block_id_middle": "0", "unet_block_id_output": "3", "unet_attn": "attn1"}, {"sigma_start": 1000, "sigma_end": 0, "self_attn_mod_eval": "torch.zeros_like(q)", "unet_block_id_input": "8", "unet_block_id_middle": "", "unet_block_id_output": "", "unet_attn": "attn2"}], "auto_cfg_ref": 8.0, "automatic_cfg": "hard", "cond_exp": true, "cond_exp_method": "subtract_attention_modifiers_input_using_uncond", "cond_exp_normalize": false, "cond_exp_sigma_end": 3.0, "cond_exp_sigma_start": 1000.0, "cond_exp_value": 0.3333333333333333, "eval_string_cond": "", "eval_string_fake": "", "eval_string_uncond": "", "fake_uncond_exp": false, "fake_uncond_exp_method": "cond_pred", "fake_uncond_exp_normalize": false, "fake_uncond_exp_value": 1.0, "fake_uncond_multiplier": 1, "fake_uncond_sigma_end": 0.0, "fake_uncond_sigma_start": 1000.0, "fake_uncond_start": false, "latent_intensity_rescale_cfg": 8.0, "latent_intensity_rescale_method": "hard", "lerp_uncond": false, "lerp_uncond_strength": 2.0, "not_in_filter": ["self", "model", "args", "args_filter", "save_as_preset", "preset_name", "model_options_copy", "eval_string"], "skip_uncond": true, "uncond_exp": true, "uncond_exp_method": "subtract_attention_modifiers_input_using_cond", "uncond_exp_normalize": false, "uncond_exp_sigma_end": 3.0, "uncond_exp_sigma_start": 1000.0, "uncond_exp_value": 0.3333333333333333, "uncond_sigma_end": 1.0, "uncond_sigma_start": 150.0}

ComfyUI/custom_nodes/ComfyUI-AutomaticCFG/presets/Crossed conds customized 3.json

@@ -0,0 +1 @@
+{"lerp_uncond_sigma_start": 15.0, "lerp_uncond_sigma_end": 1.0, "subtract_latent_mean": false, "subtract_latent_mean_sigma_start": 15.0, "subtract_latent_mean_sigma_end": 1.0, "latent_intensity_rescale": false, "latent_intensity_rescale_sigma_start": 15.0, "latent_intensity_rescale_sigma_end": 3.0, "ignore_pre_cfg_func": false, "auto_cfg_topk": 0.25, "attention_modifiers_global_enabled": true, "attention_modifiers_global": [{"sigma_start": 1000, "sigma_end": 0, "self_attn_mod_eval": "torch.zeros_like(q)", "unet_block_id_input": "8", "unet_block_id_middle": "", "unet_block_id_output": "", "unet_attn": "attn1"}], "disable_cond": false, "disable_cond_sigma_start": 1000.0, "disable_cond_sigma_end": 0.0, "kwargs": {}, "attention_modifiers_fake_negative": [{"sigma_start": 1000, "sigma_end": 0, "self_attn_mod_eval": "k", "unet_block_id_input": "7", "unet_block_id_middle": "", "unet_block_id_output": "", "unet_attn": "attn1"}, {"sigma_start": 1000, "sigma_end": 0, "self_attn_mod_eval": "v", "unet_block_id_input": "", "unet_block_id_middle": "0", "unet_block_id_output": "", "unet_attn": "attn1"}, {"sigma_start": 1000, "sigma_end": 0, "self_attn_mod_eval": "torch.zeros_like(q)", "unet_block_id_input": "8", "unet_block_id_middle": "", "unet_block_id_output": "", "unet_attn": "attn2"}], "attention_modifiers_negative": [{"sigma_start": 1000, "sigma_end": 0, "self_attn_mod_eval": "k", "unet_block_id_input": "7", "unet_block_id_middle": "", "unet_block_id_output": "", "unet_attn": "attn1"}, {"sigma_start": 1000, "sigma_end": 0, "self_attn_mod_eval": "v", "unet_block_id_input": "", "unet_block_id_middle": "0", "unet_block_id_output": "", "unet_attn": "attn1"}, {"sigma_start": 1000, "sigma_end": 0, "self_attn_mod_eval": "torch.zeros_like(q)", "unet_block_id_input": "8", "unet_block_id_middle": "", "unet_block_id_output": "", "unet_attn": "attn2"}], "attention_modifiers_positive": [{"sigma_start": 1000, "sigma_end": 0, "self_attn_mod_eval": "k", "unet_block_id_input": "7", "unet_block_id_middle": "", "unet_block_id_output": "", "unet_attn": "attn1"}, {"sigma_start": 1000, "sigma_end": 0, "self_attn_mod_eval": "v", "unet_block_id_input": "", "unet_block_id_middle": "0", "unet_block_id_output": "", "unet_attn": "attn1"}, {"sigma_start": 1000, "sigma_end": 0, "self_attn_mod_eval": "torch.zeros_like(q)", "unet_block_id_input": "8", "unet_block_id_middle": "", "unet_block_id_output": "", "unet_attn": "attn2"}], "auto_cfg_ref": 8.0, "automatic_cfg": "hard", "cond_exp": true, "cond_exp_method": "subtract_attention_modifiers_input_using_uncond", "cond_exp_normalize": false, "cond_exp_sigma_end": 0.0, "cond_exp_sigma_start": 1000.0, "cond_exp_value": 1.0, "eval_string_cond": "", "eval_string_fake": "", "eval_string_uncond": "", "fake_uncond_exp": false, "fake_uncond_exp_method": "cond_pred", "fake_uncond_exp_normalize": false, "fake_uncond_exp_value": 1.0, "fake_uncond_multiplier": 1, "fake_uncond_sigma_end": 0.0, "fake_uncond_sigma_start": 1000.0, "fake_uncond_start": false, "latent_intensity_rescale_cfg": 8.0, "latent_intensity_rescale_method": "hard", "lerp_uncond": false, "lerp_uncond_strength": 2.0, "not_in_filter": ["self", "model", "args", "args_filter", "save_as_preset", "preset_name", "model_options_copy", "eval_string"], "skip_uncond": true, "uncond_exp": true, "uncond_exp_method": "subtract_attention_modifiers_input_using_cond", "uncond_exp_normalize": false, "uncond_exp_sigma_end": 0.0, "uncond_exp_sigma_start": 1000.0, "uncond_exp_value": 1.0, "uncond_sigma_end": 1.0, "uncond_sigma_start": 150.0}

ComfyUI/custom_nodes/ComfyUI-AutomaticCFG/presets/Enhanced_details_and_tweaked_attention

@@ -0,0 +1 @@
+{"lerp_uncond_sigma_start": 15.0, "lerp_uncond_sigma_end": 1.0, "subtract_latent_mean": false, "subtract_latent_mean_sigma_start": 15.0, "subtract_latent_mean_sigma_end": 1.0, "latent_intensity_rescale": false, "latent_intensity_rescale_sigma_start": 15.0, "latent_intensity_rescale_sigma_end": 3.0, "ignore_pre_cfg_func": false, "auto_cfg_topk": 0.25, "attention_modifiers_global_enabled": true, "attention_modifiers_global": [{"sigma_start": 1000, "sigma_end": 0, "self_attn_mod_eval": "torch.zeros_like(q)", "unet_block_id_input": "8", "unet_block_id_middle": "", "unet_block_id_output": "", "unet_attn": "attn2"}], "disable_cond": false, "disable_cond_sigma_start": 1000.0, "disable_cond_sigma_end": 0.0, "kwargs": {}, "attention_modifiers_fake_negative": [], "attention_modifiers_negative": [{"sigma_start": 1000, "sigma_end": 0, "self_attn_mod_eval": "-q", "unet_block_id_input": "8", "unet_block_id_middle": "", "unet_block_id_output": "", "unet_attn": "attn2"}], "attention_modifiers_positive": [{"sigma_start": 15, "sigma_end": 0, "self_attn_mod_eval": "v", "unet_block_id_input": "", "unet_block_id_middle": "0", "unet_block_id_output": "", "unet_attn": "attn1"}, {"sigma_start": 1000, "sigma_end": 0, "self_attn_mod_eval": "q", "unet_block_id_input": "8", "unet_block_id_middle": "", "unet_block_id_output": "", "unet_attn": "attn1"}], "auto_cfg_ref": 8.0, "automatic_cfg": "hard", "cond_exp": true, "cond_exp_method": "subtract_attention_modifiers_input_using_cond", "cond_exp_normalize": true, "cond_exp_sigma_end": 0.0, "cond_exp_sigma_start": 15.0, "cond_exp_value": 0.5, "eval_string_cond": "", "eval_string_fake": "", "eval_string_uncond": "", "fake_uncond_exp": false, "fake_uncond_exp_method": "cond_pred", "fake_uncond_exp_normalize": false, "fake_uncond_exp_value": 1.0, "fake_uncond_multiplier": 1, "fake_uncond_sigma_end": 1.0, "fake_uncond_sigma_start": 15.0, "fake_uncond_start": false, "latent_intensity_rescale_cfg": 8.0, "latent_intensity_rescale_method": "hard", "lerp_uncond": false, "lerp_uncond_strength": 2.0, "not_in_filter": ["self", "model", "args", "args_filter", "save_as_preset", "preset_name", "model_options_copy", "eval_string"], "skip_uncond": true, "uncond_exp": true, "uncond_exp_method": "subtract_attention_modifiers_input_using_uncond", "uncond_exp_normalize": true, "uncond_exp_sigma_end": 0.4, "uncond_exp_sigma_start": 15.0, "uncond_exp_value": 0.5, "uncond_sigma_end": 0.4, "uncond_sigma_start": 15.0}

ComfyUI/custom_nodes/ComfyUI-AutomaticCFG/presets/Excellent_attention.json

@@ -0,0 +1 @@
+{"lerp_uncond_sigma_start": 15.0, "lerp_uncond_sigma_end": 1.0, "subtract_latent_mean": false, "subtract_latent_mean_sigma_start": 15.0, "subtract_latent_mean_sigma_end": 1.0, "latent_intensity_rescale": false, "latent_intensity_rescale_sigma_start": 15.0, "latent_intensity_rescale_sigma_end": 3.0, "ignore_pre_cfg_func": false, "auto_cfg_topk": 0.25, "attention_modifiers_global_enabled": false, "attention_modifiers_global": [], "disable_cond": true, "disable_cond_sigma_start": 1000.0, "disable_cond_sigma_end": 0.0, "kwargs": {}, "attention_modifiers_fake_negative": [{"sigma_start": 1000, "sigma_end": 0, "self_attn_mod_eval": "normalize_tensor(q+(q-attention_basic(attnbc, k, v, extra_options['n_heads'])))*attnbc.norm()", "unet_block_id_input": "", "unet_block_id_middle": "0", "unet_block_id_output": "", "unet_attn": "attn2"}, {"sigma_start": 1000, "sigma_end": 0, "self_attn_mod_eval": "torch.zeros_like(q)", "unet_block_id_input": "8", "unet_block_id_middle": "", "unet_block_id_output": "", "unet_attn": "attn1"}], "attention_modifiers_negative": [], "attention_modifiers_positive": [{"sigma_start": 1000, "sigma_end": 0, "self_attn_mod_eval": "normalize_tensor(q+(q-attention_basic(attnbc, k, v, extra_options['n_heads'])))*attnbc.norm()", "unet_block_id_input": "", "unet_block_id_middle": "0", "unet_block_id_output": "", "unet_attn": "attn2"}], "auto_cfg_ref": 8.0, "automatic_cfg": "hard", "cond_exp": true, "cond_exp_method": "attention_modifiers_input_using_cond", "cond_exp_normalize": false, "cond_exp_sigma_end": 0.0, "cond_exp_sigma_start": 1000.0, "cond_exp_value": 1.0, "eval_string_cond": "", "eval_string_fake": "", "eval_string_uncond": "", "fake_uncond_exp": true, "fake_uncond_exp_method": "attention_modifiers_input_using_uncond", "fake_uncond_exp_normalize": false, "fake_uncond_exp_value": 1000.0, "fake_uncond_multiplier": 1, "fake_uncond_sigma_end": 0.0, "fake_uncond_sigma_start": 1000.0, "fake_uncond_start": true, "latent_intensity_rescale_cfg": 8.0, "latent_intensity_rescale_method": "hard", "lerp_uncond": false, "lerp_uncond_strength": 2.0, "not_in_filter": ["self", "model", "args", "args_filter", "save_as_preset", "preset_name", "model_options_copy", "eval_string"], "skip_uncond": true, "uncond_exp": false, "uncond_exp_method": "amplify", "uncond_exp_normalize": false, "uncond_exp_sigma_end": 0.0, "uncond_exp_sigma_start": 1000.0, "uncond_exp_value": 1.0, "uncond_sigma_end": 0.0, "uncond_sigma_start": 0.0}

ComfyUI/custom_nodes/ComfyUI-AutomaticCFG/presets/For magic.json

@@ -0,0 +1 @@
+{"lerp_uncond_sigma_start": 1000.0, "lerp_uncond_sigma_end": 1.0, "subtract_latent_mean": false, "subtract_latent_mean_sigma_start": 1000.0, "subtract_latent_mean_sigma_end": 1.0, "latent_intensity_rescale": false, "latent_intensity_rescale_sigma_start": 1000.0, "latent_intensity_rescale_sigma_end": 3.0, "ignore_pre_cfg_func": false, "auto_cfg_topk": 0.25, "attention_modifiers_global_enabled": true, "attention_modifiers_global": [{"sigma_start": 15, "sigma_end": 0, "self_attn_mod_eval": "q.sin()", "unet_block_id_input": "", "unet_block_id_middle": "0", "unet_block_id_output": "", "unet_attn": "attn2"}], "disable_cond": false, "disable_cond_sigma_start": 1000.0, "disable_cond_sigma_end": 0.0, "kwargs": {}, "model_options_copy": {"transformer_options": {}}, "attention_modifiers_fake_negative": [], "attention_modifiers_negative": [], "attention_modifiers_positive": [{"sigma_start": 15, "sigma_end": 0, "self_attn_mod_eval": "q/2", "unet_block_id_input": "8", "unet_block_id_middle": "", "unet_block_id_output": "", "unet_attn": "attn2"}, {"sigma_start": 15, "sigma_end": 0, "self_attn_mod_eval": "torch.zeros_like(q)", "unet_block_id_input": "", "unet_block_id_middle": "0", "unet_block_id_output": "", "unet_attn": "attn2"}], "auto_cfg_ref": 8.0, "automatic_cfg": "hard", "cond_exp": true, "cond_exp_method": "subtract_attention_modifiers_input_using_uncond", "cond_exp_normalize": false, "cond_exp_sigma_end": 1.0, "cond_exp_sigma_start": 1000.0, "cond_exp_value": 0.5, "eval_string_cond": "", "eval_string_fake": "", "eval_string_uncond": "", "fake_uncond_exp": false, "fake_uncond_exp_method": "attention_modifiers_input_using_uncond", "fake_uncond_exp_normalize": false, "fake_uncond_exp_value": 2.0, "fake_uncond_multiplier": 1, "fake_uncond_sigma_end": 1.0, "fake_uncond_sigma_start": 1000.0, "fake_uncond_start": false, "latent_intensity_rescale_cfg": 8.0, "latent_intensity_rescale_method": "hard", "lerp_uncond": false, "lerp_uncond_strength": 2.0, "not_in_filter": ["self", "model", "args", "args_filter", "save_as_preset", "preset_name", "eval_string"], "skip_uncond": true, "uncond_exp": false, "uncond_exp_method": "subtract_attention_modifiers_input_using_uncond", "uncond_exp_normalize": false, "uncond_exp_sigma_end": 1.0, "uncond_exp_sigma_start": 1000.0, "uncond_exp_value": 1.0, "uncond_sigma_end": 1.0, "uncond_sigma_start": 15.0}

ComfyUI/custom_nodes/ComfyUI-AutomaticCFG/presets/Kickstart.json

@@ -0,0 +1 @@
+{"lerp_uncond_sigma_start": 15.0, "lerp_uncond_sigma_end": 1.0, "subtract_latent_mean": false, "subtract_latent_mean_sigma_start": 15.0, "subtract_latent_mean_sigma_end": 1.0, "latent_intensity_rescale": false, "latent_intensity_rescale_sigma_start": 15.0, "latent_intensity_rescale_sigma_end": 3.0, "ignore_pre_cfg_func": false, "auto_cfg_topk": 0.25, "attention_modifiers_global_enabled": false, "attention_modifiers_global": [], "disable_cond": true, "disable_cond_sigma_start": 1000.0, "disable_cond_sigma_end": 0.0, "kwargs": {}, "attention_modifiers_fake_negative": [{"sigma_start": 1000, "sigma_end": 7, "self_attn_mod_eval": "attnbc*2", "unet_block_id_input": "8", "unet_block_id_middle": "", "unet_block_id_output": "", "unet_attn": "attn1"}, {"sigma_start": 7, "sigma_end": 2, "self_attn_mod_eval": "attnbc*2", "unet_block_id_input": "8", "unet_block_id_middle": "", "unet_block_id_output": "", "unet_attn": "attn2"}], "attention_modifiers_negative": [], "attention_modifiers_positive": [{"sigma_start": 1000, "sigma_end": 7, "self_attn_mod_eval": "attnbc*2", "unet_block_id_input": "8", "unet_block_id_middle": "", "unet_block_id_output": "", "unet_attn": "attn1"}, {"sigma_start": 7, "sigma_end": 2, "self_attn_mod_eval": "attnbc*2", "unet_block_id_input": "8", "unet_block_id_middle": "", "unet_block_id_output": "", "unet_attn": "attn2"}], "auto_cfg_ref": 8.0, "automatic_cfg": "hard", "cond_exp": true, "cond_exp_method": "attention_modifiers_input_using_cond", "cond_exp_normalize": false, "cond_exp_sigma_end": 0.0, "cond_exp_sigma_start": 1000.0, "cond_exp_value": 0.3333333333333333, "eval_string_cond": "", "eval_string_fake": "", "eval_string_uncond": "", "fake_uncond_exp": true, "fake_uncond_exp_method": "attention_modifiers_input_using_uncond", "fake_uncond_exp_normalize": false, "fake_uncond_exp_value": 1000.0, "fake_uncond_multiplier": 1, "fake_uncond_sigma_end": 0.0, "fake_uncond_sigma_start": 1000.0, "fake_uncond_start": true, "latent_intensity_rescale_cfg": 8.0, "latent_intensity_rescale_method": "hard", "lerp_uncond": false, "lerp_uncond_strength": 2.0, "not_in_filter": ["self", "model", "args", "args_filter", "save_as_preset", "preset_name", "model_options_copy", "eval_string"], "skip_uncond": true, "uncond_exp": false, "uncond_exp_method": "amplify", "uncond_exp_normalize": false, "uncond_exp_sigma_end": 0.0, "uncond_exp_sigma_start": 1000.0, "uncond_exp_value": 0.3333333333333333, "uncond_sigma_end": 0.0, "uncond_sigma_start": 150.0}

ComfyUI/custom_nodes/ComfyUI-AutomaticCFG/presets/Mute input layer 8 attn1 and attn2 for uncond.json

@@ -0,0 +1,72 @@
+{"lerp_uncond_sigma_start": 15.0,
+"lerp_uncond_sigma_end": 1.0,
+"subtract_latent_mean": false,
+"subtract_latent_mean_sigma_start": 15.0,
+"subtract_latent_mean_sigma_end": 1.0,
+"latent_intensity_rescale": false,
+"latent_intensity_rescale_sigma_start": 15.0,
+"latent_intensity_rescale_sigma_end": 3.0,
+"ignore_pre_cfg_func": false,
+"auto_cfg_topk": 0.25,
+"attention_modifiers_global_enabled": false,
+"attention_modifiers_global": [],
+"disable_cond": false,
+"disable_cond_sigma_start": 1000.0,
+"disable_cond_sigma_end": 0.0,
+"kwargs": {},
+"attention_modifiers_fake_negative": [{"sigma_start": 1000,
+"sigma_end": 0,
+"self_attn_mod_eval": "torch.zeros_like(q)",
+"unet_block_id_input": "8",
+"unet_block_id_middle": "",
+"unet_block_id_output": "",
+"unet_attn": "attn1"},
+{"sigma_start": 1000,
+"sigma_end": 0,
+"self_attn_mod_eval": "torch.zeros_like(q)",
+"unet_block_id_input": "8",
+"unet_block_id_middle": "",
+"unet_block_id_output": "",
+"unet_attn": "attn2"}],
+"attention_modifiers_negative": [],
+"attention_modifiers_positive": [],
+"auto_cfg_ref": 8.0,
+"automatic_cfg": "hard",
+"cond_exp": false,
+"cond_exp_method": "attention_modifiers_input_using_cond",
+"cond_exp_normalize": false,
+"cond_exp_sigma_end": 0.0,
+"cond_exp_sigma_start": 1000.0,
+"cond_exp_value": 0.3333333333333333,
+"eval_string_cond": "",
+"eval_string_fake": "",
+"eval_string_uncond": "",
+"fake_uncond_exp": true,
+"fake_uncond_exp_method": "attention_modifiers_input_using_uncond",
+"fake_uncond_exp_normalize": false,
+"fake_uncond_exp_value": 1000.0,
+"fake_uncond_multiplier": 1,
+"fake_uncond_sigma_end": 0.0,
+"fake_uncond_sigma_start": 1000.0,
+"fake_uncond_start": true,
+"latent_intensity_rescale_cfg": 8.0,
+"latent_intensity_rescale_method": "hard",
+"lerp_uncond": false,
+"lerp_uncond_strength": 2.0,
+"not_in_filter": ["self",
+"model",
+"args",
+"args_filter",
+"save_as_preset",
+"preset_name",
+"model_options_copy",
+"eval_string"],
+"skip_uncond": true,
+"uncond_exp": false,
+"uncond_exp_method": "amplify",
+"uncond_exp_normalize": false,
+"uncond_exp_sigma_end": 0.0,
+"uncond_exp_sigma_start": 1000.0,
+"uncond_exp_value": 0.3333333333333333,
+"uncond_sigma_end": 0.0,
+"uncond_sigma_start": 0.0}

ComfyUI/custom_nodes/ComfyUI-AutomaticCFG/presets/Mute input layer 8 attn1 for uncond.json

@@ -0,0 +1 @@
+{"lerp_uncond_sigma_start": 15.0, "lerp_uncond_sigma_end": 1.0, "subtract_latent_mean": false, "subtract_latent_mean_sigma_start": 15.0, "subtract_latent_mean_sigma_end": 1.0, "latent_intensity_rescale": false, "latent_intensity_rescale_sigma_start": 15.0, "latent_intensity_rescale_sigma_end": 3.0, "ignore_pre_cfg_func": false, "auto_cfg_topk": 0.25, "attention_modifiers_global_enabled": false, "attention_modifiers_global": [], "disable_cond": false, "disable_cond_sigma_start": 1000.0, "disable_cond_sigma_end": 0.0, "kwargs": {}, "attention_modifiers_fake_negative": [{"sigma_start": 1000, "sigma_end": 0, "self_attn_mod_eval": "torch.zeros_like(q)", "unet_block_id_input": "8", "unet_block_id_middle": "", "unet_block_id_output": "", "unet_attn": "attn1"}], "attention_modifiers_negative": [], "attention_modifiers_positive": [], "auto_cfg_ref": 8.0, "automatic_cfg": "hard", "cond_exp": false, "cond_exp_method": "attention_modifiers_input_using_cond", "cond_exp_normalize": false, "cond_exp_sigma_end": 0.0, "cond_exp_sigma_start": 1000.0, "cond_exp_value": 0.3333333333333333, "eval_string_cond": "", "eval_string_fake": "", "eval_string_uncond": "", "fake_uncond_exp": true, "fake_uncond_exp_method": "attention_modifiers_input_using_uncond", "fake_uncond_exp_normalize": false, "fake_uncond_exp_value": 1000.0, "fake_uncond_multiplier": 1, "fake_uncond_sigma_end": 0.0, "fake_uncond_sigma_start": 1000.0, "fake_uncond_start": true, "latent_intensity_rescale_cfg": 8.0, "latent_intensity_rescale_method": "hard", "lerp_uncond": false, "lerp_uncond_strength": 2.0, "not_in_filter": ["self", "model", "args", "args_filter", "save_as_preset", "preset_name", "model_options_copy", "eval_string"], "skip_uncond": true, "uncond_exp": false, "uncond_exp_method": "amplify", "uncond_exp_normalize": false, "uncond_exp_sigma_end": 0.0, "uncond_exp_sigma_start": 1000.0, "uncond_exp_value": 0.3333333333333333, "uncond_sigma_end": 0.0, "uncond_sigma_start": 0.0}

ComfyUI/custom_nodes/ComfyUI-AutomaticCFG/presets/Mute input layer 8 attn2 for uncond.json

@@ -0,0 +1 @@
+{"lerp_uncond_sigma_start": 15.0, "lerp_uncond_sigma_end": 1.0, "subtract_latent_mean": false, "subtract_latent_mean_sigma_start": 15.0, "subtract_latent_mean_sigma_end": 1.0, "latent_intensity_rescale": false, "latent_intensity_rescale_sigma_start": 15.0, "latent_intensity_rescale_sigma_end": 3.0, "ignore_pre_cfg_func": false, "auto_cfg_topk": 0.25, "attention_modifiers_global_enabled": false, "attention_modifiers_global": [], "disable_cond": false, "disable_cond_sigma_start": 1000.0, "disable_cond_sigma_end": 0.0, "kwargs": {}, "attention_modifiers_fake_negative": [{"sigma_start": 1000, "sigma_end": 0, "self_attn_mod_eval": "torch.zeros_like(q)", "unet_block_id_input": "8", "unet_block_id_middle": "", "unet_block_id_output": "", "unet_attn": "attn2"}], "attention_modifiers_negative": [], "attention_modifiers_positive": [], "auto_cfg_ref": 8.0, "automatic_cfg": "hard", "cond_exp": false, "cond_exp_method": "attention_modifiers_input_using_cond", "cond_exp_normalize": false, "cond_exp_sigma_end": 0.0, "cond_exp_sigma_start": 1000.0, "cond_exp_value": 0.3333333333333333, "eval_string_cond": "", "eval_string_fake": "", "eval_string_uncond": "", "fake_uncond_exp": true, "fake_uncond_exp_method": "attention_modifiers_input_using_uncond", "fake_uncond_exp_normalize": false, "fake_uncond_exp_value": 1000.0, "fake_uncond_multiplier": 1, "fake_uncond_sigma_end": 0.0, "fake_uncond_sigma_start": 1000.0, "fake_uncond_start": true, "latent_intensity_rescale_cfg": 8.0, "latent_intensity_rescale_method": "hard", "lerp_uncond": false, "lerp_uncond_strength": 2.0, "not_in_filter": ["self", "model", "args", "args_filter", "save_as_preset", "preset_name", "model_options_copy", "eval_string"], "skip_uncond": true, "uncond_exp": false, "uncond_exp_method": "amplify", "uncond_exp_normalize": false, "uncond_exp_sigma_end": 0.0, "uncond_exp_sigma_start": 1000.0, "uncond_exp_value": 0.3333333333333333, "uncond_sigma_end": 0.0, "uncond_sigma_start": 0.0}