一、引言

在最開始的時候，我本來準備學習的是C4.5演算法，後來發現C4.5演算法的核心還是ID3演算法，所以又輾轉回到學習ID3演算法了，因為C4.5是他的一個改進。至於是什麼改進，在後面的描述中我會提到。

二、ID3演算法

ID3演算法是一種分類決策樹演算法。他通過一系列的規則，將資料最後分類成決策樹的形式。分類的根據是用到了熵這個概念。熵在物理這門學科中就已經出現過，表示是一個物質的穩定度，在這裡就是分類的純度的一個概念。公式為：

在ID3演算法中，是採用Gain資訊增益來作為一個分類的判定標準的。他的定義為：

每次選擇屬性中資訊增益最大作為劃分屬性，在這裡本人實現了一個java版本的ID3演算法，為了模擬資料的可操作性，就把資料寫到一個input.txt檔案中，作為資料來源，格式如下：

Day OutLook Temperature Humidity Wind PlayTennis
1 Sunny Hot High Weak No
2 Sunny Hot High Strong No
3 Overcast Hot High Weak Yes
4 Rainy Mild High Weak Yes
5 Rainy Cool Normal Weak Yes
6 Rainy Cool Normal Strong No
7 Overcast Cool Normal Strong Yes
8 Sunny Mild High Weak No
9 Sunny Cool Normal Weak Yes
10 Rainy Mild Normal Weak Yes
11 Sunny Mild Normal Strong Yes
12 Overcast Mild High Strong Yes
13 Overcast Hot Normal Weak Yes
14 Rainy Mild High Strong No
 

PalyTennis屬性為結構屬性，是作為類標識用的，中間的OutLool,Temperature,Humidity,Wind才是劃分屬性，通過將源資料與執行程式分類，這樣可以模擬巨大的資料量了。下面是ID3的主程式類，本人將ID3的演算法進行了包裝，對外只開放了一個構建決策樹的方法，在建構函式時候，只需傳入一個數據路徑檔案即可：

package DataMing_ID3;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

/**
 * ID3演算法實現類
 * 
 * @author lyq
 * 
 */
public class ID3Tool {
	// 類標號的值型別
	private final String YES = "Yes";
	private final String NO = "No";

	// 所有屬性的型別總數,在這裡就是data源資料的列數
	private int attrNum;
	private String filePath;
	// 初始源資料，用一個二維字元陣列存放模仿表格資料
	private String[][] data;
	// 資料的屬性行的名字
	private String[] attrNames;
	// 每個屬性的值所有型別
	private HashMap<String, ArrayList<String>> attrValue;

	public ID3Tool(String filePath) {
		this.filePath = filePath;
		attrValue = new HashMap<>();
	}

	/**
	 * 從檔案中讀取資料
	 */
	private void readDataFile() {
		File file = new File(filePath);
		ArrayList<String[]> dataArray = new ArrayList<String[]>();

		try {
			BufferedReader in = new BufferedReader(new FileReader(file));
			String str;
			String[] tempArray;
			while ((str = in.readLine()) != null) {
				tempArray = str.split(" ");
				dataArray.add(tempArray);
			}
			in.close();
		} catch (IOException e) {
			e.getStackTrace();
		}

		data = new String[dataArray.size()][];
		dataArray.toArray(data);
		attrNum = data[0].length;
		attrNames = data[0];

		/*
		 * for(int i=0; i<data.length;i++){ for(int j=0; j<data[0].length; j++){
		 * System.out.print(" " + data[i][j]); }
		 * 
		 * System.out.print("\n"); }
		 */
	}

	/**
	 * 首先初始化每種屬性的值的所有型別，用於後面的子類熵的計算時用
	 */
	private void initAttrValue() {
		ArrayList<String> tempValues;

		// 按照列的方式，從左往右找
		for (int j = 1; j < attrNum; j++) {
			// 從一列中的上往下開始尋找值
			tempValues = new ArrayList<>();
			for (int i = 1; i < data.length; i++) {
				if (!tempValues.contains(data[i][j])) {
					// 如果這個屬性的值沒有新增過，則新增
					tempValues.add(data[i][j]);
				}
			}

			// 一列屬性的值已經遍歷完畢，複製到map屬性表中
			attrValue.put(data[0][j], tempValues);
		}

		/*
		 * for(Map.Entry entry : attrValue.entrySet()){
		 * System.out.println("key:value " + entry.getKey() + ":" +
		 * entry.getValue()); }
		 */
	}

