Federated Logistic Regression with Enhanced Privacy: A Dynamic Gaussian Perturbation Approach via ADMM from an Information-Theoretic Perspective

Abstract

Federated learning enables distributed model training across edge nodes without direct raw data sharing, but model parameter transmission still poses significant privacy risks. To address this vulnerability, a Distributed Logistic Regression Gaussian Perturbation (DLGP) algorithm is proposed, which integrates the Alternating Direction Method of Multipliers (ADMM) with a calibrated differential privacy mechanism. The centralized logistic regression problem is decomposed into local subproblems that are solved independently on edge nodes, where only perturbed model parameters are shared with a central server. The Gaussian noise injection mechanism is designed to optimize the privacy–utility trade-off by introducing calibrated uncertainty into parameter updates, effectively obscuring sensitive information while preserving essential model characteristics. The ${\ell }_2$-sensitivity of local updates is derived, and a rigorous $(ϵ,\delta )$-differential privacy guarantee is provided. Evaluations are conducted on a real-world dataset, and it is demonstrated that DLGP maintains favorable performance across varying privacy budgets, numbers of nodes, and penalty parameters.

1. Introduction

Federated learning (FL) has emerged as a transformative paradigm for distributed machine learning, enabling collaborative model training across edge nodes while preserving data privacy by avoiding raw data transmission [1,2]. However, the exchange of model parameters between edge nodes and a central server introduces new privacy risks. Recent studies have demonstrated that adversaries can reverse-engineer sensitive information from model updates, such as training data features and label distributions [3]. This vulnerability arises because gradient updates and parameter vectors inherently encode statistical properties of the underlying datasets [4]. For example, the work of [5] showed that adversarial models can reconstruct high-fidelity approximations of training images from shared model updates, highlighting the inadequacy of FL’s native privacy guarantees. From an information-theoretic perspective, this vulnerability stems from the excessive information content, or low entropy, of the model updates, which can be exploited by adversaries to infer sensitive details about the training data. Additionally, the centralized aggregation architecture often exacerbates communication bottlenecks and computational burdens, particularly in bandwidth-constrained edge environments [6,7]. These challenges necessitate the development of robust privacy-preserving mechanisms that can mitigate information leakage during parameter transmission while maintaining computational efficiency.

To address privacy risks in FL, differential privacy (DP) has been widely adopted as a rigorous framework for quantifying and bounding information leakage [8,9]. Existing approaches typically inject calibrated noise into model parameters or gradients using mechanisms like the Gaussian mechanism [10,11] or Laplace mechanism [12,13], ensuring that individual data contributions remain indistinguishable. For instance, ref. [14] proposed a DP-regularized FL framework where noise is added to client updates before aggregation, achieving ($ϵ,\delta$)-differential privacy. The Gaussian mechanism, in particular, operates by increasing the entropy of the output distribution, making it statistically difficult to distinguish between outputs from adjacent datasets. Concurrently, distributed optimization techniques like the Alternating Direction Method of Multipliers (ADMM) have been leveraged to decompose global optimization tasks into parallelizable local subproblems, reducing reliance on centralized computation [15,16]. ADMM-based FL frameworks enable edge nodes to optimize local models independently while maintaining consistency through iterative parameter exchanges [17,18]. However, integrating DP with ADMM remains non-trivial, as the dynamic nature of distributed updates complicates sensitivity analysis and noise calibration [19,20]. Furthermore, many existing methods focus on static environments and fail to account for dynamic client dropout or heterogeneous data distributions, leading to degraded privacy–utility trade-offs [21,22].

Despite significant progress, several critical challenges persist in current FL privacy-preserving frameworks. First, most DP mechanisms assume homogeneous data distributions and static client participation, which rarely hold in real-world edge scenarios. For example, client dropout during training can invalidate privacy budgets and introduce statistical biases, yet existing solutions often lack resilience to such dynamics [23]. Second, the computational overhead of DP mechanisms, particularly for high-dimensional models, remains prohibitive for resource-constrained edge devices. Existing works rely on Laplace noise, which incurs higher variance than Gaussian noise for equivalent privacy guarantees, degrading model accuracy [24]. Third, the sensitivity analysis required for noise calibration is often oversimplified, leading to either insufficient privacy protection or excessive noise that undermines model utility. This directly impacts the information-theoretic properties of the mechanism, as miscalibrated noise fails to provide sufficient entropy to mask individual contributions effectively. Finally, current frameworks often neglect the communication efficiency challenges inherent in edge environments, where frequent parameter exchanges can strain bandwidth and latency constraints.

This paper presents the Distributed Logistic Regression Gaussian Perturbation (DLGP) algorithm, a novel FL framework that addresses these gaps by seamlessly integrating ADMM with differential privacy. The key contributions are as follows:

• DLGP employs ADMM to decompose centralized logistic regression into parallel local optimizations, allowing edge nodes to retain raw data while sharing only aggregated parameters. This architecture minimizes communication overhead and computational burdens on the central server.
• Through rigorous ${\ell }_2$-sensitivity analysis of local parameter updates, DLGP dynamically calibrates Gaussian noise to achieve $(ϵ,\delta )$-differential privacy. Unlike static noise injection methods, DLGP adjusts noise levels based on local dataset sizes and model sensitivity, ensuring optimal privacy–utility balance across heterogeneous edge nodes.
• By perturbing parameters at edge nodes before transmission, DLGP eliminates the need for a trusted central server and mitigates risks of server-side data leakage. This design aligns with the decentralized nature of edge computing and enhances resilience to adversarial attacks.
• Experimental evaluations on a real-world occupancy detection dataset demonstrate that DLGP maintains favorable empirical loss performance across varying privacy budgets and edge node configurations, validating its practical effectiveness in balancing privacy preservation and model utility.

The remainder of this paper is structured as follows: Section 2 introduces theoretical foundations including distributed logistic regression, differential privacy, and ADMM. Section 3 describes the ADMM-based distributed training framework. Section 4 presents the DLGP algorithm with its adaptive noise injection mechanism. Section 5 provides formal privacy guarantees. Section 6 reports experimental results. Finally, Section 7 reiterates the core contributions of the DLGP algorithm and synthesizes its implications for privacy-preserving federated learning.

2. Model Description and Preliminaries

This section establishes the theoretical foundation for the proposed privacy-preserving federated learning framework. The formulation of logistic regression models in both centralized and distributed paradigms is first elaborated, followed by an introduction to the core concepts of differential privacy and the ADMM, which form the basis of the proposed algorithm design. These foundational concepts are examined through an information-theoretic lens, particularly focusing on how they manage and protect information content throughout the learning process.

2.1. Distributed Logistic Regression Model

Logistic regression remains a cornerstone of statistical learning for binary classification tasks, with the goal of learning a parameter vector that maps input features to binary labels. In federated learning scenarios, the transition from centralized to distributed modeling is pivotal for mitigating raw data exposure risks, necessitating a clear distinction between these two paradigms upfront.

In the centralized setting, all training data is aggregated at a central server, where the model is trained by minimizing a regularized empirical risk function. For a global dataset $D=\{({\mathit{x}}_{ij},y_{ij}),i=1,2,\cdots ,n;j=1,2,\cdots ,m_i\}$, the centralized logistic regression objective function minimizes the regularized empirical risk as

$$\underset{\mathit{\alpha }}{min}\sum _{i=1}^n\sum _{j=1}^{m_i}{\displaystyle \frac{1}{m_i}}log\left(1+exp\left(-y_{ij}{\mathit{\alpha }}^{\mathrm{T}}{\mathit{x}}_{ij}\right)\right)+{\displaystyle \frac{\lambda }{2}}{\parallel \mathit{\alpha }\parallel }_2^2,$$

(1)

where $\mathit{\alpha }\in {\mathbb{R}}^d$ denotes the global model parameter, ${\mathit{x}}_{ij}\in {\mathbb{R}}^d$ represents the d-dimensional feature vectors, and $y_{ij}\in \{-1,1\}$ is the binary label with $-1$ and 1 indicating distinct classes such as machine normal/faulty states or user absence/presence. The term $\lambda$ is a regularization parameter, and ${\parallel \mathit{\alpha }\parallel }_2$ denotes the ${\ell }_2$ norm to prevent overfitting. However, this centralized approach concentrates the information content (and thus the risk) of the entire dataset into a single model, resulting in a low-entropy system that is highly vulnerable to privacy attacks. The key notations used throughout this chapter are summarized in

Table 1. Key symbols and their descriptions.

Symbol	Definition
${\mathit{x}}_{ij}$	Data feature vector
$y_i$	Data label
$\lambda$	Regularization parameter
$\mathit{\alpha }$	Global model parameter vector
${\mathit{\alpha }}_i$	Local model parameter vector at edge node i
${\mathit{\gamma }}_i$	Dual variable at edge node i
$\mu$	Penalty parameter
${\mathit{\alpha }}_i^k$	Local parameter vector at edge node i in iteration k
${\tilde{\mathit{\alpha }}}_i^k$	Privacy-preserving version of ${\mathit{\alpha }}_i^k$
${\mathit{\gamma }}_i^k$	Dual variable at edge node i in iteration k
${\mathit{\alpha }}^k$	Global model parameter vector in iteration k
$v_i^k$	Sampled noise at edge node i in iteration k
$\sigma$	Standard deviation of the Gaussian mechanism

. Despite its simplicity, this paradigm exhibits critical limitations in privacy-sensitive environments. Raw data must be uploaded to a central server, which creates vulnerabilities to sensitive information breaches. Additionally, aggregating large-scale data from edge nodes introduces prohibitive communication overhead and latency, making it particularly challenging for deployment in bandwidth-constrained edge computing environments [25].

To address these limitations, distributed logistic regression decomposes the global learning task across edge nodes, where each node retains its local data and shares only model parameters with the central server. Consider a federated system consisting of n edge nodes, where node i maintains a local dataset $D_i={\left\{(x_{ij},y_{ij})\right\}}_{j=1}^{m_i}$ containing $m_i$ samples. Through the decentralization of the centralized strategy, Equation (1) can be reformulated as

