AtlasPatch: Efficient Tissue Detection and High-throughput Patch Extraction for Computational Pathology at Scale

AtlasPatch is an open-source, scalable framework that leverages an adapted Segment-Anything model to achieve robust, high-precision tissue detection and high-throughput patch extraction, reducing whole-slide image preprocessing time by up to 16-fold while maintaining downstream task performance for computational pathology applications.

The Gist

Imagine you are a master chef trying to create a massive, world-class soup (a new medical AI) using millions of tiny ingredients (tissue samples) from thousands of different farms (hospitals).

The problem? The ingredients are delivered in giant, 100-foot-long scrolls of paper (Whole Slide Images or WSIs). Most of the scroll is just blank white space or messy coffee stains (background and artifacts). To make the soup, you need to cut out only the actual vegetable pieces, but doing this by hand for millions of scrolls would take forever and cost a fortune.

AtlasPatch is the new, super-fast, automated kitchen robot designed to solve this exact problem.

Here is how it works, broken down into simple concepts:

1. The "Thumbnail" Shortcut

Most old methods try to look at the entire giant scroll at full resolution to find the vegetables. This is like trying to find a specific grain of rice in a stadium by walking every single inch of the floor. It's slow and exhausting.

AtlasPatch is smarter. It first shrinks the giant scroll down to a tiny, low-resolution thumbnail (like looking at a map of a city instead of walking every street).

• The Analogy: Instead of walking the whole city to find the bakery, you look at a map, spot the bakery district, and then zoom in only on that specific area.
• The Result: It finds the tissue on the tiny thumbnail in a split second, then mathematically "zooms back out" to tell the robot exactly where to cut the real, high-quality pieces. This saves a massive amount of time.

2. The "Smart Eye" (The AI Brain)

Once it has the thumbnail, AtlasPatch uses a special pair of "smart glasses" (an AI model called SAM2) to draw a line around the tissue.

• The Challenge: Pathology slides are messy. Some are bright, some are dark, some have ink pen marks, and some are torn into tiny pieces. Old "smart glasses" often get confused by these messes and cut out the ink or miss the torn pieces.
• The Fix: The creators of AtlasPatch didn't just buy off-the-shelf glasses. They trained them on a massive, diverse library of about 30,000 different slides from many different hospitals and scanners. They taught the AI to ignore pen marks, ink stains, and scanner streaks, focusing only on the actual biological tissue.
• The Analogy: Imagine training a dog to find a specific type of ball. Most dogs might chase any round object. AtlasPatch's dog was trained on thousands of different balls in different lighting, so it knows exactly what to fetch and ignores the rocks and leaves.

3. The "Efficient Chef" (Saving Resources)

Old methods often try to cut out every single patch of the slide, even the empty background, and then throw the bad ones away later. This is like a chef chopping up the entire tablecloth just to get a few carrots, then throwing the cloth away. It wastes time and storage space.

AtlasPatch is efficient:

• It cuts only what is needed: Because it knows exactly where the tissue is, it only extracts the useful patches.
• It's fast: It processes slides 16 times faster than the current popular tools.
• It's accurate: Despite being fast, it doesn't miss the important parts. In fact, because it ignores the background noise, the "soup" (the final AI model) actually tastes better (performs better) because it isn't distracted by useless data.

4. Why Does This Matter?

We are entering an era of "Foundation Models" in medicine—super-AIs that need to learn from billions of images to become truly smart.

• The Bottleneck: Before, the slow process of cutting and organizing these images was the biggest bottleneck. It was like having a Ferrari engine (the AI) but trying to drive it with a bicycle chain (the preprocessing).
• The Solution: AtlasPatch replaces the bicycle chain with a high-speed transmission. It allows researchers to process huge datasets quickly, making it possible to train these super-AIs on the massive amounts of data they need to save lives.

In Summary

AtlasPatch is a free, open-source tool that acts like a super-fast, ultra-precise scanner. It looks at a tiny preview of a medical slide, uses a highly trained AI to find the real tissue while ignoring the mess, and then instantly tells the computer exactly where to cut the useful pieces. It turns a job that used to take days into something that takes minutes, without losing any quality.

Technical Summary

1. Problem Statement

Whole-slide image (WSI) preprocessing is a critical bottleneck in computational pathology, particularly as the field shifts toward foundation models requiring billions of diverse patches. Current challenges include:

• Inefficiency: Naïve tiling of gigapixel WSIs generates millions of background patches, inflating I/O, memory usage, and wall-clock time.
• Robustness Issues:
  • Threshold-based methods (e.g., HistoQC, CLAM) are fast but fail under varying stain conditions, tissue fragmentation, or artifacts (e.g., pen marks, scanner streaks), often requiring manual threshold tuning per cohort.
  • Patch-based Deep Learning methods (e.g., Trident) improve robustness but scale poorly, requiring thousands of forward passes per slide, leading to high computational costs.
  • General Foundation Models (e.g., standard SAM) lack domain-specific adaptation for histopathology, leading to inconsistent tissue detection.
• Scalability: Existing pipelines often lack end-to-end parallelization, making them unsuitable for the massive datasets required by modern foundation models.

2. Methodology

AtlasPatch is a modular, end-to-end Python pipeline designed to decouple tissue detection from patch extraction while maximizing efficiency.

A. Data Curation