	/**
	 * 計算資料按照不同方式劃分的熵
	 * 
	 * @param remainData
	 *            剩餘的資料
	 * @param attrName
	 *            待劃分的屬性，在算資訊增益的時候會使用到
	 * @param attrValue
	 *            劃分的子屬性值
	 * @param isParent
	 *            是否分子屬性劃分還是原來不變的劃分
	 */
	private double computeEntropy(String[][] remainData, String attrName,
			String value, boolean isParent) {
		// 例項總數
		int total = 0;
		// 正例項數
		int posNum = 0;
		// 負例項數
		int negNum = 0;

		// 還是按列從左往右遍歷屬性
		for (int j = 1; j < attrNames.length; j++) {
			// 找到了指定的屬性
			if (attrName.equals(attrNames[j])) {
				for (int i = 1; i < remainData.length; i++) {
					// 如果是父結點直接計算熵或者是通過子屬性劃分計算熵，這時要進行屬性值的過濾
					if (isParent
							|| (!isParent && remainData[i][j].equals(value))) {
						if (remainData[i][attrNames.length - 1].equals(YES)) {
							// 判斷此行資料是否為正例項
							posNum++;
						} else {
							negNum++;
						}
					}
				}
			}
		}

		total = posNum + negNum;
		double posProbobly = (double) posNum / total;
		double negProbobly = (double) negNum / total;

		if (posProbobly == 1 || posProbobly == 0) {
			// 如果資料全為同種型別，則熵為0，否則帶入下面的公式會報錯
			return 0;
		}

		double entropyValue = -posProbobly * Math.log(posProbobly)
				/ Math.log(2.0) - negProbobly * Math.log(negProbobly)
				/ Math.log(2.0);

		// 返回計算所得熵
		return entropyValue;
	}

	/**
	 * 為某個屬性計算資訊增益
	 * 
	 * @param remainData
	 *            剩餘的資料
	 * @param value
	 *            待劃分的屬性名稱
	 * @return
	 */
	private double computeGain(String[][] remainData, String value) {
		double gainValue = 0;
		// 源熵的大小將會與屬性劃分後進行比較
		double entropyOri = 0;
		// 子劃分熵和
		double childEntropySum = 0;
		// 屬性子型別的個數
		int childValueNum = 0;
		// 屬性值的種數
		ArrayList<String> attrTypes = attrValue.get(value);
		// 子屬性對應的權重比
		HashMap<String, Integer> ratioValues = new HashMap<>();

		for (int i = 0; i < attrTypes.size(); i++) {
			// 首先都統一計數為0
			ratioValues.put(attrTypes.get(i), 0);
		}

		// 還是按照一列，從左往右遍歷
		for (int j = 1; j < attrNames.length; j++) {
			// 判斷是否到了劃分的屬性列
			if (value.equals(attrNames[j])) {
				for (int i = 1; i <= remainData.length - 1; i++) {
					childValueNum = ratioValues.get(remainData[i][j]);
					// 增加個數並且重新存入
					childValueNum++;
					ratioValues.put(remainData[i][j], childValueNum);
				}
			}
		}

		// 計算原熵的大小
		entropyOri = computeEntropy(remainData, value, null, true);
		for (int i = 0; i < attrTypes.size(); i++) {
			double ratio = (double) ratioValues.get(attrTypes.get(i))
					/ (remainData.length - 1);
			childEntropySum += ratio
					* computeEntropy(remainData, value, attrTypes.get(i), false);

			// System.out.println("ratio:value: " + ratio + " " +
			// computeEntropy(remainData, value,
			// attrTypes.get(i), false));
		}

		// 二者熵相減就是資訊增益
		gainValue = entropyOri - childEntropySum;
		return gainValue;
	}