$$\underset{{\left\{{\mathit{\alpha }}_i\right\}}_{i=1}^n}{min}\sum _{i=1}^n\left(\sum _{j=1}^{m_i}{\displaystyle \frac{1}{m_i}}log\left(1+exp\left(-y_{ij}{\mathit{\alpha }}_i^{\mathrm{T}}{\mathit{x}}_{ij}\right)\right)+{\displaystyle \frac{\lambda }{2n}}{\parallel {\mathit{\alpha }}_i\parallel }_2^2\right),\mathrm{s}.\mathrm{t}.{\mathit{\alpha }}_i=\mathit{\alpha },$$

(2)

where ${\left\{{\mathit{\alpha }}_i\right\}}_{i=1}^n=\{{\mathit{\alpha }}_1,{\mathit{\alpha }}_2,\cdots ,{\mathit{\alpha }}_n\}$ denotes the set of local parameters, with ${\mathit{\alpha }}_i\in {\mathbb{R}}^d$ representing the local model parameter at edge node i and $\mathit{\alpha }\in {\mathbb{R}}^d$ denoting the global model parameter optimized across all nodes. This distributed approach inherently increases the system’s entropy by dispersing information across multiple edge nodes, thereby reducing the risk of catastrophic privacy breaches that could occur in a centralized setting. As illustrated in Figure 1, this centralized learning task is split across n edge nodes for parallel processing. In the k-th iteration, each edge node uploads its local model parameter ${\mathit{\alpha }}_i^k$ to the cloud server, where the collected local parameters are aggregated to form the global model parameter ${\mathit{\alpha }}^k$ before being made available for download. Each edge node then leverages the downloaded global parameter to resume local model training and uploads its $(k+1)$-th local model parameter to the cloud server. This iterative process continues, enabling alternating updates between local and global parameters. Eventually, all local model parameters across the edge nodes converge to the global model parameter $\mathit{\alpha }$, satisfying the constraint outlined in Equation (2).

2.2. Differential Privacy

To protect model parameters during communication against privacy inference attacks, differential privacy is employed as a rigorous framework. It quantifies the indistinguishability of algorithm outputs with respect to individual data samples, ensuring robust privacy guarantees. This indistinguishability criterion directly relates to information-theoretic concepts of uncertainty and entropy, as it ensures that the output distribution maintains sufficient randomness to prevent confident inferences about any individual data point.

Definition 1.

($ϵ,\delta$)-Differential Privacy [9]: Let $\mathcal{D}$ and ${\mathcal{D}}^{\prime }$ be two adjacent datasets that differ in at most one record. For a randomized algorithm $\mathcal{A}$, let $\mathrm{Range}\left(\mathcal{A}\right)$ denote the set of all possible outputs of the algorithm on these adjacent datasets. The algorithm $\mathcal{A}$ satisfies ($ϵ,\delta$)-differential privacy if, for any output subset $\mathit{O}\subseteq \mathrm{Range}\left(\mathcal{A}\right)$, the condition

$$Pr[\mathcal{A}\left(D\right)\in \mathit{O}]\le exp\left(ϵ\right)·Pr[\mathcal{A}\left(D^{\prime }\right)\in \mathit{O}]+\delta$$

(3)

holds.

The selection of parameters $ϵ$ and $\delta$ depends on specific privacy policies. The parameter $ϵ$ represents the privacy budget, which reflects the degree of privacy protection. The relaxation probability $\delta$ controls the probability of privacy loss. When $\delta =0$, the algorithm $\mathcal{A}$ satisfies $ϵ$-differential privacy [8]. The most commonly used privacy-preserving mechanism to achieve ($ϵ,\delta$)-differential privacy is the Gaussian mechanism, which employs data perturbation techniques by adding Gaussian noise to query results. The perturbation effectively increases the entropy of the output, making it more difficult for adversaries to extract useful information about individual data points while preserving the overall statistical utility of the model.

Definition 2.

${\ell }_2$-Sensitivity [9]: Let $\mathcal{D}$ and ${\mathcal{D}}^{\prime }$ be two adjacent datasets that differ in at most one record. For a query function q, its ${\ell }_2$-sensitivity is defined as

$$s=\underset{D,D^{\prime }}{max}{\parallel q\left(D\right)-q\left(D^{\prime }\right)\parallel }_2,$$

(4)

where ${\parallel ·\parallel }_2$ denotes the ${\ell }_2$ norm.

Definition 3.

Gaussian Mechanism [9]: Given a dataset $\mathcal{D}$ and a privacy budget $ϵ\in (0,1)$, a randomized algorithm $\mathcal{A}$ provides ($ϵ,\delta$)-differential privacy for a query function q if and only if

$$\mathcal{A}\left(D\right)=q\left(D\right)+\mathrm{Gau}\left(\sigma \right),$$

(5)

where $\sigma \ge cs/ϵ$ with $c^2>2ln(1.25/\delta )$, $\mathrm{Gau}\left(\sigma \right)$ denotes Gaussian noise with zero mean and variance ${\sigma }^2$, and s represents the ${\ell }_2$-sensitivity.

The Gaussian mechanism is well-suited for federated learning, efficiently perturbing high-dimensional parameters with manageable computational overhead. From an information-theoretic perspective, the Gaussian noise maximizes entropy for a given variance, providing the most uncertainty about the original data for a given noise power constraint, which aligns optimally with privacy preservation goals.

2.3. Alternating Direction Method of Multipliers

To solve constrained optimization problems in distributed systems, the ADMM offers a powerful framework by decomposing complex objectives into tractable subproblems [26,27]. This decomposition is particularly advantageous for federated learning scenarios, where data remains decentralized across edge nodes. The general form of optimization problems addressed by ADMM is

$$minf\left(p\right)+g\left(q\right)\mathrm{s}.\mathrm{t}.Ap+Bq=C,$$

(6)

where f and g are convex objective functions, p and q denote primal variables, and A, B, and C are parameters defining the equality constraint. The augmented Lagrangian function for the problem in (6) is

$$L(p,q,\gamma )=f\left(p\right)+g\left(q\right)+\langle \gamma ,Ap+Bq-C\rangle +{\displaystyle \frac{\mu }{2}}{\parallel Ap+Bq-C\parallel }_2^2,$$

(7)

where $\gamma \ge 0$ represents the dual variable and $\mu >0$ is a penalty parameter that controls the strength of constraint enforcement.

ADMM solves the optimization problem through an iterative process involving three alternating updates. In each iteration, the primal and dual variables are updated sequentially as

$$\begin{array}{ccc}\hfill p^{k+1}& =& arg\underset{p}{min}L(p,q^k,{\gamma }^k),\hfill \end{array}$$

(8)

$$\begin{array}{ccc}\hfill q^{k+1}& =& arg\underset{q}{min}L(p^{k+1},q,{\gamma }^k),\hfill \end{array}$$

(9)

$$\begin{array}{ccc}\hfill {\gamma }^{k+1}& =& {\gamma }^k+\mu \left(A{p}^{k+1}+B{q}^{k+1}-C\right).\hfill \end{array}$$

(10)

As evident from the update rules in (8)–(10), the primal variables p and q and the dual variable $\gamma$ are updated alternately in each iteration. This process continues until the algorithm meets predefined convergence criteria, ensuring that the solution satisfies both the objective function minimization and the equality constraint.

For our distributed logistic regression task described in Section 2.1, ADMM can be adapted to solve the constrained optimization problem in (2). By aligning the problem structure with the general ADMM framework, we decompose the global objective into local subproblems that can be solved in parallel across edge nodes, while maintaining consistency through the alternating update mechanism. This adaptation enables efficient decentralized computation, making it well-suited for privacy-preserving federated learning systems.

3. ADMM-Based Distributed Training Framework

Building upon the theoretical foundations of distributed optimization and differential privacy established in Section 2, this section presents the detailed implementation of our federated logistic regression framework. Leveraging ADMM, efficient distributed model training across edge nodes is enabled while strict consistency between local and global models is maintained. The distributed nature of this framework inherently promotes information dispersion, increasing the overall entropy of the learning system and making it more resilient to privacy attacks that exploit concentrated information patterns. The core workflow decomposes the global optimization task into parallel local computations, coordinated via a central server through iterative parameter exchanges, thereby eliminating the need for raw data transmission.

3.1. Distributed Model Formulation and Augmented Lagrangian Construction

The federated learning system under consideration comprises a central server and n edge nodes, with each edge node i maintaining a private local dataset $D_i={\left\{({\mathit{x}}_{ij},y_{ij})\right\}}_{j=1}^{m_i}$ containing $m_i$ samples. The global objective involves learning a consistent logistic regression model parameter $\mathit{\alpha }\in {\mathbb{R}}^d$ that minimizes the aggregated empirical risk across all local datasets, without direct data sharing between nodes or with the server.

As formulated in Section 2, the distributed optimization problem given by Equation (2) enforces consistency between local parameters ${\left\{{\mathit{\alpha }}_i\right\}}_{i=1}^n$ and the global parameter $\mathit{\alpha }$ through equality constraints. To solve this constrained optimization problem using ADMM, the augmented Lagrangian function is constructed by extending the general form in Equation (7) as

$$L\left({\left\{{\mathit{\alpha }}_i\right\}}_{i=1}^n,\mathit{\alpha },{\left\{{\mathit{\gamma }}_i\right\}}_{i=1}^n\right)=\sum _{i=1}^n{L}_i\left({\mathit{\alpha }}_i,\mathit{\alpha },{\mathit{\gamma }}_i\right),$$

(11)

where the local component $L_i\left({\mathit{\alpha }}_i,\mathit{\alpha },{\mathit{\gamma }}_i\right)$ for each edge node i is defined as

