NV-Generate Medical Imaging VAE Fine-Tuning
Fine-tune the NV-Generate-CTMR MAISI VAE on CT or MRI NIfTI training volumes.
The evidence requires preflight first, discloses output paths, network endpoints, cache writes, GPU training, and non-clinical scope, and pins a default upstream commit. However, Bash access, active Python-environment modification, user-cache writes, and external downloads remain broad; per-run confirmation, sensitive medical-data handling, isolation, and rollback are incomplete, so points are deducted.
The evidence includes input validation, staged configuration, missing-file and empty-dataloader errors, failure summaries, commit capture, and unit tests. Static review did not execute key paths, while full training depends on external upstream code, CUDA, packages, and model weights; some documented and manifest interfaces are not fully aligned, so the score remains below the static ceiling.
The skill clearly targets CT/MRI NIfTI VAE fine-tuning and documents inputs, outputs, preflight boundaries, and non-fit uses. It is limited to one CUDA GPU, large local datasets, and external downloads, with no Chinese-language support or mainland-China reachability analysis; trigger boundaries and alternatives have limited evidence, so points are deducted.
The evidence provides layered documentation, examples, parameter tables, troubleshooting, limitations, Apache-2.0 statements, a pinned upstream revision, and named ownership. However, versioning is minimal, no clear changelog or maintenance update path is provided, the static report flags the author format, and the supplied license metadata is NOASSERTION, so points are deducted.
The evidence indicates that the skill validates datalists, stages configurations, and produces autoencoder/discriminator checkpoints, TensorBoard logs, and a JSON summary. The benchmark reports two passing tasks with correctness and effectiveness measurements, but it does not verify output quality on representative medical data; domain-expert review remains necessary, so the score is conservative.
The evidence includes a pinned upstream reference, committed source, unit tests, validator configuration, and a benchmark report covering two tasks. Coverage is narrow, there are no negative-trigger cases, and static review cannot independently reproduce GPU training or validate medical results, so the score is limited.
- Do not use this skill for clinical deployment, diagnosis, regulatory submission, or production training-data approval; domain experts must assess quality and anatomical realism.
- Before execution, explicitly confirm Bash access, network downloads, user-cache writes, and active Python-environment modification; prefer an isolated environment.
- Mainland-China reachability and availability of external repositories and model-weight downloads are unverified; prepare local mirrors or offline dependencies.
- The fixture contains text placeholders only and does not establish real NIfTI training or validation performance.
What does this skill do, and when should you use it?
This skill fine-tunes the NV-Generate-CTMR MAISI VAE/autoencoder using user-supplied CT or MRI NIfTI training volumes. It reads a MONAI-style datalist and data root, stages the upstream training configuration, and runs a preflight or single-GPU training workflow through a Python runner. Outputs include autoencoder and discriminator checkpoints, TensorBoard logs, and a workflow summary. It is not intended for clinical interpretation, regulatory use, production deployment, or approval of synthetic data for production training.
Reads a MONAI-style JSON datalist containing training[] and validation[] or testing[] entries; resolves CT/MRI NIfTI image paths relative to --data-base-dir; copies and rewrites VAE configuration and environment JSON files from an NV-Generate-CTMR checkout; runs scripts/run_vae_finetune.py for preflight validation or GPU fine-tuning; and writes staged configs, model checkpoints, TensorBoard events, the best autoencoder checkpoint, and workflow_summary.json under --output-dir while reporting run status and loss history.
- A medical AI researcher can preflight a custom MRI NIfTI datalist before allocating GPU resources.
- A medical imaging engineer can fine-tune the VAE on CT or MRI volumes on one GPU while adjusting epochs, patch size, learning rate, and loss weights.
- A model developer can compare reconstruction and perceptual-loss curves across fine-tuning runs using the generated TensorBoard logs.
- A downstream diffusion-model developer can load the best autoencoder checkpoint to assess whether decoded volumes remain usable.
What are this skill's strengths and limitations?
- Provides a recommended preflight path that checks and stages inputs without launching GPU training.
- Supports CT and MRI NIfTI data and exposes controls for epochs, patch size, learning rate, reconstruction loss, and several loss weights.
- Automatically records staged configuration, checkpoints, TensorBoard logs, loss history, and run summaries.
- Clearly limits its scope and leaves clinical, anatomical-realism, and downstream-utility judgments to domain experts.
- Actual training requires an NVIDIA CUDA GPU, upstream dependencies, and model weights, and may be computationally expensive.
- The runner enforces single-GPU execution, and results are not deterministic across hardware, CUDA, and package versions.
- The datalist must include non-empty training[] and validation[] or testing[] sections.
- The source provides no independent test-suite, platform-coverage, or performance-benchmark evidence for this skill.
How do you install this skill?
Install the individual skill with the skills CLI: npx skills add nvidia/skills --skill nv-generate-vae-finetune --yes. The README does not document a separate repository-clone or manual-copy installation path; running the skill also requires an NV-Generate-CTMR checkout with its configuration, helper APIs, and runtime dependencies.
How do you use this skill?
Prepare a MONAI-style datalist and data root, then run the recommended preflight: 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. Remove --preflight only when actual training is intended and provide an NVIDIA CUDA GPU. NV_GENERATE_ROOT may point to an upstream checkout containing configs/config_maisi_vae_train.json, scripts/transforms.py, and scripts/utils.py. Example trigger: Please use nv-generate-vae-finetune to preflight this CT/MRI NIfTI datalist, then start single-GPU fine-tuning after it passes.