Merge 2d3a8d523d into 4e6a1b66a9

comfy/latent_formats.py

@@ -594,7 +594,6 @@ class Wan22(Wan21):
 class HunyuanImage21(LatentFormat):
     latent_channels = 64
     latent_dimensions = 2
-    spacial_downscale_ratio = 32
     scale_factor = 0.75289
 
     latent_rgb_factors = [
@@ -728,7 +727,6 @@ class HunyuanVideo15(LatentFormat):
     latent_rgb_factors_bias = [ 0.0456, -0.0202, -0.0644]
     latent_channels = 32
     latent_dimensions = 3
-    spacial_downscale_ratio = 16
     scale_factor = 1.03682
     taesd_decoder_name = "lighttaehy1_5"
 

comfy/ldm/lumina/model.py

@@ -451,7 +451,6 @@ class NextDiT(nn.Module):
         device=None,
         dtype=None,
         operations=None,
-        **kwargs,
     ) -> None:
         super().__init__()
         self.dtype = dtype

comfy/model_detection.py

@@ -444,10 +444,6 @@ def detect_unet_config(state_dict, key_prefix, metadata=None):
             dit_config["ffn_dim_multiplier"] = (8.0 / 3.0)
             dit_config["z_image_modulation"] = True
             dit_config["time_scale"] = 1000.0
-            try:
-                dit_config["allow_fp16"] = torch.std(state_dict['{}layers.{}.ffn_norm1.weight'.format(key_prefix, dit_config["n_layers"] - 2)], unbiased=False).item() < 0.42
-            except Exception:
-                pass
             if '{}cap_pad_token'.format(key_prefix) in state_dict_keys:
                 dit_config["pad_tokens_multiple"] = 32
             sig_weight = state_dict.get('{}siglip_embedder.0.weight'.format(key_prefix), None)

comfy/sd.py

@@ -20,7 +20,6 @@ import comfy.ldm.ace.vae.music_dcae_pipeline
 import comfy.ldm.hunyuan_video.vae
 import comfy.ldm.mmaudio.vae.autoencoder
 import comfy.pixel_space_convert
-import comfy.weight_adapter
 import yaml
 import math
 import os
@@ -102,105 +101,6 @@ def load_lora_for_models(model, clip, lora, strength_model, strength_clip):
     return (new_modelpatcher, new_clip)
 
 
-def load_bypass_lora_for_models(model, clip, lora, strength_model, strength_clip):
-    """
-    Load LoRA in bypass mode without modifying base model weights.
-
-    Instead of patching weights, this injects the LoRA computation into the
-    forward pass: output = base_forward(x) + lora_path(x)
-
-    Non-adapter patches (bias diff, weight diff, etc.) are applied as regular patches.
-
-    This is useful for training and when model weights are offloaded.
-    """
-    key_map = {}
-    if model is not None:
-        key_map = comfy.lora.model_lora_keys_unet(model.model, key_map)
-    if clip is not None:
-        key_map = comfy.lora.model_lora_keys_clip(clip.cond_stage_model, key_map)
-
-    logging.debug(f"[BypassLoRA] key_map has {len(key_map)} entries")
-
-    lora = comfy.lora_convert.convert_lora(lora)
-    loaded = comfy.lora.load_lora(lora, key_map)
-
-    logging.debug(f"[BypassLoRA] loaded has {len(loaded)} entries")
-
-    # Separate adapters (for bypass) from other patches (for regular patching)
-    bypass_patches = {}  # WeightAdapterBase instances -> bypass mode
-    regular_patches = {}  # diff, set, bias patches -> regular weight patching
-
-    for key, patch_data in loaded.items():
-        if isinstance(patch_data, comfy.weight_adapter.WeightAdapterBase):
-            bypass_patches[key] = patch_data
-        else:
-            regular_patches[key] = patch_data
-
-    logging.debug(f"[BypassLoRA] {len(bypass_patches)} bypass adapters, {len(regular_patches)} regular patches")
-
-    k = set()
-    k1 = set()
-
-    if model is not None:
-        new_modelpatcher = model.clone()
-
-        # Apply regular patches (bias diff, weight diff, etc.) via normal patching
-        if regular_patches:
-            patched_keys = new_modelpatcher.add_patches(regular_patches, strength_model)
-            k.update(patched_keys)
-
-        # Apply adapter patches via bypass injection
-        manager = comfy.weight_adapter.BypassInjectionManager()
-        model_sd_keys = set(new_modelpatcher.model.state_dict().keys())
-
-        for key, adapter in bypass_patches.items():
-            if key in model_sd_keys:
-                manager.add_adapter(key, adapter, strength=strength_model)
-                k.add(key)
-            else:
-                logging.warning(f"[BypassLoRA] Adapter key not in model state_dict: {key}")
-
-        injections = manager.create_injections(new_modelpatcher.model)
-
-        if manager.get_hook_count() > 0:
-            new_modelpatcher.set_injections("bypass_lora", injections)
-    else:
-        new_modelpatcher = None
-
-    if clip is not None:
-        new_clip = clip.clone()
-
-        # Apply regular patches to clip
-        if regular_patches:
-            patched_keys = new_clip.add_patches(regular_patches, strength_clip)
-            k1.update(patched_keys)
-
-        # Apply adapter patches via bypass injection
-        clip_manager = comfy.weight_adapter.BypassInjectionManager()
-        clip_sd_keys = set(new_clip.cond_stage_model.state_dict().keys())
-
-        for key, adapter in bypass_patches.items():
-            if key in clip_sd_keys:
-                clip_manager.add_adapter(key, adapter, strength=strength_clip)
-                k1.add(key)
-
-        clip_injections = clip_manager.create_injections(new_clip.cond_stage_model)
-        if clip_manager.get_hook_count() > 0:
-            new_clip.patcher.set_injections("bypass_lora", clip_injections)
-    else:
-        new_clip = None
-
-    for x in loaded:
-        if (x not in k) and (x not in k1):
-            patch_data = loaded[x]
-            patch_type = type(patch_data).__name__
-            if isinstance(patch_data, tuple):
-                patch_type = f"tuple({patch_data[0]})"
-            logging.warning(f"NOT LOADED: {x} (type={patch_type})")
-
-    return (new_modelpatcher, new_clip)
-
-
 class CLIP:
     def __init__(self, target=None, embedding_directory=None, no_init=False, tokenizer_data={}, parameters=0, state_dict=[], model_options={}):
         if no_init:

comfy/supported_models.py

@@ -1093,7 +1093,7 @@ class ZImage(Lumina2):
 
     def __init__(self, unet_config):
         super().__init__(unet_config)
-        if comfy.model_management.extended_fp16_support() and unet_config.get("allow_fp16", False):
+        if comfy.model_management.extended_fp16_support():
             self.supported_inference_dtypes = self.supported_inference_dtypes.copy()
             self.supported_inference_dtypes.insert(1, torch.float16)
 

comfy/weight_adapter/__init__.py

@@ -5,11 +5,6 @@ from .lokr import LoKrAdapter
 from .glora import GLoRAAdapter
 from .oft import OFTAdapter
 from .boft import BOFTAdapter
-from .bypass import (
-    BypassInjectionManager,
-    BypassForwardHook,
-    create_bypass_injections_from_patches,
-)
 
 
 adapters: list[type[WeightAdapterBase]] = [
@@ -36,7 +31,4 @@ __all__ = [
     "WeightAdapterTrainBase",
     "adapters",
     "adapter_maps",
-    "BypassInjectionManager",
-    "BypassForwardHook",
-    "create_bypass_injections_from_patches",
 ] + [a.__name__ for a in adapters]

comfy/weight_adapter/base.py

@@ -1,4 +1,4 @@
-from typing import Callable, Optional
+from typing import Optional
 
 import torch
 import torch.nn as nn
@@ -7,35 +7,12 @@ import comfy.model_management
 
 
 class WeightAdapterBase:
-    """
-    Base class for weight adapters (LoRA, LoHa, LoKr, OFT, etc.)
-
-    Bypass Mode:
-        All adapters follow the pattern: bypass(f)(x) = g(f(x) + h(x))
-
-        - h(x): Additive component (LoRA path). Returns delta to add to base output.
-        - g(y): Output transformation. Applied after base + h(x).
-
-        For LoRA/LoHa/LoKr: g = identity, h = adapter(x)
-        For OFT/BOFT: g = transform, h = 0
-    """
-
     name: str
     loaded_keys: set[str]
     weights: list[torch.Tensor]
 
-    # Attributes set by bypass system
-    multiplier: float = 1.0
-    shape: tuple = None  # (out_features, in_features) or (out_ch, in_ch, *kernel)
-
     @classmethod
-    def load(
-        cls,
-        x: str,
-        lora: dict[str, torch.Tensor],
-        alpha: float,
-        dora_scale: torch.Tensor,
-    ) -> Optional["WeightAdapterBase"]:
+    def load(cls, x: str, lora: dict[str, torch.Tensor], alpha: float, dora_scale: torch.Tensor) -> Optional["WeightAdapterBase"]:
         raise NotImplementedError
 
     def to_train(self) -> "WeightAdapterTrainBase":
@@ -62,202 +39,18 @@ class WeightAdapterBase:
     ):
         raise NotImplementedError
 
-    # ===== Bypass Mode Methods =====
-    #
-    # IMPORTANT: Bypass mode is designed for quantized models where original weights
-    # may not be accessible in a usable format. Therefore, h() and bypass_forward()
-    # do NOT take org_weight as a parameter. All necessary information (out_channels,
-    # in_channels, conv params, etc.) is provided via attributes set by BypassForwardHook.
-
-    def h(self, x: torch.Tensor, base_out: torch.Tensor) -> torch.Tensor:
-        """
-        Additive bypass component: h(x, base_out)
-
-        Computes the adapter's contribution to be added to base forward output.
-        For adapters that only transform output (OFT/BOFT), returns zeros.
-
-        Note:
-            This method does NOT access original model weights. Bypass mode is
-            designed for quantized models where weights may not be in a usable format.
-            All shape info comes from module attributes set by BypassForwardHook.
-
-        Args:
-            x: Input tensor
-            base_out: Output from base forward f(x), can be used for shape reference
-
-        Returns:
-            Delta tensor to add to base output. Shape matches base output.
-
-        Reference: LyCORIS LoConModule.bypass_forward_diff
-        """
-        # Default: no additive component (for OFT/BOFT)
-        # Simply return zeros matching base_out shape
-        return torch.zeros_like(base_out)
-
-    def g(self, y: torch.Tensor) -> torch.Tensor:
-        """
-        Output transformation: g(y)
-
-        Applied after base forward + h(x). For most adapters this is identity.
-        OFT/BOFT override this to apply orthogonal transformation.
-
-        Args:
-            y: Combined output (base + h(x))
-
-        Returns:
-            Transformed output
-
-        Reference: LyCORIS OFTModule applies orthogonal transform here
-        """
-        # Default: identity (for LoRA/LoHa/LoKr)
-        return y
-
-    def bypass_forward(
-        self,
-        org_forward: Callable,
-        x: torch.Tensor,
-        *args,
-        **kwargs,
-    ) -> torch.Tensor:
-        """
-        Full bypass forward: g(f(x) + h(x, f(x)))
-
-        Note:
-            This method does NOT take org_weight/org_bias parameters. Bypass mode
-            is designed for quantized models where weights may not be accessible.
-            The original forward function handles weight access internally.
-
-        Args:
-            org_forward: Original module forward function
-            x: Input tensor
-            *args, **kwargs: Additional arguments for org_forward
-
-        Returns:
-            Output with adapter applied in bypass mode
-
-        Reference: LyCORIS LoConModule.bypass_forward
-        """
-        # Base forward: f(x)
-        base_out = org_forward(x, *args, **kwargs)
-
-        # Additive component: h(x, base_out) - base_out provided for shape reference
-        h_out = self.h(x, base_out)
-
-        # Output transformation: g(base + h)
-        return self.g(base_out + h_out)
-
 
 class WeightAdapterTrainBase(nn.Module):
-    """
-    Base class for trainable weight adapters (LoRA, LoHa, LoKr, OFT, etc.)
-
-    Bypass Mode:
-        All adapters follow the pattern: bypass(f)(x) = g(f(x) + h(x))
-
-        - h(x): Additive component (LoRA path). Returns delta to add to base output.
-        - g(y): Output transformation. Applied after base + h(x).
-
-        For LoRA/LoHa/LoKr: g = identity, h = adapter(x)
-        For OFT: g = transform, h = 0
-
-    Note:
-        Unlike WeightAdapterBase, TrainBase classes have simplified weight formats
-        with fewer branches (e.g., LoKr only has w1/w2, not w1_a/w1_b decomposition).
-
-    We follow the scheme of PR #7032
-    """
-
-    # Attributes set by bypass system (BypassForwardHook)
-    # These are set before h()/g()/bypass_forward() are called
-    multiplier: float = 1.0
-    is_conv: bool = False
-    conv_dim: int = 0  # 0=linear, 1=conv1d, 2=conv2d, 3=conv3d
-    kw_dict: dict = {}  # Conv kwargs: stride, padding, dilation, groups
-    kernel_size: tuple = ()
-    in_channels: int = None
-    out_channels: int = None
-
+    # We follow the scheme of PR #7032
     def __init__(self):
         super().__init__()
 
     def __call__(self, w):
         """
-        Weight modification mode: returns modified weight.
-
-        Args:
-            w: The original weight tensor to be modified.
-
-        Returns:
-            Modified weight tensor.
+        w: The original weight tensor to be modified.
         """
         raise NotImplementedError
 
-    # ===== Bypass Mode Methods =====
-
-    def h(self, x: torch.Tensor, base_out: torch.Tensor) -> torch.Tensor:
-        """
-        Additive bypass component: h(x, base_out)
-
-        Computes the adapter's contribution to be added to base forward output.
-        For adapters that only transform output (OFT), returns zeros.
-
-        Args:
-            x: Input tensor
-            base_out: Output from base forward f(x), can be used for shape reference
-
-        Returns:
-            Delta tensor to add to base output. Shape matches base output.
-
-        Subclasses should override this method.
-        """
-        raise NotImplementedError(
-            f"{self.__class__.__name__}.h() not implemented. "
-            "Subclasses must implement h() for bypass mode."
-        )
-
-    def g(self, y: torch.Tensor) -> torch.Tensor:
-        """
-        Output transformation: g(y)
-
-        Applied after base forward + h(x). For most adapters this is identity.
-        OFT overrides this to apply orthogonal transformation.
-
-        Args:
-            y: Combined output (base + h(x))
-
-        Returns:
-            Transformed output
-        """
-        # Default: identity (for LoRA/LoHa/LoKr)
-        return y
-
-    def bypass_forward(
-        self,
-        org_forward: Callable,
-        x: torch.Tensor,
-        *args,
-        **kwargs,
-    ) -> torch.Tensor:
-        """
-        Full bypass forward: g(f(x) + h(x, f(x)))
-
-        Args:
-            org_forward: Original module forward function
-            x: Input tensor
-            *args, **kwargs: Additional arguments for org_forward
-
-        Returns:
-            Output with adapter applied in bypass mode
-        """
-        # Base forward: f(x)
-        base_out = org_forward(x, *args, **kwargs)
-
-        # Additive component: h(x, base_out) - base_out provided for shape reference
-        h_out = self.h(x, base_out)
-
-        # Output transformation: g(base + h)
-        return self.g(base_out + h_out)
-
     def passive_memory_usage(self):
         raise NotImplementedError("passive_memory_usage is not implemented")
 
