决策树算法——ID3

决策树算法是一种有监督的分类学习算法。利用经验数据建立最优分类树，再用分类树预测未知数据。

例子：利用学生上课与作业状态预测考试成绩。

上述例子包含两个可以观测的属性：上课是否认真，作业是否认真，并以此预测考试成绩。针对经验数据，我们可以建立两种分类树

两棵树都能对经验数据正确分类，实际上第二棵树更好，原因是什么呢？在此，我们介绍ID3分类算法。

1、信息熵

例如，我们想要获取球队比赛胜负的信息：中国队vs巴西队、中国队vs沙特队。

哪场比赛信息量高？答案是中国队vs沙特队。原因是中国队vs沙特队输赢的确定性小于中国队vs巴西队输赢的确定性。

假设样本集合是D，其中第k类样本所占的比例为pk，则D的信息熵为

假设中国队vs巴西队输的概率为80%，则信息量Ent = -0.8 * log2(0.8) - 0.2 * log2(0.2) = 0.722。

假设中国队vs沙特队输的概率为50%，则信息量Ent = -0.5 * log2(0.5) - 0.5 * log2(0.5) = 1。

我们可以看出来，不确定性越高的场景包含越多的信息量。

2、信息增益

实际应用中，单独使用信息熵的情况比较少，往往使用信息熵的增益来指导工作。

基于信息熵，我们可以对某个属性a定义"信息增益"

其中，a属性有V个可能取值，而D中在属性a上取值为的样本记为Dv。

比如我们买足彩竞猜两支球队的输赢，我们可以获得两个消息中的一个：比赛球队是哪两个球队，比赛日期是哪一天。你愿意获取哪一个消息？相信大部分人都会选择前一个消息。原因很简单，前一个消息对于我们预测输赢的帮助高于后一个消息。

在我们没有任何额外信息的情况下，两支球队的输赢为50%。但是当我们知道了球队名称后，我们可以根据他们的FIFA排名来预测输赢。FIFA排名高的赢得概率更高。仅仅知道比赛日期可能对于我们的预测没有太大帮助。

比如我们知道了是中国队vs巴西队的比赛，则信息增量为1-0.722 = 0.278。

3、ID3算法原理

每次分类，我们选取信息增益最大的属性进行分类，然后进行递归分类。

对于文章开始的例子，初始信息熵为Ent = -0.5 * log2(0.5) - 0.5 * log2(0.5) = 1。

