Use target dimensions for 2D H3 upscale

This commit is contained in:
2026-11-12 09:10:38 +00:00
parent 100f17d356
commit 8c0d0cf6e3
3 changed files with 28 additions and 18 deletions
+3 -2
View File
@@ -92,8 +92,9 @@ checkpoint from [LBH-123-AI](https://huggingface.co/LBH-123-AI/Minimax_h3_latent
It uses the model's published loader and architecture, but keeps DUMAS ownership
of the node and adds X/Y tiling. The full temporal latent is passed through each
tile; temporal splitting is intentionally not used. Put the checkpoint in
`models/latent_upscale_models`, then set `tile_size` and `tile_overlap` to fit
available VRAM.
`models/latent_upscale_models`, then set the target `width` and `height` in
pixels. The dimensions are converted to H3 latent dimensions internally. Set
`tile_size` and `tile_overlap` to fit available VRAM.
`DumasMMH3LatentUpscale2DModelParams` is the matching parameter node. Its output
is `latent_upscale_param` with type `H3_UPSCALE_PARAM`, so it connects to the
+23 -15
View File
@@ -29,7 +29,8 @@ class DumasMMH3LatentUpscale2DModelParams:
"model_name": (names or ["(place model in models/latent_upscale_models)"],),
"device": (["cuda", "rocm", "cpu"], {"default": "cuda"}),
"precision": (["fp32", "fp16", "bf16"], {"default": "fp16"}),
"scale": ("FLOAT", {"default": 2.0, "min": 1.0, "max": 4.0, "step": 0.05}),
"width": ("INT", {"default": 1280, "min": 16, "max": 16384, "step": 16}),
"height": ("INT", {"default": 704, "min": 16, "max": 16384, "step": 16}),
"tile_size": ("INT", {"default": 64, "min": 8, "max": 1024, "step": 8}),
"tile_overlap": ("INT", {"default": 8, "min": 0, "max": 128, "step": 1}),
"sharpness": ("INT", {"default": 1, "min": 1, "max": 6, "step": 1}),
@@ -40,7 +41,7 @@ class DumasMMH3LatentUpscale2DModelParams:
FUNCTION = "build"
CATEGORY = "Dumas/MiniMax H3/Upscale"
def build(self, model_name, device, precision, scale, tile_size, tile_overlap, sharpness):
def build(self, model_name, device, precision, width, height, tile_size, tile_overlap, sharpness):
if str(model_name).startswith("("):
raise ValueError("Place the 2D H3 model in models/latent_upscale_models")
return ({
@@ -48,7 +49,8 @@ class DumasMMH3LatentUpscale2DModelParams:
"model_name": str(model_name),
"device": str(device),
"precision": str(precision),
"scale": float(scale),
"target_width": int(width),
"target_height": int(height),
"tile_size": int(tile_size),
"tile_overlap": int(tile_overlap),
"sharpness": int(sharpness),
@@ -70,7 +72,8 @@ class DumasMMH3LatentUpscale2D:
"required": {
"latent": ("LATENT",),
"model_name": (names or ["(place model in models/latent_upscale_models)"],),
"scale": ("FLOAT", {"default": 2.0, "min": 1.0, "max": 4.0, "step": 0.05}),
"width": ("INT", {"default": 1280, "min": 16, "max": 16384, "step": 16}),
"height": ("INT", {"default": 704, "min": 16, "max": 16384, "step": 16}),
"tile_size": ("INT", {"default": 64, "min": 8, "max": 1024, "step": 8}),
"tile_overlap": ("INT", {"default": 8, "min": 0, "max": 128, "step": 1}),
"sharpness": ("INT", {"default": 1, "min": 1, "max": 6, "step": 1}),
@@ -94,7 +97,7 @@ class DumasMMH3LatentUpscale2D:
starts.append(max(0, length - tile))
return [(start, min(length, start + tile)) for start in sorted(set(starts))]
def upscale(self, latent, model_name, scale, tile_size, tile_overlap, sharpness,
def upscale(self, latent, model_name, width, height, tile_size, tile_overlap, sharpness,
device, precision):
import torch
@@ -114,9 +117,13 @@ class DumasMMH3LatentUpscale2D:
mean, std = module._make_norm_tensors(dev, compute_dtype)
src = source.to(device=dev, dtype=compute_dtype, copy=True)
b, c, t, h, w = src.shape
out_h, out_w = int(round(h * float(scale))), int(round(w * float(scale)))
if int(width) % 16 or int(height) % 16:
raise ValueError("Target width and height must be divisible by 16")
out_w, out_h = int(width) // 16, int(height) // 16
if out_h < h or out_w < w:
raise ValueError("Target dimensions must be at least as large as the input")
if out_h == h and out_w == w:
return latent, "DUMAS H3 2D upscale skipped: scale is 1"
return latent, "DUMAS H3 2D upscale skipped: target dimensions equal input"
result = torch.zeros((b, c, t, out_h, out_w), device=dev, dtype=compute_dtype)
weights = torch.zeros((1, 1, 1, out_h, out_w), device=dev, dtype=compute_dtype)
@@ -129,16 +136,17 @@ class DumasMMH3LatentUpscale2D:
xi0, xi1 = max(0, x0 - tile_overlap), min(w, x1 + tile_overlap)
tile = (src[:, :, :, yi0:yi1, xi0:xi1] - mean) / std
tile_out = model(
tile, scale=float(scale),
target_hw=(int(round((yi1 - yi0) * scale)),
int(round((xi1 - xi0) * scale))),
tile, scale=1.0,
target_hw=(int(round((yi1 - yi0) * out_h / h)),
int(round((xi1 - xi0) * out_w / w))),
enable_chunking=False,
tier=(int(sharpness) if getattr(model.resizer, "tier_dim", 0) else None),
)
oy0, oy1 = int(round((y0 - yi0) * scale)), int(round((y1 - yi0) * scale))
ox0, ox1 = int(round((x0 - xi0) * scale)), int(round((x1 - xi0) * scale))
dy0, dy1 = int(round(y0 * scale)), int(round(y1 * scale))
dx0, dx1 = int(round(x0 * scale)), int(round(x1 * scale))
sy, sx = out_h / h, out_w / w
oy0, oy1 = int(round((y0 - yi0) * sy)), int(round((y1 - yi0) * sy))
ox0, ox1 = int(round((x0 - xi0) * sx)), int(round((x1 - xi0) * sx))
dy0, dy1 = int(round(y0 * sy)), int(round(y1 * sy))
dx0, dx1 = int(round(x0 * sx)), int(round(x1 * sx))
result[:, :, :, dy0:dy1, dx0:dx1] += tile_out[:, :, :, oy0:oy1, ox0:ox1]
weights[:, :, :, dy0:dy1, dx0:dx1] += 1
del tile, tile_out
@@ -148,7 +156,7 @@ class DumasMMH3LatentUpscale2D:
if dev.type == "cuda":
torch.cuda.empty_cache()
return {"samples": out}, (
f"DUMAS H3 2D spatial upscale: {h}x{w} -> {out_h}x{out_w}; "
f"DUMAS H3 2D spatial upscale: {w * 16}x{h * 16} -> {int(width)}x{int(height)}; "
f"tiles={len(ys) * len(xs)}, tile={tile_size}, overlap={tile_overlap}, "
f"time=single-pass, sharpness={sharpness}"
)
+2 -1
View File
@@ -338,7 +338,8 @@ class DumasH3ContinuumTiledLatentUpscalePerClip:
upscaled, report = processor.upscale(
{"samples": samples},
model_name=upscale_param["model_name"],
scale=upscale_param["scale"],
width=upscale_param["target_width"],
height=upscale_param["target_height"],
tile_size=upscale_param["tile_size"],
tile_overlap=upscale_param["tile_overlap"],
sharpness=upscale_param["sharpness"],