決策樹ID3算法的java實現

決策樹的分類過程和人的決策過程比較相似，就是先挑“權重”最大的那個考慮，然后再往下細分。比如你去看醫生，症狀是流鼻涕，咳嗽等，那么醫生就會根據你的流鼻涕這個權重最大的症狀先認為你是感冒，接着再根據你咳嗽等症狀細分你是否為病毒性感冒等等。決策樹的過程其實也是基於極大似然估計。那么我們用一個什么標准來衡量某個特征是權重最大的呢，這里有信息增益和基尼系數兩個。ID3算法采用的是信息增益這個量。

根據《統計學習方法》中的描述，G(D,A)表示數據集D在特征A的划分下的信息增益。具體公式：

G(D,A)=H(D)-H(D|A)。其中H(D)表示數據集D的熵，熵可以用來描述其混亂度，計算公式為

H(D)=可見對於數據集D而言，|Dk|表示類別為k的數量，其類別越多，越混亂。

而H(D|A)表示數據集D在A的划分下的的不確定性。他們的差也即是信息增益，表示由於特征A使得數據集D的分類的不確定減少的差，所以這個值越大說明A的分類對D越有效，也就是權重越大。

H(D|A)=|Dik|表示在特征A中value為i的划分下數據集類別為k的數量。

有了這兩個公式，接下來就可以寫代碼了。這里為了清晰的表示這個結果，采用了xml來輸出。由於剛開始學java所以只能即學即用（java和python簡直不能比，python寫ID3一百行代碼妥妥的搞定，java用了將近300行。。。）

算法步驟：

輸入：數據集D，特征集A（這里也可以輸入一個閥值，如果信息增益小於該閥值就直接作為葉節點，這樣可以避免過擬合）

輸出：xml文件

1 如果D中的類別是同一類，則作為葉節點，標記為該類Ck

2 如果特征集A中沒有特征了，那么作為葉節點，並且用數據集D中類別最多的類作為類標記

3 對D的各個特征求最大信息增益，選擇信息增益最大的特征Ag

4 對特征Ag中各個值ai繼續對數據集進行分割為Di

5 以Di為數據集，A-Ag為特征集為輸入進行1-4步驟

 

具體代碼：

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.XMLWriter;






