社群發現演算法 - Fast Unfolding（Louvian）演算法初探

Andrew.Hann發表於2018-05-26

1. 社團劃分

0x1：社群是什麼

在社交網路中，使用者相當於每一個點，使用者之間通過互相的關注關係構成了整個網路的結構，在這樣的網路中，有的使用者之間的連線較為緊密，有的使用者之間的連線關係較為稀疏，在這樣的的網路中，連線較為緊密的部分可以被看成一個社群，其內部的節點之間有較為緊密的連線，而在兩個社群間則相對連線較為稀疏，這便稱為社團結構。如下圖，紅色的黑色的點集呈現出社群的結構，

用紅色的點和黑色的點對其進行標註，整個網路被劃分成了兩個部分，其中，這兩個部分的內部連線較為緊密，而這兩個社群之間的連線則較為稀疏。

如何去劃分上述的社群便稱為社群劃分的問題。

(Newman and Gievan 2004) A community is a subgraph containing nodes which are more densely linked to each other than to the rest of the graph or equivalently, a graph has a community structure if the number of links into any subgraph is higher than the number of links between those subgraphs.

這句話很明確地說明了在什麼業務場景下可以使用社群發現演算法：

1. 即我們需要先確定要解決的業務場景中，存在明顯的聚集規律，節點（可以是抽象的）之間形成一定的族群結構，而不是呈現無規律的隨機分散；
2. 同時另一方面，這種聚集的結構是“有意義的”，這裡所謂的有意義是指這種聚集本身可以翻譯為一定的上層業務場景的表現

0x2：社群劃分的出發點和意圖

直觀地說，community detection的一般目標是要探測網路中的“塊”cluster或是“社團”community。

這麼做的目的和效果有許多，比如說機房裡機器的連線方式，這裡形成了網路結構，那麼，哪些機器可以視作一個“塊”？進一步地，什麼樣的連線方式才有比較高的穩定性呢？如果我們想要讓這組服務癱瘓，選擇什麼樣的目標呢？

我們再看一個例子，word association network。即詞的聯想/搭配構成的網路：

我們用不同的顏色對community進行標記，可以看到這種detection得到的結果很有意思。

這個網路從詞bright開始進行演化，到後面分別形成了4個組：Colors, Light, Astronomy & Intelligence。

可以說以上這4個詞可以較好地概括其所在community的特點（有點聚類的感覺）；另外，community中心的詞，比如color, Sun, Smart也有很好的代表性（自動提取摘要）。

同時我們注意到，那些處在交疊位置的詞呢，比如Bright、light等詞，他們是同義項比較多的詞。這個圖也揭示出了這一層含義。

0x3：社群劃分的思路概要

什麼樣的結構能成為團？一種很直觀的想法是，同一團內的節點連線更緊密，即具有更大的density。

接下來的問題是，什麼樣的metrics可以用來描述這種density？Louvian 定義了一個數值上的概念（本質上就是一個目標函式），有了這個目標函式，就可以引出接下來要討論的 method based on modularity optimization

要注意的，社群劃分有很多不同的演算法，本文討論的 Fast Unfolding（Louvian）只是其中一種，而這種所謂的density密度評估方法也其實其中一種思想，不要固話地認為社群劃分就只有這一種方法。

Relevant Link:

https://stackoverflow.com/questions/21814235/how-can-modularity-help-in-network-analysis 
http://iopscience.iop.org/article/10.1088/1742-5468/2008/10/P10008/fulltext/
https://www.researchgate.net/publication/1913681_Fast_Unfolding_of_Communities_in_Large_Networks?enrichId=rgreq-d403e26a5cb211b7053c36946c71acb3-XXX&enrichSource=Y292ZXJQYWdlOzE5MTM2ODE7QVM6MTAxOTUyNjc5NTc5NjY3QDE0MDEzMTg4MjE3ODA%3D&el=1_x_3&_esc=publicationCoverPdf
https://www.jianshu.com/p/4ebe42dfa8ec
https://blog.csdn.net/u011089523/article/details/79090453
https://blog.csdn.net/google19890102/article/details/48660239
《Fast Unfolding of Communities in Large Networks》

