(IMPORT FAILED) ComfyUI Inpaint Nodes?

[biu5332]

[s-akamatsu-vb]

I have the same problem.

[Koxae]

I also can't install with this problem

[youxiaohanpian]

1.update ComfyUI and
pip install -r requirements.txt
2.reinstall this node

Use this way I solve this problem, I hope it will also help you guys!

[Koxae]

pip install -r requirements.txt

1.update ComfyUI and pip install -r requirements.txt 2.reinstall this node

Use this way I solve this problem, I hope it will also help you guys!

1.update ComfyUI and pip install -r requirements.txt 2.reinstall this node

Use this way I solve this problem, I hope it will also help you guys!

Thanks! Unfortunately, it didn't work for me. Maybe there is some dependency on the Python version, I'm not sure.

[Acly]

You will find the reason for failed import in ComfyUI's output (terminal window).

[Koxae]

You will find the reason for failed import in ComfyUI's output (terminal window).

Thanks! I have the following records:

File "C:\ai\ComfyUI\ComfyUI\custom_nodes\comfyui-inpaint-nodes\nodes.py", line 63, in <module>
    raise RuntimeError(too_old_msg)
RuntimeError: comfyui-inpaint-nodes requires a newer version of ComfyUI (v0.1.1 or later), please update!

Cannot import C:\ai\ComfyUI\ComfyUI\custom_nodes\comfyui-inpaint-nodes module for custom nodes: comfyui-inpaint-nodes requires a newer version of ComfyUI (v0.1.1 or later), please update!

But ComfyUI has already been updated to the latest version (ComfyUI v0.2.2 Release).

[Koxae]

I was able to fix it. I can't be 100% sure about the correct sequence, because some of my actions were repetitions of found solutions, and not conscious actions.
I performed these actions:

python -m pip uninstall torch
pip install h5py
pip install typing-extensions
pip install wheel
pip install tensorflow==2.13.0rc2
python -m pip install typing_extensions==4.11
python -m pip install torch==2.3.1 torchvision==0.18.1 torchaudio==2.3.1 --extra-index-url https://download.pytorch.org/whl/cu121
pip install insightface==0.7.3

[lsky-walt]

have same problem.

[balala8]

I also encountered this problem, but after I updated comfyui, the problem was not solved. Finally, I found that the root cause of the problem was that the code in the comfy/lora.py file was changed (probably a custom node). Paste the following code at the end of the lora.py file to solve the problem.

def weight_decompose(dora_scale, weight, lora_diff, alpha, strength, intermediate_dtype):
   dora_scale = comfy.model_management.cast_to_device(dora_scale, weight.device, intermediate_dtype)
   lora_diff *= alpha
   weight_calc = weight + lora_diff.type(weight.dtype)
   weight_norm = (
       weight_calc.transpose(0, 1)
       .reshape(weight_calc.shape[1], -1)
       .norm(dim=1, keepdim=True)
       .reshape(weight_calc.shape[1], *[1] * (weight_calc.dim() - 1))
       .transpose(0, 1)
   )

   weight_calc *= (dora_scale / weight_norm).type(weight.dtype)
   if strength != 1.0:
       weight_calc -= weight
       weight += strength * (weight_calc)
   else:
       weight[:] = weight_calc
   return weight

def pad_tensor_to_shape(tensor: torch.Tensor, new_shape: list[int]) -> torch.Tensor:
   """
   Pad a tensor to a new shape with zeros.

   Args:
       tensor (torch.Tensor): The original tensor to be padded.
       new_shape (List[int]): The desired shape of the padded tensor.

   Returns:
       torch.Tensor: A new tensor padded with zeros to the specified shape.

   Note:
       If the new shape is smaller than the original tensor in any dimension,
       the original tensor will be truncated in that dimension.
   """
   if any([new_shape[i] < tensor.shape[i] for i in range(len(new_shape))]):
       raise ValueError("The new shape must be larger than the original tensor in all dimensions")

   if len(new_shape) != len(tensor.shape):
       raise ValueError("The new shape must have the same number of dimensions as the original tensor")

   # Create a new tensor filled with zeros
   padded_tensor = torch.zeros(new_shape, dtype=tensor.dtype, device=tensor.device)

   # Create slicing tuples for both tensors
   orig_slices = tuple(slice(0, dim) for dim in tensor.shape)
   new_slices = tuple(slice(0, dim) for dim in tensor.shape)

   # Copy the original tensor into the new tensor
   padded_tensor[new_slices] = tensor[orig_slices]

   return padded_tensor

