AICG3D_H3SelfLiftStrategy

AICG3D_H3SelfLiftStrategy is the one node in this pack that never got a Chinese label - the display name is literally the class name, so searching "SelfLift" is how you find it. Which is a shame, because it's the most interesting idea in the box: a progressive-resolution sampling strategy that spends its cheap early steps on a smaller grid and its expensive later steps at full size.

The pitch, in one line: most of the composition is decided in the first few denoise steps, and those steps are the ones where a bigger canvas costs you the most and gives you the least. So run them small, lift the clean prediction up to the target size, finish there.

How it works

You don't get a patched MODEL out of this node - it's a plan, a small immutable object describing how to sample. It goes into the optional sampling_plan socket of 分段采样, 采样设置 (which passes it to the segment steps), or the plain H3 Easy sampler. The sampler reads the plan and switches execution; nothing downstream needs to know.

Under the hood, the early evaluations run on a spatially scaled-down latent (lowres_scale, default 0.8 - so 64% of the pixels). When the plan's transition_step is reached, the current clean prediction is lifted to the requested grid with the chosen upscaler, and the remaining steps run at full resolution. Grid-bound guide latents, like the keyframes H3 uses for reference images, get resized to match the low-res stage so the conditioning still lines up.

The knobs that matter

• transition_step (default 5, range 1–100) - the handover point. Low means you're only drafting with a handful of steps before paying full price; high means you save more and risk the composition being set at low res. With a 20-step schedule, 5 is a reasonable place to start.
• lowres_scale (0.25–1.0, default 0.8) - how small the draft stage is. At 1.0 the plan is a no-op, which is a useful sanity check.
• upscaler_model - the latent upscaler used at the handover. Defaults to none, which means the built-in scaling path. Drop a model in ComfyUI/models/latent_upscale_models if you want a learned one, and set upscaler_device / upscaler_precision / upscaler_chunking to suit your card. Chunking on is the low-VRAM default and you should probably leave it.
• cfg (default 1.0), rho, w_min / w_max - the correction terms. rho is how much the lifted low-res prediction is corrected against the high-res one; w_min/w_max clamp that correction. Leaving rho at 0 means no correction at all, which is the plain lift. There is a real validation here: w_min greater than w_max is an error, not a silent swap.
• advanced - a UI disclosure toggle. In the shipped code it's accepted and discarded; it doesn't change the plan.

Output is sampling_plan, one socket, into whichever sampler you're using.

Install

cd ComfyUI/custom_nodes
git clone https://github.com/JGRFW/comfyui-AICG3D

Restart, Ctrl+F5, search SelfLift or AICG3D in the node search. No extra Python dependency - it's torch and ComfyUI's own sampling internals. If you want a learned upscaler at the transition, that's a separate model download into models/latent_upscale_models.

Where it fits, and where it doesn't

SelfLift is a first-pass optimisation. It makes the first render cheaper or better per unit of compute; it is not a substitute for 分段二采, which is a genuine second denoise pass at higher resolution with the segments still chained. If your plan was "SelfLift so I don't need Refine", no - it saves you steps on the way to the same canvas, it doesn't add detail that the first pass never sampled.

Two hard limits from the pack's own validators: SelfLift only works with latent or RGB-guide continuity, not the soft/hard AV modes, and it needs the video VAE available from the context bundle (the sampler raises an error if it isn't). So this is the generated-segments path, not the selected-video replacement path.

And a reality check on expectations: on a card that's already comfortable at 480P, the win is modest. On a card that can barely hold the full canvas, the low-res draft stage is the difference between running and OOMing - that's who this node is really for.