Official agent skill

Nv Generate Vae Finetune

by NVIDIA in NVIDIA/skills

Used for finetuning the NV-Generate-CTMR MAISI VAE from CT/MRI NIfTI datalists.

OfficialApache-2.0Auto-check: notesAI & LLM Engineering

Install Nv Generate Vae Finetune

skills CLI
$ npx skills add NVIDIA/skills --skill nv-generate-vae-finetune -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install NVIDIA/skills nv-generate-vae-finetune --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/NVIDIA/skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/nv-generate-vae-finetune .claude/skills/nv-generate-vae-finetune && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
nv-generate-vae-finetune
GitHub stars
3.5k
Token cost
~3.1k tokens
SKILL.md length
1,065 words
Files
13 (incl. scripts)
Skills in repo
386
Repo updated
First seen
Licence
Apache-2.0

At a glance

Used for finetuning the NV-Generate-CTMR MAISI VAE from CT/MRI NIfTI datalists.

  • Works in 5 steps: Config and environment JSON (adapt to… → Usage (one-line training) → Monitor training (TensorBoard) → …
  • Tasks that involve Fine-tuning
  • SKILL.md covers Purpose, Instructions, Examples and Available Scripts, plus 8 more sections
  • Runs Python scripts from its folder; calls python and git; reaches github.com and huggingface.co

What it does

Nv Generate Vae Finetune is an agent skill from NVIDIA/skills, published by the product's own GitHub organization. Used for finetuning the NV-Generate-CTMR MAISI VAE from CT/MRI NIfTI datalists. Not for clinical or production data approval.

Its SKILL.md is about 3.1k tokens, which your agent loads only when the skill is triggered. The skill folder holds 20 other files, including scripts (for example `BENCHMARK.md`, `evals/evals.json` and `fixtures/README.md`).

It sits in AI & LLM Engineering, covering Fine-tuning. The repository describes itself as: Agent Skills for NVIDIA products — install into Claude Code, Codex, and other coding agents to run Physical AI, robotics, simulation, CUDA, and RAG workflows end to end. The licence is Apache-2.0.

When your agent uses it

  • Tasks that involve Fine-tuning

Example prompts

  • “/nv-generate-vae-finetune”

Requirements

  • Python 3
  • Pre-approved tools (allowed-tools): Bash

Workflow steps

5 steps, taken from the step headings in SKILL.md.

  1. Config and environment JSON (adapt to your data)
  2. Usage (one-line training)
  3. Monitor training (TensorBoard)
  4. Hyperparameter tuning and common pitfalls
  5. Evaluate the finetuned VAE

What it can do on your machine

Read from SKILL.md and the folder at commit dfdd080. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves these tools, so the agent can use them without asking each time:

    • Bash

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Ships 1 file in scripts/ (Python), which the agent can run.

    Shell commands in SKILL.md call:

    • python
    • git

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Hosts in commands or code, which the agent is likely to contact:

    • github.com
    • huggingface.co
    • download.pytorch.org

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Nv Generate Vae Finetune loads about 3.1k tokens when it runs. Until then it costs about 38 tokens; SKILL.md has 1,065 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~38
When it runs · the whole SKILL.md, loaded when a task matches
~3.1k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check: notes

The automated check noted patterns worth knowing about, such as sudo or a known installer.

  • NotePre-approves every shell command (allowed-tools: Bash)SKILL.md
    allowed-tools: Bash

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); the scripts in this folder are not scanned.

SKILL.md

The full file from NVIDIA/skills at commit dfdd080, republished under its Apache-2.0 licence (© NVIDIA). 1,065 words, ~3,115 tokens.