class Utils{
    //用於從文件中獲取數據集
    public static ArrayList<ArrayList<String>> loadDataSet(String file) throws IOException{
        ArrayList<ArrayList<String>> dataSet=new ArrayList<ArrayList<String>>();
        FileInputStream fis=new FileInputStream(file);
        InputStreamReader isr=new InputStreamReader(fis,"UTF-8");
        BufferedReader br=new BufferedReader(isr);
        String line="";
        line=br.readLine();
        while((line=br.readLine())!=null){
            String[] words=line.split(",");
            ArrayList<String> data=new ArrayList<String>();
            for(int i=0;i<words.length;i++){
                data.add(words[i]);
            }
            dataSet.add(data);
        }
        br.close();
        isr.close();
        fis.close();
        return dataSet;
    }
    //用於從文件中獲取特征
    public static ArrayList<String> loadFeature(String file) throws IOException{
        FileInputStream fis=new FileInputStream(file);
        InputStreamReader isr=new InputStreamReader(fis,"UTF-8");
        BufferedReader br=new BufferedReader(isr);
        
        String[] line=br.readLine().split(",");
        ArrayList<String> feature=new ArrayList<String>();
        for(int i=0;i<line.length-1;i++){
            feature.add(line[i]);
        }
        br.close();
        isr.close();
        fis.close();
        return feature;
    }
    //用於獲得數據集中的類別列表
    public static ArrayList<String> getClassList(ArrayList<ArrayList<String>> dataSet){
        ArrayList<String> classList=new ArrayList<String>();
        int length=dataSet.get(0).size();
        for(ArrayList<String> data:dataSet){
            String label=data.get(length-1);
            classList.add(label);
        }
        return classList;
    }
    //返回數據集中的特征數
    public static int featureNum(ArrayList<ArrayList<String>> dataList){
        int len=dataList.get(0).size()-1;
        return len;
    }
    
    
//    public static void   writeToXML(String fileName) throws IOException{
//        Document document = DocumentHelper.createDocument();
//        Element root = document.addElement("DecisionTree");
//        Element outlook=root.addElement("outlook");
//        outlook.addAttribute("value","sunny");
//        Element humidity1=outlook.addElement("humidity");
//        humidity1.addAttribute("value","high");
//        humidity1.addText("no");
//        Element humidity2=outlook.addElement("humidity");
//        humidity2.addAttribute("value","normal");
//        humidity2.addText("yes");
//        
//        XMLWriter writer=new XMLWriter(new FileWriter(fileName));
//        writer.write(document);
//        writer.close();
//    }
    //用於獲得數據集中第index列的map映射，方便后續的遍歷value和計算熵
    public static Map<String,Integer> getSubMap(ArrayList<ArrayList<String>> dataSet,int index){
        int total=dataSet.size();
        Map<String,Integer> subMap=new HashMap();
        for(ArrayList<String> data:dataSet){
            String lable=data.get(index);
            if(subMap.get(lable)==null){
                subMap.put(lable,1);
            }else{
                subMap.put(lable,subMap.get(lable)+1);
            }
        }
        return subMap;
    }
    //打印map，用於debug的時候
    public static void showMap(Map<String,Integer> map){
        for(Map.Entry<String,Integer> entry:map.entrySet()){
            System.out.println(entry.getKey()+":"+entry.getValue());
        }
    }
    //求熵
    public static double getEntropy(ArrayList<ArrayList<String>> dataSet,int index){
        int total=dataSet.size();
        Map<String,Integer> subMap=getSubMap(dataSet,index);        
        double entropy=0;
        for(Map.Entry<String,Integer> entry:subMap.entrySet()){
            double temp=entry.getValue()*1.0/total;
            entropy+=temp*(Math.log(temp)/Math.log(2));
        }
        return -entropy;
    }
    //求信息增益最大的分割點
    public static String bestFeatureSplit(ArrayList<ArrayList<String>> dataSet,ArrayList<String> featureList){
        int length=dataSet.get(0).size();
        double totalEntropy=getEntropy(dataSet,length-1);
        
        
        
        int featureNum=dataSet.get(0).size()-1;
        int index=-1;
        double maxInfoGain=-1;
        for(int i=0;i<featureNum;i++){
            double entropy=getEntropy(dataSet,i);
            Map<String,Integer> map=getSubMap(dataSet,i);//獲得該特征下的map
            ArrayList<String> lableList=new ArrayList<String>();
            double entropySum=0;
            
            for(Map.Entry<String,Integer> entry:map.entrySet()){//這里的Di就是map中的特征的value值
                Map<String,Integer> subMap=new HashMap();
                
                
                for(ArrayList<String> data:dataSet){
                    if(data.get(i).compareTo(entry.getKey())==0){
                        if(subMap.get(data.get(length-1))==null){
                            
                            subMap.put(data.get(length-1),1);
                        }else{
                            subMap.put(data.get(length-1),subMap.get(data.get(length-1))+1);
                        }
                    }
                }
                double x=0;
                for(Map.Entry<String,Integer> subEntry:subMap.entrySet()){
                    double temp=subEntry.getValue()*1.0/entry.getValue();
                    x+=temp*(Math.log(temp)/Math.log(2));
                }
                
                entropySum+=-x*(entry.getValue())/dataSet.size();
            }
            entropySum=totalEntropy-entropySum;
            if(entropySum>maxInfoGain){
                index=i;
                maxInfoGain=entropySum;
            }
        }
        return featureList.get(index);
    }
    //分割數據集，index為特征的下標
    public static ArrayList<ArrayList<String>> splitDataSet(ArrayList<ArrayList<String>> dataSet,int index,String value){
        ArrayList<ArrayList<String>> subDataSet=new ArrayList<ArrayList<String>>();
        for(ArrayList<String> data:dataSet){        
            if(data.get(index).compareTo(value)==0){
                ArrayList<String> temp=new ArrayList<String>();
                for(int i=0;i<data.size();i++){
                    if(i!=index){
                        temp.add(data.get(i));
                    }
                }
                subDataSet.add(temp);
            }
        }
        return subDataSet;
    }
    //list-》map
    public static Map<String,Integer> arrayToMap(ArrayList<String> list){
        Map<String,Integer> map=new HashMap();
        for(String word:list){
            if(map.get(word)==null){
                map.put(word,1);
            }else{
                map.put(word,map.get(word)+1);
            }
        }
        return map;
    }
    //求label中某個數量最多的類別
    public static String major(ArrayList<String> labelList){
        Map<String,Integer> map=arrayToMap(labelList);
        int max=0;
        String label="";
        for(Map.Entry<String,Integer> entry:map.entrySet()){
            if(entry.getValue()>max){
                label=entry.getKey();
            }
        }
        return label;
    }
    
