FusionCow

/

Sulphur-3

Like 423

most important settings are
enable_bf16_compute_weights use_saved_precision on loader for faster load on corrector
and correction_interval 2 or 4 , skips steps for faster gens

H3 Corrector Advanced
Parameter Guide
Complete reference for all seven custom nodes
Motion and STG update • 3 November 2026
Use this guide to choose corrector settings, understand their interactions, and build or reload a working H3 workflow. It covers every exposed input, option and output in the updated ComfyUI-H3-Corrector-Advanced package, including all 32 Controls settings and the new Motion Guider.
Begin with the existing reference workflow. Change one group of controls at a time, keep matching seeds and sampling settings for comparisons, and measure warmed total render time when testing acceleration. A lower correction budget changes the prediction; it does not normally reduce the amount of network computation.
The seven nodes
Display name Purpose
H3 Corrector Load (Advanced) Load the trained corrector and select its weight precision.
H3 Corrector Controls (Layers + Experimental Modes) Build the complete settings object bound to that corrector.
H3 Corrector Apply (Advanced) Attach correction to the H3 model used for sampling.
H3 Corrector Save Profile Save Controls as a small JSON file.
H3 Corrector Load Profile Restore a saved Controls object.
H3 Corrector Save Prepared Export a mixed BF16 and FP32 corrector checkpoint.
H3 Motion Guider (Advanced) Add motion and skip-block structure guidance during early sampling.

The six corrector nodes are under MiniMax H3/Corrector Advanced. The Motion Guider is under MiniMax H3/guidance. This guide describes the custom-node package; it does not provide a dual-GPU scheduler.

Guide contents
Topic Page
Connecting a workflow 3
Loading the corrector 4
Global correction strength and budget 5
Noise intervals and sparse correction 6
Corrector layer gains 7
Writing layer overrides 8
Caching and memory 9
Compilation 10
Attention backend selection 11
Timing and diagnostics 12
Directional residual limits 13
Local spatial residual budgets 14
Spatial frequency residual budgets 15
Applying correction and combining modes 16
Saving and loading profiles 17
Saving prepared corrector weights 18
Motion Guider inputs and settings 19
Motion guidance behavior and captions 20
Choosing an example workflow 21
Troubleshooting and practical limits 22
Validation rules and source reference 23

Connecting a workflow
The corrector is a separate trained network. Load its .safetensors file from models/h3_correctors, then use Controls and Apply to add its prediction adjustment to your H3 sampling path. The H3 model, text encoder and video/audio VAEs still load through their usual nodes.
From To
Load Advanced • corrector Controls • corrector
Load Advanced • corrector Apply Advanced • corrector
Controls • controls Apply Advanced • controls
H3 MODEL after the usual model and sigma patches Apply Advanced • model
Apply Advanced • model Your guider • model
Guider • GUIDER SamplerCustomAdvanced • guider

For motion guidance, use H3 Motion Guider (Advanced) as the guider. Connect the moving scene caption to positive and a matching frozen scene caption to still. Keep the packed video/audio latent path and sigma schedule connected to the sampler.
Replacing Controls with a saved profile
Connect Load Profile.controls directly to Apply.controls. This connected object becomes authoritative. Editing a disconnected Controls node cannot alter that run. Save the full workflow as well as a profile when you need to preserve prompts, loader precision, the guider and sampler settings.
Outputs and reports
The corrector and controls outputs carry typed objects, not text. A report output is a readable STRING for a compatible text preview node. Controls and Load Profile report the validated JSON. Apply reports the selected configuration; execution statistics and actual compiler or attention fallbacks appear in the ComfyUI console after sampling.
A valid sampling path
Use one active corrector Apply on the model path, with packed H3 video followed by audio and one active full-video positive caption. The adapter rejects regional, masked or weighted positive conditioning and multiple simultaneously active positive captions. Sampling must invoke the standard OUTER_SAMPLE and post-CFG hooks. These requirements apply even when the chosen sampler name is supported by ComfyUI.

Loading the corrector
Node: H3 Corrector Load (Advanced). The required corrector input is a filename dropdown populated from models/h3_correctors. There is no universal filename default; select your installed trained checkpoint, such as s3_corrector.safetensors. A base H3 model or LoRA is not interchangeable with this file.
Parameter Default UI values and increment
enable_bf16_compute_weights False Optional BOOLEAN • False or True
use_saved_precision True Optional BOOLEAN • False or True

enable_bf16_compute_weights — On a CUDA target, True stores Linear and Conv3d weights and biases in BF16 while keeping LayerNorm and other parameters in FP32. It converts weights once during load, reducing those parameters from four to two bytes per value. It does not skip blocks or model evaluations. False leaves an ordinary unmarked checkpoint in FP32 working storage.
use_saved_precision — True recognizes and validates the prepared checkpoint precision marker. On CUDA, a valid prepared file uses its BF16 compute and FP32 remainder policy even when enable_bf16_compute_weights is False. False ignores that policy after validation; the explicit BF16 toggle then decides working precision.
Checkpoint and target BF16 toggle Saved precision Result
Ordinary file on CUDA False Either FP32 weights
Ordinary file on CUDA True Either BF16 compute and FP32 rest
Prepared file on CUDA False True BF16 compute and FP32 rest
Prepared file on CUDA False False FP32 working weights
Prepared file on CUDA True Either BF16 compute and FP32 rest
Any file on CPU or another non CUDA target Either Either FP32 working weights

