An automatic counting algorithm for the quantification and uncertainty analysis of the number of microglial cells trainable in small and heterogeneous datasets

This paper proposes a flexible, non-parametric automatic kernel counter that enables accurate microglial cell counting and uncertainty estimation in small, heterogeneous datasets by bypassing traditional cell detection in favor of a tailored feature extraction and single hyper-parameter training approach.

The Gist

Imagine you are a detective trying to count how many specific suspects (microglial cells) are hiding in a massive, chaotic city map (a high-resolution microscope image of a rat's spinal cord).

The city is huge, but the suspects are tiny, dark brown specks. The rest of the map is filled with noise: random clouds, streetlights, and artifacts that look like suspects but aren't.

The Problem:
Traditionally, counting these suspects has two big issues:

1. Manual Counting: A human detective has to squint at the map for hours, counting every single speck. It's boring, slow, and different detectives often get different counts because they get tired or have different opinions.
2. Old Computer Methods: Early computers tried to "find" the suspects first (like a metal detector) and then count them. But because the city is so noisy and the suspects look so different (some are spiky, some are round), the metal detector gets confused. Also, teaching a computer to "find" them requires labeling every single pixel, which is a massive amount of work.

The New Solution: The "Kernel Counter" (KC)
The authors of this paper, led by Luca Martino, came up with a clever shortcut. Instead of asking the computer to find and outline every suspect, they asked it to just count the total number based on a "vibe check" of the whole image.

Here is how their method works, broken down into simple steps:

Step 1: The "Sieve" (Filtering)

Imagine you have a giant bucket of mixed sand and gold dust. You want to count the gold.
Instead of picking out every grain of gold, you pour the bucket through a series of different sieves (filters).

• Sieve A catches only the very darkest, heaviest dust.
• Sieve B catches slightly lighter dust.
• Sieve C catches even lighter dust.

In the paper, they take the microscope image and run it through many different "color sieves." Since microglial cells are dark brown, they will stick to the "dark" sieves. The background noise (which is lighter) falls through.

• The Result: For each image, they don't get a perfect picture of the cells. Instead, they get a list of numbers: "Sieve A caught 50 blobs, Sieve B caught 120 blobs, Sieve C caught 200 blobs."
• Why this helps: It turns a messy, high-resolution picture into a simple list of numbers that is much easier for a computer to understand. It's like turning a complex painting into a simple recipe.

Step 2: The "Smart Guessing Game" (The Kernel Counter)

Now, the computer has a list of numbers (from the sieves) and a human expert's count (the "ground truth").

• The Training: The computer looks at a new image. It runs it through the sieves and gets a new list of numbers. It then looks at its "memory bank" of past images to find the ones that had the most similar sieve-results.
• The Magic: It doesn't just pick the closest match. It looks at the top 10 or 20 most similar past images and takes a weighted average of their counts.
  • If the new image looks very similar to a past image where the expert counted 10 cells, the computer leans heavily toward 10.
  • If it looks somewhat like an image with 10 cells and somewhat like one with 12, it guesses 11.

Why is this special?

1. It's Flexible: It doesn't need a huge database. Because it's "non-parametric," it gets smarter the more data you give it, but it works perfectly fine even with a tiny dataset (like 12 images).
2. It Knows When It's Unsure: This is the coolest part. The computer can tell you, "I'm pretty sure it's 15 cells," or "I'm not sure, it could be anywhere between 10 and 20." This "uncertainty score" tells the human expert when they need to double-check the image.
3. It Handles Disagreement: If three different experts look at the same image and give three different counts, the computer can learn from all of them and find the "average truth," smoothing out the human errors.

The Analogy: The "Weather Forecaster"

Think of the microglial cells as raindrops.

• Old Method: Try to count every single raindrop falling in a storm. Impossible and messy.
• The New Method: You have a bunch of sensors (the sieves) that measure humidity, wind speed, and cloud darkness. You ask an expert, "How much rain fell?"
  • The computer learns: "When the humidity is 90% and the wind is 5mph, the expert usually says 10mm of rain."
  • Now, a new storm comes. The sensors say "90% humidity, 5mph wind." The computer doesn't count drops; it just says, "Based on past patterns, I predict 10mm."
  • If the sensors are weird (e.g., 90% humidity but 50mph wind), the computer says, "I'm not sure, the prediction could be anywhere from 5 to 15mm."

Why Does This Matter?

• Speed: It's much faster than a human counting every cell.
• Cost: You don't need to hire armies of people to label every single pixel. You just need an expert to give a rough count of the whole image.
• Reliability: It admits when it's confused, preventing false confidence.
• Versatility: It works even if the images are taken in different labs with different microscopes (different lighting, different sizes).

In short, this algorithm is a smart, adaptable assistant that learns to count by looking at the "big picture" patterns rather than getting lost in the details, making it perfect for small, messy, real-world scientific data.

Technical Summary

1. Problem Statement

The paper addresses the challenge of counting microglial cells in high-resolution immunohistochemistry (IHC) images of rat lumbar spinal cord cross-sections. Key difficulties include:

• Manual Limitations: Manual counting is time-consuming, labor-intensive, and prone to intra- and inter-operator variability.
• Image Complexity: Microglial cells are small, dark brown, and highly variable in shape (ramified vs. amoeboid) depending on activation states. In high-resolution images, cells constitute a tiny fraction of pixels, while the majority of the image consists of noise or artifacts (signal-to-noise ratio is extremely low, approx. $10^4$ difference).
• Data Scarcity & Heterogeneity: Creating labeled datasets is costly, resulting in small sample sizes ($D$). Furthermore, images often exhibit heterogeneity due to varying acquisition conditions (lighting, magnification, contrast) and potential structural uncertainty in expert labeling.
• Limitations of Existing Methods:
  • Threshold-based tools (e.g., ImageJ): Often require manual parameter tuning and do not provide cell counts directly, only area/intensity.
  • Deep Learning (CNNs): Require large datasets, pixel-level annotations (which are tedious), and uniform image dimensions. They struggle with uncertainty estimation and small datasets.

2. Methodology

The proposed solution, called the Kernel Counter (KC), is a two-stage framework designed to bypass the need for object detection and focus solely on the counting regression task.

Phase P1: Tailored Feature Extraction (Image Filtering)

Instead of using generic dimensionality reduction (like PCA), the authors design a domain-specific filtering process to handle the low signal-to-noise ratio.

• Color Thresholding: The RGB images are processed using $T$ different threshold vectors $\mathbf{t}^{(k)} = [t_1, t_2, t_3]$. Pixels satisfying $p_i \leq t_i$ are kept as black (foreground), while others become white.
• Object Counting in Filtered Images: For each threshold vector, the resulting binary image is processed by a standard clustering algorithm (e.g., connected components) to count the number of black objects ($r_{kd}$).
• Feature Vector Construction: For each original image $d$, a feature vector $\mathbf{r}_d = [r_{1d}, r_{2d}, \dots, r_{Td}]$ is created. This vector represents the number of objects detected under varying sensitivity levels.
  • Low thresholds: Capture only the darkest, most distinct cells (few artifacts).
  • High thresholds: Capture more cells but include more artifacts.
• Adaptive Thresholding (Robustness): To handle image heterogeneity, the authors propose converting fixed thresholds into quantile-based thresholds derived from the image's color histograms, ensuring robustness across different lighting conditions.

Phase P2: Kernel Smoother Regression

The problem is framed as a regression task: mapping the feature vector $\mathbf{r}_d$ to the expert's count $N_d$.

• Algorithm: A non-parametric, non-linear kernel smoother is used.
• Prediction: For a new image with feature vector $\mathbf{r}_{D+1}$, the predicted count $\hat{N}_{D+1}$ is a weighted average of the training labels $N_d$:
  $$\hat{N}_{D+1} = \sum_{d=1}^{D} \bar{w}_d N_d$$
  where weights $\bar{w}_d$ are derived from the Euclidean distance between the standardized feature vectors of the new image and the training images, controlled by a bandwidth hyperparameter $\eta$.
• Key Properties:
  • Non-negativity: Since weights and labels are non-negative, predictions are always $\geq 0$.
  • Flexibility: The method is non-parametric; its complexity grows with the dataset size $D$, allowing it to fit complex, heterogeneous data without overfitting small datasets (unlike parametric models).
  • Single Hyperparameter: Only $\eta$ needs tuning (via Leave-One-Out Cross-Validation), making it easy to train on small datasets.

Uncertainty and Expert Opinion Handling

• Uncertainty Estimation: The algorithm calculates the variance of the prediction ($\hat{\sigma}^2$) directly from the residuals of the training data, providing confidence intervals without bootstrapping.
• Noisy Labels: The framework accommodates "soft" labeling (probabilistic counts), multiple expert opinions for the same image (multi-output), and lower/upper bounds, effectively smoothing out human error.

3. Key Contributions

1. Counting-Only Paradigm: Shifts the focus from object detection (bounding boxes/segmentation) to direct counting, significantly reducing the annotation burden (no pixel-level labeling required).
2. Small Dataset Efficiency: The non-parametric kernel approach is specifically designed to perform well with small, heterogeneous datasets where Deep Learning fails.
3. Built-in Uncertainty Quantification: Provides a mathematical estimate of prediction uncertainty, which can flag images requiring expert re-evaluation.
4. Robustness to Heterogeneity: The adaptive thresholding and feature extraction allow the model to handle images from different labs or with varying quality.
5. Open Source: The authors provide the full MATLAB code and dataset.

4. Experimental Results

• Synthetic Experiments:
  • Demonstrated that Mean Squared Error (MSE) decreases rapidly as the number of threshold vectors ($T$) increases.
  • Showed robustness against label noise: even with significant noise added to expert counts ($\gamma = 10$), the MSE converged to near zero as $T$ increased.
• Real-World Dataset (URJC):
  • Dataset: 12 high-resolution images of rat spinal cords with manual expert counts.
  • Performance: Achieved a coefficient of determination ($R^2$) of 0.90.
  • Error: Average absolute error was < 4 cells (standard deviation 5.44).
  • Comparison: Outperformed ImageJ (threshold-based) and two state-of-the-art Convolutional Neural Networks (CNNs) which achieved $R^2$ scores of 0.67, 0.70, and 0.74 respectively. The CNNs struggled likely due to the small dataset size and lack of pixel-level annotations.
  • Uncertainty: The calculated error bars successfully contained the expert's ground truth in all cases, validating the uncertainty estimation mechanism.

5. Significance

This work presents a practical, efficient solution for biomedical image analysis in resource-constrained environments. By avoiding the heavy data requirements of Deep Learning and the rigidity of traditional thresholding, the Kernel Counter offers a "sweet spot" for laboratories with limited funding and small, heterogeneous datasets. Its ability to quantify uncertainty and handle noisy expert labels makes it particularly valuable for scientific research where data reliability is paramount. The approach is also generalizable to other counting tasks in satellite imagery, surveillance, and general microscopy.