c4.5决策树 java_C4.5决策树--Java

//import java.awt.color.ICC_ColorSpace;

import java.io.*;importjava.util.ArrayList;importjava.util.Collections;importjava.util.Comparator;importjava.util.HashMap;importjava.util.HashSet;importjava.util.Iterator;//import java.util.Iterator;

importjava.util.List;//import java.util.Locale.Category;

importjava.util.Map;importjava.util.Map.Entry;importjava.util.Set;classdecisionTree{private static Map> featureValuesAndCounts=new HashMap>();private static ArrayList dataSet=new ArrayList();private static ArrayList features=new ArrayList();private static Set category=new HashSet();//public static DecisionNode root=new DecisionNode();//private static ArrayList> featureValue=new ArrayList>();

public static voidGetDataSet()

{

File file= new File("C:\\Users\\hfz\\workspace\\decisionTree\\src\\loan.txt");try{

BufferedReader br= new BufferedReader(new FileReader(file));// String s = null;

s=br.readLine();//读取第一行的内容，即是各特征的名称

String[] tempFeatures=s.split(",");for(String string1 : tempFeatures) {

features.add(string1);

}

s=br.readLine(); //开始读取特征值

String[] tt=null;int flag=s.length();while(flag!=0){//英文文档读到结尾得到的值是null，而中文文档读到结尾得到的值却是""

tt=s.split(",");

dataSet.add(tt);//将特征值存入

category.add(tt[tt.length-1]);//category为集合类型，用于存储类型值

s=br.readLine();if (s!=null) {

flag=s.length();

}else{

flag=0;

}

}for (int j = 0; j < features.size(); j++) {//逻辑上模拟列优先的方式读取二维数组形式的数据集，就是首先读取一个特征名称，再遍历数据集

Map ttt=new HashMap();//将某特征的各个特征值存入Map中，然后再度第二个特征，再遍历数据集。。。

for (int i = 0; i < dataSet.size(); i++) {

String currentFeatureValue=dataSet.get(i)[j];if(!(ttt.containsKey(currentFeatureValue)))

ttt.put(currentFeatureValue,1);else{

ttt.replace(currentFeatureValue, ttt.get(currentFeatureValue)+1);

}

}

featureValuesAndCounts.put(features.get(j), ttt);//嵌套形式的Map，第一层的key是特征名称，value是一个新的Map//新Map中key是特征的各个值，value是特征值在数据集中出现的次数。

}

br.close();

}catch(Exception e){

e.printStackTrace();

}

}public static DecisionNode treeGrowth(ArrayListdataset,String currentFeatureName,

String currentFeatureValue,ArrayListcurrent_features,

Map>current_featureValuesCounts){/*dataset:用于split方法，从dataset数据集中去除掉具有某个特征值的对应的若干实例，生成一个新的新的数据集

currentFeatureName:当前的特征名称，用于叶子节点，赋值给叶子节点的featureName字段

currentFeatureValue：当前特征名称对应的特征值，也用于叶子节点，赋值给featureValue字段

current_features:当前数据集中包含的所有特征名称，用于findBestAttribute方法，找到信息增益最大的的属性

current_featureValuesCounts:当前数据集中所有特征的各个特征值出现的次数，用于findBestAttribute方法，用于计算条件熵，进而计算信息增益。*/ArrayList classList=new ArrayList();int flag=0;for(String[] string : dataset) {//测试数据集中类型值的数量,flag表示数据集中的类型数量

if (classList.contains(string[string.length-1])) {

}else{

classList.add(string[string.length-1]);

flag++;//如果flag>1表示数据集

}

}if(1==flag){//如果只有一个类结果，则返回此叶子节点

DecisionNode d=newDecisionNode();

d.init(currentFeatureName,classList.get(0),currentFeatureValue);returnd;

}if (dataset.get(0).length==1) {//如果数据集已经没有属性了只剩下类结果，则返回占比最大的类结果，也是叶子节点

DecisionNode d=newDecisionNode();

d.init(currentFeatureName,classify(classList),currentFeatureValue);returnd;

}/*DecisionNode是一个自定义的递归型的数据类型，类中一个children字段是DecisionNode类型的数组，

正好用这种类型来存储递归算法产生的结果(决策树)，也就是用这种结构来存储一棵树。*/

//程序运行到这里就说明此节点不是叶子节点

DecisionNode root2=new DecisionNode();//那么root2就是一个决策属性节点(非叶子节点)了，非叶子节点就有孩子节点，下面就是计算它的孩子节点

int bestFeatureIndex=findBestAttribute(dataset,current_features,current_featureValuesCounts);

String bestFeatureLabel=current_features.get(bestFeatureIndex);//root.testCondition=bestFeatureLabel;

ArrayList feature_values=new ArrayList();for (EntryfeatureEntry : current_featureValuesCounts.get(bestFeatureLabel).entrySet()) {

feature_values.add(featureEntry.getKey());

}//给非叶子节点，也就是特征节点仅仅赋特征名称值

root2.init(currentFeatureName,currentFeatureValue);//java中不能是使用像C++中默认参数的函数，只能通过重载来实现同样的目的。

for(String values : feature_values) {//DecisionNode tempRoot=new DecisionNode();

ArrayList subDataSet = splitDataSet(dataset, bestFeatureIndex, values);//生成子数据集，即去除了包含values的实例，//接下来就是计算对此数据集利用决策树进行决策，又需要调用treeGrow方法//所以，接下来需要得到对应这个子数据集的特征名称以及每个特征值在数据集中出现的次数

ArrayList currentAttibutes=new ArrayList<>();

Iterator item1=current_features.iterator();while(item1.hasNext()){

currentAttibutes.add(item1.next().toString());//这个子数据集的特征名称

}

Map> currentAttributeValuesCounts=new HashMap>();//ArrayList subDataSet = splitDataSet(dataset, bestFeatureIndex, values);

currentAttibutes.remove(bestFeatureLabel);for (int j = 0; j < currentAttibutes.size(); j++) {

Map ttt=new HashMap();for (int i = 0; i

String currentFeatureValueXX=subDataSet.get(i)[j];if(!(ttt.containsKey(currentFeatureValueXX)))

ttt.put(currentFeatureValueXX,1);else{

ttt.replace(currentFeatureValueXX, ttt.get(currentFeatureValueXX)+1);

}

}

currentAttributeValuesCounts.put(currentAttibutes.get(j), ttt);//每个特征值在数据集中出现的次数

}

root2.add(treeGrowth(subDataSet, bestFeatureLabel, values, currentAttibutes, currentAttributeValuesCounts));

}returnroot2;

}public static voidmain(String[] agrs){

decisionTree.GetDataSet();

DecisionNode dd=decisionTree.treeGrowth(dataSet,"oo","xx",features,featureValuesAndCounts);

System.out.print(dd);

}public static double calEntropy(ArrayList dataset){//熵表示随机变量X不确定性的度量，在决策树中计算的熵就是决策结果这个变量的熵。

int sampleCounts=dataset.size();

Map categoryCounts=new HashMap();for(String[] strings : dataset) {if(categoryCounts.containsKey(strings[strings.length-1]))

categoryCounts.replace(strings[strings.length-1], categoryCounts.get(strings[strings.length-1])+1);else{

categoryCounts.put(strings[strings.length-1],1);

}

}double shannonEnt=0.0;for(Integer value: categoryCounts.values()) {double probability=value.doubleValue()/sampleCounts;

shannonEnt-=probability*(Math.log10(probability)/Math.log10(2));

}returnshannonEnt;

}public static int findBestAttribute(ArrayList dataset,ArrayListcurrentFeatures,

Map>currentFeatureValuesCounts){double baseEntroy=calEntropy(dataset);//计算基础熵，就是在不划分出某个特征的情况下。

double bestInfoGain=0.0;int bestFeatureIndex=-1;for (int i = 0; i

double conditionalEntroy=0.0;double entroy=0.0;

Map tempFeatureCounts=currentFeatureValuesCounts.get(currentFeatures.get(i));//Map类型有一个entrySet方法，此方法返回一个Map.Entry类型的集合，其中集合中的每个元素就是一个键值对，利用增强型的for循环可以遍历Map中//key(entry.getkey)和value(entry.getValue)

for (Entryentry : tempFeatureCounts.entrySet()) {//计算条件熵，就是根据某个具体特征值划分出新的数据集，计算新的数据集的基础熵，再乘以权值，累加得到某个特征的条件熵。

conditionalEntroy+=(entry.getValue().doubleValue()/dataset.size())*calEntropy(splitDataSet(dataset, i, entry.getKey()));//根据信息增益进一步计算信息增益比

double tempValue=entry.getValue().doubleValue()/dataset.size();

entroy+=tempValue*(Math.log10(tempValue)/Math.log10(2));

}if ((baseEntroy-conditionalEntroy)/(-entroy)>bestInfoGain) {

bestInfoGain=(baseEntroy-conditionalEntroy)/(-entroy);

bestFeatureIndex=i;

}

}if (-1==bestFeatureIndex){

System.out.print("cannot find best attribute!");return -1;

}else{return bestFeatureIndex;//返回信息增益最大的特征的索引，在当前特征(currentFeatures)中的索引。

}

}public static String classify(ArrayListdataset) {

Map categoryCount = new HashMap();for(String s1 : dataset) {if(categoryCount.containsKey(s1)) {

categoryCount.replace(s1, categoryCount.get(s1)+ 1);

}else{

categoryCount.put(s1,1);

}

}int maxCounts=-1;

String maxCountsCategory=null;for (Entry entry:categoryCount.entrySet()){//利用Map.Entry得到Map中的Value最大的键值对。

if (entry.getValue()>maxCounts){

maxCounts=entry.getValue();

maxCountsCategory=entry.getKey();

}

}returnmaxCountsCategory;

}public static ArrayList splitDataSet(ArrayList dataset,intfeatureIndex,String featureValue

){

ArrayList tempDataSet=new ArrayList();for(String[] strings : dataset) {if(strings[featureIndex].equals(featureValue)) {

String[] xx=strings.clone();//数组的clone方法实现的是浅拷贝，实质就是以下的过程

/*for (int i = featureIndex; i < strings.length-1; i++) {

xx[i]=strings[i];//就是把引用的值(地址)复制了一份，指向了同一个对象。

}*/

for (int i = featureIndex; i < strings.length-1; i++) {//xx中各个元素的值与strings中各个元素的值完全相等。

xx[i]=xx[i+1];//只是复制了引用的值而已，跟引用指向的对象没一点关系。Java将基本类型和引用类型变量都看成是值而已·

}//最最最需要注意的一点，以上代码不能以下面这种形式实现

/*for (int i = featureIndex; i < strings.length-1; i++) {//

strings[i]=strings[i+1];//这样会改变strings指向的对象，进而影响到dataset，改变了函数的参数dataset，

这样就在函数内“无意间”修改了dataset的值，集合类型，其实所有引用类型都是，以参数形式传入函数的话，可能会“无意间”就被修改了

}*/String[] tempStrings=new String[xx.length-1];for (int i = 0; i < tempStrings.length; i++) {

tempStrings[i]=xx[i];

}

tempDataSet.add(tempStrings);

}

}returntempDataSet;

}

}classDecisionNode{publicString featureName;publicString result;publicString featureValue;public List children=new ArrayList();public voidadd(DecisionNode node){

children.add(node);

}public voidinit(String featureName,String result,String featureValue){this.featureName=featureName;this.result=result;this.featureValue=featureValue;

}public voidinit(String featureName,String featureValue){this.featureName=featureName;this.featureValue=featureValue;

}

}