A prepared BF16 file converted back to FP32 does not recover discarded precision. For the original weight reference, select the original file and turn both toggles off. The runtime already uses CUDA BF16 autocast; these loader switches control stored weights, not the existence of autocast.
Outputs: corrector (H3_CORRECTOR) and report (STRING). The report identifies the file, depth, parameter count and applied precision policy. Loader precision is not saved in a Controls profile. Invalid architecture metadata, prepared markers or tensor dtypes raise an error before sampling.

Global correction strength and budget
Node: H3 Corrector Controls (Layers + Experimental Modes). Its required corrector socket binds every settings object to the loaded corrector name and architecture. The other 32 required inputs have widget defaults. Outputs are controls (H3_CORRECTOR_CONTROLS) and report (STRING containing validated profile JSON).
Parameter Default UI values and increment
strength 1.0 FLOAT • 0 to 2 • increment 0.05
budget_fraction 0.5 FLOAT • 0.05 to 1 • increment 0.05
velocity_floor 0.001 FLOAT • 0.0001 to 1 • increment 0.0001

strength — Multiplies the soft-capped corrector residual. At 1, it retains the original global multiplier. Positive values below 1 reduce correction without avoiding the network forward pass. Above 1, it amplifies the already bounded residual, so the final allowance can exceed the budget_fraction alone. Exactly 0 makes Apply return a model clone without adding a corrector model or sampling hooks. It does not remove any upstream hooks already present.
budget_fraction — Sets the original whole-video soft cap before strength. The reference magnitude is the RMS of H3 velocity, floored by velocity_floor. RMS means the square root of the mean squared values. The calculation is per video in the batch and reduces across channels, time and space. Lower values more strongly reduce large residuals; it is a smooth cap rather than a hard elementwise clip.
velocity_floor — Provides a nonzero reference when H3 velocity is small. It also supplies the floor for directional, local and frequency constraints. Increasing it can permit a larger correction in quiet regions or weak frequency bands. It is a numerical reference, not a quality or motion detector.
A numerical example
If the H3 velocity RMS is 2 and budget_fraction is 0.5, the pre-strength budget is 1. A raw residual RMS of 1 is smoothly reduced to about 0.707. strength=0.5 reduces that to about 0.354. strength=2 raises it to about 1.414 before any optional experimental constraints. Changing positive strength or this budget does not lower the number of corrector blocks executed.
The video denoised prediction receives the current sigma multiplied by the final velocity correction. The current call’s audio slice is copied unchanged. Later joint H3 evaluations can still change final generated audio as the video trajectory changes.

Noise intervals and sparse correction
Parameter Default UI values and increment
start_step 0 INT • 0 to 1000 • integer increments
end_step -1 INT • -1 to 1000 • integer increments
enable_sparse_correction False BOOLEAN • False or True
correction_interval 2 INT • 2 to 16 • increment 1
always_correct_last True BOOLEAN • False or True

start_step — First corrected noise interval, zero-based. The adapter sorts distinct outer sigma anchors in descending order for lookup. It does not count sampler calls and does not change the sampler schedule. A value beyond the available intervals prevents correction.
end_step — Last corrected interval, inclusive. -1 means all remaining intervals. Any nonnegative end must be at least start_step. An end larger than the schedule simply includes all remaining available intervals.
enable_sparse_correction — False corrects every eligible model evaluation inside the selected range. True keeps only selected intervals; skipped predictions use H3 directly, with no previous residual reuse. It can reduce corrector calls but changes the sampling trajectory.
correction_interval — When sparse correction is on, keep start_step, start_step+N, start_step+2N, and so on. This value has no execution effect while sparse correction is off. All eligible model evaluations within a kept interval are corrected.
always_correct_last — When sparse correction is on, also keep the final interval of the complete schedule, provided it falls inside the start/end range. It does not override an end_step that excludes the final interval. It has no effect while sparse correction is off.
Twenty interval Euler example Corrected interval indices Passes
Sparse off, range 0 to 19 Every interval 20
Stride 2, final on, range 0 to 19 0, 2, 4, …, 18, 19 11
Stride 4, final on, range 0 to 19 0, 4, 8, 12, 16, 19 6
Stride 2, final on, range 3 to 8 3, 5, 7 3

These counts assume one eligible Euler evaluation per interval. Heun and adaptive methods can evaluate more often. Adaptive sampling can even take more H3 evaluations after correction changes, so fewer corrector calls do not guarantee a faster render. Sigma zero and terminal endpoint calls are bypassed.

Corrector layer gains
Parameter Default UI values and increment
enable_layer_controls False BOOLEAN • False or True
block_strength 1.0 FLOAT • 0 to 2 • increment 0.05
self_attention_strength 1.0 FLOAT • 0 to 2 • increment 0.05
cross_attention_strength 1.0 FLOAT • 0 to 2 • increment 0.05
mlp_strength 1.0 FLOAT • 0 to 2 • increment 0.05
layer_overrides {} Multiline STRING • strict JSON object

