TaylorSeer

Predicting the model instead of running it

TaylorSeer came out of ICCV 2025 (arXiv:2503.06923) and rests on an observation you can verify with a stopwatch: in a diffusion sampling run, consecutive outputs are highly correlated. So instead of computing the model at every step, compute it at some steps and use a Taylor expansion over cached features to extrapolate the ones you skip. The paper calls it feature caching; the pack calls it a speed node, and the author's measurement is that switching it off on every pass of an Anima base-image + face-detail + upscale workflow makes the image about 30% slower.

The catch is in the second half of that sentence: the predicted steps differ a little. This is not the streaming engine, which is bit-exact by design. TaylorSeer changes your picture, and it changes it in the phase where detail is being finalized, which is exactly where you notice.

And a second catch: it's Anima-only. The node streams the tooltip "The native ComfyUI Anima model" for its model input, and the pack's README tables it as Anima-only alongside RoPE Scale. Don't wire it into a Flux or Wan graph and expect anything but a shrug.

That said, this isn't a mainstream technique - you're not going to find a thousand threads of tuned settings, and the pack itself has barely any footprint in the usual communities. You're going to read the tooltips and test.

How it works

Two modes. In adaptive, the node measures the relative L1 distance between the cached features and the new estimate and only spends a real forward pass when the input has drifted past rel_l1_thresh. In step, it just computes one step out of every step_interval and extrapolates the rest. max_order controls whether the extrapolation is first-order (one derivative) or second-order (curve-aware). First and last steps can be forced to compute - first_enhance and last_enhance - because those are the steps where a wrong prediction hurts most: the start sets composition, the end sets texture.

The implementation is adapted partly from ComfyUI-Anima-TeaCache, which is the sibling idea - cache and reuse rather than recompute. If you've used TeaCache on other models, the mental model carries over.

Inputs and outputs

• model - the Anima model, from the streaming node or a LoRA chain.
• mode - adaptive (default) or step.
• rel_l1_thresh (0.08) - adaptive mode's tolerance. Lower means more steps actually computed, closer to no TaylorSeer, slower.
• step_interval (2) - step mode's fixed cadence. A value of 2 means one in every two steps is predicted.
• max_order (1) - 1 or 2. Try 2 with a small threshold if first-order looks waxy.
• first_enhance (2) / last_enhance (1) - forced full computations at the ends. Raising last_enhance is the first thing to try when output looks soft.
• cache_device - cuda or cpu. Cached features on cpu saves VRAM at the cost of transfers, which is the usual deal.
• max_predict_steps (optional, 0 = no limit) - a hard cap on how far a single prediction may reach. This exists because adaptive samplers like the pack's ReAL can jump several steps at once, and extrapolating across a long jump is where Taylor expansions fall apart. If you're running ReAL, set this.

One output, model, into the sampler.

Install

cd ComfyUI/custom_nodes
git clone https://github.com/nyanmi-1828/ComfyUI-WeightFerry

Or Manager → search WeightFerry → install → restart. No dependencies beyond ComfyUI. NVIDIA, ComfyUI 0.38.0+, and note the pack applies a global fused-block kernel for Anima's attention and feed-forward layers when Triton is available - that's a separate, bit-exact speedup you get for free just by having the pack installed.

Where it goes wrong

Blaming TaylorSeer for the wrong artifact. It only acts on the sampling it wraps. If you have a base pass and a face-detail pass and only put TaylorSeer on the base, the face pass is unaffected and the artifact you're chasing might be from the upscale. Give each pass its own node, then bypass one at a time.

Turning two dials at once. rel_l1_thresh and max_order interact. Change one, generate, change the other. Two-variable tuning on a stochastic pipeline is how people conclude a node is broken.

Few-step / Turbo models. With 6–12 steps there isn't much redundancy to exploit, and the fixed cost of the enhancement steps eats the win. The pack's own draft workflow uses a Turbo LoRA at CFG 1 and 6 steps; skip TaylorSeer there.

Expecting the 30% everywhere. That number comes from one hardware/step-count combination. On a 50-step Anima run you'll likely see more; on 20 steps, less. Time it: two warm runs, one bypassed, is a two-minute experiment and beats trusting anybody's blog, including this one.