网络算法系列之社区发现（一）：标签传播算法

社区发现简介

  社区发现问题实际上是从子图分割的问题演变而来。在社交网络中，有些用户连接非常紧密，有些用户连接较为稀疏，这些连接紧密的用户可以看做一个社区，而社区之间连接较为稀疏。下图就展示了一个社区发现。

  目前的社区发现问题分为两大类：非重叠社区发现和重叠社区发现。非重叠社区发现问题描述的是：一个网络中，每个节点均只能属于同一个社区，这意味这社区和社区之间是没有交集的。在非重叠社区发现算法中，有不同种类的解法：

• 1、基于模块度的社区发现算法
  基本思想是通过定义模块度（Modularity）来衡量一个社区的划分是不是相对比较好的结果，从而将社区发现问题转化为最大化模块度的问题进行求解。这块后续会讲到。
• 2、基于标签传播的社区发现算法
  基本思想是通过标记节点的标签信息来更新未标记节点的标签信息，在整个网络中进行传播，直至收敛。其中最具代表性的就是标签传播算法（LPA,Label Propagation Algorithm）。

标签传播算法

简介

  标签传播算法是一种基于标签传播的局部社区发现算法。其基本思想是节点的标签（community）依赖其邻居节点的标签信息，影响程度由节点相似度决定，并通过传播迭代更新达到稳定。原始论文可以参考： Near linear time algorithm to detect community structures in large-scale networks。

算法详述

算法过程

  初始化阶段：每个节点都会初始化自己作为社区标签。
  传播阶段：遍历网络中所有的节点，找到当前节点的所有邻居节点。获取所有邻居节点的社区标签，并找到权重最大(投票思想)的社区标签（对于有权图，就是所有同社区标签的edge weight之和；对于无权图，edge weight看做是1，就是出现次数做多的社区标签），将其为更新自己的社区标签。
  收敛判定阶段：遍历网络中所有的节点，找到当前节点的所有邻居节点。获取所有邻居节点的社区标签，并找到权重最大的社区标签，判定是否是自己的社区标签，如果均判定通过，则算法结束。为防止震荡情况出现，应设置一个最大迭代次数。达到最大迭代次数后也退出。

  在社区标签传播的阶段，如果我们将每个邻居

标签传播方式

  标签传播方式分为两种：同步更新、异步更新。
  1、同步更新：在第 t 次迭代中，每个节点依赖的都是邻居节点上一次迭代 t-1 时的社区标签。
  2、异步更新：在第 t 次迭代中，每个节点依赖的是当前邻居节点的社区标签，若邻居节点进行了更新，则依赖的是 t 时的社区标签，若未进行更新，则依赖的是 t-1 时的社区标签。

优缺点

优点

  1、算法逻辑简单，时间复杂度低，接近线性复杂度，在超大规模网络下会有优异的性能，适合做baseline。
  2、无须定义优化函数，无须事先指定社区个数，算法会利用自身的网络结构来指导标签传播。

缺点

  1、雪崩效应：社区结果不稳定，随机性强。由于当邻居节点的社区标签权重相同时，会随机取一个。导致传播初期一个小的错误被不断放大，最终没有得到合适的结果。尤其是异步更新时，更新顺序的不同也会导致最终社区划分结果不同。

  举个例子，上图中展示了一次标签传播算法的流程。
  初始化阶段，每个节点都以自己作为社区标签。比如a的社区就是a，c的社区就是c。当进入传播阶段，节点c的邻居节点共4个：a，b，c，d。而社区标签也是4个：a，b，c，d，假设随机取了一个a。如果是异步更新，此时b，d，e三个节点的邻居节点中社区标签均存在2个a，所以他们都会立马更新成a。如果c当时随机选择的是b，那么d,e就会更新成b，从而导致b社区标签占优，而最终的社区划分也就成b了。

  2、震荡效应：社区结果来回震荡，不收敛。当传播方式处于同步更新的时候，尤其对于二分图或子图存在二分图的结构而言，极易发生。

  举个例子，上图中展示了一次二分图中标签传播算法的流程。
  在同步更新的时候，每个节点依赖的都是上一轮迭代的社区标签。当二分图左边都是a，右边都是b时，a社区的节点此时邻居节点都是b，b社区的节点此时邻居节点都是a，根据更新规则，此时a社区的节点将全部更新为b，b社区的节点将全部更新为a。此时算法无法收敛，使得整个网络处于震荡中。