enable_layer_controls — False uses the original network path and ignores the layer gains for execution. True enables the defaults and per-layer overrides. The fields are still validated when this switch is off; an invalid JSON override can therefore prevent Controls from building.
block_strength — Default multiplier on each corrector block’s residual change. A value of 1 uses the complete block change, 0 skips the block, and intermediate values still calculate it. Setting all blocks to 0 leaves the network’s input, conditioning and output operations active, so this is not a global corrector bypass.
self_attention_strength — Scales the video space-time self-attention branch residual in each corrector block. At 0 the branch is skipped; a fractional nonzero value still computes attention. This is a corrector-network branch, separate from the H3 transformer blocks named in stg_layers.
cross_attention_strength — Scales the corrector’s caption cross-attention residual. At 0 this branch is skipped. It does not correspond to a proven identity, detail or prompt-compliance control. Useful and unwanted changes can both be reduced.
mlp_strength — Scales the feed-forward branch residual. At 0 this branch can be skipped; 0.5 still computes it. Changes affect downstream block inputs and are not equivalent to changing the final global strength.
The branch gains act sequentially inside a block. The whole-block gain then scales the accumulated change relative to that block’s input. Later branches consume earlier branch outputs, so multiplying slider values does not predict the complete block’s effect. Overrides replace the specified default gain for their layer; they are not extra multipliers on that default.

Writing layer overrides
layer_overrides — A JSON object whose keys are zero-based corrector block indices or inclusive ranges. Valid gains are finite numbers from 0 to 2. The highest index must be below the loaded corrector depth. For a 55-block network, valid indices are 0 through 54; use the depth reported by your actual checkpoint.
Supported forms
{
"0-10": {"block": 0.8},
"11": {"cross_attention": 0.9},
"12-14": 0.5,
"15": {"self_attention": 0, "mlp": 1.1}
}
This example is syntax guidance, not a quality preset. Blocks 0 through 10 use block gain 0.8. Block 11 changes only caption cross-attention. The numeric shorthand for blocks 12 through 14 means block gain 0.5. Block 15 skips self-attention and increases its MLP residual. All unspecified gains and blocks keep the corresponding global layer defaults.
JSON key inside a block object Controls default it replaces
block block_strength
self_attention self_attention_strength
cross_attention cross_attention_strength
mlp mlp_strength

Validation rules
Ranges must be ordered and must not overlap, even when they modify different branches. For example, ranges 0-10 and 10-20 conflict at block 10. Empty branch objects, unknown branch names, duplicate JSON keys, negative gains, booleans used as numeric gains, NaN and Infinity are rejected. Use quoted JSON keys and no trailing commas.
The empty object {} means no per-layer overrides. It does not turn off the global gains when enable_layer_controls is True. To disable the entire layer-control mechanism, set enable_layer_controls=False. To remove correction entirely, set strength=0 or bypass Apply on a clean model path.
Different syntax for the Motion Guider
stg_layers uses explicit comma or whitespace separated H3 block indices, such as 20,21,22. It does not accept JSON or ranges. Never paste layer_overrides into stg_layers: they configure different networks and different operations.

Caching and memory
Parameter Default UI values and increment
enable_cache False BOOLEAN • False or True
cache_limit_mb 256 INT • 16 to 2048 • increment 16

enable_cache — Enables a bounded cache for reusable corrector rotary-position values, projected captions and caption attention keys/values. It is created per sampling run and cleared when that run ends. It does not reuse video attention results or a previous correction residual between steps.
cache_limit_mb — Limits retained optional cache tensors in MiB, meaning multiples of 1,048,576 bytes despite the mb name. The value applies only when caching is enabled. It is not a cap on total GPU memory, the corrector weights, H3 weights, activations or compiler workspaces.
What happens when the budget is small
The cache admits rotary values first, projected captions next and caption keys/values after that. Cached keys/values require the caption projection cache. Components that do not fit are recomputed while those that fit can remain cached. Raising the budget can reduce repeated work but also leaves less memory for model residency and activations.
Cache validity depends on source tensor values or versions, network identity and execution keys such as geometry, device and dtype. A changed caption invalidates its projection and keys/values. The engine assumes frozen corrector weights during a run; it does not track every parameter mutation. After changing weights, start a new run with a fresh cache. The console can report partial caching or a disabled cache with its reason.
A useful starting point
Use enable_cache=True with cache_limit_mb=256 as a first trial when you want to preserve correction coverage. Compare a repeated generation of the same shape and prompt length with caching off. Increase the limit only when the reported budget is preventing useful entries and you have room for the extra memory. More memory is not automatically more speed.
The runtime may also retain a prepared caption tensor for the current run. This and other working allocations are outside the optional engine-cache limit. A machine with abundant VRAM can still wait on transfers, synchronization or other parts of the workflow; this setting does not distribute the corrector across GPUs.

Compilation
Parameter Default UI values and increment
enable_compile False BOOLEAN • False or True
compile_mode default Dropdown • default or reduce-overhead