@@ -266,12 +59,8 @@ class WeightAdapterTrainBase(nn.Module):
         return self.passive_memory_usage()
 
 
-def weight_decompose(
-    dora_scale, weight, lora_diff, alpha, strength, intermediate_dtype, function
-):
-    dora_scale = comfy.model_management.cast_to_device(
-        dora_scale, weight.device, intermediate_dtype
-    )
+def weight_decompose(dora_scale, weight, lora_diff, alpha, strength, intermediate_dtype, function):
+    dora_scale = comfy.model_management.cast_to_device(dora_scale, weight.device, intermediate_dtype)
     lora_diff *= alpha
     weight_calc = weight + function(lora_diff).type(weight.dtype)
 
@@ -317,14 +106,10 @@ def pad_tensor_to_shape(tensor: torch.Tensor, new_shape: list[int]) -> torch.Ten
         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"
-        )
+        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"
-        )
+        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)

comfy/weight_adapter/boft.py

@@ -62,13 +62,9 @@ class BOFTAdapter(WeightAdapterBase):
         alpha = v[2]
         dora_scale = v[3]
 
-        blocks = comfy.model_management.cast_to_device(
-            blocks, weight.device, intermediate_dtype
-        )
+        blocks = comfy.model_management.cast_to_device(blocks, weight.device, intermediate_dtype)
         if rescale is not None:
-            rescale = comfy.model_management.cast_to_device(
-                rescale, weight.device, intermediate_dtype
-            )
+            rescale = comfy.model_management.cast_to_device(rescale, weight.device, intermediate_dtype)
 
         boft_m, block_num, boft_b, *_ = blocks.shape
 
@@ -78,7 +74,7 @@ class BOFTAdapter(WeightAdapterBase):
             # for Q = -Q^T
             q = blocks - blocks.transpose(-1, -2)
             normed_q = q
-            if alpha > 0:  # alpha in boft/bboft is for constraint
+            if alpha > 0: # alpha in boft/bboft is for constraint
                 q_norm = torch.norm(q) + 1e-8
                 if q_norm > alpha:
                     normed_q = q * alpha / q_norm
@@ -87,13 +83,13 @@ class BOFTAdapter(WeightAdapterBase):
             r = r.to(weight)
             inp = org = weight
 
-            r_b = boft_b // 2
+            r_b = boft_b//2
             for i in range(boft_m):
                 bi = r[i]
                 g = 2
                 k = 2**i * r_b
                 if strength != 1:
-                    bi = bi * strength + (1 - strength) * I
+                    bi = bi * strength + (1-strength) * I
                 inp = (
                     inp.unflatten(0, (-1, g, k))
                     .transpose(1, 2)
@@ -102,117 +98,18 @@ class BOFTAdapter(WeightAdapterBase):
                 )
                 inp = torch.einsum("b i j, b j ...-> b i ...", bi, inp)
                 inp = (
-                    inp.flatten(0, 1)
-                    .unflatten(0, (-1, k, g))
-                    .transpose(1, 2)
-                    .flatten(0, 2)
+                    inp.flatten(0, 1).unflatten(0, (-1, k, g)).transpose(1, 2).flatten(0, 2)
                 )
 
             if rescale is not None:
                 inp = inp * rescale
 
             lora_diff = inp - org
-            lora_diff = comfy.model_management.cast_to_device(
-                lora_diff, weight.device, intermediate_dtype
-            )
+            lora_diff = comfy.model_management.cast_to_device(lora_diff, weight.device, intermediate_dtype)
             if dora_scale is not None:
-                weight = weight_decompose(
-                    dora_scale,
-                    weight,
-                    lora_diff,
-                    alpha,
-                    strength,
-                    intermediate_dtype,
-                    function,
-                )
+                weight = weight_decompose(dora_scale, weight, lora_diff, alpha, strength, intermediate_dtype, function)
             else:
                 weight += function((strength * lora_diff).type(weight.dtype))
         except Exception as e:
             logging.error("ERROR {} {} {}".format(self.name, key, e))
         return weight
-
-    def _get_orthogonal_matrices(self, device, dtype):
-        """Compute the orthogonal rotation matrices R from BOFT blocks."""
-        v = self.weights
-        blocks = v[0].to(device=device, dtype=dtype)
-        alpha = v[2]
-        if alpha is None:
-            alpha = 0
-
-        boft_m, block_num, boft_b, _ = blocks.shape
-        I = torch.eye(boft_b, device=device, dtype=dtype)
-
-        # Q = blocks - blocks^T (skew-symmetric)
-        q = blocks - blocks.transpose(-1, -2)
-        normed_q = q
-
-        # Apply constraint if alpha > 0
-        if alpha > 0:
-            q_norm = torch.norm(q) + 1e-8
-            if q_norm > alpha:
-                normed_q = q * alpha / q_norm
-
-        # Cayley transform: R = (I + Q)(I - Q)^-1
-        r = (I + normed_q) @ (I - normed_q).float().inverse()
-        return r, boft_m, boft_b
-
-    def g(self, y: torch.Tensor) -> torch.Tensor:
-        """
-        Output transformation for BOFT: applies butterfly orthogonal transform.
-
-        BOFT uses multiple stages of butterfly-structured orthogonal transforms.
-
-        Reference: LyCORIS ButterflyOFTModule._bypass_forward
-        """
-        v = self.weights
-        rescale = v[1]
-
-        r, boft_m, boft_b = self._get_orthogonal_matrices(y.device, y.dtype)
-        r_b = boft_b // 2
-
-        # Apply multiplier
-        multiplier = getattr(self, "multiplier", 1.0)
-        I = torch.eye(boft_b, device=y.device, dtype=y.dtype)
-
-        # Use module info from bypass injection to determine conv vs linear
-        is_conv = getattr(self, "is_conv", y.dim() > 2)
-
-        if is_conv:
-            # Conv output: (N, C, H, W, ...) -> transpose to (N, H, W, ..., C)
-            y = y.transpose(1, -1)
-
-        # Apply butterfly transform stages
-        inp = y
-        for i in range(boft_m):
-            bi = r[i]  # (block_num, boft_b, boft_b)
-            g = 2
-            k = 2**i * r_b
-
-            # Interpolate with identity based on multiplier
-            if multiplier != 1:
-                bi = bi * multiplier + (1 - multiplier) * I
-
-            # Reshape for butterfly: unflatten last dim, transpose, flatten, unflatten
-            inp = (
-                inp.unflatten(-1, (-1, g, k))
-                .transpose(-2, -1)
-                .flatten(-3)
-                .unflatten(-1, (-1, boft_b))
-            )
-            # Apply block-diagonal orthogonal transform
-            inp = torch.einsum("b i j, ... b j -> ... b i", bi, inp)
-            # Reshape back
-            inp = (
-                inp.flatten(-2).unflatten(-1, (-1, k, g)).transpose(-2, -1).flatten(-3)
-            )
-
-        # Apply rescale if present
-        if rescale is not None:
-            rescale = rescale.to(device=y.device, dtype=y.dtype)
-            inp = inp * rescale.transpose(0, -1)
-
-        if is_conv:
-            # Transpose back: (N, H, W, ..., C) -> (N, C, H, W, ...)
-            inp = inp.transpose(1, -1)
-
-        return inp

comfy/weight_adapter/bypass.py