$$\begin{array}{ccc}\hfill L_i\left({\mathit{\alpha }}_i,\mathit{\alpha },{\mathit{\gamma }}_i\right)& =& \sum _{j=1}^{m_i}{\displaystyle \frac{1}{m_i}}log\left(1+exp\left(-y_{ij}{\mathit{\alpha }}_i^{\mathrm{T}}{\mathit{x}}_{ij}\right)\right)+{\displaystyle \frac{\lambda }{2n}}{\parallel {\mathit{\alpha }}_i\parallel }_2^2\hfill \\ & & -\langle {\mathit{\gamma }}_i,{\mathit{\alpha }}_i-\mathit{\alpha }\rangle +{\displaystyle \frac{\mu }{2}}{\parallel {\mathit{\alpha }}_i-\mathit{\alpha }\parallel }_2^2.\hfill \end{array}$$

(12)

In this formulation, ${\mathit{\gamma }}_i$ denotes the dual variable (Lagrange multiplier) for enforcing the consistency constraint at node i, and $\mu >0$ is the penalty parameter controlling the strength of constraint enforcement. The augmented Lagrangian integrates local loss minimization with constraint penalties, enabling decomposition into parallelizable local subproblems while maintaining global model consistency.

3.2. Edge Node Local Parameter Update

The ADMM training process initiates with local parameter updates at each edge node. In the k-th iteration, each node i optimizes its local parameter ${\mathit{\alpha }}_i$ by minimizing the local augmented Lagrangian component $L_i$, with optimization performed using the global parameter ${\mathit{\alpha }}^{k-1}$ and dual variable ${\mathit{\gamma }}_i^{k-1}$ from the previous iteration. This local optimization subproblem is expressed as

$${\mathit{\alpha }}_i^k=arg\underset{{\mathit{\alpha }}_i}{min}{L}_i\left({\mathit{\alpha }}_i,{\mathit{\alpha }}^{k-1},{\mathit{\gamma }}_i^{k-1}\right).$$

(13)

To solve this convex optimization problem efficiently, Newton’s method is employed, which leverages second-order gradient information to achieve faster convergence than first-order methods. For simplicity, the local cost function is defined as $J\left({\mathit{\alpha }}_i\right)=L_i\left({\mathit{\alpha }}_i,{\mathit{\alpha }}^{k-1},{\mathit{\gamma }}_i^{k-1}\right)$. In each inner iteration t, $J\left({\mathit{\alpha }}_i\right)$ is approximated through a second-order Taylor expansion around ${\mathit{\alpha }}_i^{\left(t\right)}$, given by

$$\begin{array}{ccc}\hfill J\left({\mathit{\alpha }}_i\right)& =& J\left({\mathit{\alpha }}_i^{\left(t\right)}\right)+{({\mathit{\alpha }}_i-{\mathit{\alpha }}_i^{\left(t\right)})}^{\mathrm{T}}\nabla J\left({\mathit{\alpha }}_i^{\left(t\right)}\right)+{\displaystyle \frac{1}{2}}{({\mathit{\alpha }}_i-{\mathit{\alpha }}_i^{\left(t\right)})}^{\mathrm{T}}H\left({\mathit{\alpha }}_i^{\left(t\right)}\right)({\mathit{\alpha }}_i-{\mathit{\alpha }}_i^{\left(t\right)})\hfill \\ & & +o\left(\parallel {\mathit{\alpha }}_i-{\mathit{\alpha }}_i^{\left(t\right)}{\parallel }^2\right),\hfill \end{array}$$

(14)

where $\nabla J\left({\mathit{\alpha }}_i^{\left(t\right)}\right)$ denotes the gradient and $H\left({\mathit{\alpha }}_i^{\left(t\right)}\right)$ denotes the Hessian matrix of $J\left({\mathit{\alpha }}_i\right)$ evaluated at ${\mathit{\alpha }}_i^{\left(t\right)}$. Minimizing this quadratic approximation yields the Newton update rule expressed as

$${\mathit{\alpha }}_i^{(t+1)}={\mathit{\alpha }}_i^{\left(t\right)}-a_t{\left[H\left({\mathit{\alpha }}_i^{\left(t\right)}\right)\right]}^{-1}\nabla J\left({\mathit{\alpha }}_i^{\left(t\right)}\right),$$

(15)

where $a_t$ denotes a step size determined through line search to ensure convergence. Specifically, this step size is computed as $a_t=arg{min}_{a\ge 0}J\left({\mathit{\alpha }}_i^{\left(t\right)}-a{\left[H\left({\mathit{\alpha }}_i^{\left(t\right)}\right)\right]}^{-1}\nabla J\left({\mathit{\alpha }}_i^{\left(t\right)}\right)\right)$.

For logistic regression, closed-form expressions for the gradient and Hessian are derived using only local data. The gradient is computed as

$$\begin{array}{ccc}\hfill \nabla J\left({\mathit{\alpha }}_i^{\left(t\right)}\right)& =& \sum _{j=1}^{m_i}{\displaystyle \frac{1}{m_i}}{\displaystyle \frac{-y_{ij}{\mathit{x}}_{ij}}{1+exp\left(y_{ij}{\left({\mathit{\alpha }}_i^{\left(t\right)}\right)}^{\mathrm{T}}{\mathit{x}}_{ij}\right)}}+{\displaystyle \frac{\lambda }{n}}{\mathit{\alpha }}_i^{\left(t\right)}-{\mathit{\gamma }}_i^{k-1}+\mu \left({\mathit{\alpha }}_i^{\left(t\right)}-{\mathit{\alpha }}^{k-1}\right),\hfill \end{array}$$

(16)

and the Hessian matrix is given by

$$\begin{array}{ccc}\hfill H\left({\mathit{\alpha }}_i^{\left(t\right)}\right)& =& \sum _{j=1}^{m_i}{\displaystyle \frac{1}{m_i}}{\displaystyle \frac{y_{ij}^2{\mathit{x}}_{ij}{\mathit{x}}_{ij}^{\mathrm{T}}exp\left(y_{ij}{\left({\mathit{\alpha }}_i^{\left(t\right)}\right)}^{\mathrm{T}}{\mathit{x}}_{ij}\right)}{{\left(1+exp\left(y_{ij}{\left({\mathit{\alpha }}_i^{\left(t\right)}\right)}^{\mathrm{T}}{\mathit{x}}_{ij}\right)\right)}^2}}+\left({\displaystyle \frac{\lambda }{n}}+\mu \right){\mathit{I}}_d,\hfill \end{array}$$

(17)

where ${\mathit{I}}_d$ denotes the $d\times d$ identity matrix. Each edge node performs these inner Newton iterations until a local convergence criterion is satisfied, such as completion of $t_{\max }$ inner iterations. Upon convergence, the optimized local parameter ${\mathit{\alpha }}_i^k={\mathit{\alpha }}_i^{\left(t_{\max }\right)}$ is prepared for upload to the central server.

3.3. Cloud Server Global Parameter Aggregation

Upon completion of local updates, all edge nodes upload their optimized local parameters ${\left\{{\mathit{\alpha }}_i^k\right\}}_{i=1}^n$ to the central server. In contrast to traditional centralized training paradigms that require direct transmission of raw data, this parameter-only communication strategy minimizes bandwidth consumption and mitigates privacy risks associated with sensitive data exposure.

Upon receiving the local parameters from all edge nodes, the central server performs global model aggregation to update the global parameter ${\mathit{\alpha }}^k$. Derived from the ADMM framework, the global aggregation rule integrates dual variables to balance constraint enforcement and model consistency, and is given by

$${\mathit{\alpha }}^k={\displaystyle \frac{1}{n}}\sum _{i=1}^n{\mathit{\alpha }}_i^k-{\displaystyle \frac{1}{n}}\sum _{i=1}^n{\displaystyle \frac{{\mathit{\gamma }}_i^{k-1}}{\mu }}.$$

(18)

This aggregation mechanism ensures that the global parameter incorporates collective knowledge from all edge nodes while accounting for previous constraint violations, thereby driving the system toward a consistent solution. Following aggregation, the updated global parameter ${\mathit{\alpha }}^k$ is broadcast back to all edge nodes to guide their next round of local optimization.

3.4. Dual Variable Update

To strengthen constraint enforcement and accelerate convergence, each edge node updates its dual variable ${\mathit{\gamma }}_i$ based on the discrepancy between its local parameter and the aggregated global parameter. This update step is critical for maintaining the consistency constraint ${\mathit{\alpha }}_i=\mathit{\alpha }$ across iterations. Following the ADMM update mechanism outlined in Equation (10), the dual variable update for node i is given by

$${\mathit{\gamma }}_i^k={\mathit{\gamma }}_i^{k-1}-\mu \left({\mathit{\alpha }}_i^k-{\mathit{\alpha }}^k\right).$$

(19)

This adjustment modifies the Lagrange multiplier to penalize deviations between ${\mathit{\alpha }}_i^k$ and ${\mathit{\alpha }}^k$, where larger discrepancies result in more significant adjustments to ${\mathit{\gamma }}_i^k$ that in turn exert stronger corrective pressure on subsequent local optimization steps. As iterations progress, local parameters incrementally align with the global model, driving the system toward a consistent solution.

3.5. Complete Training Procedure

The complete ADMM-based distributed training process proceeds through iterative cycles of local parameter optimization, global aggregation, and dual variable updating, continuing until a predefined stopping criterion is satisfied (e.g., upon completing K total iterations). The detailed workflow of the algorithm is summarized in Algorithm 1.

Algorithm 1 ADMM-Based Distributed Logistic Regression Training Algorithm

