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

社区发现简介

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

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

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、同步更新：在第

次迭代中，每个节点依赖的都是邻居节点上一次迭代

时的社区标签。

2、异步更新：在第

次迭代中，每个节点依赖的是当前邻居节点的社区标签，若邻居节点进行了更新，则依赖的是

时的社区标签，若未进行更新，则依赖的是

时的社区标签。

优缺点

优点

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，优化标签传播的传播优先度，一个良好的权重定义可以隐式的划分网络结构，更有利于社区发现。