algorithmpca.java,v

包含了模式识别中常用的一些分类器设计算法

	int output_canvas_d[][];

	// classification functions
	//
	public boolean initialize()
	{
	    // Debug
	    //System.out.println(algo_id + ": initialize()");
d56 2
a57 7
	    trans_matrix_d = new Matrix();
	    cov_matrix_d = new Matrix();
	    support_vectors_d = new Vector();
	    point_means_d = new Vector();
	    decision_regions_d = new Vector();
	    step_count = 3;
	    algo_id = "AlgorithmPCA";
d59 2
a60 15
	    // add the process description for the PCA algorithm
	    if (description_d.size() == 0)
	    {
		String str = new String("   0. Initialize the original data.");
		description_d.addElement(str);
		
		str = new String("   1. Displaying the original data.");
		description_d.addElement(str);
		
		str = new String("   2. Computing the support regions.");
		description_d.addElement(str);
		
		str = new String("   3. Computing the decision regions based on the class independent principal component analysis algorithm.");
		description_d.addElement(str);
	    }
d62 3
a64 2
	    // append message to process box
	    pro_box_d.appendMessage("Class Independent Principal" + " Component Analysis:" + "\n");
d66 4
a69 18
	    // set the data points for this algorithm
	    //
	    set1_d = (Vector)data_points_d.dset1.clone();
	    set2_d = (Vector)data_points_d.dset2.clone();
	    set3_d = (Vector)data_points_d.dset3.clone();
	    set4_d = (Vector)data_points_d.dset4.clone();
	    
	    // set the step index
	    step_index_d = 0;
	    
	    // append message to process box
	    pro_box_d.appendMessage((String)description_d.get(step_index_d));
	    
	    // exit gracefully
	    return true;
	}

	// the Runnable method
d71 23
a93 1
	public void run()
d95 4
a98 2
	    // Debug
	    //System.out.println(algo_id + ": run()");
d100 6
a105 13
	    if (step_index_d == 1)
	    {
		disableControl();
		step1();
		enableControl();
	    }
	    
	    else if (step_index_d == 2)
	    {
		disableControl();
		step2(); 
		enableControl();
	    }
d107 6
a112 11
	    else if (step_index_d == 3)
	    {
		disableControl();
		step3();
		pro_box_d.appendMessage("   Algorithm Complete");
		enableControl(); 
	    }

	    // exit gracefully
	    //
	    return;
d114 45
d160 26
a185 1
	// method: step1 
d187 7
a193 2
	// arguments: none
	// return   : none
d195 4
a198 1
	// step one of the algorithm
d200 2
a201 8
	boolean step1()
	{
	    // Debug
	    //System.out.println(algo_id + ": step1()");
	    
	    pro_box_d.setProgressMin(0);
	    pro_box_d.setProgressMax(1);
	    pro_box_d.setProgressCurr(0);
d203 21
a223 11
	    scaleToFitData();

	    // Display original data
	    output_panel_d.addOutput(set1_d, Classify.PTYPE_INPUT, 
				     data_points_d.color_dset1);
	    output_panel_d.addOutput(set2_d, Classify.PTYPE_INPUT,
				     data_points_d.color_dset2);
	    output_panel_d.addOutput(set3_d, Classify.PTYPE_INPUT,
				     data_points_d.color_dset3);
	    output_panel_d.addOutput(set4_d, Classify.PTYPE_INPUT, 
				     data_points_d.color_dset4);
d225 5
a229 11
	    // step 1 completed
	    //
	    pro_box_d.setProgressCurr(1);
	    output_panel_d.repaint();
	    
	    // exit gracefully
	    //
	    return true;
	}

	// method: step2 
d231 1
a231 2
	// arguments: none
	// return   : none
d233 7
a239 1
	// step two of the algorithm