	/**
	 * 計算資訊增益比
	 * 
	 * @param remainData
	 *            剩餘資料
	 * @param value
	 *            待劃分屬性
	 * @return
	 */
	private double computeGainRatio(String[][] remainData, String value) {
		double gain = 0;
		double spiltInfo = 0;
		int childValueNum = 0;
		// 屬性值的種數
		ArrayList<String> attrTypes = attrValue.get(value);
		// 子屬性對應的權重比
		HashMap<String, Integer> ratioValues = new HashMap<>();

		for (int i = 0; i < attrTypes.size(); i++) {
			// 首先都統一計數為0
			ratioValues.put(attrTypes.get(i), 0);
		}

		// 還是按照一列，從左往右遍歷
		for (int j = 1; j < attrNames.length; j++) {
			// 判斷是否到了劃分的屬性列
			if (value.equals(attrNames[j])) {
				for (int i = 1; i <= remainData.length - 1; i++) {
					childValueNum = ratioValues.get(remainData[i][j]);
					// 增加個數並且重新存入
					childValueNum++;
					ratioValues.put(remainData[i][j], childValueNum);
				}
			}
		}

		// 計算資訊增益
		gain = computeGain(remainData, value);
		// 計算分裂資訊，分裂資訊度量被定義為(分裂資訊用來衡量屬性分裂資料的廣度和均勻)：
		for (int i = 0; i < attrTypes.size(); i++) {
			double ratio = (double) ratioValues.get(attrTypes.get(i))
					/ (remainData.length - 1);
			spiltInfo += -ratio * Math.log(ratio) / Math.log(2.0);
		}

		// 計算機資訊增益率
		return gain / spiltInfo;
	}

	/**
	 * 利用源資料構造決策樹
	 */
	private void buildDecisionTree(AttrNode node, String parentAttrValue,
			String[][] remainData, ArrayList<String> remainAttr, boolean isID3) {
		node.setParentAttrValue(parentAttrValue);

		String attrName = "";
		double gainValue = 0;
		double tempValue = 0;

		// 如果只有1個屬性則直接返回
		if (remainAttr.size() == 1) {
			System.out.println("attr null");
			return;
		}

		// 選擇剩餘屬性中資訊增益最大的作為下一個分類的屬性
		for (int i = 0; i < remainAttr.size(); i++) {
			// 判斷是否用ID3演算法還是C4.5演算法
			if (isID3) {
				// ID3演算法採用的是按照資訊增益的值來比
				tempValue = computeGain(remainData, remainAttr.get(i));
			} else {
				// C4.5演算法進行了改進，用的是資訊增益率來比,克服了用資訊增益選擇屬性時偏向選擇取值多的屬性的不足
				tempValue = computeGainRatio(remainData, remainAttr.get(i));
			}

			if (tempValue > gainValue) {
				gainValue = tempValue;
				attrName = remainAttr.get(i);
			}
		}

		node.setAttrName(attrName);
		ArrayList<String> valueTypes = attrValue.get(attrName);
		remainAttr.remove(attrName);

		AttrNode[] childNode = new AttrNode[valueTypes.size()];
		String[][] rData;
		for (int i = 0; i < valueTypes.size(); i++) {
			// 移除非此值型別的資料
			rData = removeData(remainData, attrName, valueTypes.get(i));

			childNode[i] = new AttrNode();
			boolean sameClass = true;
			ArrayList<String> indexArray = new ArrayList<>();
			for (int k = 1; k < rData.length; k++) {
				indexArray.add(rData[k][0]);
				// 判斷是否為同一類的
				if (!rData[k][attrNames.length - 1]
						.equals(rData[1][attrNames.length - 1])) {
					// 只要有1個不相等，就不是同類型的
					sameClass = false;
					break;
				}
			}

			if (!sameClass) {
				// 建立新的物件屬性，物件的同個引用會出錯
				ArrayList<String> rAttr = new ArrayList<>();
				for (String str : remainAttr) {
					rAttr.add(str);
				}

				buildDecisionTree(childNode[i], valueTypes.get(i), rData,
						rAttr, isID3);
			} else {
				// 如果是同種型別，則直接為資料節點
				childNode[i].setParentAttrValue(valueTypes.get(i));
				childNode[i].setChildDataIndex(indexArray);
			}

		}
		node.setChildAttrNode(childNode);
	}