Require:  Local datasets $D={\{{\mathit{x}}_{ij},y_{ij}\}}_{i=1,\dots ,n;j=1,\dots ,m_i}$. Ensure:  Final global model parameter ${\mathit{\alpha }}^K$. 1: Initialize the global parameter ${\mathit{\alpha }}^0$, local parameters ${\left\{{\mathit{\alpha }}_i^0\right\}}_{i=1}^n$, and dual variables ${\left\{{\mathit{\gamma }}_i^0\right\}}_{i=1}^n$. 2: for $k=1$ to K do 3:     for $i=1$ to n do 4:         for $t=1$ to $t_{\max }$ do 5:            Construct the local cost function $J\left({\mathit{\alpha }}_i\right)$ using Equation (14). 6:            Compute the gradient $\nabla J\left({\mathit{\alpha }}_i^{\left(t\right)}\right)$ using Equation (16). 7:            Compute the Hessian matrix $H\left({\mathit{\alpha }}_i^{\left(t\right)}\right)$ using Equation (17). 8:            Update the step size $a_t$ and local parameter ${\mathit{\alpha }}_i^{(t+1)}$ using Equation (15). 9:           end for 10:         Set the k-th iteration local parameter as ${\mathit{\alpha }}_i^k={\mathit{\alpha }}_i^{\left(t_{\max }\right)}$. 11:     end for 12:     Update the global parameter ${\mathit{\alpha }}^k$ using Equation (18). 13:     for $i=1$ to n do 14:         Update the dual variable ${\mathit{\gamma }}_i^k$ using Equation (19). 15:     end for 16: end for 17: return Final global model parameter ${\mathit{\alpha }}^K$.

During each iteration, local computations are executed in parallel across all edge nodes. Communication is confined exclusively to parameter exchanges between nodes and the central server. This decentralized architecture simultaneously reduces computational load on the central server and preserves data privacy by retaining raw data locally at edge nodes. Critically, theoretical convergence guarantees from ADMM are integrated with Newton’s method for efficient local optimization, enabling the framework to achieve both global model consistency and practical training efficiency. These characteristics render it ideally suited for federated learning scenarios under privacy constraints.

4. DLGP Algorithm

The ADMM-based distributed logistic regression framework decomposes centralized optimization tasks into n subproblems, enabling collaborative training across n edge nodes. While this architecture reduces network bandwidth requirements and offers partial protection for raw user data, privacy risks persist during parameter transmission where adversaries could potentially reconstruct training data through analysis of historical model parameters uploaded to the central server. To address this vulnerability, a differential privacy mechanism that injects noise into local parameter updates is introduced, thereby enhancing the algorithm’s privacy guarantees. The injected noise strategically increases the entropy of the transmitted parameters, making it information-theoretically harder for adversaries to reconstruct sensitive training data from the observed model updates. The proposed DLGP algorithm is detailed below.

4.1. ${\ell }_2$-Sensitivity Analysis

For $(ϵ,\delta )$-differential privacy implementation via a Gaussian mechanism, sensitivity analysis must first be conducted to quantify variations in local parameter updates resulting from minor input dataset modifications. In the DLGP algorithm, the ${\ell }_2$-sensitivity of local parameter ${\mathit{\alpha }}_i^k$ is analyzed, defined as the maximum ${\ell }_2$-norm difference between parameter updates derived from adjacent datasets differing by exactly one sample.

Consider two adjacent local datasets $D_i$ and $D_i^{\prime }$ at edge node i, where $|D_i▵D_i^{\prime }|=1$ (i.e., the symmetric difference contains exactly one sample). Without loss of generality, the discrepancy is assumed to occur in the first sample. The local parameters computed from $D_i$ and $D_i^{\prime }$ are denoted as ${\mathit{\alpha }}_{i,D_i}^k$ and ${\mathit{\alpha }}_{i,D_i^{\prime }}^k$, respectively, which are obtained by minimizing slightly different objective functions

$$\begin{array}{ccc}\hfill {\mathit{\alpha }}_{i,D_i}^k& =& arg\underset{{\mathit{\alpha }}_i}{min}J\left({\mathit{\alpha }}_i\right),\hfill \\ \hfill {\mathit{\alpha }}_{i,D_i^{\prime }}^k& =& arg\underset{{\mathit{\alpha }}_i}{min}J\left({\mathit{\alpha }}_i\right)+G\left({\mathit{\alpha }}_i\right),\hfill \end{array}$$

where $J\left({\mathit{\alpha }}_i\right)=L_i\left({\mathit{\alpha }}_i,\mathit{\alpha },{\mathit{\gamma }}_i\right)$ represents the local cost function from Section 3, and $G\left({\mathit{\alpha }}_i\right)$ captures the logistic loss difference introduced by the modified sample

$$G\left({\mathit{\alpha }}_i\right)={\displaystyle \frac{1}{m_i}}log\left(1+exp\left(-y_{i1}^{\prime }{\mathit{\alpha }}_i^{\mathrm{T}}{\mathit{x}}_{i1}^{\prime }\right)\right)-{\displaystyle \frac{1}{m_i}}log\left(1+exp\left(-y_{i1}{\mathit{\alpha }}_i^{\mathrm{T}}{\mathit{x}}_{i1}\right)\right).$$

(20)

From the smoothness properties of the objective functions, the gradients at their respective minima satisfy $\nabla J\left({\mathit{\alpha }}_{i,D_i}^k\right)=0$ and $\nabla J\left({\mathit{\alpha }}_{i,D_i^{\prime }}^k\right)+\nabla G\left({\mathit{\alpha }}_{i,D_i^{\prime }}^k\right)=0$. Given the $(\lambda /n+\mu )$-strong convexity of $J\left({\mathit{\alpha }}_i\right)$, the inequality

$${\left(\nabla J\left({\mathit{\alpha }}_{i,D_i}^k\right)-\nabla J\left({\mathit{\alpha }}_{i,D_i^{\prime }}^k\right)\right)}^{\mathrm{T}}\left({\mathit{\alpha }}_{i,D_i}^k-{\mathit{\alpha }}_{i,D_i^{\prime }}^k\right)\ge \left({\displaystyle \frac{\lambda }{n}}+\mu \right){\parallel {\mathit{\alpha }}_{i,D_i}^k-{\mathit{\alpha }}_{i,D_i^{\prime }}^k\parallel }_2^2$$

(21)

is satisfied. Application of the Cauchy–Schwarz inequality to the left-hand side yields

$${\left(\nabla J\left({\mathit{\alpha }}_{i,D_i}^k\right)-\nabla J\left({\mathit{\alpha }}_{i,D_i^{\prime }}^k\right)\right)}^{\mathrm{T}}\left({\mathit{\alpha }}_{i,D_i}^k-{\mathit{\alpha }}_{i,D_i^{\prime }}^k\right)\le \parallel {\mathit{\alpha }}_{i,D_i}^k-{\mathit{\alpha }}_{i,D_i^{\prime }}^k{\parallel }_2\parallel \nabla G({\mathit{\alpha }}_{i,D_i^{\prime }}^k){\parallel }_2.$$

(22)

Combining Equations (21) and (22) and substituting the expression for $\nabla G\left({\mathit{\alpha }}_i\right)$ leads to

$$\begin{array}{ccc}\hfill \parallel {\mathit{\alpha }}_{i,D_i}^k-{\mathit{\alpha }}_{i,D_i^{\prime }}^k{\parallel }_2& \le & {\displaystyle \frac{n{∥\frac{-y_{i1}^{\prime }{\mathit{x}}_{i1}^{\prime }}{1+exp\left(y_{i1}^{\prime }{\mathit{\alpha }}_i^{\mathrm{T}}{\mathit{x}}_{i1}^{\prime }\right)}-\frac{-y_{i1}{\mathit{x}}_{i1}}{1+exp\left(y_{i1}{\mathit{\alpha }}_i^{\mathrm{T}}{\mathit{x}}_{i1}\right)}∥}_2}{m_i(\lambda +\mu n)}}.\hfill \end{array}$$

(23)

By the triangle inequality, the numerator term is bounded as

$${∥{\displaystyle \frac{-y_{i1}^{\prime }{\mathit{x}}_{i1}^{\prime }}{1+exp\left(y_{i1}^{\prime }{\mathit{\alpha }}_i^{\mathrm{T}}{\mathit{x}}_{i1}^{\prime }\right)}}-{\displaystyle \frac{-y_{i1}{\mathit{x}}_{i1}}{1+exp\left(y_{i1}{\mathit{\alpha }}_i^{\mathrm{T}}{\mathit{x}}_{i1}\right)}}∥}_2\le {∥{\displaystyle \frac{-y_{i1}^{\prime }{\mathit{x}}_{i1}^{\prime }}{1+exp\left(y_{i1}^{\prime }{\mathit{\alpha }}_i^{\mathrm{T}}{\mathit{x}}_{i1}^{\prime }\right)}}∥}_2+{∥{\displaystyle \frac{-y_{i1}{\mathit{x}}_{i1}}{1+exp\left(y_{i1}{\mathit{\alpha }}_i^{\mathrm{T}}{\mathit{x}}_{i1}\right)}}∥}_2,$$

where each term is bounded by 1 due to sigmoid function properties, resulting in

$${∥{\displaystyle \frac{-y_{i1}^{\prime }{\mathit{x}}_{i1}^{\prime }}{1+exp\left(y_{i1}^{\prime }{\mathit{\alpha }}_i^{\mathrm{T}}{\mathit{x}}_{i1}^{\prime }\right)}}-{\displaystyle \frac{-y_{i1}{\mathit{x}}_{i1}}{1+exp\left(y_{i1}{\mathit{\alpha }}_i^{\mathrm{T}}{\mathit{x}}_{i1}\right)}}∥}_2\le 2.$$

(24)

Substituting Equation (24) into Equation (23) gives the ${\ell }_2$-sensitivity of the local parameter update ${\mathit{\alpha }}_i^k$ as

$$max\parallel {\mathit{\alpha }}_{i,D_i}^k-{\mathit{\alpha }}_{i,D_i^{\prime }}^k{\parallel }_2={\displaystyle \frac{2}{m_i(\lambda /n+\mu )}}.$$

(25)

This sensitivity bound quantifies the maximum information leakage that could occur from a single data point modification, providing a foundation for calibrating the noise required to achieve the desired entropy increase in the output distribution.

4.2. Dynamic Noise Generation and Perturbation Implementation