d241 18
a258 4
	boolean step2()
	{
	    // Debug
	    //System.out.println(algo_id + ": step2()");
d260 5
d266 6
a271 3
	    pro_box_d.setProgressMin(0);
	    pro_box_d.setProgressMax(20);
	    pro_box_d.setProgressCurr(0);
d273 3
a275 5
	    // append message to process box
	    //
	    transformPCA();
	    printMatrices();
	    computeMeans();
d277 10
a286 3
	    // display means
	    //
	    output_panel_d.addOutput(point_means_d, Classify.PTYPE_OUTPUT_LARGE, Color.black);
d288 3
a290 3
	    // display support vectors
	    //
	    output_panel_d.addOutput(support_vectors_d, Classify.PTYPE_INPUT, Color.cyan);
d292 3
a294 4
	    // display support vectors
	    //
	    pro_box_d.setProgressCurr(20);
	    output_panel_d.repaint();
d296 1
a296 6
	    // exit gracefully
	    //
	    return true;
	}

	// method: step3 
d298 5
a302 2
	// arguments: none
	// return   : none
d304 5
a308 1
	// step one of the algorithm
d310 2
a311 4
	boolean step3()
	{
	    // Debug
	    //System.out.println(algo_id + ": step3()");
d313 3
a315 3
	    pro_box_d.setProgressMin(0);
	    pro_box_d.setProgressMax(20);
	    pro_box_d.setProgressCurr(0);
d317 4
a320 3
	    // compute the decision regisions
	    //
	    computeDecisionRegions();
d322 3
a324 3
	    // compute errors
	    //
	    computeErrors();
d326 26
a351 13
	    // display support vectors
	    //
	    // display support vectors
	    //
	    output_panel_d.addOutput(decision_regions_d, Classify.PTYPE_INPUT, new Color(255, 200, 0));
	    
	    //Color.black);
	    //pro_box_d.setProgressCurr(20);	    
	    output_panel_d.repaint();
	    
	    // exit gracefully
	    //
	    return true;
d353 2
a354 2

	// method transformPCA
d356 4
a359 2
	// arguments:
	//    Data d: input data point
d361 10
a370 1
	// return   : none
d372 4
a375 2
	// this method transforms a given set of points to a new space
	// using the class independent principal component analysis algorithm
d377 10
a386 1
	public void transformPCA()
a387 2
	    // Debug
	    //System.out.println(algo_id + ": transformPCA()");
d389 1
a389 1
	    // declare local variables
d391 2
a392 3
	    int size = 0;
	    int xsize = 0;
	    int ysize = 0;
d394 1
a394 1
	    // declare variables to compute the global mean
d396 1
a396 4
	    double xval = 0.0;
	    double yval = 0.0;
	    double xmean = 0.0;
	    double ymean = 0.0;
d398 1
a398 1
	    // declare the covariance object
d400 2
a401 1
	    Covariance cov = new Covariance();
d403 1
a403 1
	    // declare an eigen object
d405 1
a405 2
	    // Since Eigen is a class of static member functions it is not correct to instantiate it - Phil T. 6-23-03 
	    //Eigen eigen = new Eigen();
d407 1
a407 1
	    // declare the covariance matrix
d409 1
a409 3
	    Matrix covariance = new Matrix();
	    covariance.row = covariance.col = 2;
	    covariance.Elem = new double[2][2];
d411 1
a411 1
	    // declare arrays for the eigenvalues
d413 3
a415 1
	    double eigVal[] = null;
d417 1
a417 1
	    // declare an array to store the eigen vectors
d419 10
a428 1
	    double eigVec[] = new double[2];
d430 1
a430 1
	    // declare matrix objects
d432 21
a452 3
	    Matrix T = new Matrix();
	    Matrix M = new Matrix();
	    Matrix W = new Matrix();
d454 12
a465 5
	    // allocate memory for the matrix elements
	    //
	    T.Elem = new double[2][2];
	    M.Elem = new double[2][2];
	    W.Elem = new double[2][2];
d467 7
a473 1
	    // declare arrays to store the samples
d475 2
a476 2
	    double x[] = null;
	    double y[] = null;
d478 1
a478 1
	    // declare the maximum size of all data sets together
d480 1
a480 1
	    int maxsize = set1_d.size() + set2_d.size() + set3_d.size() + set4_d.size();
d482 2
a483 1
	    // initialize arrays to store the samples
d485 1
a485 2
	    x = new double[maxsize];
	    y = new double[maxsize];
d487 1
a487 1
	    // get the samples from the first data set
d489 2
a490 1
	    size = set1_d.size();
d492 1
a492 2
	    // set up the initial random vectors i.e., the vectors of
	    // X and Y coordinate points form the display
d494 2
a495 12
	    for (int i = 0; i < size; i++)
	    {
		MyPoint p = (MyPoint)set1_d.elementAt(i);
		xval += p.x;
		yval += p.y;
		x[xsize++] = p.x;
		y[ysize++] = p.y;
	    }

	    // get the samples from the second data set
	    //
	    size = set2_d.size();
d497 1
a497 2
	    // set up the initial random vectors i.e., the vectors of
	    // X and Y coordinate points form the display
d499 4
a502 8
	    for (int i = 0; i < size; i++)
	    {
		MyPoint p = (MyPoint)set2_d.elementAt(i);
		xval += p.x;
		yval += p.y;
		x[xsize++] = p.x;
		y[ysize++] = p.y;
	    }
d504 54
a557 106
	    // get the samples from the third data set
	    //
	    size = set3_d.size();
	    
	    // set up the initial random vectors i.e., the vectors of
	    // X and Y coordinate points form the display
	    //
	    for (int i = 0; i < size; i++)
	    {
		MyPoint p = (MyPoint)set3_d.elementAt(i);
		xval += p.x;
		yval += p.y;
		x[xsize++] = p.x;
		y[ysize++] = p.y;
	    }
	    
	    // get the samples from the first data set
	    //
	    size = set4_d.size();

	    // set up the initial random vectors i.e., the vectors of
	    // X and Y coordinate points form the display
	    //
	    for (int i = 0; i < size; i++)
	    {
		MyPoint p = (MyPoint)set4_d.elementAt(i);
		xval += p.x;
		yval += p.y;
		x[xsize++] = p.x;
		y[ysize++] = p.y;
	    }
	    
	    if (maxsize > 0)
	   {
	       
	       // initialize the transformation matrix dimensions
	       //
	       W.row = 2;
	       W.col = 2;
	       
	       // reset the matrices
	       //
	       W.resetMatrix();
	       
	       // compute the covariance matrix of the first data set
	       //
	       covariance.Elem = cov.computeCovariance(x, y);
	       cov_matrix_d = covariance;
	       
	       // initialize the matrix needed to compute the eigenvalues
	       //
	       T.initMatrix(covariance.Elem, 2, 2);
	       
	       // make a copy of the original matrix
	       //
	       M.copyMatrix(T);
	       
	       // compute the eigen values
	       //
	       // Changed eigen to Eigen since member function is static - Phil T. 6-23-03
	       eigVal = Eigen.compEigenVal(T);
	       
	       // compute the eigen vectors
	       //
	       for (int i = 0; i < 2; i++)
	       {
		   //	Changed eigen to Eigen since member function is static - Phil T. 6-23-03
		   Eigen.calcEigVec(M, eigVal[i], eigVec);
		   for (int j = 0; j < 2; j++)
		   {
		       W.Elem[j][i] = eigVec[j] / Math.sqrt(eigVal[i]);
		   }
	       }
	       
	       // save the transformation matrix 
	       //
	       trans_matrix_d = W;
	   }

	    // compute the global mean of the data sets
	    //
	    xmean = xval / xsize;
	    ymean = yval / ysize;
	    
	    // determine points for the support regions
	    //
	    double val[][] = new double[2][1];
	    
	    Matrix invT = new Matrix();
	    Matrix supp = new Matrix();
	    Matrix temp = new Matrix();
	    
	    // set up the angle with which to rotate the axis
	    //
	    double theta = 0.0;
	    double alpha = cov_matrix_d.Elem[0][0] - cov_matrix_d.Elem[1][1];
	    double beta = -2 * cov_matrix_d.Elem[0][1];
	    
	    if (eigVal[0] > eigVal[1])
	    {
		theta = Math.atan2((alpha - Math.sqrt((alpha * alpha) + (beta * beta))), beta);
	    }
	    else
	    {
		theta = Math.atan2((alpha + Math.sqrt((alpha * alpha) + (beta * beta))), beta);
	    }
d559 1
a559 8
	    // compute the inverse of the transformation matrix
	    //
	    trans_matrix_d.invertMatrix(invT);
	    
	    // loop through all points on the circumference of the 
	    // gaussian sphere in the transformed space
	    //
	    for (int i = 0; i < 360; i++)
d562 1
a562 1
		// get the x and y co-ordinates
d564 3
a566 2
		val[0][0] = 1.5 * Math.cos(i);
		val[1][0] = 1.5 * Math.sin(i);
d568 1
a568 1
		// set up the points as a matrix in order for multiplication
d570 3
a572 1
		temp.initMatrix(val, 2, 1);
d574 1
a574 2
		// transform the points from the feature space back to the
		// original space to create the support region for the data set
d576 3
a578 1
		invT.multMatrix(temp, supp);
d580 1
a580 1
		// rotate the points after transforming them to the new space
d582 18
a599 14
		xval = (supp.Elem[0][0] * Math.cos(theta)) - (supp.Elem[1][0] * Math.sin(theta));
		yval = (supp.Elem[0][0] * Math.sin(theta)) + (supp.Elem[1][0] * Math.cos(theta));
		
		// time shift the co-ordinates to the global mean
		//
		xval = xval + xmean;
		yval = yval + ymean;
		
		// add the point to the support region vector
		//
		MyPoint pt = new MyPoint(xval, yval);
		support_vectors_d.addElement(pt);
	    }
	}
