lda（linear discriminant analysis）线性判别分析算法代码

做文本聚类分析，采用了pca等降维效果都不好，于是决定采用有监督的学习算法lda，网络找代码，找到一个看不懂如何降维，于是自己改写，代码如下：

package lda;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import org.apache.commons.math3.linear.EigenDecomposition;
import org.apache.commons.math3.linear.LUDecomposition;
import org.apache.commons.math3.linear.MatrixUtils;
import org.apache.commons.math3.linear.RealMatrix;
import org.apache.commons.math3.linear.RealVector;

import Jama.Matrix;

public class LDA
{
    private double[][] groupRataTengah;
    private double[][] kovarianGlobal;
    private double[] probabilitas;
    private ArrayList<Integer> groupList = new ArrayList<Integer>();
    static int hasil;
    static double f1, f2, f3;
    private HashMap _map = new HashMap();
    private RealVector[] _top2vec = new RealVector[2];
    public LDA()
    {

    }
    /**
     *
     * @param d 聚类结果数组
     * @param g 聚类的类别标识，和前面的d关系一致
     * @param p
     */
    public LDA(double[][] d, int[] g, boolean p)
    {
 // memeriksa apakah data dan kelompok array mempunyai ukuran yang sama
 if (d.length != g.length)
     return;

 double[][] data = new double[d.length][d[0].length];// panjang data(i)
           // dan fitur(j)
 for (int i = 0; i < d.length; i++)
 {
     for (int j = 0; j < d[i].length; j++)
     {
  data[i][j] = d[i][j];
     }
 }
 int[] group = new int[g.length];
 for (int j = 0; j < g.length; j++)
 {
     group[j] = g[j];
 }

 double[] rataTengah;
 double[][][] kovarian;

 // memisahkan berdasarkan grup atau kelas
 for (int i = 0; i < group.length; i++)
 {
     if (!groupList.contains(group[i]))
     {
  groupList.add(group[i]);
     }
 }

 // membagi data ke dalam subset
 ArrayList<double[]>[] subset = new ArrayList[groupList.size()];
 for (int i = 0; i < subset.length; i++)
 {
     subset[i] = new ArrayList<double[]>();
     for (int j = 0; j < data.length; j++)
     {
  if (group[j] == groupList.get(i))
  {
      subset[i].add(data[j]);
  }
     }
 }

 // menghitung mean tiap fitur tiap kelas
 groupRataTengah = new double[subset.length][data[0].length];
 for (int i = 0; i < groupRataTengah.length; i++)
 {
     for (int j = 0; j < groupRataTengah[i].length; j++)
     {
  groupRataTengah[i][j] = getGroupMean(j, subset[i]);
     }
 }

 // menghitung global mean atau mean tiap fitur pada semua kelas
 rataTengah = new double[data[0].length];
 for (int i = 0; i < data[0].length; i++)
 {
     rataTengah[i] = getGlobalMean(i, data);
 }

 
 double[][] tempMatrix = new double[subset.length][data[0].length];
 for (int i = 0; i < subset.length; i++)
 {
     for (int j = 0; j < data[0].length; j++)
     {
  tempMatrix[i][j] = groupRataTengah[i][j] - rataTengah[j];
     }
 }

 double[][] SB = new double[data[0].length][data[0].length];
 for (int k = 0; k < subset.length; k++)
 {
     int t = subset[k].size();
     for (int i = 0; i < SB.length; i++)
     {
  for (int j = 0; j < SB[i].length; j++)
  {      
      SB[i][j] = SB[i][j] + (t * (tempMatrix[k][i] * tempMatrix[k][j]))/data.length;
  }
     }
 }
 
 
 
 
 double[][] SW = new double[data[0].length][data[0].length];
 
 for (int k = 0; k < groupList.size(); k++)
 {
     ArrayList _class = subset[k];  
     for (int l = 0; l < _class.size(); l++)
     {
  double [] _el = (double[])_class.get(l);
  for (int i = 0; i < SB.length; i++)
  {
      for (int j = 0; j < SB[i].length; j++)
      {

   SW[i][j] = SW[i][j] + (groupRataTengah[k][i]-_el[i])*(groupRataTengah[k][j]-_el[j]);
    
      }
  }
     }
 }
 RealMatrix rsw = MatrixUtils.createRealMatrix(SW);
 RealMatrix rswInverse = new LUDecomposition(rsw).getSolver().getInverse();
 RealMatrix rsb = MatrixUtils.createRealMatrix(SB);
 RealMatrix r = rswInverse.multiply(rsb);
 
 
 EigenDecomposition  en = new EigenDecomposition(r);
 double [] eg =en.getRealEigenvalues();
 for(int i=0;i<eg.length;i++)
 {
    RealVector rv = en.getEigenvector(i);
    System.out.println(eg[i] + ":");
    System.out.println(rv.toString());
    _map.put(eg[i], rv);
 }
    }
   
    /**
     * 得到前两个特征向量
     * @return
     */
    public RealVector[] getTop2Vector()
    {
 RealVector [] arrVec = new RealVector[2];
 Iterator iter = this._map.entrySet().iterator();
 ArrayList _list = new ArrayList();
 while (iter.hasNext()) {
 Map.Entry entry = (Map.Entry) iter.next();
          Object key = entry.getKey();
   //Object val = entry.getValue();
          _list.add(key);
        }
 Collections.sort(_list);
 int j=0;
 for(int i=_list.size()-1;i>-1;i--)
 {
     System.out.println(_list.get(i));
     arrVec[j] = (RealVector)this._map.get(_list.get(i));
     j++;
     if(j==2)
     {
  break;
     }
 }
 this._top2vec = arrVec;
 
 return arrVec;
    }
   
