VRGDG LTX LoRA Train Chunk

VRGDG_LTXLoraTrainChunk runs one chunk of LTX-2 LoRA training using musubi-tuner, right from your workflow - train a few hundred steps, preview the result, then run the next chunk and keep going. It's the node that turns LoRA training into a ComfyUI graph instead of a separate terminal ritual.

This is the heaviest node in the pack, and the honest summary is: it's a wrapper around musubi-tuner (kohya-ss's trainer, the one the community has gravitated to for video and modern-architecture training). It shells out to musubi, manages the dataset config, caches the text-encoder embeddings, and hands you back a model with the freshly trained LoRA applied for a quick preview. Nothing about training is free - this needs the trainer installed, a 22B LTX-2 checkpoint, and a serious GPU (musubi's own guidance is 24GB VRAM for video training, 64GB system RAM). What the node buys you is the plumbing.

Inputs worth knowing

There are ~30, which is a lot, but they cluster into a few groups.

The paths - get these right first. musubi_root, ltx2_checkpoint, and gemma_root tell the node where musubi, the base checkpoint, and the Gemma text-encoder files live. The defaults are the author's own Windows machine (A:/MUSUBI/...) - you must repoint these to your install or nothing runs. This is the single most common reason this node fails for someone else.

The dataset. dataset_images_dir (your training images, captioned with sibling .txt files), workspace_dir (where cache, logs, configs, and checkpoints go), run_name/output_name, num_repeats. With create_captions on, the node writes caption files from caption_text, and add_trigger_word/trigger_text prepend a trigger word to each - which, per the LoRA training orthodoxy in the KB, is how you keep a character concept recallable at inference.

The training recipe. resolution_width/resolution_height (defaults 1920×1080; the tooltips suggest 960×540 for light tests), steps_per_run (how many steps this chunk trains - 250 default), total_target_steps (when to stop overall - 3000 default), network_dim (LoRA rank, default 64), network_alpha (default 32, "alpha at half the rank" per the tooltip and the community's modern default), learning_rate_preset (a picker: 1e-4 aggressive through 1e-5 gentle, default 7e-5), and blocks_to_swap (musubi's block swapping to trade VRAM for speed - 0 to disable, 4 balanced, 8–12 for lower-VRAM cards).

The memory dance. clear_memory_before_gemma unloads ComfyUI models before the Gemma text-encoder caching stage (keep it on if stage 2 stalls), gemma_load_in_4bit squeezes VRAM further, and gemma_recovery_mode is the experimental fallback if caching fails. cache_strategy (auto/force/skip) controls whether the cache rebuilds.

The outputs. model comes back with the latest LoRA applied at strength_model (0.0 disables the application) so you can run a preview generation right in the graph. copy_latest_to_comfy_loras drops the .comfy.safetensors file into your ComfyUI loras folder (and keep_only_comfy_lora cleans up the raw files). Plus latest_state_path, log_path, video_filename_prefix, output_name, and the two progress ints completed_steps and total_target_steps.

Why "chunked" training is the point

Train 250 steps, preview the LoRA on a real generation, and only then decide whether to keep going. If the preview is weak, tweak the recipe and run another chunk; if it's overfit, stop early. You're never committing to a 3,000-step run blind - which matters because LTX-2 LoRA training is expensive enough that a wasted full run is a real loss. The chunk model is genuinely the right way to train on video hardware.

Install

Same pack install:

cd ComfyUI/custom_nodes
git clone https://github.com/vrgamegirl19/comfyui-vrgamedevgirl

Restart ComfyUI; find it under VRGDG/Training. Then the real install: get musubi-tuner (the LTX-2 variant) onto disk, download the LTX-2/2.3 checkpoint and Gemma files, and point the three path inputs at them. The pack's requirements.txt (kornia, librosa, imageio) does not cover musubi's own dependencies - musubi is a separate project with its own environment.

Honest note

This node is the one I'd call "for the author's own machine first." The Windows absolute-path defaults, the musubi dependency, and the 24GB+ VRAM appetite mean it's not a beginner toy - but if you're already running musubi-tuner for LTX-2, this genuinely saves you the config-file drudgery and gives you the loop-training workflow for free. The single biggest gotcha (the A:/MUSUBI paths) is also the easiest to fix: repoint, verify the checkpoint loads, and start with 50 steps per chunk to smoke-test before spending real time.