2. LOUVAIN演算法模型

Louvain演算法是一種基於多層次（逐輪啟發式迭代）優化Modularity的演算法。Modularity函式最初被用於衡量社群發現演算法結果的質量，它能夠刻畫發現的社群的緊密程度。

同時，Modularity函式既然能刻畫社群的緊密程度，也就能夠被用來當作一個優化函式（目標函式），即將結點加入它的某個鄰居所在的社群中，如果能夠提升當前社群結構的modularity。則說明這次迭代優化是可接受的。

下面我們來討論Louvain演算法模型的核心元件。

0x1：Modularity的定義 - 描述社群內緊密程度的值Q

模組度是評估一個社群網路劃分好壞的度量方法，它的物理含義是社群內節點的連邊數與隨機情況下的邊數只差，它的取值範圍是 [−1/2,1)，其定義如下：

A為鄰接矩陣， $A_{i j}$ 代表了節點 i 和節點 j 之間邊的權重，網路不是帶權圖時，所有邊的權重可以看做是 1；

是所有與節點 i 相連的邊的權重之和（度數），kj也是同樣；

表示所有邊的權重之和（邊的數目），充當歸一化的作用；

是節點 i 的社群，函式表示若節點 i 和節點 j 在同一個社群內，則返回 1，否則返回 0；

模組度的公式定義可以作如下簡化：

其中 Σin 表示社群 C 內的邊的權重之和；Σtot 表示與社群 C 內的節點相連的所有邊的權重之和。

Σ i n

上面的公式還可以進一步簡化成:

這樣模組度也可以理解是：

首先modularity是針對一個社群的所有節點進行了累加計算。

modularity Q的計算公式背後體現了這種思想：社群內部邊的權重減去所有與社群節點相連的邊的權重和，對無向圖更好理解，即社群內部邊的度數減去社群內節點的總度數。

可以直觀去想象一下，如果一個社群節點完全是“封閉的（即所有節點都互相內部連線，但是不和社群外部其他節點有連線，則modularity公式的計算結果為1）”

基於模組度的社群發現演算法，都是以最大化模組度Q為目標。可以看到，這種模型可以支援我們通過策略優化，去不斷地構造出一個內部聚集，外部稀疏連線的社群結構

在一輪迭代後，若整個 Q 沒有變化，則停止迭代，否則繼續迭代，直至收斂。

0x2：模組度增量 delta Q

模組增益度是評價本次迭代效果好壞的數值化指標，這是一種啟發式的優化過程。類似決策樹中的熵增益啟發式評價。

代表由節點 i 入射叢集 C 的權重之和；代表入射叢集 C 的總權重；ki 代表入射節點 i 的總權重；

在演算法的first phase，判斷一個節點加入到哪個社群，需要找到一個delta Q最大的節點 i，具體的演算法我們後面會詳細討論，這裡只需要記住 delta Q的作用類似決策樹中的資訊增益評估的作用，它幫助整個模型向著Modularity不斷增大的方向去靠攏。

3. LOUVAIN演算法策略

Louvain演算法是基於模組度的社群發現演算法，該演算法在效率和效果上都表現較好，並且能夠發現層次性的社群結構，其優化目標是：最大化整個社群網路的模組度。

即讓整個社群網路呈現出一種模組聚集的結構。

0x1：演算法思想的聯想

Louvain演算法包括兩個階段，在步驟一它不斷地遍歷網路中的結點，嘗試將單個結點加入能夠使modularity提升最大的社群中，直到所有結點都不再變化。在步驟二，它處理第一階段的結果，將一個個小的社群歸併為一個超結點來重新構造網路，這時邊的權重為兩個結點內所有原始結點的邊權重之和。迭代這兩個步驟直至演算法穩定。

從核心思想上來看，Louvain演算法的分步迭代優化過程，和EM優化演算法有異曲同工之妙。