@@ -1,437 +0,0 @@
-"""
-Bypass mode implementation for weight adapters (LoRA, LoKr, LoHa, etc.)
-
-Bypass mode applies adapters during forward pass without modifying base weights:
-    bypass(f)(x) = g(f(x) + h(x))
-
-Where:
-    - f(x): Original layer forward
-    - h(x): Additive component from adapter (LoRA path)
-    - g(y): Output transformation (identity for most adapters)
-
-This is useful for:
-    - Training with gradient checkpointing
-    - Avoiding weight modifications when weights are offloaded
-    - Supporting multiple adapters with different strengths dynamically
-"""
-
-import logging
-from typing import Optional, Union
-
-import torch
-import torch.nn as nn
-
-from .base import WeightAdapterBase, WeightAdapterTrainBase
-from comfy.patcher_extension import PatcherInjection
-
-# Type alias for adapters that support bypass mode
-BypassAdapter = Union[WeightAdapterBase, WeightAdapterTrainBase]
-
-
-def get_module_type_info(module: nn.Module) -> dict:
-    """
-    Determine module type and extract conv parameters from module class.
-
-    This is more reliable than checking weight.ndim, especially for quantized layers
-    where weight shape might be different.
-
-    Returns:
-        dict with keys: is_conv, conv_dim, stride, padding, dilation, groups
-    """
-    info = {
-        "is_conv": False,
-        "conv_dim": 0,
-        "stride": (1,),
-        "padding": (0,),
-        "dilation": (1,),
-        "groups": 1,
-        "kernel_size": (1,),
-        "in_channels": None,
-        "out_channels": None,
-    }
-
-    # Determine conv type
-    if isinstance(module, nn.Conv1d):
-        info["is_conv"] = True
-        info["conv_dim"] = 1
-    elif isinstance(module, nn.Conv2d):
-        info["is_conv"] = True
-        info["conv_dim"] = 2
-    elif isinstance(module, nn.Conv3d):
-        info["is_conv"] = True
-        info["conv_dim"] = 3
-    elif isinstance(module, nn.Linear):
-        info["is_conv"] = False
-        info["conv_dim"] = 0
-    else:
-        # Try to infer from class name for custom/quantized layers
-        class_name = type(module).__name__.lower()
-        if "conv3d" in class_name:
-            info["is_conv"] = True
-            info["conv_dim"] = 3
-        elif "conv2d" in class_name:
-            info["is_conv"] = True
-            info["conv_dim"] = 2
-        elif "conv1d" in class_name:
-            info["is_conv"] = True
-            info["conv_dim"] = 1
-        elif "conv" in class_name:
-            info["is_conv"] = True
-            info["conv_dim"] = 2
-
-    # Extract conv parameters if it's a conv layer
-    if info["is_conv"]:
-        # Try to get stride, padding, dilation, groups, kernel_size from module
-        info["stride"] = getattr(module, "stride", (1,) * info["conv_dim"])
-        info["padding"] = getattr(module, "padding", (0,) * info["conv_dim"])
-        info["dilation"] = getattr(module, "dilation", (1,) * info["conv_dim"])
-        info["groups"] = getattr(module, "groups", 1)
-        info["kernel_size"] = getattr(module, "kernel_size", (1,) * info["conv_dim"])
-        info["in_channels"] = getattr(module, "in_channels", None)
-        info["out_channels"] = getattr(module, "out_channels", None)
-
-        # Ensure they're tuples
-        if isinstance(info["stride"], int):
-            info["stride"] = (info["stride"],) * info["conv_dim"]
-        if isinstance(info["padding"], int):
-            info["padding"] = (info["padding"],) * info["conv_dim"]
-        if isinstance(info["dilation"], int):
-            info["dilation"] = (info["dilation"],) * info["conv_dim"]
-        if isinstance(info["kernel_size"], int):
-            info["kernel_size"] = (info["kernel_size"],) * info["conv_dim"]
-
-    return info
-
-
-class BypassForwardHook:
-    """
-    Hook that wraps a layer's forward to apply adapter in bypass mode.
-
-    Stores the original forward and replaces it with bypass version.
-
-    Supports both:
-        - WeightAdapterBase: Inference adapters (uses self.weights tuple)
-        - WeightAdapterTrainBase: Training adapters (nn.Module with parameters)
-    """
-
-    def __init__(
-        self,
-        module: nn.Module,
-        adapter: BypassAdapter,
-        multiplier: float = 1.0,
-    ):
-        self.module = module
-        self.adapter = adapter
-        self.multiplier = multiplier
-        self.original_forward = None
-
-        # Determine layer type and conv params from module class (works for quantized layers)
-        module_info = get_module_type_info(module)
-
-        # Set multiplier and layer type info on adapter for use in h()
-        adapter.multiplier = multiplier
-        adapter.is_conv = module_info["is_conv"]
-        adapter.conv_dim = module_info["conv_dim"]
-        adapter.kernel_size = module_info["kernel_size"]
-        adapter.in_channels = module_info["in_channels"]
-        adapter.out_channels = module_info["out_channels"]
-        # Store kw_dict for conv operations (like LyCORIS extra_args)
-        if module_info["is_conv"]:
-            adapter.kw_dict = {
-                "stride": module_info["stride"],
-                "padding": module_info["padding"],
-                "dilation": module_info["dilation"],
-                "groups": module_info["groups"],
-            }
-        else:
-            adapter.kw_dict = {}
-
-    def _bypass_forward(self, x: torch.Tensor, *args, **kwargs) -> torch.Tensor:
-        """Bypass forward: uses adapter's bypass_forward or default g(f(x) + h(x))
-
-        Note:
-            Bypass mode does NOT access original model weights (org_weight).
-            This is intentional - bypass mode is designed for quantized models
-            where weights may not be in a usable format. All necessary shape
-            information is provided via adapter attributes set during inject().
-        """
-        # Check if adapter has custom bypass_forward (e.g., GLoRA)
-        adapter_bypass = getattr(self.adapter, "bypass_forward", None)
-        if adapter_bypass is not None:
-            # Check if it's overridden (not the base class default)
-            # Need to check both base classes since adapter could be either type
-            adapter_type = type(self.adapter)
-            is_default_bypass = (
-                adapter_type.bypass_forward is WeightAdapterBase.bypass_forward
-                or adapter_type.bypass_forward is WeightAdapterTrainBase.bypass_forward
-            )
-            if not is_default_bypass:
-                return adapter_bypass(self.original_forward, x, *args, **kwargs)
-
-        # Default bypass: g(f(x) + h(x, f(x)))
-        base_out = self.original_forward(x, *args, **kwargs)
-        h_out = self.adapter.h(x, base_out)
-        return self.adapter.g(base_out + h_out)
-
-    def inject(self):
-        """Replace module forward with bypass version."""
-        if self.original_forward is not None:
-            logging.debug(
-                f"[BypassHook] Already injected for {type(self.module).__name__}"
-            )
-            return  # Already injected
-
-        # Move adapter weights to module's device to avoid CPU-GPU transfer on every forward
-        device = None
-        dtype = None
-        if hasattr(self.module, "weight") and self.module.weight is not None:
-            device = self.module.weight.device
-            dtype = self.module.weight.dtype
-        elif hasattr(self.module, "W_q"):  # Quantized layers might use different attr
-            device = self.module.W_q.device
-            dtype = self.module.W_q.dtype
-
-        if device is not None:
-            self._move_adapter_weights_to_device(device, dtype)
-
-        self.original_forward = self.module.forward
-        self.module.forward = self._bypass_forward
-        logging.debug(
-            f"[BypassHook] Injected bypass forward for {type(self.module).__name__} (adapter={type(self.adapter).__name__})"
-        )
-
-    def _move_adapter_weights_to_device(self, device, dtype=None):
-        """Move adapter weights to specified device to avoid per-forward transfers.
-
-        Handles both:
-            - WeightAdapterBase: has self.weights tuple of tensors
-            - WeightAdapterTrainBase: nn.Module with parameters, uses .to() method
-        """
-        adapter = self.adapter
-
-        # Check if adapter is an nn.Module (WeightAdapterTrainBase)
-        if isinstance(adapter, nn.Module):
-            # In training mode we don't touch dtype as trainer will handle it
-            adapter.to(device=device)
-            logging.debug(
-                f"[BypassHook] Moved training adapter (nn.Module) to {device}"
-            )
-            return
-
-        # WeightAdapterBase: handle self.weights tuple
-        if not hasattr(adapter, "weights") or adapter.weights is None:
-            return
-
-        weights = adapter.weights
-        if isinstance(weights, (list, tuple)):
-            new_weights = []
-            for w in weights:
-                if isinstance(w, torch.Tensor):
-                    if dtype is not None:
-                        new_weights.append(w.to(device=device, dtype=dtype))
-                    else:
-                        new_weights.append(w.to(device=device))
-                else:
-                    new_weights.append(w)
-            adapter.weights = (
-                tuple(new_weights) if isinstance(weights, tuple) else new_weights
-            )
-        elif isinstance(weights, torch.Tensor):
-            if dtype is not None:
-                adapter.weights = weights.to(device=device, dtype=dtype)
-            else:
-                adapter.weights = weights.to(device=device)
-
-        logging.debug(f"[BypassHook] Moved adapter weights to {device}")
-
-    def eject(self):
-        """Restore original module forward."""
-        if self.original_forward is None:
-            logging.debug(f"[BypassHook] Not injected for {type(self.module).__name__}")
-            return  # Not injected
-
-        self.module.forward = self.original_forward
-        self.original_forward = None
-        logging.debug(
-            f"[BypassHook] Ejected bypass forward for {type(self.module).__name__}"
-        )
-
-
-class BypassInjectionManager:
-    """
-    Manages bypass mode injection for a collection of adapters.
-
-    Creates PatcherInjection objects that can be used with ModelPatcher.
-
-    Supports both inference adapters (WeightAdapterBase) and training adapters
-    (WeightAdapterTrainBase).
-
-    Usage:
-        manager = BypassInjectionManager()
-        manager.add_adapter("model.layers.0.self_attn.q_proj", lora_adapter, strength=0.8)
-        manager.add_adapter("model.layers.0.self_attn.k_proj", lora_adapter, strength=0.8)
-
-        injections = manager.create_injections(model)
-        model_patcher.set_injections("bypass_lora", injections)
-    """
-
-    def __init__(self):
-        self.adapters: dict[str, tuple[BypassAdapter, float]] = {}
-        self.hooks: list[BypassForwardHook] = []
-
-    def add_adapter(
-        self,
-        key: str,
-        adapter: BypassAdapter,
-        strength: float = 1.0,
-    ):
-        """
-        Add an adapter for a specific weight key.
-
-        Args:
-            key: Weight key (e.g., "model.layers.0.self_attn.q_proj.weight")
-            adapter: The weight adapter (LoRAAdapter, LoKrAdapter, etc.)
-            strength: Multiplier for adapter effect
-        """
-        # Remove .weight suffix if present for module lookup
-        module_key = key
-        if module_key.endswith(".weight"):
-            module_key = module_key[:-7]
-            logging.debug(
-                f"[BypassManager] Stripped .weight suffix: {key} -> {module_key}"
-            )
-
-        self.adapters[module_key] = (adapter, strength)
-        logging.debug(
-            f"[BypassManager] Added adapter: {module_key} (type={type(adapter).__name__}, strength={strength})"
-        )
-
-    def clear_adapters(self):
-        """Remove all adapters."""
-        self.adapters.clear()
-
-    def _get_module_by_key(self, model: nn.Module, key: str) -> Optional[nn.Module]:
-        """Get a submodule by dot-separated key."""
-        parts = key.split(".")
-        module = model
-        try:
-            for i, part in enumerate(parts):
-                if part.isdigit():
-                    module = module[int(part)]
-                else:
-                    module = getattr(module, part)
-            logging.debug(
-                f"[BypassManager] Found module for key {key}: {type(module).__name__}"
-            )
-            return module
-        except (AttributeError, IndexError, KeyError) as e:
-            logging.error(f"[BypassManager] Failed to find module for key {key}: {e}")
-            logging.error(
-                f"[BypassManager] Failed at part index {i}, part={part}, current module type={type(module).__name__}"
-            )
-            return None
-
-    def create_injections(self, model: nn.Module) -> list[PatcherInjection]:
-        """
-        Create PatcherInjection objects for all registered adapters.
-
-        Args:
-            model: The model to inject into (e.g., model_patcher.model)
-
-        Returns:
-            List of PatcherInjection objects to use with model_patcher.set_injections()
-        """
-        self.hooks.clear()
-
-        logging.debug(
-            f"[BypassManager] create_injections called with {len(self.adapters)} adapters"
-        )
-        logging.debug(f"[BypassManager] Model type: {type(model).__name__}")
-
-        for key, (adapter, strength) in self.adapters.items():
-            logging.debug(f"[BypassManager] Looking for module: {key}")
-            module = self._get_module_by_key(model, key)
-
-            if module is None:
-                logging.warning(f"[BypassManager] Module not found for key {key}")
-                continue
-
-            if not hasattr(module, "weight"):
-                logging.warning(
-                    f"[BypassManager] Module {key} has no weight attribute (type={type(module).__name__})"
-                )
-                continue
-
-            logging.debug(
-                f"[BypassManager] Creating hook for {key} (module type={type(module).__name__}, weight shape={module.weight.shape})"
-            )
-            hook = BypassForwardHook(module, adapter, multiplier=strength)
-            self.hooks.append(hook)
-
-        logging.debug(f"[BypassManager] Created {len(self.hooks)} hooks")
-
-        # Create single injection that manages all hooks
-        def inject_all(model_patcher):
-            logging.debug(
-                f"[BypassManager] inject_all called, injecting {len(self.hooks)} hooks"
-            )
-            for hook in self.hooks:
-                hook.inject()
-                logging.debug(
-                    f"[BypassManager] Injected hook for {type(hook.module).__name__}"
-                )
-
-        def eject_all(model_patcher):
-            logging.debug(
-                f"[BypassManager] eject_all called, ejecting {len(self.hooks)} hooks"
-            )
-            for hook in self.hooks:
-                hook.eject()
-
-        return [PatcherInjection(inject=inject_all, eject=eject_all)]
-
-    def get_hook_count(self) -> int:
-        """Return number of hooks that will be/are injected."""
-        return len(self.hooks)
-
-
-def create_bypass_injections_from_patches(
-    model: nn.Module,
-    patches: dict,
-    strength: float = 1.0,
-) -> list[PatcherInjection]:
-    """
-    Convenience function to create bypass injections from a patches dict.
-
-    This is useful when you have patches in the format used by model_patcher.add_patches()
-    and want to apply them in bypass mode instead.
-
-    Args:
-        model: The model to inject into
-        patches: Dict mapping weight keys to adapter data
-        strength: Global strength multiplier
-
-    Returns:
-        List of PatcherInjection objects
-    """
-    manager = BypassInjectionManager()
-
-    for key, patch_list in patches.items():
-        if not patch_list:
-            continue
-
-        # patches format: list of (strength_patch, patch_data, strength_model, offset, function)
-        for patch in patch_list:
-            patch_strength, patch_data, strength_model, offset, function = patch
-
-            # patch_data should be a WeightAdapterBase/WeightAdapterTrainBase or tuple
-            if isinstance(patch_data, (WeightAdapterBase, WeightAdapterTrainBase)):
-                adapter = patch_data
-            else:
-                # Skip non-adapter patches
-                continue
-
-            combined_strength = strength * patch_strength
-            manager.add_adapter(key, adapter, strength=combined_strength)
-
-    return manager.create_injections(model)

comfy/weight_adapter/glora.py

@@ -1,8 +1,7 @@
 import logging
-from typing import Callable, Optional
+from typing import Optional
 
 import torch
-import torch.nn.functional as F
 import comfy.model_management
 from .base import WeightAdapterBase, weight_decompose
 
@@ -30,14 +29,7 @@ class GLoRAAdapter(WeightAdapterBase):
         b1_name = "{}.b1.weight".format(x)
         b2_name = "{}.b2.weight".format(x)
         if a1_name in lora:
-            weights = (
-                lora[a1_name],
-                lora[a2_name],
-                lora[b1_name],
-                lora[b2_name],
-                alpha,
-                dora_scale,
-            )
+            weights = (lora[a1_name], lora[a2_name], lora[b1_name], lora[b2_name], alpha, dora_scale)
             loaded_keys.add(a1_name)
             loaded_keys.add(a2_name)
             loaded_keys.add(b1_name)
@@ -66,28 +58,16 @@ class GLoRAAdapter(WeightAdapterBase):
             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]
-            ):
+            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
-        )
+        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
@@ -96,195 +76,18 @@ class GLoRAAdapter(WeightAdapterBase):
 
         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
+                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)
+                    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(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 = weight_decompose(
-                    dora_scale,
-                    weight,
-                    lora_diff,
-                    alpha,
-                    strength,
-                    intermediate_dtype,
-                    function,
-                )
+                weight = weight_decompose(dora_scale, weight, lora_diff, alpha, strength, intermediate_dtype, function)
             else:
                 weight += function(((strength * alpha) * lora_diff).type(weight.dtype))
         except Exception as e:
             logging.error("ERROR {} {} {}".format(self.name, key, e))
         return weight
-
-    def _compute_paths(self, x: torch.Tensor):
-        """
-        Compute A path and B path outputs for GLoRA bypass.
-
-        GLoRA: f(x) = Wx + WAx + Bx
-        - A path: a1(a2(x)) - modifies input to base forward
-        - B path: b1(b2(x)) - additive component
-
-        Note:
-            Does not access original model weights - bypass mode is designed
-            for quantized models where weights may not be accessible.
-
-        Returns: (a_out, b_out)
-        """
-        v = self.weights
-        # v = (a1, a2, b1, b2, alpha, dora_scale)
-        a1 = v[0]
-        a2 = v[1]
-        b1 = v[2]
-        b2 = v[3]
-        alpha = v[4]
-
-        dtype = x.dtype
-
-        # Cast dtype (weights should already be on correct device from inject())
-        a1 = a1.to(dtype=dtype)
-        a2 = a2.to(dtype=dtype)
-        b1 = b1.to(dtype=dtype)
-        b2 = b2.to(dtype=dtype)
-
-        # Determine rank and scale
-        # Check for old vs new glora format
-        old_glora = False
-        if b2.shape[1] == b1.shape[0] == a1.shape[0] == a2.shape[1]:
-            rank = a1.shape[0]
-            old_glora = True
-
-        if b2.shape[0] == b1.shape[1] == a1.shape[1] == a2.shape[0]:
-            if old_glora and a2.shape[0] == x.shape[-1] and x.shape[-1] == x.shape[-1]:
-                pass
-            else:
-                old_glora = False
-                rank = a2.shape[0]
-
-        if alpha is not None:
-            scale = alpha / rank
-        else:
-            scale = 1.0
-
-        # Apply multiplier
-        multiplier = getattr(self, "multiplier", 1.0)
-        scale = scale * multiplier
-
-        # Use module info from bypass injection, not input tensor shape
-        is_conv = getattr(self, "is_conv", False)
-        conv_dim = getattr(self, "conv_dim", 0)
-        kw_dict = getattr(self, "kw_dict", {})
-
-        if is_conv:
-            # Conv case - conv_dim is 1/2/3 for conv1d/2d/3d
-            conv_fn = (F.conv1d, F.conv2d, F.conv3d)[conv_dim - 1]
-
-            # Get module's stride/padding for spatial dimension handling
-            module_stride = kw_dict.get("stride", (1,) * conv_dim)
-            module_padding = kw_dict.get("padding", (0,) * conv_dim)
-            kernel_size = getattr(self, "kernel_size", (1,) * conv_dim)
-            in_channels = getattr(self, "in_channels", None)
-
-            # Ensure weights are in conv shape
-            # a1, a2, b1 are always 1x1 kernels
-            if a1.ndim == 2:
-                a1 = a1.view(*a1.shape, *([1] * conv_dim))
-            if a2.ndim == 2:
-                a2 = a2.view(*a2.shape, *([1] * conv_dim))
-            if b1.ndim == 2:
-                b1 = b1.view(*b1.shape, *([1] * conv_dim))
-            # b2 has actual kernel_size (like LoRA down)
-            if b2.ndim == 2:
-                if in_channels is not None:
-                    b2 = b2.view(b2.shape[0], in_channels, *kernel_size)
-                else:
-                    b2 = b2.view(*b2.shape, *([1] * conv_dim))
-
-            # A path: a2(x) -> a1(...) - 1x1 convs, no stride/padding needed, a_out is added to x
-            a2_out = conv_fn(x, a2)
-            a_out = conv_fn(a2_out, a1) * scale
-
-            # B path: b2(x) with kernel/stride/padding -> b1(...) 1x1
-            b2_out = conv_fn(x, b2, stride=module_stride, padding=module_padding)
-            b_out = conv_fn(b2_out, b1) * scale
-        else:
-            # Linear case
-            if old_glora:
-                # Old format: a1 @ a2 @ x, b2 @ b1
-                a_out = F.linear(F.linear(x, a2), a1) * scale
-                b_out = F.linear(F.linear(x, b1), b2) * scale
-            else:
-                # New format: x @ a1 @ a2, b1 @ b2
-                a_out = F.linear(F.linear(x, a1), a2) * scale
-                b_out = F.linear(F.linear(x, b2), b1) * scale
-
-        return a_out, b_out
-
-    def bypass_forward(
-        self,
-        org_forward: Callable,
-        x: torch.Tensor,
-        *args,
-        **kwargs,
-    ) -> torch.Tensor:
-        """
-        GLoRA bypass forward: f(x + a(x)) + b(x)
-
-        Unlike standard adapters, GLoRA modifies the input to the base forward
-        AND adds the B path output.
-
-        Note:
-            Does not access original model weights - bypass mode is designed
-            for quantized models where weights may not be accessible.
-
-        Reference: LyCORIS GLoRAModule._bypass_forward
-        """
-        a_out, b_out = self._compute_paths(x)
-
-        # Call base forward with modified input
-        base_out = org_forward(x + a_out, *args, **kwargs)
-
-        # Add B path
-        return base_out + b_out
-
-    def h(self, x: torch.Tensor, base_out: torch.Tensor) -> torch.Tensor:
-        """
-        For GLoRA, h() returns the B path output.
-
-        Note:
-            GLoRA's full bypass requires overriding bypass_forward() since
-            it also modifies the input to org_forward. This h() is provided for
-            compatibility but bypass_forward() should be used for correct behavior.
-
-            Does not access original model weights - bypass mode is designed
-            for quantized models where weights may not be accessible.
-
-        Args:
-            x: Input tensor
-            base_out: Output from base forward (unused, for API consistency)
-        """
-        _, b_out = self._compute_paths(x)
-        return b_out

comfy/weight_adapter/loha.py

@@ -1,22 +1,11 @@
 import logging
-from functools import cache
 from typing import Optional
 
 import torch
-import torch.nn.functional as F
 import comfy.model_management
 from .base import WeightAdapterBase, WeightAdapterTrainBase, weight_decompose
 
 
-@cache
-def _warn_loha_bypass_inefficient():
-    """One-time warning about LoHa bypass inefficiency."""
-    logging.warning(
-        "LoHa bypass mode is inefficient: full weight diff is computed each forward pass. "
-        "Consider using LoRA or LoKr for training with bypass mode."
-    )
-
-
 class HadaWeight(torch.autograd.Function):
     @staticmethod
     def forward(ctx, w1u, w1d, w2u, w2d, scale=torch.tensor(1)):
@@ -116,19 +105,9 @@ class LohaDiff(WeightAdapterTrainBase):
 
         scale = self.alpha / self.rank
         if self.use_tucker:
-            diff_weight = HadaWeightTucker.apply(
-                self.hada_t1,
-                self.hada_w1_a,
-                self.hada_w1_b,
-                self.hada_t2,
-                self.hada_w2_a,
-                self.hada_w2_b,
-                scale,
-            )
+            diff_weight = HadaWeightTucker.apply(self.hada_t1, self.hada_w1_a, self.hada_w1_b, self.hada_t2, self.hada_w2_a, self.hada_w2_b, scale)
         else:
-            diff_weight = HadaWeight.apply(
-                self.hada_w1_a, self.hada_w1_b, self.hada_w2_a, self.hada_w2_b, scale
-            )
+            diff_weight = HadaWeight.apply(self.hada_w1_a, self.hada_w1_b, self.hada_w2_a, self.hada_w2_b, scale)
 
         # Add the scaled difference to the original weight
         weight = w.to(diff_weight) + diff_weight.reshape(w.shape)
@@ -159,7 +138,9 @@ class LoHaAdapter(WeightAdapterBase):
         mat4 = torch.empty(rank, in_dim, device=weight.device, dtype=torch.float32)
         torch.nn.init.normal_(mat3, 0.1)
         torch.nn.init.normal_(mat4, 0.01)
-        return LohaDiff((mat1, mat2, alpha, mat3, mat4, None, None, None))
+        return LohaDiff(
+            (mat1, mat2, alpha, mat3, mat4, None, None, None)
+        )
 
     def to_train(self):
         return LohaDiff(self.weights)
@@ -191,16 +172,7 @@ class LoHaAdapter(WeightAdapterBase):
                 loaded_keys.add(hada_t1_name)
                 loaded_keys.add(hada_t2_name)
 
-            weights = (
-                lora[hada_w1_a_name],
-                lora[hada_w1_b_name],
-                alpha,
-                lora[hada_w2_a_name],
-                lora[hada_w2_b_name],
-                hada_t1,
-                hada_t2,
-                dora_scale,
-            )
+            weights = (lora[hada_w1_a_name], lora[hada_w1_b_name], alpha, lora[hada_w2_a_name], lora[hada_w2_b_name], hada_t1, hada_t2, dora_scale)
             loaded_keys.add(hada_w1_a_name)
             loaded_keys.add(hada_w1_b_name)
             loaded_keys.add(hada_w2_a_name)
@@ -231,148 +203,30 @@ class LoHaAdapter(WeightAdapterBase):
         w2a = v[3]
         w2b = v[4]
         dora_scale = v[7]
-        if v[5] is not None:  # cp decomposition
+        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
-                ),
-            )
+            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
-                ),
-            )
+            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
-                ),
-            )
+            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 = weight_decompose(
-                    dora_scale,
-                    weight,
-                    lora_diff,
-                    alpha,
-                    strength,
-                    intermediate_dtype,
-                    function,
-                )
+                weight = weight_decompose(dora_scale, weight, lora_diff, alpha, strength, intermediate_dtype, function)
             else:
                 weight += function(((strength * alpha) * lora_diff).type(weight.dtype))
         except Exception as e:
             logging.error("ERROR {} {} {}".format(self.name, key, e))
         return weight
