getdata.java

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

package core;

//import Node;

import java.io.BufferedReader;
import java.io.FileReader;

import util.MyClassifier;
import util.NoiseGen;
import util.StatInstances;
import weka.classifiers.Classifier;
import weka.classifiers.bayes.NaiveBayes;
import weka.classifiers.functions.SMO;
import weka.core.Instance;
import weka.core.Instances;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.Random;

public class getdata {
	
	public static Instances trainData;
	public static Instances testData;
	public static Instances noisetrainData;
	public static Instances noisetestData;
    
    public static double[] derout;
    //mean der out
    public static double[] dermeanout;
    
	
	public static Instances[] morenoisetrain;
	public static Instances[] morenoisetest;
	
	public static Instances moredata;
	public static Instances meandata;
    
    public static Node[] array;
	
    public static double dersum;
    //mean der sum
    public static double dermeansum;
    
    public static double[][] originnoise;
    public static double[][] noise;
    
    public static int datanum;
    public static int dim; 
    
    public  getdata(int dataset) throws Exception
    {
    	
        String originTrainRead="";
        String originTestRead="";

    	switch(dataset){

    	case 0 :
           originTrainRead = "origin/ionosphere/ionosphere_train.arff";
    	   originTestRead = "origin/ionosphere/ionosphere_test.arff";
    	   System.out.println("ionosphere dataset");
    	   break;
    	case 1 :
    	   originTrainRead = "origin/iris/iris_train.arff";
    	   originTestRead = "origin/iris/iris_test.arff";
    	   System.out.println("iris dataset");
           break;
    	case 2 :
           originTrainRead = "origin/satimage/satimage_train.arff";
    	   originTestRead = "origin/satimage/satimage_test.arff";
    	   System.out.println("satimage dataset");
    	   break;
    	case 3 :  
    	   originTrainRead = "origin/segment/segment_train.arff";
    	   originTestRead = "origin/segment/segment_test.arff";
    	   System.out.println("segment dataset");
    	   break;
    	case 4 :
    	   originTrainRead = "origin/sonar/sonar_train.arff";
    	   originTestRead = "origin/sonar/sonar_test.arff";
           System.out.println("sonar dataset");
    	   break;
    	case 5 :   
    	   originTrainRead = "origin/waveform/waveform_train.arff";
    	   originTestRead = "origin/waveform/waveform_test.arff";
           System.out.println("waveform dataset");
           break;
    	case 6 :
    	   originTrainRead = "origin/wdbc/wdbc_train.arff";
    	   originTestRead = "origin/wdbc/wdbc_test.arff";
           System.out.println("wdbc dataset");
           break;      
    	case 7 :
    	   originTrainRead = "origin/wine/wine_train.arff";
    	   originTestRead = "origin/wine/wine_test.arff";
    	   System.out.println("wine dataset");
    	   break;  
    	       	       
    	case 8 :
    	   originTrainRead = "origin/optdigits/optdigits_train.arff";
    	   originTestRead = "origin/optdigits/optdigits_test.arff";
    	   System.out.println("optdigits dataset");
    	   break;      
    	
    	case 9 :
    	   originTrainRead = "origin/pendigits/pendigits_train.arff";
    	   originTestRead = "origin/pendigits/pendigits_test.arff";
    	   System.out.println("pendigits dataset");
    	   break;
    	   
    	case 10 :
     	   originTrainRead = "origin/twomoons/TwoMoons_train.arff";
     	   originTestRead = "origin/twomoons/TwoMoons_test.arff";
     	   System.out.println("TwoMoons dataset");
     	   break;
    	}
    	
    	trainData = new Instances(new BufferedReader(new FileReader(originTrainRead)));
    	trainData.setClassIndex(trainData.numAttributes() - 1);
    	trainData.sort(trainData.numAttributes()-1);
    	
    	
    	
    	testData = new Instances(new BufferedReader(new FileReader(originTestRead)));
    	testData.setClassIndex(testData.numAttributes() - 1);
    	testData.sort(testData.numAttributes()-1);

    	StatInstances st=new StatInstances(trainData);
    	double[] der=st.calcDer();
    	
    	//每个object有自己独立的各维噪声方差，存储在矩阵noise中。
       	Random uniRandom = new Random(new Date().getTime());
        
       	originnoise=new double[trainData.numInstances()][der.length];
       	datanum=trainData.numInstances();
       	dim=der.length;
       	
       	
    	for(int a=0;a<datanum;a++)
    	{
    		for(int b=0;b<dim;b++)		
    		{	
    			originnoise[a][b]=der[b]*uniRandom.nextDouble();
    		}
    	}


    }

public int showdim()
{
	return dim;
}

public double[][] shownoise()
{
	return noise;
}

public static void gendata(double noiselevel) throws Exception {
	   	
	noisetrainData = new Instances(trainData);	
	noisetestData = new Instances(trainData);
		
   	noise=new double[datanum][dim];
   	
	for(int a=0;a<datanum;a++)
	{
		for(int b=0;b<dim;b++)		
		{	
			noise[a][b]=originnoise[a][b]*noiselevel;
		}
	}
	
	
	NoiseGen[] noiseGen=new NoiseGen[datanum];	
		
	double[] mean=new double[dim];	
	
	for (int i=0;i<dim;i++) //形成噪声的均值和方差向量		{			
	{
		mean[i]=0.0;
	}

	for(int km=0;km<trainData.numInstances();km++)
	{				
		noiseGen[km]=new NoiseGen(mean,noise[km]);
		noiseGen[km].GenNorDistributiion();
	}
	
	for(int j=0;j<noisetrainData.numInstances();j++)
	{
		double[] gn=noiseGen[j].getNoise();//产生噪声		
		
		
		for (int k=0;k<gn.length;k++){//加入噪声
			
			noisetrainData.instance(j).setValue(k,noisetrainData.instance(j).value(k)+gn[k]);
			
		}
	}
	//noisetrainData.sort(noisetrainData.numAttributes()-1);
	
	
	for(int j=0;j<noisetestData.numInstances();j++)
	{
				
		double[] gn=noiseGen[j].getNoise();
		for (int k=0;k<gn.length;k++){//加入噪声
			
			noisetestData.instance(j).setValue(k,noisetestData.instance(j).value(k)+gn[k]);
			
		}
	}
	
	//noisetestData.sort(noisetestData.numAttributes()-1);	
	
	//生成噪声点数组
	int num=100;

	
	morenoisetrain = new Instances[num];
	
	for (int m=0;m<num;m++){
		
		morenoisetrain[m]=new Instances(trainData,0);		
		
		for(int j=0;j<trainData.numInstances();j++)
		{
			
				Instance tmpins=new Instance(trainData.instance(j));
				double[] gn=noiseGen[j].getNoise();//产生噪声		
				for (int k=0;k<gn.length;k++)
				{//加入噪声			
		    		tmpins.setValue(k,tmpins.value(k)+gn[k]);
				}
				morenoisetrain[m].add(tmpins);
					
		}
		
	//	morenoisetrain[m].sort(morenoisetrain[m].numAttributes()-1);
		
	}
			
	//生成噪声点数组
	int tnum=100;
	
	morenoisetest=new Instances[tnum];	
	
	for (int m=0;m<tnum;m++)
	{
			morenoisetest[m]=new Instances(trainData,0);
		
			for(int j=0;j<trainData.numInstances();j++)
			{
				Instance tmpins=new Instance(trainData.instance(j));
				double[] gn=noiseGen[j].getNoise();//产生噪声		
				for (int k=0;k<gn.length;k++)
				{//加入噪声			
		    		tmpins.setValue(k,tmpins.value(k)+gn[k]);
				}
				morenoisetest[m].add(tmpins);
			}		
		
		//morenoisetest[m].sort(morenoisetest[m].numAttributes()-1);
		
	}
	
		
	}


}