基于随机游走的社团划分算法label progation 的python实现

来源：互联网发布：mac电脑卸载软件编辑：程序博客网时间：2024/05/02 04:59

 分类：
索引（1） 

简介
python代码实现
存在问题

参考文章：

http://www.lxway.com/619051121.htm

其实这个算法也可以作为聚类算法来用，计算出两两样本之间的相似度，作为这个算法里边的权重，可以去掉值很低的，然后进行聚类。我们假设一个图有m个节点n条边，label propagation的复杂度是O(kn) （不确定）k是迭代次数。在一般情况下，n远远小于m2因此是个和图规模线性关系的算法。如果聚类最后一步采用这种方法，那么计算两两相似度得到图结构，需要O(m2)应该是主要开销。
之前也介绍过这个算法：

http://blog.csdn.net/lgnlgn/archive/2011/01/29/6168756.aspx

算法叫label propagation，基本思想很简单，就是一个节点的所在类别由与其相连的节点共同决定，实际就是类标的马尔科夫随机游走过程。计算的时候需要迭代多次，每个节点选择它邻接节点类标数最多的那一个。
原版算法在选择类标时候过于严格，只选一个；其实很容易想到，可以有各种扩展的办法，比如选若干个，分别赋予隶属度，这样每个节点可以属于多个类别，类别差距大的，可以确定成一个。
具体地就是
首先：每个节点把自己的类标传播到邻居；然后：每个节点根据邻居传过来的消息作出选择
很容易看到，这两步都可以同步地进行，因此非常适合用MapReduce的框架完成，很多图算法基于随机游走模型的，其实都适用，如pagerank。
我简单实现了一个Python的版本，虽然是mapreduce的思路，但是纯粹的顺序执行。代码不多直接贴了，随便建立一个文本文件每行记录一个节点id，它的邻居节点和权重 tuple，如下
1,((2,1),(3,1),(4,1))
2,((1,1),)
3,((1,1),(4,1))
4,((1,1),(3,1))
代码里面解析直接用了eval方法所以格式得注意保证。这个算法是无向图的，因此边要多写一次，例如(1,4) 在(4,1)也要写一份。

from itertools import imapglobal gdata_fileglobal label_vectorglobal group_mappath = "d:/data/graph.txt"def getMaxId():    return max(imap(lambda x:eval(x)[0],file(path,'r').xreadlines()))+1def mapFunc(line):    ##voting    node,edges = eval(line.strip())##    edges = ((node,1),) + edges    labels = label_vector[node]    if labels:        return [(edge+(labels,)) for edge in edges]    else:        return [(edge+({node:1},)) for edge in edges]def mergeMap(a,b,weight):##merge b to a    for k,v in b.iteritems():        g = a.get(k)        if g:            a[k] = g + v * weight        else:            a[k] = v * weight    return adef reduceFunc(map_phrase): ##merge    tmp = {}    for map_results in map_phrase:        for map_result in map_results:            l = tmp.get(map_result[0])            if l:                mergeMap(l,map_result[2],map_result[1])            else:                tmp[map_result[0]] = mergeMap(dict(),map_result[2],map_result[1])    return tmpdef select(m): ##select top k labels    u = sorted(m.items(),key = lambda x:x[1],reverse=True)    if len(u) >=3 and ((u[0][1] - u[1][1]) > (u[1][1] - u[2][1])):        uu = u[:2]    else:        uu = u[:3]    s = sum([x[1] for x in uu])    return dict( [(x[0],(x[1]+0.0)/s) for x in uu])def close():    print label_vectorlabel_vector = [None] * getMaxId()group_map = {}if __name__ == '__main__':    for loop in xrange(7):        gdata_file = file(path,"r")        map_phrase = map(mapFunc, gdata_file.xreadlines())        group_map = reduceFunc(map_phrase)        gdata_file.close()        for k,v in group_map.iteritems():            label_vector[k] = select(v)    close()1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

每次map是一个解析图结构的过程，将节点类标投得到每个邻居，reduce过程就是简单地把所有结果合并。从main开始，迭代多次，每次节点保留隶属度最大的2~3个节点，作为下一次计算的依据，最后close方法用来整理输出。

我还有个疑问，就是向邻居投票的时候，需要包含自己的类标吗？这个我在map阶段注释掉了

熟悉python的话看起来不难，代码写得非常业余和不规范。另外只测试能跑和简单的正确性检查

0 0