	/**
	 * 屬性劃分完畢，進行資料的移除
	 * 
	 * @param srcData
	 *            源資料
	 * @param attrName
	 *            劃分的屬性名稱
	 * @param valueType
	 *            屬性的值型別
	 */
	private String[][] removeData(String[][] srcData, String attrName,
			String valueType) {
		String[][] desDataArray;
		ArrayList<String[]> desData = new ArrayList<>();
		// 待刪除資料
		ArrayList<String[]> selectData = new ArrayList<>();
		selectData.add(attrNames);

		// 陣列資料轉化到列表中，方便移除
		for (int i = 0; i < srcData.length; i++) {
			desData.add(srcData[i]);
		}

		// 還是從左往右一列列的查詢
		for (int j = 1; j < attrNames.length; j++) {
			if (attrNames[j].equals(attrName)) {
				for (int i = 1; i < desData.size(); i++) {
					if (desData.get(i)[j].equals(valueType)) {
						// 如果匹配這個資料，則移除其他的資料
						selectData.add(desData.get(i));
					}
				}
			}
		}

		desDataArray = new String[selectData.size()][];
		selectData.toArray(desDataArray);

		return desDataArray;
	}

	/**
	 * 開始構建決策樹
	 * 
	 * @param isID3
	 *            是否採用ID3演算法構架決策樹
	 */
	public void startBuildingTree(boolean isID3) {
		readDataFile();
		initAttrValue();

		ArrayList<String> remainAttr = new ArrayList<>();
		// 新增屬性，除了最後一個類標號屬性
		for (int i = 1; i < attrNames.length - 1; i++) {
			remainAttr.add(attrNames[i]);
		}

		AttrNode rootNode = new AttrNode();
		buildDecisionTree(rootNode, "", data, remainAttr, isID3);
		showDecisionTree(rootNode, 1);
	}

	/**
	 * 顯示決策樹
	 * 
	 * @param node
	 *            待顯示的節點
	 * @param blankNum
	 *            行空格符，用於顯示樹型結構
	 */
	private void showDecisionTree(AttrNode node, int blankNum) {
		System.out.println();
		for (int i = 0; i < blankNum; i++) {
			System.out.print("\t");
		}
		System.out.print("--");
		// 顯示分類的屬性值
		if (node.getParentAttrValue() != null
				&& node.getParentAttrValue().length() > 0) {
			System.out.print(node.getParentAttrValue());
		} else {
			System.out.print("--");
		}
		System.out.print("--");

		if (node.getChildDataIndex() != null
				&& node.getChildDataIndex().size() > 0) {
			String i = node.getChildDataIndex().get(0);
			System.out.print("類別:"
					+ data[Integer.parseInt(i)][attrNames.length - 1]);
			System.out.print("[");
			for (String index : node.getChildDataIndex()) {
				System.out.print(index + ", ");
			}
			System.out.print("]");
		} else {
			// 遞迴顯示子節點
			System.out.print("【" + node.getAttrName() + "】");
			for (AttrNode childNode : node.getChildAttrNode()) {
				showDecisionTree(childNode, 2 * blankNum);
			}
		}

	}

}
 

他的場景呼叫實現的方式為：

/**
 * ID3決策樹分類演算法測試場景類
 * @author lyq
 *
 */
public class Client {
	public static void main(String[] args){
		String filePath = "C:\\Users\\lyq\\Desktop\\icon\\input.txt";
		
		ID3Tool tool = new ID3Tool(filePath);
		tool.startBuildingTree(true);
	}
}

