BGLL社区划分算法python+networkx包

算法来自论文：Fast unfolding of communities in large networks 是一种快速的非重叠的社团划分算法 使用说明，直接调用BGLL函数，参数传入Graph类型的变量就可以得到结果，返回值第一个是所返回的社区结果，第二个是所有节点对应的社区号。

# -*- coding: UTF-8 -*-
import networkx as nx
import time


def calculateQ（IN TOT m）:
    Q =IN/m-（（TOT/（2*m））**2）
    return Q



def phases_one（G）:
    ##用来存社区编号和其节点
    community_dict={}
    ##用来存节点所对应的社区编号
    community_node_in_dict={}
    ##用来保存边两头节点所在社区
    edge_dict={}
    ##存Tot和In
    Tot={}
    In={}

    ##初始化上述指标
    for node in G.nodes（）:
        community_dict[node]=[node]
        community_node_in_dict[node]=node
        #初始化Tot
        T=0.
        for nbrs in G.neighbors（node）:
            if node==nbrs:
                T += （2*G.get_edge_data（nbrs node）.values（）[0]）
            else:
                T+=G.get_edge_data（nbrsnode）.values（）[0]
        Tot[node]=T
        #初始化In
        if G.get_edge_data（nodenode）==None:
            In[node]=0.
        else:
            In[node]=G.get_edge_data（nodenode）.values（）[0]

    #初始化M
    M=0.0
    for edge in G.edges（）:
        M+=G.get_edge_data（*edge）.values（）[0]
        edge_dict[（edge[0]edge[1]）]=（community_node_in_dict[edge[0]]community_node_in_dict[edge[1]]）
    index=True
    ##一直遍历直到收敛
    while index==True:
        index=False
        ##遍历所有节点
        for node in G.nodes（）:
            ##保存节点之前所在社区
            old_community=community_node_in_dict[node]
            # 用来保存节点node的总权值
            ki = 0
            # 保存其所有邻居社区
            nbrs_community={}
            # 保存该节点移动到某社区所带来的In增益
            kiin_dict={}
            # 保存其离开自己所在社区的的In减少量
            kiout=0.
            # 目标社区
            max_community=-1
            max_detaQ=-1
            max_nbrs=-1
            # 临时保存edge_dict变化
            edge_dict_tmp={}
            for nbrs in G.neighbors（node）:
                weight=G.get_edge_data（nodenbrs）.values（）[0]
                if nbrs==node:
                    ki+=（2*weight）
                else:
                    ki+=weight
                current_community=community_node_in_dict[nbrs]
                if current_community==old_community:
                    kiout+=weight
                    continue

                if nbrs_community.has_key（current_community）:
                    kiin_dict[current_community]+=weight
                else :
                    nbrs_community[current_community]=current_community
                    kiin_dict[current_community]=weight
                    if G.has_edge（node node）:
                        kiin_dict[current_community] += G.get_edge_data（node node）.values（）[0]
            #计算它离开自己社区的detaQ
            detaQ1=calculateQ（In[old_community]-kioutTot[old_community]-kiM）-calculateQ（In[old_community]Tot[old_community]M）
            #计算将要加入的社区的detaQ
            for com in nbrs_community:
                detaQ2=calculateQ（In[com]+kiin_dict[com]Tot[com]+kiM）-calculateQ（In[com]Tot[com]M）
                Q=detaQ2+detaQ1
                if Q>max_detaQ and Q>0:
                    max_detaQ=Q
                    max_community=com

 属性            大小     日期    时间   名称
----------- ---------  ---------- -----  ----
     文件        7728  2017-08-10 10:16  BGLL.py