enable_compile — Requests torch.compile for the complete corrector block computation on CUDA. The implementation passes changing block weights as inputs to a shared block body rather than building one independent graph for every block. It retains the configured block/branch gains and eligible evaluations. It does not train, distill or merge the corrector into H3.
compile_mode — default is the starting option when compilation is enabled. reduce-overhead is an optional mode that may use CUDA graphs and extra memory to reduce repeated launch overhead. Its benefit depends on shape stability, backend support and workload. The value has no effect while enable_compile is False.
Warmup and fallback
The first use can spend substantial time compiling and preparing kernels. Different shapes or execution conditions can require more preparation. Measure later generations with comparable resolution, duration, batch and caption length. When an exactly unchanged workflow is cached by ComfyUI, change the seed to force a new run; use matching seeds when comparing settings.
If compilation is unavailable or fails, the package reports the reason and uses full eager execution. CPU and other non-CUDA targets use eager execution. An out-of-memory error remains visible rather than being disguised as a compiler fallback. Read the actual console status: enabling the checkbox is only a request.
Combining options
Compilation can be combined with the BF16 loader, caching and a chosen attention backend. With sparse correction and layer skipping off, these choices target the cost of the same configured computation. They can still change floating-point results. The compiled state belongs to the Apply configuration and is not stored in a saved checkpoint or Controls profile as executable code.
Blocks with a zero whole-block gain are skipped. A block with any zero self-attention, cross-attention or MLP gain uses eager branch skipping; the compiled block path requires all three branch gains to be nonzero.
If memory pressure rises, try compile_mode=default, lower the cache budget or disable compilation. The model should remain fully functional in eager mode. A small number of corrector evaluations may not repay compilation cost, so compare total generation time rather than only a warmed kernel measurement.

Attention backend selection
Parameter Default UI values and increment
attention_backend auto Dropdown • auto, flash, efficient, cudnn, math

This setting chooses a preference for PyTorch scaled dot-product attention inside the corrector. It does not configure the H3 model’s separate attention implementation. Attention is already used by the original corrector; this control changes backend selection rather than introducing attention acceleration for the first time.
Option Meaning and use
auto Preserve the global PyTorch policy and let available kernels be selected. Start here.
flash Request the Flash Attention SDPA backend when supported by the device, dtype and shapes.
efficient Request the memory-efficient SDPA backend when available.
cudnn Request the cuDNN SDPA backend when available.
math Request the mathematical SDPA implementation; useful as a compatibility comparison.

Unsupported explicit choices report a fallback to automatic policy. Non-CUDA execution uses the normal automatic path. Different backends may have different numeric rounding, performance and workspace use, so no dropdown choice guarantees the fastest or identical output on every machine.
Checking what actually ran
Enable diagnostics for an inspection run and read the observed attention operator families. A selected dropdown or an execution preference alone is not proof that a particular kernel executed. If the profiler cannot observe a relevant operator, the report can say unknown. Avoid inferring a backend solely from GPU utilization.
Comparison procedure
Keep the checkpoint, prompt, seed, dimensions, steps and correction coverage constant. Compare auto with one explicit backend at a time after warmup. Inspect fallback messages before interpreting timing. Restore auto if an explicit option is unsupported or slower. Turn diagnostics off for the final performance comparison because profiling adds overhead.

Timing and diagnostics
Parameter Default UI values and increment
enable_timing False BOOLEAN • False or True
enable_diagnostics False BOOLEAN • False or True

enable_timing — Records aggregate callback host time, CUDA event time for the corrector region when on CUDA, and lifecycle wall time for each sampling run. Events are read at the end rather than synchronizing every block. Measurement still adds overhead, so disable it after investigating performance.
enable_diagnostics — Observes one eligible corrector evaluation and reports accessible model residency, dtypes, bytes and attention operators. With compilation enabled, it waits until after the first corrector call before collecting the profile. A very short or mostly skipped run may have no eligible warmed capture.
Reported quantity How to interpret it
Callback host seconds Time in the CPU callback; may include waiting for earlier H3 GPU work.
CUDA corrector region Duration between events surrounding the corrector region, excluding earlier queued H3 work.
Lifecycle wall seconds Sampling lifecycle elapsed time, including preparation. It is not just corrector compute.
Corrected and evaluated counts How many model evaluations reached the adapter and how many received correction.
Correction to velocity RMS Magnitude of the applied adjustment relative to velocity. It is not a visual-quality score.
Residency and copy hints Observed accessible tensors and transfer operators. They do not prove all H3 layers remained on GPU.

Host, GPU and lifecycle times overlap. Do not add them together or subtract host callback time from lifecycle time to calculate H3 cost. Lifecycle time covers sampling and its preparation, excluding earlier text encoding and later VAE decode or export. Profiler operator totals may also overlap. A progress value such as seconds per iteration cannot isolate the corrector.
Normal end-of-run statistics and configuration logs can still appear with these toggles off. enable_diagnostics controls the additional observation work; it is not a master switch for all logging. To compare speed, use warmed total wall time with diagnostics disabled and the same workload.

Directional residual limits
Parameter Default UI values and increment
enable_directional False BOOLEAN • False or True
backward_limit 0.25 FLOAT • 0 to 0.99 • increment 0.01
forward_limit 0.25 FLOAT • 0 to 2 • increment 0.01
turn_limit 0.20 FLOAT • 0 to 2 • increment 0.01