同時有一個題外話值得注意，Louvain演算法是一個迭代演算法，每一輪迭代都會產出一個當前區域性最優的社群結構，所以理論上，假如演算法迭代了5次，我們可以得到5個不同粒度層次的社群結構，從業務場景上，這為我們發現不同的社群聚集提供了一個更靈活的視角。

關於社群發現演算法可以應用在哪些領域，我也還在思考中，從這個演算法的思想上來看，我傾向於認為社群發現演算法比較適合發現一種"抽象泛共現模式"，這種共現是一種泛化的共現，它可以是任何形式的共現，例如

1. 兩臺主機擁有類似的網路對外發包模式
2. 兩臺主機間擁有累計的event log序列
3. 兩個攻擊payload擁有類似的詞頻特徵，可以認為是同一組漏洞利用方式
4. 在netword gateway上發現了類似的網路raw流量，也可以反過來用一直的label流量特徵進行有監督的聚類
..

社群發現可能可以提供一種更高層的視角來看待整體的大盤情況，具體的應用場景還需要不斷的摸索。

0x2：關於啟發式/貪婪思想的社群發現的進一步思考

社群發現演算法，或者說在社群發現的專案中，很容易遇到的一個問題就是：“社群過大，將過多的outerlier包括到了社群中”，換句話說，社群聚類的過程中沒有能及時收斂。

我們來看下面這張圖：

如果按照啟發式/貪婪思想進行”one-step one node“的社群聚類，O9、O10、O11會被先加入到社群D中，因為在每次這樣的迭代中，D社群內部的緊密度（不管基於node密度還是edge得modularity評估）都是不斷提高，符合演算法的check條件，因此，O9、O10、O11會被加入到社群D中。

隨後，O1 ~ O8也會被逐個被加入到社群D中，加入的原因和O9、O10、O11被加入是一樣的。

從區域性上來看，這些步驟是合理的，但是如果從上帝視角的全域性來看，這種做法導致outerlier被錯誤的聚類到的社群中，導致precision下降。

解決這種問題的一個辦法我覺得可以從CNN/DNN的做法中得到靈感，即設定一個Delta增益的閾值，即在每輪的迭代中（社群擴增後緊密度提升的度量）如果不能超過這個閾值，則判定為收斂成功，立即停止演算法迭代。

0x3：社群發現（聚類）的效果非常依賴於weight權重計算的策略和方法

louvain社群發現是將一個無向權重圖，轉化為多個節點集合，每個節點集合代表了一個社群。

社群發現的思想是非常直接簡單的，因為聚類的效果非常依賴於weight權重計算的方法，我們選擇的權重計算方法必須要能夠“很好地”在值域空間中分離開來，否則會導致overcluster。

在實際工程中，我們發現，如果採用exp的【0，1】概率值域空間，節點間weight的區別非常小，很容易導致社群發現演算法將全部節點都判定為同一個社群。

1. weight的表徵意義問題要特別注意！

weigth對於pylouvain社群發現演算法來說，期望表徵的是節點間的關係，這種關係必須是非對偶已經唯一確定的。

舉例來說，如果我們用節點間的simhash相似性來表徵來節點間的weight，則會出現這種情況：

A <-> B：weight（相似性）= 0.1

B <-> C：weight（相似性）= 0.1

但是，很可能存在 A 和 C 是完全不同的兩個樣本，所以 A 和 C 屬於一個社群的這種傳遞關係是不能成立的。

本質上來說，這涉及到如何進行圖節點間weight的特徵工程問題，特徵工程提取的方法必須要能unique唯一代表樣本本身的規律，不能出現：2+8 = 5+5 這種非唯一的情況，即不能出現兩個擁有不同概率分佈的樣本，特徵向量是一樣的。

4. LOUVAIN演算法流程

0x1：演算法形式化描述

1）初始化：

將圖中的每個節點看成一個獨立的社群，社群的數目與節點個數相同；

2）開始first phase迭代 - 社群間節點轉移：

對每個節點i，依次嘗試把節點 i 分配到其每個鄰居節點所在的社群，計算分配前與分配後的模組度變化 $Δ Q$