算法实现

输入数据格式

  采用的是边表的数据格式，即数据共三列，分别是node_in、node_out、edge_weight。

python代码

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
import string


def loadData(filePath):
    f = open(filePath)
    node_dict = {}
    edge_list_dict = {}
    for line in f.readlines():
        lines = line.strip().split("\t")
        for i in range(2):
            if lines[i] not in node_dict:
                node_dict[lines[i]] = (lines[i])    # 每个节点的社区标签就是自己
                edge_list = []                   # 存放每个节点的所有邻居节点及边权重
                if len(lines) == 3:
                    edge_list.append(lines[1 - i] + ":" + lines[2])
                else:
                    edge_list.append(lines[1 - i] + ":" + "1")   # 无权图默认权重是1
                edge_list_dict[lines[i]] = edge_list
            else:
                edge_list = edge_list_dict[lines[i]]
                if len(lines) == 3:
                    edge_list.append(lines[1 - i] + ":" + lines[2])
                else:
                    edge_list.append(lines[1 - i] + ":" + "1")
                edge_list_dict[lines[i]] = edge_list
    return node_dict, edge_list_dict


def get_max_community_label(node_dict, adjacency_node_list):
    label_dict = {}
    for node in adjacency_node_list:
        node_id_weight = node.strip().split(":")
        node_id = node_id_weight[0]
        node_weight = int(node_id_weight[1])

        # 按照label为group维度，统计每个label的weight累加和
        if node_dict[node_id] not in label_dict:
            label_dict[node_dict[node_id]] = node_weight
        else:
            label_dict[node_dict[node_id]] += node_weight
    
    sort_list = sorted(label_dict.items(), key=lambda d: d[1], reverse=True) # 返回weight累加和最大的社区标签
    return sort_list[0][0]


def check(node_dict, edge_dict):
    for node in node_dict.keys():
        adjacency_node_list = edge_dict[node]   # 获取该节点的邻居节点
        node_label = node_dict[node]          # 获取该节点当前label
        label = get_max_community_label(node_dict, adjacency_node_list)   # 从邻居节点列表中选择weight累加和最大的label
        if node_label >= label:
            continue
        else:
            return 0    # 找到weight权重累加和更大的label
    return 1


def label_propagation(node_dict, edge_list_dict, iteration_max):
    t = 0
    while True:
        if t > iteration_max:
            break;
        # 收敛判定阶段
        if (check(node_dict, edge_list_dict) == 0):
            t = t + 1
            print ('iteration: ', t)
            # 每轮迭代都更新一遍所有节点的社区label
            for node in node_dict.keys():
                # adjacency_node_list存放该节点的所有邻居节点及边权重
                adjacency_node_list = edge_list_dict[node]
                # 传播阶段，将所有邻居节点最大的社区标签更新为自己的社区标签
                node_dict[node] = get_max_community_label(node_dict, adjacency_node_list)
        else:
            break
    return node_dict



if __name__ == '__main__':
    # 加载文件
    filePath = 'xx/xx.txt'
    
    print ("初始化阶段开始！")
    # node_dict表示每个节点归属社区的状态，key是node，value是社区标签。
    # edge_list表示每个节点的所有所有邻居节点及边权重，key是node,value是一个list,list中的每个item就是该node的一个邻居节点及边权重。
    node_dict, edge_list_dict = loadData(filePath)
    iteration_max = 1000 # 设置最大迭代次数
    print ("初始化阶段结束！")


    print ("标签传播算法开始！")
    node_dict = label_propagation(node_dict, edge_list_dict, iteration_max)
    print ("标签传播算法结束！")
    print ("最终的结果为：")
    print (node_dict)
复制代码

优化方向

初始化阶段改进

  人工标注或者采用算法提取一些紧密的子结构，确定好网络社区的雏形，再进行传播。

传播阶段改进

  根据具体的业务场景，仔细定义边权重edge_weight，点权重node_weight，优化标签传播的传播优先度，一个良好的权重定义可以隐式的划分网络结构，更有利于社区发现。

作者：大龙1993
链接：https://juejin.cn/post/6844904117115027464
来源：掘金
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。