🤖 machine learning

Evidential Trust-Aware Model Personalization in Decentralized Federated Learning for Wearable IoT

The paper presents Murmura, a decentralized federated learning framework for wearable IoT that leverages evidential deep learning to quantify epistemic uncertainty as a principled measure of peer compatibility, thereby enabling trust-aware model personalization that significantly outperforms existing methods in non-IID environments.

Original authors: Murtaza Rangwala, Richard O. Sinnott, Rajkumar Buyya

Published 2026-05-22

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Murtaza Rangwala, Richard O. Sinnott, Rajkumar Buyya

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 thousands of smartwatches and fitness trackers want to learn how to recognize your activities—like walking, running, or sleeping—without ever sending your private data to a central server. This is the world of Decentralized Federated Learning (DFL). Instead of a bossy teacher collecting everyone's homework, the devices talk to each other directly, sharing what they've learned to get smarter together.

However, there's a big problem: everyone is different.

Your watch might be on your left wrist, while your friend's is on their right. You might be a marathon runner, while they are a casual walker. Your data is "statistically heterogeneous," meaning the patterns your watch sees are different from what others see. If they all just mash their knowledge together into one "average" model, the result is a mediocre model that doesn't work well for anyone.

The paper introduces a new framework called MURMURA to solve this. Think of MURMURA as a smart, cautious diplomat that helps these devices decide who to trust and who to ignore so they can build personalized models that actually work for them.

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

1. The Problem: The "Bad Neighbor" Dilemma

In a normal decentralized network, if Device A gets a model update from Device B, it usually just blends them together. But what if Device B is learning about "swimming" while Device A is learning about "cycling"? If Device A blindly accepts Device B's advice, it might get confused and start thinking swimming is cycling.

Existing methods try to solve this by measuring how "similar" the models look (like comparing the length of their arms). But this is flawed. Two devices might have very different data (one swims, one cycles) but still have similar-looking models because they are both good at what they do. Conversely, two devices might have similar data but one is just learning poorly. Simple similarity checks can't tell the difference between "different but good" and "different and bad."

2. The Solution: The "Uncertainty Detective"

MURMURA uses a special type of AI called Evidential Deep Learning. Think of this as giving every device a "confidence meter" that doesn't just say "I think this is walking," but also says, "I am 90% sure, and I know why I am sure."

This confidence meter breaks uncertainty into two types:

The "I've never seen this before" feeling (Epistemic Uncertainty): If a device looks at your data and says, "I have no idea what this is because I was trained on totally different stuff," that's a red flag. It means the other device is incompatible.
The "This is a tricky case" feeling (Aleatoric Uncertainty): If a device says, "This looks like walking, but it's a weird, wobbly walk, so I'm not 100% sure," that's fine. It means the data is just hard, not incompatible.

3. How MURMURA Works: The "Trust Filter"

Here is the step-by-step process MURMURA uses:

The Test Drive: When Device A receives a model from Device B, it doesn't just accept it. It runs Device B's model on its own local "test questions" (validation data).
The Confidence Check: Device A looks at the "I've never seen this before" score (Epistemic Uncertainty).
- High Score: "Whoa, this model is totally lost on my data. This person is from a different world." -> Reject.
- Low Score: "This model understands my data, even if it's not perfect." -> Trust.
The Smart Mix: Device A only mixes its own model with the models of the "trusted" neighbors. It ignores the ones that don't fit.
Getting Stricter Over Time: At the very beginning of training, everyone is confused, so MURMURA is lenient and lets many neighbors in. As training progresses and models get smarter, the "trust filter" gets stricter, only letting in the most compatible peers.

4. The Results: Why It Matters

The authors tested MURMURA on three real-world wearable datasets (involving activities like walking, running, and heart rate monitoring). Here is what they found:

It Handles Chaos Better: When the data was very messy and different (non-IID), standard methods crashed, losing about 19% of their accuracy. MURMURA only lost 0.9%. It kept its cool while others panicked.
It Learns Faster: Because it filters out the "noise" from incompatible neighbors, it converges (reaches its peak performance) 7.4 times faster than standard methods. This means less battery drain and less time waiting for the model to work.
It's Stable: It didn't need to be tweaked perfectly to work. Whether the settings were slightly off or spot on, it performed consistently well.

The Bottom Line

MURMURA is like a smart social network for your devices. Instead of forcing everyone to agree on one "average" opinion, it lets each device find its own "tribe" of compatible neighbors. By using a special "uncertainty meter" to detect who truly understands their local data, it ensures that every device gets a personalized model that works perfectly for them, without getting confused by the rest of the world.

Technical Summary: MURMURA – Evidential Trust-Aware Model Personalization in Decentralized Federated Learning

1. Problem Statement

Decentralized Federated Learning (DFL) enables collaborative model training across edge devices without a central coordinator, offering resilience against single points of failure. However, a fundamental challenge arises from statistical heterogeneity (non-IID data), where local data distributions vary significantly due to user diversity, sensor placement, and environmental contexts.

This heterogeneity creates a tension: nodes require models personalized to their local distributions, yet naive collaboration with incompatible peers can degrade performance. Existing approaches face two primary limitations:

Global Model Enforcement: Standard methods often force a single global model that fits no specific node well.
Heuristic Peer Selection: Current personalized DFL methods rely on similarity metrics (e.g., parameter distance, gradient norms) that cannot distinguish between harmful dissimilarity (incompatible data distributions) and beneficial diversity (high-quality but different data). Furthermore, standard neural networks output only predictions without indicating why a prediction was made, making it impossible to differentiate between a model that has never seen similar data (incompatible peer) and one that finds the data inherently difficult (potentially valuable peer).