3）重複2）- 繼續進行社群間節點轉移評估：

直到所有節點的所屬社群不再變化，即社群間的節點轉移結束，可以理解為本輪迭代的 Local Maximization 已達到；

4）second phase - Rebuilding Graph：

因為在這輪的first phase中，社群 C 中新增了一個新的節點 i，而 i 所在的舊的社群少了一個節點，因此需要對整個圖進行一個rebuild。

對圖進行重構，將所有在同一個社群的節點重構成一個新社群，社群內節點之間的邊的權重更新為新節點的環的權重，社群間的邊權重更新為新節點間的邊權重；

5）重複2）- 繼續開始下一輪的first/second phase：

直到整個圖的模組度不再發生變化。

0x2：演算法時間複雜度

從流程來看，該演算法能夠產生層次性的社群結構，其中計算耗時較多的是最底一層的社群劃分，節點按社群壓縮後，將大大縮小邊和節點數目，

並且計算節點 i 分配到其鄰居 j 時，模組度的變化只與節點 i、j 的社群有關，與其他社群無關，因此計算很快。

在論文中，把節點 i 分配到鄰居節點 j 所在的社群 c 時模組度變化為：

$D e l t a Q$

Relevant Link:

https://blog.csdn.net/xuanyuansen/article/details/68941507
https://www.cnblogs.com/fengfenggirl/p/louvain.html 
http://www.cnblogs.com/allanspark/p/4197980.html 
https://github.com/gephi/gephi/wiki
https://blog.csdn.net/qq547276542/article/details/70175157

5. A Python implementation of the Louvain method to find communities in large networks

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