enable_directional — Enables geometric constraints on the already strength-scaled residual. Each latent time slice is treated separately, combining its channels and spatial cells into one vector. The direction is alignment with H3’s latent velocity vector, not a measured direction of a person or camera in the video. False makes all three limit values inactive for execution.
backward_limit — Limits the component of correction opposite to H3 velocity. At 0.25, the parallel correction can subtract at most 25% of the velocity component under this directional rule. At 0 it removes opposing parallel correction. The accepted value remains below 1, preventing that parallel component from reversing H3 velocity through this rule alone.
forward_limit — Limits the reinforcing parallel correction. At 0.25 it permits a positive parallel correction up to 25% of H3 velocity. At 0 it removes reinforcing parallel correction; permitted opposing or orthogonal correction can remain.
turn_limit — Limits the RMS of the perpendicular correction relative to the velocity RMS for that latent frame. At 0.20 it allows perpendicular RMS up to 20% of the velocity RMS. At 0 it removes the perpendicular part when the velocity direction is valid.
Near zero velocity
When a frame’s velocity RMS is at or below velocity_floor, the direction is treated as unreliable. The entire residual is then uniformly limited to turn_limit multiplied by velocity_floor. The forward and backward settings do not control that branch. With the default floor of 0.001 and turn limit of 0.20, this absolute residual RMS cap is 0.0002.
Example and tradeoff
For velocity RMS 1, a correction with parallel coefficient -0.5 and perpendicular RMS 0.6 is limited by the defaults to -0.25 and 0.2 respectively. This constrains latent-vector geometry. It does not identify whether the original correction was visually beneficial, and it adds computation after the corrector network has already run.

Local spatial residual budgets
Parameter Default UI values and increment
enable_local_budget False BOOLEAN • False or True
local_budget 0.25 FLOAT • 0 to 2 • increment 0.01
local_window 5 INT • odd values 1 to 31 • increment 2

enable_local_budget — Enables local limits on concentrations of the strength-scaled correction. False disables the local algorithm; local_budget and local_window then have no execution effect. This is a numerical spatial constraint and does not detect faces, objects or unwanted concepts.
local_budget — For each spatial window, permits correction RMS up to this fraction of that window’s H3 velocity RMS, floored by velocity_floor. Raising the value relaxes attenuation; it does not amplify the incoming correction. At 0, the enabled local mode suppresses the correction residual.
local_window — The side length of an overlapping square window in latent cells. The default 5 means 5 by 5 latent cells, not five decoded pixels and not five video frames. A value of 1 still measures across channels at each cell. Larger windows measure a broader spatial neighborhood. Only odd integers from 1 through 31 are accepted.
How overlapping windows behave
The algorithm averages squared values over channels and the selected spatial neighborhood, independently for each latent time slice. Edge windows use only valid cells. Each cell receives the smallest permitted gain among all windows that cover it. This conservative overlap rule allows a strict nearby window to attenuate neighboring cells as well.
For example, if a window’s velocity RMS is 0.8 and local_budget is 0.25, its correction budget is 0.2. If its incoming correction RMS is 0.4, the window requires a gain of 0.5. A cell can receive an even smaller gain because another window covering it has a tighter bound.
Interactions
This mode operates after the global soft cap and strength, and after directional projection when that mode is enabled. Frequency processing can change local concentrations afterward, so a final intersection pass checks the enabled constraints again. That pass may scale the entire latent frame down to satisfy its tightest local requirement.
Changing local_window does not perform temporal smoothing. Reducing local_budget can suppress useful local corrections along with artifacts. Leave this experimental switch off when the goal is to measure the cost of the original corrector computation.

Spatial frequency residual budgets
Parameter Default UI values and increment
enable_frequency_budget False BOOLEAN • False or True
low_budget 0.15 FLOAT • 0 to 2 • increment 0.01
high_budget 0.35 FLOAT • 0 to 2 • increment 0.01
frequency_cutoff 0.25 FLOAT • 0.01 to 1 • increment 0.01

enable_frequency_budget — Splits the correction and H3 velocity into low and high spatial frequency bands using an FFT over height and width. The split is independent for each channel and latent time slice. There is no FFT across time. False disables the frequency algorithm and makes its three numeric settings inactive for execution.
low_budget — Limits low-band correction RMS relative to low-band H3 velocity RMS, floored by velocity_floor. The default 0.15 permits up to 15% of the floored reference. At 0, this mode removes the low spatial frequency band of the correction, not the low frequencies of the base H3 prediction.
high_budget — The equivalent allowance for the high spatial frequency band. At 0, it removes that part of the correction. Increasing either budget relaxes its limit; it does not create additional detail or amplify a band beyond the incoming correction.
frequency_cutoff — Defines the low-band boundary as radial spatial frequency divided by axial Nyquist. The low band includes frequencies at or below the cutoff, and the high band contains the remainder. At 0.25, the on-axis boundary is 0.125 cycles per latent cell, corresponding to a wavelength of eight latent cells.
Interpreting the bands
Low and high are spatial-frequency labels. They do not reliably separate identity from detail, useful changes from artifacts, or subject appearance from motion. The values refer to the latent grid rather than decoded pixels. Diagonal corner frequencies can exceed normalized radius 1, so frequency_cutoff=1 does not assign every frequency to the low band.
Cost and combined limits
The mode computes spatial transforms and reductions after the corrector forward pass, adding work. After recombining the independently limited bands, the final intersection pass rechecks every enabled constraint. A change in band balance can affect local concentrations and directional alignment, so combined modes may attenuate more than their individual settings suggest.

Applying correction and combining modes
Node: H3 Corrector Apply (Advanced). All three inputs are required. It has no independent strength slider; every correction choice arrives through controls.
Input Type Meaning
model MODEL The H3 model before any existing corrector Apply.
corrector H3_CORRECTOR The loaded trained corrector network.
controls H3_CORRECTOR_CONTROLS Controls output or a loaded profile matching this corrector.

