datamining.java

基于weka平台的数据挖掘方法

import java.io.*;
import java.util.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import weka.core.*;
import weka.classifiers.*;
import weka.classifiers.functions.*;
//import weka.classifiers.functions.SMO;
import weka.classifiers.functions.supportVector.*;

class DataMining implements Runnable{
	FileReader my_reader;
	Instances my_instances;
	Classifier m_classifier;
	String outfilename;
	int randomseed;
	int fold;
	DataMining(){
		this("SMO.arff");
	}
	DataMining(String filename){
		this(filename,"DatMining.arff","weka.classifiers.functions.SMO",10,1);
	}
	DataMining(String infilename,String outfile,String classifier,int m_fold,int seed){
		try{
		my_reader=new FileReader(infilename);
		outfilename=outfile;
		my_instances=new Instances(my_reader);
		Class cl=Class.forName(classifier);
		m_classifier=(Classifier)cl.newInstance();
		
		fold=m_fold;
		randomseed=seed;
		}catch(Exception ex){
			ex.printStackTrace();
		}
	}
	DataMining(String infilename,String outfile,Classifier classifier,int m_fold,int seed){
		try{
		my_reader=new FileReader(infilename);
		outfilename=outfile;
		my_instances=new Instances(my_reader);
		
		m_classifier=classifier;
		
		fold=m_fold;
		randomseed=seed;
		}catch(Exception ex){
			ex.printStackTrace();
		}
	}
	public void setfold(int fold){
		this.fold=fold;
	}
	public int getfold(){
		return fold;
	}
	public void setClassifier(Classifier classifier){
		m_classifier=classifier;
	}
	public Classifier getClassifier(){
		return m_classifier;
	}
	public void setRandomSeed(int seed){
		randomseed=seed;
	}
	public int getRandomSeed(){
		return randomseed;
	}
	public void setInstances(Instances insts){
		my_instances=insts;
	}
	public Instances getInstances(){
		return my_instances;
	}
	public void setClassIndex(int index){
		my_instances.setClassIndex(index);
	}
	public void setClassIndex(){		
		int i=0;
		my_instances.setClassIndex(i);
		while(i<my_instances.numAttributes()){
			if(my_instances.attribute(i).name().equalsIgnoreCase("class")){
				my_instances.setClassIndex(i);
				break;
			}
			i++;
		}		
	}
	public double result(Classifier classify,Instances insts,int f,int seed){
		double d=0.0;
		try{
		Evaluation eval=new Evaluation(insts);
		eval.crossValidateModel(classify,insts,f,new Random(seed));		
		d=eval.pctCorrect();
		}catch(Exception ex){
			ex.printStackTrace();
		}
			return d;
	}
	public void run(){ 
		Instances insts=new Instances(my_instances);
		int m=insts.numAttributes();
		int n=1;
		double max_score[]=new double[m];
		double score=0.0,resl=0.0;
		double sec_score=0.0;
		int count=1;
                final Thread th=Thread.currentThread();
                JFrame jf=new JFrame("Calculating...");
                JTextArea jta=new JTextArea();
                JScrollPane jsp=new JScrollPane(jta);
                jf.addWindowListener(new WindowAdapter(){
                    public void windowClosing(WindowEvent e){
                        ((JFrame)e.getSource()).dispose();                 
                        th.stop();
                    }
                });
                jf.getContentPane().add(jsp);
                jf.setSize(460,260);
                jf.setLocation(260,260);
                jf.setVisible(true);
                try{
                    FileWriter fw=new FileWriter(outfilename);
                
		
		Instances second=insts;
		Instances storeinsts=insts;
		double storescore=0.0;
		int flag=0;
		score=result(m_classifier,insts,fold,randomseed);
		while(m>=5){
			sec_score=0.0;	
			flag=0;
			while(n<m){
                                String ss=String.format("%d %f \n",m,score);
                                jta.append(ss);
				Instances tmp=new Instances(insts);		
				tmp.deleteAttributeAt(n);		
				resl=result(m_classifier,tmp,fold,randomseed);
				if(score<=resl){
					score=resl;
					flag=1;
					insts=tmp;
					m--;
					if(storescore<=resl){
						storescore=resl;
						storeinsts=tmp;
					}
				
					}
					else
					{
						if(sec_score<resl){
							sec_score=resl;
							if(flag==0){
								count=n;
								second=tmp;
							}						
						}
						n++;
					}
					if(flag==1){
							if(max_score[m]<score)							
								max_score[m]=score;
					}
					else{
							if(max_score[m-1]<sec_score)
								max_score[m-1]=sec_score;
						}
						
			}
			if(flag==1)
				n=1;
			else{
				score=sec_score;
				insts=second;
				n=count;
				m--;
			}
		}
		for(int i=5;i<max_score.length;i++){
                        String ss=String.format("The accurary of %d features is %g\n",i,max_score[i]);
                        jta.append(ss);
		}
		
                fw.write(storeinsts.toString());
		fw.close();
                Evaluation eval=new Evaluation(storeinsts);
                eval.crossValidateModel(m_classifier,storeinsts,fold,new Random(randomseed));
                jta.append(eval.toSummaryString("\n---Summary of Cross-Validation Result for the Best Features---",true));
                jta.append(eval.toClassDetailsString("\n---Detail Accuracy for the Best Features---"));             
                jta.append(eval.toMatrixString("\n---Confusion Matrix for the Best Features---"));
                jta.append("\n");
                }catch(Exception ex){
                    ex.printStackTrace();
                }
                jta.append("END\n");
                jf.setTitle("Calculate Finished");
	}
	public static void main(String arg[]){
		DataMining dm=new DataMining();
		dm.setClassIndex();
		try{
			dm.run();
		}catch(Exception ex){
			ex.printStackTrace();
		}
		
	}
}