🤖 machine learning

QFedPolyp: A Communication- and Inference-Efficient Federated Learning Framework for Polyp Segmentation

QFedPolyp is a communication- and inference-efficient federated learning framework that utilizes quantization-aware training and low-precision model transmission to enable privacy-preserving, high-accuracy polyp segmentation with significantly reduced communication costs and faster inference speeds.

Original authors: Madan Baduwal, Priyanka Paudel

Published 2026-07-28

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Madan Baduwal, Priyanka Paudel

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine a world where doctors could team up to solve medical mysteries without ever showing each other their patients' private files. This is the heart of Federated Learning, a clever way for computers to learn together while keeping secrets safe. Usually, to teach a computer how to spot a disease, you need to gather thousands of medical images into one giant pile. But hospitals can't do that; privacy laws and ethical rules say they must keep patient data locked inside their own walls. So, instead of moving the data, they move the teacher. Each hospital trains a local computer brain, sends just the "lessons learned" (the math updates) to a central hub, and gets a smarter, combined brain back.

However, there's a catch: these "lessons" are huge. Sending them back and forth is like trying to mail a library of encyclopedias every time you want to update a single recipe. It's slow, expensive, and clogs up the internet. This paper tackles that traffic jam. It asks: Can we shrink those massive lessons down to tiny, lightweight notes without losing the wisdom inside? If we could, we wouldn't just save bandwidth; we could also make the final computer brain run super fast on small devices, like the ones used during real-time colonoscopies. The goal is to find a way to share knowledge that is both private and speedy.

The Paper: QFedPolyp – The "Tiny Messenger" for Polyp Detectives

Meet QFedPolyp, a new framework designed to help hospitals collaborate on spotting polyps (those little tissue bumps in the colon that can turn into cancer if ignored) without breaking the bank or the bank's privacy policies. Think of polyp detection as a high-stakes game of "Where's Waldo?" but instead of a striped shirt, you're looking for tiny, tricky bumps in a sea of pink tissue.

The Problem: The Heavy Backpack

In the old way of doing things (Centralized Training), every hospital would have to pack up their entire library of colonoscopy videos and ship them to a central server. This is a privacy nightmare and often illegal.
In the current "Federated" way, hospitals keep their data safe but still have to send back massive, heavy backpacks full of math (full-precision model parameters) every time they learn something new. It's like sending a 100-pound encyclopedia to update a single fact. It works, but it's slow and expensive, especially if the hospital's internet connection is a bit wobbly.

The Solution: The "Quantization-Aware" Trick

The authors of this paper, Madan Baduwal and Priyanka Paudel, came up with a clever two-part strategy called QFedPolyp.

The "Practice Run" (Quantization-Aware Training): Imagine you are a student preparing for a test where you can only write with a very blunt pencil that smudges easily. Most students practice with a sharp pencil and then panic when they get the blunt one. QFedPolyp is different. During the training phase, the computer pretends it is using a blunt pencil (low-precision math) while it learns. It practices writing with the smudgy pencil so that by the time it actually has to send its notes, it's already an expert at writing clearly with a blunt tool. This is called Quantization-Aware Training (QAT).
The "Tiny Messenger" (Low-Precision Communication): Because the computer has practiced with the blunt pencil, it can now send its "lessons" as tiny, compressed notes instead of heavy encyclopedias. Instead of sending a 32-bit number (a big, heavy float), it sends an 8-bit number (a tiny, light integer). This shrinks the data size by about 4 times (a 4× reduction).

What They Found: Speed and Smarts

The researchers tested this idea on four different datasets of colonoscopy images: Kvasir-SEG, CVC-ClinicVideoDB, PolypGen, and BKAI-IGH NeoPolyp. They simulated a scenario where 5 different hospitals (clients) worked together.

Here is the magic they discovered:

Accuracy Stays High: Even though they sent tiny, compressed notes, the final "team brain" was almost as smart as the one built with heavy, full-size notes. On the CVC-ClinicVideoDB dataset, the full-precision team got a Dice score of 0.930 (a measure of how well the computer found the polyps), while the compressed team got 0.915. That's a tiny drop for a massive speedup.
The "Mixed-Size" Team: They also tried a scenario where some hospitals had fast internet (sending 16-bit or 32-bit notes) and others had slow internet (sending 4-bit or 8-bit notes). The system handled this mix perfectly. Even with hospitals sending different sizes of notes, the team still learned effectively, proving that the system is flexible enough for real-world hospitals with different tech setups.
Super Fast Inference: The best part? Because the computer learned to think in "blunt pencil" math, the final model runs incredibly fast. When they tested the model on a standard computer chip (Intel i9-14900KF), it processed images in 71.59 milliseconds (about 14 frames per second). On a powerful graphics card (NVIDIA RTX 4090), it zoomed through 400 frames per second. That is 1.5 times faster than the standard, heavy model.

Why This Matters

The paper argues that this approach solves a double problem. First, it makes it easier for hospitals to share knowledge without clogging their networks (saving money and time). Second, it creates a final model that is light enough to run on real-time devices, like the processors inside a colonoscopy camera. This means a doctor could get instant, AI-powered help while the camera is still moving inside a patient, without needing a supercomputer nearby.

The authors are confident in these results because they tested them on real, public datasets and compared them against the best existing methods. They didn't just guess; they measured the accuracy (using Dice scores and IoU) and the speed (latency in milliseconds). They showed that you don't have to choose between privacy, speed, and accuracy—you can have all three if you teach your computer to practice with the tools it will actually use.

