信息熵：变量的不确定性越大，熵越大。熵可用下面的公式描述：
-（p1*logp1+p2*logp2+...+pn*logpn)
pi表示事件i发生的概率
ID3：
GAIN(A)=INFO(D)-INFO_A(D)
节点A的信息增益为不加节点A时的信息量INFO(D)-加上A后的信息量INFO_A(D)
算法步骤：
1、树以代表训练样本的某个结点开始
2、如果样本都在同一类，则将该节点设置为叶子，并使用该类标号
3、否则，算法使用熵度量每个样本的分类结点，选择可以获得最大信息的节点
4、所有的属性都是分类的，连续值必须离散化
停止条件：该节点上所有的样本都属于一个类
没有剩余的属性
没有属性时，比如已经分到第三个属性，但是没有第四个属性，这时将样本分到最多的那类
C4.5与ID3区别在于属性度量方式的不同
优点：直观、便于理解、小规模数据有效
缺点：处理连续变量不好
类别较多时，错误增加比较快
可规模性一般
package dTree;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class dataClass {
public static void main(String[] args) {
double [][]exerciseData = {{1,1,0,0},{1,3,1,1},{3,2,1,1},{2,2,1,1},{3,2,1,1},{2,3,0,1},{2,1,0,0},{3,2,0,1},{2,1,0,1},{1,1,1,0}};//每一列表示一个属性值，最后一列表示决策层
int[] index = gainResult(exerciseData);//输出的结果表示按照决策树规则所对应的属性参考顺序
for(int i = 0;i<index.length;i++){
System.out.print(" "+(index[i]+1));
}
}
private static int[] gainResult(double[][] exerciseData) {
int dataQuantity = exerciseData.length;
int attributeQuantity = exerciseData[0].length-1;
int []attribute = new int[attributeQuantity];
int []newAttribute = new int [attributeQuantity];
double [][]newExerciseData = exerciseData ;
double [][]maxgainIndexData = new double[dataQuantity][attributeQuantity];
for(int i = 0;i<attributeQuantity;i++){
attribute[i] = MaxgainIndex(newExerciseData);
for(int j = 0;j<maxgainIndexData.length;j++){
maxgainIndexData[j][i] = newExerciseData[j][attribute[i]];
}
newExerciseData = NewData(newExerciseData,attribute[i]);
}
boolean flag =true;
for(int i = 0;i<maxgainIndexData[0].length;i++){//寻找第i列所对应的exerciseData
for(int k = 0;k<exerciseData[0].length-1;k++){
flag = true;
for(int j = 0;j<exerciseData.length;j++){
if(maxgainIndexData[j][i]!=exerciseData[j][k]){
flag = false;
break;
}
}
if(flag==true){
newAttribute[i] = k;
}
}
}
return newAttribute;
}
//矩阵转置
private static double[][] Transpose(double[][] exerciseData){
int rows = exerciseData.length;
int columns = exerciseData[0].length;
double [][]newData = new double [columns][rows];
for(int i = 0;i<columns;i++){
for(int j= 0;j<rows;j++){
newData[i][j] = exerciseData[j][i];
}
}
return newData;
}
private static double[][] NewData(double[][] exerciseData,int maxIndex) {//删除exerciseData中maxindex列的数据，产生新数据
double [][]newExerciseData = new double[exerciseData.length][];
for(int i = 0;i<exerciseData.length;i++){
newExerciseData[i] = new double[exerciseData[i].length-1];
for(int j = 0;j<newExerciseData[i].length;j++){
if(j>=maxIndex){
newExerciseData[i][j] = exerciseData[i][j+1];
}else{
newExerciseData[i][j] = exerciseData[i][j];
}
}
}
return newExerciseData;
}
private static int MaxgainIndex(double[][] exerciseData) {//获取exerciseData最大增益率所对应的一列
double []gainRatio = gainAll(exerciseData);
double maxGain = gainRatio[0];//最大增益率
int maxIndex = 0;//最大增益率所对应的索引值
for(int i=1;i<gainRatio.length-1;i++){
if(maxGain<gainRatio[i]){
maxGain = gainRatio[i];
maxIndex = i;
}
}
return maxIndex;
}
public static double[] gainAll(double [][]Data){//得到Data中每一列的增益值
int col = Data.length;//数据个数
int vol = Data[0].length;//属性个数
double [][]count = new double[vol][];
double []info = new double[vol];
double Lcount[][] = new double[vol][];//第i个属性的第j个分类的比率
double Mcount[][] = new double[vol][];
List <List<Map1>>listM = new ArrayList<List<Map1>>();
List <List<Map1>>listM2 = new ArrayList<List<Map1>>();
double []gain;
//矩阵的属性统计
for (int i = 0;i<vol;i++){
//属性i的不重复的分类集（mapList加入了属性i以及对应的决策层的值）
List<Map> mapList = new ArrayList<Map>();
for(int j = 0;j<col;j++){
Map y = new HashMap();
y.put(Data[j][i],Data[j][vol-1]);
if(!mapList.contains(y)){
mapList.add(y);
}
}
//属性i全部分类集（重复，listM2加入了i值以及决策层的值）
List<Map> AllmapList = new ArrayList<Map>();
for(int j = 0;j<col;j++){
Map y = new HashMap();
y.put(Data[j][i],Data[j][vol-1]);
AllmapList.add(y);
}
count[i] = new double[mapList.size()];
double sum = 0;
double num = 0;
List<Map1>LM = new ArrayList<Map1>();
for(int j=0;j<mapList.size();j++){
Iterator it =((Map)(mapList.get(j))).keySet().iterator();
num = (Double) it.next();
for(int k = 0;k<AllmapList.size();k++){
if(mapList.get(j).equals(AllmapList.get(k))){
count[i][j] = count[i][j]+1;
}
}
Map1 p = new Map1();
p.setKey(count[i][j]);
p.setValue(num);
LM.add(p);
}
listM2.add(LM);
}
for( int k = 0;k<vol;k++){
List <Double>list = new ArrayList<Double>();
for(int i = 0;i<col;i++){
if(!list.contains(Data[i][k])){
list.add(Data[i][k]);
}
}
Lcount[k] = new double[list.size()];
Mcount[k] = new double[list.size()];
for(int j = 0;j<col;j++){
int index = list.indexOf(Data[j][k]);
Lcount[k][index] = Lcount[k][index]+1;
Mcount[k][index] = Mcount[k][index]+1;
}
double LastSum = 0;
for(int i = 0;i<Lcount[k].length;i++){
LastSum = LastSum+Lcount[k][i];
}
for(int j = 0;j<Lcount[k].length;j++){
Lcount[k][j] = Lcount[k][j]/LastSum;
}
List<Map1> LM = new ArrayList<Map1>();
for(int i = 0;i<Lcount[k].length;i++){
Map1 p = new Map1();
p.setKey(Mcount[k][i]);
p.setValue(list.get(i));
LM.add(p);
}
listM.add(LM);
}
gain = new double[listM2.size()];
for(int i = 0; i<listM2.size()-1;i++){
List listi = new ArrayList();
listi = listM.get(i);
double sum = 0;
for(int j=0;j<listi.size();j++){
Map1 p = (Map1) listi.get(j);
double key = p.getKey();
double value = p.getValue();
for(int k = 0;k<listM2.get(i).size();k++){
Map1 p1 = (Map1) listM2.get(i).get(k);
if(p1.value==value){
sum = sum+xlog2(p1.key/p.key);
}
//System.out.println(sum);
}
gain[i]+=sum*Lcount[i][j];
sum = 0;
}
}
for(int i = 0;i<Lcount[Lcount.length-1].length;i++){
gain[listM2.size()-1] += -xlog2(Lcount[Lcount.length-1][i]);
}
for(int j = 0;j<gain.length-1;j++){
gain[j] = gain[gain.length-1]+gain[j];
}
double[]Scount = new double [Lcount.length-1];
for(int j= 0;j<Lcount.length-1;j++){
double sum = 0;
for(int k = 0;k<Lcount[j].length;k++){
sum += xlog2(Lcount[j][k]);
}
Scount[j] = -sum;
}
for(int j= 0;j<Scount.length;j++){
gain[j] = gain[j]/Scount[j];
}
return gain;
}
public static boolean contain(Map mapList,double key,double value){
if(value==Double.parseDouble(mapList.get(key).toString())){
return true;
}else{
return false;
}
}
public static double xlog2(double x){
return x*(Math.log(x)/Math.log((double)2));
}
}