def calculate_weight(patches, weight, key, intermediate_dtype=torch.float32):
   for p in patches:
       strength = p[0]
       v = p[1]
       strength_model = p[2]
       offset = p[3]
       function = p[4]
       if function is None:
           function = lambda a: a

       old_weight = None
       if offset is not None:
           old_weight = weight
           weight = weight.narrow(offset[0], offset[1], offset[2])

       if strength_model != 1.0:
           weight *= strength_model

       if isinstance(v, list):
           v = (calculate_weight(v[1:], comfy.model_management.cast_to_device(v[0], weight.device, intermediate_dtype, copy=True), key, intermediate_dtype=intermediate_dtype), )

       if len(v) == 1:
           patch_type = "diff"
       elif len(v) == 2:
           patch_type = v[0]
           v = v[1]

       if patch_type == "diff":
           diff: torch.Tensor = v[0]
           # An extra flag to pad the weight if the diff's shape is larger than the weight
           do_pad_weight = len(v) > 1 and v[1]['pad_weight']
           if do_pad_weight and diff.shape != weight.shape:
               logging.info("Pad weight {} from {} to shape: {}".format(key, weight.shape, diff.shape))
               weight = pad_tensor_to_shape(weight, diff.shape)

           if strength != 0.0:
               if diff.shape != weight.shape:
                   logging.warning("WARNING SHAPE MISMATCH {} WEIGHT NOT MERGED {} != {}".format(key, diff.shape, weight.shape))
               else:
                   weight += function(strength * comfy.model_management.cast_to_device(diff, weight.device, weight.dtype))
       elif patch_type == "lora": #lora/locon
           mat1 = comfy.model_management.cast_to_device(v[0], weight.device, intermediate_dtype)
           mat2 = comfy.model_management.cast_to_device(v[1], weight.device, intermediate_dtype)
           dora_scale = v[4]
           if v[2] is not None:
               alpha = v[2] / mat2.shape[0]
           else:
               alpha = 1.0

           if v[3] is not None:
               #locon mid weights, hopefully the math is fine because I didn't properly test it
               mat3 = comfy.model_management.cast_to_device(v[3], weight.device, intermediate_dtype)
               final_shape = [mat2.shape[1], mat2.shape[0], mat3.shape[2], mat3.shape[3]]
               mat2 = torch.mm(mat2.transpose(0, 1).flatten(start_dim=1), mat3.transpose(0, 1).flatten(start_dim=1)).reshape(final_shape).transpose(0, 1)
           try:
               lora_diff = torch.mm(mat1.flatten(start_dim=1), mat2.flatten(start_dim=1)).reshape(weight.shape)
               if dora_scale is not None:
                   weight = function(weight_decompose(dora_scale, weight, lora_diff, alpha, strength, intermediate_dtype))
               else:
                   weight += function(((strength * alpha) * lora_diff).type(weight.dtype))
           except Exception as e:
               logging.error("ERROR {} {} {}".format(patch_type, key, e))
       elif patch_type == "lokr":
           w1 = v[0]
           w2 = v[1]
           w1_a = v[3]
           w1_b = v[4]
           w2_a = v[5]
           w2_b = v[6]
           t2 = v[7]
           dora_scale = v[8]
           dim = None

           if w1 is None:
               dim = w1_b.shape[0]
               w1 = torch.mm(comfy.model_management.cast_to_device(w1_a, weight.device, intermediate_dtype),
                               comfy.model_management.cast_to_device(w1_b, weight.device, intermediate_dtype))
           else:
               w1 = comfy.model_management.cast_to_device(w1, weight.device, intermediate_dtype)

           if w2 is None:
               dim = w2_b.shape[0]
               if t2 is None:
                   w2 = torch.mm(comfy.model_management.cast_to_device(w2_a, weight.device, intermediate_dtype),
                                   comfy.model_management.cast_to_device(w2_b, weight.device, intermediate_dtype))
               else:
                   w2 = torch.einsum('i j k l, j r, i p -> p r k l',
                                       comfy.model_management.cast_to_device(t2, weight.device, intermediate_dtype),
                                       comfy.model_management.cast_to_device(w2_b, weight.device, intermediate_dtype),
                                       comfy.model_management.cast_to_device(w2_a, weight.device, intermediate_dtype))
           else:
               w2 = comfy.model_management.cast_to_device(w2, weight.device, intermediate_dtype)

           if len(w2.shape) == 4:
               w1 = w1.unsqueeze(2).unsqueeze(2)
           if v[2] is not None and dim is not None:
               alpha = v[2] / dim
           else:
               alpha = 1.0

           try:
               lora_diff = torch.kron(w1, w2).reshape(weight.shape)
               if dora_scale is not None:
                   weight = function(weight_decompose(dora_scale, weight, lora_diff, alpha, strength, intermediate_dtype))
               else:
                   weight += function(((strength * alpha) * lora_diff).type(weight.dtype))
           except Exception as e:
               logging.error("ERROR {} {} {}".format(patch_type, key, e))
       elif patch_type == "loha":
           w1a = v[0]
           w1b = v[1]
           if v[2] is not None:
               alpha = v[2] / w1b.shape[0]
           else:
               alpha = 1.0

           w2a = v[3]
           w2b = v[4]
           dora_scale = v[7]
           if v[5] is not None: #cp decomposition
               t1 = v[5]
               t2 = v[6]
               m1 = torch.einsum('i j k l, j r, i p -> p r k l',
                                   comfy.model_management.cast_to_device(t1, weight.device, intermediate_dtype),
                                   comfy.model_management.cast_to_device(w1b, weight.device, intermediate_dtype),
                                   comfy.model_management.cast_to_device(w1a, weight.device, intermediate_dtype))

               m2 = torch.einsum('i j k l, j r, i p -> p r k l',
                                   comfy.model_management.cast_to_device(t2, weight.device, intermediate_dtype),
                                   comfy.model_management.cast_to_device(w2b, weight.device, intermediate_dtype),
                                   comfy.model_management.cast_to_device(w2a, weight.device, intermediate_dtype))
           else:
               m1 = torch.mm(comfy.model_management.cast_to_device(w1a, weight.device, intermediate_dtype),
                               comfy.model_management.cast_to_device(w1b, weight.device, intermediate_dtype))
               m2 = torch.mm(comfy.model_management.cast_to_device(w2a, weight.device, intermediate_dtype),
                               comfy.model_management.cast_to_device(w2b, weight.device, intermediate_dtype))

           try:
               lora_diff = (m1 * m2).reshape(weight.shape)
               if dora_scale is not None:
                   weight = function(weight_decompose(dora_scale, weight, lora_diff, alpha, strength, intermediate_dtype))
               else:
                   weight += function(((strength * alpha) * lora_diff).type(weight.dtype))
           except Exception as e:
               logging.error("ERROR {} {} {}".format(patch_type, key, e))
       elif patch_type == "glora":
           dora_scale = v[5]

           old_glora = False
           if v[3].shape[1] == v[2].shape[0] == v[0].shape[0] == v[1].shape[1]:
               rank = v[0].shape[0]
               old_glora = True

           if v[3].shape[0] == v[2].shape[1] == v[0].shape[1] == v[1].shape[0]:
               if old_glora and v[1].shape[0] == weight.shape[0] and weight.shape[0] == weight.shape[1]:
                   pass
               else:
                   old_glora = False
                   rank = v[1].shape[0]

           a1 = comfy.model_management.cast_to_device(v[0].flatten(start_dim=1), weight.device, intermediate_dtype)
           a2 = comfy.model_management.cast_to_device(v[1].flatten(start_dim=1), weight.device, intermediate_dtype)
           b1 = comfy.model_management.cast_to_device(v[2].flatten(start_dim=1), weight.device, intermediate_dtype)
           b2 = comfy.model_management.cast_to_device(v[3].flatten(start_dim=1), weight.device, intermediate_dtype)

           if v[4] is not None:
               alpha = v[4] / rank
           else:
               alpha = 1.0

           try:
               if old_glora:
                   lora_diff = (torch.mm(b2, b1) + torch.mm(torch.mm(weight.flatten(start_dim=1).to(dtype=intermediate_dtype), a2), a1)).reshape(weight.shape) #old lycoris glora
               else:
                   if weight.dim() > 2:
                       lora_diff = torch.einsum("o i ..., i j -> o j ...", torch.einsum("o i ..., i j -> o j ...", weight.to(dtype=intermediate_dtype), a1), a2).reshape(weight.shape)
                   else:
                       lora_diff = torch.mm(torch.mm(weight.to(dtype=intermediate_dtype), a1), a2).reshape(weight.shape)
                   lora_diff += torch.mm(b1, b2).reshape(weight.shape)

               if dora_scale is not None:
                   weight = function(weight_decompose(dora_scale, weight, lora_diff, alpha, strength, intermediate_dtype))
               else:
                   weight += function(((strength * alpha) * lora_diff).type(weight.dtype))
           except Exception as e:
               logging.error("ERROR {} {} {}".format(patch_type, key, e))
       else:
           logging.warning("patch type not recognized {} {}".format(patch_type, key))

       if old_weight is not None:
           weight = old_weight

   return weight

