PaperlayerView exact revision on arXiv

Source-linked AI summary

Blockchain Assisted Decentralized Federated Learning (BLADE-FL): Performance Analysis and Resource Allocation

Jun Li, Yumeng Shao, Kang Wei, Ming Ding, Chuan Ma, Long Shi, Zhu Han, H. Vincent Poor

arXiv:2101.06905v2cs.LGcs.DC

TL;DR

Standard FL relies on centralized aggregation, creating vulnerabilities involving server failures, trust, and attacks. The paper proposes BLADE-FL, analyzes loss bounds and resource allocation, and studies lazy clients. Experiments on MNIST and Fashion-MNIST are consistent with the analysis, with gaps lower than 5% and optimized K reaching the experimental loss minimum.

  • Problem

    Centralized aggregation makes standard FL vulnerable to server malfunctions, untrustworthy servers, and external attacks, while blockchain-assisted FL can introduce leakage and neglect convergence and mining resources.

  • Method

    BLADE-FL integrates local training and blockchain mining at each client, derives loss upper bounds, optimizes K and resource allocation, and models lazy clients that plagiarize models with artificial noise.

  • Results

    The developed upper bound is close to experiments, with the gap lower than 5%, and the optimal K minimizing the bound also reaches the experimental loss minimum.

  • Takeaways & Limitations

    BLADE-FL provides a decentralized FL framework that maintains FL’s privacy-promoting capabilities while addressing centralized-network single-point failure through integrated client-side training and mining.

  • Takeaways & Limitations

    The paper leaves efficient incentives and plagiarism detection for lazy clients as future work.

Abstract

from arXiv · show

Federated learning (FL), as a distributed machine learning paradigm, promotes personal privacy by local data processing at each client. However, relying on a centralized server for model aggregation, standard FL is vulnerable to server malfunctions, untrustworthy server, and external attacks. To address this issue, we propose a decentralized FL framework by integrating blockchain into FL, namely, blockchain assisted decentralized federated learning (BLADE-FL). In a round of the proposed BLADE-FL, each client broadcasts the trained model to other clients, aggregates its own model with received ones, and then competes to generate a block before its local training of the next round. We evaluate the learning performance of BLADE-FL, and develop an upper bound on the global loss function. Then we verify that this bound is convex with respect to the number of overall aggregation rounds K, and optimize the computing resource allocation for minimizing the upper bound. We also note that there is a critical problem of training deficiency, caused by lazy clients who plagiarize others' trained models and add artificial noises to disguise their cheating behaviors. Focusing on this problem, we explore the impact of lazy clients on the learning performance of BLADE-FL, and characterize the relationship among the optimal K, the learning parameters, and the proportion of lazy clients. Based on MNIST and Fashion-MNIST datasets, we show that the experimental results are consistent with the analytical ones. To be specific, the gap between the developed upper bound and experimental results is lower than 5%, and the optimized K based on the upper bound can effectively minimize the loss function.

1 INTRODUCTION

The paper proposes BLADE-FL to replace centralized aggregation with a decentralized blockchain-assisted FL architecture, while analyzing learning performance, resource allocation, and lazy-client effects.

  • 1 INTRODUCTION: Prior blockchain-assisted FL systems introduced third-party miners, potentially leaked information, omitted convergence analysis, and often neglected mining resources.The paper motivates client-side integration of training and mining as an alternative resource-allocation framework.
  • 1 INTRODUCTION: BLADE-FL addresses centralized aggregation vulnerabilities by implementing training and mining at each client.The framework targets model leakage, tampering, server malfunctions, and external attacks through decentralized aggregation and blockchain.
  • 1 INTRODUCTION: The paper derives an upper bound on the loss function and optimizes computing resources between local training and mining.It also studies how the optimal number of integrated rounds depends on training time, mining time, client count, and learning rate.
  • 1 INTRODUCTION: Lazy clients plagiarize other clients’ models and add artificial noises, causing training deficiency and performance degradation.The paper analyzes the effects of lazy-client numbers and artificial-noise power on learning performance.
  • 1 INTRODUCTION: The developed upper bound can have a gap lower than 5% from experimental results, while optimized resource allocation approaches the minimum loss function.The experiments are reported as consistent with the analytical results.

2 PRELIMINARIES

The preliminaries define federated learning as local model training with server aggregation and introduce blockchain as a decentralized ledger maintained through consensus and mining.

  • 2 PRELIMINARIES: In federated learning, clients train models on local datasets and transmit models rather than personal data to a server.The server aggregates received weights across communication rounds to update the global model.
  • 2 PRELIMINARIES: The global loss function aggregates clients’ local loss functions, and training seeks to minimize this global objective.The system outputs the global loss after K communication rounds.
  • 2 PRELIMINARIES: Blockchain is a shared decentralized ledger whose consensus mechanism validates transactions and makes newly generated blocks immutable.Participating nodes store the same blockchain data.
  • 2 PRELIMINARIES: In blockchain operation, nodes broadcast and verify transactions before competing to generate a block by finding a nonce meeting a hash target.The successful node becomes eligible to generate and broadcast the new block.
  • 2 PRELIMINARIES: Mining requires substantial computing resources because the proof-of-work problem is easy to verify but extremely hard to solve.The process is performed by nodes known as miners.