The workflow of the DLGP algorithm is illustrated in Figure 2. Computational tasks are distributed by the central server to n edge nodes. During the k-th iteration, local parameters are computed by each edge node using Newton iterations as described in Section 3. To prevent privacy leakage, calibrated Gaussian noise is injected into these local parameters prior to transmission to the server.

Based on the Gaussian mechanism for differential privacy and the sensitivity result in Equation (25), the noise added to each local parameter must follow a Gaussian distribution ${\mathit{v}}_i^k\sim \mathcal{N}(0,{\sigma }^2{\mathit{I}}_d)$, where the standard deviation $\sigma$ is calibrated as

$$\sigma \ge {\displaystyle \frac{2\sqrt{2ln(1.25/\delta )}}{m_i(\lambda /n+\mu )ϵ}},$$

(26)

which ensures that the perturbed parameter ${\tilde{\mathit{\alpha }}}_i^k={\mathit{\alpha }}_i^k+{\mathit{v}}_i^k$ satisfies $(ϵ,\delta )$-differential privacy for each update step. The Gaussian distribution is chosen specifically because it represents the maximum entropy distribution for a given variance, meaning it provides the greatest amount of uncertainty for a given noise power constraint. This optimal entropy property makes Gaussian noise particularly effective for obscuring the original parameter values while minimizing the impact on utility.

Following privacy protection implementation across all edge nodes, perturbed values ${\left\{{\tilde{\mathit{\alpha }}}_i^k\right\}}_{i=1}^n$ are uploaded to the central server for global aggregation. The global parameter update rule is adjusted for perturbed local parameters as

$${\mathit{\alpha }}^k={\displaystyle \frac{1}{n}}\sum _{i=1}^n{\tilde{\mathit{\alpha }}}_i^k-{\displaystyle \frac{1}{n}}\sum _{i=1}^n{\displaystyle \frac{{\mathit{\gamma }}_i^{k-1}}{\mu }}.$$

(27)

Subsequently, dual variables are updated by each edge node using perturbed local and aggregated global parameters

$${\mathit{\gamma }}_i^k={\mathit{\gamma }}_i^{k-1}-\mu \left({\tilde{\mathit{\alpha }}}_i^k-{\mathit{\alpha }}^k\right).$$

(28)

Updated dual variables and global parameters are then utilized for the $(k+1)$-th iteration of local parameter optimization. This process continues until K total iterations are completed, at which point final global parameter ${\mathit{\alpha }}^K$ is returned. The iterative noise injection creates a cumulative privacy protection effect, where each round of perturbation further increases the uncertainty about the original training data, effectively implementing a form of progressive information obfuscation throughout the learning process. The complete DLGP algorithm is summarized in Algorithm 2.

Algorithm 2 Pseudocode for the DLGP algorithm

Require:  Local datasets $D={\{{\mathit{x}}_{ij},y_{ij}\}}_{i=1,\dots ,n;j=1,\dots ,m_i}$. Ensure:  Final global model parameter ${\mathit{\alpha }}^K$. 1: Initialize ${\mathit{\alpha }}^0$, ${\left\{{\mathit{\alpha }}_i^0\right\}}_{i=1}^n$, and ${\left\{{\mathit{\gamma }}_i^0\right\}}_{i=1}^n$. 2: for $k=1$ to K do 3:     for $i=1$ to n do 4:         for $t=1$ to $t_{\max }$ do 5:            Construct the local cost function $J\left({\mathit{\alpha }}_i\right)$ using Equation (14). 6:            Update the gradient $\nabla J\left({\mathit{\alpha }}_i^{\left(t\right)}\right)$ using Equation (16). 7:            Update the Hessian matrix $H\left({\mathit{\alpha }}_i^{\left(t\right)}\right)$ using Equation (17). 8:            Update the step size $a_t$ and local parameter ${\mathit{\alpha }}_i^{(t+1)}$ using Equation (15). 9:           end for 10:         Set the local parameter ${\mathit{\alpha }}_i^k={\mathit{\alpha }}_i^{\left(t_{\max }\right)}$. 11:         Compute the sensitivity using Equation (25). 12:         Calculate the Gaussian noise standard deviation $\sigma$ using Equation (26). 13:         Generate Gaussian noise ${\mathit{v}}_i^k\sim \mathcal{N}(0,{\sigma }^2{\mathit{I}}_d)$. 14:         Apply perturbation: ${\tilde{\mathit{\alpha }}}_i^k={\mathit{\alpha }}_i^k+{\mathit{v}}_i^k$. 15:     end for 16:     Update the global parameter ${\mathit{\alpha }}^k$ using Equation (27). 17:     for $i=1$ to n do 18:         Update the dual variable ${\mathit{\gamma }}_i^k$ using Equation (28). 19:     end for 20: end for 21: return Final global model parameter ${\mathit{\alpha }}^K$.

In practical deployments, the selection of the privacy budget $ϵ$ critically influences the trade-off between privacy guarantees and model utility. A smaller $ϵ$ value enforces stronger privacy protection by increasing the noise scale according to Equation (26), which can potentially degrade model accuracy by obscuring the true parameter updates. However, for larger datasets, the impact of noise is mitigated due to the reduced ${\ell }_2$-sensitivity per data point, as sensitivity is inversely proportional to the local dataset size $m_i$. This implies that in data-rich environments, even stringent privacy settings can be achieved without substantial loss in utility, as the model benefits from greater statistical stability.

4.3. Computational Complexity Analysis

The computational complexity of DLGP primarily stems from local parameter updates using Newton’s method, global parameter aggregation, dual variable updates, and the additional privacy protection mechanism. Consider a federated system with n edge nodes, each maintaining a local dataset of size $m_i$ (assumed equal to m for simplicity), feature dimension d, ADMM iteration count K, and maximum Newton iterations $t_{\max }$ per ADMM round.

The local parameter update represents the most computationally intensive component of the algorithm. At each edge node during every ADMM iteration, Newton’s method is employed to minimize the local augmented Lagrangian function. The gradient computation according to Equation (16) requires evaluating the logistic loss gradient, regularization term, and constraint penalties across all m local samples, resulting in $O\left(md\right)$ complexity. The Hessian matrix calculation following Equation (17) involves computing the sum of outer products for all samples, yielding $O\left(m{d}^2\right)$ complexity. The Newton update step in Equation (15) necessitates solving a linear system through matrix inversion, which incurs $O\left(d^3\right)$ complexity. With $t_{\max }$ Newton iterations per ADMM round, the total local computation complexity per node becomes $O\left(t_{\max }(m{d}^2+d^3)\right)$.

The privacy protection mechanism introduces additional computational overhead that must be quantified. The ${\ell }_2$-sensitivity calculation derived in Equation (25) involves a closed-form expression computable in $O\left(1\right)$ time. Gaussian noise generation according to Equation (26) requires sampling d independent random values, resulting in $O\left(d\right)$ complexity. Although these privacy operations add incremental costs, they are negligible compared to the local optimization overhead.

Global aggregation and dual variable updates contribute moderately to the overall computational burden. The server-side global parameter aggregation in Equation (27) computes the average of n perturbed local parameters, requiring $O\left(nd\right)$ operations. The dual variable updates at each edge node following Equation (28) involve simple vector operations with $O\left(d\right)$ complexity per node, totaling $O\left(nd\right)$ across all nodes.

The overall computational complexity of DLGP across K ADMM iterations combines all these components. The dominant factor is the local Newton optimization, which scales with $O\left(Kn{t}_{\max }(m{d}^2+d^3)\right)$. The privacy protection and coordination operations contribute $O\left(Knd\right)$, which becomes negligible for practical problems where $d^2$ or $d^3$ dominates. The specific complexity characteristics depend on the relationship between feature dimension d and sample size m. When $d\ll m$, the $O\left(m{d}^2\right)$ term dominates, making complexity linear in sample size. When d is large ($d\sim m$ or $d>m$), the $O\left(d^3\right)$ term from matrix inversion becomes predominant.

Communication overhead represents another critical aspect of distributed algorithm performance. In each ADMM iteration, every edge node uploads a perturbed d-dimensional parameter vector and downloads the global d-dimensional parameter, resulting in $O\left(nd\right)$ communication per round. The total communication overhead over K iterations is $O\left(Knd\right)$, which is identical to the baseline ADMM algorithm without privacy protection. This demonstrates that the privacy mechanism does not increase communication overhead.

Therefore, compared to the standard ADMM framework, DLGP introduces minimal additional computational burden. The privacy operations add only $O\left(Knd\right)$ to the overall complexity, which is dominated by the $O\left(Kn{t}_{\max }(m{d}^2+d^3)\right)$ local optimization costs.

The computational complexity analysis reveals that the DLGP algorithm maintains practical efficiency for edge computing environments. As summarized in

Table 2. Computational complexity analysis of DLGP algorithm.

Component	Per Iteration	Total (K Iterations)
Computation
Local gradient computation	$O\left(n{t}_{\max }md\right)$	$O\left(Kn{t}_{\max }md\right)$
Local Hessian computation	$O\left(n{t}_{\max }m{d}^2\right)$	$O\left(Kn{t}_{\max }m{d}^2\right)$
Newton update	$O\left(n{t}_{\max }{d}^3\right)$	$O\left(Kn{t}_{\max }{d}^3\right)$
Sensitivity calculation	$O\left(n\right)$	$O\left(Kn\right)$
Noise generation	$O\left(nd\right)$	$O\left(Knd\right)$
Global aggregation	$O\left(nd\right)$	$O\left(Knd\right)$
Dual variable update	$O\left(nd\right)$	$O\left(Knd\right)$
Communication
Parameter transmission	$O\left(nd\right)$	$O\left(Knd\right)$
Total Complexity	$O\left(Kn{t}_{\max }(m{d}^2+d^3)+Knd\right)$

