baseCode - 0.2.5

Clover coverage report - baseCode - 0.2.5

Coverage timestamp: Tue Apr 12 2005 11:31:58 EDT

FRAMES NO FRAMES

file stats:	LOC:	121		Methods:	6
	NCLOC:	56		Classes:	1

30 day Evaluation Version distributed via the Maven Jar Repository. Clover is not free. You have 30 days to evaluate it. Please visit http://www.thecortex.net/clover to obtain a licensed version of Clover

Source file

Conditionals

Statements

Methods

TOTAL

RankProp.java

 package baseCode.algorithm.learning.unsupervised;
 
 import baseCode.algorithm.Algorithm;
 import baseCode.dataStructure.matrix.AbstractNamedDoubleMatrix;
 import baseCode.dataStructure.matrix.DenseDoubleMatrix1D;
 import cern.colt.matrix.DoubleMatrix1D;
 
 import com.braju.beta.format.Format;
 import com.braju.beta.format.Parameters;
 
 /**
  * Implementation of RankProp, as described in Weston et al. PNAS
  * <hr>
  * <p>
  * Copyright (c) 2004 Columbia University
  * 
  * @author Paul Pavlidis (port from Jason's code)
  * @version $Id: RankProp.java,v 1.10 2005/01/05 02:01:02 pavlidis Exp $
  */
 public class RankProp extends Algorithm {
 
    double alpha = 0.95; // alpha parameter, controls amount of "clustering"
    int maxIter = 20;// number of iterations of algorithm
 
    /**
     * @param matrix
     * @param query
     * @param k
     * @return
     */
    public DoubleMatrix1D computeRanking( AbstractNamedDoubleMatrix matrix,
          AbstractNamedDoubleMatrix query, int k ) {
 
       DoubleMatrix1D yorig = new DenseDoubleMatrix1D( query.viewRow( 0 )
             .toArray() );
       
       return this.computeRanking(matrix, yorig, k);
 
    }
 
  
    /**
     * @param matrix
     * @param matrix1D
     * @param k
     * @return
     */
    public DoubleMatrix1D computeRanking( AbstractNamedDoubleMatrix matrix, DoubleMatrix1D query, int indexOfQuery ) {
       int dim = query.size();
       DoubleMatrix1D y = new DenseDoubleMatrix1D( dim ); // we use own implementation for performance.s
       DoubleMatrix1D yold = new DenseDoubleMatrix1D( dim );
 
       if (query.size() <= 1) {
          return null;
       }
       
       y.assign( 0.0 ); // set all to zero.
       y.setQuick( indexOfQuery, 1.0 );
 
       if ( alpha == 0.0 ) {
          return query;
       }
 
       for ( int loops = 0; loops < maxIter; loops++ ) { // iterations of propagation
 
          yold.assign( y ); // initially all zero except for 1 at the query point.
 
          int lim = Math.min( query.size(), matrix.rows() );
          
          for ( int j = 0; j < lim; j++ ) {
             if ( j == indexOfQuery ) continue; // don't update query
 
             double dotProduct = matrix.viewRow( j ).zDotProduct( yold );
 
             // new y is old y +
             // new weighted linear combination of neighbors
             y.set( j, ( alpha * dotProduct ) + query.getQuick( j ) );
          }
 
          if ( loops % 5 == 0 ) {
             log.info( " iteration " + loops + " y[0]="
                   + Format.sprintf( "%g", new Parameters( y.getQuick( 0 ) ) ) );
          }
       }
       return y;
    }
    
    /**
     * @return Returns the alpha.
     */
    public double getAlpha() {
       return alpha;
    }
 
    /**
     * controls amount of "clustering"
     * @param alpha The alpha to set.
     */
    public void setAlpha( double alpha ) {
       this.alpha = alpha;
    }
 
    /**
     * Maximum iterations before stopping.
     * @return Returns the max_loops.
     */
    public int getMaxIter() {
       return maxIter;
    }
 
    /**
     * Maximum iterations before stopping.
     * @param max_loops The max_loops to set.
     */
    public void setMaxIter( int maxIter ) {
       this.maxIter = maxIter;
    }
 
 }
 
 

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	0	public DoubleMatrix1D computeRanking( AbstractNamedDoubleMatrix matrix,
32		AbstractNamedDoubleMatrix query, int k ) {
33
34	0	DoubleMatrix1D yorig = new DenseDoubleMatrix1D( query.viewRow( 0 )
35		.toArray() );
36
37	0	return this.computeRanking(matrix, yorig, k);
38
39		}
40
41
42		/**
43		* @param matrix
44		* @param matrix1D
45		* @param k
46		* @return
47		*/
48	0	public DoubleMatrix1D computeRanking( AbstractNamedDoubleMatrix matrix, DoubleMatrix1D query, int indexOfQuery ) {
49	0	int dim = query.size();
50	0	DoubleMatrix1D y = new DenseDoubleMatrix1D( dim ); // we use own implementation for performance.s
51	0	DoubleMatrix1D yold = new DenseDoubleMatrix1D( dim );
52
53	0	if (query.size() <= 1) {
54	0	return null;
55		}
56
57	0	y.assign( 0.0 ); // set all to zero.
58	0	y.setQuick( indexOfQuery, 1.0 );
59
60	0	if ( alpha == 0.0 ) {
61	0	return query;
62		}
63
64	0	for ( int loops = 0; loops < maxIter; loops++ ) { // iterations of propagation
65
66	0	yold.assign( y ); // initially all zero except for 1 at the query point.
67
68	0	int lim = Math.min( query.size(), matrix.rows() );
69
70	0	for ( int j = 0; j < lim; j++ ) {
71	0	if ( j == indexOfQuery ) continue; // don't update query
72
73	0	double dotProduct = matrix.viewRow( j ).zDotProduct( yold );
74
75		// new y is old y +
76		// new weighted linear combination of neighbors
77	0	y.set( j, ( alpha * dotProduct ) + query.getQuick( j ) );
78		}
79
80	0	if ( loops % 5 == 0 ) {
81	0	log.info( " iteration " + loops + " y[0]="
82		+ Format.sprintf( "%g", new Parameters( y.getQuick( 0 ) ) ) );
83		}
84		}
85	0	return y;
86		}
87
88		/**
89		* @return Returns the alpha.
90		*/
91	0	public double getAlpha() {
92	0	return alpha;
93		}
94
95		/**
96		* controls amount of "clustering"
97		* @param alpha The alpha to set.
98		*/
99	0	public void setAlpha( double alpha ) {
100	0	this.alpha = alpha;
101		}
102
103		/**
104		* Maximum iterations before stopping.
105		* @return Returns the max_loops.
106		*/
107	0	public int getMaxIter() {
108	0	return maxIter;
109		}
110
111		/**
112		* Maximum iterations before stopping.
113		* @param max_loops The max_loops to set.
114		*/
115	0	public void setMaxIter( int maxIter ) {
116	0	this.maxIter = maxIter;
117		}
118
119		}
120
121