[Natriumpikant]

I also encountered this problem, but after I updated comfyui, the problem was not solved. Finally, I found that the root cause of the problem was that the code in the comfy/lora.py file was changed (probably a custom node). Paste the following code at the end of the lora.py file to solve the problem.

def weight_decompose(dora_scale, weight, lora_diff, alpha, strength, intermediate_dtype):
   dora_scale = comfy.model_management.cast_to_device(dora_scale, weight.device, intermediate_dtype)
   lora_diff *= alpha
   weight_calc = weight + lora_diff.type(weight.dtype)
   weight_norm = (
       weight_calc.transpose(0, 1)
       .reshape(weight_calc.shape[1], -1)
       .norm(dim=1, keepdim=True)
       .reshape(weight_calc.shape[1], *[1] * (weight_calc.dim() - 1))
       .transpose(0, 1)
   )

   weight_calc *= (dora_scale / weight_norm).type(weight.dtype)
   if strength != 1.0:
       weight_calc -= weight
       weight += strength * (weight_calc)
   else:
       weight[:] = weight_calc
   return weight

def pad_tensor_to_shape(tensor: torch.Tensor, new_shape: list[int]) -> torch.Tensor:
   """
   Pad a tensor to a new shape with zeros.

   Args:
       tensor (torch.Tensor): The original tensor to be padded.
       new_shape (List[int]): The desired shape of the padded tensor.

   Returns:
       torch.Tensor: A new tensor padded with zeros to the specified shape.

   Note:
       If the new shape is smaller than the original tensor in any dimension,
       the original tensor will be truncated in that dimension.
   """
   if any([new_shape[i] < tensor.shape[i] for i in range(len(new_shape))]):
       raise ValueError("The new shape must be larger than the original tensor in all dimensions")

   if len(new_shape) != len(tensor.shape):
       raise ValueError("The new shape must have the same number of dimensions as the original tensor")

   # Create a new tensor filled with zeros
   padded_tensor = torch.zeros(new_shape, dtype=tensor.dtype, device=tensor.device)

   # Create slicing tuples for both tensors
   orig_slices = tuple(slice(0, dim) for dim in tensor.shape)
   new_slices = tuple(slice(0, dim) for dim in tensor.shape)

   # Copy the original tensor into the new tensor
   padded_tensor[new_slices] = tensor[orig_slices]

   return padded_tensor