'''
    Implements the Louvain method.
    Input: a weighted undirected graph
    Ouput: a (partition, modularity) pair where modularity is maximum
'''
class PyLouvain:

    '''
        Builds a graph from _path.
        _path: a path to a file containing "node_from node_to" edges (one per line)
    '''
    @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:
                w = int(n[2])
            edges.append(((n[0], n[1]), w))
        # rebuild graph with successive identifiers
        nodes_, edges_ = in_order(nodes, edges)
        print("%d nodes, %d edges" % (len(nodes_), len(edges_)))
        return cls(nodes_, edges_)

    '''
        Builds a graph from _path.
        _path: a path to a file following the Graph Modeling Language specification
    '''
    @classmethod
    def from_gml_file(cls, path):
        f = open(path, 'r')
        lines = f.readlines()
        f.close()
        nodes = {}
        edges = []
        current_edge = (-1, -1, 1)
        in_edge = 0
        for line in lines:
            words = line.split()
            if not words:
                break
            if words[0] == 'id':
                nodes[int(words[1])] = 1
            elif words[0] == 'source':
                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] == 'value' 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]), 1))
                current_edge = (-1, -1, 1)
                in_edge = 0
        nodes, edges = in_order(nodes, edges)
        print("%d nodes, %d edges" % (len(nodes), len(edges)))
        return cls(nodes, edges)

    '''
        Initializes the method.
        _nodes: a list of ints
        _edges: a list of ((int, int), weight) pairs
    '''
    def __init__(self, nodes, edges):
        self.nodes = nodes
        self.edges = edges
        # precompute m (sum of the weights of all links in network)
        #            k_i (sum of the weights of the links incident to node i)
        self.m = 0
        self.k_i = [0 for n in nodes]
        self.edges_of_node = {}
        self.w = [0 for n in nodes]

        for e in edges:
            self.m += e[1]
            self.k_i[e[0][0]] += e[1]
            self.k_i[e[0][1]] += e[1] # there's no self-loop initially
            # save edges by node
            if e[0][0] not in self.edges_of_node:
                self.edges_of_node[e[0][0]] = [e]
            else:
                self.edges_of_node[e[0][0]].append(e)
            if e[0][1] not in self.edges_of_node:
                self.edges_of_node[e[0][1]] = [e]
            elif e[0][0] != e[0][1]:
                self.edges_of_node[e[0][1]].append(e)
        # access community of a node in O(1) time
        self.communities = [n for n in nodes]
        self.actual_partition = []


    '''
        Applies the Louvain method.
    '''
    def apply_method(self):
        network = (self.nodes, self.edges)
        best_partition = [[node] for node in network[0]]
        best_q = -1
        i = 1
        while 1:
            i += 1
            partition = self.first_phase(network)
            q = self.compute_modularity(partition)
            partition = [c for c in partition if c]
            # clustering initial nodes with partition
            if self.actual_partition:
                actual = []
                for p in partition:
                    part = []
                    for n in p:
                        part.extend(self.actual_partition[n])
                    actual.append(part)
                self.actual_partition = actual
            else:
                self.actual_partition = partition
            if q == best_q: # 如果本輪迭代modularity沒有改變，則認為收斂，停止
                break
            network = self.second_phase(network, partition)
            best_partition = partition
            best_q = q
        return (self.actual_partition, best_q)

    '''
        Computes the modularity of the current network.
        _partition: a list of lists of nodes
    '''
    def compute_modularity(self, partition):
        q = 0
        m2 = self.m * 2
        for i in range(len(partition)):
            q += self.s_in[i] / m2 - (self.s_tot[i] / m2) ** 2
        return q

    '''
        Computes the modularity gain of having node in community _c.
        _node: an int
        _c: an int
        _k_i_in: the sum of the weights of the links from _node to nodes in _c
    '''
    def compute_modularity_gain(self, node, c, k_i_in):
        return 2 * k_i_in - self.s_tot[c] * self.k_i[node] / self.m

    '''
        Performs the first phase of the method.
        _network: a (nodes, edges) pair
    '''
    def first_phase(self, network):
        # make initial partition
        best_partition = self.make_initial_partition(network)
        while 1:
            improvement = 0
            for node in network[0]:
                node_community = self.communities[node]
                # default best community is its own
                best_community = node_community
                best_gain = 0
                # remove _node from its community
                best_partition[node_community].remove(node)
                best_shared_links = 0
                for e in self.edges_of_node[node]:
                    if e[0][0] == e[0][1]:
                        continue
                    if e[0][0] == node and self.communities[e[0][1]] == node_community or e[0][1] == node and self.communities[e[0][0]] == node_community:
                        best_shared_links += e[1]
                self.s_in[node_community] -= 2 * (best_shared_links + self.w[node])
                self.s_tot[node_community] -= self.k_i[node]
                self.communities[node] = -1
                communities = {} # only consider neighbors of different communities
                for neighbor in self.get_neighbors(node):
                    community = self.communities[neighbor]
                    if community in communities:
                        continue
                    communities[community] = 1
                    shared_links = 0
                    for e in self.edges_of_node[node]:
                        if e[0][0] == e[0][1]:
                            continue
                        if e[0][0] == node and self.communities[e[0][1]] == community or e[0][1] == node and self.communities[e[0][0]] == community:
                            shared_links += e[1]
                    # compute modularity gain obtained by moving _node to the community of _neighbor
                    gain = self.compute_modularity_gain(node, community, shared_links)
                    if gain > best_gain:
                        best_community = community
                        best_gain = gain
                        best_shared_links = shared_links
                # insert _node into the community maximizing the modularity gain
                best_partition[best_community].append(node)
                self.communities[node] = best_community
                self.s_in[best_community] += 2 * (best_shared_links + self.w[node])
                self.s_tot[best_community] += self.k_i[node]
                if node_community != best_community:
                    improvement = 1
            if not improvement:
                break
        return best_partition

    '''
        Yields the nodes adjacent to _node.
        _node: an int
    '''
    def get_neighbors(self, node):
        for e in self.edges_of_node[node]:
            if e[0][0] == e[0][1]: # a node is not neighbor with itself
                continue
            if e[0][0] == node:
                yield e[0][1]
            if e[0][1] == node:
                yield e[0][0]

    '''
        Builds the initial partition from _network.
        _network: a (nodes, edges) pair
    '''
    def make_initial_partition(self, network):
        partition = [[node] for node in network[0]]
        self.s_in = [0 for node in network[0]]
        self.s_tot = [self.k_i[node] for node in network[0]]
        for e in network[1]:
            if e[0][0] == e[0][1]: # only self-loops
                self.s_in[e[0][0]] += e[1]
                self.s_in[e[0][1]] += e[1]
        return partition

    '''
        Performs the second phase of the method.
        _network: a (nodes, edges) pair
        _partition: a list of lists of nodes
    '''
    def second_phase(self, network, partition):
        nodes_ = [i for i in range(len(partition))]
        # relabelling communities
        communities_ = []
        d = {}
        i = 0
        for community in self.communities:
            if community in d:
                communities_.append(d[community])
            else:
                d[community] = i
                communities_.append(i)
                i += 1
        self.communities = communities_
        # building relabelled edges
        edges_ = {}
        for e in network[1]:
            ci = self.communities[e[0][0]]
            cj = self.communities[e[0][1]]
            try:
                edges_[(ci, cj)] += e[1]
            except KeyError:
                edges_[(ci, cj)] = e[1]
        edges_ = [(k, v) for k, v in edges_.items()]
        # recomputing k_i vector and storing edges by node
        self.k_i = [0 for n in nodes_]
        self.edges_of_node = {}
        self.w = [0 for n in nodes_]
        for e in edges_:
            self.k_i[e[0][0]] += e[1]
            self.k_i[e[0][1]] += e[1]
            if e[0][0] == e[0][1]:
                self.w[e[0][0]] += e[1]
            if e[0][0] not in self.edges_of_node:
                self.edges_of_node[e[0][0]] = [e]
            else:
                self.edges_of_node[e[0][0]].append(e)
            if e[0][1] not in self.edges_of_node:
                self.edges_of_node[e[0][1]] = [e]
            elif e[0][0] != e[0][1]:
                self.edges_of_node[e[0][1]].append(e)
        # resetting communities
        self.communities = [n for n in nodes_]
        return (nodes_, edges_)