• Dataset: A heterogeneous corpus of ~36,000 WSI thumbnails was curated from four centers (CHUM, TCGA, Radboud UMC, Karolinska) covering multiple organs (breast, lung, kidney, prostate, etc.) and stain types (H&E and IHC).
• Annotation: A semi-manual workflow using Labelbox was employed. Annotators refined automated masks or drew boundaries on thumbnails, with quality control by board-certified pathologists. This resulted in ~30,000 high-quality tissue-vs-background mask pairs.
• Diversity: The dataset captures variations in tissue coverage, boundary definition, fragmentation, brightness, and scanner artifacts.

B. Tissue Detection Model (SAM2 Adaptation)

• Base Model: Uses Segment Anything Model 2 (SAM2), specifically the Hiera-tiny backbone, chosen for its speed (6× faster than original SAM) and hierarchical feature extraction.
• Parameter-Efficient Fine-Tuning (PEFT): Instead of full fine-tuning (which is computationally expensive and risks overfitting), AtlasPatch employs Layer Normalization (LN) Fine-Tuning.
  • Only the affine parameters ($\gamma$ and $\beta$) of the normalization layers are updated (~0.076% of total parameters).
  • This adapts the pretrained natural image features to the histopathology domain with minimal memory and training time.
• Inference Strategy:
  1. WSIs are converted to low-resolution thumbnails (e.g., 1.25x magnification).
  2. A single forward pass with a global bounding-box prompt generates a binary tissue mask.
  3. Contours are vectorized at thumbnail resolution and extrapolated to the target high-resolution (e.g., 20x/40x) using WSI pyramid metadata.
  4. Patch coordinates are generated in contour space, pruning background and artifacts without reading high-resolution pixels until necessary.

C. Pipeline Architecture

The tool is modular and parallelized:

1. Tissue Detection: Batched GPU inference on thumbnails.
2. Coordinate Extraction: Multi-core CPU parallelization to generate patch grids based on extrapolated contours.
3. Patch Embedding/Export: Optional streaming of patches into encoders (e.g., UNI, CLAM) or export to disk.
4. Parallelism: Supports concurrent processing of multiple slides and overlapping I/O with computation.

3. Key Contributions

1. High-Throughput Efficiency: AtlasPatch reduces end-to-end WSI preprocessing time by up to 16× compared to patch-based deep learning pipelines (e.g., Trident-Hest) and 2.6× compared to thumbnail-based deep learning (Trident-GrandQC), while maintaining comparable downstream performance.
2. Robustness via Heterogeneity: By training on a diverse, multi-institutional dataset and using PEFT, the model achieves high precision (0.986) and generalizes across varying scanners, stains, and tissue conditions (fragmentation, low contrast, artifacts) without manual tuning.
3. Open-Source Framework: Provides a flexible, open-source tool (GitHub) that supports both pathology departments (for QC and tissue detection) and AI researchers (for dataset creation and model training).
4. Downstream Performance Validation: Demonstrated that thumbnail-based detection is sufficient for Multiple Instance Learning (MIL) tasks, achieving state-of-the-art or superior slide-level classification accuracy across six diverse tasks (e.g., PANDA, TCGA-BRCA, LUAD vs. LUSC).

4. Key Results

• Tissue Detection Metrics: On a held-out test set of 3,000 WSIs, AtlasPatch achieved:
  • Precision: 0.986 (highest among competitors).
  • F1 Score: 0.988.
  • IoU: Outperformed thresholding methods (CLAM, TIAToolbox) and patch-based DL methods (Trident variants) in handling artifacts and fragmented tissue.
• Runtime Performance:
  • Processing 100 slides: 195.5 seconds (AtlasPatch) vs. ~400s (CLAM/Trident-GrandQC) and ~3,100s (Trident-Hest).
  • AtlasPatch is >16× faster than the most robust patch-based baseline.
• Downstream MIL Tasks:
  • AtlasPatch-derived patches achieved slide-level accuracy comparable to or exceeding baselines (e.g., 73.5% on PANDA, 97.7% on KIRC vs. KIRP).
  • Data Efficiency: Produced significantly fewer patches per slide (~3,047 vs. ~8,976 for CLAM) by excluding redundant background, reducing storage and compute burdens for downstream models.
• Ablation Studies:
  • Training on restricted subsets (single scanner or specific tissue brightness) caused significant performance drops (up to 44% precision loss), validating the necessity of the heterogeneous training set.
  • The Hiera-tiny backbone with LN fine-tuning offered the best trade-off between performance and computational cost.

5. Significance

AtlasPatch addresses the "preprocessing tax" that currently limits the scalability of computational pathology. By shifting the paradigm from patch-level inference to thumbnail-level detection with contour extrapolation, it enables:

• Foundation Model Training: Facilitates the processing of billions of patches required for training large-scale pathology foundation models (e.g., UNI, CONCH) by drastically reducing I/O and compute overhead.
• Clinical Scalability: Makes high-throughput digital pathology feasible for large cohorts and routine clinical workflows without sacrificing diagnostic accuracy.
• Reproducibility: Standardizes the preprocessing pipeline, reducing the variability introduced by manual threshold tuning or inconsistent artifact handling in existing tools.

In summary, AtlasPatch provides a computationally efficient, robust, and scalable backbone for the next generation of AI-driven pathology, ensuring that preprocessing does not become the bottleneck in the era of foundation models.