NV-Segment-CT Medical Imaging Segmentation Skill
Run VISTA3D on CT NIfTI volumes and produce verifiable label-map evidence.
The files disclose local CT NIfTI handling, isolated Python environments, network endpoints, cache writes, non-clinical scope, and the prohibition on untrusted checkpoints; no malware or credential theft is evident. However, execution creates environments, downloads an approximately 832 MB model and approximately 1.5 GB fixture, and writes to user directories without explicit pre-execution confirmation, rollback/cleanup guidance, or clear artifact-integrity verification, so 7 points are deducted.
The entrypoint, arguments, fixed label mapping, output structure, failure messages, validation gates, and two mask-summary tests are documented. Full model execution, end-to-end inference, network failures, malformed inputs, and CPU/GPU behavior are not reproduced in the supplied material, and some argument/error boundaries are thin; the static ceiling therefore supports 9 points.
Audience, CT NIfTI input, label-map and JSON outputs, and non-CT/non-diagnostic boundaries are clear. However, Chinese-language interaction and localization are not addressed, and core setup depends on Hugging Face, GitHub Raw, and an overseas S3 endpoint with no mainland-China reachability mitigation; 4 points are deducted.
The skill has clear sections for prerequisites, exact commands, limitations, troubleshooting, dependency versions, version 0.2.1, Apache-2.0 licensing, pinned upstream references, ownership, and an evaluation report. It lacks the recommended Examples section and provides limited changelog, explicit maintenance/update path, and post-install verification guidance; 4 points are deducted.
It directly supplies a VISTA3D CT segmentation entrypoint, fixed anatomy-to-label mapping, NIfTI label-map output, and structured geometry/volume/runtime evidence. The included evaluation report indicates usefulness on a positive task, but complete output depends on a large external model and runtime, static review cannot confirm the key execution path, and downstream verification and human review remain necessary; the static calibration supports 7 points.
Pinned upstream repositories and revisions, manifest and schema references, the evaluation report, and two unit tests provide auditable evidence. Coverage is limited to two benchmark tasks and helper-level tests, with no supplied CI or independently reproducible end-to-end result; the static ceiling supports 4 points.
- Obtain explicit confirmation before downloading the model, dependencies, and fixture or writing to user cache directories, and document cleanup/rollback steps.
- Do not use the output for clinical interpretation, diagnosis, or regulatory submission; inspect verifier results and require appropriate human or professional review.
- First-run setup depends on Hugging Face, GitHub Raw, and an overseas S3 download; verify mainland-China reachability or use an approved mirror/offline cache.
- Add integrity verification for model, dependencies, and datasets, plus end-to-end CI, malformed-input tests, and a changelog.
What does this skill do, and when should you use it?
NV-Segment-CT is an NVIDIA skill for segmenting CT NIfTI volumes with VISTA3D. It invokes an upstream NVIDIA helper through a fixed wrapper and produces a label map plus structured JSON evidence. Common abdominal targets include the liver, spleen, right kidney, and left kidney. It is intended for engineering validation and evidence capture, not clinical interpretation, diagnosis, or production deployment.
Reads a CT NIfTI volume, creates an isolated Python 3.10 environment, installs pinned dependencies, downloads the NVIDIA NV-Segment-CT model bundle, and runs scripts/run_vista3d.py. The manifest input is ct_volume; outputs are label_map and result_json. The evidence JSON records input geometry, output mask path, observed and unexpected label IDs, per-class voxel counts, physical volumes, runtime, model identity, and fixed checks for mask shape, affine matching, label set, foreground count, and class-volume bounds. A ground-truth path may also be recorded, but Dice is computed by the paired verifier.
- A medical-imaging engineer needs liver, spleen, or kidney masks from CT NIfTI volumes.
- A researcher needs to reproduce an experimental abdominal CT segmentation workflow with pinned model and dependency versions.
- An evaluation team needs an evidence pack containing geometry, label, and volume checks for a segmentation run.
- A development team needs to validate the wrapper and verification gates against the documented spleen fixture.
What are this skill's strengths and limitations?
- Uses pinned NVIDIA upstream code and model revisions for reproducibility.
- Provides engineering checks for label sets, foreground presence, geometry, and class volumes.
- Automatically selects CUDA when available and supports CPU fallback.
- Produces both a label map and structured JSON evidence.
- Requires Python 3.10, dependency installation, model downloads, and local filesystem writes.
- First-time setup may contact Hugging Face and raw.githubusercontent.com.
- CPU fallback is supported but slow.
- Outputs can be schema-valid but semantically empty; the skill is unsuitable for clinical interpretation, production deployment, or non-CT modalities.
- The supplied material does not document a complete test suite or cross-platform validation matrix.
How do you install this skill?
Install the skill from the NVIDIA/skills repository with: npx skills add nvidia/skills --skill nv-segment-ct --yes. Before running, provide Python 3.10 with venv support. From the repository root, create the environment and install dependencies: export NV_SEGMENT_CT_VENV="${NV_SEGMENT_CT_VENV:-$HOME/.cache/nvidia-skills/venvs/nv-segment-ct-f9f5f51}"; python3.10 -m venv "$NV_SEGMENT_CT_VENV"; "$NV_SEGMENT_CT_VENV/bin/python" -m pip install -r "https://raw.githubusercontent.com/NVIDIA-Medtech/NV-Segment-CTMR/f9f5f51b589e5dc9c23c453cf5138398e4084056/NV-Segment-CT/requirements.txt" "transformers==4.46.3" "typer>=0.9". Then download the model bundle: "$NV_SEGMENT_CT_VENV/bin/hf" download nvidia/NV-Segment-CT --revision afb51518689f71e6abb367ee6301b2cd0225c66a --local-dir skills/nv-segment-ct/bundle/. The bundle is about 832 MB. The optional spleen fixture command is python skills/nv-segment-ct/fixtures/fetch_spleen_fixture.py.
How do you use this skill?
From the skills repository root, run: "$NV_SEGMENT_CT_VENV/bin/python" skills/nv-segment-ct/scripts/run_vista3d.py PATH_TO_CT.nii.gz --label-prompts "1,3,5,14" --output-dir OUT_DIR. Use ID 1 for liver, 3 for spleen, 5 for right kidney, and 14 for left kidney. Inspect the wrapper JSON and paired verifier guidance before treating the run as evidence. Do not replace the documented entrypoint with infer.py, Medical AI Skills run, python -m nv_segment_ct, or anatomy-name-only flags.
How does this skill compare with similar options?
This skill is a thin wrapper around the upstream nvidia/NV-Segment-CT helper. Inference, preprocessing, and postprocessing are delegated to the official HuggingFacePipelineHelper in bundle/ rather than reimplemented by the wrapper.