'''
    Rebuilds a graph with successive nodes' ids.
    _nodes: a dict of int
    _edges: a list of ((int, int), weight) pairs
'''
def in_order(nodes, edges):
        # rebuild graph with successive identifiers
        nodes = list(nodes.keys())
        nodes.sort()
        i = 0
        nodes_ = []
        d = {}
        for n in nodes:
            nodes_.append(i)
            d[n] = i
            i += 1
        edges_ = []
        for e in edges:
            edges_.append(((d[e[0][0]], d[e[0][1]]), e[1]))
        return (nodes_, edges_)

社群發現的最後一輪結果為：

以polbooks.gml為例，16、17、18、19被歸類為同一個社群：

node
  [
    id 16
    label "Betrayal"
    value "c"
  ]
  node
  [
    id 17
    label "Shut Up and Sing"
    value "c"
  ]
  node
  [
    id 18
    label "Meant To Be"
    value "n"
  ]
  node
  [
    id 19
    label "The Right Man"
    value "c"
  ]

從讀者的共同購買情況作為權重評估，社群發現的結果暗示了這幾本書可能屬於同一類的書籍

利用louvain進行社群發現的核心在於，我們需要對我們的業務場景進行抽象，提取出node1_src/node_dst的節點概念，同時要通過專家領域經驗，進行節點間weight的計算，得到了weight後，就可以通過louvain這種迭代演算法進行社群拓樸的發現了。

Relevant Link:

http://www.cnblogs.com/allanspark/p/4197980.html
https://arxiv.org/pdf/0803.0476.pdf
https://github.com/LittleHann/pylouvain
http://www.cnblogs.com/allanspark/p/4197980.html
https://www.jianshu.com/p/e543dc63454f

6. 其他社群發現演算法

Relevant Link:

http://blog.sina.com.cn/s/blog_63891e610101722t.html
https://www.zhihu.com/question/29042018 
https://wenku.baidu.com/view/36fa145a3169a4517623a313.html

