3D LPA: Connectivity-Aware Label Propagation

• The paper introduces a connectivity-aware label propagation mechanism by integrating a neighborhood-strength metric to improve label selection and community detection quality.
• It employs asynchronous updates and an active-node management strategy, drastically reducing redundant computations and iteration counts compared to standard LPA.
• Empirical evaluations on synthetic and real networks show enhanced modularity and scalability, particularly in settings with high local clustering.

Connectivity-Aware Label Propagation Algorithm (3D LPA) delivers a community detection architecture that incorporates local neighborhood connectivity into the label update criterion, improving both computational efficiency and partition quality compared to the standard Label Propagation Algorithm (LPA). It achieves nearly-linear runtime via asynchronous updates and active-node management, and bolsters accuracy—particularly in networks characterized by high local clustering—by privileging neighbors tightly integrated within a node’s immediate environment (Xie et al., 2011).

1. Neighborhood-Strength Measure

In the standard LPA, each node $i$ updates its label by selecting the most frequently occurring label among its neighbors $N(i)$. The 3D LPA introduces a neighborhood-strength metric to quantify, for each neighbor $j\in N(i)$, the extent to which $j$ connects to the remainder of $i$'s local environment. This is formalized by:

$$h_j(i) = |\{ k\in N(i)\setminus\{i\} : (j,k)\in E \}|,$$

where $E$ is the edge set. Thus, $h_j(i)$ counts the number of edges from $j$ to other neighbors of $i$ (excluding $i$ itself). For each candidate label $k$ present in $N(i)$, the subset $C_k \subseteq N(i)$ of neighbors carrying label $k$ receives a neighborhood-strength-driven score:

$S(C_k) = \sum_{j\in C_k}\bigl[1 + c\,h_j(i)\bigr],$

where $c \in [0,1]$ is a tunable parameter. At $c=0$, 3D LPA reverts to standard LPA; at $c=1$, each intra-neighborhood link receives equal weighting. The $S(C_k)$ score thus fuses label frequency with intra-neighborhood cohesiveness.

2. Generalized Label Update Rule

Instead of the majority-vote mechanism, 3D LPA enacts the following asynchronous update for each selected node $i$:

1. For each candidate label $k$ in $N(i)$, identify the set $C_k = \{j \in N(i) : L(j) = k\}$.
2. Compute $S(C_k)$ as above for each candidate $k$.
3. Set

$L(i) \leftarrow \underset{k}{\arg\max} S(C_k),$

breaking ties randomly.

This refinement weights influence so that neighbors more densely connected within $i$’s immediate vicinity exert proportionally greater effect. As $c$ increases, structurally central neighbors are systematically preferred over sparsely connected ones for label propagation.

3. Algorithmic Workflow with Speed-Up Optimizations

3D LPA integrates two principal enhancements:

• The connectivity-weighted label selection as described.
• An active-node list that manages which nodes need possible label reevaluation, yielding substantial efficiency gains.

Initialization:

• Assign each node a unique label: $L(i) \gets$ unique identifier.
• ActiveList $\gets$ all nodes.

Iterative Update Loop:

1. Randomly select and remove node $i$ from ActiveList.
2. For all $j \in N(i)$, compute $h_j(i)$.
3. Partition $N(i)$ into $C_k$ for each observed label $k$.
4. Compute $S(C_k) = \sum_{j\in C_k}[1 + c \cdot h_j(i)]$ for all $k$.
5. Set $L(i) \gets$ label $k^*$ with maximal $S(C_k)$ (breaking ties randomly).
6. If $L(i)$ changes, propagate status updates:
   • For $i$ and each neighbor $\ell \in N(i)$, determine node status:
     • Interior: all neighbors share its label.
     • Passive: node would not change label upon update.
     • Active: otherwise.
   • Update ActiveList to reflect status changes; add newly active, remove newly passive.

Optimization remarks:

• Naïve $h_j(i)$ computation scales as $O(d_i^2)$, but adjacency bitsets and incremental histograms reduce this to $O(d_j)$ (or amortized $O(1)$ per link).
• The active-node bookkeeping ensures each update is effective (i.e., results in a label change), minimizing redundant operations.

4. Computational Complexity Analysis

Let $n$ denote the number of nodes, $m$ the number of edges in a sparse graph ($m = O(n)$).

Original LPA:

• Each node scan: $O(d_i)$.
• Empirically, the number of iterations per node, $T_{\text{orig}}/n$, ranges $1$–$20$.
• Total complexity: $O(m \cdot T_{\text{orig}} / n)$.

3D LPA:

• Effective update cost: $O(d_i + \sum_{j \in N(i)} d_j)$ using direct computation, reduced to $O(d_i)$ by histogram/bitset optimizations.
• Number of iterations matches the count of label changes (passive/interior nodes excluded), with $T_{3D}/n < 3$ observed empirically—representing $6$–$20\times$ fewer iterations than original LPA.
• Overall runtime per pass: $O(m)$, but with significantly diminished constant and pass count.

Both algorithms maintain nominal linear scaling, but 3D LPA’s strictly “effective” updates deliver reduced running time and improved scalability for larger networks.

5. Empirical Validation on Synthetic and Real Networks

3D LPA was evaluated on:

• Synthetic benchmarks: LFR benchmarks ($N=1000$, $\langle k \rangle=5$, variable mixing $\mu$).
  • Metrics: Normalized Mutual Information (NMI), Adjusted Rand Index (ARI) against ground truth.
  • For $\mu < 0.3$, all $c$ values yield similar results.
  • For $\mu > 0.35$ up to $0.65$, $c>0$ variants outperform $c=0$ by $5$–$20\%$ NMI/ARI, and maintain partition integrity where standard LPA fails.
• Real-world networks: Nine social graphs (size range $34$–$10,680$ nodes; datasets include karate, football, netscience, email, PGP).
  • Metric: modularity $Q$, with $100$ runs per dataset.
  • Highest $Q$: $c>0$ (often $c=1$) surpasses $c=0$ by up to $0.04$ absolute.
  • Mean $Q$: $c>0$ is consistently higher and more stable, fewer all-in-one collapses ($c=1$).
  • Iteration reduction: $1.5\times$–$21\times$ across diverse networks.

Improvements are most pronounced when clustering coefficients are high, as the algorithm’s weighting rewards neighbors that form cohesive local structures.

6. Context and Interpretation

3D LPA augments the parameter-free, asynchronous update framework of standard label propagation by embedding the neighborhood-strength score $S(C_k)$ for each candidate label. The integration of connectivity-aware scoring and efficient bookkeeping produces accelerated convergence and reinforced community boundaries within topologies abundant in local triangles. This suggests that the method is particularly suited for network domains—social, biological, information—where clustering and intra-community density are signature features. A plausible implication is that the approach is robust against “collapse” into trivial partitions in the presence of strong local structure, supporting its utility in large-scale, real-world network analysis (Xie et al., 2011).