PyRadiomics-cuda: 3D features extraction from medical images for HPC using GPU acceleration

PyRadiomics-cuda is a GPU-accelerated extension of the PyRadiomics library that dramatically speeds up 3D medical image feature extraction for high-throughput AI workflows while maintaining full API compatibility across diverse hardware environments.

The Gist

Imagine you are a doctor trying to diagnose a patient. You have a 3D scan of their body (like a CT scan), and you want to measure the exact shape of a tumor inside. You need to know its volume, surface area, and the longest distance across it (diameter).

Doing this mathematically on a computer is like trying to count every single grain of sand on a beach to measure the beach's size. For a small patch of sand, it's easy. But for a whole beach? It takes forever.

This is the problem with PyRadiomics, a popular computer program used by scientists to analyze medical images. It's great, but when it tries to measure the 3D shapes of tumors in large scans, it gets stuck in "traffic." It spends 99% of its time just calculating the longest distance across the shape, leaving the computer CPU (the brain) exhausted and waiting.

The Solution: PyRadiomics-cuda

The authors of this paper built a super-charged version of this tool called PyRadiomics-cuda. Think of it as taking that slow, single-lane road (the CPU) and turning it into a massive, 100-lane highway (the GPU).

Here is how they did it, using some simple analogies:

1. The "Construction Crew" Analogy (Mesh Generation)

To measure a 3D shape, the computer first has to build a digital "skeleton" or "mesh" out of triangles, kind of like wrapping a gift in paper made of tiny triangles.

• The Old Way (CPU): Imagine one single construction worker walking through the entire 3D scan, checking every single pixel, and placing one triangle at a time. It's slow and methodical.
• The New Way (GPU): Imagine hiring 10,000 construction workers. They all split up the job. Worker A handles the top left corner, Worker B handles the bottom right, and so on. They all place their triangles simultaneously. This is what the CUDA (GPU) technology does.

2. The "Race to the Finish" Analogy (Diameter Calculation)

The hardest part is finding the "diameter"—the two points on the tumor that are farthest apart.

• The Old Way: The computer checks every possible pair of points against every other pair. It's like asking a single person to shake hands with everyone in a stadium of 100,000 people, one by one, to see who is the farthest away.
• The New Way: The GPU splits the stadium into sections. Each section has a team that finds the two farthest people in their section. Then, the teams quickly compare their results to find the absolute farthest pair. This "divide and conquer" strategy happens in milliseconds.

The Magic Trick: "Plug and Play"

Usually, when you upgrade a computer system to use a super-fast GPU, you have to rewrite all your software code. It's like buying a Ferrari engine but having to rebuild your entire house to fit it.

The authors made PyRadiomics-cuda special because it is transparent.

• No Code Changes: You don't need to be a programmer to use it. If you have a script that says "Calculate the tumor size," you just run it.
• Smart Switching: The software is like a smart traffic cop. It looks at your computer.
  • If you have a powerful GPU: "Great! Send the heavy lifting to the GPU highway!"
  • If you only have an old laptop: "No problem, we'll use the CPU road. It will be slower, but it will still work."
  • You don't have to tell it which one to use; it figures it out automatically.

The Results: From Hours to Seconds

The researchers tested this on three types of computers:

1. A Supercomputer Cluster (The H100): Like a Formula 1 race car.
2. A Modern Desktop (RTX 4070): Like a high-performance sports car.
3. An Old Server with a Budget GPU (T4): Like a reliable, older sedan.

The outcome?

• On the Supercomputer, they made the process 2,000 times faster. A task that took 2 minutes now takes less than a second.
• On the Budget GPU, they still got a 20x speedup.
• Even on the Desktop, they cut the time by 8 times.

Why Does This Matter?

In the world of medical AI, scientists need to analyze thousands of scans to train computers to detect cancer.

• Before: Analyzing 40,000 lung scans might take weeks of computer time, costing a fortune in electricity and server rental.
• After: With PyRadiomics-cuda, that same job could take hours or even minutes.

It's like going from hand-copying a library of books to using a high-speed photocopier. The information is exactly the same, but the time and money saved are enormous. This allows doctors and researchers to process data faster, leading to quicker discoveries and better patient care.

Technical Summary

1. Problem Statement

Radiomics involves extracting quantitative features from medical images (CT, MRI, PET) to build predictive models for diagnosis and treatment. While the open-source library PyRadiomics is the industry standard, it faces severe scalability issues when processing large 3D volumetric datasets.