演算法初探--遞迴演算法
2018-10-30
演算法遞迴
PageRank演算法初探
2018-11-18
演算法
社群發現之標籤傳播演算法（LPA）python實現
2024-04-26
演算法Python
Fast角點檢測演算法
2018-05-08
AST演算法
【目標檢測】Fast R-CNN演算法實現
2023-09-20
ASTCNN演算法
【大創_社群劃分】——PageRank演算法MapReduce實現
2015-08-12
演算法
初探DBSCAN聚類演算法
2021-05-22
聚類演算法
字串匹配KMP演算法初探
2012-09-05
字串匹配KMP演算法
openCV - 角點檢測快速演算法 FAST
2019-07-31
OpenCV演算法AST
關聯分析Apriori演算法和FP-growth演算法初探
2018-08-04
演算法
Decision tree(決策樹)演算法初探
2017-08-12
演算法
XXX寶典演算法初探
2015-11-15
演算法
並行Louvain社群檢測演算法
2021-12-12
並行AI演算法
【大創_社群劃分】——PageRank演算法的解析與Python實現
2015-08-12
演算法Python
初探富文字之OT協同演算法
2023-01-08
演算法
初探富文字之CRDT協同演算法
2023-02-12
演算法
各類聚類（clustering）演算法初探
2018-01-20
聚類演算法
以太坊原始碼分析(52）以太坊fast sync演算法
2018-05-14
原始碼AST演算法
初探富文字之搜尋替換演算法
2024-11-04
演算法
圖資料探勘：社群檢測演算法（一）
2021-12-08
演算法
演算法-排序演算法思想及實現
2017-11-28
演算法排序
基於CNN的新詞發現演算法
2022-10-20
CNN演算法
網路拓撲自動發現演算法
2012-09-02
演算法
pangrank演算法--PageRank演算法並行實現
2021-09-09
演算法並行
排序演算法-Java實現快速排序演算法
2020-12-10
排序演算法Java
線性迴歸演算法模型與線性分類演算法模型聯絡與區別初探
2017-08-28
演算法模型
micropather實現A*演算法
2019-01-08
演算法
演算法strstr實現
2014-04-19
演算法
LFU演算法實現
2024-07-07
演算法
ARC演算法實現
2024-07-12
演算法
從資料結構到演算法：圖網路方法初探
2019-08-23
資料結構演算法
初探SEO關鍵詞競爭程度的智慧演算法思路
2018-10-27
演算法
機器學習演算法（三）：K近鄰(k-nearest neighbors)初探
2020-12-21
機器學習演算法REST
二維社群，發現新地圖
2019-05-11
地圖
JavaScript實現《啊哈！演算法》中的系列演算法
2018-11-26
JavaScript演算法
【演算法】Java實現七種常用排序演算法
2018-04-23
演算法Java排序
演算法單鏈錶快速排序演算法實現
2014-04-15
演算法排序
R語言社群主題檢測演算法應用案例
2020-12-03
R語言演算法

社群發現演算法 - Fast Unfolding（Louvian）演算法初探

1. 社團劃分

0x1：社群是什麼

0x2：社群劃分的出發點和意圖

0x3：社群劃分的思路概要

2. LOUVAIN演算法模型

0x1：Modularity的定義 - 描述社群內緊密程度的值Q

0x2：模組度增量 delta Q

3. LOUVAIN演算法策略

0x1：演算法思想的聯想

0x2：關於啟發式/貪婪思想的社群發現的進一步思考

0x3：社群發現（聚類）的效果非常依賴於weight權重計算的策略和方法

1. weight的表徵意義問題要特別注意！

4. LOUVAIN演算法流程

0x1：演算法形式化描述

1）初始化：

2）開始first phase迭代 - 社群間節點轉移：

3）重複2）- 繼續進行社群間節點轉移評估：

4）second phase - Rebuilding Graph：

5）重複2）- 繼續開始下一輪的first/second phase：

0x2：演算法時間複雜度

5. A Python implementation of the Louvain method to find communities in large networks

6. 其他社群發現演算法

相關文章