def calculate_weight(patches, weight, key, intermediate_dtype=torch.float32):
   for p in patches:
       strength = p[0]
       v = p[1]
       strength_model = p[2]
       offset = p[3]
       function = p[4]
       if function is None:
           function = lambda a: a

       old_weight = None
       if offset is not None:
           old_weight = weight
           weight = weight.narrow(offset[0], offset[1], offset[2])

       if strength_model != 1.0:
           weight *= strength_model

       if isinstance(v, list):
           v = (calculate_weight(v[1:], comfy.model_management.cast_to_device(v[0], weight.device, intermediate_dtype, copy=True), key, intermediate_dtype=intermediate_dtype), )

       if len(v) == 1:
           patch_type = "diff"
       elif len(v) == 2:
           patch_type = v[0]
           v = v[1]

       if patch_type == "diff":
           diff: torch.Tensor = v[0]
           # An extra flag to pad the weight if the diff's shape is larger than the weight
           do_pad_weight = len(v) > 1 and v[1]['pad_weight']
           if do_pad_weight and diff.shape != weight.shape:
               logging.info("Pad weight {} from {} to shape: {}".format(key, weight.shape, diff.shape))
               weight = pad_tensor_to_shape(weight, diff.shape)

           if strength != 0.0:
               if diff.shape != weight.shape:
                   logging.warning("WARNING SHAPE MISMATCH {} WEIGHT NOT MERGED {} != {}".format(key, diff.shape, weight.shape))
               else:
                   weight += function(strength * comfy.model_management.cast_to_device(diff, weight.device, weight.dtype))
       elif patch_type == "lora": #lora/locon
           mat1 = comfy.model_management.cast_to_device(v[0], weight.device, intermediate_dtype)
           mat2 = comfy.model_management.cast_to_device(v[1], weight.device, intermediate_dtype)
           dora_scale = v[4]
           if v[2] is not None:
               alpha = v[2] / mat2.shape[0]
           else:
               alpha = 1.0

           if v[3] is not None:
               #locon mid weights, hopefully the math is fine because I didn't properly test it
               mat3 = comfy.model_management.cast_to_device(v[3], weight.device, intermediate_dtype)
               final_shape = [mat2.shape[1], mat2.shape[0], mat3.shape[2], mat3.shape[3]]
               mat2 = torch.mm(mat2.transpose(0, 1).flatten(start_dim=1), mat3.transpose(0, 1).flatten(start_dim=1)).reshape(final_shape).transpose(0, 1)
           try:
               lora_diff = torch.mm(mat1.flatten(start_dim=1), mat2.flatten(start_dim=1)).reshape(weight.shape)
               if dora_scale is not None:
                   weight = function(weight_decompose(dora_scale, weight, lora_diff, alpha, strength, intermediate_dtype))
               else:
                   weight += function(((strength * alpha) * lora_diff).type(weight.dtype))
           except Exception as e:
               logging.error("ERROR {} {} {}".format(patch_type, key, e))
       elif patch_type == "lokr":
           w1 = v[0]
           w2 = v[1]
           w1_a = v[3]
           w1_b = v[4]
           w2_a = v[5]
           w2_b = v[6]
           t2 = v[7]
           dora_scale = v[8]
           dim = None

           if w1 is None:
               dim = w1_b.shape[0]
               w1 = torch.mm(comfy.model_management.cast_to_device(w1_a, weight.device, intermediate_dtype),
                               comfy.model_management.cast_to_device(w1_b, weight.device, intermediate_dtype))
           else:
               w1 = comfy.model_management.cast_to_device(w1, weight.device, intermediate_dtype)

           if w2 is None:
               dim = w2_b.shape[0]
               if t2 is None:
                   w2 = torch.mm(comfy.model_management.cast_to_device(w2_a, weight.device, intermediate_dtype),
                                   comfy.model_management.cast_to_device(w2_b, weight.device, intermediate_dtype))
               else:
                   w2 = torch.einsum('i j k l, j r, i p -> p r k l',
                                       comfy.model_management.cast_to_device(t2, weight.device, intermediate_dtype),
                                       comfy.model_management.cast_to_device(w2_b, weight.device, intermediate_dtype),
                                       comfy.model_management.cast_to_device(w2_a, weight.device, intermediate_dtype))
           else:
               w2 = comfy.model_management.cast_to_device(w2, weight.device, intermediate_dtype)

           if len(w2.shape) == 4:
               w1 = w1.unsqueeze(2).unsqueeze(2)
           if v[2] is not None and dim is not None:
               alpha = v[2] / dim
           else:
               alpha = 1.0

           try:
               lora_diff = torch.kron(w1, w2).reshape(weight.shape)
               if dora_scale is not None:
                   weight = function(weight_decompose(dora_scale, weight, lora_diff, alpha, strength, intermediate_dtype))
               else:
                   weight += function(((strength * alpha) * lora_diff).type(weight.dtype))
           except Exception as e:
               logging.error("ERROR {} {} {}".format(patch_type, key, e))
       elif patch_type == "loha":
           w1a = v[0]
           w1b = v[1]
           if v[2] is not None:
               alpha = v[2] / w1b.shape[0]
           else:
               alpha = 1.0

           w2a = v[3]
           w2b = v[4]
           dora_scale = v[7]
           if v[5] is not None: #cp decomposition
               t1 = v[5]
               t2 = v[6]
               m1 = torch.einsum('i j k l, j r, i p -> p r k l',
                                   comfy.model_management.cast_to_device(t1, weight.device, intermediate_dtype),
                                   comfy.model_management.cast_to_device(w1b, weight.device, intermediate_dtype),
                                   comfy.model_management.cast_to_device(w1a, weight.device, intermediate_dtype))

               m2 = torch.einsum('i j k l, j r, i p -> p r k l',
                                   comfy.model_management.cast_to_device(t2, weight.device, intermediate_dtype),
                                   comfy.model_management.cast_to_device(w2b, weight.device, intermediate_dtype),
                                   comfy.model_management.cast_to_device(w2a, weight.device, intermediate_dtype))
           else:
               m1 = torch.mm(comfy.model_management.cast_to_device(w1a, weight.device, intermediate_dtype),
                               comfy.model_management.cast_to_device(w1b, weight.device, intermediate_dtype))
               m2 = torch.mm(comfy.model_management.cast_to_device(w2a, weight.device, intermediate_dtype),
                               comfy.model_management.cast_to_device(w2b, weight.device, intermediate_dtype))

           try:
               lora_diff = (m1 * m2).reshape(weight.shape)
               if dora_scale is not None:
                   weight = function(weight_decompose(dora_scale, weight, lora_diff, alpha, strength, intermediate_dtype))
               else:
                   weight += function(((strength * alpha) * lora_diff).type(weight.dtype))
           except Exception as e:
               logging.error("ERROR {} {} {}".format(patch_type, key, e))
       elif patch_type == "glora":
           dora_scale = v[5]

           old_glora = False
           if v[3].shape[1] == v[2].shape[0] == v[0].shape[0] == v[1].shape[1]:
               rank = v[0].shape[0]
               old_glora = True

           if v[3].shape[0] == v[2].shape[1] == v[0].shape[1] == v[1].shape[0]:
               if old_glora and v[1].shape[0] == weight.shape[0] and weight.shape[0] == weight.shape[1]:
                   pass
               else:
                   old_glora = False
                   rank = v[1].shape[0]

           a1 = comfy.model_management.cast_to_device(v[0].flatten(start_dim=1), weight.device, intermediate_dtype)
           a2 = comfy.model_management.cast_to_device(v[1].flatten(start_dim=1), weight.device, intermediate_dtype)
           b1 = comfy.model_management.cast_to_device(v[2].flatten(start_dim=1), weight.device, intermediate_dtype)
           b2 = comfy.model_management.cast_to_device(v[3].flatten(start_dim=1), weight.device, intermediate_dtype)

           if v[4] is not None:
               alpha = v[4] / rank
           else:
               alpha = 1.0

           try:
               if old_glora:
                   lora_diff = (torch.mm(b2, b1) + torch.mm(torch.mm(weight.flatten(start_dim=1).to(dtype=intermediate_dtype), a2), a1)).reshape(weight.shape) #old lycoris glora
               else:
                   if weight.dim() > 2:
                       lora_diff = torch.einsum("o i ..., i j -> o j ...", torch.einsum("o i ..., i j -> o j ...", weight.to(dtype=intermediate_dtype), a1), a2).reshape(weight.shape)
                   else:
                       lora_diff = torch.mm(torch.mm(weight.to(dtype=intermediate_dtype), a1), a2).reshape(weight.shape)
                   lora_diff += torch.mm(b1, b2).reshape(weight.shape)

               if dora_scale is not None:
                   weight = function(weight_decompose(dora_scale, weight, lora_diff, alpha, strength, intermediate_dtype))
               else:
                   weight += function(((strength * alpha) * lora_diff).type(weight.dtype))
           except Exception as e:
               logging.error("ERROR {} {} {}".format(patch_type, key, e))
       else:
           logging.warning("patch type not recognized {} {}".format(patch_type, key))

       if old_weight is not None:
           weight = old_weight

   return weight

This one works.

But you also have to add

import torch

at beginning of comfy/lora.py