roughset.java

数据挖掘技术-粗糙集属性约减算法

    return Ind;
}

/*
private Instances[] pos(Instances data, Attribute[] C,Attribute D) {
	Instances POS;
	Instances ind
	for(int i=1;i < C.length;i++){
		ind(data,C[i]);
		
	}	
}
*/


private Instances pos(Instances[] condition, Instances[] decision,Instances data) {
	Instances Pos = new Instances(data, data.numInstances());

	int i, j;
//	double c =1.0; 
	
	
	if(condition==null){
		return null;
	}
	
	for (i = 0; i < decision.length&&decision[i].sumOfWeights()!=0; i++) {		
		for (j = 0; j < condition.length&&condition[j].sumOfWeights()!=0; j++) {
            if(XIncludeY(condition[j],decision[i])==1){
            	Enumeration instEnum = condition[j].enumerateInstances();
                while (instEnum.hasMoreElements()) {
                  Instance inst = (Instance) instEnum.nextElement();
            	  Pos.add(inst);
                }
            }
            
/*			
			int sum = 0;
			for (int m = 0; m < condition[j].numInstances(); m++) {
				for (int n = 0; n < decision[i].numInstances(); n++) {
					if (condition[j].instance(m).weight() == decision[i].instance(n).weight()) {
						sum++;
						break;
					}
				}
				
			}
			c = 1 - sum / condition[j].numInstances();
			if (c == 0) {
				for(int m = 0; m < condition[j].numInstances(); m++){
					Pos.add(condition[j].instance(m));
				}									
			}
			*/
		}
//			Enumeration instEnum1 = condition[j].enumerateInstances();
//			Enumeration instEnum2 = decision[i].enumerateInstances();
//			while ()
	}
	Pos.compactify();
	return Pos;
}

private double importance(Attribute[] C,Attribute[] D, Instances data) {
	int countC=1;
	for(int i=0;i<C.length&&C[i]!=null;i++){
		countC=countC*C[i].numValues();		
	}
	
	int countD=1;
	for(int i=0;i<D.length&&D[i]!=null;i++){

		countD=countD*(D[i].numValues());
		
	}
	
	Instances[] ind1 = new Instances[countC];
	Instances[] ind2 = new Instances[countD];
	ind1=ind(data,C);
	ind2=ind(data,D);
	Instances POS;
	POS=pos(ind1,ind2,data);
	
	double r = 0;
	
	if(POS==null){
		return r;
	}
	
	return r = (double)POS.numInstances() /(double) data.numInstances();
}

private int MaxAttribute(Attribute[] R,Attribute[] D,Instances data,double Rr ){
	int i=0,max=0,l,n;
	double r;
	
	Attribute[] C=new Attribute[data.numAttributes()-1];
	Enumeration attEnum = data.enumerateAttributes();
    while (attEnum.hasMoreElements()) {
      Attribute att = (Attribute) attEnum.nextElement();
      C[i]=att;
      i++;
    }
    Attribute[] B=new Attribute[R.length+1];
    Attribute[] Q=new Attribute[R.length];
    
    int conut=0;
    for(i=0;i<R.length&&Q[i]!=null;i++){
    	conut++;
    }
    	
    	
    Attribute[] C1=new Attribute[C.length-conut];
    
    
    
    for(int k = 0;k<R.length;k++){
		Q[k]=R[k];
	}
    int j=0;
    int flag;
	for(int k = 0;k<C.length&&C[k]!=null;k++){
		flag=1;
		for(i=0;i<Q.length&&Q[i]!=null;i++)	{
			if(Q[i]==C[k]){
				flag=0;
				break;
			}			
		}
		if(flag==1){
			C1[j]=C[k];
			j++;
		}
	}
	
	
	l=j;
	double[] SGF=new double[l];
	for(i=0;i<l;i++){
		SGF[i]=0.0;
	}
	int p=0;
	while(p<l){
		for(n=0;n<Q.length;n++){
			B[n]=Q[n];
		}
		for(n=0;n<B.length;n++){
			if(B[n]==null&&C1[p]!=null){
				B[n]=C1[p];
				break;
			}
		}
		
		r=importance(B,D,data);
		SGF[p]=r-Rr;
		if(SGF[0]<SGF[p]){
			max=p;
			SGF[0]=SGF[p];
		}
		p=p+1;
	}
	return max;
}

