artianomalyg.java

自己编写的一个小算法 用于weka中

    package weka.ArtiAG;
 
    import java.io.*;
    import java.util.*;
   
    import weka.classifiers.*;
    import weka.classifiers.rules.JRip;
    import weka.core.*;
    import weka.datagenerators.DataGenerator;
  
  
    public class ArtiAnomalyG
		{  
			
			  Double [] classvalue;
			
        Attribute []attributes;

		  	Instances instances;
		  	FastVector attri=new FastVector(0);

			  String [][]attribute_Value;/*每个属性的取值范围或取值集合*/

			  int numInstances;
		  	int numAttributes;

        Instance instance;
		  	Instances finalInsts;
        
            
        Integer [] number;
			  
			  
			  Double values[][];
            
        int numClass;

//===========================================================================================	 

        public ArtiAnomalyG(Instances instan)
			  {
		          instances=new Instances(instan);
		          
		        		      
	            finalInsts=new Instances(instances);//最终产生出的finalInsts数据集是原有数据集与产生出的人工异常数据集的集合.*/
	            				  
				      numInstances=instances.numInstances();
              numAttributes=instances.numAttributes();
                
              instances.setClassIndex(numAttributes-1);/*因为从文件中读出数据后放在Instances对象中,该对象的classIndex为-1,
              需要重新赋类标classIndex,类标指的是所有属性的标识.如共有42个属性,最后一个为类标,因此类标为41.*/
				  
				   
				      /*将enumeration转换为fastvector.*/ 
				      Enumeration enume=instances.enumerateAttributes();
            		
				      
				      attributes=new Attribute[numAttributes];
			        /*获取了每一个特征,并且为Attribute类对象*/
              for(int w=0;w<numAttributes;w++)
                      attributes[w]=(Attribute)enume.nextElement();
				          

			        numClass=instances.classAttribute().numValues();/*有几种类别*/
                
				      number=new Integer[numClass];
				      
				      
				     
			  }
			  
//===========================================================================================					  
			  
			  
			  protected void summaryAttributeNum()/*用来统计每个属性取值在训练数据集中出现的次数,
			  是ArtiAnomalyG算法制造人工异常实例的一个前提处理,对于数值型的属性,只要获取其的最大取值及最小取值即可.*/
			  {
			  	    int thenum=0;
			  	
			  	    attribute_Value=new String[attributes.length][];
                                                                     
              for(int a=0;a<attributes.length;a++)
				      {  
				  	
				           if(instances.attribute(a).isNumeric())
				  	       {
				  	      	      thenum++;
				  	      	      attribute_Value[a]=null;
				  	       }/*统计有多少个字段是数值型*/
				  	       else
				  	       {
			                    attribute_Value[a]=new String[instances.attribute(a).numValues()];

					                Enumeration enmer=instances.attribute(a).enumerateValues();
					                for(int b=0;enmer.hasMoreElements();b++)
	                        { 
                                attribute_Value[a][b]=new String((String)enmer.nextElement());      
		                      }
		               }				 /*获取特征的所有取值*/

				      }
				     
				      values=new Double[thenum][2];/*创建一个二维数组,该数组共有thenum个元素,而且每个元素又是一个一维数组,共有两个元素*/
				      for(int a=0,p=0;a<attributes.length;a++)
				      {
				     	     if(attribute_Value[a]==null)
				     	     /*对于real类型的字段需要统计出取值范围来。weka系统只统计非numeric类型字段的取值个数*/
				  	       {	         
				  	      	      values[p][0]=new Double(instances.instance(0).value(a));
				  	      	      values[p][1]=new Double(instances.instance(0).value(a));
				  	      	      for(int qq=1;qq<numInstances;qq++)
				  	      	      {
				  	      	      	     if(instances.instance(qq).value(a)>values[p][0].doubleValue())
				  	      	      	             values[p][0]=new Double(instances.instance(qq).value(a));
				  	      	      	     else if(instances.instance(qq).value(a)<values[p][1].doubleValue())
				  	      	      	             values[p][1]=new Double(instances.instance(qq).value(a));
				  	      	      }
				  	      	      
				  	      	      p++;
				  	      }     
				      }
				     
  
			  }
			  
//===========================================================================================			  
			  

			  protected void summaryNum()/*用来统计每个类别的实例数目*/
			  {
                 
             for(int k=0;k<number.length;k++)
			       {
				           number[k]=new Integer(0);
			       }
			     
			        
			     
			       Enumeration enmer=instances.classAttribute().enumerateValues();/*获取了类别的标识, 以字符串形式给出*/	  
				     for(;enmer.hasMoreElements();attri.addElement(enmer.nextElement()));
				     
				     
			     
			       classTovalue(); /*作用是将字符串形式的类别转为数值类型来表示*/
			     
			     
			       for(int i=0;i<numInstances;i++)
			       {
                
				               instance=instances.instance(i);	
		           		                
                       for(int j=0;j<numClass;j++)
				               {
				         	
				                     if(classvalue[j].doubleValue()==instance.classValue())/*需要得到值*/
							               {		    	
								                     number[j]=new Integer(number[j].intValue()+1);
								                     
							               }
  		    	           }

			       }/*用于统计各种类别的实例数目*/
			    			    
				      
			  }
			          
			     
//===========================================================================================


			  protected Instances artiGenerator(String className)
				/*className为人工标识的类标*/
			  {
             	
	           Instances artiInsts=new Instances(instances,0);
	           /*希望将产生出的人工异常实例放在该数据集中. 
	            该类有一个数据成员为finalInsts,在该方法中,也将产生出的人工异常实例放到finalInsts数据集中.*/
             int artianomalyNum=0;
              
             Integer []num;
            
             Instance instance1;
             
             Instance []insts=new Instance[numInstances];
             Enumeration enume=instances.enumerateInstances();/*获取instances中的每一个实例*/
             for(int p=0;enume.hasMoreElements();p++)
             {
            	     insts[p]=(Instance)enume.nextElement();
             }
             
             
             summaryAttributeNum();             
                 	
             int ii=0;                 	          
            
             for(int i=0;i<numAttributes-1;i++)
            /*外层循环：取属性*/
             {    	
            		   
            		               		   
            		   
            		   int flag_value=0;
            		   /*起标记的作用,最外层的一次循环中,如果进入过attribute_Value[i]==null的条件中,
            		   ii的值就加1,之后无论进入到多少次,都不再增加,当进入下一轮最外层循环时,ii值再加1.
            		   选用一个整型数作标记,只要进入一次attribute_value[i]==null,flag_value的值就加1,因此它的值
            		   表示了进入多少次循环.只有第一次进入的时候,ii值才增加.*/
            		   
            		   num=new Integer[numInstances];
            		    
            		   for(int l=0;l<num.length;l++)
					         {
                        num[l]=new Integer(1);/*全部初始化为1*/
					         }	
            		   
            		   
            		   for(int j=0;j<numInstances-1;)
                   {
                        for(int k=j+1;k<numInstances;k++)
                        {  	                
            	                   if(insts[k].value(i)-insts[j].value(i)<1e-6)
            	                   {
            	                	      num[j]=new Integer(num[j].intValue()+1);
            	          	            num[k]=new Integer(-j);
            	                   }
                        } /*处理为-j,负号表示该位置特征值在前面已经出现过,|-j|绝对值表示该位置特征值与|-j|下标特征值相同.*/

                        for(j++;j<numInstances-1&&num[j].intValue()<=0;j++);                 
                   }
            	
            
                       
					         int countVmax=num[0].intValue();
					         for(int m=1;m<num.length;m++)
					         {
						 	           if(countVmax<num[m].intValue())
								                countVmax=num[m].intValue();
					         }/*获取数据num中最大的数*/

                       
					         for(int n=0;n<numInstances;)
					         {
						             int countV;
						             
						             if(num[n].intValue()<=0)
								                   countV=num[-(num[n].intValue())].intValue();
							           else
								                   countV=num[n].intValue();
							
							
							           for(int j=countV+1;j<=countVmax;j++)
						             {
                                                                                                 
								                  Instance d=instances.instance((int)(Math.random()*numInstances));