, the dominant computational cost stems from the local Newton optimization, specifically the Hessian computation ($O\left(m{d}^2\right)$) and matrix inversion ($O\left(d^3\right)$) operations. The privacy protection mechanism introduces only linear overhead $O\left(nd\right)$, which becomes negligible compared to the polynomial terms in the local optimization. Importantly, the communication overhead remains at $O\left(nd\right)$ per iteration, involving only the transmission of parameter vectors between edge nodes and the central server. The favorable complexity profile ensures the algorithm’s scalability while maintaining rigorous privacy guarantees through differential privacy.

5. Privacy Analysis of the DLGP Algorithm

This section presents a rigorous proof of the differential privacy guarantee for the DLGP algorithm, establishing the theoretical foundation for its privacy-preserving capabilities. Specifically, we analyze the sensitivity of local parameter updates within the ADMM framework, derive the precise noise magnitude required for Gaussian perturbation, and formally verify that the proposed mechanism satisfies $(ϵ,\delta )$-differential privacy. This theoretical analysis not only validates the algorithm’s privacy guarantees but also provides quantifiable bounds for balancing privacy protection and model utility in practical deployments. The privacy proof essentially establishes an upper bound on the information leakage that could occur through the model updates, ensuring that the algorithm preserves the confidentiality of individual data points while maintaining useful aggregate statistics.

Theorem 1.

Given privacy budget $ϵ\in (0,1)$ and failure probability $\delta \in (0,1)$, let $v_i^k$ be Gaussian noise with mean 0 and variance ${\sigma }^2$ satisfying

$$\sigma \ge {\displaystyle \frac{2\sqrt{2ln(1.25/\delta )}}{m_i(\lambda /n+\mu )ϵ}}.$$

The Gaussian mechanism guarantees $(ϵ,\delta )$-differential privacy such that for any adjacent datasets $D_i$ and $D_i^{\prime }$, and any output ${\tilde{\mathit{\alpha }}}_i^k$, the inequality

$$\mathrm{Pr}[{\tilde{\mathit{\alpha }}}_i^k\mid D_i]\le exp\left(ϵ\right)·\mathrm{Pr}[{\tilde{\mathit{\alpha }}}_i^k\mid D_i^{\prime }]+\delta$$

(29)

holds.

Proof. 

Let ${\tilde{\alpha }}_i^k$, $v_i^k$, and ${v^{\prime }}_i^k$ represent arbitrary components of ${\tilde{\mathit{\alpha }}}_i^k$, ${\mathit{v}}_i^k$, and ${{\mathit{v}}^{\prime }}_i^k$, respectively, where both $v_i^k$ and ${v^{\prime }}_i^k$ are Gaussian noise with mean 0 and variance ${\sigma }^2$. The privacy loss for output ${\tilde{\mathit{\alpha }}}_i^k$ is expressed as

$$\begin{array}{cc}\hfill |ln{\displaystyle \frac{\mathrm{Pr}[{\tilde{\mathit{\alpha }}}_i^k\mid D_i]}{\mathrm{Pr}[{\tilde{\mathit{\alpha }}}_i^k\mid D_i^{\prime }]}}|& =|ln{\displaystyle \frac{\mathrm{Pr}[{\tilde{\alpha }}_i^k\mid D_i]}{\mathrm{Pr}[{\tilde{\alpha }}_i^k\mid D_i^{\prime }]}}|\hfill \\ \hfill & =|ln{\displaystyle \frac{\mathrm{Pr}[{\tilde{\alpha }}_{i,D_i}^k={\alpha }_{i,D_i}^k+v_i^k]}{\mathrm{Pr}[{\tilde{\alpha }}_{i,D_i}^k={\alpha }_{i,{D^{\prime }}_i}^k+{v^{\prime }}_i^k]}}|\hfill \\ \hfill & =|ln{\displaystyle \frac{\mathrm{Pr}\left[v_i^k\right]}{\mathrm{Pr}\left[{v^{\prime }}_i^k\right]}}|\hfill \\ \hfill & =\left|{\displaystyle \frac{1}{2{\sigma }^2}}\left(|v_i^k{|}^2-{|{v^{\prime }}_i^k|}^2\right)\right|\hfill \\ \hfill & =\left|{\displaystyle \frac{1}{2{\sigma }^2}}\left(|v_i^k{|}^2-{|v_i^k+{\alpha }_{i,D_i}^k-{\alpha }_{i,D_i^{\prime }}^k|}^2\right)\right|\hfill \\ \hfill & =\left|{\displaystyle \frac{1}{2{\sigma }^2}}\left(2v_i^k|{\alpha }_{i,D_i}^k-{\alpha }_{i,D_i^{\prime }}^k|+|{\alpha }_{i,D_i}^k-{\alpha }_{i,D_i^{\prime }}^k{|}^2\right)\right|.\hfill \end{array}$$

(30)

To bound the privacy loss within the privacy budget $ϵ$, the condition

$$\begin{array}{cc}\hfill ϵ& \ge |ln{\displaystyle \frac{\mathrm{Pr}[{\tilde{\mathit{\alpha }}}_i^k\mid D_i]}{\mathrm{Pr}[{\tilde{\mathit{\alpha }}}_i^k\mid D_i^{\prime }]}}|\hfill \\ \hfill & \ge \left|{\displaystyle \frac{1}{2{\sigma }^2}}\left(2v_i^k|{\alpha }_{i,D_i}^k-{\alpha }_{i,D_i^{\prime }}^k|+|{\alpha }_{i,D_i}^k-{\alpha }_{i,D_i^{\prime }}^k{|}^2\right)\right|\hfill \end{array}$$

(31)

must be satisfied. Since $|{\alpha }_{i,D_i}^k-{\alpha }_{i,D_i^{\prime }}^k|\le \parallel {\mathit{\alpha }}_{i,D_i}^k-{\mathit{\alpha }}_{i,D_i^{\prime }}^k{\parallel }_2$, substitution of the sensitivity result from Equation (25) yields the bound

$$|v_i^k|\le {\displaystyle \frac{ϵ{\sigma }^2{m}_i(\lambda +\mu n)}{2n}}-{\displaystyle \frac{n}{m_i(\lambda +\mu n)}}.$$

For notational convenience, define the threshold value

$$z={\displaystyle \frac{ϵ{\sigma }^2{m}_i(\lambda +\mu n)}{2n}}-{\displaystyle \frac{n}{m_i(\lambda +\mu n)}}.$$

(32)

The $ϵ$-differential privacy requirement is satisfied when $|v_i^k|\le z$, as this condition ensures $ln\left({\displaystyle \frac{\mathrm{Pr}[{\tilde{\mathit{\alpha }}}_i^k\mid D_i]}{\mathrm{Pr}[{\tilde{\mathit{\alpha }}}_i^k\mid D_i^{\prime }]}}\right)\le ϵ.$ For scenarios where $|v_i^k|>z$, privacy leakage must be bounded by $\delta$, necessitating $\mathrm{Pr}[|v_i^k|>z]\le \delta .$ By symmetry of the Gaussian probability density function, the one-sided tail probability is constrained as

$$\mathrm{Pr}[v_i^k>z]\le {\displaystyle \frac{\delta }{2}}.$$

(33)

Using the probability density function of the Gaussian distribution, the left-hand side of Equation (33) can be rewritten as

$$\begin{array}{ccc}\hfill Pr[v_i^k>z]& =& {\displaystyle \frac{1}{\sqrt{2\pi }\sigma }}{\int }_z^{\infty }exp\left(-{\displaystyle \frac{{\left(v_i^k\right)}^2}{2{\sigma }^2}}\right)d{v}_i^k\hfill \\ & <& {\displaystyle \frac{1}{\sqrt{2\pi }\sigma }}{\int }_z^{\infty }{\displaystyle \frac{v_i^k}{z}}exp\left(-{\displaystyle \frac{{\left(v_i^k\right)}^2}{2{\sigma }^2}}\right)d{v}_i^k\hfill \\ & =& {\displaystyle \frac{\sigma }{\sqrt{2\pi }z}}exp\left(-{\displaystyle \frac{z^2}{2{\sigma }^2}}\right).\hfill \end{array}$$

(34)

Substituting Equation (34) into Equation (33) gives

$$\begin{array}{ccc}\hfill {\displaystyle \frac{\sigma }{\sqrt{2\pi }z}}exp\left(-{\displaystyle \frac{z^2}{2{\sigma }^2}}\right)& <& {\displaystyle \frac{\delta }{2}}\hfill \\ \hfill {\displaystyle \frac{z}{\sigma }}exp\left({\displaystyle \frac{z^2}{2{\sigma }^2}}\right)& >& {\displaystyle \frac{2}{\sqrt{2\pi }\delta }}\hfill \\ \hfill ln{\displaystyle \frac{z}{\sigma }}+{\displaystyle \frac{z^2}{2{\sigma }^2}}& >& ln{\displaystyle \frac{2}{\sqrt{2\pi }\delta }}.\hfill \end{array}$$

(35)

To determine the required standard deviation $\sigma$ for the Gaussian mechanism, sufficient conditions for Equation (35) are established through the inequalities

$$\begin{array}{cc}\hfill ln{\displaystyle \frac{z}{\sigma }}& \ge 0,\hfill \end{array}$$

(36)

$$\begin{array}{cc}\hfill {\displaystyle \frac{z^2}{2{\sigma }^2}}& >ln{\displaystyle \frac{2}{\sqrt{2\pi }\delta }}.\hfill \end{array}$$

(37)

Analysis begins with Equation (36) where

$$\sigma ={\displaystyle \frac{2nc}{m_i(\lambda +\mu n)ϵ}}$$

(38)

with $c\ge 1$. Substitution into Equation (32) yields

$${\displaystyle \frac{z}{\sigma }}=c-{\displaystyle \frac{ϵ}{2c}}.$$

(39)

Since $ϵ<1$ and $c\ge 1$, Equation (36) becomes

$$ln{\displaystyle \frac{z}{\sigma }}=ln\left(c-{\displaystyle \frac{ϵ}{2c}}\right)\ge ln\left(c-{\displaystyle \frac{1}{2}}\right),$$

