Merge 96e5287a72 into e9c311b245

* feat(api-nodes-bytedance): use the virtual portrait library for regular images

Signed-off-by: bigcat88 <bigcat88@icloud.com>

* fix: include shape in image dedup hash

Signed-off-by: bigcat88 <bigcat88@icloud.com>

---------

Signed-off-by: bigcat88 <bigcat88@icloud.com>

comfy/lora.py

@@ -342,6 +342,12 @@ def model_lora_keys_unet(model, key_map={}):
                 key_map["base_model.model.{}".format(key_lora)] = k  # Official base model loras
                 key_map["lycoris_{}".format(key_lora.replace(".", "_"))] = k  # LyCORIS/LoKR format
 
+    if isinstance(model, comfy.model_base.ErnieImage):
+        for k in sdk:
+            if k.startswith("diffusion_model.") and k.endswith(".weight"):
+                key_lora = k[len("diffusion_model."):-len(".weight")]
+                key_map["transformer.{}".format(key_lora)] = k
+
     return key_map
 
 

comfy/ops.py

@@ -1011,6 +1011,51 @@ def mixed_precision_ops(quant_config={}, compute_dtype=torch.bfloat16, full_prec
                             orig_dtype=MixedPrecisionOps._compute_dtype,
                             orig_shape=(self.out_features, self.in_features),
                         )
+                    elif self.quant_format == "svdquant_w4a4":
+                        # SVDQuant W4A4: per-group weight scales + low-rank correction
+                        # (proj_down, proj_up) + activation smoothing (smooth_factor)
+                        wscales = self._load_scale_param(state_dict, prefix, "weight_scale", device, manually_loaded_keys)
+                        proj_down = self._load_scale_param(state_dict, prefix, "proj_down", device, manually_loaded_keys)
+                        proj_up = self._load_scale_param(state_dict, prefix, "proj_up", device, manually_loaded_keys)
+                        smooth_factor = self._load_scale_param(state_dict, prefix, "smooth_factor", device, manually_loaded_keys)
+                        act_unsigned = bool(layer_conf.get("act_unsigned", False))
+
+                        # Early Qwen-Image conversion artifacts did not persist the
+                        # fused GELU -> fc2 unsigned-activation flag. Those layers
+                        # are the second linear in the feed-forward block.
+                        if not act_unsigned and (
+                            layer_name.endswith(".img_mlp.net.2") or layer_name.endswith(".txt_mlp.net.2")
+                        ):
+                            act_unsigned = True
+
+                        if any(t is None for t in (wscales, proj_down, proj_up, smooth_factor)):
+                            raise ValueError(f"Missing SVDQuant W4A4 parameters for layer {layer_name}")
+
+                        params = layout_cls.Params(
+                            scale=wscales,
+                            orig_dtype=MixedPrecisionOps._compute_dtype,
+                            orig_shape=(self.out_features, self.in_features),
+                            proj_down=proj_down,
+                            proj_up=proj_up,
+                            smooth_factor=smooth_factor,
+                            act_unsigned=act_unsigned,
+                        )
+                    elif self.quant_format == "awq_w4a16":
+                        # AWQ W4A16: int4 weight, fp16/bf16 activation. Used for
+                        # the modulation linears (img_mod.1 / txt_mod.1) so they
+                        # stay int4 in checkpoint + VRAM rather than getting
+                        # dequantized to bf16 at conversion time (~10 GB saving).
+                        wscales = self._load_scale_param(state_dict, prefix, "weight_scale", device, manually_loaded_keys)
+                        wzeros = self._load_scale_param(state_dict, prefix, "weight_zero", device, manually_loaded_keys)
+                        if wscales is None or wzeros is None:
+                            raise ValueError(f"Missing AWQ W4A16 parameters for layer {layer_name}")
+                        params = layout_cls.Params(
+                            scale=wscales,
+                            zeros=wzeros,
+                            group_size=int(layer_conf.get("group_size", qconfig.get("group_size", 64))),
+                            orig_dtype=MixedPrecisionOps._compute_dtype,
+                            orig_shape=(self.out_features, self.in_features),
+                        )
                     else:
                         raise ValueError(f"Unsupported quantization format: {self.quant_format}")
 
