先上问题吧，我们统计了14天的气象数据(指标包括outlook，temperature，humidity，windy)，并已知这些天气是否打球(play)。如果给出新一天的气象指标数据:sunny,cool,high,TRUE，判断一下会不会去打球。
table 1
| outlook | temperature | humidity | windy | play |
| sunny | hot | high | FALSE | no |
| sunny | hot | high | TRUE | no |
| overcast | hot | high | FALSE | yes |
| rainy | mild | high | FALSE | yes |
| rainy | cool | normal | FALSE | yes |
| rainy | cool | normal | TRUE | no |
| overcast | cool | normal | TRUE | yes |
| sunny | mild | high | FALSE | no |
| sunny | cool | normal | FALSE | yes |
| rainy | mild | normal | FALSE | yes |
| sunny | mild | normal | TRUE | yes |
| overcast | mild | high | TRUE | yes |
| overcast | hot | normal | FALSE | yes |
| rainy | mild | high | TRUE | no |
这个问题当然可以用朴素贝叶斯法求解，分别计算在给定天气条件下打球和不打球的概率，选概率大者作为推测结果。
现在我们使用ID3归纳决策树的方法来求解该问题。
预备知识：信息熵
熵是无序性（或不确定性）的度量指标。假如事件A的全概率划分是（A1,A2,...,An），每部分发生的概率是(p1,p2,...,pn)，那信息熵定义为：
通常以2为底数，所以信息熵的单位是bit。
补充两个对数去处公式：
ID3算法
构造树的基本想法是随着树深度的增加，节点的熵迅速地降低。熵降低的速度越快越好，这样我们有望得到一棵高度最矮的决策树。
在没有给定任何天气信息时，根据历史数据，我们只知道新的一天打球的概率是9/14，不打的概率是5/14。此时的熵为：
属性有4个：outlook，temperature，humidity，windy。我们首先要决定哪个属性作树的根节点。
对每项指标分别统计：在不同的取值下打球和不打球的次数。
table 2
| outlook | temperature | humidity | windy | play | |||||||||
| yes | no | yes | no | yes | no | yes | no | yes | no | ||||
| sunny | 2 | 3 | hot | 2 | 2 | high | 3 | 4 | FALSE | 6 | 2 | 9 | 5 |
| overcast | 4 | 0 | mild | 4 | 2 | normal | 6 | 1 | TRUR | 3 | 3 | ||
| rainy | 3 | 2 | cool | 3 | 1 | | |||||||
下面我们计算当已知变量outlook的值时，信息熵为多少。
outlook=sunny时，2/5的概率打球，3/5的概率不打球。entropy=0.971
outlook=overcast时，entropy=0
outlook=rainy时，entropy=0.971
而根据历史统计数据，outlook取值为sunny、overcast、rainy的概率分别是5/14、4/14、5/14，所以当已知变量outlook的值时，信息熵为：5/14 × 0.971 + 4/14 × 0 + 5/14 × 0.971 = 0.693
这样的话系统熵就从0.940下降到了0.693，信息增溢gain(outlook)为0.940-0.693=0.247
同样可以计算出gain(temperature)=0.029，gain(humidity)=0.152，gain(windy)=0.048。
gain(outlook)最大（即outlook在第一步使系统的信息熵下降得最快），所以决策树的根节点就取outlook。
接下来要确定N1取temperature、humidity还是windy?在已知outlook=sunny的情况，根据历史数据，我们作出类似table 2的一张表，分别计算gain(temperature)、gain(humidity)和gain(windy)，选最大者为N1。
依此类推，构造决策树。当系统的信息熵降为0时，就没有必要再往下构造决策树了，此时叶子节点都是纯的--这是理想情况。最坏的情况下，决策树的高度为属性（决策变量）的个数，叶子节点不纯（这意味着我们要以一定的概率来作出决策）。
Java实现
最终的决策树保存在了XML中，使用了Dom4J，注意如果要让Dom4J支持按XPath选择节点，还得引入包jaxen.jar。程序代码要求输入文件满足ARFF格式，并且属性都是标称变量。
实验用的数据文件：
@relation weather.symbolic
@attribute outlook {sunny, overcast, rainy}
@attribute temperature {hot, mild, cool}
@attribute humidity {high, normal}
@attribute windy {TRUE, FALSE}
@attribute play {yes, no}
@data
sunny,hot,high,FALSE,no
sunny,hot,high,TRUE,no
overcast,hot,high,FALSE,yes
rainy,mild,high,FALSE,yes
rainy,cool,normal,FALSE,yes
rainy,cool,normal,TRUE,no
overcast,cool,normal,TRUE,yes
sunny,mild,high,FALSE,no
sunny,cool,normal,FALSE,yes
rainy,mild,normal,FALSE,yes
sunny,mild,normal,TRUE,yes
overcast,mild,high,TRUE,yes
overcast,hot,normal,FALSE,yes
rainy,mild,high,TRUE,no程序代码：
package schoolarship;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.XMLWriter;
public class ID3 {
//存储属性的名称，这里判别变量和决策变量一律称为“属性”
private ArrayList<String> attribute = new ArrayList<String>();
//存储每个属性（都是离散变量）的取值集合
private ArrayList<ArrayList<String>> attributevalue = new ArrayList<ArrayList<String>>();
//存储所有的训练数据，这是一个二维数组
private ArrayList<String[]> data = new ArrayList<String[]>();
//决策变量的属性列表中的索引号
int decatt;
//用于匹配ARFF文件中的@attribute行
public static final String patternString = "@attribute(.*)[{](.*?)[}]";
//使用Dom4j读写XML文件
Document xmldoc;
Element root;
//构造函数中初始化Dom元素
public ID3() {
xmldoc = DocumentHelper.createDocument();
root = xmldoc.addElement("root");
root.addElement("DecisionTree").addAttribute("value", "null");
}
public static void main(String[] args) {
ID3 inst = new ID3();
//读入训练文件
inst.readARFF(new File("d:\\weather.arff"));
//设置决策变量的名称
inst.setDec("play");
//将所有属性（决策变量除外）的索引号存入ll
LinkedList<Integer> ll = new LinkedList<Integer>();
for (int i = 0; i < inst.attribute.size(); i++) {
if (i != inst.decatt)
ll.add(i);
}
//将全部训练数据的序号存入al
ArrayList<Integer> al = new ArrayList<Integer>();
for (int i = 0; i < inst.data.size(); i++) {
al.add(i);
}
//递归构建决策树
inst.buildDT(inst.root, al, ll);
//将决策树写入XML文件
inst.writeXML("d:\\dt.xml");
}
//读取输入文件，为全局变量attribute、attributevalue和data赋值
public void readARFF(File file) {
try {
FileInputStream fis = new FileInputStream(file);
InputStreamReader isr = new InputStreamReader(fis,
initBookEncode(fis));
BufferedReader br = new BufferedReader(isr);
String line;
Pattern pattern = Pattern.compile(patternString);
while ((line = br.readLine()) != null) {
Matcher matcher = pattern.matcher(line);
if (matcher.find()) {
attribute.add(matcher.group(1).trim());
String[] values = matcher.group(2).split(",");
ArrayList<String> al = new ArrayList<String>(values.length);
for (String value : values) {
al.add(value.trim());
}
attributevalue.add(al);
} else if (line.startsWith("@data")) {
while ((line = br.readLine()) != null) {
if (line.equals(""))
continue;
String[] row = line.split(",");
data.add(row);
}
} else {
continue;
}
}
br.close();
} catch (IOException e1) {
e1.printStackTrace();
}
}
//将参数n赋给全局变量decatt
public void setDec(int n) {
if (n < 0 || n >= attribute.size()) {
System.err.println("给定的决策变量名称有误");
System.exit(2);
}
decatt = n;
}
//根据属性的名称设置全局变量decatt
public void setDec(String name) {
int n = attribute.indexOf(name);
setDec(n);
}
//计算信息熵。arr中存储各种情况的频数
public double getEntropy(int[] arr) {
int sum = 0;
for (int i = 0; i < arr.length; i++) {
sum += arr[i];
}
return getEntropy(arr, sum);
}
//计算信息熵。arr中存储各种情况的频数，sum给出频数的总和
public double getEntropy(int[] arr, int sum) {
if (sum == 0)
return 0;
double entropy = 0.0;
for (int i = 0; i < arr.length; i++) {
//加上Double.MIN_VALUE是为了防止出现log(0)的情况
entropy -= arr[i] * Math.log(arr[i] + Double.MIN_VALUE)
/ Math.log(2);
}
entropy += sum * Math.log(sum + Double.MIN_VALUE) / Math.log(2);
entropy /= sum;
//由于上面加了Double.MIN_VALUE，所以算出来的熵可能会略大于1
if (entropy > 1 && entropy - 1 < 0.00001)
entropy = 1;
return entropy;
}
//subset给写训练数据的一个子集（subset中存储的是每条数据的索引号），判断这些子集的决策变量值是否都相同
public boolean infoPure(ArrayList<Integer> subset) {
String value = data.get(subset.get(0))[decatt];
for (int i = 1; i < subset.size(); i++) {
String next = data.get(subset.get(i))[decatt];
if (!value.equals(next))
return false;
}
return true;
}
/**
* 计算节点的信息熵
* @param subset 节点上所包含的数据子集
* @param index 节点以第index个属性作为判断的依据
* @return 节点的信息熵
*/
public double calNodeEntropy(ArrayList<Integer> subset, int index) {
int sum = subset.size();
double entropy = 0.0;
int[][] info = new int[attributevalue.get(index).size()][];
for (int i = 0; i < info.length; i++)
info[i] = new int[attributevalue.get(decatt).size()];
int[] count = new int[attributevalue.get(index).size()];
for (int i = 0; i < sum; i++) {
int n = subset.get(i);
String nodevalue = data.get(n)[index];
int nodeind = attributevalue.get(index).indexOf(nodevalue);
count[nodeind]++;
String decvalue = data.get(n)[decatt];
int decind = attributevalue.get(decatt).indexOf(decvalue);
info[nodeind][decind]++;
}
for (int i = 0; i < info.length; i++) {
entropy += getEntropy(info[i]) * count[i] / sum;
}
return entropy;
}
// 递归构建决策树
public void buildDT(Element ele, ArrayList<Integer> subset,
LinkedList<Integer> selatt) {
//指定name和value的节点不包含数据子集时，递归可以终止。同时要删除该节点
if (subset.size() == 0){
ele.getParent().remove(ele);
return;
}
//selatt.size() == 0说明树已经达到最大的深度，即所有判别属性都已经用完了。
//这个时候递归还没有终止说明训练数据中存在判别属性值完全相同，决策属性值却不相同的情况，取决策属性值最多的情况为最终结果
if(selatt.size() == 0){
Map<String,Integer> map=new HashMap<String,Integer>();
for(int i:subset){
String key=data.get(i)[decatt];
Integer v=map.get(key);
if(v!=null)
map.put(key, v+1);
else
map.put(key, 1);
}
String decision="should not appear";
int maxCount=-1;
Set<Entry<String,Integer>> set=map.entrySet();
for(Entry<String,Integer> entry:set){
if(entry.getValue()>maxCount){
maxCount=entry.getValue();
decision=entry.getKey();
}
}
ele.setText(decision);
return;
}
//如果节点是纯的，那么就到达叶子节点了，给出决策，不需要继续递归了
if (infoPure(subset)) {
ele.setText(data.get(subset.get(0))[decatt]);
return;
}
//选择下一个用于判别的属性。应该选熵最小的，因为这样信息增益最大
int minIndex = -1;
double minEntropy = Double.MAX_VALUE;
for (int i = 0; i < selatt.size(); i++) {
if (i == decatt)
continue;
double entropy = calNodeEntropy(subset, selatt.get(i));
if (entropy < minEntropy) {
minIndex = selatt.get(i);
minEntropy = entropy;
}
}
String nodeName = attribute.get(minIndex);
//每次递归时selatt都会少一个元素，即去除刚刚选择的判别属性
selatt.remove(new Integer(minIndex));
//刚刚选择的属性有多少种取值，该节点就有多少个分枝。遍历这些分枝，递归完善子树。
ArrayList<String> attvalues = attributevalue.get(minIndex);
for (String val : attvalues) {
Element child=ele.addElement(nodeName).addAttribute("value", val);
ArrayList<Integer> al = new ArrayList<Integer>();
for (int i = 0; i < subset.size(); i++) {
if (data.get(subset.get(i))[minIndex].equals(val)) {
al.add(subset.get(i));
}
}
//注意bBuildDT()里面selatt会被改变，所以每次传递这个参数的时候要进行深复制
buildDT(child, al, new LinkedList<Integer>(selatt));
}
}
//将Dom写入XML文件
public void writeXML(String filename) {
try {
File file = new File(filename);
if (!file.exists())
file.createNewFile();
FileWriter fw = new FileWriter(file);
OutputFormat format = OutputFormat.createPrettyPrint();
XMLWriter output = new XMLWriter(fw, format);
output.write(xmldoc);
output.close();
} catch (IOException e) {
System.out.println(e.getMessage());
}
}
/*正面这两个函数用于正确读取中文文件*/
String changeToGBK(String ss, String code) {
String temp = null;
try {
temp = new String(ss.getBytes(), code);
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
return temp;
}
public String initBookEncode(FileInputStream fileInputStream) {
String encode = "gb2312";
try {
byte[] head = new byte[3];
fileInputStream.read(head);
if (head[0] == -17 && head[1] == -69 && head[2] == -65)
encode = "UTF-8";
else if (head[0] == -1 && head[1] == -2)
encode = "UTF-16";
else if (head[0] == -2 && head[1] == -1)
encode = "Unicode";
} catch (IOException e) {
System.out.println(e.getMessage());
}
return encode;
}
}最终生成的文件如下：
<?xml version="1.0" encoding="UTF-8"?>
<root>
<DecisionTree value="null">
<outlook value="sunny">
<humidity value="high">no</humidity>
<humidity value="normal">yes</humidity>
</outlook>
<outlook value="overcast">yes</outlook>
<outlook value="rainy">
<windy value="TRUE">no</windy>
<windy value="FALSE">yes</windy>
</outlook>
</DecisionTree>
</root>
用图形象地表示就是：
扫一扫
2841
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
