重叠社区发现-LFM算法

#coding=utf-8
from numpy import *
#文件读取
def LoadAdjacentMatrixData(filename,vertices):
Adjmartrix = [[0 for col in range(vertices)] for row in range(vertices)]
file_object = open(filename, 'r')
for x, line in enumerate(file_object):
line=line.strip()
t_list = line.split('\t')
for y in range(len(t_list)):
Adjmartrix[x][y] = int(t_list[y])
#Adjmartrix = mat(Adjmartrix)
return Adjmartrix
#获取队列
def Degree_Sorting(Adjmartrix,vertices):
degree_s = [[i,0] for i in range(vertices)]
neighbours = [[] for i in range(vertices)]
sums = 0
for i in range(vertices):
for j in range(vertices):
if Adjmartrix[i][j] == 1:
degree_s[i][1] += 1
sums += 1
neighbours[i].append(j)
#degree_s = sorted(degree_s, key=lambda x: x[1], reverse=True)
return degree_s,neighbours,sums/2
#获取graph的所有邻居节点
def get_allneighbours(coms,neighbours):
ne = []
for each in coms:
for eachne in neighbours[each]:
if eachne not in ne and eachne not in coms:
ne.append(eachne)
return ne
#获取所有graph邻居加入后的F值列表
def get_allfitness(A,coms,neighbours,Func='F'):
nel = get_allneighbours(coms,neighbours)
#print 'coms',coms,'neigh',nel
nelf = []
if nel:
if Func == 'Q':
s,v = get_sumver(A,coms)
fib = Modulartiy(A,coms,s,v)
else:
fib = get_Fitness(A, coms, neighbours)
for eachne in nel:
coms.add(eachne)
if Func == 'Q':
s,v = get_sumver(A,coms)
fia = Modulartiy(A,coms,s,v)
else:
fia = get_Fitness(A, coms, neighbours)
fi = fia - fib
#print 'coms',coms,fi
nelf.append(fi)
coms.remove(eachne)
return nel,nelf
#清洗graph内部F小于0的点（返回F值列表）
def get_infitness(A,coms,neighbours,Func='F'):
if Func == 'Q':
s,v = get_sumver(A,coms)
fia = Modulartiy(A,coms,s,v)
else:
fia = get_Fitness(A, coms, neighbours)
for each in coms:
coms.remove(each)
if Func == 'Q':
s,v = get_sumver(A,coms)
fib = Modulartiy(A,coms,s,v)
else:
fib = get_Fitness(A, coms, neighbours)
fi = fia - fib
coms.add(each)
if fi < 0:
return each
return -1
#迭代过程
def Propagate(A,coms,neighbours,Func='F'):
nel, nelf = get_allfitness(A,coms,neighbours)
#stops when the nodes all have negative fitness
if max(nelf) >= 0:
t = nel[nelf.index(max(nelf))]
coms.add(t)
#print 'r',coms
while(1):
negative = get_infitness(A,coms,neighbours)
if negative != -1:
coms.remove(negative)
return Propagate(A,coms,neighbours)
else:
return Propagate(A,coms,neighbours)
else:
return coms
#获取自然子图结构，重叠节点
def get_naturalcoms(A, neighbours,vertices,Func='F'):
nodes = [i for i in range(vertices)]
graph = {}
gnums = 0
while(1):
a = nodes[random.randint(len(nodes))]
graph[gnums] = {a}
print 'before:','graphid',gnums,',seed',list(graph[gnums])
graph[gnums] = Propagate(A,graph[gnums],neighbours,Func)
print 'after:',list(graph[gnums])
for node in graph[gnums]:
if node in nodes:
nodes.remove(node)
if len(nodes) == 0:
return graph
gnums += 1
return graph
#获取graph的边数和节点数
def get_sumver(A,coms):
s = 0
v = len(coms)
for i in coms:
for j in coms:
if Adjmartrix[i][j] == 1:
s += 1
return s/2,v
#Q函数
def Modulartiy(A, coms, sums,vertices):
Q = 0.0
for eachc in coms:
li = 0
for eachp in coms[eachc]:
for eachq in coms[eachc]:
li += A[eachp][eachq]
li /= 2
di = 0
for eachp in coms[eachc]:
for eachq in range(vertices):
di += A[eachp][eachq]
Q = Q + (li - (di * di) /(sums*4))
Q = Q / float(sums)
return Q
#F函数
def get_Fitness(A, coms, neighbours, alpha=1):
#获得内部度数
kin = 0
for eachp in coms:
for eachq in coms:
kin += A[eachp][eachq]
#获得外部度数
kout = 0
#只算边数，没考虑连接的外部节点数
for eachp in coms:
for each in neighbours[eachp]:
if each not in coms:
kout += 1
fitness = pow((kin + kout),alpha)
fitness = kin / float(fitness)
return fitness
#主函数
if __name__ == '__main__':
#节点个数,V
vertices = [34,115,105,62]
txtlist = ['karate.txt','football.txt','books.txt','dolphins.txt']
#vertices = [64,128,256,512]
#txtlist = ['RN1.txt','RN2.txt','RN3.txt','RN4.txt']
testv = [1,2,3,4,5]
#testv = [i+1 for i in range(34)]
for i in range(len(txtlist)):
print txtlist[i],vertices[i]
A = LoadAdjacentMatrixData(txtlist[i],vertices[i])
degree_s, neighbours, sums = Degree_Sorting(A, vertices[i])
graph = get_naturalcoms(A,neighbours,vertices[i],Func='Q')
#获得重叠节点
prenode = {}
for p in graph:
for q in graph:
if p != q:
if graph[p]&graph[q]:
prenode[str(p)+'_'+str(q)] = graph[p] & graph[q]
#获得分区结果
print '子图结构',graph
coms = {}
for eg in graph:
coms[eg] = list(graph[eg])
print 'Q=',Modulartiy(A,coms,sums,vertices[i])
print