-
-    def h(self, x: torch.Tensor, base_out: torch.Tensor) -> torch.Tensor:
-        """
-        Additive bypass component for LoHa: h(x) = diff_weight @ x
-
-        WARNING: Inefficient - computes full Hadamard product each forward.
-
-        Note:
-            Does not access original model weights - bypass mode is designed
-            for quantized models where weights may not be accessible.
-
-        Args:
-            x: Input tensor
-            base_out: Output from base forward (unused, for API consistency)
-
-        Reference: LyCORIS functional/loha.py bypass_forward_diff
-        """
-        _warn_loha_bypass_inefficient()
-
-        # FUNC_LIST: [None, None, F.linear, F.conv1d, F.conv2d, F.conv3d]
-        FUNC_LIST = [None, None, F.linear, F.conv1d, F.conv2d, F.conv3d]
-
-        v = self.weights
-        # v[0]=w1a, v[1]=w1b, v[2]=alpha, v[3]=w2a, v[4]=w2b, v[5]=t1, v[6]=t2, v[7]=dora
-        w1a = v[0]
-        w1b = v[1]
-        alpha = v[2]
-        w2a = v[3]
-        w2b = v[4]
-        t1 = v[5]
-        t2 = v[6]
-
-        # Compute scale
-        rank = w1b.shape[0]
-        scale = (alpha / rank if alpha is not None else 1.0) * getattr(
-            self, "multiplier", 1.0
-        )
-
-        # Cast dtype
-        w1a = w1a.to(dtype=x.dtype)
-        w1b = w1b.to(dtype=x.dtype)
-        w2a = w2a.to(dtype=x.dtype)
-        w2b = w2b.to(dtype=x.dtype)
-
-        # Use module info from bypass injection, not weight dimension
-        is_conv = getattr(self, "is_conv", False)
-        conv_dim = getattr(self, "conv_dim", 0)
-        kw_dict = getattr(self, "kw_dict", {})
-
-        # Compute diff weight using Hadamard product
-        if t1 is not None and t2 is not None:
-            t1 = t1.to(dtype=x.dtype)
-            t2 = t2.to(dtype=x.dtype)
-            m1 = torch.einsum("i j k l, j r, i p -> p r k l", t1, w1b, w1a)
-            m2 = torch.einsum("i j k l, j r, i p -> p r k l", t2, w2b, w2a)
-            diff_weight = (m1 * m2) * scale
-        else:
-            m1 = w1a @ w1b
-            m2 = w2a @ w2b
-            diff_weight = (m1 * m2) * scale
-
-        if is_conv:
-            op = FUNC_LIST[conv_dim + 2]
-            kernel_size = getattr(self, "kernel_size", (1,) * conv_dim)
-            in_channels = getattr(self, "in_channels", None)
-
-            # Reshape 2D diff_weight to conv format using kernel_size
-            # diff_weight: [out_channels, in_channels * prod(kernel_size)] -> [out_channels, in_channels, *kernel_size]
-            if diff_weight.dim() == 2:
-                if in_channels is not None:
-                    diff_weight = diff_weight.view(
-                        diff_weight.shape[0], in_channels, *kernel_size
-                    )
-                else:
-                    diff_weight = diff_weight.view(
-                        *diff_weight.shape, *([1] * conv_dim)
-                    )
-        else:
-            op = F.linear
-            kw_dict = {}
-
-        return op(x, diff_weight, **kw_dict)

comfy/weight_adapter/lokr.py

@@ -2,7 +2,6 @@ import logging
 from typing import Optional
 
 import torch
-import torch.nn.functional as F
 import comfy.model_management
 from .base import (
     WeightAdapterBase,
@@ -15,17 +14,7 @@ from .base import (
 class LokrDiff(WeightAdapterTrainBase):
     def __init__(self, weights):
         super().__init__()
-        (
-            lokr_w1,
-            lokr_w2,
-            alpha,
-            lokr_w1_a,
-            lokr_w1_b,
-            lokr_w2_a,
-            lokr_w2_b,
-            lokr_t2,
-            dora_scale,
-        ) = weights
+        (lokr_w1, lokr_w2, alpha, lokr_w1_a, lokr_w1_b, lokr_w2_a, lokr_w2_b, lokr_t2, dora_scale) = weights
         self.use_tucker = False
         if lokr_w1_a is not None:
             _, rank_a = lokr_w1_a.shape[0], lokr_w1_a.shape[1]
@@ -68,10 +57,10 @@ class LokrDiff(WeightAdapterTrainBase):
         if self.w2_rebuild:
             if self.use_tucker:
                 w2 = torch.einsum(
-                    "i j k l, j r, i p -> p r k l",
+                    'i j k l, j r, i p -> p r k l',
                     self.lokr_t2,
                     self.lokr_w2_b,
-                    self.lokr_w2_a,
+                    self.lokr_w2_a
                 )
             else:
                 w2 = self.lokr_w2_a @ self.lokr_w2_b
@@ -80,89 +69,9 @@ class LokrDiff(WeightAdapterTrainBase):
             return self.lokr_w2
 
     def __call__(self, w):
-        w1 = self.w1
-        w2 = self.w2
-        # Unsqueeze w1 to match w2 dims for proper kron product (like LyCORIS make_kron)
-        for _ in range(w2.dim() - w1.dim()):
-            w1 = w1.unsqueeze(-1)
-        diff = torch.kron(w1, w2)
+        diff = torch.kron(self.w1, self.w2)
         return w + diff.reshape(w.shape).to(w)
 
-    def h(self, x: torch.Tensor, base_out: torch.Tensor) -> torch.Tensor:
-        """
-        Additive bypass component for LoKr training: efficient Kronecker product.
-
-        Uses w1/w2 properties which handle both direct and decomposed cases.
-        For create_train (direct w1/w2), no alpha scaling in properties.
-        For to_train (decomposed), alpha/rank scaling is in properties.
-
-        Args:
-            x: Input tensor
-            base_out: Output from base forward (unused, for API consistency)
-        """
-        # Get w1, w2 from properties (handles rebuild vs direct)
-        w1 = self.w1
-        w2 = self.w2
-
-        # Multiplier from bypass injection
-        multiplier = getattr(self, "multiplier", 1.0)
-
-        # Get module info from bypass injection
-        is_conv = getattr(self, "is_conv", False)
-        conv_dim = getattr(self, "conv_dim", 0)
-        kw_dict = getattr(self, "kw_dict", {})
-
-        # Efficient Kronecker application without materializing full weight
-        # kron(w1, w2) @ x can be computed as nested operations
-        # w1: [out_l, in_m], w2: [out_k, in_n, *k_size]
-        # Full weight would be [out_l*out_k, in_m*in_n, *k_size]
-
-        uq = w1.size(1)  # in_m - inner grouping dimension
-
-        if is_conv:
-            conv_fn = (F.conv1d, F.conv2d, F.conv3d)[conv_dim - 1]
-
-            B, C_in, *spatial = x.shape
-            # Reshape input for grouped application: [B * uq, C_in // uq, *spatial]
-            h_in_group = x.reshape(B * uq, -1, *spatial)
-
-            # Ensure w2 has conv dims
-            if w2.dim() == 2:
-                w2 = w2.view(*w2.shape, *([1] * conv_dim))
-
-            # Apply w2 path with stride/padding
-            hb = conv_fn(h_in_group, w2, **kw_dict)
-
-            # Reshape for cross-group operation
-            hb = hb.view(B, -1, *hb.shape[1:])
-            h_cross = hb.transpose(1, -1)
-
-            # Apply w1 (always 2D, applied as linear on channel dim)
-            hc = F.linear(h_cross, w1)
-            hc = hc.transpose(1, -1)
-
-            # Reshape to output
-            out = hc.reshape(B, -1, *hc.shape[3:])
-        else:
-            # Linear case
-            # Reshape input: [..., in_m * in_n] -> [..., uq (in_m), in_n]
-            h_in_group = x.reshape(*x.shape[:-1], uq, -1)
-
-            # Apply w2: [..., uq, in_n] @ [out_k, in_n].T -> [..., uq, out_k]
-            hb = F.linear(h_in_group, w2)
-
-            # Transpose for w1: [..., uq, out_k] -> [..., out_k, uq]
-            h_cross = hb.transpose(-1, -2)
-
-            # Apply w1: [..., out_k, uq] @ [out_l, uq].T -> [..., out_k, out_l]
-            hc = F.linear(h_cross, w1)
-
-            # Transpose back and flatten: [..., out_k, out_l] -> [..., out_l * out_k]
-            hc = hc.transpose(-1, -2)
-            out = hc.reshape(*hc.shape[:-2], -1)
-
-        return out * multiplier
-
     def passive_memory_usage(self):
         return sum(param.numel() * param.element_size() for param in self.parameters())
 
@@ -177,22 +86,16 @@ class LoKrAdapter(WeightAdapterBase):
     @classmethod
     def create_train(cls, weight, rank=1, alpha=1.0):
         out_dim = weight.shape[0]
-        in_dim = weight.shape[1]  # Just in_channels, not flattened with kernel
-        k_size = weight.shape[2:] if weight.dim() > 2 else ()
-
-        out_l, out_k = factorization(out_dim, rank)
-        in_m, in_n = factorization(in_dim, rank)
-
-        # w1: [out_l, in_m]
-        mat1 = torch.empty(out_l, in_m, device=weight.device, dtype=torch.float32)
-        # w2: [out_k, in_n, *k_size] for conv, [out_k, in_n] for linear
-        mat2 = torch.empty(
-            out_k, in_n, *k_size, device=weight.device, dtype=torch.float32
-        )
-
+        in_dim = weight.shape[1:].numel()
+        out1, out2 = factorization(out_dim, rank)
+        in1, in2 = factorization(in_dim, rank)
+        mat1 = torch.empty(out1, in1, device=weight.device, dtype=torch.float32)
+        mat2 = torch.empty(out2, in2, device=weight.device, dtype=torch.float32)
         torch.nn.init.kaiming_uniform_(mat2, a=5**0.5)
         torch.nn.init.constant_(mat1, 0.0)
-        return LokrDiff((mat1, mat2, alpha, None, None, None, None, None, None))
+        return LokrDiff(
+            (mat1, mat2, alpha, None, None, None, None, None, None)
+        )
 
     def to_train(self):
         return LokrDiff(self.weights)
@@ -251,23 +154,8 @@ class LoKrAdapter(WeightAdapterBase):
             lokr_t2 = lora[lokr_t2_name]
             loaded_keys.add(lokr_t2_name)
 
-        if (
-            (lokr_w1 is not None)
-            or (lokr_w2 is not None)
-            or (lokr_w1_a is not None)
-            or (lokr_w2_a is not None)
-        ):
-            weights = (
-                lokr_w1,
-                lokr_w2,
-                alpha,
-                lokr_w1_a,
-                lokr_w1_b,
-                lokr_w2_a,
-                lokr_w2_b,
-                lokr_t2,
-                dora_scale,
-            )
+        if (lokr_w1 is not None) or (lokr_w2 is not None) or (lokr_w1_a is not None) or (lokr_w2_a is not None):
+            weights = (lokr_w1, lokr_w2, alpha, lokr_w1_a, lokr_w1_b, lokr_w2_a, lokr_w2_b, lokr_t2, dora_scale)
             return cls(loaded_keys, weights)
         else:
             return None
@@ -296,47 +184,23 @@ class LoKrAdapter(WeightAdapterBase):
 
         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
-                ),
-            )
+            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
-            )
+            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
-                    ),
-                )
+                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
-                    ),
-                )
+                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
-            )
+            w2 = comfy.model_management.cast_to_device(w2, weight.device, intermediate_dtype)
 
         if len(w2.shape) == 4:
             w1 = w1.unsqueeze(2).unsqueeze(2)
