NV-Generate-CT Synthetic CT Generator
Generate paired synthetic CT volumes and masks through NVIDIA’s rflow-ct pipeline.
The skill limits itself to Bash, mandates a fixed wrapper, caller-provided output directories, no deletion, and discloses output writes, cache locations, and Hugging Face/GitHub network access. It also clearly warns about synthetic data, non-clinical use, and review requirements. Points are deducted because general user-confirmation handling, sensitive-data handling, dependency-integrity checks, and rollback are incomplete.
The documentation specifies a fixed entrypoint, deterministic seeds, preflight checks, output validation, troubleshooting, and retention of failure evidence; BENCHMARK reports limited evaluation results. Because nothing was executed here and the benchmark has only two tasks without reproducible full-path test coverage, the score is conservatively limited below the static ceiling.
The target use—synthetic CT volumes and masks—is clear, with stated inputs, outputs, hardware prerequisites, non-fit uses, preflight behavior, and advanced-mode boundaries. Points are deducted because Chinese-language support is not stated and the core workflow depends on CUDA, about 5.5 GB of downloads, and Hugging Face/GitHub access, creating possible mainland-China reachability constraints.
The skill provides readable purpose, instructions, script inventory, prerequisites, limitations, troubleshooting, usage, fixtures, and a pinned upstream revision; license and author metadata are explicit. Points are deducted for the missing recommended Examples section, incomplete skill-specific changelog/version governance and maintenance ownership, and reliance on referenced manifest/materials not included in the supplied evidence.
The wrapper directly produces paired NIfTI outputs, result_json, a summary card, and validation evidence, while fixtures cover several anatomical regions. Points are deducted for GPU and large model/data requirements, and because the two-task benchmark reports relatively weak effectiveness signals and cannot establish broad output quality from static evidence alone.
The documentation pins an upstream commit, states that upstream commits and model hashes are recorded, and defines preflight and evidence fields; the BENCHMARK adds limited evaluation evidence. Points are deducted because there was no execution during this review and no complete reproducible test suite or independently corroborated third-party execution artifacts were supplied.
- Execution downloads about 5.5 GB of model/data assets and may contact Hugging Face/GitHub; verify network, licensing, and cache policy first.
- At least about 16 GB VRAM is required, with larger outputs potentially needing an A100/H100; run --preflight-only first.
- Outputs are synthetic research data and should not be used clinically, for regulatory submission, or as production training data without independent quality review.
- The documentation requires skill_manifest.yaml and referenced materials, but they were not supplied here, so those constraints could not be fully verified.
What does this skill do, and when should you use it?
This skill invokes the rflow-ct workflow from NVIDIA-Medtech/NV-Generate-CTMR to generate synthetic CT volumes and masks. Its wrapper stages configuration, manages output paths, records label-mapping evidence, and performs validation instead of reimplementing inference, sampling, or decoding. Execution requires CUDA and an NVIDIA GPU with at least 16 GB of VRAM; initial setup also requires about 5.5 GB of model and mask-candidate data. Outputs are for synthetic research only and require independent quality review before any production medical-AI training use; they are not for clinical deployment or interpretation.
Reads a config_infer.json override, runs scripts/run_rflow_ct.py, and writes results under a caller-provided --output-dir. It invokes the upstream scripts.inference entry point and can produce paired CT images and masks, result_json, and an optional summary.html. Each run performs checks for configuration, anatomy names, output size and spacing, datasets, CUDA, estimated VRAM, and wall time; its evidence records the upstream commit, checkpoint hashes, rendered configuration, image/mask geometry, label set, HU-range summary, and per-class voxel volumes.
- A medical-imaging researcher needs paired synthetic CT and labels for chest lung-lobe or controllable lung-tumor studies.
- A medical-AI engineer needs research samples involving abdominal solid organs or controllable hepatic tumors.
- An evaluator wants to validate a configuration and preview estimated resource cost before launching inference.
- A developer needs to diagnose raw MAISI mask generation, generate CT from an existing label mask, or create CT images without paired labels.
What are this skill's strengths and limitations?
- Wraps a pinned upstream rflow-ct entry point without requiring custom inference code for normal runs.
- Provides preflight checks, label-mapping evidence, geometry validation, and a visual summary card.
- Supports controllable anatomy size, paired CT/mask generation, and several advanced diagnostic helpers.
- Requires CUDA and an NVIDIA GPU with at least 16 GB of VRAM; there is no CPU fallback.
- Larger outputs may require an A100 or H100, while initial setup may download about 5.5 GB and contact Hugging Face or GitHub.
- Synthetic outputs are not suitable for production training without independent review and are not for clinical deployment, interpretation, autonomous diagnosis, or regulatory submission.
- The supplied material does not show an independent test suite or cross-platform test results.
How do you install this skill?
Install the individual skill with the CLI documented in the repository README: npx skills add nvidia/skills --skill nv-generate-ct-rflow --yes. Set NV_GENERATE_ROOT at runtime; in a fresh environment, install upstream requirements with python -m pip install -r "$NV_GENERATE_ROOT/requirements.txt". The first setup also requires cloning the pinned NV-Generate-CTMR checkout and downloading rflow-ct weights plus mask-candidate data as documented by the skill. No additional platform-specific installation procedure is documented.
How do you use this skill?
Prepare a config_infer.json override and run from the medical-AI-skills repository root: 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 skills/nv-generate-ct-rflow/scripts/run_rflow_ct.py PATH_TO_CONFIG_INFER.json --output-dir runs/nv_generate_ct_rflow_demo --random-seed 0 --version rflow-ct. Replace PATH_TO_CONFIG_INFER.json with the actual request path. Afterward, inspect result_json, the paired verifier guidance, and summary.html before treating the run as evidence. Runs estimated above five minutes or 30 GB peak VRAM require --yes.