3 PROPOSED FRAMEWORK

BLADE-FL makes each client both trainer and miner, combining local model exchange, aggregation, block mining, and validation in integrated rounds. Its resource model exposes a training–mining tradeoff under a fixed computing-time budget.

  • BLADE-FL framework: Each client trains a local model, broadcasts it, verifies received transactions, aggregates models, mines a block, and validates the block.
  • Integrated rounds: An integrated round combines one FL communication round with one blockchain mining round under a shared client time-allocation strategy.
  • BLADE-FL framework: BLADE-FL avoids an additional third-party for global aggregation and uses PoW to support tamper-resistant model updates.
  • Computing resource allocation: Block generation time is modeled from PoW hash complexity, mining difficulty, average required CPU cycles, and total network computing power.
  • Computing resource allocation: Local training time depends on τ iterations, client sample count, and CPU cycles required per sample, with equal hardware and data-volume assumptions across clients.
  • Computing resource allocation: The fixed-duration model creates a tradeoff: longer mining leaves less training time, while more local iterations reduce the number of integrated rounds K.

4 PERFORMANCE ANALYSIS OF THE BLADE-FL SYSTEM

The paper derives and analyzes an upper bound on BLADE-FL’s loss, showing convexity in integrated rounds and optimizing computing-resource allocation across training and mining.

  • Upper-bound analysis: BLADE-FL’s loss upper bound is convex with respect to the number of integrated rounds K.
  • Upper-bound analysis: The upper bound depends on K, local training time α, mining time β, learning rate η, data-distribution divergence δ, and total computing time tsum.
  • Optimal computing resource allocation: Theorem 3 gives the optimal integrated-round count K* that minimizes the loss upper bound for fixed α, β, N or δ, and η.
  • Optimal computing resource allocation: As either α or β increases, optimal K decreases, with more computing time allocated respectively to training or mining.
  • Optimal computing resource allocation: As gradient divergence δ increases, optimal K grows and more time is allocated to mining; as client count N grows, K* becomes smaller and more time goes to training.
  • Optimal computing resource allocation: As η increases, K* increases while the upper bound drops when ηL < 1, reflecting a tradeoff between convergence speed and local-model accuracy.

5 PERFORMANCE ANALYSIS WITH LAZY CLIENTS

BLADE-FL faces training deficiency when lazy clients plagiarize models and add noise, so the paper bounds the resulting loss and analyzes resource allocation and optimal rounds. Plagiarism has a larger learning-performance effect than noise, while more lazy clients or higher noise variance reduce the optimal number of rounds.

  • Lazy-client model: Lazy clients plagiarize other models and add artificial Gaussian noise, causing training deficiency and performance degradation.They otherwise follow honest clients’ training procedure, making the cheating behavior difficult to detect.
  • Loss analysis: Theorem 4 develops an upper bound on the loss after K integrated rounds as a function of the lazy ratio and artificial-noise power.The bound is then used to evaluate BLADE-FL learning performance with lazy clients.
  • Assumption: Lazy clients are assumed to choose noise variance σ2 comparable to the degradation parameter θ to conceal their behavior.The assumption excludes deliberately huge or tiny noise levels as practically implausible concealment strategies.
  • Loss analysis: Plagiarism contributes a term proportional to M/N, whereas artificial noise contributes a term proportional to M/N and σ2, making plagiarism more consequential for learning performance.The comparison follows from the bound’s separate terms for plagiarism and noise perturbation.
  • Optimal aggregation rounds: The optimal K decreases as either the lazy ratio M/N or noise variance σ2 increases.The analysis characterizes how lazy-client prevalence and noise intensity affect the round count minimizing the loss bound.
  • Resource allocation: When the lazy ratio approaches 1, more computing power should be allocated to local training to compensate for insufficient learning.This resource-allocation adjustment addresses the reduced contribution from lazy clients.

6 DISCUSSIONS ON PRIVACY ISSUE