2. Methodology: The MURMURA Framework

The authors propose MURMURA, a framework that leverages Evidential Deep Learning (EDL) to enable trust-aware model personalization. The core insight is that epistemic uncertainty (uncertainty due to a lack of knowledge) directly indicates peer compatibility.

A. Evidential Uncertainty Quantification

MURMURA replaces standard softmax outputs with Dirichlet-based evidential models. These models output evidence values parameterizing a Dirichlet distribution, allowing the decomposition of uncertainty into two distinct types:

Epistemic Uncertainty ( $u$ ): Measures the lack of knowledge regarding the data distribution. High epistemic uncertainty signals that the model has not seen similar data during training, indicating a distributional mismatch with the evaluating node.
Aleatoric Uncertainty: Measures inherent data ambiguity (e.g., noisy or transitional sensor readings). High aleatoric uncertainty does not necessarily imply incompatibility.

B. Trust-Aware Aggregation Mechanism

The framework operates through a decentralized training protocol where nodes autonomously decide which peers to collaborate with based on cross-evaluation:

Cross-Evaluation: Node $i$ evaluates a peer's model $j$ on its own local validation data.
Compatibility Scoring: A trust score is computed based on prediction accuracy and, crucially, the mean epistemic uncertainty.
- If a peer's model exhibits high epistemic uncertainty on local data, it is deemed incompatible and excluded.
- If the uncertainty is low, the peer is considered compatible, regardless of whether the prediction was perfect (distinguishing between "unknown data" and "hard data").
Adaptive Thresholds: Trust thresholds are not static. They start leniently in early training rounds (when all models are uncertain) and tighten adaptively as models converge, preventing premature rejection of peers.
Personalized Aggregation: Nodes aggregate updates only from trusted peers, weighted by their trust scores, while maintaining a portion of their local model (controlled by a self-weight parameter). If no peers pass the threshold, the node retains its local model, ensuring graceful degradation to isolated learning.

C. System Architecture

MURMURA is implemented as a modular Python/PyTorch framework supporting various network topologies (ring, fully-connected, etc.). It separates network orchestration from node-level decision-making, allowing for systematic evaluation of personalization strategies independent of topology effects. It supports controlled heterogeneity simulation via Dirichlet partitioning and natural partitioning (e.g., by subject ID).

3. Key Contributions

First Integration of EDL in Decentralized Personalization: MURMURA is the first framework to combine evidential uncertainty quantification with trust-aware personalization in fully decentralized settings, enabling nodes to maintain personalized models through selective collaboration in non-IID environments.
Adaptive Trust-Aware Algorithm: The authors developed an aggregation algorithm that evaluates peer compatibility via cross-evaluation on local data and applies adaptive trust thresholds that tighten as training progresses.
Open and Extensible Framework: MURMURA is provided as an open-source framework supporting multiple topologies, baseline aggregation methods, and systematic evaluation under varying heterogeneity levels.
Computational Efficiency: The approach computes uncertainty with a single forward pass per evaluation, avoiding the heavy computational overhead of ensemble methods or Monte Carlo dropout while providing richer information than point estimates.

4. Experimental Results

The framework was evaluated on three wearable IoT datasets: UCI HAR, PAMAP2, and PPG-DaLiA.

Robustness to Heterogeneity: Under high heterogeneity (Dirichlet $\alpha = 0.1$ ), MURMURA significantly reduced performance degradation compared to baselines. The accuracy drop from IID to non-IID conditions was only 0.9% for MURMURA, compared to 19.3% for standard FedAvg.
Convergence Speed: MURMURA achieved 7.4× faster convergence (reaching peak accuracy in 4.0 rounds) compared to FedAvg (29.5 rounds). This is attributed to the exclusion of noisy updates from incompatible peers.
Stability: The framework maintained stable accuracy across different hyperparameter choices (e.g., self-weight, trust thresholds), with standard deviations below 1% for most datasets, reducing the need for extensive per-device tuning.
Variance Reduction: MURMURA achieved high mean accuracy with lower variance across nodes compared to FedAvg, indicating that personalization benefits all nodes rather than improving some at the expense of others.

5. Significance and Claims

The paper claims that MURMURA establishes evidential uncertainty as a principled foundation for compatibility-aware personalization in decentralized heterogeneous environments.

Distinguishing Incompatibility from Difficulty: By separating epistemic from aleatoric uncertainty, the framework solves the "peer compatibility problem," allowing nodes to distinguish between peers with genuinely incompatible data distributions and those with challenging but compatible data.
Autonomous Decision Making: It enables fully decentralized nodes to make principled compatibility decisions without central oversight or reliance on heuristic similarity metrics that conflate model quality with distributional differences.
Practical Viability: The results suggest that evidential trust-aware aggregation is a practical solution for resource-constrained wearable IoT devices, offering faster convergence (reducing energy and bandwidth usage) and robustness to extreme data heterogeneity without requiring complex hyperparameter tuning.

The authors note that while MURMURA performs well, in scenarios with extreme physiological variability (e.g., PPG-DaLiA), conservative filtering may lead to near-isolated training when few compatible peers exist. They suggest future work could explore graduated trust mechanisms to extract value from moderately compatible peers.