Train Anima Slider LoRA (QPOLA)

Normally, training a LoRA means collecting images, captioning them, and fighting a dataset loader. This node does none of that. It trains an Anima "slider" LoRA - a direction LoRA that pushes one attribute up or down - from nothing but a YAML file full of prompts, and this particular variant does it with QPOLA, a moment-free CUDA optimizer most people have never heard of. If that sounds like a science experiment, you've got the right read: it's marked experimental by the author on purpose.

This is the Train Anima Slider LoRA (QPOLA) node from Shiba-2-shiba's comfyui-anima-slider-node pack, sitting alongside its plain AdamW sibling. Anima has no ControlNet, so sliders are one of the few levers you get for steering attributes - breast size, skirt length, emotion intensity, chibi style - and the pack ships around forty bundled prompt YAMLs covering exactly those. The author ported the anima-slider-experiment flow-slider trainer into ComfyUI so you can train one without leaving the app.

Why there are two nodes

The QPOLA node exists so you can A/B it against the AdamW one. Same prompts, same teacher signal, same MSE loss, same LoRA targets - the only thing that changes is the optimizer. QPOLA is a "moment-free, spatially-cooperative" update rule, vendored at v1.0.4 with its CUDA kernel and PTX shipped inside the pack (Apache-2.0, attribution in third_party/qpola). It replaces loss.backward() + AdamW with a custom per-step update that runs as a CUDA kernel.

The author is refreshingly blunt about scope: QPOLA needs NVIDIA CUDA, needs the LoRA weights in fp32, needs a driver that can load the bundled PTX, and there is no fallback. If the loader, preflight, or kernel launch fails, the node errors out rather than silently training with AdamW. The report JSON and the safetensors metadata record which optimizer ran and what version. No pretending.

How it works

Under the hood it's the same flow as the base node:

1. Load a prompt YAML - a list of entries with target, positive, unconditional, neutral, guidance_scale, and action (enhance or erase).
2. Encode those prompts once with your loaded CLIP (the Qwen3 encoder Anima uses) - no text-encoder training, and the embeddings are cached up front, which is the big speed lever in modern LoRA training.
3. Build the teacher as target ± eta × (positive − unconditional), optionally norm-matched to the neutral reference.
4. Take MSE between that teacher and the model's output with the LoRA injected, backprop, and let QPOLA (or AdamW on the sibling node) step.

The VAE input is there for workflow parity with Anima pipelines - the current text-only trainer doesn't encode any images, so you can feed it but it's ignored.

The inputs that actually matter

Most of the schema is AdamW-node plumbing you won't touch. Set these:

• model, clip - the Anima model and its text encoder, loaded as usual. vae is ignored.
• prompt_yaml - pick a bundled YAML (default prompts-anima-breast_size_slider.yaml), or point custom_prompt_yaml_path at your own file.
• prompt_indices / eval_prompt_indices - bundled prompts are ordered 0–5 train, 6–7 eval. Keep that default.
• steps (600) and lr - QPOLA's default is 1e-4; the README's first comparison ladder is 3e-5, 1e-4, 3e-4.
• rank / alpha - 16/16, the sensible modern default for a DiT.
• network_preset (attn_mlp), model_residency (prefer_cuda), gradient_checkpointing (on) - the README's 16GB VRAM recipe for 1024×1024.
• qpola_eps (1e-8) and qpola_low_vram (on) - QPOLA-specific. Low-VRAM frees the CUDA allocator cache after every step, which saves cached memory but can slow training; turn it off if it's hurting.
• width / height - 0 uses the YAML's resolution. If you copied a workflow that saved 512, reset these to 0 or you'll silently train full-body sliders at 512.

What comes out

Four outputs: lora (a LORA_MODEL you can wire straight into an Apply LoRA), report_json, and the file paths - lora_path and report_path. It saves to ComfyUI's output directory under loras/anima_slider_qpola by default. The report carries the optimizer type, QPOLA version, gradient-checkpointing flag, eval-skip settings, and CUDA memory diagnostics, which is exactly what you want for comparing runs.

Installing it

ComfyUI Manager: search comfyui-anima-slider-node and install. Or the manual route:

cd C:\path\to\ComfyUI\custom_nodes
git clone https://github.com/Shiba-2-shiba/Comfyui-anima-slider-node Comfyui-anima-slider-node

Restart ComfyUI and you'll find it under training/anima slider. There's no requirements.txt - it's a ComfyUI V3 backend node that rides on ComfyUI's own torch, so the only real dependency is the NVIDIA CUDA driver. And note the pack's third-party notice: QPOLA's CUDA source and PTX are bundled, so nothing to download, but it's another reason this one is NVIDIA-only.

Where people get burned

• No CUDA, or a stale driver → hard error from the preflight, and lora_weight_dtype is locked to fp32 here. On a CPU-only box the README points you at the AdamW node instead.
• OOM at 1024² on 16GB → work the README's ladder: 512 first, then 768, then 1024 with skip_initial_eval/skip_final_eval on to isolate the OOM phase, then turn evals back on. Those toggles are diagnostics, not quality switches - don't ship a run with them off.
• Full-body sliders looking wrong → resolution trap. Chibi/skirt sliders want 896×1152 or width=0/height=0, not 512.
• Age-slider YAMLs erroring → some bundled age prompts need allow_unsafe_age_terms=True.

It's an experiment, and the honest expectation is a weekend of fiddling rather than a turnkey result. But for "how do I make this one attribute stronger without a dataset," it's the only tool doing it inside ComfyUI - and if QPOLA ever does beat AdamW for you, the metadata is right there in the JSON to prove it.