The paper discusses differential privacy as a separate privacy-preservation mechanism for BLADE-FL. It reports that adding small Gaussian noise for privacy does not change the optimal integrated rounds or computing-power allocation, while experiments compare the analytical bound with results.

  • Differential privacy: ϵ-DP bounds the distinguishability of outputs on neighboring datasets, and larger ϵ corresponds to higher privacy-violation risk.The paper introduces ϵ-DP as a randomized mechanism over a domain and range satisfying a measurable-set condition.
  • Problem distinction: Differential privacy addresses privacy leakage, whereas BLADE-FL addresses robust learning, so the paper treats the two problems separately.The discussion positions DP as an inner privacy mechanism rather than a replacement for the decentralized learning design.
  • System implications: Small Gaussian DP noise does not affect the optimal integrated round or optimal computing-power allocation in BLADE-FL.The paper states that the allocation remains the same whether DP noise is added or not.
  • Experimental comparison: Figure 3 compares the upper bound in (4) with experimental results under two parameter settings, including different learning rates and lazy-client configurations.The settings use α = 1, β = 6, N = 20, with M = 0 or M = 8 and η = 0.005 or 0.010.

7 EXPERIMENTAL RESULTS

Experiments on MNIST and Fashion-MNIST evaluate the analytical upper bound, resource-allocation effects, lazy clients, noise, and privacy. Results generally match the analysis, with performance and optimal allocations varying systematically with the tested parameters.

  • Upper-bound validation: The developed upper bound stays above experimental results, while both are convex in K and attain their minimum at the same optimal K.The bound is close to the experiments under the evaluated conditions.
  • Training and mining parameters: Larger β increases loss, reduces K*, and increases optimal mining time; on MNIST, mining time rises from 60 to 72 as β increases from 6 to 12.
  • Client population and learning rate: Increasing N lowers optimal mining time and loss; on MNIST, βK* decreases from 70 to 50 as N rises from 10 to 25.
  • Client population and learning rate: As η increases, optimal mining time rises from 54 to 72 on MNIST between η = 0.005 and 0.1, while loss increases when η > 0.05.
  • Lazy clients and noise: More lazy clients or greater artificial-noise power degrades learning performance and increases optimal training time; with 20% lazy clients, training time rises from 30 to 50 as σ2 increases from 0.01 to 0.3.
  • Differential privacy: Increasing privacy budget ϵ improves loss and accuracy but weakens privacy protection, while the optimal integrated round remains unrelated to ϵ.

8 CONCLUSIONS

The conclusion presents BLADE-FL as a decentralized framework integrating training and mining at each client, and summarizes its analytical and experimental findings. It also identifies incentive design and lazy-client detection as future work.

  • BLADE-FL integrates training and mining at each client to address centralized-network single-point failure while retaining FL’s privacy-promoting capabilities.
  • The paper derives an upper bound for the lazy-client setting and reports experiments consistent with its analytical results.
  • The upper bound differs from experiments by less than 5%, and its minimizing K also minimizes the experimental loss function.
  • Future work includes incentive mechanisms, plagiarism detection, and discouraging lazy clients; lazy-client detection is explicitly deferred.

APPENDIX B PROOF OF THEOREM 2

The proof establishes convexity of the upper-bound objective G(K) by analyzing its auxiliary function and derivatives. Consequently, G(K) has a minimum.

  • The proof rewrites G(K) through positive auxiliary functions g(K) and γ(K), then analyzes derivatives with respect to K.
  • G(K) is proved convex with respect to K and therefore has its own minimum value.

APPENDIX D PROOF OF COROLLARY 2

The appendix proof analyzes the monotonicity of auxiliary functions to determine how the optimal integrated-round solution changes with a parameter δ. It concludes that K* increases as δ rises.

  • The proof shows p(x) is increasing in x because its derivative equals λ^x(ln λ)^2 > 0.
  • Because Ω decreases with δ while p(x) increases with x, the solution x decreases as δ grows and K* increases.

APPENDIX E PROOF OF COROLLARY 4

The proof analyzes how the loss bound changes with learning rate η under the condition ηL < 1, while incorporating lazy-client model behavior and Gaussian noise assumptions.

  • Learning-rate dependence: As η increases, the upper-bound analysis considers the derivative of g(·) and the condition ηL < 1.The supplied proof passages identify this derivative-based condition but do not provide the complete derivation.
  • Learning-rate dependence: When ηL < 1, the loss function decreases as the learning rate η increases.
  • Learning-rate dependence: If η becomes sufficiently large so that ηL < 1 is not satisfied, g(·) is not increasing with η and the loss function becomes larger.
  • Lazy-client model: Lazy clients are modeled as plagiarizing model parameters and potentially adding Gaussian noise with a common variance.The passages define the plagiarized parameters through j′ and state the equal-variance Gaussian-noise assumption.

APPENDIX G PROOF OF COROLLARY 5

The proof defines a lazy-client loss representation and establishes its convexity in the number of aggregation rounds K. It further shows that the minimizing K decreases as the number of clients or noise variance increases.

  • Loss representation: The loss function with lazy clients is represented by ˜G(K), with L(K) = ˜G(K).
  • Convexity: L(K) remains convex with respect to K.
  • Optimal aggregation rounds: K∗ decreases as either N or σ2 grows.The proof links increases in N or σ2 to higher x, followed by a decline in the minimizing K∗.
Loading 2101.06905v2…