mymath.java

Java语言实现的支持向量机的源码。对研究人工智能的朋友有用。

package util;

import weka.core.Attribute;
import weka.core.FastVector;
import weka.core.Instance;
import weka.core.Instances;
import weka.core.matrix.Matrix;

//一些普通算法
public class MyMath{

    public MyMath(){
    }
    //对数组降序排列，并取得排序后的下标数组, array[...] >=0
    public int[] sort_index(double[] array){
        int[] index = new int[array.length];
        int max;
        for(int i=0;i<array.length;i++){
            max = 0;
            for(int j=1;j<array.length;j++){
                if(array[j]>array[max])
                    max = j;
            }
            index[i] = max;
            array[max]=-1; // 假设数组元素都是大于等于0
        }
        return index;
    }

    // 对数组进行升序排序
    public int[] sort_insert(int[] d){
        int length = d.length;

        for(int i=1;i<length;i++){
            int j=i;
            while(j>0){
                if (d[j] < d[j - 1]) {
                    int temp = d[j];
                    d[j] = d[j - 1];
                    d[j - 1] = temp;
                }
                j--;
            }
        }
        return d;
    }

    public double[] sort_insert(double[] d){
        int length = d.length;

        for(int i=1;i<length;i++){
            int j=i;
            while(j>0){
                if (d[j] < d[j - 1]) {
                	double temp = d[j];
                    d[j] = d[j - 1];
                    d[j - 1] = temp;
                }
                j--;
            }
        }
        return d;
    }
    
    //输出数组
    public void output(int[] d){
        System.out.println("\n\n^^^^^^^^^^^^");
        for(int i=0;i<d.length;i++){
            System.out.println(d[i]);
        }
        System.out.println("^^^^^^^^^^^^\n\n");
    }

    //输出数组
    public void output(double[] d){
        System.out.println("\n\n^^^^^^^^^^^^");
        for(int i=0;i<d.length;i++){
            System.out.println(d[i]);
        }
        System.out.println("^^^^^^^^^^^^\n\n");
    }
    
    //降维
    public Instances RD(int fn, int[] feature, Instances data){
   	 int idx,i,j;
   	 FastVector fv = new FastVector();
   	 //设置特征属性
   	 for(idx=0;idx<fn;idx++){
   		 fv.addElement(new Attribute("F"+idx));
   	 }
   	 //设置类属性
   	 FastVector classAttribute = new FastVector();
   	 for(idx=0;idx<data.numClasses();idx++){
   		 classAttribute.addElement(""+idx);
   	 }
   	 fv.addElement(new Attribute("class",classAttribute));
   	 //创建新实例集
   	 Instances ND = new Instances("RD_"+data.relationName(),fv,data.numInstances());
   	 for(idx=0;idx<data.numInstances();idx++){
   		 Instance f = new Instance(fn+1);
   		 for(j=0;j<fn;j++){
   			 f.setValue(j,data.instance(idx).toDoubleArray()[feature[j]]);
   		 }
   		 f.setValue(j,(int)data.instance(idx).classValue());
   		 ND.add(f);
   	 } 
   	 ND.setClassIndex(fn);
   	 return ND;
    }
    
    //若key 在array中，则返回true； 否则返回 false
    public static boolean isIn(int key, int[] array,int n){
        for(int i=0; i<array.length && i<n; i++){
            if(key == array[i]) return true;
        }
        return false;
    }
    
  //快速排序
    private void runSort(Matrix A, Matrix B, int left, int right) {
		int i, j;
		double middle, temp;
		i = left;
		j = right;
		middle = A.get(A.getColumnDimension() / 2, A.getColumnDimension() / 2);
		do {
			while(A.get(i, i) > middle && i < right) i++;
			while(A.get(j, j) < middle && j > left) j--;
			if (i <= j) {
				temp = A.get(i, i);
				A.set(i, i, A.get(j, j));
				A.set(j, j, temp);
				for (int k = 0; k < B.getRowDimension(); k++) {
					temp = B.get(k, i);
					B.set(k, i, B.get(k, j));
					B.set(k, j, temp);
				}
				i++; 
				j--;
			}
		}while (i <= j);
		
		if (left < j) runSort(A, B, left, j);
		if (right > i) runSort(A, B, i, right);
	}
	public void quickSort(Matrix A, Matrix B) {
		runSort(A, B, 0, A.getRowDimension() - 1);
	}
	//计算两个集合分布的相似性
	public double cmpP(Instances In, Instances Out){
		double A[] = new double[In.numAttributes()];
		double B[] = new double[Out.numAttributes()];
		int i,j;
		for(i=0;i<In.numAttributes()-1;i++){
			A[i] = 0.0;
		}
		for(i=0;i<Out.numAttributes()-1;i++){
			B[i] = 0.0;
		}
		for(j=0;j<In.numAttributes()-1;j++){
			for(i=0;i<In.numInstances();i++){
				A[j] += In.instance(i).value(j);
			}
			A[j] /= In.numInstances();
		}
		for(j=0;j<Out.numAttributes()-1;j++){
			for(i=0;i<Out.numInstances();i++){
				B[j] += Out.instance(i).value(j);
			}
			B[j] /= Out.numInstances();
		}
    	double r = 0;
    	for(i=0;i<In.numAttributes()-1;i++) r+=(A[i]-B[i])*(A[i]-B[i]);
    	return r;
	}
    //计算两个实例之间的相似程度,采用欧式距离
	public double CalSim(Instance A, Instance B){
    	double Ar[] = A.toDoubleArray();
    	double Br[] = B.toDoubleArray();
    	double r = 0.0;
    	int fNum = A.numAttributes()-1;
    	for(int i=0;i<fNum;i++) r=r+(Ar[i]-Br[i])*(Ar[i]-Br[i]);
    	return r;
    }
	
	//输入参数为两个instance,der[],omit
	public double CalEachDemSim(Instance A,Instance B,double[] der,double omit)
	{
		double Ar[] = A.toDoubleArray();
		double Br[] = B.toDoubleArray();
		double r = 0.0;
		double t =1.0;
		int fNum = A.numAttributes()-1;
		for(int i =0; i<fNum;i++) 
		{
			r = r+(Ar[i]-Br[i])*(Ar[i]-Br[i])/(der[i] +omit);
			//System.out.println("the der["+i+"]"+" is "+der[i]  );
			t =t* Math.sqrt(4*der[i]/omit+2);
		}	
		
		//double v=Math.exp(-r)/t;
		double v=Math.exp(-r);
		//System.out.println("r is "+r+"  t is "+t+"  exp(-r)/t is "+v+"  the original value is "+CalSim(A,B));
		return v;
		
		
	}
	
	
}