private int XIncludeY(Instances X, Instances Y) {
    int flag=0,sum=0;
    Enumeration instEnumX = X.enumerateInstances();
    Enumeration instEnumY = Y.enumerateInstances();
//    Enumeration instEnumY1 = Y.enumerateInstances();
    Instance instX,instY;
    
    while (instEnumX.hasMoreElements()) {
    	instX= (Instance) instEnumX.nextElement();
    	instEnumY = Y.enumerateInstances();
      while (instEnumY.hasMoreElements()){
    	  instY= (Instance) instEnumY.nextElement();
    	  if (instX.weight() == instY.weight()) {
				sum++;
				break;
           }
      }
    }
    flag=sum / X.numInstances();
	return flag;
}

private void makeRules(Instances data){
	
	Instances Data = new Instances(data, data.numInstances());
	int d=1,p;
	
	RoughSetRule rule = null;
	
	Enumeration instEnum = data.enumerateInstances();
    while (instEnum.hasMoreElements()) {
      Instance inst = (Instance) instEnum.nextElement();
      inst.setWeight((double)d);
      Data.add(inst);
      
      d++;
    }
    int i=0;
    Enumeration attEnum = Data.enumerateAttributes();
    Attribute[] C=new Attribute[Data.numAttributes()-1];
    while (attEnum.hasMoreElements()) {
      Attribute att = (Attribute) attEnum.nextElement();
      C[i]=att;
      i++;
    }
    Attribute[] C1=new Attribute[Data.numAttributes()-1];
    
    for(int k = 0;k<C.length;k++){
		C1[k]=C[k];
	}
    Attribute[] D=new Attribute[1];
    Attribute att=data.classAttribute();
    D[0]=att;
//    Attribute[] B=new Attribute[Data.numAttributes()];
    
    Attribute[] B=new Attribute[Data.numAttributes()-1];
    Attribute[] C2=new Attribute[Data.numAttributes()-1];
	int n=0;
	int Flag;
	int C2num;
	for(int k = 0;k<C.length&&C[k]!=null;k++){
		Flag=1;
		for(i=0;i<B.length&&B[i]!=null;i++){
			if(B[i]==C1[k]){
				Flag=0;
				break;
			}
		}
		if(Flag==1){
			C2[n]=C[k];
			n++;
		}
	}
	C2num=n-1;
    while(C2num>-1){
 
    	double Br=importance(B,D,Data);
    	int j=MaxAttribute(B,D,Data,Br);
    	
    	
    	for(i=0;i<B.length;i++){
    		if(B[i]==null){
    			B[i]=C2[j];
    			break;
    		}
    	}
    	
    	int countB=1;
    	for(i=0;i<B.length&&B[i]!=null;i++){
    		countB=countB*B[i].numValues();
    	}
    	
    	Instances[] indUB = new Instances[countB];
    	indUB=ind(Data,B);
    	
    	int countD=1;
    	for(i=0;i<D.length&&D[i]!=null;i++){
    		countD=countD*D[i].numValues();
    	}
    	Instances[] indUD = new Instances[countD];
    	indUD=ind(Data,D);
    	
    	int[] flag = new int[countB];
    	for(i=0;i<flag.length;i++){
    		flag[i]=0;
    	}
    	int y=0;
    	while(y<countD){
    		if(indUD[y].sumOfWeights()==0){
    			y=y+1;
    			continue;//goto y=y+1;
    		}
    		p=0;
    		while(p<countB){
    			if(flag[p]==1){
    				p=p+1;
    				continue;// goto p=p+1;
    			}
    			if(indUB[p].sumOfWeights()==0){
    				p=p+1;
    				continue;
    			}
    			if((XIncludeY(indUB[p],indUD[y]))==1){
    				
    				
 //   				ruleXY(indUB[p],B,D); //  desX==>desY;
    				rule=addRule(rule,ruleXY(indUB[p],B,D,data));
    				
    				
    				
    				Data=UlessX(Data,indUB[p]);
    				indUD[y]=UlessX(indUD[y],indUB[p]);
    			}
    			p=p+1;
    		}
	
    	y=y+1; 
    	}
    
    
    n=0;
	
	for(int k = 0;k<C.length&&C[k]!=null;k++){
		Flag=1;
		for(i=0;i<B.length&&B[i]!=null;i++){
			if(B[i]==C1[k]){
				Flag=0;
				break;
			}
		}
		if(Flag==1){
			C2[n]=C[k];
			n++;
		}
	}
	C2num=n-1;
	for(i=n;i< C2.length;i++){
		C2[i]=null;
	}
	
   }
}


 
 private Instances UlessX(Instances U, Instances X){
	 
	 int flag;
	 Enumeration instEnumU = U.enumerateInstances();
	 Enumeration instEnumX = X.enumerateInstances();
//	 Enumeration instEnumX1 = X.enumerateInstances();
	 
	 Instance instX,instU;
	 Instances U1=new Instances(U, U.numInstances());
	    
	    while (instEnumU.hasMoreElements()) {
	    	flag=1;
	    	instU= (Instance) instEnumU.nextElement();
	    	instEnumX = X.enumerateInstances();
	      while (instEnumX.hasMoreElements()){
	    	  instX= (Instance) instEnumX.nextElement();
	    	  if (instX.weight() == instU.weight()) {
	    		  flag=0;
	    		  break;
	    	  }
	      }
	      if(flag!=0){
	         U1.add(instU);  
	       }
	      
	    }
	    U1.compactify();
	  return U1;  
 }
 
