FedSCS-XGB -- Federated Server-centric surrogate XGBoost for continual health monitoring

This paper introduces FedSCS-XGB, a novel federated learning protocol for distributed XGBoost that preserves the algorithm's structural advantages and achieves near-centralized performance (within a 1% gap) for continual health monitoring via wearable sensors.

The Gist

The Big Picture: The "Smart Watch" Problem

Imagine you have a smartwatch that tracks your health 24/7. It knows when you are sleeping, walking, or sitting in a wheelchair. For people with spinal cord injuries, this data is life-saving; it can predict dangerous pressure sores or blood pressure drops before they happen.

The Problem: To make the watch smart, you usually need to send all that private data to a giant central computer (the "Cloud") to train a brain (an AI model). But sending your private health data to a central server is risky. It's like mailing your diary to a stranger just so they can learn how to write better stories.

The Solution: The authors created a new way to train this AI without ever sending the raw diary pages. Instead, the AI learns by exchanging only "clues" between the watch and the server. They call this FedSCS-XGB.

---

The Cast of Characters

1. The Patients (The Clients): People wearing sensors on their bodies and wheelchairs. They hold the data.
2. The Server (The Teacher): A central computer that wants to teach the AI how to recognize activities (like "eating," "transferring to a chair," or "sleeping").
3. The AI (XGBoost): Think of this as a very smart, rule-based detective. It doesn't use deep neural networks (which are like black boxes); instead, it uses a flowchart of "If this, then that" rules. It's fast, explainable, and great for medical decisions.

---

The Analogy: The "Classroom" vs. The "Secret Club"

The Old Way (Centralized Training)

Imagine a teacher (Server) wants to teach a class how to identify different animals.

• Old Method: Every student brings their own photo album of animals to the teacher's desk. The teacher looks at all the photos at once to learn.
• The Issue: The students don't want to leave their photo albums on the teacher's desk because they are private.

The New Way (Federated Learning)

The teacher stays at the desk. The students stay in their seats.

• The Process: The teacher asks, "Who has a picture of a cat?" The students look at their own albums. Instead of sending the photo, they send a tiny note: "I have 5 cat pictures, and they are mostly orange."
• The Result: The teacher combines all the notes to build a master rulebook: "Cats are usually orange." No photos ever left the students' desks.

FedSCS-XGB is a super-advanced version of this "note-passing" system, specifically designed for a type of AI called XGBoost.

---

How FedSCS-XGB Works: The "Two-Round" Dance

The paper introduces a specific dance the Server and the Patients do to learn together. It happens in two rounds:

Round 1: The "Rough Sketch" (Finding the Boundaries)

• The Goal: The Server needs to know where to draw the lines in the data. (e.g., Is "fast movement" 5 meters per second or 10?)
• The Action: The Server asks the Patients: "Give me a rough sketch of your data distribution, weighted by how important each data point is."
• The Analogy: Imagine the Server asks the class, "Without showing me your photos, just tell me: roughly how many orange cats do you have compared to black cats?"
• The Magic: The Patients send a compressed summary (a "sketch"). The Server merges these sketches to draw a global map of where the lines should be.

Round 2: The "Exact Count" (Filling in the Details)

• The Goal: Now that the Server has the map (the boundaries), it needs to count exactly how many data points fall into each box.
• The Action: The Server sends the map back to the Patients. The Patients look at their data, sort it into the boxes defined by the map, and send back the counts (e.g., "I have 12 data points in the 'Fast' box").
• The Result: The Server now has a perfect histogram (a bar chart) of the entire group's data, without ever seeing a single raw number. It uses this to update the AI's rules.

Why is this better than the old "Federated XGBoost" (PAX)?

The paper compares their new method (FedSCS-XGB) to an older method called PAX.

• PAX (The "Local Translator"): In the old method, every student tried to translate their own data into a local language before sending it. The teacher had to try to understand all these different local languages. Sometimes, the translations didn't match up perfectly, leading to confusion and a weaker AI.
• FedSCS-XGB (The "Global Map"): In the new method, the teacher first establishes a single, universal map (the boundaries) that everyone agrees on. Then, everyone just counts their items according to that same map.
• The Result: Because everyone is counting on the same map, the final AI is much more accurate. The paper shows that this new method performs almost exactly as well as if the teacher had seen all the raw data (within a 1% difference), but with total privacy.

Why Does This Matter for Spinal Cord Injuries?

1. Privacy First: People with spinal cord injuries generate sensitive data. This method ensures their daily movements and health stats never leave their devices.
2. Personalization: Everyone's body moves differently. This system allows the AI to learn from a group of people while respecting individual differences (heterogeneity).
3. Speed and Clarity: Unlike complex "Deep Learning" models that are slow and hard to understand, this "Tree-based" AI is fast and its decisions can be explained (e.g., "The AI flagged a risk because you sat still for 2 hours").

The Bottom Line

The authors built a privacy-preserving classroom where a central teacher can learn to recognize human activities from wearable sensors without ever seeing the students' private data.

By using a clever two-step process (Sketching boundaries, then counting atoms), they proved mathematically and practically that you can get 99% of the performance of a central AI while keeping the data 100% private. This is a huge step forward for wearable health tech that actually respects user privacy.

Technical Summary

1. Problem Statement

The paper addresses the challenge of continual health monitoring for individuals with Spinal Cord Injuries (SCI), who are at high risk for secondary health conditions (e.g., pressure injuries, blood pressure instability).

