MONAILabel 0.8.5 on AMD Instinct™ GPUs: Interactive Medical-Image Annotation MONAILabel 0.8.5 is now available as an Early Access release on AMD Instinct GPUs via AMD Life Science 26.08, which supports ROCm 10.0, AMD reported. On an AMD Instinct MI355X with ROCm 10.0, model inference ran 131× faster than host CPU in like-for-like fp32 (median; range 115–133×), with per-volume inference at roughly 0.05–0.12 s in bf16 and a single 96³ patch taking about 5.5–7.8 ms, while CPU–GPU numerical parity held at a maximum absolute error of about 4.6×10⁻⁶ against a 5×10⁻² tolerance. The port is deliberately small, confined to three files — a rocm-smi VRAM fallback in generic.py, a backend-agnostic /gpu endpoint in logs.py, and Dockerfile documentation — with no Python API changes and no new GPU kernels, so existing MONAI bundles and configs run unmodified. MONAILabel 0.8.5 on AMD Instinct™ GPUs: Interactive Medical-Image Annotation monailabel-0-8-5-on-amd-instinct-gpus-interactive-medical-image-annotation Behind every well-trained medical imaging model is a painstakingly labeled dataset, and behind that dataset is a human expert drawing contours one slice at a time. MONAILabel exists to make that human faster. Developed by Project MONAI Medical Open Network for AI , it is a widely used open-source active-learning annotation server for medical imaging. It bridges 3D Slicer, the Open Health Imaging Foundation OHIF Viewer, and QuPath to MONAI-powered deep learning models, so radiologists and researchers can label 3D computed tomography CT and magnetic resonance imaging MRI volumes and whole-slide images interactively, with the model suggesting and the human refining. With AMD Life Science 26.08 https://rocm.docs.amd.com/projects/lifescience/en/latest/ , which supports ROCm™ 10.0 , MONAILabel 0.8.5 comes to AMD Instinct™ GPUs as an Early Access release. In this blog you will learn how the port works, explore its performance on a real spleen CT segmentation workload, and see how you can try it yourself. This post is part of a series on the AMD Life Science medical-imaging stack. The companion posts cover the hipCIM image-I/O library https://rocm.blogs.amd.com/software-tools-optimization/hipcim-26-08/README.html , MONAI data loading https://rocm.blogs.amd.com/artificial-intelligence/monai-hipcim-2608/README.html , and validated Model Zoo inference https://rocm.blogs.amd.com/artificial-intelligence/monai-zoo-2608/README.html . At a Glance at-a-glance The table below summarizes the headline results, all measured on AMD Instinct™ MI355X with ROCm 10.0. | Metric | Result | Hardware | Baseline / workload | |---|---|---|---| | Model inference vs CPU like-for-like, fp32 | 131× median; range 115–133× | MI355X with ROCm 10.0 | host CPU, fp32 | | Per-volume inference as deployed, bf16 | ~0.05–0.12 s | MI355X with ROCm 10.0 | 4 spleen CT volumes | | Single 96³ patch inference, GPU | ~5.5–7.8 ms | MI355X with ROCm 10.0 | — | | CPU–GPU numerical parity | maximum absolute error ~4.6×10⁻⁶ | MI355X with ROCm 10.0 | float32; tolerance 5×10⁻² | Table 1. Summary of the results in this post. Why This Matters for Annotation why-this-matters-for-annotation Annotation is a conversation. Each cycle runs the same loop: load the volume, run inference to propose a segmentation, let the annotator correct it, and feed the correction back. For that loop to stay productive, every inference has to return in seconds. On a CPU, sliding-window inference over a full CT volume can drag on for minutes, and the annotator sits waiting. On an AMD Instinct™ GPU, the same pipeline finishes in seconds, and the conversation keeps flowing. With AMD Life Science, teams get this speedup without changing their workflows. The port is framework-transparent: all GPU compute runs through PyTorch-ROCm, where HIP presents itself as torch.cuda. . Existing model configs, sample apps, and MONAI bundles run without modification. The annotator’s experience hasn’t changed; it’s only been made faster. A Deliberately Small Port a-deliberately-small-port One of the strengths of this port is its small footprint. The entire functional ROCm enablement lives in three files , listed in Table 2 below, with no changes to the Python API and no new GPU kernels: | File | Change | |---|---| | monailabel/utils/others/generic.py | gpu memory map gains a rocm-smi --showmeminfo vram --csv fallback, so AMD VRAM is monitored correctly when nvidia-smi is absent | | monailabel/endpoints/logs.py | the /gpu REST endpoint becomes backend-agnostic, dispatching to whichever GPU tool is present, nvidia-smi or rocm-smi | | Dockerfile | documents the AMD ROCm base image and AMD PyPI wheel index alongside the existing CUDA instructions | Table 2. The three files changed by the port. Because the port works at the framework level rather than by rewriting GPU kernels, every future upstream MONAI update inherits AMD GPU support automatically. There is no fork to maintain and no kernel to keep in sync. Performance on AMD Instinct™ MI355X performance-on-amd-instinct-mi355x The headline inference figures below come from the configuration in System Configuration system-configuration . Model inference is timed over four spleen CT volumes from the Medical Segmentation Decathlon Task09 Spleen , and the CPU baseline is the same model at the same fp32 precision on the host CPU, an AMD Ryzen™ Threadripper™ PRO 7955WX with 32 threads pinned . CPU–GPU parity is checked against the CPU output at fp32 tolerance 5×10⁻² . The offline unit suite 57/57 PASS was run on the same MONAILabel 0.8.5 wheel. The Core Operation: Model Inference the-core-operation-model-inference Every annotation cycle runs the same segmentation model over the volume the annotator is working on, so model-inference latency is what the annotator experiences. On MI355X with ROCm 10.0, that inference runs 131× faster than the same model on a host CPU at the same fp32 precision median across four spleen CT volumes from the Medical Segmentation Decathlon Task09; range 115–133× . As deployed, with bf16 autocast, each volume’s inference completes in roughly 0.05–0.12 s . At fp32, it completes in about 0.13–0.28 s. The smallest unit of that work, a single 96³-voxel sliding-window patch through the BasicUNet-3D backbone 5.7M parameters , runs in single-digit milliseconds on MI355X. The range of ~5.5–7.8 ms brackets three independent measurement runs of the same patch rather than variation within one run. The headline figure is the like-for-like fp32 volume ratio rather than a patch-level speedup, and that is deliberate. The two behave differently. A patch-level ratio depends entirely on which CPU baseline you pick: on one machine it moves from 178× to 356× by changing the thread count alone. The volume-level, same-precision ratio does not move that way, which is why 131× is the number quoted here and why the baseline part and thread count are stated with it. Speed doesn’t come at the cost of correctness: the maximum absolute error between CPU and GPU outputs is ~4.6×10⁻⁶ . This is within float32 accumulation rounding and far tighter than the 5×10⁻² tolerance, so parity passes. What the Annotator Waits For what-the-annotator-waits-for Unlike a single inference, a complete annotation request loads and resamples the volume, runs sliding-window inference, and writes the result back. With model inference now taking a fraction of a second, that step is no longer the bottleneck. Across the spleen volumes, pre-processing and file I/O account for 94–99% of a warm request , meaning one where the server and model are already loaded so no start-up cost is counted, and GPU inference is the small remainder. The GPU has, in effect, made model inference free within the request. What is left is data movement, the cost of which scales with volume size and host page-cache state rather than with the GPU. The practical takeaway for an annotation team is simple: the model is no longer what you wait on, and the interactive loop stays responsive. Every request produces a valid segmentation mask entirely on the GPU device: cuda throughout . MONAILabel and hipCIM Together monailabel-and-hipcim-together MONAILabel doesn’t need hipCIM https://rocm.docs.amd.com/projects/hipCIM/en/docs-26.08/ , AMD’s GPU-accelerated image I/O library, to run. However, MONAILabel runs faster when hipCIM is present. hipCIM plugs into the radiology sample app through MONAI’s optional cuCIM integration. When both cucim provided by hipCIM and CuPy are installed, MONAI moves the connected-component post-processing step from CPU to GPU. With amd-hipcim installed, MONAI reports has cucim=True . Adding amd-cupy then activates the GPU connected-component path, which takes the post-processing and connected-component stage off the CPU. hipCIM’s GPU image I/O is also available independently of CuPy for other stages of the pipeline. This is a preview of how the AMD Life Science components reinforce one another. Getting Started getting-started MONAILabel on ROCm needs an AMD Instinct™ GPU with ROCm 10.0 for the 26.08 release, Python 3.12, and a PyTorch-ROCm wheel. The recommended setup pulls ROCm-validated packages from the AMD ROCm package index https://pypi.amd.com/rocm-10.0.0/simple/ , or starts from a ROCm PyTorch Docker image https://hub.docker.com/r/rocm/pytorch : From the AMD PyPI index ROCm-validated packages pip install monailabel --extra-index-url https://pypi.amd.com/rocm-10.0.0/simple/ Start the radiology sample app and run spleen segmentation monailabel start server --app radiology --studies