算法名称：复杂网络中重叠及层次社区发现算法LFM（改）
算法输入：无向无权图邻接矩阵AdjacentMatrix，节点个数VerticeNum，各节点邻居集合Neighbor
算法输出：存储节点标签的分类数组graph

//初始化节点队列和标记数组
For i <- 0 to VerticeNum Do
nodes[i] <- i
hindex[i] <- 0
/*
pr = get_PR(neighbours, vertices, dtype=1)//pr 为不同方式获得的PR评分队列
*/
while (nodes) Do
//1>随机选择一个未扩散节点种子节点
seed = nodes[random.randint(len(nodes))]
/*
2>选择未扩散点中度数最大的节点作为种子
seed = get_seedbydegree(nodes, Neighbor, hindex)
3>PageRank方式选择种子
seed = get_seedbyPR(nodes, pr, hindex)
*/
comm = Propagate(AdjacentMatrix,seed,Neighbor,Func)//Func为评价函数：原LFM中f函数/Q函数
graph.add(comm)
nodes.remove(comm)

Propagate(A, coms, neighbours, Func):
nelf = get_allfitness(A,coms,neighbours,Func)//获取当前子图所有邻居加入后的F值列表
//当所有节点的Func为负值时停止
If max(nelf) >= 0
coms.add(argmax(nelf))
while (True) Do
//去除当前子图内部Func为负的点
negative = get_infitness(A,coms,neighbours,Func)
If negative:
coms.remove(negative)
return Propagate(A,coms,neighbours,Func)
Else:
return Propagate(A,coms,neighbours,Func)
Else:
Return coms

//dtype： 1:Wi = E(Wj/DWj)   2:Wi = (E(Wj))/DWi   3: wi = E(Wj/(EWj)*Wj)
//说明：  E:求和  Wi:节点i的pr值 Wj:节点i的邻居的pr值 DWi:节点i的度数
get_PR( neighbours, vertices, dtype=1):
//初始化pr队列为节点度数
For i <- 0 to VerticeNum Do
pr[i] <- len(neighbours[i])
If dtype == 1
For i <- 0 to VerticeNum Do
If neighbours[i]
For en in neighbours[each] Do
pr[i] += pr[en]/len(neighbours[en])
Else If dtype == 2:
For i <- 0 to VerticeNum Do
If neighbours[i]
For en in neighbours[each] Do
pr[i] += pr[en]
pr[i] = pr[i]/len(neighbours[i])
Else If dtype == 3
For i <- 0 to VerticeNum Do
If neighbours[i]
For en in neighbours[each] Do
tw += pr[en]
tp += pr[en]**2
pr[i] = tw/tp
Return pr