d601 24
a624 56

	// method: computeDecisionRegions
	//
	// arguments: none
	// return   : none
	//
	// method computes the line of discrimination for the classification 
	// algorithms when the corresponding flags have been initialized
	//
	public void computeDecisionRegions()
	{
	    // Debug
	    //System.out.println(algo_id + ": computeDecisionRegions()");
	    
	    DisplayScale scale = output_panel_d.disp_area_d.getDisplayScale();
	    
	    double currentX = scale.xmin;
	    double currentY = scale.ymin;
	    
	    // set precision
	    //
	    int outputWidth = output_panel_d.disp_area_d.getXPrecision();
	    int outputHeight = output_panel_d.disp_area_d.getYPrecision();
	    
	    double incrementY = (scale.ymax-scale.ymin)/outputHeight;
	    double incrementX = (scale.xmax-scale.xmin)/outputWidth;
	    
	    // declare a 2D array to store the class associations
	    //
	    output_canvas_d = new int[outputWidth][outputHeight];
	    
	    // loop through each and every point on the pixmap and
	    // determine which class each pixel is associated with
	    //
	    MyPoint point;
	    double dist = 0.0;
	    int associated = 0;
	    double smallestSoFar = Double.MAX_VALUE;
	    
	    int target = 0;
	    boolean set1flag = true;
	    boolean set2flag = true;
	    boolean set3flag = true;
	    
	    pro_box_d.setProgressMin(0);
	    pro_box_d.setProgressMax(outputWidth);
	    pro_box_d.setProgressCurr(0);

	    for (int i = 0; i < outputWidth; i++)
	    {
		currentX += incrementX;
		currentY = scale.ymin;
		pro_box_d.setProgressCurr(i);    
		
		for (int j = 0; j < outputHeight; j++)
		{
d626 1
a626 1
		    // declare the current pixel point
d628 2
a629 3
		    currentY += incrementY;
		    MyPoint pixel = new MyPoint(currentX, currentY);
		    smallestSoFar = Double.MAX_VALUE;
d631 1
a631 1
		    // convert the pixel to the time domain
d633 2
a634 3
		    double X[][] = new double[1][2];
		    X[0][0] = pixel.x;
		    X[0][1] = pixel.y;
d636 2
a637 1
		    // reset the boolean flags
d639 5
a643 3
		    set1flag = true;
		    set2flag = true;
		    set3flag = true;
d645 2
a646 1
		    // find the closest point from the first class
d648 3
a650 1
		    for (int k = 0; k < point_means_d.size(); k++)
d653 2
a654 71
			// classify the sample to the first set
			//
			if (set1_d.size() > 0 && set1flag)
			{