@@ -348,134 +212,9 @@ class LoKrAdapter(WeightAdapterBase):
         try:
             lora_diff = torch.kron(w1, w2).reshape(weight.shape)
             if dora_scale is not None:
-                weight = weight_decompose(
-                    dora_scale,
-                    weight,
-                    lora_diff,
-                    alpha,
-                    strength,
-                    intermediate_dtype,
-                    function,
-                )
+                weight = weight_decompose(dora_scale, weight, lora_diff, alpha, strength, intermediate_dtype, function)
             else:
                 weight += function(((strength * alpha) * lora_diff).type(weight.dtype))
         except Exception as e:
             logging.error("ERROR {} {} {}".format(self.name, key, e))
         return weight
-
-    def h(self, x: torch.Tensor, base_out: torch.Tensor) -> torch.Tensor:
-        """
-        Additive bypass component for LoKr: efficient Kronecker product application.
-
-        Note:
-            Does not access original model weights - bypass mode is designed
-            for quantized models where weights may not be accessible.
-
-        Args:
-            x: Input tensor
-            base_out: Output from base forward (unused, for API consistency)
-
-        Reference: LyCORIS functional/lokr.py bypass_forward_diff
-        """
-        # FUNC_LIST: [None, None, F.linear, F.conv1d, F.conv2d, F.conv3d]
-        FUNC_LIST = [None, None, F.linear, F.conv1d, F.conv2d, F.conv3d]
-
-        v = self.weights
-        # v[0]=w1, v[1]=w2, v[2]=alpha, v[3]=w1_a, v[4]=w1_b, v[5]=w2_a, v[6]=w2_b, v[7]=t2, v[8]=dora
-        w1 = v[0]
-        w2 = v[1]
-        alpha = v[2]
-        w1_a = v[3]
-        w1_b = v[4]
-        w2_a = v[5]
-        w2_b = v[6]
-        t2 = v[7]
-
-        use_w1 = w1 is not None
-        use_w2 = w2 is not None
-        tucker = t2 is not None
-
-        # Use module info from bypass injection, not weight dimension
-        is_conv = getattr(self, "is_conv", False)
-        conv_dim = getattr(self, "conv_dim", 0)
-        kw_dict = getattr(self, "kw_dict", {}) if is_conv else {}
-
-        if is_conv:
-            op = FUNC_LIST[conv_dim + 2]
-        else:
-            op = F.linear
-
-        # Determine rank and scale
-        rank = w1_b.size(0) if not use_w1 else w2_b.size(0) if not use_w2 else alpha
-        scale = (alpha / rank if alpha is not None else 1.0) * getattr(
-            self, "multiplier", 1.0
-        )
-
-        # Build c (w1)
-        if use_w1:
-            c = w1.to(dtype=x.dtype)
-        else:
-            c = w1_a.to(dtype=x.dtype) @ w1_b.to(dtype=x.dtype)
-        uq = c.size(1)
-
-        # Build w2 components
-        if use_w2:
-            ba = w2.to(dtype=x.dtype)
-        else:
-            a = w2_b.to(dtype=x.dtype)
-            b = w2_a.to(dtype=x.dtype)
-            if is_conv:
-                if tucker:
-                    # Tucker: a, b get 1s appended (kernel is in t2)
-                    if a.dim() == 2:
-                        a = a.view(*a.shape, *([1] * conv_dim))
-                    if b.dim() == 2:
-                        b = b.view(*b.shape, *([1] * conv_dim))
-                else:
-                    # Non-tucker conv: b may need 1s appended
-                    if b.dim() == 2:
-                        b = b.view(*b.shape, *([1] * conv_dim))
-
-        # Reshape input by uq groups
-        if is_conv:
-            B, _, *rest = x.shape
-            h_in_group = x.reshape(B * uq, -1, *rest)
-        else:
-            h_in_group = x.reshape(*x.shape[:-1], uq, -1)
-
-        # Apply w2 path
-        if use_w2:
-            hb = op(h_in_group, ba, **kw_dict)
-        else:
-            if is_conv:
-                if tucker:
-                    t = t2.to(dtype=x.dtype)
-                    if t.dim() == 2:
-                        t = t.view(*t.shape, *([1] * conv_dim))
-                    ha = op(h_in_group, a)
-                    ht = op(ha, t, **kw_dict)
-                    hb = op(ht, b)
-                else:
-                    ha = op(h_in_group, a, **kw_dict)
-                    hb = op(ha, b)
-            else:
-                ha = op(h_in_group, a)
-                hb = op(ha, b)
-
-        # Reshape and apply c (w1)
-        if is_conv:
-            hb = hb.view(B, -1, *hb.shape[1:])
-            h_cross_group = hb.transpose(1, -1)
-        else:
-            h_cross_group = hb.transpose(-1, -2)
-
-        hc = F.linear(h_cross_group, c)
-
-        if is_conv:
-            hc = hc.transpose(1, -1)
-            out = hc.reshape(B, -1, *hc.shape[3:])
-        else:
-            hc = hc.transpose(-1, -2)
-            out = hc.reshape(*hc.shape[:-2], -1)
-
-        return out * scale

comfy/weight_adapter/lora.py

@@ -2,7 +2,6 @@ import logging
 from typing import Optional
 
 import torch