Outputs are model (MODEL) and report (STRING). The returned model is a clone with the additional corrector model and sampling hooks attached. Connect that returned model to the guider. If you continue sampling from the original upstream model, this Apply node cannot affect the render.
Order of operations
Stage What happens
1 Eligibility Actual sigma selects the interval; start/end and sparse rules determine whether to run.
2 Learned correction The corrector predicts a video residual using the selected layer settings.
3 Global magnitude The original soft cap is applied, then strength multiplies the result.
4 Optional constraints Directional, then local, then frequency processing runs when enabled.
5 Final intersection A non-amplifying scalar per latent frame re-enforces every enabled constraint.
6 Prediction update The final residual is applied to video; this call’s audio slice is copied.

The final scalar is uniform across channels and spatial cells within each latent frame. A strict local window can therefore reduce correction across that entire frame. These are geometric bounds, not learned quality estimators. Start with one experimental mode at a time before combining them.
Bypass and compatibility
strength=0 validates the profile and returns a clone without adding this corrector’s hooks or additional GPU model. The upstream loader can still load the checkpoint into CPU memory. Bypassing Apply in the workflow can also remove its dependency path from execution. Neither action cleans an already corrected input model; feed Apply from before any older corrector node.
For nonzero strength, stacking an original or Advanced corrector on the same model path is rejected. The adapter has no sampler-name whitelist, but requires standard lifecycle and post-CFG hooks. Support for executing a sampler does not establish that the learned corrector preserves that solver’s formal accuracy or visual quality.

Saving and loading profiles
A profile saves the 32 Controls settings plus a corrector name and architecture binding. It is a small JSON configuration, with schema_version=1. It does not contain model weights, prompts, seed, sampler settings, loader precision toggles or Motion Guider settings.
H3 Corrector Save Profile
Parameter Default UI values and increment
controls Connected Required H3_CORRECTOR_CONTROLS socket
profile_name my_h3_corrector Required STRING • safe filename
overwrite False Required BOOLEAN • False or True

controls — Connect Controls.controls or Load Profile.controls. The node validates and serializes this complete object, including any inactive settings.
profile_name — Saves to models/h3_corrector_profiles/.json. Use 1 to 120 characters beginning with an ASCII letter or digit, followed by letters, digits, underscore, dash or dot. Directories and spaces are not accepted. An optional .json suffix is removed before the extension is added; the initial length check includes that suffix.
overwrite — False refuses to replace an existing different profile. If the serialized contents are already identical, saving reports unchanged without an error. True replaces the destination profile. It does not change a loaded model or a separate workflow automatically.
Output: report (STRING). This is an output node, so queueing its connected save graph can write a profile without running a video generation. Refresh the Load Profile dropdown after saving.
H3 Corrector Load Profile
Its only input is the required profile_name dropdown populated from models/h3_corrector_profiles; there is no universal file default. Outputs are controls (H3_CORRECTOR_CONTROLS) and report (STRING). Files over 1 MiB are rejected. File timestamp and size participate in detecting an updated file.
Connect controls to Apply. The profile’s name and architecture must match the loaded corrector. A renamed checkpoint or new prepared filename can require rebuilding and saving Controls for that file. Binding is not a weight hash and cannot establish compatibility with the selected H3 base model.
Older schema-1 profiles fill missing settings with current defaults. Unknown settings, invalid types, malformed JSON and unsupported schema versions are rejected. Keep ordinary profile names portable, such as s3_reference or s3_full_speed.

Saving prepared corrector weights
Node: H3 Corrector Save Prepared. This writes an actual corrector checkpoint with BF16 Linear and Conv3d weights/biases and FP32 normalization and other parameters. It preserves architecture metadata and records a validated precision marker. Its only output is report (STRING); queueing this output node writes the file.
Parameter Default UI values and increment
corrector Connected Required H3_CORRECTOR socket
save_name s3_corrector_prepared_bf16 Required STRING • safe filename
overwrite False Required BOOLEAN • False or True

corrector — Connect the loaded corrector. Export can start from CPU weights, so the loader’s BF16 toggle may be off. No H3 model, VAE, prompt, sampler or rendered video is required. Saving does not mutate the currently connected network or move it to another device.
save_name — Writes models/h3_correctors/.safetensors. An optional .safetensors extension is accepted. The basename must be 1 to 120 characters, start with an ASCII letter or digit, and contain only letters, digits, underscore, dash or dot. Directories, trailing dots, Windows reserved names and symlink destinations are rejected.
overwrite — False refuses an existing destination, even if it contains equivalent weights. True permits replacing a different prepared destination, but never permits replacing the currently loaded source checkpoint. Choose a new filename to protect the source.
Export and reload procedure

1. Open example_save_prepared.json, or connect Load Advanced.corrector to Save Prepared.corrector. Select your original trained corrector and choose a new save_name.
2. Queue the save node. Its report output names the written file. Refresh the corrector loader list and select that prepared file in your generation workflow.
3. Leave use_saved_precision=True on Advanced Load. CUDA will honor the mixed precision policy. CPU or another non-CUDA target still uses FP32 working tensors.
4. Build Controls against the newly loaded file and save a profile with its new binding if needed. Save the whole workflow to retain loader and guider options.
   What the file does and does not contain
   The export contains weights and metadata. It does not bake in strength, budgets, layer gains, sparse intervals, residual constraints, cached captions, compiled kernels or sampling state. It is not a LoRA. It can avoid repeating weight preparation on later loads; it does not add a second speed multiplier to generation that already uses the same in-memory BF16 weights. Retain the original checkpoint for original-precision comparisons.