    /**
     * 输入点向量，得到对应的二维平面坐标
     * @param in
     * @return
     */
    public double[] getxydot(double[]in)
    {
 
 RealVector inv = MatrixUtils.createRealVector(in);
 double[] out = new double[2];
 for(int i=0;i<2;i++)
 {
     out[i] = this._top2vec[i].dotProduct(inv);
 }
 
 return out;
    }
   
   
   
   
    private double getGroupMean(int column, ArrayList<double[]> data)
    {
 double[] d = new double[data.size()];
 for (int i = 0; i < data.size(); i++)
 {
     d[i] = data.get(i)[column];
 }

 return getMean(d);
    }

    private double getGlobalMean(int column, double data[][])
    {
 double[] d = new double[data.length];
 for (int i = 0; i < data.length; i++)
 {
     d[i] = data[i][column];
 }

 return getMean(d);
    }

    // menghitung nilai fungsi discriminant untuk kelas yang berbeda
    public double[] getDiscriminantFunctionValues(double[] values)
    {
 double[] function = new double[groupList.size()];
 for (int i = 0; i < groupList.size(); i++)
 {
     double[] tmp = matrixMultiplication(groupRataTengah[i], kovarianGlobal);
     function[i] = (matrixMultiplication(tmp, values))// fi=miu i*invers
            // kovarian*data
            // testing-1/2 miu
            // i*invers
            // kovarian*miu i
            // trans+ln(pi)
      - (.5d * matrixMultiplication(tmp, groupRataTengah[i]))
      + Math.log(probabilitas[i]);
 }

 return function;
    }

    // memprediksi masuk kelas mana
    public int predict(double[] values)
    {
 int group = -1;
 double max = Double.NEGATIVE_INFINITY;
 double[] discr = this.getDiscriminantFunctionValues(values);
 for (int i = 0; i < discr.length; i++)
 {
     if (discr[i] > max)
     {
  max = discr[i];
  group = groupList.get(i);
     }
 }

 return group;
    }

    // mengalikan dua matriks
    private double[] matrixMultiplication(double[] matrixA, double[][] matrixB)
    {

 double c[] = new double[matrixA.length];
 for (int i = 0; i < matrixA.length; i++)
 {
     c[i] = 0;
     for (int j = 0; j < matrixB[i].length; j++)
     {
  c[i] += matrixA[i] * matrixB[i][j];
     }
 }

 return c;
    }

    private double matrixMultiplication(double[] matrixA, double[] matrixB)
    {

 double c = 0d;
 for (int i = 0; i < matrixA.length; i++)
 {
     c += matrixA[i] * matrixB[i];
 }

 return c;
    }

    public static double getMean(final double[] values)
    {
 if (values == null || values.length == 0)
     return Double.NaN;

 double mean = 0.0d;

 for (int index = 0; index < values.length; index++)
     mean += values[index];

 return mean / (double) values.length;
    }

    public static void test(extraksi_fitur e, double a, double b, double c, double d)
    {
 extraksi_fitur ef = e;
 int[] group = { 1, 1, 1, 1, 2, 2, 2 };// 1=lemon,2=manis,3=nipis
 double[][] data = new double[7][2];// 15=jumlah data,4=fitur R,G,B,D
 int count = 0;

 data[0][0] = 2.95;
 data[0][1] = 6.63;
 data[0][0] = 2.53;
 data[0][1] = 7.79;
 data[0][0] = 3.57;
 data[0][1] = 5.65;
 data[0][0] = 3.16;
 data[0][1] = 5.47;
 data[0][0] = 2.58;
 data[0][1] = 4.46;
 data[0][0] = 2.16;
 data[0][1] = 6.22;
 data[0][0] = 3.27;
 data[0][1] = 3.52;

 LDA test = new LDA(data, group, true);
 double[] testData = { a, b, c, d };

 // test
 double[] values = test.getDiscriminantFunctionValues(testData);
 for (int i = 0; i < values.length; i++)
 {
     System.out.println("Discriminant function " + (i + 1) + ": " + values[i]);
 }

 System.out.println("Predicted group: " + test.predict(testData));
 hasil = test.predict(testData);
 f1 = values[0];
 f2 = values[1];
 f3 = values[2];
    }

    public static void main(String[] args)
    {
 double[][] data = new double[7][3];// 15=jumlah data,4=fitur R,G,B,D
 data[0][0] = 2.95;
 data[0][1] = 6.63;
 data[0][2] = 2.34;
 data[1][0] = 2.53;
 data[1][1] = 7.79;
 data[1][2] = 2.56;
 data[2][0] = 3.57;
 data[2][1] = 5.65;
 data[2][2] = 2.76;
 data[3][0] = 3.16;
 data[3][1] = 5.47;
 data[3][2] = 2.36;
 data[4][0] = 2.58;
 data[4][1] = 4.46;
 data[4][2] = 5.2;
 data[5][0] = 2.16;
 data[5][1] = 6.22;
 data[5][2] = 5.4;
 data[6][0] = 3.27;
 data[6][1] = 3.52;
 data[6][2] = 6;
 int[] group = { 1, 1, 1, 1, 2, 2, 2 };// 1=lemon,2=manis,3=nipis
 LDA lda = new LDA(data, group, true);
 lda.getTop2Vector();
 double[] tt = {123.0,23.0,4};
 double[] out = lda.getxydot(tt);
 for(int i=0;i<out.length;i++)
 {
     System.out.println(out[i]);
 }
    }
}

 

试用效果良好，实验数据为200维矩阵。