• The Bottleneck: The extraction of 3D shape features (e.g., mesh volume, surface area, maximum 3D diameter) is computationally intensive.
• Complexity: Operations like mesh generation (Marching Cubes) and pairwise distance calculations for diameter have high computational complexity ($O(n^3)$ and $O(m^2)$ respectively).
• Impact: In large Regions of Interest (ROIs), PyRadiomics can spend up to 99.9% of its processing time on diameter calculations. This limits the feasibility of high-throughput AI pipelines, such as the xLUNGS project involving ~40,000 CT scans.
• Limitations of Existing Solutions: Previous GPU-accelerated attempts (e.g., experimental forks using PyCUDA/CuPy or the library cuRadiomics) either lacked backward compatibility with the PyRadiomics API, required significant code restructuring, or failed to compute geometric properties (focusing only on texture/first-order stats).

2. Methodology

The authors developed PyRadiomics-cuda, a GPU-accelerated extension that offloads specific geometric computations to NVIDIA hardware while maintaining full API compatibility with the original library.

Core Design & Architecture

• Targeted Acceleration: The system focuses exclusively on the Shape feature class, specifically:
  1. Mesh Generation: Creating a triangle mesh from the 3D ROI using a parallelized version of the Marching Cubes algorithm.
  2. Metric Calculation: Computing mesh volume, surface area, and maximum 3D/planar diameters.
• Seamless Integration:
  • Uses a build-time injection mechanism via setuptools.
  • Automatically detects the NVIDIA CUDA compiler (nvcc).
  • Runtime Dispatcher: At runtime, the system queries for a CUDA-capable device. If available, it offloads computation to CUDA kernels; if not, it gracefully falls back to the original CPU implementation. This ensures zero code changes for end-users.

Algorithmic Optimizations

The authors implemented and tested several optimization strategies for the GPU kernels, focusing on the diameter calculation (the primary bottleneck):

1. Parallel Marching Cubes: Each voxel is processed in a separate thread. Threads detect isosurfaces, compute triangles, and update global volume/surface area accumulators.
2. Parallel Diameter Calculation: A divide-and-conquer approach where threads compute distances for subsets of vertex pairs, storing local maxima in accumulators.
3. Optimization Strategies Tested:
   • Load Balancing: Basic thread distribution.
   • Block-based Atomic Reductions: Using atomic operations for accumulation.
   • Shared Memory Optimization: Loading data into 2D structures in shared memory (effective on older hardware).
   • Local Thread Accumulators: Reducing atomic operations by using local registers (most effective on modern GPUs like RTX 4070).
   • Memory Access Patterns: Simplifying 2D structures to 1D arrays (found to offer negligible improvement).

3. Key Contributions

1. API Transparency: Unlike previous GPU adaptations, PyRadiomics-cuda maintains full backward compatibility with the original PyRadiomics API, allowing immediate integration into existing AI workflows.
2. Robust Fallback Mechanism: The system automatically handles environments without GPUs, ensuring reliability across diverse hardware configurations (from research clusters to home devices).
3. Comprehensive Optimization: The paper provides a rigorous micro-benchmarking study comparing different parallelization strategies (atomic vs. local accumulation) across different GPU generations (H100, RTX 4070, T4).
4. Open Source: The tool is released under the BSD license, filling a gap in the open-source radiomics ecosystem for high-performance geometric feature extraction.

4. Results

The system was tested on three distinct hardware configurations using the KITS19 (Kidney Tumor Segmentation) dataset:

• Hardware:
  1. Modern Cluster (NVIDIA H100, AMD EPYC 9534).
  2. Desktop (NVIDIA RTX 4070, AMD Ryzen 5 7600x).
  3. Budget/Old Server (NVIDIA T4, Intel Xeon E5649).
• Performance Metrics:
  • Diameter Calculation: This step accounts for 95.7% to 99.9% of total processing time on CPU.
  • Speedup:
    • Budget GPU (T4): 8x to 24x speedup for 3D feature extraction.
    • Modern GPU (RTX 4070/H100): 50x to 2,000x speedup compared to the Intel Xeon CPU baseline.
    • End-to-End Workflow: For large files (>200k vertices), the total workflow speedup on a desktop was 8x.
  • Scalability: The speedup increases significantly with the number of vertices (dataset size). For small datasets, file I/O dominates, limiting speedup, but for large datasets, the GPU acceleration is transformative.
  • Overhead: Data transfer between CPU and GPU was negligible compared to the computation time savings; no performance degradation was observed.

5. Significance

• Enabling Large-Scale AI: PyRadiomics-cuda solves the scalability bottleneck for massive medical imaging projects (e.g., the xLUNGS project with 40,000 scans), making high-throughput radiomics feasible without prohibitive infrastructure costs.
• Cost Efficiency: By drastically reducing processing time, it lowers the cost of utilizing expensive HPC clusters and accelerates the training of AI models.
• Bridging HPC and Clinical Practice: It successfully bridges high-performance computing techniques with practical biomedical analysis by integrating directly into the most widely used radiomics library without requiring users to be CUDA experts.
• Reproducibility: By providing an open-source, drop-in replacement, it ensures that future large-scale studies can be conducted reproducibly with standardized, accelerated feature extraction.