AVRank, HVRank的实现

看了论文《Deeply Exploiting Link Structure: Setting a Tougher Life for Spammers》，用Java和webgraph库实现了一下其中的算法CPV，即计算AVRank和HVRank。最终的结果没有做归一化处理，我用数据集试了一下，发现效果还不错。

代码实现如下：

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

package cn.edu.dlut.wisdom;
 
import it.unimi.dsi.webgraph.*;
 
public class Cpv {
    private ImmutableGraph graph;
    private ImmutableGraph igraph;
    private double alpha = 0.5;
    private double beta = 0.5;
    private double dampening = 0.85;
    private int numNodes;
    private int m = 50;
 
    public void setM(int m) {
        this.m = m;
    }
 
    public void setAlpha(double alpha) {
        this.alpha = alpha;
    }
 
    public void setBeta(double beta) {
        this.beta = beta;
    }
 
    public void setDampening(double dampening) {
        this.dampening = dampening;
    }
 
    public void setGraph(ImmutableGraph graph) {
        this.graph = graph;
    }
 
    public void setIAVRank(double[] iAVRank) {
        this.iAVRank = iAVRank;
    }
 
    public void setIgraph(ImmutableGraph igraph) {
        this.igraph = igraph;
    }
 
    public void setIHVRank(double[] iHVRank) {
        this.iHVRank = iHVRank;
    }
    private double[] iAVRank;
    private double[] iHVRank;
    private double[] aVRank;
    private double[] hVRank;
 
    public double[] getAVRank() {
        return aVRank;
    }
 
    public double[] getHvRank() {
        return hVRank;
    }
 
    public Cpv(ImmutableGraph graph, ImmutableGraph igraph, double [] iAVRank, double[] iHVRank, double alpha, double beta, double dampening, int m) {
        this.iAVRank = iAVRank;
        this.iHVRank = iHVRank;
        this.alpha = alpha;
        this.beta = beta;
        this.dampening = dampening;
        this.m = m;
        this.graph = graph;
        this.igraph = igraph;
        numNodes = graph.numNodes();
    }
 
    public Cpv(ImmutableGraph graph, ImmutableGraph igraph) {
        this.graph = graph;
        this.igraph = igraph;
        numNodes = graph.numNodes();
        iAVRank = new double[numNodes];
        iHVRank = new double[numNodes];
        double temp = 1.0 / numNodes;
        for(int i = 0; i < numNodes; i++) {
            iAVRank[i] = temp;
            iHVRank[i] = temp;
        }
    }
 
    public Cpv(ImmutableGraph graph) {
        this.graph = graph;
        igraph = Transform.transpose(graph);
        numNodes = graph.numNodes();
        iAVRank = new double[numNodes];
        iHVRank = new double[numNodes];
        double temp = 1.0 / numNodes;
        for(int i = 0; i < numNodes; i++) {
            iAVRank[i] = temp;
            iHVRank[i] = temp;
        }
    }
 
    public void computeRank() {
        // 初始化
        aVRank = iAVRank.clone();
        hVRank = iHVRank.clone();
         
        int iter = m;
        // 迭代
        while(iter-- > 0) {
            for(int i = 0; i < numNodes; i++) {
                if(igraph.outdegree(i) > 0) {
                    aVRank[i] = 0;
                    for(int j : igraph.successorArray(i)) {
                        int outDegree = graph.outdegree(j);
                        aVRank[i] += alpha * aVRank[j] / outDegree + (1 - alpha) * hVRank[j] / outDegree;
                    }
                }
            }
 
            for(int i = 0; i < numNodes; i++) {
                if(graph.outdegree(i) > 0) {
                    hVRank[i] = 0;
                    for(int j : graph.successorArray(i)) {
                        int inDegree = igraph.outdegree(j);
                        hVRank[i] += beta * aVRank[j] / inDegree + (1 - beta) * hVRank[j] / inDegree;
                    }
                }
            }
 
            for(int i = 0; i < numNodes; i++) {
                aVRank[i] = dampening * aVRank[i] + (1 - dampening) * iAVRank[i];
                hVRank[i] = dampening * hVRank[i] + (1 - dampening) * hVRank[i];
            }
        }
    }
}