View Javadoc

1   package baseCode.algorithm.learning.unsupervised;
2   
3   import baseCode.algorithm.Algorithm;
4   import baseCode.dataStructure.matrix.AbstractNamedDoubleMatrix;
5   import baseCode.dataStructure.matrix.DenseDoubleMatrix1D;
6   import cern.colt.matrix.DoubleMatrix1D;
7   
8   import com.braju.beta.format.Format;
9   import com.braju.beta.format.Parameters;
10  
11  /***
12   * Implementation of RankProp, as described in Weston et al. PNAS
13   * <hr>
14   * <p>
15   * Copyright (c) 2004 Columbia University
16   * 
17   * @author Paul Pavlidis (port from Jason's code)
18   * @version $Id: RankProp.java,v 1.10 2005/01/05 02:01:02 pavlidis Exp $
19   */
20  public class RankProp extends Algorithm {
21  
22     double alpha = 0.95; // alpha parameter, controls amount of "clustering"
23     int maxIter = 20;// number of iterations of algorithm
24  
25     /***
26      * @param matrix
27      * @param query
28      * @param k
29      * @return
30      */
31     public DoubleMatrix1D computeRanking( AbstractNamedDoubleMatrix matrix,
32           AbstractNamedDoubleMatrix query, int k ) {
33  
34        DoubleMatrix1D yorig = new DenseDoubleMatrix1D( query.viewRow( 0 )
35              .toArray() );
36        
37        return this.computeRanking(matrix, yorig, k);
38  
39     }
40  
41   
42     /***
43      * @param matrix
44      * @param matrix1D
45      * @param k
46      * @return
47      */
48     public DoubleMatrix1D computeRanking( AbstractNamedDoubleMatrix matrix, DoubleMatrix1D query, int indexOfQuery ) {
49        int dim = query.size();
50        DoubleMatrix1D y = new DenseDoubleMatrix1D( dim ); // we use own implementation for performance.s
51        DoubleMatrix1D yold = new DenseDoubleMatrix1D( dim );
52  
53        if (query.size() <= 1) {
54           return null;
55        }
56        
57        y.assign( 0.0 ); // set all to zero.
58        y.setQuick( indexOfQuery, 1.0 );
59  
60        if ( alpha == 0.0 ) {
61           return query;
62        }
63  
64        for ( int loops = 0; loops < maxIter; loops++ ) { // iterations of propagation
65  
66           yold.assign( y ); // initially all zero except for 1 at the query point.
67  
68           int lim = Math.min( query.size(), matrix.rows() );
69           
70           for ( int j = 0; j < lim; j++ ) {
71              if ( j == indexOfQuery ) continue; // don't update query
72  
73              double dotProduct = matrix.viewRow( j ).zDotProduct( yold );
74  
75              // new y is old y +
76              // new weighted linear combination of neighbors
77              y.set( j, ( alpha * dotProduct ) + query.getQuick( j ) );
78           }
79  
80           if ( loops % 5 == 0 ) {
81              log.info( " iteration " + loops + " y[0]="
82                    + Format.sprintf( "%g", new Parameters( y.getQuick( 0 ) ) ) );
83           }
84        }
85        return y;
86     }
87     
88     /***
89      * @return Returns the alpha.
90      */
91     public double getAlpha() {
92        return alpha;
93     }
94  
95     /***
96      * controls amount of "clustering"
97      * @param alpha The alpha to set.
98      */
99     public void setAlpha( double alpha ) {
100       this.alpha = alpha;
101    }
102 
103    /***
104     * Maximum iterations before stopping.
105     * @return Returns the max_loops.
106     */
107    public int getMaxIter() {
108       return maxIter;
109    }
110 
111    /***
112     * Maximum iterations before stopping.
113     * @param max_loops The max_loops to set.
114     */
115    public void setMaxIter( int maxIter ) {
116       this.maxIter = maxIter;
117    }
118 
119 }
120