精华内容
下载资源
问答
  • Louvain
    千次阅读
    2020-12-24 12:24:26

    本发明涉及数据挖掘技术领域,尤其涉及一种基于Louvain算法的社区发现方法及一种基于Louvain算法的社区发现系统

    背景技术:

    随着信息化技术的发展,信息系统中保存着大量用户的信息特征,用户与用户之间也存在着某种关联性。用户的特征具有多维度,且多关联性。社区发现能帮助人们更有效地了解网络的结构特征,从而提供更有效、更具个性化的服务。

    当前,许多研究通过分析网络的结构来发现社区。其中,Blondel等人基于现实中的大规模网络的社区结构都具有层次性,提出了一种迭代的两阶段模块度最大化的快速算法(BGL算法)用于发现社区。该算法分为两步:第一步、通过社区之间局部交换节点使得社区划分的模块度最大化。第二步、将前一步网络划分产生的社区作为新的网络中的一个节点,节点之间边的权值为其代表的两个社区之间的边的权值之和。反复迭代以上两个步骤,直到模块度的大小不再可能增加。BGL算法所使用的模块度度量标准如下式所定义,该定义适用于加权网络:

    其中,Aij表示节点i和节点j之间的边的权重;ki=∑jAij表示与节点i相连的所有边的权值之和;ci表示节点i所在的(所属的)社区;δ函数δ(u,v)表示当u与v相等时为1,而其余情况下为0;表示网络中所有边的权值之和。

    然而,BGL算法没有涉及到网络节点的属性信息。而研究表明,在真实的在线社交网络中,节点的属性信息可以是判断的标准之一,在结构紧密的前提下,同一社区内的节点属性越相似越好。除此之外,虽然现有的很多聚类方法已将网络的结构和节点的属性特征(或称节点属性或节点属性信息)结合起来考虑(例如,通过对属性和结构进行加权的方法构造新的网络,并在新的网络上进行社区划分),但是这些聚类的结果往往存在结构上并不紧密或者不关联的社区,从而导致社区发现的结果不准确;而且,这些方法的时间复杂度较高,不适于处理大规模的数据。

    技术实现要素:

    本发明所要解决的技术问题在于,提供一种基于Louvain算法的社区发现方法及系统,可将网络中的每个节点当作社区,并针对社区的模块度和边权重分析,从而可以得到更加精准的社区发现。

    为了解决上述技术问题,本发明提供了一种基于Louvain算法的社区发现方法,包括:

    S1,初始化社区,把每个节点作为一个社区;

    S2,将每个节点依次分配到每个邻居节点所在社区以构建社区图形;

    S3,根据社区图形把社区看作一个节点,重新构建社区图形;

    S4,重复步骤S3,直到所有状态稳定,则输出结果。

    作为上述方案的改进,所述步骤S2包括:将每个节点,依次尝试分配到每个邻居节点所在社区;计算分配前与分配后的模块度变化量;提取模块度变化量的最大值;若模块度变化量的最大值大于0,则将节点分配到该社区,一直重复这个步骤,直到所有节点不再变化,形成社区图形。

    作为上述方案的改进,所述重新构建社区图形的方法包括:把社区内节点度数和,转化为新节点到自己的环路的权重;把社区间的边权重转化为新节点间的边权重;重复步骤S2。

    作为上述方案的改进,所述步骤S3之前还包括:压缩社区图形。

    作为上述方案的改进,通过Python压缩社区图形。

    相应地,本发明还提供了一种基于Louvain算法的社区发现系统,包括:初始化模块,用于初始化社区,把每个节点作为一个社区;第一构建模块,用于将每个节点依次分配到每个邻居节点所在社区以构建社区图形;第二构建模块,用于根据社区图形把社区看作一个节点,重新构建社区图形;输出模块,用于当所有状态稳定时,输出结果。

    作为上述方案的改进,所述第一构建模块包括:分配单元,用于将每个节点,依次尝试分配到每个邻居节点所在社区;计算单元,用于计算分配前与分配后的模块度变化量;提取单元,用于提取模块度变化量的最大值;图形单元,用于若模块度变化量的最大值大于0,则将节点分配到该社区,直到所有节点不再变化,形成社区图形。

    作为上述方案的改进,所述第二构建模块包括:第一转化单元,用于把社区内节点度数和,转化为新节点到自己的环路的权重;第二转化单元,把社区间的边权重转化为新节点间的边权重。

    作为上述方案的改进,所述基于Louvain算法的社区发现系统还包括压缩模块,用于压缩社区图形。

    作为上述方案的改进,所述压缩模块通过Python压缩社区图形。

    实施本发明,具有如下有益效果:

    本发明利用大数据中的聚类算法技术,实现复杂网络中的社区发现。将网络中的每个节点当作社区,并针对社区的模块度和边权重分析,从而可以得到更加精准的社区发现,具体地:

    1、本发明采用基于Louvain算法实现社区发现,针对社区中的节点进行模块度的关联分析;

    2、本发明采用两层计算。开始通过模块度变化量对每个节点进行社区划分,然后针对划分后形成的社区,做图形压缩,从而再次进行社区的模块度和边权重分析并进行社区划分,直到所有状态稳定,再输出结果,对社区的发现更加深入。

    3、由于节点具有随机性,本发明没有使用节点的特征向量对节点进行相似度判断,而是直接对节点进行向量及模块度的关联,更为准确。

    附图说明

    图1是社区节点示意图;

    图2是本发明基于Louvain算法的社区发现方法的第一实施例流程;

    图3是本发明基于Louvain算法的社区发现方法的第二实施例流程;

    图4是本发明基于Louvain算法的社区发现系统的第一实施例结构示意图;

    图5是本发明中第一构建模块的结构示意图;

    图6是本发明中第二构建模块的结构示意图;

    图7是本发明基于Louvain算法的社区发现系统的第二实施例结构示意图。

    具体实施方式

    为使本发明的目的、技术方案和优点更加清楚,下面将结合附图对本发明作进一步地详细描述。仅此声明,本发明在文中出现或即将出现的上、下、左、右、前、后、内、外等方位用词,仅以本发明的附图为基准,其并不是对本发明的具体限定。

    复杂网络是一个复杂系统的抽象,网络中的节点表示个体,边表示个体间的关系。社区结构是复杂网络中的一个普通特征,整个网络是由多个社区组成。社区发现(Community Detection)算法用来发现网络中的社区结构,也可以看作是一种聚类算法。该算法是一个复杂而有意义的过程,它对研究复杂网络特征具有重要作用。算法试图归纳各个节点为社区,使得同一个社区内节点连接紧密,而社区间连接比较稀疏(参见图1)。本发明选用基于模块度评估的Louvain算法实现社区发现过程。

    参见图2,图2显示了本发明一种基于Louvain算法的社区发现方法的第一实施例流程图,其包括:

    S101,初始化社区,把每个节点作为一个社区;

    S102,将每个节点依次分配到每个邻居节点所在社区以构建社区图形;

    具体地,所述步骤S102包括:

    (1)将每个节点,依次尝试分配到每个邻居节点所在社区;优选地,采用轮询方式进行分配。

    (2)计算分配前与分配后的模块度变化量;其中,分配前与分配后的模块度变化量是指分配前模块度与分配后模块度之差。

    (3)提取模块度变化量的最大值;

    (4)若模块度变化量的最大值大于0,则将节点分配到该社区,一直重复这个步骤,直到所有节点不再变化,形成社区图形。

    具体地,与模块度变化量相关统计指标如下:

    节点的度:与节点相连的边的权和(无权图则=边数),对于有向图,度可以分为入度及出度,分别对应以该节点为终点的权和与起点的权和,入度+出度=度

    节点聚类系数:节点与其邻居实际存在的边数与可能存在的边数之比聚类系数越大,节点与周围连接越密切。

    图的平均聚类系数:节点聚类系数平均值,越大则图形中的点的关系越密切,更容易成团。

    最短路径长度:图中指定节点有任意路径相连,经过路径最短的长度为最短路径长度。

    模块度:评估一个社区网络划分好坏的度量方法,它的物理含义是社区内节点的连边数与随机情况下的边数之差:其中Aij为边ij的权重,ki=∑j,iAij表示节点i的度,ci表示i所属社区,表示图的总度数。以上社区划分方法基于模块度计算。

    S103,根据社区图形把社区看作一个节点,重新构建社区图形;

    具体地,所述重新构建社区图形的方法包括:

    (1)把社区内节点度数和,转化为新节点到自己的环路的权重;

    (2)把社区间的边权重转化为新节点间的边权重;

    (3)重复步骤S102。

    S104,重复步骤S103,直到所有状态稳定,则输出结果。

    社区的稳定状态,是指社区号不变的状态。一开始,大家都有一个社区号,自成一个社区,然后就迭代。如果跟旁边结合,模块度会下降,就结合,然后结合在一起的就记共同一个社区号。继续迭代,同样的,一个点,如果要去旁边的社区,就必须脱离现在的社区,如果去旁边的社区模块度比脱离现在社区的模块度还要大,那就不脱离了,那就稳定下来了。当所有点都稳定了,迭代结束。社区号不变,就是一个稳定的状态。

    参见图3,图3显示了本发明一种基于Louvain算法的社区发现方法的第二实施例流程图,其包括:

    S201,初始化社区,把每个节点作为一个社区;

    S202,将每个节点依次分配到每个邻居节点所在社区以构建社区图形;

    具体地,所述步骤S202包括:

    (1)将每个节点,依次尝试分配到每个邻居节点所在社区;

    (2)计算分配前与分配后的模块度变化量;其中,分配前与分配后的模块度变化量是指分配前模块度与分配后模块度之差。

    (3)提取模块度变化量的最大值;

    (4)若模块度变化量的最大值大于0,则将节点分配到该社区,一直重复这个步骤,直到所有节点不再变化,形成社区图形。

    S203,压缩社区图形。

    通过Python方式实现降维及类聚,从而实现社区图形的压缩。

    S204,根据社区图形把社区看作一个节点,重新构建社区图形;

    具体地,所述重新构建社区图形的方法包括:

    (1)把社区内节点度数和,转化为新节点到自己的环路的权重;

    (2)把社区间的边权重转化为新节点间的边权重;

    (3)重复步骤S202。

    S205,重复步骤S204,直到所有状态稳定,则输出结果。

    因此,本发明利用大数据中的聚类算法技术,实现复杂网络中的社区发现。将网络中的每个节点当作社区,并针对社区的模块度和边权重分析,从而可以得到更加精准的社区发现。相应地,通过社区发现,在教育领域中,可以发现学校内全部学生的社区关系,为学校内学生的大数据分析及服务提供帮助,如可以提供好友发现,更加精准的为学生推荐好友;图书推荐,可以利用社区中的阅读风格或者阅读内容,进行图书推荐;课程推荐,促进学生个性化学习;职业推荐,根据社区关系推进类似的工作,增加职业推荐的智能性等。

    参见图4,图4显示了本发明基于Louvain算法的社区发现系统100的第一实施例,其包括:

    初始化模块1,用于初始化社区,把每个节点作为一个社区;

    第一构建模块2,用于将每个节点依次分配到每个邻居节点所在社区以构建社区图形;

    第二构建模块3,用于根据社区图形把社区看作一个节点,重新构建社区图形;

    输出模块4,用于当所有状态稳定时,输出结果。

    如图5所示,所述第一构建模块2包括:

    分配单元21,用于将每个节点,依次尝试分配到每个邻居节点所在社区;优选地,采用轮询方式进行分配。

    计算单元22,用于计算分配前与分配后的模块度变化量;其中,分配前与分配后的模块度变化量是指分配前模块度与分配后模块度之差。

    提取单元23,用于提取模块度变化量的最大值;

    图形单元24,用于若模块度变化量的最大值大于0,则将节点分配到该社区,直到所有节点不再变化,形成社区图形。

    如图6所示,所述第二构建模块3包括:

    第一转化单元31,用于把社区内节点度数和,转化为新节点到自己的环路的权重;

    第二转化单元32,把社区间的边权重转化为新节点间的边权重。

    参见图7,图7显示了本发明基于Louvain算法的社区发现系统的第二实施例,与图4所示的第一实施例不同的是,本实施例中所述基于Louvain算法的社区发现系统还包括压缩模块5,所述压缩模块5用于压缩社区图形。优选地,压缩模块5通过Python方式实现降维及类聚,从而实现社区图形的压缩。

    由上可知,本发明具有以下有益效果:

    1、本发明采用基于Louvain算法实现社区发现,针对社区中的节点进行模块度的关联分析;

    2、本发明采用两层计算。开始通过模块度变化量对每个节点进行社区划分,然后针对划分后形成的社区,做图形压缩,从而再次进行社区的模块度和边权重分析并进行社区划分,直到所有状态稳定,再输出结果,对社区的发现更加深入。

    3、由于节点具有随机性,本发明没有使用节点的特征向量对节点进行相似度判断,而是直接对节点进行向量及模块度的关联,更为准确。

    以上所述是本发明的优选实施方式,应当指出,对于本技术领域的普通技术人员来说,在不脱离本发明原理的前提下,还可以做出若干改进和润饰,这些改进和润饰也视为本发明的保护范围。

    更多相关内容
  • 使用python实现社区分类的louvain算法
  • 广义 Louvain 优化(用于图分区问题) 该代码实现了一个通用的 Louvain 优化算法,可用于优化多个目标函数,例如文章中讨论的那些: Michael T. Schaub、Jean-Charles Delvenne、Renaud Lambiotte、Mauricio ...
  • dga-graphx ...Louvain分布式社区检测是这项工作的并行版本: Fast unfolding of communities in large networks, Vincent D Blondel, Jean-Loup Guillaume, Renaud Lambiotte, Etienne Lefebvre, Journal
  • ngraph.louvain 给定一个图实例,可以使用检测聚类。 用法 // Let's say you have an ngraph instance: var graph = createAGraph ( ) ; // To detect clusters: var detectClusters = require ( 'ngraph.louvain'...
  • 笔迹学社区Louvain 用于社区检测的实现与一起使用。参考MEJ Newman,《网络中的模块化和社区结构》,Proc。 Natl。 学院科学美国,卷。 103,No 23,2006年,第23页。 8577–8582 Newman,MEJ«网络中的社区检测:...
  • 改进的Louvain社团划分算法
  • Louvain方法的Python实现,用于在大型网络中查找社区。 该方法首次发表在:,Vincent D Blondel,Jean-Loup Guillaume,Renaud Lambiotte,Etienne Lefebvre,《统计力学杂志:理论与实验》 2008年第10期,P1000 ...
  • 鲁汶社区检测正在安装要从源代码构建和安装,请运行python setup.py install 您也可以从pip安装pip install python-louvain pip上的软件包名称是python-louvain但已作为community导入到python中。 有关此模块的更多...
  • Louvain-算法 Louvain算法的实现 该算法的详细信息可以在论文中找到:“大型网络中社区的快速展开,Vincent D Blondel、Jean-Loup Guillaume、Renaud Lambiotte、Etienne Lefebvre,Journal of Statistical ...
  • 用于大图中社区检测的 Louvain 方法的实现。 还提供使用模块化以外的其他质量功能的版本。
  • Louvain算法matlab实现

    2017-03-26 16:16:49
  • LOUVAIN——社交网络挖掘之大规模网络的社区发现算法,matlab实现版本,输入n*n矩阵,输出划分结果及q值
  • matlab如何敲代码################################################ ...该代码实现了通用的Louvain优化算法,该算法可用于优化多个目标函数,例如,本文中讨论的目标函数: Michael T. Schaub,Jean-C
  • 发明了非常流行的“ Louvain方法”用于社区检测[1]。 该库使用C#实现其算法。 此外,使用plinq对库进行并行化以最大程度地提高速度。 在测试项目的帮助下说明了该库的使用。 该库还允许构造完整的树状图。 [1] ...
  • Louvain java实现

    2019-01-18 15:50:55
    社区发现算法Louvain,运算速度非常快,只需要计算相邻结点社区变换Q的变换。贪婪优化
  • “在MATLAB中实现的用于社区检测的通用Louvain方法,” (2011-2019年)。 内容: 该软件包包含主要的genlouvain.m文件,该文件调用许多实现为mex函数的子例程。 mex文件的源代码包含在“ MEX_SRC”目录中。 专用...
  • python库,解压后可用。 资源全名:louvain-0.6.0-cp36-cp36m-win_amd64.whl
  • louvain经典复杂网络社团结构检测程序
  • louvain-original-master.zip,louvain-original-master,community.cpp,Makefile,main_community.cpp,graph.h,main_hierarchy.cpp,main_random.cpp,README.md,graph.cpp,graph.bin,main_convert.cpp,community.h,...
  • Clustering-by-Louvain-Algorithm-main.zip,Clustering-by-Louvain-Algorithm-main,README.md,louvain.ipynb
  • 资源来自pypi官网。 资源全名:louvain-0.6.2-cp36-cp36m-macosx_10_9_x86_64.whl
  • Community_BGLL_Louvain.rar,Community_BGLL_Louvain,cluster_jl_cpp.m,cluster_jl_orientT_cpp.m,jl_mnew.mexglx,cluster_jl_orient_cpp.m,cluster_jl_orientT.m,cluster_jl.m,jl_clust.mexglx,jl_clust.cpp,A2.mat...
  • 用Python包实现对图(Graph) 的社区性质的分析,判断图是否可划分不同社区等等
  • 社团识别中的一个经典的算法,鲁文算法,和newman快速算法一样用于社团识别
  • Louvain method

    2016-07-21 19:50:44
    Louvain method
  • Louvain算法实现

    千次阅读 2020-04-14 00:02:32
    Louvain是一种无监督算法(执行前不需要输入社区数量或社区大小),分为两个阶段:模块化优化和社区聚集[1]。 第一步完成后,接下来是第二步。 两者都将执行,直到网络中没有更多更改并实现最大的模块化为止。 是...

    谢谢平台提供-http://bjbsair.com/2020-04-13/tech-info/65263.html

    社区查找找的算法

    Louvain是一种无监督算法(执行前不需要输入社区数量或社区大小),分为两个阶段:模块化优化和社区聚集[1]。 第一步完成后,接下来是第二步。 两者都将执行,直到网络中没有更多更改并实现最大的模块化为止。

    Louvain算法

    是邻接矩阵representing的权重的邻接矩阵条目,= ∑是节点the的程度,是其所属的族,如果,函数(,)为1。 =,否则为0。 = 1 ∑ 2是图形中所有边缘的权重之和。

    模块化优化

    Louvain将在模块化优化中随机排序网络中的所有节点。 然后,它将逐个删除并在不同的社区中插入每个节点直到验证模块化(输入参数)没有显着增加:

    Louvain算法

    设为inside中链接的权重之和,为中节点的所有链接的权重之和,incident入射节点的所有链接的权重之和,,权重之和 从节点到社区中的节点的链接的总和是图中所有边的权重的总和。

    进一步提高算法性能的一种方法是简化(2)并计算∆而不是完整表达式:

    Louvain算法

    尽管需要为每个试验社区计算,和Σ,但k/(2m)特定于要分析的节点。 这样,仅当在模块化优化中考虑其他节点时才重新计算后一个表达式。

    社区聚集

    完成第一步后,属于同一社区的所有节点都将合并为一个巨型节点。 连接巨型节点的链接是先前连接相同社区的节点的总和。 此步骤还生成自循环,该自循环是给定社区内所有链接的总和,然后分解为一个节点(图1)。

    Louvain算法

    Figure 1 Sequence of steps followed by Louvain algorithm. Adapted from [1].

    因此,通过在第一遍之后对社区的社区进行聚类,它就固有地考虑了网络中是否存在分层组织。 算法1中的伪代码。

    Louvain算法

    参考

    [1] V. D. Blondl,J.-L。 Guillaume,R。Lambiotte和E. Lefebvre,“大型网络中社区的快速发展”,J。Stat。 机甲。 (2008)P10008,第 2008年12月12日。
    谢谢平台提供-http://bjbsair.com/2020-04-13/tech-info/65263.html

    社区查找找的算法

    Louvain是一种无监督算法(执行前不需要输入社区数量或社区大小),分为两个阶段:模块化优化和社区聚集[1]。 第一步完成后,接下来是第二步。 两者都将执行,直到网络中没有更多更改并实现最大的模块化为止。

    Louvain算法

    是邻接矩阵representing的权重的邻接矩阵条目,= ∑是节点the的程度,是其所属的族,如果,函数(,)为1。 =,否则为0。 = 1 ∑ 2是图形中所有边缘的权重之和。

    模块化优化

    Louvain将在模块化优化中随机排序网络中的所有节点。 然后,它将逐个删除并在不同的社区中插入每个节点直到验证模块化(输入参数)没有显着增加:

    Louvain算法

    设为inside中链接的权重之和,为中节点的所有链接的权重之和,incident入射节点的所有链接的权重之和,,权重之和 从节点到社区中的节点的链接的总和是图中所有边的权重的总和。

    进一步提高算法性能的一种方法是简化(2)并计算∆而不是完整表达式:

    Louvain算法

    尽管需要为每个试验社区计算,和Σ,但k/(2m)特定于要分析的节点。 这样,仅当在模块化优化中考虑其他节点时才重新计算后一个表达式。

    社区聚集

    完成第一步后,属于同一社区的所有节点都将合并为一个巨型节点。 连接巨型节点的链接是先前连接相同社区的节点的总和。 此步骤还生成自循环,该自循环是给定社区内所有链接的总和,然后分解为一个节点(图1)。

    Louvain算法

    Figure 1 Sequence of steps followed by Louvain algorithm. Adapted from [1].

    因此,通过在第一遍之后对社区的社区进行聚类,它就固有地考虑了网络中是否存在分层组织。 算法1中的伪代码。

    Louvain算法

    参考

    [1] V. D. Blondl,J.-L。 Guillaume,R。Lambiotte和E. Lefebvre,“大型网络中社区的快速发展”,J。Stat。 机甲。 (2008)P10008,第 2008年12月12日。
    谢谢平台提供-http://bjbsair.com/2020-04-13/tech-info/65263.html

    社区查找找的算法

    Louvain是一种无监督算法(执行前不需要输入社区数量或社区大小),分为两个阶段:模块化优化和社区聚集[1]。 第一步完成后,接下来是第二步。 两者都将执行,直到网络中没有更多更改并实现最大的模块化为止。

    Louvain算法

    是邻接矩阵representing的权重的邻接矩阵条目,= ∑是节点the的程度,是其所属的族,如果,函数(,)为1。 =,否则为0。 = 1 ∑ 2是图形中所有边缘的权重之和。

    模块化优化

    Louvain将在模块化优化中随机排序网络中的所有节点。 然后,它将逐个删除并在不同的社区中插入每个节点直到验证模块化(输入参数)没有显着增加:

    Louvain算法

    设为inside中链接的权重之和,为中节点的所有链接的权重之和,incident入射节点的所有链接的权重之和,,权重之和 从节点到社区中的节点的链接的总和是图中所有边的权重的总和。

    进一步提高算法性能的一种方法是简化(2)并计算∆而不是完整表达式:

    Louvain算法

    尽管需要为每个试验社区计算,和Σ,但k/(2m)特定于要分析的节点。 这样,仅当在模块化优化中考虑其他节点时才重新计算后一个表达式。

    社区聚集

    完成第一步后,属于同一社区的所有节点都将合并为一个巨型节点。 连接巨型节点的链接是先前连接相同社区的节点的总和。 此步骤还生成自循环,该自循环是给定社区内所有链接的总和,然后分解为一个节点(图1)。

    Louvain算法

    Figure 1 Sequence of steps followed by Louvain algorithm. Adapted from [1].

    因此,通过在第一遍之后对社区的社区进行聚类,它就固有地考虑了网络中是否存在分层组织。 算法1中的伪代码。

    Louvain算法

    参考

    [1] V. D. Blondl,J.-L。 Guillaume,R。Lambiotte和E. Lefebvre,“大型网络中社区的快速发展”,J。Stat。 机甲。 (2008)P10008,第 2008年12月12日。
    谢谢平台提供-http://bjbsair.com/2020-04-13/tech-info/65263.html

    社区查找找的算法

    Louvain是一种无监督算法(执行前不需要输入社区数量或社区大小),分为两个阶段:模块化优化和社区聚集[1]。 第一步完成后,接下来是第二步。 两者都将执行,直到网络中没有更多更改并实现最大的模块化为止。

    Louvain算法

    是邻接矩阵representing的权重的邻接矩阵条目,= ∑是节点the的程度,是其所属的族,如果,函数(,)为1。 =,否则为0。 = 1 ∑ 2是图形中所有边缘的权重之和。

    模块化优化

    Louvain将在模块化优化中随机排序网络中的所有节点。 然后,它将逐个删除并在不同的社区中插入每个节点直到验证模块化(输入参数)没有显着增加:

    Louvain算法

    设为inside中链接的权重之和,为中节点的所有链接的权重之和,incident入射节点的所有链接的权重之和,,权重之和 从节点到社区中的节点的链接的总和是图中所有边的权重的总和。

    进一步提高算法性能的一种方法是简化(2)并计算∆而不是完整表达式:

    Louvain算法

    尽管需要为每个试验社区计算,和Σ,但k/(2m)特定于要分析的节点。 这样,仅当在模块化优化中考虑其他节点时才重新计算后一个表达式。

    社区聚集

    完成第一步后,属于同一社区的所有节点都将合并为一个巨型节点。 连接巨型节点的链接是先前连接相同社区的节点的总和。 此步骤还生成自循环,该自循环是给定社区内所有链接的总和,然后分解为一个节点(图1)。

    Louvain算法

    Figure 1 Sequence of steps followed by Louvain algorithm. Adapted from [1].

    因此,通过在第一遍之后对社区的社区进行聚类,它就固有地考虑了网络中是否存在分层组织。 算法1中的伪代码。

    Louvain算法

    参考

    [1] V. D. Blondl,J.-L。 Guillaume,R。Lambiotte和E. Lefebvre,“大型网络中社区的快速发展”,J。Stat。 机甲。 (2008)P10008,第 2008年12月12日。
    谢谢平台提供-http://bjbsair.com/2020-04-13/tech-info/65263.html

    社区查找找的算法

    Louvain是一种无监督算法(执行前不需要输入社区数量或社区大小),分为两个阶段:模块化优化和社区聚集[1]。 第一步完成后,接下来是第二步。 两者都将执行,直到网络中没有更多更改并实现最大的模块化为止。

    Louvain算法

    是邻接矩阵representing的权重的邻接矩阵条目,= ∑是节点the的程度,是其所属的族,如果,函数(,)为1。 =,否则为0。 = 1 ∑ 2是图形中所有边缘的权重之和。

    模块化优化

    Louvain将在模块化优化中随机排序网络中的所有节点。 然后,它将逐个删除并在不同的社区中插入每个节点直到验证模块化(输入参数)没有显着增加:

    Louvain算法

    设为inside中链接的权重之和,为中节点的所有链接的权重之和,incident入射节点的所有链接的权重之和,,权重之和 从节点到社区中的节点的链接的总和是图中所有边的权重的总和。

    进一步提高算法性能的一种方法是简化(2)并计算∆而不是完整表达式:

    Louvain算法

    尽管需要为每个试验社区计算,和Σ,但k/(2m)特定于要分析的节点。 这样,仅当在模块化优化中考虑其他节点时才重新计算后一个表达式。

    社区聚集

    完成第一步后,属于同一社区的所有节点都将合并为一个巨型节点。 连接巨型节点的链接是先前连接相同社区的节点的总和。 此步骤还生成自循环,该自循环是给定社区内所有链接的总和,然后分解为一个节点(图1)。

    Louvain算法

    Figure 1 Sequence of steps followed by Louvain algorithm. Adapted from [1].

    因此,通过在第一遍之后对社区的社区进行聚类,它就固有地考虑了网络中是否存在分层组织。 算法1中的伪代码。

    Louvain算法

    参考

    [1] V. D. Blondl,J.-L。 Guillaume,R。Lambiotte和E. Lefebvre,“大型网络中社区的快速发展”,J。Stat。 机甲。 (2008)P10008,第 2008年12月12日。
    谢谢平台提供-http://bjbsair.com/2020-04-13/tech-info/65263.html

    社区查找找的算法

    Louvain是一种无监督算法(执行前不需要输入社区数量或社区大小),分为两个阶段:模块化优化和社区聚集[1]。 第一步完成后,接下来是第二步。 两者都将执行,直到网络中没有更多更改并实现最大的模块化为止。

    Louvain算法

    是邻接矩阵representing的权重的邻接矩阵条目,= ∑是节点the的程度,是其所属的族,如果,函数(,)为1。 =,否则为0。 = 1 ∑ 2是图形中所有边缘的权重之和。

    模块化优化

    Louvain将在模块化优化中随机排序网络中的所有节点。 然后,它将逐个删除并在不同的社区中插入每个节点直到验证模块化(输入参数)没有显着增加:

    Louvain算法

    设为inside中链接的权重之和,为中节点的所有链接的权重之和,incident入射节点的所有链接的权重之和,,权重之和 从节点到社区中的节点的链接的总和是图中所有边的权重的总和。

    进一步提高算法性能的一种方法是简化(2)并计算∆而不是完整表达式:

    Louvain算法

    尽管需要为每个试验社区计算,和Σ,但k/(2m)特定于要分析的节点。 这样,仅当在模块化优化中考虑其他节点时才重新计算后一个表达式。

    社区聚集

    完成第一步后,属于同一社区的所有节点都将合并为一个巨型节点。 连接巨型节点的链接是先前连接相同社区的节点的总和。 此步骤还生成自循环,该自循环是给定社区内所有链接的总和,然后分解为一个节点(图1)。

    Louvain算法

    Figure 1 Sequence of steps followed by Louvain algorithm. Adapted from [1].

    因此,通过在第一遍之后对社区的社区进行聚类,它就固有地考虑了网络中是否存在分层组织。 算法1中的伪代码。

    Louvain算法

    参考

    [1] V. D. Blondl,J.-L。 Guillaume,R。Lambiotte和E. Lefebvre,“大型网络中社区的快速发展”,J。Stat。 机甲。 (2008)P10008,第 2008年12月12日。
    谢谢平台提供-http://bjbsair.com/2020-04-13/tech-info/65263.html

    社区查找找的算法

    Louvain是一种无监督算法(执行前不需要输入社区数量或社区大小),分为两个阶段:模块化优化和社区聚集[1]。 第一步完成后,接下来是第二步。 两者都将执行,直到网络中没有更多更改并实现最大的模块化为止。

    Louvain算法

    是邻接矩阵representing的权重的邻接矩阵条目,= ∑是节点the的程度,是其所属的族,如果,函数(,)为1。 =,否则为0。 = 1 ∑ 2是图形中所有边缘的权重之和。

    模块化优化

    Louvain将在模块化优化中随机排序网络中的所有节点。 然后,它将逐个删除并在不同的社区中插入每个节点直到验证模块化(输入参数)没有显着增加:

    Louvain算法

    设为inside中链接的权重之和,为中节点的所有链接的权重之和,incident入射节点的所有链接的权重之和,,权重之和 从节点到社区中的节点的链接的总和是图中所有边的权重的总和。

    进一步提高算法性能的一种方法是简化(2)并计算∆而不是完整表达式:

    Louvain算法

    尽管需要为每个试验社区计算,和Σ,但k/(2m)特定于要分析的节点。 这样,仅当在模块化优化中考虑其他节点时才重新计算后一个表达式。

    社区聚集

    完成第一步后,属于同一社区的所有节点都将合并为一个巨型节点。 连接巨型节点的链接是先前连接相同社区的节点的总和。 此步骤还生成自循环,该自循环是给定社区内所有链接的总和,然后分解为一个节点(图1)。

    Louvain算法

    Figure 1 Sequence of steps followed by Louvain algorithm. Adapted from [1].

    因此,通过在第一遍之后对社区的社区进行聚类,它就固有地考虑了网络中是否存在分层组织。 算法1中的伪代码。

    Louvain算法

    参考

    [1] V. D. Blondl,J.-L。 Guillaume,R。Lambiotte和E. Lefebvre,“大型网络中社区的快速发展”,J。Stat。 机甲。 (2008)P10008,第 2008年12月12日。
    谢谢平台提供-http://bjbsair.com/2020-04-13/tech-info/65263.html

    社区查找找的算法

    Louvain是一种无监督算法(执行前不需要输入社区数量或社区大小),分为两个阶段:模块化优化和社区聚集[1]。 第一步完成后,接下来是第二步。 两者都将执行,直到网络中没有更多更改并实现最大的模块化为止。

    Louvain算法

    是邻接矩阵representing的权重的邻接矩阵条目,= ∑是节点the的程度,是其所属的族,如果,函数(,)为1。 =,否则为0。 = 1 ∑ 2是图形中所有边缘的权重之和。

    模块化优化

    Louvain将在模块化优化中随机排序网络中的所有节点。 然后,它将逐个删除并在不同的社区中插入每个节点直到验证模块化(输入参数)没有显着增加:

    Louvain算法

    设为inside中链接的权重之和,为中节点的所有链接的权重之和,incident入射节点的所有链接的权重之和,,权重之和 从节点到社区中的节点的链接的总和是图中所有边的权重的总和。

    进一步提高算法性能的一种方法是简化(2)并计算∆而不是完整表达式:

    Louvain算法

    尽管需要为每个试验社区计算,和Σ,但k/(2m)特定于要分析的节点。 这样,仅当在模块化优化中考虑其他节点时才重新计算后一个表达式。

    社区聚集

    完成第一步后,属于同一社区的所有节点都将合并为一个巨型节点。 连接巨型节点的链接是先前连接相同社区的节点的总和。 此步骤还生成自循环,该自循环是给定社区内所有链接的总和,然后分解为一个节点(图1)。

    Louvain算法

    Figure 1 Sequence of steps followed by Louvain algorithm. Adapted from [1].

    因此,通过在第一遍之后对社区的社区进行聚类,它就固有地考虑了网络中是否存在分层组织。 算法1中的伪代码。

    Louvain算法

    参考

    [1] V. D. Blondl,J.-L。 Guillaume,R。Lambiotte和E. Lefebvre,“大型网络中社区的快速发展”,J。Stat。 机甲。 (2008)P10008,第 2008年12月12日。
    谢谢平台提供-http://bjbsair.com/2020-04-13/tech-info/65263.html

    社区查找找的算法

    Louvain是一种无监督算法(执行前不需要输入社区数量或社区大小),分为两个阶段:模块化优化和社区聚集[1]。 第一步完成后,接下来是第二步。 两者都将执行,直到网络中没有更多更改并实现最大的模块化为止。

    Louvain算法

    是邻接矩阵representing的权重的邻接矩阵条目,= ∑是节点the的程度,是其所属的族,如果,函数(,)为1。 =,否则为0。 = 1 ∑ 2是图形中所有边缘的权重之和。

    模块化优化

    Louvain将在模块化优化中随机排序网络中的所有节点。 然后,它将逐个删除并在不同的社区中插入每个节点直到验证模块化(输入参数)没有显着增加:

    Louvain算法

    设为inside中链接的权重之和,为中节点的所有链接的权重之和,incident入射节点的所有链接的权重之和,,权重之和 从节点到社区中的节点的链接的总和是图中所有边的权重的总和。

    进一步提高算法性能的一种方法是简化(2)并计算∆而不是完整表达式:

    Louvain算法

    尽管需要为每个试验社区计算,和Σ,但k/(2m)特定于要分析的节点。 这样,仅当在模块化优化中考虑其他节点时才重新计算后一个表达式。

    社区聚集

    完成第一步后,属于同一社区的所有节点都将合并为一个巨型节点。 连接巨型节点的链接是先前连接相同社区的节点的总和。 此步骤还生成自循环,该自循环是给定社区内所有链接的总和,然后分解为一个节点(图1)。

    Louvain算法

    Figure 1 Sequence of steps followed by Louvain algorithm. Adapted from [1].

    因此,通过在第一遍之后对社区的社区进行聚类,它就固有地考虑了网络中是否存在分层组织。 算法1中的伪代码。

    Louvain算法

    参考

    [1] V. D. Blondl,J.-L。 Guillaume,R。Lambiotte和E. Lefebvre,“大型网络中社区的快速发展”,J。Stat。 机甲。 (2008)P10008,第 2008年12月12日。
    谢谢平台提供-http://bjbsair.com/2020-04-13/tech-info/65263.html

    社区查找找的算法

    Louvain是一种无监督算法(执行前不需要输入社区数量或社区大小),分为两个阶段:模块化优化和社区聚集[1]。 第一步完成后,接下来是第二步。 两者都将执行,直到网络中没有更多更改并实现最大的模块化为止。

    Louvain算法

    是邻接矩阵representing的权重的邻接矩阵条目,= ∑是节点the的程度,是其所属的族,如果,函数(,)为1。 =,否则为0。 = 1 ∑ 2是图形中所有边缘的权重之和。

    模块化优化

    Louvain将在模块化优化中随机排序网络中的所有节点。 然后,它将逐个删除并在不同的社区中插入每个节点直到验证模块化(输入参数)没有显着增加:

    Louvain算法

    设为inside中链接的权重之和,为中节点的所有链接的权重之和,incident入射节点的所有链接的权重之和,,权重之和 从节点到社区中的节点的链接的总和是图中所有边的权重的总和。

    进一步提高算法性能的一种方法是简化(2)并计算∆而不是完整表达式:

    Louvain算法

    尽管需要为每个试验社区计算,和Σ,但k/(2m)特定于要分析的节点。 这样,仅当在模块化优化中考虑其他节点时才重新计算后一个表达式。

    社区聚集

    完成第一步后,属于同一社区的所有节点都将合并为一个巨型节点。 连接巨型节点的链接是先前连接相同社区的节点的总和。 此步骤还生成自循环,该自循环是给定社区内所有链接的总和,然后分解为一个节点(图1)。

    Louvain算法

    Figure 1 Sequence of steps followed by Louvain algorithm. Adapted from [1].

    因此,通过在第一遍之后对社区的社区进行聚类,它就固有地考虑了网络中是否存在分层组织。 算法1中的伪代码。

    Louvain算法

    参考

    [1] V. D. Blondl,J.-L。 Guillaume,R。Lambiotte和E. Lefebvre,“大型网络中社区的快速发展”,J。Stat。 机甲。 (2008)P10008,第 2008年12月12日。

    展开全文
  • Louvain算法Matlab版本

    2016-07-24 19:28:53
    Louvain算法Matlab版本
  • 社区发现算法——Louvain 算法

    千次阅读 多人点赞 2022-02-08 16:07:40
    Louvain 算法 原始论文为:《Fast unfolding of communities in large networks》。 所以又被称为Fast unfolding算法。 Louvain算法是一种基于模块度的社区发现算法。其基本思想是网络中节点尝试遍历所有邻居的社区...

    Louvain 算法

    原始论文为:《Fast unfolding of communities in large networks》。

    所以又被称为Fast unfolding算法。

    Louvain算法是一种基于模块度的社区发现算法。其基本思想是网络中节点尝试遍历所有邻居的社区标签,并选择最大化模块度增量的社区标签。在最大化模块度之后,每个社区看成一个新的节点,重复直到模块度不再增大。

    首先复习下模块度:

    在这里插入图片描述
    这里引入了权重方便扩展到有权图,但其实对于无权图,可以看做所有边权重为1,这时候就等于用节点的度计算,用度理解一样。

    算法详述:

    1. 模块度优化阶段:每个节点将自己作为自己社区标签。每个节点遍历自己的所有邻居节点,尝试将自己的社区标签更新成邻居节点的社区标签,选择模块度增量最大(贪婪思想)的社区标签,直到所有节点都不能通过改变社区标签来增加模块度

      也就是说,首先将每个节点指定到唯一的一个社区,然后按顺序将节点在这些社区间进行移动。怎么移动呢?假设有一节点 i ,它有三个邻居节点 j1, j2, j3,我们分别尝试将节点 i 移动到 j1, j2, j3 所在的社区,并计算相应的 modularity 变化值ΔQ,哪个变化值最大就将节点 i 移动到相应的社区中去(当然,这里我们要求最大的 modularity 变化值要为正,如果变化值均为负,则节点 i 保持不动)。按照这个方法反复迭代,直到网络中任何节点的移动都不能再改善总的 modularity 值为止。

      移动到一个社区C中所获得的模块化Q增益可以很容易地计算出来:在这里插入图片描述

      = 1 2 m ( k i , i n − Σ t o t k i m ) \frac{1}{2m}(k_{i,in}-{Σ_{tot}ki\over m}) 2m1(ki,inmΣtotki)

      其中 Σ i n Σ_{in} Σin是在社区C内的链路的权重总和(权重为1时就等于度数),如果是初始情况,即一个节点作为一个社区时,它就为这个节点自己到自己的连接,这时候仍然需要起点加weight,终点加weight(即使这个时候起点和终点为同一节点,对于无环图权为0)

      Σ t o t Σ_{tot} Σtot是关联到C中的节点的链路上的权重的总和

      ki是关联到节点i的链路的权重的总和

      ki,in是从节点i连接到C中的节点的链路的总和

      m是网络中的所有链路的权重的总和

    2. 网络凝聚阶段:每个社区合并为一个新的超级节点,超级节点的边权重为原始社区内所有节点的边权重之和,形成一个新的网络

      将第一个阶段得到的社区视为新的“节点”(一个社区对应一个),重新构造子图,两个新“节点”之间边的权值为相应两个社区之间各边的权值的总和。如这个图所示,如果第一个阶段得到的社区有以下三个,那么第二个阶段的任务就是将这三个社分别看一个新的节点,然后将任意两个新节点之间的所有连线的权重相加得到的和,作为这两个新节点之间的连线的权重。

    在这里插入图片描述

    上述两个阶段迭代进行,直到模块度不再增大。
      下图很好的描述了这两个阶段。第一次迭代,经过模块度优化阶段,总的 modularity 值不再改变,算法将16个节点划分成4个社区;在网络凝聚阶段,4个社区被凝聚成4个超级节点,并重新更新了边权重。之后就进入第二次迭代中。

    在这里插入图片描述

    算法通过引入分步迭代的思想(类比EM算法),避免陷入贪婪思想导致的局部最优。

    算法流程:

    1、初始时将每个顶点当作一个社区,社区个数与顶点个数相同。
    2、依次将每个顶点与之相邻顶点合并在一起,计算它们最大的模块度增益是否大于0,如果大于0,就将该结点放入模块度增量最大的相邻结点所在社区。
    3、迭代第二步,直至算法稳定,即所有顶点所属社区不再变化。
    4、将各个社区所有节点压缩成为一个结点,社区内点的权重转化为新结点环的权重,社区间权重转化为新结点边的权重。
    5、重复步骤1-3,直至算法稳定。

    可以看到Louvain 算法与FN算法非常相似,我觉得最大的不同时Louvain 算法在凝聚阶段是将整个社区看做一个新的超节点来看,而FN算法是以社区的观点来凝聚。

    算法优缺点

    优点

    1、时间复杂度低,适合大规模的网络。
      2、社区划分结果稳定,有具体指标能够评估社区划分好坏。
      3、消除了模块化分辨率的限制。由于模块度是全局指标,最大化的时候很难发现小型的社区,很容易将小型社区合并。而算法第一次迭代是以单个节点作为社区的粒度,规避了这种问题。
      4、天然自带层次化的社区划分结果,每一次迭代的社区划分结果都可以保留下来,作为社区划分的中间结果,可供选择。

    缺点

    1、社区过大,不能及时收敛。如果我们将模块度类比为损失函数的话,Fast Unfolding在模块度优化阶段采用的贪婪思想很容易将整个社区划分“过拟合”。因为Fast Unfolding是针对点遍历,很容易将一些外围的点加入到原本紧凑的社区中,导致一些错误的合并。这种划分有时候在局部视角是优的,但是全局视角下会变成劣的。
      
      Python代码如下:

    class Louvain:
        def __init__(self, G):
            self._G = G
            self._m = 0  # 边数量 图会凝聚动态变化
            self._cid_vertices = {}  # 需维护的关于社区的信息(社区编号,其中包含的结点编号的集合)
            self._vid_vertex = {}  # 需维护的关于结点的信息(结点编号,相应的Vertex实例)
            for vid in self._G.keys():
                # 刚开始每个点作为一个社区
                self._cid_vertices[vid] = {vid}
                # 刚开始社区编号就是节点编号
                self._vid_vertex[vid] = Vertex(vid, vid, {vid})
                # 计算边数  每两个点维护一条边
                self._m += sum([1 for neighbor in self._G[vid].keys() if neighbor > vid])
    
        # 模块度优化阶段
        def first_stage(self):
            mod_inc = False  # 用于判断算法是否可终止
            visit_sequence = self._G.keys()
            # 随机访问
            random.shuffle(list(visit_sequence))
            while True:
                can_stop = True  # 第一阶段是否可终止
                # 遍历所有节点
                for v_vid in visit_sequence:
                    # 获得节点的社区编号
                    v_cid = self._vid_vertex[v_vid]._cid
                    # k_v节点的权重(度数)  内部与外部边权重之和
                    k_v = sum(self._G[v_vid].values()) + self._vid_vertex[v_vid]._kin
                    # 存储模块度增益大于0的社区编号
                    cid_Q = {}
                    # 遍历节点的邻居
                    for w_vid in self._G[v_vid].keys():
                        # 获得该邻居的社区编号
                        w_cid = self._vid_vertex[w_vid]._cid
                        if w_cid in cid_Q:
                            continue
                        else:
                            # tot是关联到社区C中的节点的链路上的权重的总和
                            tot = sum(
                                [sum(self._G[k].values()) + self._vid_vertex[k]._kin for k in self._cid_vertices[w_cid]])
                            if w_cid == v_cid:
                                tot -= k_v
                            # k_v_in是从节点i连接到C中的节点的链路的总和
                            k_v_in = sum([v for k, v in self._G[v_vid].items() if k in self._cid_vertices[w_cid]])
                            delta_Q = k_v_in - k_v * tot / self._m  # 由于只需要知道delta_Q的正负,所以少乘了1/(2*self._m)
                            cid_Q[w_cid] = delta_Q
    
                    # 取得最大增益的编号
                    cid, max_delta_Q = sorted(cid_Q.items(), key=lambda item: item[1], reverse=True)[0]
                    if max_delta_Q > 0.0 and cid != v_cid:
                        # 让该节点的社区编号变为取得最大增益邻居节点的编号
                        self._vid_vertex[v_vid]._cid = cid
                        # 在该社区编号下添加该节点
                        self._cid_vertices[cid].add(v_vid)
                        # 以前的社区中去除该节点
                        self._cid_vertices[v_cid].remove(v_vid)
                        # 模块度还能增加 继续迭代
                        can_stop = False
                        mod_inc = True
                if can_stop:
                    break
            return mod_inc
    
        # 网络凝聚阶段
        def second_stage(self):
            cid_vertices = {}
            vid_vertex = {}
            # 遍历社区和社区内的节点
            for cid, vertices in self._cid_vertices.items():
                if len(vertices) == 0:
                    continue
                new_vertex = Vertex(cid, cid, set())
                # 将该社区内的所有点看做一个点
                for vid in vertices:
                    new_vertex._nodes.update(self._vid_vertex[vid]._nodes)
                    new_vertex._kin += self._vid_vertex[vid]._kin
                    # k,v为邻居和它们之间边的权重 计算kin社区内部总权重 这里遍历vid的每一个在社区内的邻居   因为边被两点共享后面还会计算  所以权重/2
                    for k, v in self._G[vid].items():
                        if k in vertices:
                            new_vertex._kin += v / 2.0
                # 新的社区与节点编号
                cid_vertices[cid] = {cid}
                vid_vertex[cid] = new_vertex
    
            G = collections.defaultdict(dict)
            # 遍历现在不为空的社区编号 求社区之间边的权重
            for cid1, vertices1 in self._cid_vertices.items():
                if len(vertices1) == 0:
                    continue
                for cid2, vertices2 in self._cid_vertices.items():
                    # 找到cid后另一个不为空的社区
                    if cid2 <= cid1 or len(vertices2) == 0:
                        continue
                    edge_weight = 0.0
                    # 遍历 cid1社区中的点
                    for vid in vertices1:
                        # 遍历该点在社区2的邻居已经之间边的权重(即两个社区之间边的总权重  将多条边看做一条边)
                        for k, v in self._G[vid].items():
                            if k in vertices2:
                                edge_weight += v
                    if edge_weight != 0:
                        G[cid1][cid2] = edge_weight
                        G[cid2][cid1] = edge_weight
            # 更新社区和点 每个社区看做一个点
            self._cid_vertices = cid_vertices
            self._vid_vertex = vid_vertex
            self._G = G
    
        def get_communities(self):
            communities = []
            for vertices in self._cid_vertices.values():
                if len(vertices) != 0:
                    c = set()
                    for vid in vertices:
                        c.update(self._vid_vertex[vid]._nodes)
                    communities.append(list(c))
            return communities
    
        def execute(self):
            iter_time = 1
            while True:
                iter_time += 1
                # 反复迭代,直到网络中任何节点的移动都不能再改善总的 modularity 值为止
                mod_inc = self.first_stage()
                if mod_inc:
                    self.second_stage()
                else:
                    break
            return self.get_communities()
    

    参考结果如下:

    社区 1 [0, 1, 2, 3, 4, 5, 6, 7, 9, 10, 11, 12, 13, 16, 17, 19, 21]
    社区 2 [32, 33, 8, 14, 15, 18, 20, 22, 26, 29, 30]
    社区 3 [23, 24, 25, 27, 28, 31]
    0.388560157790927
    算法执行时间0.002000093460083008
    在这里插入图片描述

    展开全文
  • lin_bisection >>> com = list(kernighan_lin_bisection(G)) >>> print('社区数量', len(com)) 社区数量 2 >>> draw_spring(G, com) 效果: 三、Louvain社区发现算法 Louvain算法是一种基于模块度的社区发现算法,其...

    一、社区发现概述

    根据图论,加权网络表示为𝐺=(𝑉,𝐸,𝑊),未加权网络表示为𝐺=(𝑉,𝐸),其中𝑉和𝐸表示节点和边的集合,𝑊分别表示𝐸相应的权重,以连接的强度或容量为单位。在未加权的网络中,𝑊被视为1。子图𝑔⊆𝐺是保留原始网络结构的图划分。子图的划分遵循预定义(pre-define)的规则,不同的规则可能会导致不同形式的子图。

    社区是代表真实社会现象的一种子图。换句话说,社区是一组具有共同特征的人或对象。

    社区是网络中节点密集连接的子图,稀疏连接的节点沟通了不同的社区,使用𝐶={𝐶1,𝐶2,⋯,𝐶𝑘}表示将网络𝐺划分为𝑘个社区的集合,其中𝐶𝑖是社区划分的第𝑖个社区。

    节点𝑣属于社区𝐶𝑖满足如下条件:社区内部每个节点的内部度大于其外部度。

    因此,社区发现的目标是发现网络𝐺中的社区𝐶。

    技术交流

    目前开通了技术交流,群友已超过3000人,添加时最好的备注方式为:来源+兴趣方向,方便找到志同道合的朋友,资料、代码获取也可以加入

    方式1、添加微信号:dkl88191,备注:来自CSDN
    方式2、微信搜索公众号:Python学习与数据挖掘,后台回复:加群

    二、KL社区发现算法

    K-L(Kernighan-Lin)算法是一种将已知网络划分为已知大小的两个社区的二分方法,它是一种贪婪算法,它的主要思想是为网络划分定义了一个函数增益Q,Q表示的是社区内部的边数与社区之间的边数之差,根据这个方法找出使增益函数Q的值成为最大值的划分社区的方法。

    1、实现策略

    该算法的具体策略是,将社区结构中的结点移动到其他的社区结构中或者交换不同社区结构中的结点。从初始解开始搜索,直到从当前的解出发找不到更优的候选解,然后停止。

    首先将整个网络的节点随机的或根据网络的现有信息分为两个部分,在两个社团之间考虑所有可能的节点对,试探交换每对节点并计算交换前后的ΔQ,ΔQ=Q交换后-Q交换前,记录ΔQ最大的交换节点对,并将这两个节点互换,记录此时的Q值。

    规定每个节点只能交换一次,重复这个过程直至网络中的所有节点都被交换一次为止。需要注意的是不能在Q值发生下降时就停止,因为Q值不是单调增加的,既使某一步交换会使Q值有所下降,但其后的一步交换可能会出现一个更大的Q值。在所有的节点都交换过之后,对应Q值最大的社团结构即被认为是该网络的理想社团结构。

    图片

    地址:http://eda.ee.ucla.edu/EE201A-04Spring/kl.pdf

    2、代码实现:

    >>> def draw_spring(G, com):
    ...     pos = nx.spring_layout(G)  # 节点的布局为spring型
    ...     NodeId = list(G.nodes())
    ...     node_size = [G.degree(i) ** 1.2 * 90 for i in NodeId]  # 节点大小
    ...     plt.figure(figsize=(8, 6))  # 图片大小
    ...     nx.draw(G, pos, with_labels=True, node_size=node_size, node_color='w', node_shape='.')
    ...     color_list = ['pink', 'orange', 'r', 'g', 'b', 'y', 'm', 'gray', 'black', 'c', 'brown']
    ...     for i in range(len(com)):
    ...         nx.draw_networkx_nodes(G, pos, nodelist=com[i], node_color=color_list[i])
    ...     plt.show()
    ... 
    >>> import networkx as nx
    >>> import matplotlib.pyplot as plt
    >>> G = nx.karate_club_graph()
    >>> com = list(kernighan_lin_bisection(G))
    >>> import matplotlib.pyplot as plt
    >>> from networkx.algorithms.community import kernighan_lin_bisection
    >>> com = list(kernighan_lin_bisection(G))
    >>> print('社区数量', len(com))
    社区数量 2
    >>> draw_spring(G, com)
    

    效果:图片

    三、Louvain社区发现算法

    Louvain算法是一种基于模块度的社区发现算法,其基本思想是网络中节点尝试遍历所有邻居的社区标签,并选择最大化模块度增量的社区标签,在最大化模块度之后,每个社区看成一个新的节点,重复直到模块度不再增大。

    图片地址:https://arxiv.org/pdf/0803.0476.pdf

    1、实现策略

    具体实现上,如下图所示,步骤如下:

    1)初始时将每个顶点当作一个社区,社区个数与顶点个数相同。

    2)依次将每个顶点与之相邻顶点合并在一起,计算它们最大的模块度增益是否大于0,如果大于0,就将该结点放入模块度增量最大的相邻结点所在社区。

    其中,模块度用来衡量一个社区的质量,公式第一如下。

    图片

    3)迭代第二步,直至算法稳定,即所有顶点所属社区不再变化。

    4)将各个社区所有节点压缩成为一个结点,社区内点的权重转化为新结点环的权重,社区间权重转化为新****结点边的权重。

    5)重复步骤1-3,直至算法稳定。

    图片

    2、代码实现:

    >>> import networkx as nx
    >>> import matplotlib.pyplot as plt
    >>> G = nx.karate_club_graph()
    >>> com = list(kernighan_lin_bisection(G))
    >>> import matplotlib.pyplot as plt
    >>> from networkx.algorithms.community import louvain_communities
    >>> com = list(louvain_communities(G))
    >>> print('社区数量', len(com))
    社区数量 4
    >>> draw_spring(G, com)
    

    3、效果:

    图片

    四、标签传播社区发现算法

    LPA全称label propagation algorithm,即标签传递算法,是一种图聚类算法,常用在社交网络中,用于发现潜在的社区,是一种基于标签传播的局部社区划分。对于网络中的每一个节点,在初始阶段,Label Propagation算法对于每一个节点都会初始化一个唯一的一个标签。

    每一次迭代都会根据与自己相连的节点所属的标签改变自己的标签,更改的原则是选择与其相连的节点中所属标签最多的社区标签为自己的社区标签,这就是标签传播的含义,随着社区标签不断传播。最终,连接紧密的节点将有共同的标签

    1、实现策略

    LPA认为每个结点的标签应该和其大多数邻居的标签相同,将一个节点的邻居节点的标签中数量最多的标签作为该节点自身的标签(bagging思想)。给每个节点添加标签(label)以代表它所属的社区,并通过标签的“传播”形成同一个“社区”内部拥有同一个“标签”。

    标签传播算法(LPA)的做法如下:

    第一步: 为所有节点指定一个唯一的标签;

    第二步: 逐轮刷新所有节点的标签,直到达到收敛要求为止。对于每一轮刷新,节点标签刷新的规则如下:

    对于某一个节点,考察其所有邻居节点的标签,并进行统计,将出现个数最多的那个标签赋给当前节点。当个数最多的标签不唯一 时,随机选一个。

    2、代码实现:

    >>> import networkx as nx
    >>> import matplotlib.pyplot as plt
    >>> G = nx.karate_club_graph()
    >>> com = list(kernighan_lin_bisection(G))
    >>> import matplotlib.pyplot as plt
    >>> from networkx.algorithms.community import label_propagation_communities
    >>> com = list(label_propagation_communities(G))
    >>> print('社区数量', len(com))
    社区数量 3
    >>> draw_spring(G, com)
    

    3、效果

    图片

    五、greedy_modularity社区算法

    1、实现策略

    贪心模块度社区算法,是一种用于检测社区结构的分层聚集算法,它在具有n个顶点和m条边的网络上的运行时间是O(mdlogn),其中d是描述社区结构的树状图的深度。

    图片

    地址:https://arxiv.org/pdf/cond-mat/0408187v2.pdf

    2、代码实现:

    >>> import networkx as nx
    >>> import matplotlib.pyplot as plt
    >>> G = nx.karate_club_graph()
    >>> com = list(kernighan_lin_bisection(G))
    >>> import matplotlib.pyplot as plt
    >>> from networkx.algorithms.community import greedy_modularity_communities
    >>> com = list(greedy_modularity_communities(G))
    >>> print('社区数量', len(com))
    社区数量 3
    >>> draw_spring(G, com)
    

    3、效果:

    图片

    参考文献

    1、https://icode9.com/content-1-1321350.html
    2、https://blog.csdn.net/qq_16543881/article/details/122825957
    3、https://blog.csdn.net/qq_16543881/article/details/122781642

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,112
精华内容 444
关键字:

Louvain

友情链接: Python-2.zip