private RoughSetRule ruleXY(Instances X,Attribute[] B,Attribute[] D,Instances data){
/*	
	Enumeration attEnum = X.enumerateAttributes();
	Attribute[] C=new Attribute[X.numAttributes()];
	int i=0;
    while (attEnum.hasMoreElements()) {
      Attribute att = (Attribute) attEnum.nextElement();
      C[i]=att;
      i++;
    }
  */  
	
	RoughSetRule rule =new RoughSetRule(data);
    Attr attr = null, oldAttr = null;
    
	Enumeration instEnum = X.enumerateInstances();
	Instance inst =new Instance(1);
	while (instEnum.hasMoreElements()) {
		inst= (Instance) instEnum.nextElement();
	   break;
	}
//   inst.toString();
	   for(int i=0;i<B.length;i++){
		   if(B[i]==null){
			   break;
		   }
		   attr = new Attr();
//		   attr.m_next=null;
		   attr.m_attr=B[i].index();
		   attr.m_val=(int) inst.value(B[i]);
//		   text.append(B[i].name() + " = " + B[i].value((int) inst.value(B[i])));
//		   if((i+1)<B.length&&(B[i+1]!=null)){
//			   text.append( " and " ); 
//	        }
		   oldAttr = addAttr(rule, oldAttr, attr);
	   }
//	   text.append( " ==> " + D[0].value((int) inst.value(D[0])));
//	   text.toString();
	   rule.m_classification=(int) inst.value(D[0]);
	   rule.m_num=X.numInstances();
	   
	   return rule;
	
}


/**
 * Prints a description of the classifier.
 *
 * @return a description of the classifier as a string
 */
public String toString() {

  if (m_rules == null) {
    return "RoughSet: No model built yet.";
  }
  return "RoughSet rules\n----------\n" + m_rules.toString();
}

public static void main(String[] args) {
    runClassifier(new RoughSet(), args);
  }
}