• Data Characteristics: Wearable sensor data is inherently heterogeneous, non-stationary, and privacy-sensitive. Centralizing this data for model training violates privacy regulations and creates logistical bottlenecks.
• Limitations of Current Solutions:
  • Deep Learning: While popular in Federated Learning (FL) for Human Activity Recognition (HAR), neural networks are computationally expensive for edge devices and often lack interpretability.
  • Standard XGBoost: While efficient and interpretable, standard XGBoost requires centralized data access, which conflicts with privacy-preserving deployments.
  • Existing Federated XGBoost: Previous approaches like Party-Adaptive XGBoost (PAX) rely on client-specific surrogate representations, which can degrade performance in highly heterogeneous federated settings and may not fully preserve the optimization dynamics of centralized XGBoost.

Goal: Develop a distributed machine learning (DML) protocol that enables privacy-preserving, collaborative training of XGBoost models on wearable sensor data while maintaining the structural and optimization properties of centralized training.

2. Methodology: FedSCS-XGB

The authors propose FedSCS-XGB (Federated Server-Centric Surrogate XGBoost), a novel protocol inspired by PAX but designed to explicitly preserve the histogram-based split construction and tree-ensemble dynamics of standard XGBoost.

Core Protocol Mechanics

The protocol operates in two alternating synchronous phases per boosting round:

1. Sketch Phase (Bin Edge Estimation):
   • Clients compute Hessian-weighted DDSketches (mergeable quantile sketches) for each feature based on local data gradients and Hessians.
   • Clients transmit these sketches to the server.
   • The server merges the sketches to derive global bin edges. This ensures that all clients quantize their data using the same global boundaries, rather than client-specific ones.
2. Atom Phase (Sufficient Statistics Aggregation):
   • Clients quantize their local samples using the received global bin edges.
   • Clients aggregate sufficient statistics (weights $W$, gradients $G$, and Hessians $H$) for each unique multi-feature bin vector (called an "atom").
   • Clients transmit only these aggregated atom summaries to the server.
   • The server performs the split search, tree growth, and weight calculation using these global histograms, then sends the resulting tree stumps back to clients to update local margins.

Key Technical Distinctions from PAX

• Separation of Concerns: FedSCS-XGB separates bin-edge estimation from statistic aggregation into two distinct phases, whereas PAX constructs party-specific surrogate features.
• Global Alignment: By using Hessian-weighted global bin edges, FedSCS-XGB ensures that the split candidates evaluated by the server are consistent with a centralized histogram XGBoost, rather than an approximation based on local surrogates.
• Multiclass Support: The protocol supports multiclass classification (softmax) by growing a tree group (one tree per class) per boosting round, maintaining the standard XGBoost semantics.

3. Key Contributions

1. Theoretical Convergence Analysis: The authors provide a rigorous proof showing that under specific conditions (bounded derivatives, accurate sketching, and fixed edges), the FedSCS-XGB objective converges to the centralized XGBoost objective. They demonstrate that the gap in objective value is bounded by the sketch accuracy ($\alpha$), proving that the distributed solution can be arbitrarily close to the centralized one.
2. Novel Protocol Design: The introduction of a server-centric approach that retains native histogram construction and split-finding dynamics, avoiding the need to adapt the model structure to protocol constraints.
3. Empirical Validation on Real-World Data: Evaluation on a dataset of 8 SCI patients performing 16 distinct Activities of Daily Living (ADLs) using multimodal wearable sensors (ECG, accelerometers, pressure mats).
4. Performance Benchmarking: A comprehensive comparison against centralized XGBoost and the PAX protocol, demonstrating superior performance and stability.

4. Experimental Results

The system was implemented using the Flower federated learning framework and evaluated on a dataset of 44,358 time-windowed samples.

• Performance Gap: FedSCS-XGB closely matches the performance of centralized XGBoost, with an accuracy gap of less than 1.5% across all tested histogram bin counts (64 to 512).
• Comparison with PAX: FedSCS-XGB consistently outperformed PAX.
  • Accuracy: FedSCS-XGB achieved higher accuracy than PAX across all clients and bin sizes.
  • Stability: FedSCS-XGB showed significantly lower variance in F1-scores across clients, indicating better robustness to class imbalance and client heterogeneity. PAX exhibited substantial performance degradation, particularly with larger bin counts.
• Bin Resolution Sensitivity: Performance remained stable when increasing bin sizes from 128 to 512, suggesting that once global alignment is achieved, the system is not overly sensitive to resolution, unlike PAX which showed degradation with higher complexity.

Table II Summary (Key Findings):

• Centralized Baseline: ~95.7% Accuracy, ~91.4% F1.
• FedSCS-XGB: ~94.4–95.1% Accuracy, ~88.9–90.2% F1 (Gap < 1.5%).
• PAX: ~91.4–93.9% Accuracy, ~85.3–88.6% F1 (Significant gap, especially in F1).

5. Significance and Conclusion

• Privacy-Preserving Edge AI: The work demonstrates that high-performance, interpretable tree-based models can be trained on sensitive medical data without centralizing raw sensor streams.
• Interpretability & Efficiency: By leveraging XGBoost, the resulting models offer deterministic inference and interpretable decision logic (via tree splits), which is crucial for clinical trust and deployment on resource-constrained wearable devices.
• Robustness to Heterogeneity: The server-centric, Hessian-weighted bin alignment mechanism proves more effective than party-adaptive surrogates in handling the non-IID (non-independent and identically distributed) data typical of individual patient monitoring.
• Future Directions: While currently a foundation model, the authors note that future work will focus on extending the framework to support personalization (adapting models to individual users) and handling noisy, longitudinal real-world data.

In summary, FedSCS-XGB bridges the gap between the efficiency/interpretability of Gradient Boosted Decision Trees and the privacy requirements of Federated Learning, offering a viable solution for scalable, continuous health monitoring in chronic care scenarios.