Motion Guider inputs and settings
Node: H3 Motion Guider (Advanced). Its unique ID is H3CorrectorAdvancedMotionGuider, allowing it to coexist with the developer’s original H3MotionGuider. All inputs below are required. The output is GUIDER, connected to SamplerCustomAdvanced.guider.
Input Type Meaning
model MODEL H3 model, optionally from Advanced Apply.
positive CONDITIONING Caption describing the intended scene and movement.
still CONDITIONING Same scene with subject, camera and environmental movement frozen.

Parameter Default UI values and increment
motion_scale 2.0 FLOAT • 0 to 6 • increment 0.1
stg_scale 1.0 FLOAT • 0 to 3 • increment 0.1
stg_layers 20,21,22 STRING • comma or whitespace separated indices
until 0.25 FLOAT • 0 to 1 • increment 0.05

motion_scale — Strength of the contrast against the still caption. Zero disables this motion contribution. Larger values push the video prediction further away from the still prediction and can amplify the earlier STG term as well. The developer node defaults to 2, while both new example workflows explicitly use 1.
stg_scale — Strength of the contrast against a weak prediction produced with selected H3 transformer blocks bypassed. Zero disables STG. This is a base-model guidance setting; it does not change the Advanced corrector’s layer gains.
stg_layers — Lists zero-based H3 DiT blocks to bypass only for the temporary weak prediction. Use explicit nonnegative ASCII integers, for example 20,21,22 or 20 21 22. Duplicates are removed in their first-seen order. An empty or whitespace-only list disables STG even if stg_scale is positive. Negative values, ranges such as 20-22, trailing commas and malformed tokens raise an error. The parser does not validate the selected indices against the loaded H3 model’s actual depth.
until — The early fraction of the supplied descending sigma schedule that receives motion/STG guidance. It activates round(number_of_intervals * until) intervals. Zero, or a fraction rounding to zero, disables guidance; 1 covers all scheduled intervals. This setting is independent of the corrector’s start_step and end_step.

Motion guidance behavior and captions
At each active evaluation, the guider obtains the positive prediction and, when motion is enabled, a still-caption prediction. STG adds a weak positive-caption prediction with only the listed H3 blocks skipped. Temporary block replacements are isolated so they do not affect ordinary predictions or later steps.
The developer calculation
guided = positive_prediction
if stg_enabled:
guided = guided + stg_scale * (positive_prediction - weak_prediction)
if motion_enabled:
guided = guided + motion_scale * (guided - still_prediction)
The operations are sequential. The effective STG difference coefficient is stg_scale multiplied by (1 + motion_scale), so the two scales are not independent additive knobs. As an illustration, positive=10, weak=8, still=7 and both scales=1 produce 12 after STG and 17 after motion. These scalar values demonstrate the calculation, not a quality target.
The packed audio portion is restored from the positive prediction. The guider then invokes the standard CFG/post-CFG path once with CFG 1. If Advanced Apply is active, its corrector sees the final guided video prediction once per eligible evaluation; it is not run separately on the positive, still and weak branches.
Use motion_scale=0 to disable motion contrast. Reusing the positive caption as still can still amplify STG. The still socket remains required even at zero, so its upstream text encoding may still run. With both guidance contributions disabled, the node uses CFG 1 and attached corrector hooks remain active.
Writing the still caption
Positive example: A woman walks along a forest path while the camera tracks beside her. Her scarf moves in the breeze and footsteps are audible.
Still example: The same woman stands motionless on the same forest path. The camera is fixed. Her scarf and the surrounding leaves are still. The scene is quiet with no footsteps.
Keep the subject, scene, style and composition consistent. A generic negative prompt is not a substitute for the still caption. Freeze camera and environment movement as well as the main subject, and remove contradictory walking or footstep language.
Schedule and cost
For 20 Euler intervals and until=0.25, guidance runs on the first five intervals, followed by CFG 1. Both active guidance terms request three prediction branches during those intervals. That is roughly 30 prediction branches over the run versus 20 for plain CFG 1, although batching and skipped blocks change actual runtime. Motion/STG adds model work; it is not a speed control.
Missing or fewer than two sample sigmas disable guidance. The guider retains the developer’s descending-schedule assumptions and uses sigma intervals rather than a call counter. Active guidance calls calc_cond_batch directly and bypasses custom pre-CFG and custom conditional-batch hooks; post-CFG hooks still run. Ending guidance does not turn off the corrector.

Choosing an example workflow
The package includes seven example workflows. Import one into ComfyUI and select your installed files in each model loader. The settings below describe the included workflow presets, which can differ from the default values of a newly added node.
Workflow Use and correction policy
example_original.json Reference residual calculation. Acceleration and experimental controls are off.
example_full_speed.json BF16, compile and cache trial; sparse is off. Timing and diagnostics are on for inspection. Turn diagnostics off for final speed comparisons.
example_fast.json Sparse interval approximation. Fewer corrected intervals can change quality.
example_directional_local.json Separate experiment with directional and local limits. Frequency and layer controls remain off.
example_save_prepared.json Two-node Load and Save Prepared graph; exports weights without generation.
example_motion_corrector.json Regular S3 with Advanced correction active and Motion/STG guidance.
example_s3_rl_motion.json Developer S3-RL configuration. Motion/STG is active; Advanced Apply is bypassed by default.