which implies $c\ge 3/2$ when $ln(z/\sigma )\ge 0$. Next, squaring both sides of Equation (39) gives

$$\begin{array}{ccc}\hfill {\left({\displaystyle \frac{z}{\sigma }}\right)}^2& =& {\left(c-{\displaystyle \frac{ϵ}{2c}}\right)}^2\hfill \\ & =& c^2-ϵ+{\displaystyle \frac{{ϵ}^2}{4c^2}}\hfill \\ & >& c^2-{\displaystyle \frac{8}{9}}.\hfill \end{array}$$

(40)

Since the function $F\left(c\right)=c^2-ϵ+{\displaystyle \frac{{ϵ}^2}{4c^2}}$ satisfies $\nabla F\left(c\right)>0$, Equation (40) holds. Substituting Equation (40) into Equation (37) yields

$$\begin{array}{cc}\hfill {\left({\displaystyle \frac{z}{\sigma }}\right)}^2& >2ln{\displaystyle \frac{2}{\sqrt{2\pi }\delta }}\hfill \\ \hfill c^2-{\displaystyle \frac{8}{9}}& >2ln{\displaystyle \frac{2}{\sqrt{2\pi }\delta }}\hfill \\ \hfill c^2& >{\displaystyle \frac{8}{9}}+ln{\displaystyle \frac{2}{\pi }}+2ln{\displaystyle \frac{1}{\delta }}\hfill \\ \hfill c^2& >lnexp\left({\displaystyle \frac{8}{9}}\right)+ln{\displaystyle \frac{2}{\pi }}+2ln{\displaystyle \frac{1}{\delta }}\hfill \\ \hfill c^2& >2ln{\displaystyle \frac{1.25}{\delta }},\hfill \end{array}$$

which sufficiently ensures Equation (35) holds. Consequently, for $\sigma \ge 2n\sqrt{2ln(1.25/\delta )}/\left(m_i(\lambda +\mu n)ϵ\right)$, the probability

$$Pr\left[v_i^k>{\displaystyle \frac{ϵ{\sigma }^2{m}_i(\lambda +\mu n)}{2n}}-{\displaystyle \frac{n}{m_i(\lambda +\mu n)}}\right]\le {\displaystyle \frac{\delta }{2}}$$

is established, and similarly

$$Pr\left[|v_i^k|>{\displaystyle \frac{ϵ{\sigma }^2{m}_i(\lambda +\mu n)}{2n}}-{\displaystyle \frac{n}{m_i(\lambda +\mu n)}}\right]\le \delta .$$

Partition $\mathbb{R}$ into two subsets: $\mathbb{R}={\mathbb{R}}_1\cup {\mathbb{R}}_2$, where

$${\mathbb{R}}_1=\left\{v_i^k\in \mathbb{R}\mid |v_i^k|\le {\displaystyle \frac{ϵ{\sigma }^2{m}_i(\lambda +\mu n)}{2n}}-{\displaystyle \frac{n}{m_i(\lambda +\mu n)}}\right\}$$

and

$${\mathbb{R}}_2=\left\{v_i^k\in \mathbb{R}\mid |v_i^k|>{\displaystyle \frac{ϵ{\sigma }^2{m}_i(\lambda +\mu n)}{2n}}-{\displaystyle \frac{n}{m_i(\lambda +\mu n)}}\right\}.$$

For any subset $O\subseteq \mathbb{R}$, define $O_1=\{{\alpha }_{i,D_i}^k+v_i^k\mid v_i^k\in {\mathbb{R}}_1\}$ and $O_2=\{{\alpha }_{i,D_i}^k+v_i^k\mid v_i^k\in {\mathbb{R}}_2\}$. The probability of any point in O is bounded as

$$\begin{array}{cc}\hfill \mathrm{Pr}[{\tilde{\mathit{\alpha }}}_i^k\mid D_i]& =\mathrm{Pr}[{\alpha }_{i,D_i}^k+v_i^k:v_i^k\in O_1]+\mathrm{Pr}[{\alpha }_{i,D_i}^k+v_i^k:v_i^k\in O_2]\hfill \\ \hfill & \le \mathrm{Pr}[{\alpha }_{i,D_i}^k+v_i^k:v_i^k\in O_1]+\delta \hfill \\ \hfill & \le exp\left(ϵ\right)·\mathrm{Pr}[{\tilde{\mathit{\alpha }}}_i^k\mid D_i^{\prime }]+\delta ,\hfill \end{array}$$

satisfying $(ϵ,\delta )$-differential privacy and completing the proof of Theorem 1. □

6. Experimental Simulation

This section presents experimental results validating the performance of the proposed DLGP algorithm. The privacy–accuracy trade-off, convergence behavior, and parameter sensitivity are evaluated using a real-world occupancy detection dataset, with comparisons against state-of-the-art methods. All experiments are conducted under controlled conditions to ensure reproducibility, with key findings analyzed in conjunction with theoretical results from previous sections.

6.1. Dataset and Experimental Setup

The experimental evaluation was performed on the Room Occupancy Estimation dataset from UCI Machine Learning Repository [28], containing 10,129 time-series samples collected from a controlled smart building room. Each sample consists of 18 multivariate features (e.g., temperature, light, sound, CO₂, digital passive infrared) and a corresponding occupancy label. The dataset was preprocessed with features max-normalized to [0, 1], followed by ${\ell }_2$ normalization of each sample to unit norm. The original labels reflect the number of occupants in the room during the 4-day controlled data collection period, ranging from 0 to 3. To meet the model’s input specification, we recoded the labels by assigning a value of −1 to samples with zero occupants and +1 to those with one to three occupants. For each experiment, 8000 samples were used as the training set, with the remaining 2129 samples serving as the test set. Simulations were implemented in MATLAB R2023b and executed on a machine equipped with a 3.4 GHz processor and 8 GB of RAM. The current experimental setup assumes homogeneous data distribution across all edge nodes and static client participation throughout the training process. Unless otherwise specified, the default parameters are summarized in

Table 3. Default experimental parameters.

Parameter	Default Value
Iterations (K)	100
Edge nodes (n)	100
Penalty parameter ($\mu$)	0.1
Privacy budget ($ϵ$)	0.9
Relaxation probability ($\delta$)	0.01
Regularization parameter ($\lambda$)	0.01

.

To validate the effectiveness of the DLGP algorithm, comparative experiments were conducted with five baseline methods, including a centralized strategy, ADMM, Distributed Logistic Variable Perturbation (DLVP) algorithm [24], Differentially Private Stochastic Gradient Descent (DPSGD) [29], and Differentially Private Per-Sample Adaptive Clipping Federated Learning (DP-PSAC-FL) [30]. For DPSGD and DP-PSAC-FL, the learning rate was set to 0.1. Additionally, in DP-PSAC-FL, the stability constant was configured as 0.1. The evaluation employed two key metrics: classification accuracy and empirical loss.

The empirical loss function is defined as

$${\displaystyle \frac{1}{n}}\sum _{i=1}^n\sum _{j=1}^{m_i}{\displaystyle \frac{1}{m_i}}log\left(1+exp\left(-y_{ij}{\tilde{\mathit{\alpha }}}_i^{\mathrm{T}}{\mathit{x}}_{ij}\right)\right),$$

where ${\tilde{\mathit{\alpha }}}_i$ denotes the perturbed local parameter vector at edge node i, ${\mathit{x}}_{ij}$ represents the j-th feature vector at node i, and $y_{ij}$ is the corresponding label.

6.2. Performance Analysis with Varying Number of Nodes

To evaluate the impact of edge node quantity on algorithm performance, both empirical loss and accuracy were measured under different node configurations $n\in \{50,80,100,200\}$ and privacy budgets $ϵ\in \{0.5,0.9\}$. This dual-metric evaluation addresses the distinction between data fitting and classification performance while validating consistency between experimental results and theoretical conclusions from Theorem 1.

As presented in

Table 4. Empirical loss comparison with different numbers of nodes.

Algorithm	$\mathit{ϵ}$ = 0.5				$\mathit{ϵ}$ = 0.9
	$\mathit{n}$ = 50	$\mathit{n}$ = 80	$\mathit{n}$ = 100	$\mathit{n}$ = 200	$\mathit{n}$ = 50	$\mathit{n}$ = 80	$\mathit{n}$ = 100	$\mathit{n}$ = 200
Centralized	0.0451	0.0451	0.0451	0.0451	0.0451	0.0451	0.0451	0.0451
ADMM	0.0455	0.0461	0.0464	0.0471	0.0455	0.0461	0.0464	0.0471
DLVP	0.4897	1.1639	1.1625	3.3431	0.1861	0.4415	0.4906	1.5274
DPSGD	0.3502	0.5257	0.5592	0.6685	0.3694	0.3971	0.4415	0.4906
DLGP	0.0840	0.2050	0.2075	0.6509	0.0572	0.0895	0.0943	0.2705
DP-PSAC-FL	0.3150	0.4832	0.5033	0.6679	0.3171	0.3176	0.3837	0.4564

and Figure 3, all privacy-preserving algorithms (DLGP, DLVP, DPSGD, and DP-PSAC-FL) exhibit a consistent upward trend in empirical loss with increasing n. The centralized strategy, which is inherently independent of node quantity, maintains identical loss values across all n configurations. ADMM, as a distributed non-privacy-preserving baseline, also shows negligible variations in loss. Under $ϵ=0.5$, the empirical loss of DLGP increases from 0.0840 at $n=50$ to 0.6509 at $n=200$, a range substantially lower than the corresponding increases observed for DLVP (from 0.4897 to 3.3431), DPSGD (from 0.3502 to 0.6685), and DP-PSAC-FL (from 0.3150 to 0.6679). A similar behavior is observed for $ϵ=0.9$, with DLGP consistently outperforming all comparative privacy-preserving algorithms. Taking the default number of nodes $n=100$ as an example, DLGP reduces the empirical loss to 0.0943, which is approximately 80.8% lower than DLVP (0.4906), around 78.6% lower than DPSGD (0.4415), and about 75.4% lower than DP-PSAC-FL (0.3837). This observation aligns with Theorem 1, which stipulates that noise intensity is proportional to $1/m_i$. An increase in n reduces $m_i$, necessitating the injection of additional noise to sustain privacy protection and thereby leading to elevated empirical loss.