-import torch.nn.functional as F
 import comfy.model_management
 from .base import (
     WeightAdapterBase,
@@ -21,7 +20,11 @@ class LoraDiff(WeightAdapterTrainBase):
         rank, in_dim = mat2.shape[0], mat2.shape[1]
         if mid is not None:
             convdim = mid.ndim - 2
-            layer = (torch.nn.Conv1d, torch.nn.Conv2d, torch.nn.Conv3d)[convdim]
+            layer = (
+                torch.nn.Conv1d,
+                torch.nn.Conv2d,
+                torch.nn.Conv3d
+            )[convdim]
         else:
             layer = torch.nn.Linear
         self.lora_up = layer(rank, out_dim, bias=False)
@@ -48,78 +51,6 @@ class LoraDiff(WeightAdapterTrainBase):
         weight = w + scale * diff.reshape(w.shape)
         return weight.to(org_dtype)
 
-    def h(self, x: torch.Tensor, base_out: torch.Tensor) -> torch.Tensor:
-        """
-        Additive bypass component for LoRA training: h(x) = up(down(x)) * scale
-
-        Simple implementation using the nn.Module weights directly.
-        No mid/dora/reshape branches (create_train doesn't create them).
-
-        Args:
-            x: Input tensor
-            base_out: Output from base forward (unused, for API consistency)
-        """
-        # Compute scale = alpha / rank * multiplier
-        scale = (self.alpha / self.rank) * getattr(self, "multiplier", 1.0)
-
-        # Get module info from bypass injection
-        is_conv = getattr(self, "is_conv", False)
-        conv_dim = getattr(self, "conv_dim", 0)
-        kw_dict = getattr(self, "kw_dict", {})
-
-        # Get weights (keep in original dtype for numerical stability)
-        down_weight = self.lora_down.weight
-        up_weight = self.lora_up.weight
-
-        if is_conv:
-            # Conv path: use functional conv
-            # conv_dim: 1=conv1d, 2=conv2d, 3=conv3d
-            conv_fn = (F.conv1d, F.conv2d, F.conv3d)[conv_dim - 1]
-
-            # Reshape 2D weights to conv format if needed
-            # down: [rank, in_features] -> [rank, in_channels, *kernel_size]
-            # up: [out_features, rank] -> [out_features, rank, 1, 1, ...]
-            if down_weight.dim() == 2:
-                kernel_size = getattr(self, "kernel_size", (1,) * conv_dim)
-                in_channels = getattr(self, "in_channels", None)
-                if in_channels is not None:
-                    down_weight = down_weight.view(
-                        down_weight.shape[0], in_channels, *kernel_size
-                    )
-                else:
-                    # Fallback: assume 1x1 kernel
-                    down_weight = down_weight.view(
-                        *down_weight.shape, *([1] * conv_dim)
-                    )
-            if up_weight.dim() == 2:
-                # up always uses 1x1 kernel
-                up_weight = up_weight.view(*up_weight.shape, *([1] * conv_dim))
-
-            # down conv uses stride/padding from module, up is 1x1
-            hidden = conv_fn(x, down_weight, **kw_dict)
-
-            # mid layer if exists (tucker decomposition)
-            if self.lora_mid is not None:
-                mid_weight = self.lora_mid.weight
-                if mid_weight.dim() == 2:
-                    mid_weight = mid_weight.view(*mid_weight.shape, *([1] * conv_dim))
-                hidden = conv_fn(hidden, mid_weight)
-
-            # up conv is always 1x1 (no stride/padding)
-            out = conv_fn(hidden, up_weight)
-        else:
-            # Linear path: simple matmul chain
-            hidden = F.linear(x, down_weight)
-
-            # mid layer if exists
-            if self.lora_mid is not None:
-                mid_weight = self.lora_mid.weight
-                hidden = F.linear(hidden, mid_weight)
-
-            out = F.linear(hidden, up_weight)
-
-        return out * scale
-
     def passive_memory_usage(self):
         return sum(param.numel() * param.element_size() for param in self.parameters())
 
@@ -139,7 +70,9 @@ class LoRAAdapter(WeightAdapterBase):
         mat2 = torch.empty(rank, in_dim, device=weight.device, dtype=torch.float32)
         torch.nn.init.kaiming_uniform_(mat1, a=5**0.5)
         torch.nn.init.constant_(mat2, 0.0)
-        return LoraDiff((mat1, mat2, alpha, None, None, None))
+        return LoraDiff(
+            (mat1, mat2, alpha, None, None, None)
+        )
 
     def to_train(self):
         return LoraDiff(self.weights)
@@ -277,85 +210,3 @@ class LoRAAdapter(WeightAdapterBase):
         except Exception as e:
             logging.error("ERROR {} {} {}".format(self.name, key, e))
         return weight
-
-    def h(self, x: torch.Tensor, base_out: torch.Tensor) -> torch.Tensor:
-        """
-        Additive bypass component for LoRA: h(x) = up(down(x)) * scale
-
-        Note:
-            Does not access original model weights - bypass mode is designed
-            for quantized models where weights may not be accessible.
-
-        Args:
-            x: Input tensor
-            base_out: Output from base forward (unused, for API consistency)
-
-        Reference: LyCORIS functional/locon.py bypass_forward_diff
-        """
-        # FUNC_LIST: [None, None, F.linear, F.conv1d, F.conv2d, F.conv3d]
-        FUNC_LIST = [None, None, F.linear, F.conv1d, F.conv2d, F.conv3d]
-
-        v = self.weights
-        # v[0]=up, v[1]=down, v[2]=alpha, v[3]=mid, v[4]=dora_scale, v[5]=reshape
-        up = v[0]
-        down = v[1]
-        alpha = v[2]
-        mid = v[3]
-
-        # Compute scale = alpha / rank
-        rank = down.shape[0]
-        if alpha is not None:
-            scale = alpha / rank
-        else:
-            scale = 1.0
-        scale = scale * getattr(self, "multiplier", 1.0)
-
-        # Cast dtype
-        up = up.to(dtype=x.dtype)
-        down = down.to(dtype=x.dtype)
-
-        # Use module info from bypass injection, not weight dimension
-        is_conv = getattr(self, "is_conv", False)
-        conv_dim = getattr(self, "conv_dim", 0)
-        kw_dict = getattr(self, "kw_dict", {})
-
-        if is_conv:
-            op = FUNC_LIST[
-                conv_dim + 2
-            ]  # conv_dim 1->conv1d(3), 2->conv2d(4), 3->conv3d(5)
-            kernel_size = getattr(self, "kernel_size", (1,) * conv_dim)
-            in_channels = getattr(self, "in_channels", None)
-
-            # Reshape 2D weights to conv format using kernel_size
-            # down: [rank, in_channels * prod(kernel_size)] -> [rank, in_channels, *kernel_size]
-            # up: [out_channels, rank] -> [out_channels, rank, 1, 1, ...] (1x1 kernel)
-            if down.dim() == 2:
-                # down.shape[1] = in_channels * prod(kernel_size)
-                if in_channels is not None:
-                    down = down.view(down.shape[0], in_channels, *kernel_size)
-                else:
-                    # Fallback: assume 1x1 kernel if in_channels unknown
-                    down = down.view(*down.shape, *([1] * conv_dim))
-            if up.dim() == 2:
-                # up always uses 1x1 kernel
-                up = up.view(*up.shape, *([1] * conv_dim))
-            if mid is not None:
-                mid = mid.to(dtype=x.dtype)
-                if mid.dim() == 2:
-                    mid = mid.view(*mid.shape, *([1] * conv_dim))
-        else:
-            op = F.linear
-            kw_dict = {}  # linear doesn't take stride/padding
-
-        # Simple chain: down -> mid (if tucker) -> up
-        if mid is not None:
-            if not is_conv:
-                mid = mid.to(dtype=x.dtype)
-            hidden = op(x, down)
-            hidden = op(hidden, mid, **kw_dict)
-            out = op(hidden, up)
-        else:
-            hidden = op(x, down, **kw_dict)
-            out = op(hidden, up)
-
-        return out * scale

comfy/weight_adapter/oft.py

@@ -3,18 +3,13 @@ from typing import Optional
 
 import torch
 import comfy.model_management
-from .base import (
-    WeightAdapterBase,
-    WeightAdapterTrainBase,
-    weight_decompose,
-    factorization,
-)
+from .base import WeightAdapterBase, WeightAdapterTrainBase, weight_decompose, factorization
 
 
 class OFTDiff(WeightAdapterTrainBase):
     def __init__(self, weights):
         super().__init__()
-        # Unpack weights tuple from OFTAdapter
+        # Unpack weights tuple from LoHaAdapter
         blocks, rescale, alpha, _ = weights
 
         # Create trainable parameters
@@ -57,78 +52,6 @@ class OFTDiff(WeightAdapterTrainBase):
             weight = self.rescale * weight
         return weight.to(org_dtype)
 
-    def _get_orthogonal_matrix(self, device, dtype):
-        """Compute the orthogonal rotation matrix R from OFT blocks."""
-        blocks = self.oft_blocks.to(device=device, dtype=dtype)
-        I = torch.eye(self.block_size, device=device, dtype=dtype)
-
-        # Q = blocks - blocks^T (skew-symmetric)
-        q = blocks - blocks.transpose(1, 2)
-        normed_q = q
-
-        # Apply constraint if set
-        if self.constraint:
-            q_norm = torch.norm(q) + 1e-8
-            if q_norm > self.constraint:
-                normed_q = q * self.constraint / q_norm
-
-        # Cayley transform: R = (I + Q)(I - Q)^-1
-        r = (I + normed_q) @ (I - normed_q).float().inverse()
-        return r.to(dtype)
-
-    def h(self, x: torch.Tensor, base_out: torch.Tensor) -> torch.Tensor:
-        """
-        OFT has no additive component - returns zeros matching base_out shape.
-
-        OFT only transforms the output via g(), it doesn't add to it.
-        """
-        return torch.zeros_like(base_out)
-
-    def g(self, y: torch.Tensor) -> torch.Tensor:
-        """
-        Output transformation for OFT: applies orthogonal rotation.
-
-        OFT transforms output channels using block-diagonal orthogonal matrices.
-        """
-        r = self._get_orthogonal_matrix(y.device, y.dtype)
-
-        # Apply multiplier to interpolate between identity and full transform
-        multiplier = getattr(self, "multiplier", 1.0)
-        I = torch.eye(self.block_size, device=y.device, dtype=y.dtype)
-        r = r * multiplier + (1 - multiplier) * I
-
-        # Use module info from bypass injection
-        is_conv = getattr(self, "is_conv", y.dim() > 2)
-
-        if is_conv:
-            # Conv output: (N, C, H, W, ...) -> transpose to (N, H, W, ..., C)
-            y = y.transpose(1, -1)
-
-        # y now has channels in last dim
-        *batch_shape, out_features = y.shape
-
-        # Reshape to apply block-diagonal transform
-        # (*, out_features) -> (*, block_num, block_size)
-        y_blocked = y.reshape(*batch_shape, self.block_num, self.block_size)
-
-        # Apply orthogonal transform: R @ y for each block
-        # r: (block_num, block_size, block_size), y_blocked: (*, block_num, block_size)
-        out_blocked = torch.einsum("k n m, ... k n -> ... k m", r, y_blocked)
-
-        # Reshape back: (*, block_num, block_size) -> (*, out_features)
-        out = out_blocked.reshape(*batch_shape, out_features)
-
-        # Apply rescale if present
-        if self.rescaled:
-            rescale = self.rescale.to(device=y.device, dtype=y.dtype)
-            out = out * rescale.view(-1)
-
-        if is_conv:
-            # Transpose back: (N, H, W, ..., C) -> (N, C, H, W, ...)
-            out = out.transpose(1, -1)
-
-        return out
-
     def passive_memory_usage(self):
         """Calculates memory usage of the trainable parameters."""
         return sum(param.numel() * param.element_size() for param in self.parameters())
@@ -145,10 +68,10 @@ class OFTAdapter(WeightAdapterBase):
     def create_train(cls, weight, rank=1, alpha=1.0):
         out_dim = weight.shape[0]
         block_size, block_num = factorization(out_dim, rank)
-        block = torch.zeros(
-            block_num, block_size, block_size, device=weight.device, dtype=torch.float32
+        block = torch.zeros(block_num, block_size, block_size, device=weight.device, dtype=torch.float32)
+        return OFTDiff(
+            (block, None, alpha, None)
         )
-        return OFTDiff((block, None, alpha, None))
 
     def to_train(self):
         return OFTDiff(self.weights)
@@ -204,13 +127,9 @@ class OFTAdapter(WeightAdapterBase):
             alpha = 0
         dora_scale = v[3]
 
-        blocks = comfy.model_management.cast_to_device(
-            blocks, weight.device, intermediate_dtype
-        )
+        blocks = comfy.model_management.cast_to_device(blocks, weight.device, intermediate_dtype)
         if rescale is not None:
-            rescale = comfy.model_management.cast_to_device(
-                rescale, weight.device, intermediate_dtype
-            )
+            rescale = comfy.model_management.cast_to_device(rescale, weight.device, intermediate_dtype)
 
         block_num, block_size, *_ = blocks.shape
 
@@ -220,108 +139,23 @@ class OFTAdapter(WeightAdapterBase):
             # for Q = -Q^T
             q = blocks - blocks.transpose(1, 2)
             normed_q = q
-            if alpha > 0:  # alpha in oft/boft is for constraint
+            if alpha > 0: # alpha in oft/boft is for constraint
                 q_norm = torch.norm(q) + 1e-8
                 if q_norm > alpha:
                     normed_q = q * alpha / q_norm
             # use float() to prevent unsupported type in .inverse()
             r = (I + normed_q) @ (I - normed_q).float().inverse()
             r = r.to(weight)
-            # Create I in weight's dtype for the einsum
-            I_w = torch.eye(block_size, device=weight.device, dtype=weight.dtype)
             _, *shape = weight.shape
             lora_diff = torch.einsum(
                 "k n m, k n ... -> k m ...",
-                (r * strength) - strength * I_w,
+                (r * strength) - strength * I,
                 weight.view(block_num, block_size, *shape),
             ).view(-1, *shape)
             if dora_scale is not None:
-                weight = weight_decompose(
-                    dora_scale,
-                    weight,
-                    lora_diff,
-                    alpha,
-                    strength,
-                    intermediate_dtype,
-                    function,
-                )
+                weight = weight_decompose(dora_scale, weight, lora_diff, alpha, strength, intermediate_dtype, function)
             else:
                 weight += function((strength * lora_diff).type(weight.dtype))
         except Exception as e:
             logging.error("ERROR {} {} {}".format(self.name, key, e))
         return weight
-
-    def _get_orthogonal_matrix(self, device, dtype):
-        """Compute the orthogonal rotation matrix R from OFT blocks."""
-        v = self.weights
-        blocks = v[0].to(device=device, dtype=dtype)
-        alpha = v[2]
-        if alpha is None:
-            alpha = 0
-
-        block_num, block_size, _ = blocks.shape
-        I = torch.eye(block_size, device=device, dtype=dtype)
-
-        # Q = blocks - blocks^T (skew-symmetric)
-        q = blocks - blocks.transpose(1, 2)
-        normed_q = q
-
-        # Apply constraint if alpha > 0
-        if alpha > 0:
-            q_norm = torch.norm(q) + 1e-8
-            if q_norm > alpha:
-                normed_q = q * alpha / q_norm
-
-        # Cayley transform: R = (I + Q)(I - Q)^-1
-        r = (I + normed_q) @ (I - normed_q).float().inverse()
-        return r, block_num, block_size
-
-    def g(self, y: torch.Tensor) -> torch.Tensor:
-        """
-        Output transformation for OFT: applies orthogonal rotation to output.
-
-        OFT transforms the output channels using block-diagonal orthogonal matrices.
-
-        Reference: LyCORIS DiagOFTModule._bypass_forward
-        """
-        v = self.weights
-        rescale = v[1]
-
-        r, block_num, block_size = self._get_orthogonal_matrix(y.device, y.dtype)
-
-        # Apply multiplier to interpolate between identity and full transform
-        multiplier = getattr(self, "multiplier", 1.0)
-        I = torch.eye(block_size, device=y.device, dtype=y.dtype)
-        r = r * multiplier + (1 - multiplier) * I
-
-        # Use module info from bypass injection to determine conv vs linear
-        is_conv = getattr(self, "is_conv", y.dim() > 2)
-
-        if is_conv:
-            # Conv output: (N, C, H, W, ...) -> transpose to (N, H, W, ..., C)
-            y = y.transpose(1, -1)
-
-        # y now has channels in last dim
-        *batch_shape, out_features = y.shape
-
-        # Reshape to apply block-diagonal transform
-        # (*, out_features) -> (*, block_num, block_size)
-        y_blocked = y.view(*batch_shape, block_num, block_size)
-
-        # Apply orthogonal transform: R @ y for each block
-        # r: (block_num, block_size, block_size), y_blocked: (*, block_num, block_size)
-        out_blocked = torch.einsum("k n m, ... k n -> ... k m", r, y_blocked)
-
-        # Reshape back: (*, block_num, block_size) -> (*, out_features)
-        out = out_blocked.view(*batch_shape, out_features)
-
-        # Apply rescale if present
-        if rescale is not None:
-            rescale = rescale.to(device=y.device, dtype=y.dtype)
-            out = out * rescale.view(-1)
-
-        if is_conv:
-            # Transpose back: (N, H, W, ..., C) -> (N, C, H, W, ...)
-            out = out.transpose(1, -1)
-
-        return out

comfy_api/latest/_io.py

@@ -1383,8 +1383,6 @@ class Schema:
     """Flags a node as not idempotent; when True, the node will run and not reuse the cached outputs when identical inputs are provided on a different node in the graph."""
     enable_expand: bool=False
     """Flags a node as expandable, allowing NodeOutput to include 'expand' property."""
-    accept_all_inputs: bool=False
-    """When True, all inputs from the prompt will be passed to the node as kwargs, even if not defined in the schema."""
 
     def validate(self):
         '''Validate the schema:
@@ -1855,14 +1853,6 @@ class _ComfyNodeBaseInternal(_ComfyNodeInternal):
             cls.GET_SCHEMA()
         return cls._NOT_IDEMPOTENT
 
-    _ACCEPT_ALL_INPUTS = None
-    @final
-    @classproperty
-    def ACCEPT_ALL_INPUTS(cls):  # noqa
-        if cls._ACCEPT_ALL_INPUTS is None:
-            cls.GET_SCHEMA()
-        return cls._ACCEPT_ALL_INPUTS
-
     @final
     @classmethod
     def INPUT_TYPES(cls) -> dict[str, dict]:
@@ -1901,8 +1891,6 @@ class _ComfyNodeBaseInternal(_ComfyNodeInternal):
             cls._INPUT_IS_LIST = schema.is_input_list
         if cls._NOT_IDEMPOTENT is None:
             cls._NOT_IDEMPOTENT = schema.not_idempotent
-        if cls._ACCEPT_ALL_INPUTS is None:
-            cls._ACCEPT_ALL_INPUTS = schema.accept_all_inputs
 
         if cls._RETURN_TYPES is None:
             output = []

comfy_api_nodes/apis/hunyuan3d.py

@@ -1,66 +0,0 @@
-from typing import TypedDict
-
-from pydantic import BaseModel, Field, model_validator
-
-
-class InputGenerateType(TypedDict):
-    generate_type: str
-    polygon_type: str
-    pbr: bool
-
-
-class Hunyuan3DViewImage(BaseModel):
-    ViewType: str = Field(..., description="Valid values: back, left, right.")
-    ViewImageUrl: str = Field(...)
-
-
-class To3DProTaskRequest(BaseModel):
-    Model: str = Field(...)
-    Prompt: str | None = Field(None)
-    ImageUrl: str | None = Field(None)
-    MultiViewImages: list[Hunyuan3DViewImage] | None = Field(None)
-    EnablePBR: bool | None = Field(...)
-    FaceCount: int | None = Field(...)
-    GenerateType: str | None = Field(...)
-    PolygonType: str | None = Field(...)
-
-
-class RequestError(BaseModel):
-    Code: str = Field("")
-    Message: str = Field("")
-
-
-class To3DProTaskCreateResponse(BaseModel):
-    JobId: str | None = Field(None)
-    Error: RequestError | None = Field(None)
-
-    @model_validator(mode="before")
-    @classmethod
-    def unwrap_data(cls, values: dict) -> dict:
-        if "Response" in values and isinstance(values["Response"], dict):
-            return values["Response"]
-        return values
-
-
-class ResultFile3D(BaseModel):
-    Type: str = Field(...)
-    Url: str = Field(...)
-    PreviewImageUrl: str = Field("")
-
-
-class To3DProTaskResultResponse(BaseModel):
-    ErrorCode: str = Field("")
-    ErrorMessage: str = Field("")
-    ResultFile3Ds: list[ResultFile3D] = Field([])
-    Status: str = Field(...)
-
-    @model_validator(mode="before")
-    @classmethod
-    def unwrap_data(cls, values: dict) -> dict:
-        if "Response" in values and isinstance(values["Response"], dict):
-            return values["Response"]
-        return values
-
-
-class To3DProTaskQueryRequest(BaseModel):
-    JobId: str = Field(...)

comfy_api_nodes/nodes_hunyuan3d.py

@@ -1,297 +0,0 @@
-import os
-
-from typing_extensions import override
-
-from comfy_api.latest import IO, ComfyExtension, Input
-from comfy_api_nodes.apis.hunyuan3d import (
-    Hunyuan3DViewImage,
-    InputGenerateType,
-    ResultFile3D,
-    To3DProTaskCreateResponse,
-    To3DProTaskQueryRequest,
-    To3DProTaskRequest,
-    To3DProTaskResultResponse,
-)
-from comfy_api_nodes.util import (
-    ApiEndpoint,
-    download_url_to_bytesio,
-    downscale_image_tensor_by_max_side,
-    poll_op,
-    sync_op,
-    upload_image_to_comfyapi,
-    validate_image_dimensions,
-    validate_string,
-)
-from folder_paths import get_output_directory
-
-
-def get_glb_obj_from_response(response_objs: list[ResultFile3D]) -> ResultFile3D:
-    for i in response_objs:
-        if i.Type.lower() == "glb":
-            return i
-    raise ValueError("No GLB file found in response. Please report this to the developers.")
-
-
-class TencentTextToModelNode(IO.ComfyNode):
-
-    @classmethod
-    def define_schema(cls):
-        return IO.Schema(
-            node_id="TencentTextToModelNode",
-            display_name="Hunyuan3D: Text to Model (Pro)",
-            category="api node/3d/Tencent",
-            inputs=[
-                IO.Combo.Input(
-                    "model",
-                    options=["3.0", "3.1"],
-                    tooltip="The LowPoly option is unavailable for the `3.1` model.",
-                ),
-                IO.String.Input("prompt", multiline=True, default="", tooltip="Supports up to 1024 characters."),
-                IO.Int.Input("face_count", default=500000, min=40000, max=1500000),
-                IO.DynamicCombo.Input(
-                    "generate_type",
-                    options=[
-                        IO.DynamicCombo.Option("Normal", [IO.Boolean.Input("pbr", default=False)]),
-                        IO.DynamicCombo.Option(
-                            "LowPoly",
-                            [
-                                IO.Combo.Input("polygon_type", options=["triangle", "quadrilateral"]),
-                                IO.Boolean.Input("pbr", default=False),
-                            ],
-                        ),
-                        IO.DynamicCombo.Option("Geometry", []),
-                    ],
-                ),
-                IO.Int.Input(
-                    "seed",
-                    default=0,
-                    min=0,
-                    max=2147483647,
-                    display_mode=IO.NumberDisplay.number,
-                    control_after_generate=True,
-                    tooltip="Seed controls whether the node should re-run; "
-                    "results are non-deterministic regardless of seed.",
-                ),
-            ],
-            outputs=[
-                IO.String.Output(display_name="model_file"),
-            ],
-            hidden=[
-                IO.Hidden.auth_token_comfy_org,
-                IO.Hidden.api_key_comfy_org,
-                IO.Hidden.unique_id,
-            ],
-            is_api_node=True,
-            is_output_node=True,
-            price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(widgets=["generate_type", "generate_type.pbr", "face_count"]),
-                expr="""
-                (
-                  $base := widgets.generate_type = "normal" ? 25 : widgets.generate_type = "lowpoly" ? 30 : 15;
-                  $pbr := $lookup(widgets, "generate_type.pbr") ? 10 : 0;
-                  $face := widgets.face_count != 500000 ? 10 : 0;
-                  {"type":"usd","usd": ($base + $pbr + $face) * 0.02}
-                )
-                """,
-            ),
-        )
-
-    @classmethod
-    async def execute(
-        cls,
-        model: str,
-        prompt: str,
-        face_count: int,
-        generate_type: InputGenerateType,
-        seed: int,
-    ) -> IO.NodeOutput:
-        _ = seed
-        validate_string(prompt, field_name="prompt", min_length=1, max_length=1024)
-        if model == "3.1" and generate_type["generate_type"].lower() == "lowpoly":
-            raise ValueError("The LowPoly option is currently unavailable for the 3.1 model.")
-        response = await sync_op(
-            cls,
-            ApiEndpoint(path="/proxy/tencent/hunyuan/3d-pro", method="POST"),
-            response_model=To3DProTaskCreateResponse,
-            data=To3DProTaskRequest(
-                Model=model,
-                Prompt=prompt,
-                FaceCount=face_count,
-                GenerateType=generate_type["generate_type"],
-                EnablePBR=generate_type.get("pbr", None),
-                PolygonType=generate_type.get("polygon_type", None),
-            ),
-        )
-        if response.Error:
-            raise ValueError(f"Task creation failed with code {response.Error.Code}: {response.Error.Message}")
-        result = await poll_op(
-            cls,
-            ApiEndpoint(path="/proxy/tencent/hunyuan/3d-pro/query", method="POST"),
-            data=To3DProTaskQueryRequest(JobId=response.JobId),
-            response_model=To3DProTaskResultResponse,
-            status_extractor=lambda r: r.Status,
-        )
-        model_file = f"hunyuan_model_{response.JobId}.glb"
-        await download_url_to_bytesio(
-            get_glb_obj_from_response(result.ResultFile3Ds).Url,
-            os.path.join(get_output_directory(), model_file),
-        )
-        return IO.NodeOutput(model_file)
-
-
-class TencentImageToModelNode(IO.ComfyNode):
-
-    @classmethod
-    def define_schema(cls):
-        return IO.Schema(
-            node_id="TencentImageToModelNode",
-            display_name="Hunyuan3D: Image(s) to Model (Pro)",
-            category="api node/3d/Tencent",
-            inputs=[
-                IO.Combo.Input(
-                    "model",
-                    options=["3.0", "3.1"],
-                    tooltip="The LowPoly option is unavailable for the `3.1` model.",
-                ),
-                IO.Image.Input("image"),
-                IO.Image.Input("image_left", optional=True),
-                IO.Image.Input("image_right", optional=True),
-                IO.Image.Input("image_back", optional=True),
-                IO.Int.Input("face_count", default=500000, min=40000, max=1500000),
-                IO.DynamicCombo.Input(
-                    "generate_type",
-                    options=[
-                        IO.DynamicCombo.Option("Normal", [IO.Boolean.Input("pbr", default=False)]),
-                        IO.DynamicCombo.Option(
-                            "LowPoly",
-                            [
-                                IO.Combo.Input("polygon_type", options=["triangle", "quadrilateral"]),
-                                IO.Boolean.Input("pbr", default=False),
-                            ],
-                        ),
-                        IO.DynamicCombo.Option("Geometry", []),
-                    ],
-                ),
-                IO.Int.Input(
-                    "seed",
-                    default=0,
-                    min=0,
-                    max=2147483647,
-                    display_mode=IO.NumberDisplay.number,
-                    control_after_generate=True,
-                    tooltip="Seed controls whether the node should re-run; "
-                    "results are non-deterministic regardless of seed.",
-                ),
-            ],
-            outputs=[
-                IO.String.Output(display_name="model_file"),
-            ],
-            hidden=[
-                IO.Hidden.auth_token_comfy_org,
-                IO.Hidden.api_key_comfy_org,
-                IO.Hidden.unique_id,
-            ],
-            is_api_node=True,
-            is_output_node=True,
-            price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(
-                    widgets=["generate_type", "generate_type.pbr", "face_count"],
-                    inputs=["image_left", "image_right", "image_back"],
-                ),
-                expr="""
-                (
-                  $base := widgets.generate_type = "normal" ? 25 : widgets.generate_type = "lowpoly" ? 30 : 15;
-                  $multiview := (
-                    inputs.image_left.connected or inputs.image_right.connected or inputs.image_back.connected
-                  ) ? 10 : 0;
-                  $pbr := $lookup(widgets, "generate_type.pbr") ? 10 : 0;
-                  $face := widgets.face_count != 500000 ? 10 : 0;
-                  {"type":"usd","usd": ($base + $multiview + $pbr + $face) * 0.02}
-                )
-                """,
-            ),
-        )
-
-    @classmethod
-    async def execute(
-        cls,
-        model: str,
-        image: Input.Image,
-        face_count: int,
-        generate_type: InputGenerateType,
-        seed: int,
-        image_left: Input.Image | None = None,
-        image_right: Input.Image | None = None,
-        image_back: Input.Image | None = None,
-    ) -> IO.NodeOutput:
-        _ = seed
-        if model == "3.1" and generate_type["generate_type"].lower() == "lowpoly":
-            raise ValueError("The LowPoly option is currently unavailable for the 3.1 model.")
-        validate_image_dimensions(image, min_width=128, min_height=128)
-        multiview_images = []
-        for k, v in {
-            "left": image_left,
-            "right": image_right,
-            "back": image_back,
-        }.items():
-            if v is None:
-                continue
-            validate_image_dimensions(v, min_width=128, min_height=128)
-            multiview_images.append(
-                Hunyuan3DViewImage(
-                    ViewType=k,
-                    ViewImageUrl=await upload_image_to_comfyapi(
-                        cls,
-                        downscale_image_tensor_by_max_side(v, max_side=4900),
-                        mime_type="image/webp",
-                        total_pixels=24_010_000,
-                    ),
-                )
-            )
-        response = await sync_op(
-            cls,
-            ApiEndpoint(path="/proxy/tencent/hunyuan/3d-pro", method="POST"),
-            response_model=To3DProTaskCreateResponse,
-            data=To3DProTaskRequest(
-                Model=model,
-                FaceCount=face_count,
-                GenerateType=generate_type["generate_type"],
-                ImageUrl=await upload_image_to_comfyapi(
-                    cls,
-                    downscale_image_tensor_by_max_side(image, max_side=4900),
-                    mime_type="image/webp",
-                    total_pixels=24_010_000,
-                ),
-                MultiViewImages=multiview_images if multiview_images else None,
-                EnablePBR=generate_type.get("pbr", None),
-                PolygonType=generate_type.get("polygon_type", None),
-            ),
-        )
-        if response.Error:
-            raise ValueError(f"Task creation failed with code {response.Error.Code}: {response.Error.Message}")
-        result = await poll_op(
-            cls,
-            ApiEndpoint(path="/proxy/tencent/hunyuan/3d-pro/query", method="POST"),
-            data=To3DProTaskQueryRequest(JobId=response.JobId),
-            response_model=To3DProTaskResultResponse,
-            status_extractor=lambda r: r.Status,
-        )
-        model_file = f"hunyuan_model_{response.JobId}.glb"
-        await download_url_to_bytesio(
-            get_glb_obj_from_response(result.ResultFile3Ds).Url,
-            os.path.join(get_output_directory(), model_file),
-        )
-        return IO.NodeOutput(model_file)
-
-
-class TencentHunyuan3DExtension(ComfyExtension):
-    @override
-    async def get_node_list(self) -> list[type[IO.ComfyNode]]:
-        return [
-            TencentTextToModelNode,
-            TencentImageToModelNode,
-        ]
-
-
-async def comfy_entrypoint() -> TencentHunyuan3DExtension:
-    return TencentHunyuan3DExtension()

comfy_api_nodes/nodes_kling.py

@@ -249,6 +249,7 @@ async def finish_omni_video_task(cls: type[IO.ComfyNode], response: TaskStatusRe
         ApiEndpoint(path=f"/proxy/kling/v1/videos/omni-video/{response.data.task_id}"),
         response_model=TaskStatusResponse,
         status_extractor=lambda r: (r.data.task_status if r.data else None),
+        max_poll_attempts=160,
     )
     return IO.NodeOutput(await download_url_to_video_output(final_response.data.task_result.videos[0].url))
 

comfy_api_nodes/nodes_sora.py

@@ -149,6 +149,7 @@ class OpenAIVideoSora2(IO.ComfyNode):
             response_model=Sora2GenerationResponse,
             status_extractor=lambda x: x.status,
             poll_interval=8.0,
+            max_poll_attempts=160,
             estimated_duration=int(45 * (duration / 4) * model_time_multiplier),
         )
         return IO.NodeOutput(

comfy_api_nodes/nodes_topaz.py

@@ -203,6 +203,7 @@ class TopazImageEnhance(IO.ComfyNode):
             progress_extractor=lambda x: getattr(x, "progress", 0),
             price_extractor=lambda x: x.credits * 0.08,
             poll_interval=8.0,
+            max_poll_attempts=160,
             estimated_duration=60,
         )
 

comfy_api_nodes/util/__init__.py

@@ -13,7 +13,6 @@ from .conversions import (
     bytesio_to_image_tensor,
     convert_mask_to_image,
     downscale_image_tensor,
-    downscale_image_tensor_by_max_side,
     image_tensor_pair_to_batch,
     pil_to_bytesio,
     resize_mask_to_image,
@@ -34,7 +33,6 @@ from .download_helpers import (
 from .upload_helpers import (
     upload_audio_to_comfyapi,
     upload_file_to_comfyapi,
-    upload_image_to_comfyapi,
     upload_images_to_comfyapi,
     upload_video_to_comfyapi,
 )
@@ -63,7 +61,6 @@ __all__ = [
     # Upload helpers
     "upload_audio_to_comfyapi",
     "upload_file_to_comfyapi",
-    "upload_image_to_comfyapi",
     "upload_images_to_comfyapi",
     "upload_video_to_comfyapi",
     # Download helpers
@@ -78,7 +75,6 @@ __all__ = [
     "bytesio_to_image_tensor",
     "convert_mask_to_image",
     "downscale_image_tensor",
-    "downscale_image_tensor_by_max_side",
     "image_tensor_pair_to_batch",
     "pil_to_bytesio",
     "resize_mask_to_image",

comfy_api_nodes/util/client.py

@@ -141,7 +141,7 @@ async def poll_op(
     queued_statuses: list[str | int] | None = None,
     data: BaseModel | None = None,
     poll_interval: float = 5.0,
-    max_poll_attempts: int = 160,
+    max_poll_attempts: int = 120,
     timeout_per_poll: float = 120.0,
     max_retries_per_poll: int = 3,
     retry_delay_per_poll: float = 1.0,
@@ -238,7 +238,7 @@ async def poll_op_raw(
     queued_statuses: list[str | int] | None = None,
     data: dict[str, Any] | BaseModel | None = None,
     poll_interval: float = 5.0,
-    max_poll_attempts: int = 160,
+    max_poll_attempts: int = 120,
     timeout_per_poll: float = 120.0,
     max_retries_per_poll: int = 3,
     retry_delay_per_poll: float = 1.0,

comfy_api_nodes/util/conversions.py

@@ -144,21 +144,6 @@ def downscale_image_tensor(image: torch.Tensor, total_pixels: int = 1536 * 1024)
     return s
 
 
-def downscale_image_tensor_by_max_side(image: torch.Tensor, *,  max_side: int) -> torch.Tensor:
-    """Downscale input image tensor so the largest dimension is at most max_side pixels."""
-    samples = image.movedim(-1, 1)
-    height, width = samples.shape[2], samples.shape[3]
-    max_dim = max(width, height)
-    if max_dim <= max_side:
-        return image
-    scale_by = max_side / max_dim
-    new_width = round(width * scale_by)
-    new_height = round(height * scale_by)
-    s = common_upscale(samples, new_width, new_height, "lanczos", "disabled")
-    s = s.movedim(1, -1)
-    return s
-
-
 def tensor_to_data_uri(
     image_tensor: torch.Tensor,
     total_pixels: int = 2048 * 2048,

comfy_api_nodes/util/upload_helpers.py

@@ -88,28 +88,6 @@ async def upload_images_to_comfyapi(
     return download_urls
 
 
-async def upload_image_to_comfyapi(
-    cls: type[IO.ComfyNode],
-    image: torch.Tensor,
-    *,
-    mime_type: str | None = None,
-    wait_label: str | None = "Uploading",
-    total_pixels: int = 2048 * 2048,
-) -> str:
-    """Uploads a single image to ComfyUI API and returns its download URL."""
-    return (
-        await upload_images_to_comfyapi(
-            cls,
-            image,
-            max_images=1,
-            mime_type=mime_type,
-            wait_label=wait_label,
-            show_batch_index=False,
-            total_pixels=total_pixels,
-        )
-    )[0]
-
-
 async def upload_audio_to_comfyapi(
     cls: type[IO.ComfyNode],
     audio: Input.Audio,

comfy_extras/nodes_logic.py

@@ -104,23 +104,19 @@ class CustomComboNode(io.ComfyNode):
             category="utils",
             is_experimental=True,
             inputs=[io.Combo.Input("choice", options=[])],
-            outputs=[
-                io.String.Output(display_name="STRING"),
-                io.Int.Output(display_name="INDEX"),
-            ],
-            accept_all_inputs=True,
+            outputs=[io.String.Output()]
         )
 
     @classmethod
-    def validate_inputs(cls, choice: io.Combo.Type, index: int = 0, **kwargs) -> bool:
+    def validate_inputs(cls, choice: io.Combo.Type) -> bool:
         # NOTE: DO NOT DO THIS unless you want to skip validation entirely on the node's inputs.
         # I am doing that here because the widgets (besides the combo dropdown) on this node are fully frontend defined.
         # I need to skip checking that the chosen combo option is in the options list, since those are defined by the user.
         return True
 
     @classmethod
-    def execute(cls, choice: io.Combo.Type, index: int = 0, **kwargs) -> io.NodeOutput:
-        return io.NodeOutput(choice, index)
+    def execute(cls, choice: io.Combo.Type) -> io.NodeOutput:
+        return io.NodeOutput(choice)
 
 
 class DCTestNode(io.ComfyNode):

comfy_extras/nodes_lora_debug.py

@@ -1,79 +0,0 @@
-import folder_paths
-import comfy.utils
-import comfy.sd
-
-
-class LoraLoaderBypass:
-    """
-    Apply LoRA in bypass mode without modifying base model weights.
-
-    Bypass mode computes: output = base_forward(x) + lora_path(x)
-    This is useful for training and when model weights are offloaded.
-    """
-
-    def __init__(self):
-        self.loaded_lora = None
-
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "model": ("MODEL", {"tooltip": "The diffusion model the LoRA will be applied to."}),
-                "clip": ("CLIP", {"tooltip": "The CLIP model the LoRA will be applied to."}),
-                "lora_name": (folder_paths.get_filename_list("loras"), {"tooltip": "The name of the LoRA."}),
-                "strength_model": ("FLOAT", {"default": 1.0, "min": -100.0, "max": 100.0, "step": 0.01, "tooltip": "How strongly to modify the diffusion model. This value can be negative."}),
-                "strength_clip": ("FLOAT", {"default": 1.0, "min": -100.0, "max": 100.0, "step": 0.01, "tooltip": "How strongly to modify the CLIP model. This value can be negative."}),
-            }
-        }
-
-    RETURN_TYPES = ("MODEL", "CLIP")
-    OUTPUT_TOOLTIPS = ("The modified diffusion model.", "The modified CLIP model.")
-    FUNCTION = "load_lora"
-
-    CATEGORY = "loaders"
-    DESCRIPTION = "Apply LoRA in bypass mode. Unlike regular LoRA, this doesn't modify model weights - instead it injects the LoRA computation during forward pass. Useful for training scenarios."
-    EXPERIMENTAL = True
-
-    def load_lora(self, model, clip, lora_name, strength_model, strength_clip):
-        if strength_model == 0 and strength_clip == 0:
-            return (model, clip)
-
-        lora_path = folder_paths.get_full_path_or_raise("loras", lora_name)
-        lora = None
-        if self.loaded_lora is not None:
-            if self.loaded_lora[0] == lora_path:
-                lora = self.loaded_lora[1]
-            else:
-                self.loaded_lora = None
-
-        if lora is None:
-            lora = comfy.utils.load_torch_file(lora_path, safe_load=True)
-            self.loaded_lora = (lora_path, lora)
-
-        model_lora, clip_lora = comfy.sd.load_bypass_lora_for_models(model, clip, lora, strength_model, strength_clip)
-        return (model_lora, clip_lora)
-
-
-class LoraLoaderBypassModelOnly(LoraLoaderBypass):
-    @classmethod
-    def INPUT_TYPES(s):
-        return {"required": { "model": ("MODEL",),
-                              "lora_name": (folder_paths.get_filename_list("loras"), ),
-                              "strength_model": ("FLOAT", {"default": 1.0, "min": -100.0, "max": 100.0, "step": 0.01}),
-                              }}
-    RETURN_TYPES = ("MODEL",)
-    FUNCTION = "load_lora_model_only"
-
-    def load_lora_model_only(self, model, lora_name, strength_model):
-        return (self.load_lora(model, None, lora_name, strength_model, 0)[0],)
-
-
-NODE_CLASS_MAPPINGS = {
-    "LoraLoaderBypass": LoraLoaderBypass,
-    "LoraLoaderBypassModelOnly": LoraLoaderBypassModelOnly,
-}
-
-NODE_DISPLAY_NAME_MAPPINGS = {
-    "LoraLoaderBypass": "Load LoRA (Bypass) (For debugging)",
-    "LoraLoaderBypassModelOnly": "Load LoRA (Bypass, Model Only) (for debugging)",
-}

comfy_extras/nodes_train.py

@@ -18,7 +18,6 @@ import comfy_extras.nodes_custom_sampler
 import folder_paths
 import node_helpers
 from comfy.weight_adapter import adapters, adapter_maps
-from comfy.weight_adapter.bypass import BypassInjectionManager
 from comfy_api.latest import ComfyExtension, io, ui
 from comfy.utils import ProgressBar
 
@@ -340,11 +339,6 @@ class TrainSampler(comfy.samplers.Sampler):
                 self._train_step_multires_mode(model_wrap, cond, extra_args, noisegen, latent_image, dataset_size, pbar)
 
             if (i + 1) % self.grad_acc == 0:
-                for param_groups in self.optimizer.param_groups:
-                    for param in param_groups["params"]:
-                        if param.grad is None:
-                            continue
-                        param.grad.data = param.grad.data.to(param.data.dtype)
                 self.optimizer.step()
                 self.optimizer.zero_grad()
             ui_pbar.update(1)
@@ -504,9 +498,9 @@ def _prepare_latents_and_count(latents, dtype, bucket_mode):
         num_images = sum(t.shape[0] for t in latents)
         multi_res = False  # Not using multi_res path in bucket mode
 
-        logging.debug(f"Bucket mode: {num_buckets} buckets, {num_images} total samples")
+        logging.info(f"Bucket mode: {num_buckets} buckets, {num_images} total samples")
         for i, lat in enumerate(latents):
-            logging.debug(f"  Bucket {i}: shape {lat.shape}")
+            logging.info(f"  Bucket {i}: shape {lat.shape}")
         return latents, num_images, multi_res
 
     # Non-bucket mode
@@ -515,7 +509,7 @@ def _prepare_latents_and_count(latents, dtype, bucket_mode):
         latents = [t.to(dtype) for t in latents]
         for latent in latents:
             all_shapes.add(latent.shape)
-        logging.debug(f"Latent shapes: {all_shapes}")
+        logging.info(f"Latent shapes: {all_shapes}")
         if len(all_shapes) > 1:
             multi_res = True
         else:
@@ -551,7 +545,7 @@ def _validate_and_expand_conditioning(positive, num_images, bucket_mode):
     if bucket_mode:
         return positive  # Skip validation in bucket mode
 
-    logging.debug(f"Total Images: {num_images}, Total Captions: {len(positive)}")
+    logging.info(f"Total Images: {num_images}, Total Captions: {len(positive)}")
     if len(positive) == 1 and num_images > 1:
         return positive * num_images
     elif len(positive) != num_images:
@@ -602,8 +596,6 @@ def _create_weight_adapter(
     shape = module.weight.shape
     lora_params = {}
 
-    logging.debug(f"Creating weight adapter for {key} with shape {shape}")
-
     if len(shape) >= 2:
         alpha = float(existing_weights.get(f"{key}.alpha", 1.0))
         dora_scale = existing_weights.get(f"{key}.dora_scale", None)
@@ -698,61 +690,6 @@ def _setup_lora_adapters(mp, existing_weights, algorithm, lora_dtype, rank):
     return lora_sd, all_weight_adapters
 
 
-def _setup_lora_adapters_bypass(mp, existing_weights, algorithm, lora_dtype, rank):
-    """Setup LoRA adapters in bypass mode.
-
-    In bypass mode:
-        - Weight adapters (lora/lokr/oft) use bypass injection (forward hook)
-        - Bias/norm adapters (BiasDiff) still use weight wrapper (direct modification)
-
-    This is useful when the base model weights are quantized and cannot be
-    directly modified.
-
-    Args:
-        mp: Model patcher
-        existing_weights: Dict of existing LoRA weights
-        algorithm: Algorithm name for new adapters
-        lora_dtype: dtype for LoRA weights
-        rank: Rank for new LoRA adapters
-
-    Returns:
-        tuple: (lora_sd dict, all_weight_adapters list, bypass_manager)
-    """
-    lora_sd = {}
-    all_weight_adapters = []
-    bypass_manager = BypassInjectionManager()
-
-    for n, m in mp.model.named_modules():
-        if hasattr(m, "weight_function"):
-            if m.weight is not None:
-                adapter, params = _create_weight_adapter(
-                    m, n, existing_weights, algorithm, lora_dtype, rank
-                )
-                lora_sd.update(params)
-                all_weight_adapters.append(adapter)
-
-                key = f"{n}.weight"
-                # BiasDiff (for 1D weights like norm) uses weight wrapper, not bypass
-                # Only use bypass for adapters that have h() method (lora/lokr/oft)
-                if isinstance(adapter, BiasDiff):
-                    mp.add_weight_wrapper(key, adapter)
-                    logging.debug(f"[BypassMode] Added 1D weight adapter (weight wrapper) for {key}")
-                else:
-                    bypass_manager.add_adapter(key, adapter, strength=1.0)
-                    logging.debug(f"[BypassMode] Added weight adapter (bypass) for {key}")
-
-            if hasattr(m, "bias") and m.bias is not None:
-                # Bias adapters still use weight wrapper (bias is usually not quantized)
-                bias_adapter, bias_params = _create_bias_adapter(m, n, lora_dtype)
-                lora_sd.update(bias_params)
-                key = f"{n}.bias"
-                mp.add_weight_wrapper(key, bias_adapter)
-                all_weight_adapters.append(bias_adapter)
-                logging.debug(f"[BypassMode] Added bias adapter (weight wrapper) for {key}")
-
-    return lora_sd, all_weight_adapters, bypass_manager
-
-
 def _create_optimizer(optimizer_name, parameters, learning_rate):
     """Create optimizer based on name.
 
@@ -947,13 +884,11 @@ class TrainLoraNode(io.ComfyNode):
                     default=False,
                     tooltip="Enable resolution bucket mode. When enabled, expects pre-bucketed latents from ResolutionBucket node.",
                 ),
-                io.Boolean.Input(
-                    "bypass_mode",
-                    default=False,
-                    tooltip="Enable bypass mode for training. When enabled, adapters are applied via forward hooks instead of weight modification. Useful for quantized models where weights cannot be directly modified.",
-                ),
             ],
             outputs=[
+                io.Model.Output(
+                    display_name="model", tooltip="Model with LoRA applied"
+                ),
                 io.Custom("LORA_MODEL").Output(
                     display_name="lora", tooltip="LoRA weights"
                 ),
@@ -984,7 +919,6 @@ class TrainLoraNode(io.ComfyNode):
         gradient_checkpointing,
         existing_lora,
         bucket_mode,
-        bypass_mode,
     ):
         # Extract scalars from lists (due to is_input_list=True)
         model = model[0]
@@ -1002,7 +936,6 @@ class TrainLoraNode(io.ComfyNode):
         gradient_checkpointing = gradient_checkpointing[0]
         existing_lora = existing_lora[0]
         bucket_mode = bucket_mode[0]
-        bypass_mode = bypass_mode[0]
 
         # Process latents based on mode
         if bucket_mode:
@@ -1035,16 +968,9 @@ class TrainLoraNode(io.ComfyNode):
             existing_weights, existing_steps = _load_existing_lora(existing_lora)
 
             # Setup LoRA adapters
-            bypass_manager = None
-            if bypass_mode:
-                logging.debug("Using bypass mode for training")
-                lora_sd, all_weight_adapters, bypass_manager = _setup_lora_adapters_bypass(
-                    mp, existing_weights, algorithm, lora_dtype, rank
-                )
-            else:
-                lora_sd, all_weight_adapters = _setup_lora_adapters(
-                    mp, existing_weights, algorithm, lora_dtype, rank
-                )
+            lora_sd, all_weight_adapters = _setup_lora_adapters(
+                mp, existing_weights, algorithm, lora_dtype, rank
+            )
 
             # Create optimizer and loss function
             optimizer = _create_optimizer(
@@ -1103,14 +1029,6 @@ class TrainLoraNode(io.ComfyNode):
             guider = TrainGuider(mp)
             guider.set_conds(positive)
 
-            # Inject bypass hooks if bypass mode is enabled
-            bypass_injections = None
-            if bypass_manager is not None:
-                bypass_injections = bypass_manager.create_injections(mp.model)
-                for injection in bypass_injections:
-                    injection.inject(mp)
-                logging.debug(f"[BypassMode] Injected {bypass_manager.get_hook_count()} bypass hooks")
-
             # Run training loop
             try:
                 _run_training_loop(
@@ -1123,11 +1041,6 @@ class TrainLoraNode(io.ComfyNode):
                     multi_res,
                 )
             finally:
-                # Eject bypass hooks if they were injected
-                if bypass_injections is not None:
-                    for injection in bypass_injections:
-                        injection.eject(mp)
-                    logging.debug("[BypassMode] Ejected bypass hooks")
                 for m in mp.model.modules():
                     unpatch(m)
             del train_sampler, optimizer
@@ -1139,9 +1052,7 @@ class TrainLoraNode(io.ComfyNode):
             for param in lora_sd:
                 lora_sd[param] = lora_sd[param].to(lora_dtype)
 
-            # mp in train node is highly specialized for training
-            # use it in inference will result in bad behavior so we don't return it
-            return io.NodeOutput(lora_sd, loss_map, steps + existing_steps)
+            return io.NodeOutput(mp, lora_sd, loss_map, steps + existing_steps)
 
 
 class LoraModelLoader(io.ComfyNode):#

execution.py

@@ -175,7 +175,7 @@ def get_input_data(inputs, class_def, unique_id, execution_list=None, dynprompt=
                 continue
             obj = cached.outputs[output_index]
             input_data_all[x] = obj
-        elif input_category is not None or (is_v3 and class_def.ACCEPT_ALL_INPUTS):
+        elif input_category is not None:
             input_data_all[x] = [input_data]
 
     if is_v3:

nodes.py

@@ -2431,7 +2431,6 @@ async def init_builtin_extra_nodes():
         "nodes_wanmove.py",
         "nodes_image_compare.py",
         "nodes_zimage.py",
-        "nodes_lora_debug.py"
     ]
 
     import_failed = []