Bump version from 0.2.6 to 0.2.7

Author: silveroxides

nodes/merger.py

@@ -249,7 +249,7 @@ def define_schema(cls):
 
     @classmethod
     def execute(cls, execution_mode: str, model_a: str, model_b: str,
-                calc_mode: str, mismatch_mode: str, alpha: float, beta: float,
+                calc_mode: str, mismatch_mode: str, alignment_mode: str, alpha: float, beta: float,
                 gamma: float, delta: float, seed: int, output_filename: str, save_dtype: str,
                 process_device: str, exclude_patterns: str, discard_patterns: str) -> io.NodeOutput:
         doc = load_documentation_from_file('merger_2_model_modes.md')
@@ -258,7 +258,7 @@ def execute(cls, execution_mode: str, model_a: str, model_b: str,
 
         recipe_params = {
             "model_a": model_a, "model_b": model_b, "calc_mode": calc_mode,
-            "mismatch_mode": mismatch_mode, "alignment_mode": recipe_params.get('alignment_mode', 'pad/crop'),
+            "mismatch_mode": mismatch_mode, "alignment_mode": alignment_mode,
             "alpha": alpha, "beta": beta, "gamma": gamma, "delta": delta, "seed": seed,
             "output_filename": output_filename, "save_dtype": save_dtype,
             "device": process_device, "dtype": torch.float32,
@@ -304,7 +304,7 @@ def define_schema(cls):
 
     @classmethod
     def execute(cls, execution_mode: str, model_a: str, model_b: str,
-                calc_mode: str, mismatch_mode: str, alpha: float, beta: float,
+                calc_mode: str, mismatch_mode: str, alignment_mode: str, alpha: float, beta: float,
                 gamma: float, delta: float, seed: int, output_filename: str, save_dtype: str,
                 process_device: str, exclude_patterns: str, discard_patterns: str) -> io.NodeOutput:
         doc = load_documentation_from_file('merger_2_model_modes.md')
@@ -313,7 +313,7 @@ def execute(cls, execution_mode: str, model_a: str, model_b: str,
 
         recipe_params = {
             "model_a": model_a, "model_b": model_b, "calc_mode": calc_mode,
-            "mismatch_mode": mismatch_mode, "alignment_mode": recipe_params.get('alignment_mode', 'pad/crop'),
+            "mismatch_mode": mismatch_mode, "alignment_mode": alignment_mode,
             "alpha": alpha, "beta": beta, "gamma": gamma, "delta": delta, "seed": seed,
             "output_filename": output_filename, "save_dtype": save_dtype,
             "device": process_device, "dtype": torch.float32,
@@ -359,7 +359,7 @@ def define_schema(cls):
 
     @classmethod
     def execute(cls, execution_mode: str, model_a: str, model_b: str,
-                calc_mode: str, mismatch_mode: str, alpha: float, beta: float,
+                calc_mode: str, mismatch_mode: str, alignment_mode: str, alpha: float, beta: float,
                 gamma: float, delta: float, seed: int, output_filename: str, save_dtype: str,
                 process_device: str, exclude_patterns: str, discard_patterns: str) -> io.NodeOutput:
         doc = load_documentation_from_file('merger_2_model_modes.md')
@@ -368,7 +368,7 @@ def execute(cls, execution_mode: str, model_a: str, model_b: str,
 
         recipe_params = {
             "model_a": model_a, "model_b": model_b, "calc_mode": calc_mode,
-            "mismatch_mode": mismatch_mode, "alignment_mode": recipe_params.get('alignment_mode', 'pad/crop'),
+            "mismatch_mode": mismatch_mode, "alignment_mode": alignment_mode,
             "alpha": alpha, "beta": beta, "gamma": gamma, "delta": delta, "seed": seed,
             "output_filename": output_filename, "save_dtype": save_dtype,
             "device": process_device, "dtype": torch.float32,
@@ -414,7 +414,7 @@ def define_schema(cls):
 
     @classmethod
     def execute(cls, execution_mode: str, model_a: str, model_b: str,
-                calc_mode: str, mismatch_mode: str, alpha: float, beta: float,
+                calc_mode: str, mismatch_mode: str, alignment_mode: str, alpha: float, beta: float,
                 gamma: float, delta: float, seed: int, output_filename: str, save_dtype: str,
                 process_device: str, exclude_patterns: str, discard_patterns: str) -> io.NodeOutput:
         doc = load_documentation_from_file('merger_2_model_modes.md')
@@ -423,7 +423,7 @@ def execute(cls, execution_mode: str, model_a: str, model_b: str,
 
         recipe_params = {
             "model_a": model_a, "model_b": model_b, "calc_mode": calc_mode,
-            "mismatch_mode": mismatch_mode, "alignment_mode": recipe_params.get('alignment_mode', 'pad/crop'),
+            "mismatch_mode": mismatch_mode, "alignment_mode": alignment_mode,
             "alpha": alpha, "beta": beta, "gamma": gamma, "delta": delta, "seed": seed,
             "output_filename": output_filename, "save_dtype": save_dtype,
             "device": process_device, "dtype": torch.float32,
@@ -469,7 +469,7 @@ def define_schema(cls):
 
     @classmethod
     def execute(cls, execution_mode: str, model_a: str, model_b: str,
-                calc_mode: str, mismatch_mode: str, alpha: float, beta: float,
+                calc_mode: str, mismatch_mode: str, alignment_mode: str, alpha: float, beta: float,
                 gamma: float, delta: float, seed: int, output_filename: str, save_dtype: str,
                 process_device: str, exclude_patterns: str, discard_patterns: str) -> io.NodeOutput:
         doc = load_documentation_from_file('merger_2_model_modes.md')
@@ -478,7 +478,7 @@ def execute(cls, execution_mode: str, model_a: str, model_b: str,
 
         recipe_params = {
             "model_a": model_a, "model_b": model_b, "calc_mode": calc_mode,
-            "mismatch_mode": mismatch_mode, "alignment_mode": recipe_params.get('alignment_mode', 'pad/crop'),
+            "mismatch_mode": mismatch_mode, "alignment_mode": alignment_mode,
             "alpha": alpha, "beta": beta, "gamma": gamma, "delta": delta, "seed": seed,
             "output_filename": output_filename, "save_dtype": save_dtype,
             "device": process_device, "dtype": torch.float32,
@@ -527,7 +527,7 @@ def define_schema(cls):
 
     @classmethod
     def execute(cls, execution_mode: str, model_a: str, model_b: str, model_c: str,
-                calc_mode: str, mismatch_mode: str, alpha: float, beta: float,
+                calc_mode: str, mismatch_mode: str, alignment_mode: str, alpha: float, beta: float,
                 gamma: float, delta: float, seed: int, output_filename: str, save_dtype: str,
                 process_device: str, exclude_patterns: str, discard_patterns: str) -> io.NodeOutput:
         doc = load_documentation_from_file('merger_3_model_modes.md')
@@ -536,7 +536,7 @@ def execute(cls, execution_mode: str, model_a: str, model_b: str, model_c: str,
 
         recipe_params = {
             "model_a": model_a, "model_b": model_b, "model_c": model_c, "calc_mode": calc_mode,
-            "mismatch_mode": mismatch_mode, "alignment_mode": recipe_params.get('alignment_mode', 'pad/crop'),
+            "mismatch_mode": mismatch_mode, "alignment_mode": alignment_mode,
             "alpha": alpha, "beta": beta, "gamma": gamma, "delta": delta, "seed": seed,
             "output_filename": output_filename, "save_dtype": save_dtype,
             "device": process_device, "dtype": torch.float32,
@@ -583,7 +583,7 @@ def define_schema(cls):
 
     @classmethod
     def execute(cls, execution_mode: str, model_a: str, model_b: str, model_c: str,
-                calc_mode: str, mismatch_mode: str, alpha: float, beta: float,
+                calc_mode: str, mismatch_mode: str, alignment_mode: str, alpha: float, beta: float,
                 gamma: float, delta: float, seed: int, output_filename: str, save_dtype: str,
                 process_device: str, exclude_patterns: str, discard_patterns: str) -> io.NodeOutput:
         doc = load_documentation_from_file('merger_3_model_modes.md')
@@ -592,7 +592,7 @@ def execute(cls, execution_mode: str, model_a: str, model_b: str, model_c: str,
 
         recipe_params = {
             "model_a": model_a, "model_b": model_b, "model_c": model_c, "calc_mode": calc_mode,
-            "mismatch_mode": mismatch_mode, "alignment_mode": recipe_params.get('alignment_mode', 'pad/crop'),
+            "mismatch_mode": mismatch_mode, "alignment_mode": alignment_mode,
             "alpha": alpha, "beta": beta, "gamma": gamma, "delta": delta, "seed": seed,
             "output_filename": output_filename, "save_dtype": save_dtype,
             "device": process_device, "dtype": torch.float32,
@@ -639,7 +639,7 @@ def define_schema(cls):
 
     @classmethod
     def execute(cls, execution_mode: str, model_a: str, model_b: str, model_c: str,
-                calc_mode: str, mismatch_mode: str, alpha: float, beta: float,
+                calc_mode: str, mismatch_mode: str, alignment_mode: str, alpha: float, beta: float,
                 gamma: float, delta: float, seed: int, output_filename: str, save_dtype: str,
                 process_device: str, exclude_patterns: str, discard_patterns: str) -> io.NodeOutput:
         doc = load_documentation_from_file('merger_3_model_modes.md')
@@ -648,7 +648,7 @@ def execute(cls, execution_mode: str, model_a: str, model_b: str, model_c: str,
 
         recipe_params = {
             "model_a": model_a, "model_b": model_b, "model_c": model_c, "calc_mode": calc_mode,
-            "mismatch_mode": mismatch_mode, "alignment_mode": recipe_params.get('alignment_mode', 'pad/crop'),
+            "mismatch_mode": mismatch_mode, "alignment_mode": alignment_mode,
             "alpha": alpha, "beta": beta, "gamma": gamma, "delta": delta, "seed": seed,
             "output_filename": output_filename, "save_dtype": save_dtype,
             "device": process_device, "dtype": torch.float32,
@@ -695,7 +695,7 @@ def define_schema(cls):
 
     @classmethod
     def execute(cls, execution_mode: str, model_a: str, model_b: str, model_c: str,
-                calc_mode: str, mismatch_mode: str, alpha: float, beta: float,
+                calc_mode: str, mismatch_mode: str, alignment_mode: str, alpha: float, beta: float,
                 gamma: float, delta: float, seed: int, output_filename: str, save_dtype: str,
                 process_device: str, exclude_patterns: str, discard_patterns: str) -> io.NodeOutput:
         doc = load_documentation_from_file('merger_3_model_modes.md')
@@ -704,7 +704,7 @@ def execute(cls, execution_mode: str, model_a: str, model_b: str, model_c: str,
 
         recipe_params = {
             "model_a": model_a, "model_b": model_b, "model_c": model_c, "calc_mode": calc_mode,
-            "mismatch_mode": mismatch_mode, "alignment_mode": recipe_params.get('alignment_mode', 'pad/crop'),
+            "mismatch_mode": mismatch_mode, "alignment_mode": alignment_mode,
             "alpha": alpha, "beta": beta, "gamma": gamma, "delta": delta, "seed": seed,
             "output_filename": output_filename, "save_dtype": save_dtype,
             "device": process_device, "dtype": torch.float32,
@@ -751,7 +751,7 @@ def define_schema(cls):
 
     @classmethod
     def execute(cls, execution_mode: str, model_a: str, model_b: str, model_c: str,
-                calc_mode: str, mismatch_mode: str, alpha: float, beta: float,
+                calc_mode: str, mismatch_mode: str, alignment_mode: str, alpha: float, beta: float,
                 gamma: float, delta: float, seed: int, output_filename: str, save_dtype: str,
                 process_device: str, exclude_patterns: str, discard_patterns: str) -> io.NodeOutput:
         doc = load_documentation_from_file('merger_3_model_modes.md')
@@ -760,7 +760,7 @@ def execute(cls, execution_mode: str, model_a: str, model_b: str, model_c: str,
 
         recipe_params = {
             "model_a": model_a, "model_b": model_b, "model_c": model_c, "calc_mode": calc_mode,
-            "mismatch_mode": mismatch_mode, "alignment_mode": recipe_params.get('alignment_mode', 'pad/crop'),
+            "mismatch_mode": mismatch_mode, "alignment_mode": alignment_mode,
             "alpha": alpha, "beta": beta, "gamma": gamma, "delta": delta, "seed": seed,
             "output_filename": output_filename, "save_dtype": save_dtype,
             "device": process_device, "dtype": torch.float32,

nodes/merger_ops.py

@@ -40,6 +40,14 @@ def resize_by_interpolation(tensor1, tensor2):
     t2_f = t2_f.view(view_shape)
 
     # Select mode based on dimensions
+    if dims1 == 4:
+        # [Out, In, H, W] -> [1, 1, Out, In, H*W] (5D)
+        view_shape = [1, 1, tensor2.shape[0], tensor2.shape[1], tensor2.shape[2] * tensor2.shape[3]]
+        target_size = [tensor1.shape[0], tensor1.shape[1], tensor1.shape[2] * tensor1.shape[3]]
+        t2_f = t2_f.view(view_shape)
+        t2_res = F.interpolate(t2_f, size=target_size, mode='trilinear', align_corners=False)
+        return tensor1, t2_res.view(tensor1.shape).to(orig_dtype)
+
     if dims1 == 1:
         mode = 'linear'
     elif dims1 == 2:
@@ -448,6 +456,7 @@ def create_recipe(self, key, **kwargs):
         b = LoadTensor(key, kwargs['model_b'], **loader_args_bc)
         c = LoadTensor(key, kwargs['model_c'], **loader_args_bc)
         diff = Sub(key, b, c)
+        diff.alignment_mode = alignment_mode
         if kwargs['beta'] == 1: diff = Smooth(key, diff)
         diffm = Multiply(key, kwargs['alpha'], diff)
         res = Add(key, a, diffm)
@@ -474,6 +483,7 @@ def create_recipe(self, key, **kwargs):
         b = LoadTensor(key, kwargs['model_b'], **loader_args_bc)
         c = LoadTensor(key, kwargs['model_c'], **loader_args_bc)
         diff = TrainDiff(key, a, b, c)
+        diff.alignment_mode = alignment_mode
         diffm = Multiply(key, kwargs['alpha'], diff)
         res = Add(key, a, diffm)
         res.alignment_mode = alignment_mode
@@ -523,6 +533,7 @@ def create_recipe(self, key, **kwargs):
         b = LoadTensor(key, kwargs['model_b'], **loader_args_bc)
         c = LoadTensor(key, kwargs['model_c'], **loader_args_bc)
         extracted = ExtractOp(key, kwargs['alpha'], kwargs['beta'], kwargs['gamma'] * 15, a, b, c)
+        extracted.alignment_mode = alignment_mode
         multiplied = Multiply(key, kwargs['delta'], extracted)
         res = Add(key, a, multiplied)
         res.alignment_mode = alignment_mode
@@ -548,6 +559,7 @@ def create_recipe(self, key, **kwargs):
         b = LoadTensor(key, kwargs['model_b'], **loader_args_bc)
         c = LoadTensor(key, kwargs['model_c'], **loader_args_bc)
         extracted = Similarities(key, kwargs['alpha'], 1, kwargs['gamma'] * 15, b, c)
+        extracted.alignment_mode = alignment_mode
         multiplied = Multiply(key, kwargs['beta'], extracted)
         res = Add(key, a, multiplied)
         res.alignment_mode = alignment_mode

pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "ComfyUI-ModelUtils"
 description = "[WIP]Custom nodes for handling, inspecting, modifying and creating various model files."
-version = "0.2.6"
+version = "0.2.7"
 license = { file = "LICENSE" }
 
 [project.urls]