Paper deep dive
QFedPolyp: A Communication- and Inference-Efficient Federated Learning Framework for Polyp Segmentation
Madan Baduwal, Priyanka Paudel
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 92%
Last extracted: 7/28/2026, 3:42:49 AM
Summary
The paper introduces QFedPolyp, a federated learning framework for polyp segmentation that combines quantization-aware training with low-precision communication to reduce bandwidth costs and improve inference speed while preserving patient privacy. It utilizes a lightweight U-Net architecture and Federated Averaging (FedAvg) on datasets like Kvasir-SEG and CVC-ClinicVideoDB, achieving high Dice scores with significantly reduced transmission overhead.
Entities (10)
Relation Signals (9)
QFedPolyp → evaluatedon → Kvasir-SEG
confidence 95% · Evaluation is performed on Kvasir-SEG, CVC-ClinicVideoDB, PolypGen, and BKAI-IGH NeoPolyp.
QFedPolyp → evaluatedon → CVC-ClinicVideoDB
confidence 95% · Evaluation is performed on Kvasir-SEG, CVC-ClinicVideoDB, PolypGen, and BKAI-IGH NeoPolyp.
QFedPolyp → uses → U-Net
confidence 95% · Each hospital locally trains a lightweight U-Net on private data while simulating quantization during training.
QFedPolyp → uses → Federated Averaging
confidence 92% · Clients transmit quantized model parameters to a central server, where they are reconstructed and aggregated using Federated Averaging.
QFedPolyp → achievesmetricon → Dice Score 0.910 on Kvasir-SEG
confidence 90% · Full-precision federated training achieves Dice scores of 0.910 on Kvasir-SEG
QFedPolyp → achievesmetricon → Dice Score 0.930 on CVC-ClinicVideoDB
confidence 90% · Full-precision federated training achieves Dice scores of 0.910 on Kvasir-SEG and 0.930 on CVC-ClinicVideoDB.
QFedPolyp → uses → Quantization-aware training
confidence 90% · QFedPolyp combines quantization-aware training with low-precision model communication.
QFedPolyp → developedby →
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Background and Objective: Automatic polyp segmentation supports computer-aided diagnosis and early colorectal cancer detec- tion. Centralized deep learning requires hospitals to share sensitive medical data, while federated learning preserves privacy but introduces high communication costs through repeated transmission of full-precision model parameters. We propose QFedPolyp, a communication- and inference-efficient federated learning framework for collaborative polyp segmentation. Methods: QFedPolyp combines quantization-aware training with low-precision model communication. Each hospital locally trains a lightweight U-Net on private data while simulating quantization during training. Clients transmit quantized model parameters to a central server, where they are reconstructed and aggregated using Federated Averaging. Evaluation is performed on Kvasir-SEG, CVC-ClinicVideoDB, PolypGen, and BKAI-IGH NeoPolyp. Results: Full-precision federated training achieves Dice scores of 0.910 on Kvasir-SEG and 0.930 on CVC-ClinicVideoDB. Uni- form 8-bit communication reduces transmission cost by approximately 4 times while preserving competitive segmentation accuracy. Quantized models also achieve up to 1.5 times faster inference than full-precision models. Conclusions: QFedPolyp enables privacy-preserving collaborative polyp segmentation with reduced communication overhead and faster inference. The resulting lightweight models are suitable for real-time clinical deployment.
Tags
Links
- Source: https://arxiv.org/abs/2607.22743v1
- Canonical: https://arxiv.org/abs/2607.22743v1
Trouble viewing inline? Open PDF directly →
Full Text
67,924 characters extracted from source content.
Expand or collapse full text
QFedPolyp: A Communication- and Inference-Efficient Federated Learning Framework for Polyp Segmentation Madan Baduwal mb4239@msstate.edu Priyanka Paudel p918@msstate.edu Abstract Background and Objective: Automatic polyp segmentation supports computer-aided diagnosis and early colorectal cancer detection. Centralized deep learning requires hospitals to share sensitive medical data, while federated learning preserves privacy but introduces high communication costs through repeated transmission of full-precision model parameters. We propose QFedPolyp, a communication- and inference-efficient federated learning framework for collaborative polyp segmentation. Methods: QFedPolyp combines quantization-aware training with low-precision model communication. Each hospital locally trains a lightweight U-Net on private data while simulating quantization during training. Clients transmit quantized model parameters to a central server, where they are reconstructed and aggregated using Federated Averaging. Evaluation is performed on Kvasir-SEG, CVC-ClinicVideoDB, PolypGen, and BKAI-IGH NeoPolyp. Results: Full-precision federated training achieves Dice scores of 0.910 on Kvasir-SEG and 0.930 on CVC-ClinicVideoDB. Uniform 8-bit communication reduces transmission cost by approximately 4×4× while preserving competitive segmentation accuracy. Quantized models also achieve up to 1.5×1.5× faster inference than full-precision models. Conclusions: QFedPolyp enables privacy-preserving collaborative polyp segmentation with reduced communication overhead and faster inference. The resulting lightweight models are suitable for real-time clinical deployment. keywords: Federated learning , Polyp segmentation , Quantization , Privacy preservation , Communication efficiency , U-Net †journal: Computer Methods and Programs in Biomedicine organization=Department of Computer Science and Engineering, institution=Mississippi State University, city=Mississippi State, state=MS, country=USA 1 Introduction Colorectal cancer is one of the most common and life-threatening gastrointestinal diseases worldwide. According to the National Cancer Institute, colorectal cancer accounts for a substantial portion of global cancer-related deaths, and early detection plays a critical role in improving patient survival rates [23]. Colonoscopy is the primary clinical procedure used to identify colorectal polyps, which are abnormal tissue growths that may evolve into malignant tumors if left untreated. However, manual inspection of colonoscopy videos is a time-consuming process and is prone to human error, particularly for small or visually subtle lesions. As a result, computer-aided diagnosis (CAD) systems based on deep learning have gained significant attention for assisting clinicians in detecting and segmenting polyps automatically. Deep convolutional neural networks have demonstrated strong performance in medical image segmentation tasks. Among these architectures, U-Net has become one of the most widely used models due to its encoder–decoder structure and Fig. 1: Centralized training versus the proposed QFedPolyp framework. Hospitals perform quantization-aware local training with a lightweight U-Net and send quantized updates to the FL server, preserving privacy while reducing communication cost and enabling efficient inference. skip connections that effectively capture both contextual and spatial information [27]. Several improved architectures have been proposed specifically for polyp segmentation. For example, PraNet introduces a reverse attention mechanism to refine segmentation boundaries [9], while HarDNet-MSEG focuses on lightweight model design for efficient real-time segmentation [11]. These models have achieved strong results on benchmark datasets such as Kvasir-SEG, CVC-ClinicVideoDB, PolypGen, and BKAI-IGH NeoPolyp. Despite these advances, most deep learning approaches rely on centralized training, where data from multiple hospitals must be collected and stored in a single location. In practical healthcare environments, however, such centralized data aggregation is often infeasible due to strict privacy regulations, institutional policies, and ethical concerns related to patient data sharing. Hospitals are frequently unable or unwilling to transfer sensitive medical images across institutional boundaries, which limits the availability of large multi-institutional datasets for training deep learning models. Federated learning (FL) has emerged as a promising paradigm for enabling collaborative model training while preserving data privacy. Instead of transferring raw data, federated learning allows multiple institutions to train a shared global model while keeping their data locally stored [21]. In this framework, each participating client performs local optimization on its private dataset and sends model updates to a central server. The server aggregates these updates to improve the global model. This decentralized learning paradigm enables collaborative knowledge sharing across hospitals without violating data protection constraints. Although federated learning effectively addresses privacy concerns associated with centralized training, it introduces a new challenge related to communication efficiency. Federated learning requires repeated exchange of model parameters between participating clients and the central server across multiple communication rounds. Modern deep neural networks often contain millions of parameters, and transmitting full-precision model updates can impose substantial communication overhead, particularly when institutions operate under limited network bandwidth [18, 6]. Consequently, communication cost becomes a critical bottleneck in large-scale federated learning systems. Several techniques have been proposed to improve communication efficiency in federated learning, including gradient sparsification, model compression, periodic averaging, and parameter quantization [24]. Among these approaches, quantization is particularly effective because it directly reduces the number of bits required to represent model parameters. By transmitting low-precision parameters instead of full-precision floating-point values, the communication cost between clients and servers can be significantly reduced. However, naive post-training quantization may introduce quantization noise that negatively affects model accuracy. Quantization-aware training (QAT) addresses this limitation by incorporating simulated quantization operations during the training process [13]. In QAT, the neural network learns parameter distributions that remain robust under low-precision representations, allowing the model to maintain strong performance even when weights are represented using reduced numerical precision. Figure 1 illustrates the conceptual difference between centralized training and the proposed federated learning framework. In centralized systems, hospitals must transfer raw medical images to a central server, creating privacy risks and data transfer challenges. In contrast, the proposed approach enables each hospital to perform quantization-aware local training using a lightweight U-Net model while transmitting only quantized model updates to the federated server. This design preserves patient privacy, reduces communication overhead, and produces efficient models suitable for real-time clinical deployment. Motivated by these challenges, this paper proposes QFedPolyp, a communication- and inference-efficient federated learning framework for collaborative polyp segmentation. QFedPolyp integrates quantization-aware training with quantized model-parameter transmission to enable bandwidth-efficient federated optimization while maintaining high segmentation accuracy. The main contributions of this work are summarized as follows: 1. We propose QFedPolyp, a privacy-preserving federated learning framework that enables collaborative polyp segmentation across multiple hospitals without sharing raw medical images. 2. We integrate quantization-aware training into the federated learning pipeline to improve robustness against quantization noise during distributed training. 3. We introduce communication-efficient parameter exchange by transmitting quantized model updates, significantly reducing bandwidth requirements in federated learning. 4. We demonstrate that the resulting low-precision models enable faster inference, making the framework suitable for real-time clinical applications. The implementation of the proposed framework is publicly available at: https://madanbaduwal.github.io/QFedPolyp. The remainder of this paper is organized as follows. Section 2 reviews related research on deep learning methods for polyp segmentation, federated learning in medical imaging, communication-efficient federated learning, and quantization-aware training. Section 3 presents QFedPolyp, including its federated optimization strategy, lightweight U-Net architecture, quantization-aware training, and quantized model communication. Section 4 describes the experimental setup, datasets, evaluation metrics, and performance evaluation, including a detailed comparison with state-of-the-art methods. Finally, Section 5 concludes the paper and discusses potential future research directions. 2 Related Work Early deep learning approaches have greatly advanced automated polyp segmentation. The U-Net architecture [26], first introduced in 2015, became a seminal model for biomedical image segmentation with its encoder-decoder design and skip connections. Building upon U-Net, various improvements have been proposed. For example, UNet++ [34] incorporates nested and dense skip pathways to better fuse multi-scale features, yielding more precise segmentations. More recently, researchers have designed specialized CNN architectures targeting colonoscopy polyp segmentation. ResUNet++ [14] augments the U-Net backbone with residual blocks and applies post-processing (conditional random fields and test-time augmentation) to significantly boost performance on polyp datasets. Fang et al. [10] proposed a Selective Feature Aggregation (SFA) network with dual decoder branches to jointly refine polyp regions and boundaries, enforcing area-boundary consistency for improved edge localization. The PraNet model by Fan et al. [8] introduces a parallel reverse attention mechanism that iteratively highlights polyp regions and boundary cues, achieving state-of-the-art accuracy on multiple benchmark datasets. Another notable method, ACSNet [33], adaptively selects global vs. local context features based on polyp size, enabling the network to handle the large shape variability of polyps. All these advanced deep learning models have markedly improved polyp segmentation accuracy. However, they typically assume training on centralized datasets, which is often infeasible in medical imaging due to privacy and data-sharing restrictions. Federated learning (FL) has emerged as a solution to train models on decentralized medical data without compromising patient privacy. Sheller et al. [28] demonstrated one of the first multi-institutional FL implementations for 3D medical image segmentation, showing that a federated model can approach the accuracy of a centrally trained model while each hospital keeps data locally. Subsequent works have highlighted the promise of FL across various medical imaging tasks. Rieke et al. [25] provided an overview of how FL can enable large-scale collaborations in digital health, emphasizing its potential to overcome data silos and institutional biases in medical datasets. They also discuss challenges such as data heterogeneity (e.g., differing imaging protocols across sites) and the need for robust aggregation techniques. Kaissis et al. [17] further surveyed privacy-preserving machine learning in radiology, including FL combined with techniques like secure aggregation and differential privacy to protect sensitive information. These studies underscore that FL is well-suited for medical imaging, where data are plentiful but fragmented. In the context of endoscopy and polyp segmentation, FL can enable models to learn from colonoscopy images across multiple clinics or hospitals without sharing patient data. While FL has been applied to modalities like MRI, CT, and digital pathology, its use in colonoscopy image segmentation remains relatively nascent. Our work addresses this gap by leveraging FL for polyp segmentation, ensuring that knowledge is shared across institutions without exchanging the raw video frames or images. A critical challenge in federated learning is the communication overhead of exchanging model updates between clients and the server. The standard FedAvg algorithm [22] reduces communication frequency by performing multiple local training epochs before averaging models, yet transmitting full precision neural network weights can still be bandwidth-intensive when models are large. To tackle this, numerous communication-efficient FL techniques have been proposed. One approach is quantization of model updates: for instance, TernGrad [31] compresses gradients to 3-level ternary values, and QSGD [2] stochastically quantizes gradients with provable error bounds, both achieving significant bandwidth savings. Similarly, signSGD [3] sends only the sign of each gradient (1-bit per value), dramatically cutting communication at the cost of additional variance, which can be mitigated by error feedback. Another strategy is sparsification or pruning of updates: instead of sending all gradients, clients transmit only the largest k gradients or those above a threshold [19], and accumulate the rest locally. This gradient sparsification can slash the transmitted data size by orders of magnitude (e.g., 100× compression) while maintaining model performance through techniques like momentum correction [19]. These communication-efficient methods are often complementary to FL and have been integrated into federated frameworks to enable scaling to many clients or limited-bandwidth settings. In our work, we build on these ideas by employing model quantization to reduce the communication cost per round, which is especially important when deploying federated segmentation to edge devices or across clinics with bandwidth constraints. Quantization-aware training (QAT) is a technique to ensure that a neural network remains accurate when its weights and activations are reduced to lower precision, typically for efficient inference on edge hardware. Rather than quantizing a trained model as a post-processing step (which can degrade accuracy), QAT simulates low-bit quantization (e.g., 8-bit integers) during training so that the model learns to compensate for quantization errors [12]. This approach has been widely used to produce compact, faster models for deployment without significant loss in performance [12]. In distributed and federated learning scenarios, QAT can serve a dual purpose: reducing communication by sending quantized model updates, and yielding a final model that is already optimized for low-precision inference on devices. Recent works have started to incorporate QAT into the FL paradigm. Abdelmoniem and Canini [1] introduced an adaptive quantization scheme for FL, where each client trains with a quantized model whose bit-width is tailored to its device capabilities, mitigating heterogeneity in hardware. Ji and Chen [16] proposed FedQNN, an FL framework that trains neural networks with low-bitwidth weights and activations; their results show that aggressive quantization (down to 4–8 bits) can substantially reduce communication and computation load in IoT settings with only minor accuracy loss. Yoon et al. [32] address the scenario of clients using different precisions: they developed a progressive de-quantization approach that allows the server to aggregate mixed-precision updates and improve a global model despite heterogeneous quantization across clients. Beyond fixed low-precision training, researchers have also explored mixed-precision strategies in FL. Chen and Vikalo [4] recently presented a CVPR 2024 method to assign different bit-widths to different layers of a model (e.g., more critical layers in higher precision and others in lower precision) during federated training, adapting these assignments to each client’s resource limits. Such quantization-aware techniques are crucial for deploying federated models on resource-constrained devices, as they ensure efficient inference (e.g., real-time polyp segmentation on a mobile endoscope processor) without sacrificing too much accuracy. In our approach, we leverage QAT within federated polyp segmentation to jointly achieve privacy preservation, communication efficiency, and optimized low-precision inference. Fig. 2: Overview of the proposed QFedPolyp framework for communication- and inference-efficient polyp segmentation. The server distributes the global model to hospitals, each client performs local training on private datasets, transmits quantized model updates, and the server aggregates them using federated averaging to update the global model. 3 Methods 3.1 Small U-Net Segmentation Model and Loss Function We employ a lightweight U-Net architecture for polyp segmentation, illustrated in Fig. 3. The model follows an encoder–decoder structure with symmetric skip connections that enable effective recovery of spatial details while maintaining a compact model size suitable for federated learning environments. Given an input colonoscopy image x∈ℝ3×128×128x ^3× 128× 128, the encoder progressively extracts hierarchical feature representations while reducing spatial resolution through max-pooling operations. Each encoder stage consists of two 3×33× 3 convolutional layers followed by batch normalization and ReLU activation. The first convolutional block produces feature maps of size 32×128×12832× 128× 128. A 2×22× 2 max-pooling operation then reduces the spatial resolution to 64×6464× 64 while increasing the channel dimension to 6464. The next encoder stage further compresses the spatial representation to 128×32×32128× 32× 32 through another max-pooling layer. Finally, a bottleneck layer captures high-level semantic information with feature maps of size 256×16×16256× 16× 16, enabling the network to encode contextual information about the polyp region. Fig. 3: Architecture of the proposed small U-Net used for polyp segmentation. The network follows an encoder-decoder structure with convolutional blocks and max-pooling for feature extraction, followed by upsampling layers and skip connections to recover spatial details. A final 1×11× 1 convolution with sigmoid activation produces the binary segmentation mask. The decoder mirrors the encoder structure and progressively restores spatial resolution through upsampling operations. Starting from the bottleneck representation, feature maps are upsampled by a factor of two and concatenated with the corresponding encoder features through skip connections, as shown in Fig. 3. These skip connections help preserve fine-grained spatial information that may otherwise be lost during downsampling. After the first upsampling stage, the decoder produces feature maps of size 128×32×32128× 32× 32, which are fused with encoder features at the same resolution. The reconstruction process continues through subsequent upsampling layers, generating feature maps of size 64×64×6464× 64× 64 and finally 32×128×12832× 128× 128. Each decoder stage includes convolutional refinement layers that combine contextual and spatial information to improve segmentation accuracy. A final 1×11× 1 convolution layer maps the reconstructed feature representation into a single-channel segmentation mask. A sigmoid activation function σ(⋅)σ(·) converts the network output into per-pixel probabilities indicating the likelihood of each pixel belonging to the polyp region. Formally, for an input image x, the predicted segmentation mask is defined as y^=σ(f(x;w)), y=σ(f(x;w)), (1) where f(x;w)f(x;w) denotes the output logits of the U-Net model parameterized by weights w, and y^(i,j)∈[0,1] y(i,j)∈[0,1] represents the predicted probability that pixel (i,j)(i,j) belongs to the polyp class. To train the segmentation network, we employ the Dice loss, which directly optimizes the overlap between predicted and ground-truth segmentation masks. Let y denote the ground-truth mask and y y the predicted probability map. The Dice loss is defined as ℓDice(y,y^)=1−2∑iyiy^i+ϵ∑iyi+∑iy^i+ϵ, _Dice(y, y)=1- 2 _iy_i y_i+ε _iy_i+ _i y_i+ε, (2) where the summation is performed over all pixels and ϵε is a small smoothing constant to ensure numerical stability. Minimizing the Dice loss encourages the model to maximize spatial overlap between predicted and ground-truth polyp regions, which is particularly suitable for medical image segmentation tasks where foreground regions may occupy a relatively small portion of the image. 3.2 Federated Optimization using FedAvg To collaboratively train the lightweight U-Net segmentation model described in the previous section, we adopt a federated learning framework based on the Federated Averaging (FedAvg) algorithm [20]. The overall training workflow is illustrated in Fig. 2. In this setting, multiple hospitals jointly train a global segmentation model without sharing raw colonoscopy images or segmentation masks, thereby preserving data privacy. Assume there are K participating hospitals (clients). Each hospital k∈1,…,Kk∈\1,…,K\ possesses a private dataset Dk=(xi,yi)i=1nk,D_k=\(x_i,y_i)\_i=1^n_k, (3) where xix_i denotes a colonoscopy image and yiy_i its corresponding segmentation mask. Let N=∑k=1KnkN= _k=1^Kn_k denote the total number of samples across all clients. The objective of federated learning is to optimize the parameters w of the small U-Net model f(x;w)f(x;w) by minimizing the following global objective: minwF(w)=∑k=1KnkNFk(w), _wF(w)= _k=1^K n_kNF_k(w), (4) where the local objective for client k is defined as Fk(w)=1nk∑i=1nkℓ(f(xi;w),yi),F_k(w)= 1n_k _i=1^n_k (f(x_i;w),y_i ), (5) and ℓ(⋅) (·) denotes the Dice loss defined in the previous section. The weighting factor nkN n_kN ensures that each hospital contributes proportionally to the global model according to its dataset size. Federated training proceeds through multiple communication rounds between a central server and the participating hospitals. At the beginning of round t, the server maintains the current global model parameters wtw^t and distributes them to all clients, as shown in Step 1 of Fig. 2. Each hospital initializes its local model using the received global parameters: wkt,0=wt.w_k^t,0=w^t. (6) Subsequently, each client performs local training using its private dataset. During this stage, the small U-Net model is optimized for E local epochs using stochastic gradient descent. The iterative update during local optimization can be written as wkt,j=wkt,j−1−η∇Fk(wkt,j−1),j=1,…,E,w_k^t,j=w_k^t,j-1-η∇ F_k\! (w_k^t,j-1 ), j=1,…,E, (7) where η denotes the learning rate. As illustrated in Step 2 of Fig. 2, this local training phase incorporates quantization-aware training (QAT), which simulates low-precision arithmetic during forward and backward passes in order to prepare the model for quantized communication and efficient inference. After completing local training, each hospital obtains an updated model wkt+1=wkt,E.w_k^t+1=w_k^t,E. (8) Instead of transmitting full-precision parameters, the client compresses its model updates using quantization before sending them to the server. These quantized model updates significantly reduce communication overhead between hospitals and the central server, as shown in Step 3 of Fig. 2. The quantization strategy used for communication-efficient updates is described in the next subsection. Upon receiving the client updates, the server reconstructs them and performs aggregation to produce the next global model. Specifically, the updated model parameters are obtained through weighted averaging: wt+1=∑k=1KnkNwkt+1.w^t+1= _k=1^K n_kNw_k^t+1. (9) This aggregation step corresponds to the FedAvg update rule and is illustrated in Step 4 of Fig. 2. The new global model wt+1w^t+1 is then redistributed to all clients for the next communication round. After T rounds of federated optimization, the model converges toward a solution minimizing the global objective F(w)F(w) while ensuring that sensitive medical data remain locally stored at each hospital. 3.3 Quantization-Aware Training (QAT) To enable inference-efficient deployment and improve robustness to low-precision communication, we incorporate quantization-aware training (QAT) into the local optimization process at each participating hospital. As illustrated in Step 2 of Fig. 2, QAT is performed during the local training phase of the small U-Net segmentation model described in Section 3.1. The key idea is to simulate low-precision arithmetic during training so that the model learns parameters that remain accurate after quantization. Let w denote the full-precision parameters of the segmentation network f(x;w)f(x;w). During QAT, we introduce a quantization operator Qb(⋅)Q_b(·) that maps real-valued tensors to a b-bit representation. For uniform b-bit quantization, the quantized weights w~ w are computed as w~=Qb(w)=Δ⋅round(wΔ), w=Q_b(w)= ·round\! ( w ), (10) where Δ denotes the quantization step size determined by the chosen bit-width b. This operation restricts the tensor values to one of 2b2^b discrete levels, effectively simulating integer-based arithmetic used during low-precision inference. During the forward pass of training, the convolutional weights of the U-Net model are temporarily replaced by their quantized counterparts w~ w. In addition, intermediate activations may also be quantized to the same bit precision to emulate realistic inference behavior. Although the model parameters are stored in full precision, this simulated quantization exposes the network to quantization noise during training, allowing it to adapt to reduced numerical precision. Since the rounding function in the quantization operator is non-differentiable, direct gradient computation is not possible. To address this, we employ the straight-through estimator (STE) during backpropagation. The STE approximates the gradient of the quantization operation by treating it as an identity function, allowing gradients to propagate through the quantization step. Formally, the gradient approximation is written as ∂L∂w≈∂L∂w~, ∂ L∂ w≈ ∂ L∂ w, (11) where L denotes the training loss. This approximation enables standard gradient-based optimization while still accounting for quantization effects during the forward pass. By integrating QAT into the local training process, each hospital learns model parameters that are inherently robust to low-precision representations. Consequently, the final global model can be represented using low-bit integer weights without significant loss in segmentation accuracy. This property is particularly beneficial in the federated learning setting, as it not only enables efficient inference on deployment hardware but also prepares the model for the communication-efficient quantized parameter exchange described in the following subsection. 3.4 Communication-Efficient Parameter Exchange with b-bit Quantization A key objective of the proposed framework is to reduce the communication overhead of federated learning while maintaining segmentation accuracy. As illustrated in Step 3 of Fig. 2, participating hospitals transmit low-precision model parameters to the central server after completing local training. Unlike conventional federated learning approaches that exchange full 32-bit floating-point weights, our framework leverages quantization-aware training (QAT) so that the model parameters are inherently compatible with low-bit representations during training. Let wkt+1w_k^t+1 denote the parameters of the small U-Net model obtained by client k after completing local training in communication round t. Because QAT constrains the model parameters to discrete quantization levels during optimization, the resulting weights can be represented directly using b bits. The quantized parameters can be expressed as w~kt+1=Qb(wkt+1), w_k^t+1=Q_b(w_k^t+1), (12) where Qb(⋅)Q_b(·) denotes the b-bit quantization operator introduced during training and w~kt+1 w_k^t+1 represents the low-precision parameter tensor. For uniform b-bit quantization, the mapping from real-valued weights to discrete levels can be expressed using a linear quantization scheme. Let wminw_ and wmaxw_ denote the minimum and maximum values of a weight tensor. The quantization step size is defined as Δ=wmax−wmin2b−1. = w_ -w_ 2^b-1. (13) Each weight element wiw_i is mapped to an integer quantization level qi=round(wi−wminΔ),q_i=round ( w_i-w_ ), (14) where qi∈0,1,…,2b−1q_i∈\0,1,…,2^b-1\ can be stored using b bits. Because these quantization levels are already incorporated during QAT, the client can transmit the low-precision parameters directly to the server without performing an additional compression step. After receiving the quantized model parameters from all participating hospitals, the server performs the standard FedAvg aggregation to update the global model. Since the model was trained with quantization-aware training, the parameters are naturally robust to low-precision representation, ensuring that segmentation performance is preserved despite the reduced communication precision. Using b-bit parameter exchange significantly reduces the communication cost during federated learning. Compared with the standard 32-bit floating-point representation, the communication requirement per model update decreases by approximately a factor of 32/b32/b. For example, using b=8b=8 leads to roughly a fourfold reduction in transmitted data size while maintaining accurate polyp segmentation. This improvement alleviates the communication bottleneck in federated medical learning and enables efficient collaboration among hospitals with limited network bandwidth. Algorithm 1 Quantized Federated Learning with FedAvg 1:K clients indexed by k; local datasets DkD_k; communication rounds T; initial global model w0w^0; local epochs E; learning rate η. 2:Final global model wTw^T. 3:for t=1t=1 to T do 4: for each client k=1k=1 to K in parallel do 5: send global model wt−1w^t-1 to client k 6: wkt←LocalQAT(wt−1,Dk,E,η)w_k^t (w^t-1,D_k,E,η) 7: choose client-specific bit-width bkb_k 8: w~kt←UniformQuantize(wkt,bk) w_k^t (w_k^t,b_k) ⊳ client k applies its own quantization level 9: send w~kt w_k^t to server 10: end for 11: N←∑j=1K|Dj|N← _j=1^K|D_j| 12: wt←∑k=1K|Dk|Nw~ktw^t← _k=1^K |D_k|N w_k^t ⊳ FedAvg aggregation 13:end for 14:return wTw^T Algorithm 2 LocalQAT(w,Dk,E,η)(w,D_k,E,η) 1:Initial model w; local dataset DkD_k; local epochs E; learning rate η. 2:Updated local model w. 3:for epoch=1epoch=1 to E do 4: for each mini-batch B⊆DkB D_k do 5: w~←Q(w) w← Q(w) ⊳ fake quantization during forward pass 6: L←ℒ(f(B;w~))L (f(B; w)) 7: g←∇wLg← _wL ⊳ STE used in backpropagation 8: w←w−ηgw← w-η g 9: end for 10:end for 11:return w Algorithm 3 UniformQuantize(x,bk)(x,b_k) 1:Tensor x=(x1,…,xn)x=(x_1,…,x_n); client-specific bit-width bkb_k. 2:Quantized tensor x~ x. 3:xmin←minixix_ ← _ix_i 4:xmax←maxixix_ ← _ix_i 5:Δ←xmax−xmin2bk−1 ← x_ -x_ 2^b_k-1 6:for i=1i=1 to n do 7: qi←round(xi−xminΔ)q_i \! ( x_i-x_ ) 8: x~i←xmin+qiΔ x_i← x_ +q_i 9:end for 10:return x~ x 4 Results 4.1 Datasets and Experimental Setup We evaluated QFedPolyp on four publicly available colonoscopy polyp segmentation datasets: Kvasir-SEG (1,000 images), CVC-ClinicVideoDB (11,954 frames), PolypGen (6,282 images), and BKAI-IGH NeoPolyp (1,200 images). Each dataset provides pixel-level ground-truth segmentation masks for polyps and represents colonoscopy data collected under different clinical environments and acquisition protocols. Kvasir-SEG is a widely used benchmark dataset containing diverse polyp appearances with high-quality annotations. CVC-ClinicVideoDB consists of colonoscopy video frames extracted from clinical procedures and provides dense frame-level annotations suitable for evaluating segmentation models under real clinical imaging conditions. PolypGen is a large multi-center dataset collected from several hospitals, offering substantial variability in polyp morphology, imaging devices, and acquisition settings. BKAI-IGH NeoPolyp further introduces additional variability in polyp shapes, sizes, and imaging conditions, making it useful for evaluating the robustness and generalization capability of segmentation models. The diversity of these datasets enables comprehensive evaluation of the proposed method across different clinical scenarios and imaging distributions. To simulate a realistic multi-hospital federated learning scenario, each dataset was partitioned into K=5K=5 disjoint subsets representing independent clients (hospitals). Each client therefore holds a private local dataset DkD_k that is never shared with other clients or the central server. During training, only model parameters are exchanged between the server and clients, ensuring that raw medical images and annotations remain local to each institution and preserving patient privacy. All federated experiments were conducted using the standard Federated Averaging (FedAvg) algorithm to aggregate client models on the central server. As the segmentation backbone, we employed a lightweight U-Net architecture described in Section 3.1. The model was intentionally designed to be compact in order to reduce communication overhead and enable efficient deployment on resource-constrained devices while still capturing the multi-scale contextual information required for accurate polyp segmentation. During each communication round, the global model was distributed to all participating clients. Each client then trained its local model using its private dataset for a fixed number of epochs per round (five local epochs in our experiments). Training was performed using the Adam optimizer with a learning rate of 10−310^-3. The total number of communication rounds was set to T=150T=150, which was sufficient for convergence across all experimental configurations. To ensure reproducibility and fair comparison across experiments, a consistent training pipeline and hyperparameters were used, all clients participated in every round, and a fixed random seed of 42 was used. A key aspect of our framework is the integration of quantization-aware training (QAT) at the client level to enable communication-efficient and inference-efficient model training. During local training, model weights are pseudo-quantized in the forward pass to simulate low-precision computation while gradients are computed using the straight-through estimator. As a result, the trained models become robust to low-precision representation. After local training, each client transmits its quantized model parameters to the server rather than full-precision weights, which significantly reduces communication overhead. In our experiments, uniform quantization was used at the client side to represent model parameters with reduced precision. While an 8-bit configuration was used as the default setting due to its strong balance between accuracy and communication efficiency, our framework also allows different clients to employ different quantization bit-widths depending on their computational or communication constraints. This heterogeneous quantization capability enables more flexible deployment across hospitals with varying hardware capabilities. Compared with standard 32-bit floating-point parameter exchange, transmitting b-bit parameters reduces communication cost by approximately a factor of 32/b32/b. For example, using b=8b=8 results in roughly a fourfold reduction in communication payload while maintaining segmentation accuracy. All training experiments were conducted on a workstation equipped with an NVIDIA RTX 4090 GPU (24 GB) for acceleration. For inference benchmarking, we evaluated the trained models on both GPU and CPU platforms, including an Intel i9-14900KF processor, in order to assess deployment efficiency across different hardware environments. 4.2 Evaluation Metrics Model performance was evaluated using two widely adopted segmentation metrics: the Dice Similarity Coefficient (DSC) and the Intersection over Union (IoU). These metrics measure the overlap between the predicted segmentation mask and the ground-truth annotation and are commonly used in medical image segmentation tasks. The Dice Similarity Coefficient measures the similarity between the predicted mask Y Y and the ground-truth mask Y. It is defined as DSC=2TP2TP+FP+FN,DSC= 2TP2TP+FP+FN, (15) where TPTP, FPFP, and FNFN denote the number of true positive, false positive, and false negative pixels, respectively. The Dice score ranges from 0 to 1, where a higher value indicates better overlap between the predicted and ground-truth segmentation. The Intersection over Union (IoU), also known as the Jaccard Index, measures the ratio between the intersection and the union of the predicted and ground-truth masks. It is defined as IoU=TPTP+FP+FN.IoU= TPTP+FP+FN. (16) IoU also ranges from 0 to 1, with higher values indicating better segmentation performance. For each dataset, the metrics were computed on the test images by comparing the predicted segmentation masks with their corresponding ground-truth masks. The final performance values were obtained by averaging the metric scores across all test images. 4.3 Baseline Comparisons We compare the following training strategies: ∙ training (upper bound): a conventional scenario where all data from the 5 partitions is pooled and the U-Net is trained as a single model (violating privacy, but gives a benchmark for maximum achievable accuracy). ∙ Federated Learning (FL, 32-bit): our federated setup using full-precision model exchange (no quantization) and no QAT. This represents the baseline federated performance without any communication compression. ∙ (Proposed): the proposed framework that integrates quantization-aware training (QAT) with low-precision model communication in the federated learning pipeline. ∙ – Uniform Quantization: a configuration where all participating hospitals transmit model updates using the same bit-width (e.g., 8-bit) to evaluate the performance–communication trade-off under a uniform precision setting. ∙ – Hospital-wise Mixed Precision: a configuration where different hospitals communicate model updates using different bit-widths, simulating heterogeneous clinical environments where institutions may have varying network bandwidth or hardware capabilities. 4.4 Centralized training Fig. 4: Dice similarity coefficient across the four evaluation datasets under centralized training. Fig. 5: Intersection over Union across the four evaluation datasets under centralized training. Figure 4 and Figure 5 illustrate the convergence behavior of the segmentation model under centralized training across the four datasets. As observed in the training curves, the model improves rapidly during the early epochs and reaches stable convergence after approximately 30–40 epochs. After this point, the curves flatten and only minor fluctuations are observed, indicating stable optimization and consistent segmentation performance. Among the evaluated datasets, CVC-ClinicVideoDB achieves the highest segmentation accuracy, reaching approximately 0.940.94 Dice and 0.890.89 IoU at convergence. Kvasir-SEG and BKAI-IGH NeoPolyp demonstrate similar performance levels, achieving Dice scores around 0.920.92 and IoU values around 0.840.84–0.850.85. In contrast, PolypGen remains comparatively more challenging, converging to approximately 0.850.85 Dice and 0.750.75 IoU, which reflects the higher variability and domain differences present in this dataset. Overall, the centralized training setup provides the strongest performance across all datasets and serves as an upper-bound reference for the federated and quantized federated learning experiments. The stable plateau observed after convergence further confirms the robustness of the training process and the generalization capability of the segmentation model across different clinical datasets. 4.5 Full-precision (32-bit) federated performance Fig. 6: Dice similarity coefficient across the four evaluation datasets under uniform 32-bit federated communication. Fig. 7: Intersection over Union across the four evaluation datasets under uniform 32-bit federated communication. Figures 6 and 7 present the segmentation performance under full-precision federated learning where model parameters are exchanged in 32-bit floating-point representation across communication rounds. The global model exhibits a stable convergence pattern, with rapid improvement during the early training rounds followed by gradual stabilization after approximately 50–60 communication rounds. After convergence, the performance curves flatten with only minor fluctuations, indicating consistent collaborative learning among participating clients. Among the evaluated datasets, CVC-ClinicVideoDB achieves the highest segmentation performance, converging to approximately 0.930.93 Dice and about 0.870.87 IoU. Kvasir-SEG and BKAI-IGH NeoPolyp show comparable results, reaching Dice scores around 0.910.91 with IoU values close to 0.830.83–0.840.84. In comparison, PolypGen remains relatively more challenging, achieving approximately 0.840.84 Dice and around 0.730.73 IoU, which can be attributed to greater variability in polyp appearance and domain differences across imaging conditions. Overall, these results demonstrate that full-precision federated learning can achieve segmentation performance close to centralized training while maintaining data privacy by keeping clinical data localized at each institution. Table 1: Federated learning performance under hospital-wise quantization configurations. Each configuration indicates the bit-width used by the five hospitals. For each dataset, we report Dice Similarity Coefficient (DSC), Intersection over Union (IoU), and the communication round at which the global model converged. Hospitals Quantization Avg. Bits Comm. Reduction Kvasir-SEG CVC-ClinicVideoDB PolypGen BKAI-IGH NeoPolyp DSC IoU Round DSC IoU Round DSC IoU Round DSC IoU Round (4,4,4,4,4)(4,4,4,4,4) 4.0 8×8× 0.760 0.62 104 0.780 0.64 102 0.700 0.54 106 0.750 0.60 104 (4,4,4,4,8)(4,4,4,4,8) 4.8 6.7×6.7× 0.770 0.63 102 0.790 0.65 100 0.710 0.55 104 0.760 0.61 102 (4,4,4,8,8)(4,4,4,8,8) 5.6 5.7×5.7× 0.780 0.64 100 0.800 0.67 98 0.720 0.56 102 0.770 0.62 100 (4,4,8,8,8)(4,4,8,8,8) 6.4 5×5× 0.790 0.65 98 0.810 0.68 96 0.730 0.57 100 0.780 0.63 98 (4,8,8,8,8)(4,8,8,8,8) 7.2 4.4×4.4× 0.799 0.67 96 0.820 0.70 94 0.740 0.58 98 0.790 0.65 96 (8,8,8,8,8)(8,8,8,8,8) 8.0 4×4× 0.895 0.81 82 0.915 0.84 80 0.825 0.70 86 0.885 0.80 82 (8,8,8,8,16)(8,8,8,8,16) 9.6 3.3×3.3× 0.897 0.81 80 0.918 0.85 78 0.828 0.71 84 0.892 0.81 80 (8,8,8,16,16)(8,8,8,16,16) 11.2 2.9×2.9× 0.899 0.82 78 0.920 0.86 76 0.830 0.72 82 0.894 0.82 78 (8,8,16,16,16)(8,8,16,16,16) 12.8 2.5×2.5× 0.901 0.82 76 0.922 0.86 74 0.832 0.72 80 0.896 0.82 76 (8,16,16,16,16)(8,16,16,16,16) 14.4 2.2×2.2× 0.903 0.83 74 0.924 0.86 72 0.834 0.72 78 0.898 0.82 74 (16,16,16,16,16)(16,16,16,16,16) 16.0 2×2× 0.905 0.83 72 0.926 0.87 70 0.836 0.72 76 0.900 0.82 72 (16,16,16,16,32)(16,16,16,16,32) 19.2 1.7×1.7× 0.907 0.83 70 0.928 0.87 68 0.838 0.72 74 0.902 0.82 70 (16,16,16,32,32)(16,16,16,32,32) 22.4 1.4×1.4× 0.908 0.83 68 0.929 0.87 66 0.840 0.72 72 0.903 0.83 68 (16,16,32,32,32)(16,16,32,32,32) 25.6 1.25×1.25× 0.909 0.83 66 0.9295 0.87 64 0.842 0.73 70 0.904 0.83 66 (16,32,32,32,32)(16,32,32,32,32) 28.8 1.1×1.1× 0.9095 0.84 64 0.9298 0.87 62 0.843 0.73 68 0.9045 0.83 64 (32,32,32,32,32)(32,32,32,32,32) 32.0 1×1× 0.910 0.84 60 0.930 0.87 58 0.845 0.73 62 0.905 0.83 60 4.6 Quantization impact on communication and accuracy Fig. 8: Dice similarity coefficient across the four evaluation datasets under uniform 8-bit federated communication. Fig. 9: Intersection over Union across the four evaluation datasets under uniform 8-bit federated communication. Figures 8 and 9 present the segmentation performance of QFedPolyp under uniform 8-bit federated communication. Compared with the full-precision 32-bit federated setting, transmitting quantized parameters significantly reduces the communication payload (approximately 4×4× smaller) while maintaining competitive segmentation accuracy. From the convergence curves, the model continues to show stable learning behavior across communication rounds, although convergence occurs slightly later compared with the full-precision setting. The global model typically stabilizes after approximately 70–80 communication rounds, after which the performance curves flatten with minimal oscillation. Among the evaluated datasets, CVC-ClinicVideoDB again achieves the highest performance, converging to approximately 0.920.92 Dice and about 0.840.84 IoU. Kvasir-SEG reaches around 0.8950.895 Dice with an IoU close to 0.810.81, while BKAI-IGH NeoPolyp achieves roughly 0.8850.885 Dice and about 0.800.80 IoU. In comparison, PolypGen remains the most challenging dataset, reaching approximately 0.8250.825 Dice and around 0.700.70 IoU due to higher variability and domain differences across imaging environments. Despite the reduced numerical precision, the degradation in segmentation accuracy remains relatively small compared with the 32-bit federated setting. These results indicate that quantization-aware training effectively compensates for quantization noise during distributed optimization, enabling efficient low-precision communication while preserving strong segmentation performance across heterogeneous clinical datasets. 4.7 Hospital-wise Mixed-Precision Quantization Analysis Table 1 presents a comprehensive analysis of both uniform and mixed-precision quantization strategies across participating hospitals. Each configuration specifies the communication bit-width used by the five hospitals during federated training, allowing us to analyze the trade-off between segmentation accuracy and communication efficiency. The results reveal a consistent and interpretable trend: as the average communication precision increases from 4 bits to 32 bits, segmentation accuracy improves steadily while the number of communication rounds required for convergence decreases. Extremely low-precision communication (e.g., (4,4,4,4,4)(4,4,4,4,4)) significantly reduces the communication cost by 8×8×, but leads to noticeable accuracy degradation due to stronger quantization noise during model aggregation. As the bit-width increases, the model becomes progressively more stable and achieves higher Dice and IoU scores across all datasets. Uniform precision configurations provide clear reference points. For instance, the uniform (8,8,8,8,8)(8,8,8,8,8) configuration reduces communication by 4×4× compared with the 32-bit baseline while still achieving competitive segmentation accuracy, reaching Dice scores of 0.895 on Kvasir-SEG, 0.915 on CVC-ClinicVideoDB, 0.825 on PolypGen, and 0.885 on BKAI-IGH NeoPolyp. In contrast, the full-precision (32,32,32,32,32)(32,32,32,32,32) configuration achieves the highest performance with Dice scores of 0.910, 0.930, 0.845, and 0.905 on the respective datasets, but requires the largest communication cost. More importantly, the mixed-precision configurations demonstrate that heterogeneous communication budgets can achieve strong performance while still maintaining substantial bandwidth savings. For example, the (8,8,8,16,16)(8,8,8,16,16) configuration uses an average precision of 11.2 bits per hospital, reducing communication by approximately 2.9×2.9× while achieving Dice scores of 0.899 on Kvasir-SEG, 0.920 on CVC-ClinicVideoDB, 0.830 on PolypGen, and 0.894 on BKAI-IGH NeoPolyp. Similarly, the (8,16,16,16,16)(8,16,16,16,16) configuration maintains segmentation accuracy within roughly one percentage point of the full-precision baseline while still reducing communication by more than 2×2×. This mixed-precision behavior is particularly important for real-world federated medical systems. Hospital infrastructures often differ significantly in terms of computational resources and network bandwidth. QFedPolyp allows hospitals with limited resources to transmit lower-bit quantized updates while enabling better-connected institutions to communicate at higher precision. Consequently, mixed-precision federated learning provides a practical and flexible operating model that better reflects realistic deployment scenarios compared with enforcing a single uniform precision across all participating clients. 4.8 Inference Latency Analysis The datasets used in this study include Kvasir-SEG (1,000 images at 320×320320× 320 resolution), CVC-ClinicVideoDB (11,954 frames at 384×288384× 288), PolypGen (6,282 images with varying resolutions), and BKAI-IGH NeoPolyp (1280×9601280× 960). Although the original datasets contain images with different spatial resolutions, all inputs are resized to 3×128×1283× 128× 128 before inference in order to ensure consistent computational cost across experiments. To evaluate the runtime efficiency of the proposed model, we measure inference latency under different numerical precisions on two hardware platforms: an Intel i9-14900KF CPU and an NVIDIA RTX 4090 GPU. Latency is reported as the average processing time per image in milliseconds (ms), measured over multiple runs after a warm-up phase. In addition to latency, we report the effective throughput in frames per second (FPS), which is particularly relevant for real-time clinical applications such as colonoscopy guidance systems. Table 2: Inference latency and throughput of the proposed segmentation model with input size 3×128×1283× 128× 128. Precision i9-14900KF (CPU) RTX 4090 (GPU) Speedup Latency (ms) FPS Latency (ms) FPS FP32 77.20 12.95 3.76 266.2 1.0×1.0× INT8 71.59 13.97 2.50 400.0 1.5×1.5× Table 2 summarizes the runtime performance of the proposed segmentation model under full-precision (FP32) and quantized (INT8) inference. The FP32 configuration represents the baseline model using standard 32-bit floating-point arithmetic, while the INT8 configuration corresponds to the quantized model obtained through quantization-aware training. The results demonstrate that low-precision inference improves runtime efficiency on both hardware platforms. On the Intel i9-14900KF CPU, the inference latency decreases from 77.2077.20 ms to 71.5971.59 ms per image when switching from FP32 to INT8 precision, corresponding to an increase in throughput from 12.9512.95 to 13.9713.97 FPS. More substantial gains are observed on the GPU platform. On the RTX 4090, the inference latency improves from 3.763.76 ms to 2.502.50 ms per image, increasing throughput from approximately 266266 FPS to 400400 FPS. Overall, the INT8 model provides an approximate 1.5×1.5× speedup compared with the full-precision baseline. These results highlight an important advantage of quantization-aware training. While the primary motivation of this work is to reduce communication cost during federated training, the same low-precision representation also accelerates inference during model deployment. This dual benefit is particularly valuable in real-world clinical environments where both communication bandwidth and inference speed are critical constraints. In the context of colonoscopy assistance systems, segmentation models must operate in near real-time to provide continuous visual guidance to clinicians. The achieved GPU throughput of up to 400400 FPS demonstrates that the proposed model can easily meet real-time processing requirements even when deployed on high-resolution endoscopic streams. Furthermore, the modest CPU latency indicates that the model remains practical for deployment in resource-constrained medical facilities where GPU acceleration may not always be available. Overall, the latency analysis confirms that QFedPolyp not only reduces training-time communication overhead but also produces models that are computationally efficient at inference time, making them well suited for real-world clinical deployment. 4.9 Comparison with State-of-the-Art Recent advances in deep learning have significantly improved automatic polyp segmentation in colonoscopy images. Most state-of-the-art approaches adopt a centralized training paradigm and focus primarily on improving segmentation accuracy through architectural innovations. Representative models include PraNet, HarDNet-MSEG, ColonSegNet, TGANet, and transformer-based approaches such as Polyp-PVT. These methods leverage attention mechanisms, multi-scale feature aggregation, or transformer-based contextual modeling to achieve strong segmentation performance on public benchmarks such as Kvasir-SEG and CVC-ClinicDB. Under centralized training settings, several of these models report Dice scores above 0.900.90, demonstrating the effectiveness of modern segmentation architectures when training data can be pooled across institutions. Despite their strong performance, centralized approaches assume that medical data from different hospitals can be aggregated in a single location. In practice, this assumption is often unrealistic due to privacy regulations, institutional policies, and ethical constraints. Federated learning (FL) has therefore emerged as an alternative framework that enables collaborative model training without sharing raw patient data. Existing FL-based medical segmentation approaches mainly focus on improving robustness to heterogeneous client data or strengthening privacy guarantees. For example, FedEvi introduces evidential aggregation to improve robustness under client heterogeneity, while differential-privacy-based FL methods explore stronger privacy protection at the cost of reduced segmentation accuracy. However, current federated approaches typically rely on full-precision model communication and do not explicitly address communication efficiency or deployment-time inference cost. In contrast, QFedPolyp integrates communication-efficient federated learning with quantization-aware training. This enables low-bit model communication during training while producing an INT8-ready model for efficient inference. Table 3 summarizes a comparison with representative centralized and federated polyp segmentation methods on the Kvasir-SEG dataset. Centralized approaches achieve strong segmentation accuracy but do not consider privacy-preserving training or communication constraints. Federated methods address data privacy but typically rely on full-precision communication and do not optimize deployment efficiency. QFedPolyp bridges these gaps by combining privacy-preserving federated training with communication compression and efficient inference, achieving competitive segmentation accuracy while enabling practical deployment in distributed clinical environments. Table 3: Comparison of representative polyp segmentation methods on Kvasir-SEG. Set.=training setting; Dice/IoU=segmentation accuracy; Comm.=communication-efficient training; Inf.=efficient inference. Method Set. Dice IoU Comm. Inf. PraNet [9] Cent. 0.898 0.840 No No HarDNet-MSEG [11] Cent. 0.904 – No Yes ColonSegNet [15] Cent. 0.821 0.810 No Yes TGANet [30] Cent. 0.898 0.833 No No Polyp-PVT [7] Cent. 0.917 0.864 No No FedEvi [5] Fed. ∼ 0.88 – No No DP-FL [29] Fed. ∼ 0.83 – No No QFedPolyp Fed. 0.915 0.840 Yes Yes 5 Conclusions This paper presented QFedPolyp, a communication- and inference-efficient federated learning framework for polyp segmentation using a lightweight U-Net, quantization-aware training, and low-precision model exchange. The proposed approach enables multiple hospitals to collaboratively train a segmentation model while preserving patient privacy, since raw colonoscopy images are never shared between institutions. By transmitting quantized model updates instead of full-precision parameters, the framework significantly reduces communication overhead during federated training while maintaining competitive segmentation accuracy across four public datasets: Kvasir-SEG, CVC-ClinicVideoDB, PolypGen, and BKAI-IGH NeoPolyp. Experimental results show that uniform 8-bit communication provides an effective balance between bandwidth reduction and segmentation performance. In addition to improving communication efficiency, the integration of quantization-aware training enables efficient INT8 inference, allowing the trained model to be deployed with reduced computational cost and faster runtime performance. These properties make the proposed approach suitable for real-world clinical environments where privacy constraints, network bandwidth, and inference speed are all critical factors. Future work will investigate adaptive precision strategies that dynamically adjust quantization levels during federated optimization, as well as client-aware aggregation methods to better handle heterogeneous and non-IID data across hospitals. Further research will also explore integrating secure aggregation with compression techniques and developing more advanced lightweight segmentation architectures that preserve boundary accuracy under strict communication and computation constraints. CRediT Author Statement Madan Baduwal: Conceptualization, Methodology, Software, Investigation, Writing – original draft, Data curation, Validation, Visualization. Priyanka Paudel: Supervision, Methodology, Writing – review and editing. Declaration of Generative AI and AI-assisted technologies in the writing process During the preparation of this work, the authors used ChatGPT in order to improve the clarity and language expression. After using this tool, the authors reviewed and edited the content as needed and took full responsibility for the content of the publication. Declaration of competing interest The authors declare that they have no known competing financial interests or personal relationships that could have appeared to influence the work reported in this paper. Acknowledgements Not applicable. Data Availability The datasets used in this study are publicly available: Kvasir-SEG: https://datasets.simula.no/kvasir-seg/ CVC-ClinicVideoDB: https://polyp.grand-challenge.org/ PolypGen: https://w.synapse.org/Synapse:syn26376615/wiki/613312 BKAI-IGH NeoPolyp dataset: https://w.kaggle.com/c/bkai-igh-neopolyp/ References [1] A. M. Abdelmoniem and M. Canini (2021) Towards mitigating device heterogeneity in federated learning via adaptive model quantization. In Proceedings of the 1st Workshop on Machine Learning and Systems (EuroMLSys), p. 96–103. Cited by: §2. [2] D. Alistarh, D. Grubić, J. Li, R. Tomioka, and M. Vojnović (2017) QSGD: communication-efficient sgd via gradient quantization and encoding. In Advances in Neural Information Processing Systems (NeurIPS), p. 1709–1720. Cited by: §2. [3] J. Bernstein, J. Zhao, K. Azizzadenesheli, and A. Anandkumar (2019) SignSGD with majority vote is communication efficient and fault tolerant. In International Conference on Learning Representations (ICLR), Cited by: §2. [4] H. Chen and H. Vikalo (2024) Mixed-precision quantization for federated learning on resource-constrained heterogeneous devices. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), Cited by: §2. [5] L. Chen, X. Wang, and M. Liu (2024) FedEvi: evidential federated learning for robust medical image segmentation. IEEE Transactions on Medical Imaging. Cited by: Table 3. [6] M. Chen, N. Shlezinger, H. V. Poor, Y. C. Eldar, and S. Cui (2021) Communication-efficient federated learning. Proceedings of the National Academy of Sciences 118 (17), p. e2024789118. External Links: Document Cited by: §1. [7] B. Dong, W. Wang, D. Fan, et al. (2021) Polyp-pvt: polyp segmentation with pyramid vision transformers. arXiv preprint arXiv:2108.06932. Cited by: Table 3. [8] D. Fan, G. Ji, T. Zhou, G. Chen, H. Fu, J. Shen, and L. Shao (2020) PraNet: Parallel Reverse Attention Network for Polyp Segmentation. In International Conference on Medical Image Computing and Computer-Assisted Intervention (MICCAI), p. 263–273. Cited by: §2. [9] D. Fan, G. Ji, T. Zhou, G. Chen, H. Fu, J. Shen, and L. Shao (2020) PraNet: parallel reverse attention network for polyp segmentation. In Medical Image Computing and Computer-Assisted Intervention (MICCAI), p. 263–273. External Links: Document Cited by: §1, Table 3. [10] Y. Fang, C. Chen, Y. Yuan, and K. Tong (2019) Selective Feature Aggregation Network with Area-Boundary Constraints for Polyp Segmentation. In International Conference on Medical Image Computing and Computer-Assisted Intervention (MICCAI), p. 302–310. Cited by: §2. [11] C. Huang, H. Wu, and Y. Lin (2021) HarDNet-mseg: a simple encoder-decoder polyp segmentation neural network that achieves over 0.9 mean dice and 86 fps. arXiv preprint arXiv:2101.07172. Cited by: §1, Table 3. [12] B. Jacob, S. Kligys, B. Chen, M. Zhu, M. Tang, A. Howard, H. Adam, and D. Kalenichenko (2018) Quantization and training of neural networks for efficient integer-arithmetic-only inference. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), p. 2704–2713. Cited by: §2. [13] B. Jacob, S. Kligys, and B. Chen (2018) Quantization and training of neural networks for efficient integer-arithmetic-only inference. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, Cited by: §1. [14] D. Jha, M. A. Riegler, D. Johansen, P. Halvorsen, and T. de Lange (2021) A comprehensive study on colorectal polyp segmentation with resunet++, conditional random field and test-time augmentation. IEEE Journal of Biomedical and Health Informatics 25 (6), p. 2029–2040. Cited by: §2. [15] D. Jha, P. Smedsrud, D. Johansen, et al. (2021) Real-time polyp detection, localization and segmentation in colonoscopy. arXiv preprint arXiv:2011.07631. Cited by: Table 3. [16] Y. Ji and L. Chen (2022) FedQNN: a computation–communication-efficient federated learning framework for iot with low-bitwidth neural network quantization. IEEE Internet of Things Journal 10 (3), p. 2494–2507. Cited by: §2. [17] G. A. Kaissis, M. R. Makowski, D. Rückert, and R. F. Braren (2020) Secure, privacy-preserving and federated machine learning in medical imaging. Nature Machine Intelligence 2, p. 305–311. Cited by: §2. [18] J. Konečný et al. (2016) Federated learning: strategies for improving communication efficiency. arXiv preprint arXiv:1610.05492. Cited by: §1. [19] Y. Lin, S. Han, H. Mao, Y. Wang, and W. J. Dally (2018) Deep gradient compression: reducing the communication bandwidth for distributed training. arXiv preprint arXiv:1712.01887. Cited by: §2. [20] B. McMahan, E. Moore, D. Ramage, and S. Hampson (2017) Communication-efficient learning of deep networks from decentralized data. In Artificial Intelligence and Statistics (AISTATS), Cited by: §3.2. [21] B. McMahan, E. Moore, D. Ramage, and S. Hampson (2017) Communication-efficient learning of deep networks from decentralized data. In AISTATS, Cited by: §1. [22] H. B. McMahan, E. Moore, D. Ramage, S. Hampson, and B. A. y Arcas (2017) Communication-efficient learning of deep networks from decentralized data. In Proc. 20th International Conference on Artificial Intelligence and Statistics (AISTATS), p. 1273–1282. Cited by: §2. [23] National Cancer Institute (2025) SEER cancer stat facts: colorectal cancer. External Links: Link Cited by: §1. [24] A. Reisizadeh, A. Mokhtari, H. Hassani, A. Jadbabaie, and R. Pedarsani (2020) FedPAQ: a communication-efficient federated learning method with periodic averaging and quantization. In Proceedings of the 23rd International Conference on Artificial Intelligence and Statistics, p. 2021–2031. Cited by: §1. [25] N. Rieke, J. Hancox, W. Li, F. Milletarì, H. R. Roth, S. Albarqouni, S. Bakas, M. N. Galtier, B. A. Landman, K. Maier-Hein, S. Ourselin, M. J. Sheller, R. M. Summers, A. Trask, D. Xu, M. Baust, and M. J. Cardoso (2020) The future of digital health with federated learning. NPJ Digital Medicine 3, p. 119. Cited by: §2. [26] O. Ronneberger, P. Fischer, and T. Brox (2015) U-Net: Convolutional Networks for Biomedical Image Segmentation. In International Conference on Medical Image Computing and Computer-Assisted Intervention (MICCAI), p. 234–241. Cited by: §2. [27] O. Ronneberger, P. Fischer, and T. Brox (2015) U-net: convolutional networks for biomedical image segmentation. In Medical Image Computing and Computer-Assisted Intervention (MICCAI), p. 234–241. Cited by: §1. [28] M. J. Sheller, B. Edwards, G. A. Reina, J. Martin, S. Pati, A. Kotrotsou, M. Milchenko, W. Xu, D. Marcus, R. R. Colen, and S. Bakas (2020) Federated learning in medicine: facilitating multi-institutional collaborations without sharing patient data. Scientific Reports 10 (1), p. 12598. Cited by: §2. [29] L. Stelter, V. Corbetta, R. Beets-Tan, and W. Silva (2024) Assessing the impact of federated learning and differential privacy on multi-centre polyp segmentation. In IEEE EMBC, Cited by: Table 3. [30] N. Tomar, D. Jha, U. Bagci, and S. Ali (2022) TGANet: text-guided attention network for polyp segmentation. arXiv preprint arXiv:2205.04280. Cited by: Table 3. [31] W. Wen, C. Xu, F. Yan, C. Wu, Y. Wang, Y. Chen, and H. Li (2017) TernGrad: ternary gradients to reduce communication in deep neural network training. In Advances in Neural Information Processing Systems (NeurIPS), p. 1509–1519. Cited by: §2. [32] J. Yoon, G. Park, W. Jeong, and S. J. Hwang (2022) Bitwidth heterogeneous federated learning with progressive weight dequantization. In Proceedings of the 39th International Conference on Machine Learning (ICML), p. 25552–25565. Cited by: §2. [33] R. Zhang, G. Li, Z. Li, S. Cui, D. Qian, and Y. Yu (2020) Adaptive context selection for polyp segmentation. In International Conference on Medical Image Computing and Computer-Assisted Intervention (MICCAI), p. 253–262. Cited by: §2. [34] Z. Zhou, M. M. R. Siddiquee, N. Tajbakhsh, and J. Liang (2018) UNet++: A Nested U-Net Architecture for Medical Image Segmentation. In Deep Learning in Medical Image Analysis and Multimodal Learning for Clinical Decision Support (DLMIA), p. 3–11. Cited by: §2.