---
title: VL-PUB Module Overview
url: https://www.emergentmind.com/topics/vl-pub-module
type: topic
---

# VL-PUB Module Overview

The VL-PUB module is the publisher-side orchestration and computation unit in the PubSub-VFL framework for two-party vertical federated learning (VFL). Engineered for efficient, privacy-preserving split learning between organizations with heterogeneous resources, VL-PUB operationalizes asynchronous embedding publication, local differential privacy (DP) protection, gradient backpropagation, and synchronized parameter updates. Achieving substantial resource utilization and training acceleration, it forms the “passive party” (denoted \(P_p\)) counterpart to the subscriber, functioning as both an independent compute engine and a tightly integrated publisher node in the Publisher/Subscriber (Pub/Sub) layering of PubSub-VFL [2510.12494].

## 1. Architectural and Functional Overview

VL-PUB executes on the side of the passive participant \(P_p\) in a two-party VFL arrangement. Its duties include:

- Sampling local feature minibatches \(\{x_i^p\}_{i\in B}\) and computing embeddings \(z^p = f_p(x^p;\theta_p)\) using the bottom model.
- Applying Gaussian DP noise: \(z^p \leftarrow z^p + \xi_{dp}\), where \(\xi_{dp} \sim \mathcal{N}(0,\sigma_{dp}^2I)\).
- Publishing these noisy embeddings into an embedding channel \(\mathcal{C}_e[b]\) keyed by batch identifier.
- On receipt of the corresponding embedding gradient \(\nabla_{z^p}\mathcal{L}\) from the subscriber, performing backpropagation to obtain parameter gradients \(\nabla_{\theta_p}\mathcal{L}\) and pushing updated parameters to the local Parameter Server (PS).

The module interfaces asynchronously with both the VL-SUB (“active” party) via embedding (\(\mathcal{C}_e\)) and gradient (\(\mathcal{C}_g\)) channels, and with the local PS via scheduled aggregation/broadcast. All updates and synchronizations accommodate data and system heterogeneity, bounded staleness, and strict privacy constraints.

### Data and Gradient Workflow

1. VL-PUB samples batch \(B\).
2. Computes \(z^p = f_p(x^p; \theta_p)\).
3. Perturbs with Gaussian DP noise: \(\xi_{dp} \sim \mathcal{N}(0, \sigma_{dp}^2I)\).
4. Publishes \((z^p, b)\) to embedding channel \(\mathcal{C}_e[b]\).
5. After VL-SUB computes \(\nabla_{z^p}\mathcal{L}\), pulls gradient from \(\mathcal{C}_g[b]\).
6. Backpropagates through \(f_p\), updates \(\theta_p\), pushes to local PS.
7. At semi-async intervals, PS aggregates local model copies and rebroadcasts fresh parameters.

*Diagrammatic flow:*
\[
x^p \rightarrow [f_p] \rightarrow (z^p+\xi_{dp}) \xrightarrow{\text{embedding channel}} [\text{VL-SUB}] \rightarrow \text{loss} \xrightarrow{\text{grad channel}} [f_p\ \text{backprop}]
\]

## 2. Hierarchical Asynchronous Update Logic

VL-PUB supports a two-level asynchronous paradigm:

- **Pub/Sub Asynchrony (Cross-Party):** Embedding and gradient exchanges between publisher and subscriber occur via decoupled, FIFO Pub/Sub channels.
- **Semi-Asynchronous PS Updates (Within-Party):** Local PS aggregates worker parameter updates every \(\tau_s\) steps, broadcasting the average to all party workers.

A key pseudo-code summary for the VL-PUB worker loop:

```pseudo
Algorithm VL-PUB Worker Loop
Require: Bottom net f_p(x;θ_p), embedding C_e[·], grad C_g[·], DP noise σ_dp, wait deadline τ_p, PS sync τ_s
Loop over batches id=1,2,…:
  1. X_p ← sample_batch(id)
  2. z_p ← f_p(X_p; θ_p)
  3. z̃_p ← z_p + Normal(0, σ_dp^2 I)
  4. publish (id, z̃_p) → C_e[id]
  5. start timer
  6. repeat
         if C_g[id] has grad Δzp then g_p ← Δzp; break
     until elapsed_time ≥ τ_p
  7. if no gradient by τ_p then drop/re-enqueue batch; continue
  8. ∇θ_p ← backprop(f_p, g_p)
  9. θ_p ← θ_p − η ∇θ_p
 10. push θ_p to local PS
 11. if local_step mod τ_s == 0 then θ_p ← PS.aggregate_and_broadcast()
End Loop
```

**Update Equations:**
\[
\theta_{p, t+1} = \theta_{p, t} - \eta \bigl( g_{p, t-\tau_p} + \xi_{dp, t} \bigr)
\]
where \(\tau_p \le T_{ddl}\) (maximum staleness) and \(\xi_{dp,t}\) is DP noise.

