精华内容
参与话题
问答
  • 社区发现

    千次阅读 2012-09-29 11:26:34
    社区要满足两个条件:一是社区的成员有共同的话题和爱好;二是社区的成员之间的联系相比和社区外的联系要紧密。 通过用户的搜索情况可以找到有相同爱好的人,这些人组成候选社区成员。比如用户搜索“NBA”,这个...

    社区要满足两个条件:一是社区的成员有共同的话题和爱好;二是社区的成员之间的联系相比和社区外的联系要紧密。

    通过用户的搜索情况可以找到有相同爱好的人,这些人组成候选社区成员。比如用户搜索“NBA”,这个用户就是候选的NBA社区成员。

    通过一定的算法计算这些成员间的紧密程度,大于一定阀值的成员共同组成了NBA社区。算法有HITS,类似于搜索引擎的链接分析,每个人都有一个H值和A值,迭代计算。也可以用聚类的算法,每个成员可以表示为一个向量,向量取值为1标识和另一个成员有联系,取0标识没有联系,通过聚类可以发现社区。这种方式还可以发现多个NBA社区。

    展开全文
  • 虚拟社区中的社区发现算法,苗蕊,刘鲁,从虚拟社区中发现隐含的子社区对于理解用户间合作和交流的模式,挖掘不同用户的兴趣,促进知识共享具有十分重要的意义。本文在Lat
  • 社区发现算法之——Louvain

    万次阅读 多人点赞 2018-10-25 09:13:39
    1、什么是社区 ...社区发现算法有很多,例如LPA,HANP,SLPA以及我们今天的主人公——Louvain。不同的算法划分社区的效果不尽相同。那么,如何评价这些算法孰优孰劣呢? 用模块度modularity来衡量。模...

    1、什么是社区

    如果一张图是对一片区域的描述的话,我们将这张图划分为很多个子图。当子图之内满足关联性尽可能大,而子图之间关联性尽可能低时,这样的子图我们可以称之为一个社区。

    2、社区发现算法及评价标准

    社区发现算法有很多,例如LPA,HANP,SLPA以及我们今天的主人公——Louvain。不同的算法划分社区的效果不尽相同。那么,如何评价这些算法孰优孰劣呢?
    用模块度modularity来衡量。模块度定义如下:模块度是评估一个社区网络划分好坏的度量方法,它的物理含义是社区内节点的连边数与随机情况下的边数只差,它的取值范围是 [−1/2,1)。可以简单地理解为社区内部所有边权重和减去与社区相连的边权重和。
    在这里插入图片描述

    Louvain算法

    一种基于模块度的图算法模型,与普通的基于模块度和模块度增益不同的是,该算法速度很快,而且对一些点多边少的图,进行聚类效果特别明显。
    算法流程:
    1、初始时将每个顶点当作一个社区,社区个数与顶点个数相同。
    2、依次将每个顶点与之相邻顶点合并在一起,计算它们的模块度增益是否大于0,如果大于0,就将该结点放入该相邻结点所在社区。
    3、迭代第二步,直至算法稳定,即所有顶点所属社区不再变化。
    4、将各个社区所有节点压缩成为一个结点,社区内点的权重转化为新结点环的权重,社区间权重转化为新结点边的权重。
    5、重复步骤1-3,直至算法稳定。

    # coding=utf-8
    import collections
    import random
    
    def load_graph(path):
        G = collections.defaultdict(dict)
        with open(path) as text:
            for line in text:
                vertices = line.strip().split()
                v_i = int(vertices[0])
                v_j = int(vertices[1])
                w = float(vertices[2])
                G[v_i][v_j] = w
                G[v_j][v_i] = w
        return G
    
    class Vertex():
        def __init__(self, vid, cid, nodes, k_in=0):
            self._vid = vid
            self._cid = cid
            self._nodes = nodes
            self._kin = k_in  # 结点内部的边的权重
    
    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] = set([vid])
                self._vid_vertex[vid] = Vertex(vid, vid, set([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 = sum(self._G[v_vid].values()) + self._vid_vertex[v_vid]._kin
                    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 = 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 = 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
                    for k, v in self._G[vid].items():
                        if k in vertices:
                            new_vertex._kin += v / 2.0
                cid_vertices[cid] = set([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():
                    if cid2 <= cid1 or len(vertices2) == 0:
                        continue
                    edge_weight = 0.0
                    for vid in vertices1:
                        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(c)
            return communities
    
        def execute(self):
            iter_time = 1
            while True:
                iter_time += 1
                mod_inc = self.first_stage()
                if mod_inc:
                    self.second_stage()
                else:
                    break
            return self.get_communities()
    
    if __name__ == '__main__':
        G = load_graph(r'C:\\Users\\程勇\\Desktop\\similarity.txt')
        algorithm = Louvain(G)
        communities = algorithm.execute()
        # 按照社区大小从大到小排序输出
        communities = sorted(communities, key=lambda b: -len(b)) # 按社区大小排序
        count = 0
        for communitie in communities:
            count += 1
            print("社区", count, " ", communitie)
        
    
    

    测试用例文件如图:
    在这里插入图片描述
    这是部分测试用例的截图,一行的前两个数是顶点编号,第三个数是权重。按照每个社区大小顺序从大到小打印:
    在这里插入图片描述
    \quad需要测试文件的话在评论区留下你的邮箱哦,求关注~

    展开全文
  • 社区发现图法

    2019-10-31 09:57:26
    社区发现图法社区发现算法思路GN算法 社区发现算法思路 社区划分问题大多基于这样一个假设:同一社区内部的节点连接较为紧密,社区之间的节点连接较为稀疏。因此,社区发现本质上就是网络中结构紧密的节点的聚类...

    社区发现算法思路


    社区划分问题大多基于这样一个假设:同一社区内部的节点连接较为紧密,社区之间的节点连接较为稀疏。因此,社区发现本质上就是网络中结构紧密的节点的聚类。

    从这个角度来说,这跟聚类算法一样,社区划分问题主要有两种思路:

           (1)凝聚方法(agglomerative method):添加边
           (2)分裂方法(divisive method):移除边
    

    另一方面,我们也可以认为同一个社区内的节点,之所以能够聚集在一起,是因为它们有相似性。因此只要我们能够将一个节点很好地表示,成为一个向量,那么同样可以用相似性大法来寻找社区聚集,不过这点上需要向量对节点的描述足够好和足够完备。

    GN算法据说是社区发现领域的第一个算法,或者说它开启了这个领域的研究。下面我们来分别介绍这个领域及其算法是如何演化的。

    GN算法

    1. 计算每一条边的边介数
    2. 删除边界数最大的边;
    3. 重新计算网络中剩下的边的边阶数;
    4. 重复(3)和(4)步骤,直到网络中的任一顶点作为一个社区为止。
        
      GN算法的R分析代码
    // An highlighted block
    > library("igraph")
    > karate  <-  graph.famous("Zachary")
    > ebc <- edge.betweenness.community(karate)
    > ebc
    Graph community structure calculated with the edge betweenness algorithm
    Number of communities (best split): 5 
    Modularity (best split): 0.4012985 
    Membership vector:
     [1] 1 1 2 1 3 3 3 1 4 5 3 1 1 1 4 4 3 1 4 1 4 1 4 4 2 2 4 2 2 4 4 2 4 4
    > modularity(ebc)
    [1] 0.4012985
    > membership(ebc)
     [1] 1 1 2 1 3 3 3 1 4 5 3 1 1 1 4 4 3 1 4 1 4 1 4 4 2 2 4 2 2 4 4 2 4 4
    > plot(ebc,karate)
    
    展开全文
  • 社区发现算法⼯工作简介 社区发现算法的发展、简介 • 我的社区发现算法相关⼯工作
  • 动态社区发现的研究现状进行研究和综述并进行分析。首先,基于复杂网络的研究背景,提出了通用的动态社区发现研究框架。接着,形式化表示动态社区发现的相关定义,并从网络层面和节点层面对动态社区演化进行详细分析...
  • 社区发现算法

    热门讨论 2013-07-16 18:07:46
    基于相似度的社区发现分裂算法,包括GML文件的读取,相似度计算等,有实例文件可进行实验。
  • 模糊谱聚类重叠社区发现算法OverlappingCommunityDiscoveryAlgorithmBasedonFuzzySpectralClustering【摘要】摘要:为克服传统重叠社区发现算法产生局部最优解的缺陷,提出一种新的基于模糊谱聚类的重叠社区发现算法...

    模糊谱聚类重叠社区发现算法

    Overlapping

    Community

    Discovery

    Algorithm

    Based

    on

    Fuzzy

    Spectral

    Clustering

    【摘

    要】

    :

    为克服传统重叠社区发现算法产生局部最优解的缺陷,提出一

    种新的基于模糊谱聚类的重叠社区发现算法。用局部连接相似度度量构造原始

    样本数据集的相似度矩阵,并采用谱方法将原样本嵌入到一个低维空间。在这

    个空间上,构造模糊相似矩阵,采用模糊聚类划分社区,检测并合并冗余社区。

    试验结果表明,该算法能够有效地提高重叠社区划分的质量。

    【期刊名称】

    自动化仪表

    【年

    (

    ),

    期】

    2016(037)003

    【总页数】

    4

    【关键词】

    关键词

    :

    模糊谱聚类

    模糊理论

    谱方法

    重叠社区

    相似度矩阵

    冗余社区

    二乘法

    第一作者闫晓鹏

    (1990

    )

    ,女,现为江西师范大学软件工程专业在读硕士研究

    ;

    主要从事本体论和语义

    Web

    、数据挖掘、社会网络分析方面的研究。

    0

    引言

    早期的社区发现研究是针对非重叠社区,认为网络可以被分割成若干个互不相

    连的社区,每个节点只能属于唯一的社区。然而,在实际的社交网络中,存在

    一些节点同时隶属于不同的社区,且这些节点在社区间的信息传播和演变中起

    着重要的中介或过滤的作用,能够衔接各个社区。为此,研究者们陆续提出一

    :

    (clique

    percolation

    method

    CPM)

    1

    2

    ;

    :

    展开全文
  • 社区发现算法LPA

    2020-10-22 18:57:29
    什么是社区发现 现实中存在着各种网络:社交网络,交通网络,交易网络,食物链。将这些行为转化为图的网络形式 社区发现是一种聚类算法 作用:精准定位群体,方便进行商品推荐,好友推荐,广告投放 社区的种类: ...
  • 社区发现理解

    千次阅读 2018-07-02 09:58:21
    最近一段时间工作上使用到了社区发现,虽然只是小小一部分。但是呢,工作量还是不小的,在网上找了很多的资料,也做了很多的研究性工作,看了非常多的paper,也做了一点小改进。那么来开始总结一下社区划分究竟怎么...
  • 社区发现算法综述

    千次阅读 2019-01-16 19:54:38
    社区发现算法综述一个社区发现算法PPT 一个社区发现算法PPT 链接: https://blog.csdn.net/itplus/article/details/9286905
  • 社区发现简介社区发现问题实际上是从子图分割的问题演变而来。在社交网络中,有些用户连接非常紧密,有些用户连接较为稀疏,这些连接紧密的用户可以看做一个社区,而社区之间连接较为稀疏。下图就展示了一个社区发现...
  • 社区发现能有效挖掘网络的特性以及隐藏的信息。局部扩展是社区发现常用的一种方法,该方法大体上可以分为种子的选择和局部扩展两部分。因此,为了分析现有方法的优劣以及适用场合,对种子的选择、局部扩展以及评价...
  • 作者: peghoty社区发现(Community Detection)算法用来发现网络中的社区结构,也可以看做是一种聚类算法。以下是我的一个 PPT 报告,分享给大家。从上述定义可以看出:社区是一个比较含糊的概念,只给出了一个定性的...
  • 基于密度吸引点和其对相邻节点的影响度,提出了一种密度分布社区发现算法。该算法以节点度数最大的密度吸引点为初始社区,访问社区的相邻节点,把对社区影响度最大的节点加入到社区中,如果有些节点对多个社区都有...
  • author:xiao黄缓慢而坚定的生长公众号:Community Detection本人更新在博客园关于社区发现(Community Detection)方面的知识会同步更新到公众号中。KL算法介绍Kernighan-Lin算法是一种试探优化的方法,其基本的思想...
  • 社区发现简介社区发现问题实际上是从子图分割的问题演变而来。在社交网络中,有些用户连接非常紧密,有些用户连接较为稀疏,这些连接紧密的用户可以看做一个社区,而社区之间连接较为稀疏。下图就展示了一个社区发现...
  • 随着在线社交网络用户数量的急剧增长,传统的社区发现手段已经难以适应,从而催生了并行社区发现技术的发展。对当前主流并行社区发现方法Louvain算法和标签传播算法在超大规模数据集上的可扩展性进行了研究,指出了...
  • 压缩包中包含了多数社区发现公开数据集:karate、football、power、polbooks、polblogs、lesmis、dophins、celegansneural、adjnoun。希望能帮到你。
  • 社区发现综述

    千次阅读 2016-09-28 15:31:42
    最近做社区发现方向:  一些好的community detection 博客文章地址:  community detection (1):http://blog.csdn.net/cmonkey_cfj/article/details/18680375  community detection (2):...
  • 社区发现数据集

    万次阅读 多人点赞 2016-04-07 23:09:05
    社区发现数据集目录社区发现数据集目录 基于链接分析的数据集 基于链接与离散型属性的数据集 基于链接与文本型属性的数据集 其他常见的数据集链接基于链接分析的数据集 Zachary karate club Zachary 网络是通过对一...
  • 网络中的社区发现是当前的一个研究热点。在众多社区发现算法中,标签传播算法因简单快速而被广泛应用。但标签传播算法也存在结果稳定性较差的问题。通过提取非重叠完全子图来避免社区重叠,提取最小极大团来避免巨型...
  • 社区发现(Community Detection)算法用来发现网络中的社区结构,也可以视为一种广义的聚类算法。 1. 研究背景 复杂网络是复杂系统的抽象,现实中许多复杂系统都可以用复杂网络的相关特性进行描述和分析。 网络中的...
  • lpa社区发现

    千次阅读 2016-03-22 10:39:00
    with dense connections within groups and only sparser connections between them" (Newman, 2004)...当前所用的一些社区发现算法,需要先验信息,比如社团的数目和大小,或者计算量很大。LPA算法只需要使用网络结构
  • 什么事社区发现

    2019-12-16 02:04:55
    朋友要我通俗地讲讲什么是“社区发现”,这下还真觉得有些为难。之前写东西,上来就是概念、术语、公式和算法,这些对于有专业基础的朋友当然没问题,但对于那些没有基础而且也只想知道个大概的朋友显然就不适合了。...
  • 鉴于计算代价高昂的谱聚类无法满足海量网络社区发现的需求, 提出一种用于网络重叠社区发现的谱聚类集成算法(SCEA). 首先, 利用高效的近似谱聚类(KASP) 算法生成个体聚类集合; 然后, 引入个体聚类选择机制对个体聚类...
  • 社区发现,用来发现网络中的社区结构,可以看做是一种聚类。 网络中节点表示系统中的个体,边表示个体之间的关系。社区内节点连接紧密,社区间节点连接稀疏。 社区是一个子图,包括节点和边。一个图的所有社区的...
  • 社区发现数据集共享

    2020-09-15 09:37:09
    社区发现数据集 目录 社区发现数据集 目录 基于链接分析的数据集 基于链接与离散型属性的数据集 基于链接与文本型属性的数据集 其他常见的数据集链接 Mark Newman收集的数据集 Social ...

空空如也

1 2 3 4 5 ... 20
收藏数 8,911
精华内容 3,564
关键字:

社区发现