@@ -1060,6 +1105,8 @@ def mixed_precision_ops(quant_config={}, compute_dtype=torch.bfloat16, full_prec
                     quant_conf = {"format": self.quant_format}
                     if self._full_precision_mm_config:
                         quant_conf["full_precision_matrix_mult"] = True
+                    if bool(getattr(getattr(self.weight, "_params", None), "act_unsigned", False)):
+                        quant_conf["act_unsigned"] = True
                     sd["{}comfy_quant".format(prefix)] = torch.tensor(list(json.dumps(quant_conf).encode('utf-8')), dtype=torch.uint8)
 
                     input_scale = getattr(self, 'input_scale', None)
@@ -1117,18 +1164,24 @@ def mixed_precision_ops(quant_config={}, compute_dtype=torch.bfloat16, full_prec
 
                 # Inference path (unchanged)
                 if _use_quantized:
+                    # Some layouts (e.g. SVDQuant W4A4) do activation quantization
+                    # inside their fused kernel and cannot pre-quantize a float
+                    # tensor up-front. Skip the input wrapping for those.
+                    layout_cls = get_layout_class(self.layout_type)
+                    layout_quantizes_input = getattr(layout_cls, "QUANTIZES_INPUT", True)
 
-                    # Reshape 3D tensors to 2D for quantization (needed for NVFP4 and others)
-                    input_reshaped = input.reshape(-1, input_shape[2]) if input.ndim == 3 else input
+                    if layout_quantizes_input:
+                        # Reshape 3D tensors to 2D for quantization (needed for NVFP4 and others)
+                        input_reshaped = input.reshape(-1, input_shape[2]) if input.ndim == 3 else input
 
-                    # Fall back to non-quantized for non-2D tensors
-                    if input_reshaped.ndim == 2:
-                        reshaped_3d = input.ndim == 3
-                        # dtype is now implicit in the layout class
-                        scale = getattr(self, 'input_scale', None)
-                        if scale is not None:
-                            scale = comfy.model_management.cast_to_device(scale, input.device, None)
-                        input = QuantizedTensor.from_float(input_reshaped, self.layout_type, scale=scale)
+                        # Fall back to non-quantized for non-2D tensors
+                        if input_reshaped.ndim == 2:
+                            reshaped_3d = input.ndim == 3
+                            # dtype is now implicit in the layout class
+                            scale = getattr(self, 'input_scale', None)
+                            if scale is not None:
+                                scale = comfy.model_management.cast_to_device(scale, input.device, None)
+                            input = QuantizedTensor.from_float(input_reshaped, self.layout_type, scale=scale)
 
                 output = self.forward_comfy_cast_weights(input, compute_dtype, want_requant=isinstance(input, QuantizedTensor))
 

comfy/quant_ops.py

@@ -37,6 +37,12 @@ except ImportError as e:
     class _CKNvfp4Layout:
         pass
 
+    class _CKSVDQuantW4A4Layout:
+        pass
+
+    class _CKAWQW4A16Layout:
+        pass
+
     def register_layout_class(name, cls):
         pass
 
@@ -55,6 +61,26 @@ if not _CK_MXFP8_AVAILABLE:
     class _CKMxfp8Layout:
         pass
 
+_CK_SVDQUANT_W4A4_AVAILABLE = False
+if _CK_AVAILABLE:
+    try:
+        from comfy_kitchen.tensor import TensorCoreSVDQuantW4A4Layout as _CKSVDQuantW4A4Layout
+        _CK_SVDQUANT_W4A4_AVAILABLE = True
+    except ImportError:
+        logging.info("comfy_kitchen does not expose SVDQuant W4A4 layout; int4 SVDQuant checkpoints will not be supported.")
+        class _CKSVDQuantW4A4Layout:
+            pass
+
+_CK_AWQ_W4A16_AVAILABLE = False
+if _CK_AVAILABLE:
+    try:
+        from comfy_kitchen.tensor import TensorCoreAWQW4A16Layout as _CKAWQW4A16Layout
+        _CK_AWQ_W4A16_AVAILABLE = True
+    except ImportError:
+        logging.info("comfy_kitchen does not expose AWQ W4A16 layout; int4 AWQ modulation checkpoints will fall back to bf16-dequantized layers.")
+        class _CKAWQW4A16Layout:
+            pass
+
 import comfy.float
 
 # ==============================================================================
@@ -162,6 +188,21 @@ class TensorCoreFP8E5M2Layout(_TensorCoreFP8LayoutBase):
     FP8_DTYPE = torch.float8_e5m2
 
 
+# SVDQuant W4A4 — pre-quantized offline (no runtime quantize), pass through the
+# kitchen-registered layout class unchanged. Comfy-side extension reserved in
+# case per-layer input scales or other Comfy-specific metadata are added later.
+class TensorCoreSVDQuantW4A4Layout(_CKSVDQuantW4A4Layout):
+    pass
+
+
+# AWQ W4A16 — pre-quantized offline (no runtime quantize) via the kitchen
+# eager `gemv_awq_w4a16` op. Used for modulation linears (img_mod.1 /
+# txt_mod.1) on Qwen-Image-Edit and similar topologies where keeping the
+# weight at int4 saves ~10 GB of VRAM vs the bf16-dequantized fallback.
+class TensorCoreAWQW4A16Layout(_CKAWQW4A16Layout):
+    pass
+
+
 # Backward compatibility alias - default to E4M3
 TensorCoreFP8Layout = TensorCoreFP8E4M3Layout
 
@@ -176,6 +217,10 @@ register_layout_class("TensorCoreFP8E5M2Layout", TensorCoreFP8E5M2Layout)
 register_layout_class("TensorCoreNVFP4Layout", TensorCoreNVFP4Layout)
 if _CK_MXFP8_AVAILABLE:
     register_layout_class("TensorCoreMXFP8Layout", TensorCoreMXFP8Layout)
+if _CK_SVDQUANT_W4A4_AVAILABLE:
+    register_layout_class("TensorCoreSVDQuantW4A4Layout", TensorCoreSVDQuantW4A4Layout)
+if _CK_AWQ_W4A16_AVAILABLE:
+    register_layout_class("TensorCoreAWQW4A16Layout", TensorCoreAWQW4A16Layout)
 
 QUANT_ALGOS = {
     "float8_e4m3fn": {
@@ -204,6 +249,22 @@ if _CK_MXFP8_AVAILABLE:
         "group_size": 32,
     }
 
+if _CK_SVDQUANT_W4A4_AVAILABLE:
+    QUANT_ALGOS["svdquant_w4a4"] = {
+        "storage_t": torch.int8,
+        "parameters": {"weight_scale", "proj_down", "proj_up", "smooth_factor"},
+        "comfy_tensor_layout": "TensorCoreSVDQuantW4A4Layout",
+        "group_size": 64,
+    }
+
+if _CK_AWQ_W4A16_AVAILABLE:
+    QUANT_ALGOS["awq_w4a16"] = {
+        "storage_t": torch.int8,
+        "parameters": {"weight_scale", "weight_zero"},
+        "comfy_tensor_layout": "TensorCoreAWQW4A16Layout",
+        "group_size": 64,
+    }
+
 
 # ==============================================================================
 # Re-exports for backward compatibility
@@ -212,10 +273,12 @@ if _CK_MXFP8_AVAILABLE:
 __all__ = [
     "QuantizedTensor",
     "QuantizedLayout",
+    "TensorCoreAWQW4A16Layout",
     "TensorCoreFP8Layout",
     "TensorCoreFP8E4M3Layout",
     "TensorCoreFP8E5M2Layout",
     "TensorCoreNVFP4Layout",
+    "TensorCoreSVDQuantW4A4Layout",
     "QUANT_ALGOS",
     "register_layout_op",
 ]

comfy_api/latest/_input_impl/video_types.py

@@ -290,7 +290,7 @@ class VideoFromFile(VideoInput):
                                     alphas = []
                                     alpha_channel = True
                                     break
-                            if frame.format.name in ("yuvj420p", "rgb24", "rgba", "pal8"):
+                            if frame.format.name in ("yuvj420p", "yuvj422p", "yuvj444p", "rgb24", "rgba", "pal8"):
                                 process_image_format = lambda a: a.float() / 255.0
                                 if alpha_channel:
                                     image_format = 'rgba'

comfy_api_nodes/apis/bytedance.py

@@ -157,6 +157,11 @@ class SeedanceCreateAssetResponse(BaseModel):
     asset_id: str = Field(...)
 
 
+class SeedanceVirtualLibraryCreateAssetRequest(BaseModel):
+    url: str = Field(..., description="Publicly accessible URL of the image asset to upload.")
+    hash: str = Field(..., description="Dedup key. Re-submitting the same hash returns the existing asset id.")
+
+
 # Dollars per 1K tokens, keyed by (model_id, has_video_input).
 SEEDANCE2_PRICE_PER_1K_TOKENS = {
     ("dreamina-seedance-2-0-260128", False): 0.007,

comfy_api_nodes/nodes_bytedance.py

@@ -1,3 +1,4 @@
+import hashlib
 import logging
 import math
 import re
@@ -20,6 +21,7 @@ from comfy_api_nodes.apis.bytedance import (
     SeedanceCreateAssetResponse,
     SeedanceCreateVisualValidateSessionResponse,
     SeedanceGetVisualValidateSessionResponse,
+    SeedanceVirtualLibraryCreateAssetRequest,
     Seedream4Options,
     Seedream4TaskCreationRequest,
     TaskAudioContent,
@@ -271,6 +273,30 @@ async def _wait_for_asset_active(cls: type[IO.ComfyNode], asset_id: str, group_i
     )
 
 
+async def _seedance_virtual_library_upload_image_asset(
+    cls: type[IO.ComfyNode],
+    image: torch.Tensor,
+    *,
+    wait_label: str = "Uploading image",
+) -> str:
+    """Upload an image into the caller's per-customer Seedance virtual library."""
+    public_url = await upload_image_to_comfyapi(cls, image, wait_label=wait_label)
+    normalized = image.detach().cpu().contiguous().to(torch.float32)
+    digest = hashlib.sha256()
+    digest.update(str(tuple(normalized.shape)).encode("utf-8"))
+    digest.update(b"\0")
+    digest.update(normalized.numpy().tobytes())
+    image_hash = digest.hexdigest()
+    create_resp = await sync_op(
+        cls,
+        ApiEndpoint(path="/proxy/seedance/virtual-library/assets", method="POST"),
+        response_model=SeedanceCreateAssetResponse,
+        data=SeedanceVirtualLibraryCreateAssetRequest(url=public_url, hash=image_hash),
+    )
+    await _wait_for_asset_active(cls, create_resp.asset_id, group_id="virtual-library")
+    return f"asset://{create_resp.asset_id}"
+
+
 def _seedance2_price_extractor(model_id: str, has_video_input: bool):
     """Returns a price_extractor closure for Seedance 2.0 poll_op."""
     rate = SEEDANCE2_PRICE_PER_1K_TOKENS.get((model_id, has_video_input))
@@ -1507,7 +1533,9 @@ class ByteDance2FirstLastFrameNode(IO.ComfyNode):
         if first_frame_asset_id:
             first_frame_url = image_assets[first_frame_asset_id]
         else:
-            first_frame_url = await upload_image_to_comfyapi(cls, first_frame, wait_label="Uploading first frame.")
+            first_frame_url = await _seedance_virtual_library_upload_image_asset(
+                cls, first_frame, wait_label="Uploading first frame."
+            )
 
         content: list[TaskTextContent | TaskImageContent] = [
             TaskTextContent(text=model["prompt"]),
@@ -1527,7 +1555,9 @@ class ByteDance2FirstLastFrameNode(IO.ComfyNode):
             content.append(
                 TaskImageContent(
                     image_url=TaskImageContentUrl(
-                        url=await upload_image_to_comfyapi(cls, last_frame, wait_label="Uploading last frame.")
+                        url=await _seedance_virtual_library_upload_image_asset(
+                            cls, last_frame, wait_label="Uploading last frame."
+                        )
                     ),
                     role="last_frame",
                 ),
@@ -1805,9 +1835,9 @@ class ByteDance2ReferenceNode(IO.ComfyNode):
             content.append(
                 TaskImageContent(
                     image_url=TaskImageContentUrl(
-                        url=await upload_image_to_comfyapi(
+                        url=await _seedance_virtual_library_upload_image_asset(
                             cls,
-                            image=reference_images[key],
+                            reference_images[key],
                             wait_label=f"Uploading image {i}",
                         ),
                     ),

comfy_api_nodes/nodes_openai.py

@@ -415,8 +415,9 @@ class OpenAIGPTImage1(IO.ComfyNode):
                         "1152x2048",
                         "3840x2160",
                         "2160x3840",
+                        "Custom",
                     ],
-                    tooltip="Image size",
+                    tooltip="Image size. Select 'Custom' to use the custom width and height (GPT Image 2 only).",
                     optional=True,
                 ),
                 IO.Int.Input(
@@ -445,6 +446,26 @@ class OpenAIGPTImage1(IO.ComfyNode):
                     default="gpt-image-2",
                     optional=True,
                 ),
+                IO.Int.Input(
+                    "custom_width",
+                    default=1024,
+                    min=1024,
+                    max=3840,
+                    step=16,
+                    tooltip="Used only when `size` is 'Custom'. Must be a multiple of 16 (GPT Image 2 only).",
+                    optional=True,
+                    advanced=True,
+                ),
+                IO.Int.Input(
+                    "custom_height",
+                    default=1024,
+                    min=1024,
+                    max=3840,
+                    step=16,
+                    tooltip="Used only when `size` is 'Custom'. Must be a multiple of 16 (GPT Image 2 only).",
+                    optional=True,
+                    advanced=True,
+                ),
             ],
             outputs=[
                 IO.Image.Output(),
@@ -471,9 +492,9 @@ class OpenAIGPTImage1(IO.ComfyNode):
                       "high":   [0.133, 0.22]
                     },
                     "gpt-image-2": {
-                      "low":    [0.0048, 0.012],
-                      "medium": [0.041, 0.112],
-                      "high":   [0.165, 0.43]
+                      "low":    [0.0048, 0.019],
+                      "medium": [0.041, 0.168],
+                      "high":   [0.165, 0.67]
                     }
                   };
                   $range := $lookup($lookup($ranges, widgets.model), widgets.quality);
@@ -503,6 +524,8 @@ class OpenAIGPTImage1(IO.ComfyNode):
         mask: Input.Image | None = None,
         n: int = 1,
         size: str = "1024x1024",
+        custom_width: int = 1024,
+        custom_height: int = 1024,
         model: str = "gpt-image-1",
     ) -> IO.NodeOutput:
         validate_string(prompt, strip_whitespace=False)
@@ -510,7 +533,25 @@ class OpenAIGPTImage1(IO.ComfyNode):
         if mask is not None and image is None:
             raise ValueError("Cannot use a mask without an input image")
 
-        if model in ("gpt-image-1", "gpt-image-1.5"):
+        if size == "Custom":
+            if model != "gpt-image-2":
+                raise ValueError("Custom resolution is only supported by GPT Image 2 model")
+            if custom_width % 16 != 0 or custom_height % 16 != 0:
+                raise ValueError(f"Custom width and height must be multiples of 16, got {custom_width}x{custom_height}")
+            if max(custom_width, custom_height) > 3840:
+                raise ValueError(f"Custom resolution max edge must be <= 3840, got {custom_width}x{custom_height}")
+            ratio = max(custom_width, custom_height) / min(custom_width, custom_height)
+            if ratio > 3:
+                raise ValueError(
+                    f"Custom resolution aspect ratio must not exceed 3:1, got {custom_width}x{custom_height}"
+                )
+            total_pixels = custom_width * custom_height
+            if not 655_360 <= total_pixels <= 8_294_400:
+                raise ValueError(
+                    f"Custom resolution total pixels must be between 655,360 and 8,294,400, got {total_pixels}"
+                )
+            size = f"{custom_width}x{custom_height}"
+        elif model in ("gpt-image-1", "gpt-image-1.5"):
             if size not in ("auto", "1024x1024", "1024x1536", "1536x1024"):
                 raise ValueError(f"Resolution {size} is only supported by GPT Image 2 model")