**Staleness Bound:**
\[
\|\nabla f(\theta_t) - \nabla f(\theta_{t-\tau_p})\| \le L \sum_{j=t-\tau_p}^{t-1} \|\theta_{j+1} - \theta_j\|
\]

## 3. Heterogeneity-Aware Optimization Problem

VL-PUB is engineered to adaptively optimize performance under resource and data heterogeneity by formalizing and solving a discrete minimax latency problem:

**Objective:**
\[
\min_{w_a, w_p, B} \max \bigl\{ T_A(w_a,B), T_P(w_p,B) \bigr\}
\]
subject to DP privacy, memory, and resource constraints.

- \(T_A\): end-to-end per-batch time for subscriber, includes forward and backward passes, top model, and gradient comm.
- \(T_P\): end-to-end per-batch time for publisher, includes forward and backward passes, and embedding comm.

**Subcomponent Latencies:**
\[
T_f^{(p)}(B)=\frac{\lambda_p}{B^{\gamma_p}\sum_{j=1}^{w_p}c_{p,j}},\qquad
T_b^{(p)}(B)=\frac{\varphi_p}{B^{\beta_p}\sum_{j=1}^{w_p}c_{p,j}}
\]
(similar expressions for active side).

Communication times:
\[
T_{\rm emb}=E/B_b,\quad T_{\rm grad}=G/B_b
\]

**Privacy Constraint:**
\[
\sigma_{dp} = \mathcal{O}\left( \frac{N_m \sqrt{K}}{\mu N} \right)
\]
for \((\mu, \sigma_{dp})\)-GDP.

**Dynamic Programming Solution:**
\[
\text{Cost}[i,j,r] =\,
\text{latency cost for }\; w_a = P+i-1,\, w_p = M+j-1,\, B = B_r
\]
Selects optimal \((w_a, w_p, B)\) via \(\arg\min\).

## 4. Convergence and Privacy Guarantees

Convergence of the VL-PUB module (and thus the overall PubSub-VFL framework) is rigorously characterized:

**Theorem (5.1 [2510.12494], under standard convexity, smoothness, bounded variance, staleness, DP):**
\[
\mathbb{E}\left[ f(\theta_t) - f(\theta^*) \right] \le
\left( 1 - 2\mu\eta + O(\eta^2 L + \eta^3 L^2 \tau_p) \right)^t [f(\theta_0) - f(\theta^*)]
+ \frac{L\eta(\sigma^2+\sigma_{dp}^2)}{4\mu}
\]
Thus, the process achieves linear convergence up to a variance floor dependent on the sum of SGD and DP noises.

DP compatibility follows from the independence and zero-mean property of injected GDP noise; the only consequence is a higher asymptotic variance. Convergence and privacy results remain intact for small enough stepsize \(\eta\), even under bounded staleness.

## 5. Empirical Acceleration and Resource Utilization

VL-PUB yields substantial practical speedup and efficient hardware utilization:

| Method      | Time (s) | Speedup | CPU Util (%) |
|-------------|----------|---------|--------------|
| AVFL-PS     | 885.01   | 1.0×    | 76.2         |
| PubSub-VFL  | 124.01   | 7.14×   | 89.97        |

Across five benchmark datasets, PubSub-VFL (with VL-PUB) achieved \(2\sim 7\times\) speedup and CPU utilization up to 91.07%, with comparable or improved test accuracy [2510.12494].

**Per-batch computational costs at VL-PUB:**

- Forward: \(O(B \cdot d_p \cdot \text{model-Flops})\)
- Backward: similar
- Communication: Transmit/receive \(B \times \dim(z)\) floats
- PS aggregation: \(O(\dim(\theta_p))\) every \(\tau_s\) steps

## 6. Implementation and Integration

**Basic Integration:**

- VL-PUB functions as an asynchronous publisher within any VFL codebase.
- Each worker requires:
  - Pub/Sub client for embedding (\(\mathcal{C}_e\)) and gradient (\(\mathcal{C}_g\)) channels
  - Small FIFO buffer (\(p,q \approx 5\))
  - Waiting-deadline (\(\tau_p = T_{ddl} \approx 10\,s\))
  - DP noise generator (\(\sigma_{dp}\) calibrated via Eq. (25))
  - Semi-async PS-sync interval (\(\tau_s = \Delta T_t\))

**Hyperparameter Selection:**

- Synchronous profiling round for \(\{\lambda, \gamma, \varphi, \beta\}\).
- Solve the DP or use provided dynamic programming code for optimal \((w_a, w_p, B)\). Defaults: \((8,10,256)\).
- Monitor channel latencies; adjust \(\tau_p\) or buffer sizes as needed.
- Re-solve DP if data imbalance emerges.

VL-PUB thereby implements lightweight yet robust asynchronous publication, gradient consumption, and parameter updates with bounded staleness, strict privacy via GDP, and explicit resource heterogeneity adaptation. It achieves notable end-to-end acceleration (\(2{\sim}7\times\)) and near-optimal hardware efficiency (up to 91.07% CPU utilization) in empirical testing [2510.12494].

Source: https://www.emergentmind.com/topics/vl-pub-module