Add tiled MiniMax H3 latent upscale node

This commit is contained in:
2026-10-13 15:50:59 +00:00
parent cfdad89f3e
commit 09a340e8f3
4 changed files with 284 additions and 0 deletions
+26
View File
@@ -30,6 +30,32 @@ or accept a re-encoded workflow.
## Project rendering
## MiniMax-H3 tiled latent upscale
`DumasMMH3TiledLatentUpscale` is a thin integration node for the native
`MMH3UltimateUpscale` node used by the MiniMax-H3 workflow. It accepts the
native H3 latent-upscale, temporal-split, and spatial-split parameter objects,
but creates a separate upscale sampler, scheduler, sigma schedule, noise seed,
denoise value, steps value, and CFG value. The base H3 sampling pass is not
changed.
Typical wiring:
```text
base H3 latent + model + conditioning
-> Dumas MiniMax-H3 Tiled Latent Upscale
H3 Latent Upscale Params --------------------^
H3 Temporal Split Params ---------------------^
H3 Spatial Split Params -----------------------^
```
The node requires the ComfyUI installation to provide `MMH3UltimateUpscale`,
`RandomNoise`, `KSamplerSelect`, and `BasicScheduler`. It does not copy or
redistribute the third-party H3 LongVideos implementation. The native node's
current socket types are `H3_UPSCALE_PARAM`, `H3_TEMPORAL_PARAM`, and
`H3_SPATIAL_PARAM`; these are deliberately used unchanged for workflow
compatibility.
The CSGlide `Render Project` control is the generation orchestrator: it renders
clips sequentially, adopts each completed render, extracts the previous clip's
tail, fills the next clip's `CONTINUE FROM` guide, and waits before advancing.
+6
View File
@@ -14,16 +14,22 @@ from .dumas_video_nodes import (
NODE_CLASS_MAPPINGS as VIDEO_NODE_CLASS_MAPPINGS,
NODE_DISPLAY_NAME_MAPPINGS as VIDEO_NODE_DISPLAY_NAME_MAPPINGS,
)
from .dumas_minimax_nodes import (
NODE_CLASS_MAPPINGS as MINIMAX_NODE_CLASS_MAPPINGS,
NODE_DISPLAY_NAME_MAPPINGS as MINIMAX_NODE_DISPLAY_NAME_MAPPINGS,
)
NODE_CLASS_MAPPINGS = {}
NODE_CLASS_MAPPINGS.update(JSON_NODE_CLASS_MAPPINGS)
NODE_CLASS_MAPPINGS.update(IMAGE_NODE_CLASS_MAPPINGS)
NODE_CLASS_MAPPINGS.update(VIDEO_NODE_CLASS_MAPPINGS)
NODE_CLASS_MAPPINGS.update(MINIMAX_NODE_CLASS_MAPPINGS)
NODE_DISPLAY_NAME_MAPPINGS = {}
NODE_DISPLAY_NAME_MAPPINGS.update(JSON_NODE_DISPLAY_NAME_MAPPINGS)
NODE_DISPLAY_NAME_MAPPINGS.update(IMAGE_NODE_DISPLAY_NAME_MAPPINGS)
NODE_DISPLAY_NAME_MAPPINGS.update(VIDEO_NODE_DISPLAY_NAME_MAPPINGS)
NODE_DISPLAY_NAME_MAPPINGS.update(MINIMAX_NODE_DISPLAY_NAME_MAPPINGS)
WEB_DIRECTORY = "./js"
+150
View File
@@ -0,0 +1,150 @@
"""Dumas MiniMax-H3 helpers.
This module intentionally does not vendor the third-party H3 LongVideos node.
It provides the missing tiled latent second pass around the native
``MMH3UltimateUpscale`` node that is already used by the user's H3 workflow.
The node keeps its own sampling controls, so changing the upscale pass cannot
silently change the base H3 render.
"""
def _sampler_options():
try:
import comfy.samplers
return list(comfy.samplers.KSampler.SAMPLERS)
except Exception: # import-time test fallback
return ["euler", "euler_ancestral", "res_multistep", "sa_solver"]
def _scheduler_options():
try:
import comfy.samplers
return list(comfy.samplers.KSampler.SCHEDULERS)
except Exception: # import-time test fallback
return ["simple", "beta", "sgm_uniform", "karras", "exponential"]
def _native_node(name):
try:
import nodes
mapping = getattr(nodes, "NODE_CLASS_MAPPINGS", {}) or {}
cls = mapping.get(name)
if cls is not None:
return cls
except Exception:
pass
return None
class DumasMMH3TiledLatentUpscale:
"""Run a tiled MiniMax-H3 latent upscale/refinement pass.
The incoming latent is normally the output of the base H3 sampler. The
native MMH3 upscale node performs the actual model-specific tiled work;
this wrapper creates its noise, sampler and sigma schedule from its own
widgets and passes through the user's spatial split parameter object.
"""
@classmethod
def INPUT_TYPES(cls):
return {
"required": {
"model": ("MODEL",),
"conditioning": ("CONDITIONING",),
"latent": ("LATENT",),
"latent_upscale_param": ("H3_UPSCALE_PARAM",),
"spatial_split_param": ("H3_SPATIAL_PARAM",),
"upscale_sampler": (_sampler_options(), {"default": "euler_ancestral"}),
"upscale_scheduler": (_scheduler_options(), {"default": "simple"}),
"upscale_steps": ("INT", {"default": 3, "min": 1, "max": 50}),
"upscale_denoise": ("FLOAT", {"default": 0.2, "min": 0.0, "max": 1.0, "step": 0.01}),
"upscale_cfg": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 20.0, "step": 0.1}),
"upscale_noise_seed": ("INT", {"default": 363742558835919, "min": 0, "max": 0xffffffffffffffff, "control_after_generate": True}),
},
"optional": {
"negative": ("CONDITIONING",),
"temporal_split_param": ("H3_TEMPORAL_PARAM",),
"upscale_sigmas": ("SIGMAS",),
},
}
RETURN_TYPES = ("LATENT", "STRING")
RETURN_NAMES = ("upscaled_latent", "info")
FUNCTION = "upscale"
CATEGORY = "Dumas/MiniMax"
def upscale(
self, model, conditioning, latent, latent_upscale_param,
spatial_split_param, upscale_sampler, upscale_scheduler,
upscale_steps, upscale_denoise, upscale_cfg, upscale_noise_seed,
negative=None, temporal_split_param=None, upscale_sigmas=None,
):
native = _native_node("MMH3UltimateUpscale")
if native is None:
raise RuntimeError(
"MMH3UltimateUpscale is not installed. Install/update the MiniMax-H3 "
"node pack that provides the native tiled upscale node."
)
random_noise = _native_node("RandomNoise")
sampler_select = _native_node("KSamplerSelect")
scheduler = _native_node("BasicScheduler")
missing = [
name for name, value in (("RandomNoise", random_noise),
("KSamplerSelect", sampler_select),
("BasicScheduler", scheduler))
if value is None
]
if missing:
raise RuntimeError("Missing native ComfyUI nodes: " + ", ".join(missing))
noise = random_noise().get_noise(int(upscale_noise_seed))
sampler = sampler_select().get_sampler(str(upscale_sampler))
sigmas = upscale_sigmas
if sigmas is None:
sigmas = scheduler().get_sigmas(
model, str(upscale_scheduler), int(upscale_steps), float(upscale_denoise)
)
kwargs = {
"model": model,
"conditioning": conditioning,
"latent": latent,
"noise": noise,
"sampler": sampler,
"sigmas": sigmas,
"cfg": float(upscale_cfg),
"latent_upscale_param": latent_upscale_param,
"temporal_split_param": temporal_split_param,
"spatial_split_param": spatial_split_param,
}
if negative is not None:
kwargs["negative"] = negative
result = native().upscale(**kwargs)
if not isinstance(result, (tuple, list)) or not result:
raise RuntimeError("MMH3UltimateUpscale returned no latent output.")
output = result[0]
if not isinstance(output, dict) or "samples" not in output:
raise RuntimeError("MMH3UltimateUpscale returned an unexpected latent object.")
samples = output["samples"]
if samples.ndim != 5:
raise RuntimeError(f"Expected a 5-D H3 latent, got shape {tuple(samples.shape)}.")
if samples.shape[2] != latent["samples"].shape[2]:
raise RuntimeError("Tiled spatial upscale changed the temporal latent length.")
info = (
"Dumas tiled MiniMax-H3 latent upscale: "
f"sampler={upscale_sampler}, scheduler={upscale_scheduler}, "
f"steps={int(upscale_steps)}, denoise={float(upscale_denoise):g}, "
f"cfg={float(upscale_cfg):g}, noise_seed={int(upscale_noise_seed)}; "
"spatial split supplied by MMH3SpatialSplitParams"
)
return output, info
NODE_CLASS_MAPPINGS = {
"DumasMMH3TiledLatentUpscale": DumasMMH3TiledLatentUpscale,
}
NODE_DISPLAY_NAME_MAPPINGS = {
"DumasMMH3TiledLatentUpscale": "Dumas MiniMax-H3 Tiled Latent Upscale",
}
+102
View File
@@ -0,0 +1,102 @@
import importlib.util
import sys
import types
import unittest
class DumasMiniMaxNodeTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
comfy = types.ModuleType("comfy")
samplers = types.ModuleType("comfy.samplers")
samplers.KSampler = types.SimpleNamespace(
SAMPLERS=["euler", "euler_ancestral"],
SCHEDULERS=["simple", "beta"],
)
comfy.samplers = samplers
sys.modules.setdefault("comfy", comfy)
sys.modules.setdefault("comfy.samplers", samplers)
spec = importlib.util.spec_from_file_location("dumas_minimax_nodes", "dumas_minimax_nodes.py")
cls.module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(cls.module)
def test_registers_tiled_upscale_node(self):
self.assertEqual(set(self.module.NODE_CLASS_MAPPINGS), {"DumasMMH3TiledLatentUpscale"})
def test_exposes_independent_upscale_controls_and_param_inputs(self):
inputs = self.module.DumasMMH3TiledLatentUpscale.INPUT_TYPES()
required = inputs["required"]
self.assertEqual(required["latent_upscale_param"][0], "H3_UPSCALE_PARAM")
self.assertEqual(required["spatial_split_param"][0], "H3_SPATIAL_PARAM")
self.assertEqual(required["upscale_steps"][1]["default"], 3)
self.assertIn("upscale_noise_seed", required)
self.assertEqual(inputs["optional"]["temporal_split_param"][0], "H3_TEMPORAL_PARAM")
self.assertIn("upscale_sigmas", inputs["optional"])
def test_missing_native_node_is_reported(self):
original = self.module._native_node
self.module._native_node = lambda name: None
try:
with self.assertRaisesRegex(RuntimeError, "MMH3UltimateUpscale"):
self.module.DumasMMH3TiledLatentUpscale().upscale(
object(), object(), {"samples": object()}, {}, {},
"euler_ancestral", "simple", 3, 0.2, 1.0, 1,
)
finally:
self.module._native_node = original
def test_calls_native_upscale_with_tiled_params_and_own_schedule(self):
calls = {}
class Noise:
def get_noise(self, seed):
calls["seed"] = seed
return "noise"
class Sampler:
def get_sampler(self, name):
calls["sampler"] = name
return "sampler"
class Scheduler:
def get_sigmas(self, model, name, steps, denoise):
calls["schedule"] = (name, steps, denoise)
return "sigmas"
class Native:
def upscale(self, **kwargs):
calls["kwargs"] = kwargs
return ({"samples": FakeTensor((1, 24, 9, 48, 72))}, {}, {})
class FakeTensor:
def __init__(self, shape):
self.shape = shape
self.ndim = len(shape)
original = self.module._native_node
mapping = {
"MMH3UltimateUpscale": Native,
"RandomNoise": Noise,
"KSamplerSelect": Sampler,
"BasicScheduler": Scheduler,
}
self.module._native_node = lambda name: mapping[name]
try:
latent = {"samples": FakeTensor((1, 24, 9, 24, 36))}
result, info = self.module.DumasMMH3TiledLatentUpscale().upscale(
"model", "conditioning", latent, "upscale", "spatial",
"euler_ancestral", "simple", 3, 0.2, 1.0, 123,
temporal_split_param="temporal",
)
self.assertEqual(result["samples"].shape[2], 9)
self.assertEqual(calls["seed"], 123)
self.assertEqual(calls["schedule"], ("simple", 3, 0.2))
self.assertEqual(calls["kwargs"]["spatial_split_param"], "spatial")
self.assertEqual(calls["kwargs"]["temporal_split_param"], "temporal")
self.assertIn("Dumas tiled MiniMax-H3", info)
finally:
self.module._native_node = original
if __name__ == "__main__":
unittest.main()