Both new motion workflows use Euler, 20 steps, motion_scale=1, stg_scale=1, layers 20,21,22 and until=0.25. The regular S3 example keeps the reference corrector controls. The S3-RL example intentionally does not run the corrector until you enable Apply.
A controlled acceleration trial
Keep strength=1, budget_fraction=0.5, velocity_floor=0.001 and the full interval range. Leave sparse, layer controls and all three experimental modes off. Try BF16 loading, compile=default and cache=256 MiB with attention=auto. Inspect one warmed run with diagnostics, then turn diagnostics off for total-time measurements. Each option remains a trial until measured on your hardware.
A controlled magnitude trial
Starting from the original reference, compare strength=1 with 0.5 while keeping all other choices fixed. This tests a smaller correction without deliberately skipping its network work. Test sparse coverage or experimental budgets separately so a changed result has an identifiable cause. Motion settings belong to another comparison because they add H3 prediction branches.

Troubleshooting and practical limits
Symptom Check or action
Nodes are missing or unknown Replace the complete Advanced folder, restart ComfyUI and refresh the browser. Read startup import errors.
Corrector dropdown is empty Put the trained .safetensors file in models/h3_correctors. Refresh the dropdown.
Metadata or tensor mismatch Use the compatible corrector checkpoint. A base H3 model or LoRA cannot substitute for it.
Profile binding does not match Load its matching corrector, or rebuild Controls and save a profile for the selected filename and architecture.
Editing Controls has no effect Check that its controls output actually feeds Apply. A connected Load Profile overrides a disconnected Controls node.
Correction does not run Check strength, bypass state, interval selection, guider model connection and the console’s corrected count.
Already applied error Feed Apply from before every earlier corrector Apply node. Do not stack original and Advanced correction.
Caption or packed latent error Use one active full-video positive caption and the H3 packed video/audio path. Regional or weighted caption adapters are not supplied.
Sparse controls appear ineffective Enable enable_sparse_correction; interval and final toggles are inactive otherwise.
Layers appear ineffective Enable enable_layer_controls. Nonzero fractional gains still perform their branch computation.
Compilation is slow or falls back Allow warmup, read the fallback reason, compare eager execution and confirm the actual status.
Out of memory Try default compile mode, reduce cache size or disable compilation. Lowering positive strength does not reduce weight memory.
STG list is rejected Use explicit indices such as 20,21,22. JSON, negatives and 20-22 ranges are invalid here.
Motion example is slower Active guidance adds H3 branches. Compare without Motion/STG to isolate corrector cost.

This package does not force both GPUs to full utilization or replicate the corrector across GPUs. Attention, transfer, batching and sampler behavior influence utilization. Benchmark total generation time on the intended system; a utilization percentage alone does not establish a speed improvement.

Validation rules and source reference
Reading the parameter tables
Default means the value for a newly added node. Example workflows can explicitly override it. Numeric UI ranges are inclusive unless noted. Widget increments describe editing steps, not numeric quantization of a saved profile. start_step and end_step are integer fields whose source schema does not specify a separate step value.
Controls validates every field even when its controlling switch is off. Boolean fields require real true/false values, not strings or 0/1. Numeric settings require finite numbers; NaN, Infinity and booleans used as numbers are rejected. Unknown keys and duplicate JSON keys are rejected. end_step must be -1 or at least start_step, and local_window must be odd.
Two profile bounds are wider than their ordinary widgets: backward_limit accepts any finite value from 0 up to but excluding 1, while the widget maximum is 0.99; frequency_cutoff accepts values greater than 0 through 1, while the widget minimum is 0.01. Integer cache_limit_mb values inside 16 to 2048 are valid even if they are not multiples of the widget increment of 16.
Noise anchors used by the corrector
For distinct descending anchors [1.0, 0.6, 0.2, 0.0], an evaluation at 0.8 uses 0.6 as the next lower conditioning anchor. An evaluation at exactly 0.6 uses 0.2. Above-first evaluations use 1.0, and evaluations at or below the terminal anchor are bypassed. Small floating-point differences near boundaries receive a tight tolerance. This anchor conditions the learned corrector; it does not command the solver’s actual next stage.
Source version
This reference describes H3_Corrector_Advanced_Motion_STG.zip, incorporating the Motion/STG feature from S3_ComfyUI_m.zip. The new developer archive and Advanced package contain byte-identical corrector network code. The implementation review used nodes.py, profiles.py, runtime.py, engine.py, acceleration.py, residual_modes.py, checkpoint_io.py, diagnostics.py, guidance.py and the seven included workflow JSON files.
The merge’s validation record reports 501 tests passed and 4 skipped in a CPU test environment. It includes guidance arithmetic, audio preservation, isolated STG options and the actual Advanced runtime with a tiny corrector network. Those tests are not GPU render, quality or performance benchmarks. The detailed record is included in DEV_MERGE_VALIDATION.txt.
Terms used in this guide
A latent is the encoded video or audio representation used during sampling. Sigma identifies a noise level. A residual is the learned adjustment to H3’s prediction. CFG is classifier-free guidance; this Motion Guider uses a CFG-1 result after its custom contrasts. STG here means guidance using a prediction with selected H3 blocks skipped. BF16 and FP32 describe numeric precision. MiB is a binary unit of memory.