In short, QFedPolyp is like teaching a class to write a summary using a tiny notepad. By practicing with the small notepad, the students can send their notes quickly, save paper, and still get an A+ on the test.

Technical Summary: QFedPolyp

Problem Statement

Automatic polyp segmentation is critical for computer-aided diagnosis and early colorectal cancer detection. While deep learning models, particularly U-Net architectures, have achieved strong performance in this domain, they typically rely on centralized training, which requires aggregating sensitive medical data from multiple hospitals into a single location. This approach is often infeasible due to strict privacy regulations, institutional policies, and ethical concerns regarding patient data sharing.

Federated Learning (FL) offers a privacy-preserving alternative by allowing hospitals to train a shared global model while keeping data local. However, standard FL introduces a significant bottleneck: the repeated transmission of full-precision (32-bit floating-point) model parameters between clients and the server. In large-scale medical systems or environments with limited network bandwidth, this communication overhead is prohibitive. Furthermore, standard FL models often lack optimization for efficient inference on edge devices or clinical hardware.

Methodology

The authors propose QFedPolyp, a framework designed to be both communication- and inference-efficient for collaborative polyp segmentation. The methodology integrates three core components:

Lightweight Architecture: The system employs a compact U-Net model with an encoder-decoder structure and symmetric skip connections. The model is designed to be small enough to reduce communication payload while retaining the capacity to capture multi-scale contextual information necessary for polyp segmentation. The network uses Dice Loss to optimize the overlap between predicted and ground-truth masks, which is particularly effective for medical images where foreground regions are small.
Quantization-Aware Training (QAT): To address the accuracy degradation typically associated with low-precision models, QFedPolyp incorporates QAT into the local training phase at each hospital. During local optimization, the model simulates low-bit arithmetic (e.g., 8-bit integers) via a quantization operator $Q_b(\cdot)$ and uses the Straight-Through Estimator (STE) to approximate gradients through the non-differentiable rounding function. This allows the model to learn parameter distributions that are robust to quantization noise, ensuring high accuracy even when weights are represented with reduced precision.
Communication-Efficient Parameter Exchange: Instead of transmitting full-precision updates, participating hospitals send quantized model parameters to the central server. The server reconstructs these updates and aggregates them using the Federated Averaging (FedAvg) algorithm. The framework supports both uniform quantization (all hospitals using the same bit-width) and mixed-precision quantization (hospitals using different bit-widths based on their specific network or hardware constraints), allowing for flexible deployment in heterogeneous clinical environments.

Key Contributions

The paper outlines four primary contributions:

QFedPolyp Framework: A privacy-preserving federated learning system enabling collaborative polyp segmentation across multiple institutions without sharing raw medical images.
Integration of QAT: The incorporation of quantization-aware training into the federated pipeline to enhance model robustness against quantization noise during distributed training.
Communication Efficiency: The introduction of a quantized parameter exchange mechanism that significantly reduces bandwidth requirements compared to standard 32-bit FL.
Inference Efficiency: Demonstration that the resulting low-precision models enable faster inference, making the framework suitable for real-time clinical applications.

Experimental Results

The framework was evaluated on four public datasets: Kvasir-SEG, CVC-ClinicVideoDB, PolypGen, and BKAI-IGH NeoPolyp. The experiments compared centralized training, full-precision FL (32-bit), and the proposed QFedPolyp (using uniform and mixed-precision quantization).

Accuracy: Full-precision federated training achieved Dice scores of 0.910 (Kvasir-SEG) and 0.930 (CVC-ClinicVideoDB). The proposed uniform 8-bit communication reduced transmission costs by approximately 4× while maintaining competitive accuracy (e.g., 0.895 Dice on Kvasir-SEG and 0.915 on CVC-ClinicVideoDB).
Mixed-Precision Flexibility: Experiments with mixed-precision configurations (e.g., hospitals using 8-bit and 16-bit updates) demonstrated that the system could adapt to varying bandwidth constraints, achieving strong performance with average bit-widths significantly lower than 32 bits.
Inference Speed: The quantized models (INT8) achieved up to 1.5× faster inference compared to full-precision models. On an NVIDIA RTX 4090 GPU, throughput increased from ~266 FPS (FP32) to 400 FPS (INT8), while CPU latency also decreased.
Convergence: The models trained with quantization converged stably, though slightly later than full-precision counterparts (e.g., stabilizing around 70–80 rounds for 8-bit vs. 50–60 rounds for 32-bit).

Significance and Claims

The paper claims that QFedPolyp successfully bridges the gap between privacy preservation, communication efficiency, and deployment efficiency in medical imaging. By combining QAT with low-precision communication, the framework enables:

Privacy Preservation: Hospitals can collaborate without violating data protection constraints.
Reduced Overhead: The 4× reduction in communication payload alleviates the bottleneck in large-scale FL systems, making it viable for institutions with limited network bandwidth.
Real-Time Deployment: The resulting lightweight, low-precision models are optimized for inference on resource-constrained hardware (such as mobile endoscope processors), facilitating real-time clinical guidance.

The authors position QFedPolyp as a practical solution for real-world clinical environments where privacy, bandwidth, and inference speed are simultaneously critical constraints, noting that future work will explore adaptive precision strategies and more advanced lightweight architectures.