Download SKILL.mdSave it as .claude/skills/nv-generate-vae-finetune/SKILL.md (or your agent's skills folder). This skill also uses 12 other files; get the full folder from GitHub.
name
nv-generate-vae-finetune
description
Used for finetuning the NV-Generate-CTMR MAISI VAE from CT/MRI NIfTI datalists. Not for clinical or production data approval.
allowed-tools
Bash
license
Apache-2.0
metadata.author
NVIDIA MedTech Team
metadata.tags
MedTech, CT, MRI, VAE, finetune

NV-Generate-VAE-Finetune

Purpose

  • Used for finetuning the NV-Generate-CTMR MAISI VAE/autoencoder from user-supplied CT or MRI NIfTI training volumes.
  • Not for clinical interpretation, regulatory use, or approving synthetic data for production training.
  • Upstream currently documents VAE training in train_vae_tutorial.ipynb and provides configs/helpers, but not a scripts.train_vae CLI. This skill does not execute the notebook; it stages the required config/datalist glue locally and uses upstream helper APIs.
  • Manifest I/O: inputs are datalist and data_base_dir; outputs are autoencoder_checkpoint, discriminator_checkpoint, and result_json.
  • The underlying training contract is the upstream config/env JSON (config_maisi_vae_train.json + environment_maisi_vae_train.json, as used in train_vae_tutorial.ipynb). The wrapper stages those JSON files for you and exposes the most-tuned fields as CLI flags; the sections below document the fields, their defaults, and how to monitor/tune a run.

Instructions

  • Read skill_manifest.yaml before changing arguments, side effects, or validation gates.
  • Run scripts/run_vae_finetune.py from the Medical AI Skills repo root.
  • If a host agent exposes run_script, use run_script("scripts/run_vae_finetune.py", args=[...]); otherwise run the Bash/Python command below.
  • Use --preflight first when checking a new datalist; remove --preflight only when the user explicitly wants to launch GPU finetuning.
  • For a staged preflight input bundle directory, use BUNDLE/preflight_datalist.json as the datalist and BUNDLE/preflight_dataset as --data-base-dir when those files are present.

Examples

Validate and stage a preflight finetune check from an input bundle (the recommended first step — no GPU, no training). This is the single canonical command; replace INPUT_BUNDLE and OUT_DIR with your paths:

bash
export NV_GENERATE_ROOT="${NV_GENERATE_ROOT:-$HOME/.cache/nvidia-skills/upstreams/NV-Generate-CTMR-61c4ec7}" && \
python skills/nv-generate-vae-finetune/scripts/run_vae_finetune.py \
  INPUT_BUNDLE/preflight_datalist.json \
  --data-base-dir INPUT_BUNDLE/preflight_dataset \
  --output-dir OUT_DIR \
  --modality mri \
  --preflight

For real GPU finetuning and other variations, see Usage below.

Available Scripts

ScriptPurposeArguments
scripts/run_vae_finetune.pyPrimary entrypoint declared by skill_manifest.yaml.DATALIST.json --data-base-dir DATA_DIR --output-dir OUT_DIR [--epochs N] [--modality mri] [--patch-size 64,64,64] [--preflight]

Prerequisites

  • An explicit NV_GENERATE_ROOT may point to the caller's local checkout and must contain configs/config_maisi_vae_train.json, scripts/transforms.py, and scripts/utils.py. The result records its current commit.
  • If NV_GENERATE_ROOT is unset, the wrapper searches .workbench_data/upstreams/NV-Generate-CTMR.
  • CUDA_VISIBLE_DEVICES is optional and can be used to select the GPU for real training.
  • Runtime requirements: NVIDIA CUDA GPU for real training, Python packages from the upstream requirements.txt, lpips, and downloaded VAE weights unless using --train-from-scratch.
  • Side effects: writes staged configs, checkpoints, TensorBoard logs, and run summaries under the caller-provided --output-dir; may write model caches under the upstream checkout, ~/.cache/huggingface/, and ~/.cache/torch/; may contact https://huggingface.co, https://github.com, and https://download.pytorch.org.
  • The datalist is a MONAI-style JSON object with non-empty training[] and validation[] or testing[]. Each entry has an image path relative to --data-base-dir and optional class or modality of ct or mri.

When no local checkout is supplied, create the recommended pinned default checkout once:

bash
if [ -z "${NV_GENERATE_ROOT:-}" ]; then
  export NV_GENERATE_COMMIT=61c4ec709b84cad468852243c48e250bec732074
  export NV_GENERATE_ROOT="$HOME/.cache/nvidia-skills/upstreams/NV-Generate-CTMR-61c4ec7"
  if [ ! -d "$NV_GENERATE_ROOT/.git" ]; then
    git clone https://github.com/NVIDIA-Medtech/NV-Generate-CTMR.git "$NV_GENERATE_ROOT"
    git -C "$NV_GENERATE_ROOT" checkout --detach "$NV_GENERATE_COMMIT"
  fi
fi

1. Config and environment JSON (adapt to your data)

The wrapper copies the upstream VAE config/env JSON from $NV_GENERATE_ROOT/configs, rewrites the fields below, and writes the staged copies under OUT_DIR/workflow/configs/. You normally only set your datalist and data root; the listed CLI flags override individual fields when you need to.

Environment JSON (environment_maisi_vae_train.json):

FieldSet fromNotes
model_dir--output-dirWhere autoencoder.pt/discriminator.pt and best checkpoints are saved.
tfevent_path--output-dirTensorBoard event directory.
finetune--train-from-scratchtrue (default) loads trained_autoencoder_path; the flag sets it false.
trained_autoencoder_pathupstream weights / --trained-autoencoder-pathStarting VAE checkpoint when finetuning.

Training fields (config_maisi_vae_train.json):

FieldFlagTypeDefaultNotes
autoencoder_train.n_epochs--epochsint1
autoencoder_train.batch_size--batch-sizeint1Per-GPU (single-GPU runner).
autoencoder_train.patch_size--patch-sizeint,int,int64,64,64Training crop.
autoencoder_train.val_batch_size--val-batch-sizeint1
autoencoder_train.val_sliding_window_patch_size--val-sliding-window-patch-sizeint,int,int96,96,64Sliding-window validation ROI.
autoencoder_train.lr--lrfloat1e-4
autoencoder_train.perceptual_weight--perceptual-weightfloat0.3LPIPS term.
autoencoder_train.kl_weight--kl-weightfloat1e-7KL term.
autoencoder_train.adv_weight--adv-weightfloat0.1Adversarial term.
autoencoder_train.recon_loss--recon-lossl1|l2l1
autoencoder_train.val_interval--val-intervalint1Epochs between validation passes.
autoencoder_train.cache--cache-ratefloat0.0MONAI CacheDataset fraction.
autoencoder_train.amp--no-ampflagonMixed precision; flag disables it.
data_option.random_aug--no-random-augflagonRandom augmentation; flag disables it.
data_option.spacing_type--spacing-typeoriginal|fixed|rand_zoomoriginal
data_option.spacing--spacingfloat,float,floatunsetRequired when spacing_type is fixed/rand_zoom.
data_option.select_channel--select-channelint0Channel for multi-channel inputs.

--modality (ct or mri, default mri) fills the per-entry class for datalist items missing one. Validation/testing entries are required because the training loop runs a validation pass.

For an end-to-end reference including example data download, see the upstream tutorial train_vae_tutorial.ipynb.

Show full SKILL.md (409 more words)Show less

2. Usage (one-line training)

Preflight only:

bash
export NV_GENERATE_ROOT="${NV_GENERATE_ROOT:-$HOME/.cache/nvidia-skills/upstreams/NV-Generate-CTMR-61c4ec7}" && \
python skills/nv-generate-vae-finetune/scripts/run_vae_finetune.py \
  PATH_TO_DATALIST.json \
  --data-base-dir PATH_TO_DATA_ROOT \
  --output-dir runs/nv_generate_vae_finetune_preflight \
  --preflight

Preflight bundle input:

bash
export NV_GENERATE_ROOT="${NV_GENERATE_ROOT:-$HOME/.cache/nvidia-skills/upstreams/NV-Generate-CTMR-61c4ec7}" && \
python skills/nv-generate-vae-finetune/scripts/run_vae_finetune.py \
  PATH_TO_INPUT_BUNDLE/preflight_datalist.json \
  --data-base-dir PATH_TO_INPUT_BUNDLE/preflight_dataset \
  --output-dir runs/nv_generate_vae_finetune_preflight \
  --preflight

GPU finetuning:

bash
export NV_GENERATE_ROOT="${NV_GENERATE_ROOT:-$HOME/.cache/nvidia-skills/upstreams/NV-Generate-CTMR-61c4ec7}" && \
python -m pip install -r "$NV_GENERATE_ROOT/requirements.txt" && \
python -m pip install lpips tensorboard && \
python skills/nv-generate-vae-finetune/scripts/run_vae_finetune.py \
  PATH_TO_DATALIST.json \
  --data-base-dir PATH_TO_DATA_ROOT \
  --output-dir runs/nv_generate_vae_finetune \
  --epochs 1 \
  --modality mri \
  --patch-size 64,64,64 \
  --download-model-data

Replace PATH_TO_DATALIST.json and PATH_TO_DATA_ROOT with the user's actual paths. Do not use the fixture datalist for real training; it is a preflight-only placeholder.

3. Monitor training (TensorBoard)

The runner writes TensorBoard scalars (per-iteration and per-epoch recons_loss, kl_loss, p_loss, adversarial/real/fake losses, and a validation scale_factor) under OUT_DIR/artifacts/tfevent/autoencoder. Launch TensorBoard against the output directory:

bash
python -m pip install tensorboard && \
tensorboard --logdir runs/nv_generate_vae_finetune/artifacts/tfevent

The same per-epoch loss history is also captured in OUT_DIR/artifacts/workflow_summary.json and echoed in the JSON the wrapper prints to stdout (loss_history, best-checkpoint paths, exit_code, stderr_tail).

4. Hyperparameter tuning and common pitfalls

  • Reconstructions blurry — raise --perceptual-weight (default 0.3); try --recon-loss l2 if edges look washed out.
  • Posterior collapse / over-regularized latents — --kl-weight is intentionally tiny (1e-7); increasing it too much degrades reconstruction.
  • Adversarial training unstable — lower --adv-weight (default 0.1) or --lr; a warmup schedule already ramps the LR over the first 20 epochs.
  • Out-of-memory — reduce --patch-size (e.g. 48,48,48) and --val-sliding-window-patch-size, keep --batch-size 1, and lower --cache-rate.
  • datalist must include non-empty validation[] or testing[] — the validation loop is mandatory; add validation[] (or testing[]) entries.
  • Single-GPU only — the runner asserts exactly one CUDA GPU; set CUDA_VISIBLE_DEVICES to pick which one.

5. Evaluate the finetuned VAE

Validation reconstruction loss (lowest-val_weighted_loss epoch) is tracked automatically and the best autoencoder is saved as autoencoder_epochN.pt under OUT_DIR/artifacts/models. To evaluate downstream:

  • Compare validation recons_loss/p_loss curves across runs in TensorBoard, and
  • Plug the finetuned autoencoder into a diffusion finetune/generation run (e.g. nv-generate-mr-brain-finetune via --trained-autoencoder-path) to confirm latents still decode to usable volumes.

This skill gates file accounting and reconstruction bookkeeping only — image quality and downstream utility must be judged by a domain expert.

Limitations

  • Requires a current upstream NV-Generate-CTMR checkout with VAE configs and helper APIs. The skill owns the runner glue and does not depend on the notebook.
  • Full training can be expensive and is not deterministic across hardware, CUDA, and package versions.
  • The wrapper gates file accounting and command provenance, not anatomical realism, reconstruction quality, or downstream model utility.
  • Not for clinical deployment, clinical interpretation, autonomous diagnosis, regulatory submission, or production training-data approval.

Troubleshooting

ErrorCauseFix
VAE configs/helpers were not foundNV_GENERATE_ROOT does not point at a current NV-Generate-CTMR checkout.Clone or update https://github.com/NVIDIA-Medtech/NV-Generate-CTMR and set NV_GENERATE_ROOT.
datalist must include non-empty validation[] or testing[]VAE training requires validation data for the configured validation loop.Add validation[] or testing[] entries with relative image paths.
CUDA, MONAI, or LPIPS import failureRuntime environment lacks upstream dependencies.Install "$NV_GENERATE_ROOT/requirements.txt" plus lpips tensorboard in the selected environment.

© NVIDIA, Apache-2.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 12 other files (scripts) in skills/nv-generate-vae-finetune of NVIDIA/skills.

  • SKILL.md
  • BENCHMARK.md
  • evals/evals.json
  • fixtures/README.md
  • fixtures/preflight_datalist.json
  • fixtures/preflight_dataset/imagesTr/placeholder_mri_train.txt
  • fixtures/preflight_dataset/imagesVal/placeholder_mri_val.txt
  • scripts/run_vae_finetune.py
  • skill-card.md
  • skill.oms.sig
  • skill_manifest.yaml
  • tests/test_run_vae_finetune.py
  • validators/output_schema.json

Open the folder on GitHubat commit dfdd080

Compare with similar skills

Nv Generate Vae Finetune next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Nv Generate Vae Finetune compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Nv Generate Vae Finetune this skillNVIDIA/skills3.5k—~3.1kAutomated safety check: NotesApache-2.0
Sentence-Transformers Training Routerhuggingface/skills11k1 repos~2.6kAutomated safety check: PassApache-2.0
Train RlOpenPipe/ART11k—~2.4kAutomated safety check: PassApache-2.0
Qwopus27b Rl TrainingR6410418/Jackrong-llm-finetuning-guide1.7k—~830Automated safety check: PassApache-2.0
Dataset Evaluationawslabs/agent-plugins9151 repos~1.3kAutomated safety check: PassApache-2.0
Train SftOpenPipe/ART11k—~2.9kAutomated safety check: PassApache-2.0

Similar skills

  • Official

    Routes a sentence-transformers training task to the right model type and required reference docs and example scripts, covering bi-encoders, rerankers, sparse and multi-vector models.

    11k GitHub starsUsed in 1 repo~2.6k tokens
    AI & LLM EngineeringAuto-check passed
  • Train Rl

    OpenPipe/ART

    RL training reference for the ART framework. An agent skill from OpenPipe/ART.

    11k GitHub stars~2.4k tokensUpdated today
    AI & LLM EngineeringAuto-check passed
  • Qwopus27b Rl Training

    R6410418/Jackrong-llm-finetuning-guide

    Prepare, validate, launch-plan, monitor, resume, and stop configurable Qwopus 27B reinforcement-learning workflows for GRPO or GSPO.

    1.7k GitHub stars~830 tokensUpdated 3 mo ago
    AI & LLM EngineeringAuto-check passed
  • Dataset Evaluation

    awslabs/agent-plugins

    Official

    Validates dataset formatting and quality for SageMaker model fine-tuning (SFT, DPO, or RLVR).

    915 GitHub starsUsed in 1 repo~1.3k tokens
    AI & LLM EngineeringAuto-check passed
  • Train Sft

    OpenPipe/ART

    SFT training reference for the ART framework. An agent skill from OpenPipe/ART.

    11k GitHub stars~2.9k tokensUpdated today
    AI & LLM EngineeringAuto-check passed
  • Fine Tuning With Trl

    Orchestra-Research/AI-Research-SKILLs

    Fine-tune LLMs using reinforcement learning with TRL - SFT for instruction tuning, DPO for preference alignment, PPO/GRPO for reward optimization, and reward model training.

    13k GitHub starsUsed in 6 repos~2.9k tokens
    AI & LLM EngineeringAuto-check passed

More from NVIDIA/skills

All 386 skills in this repo
  • Official

    A skill your agent uses when the user wants to deploy, run, debug, tear down, or call the REST API of the RTVI-CV 2D detection / tracking microservice.

    3.5k GitHub starsUsed in 1 repo~4.5k tokens
    Auto-check passed
  • Official

    Generates, validates, compares and explains HOLOLINK_def.svh macro files for the HSB IP, using bundled Python scripts and asking before it writes anything.

    3.5k GitHub stars~2.9k tokensUpdated today
    Auto-check passed
  • Official

    Runs and validates an end-to-end Mission Control demo in a locally installed Isaac Sim, with a Nova Carter robot driven through a Python server.

    3.5k GitHub stars~4.8k tokensUpdated today
    Auto-check passed
  • Orchestrates defect image generation for PCBA, metal surface and glass inspection with NVIDIA Cosmos AnomalyGen on OSMO, from cold-start Day 0 to real-photo Day 1 labeling.

    3.5k GitHub stars~5k tokensUpdated today
    Auto-check: notes
  • Orchestrates video data augmentation and auto-labeling workflows on OSMO, from flow selection and preflight checks to submission, monitoring and output download.

    3.5k GitHub stars~4.7k tokensUpdated today
    Auto-check: notes
  • Official

    Runs NVIDIA TAO Data Services KPI analysis on object detection results, comparing predictions to ground truth and writing per-class precision, recall and AP to a CSV.

    3.5k GitHub stars~2.7k tokensUpdated today
    Auto-check: notes

Questions about Nv Generate Vae Finetune

What does Nv Generate Vae Finetune do?

Used for finetuning the NV-Generate-CTMR MAISI VAE from CT/MRI NIfTI datalists. Nv Generate Vae Finetune is an agent skill from NVIDIA/skills, published by the product's own GitHub organization. Used for finetuning the NV-Generate-CTMR MAISI VAE from CT/MRI NIfTI datalists.

When should I use Nv Generate Vae Finetune?

Nv Generate Vae Finetune fits situations like: tasks that involve Fine-tuning.

How do I install Nv Generate Vae Finetune in Claude Code?

Run `npx skills add NVIDIA/skills --skill nv-generate-vae-finetune -a claude-code`. Or copy the skill folder (skills/nv-generate-vae-finetune in NVIDIA/skills) into .claude/skills/nv-generate-vae-finetune in your project. Claude Code loads it when a task matches its description.

How do I install Nv Generate Vae Finetune in Codex?

Run `npx skills add NVIDIA/skills --skill nv-generate-vae-finetune -a codex`. Or copy the skill folder (skills/nv-generate-vae-finetune in NVIDIA/skills) into .agents/skills/nv-generate-vae-finetune in your project. Codex loads it when a task matches its description.

Can I use Nv Generate Vae Finetune in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add NVIDIA/skills --skill nv-generate-vae-finetune -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/nv-generate-vae-finetune, .gemini/skills/nv-generate-vae-finetune, .github/skills/nv-generate-vae-finetune and .opencode/skills/nv-generate-vae-finetune in your project.

What does Nv Generate Vae Finetune need to run?

Going by SKILL.md and its folder, Nv Generate Vae Finetune needs Python for the scripts in its folder and the command-line tools its instructions call (python and git). Our summary lists: Python 3. Its frontmatter pre-approves these tools: Bash.

Does Nv Generate Vae Finetune access the network?

SKILL.md names 3 domains. In commands or code: github.com, huggingface.co and download.pytorch.org; the agent is likely to contact these when it follows the instructions. This is read from the text; nothing was executed.

Is Nv Generate Vae Finetune safe to install?

Our automated static check of SKILL.md found notes only (pre-approves every shell command (allowed-tools: bash)), nothing it rates as a warning. It is not a guarantee. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.

What licence does Nv Generate Vae Finetune use?

Nv Generate Vae Finetune is published under the Apache-2.0 licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Nv Generate Vae Finetune use?

About 3.1k tokens (SKILL.md is roughly 12k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Nv Generate Vae Finetune?

Skills that share tags, products or a category with Nv Generate Vae Finetune: Sentence-Transformers Training Router (huggingface/skills, 11k stars), Train Rl (OpenPipe/ART, 11k stars), Qwopus27b Rl Training (R6410418/Jackrong-llm-finetuning-guide, 1.7k stars) and Dataset Evaluation (awslabs/agent-plugins, 915 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Nv Generate Vae Finetune?

NVIDIA (a GitHub organization, an official publisher) maintains it in NVIDIA/skills, which has 3,546 GitHub stars. The repository holds 386 skills in this directory. The repository was last updated on October 9, 2026.

Source: NVIDIA/skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.