    public static Set<String> getValueFromDataSet(ArrayList<ArrayList<String>> dataSet,int index){
        ArrayList<String> values=new ArrayList<String>();
        for(ArrayList<String> data:dataSet){
            try{
            values.add(data.get(index));
            }catch(Exception e){
                
                System.out.println("index is "+index);
            }
        }
        Set<String> set=new HashSet();
        for(String value:values){
            set.add(value);
        }
        return set;
    }
    
    public static ArrayList<String> copyArrayList(ArrayList<String> src){
        ArrayList<String> dest=new ArrayList<String>();
        for(String s:src){
            dest.add(s);
        }
        return dest;
    }
    
    
    public static void showArrayList(ArrayList<ArrayList<String>> dataSet){
        for(ArrayList<String> data:dataSet){
            System.out.println(data);
        }
    }
    
}


public class DecisionTree {
    
    
    public static int  createTree(ArrayList<ArrayList<String>> dataSet,ArrayList<String> featureList,Element e){
        ArrayList<String> labelList=Utils.getClassList(dataSet);//獲取數據集中label的列表
        if(Utils.arrayToMap(labelList).size()==1){//表示label中只有一種類別，所以此時不需要再分類了
            e.addText(labelList.get(0));
            return 1;
        }
        if(dataSet.get(0).size()==1){//表示此時已經沒有特征了，所以也不需要再繼續了，此時以label中最多的類別為該節點的類別
            e.addText(Utils.major(labelList));
            return 1;
        }
        
        ArrayList<String> subFeatureList=Utils.copyArrayList(featureList);
        
        
        
        String feature=Utils.bestFeatureSplit(dataSet,featureList);
        subFeatureList.remove(feature);
        int index=featureList.indexOf(feature);

        Set<String> valueSet=Utils.getValueFromDataSet(dataSet,index);
//        Element next=e.addElement(feature);//原來的代碼位置
        for(String value:valueSet){
             Element next=e.addElement(feature);//后來放到這里之后，xml的輸出就正確了,原因在於每遞歸一次就需要創建一個element，所以應該在for內創建。
             next.addAttribute("value",value);
             ArrayList<ArrayList<String>> subDataSet=Utils.splitDataSet(dataSet,index,value);
             createTree(subDataSet,subFeatureList,next);
        }
        return 1;
    }
    
    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub
        String file="C:/Users/Administrator/Desktop/upload/DT.txt";
        String xml="C:/Users/Administrator/Desktop/upload/DT1.xml";
        ArrayList<ArrayList<String>> dataSet=Utils.loadDataSet(file);
        ArrayList<String> featureList=Utils.loadFeature(file);
        Document document = DocumentHelper.createDocument();
        Element root = document.addElement("DecisionTree");
        createTree(dataSet,featureList,root);
        XMLWriter writer=new XMLWriter(new FileWriter(xml));
        writer.write(document);
        writer.close();
        System.out.println("finished");
    }

}

這次除了算法上的理解更加深刻了外，在java上也學到了些關於xml解析，讀寫等方法。

另外對遞歸的使用也更加形象些，對於遞歸一個容易錯的點就是函數上的參數，一定要認真對待，要清楚該參數該在什么時候初始化，什么時候被用到。我一開始在第269行上就出現錯誤了，一開始沒有考慮清楚這個next該在什么時候分配，后來發現每次創建節點的時候我們在xml就要創建一個相應的節點用來描述他，所以應該是在for循環里面創建，如果在for外面創建就表示，該特征下的所有值都只有一個element。

當然對於set，map的遍歷啥的也更加清晰了。