最終的結果為：

	------【OutLook】
		--Sunny--【Humidity】
				--High--類別:No[1, 2, 8, ]
				--Normal--類別:Yes[9, 11, ]
		--Overcast--類別:Yes[3, 7, 12, 13, ]
		--Rainy--【Wind】
				--Weak--類別:Yes[4, 5, 10, ]
				--Strong--類別:No[6, 14, ]

請從左往右觀察這棵決策樹，【】裡面的是分類屬性，---XXX----，XXX為屬性的值，在葉子節點處為類標記。

對應的分類結果圖：

這裡的構造決策樹和顯示決策樹採用的DFS的方法，所以可能會比較難懂，希望讀者能細細體會，可以除錯一下程式碼，一步步的跟蹤會更加容易理解的。

三、C4.5演算法

如果你已經理解了上面ID3演算法的實現，那麼理解C4.5也很容易了，C4.5與ID3在核心的演算法是一樣的，但是有一點所採用的辦法是不同的，C4.5採用了資訊增益率作為劃分的根據，克服了ID3演算法中採用資訊增益劃分導致屬性選擇偏向取值多的屬性。資訊增益率的公式為:

分母的位置是分裂因子，他的計算公式為：

和熵的計算公式比較像，具體的資訊增益率的演算法也在上面的程式碼中了，請關注著2個方法：

		// 選擇剩餘屬性中資訊增益最大的作為下一個分類的屬性
		for (int i = 0; i < remainAttr.size(); i++) {
			// 判斷是否用ID3演算法還是C4.5演算法
			if (isID3) {
				// ID3演算法採用的是按照資訊增益的值來比
				tempValue = computeGain(remainData, remainAttr.get(i));
			} else {
				// C4.5演算法進行了改進，用的是資訊增益率來比,克服了用資訊增益選擇屬性時偏向選擇取值多的屬性的不足
				tempValue = computeGainRatio(remainData, remainAttr.get(i));
			}

			if (tempValue > gainValue) {
				gainValue = tempValue;
				attrName = remainAttr.get(i);
			}
		}

在補充一下C4.5在其他方面對ID3的補充和改進：

1、在構造決策樹的過程中能對樹進行剪枝。

2、能對連續性的值進行離散化的操作。

四、編碼時遇到的一些問題

為了實現ID3演算法，從理解閱讀他的原理就已經用掉了比較多的時間，然後再嘗試閱讀別人寫的C++版本的程式碼，又是看了幾天，好不容易實現了2個演算法，最後在構造樹的過程中遇到了最大了麻煩，因為用到了遞迴構造樹，對於其中節點的設計就顯得至關重要了，也許我自己目前的設計也不是最優秀的。下面盤點一下我的程式的遇到的一些問題和存在的潛在的問題:

1、在構建決策樹的時候，出現了remainAttr值缺少的情況，就是遞迴的時候remainAttr的屬性劃分移除掉之後，對於上次的遞迴操作的屬性時受到影響了，後來發現是因為我remainAttr採用的是ArrayList，他是一個引用物件，通過引用傳入的方式，物件用的還是同一個，所以果斷重新建了一個ArrayList物件，問題就OK了。

				// 建立新的物件屬性，物件的同個引用會出錯
				ArrayList<String> rAttr = new ArrayList<>();
				for (String str : remainAttr) {
					rAttr.add(str);
				}

				buildDecisionTree(childNode[i], valueTypes.get(i), rData,
						rAttr, isID3);

2、第二個問題是當程式劃分到最後一個屬性時，如果出現了資料的類標識並不是同一個類的時候，我的處理操作時直接不處理，直接返回，會造成節點沒有資料屬性，也沒有資料索引。

	private void buildDecisionTree(AttrNode node, String parentAttrValue,
			String[][] remainData, ArrayList<String> remainAttr, boolean isID3) {
		node.setParentAttrValue(parentAttrValue);

		String attrName = "";
		double gainValue = 0;
		double tempValue = 0;

		// 如果只有1個屬性則直接返回
		if (remainAttr.size() == 1) {
			System.out.println("attr null");
			return;
		}
		.....

在這種情況下的處理不是很恰當個人覺得是這樣。