选择认真上课属性后，信息熵Ent(认真上课)  = -5/8 * ((3/5 * log2(3/5) - 2/5 * log2(2/5)) - 3/8 * ((1/3 * log2(1/3) - 2/3 * log2(2/3)) = 0.951，信息增益为0.049。

选择认真作业属性后，信息熵Ent(认真作业)  = -4/8 * ((1 * log2(1) - 0 * log2(0)) - 4/8 * ((1 * log2(1) - 0 * log2(0)) = 0，信息增益为1。

所以选择认真作业属性更优。

4、实例

根据年龄，身份，收入，信用预测买电脑的情况。java代码如下

package com.coshaho.learn.detree;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 *
 * ID3Tree.java Create on 2018年6月19日 上午12:29:06
 *
 * 类功能说明:   ID3 决策树算法
 *
 * Copyright: Copyright(c) 2013
 * Company: COSHAHO
 * @Version 1.0
 * @Author coshaho
 */
public class ID3Tree
{
    public void createTree(String[] feature, int[][] data)
    {
        Node root = new Node();
        root.setParent(null);
        root.setFeature("root");
        root.setValue(-1);
        root.setLevel(0);
        bestFit(feature, data, root, 0);
        System.out.print(root);
    }

    /**
     * 选择最优属性（获得信息量最大的属性）
     * @author coshaho
     * @param feature
     * @param data
     * @param parent
     * @param level
     */
    public void bestFit(String[] feature, int[][] data, Node parent, int level)
    {
        if(!validateData(data))
        {
            Node me = new Node();
            me.setLevel(level + 1);
            me.setFeature("class");
            me.setParent(parent);
            me.setValue(data[0][data[0].length - 1]);
            parent.getChildren().add(me);
            return;
        }

        int m = data.length;
        int n = data[0].length;
        int featureNum = n - 1;

        // 计算当前信息量
        double oldEntropy = calEntropy(data);
        double gainEntropy = -1d;
        int bestFeature = 0;
        Map<Integer, int[][]> nextData = null;
        for(int i = 0; i < featureNum; i++)
        {
            double newEntropy = 0.0d;
            Map<Integer, int[][]> splitData = splitData(data, i);

            // 按照某属性分类后的信息量
            for(Map.Entry<Integer, int[][]> entry : splitData.entrySet())
            {
                double entropy = calEntropy(entry.getValue());
                newEntropy = newEntropy + entropy * entry.getValue().length / m;
            }

            // 选取信息量获取最大的属性分类
            if(oldEntropy - newEntropy > gainEntropy)
            {
                gainEntropy = oldEntropy - newEntropy;
                bestFeature = i;
                nextData = splitData;
            }
        }

        String[] nextFeature = removeBestFeature(feature, bestFeature);

        // 递归分解
        for(Map.Entry<Integer, int[][]> entry : nextData.entrySet())
        {
            Node me = new Node();
            me.setFeature(feature[bestFeature]);
            me.setParent(parent);
            me.setValue(entry.getKey());
            me.setLevel(level + 1);
            parent.getChildren().add(me);
            bestFit(nextFeature, entry.getValue(), me, level + 1);
        }

    }

    /**
     * 移除已经分类的属性
     * @author coshaho
     * @param feature
     * @param index
     * @return
     */
    private String[] removeBestFeature(String[] feature, int index)
    {
        String[] result = new String[feature.length - 1];
        boolean flag = true;
        for(int j = 0; j < feature.length; j++)
        {
            if(index == j)
            {
                flag = false;
                continue;
            }
            if(flag)
            {
                result[j] = feature[j];
            }
            else
            {
                result[j - 1] = feature[j];
            }
        }

        return result;
    }

    /**
     * 计算信息熵
     * Entropy = -sigma(u * log2(u))
     * @author coshaho
     * @param data
     * @return
     */
    private double calEntropy(int[][] data)
    {
        int m = data.length;
        int n = data[0].length;

        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
        for(int i = 0; i < m; i++)
        {
            map.put(data[i][n-1], null == map.get(data[i][n-1]) ? 1 : map.get(data[i][n-1]) + 1);
        }

        double result = 0.0d;
        for(Map.Entry<Integer, Integer> entry : map.entrySet())
        {
            result = result - (double)entry.getValue() / m * Math.log((double)entry.getValue() / m) / Math.log(2);
        }
        return result;
    }

    /**
     * 按照属性index进行数据聚类
     * @author coshaho
     * @param data
     * @param index
     * @return
     */
    private Map<Integer, int[][]> splitData(int[][] data, int index)
    {
        int m = data.length;
        int n = data[0].length;

        // 数据划分：删除某列属性值并按照这列属性划分数据
        Map<Integer, List<int[]>> map = new HashMap<Integer, List<int[]>>();
        for(int i = 0; i < m; i++)
        {
            int key = data[i][index];
            int[] v = new int[n - 1];
            boolean flag = true;
            for(int j = 0; j < n; j++)
            {
                if(index == j)
                {
                    flag = false;
                    continue;
                }
                if(flag)
                {
                    v[j] = data[i][j];
                }
                else
                {
                    v[j - 1] = data[i][j];
                }
            }

            if(map.containsKey(key))
            {
                map.get(key).add(v);
            }
            else
            {
                List<int[]> list = new ArrayList<int[]>();
                list.add(v);
                map.put(key, list);
            }
        }

        // 数据格式转换
        Map<Integer, int[][]> result = new HashMap<Integer, int[][]>();
        for(Map.Entry<Integer, List<int[]>> entry : map.entrySet())
        {
            List<int[]> v = entry.getValue();
            int[][] value = new int[v.size()][];
            v.toArray(value);
            result.put(entry.getKey(), value);
        }

        return result;
    }

    /**
     * 数据校验
     * @author coshaho
     * @param data
     * @return
     */
    private boolean validateData(int[][] data)
    {
        if(1 == data.length || 1 == data[0].length)
        {
            return false;
        }

        int m = data.length;
        int n = data[0].length;

        int classOne = 1;
        for(int i = 1; i < m; i++)
        {
            if(data[i][n - 1] == data[0][n - 1])
            {
                classOne++;
            }
        }

        if(m == classOne)
        {
            return false;
        }

        return true;
    }

    public static class Node
    {
        private Node parent;

        private List<Node> children = new ArrayList<Node>();

        private int value;

        private String feature;

        private int level;

        public int getLevel() {
            return level;
        }

        public void setLevel(int level) {
            this.level = level;
        }

        public Node getParent() {
            return parent;
        }

        public void setParent(Node parent) {
            this.parent = parent;
        }

        public List<Node> getChildren() {
            return children;
        }

        public void setChildren(List<Node> children) {
            this.children = children;
        }

        public int getValue() {
            return value;
        }

        public void setValue(int value) {
            this.value = value;
        }

        public String getFeature() {
            return feature;
        }

        public void setFeature(String feature) {
            this.feature = feature;
        }

        public String toString()
        {
            String result = blank() + feature + ":" + value + "\n";
            for(Node node : children)
            {
                result = result + node.toString();
            }

            return result;
        }

        private String blank()
        {
            StringBuffer sb = new StringBuffer();
            for(int i = 0; i < level; i++)
            {
                sb.append("--");
            }
            return sb.toString();
        }
    }

    public static void main(String[] args)
    {
        int[][] data = {{0,2,0,0,0},
                {0,2,0,1,0},
                {1,2,0,0,1},
                {2,1,0,0,1},
                {2,0,1,0,1},
                {2,0,1,1,0},
                {1,0,1,1,1},
                {0,1,0,0,0},
                {0,0,1,0,1},
                {2,1,1,0,1},
                {0,1,1,1,1},
                {1,1,0,1,1},
                {1,2,1,0,1},
                {2,1,0,1,0}};
        String[] feature = {"age", "income", "student", "credit", "class"};

        new ID3Tree().createTree(feature, data);
    }
}

运行结果

root:-1
--age:0
----student:0
------class:0
----student:1
------class:1
--age:1
----class:1
--age:2
----credit:0
------class:1
----credit:1
------class:0