Python实现社区发现算法-fast_unfolding算法可直接使用

‘‘‘
第一阶段称为Modularity Optimization，主要是将每个节点划分到与其邻接的节点所在的社区中，以使得模块度的值不断变大；
第二阶段称为Community Aggregation，主要是将第一步划分出来的社区聚合成为一个点，即根据上一步生成的社区结构重新构造网络。
重复以上的过程，直到网络中的结构不再改变为止。
因为要带权重所以读数据才那么慢？
‘‘‘
import numpy as np

class FastUnfolding:
    ‘‘‘
        从一个csv文件路径中创建一个图.
        path: 文件中包含 “node_from node_to“ edges （一对一行）
    ‘‘‘
    #classmethod 修饰符对应的函数不需要实例化，不需要 self 参数，
    # 但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等

    @classmethod
    def from_csv（cls data）:
        dataarray = np.asarray（data）
        nodes = {}
        edges = []
        for n in dataarray:
            nodes[n[0]] = 1
            nodes[n[1]] = 1
            w = 1
            if len（n） == 3:
                w = int（n[2]）
            edges.append（（（n[0] n[1]） w））
        # 用连续的点重编码图中的点
        nodes_ edges_d = in_order（nodes edges）
        return cls（nodes_ edges_）d

    ‘‘‘
        从一个txt文件路径中创建一个图.
        path: 文件中包含 “node_from node_to“ edges （一对一行）
    ‘‘‘
    @classmethod
    def from_file（cls path）:

        f = open（path ‘r‘）
        lines = f.readlines（）
        f.close（）
        nodes = {}
        edges = []
        for line in lines:
            n = line.split（）
            if not n:
                break
            nodes[n[0]] = 1#生成一个字典，记录原始图中出现的点
            nodes[n[1]] = 1
            w = 1
            if len（n） == 3:#有权重是权重，没权重是1
                w = int（n[2]）
            edges.append（（（n[0] n[1]） w））
        # 用连续的点重编码图中的点
        nodes_ edges_d = in_order（nodes edges）
        print（“%d nodes %d edges“ % （len（nodes_） len（edges_）））
        return cls（nodes_ edges_）d


    ‘‘‘
        从一个gml文件路径中创建一个图.

    ‘‘‘

    @classmethod
    def from_gml_file（cls path）:
        f = open（path ‘r‘）
        lines = f.readlines（）
        f.close（）
        nodes = {}
        edges = []
        current_edge = （-1 -1 1）
        # dic ={}
        in_edge = 0
        for line in lines:
            words = line.split（）
            if not words:
                break
            if words[0] == ‘id‘:
                # a = int（words[1]）
                nodes[int（words[1]）] = 1
            # if words[0] == ‘label‘:
            #     dic[words[1]] = a
            elif words[0] == ‘source‘:#当读到source的时候，开始刷新current_edge
                in_edge = 1
                current_edge = （int（words[1]） current_edge[1] current_edge[2]）
            elif words[0] == ‘target‘ and in_edge:
                current_edge = （current_edge[0] int（words[1]） current_edge[2]）
            elif words[0] == ‘weight‘ and in_edge:
                current_edge = （current_edge[0] current_edge[1] int（words[1]））
            elif words[0] == ‘]‘ and in_edge:
                edges.append（（（current_edge[0] current_edge[1]）current_edge[2]））
                current_edge = （-1 -1 1）
                in_edge = 0#读完一个边，添加到edges中，并刷新current_edge和in_edge
        nodes edgesd = in_order（nodes edges）