Table 5. Accuracy comparison with different numbers of nodes.

Algorithm	$\mathit{ϵ}$ = 0.5				$\mathit{ϵ}$ = 0.9
	$\mathit{n}$ = 50	$\mathit{n}$ = 80	$\mathit{n}$ = 100	$\mathit{n}$ = 200	$\mathit{n}$ = 50	$\mathit{n}$ = 80	$\mathit{n}$ = 100	$\mathit{n}$ = 200
Centralized	0.9915	0.9915	0.9915	0.9915	0.9915	0.9915	0.9915	0.9915
ADMM	0.9915	0.9911	0.9911	0.9911	0.9915	0.9911	0.9911	0.9911
DLVP	0.9782	0.9673	0.9561	0.9031	0.9906	0.9797	0.9685	0.9154
DPSGD	0.9029	08960	0.8862	0.8423	0.9153	0.9083	0.8985	0.8545
DLGP	0.9870	0.9791	0.9739	0.9498	0.9911	0.9821	0.9766	0.9510
DP-PSAC-FL	0.9372	0.9315	0.9209	0.8819	0.9461	0.9348	0.9177	0.8576

and Figure 4 further confirm an inverse relationship between accuracy and node quantity for privacy-preserving methods. Under $ϵ=0.5$, DLGP maintains high accuracy with a mild degradation from 0.9870 at $n=50$ to 0.9498 at $n=200$. In contrast, DLVP, DPSGD, and DP-PSAC-FL undergo more pronounced accuracy declines, falling from 0.9782 to 0.9031, from 0.9029 to 0.8423, and from 0.9372 to 0.8819, respectively. For $ϵ=0.9$, DLGP’s accuracy decreases slightly from 0.9911 to 0.9510, while maintaining a clear advantage over other privacy-preserving methods. At $n=100$, its accuracy reaches 0.9766, representing an improvement of $0.81\%$ over DLVP (0.9685), $7.81\%$ over DPSGD (0.8985), and $6.03\%$ over DP-PSAC-FL (0.9177). This keeps DLGP’s performance closer to that of non-privacy-preserving baselines compared to other privacy-aware algorithms. The stable accuracy of the centralized strategy and ADMM confirms that privacy-unconstrained methods are unaffected by variations in node quantity, providing a benchmark for assessing the privacy–performance trade-off of the proposed DLGP and comparative algorithms.

6.3. Impact of Privacy Budget $ϵ$

To provide a more intuitive demonstration of how privacy budget $ϵ$ impacts empirical loss, experimental results for five algorithms (ADMM, DLVP, DPSGD, DP-PSAC-FL, and the proposed DLGP) are analyzed under varying privacy budgets $ϵ\in \{0.3,0.5,0.7,0.9\}$, with the number of edge nodes fixed at 100. From the overall experimental trends, all five algorithms show a consistent downward shift in empirical loss as $ϵ$ increases from 0.3 to 0.9, and each algorithm achieves its lowest empirical loss at $ϵ=0.9$ relative to other privacy levels. This trend aligns with Theorem 1, which specifies that a larger privacy budget corresponds to a smaller noise variance, with reduced noise injection during training minimizing deviations between model predictions and true labels and in turn lowering empirical loss.

As illustrated in Figure 5d, when $ϵ=0.9$, ADMM maintains the lowest empirical loss among all algorithms and exhibits nearly no error fluctuations. This phenomenon is attributed to ADMM’s nature as a distributed non-privacy-preserving algorithm, which does not introduce any privacy-related noise into intermediate variable transmission or local parameter updates during training. Its empirical loss is thus only determined by model fitting performance, free from noise interference, leading to both minimal and stable loss values. Among the privacy-preserving algorithms (DLVP, DPSGD, DLGP, DP-PSAC-FL), the proposed DLGP outperforms DLVP and DPSGD significantly at $ϵ=0.9$. DLGP outperforms DLVP in accuracy because the Gaussian mechanism introduces less noise than the Laplace mechanism employed by DLVP. Furthermore, DLGP also surpasses both DPSGD and DP-PSAC-FL, as its design mitigates noise accumulation during training. In contrast, the stochastic gradient-based perturbation mechanisms used in DPSGD and DP-PSAC-FL are more sensitive to gradient fluctuations, leading to higher empirical loss.

To validate the computational efficiency of the proposed DLGP algorithm, we conducted runtime simulations comparing it with three baseline approaches: ADMM, DLVP, DPSGD, and DP-PSAC-FL. Each algorithm was executed five times under identical experimental conditions, and the average computation times were recorded. As shown in

Table 6. Average computation time of algorithms.

Algorithm	Average Runtime (s)
ADMM	2.0768
DLVP	2.2812
DPSGD	0.2471
DLGP	2.1555
DP-PSAC-FL	0.3158

, DLGP achieved a competitive runtime of 2.1555 s, which is comparable to the standard ADMM approach (2.0768 s) while providing enhanced privacy guarantees. The DLVP algorithm exhibited the longest computation time at 2.2812 s, while DPSGD and DP-PSAC-FL demonstrated significantly faster execution at 0.2471 s and 0.3158 s, respectively, due to their simpler optimization frameworks. These results confirm that the additional privacy protection mechanisms in DLGP introduce only modest computational overhead, making it practically viable for real-world federated learning applications where both efficiency and privacy are critical considerations.

6.4. Sensitivity to Penalty Parameter

The impact of the penalty parameter $\mu$ on model training performance is analyzed in Figure 6, which displays the empirical loss curves of three privacy-preserving algorithms for $\mu \in \{0.01,0.1\}$. All algorithms exhibit consistently higher empirical loss at $\mu =0.01$ than at $\mu =0.1$. As iterations increase, their empirical loss generally decreases, but the curves for $\mu =0.01$ consistently remain above those for $\mu =0.1$.

This trend aligns with Theorem 1, which states noise level is inversely proportional to $\mu$. A smaller penalty parameter ($\mu =0.01$) leads to more noise injected during training, disrupting parameter update accuracy and ultimately increasing empirical loss. Among four algorithms, DLGP maintains the lowest empirical loss across both $\mu$ settings. Its advantage is particularly prominent under $\mu =0.01$, and even when iterations reach 100, its empirical loss remains lower than that of DLVP, DPSGD, and DP-PSAC-FL. This confirms DLGP possesses stronger adaptability to ADMM penalty parameter variations and sustains superior training performance even in scenarios with more injected noise.

6.5. Impact of Regularization Parameter

The influence of the regularization parameter $\lambda$ on model training performance is evaluated in Figure 7, which depicts the empirical loss curves of DLVP, DPSGD, and DP-PSAC-FL for $\lambda \in \{0.01,0.1\}$. All algorithms exhibit a consistent decline in empirical loss as iterations progress. Notably, the difference in loss between the two $\lambda$ values is marginal throughout the training process. Among the four methods, DLGP achieves the lowest empirical loss under both $\lambda$ settings, followed by DLVP and DP-PSAC-FL, while DPSGD consistently yields the highest loss.

This observation aligns with Equation (26), where the impact of $\lambda$ on noise level is scaled by $1/n$. With the default number of edge nodes $n=100$, the scaling effect weakens the influence of $\lambda$ on empirical loss, resulting in the minor differences between the loss curves of different $\lambda$ values observed in the figure. This further confirms that the regularization parameter $\lambda$ exerts a weaker influence on model empirical loss compared to the ADMM penalty parameter, and the proposed DLGP remains robust to variations in $\lambda$ while maintaining superior performance.

Based on Figure 3, Figure 4, Figure 5, Figure 6 and Figure 7 and Table 4 and Table 5, we can draw the following conclusions.

• As the number of edge nodes increases, the empirical loss of privacy-preserving algorithms (DLGP, DLVP, DPSGD, and DP-PSAC-FL) rises, whereas non-private baselines remain stable. Across all node counts, DLGP consistently outperforms other privacy-preserving algorithms in both empirical loss and accuracy, demonstrating superior scalability.
• Figure 5 demonstrates that empirical loss decreases with increasing privacy budget for all algorithms, with DLGP maintaining lower loss values compared to DLVP, DPSGD, and DP-PSAC-FL across all tested privacy levels.
• Figure 6 reveals that empirical loss increases with decreasing penalty parameters for all algorithms. The superiority of DLGP over DLVP, DPSGD, and DP-PSAC-FL becomes more pronounced as the penalty parameter decreases.
• Figure 7 indicates that the regularization parameter has a relatively minor impact on the empirical loss of all privacy-preserving algorithms.

7. Conclusions

This paper develops the DLGP algorithm, which integrates ADMM with differential privacy mechanisms to address privacy–utility trade-offs in federated learning scenarios. Theoretical analysis establishes bounded ${\ell }_2$-sensitivity of local parameter updates, enabling rigorous $(ϵ,\delta )$-differential privacy guarantees through calibrated Gaussian noise injection. Experimental evaluations on the Room Occupancy Estimation dataset from the UCI Repository demonstrate DLGP’s superior performance with quantifiable metrics. Under various configurations, DLGP achieves substantially lower empirical loss and higher classification accuracy compared to all baseline methods. This superiority persists across different configurations, with DLGP maintaining stronger robustness to variations in penalty parameter $\mu$ and regularization parameter $\lambda$ than baseline algorithms while upholding formal $(ϵ,\delta )$-differential privacy guarantees.

While the proposed DLGP framework provides formal privacy guarantees for federated logistic regression, its evaluation is limited to the IID data setting. Future work will focus on developing personalized variants of the model through client-specific regularization techniques and exploring robust optimization methods to enhance performance under non-IID data distributions while maintaining the established differential privacy guarantees.