一、RandomTree演算法

在網上搜了一下，並沒有找到RandomTree的嚴格意義上的演算法描述，因此我覺得RandomTree充其量只是一種構建樹的思路，和普通決策樹相比，RandomTree會隨機的選擇若干屬性來進行構建而不是選取所有的屬性。

Weka在實現上，對於隨機屬性的選取、生成分裂點的過程是這樣的：

1、設定一個要選取的屬性的數量K

2、在全域屬性中無放回的對屬性進行抽樣

3、算出該屬性的資訊增益（注意不是資訊增益率）

4、重複K次，選出資訊增益最大的當分裂節點。

5、構建該節點的孩子子樹。

二、具體程式碼實現

（1）buildClassifier

1. publicvoid buildClassifier(Instances data) throws Exception {  
2.    // 如果傳入的K不合理，把K放到一個合理的範圍裡
3.    if (m_KValue > data.numAttributes() - 1)  
4.      m_KValue = data.numAttributes() - 1;  
5.    if (m_KValue < 1)  
6.      m_KValue = (int) Utils.log2(data.numAttributes()) + 1;//這個是K的預設值
7.    // 判斷一下該分類器是否有能力處理這個資料集，如果沒能力直接就在testWithFail裡拋異常退出了
8.    getCapabilities().testWithFail(data);  
9.    // 刪除掉missClass
10.    data = new Instances(data);  
11.    data.deleteWithMissingClass();  
12.    // 如果只有一列，就build一個ZeroR模型，之後就結束了。ZeroR模型分類是這樣的：如果是連續型，總是返回期望，如果離散型，總是返回訓練集中出現最多的那個
13.    if (data.numAttributes() == 1) {  
14.      System.err  
15.          .println("Cannot build model (only class attribute present in data!), "
16.              + "using ZeroR model instead!");  
17.      m_zeroR = new weka.classifiers.rules.ZeroR();  
18.      m_zeroR.buildClassifier(data);  
19.      return;  
20.    } else {  
21.      m_zeroR = null;  
22.    }  
23.    // 如果m_NumFlods大於0，則會把資料集分為兩部分，一部分用於train，一部分用於test，也就是backfit

1. //分的方式和多折交叉驗證是一樣的，例如m_NumFlods是10的話，則train佔90%，backfit佔10%
2.   Instances train = null;  
3.   Instances backfit = null;  
4.   Random rand = data.getRandomNumberGenerator(m_randomSeed);  
5.   if (m_NumFolds <= 0) {  
6.     train = data;  
7.   } else {  
8.     data.randomize(rand);  
9.     data.stratify(m_NumFolds);  
10.     train = data.trainCV(m_NumFolds, 1, rand);  
11.     backfit = data.testCV(m_NumFolds, 1);  
12.   }  
13.   // 生成所有的可選屬性
14.   int[] attIndicesWindow = newint[data.numAttributes() - 1];  
15.   int j = 0;  
16.   for (int i = 0; i < attIndicesWindow.length; i++) {  
17.     if (j == data.classIndex())  
18.       j++; // 忽略掉classIndex
19.     attIndicesWindow[i] = j++;//這段程式碼有點奇怪，i和j是相等的，為啥不用attIndicesWindow=i?
20.   }  
21.   // 算出每個class的頻率，也就是每個分類出現的次數（更正確的說法應該是權重，但權重預設都是1）
22.   double[] classProbs = newdouble[train.numClasses()];  
23.   for (int i = 0; i < train.numInstances(); i++) {  
24.     Instance inst = train.instance(i);  
25.     classProbs[(int) inst.classValue()] += inst.weight();  
26.   }  
27.   // Build tree
28.   m_Tree = new Tree();  
29.   m_Info = new Instances(data, 0);  
30.   m_Tree.buildTree(train, classProbs, attIndicesWindow, rand, 0);//呼叫tree的build方法,在後面單獨分析
31.   // Backfit if required
32.   if (backfit != null) {  
33.     m_Tree.backfitData(backfit);//在後面單獨分析
34.   }  
35. }  

（2）tree.buildTree

1. protectedvoid buildTree(Instances data, double[] classProbs,  
2.        int[] attIndicesWindow, Random random, int depth) throws Exception {  
3.      //首先判斷一下是否有instance，如果沒有的話直接就返回
4.      if (data.numInstances() == 0) {  
5.        m_Attribute = -1;  
6.        m_ClassDistribution = null;  
7.        m_Prop = null;  
8.        return;  
9.      }  
10.      m_ClassDistribution = classProbs.clone();  
11.      if (Utils.sum(m_ClassDistribution) < 2 * m_MinNum  
12.          || Utils.eq(m_ClassDistribution[Utils.maxIndex(m_ClassDistribution)],  
13.              Utils.sum(m_ClassDistribution))  
14.          || ((getMaxDepth() > 0) && (depth >= getMaxDepth()))) {  
15.        // 遞迴結束的條件有3個 1、instance數量小於2*m_Minnum  2、instance都已經在同一個類中 3、達到最大的深度

1. //前兩個條件和j48的遞迴結束條件很相似，相關內容可參考我之前的幾篇部落格。
2.   m_Attribute = -1;  
3.   m_Prop = null;  
4.   return;  
5. }  
6. double val = -Double.MAX_VALUE;  
7. double split = -Double.MAX_VALUE;  
8. double[][] bestDists = null;  
9. double[] bestProps = null;  
10. int bestIndex = 0;  
11. double[][] props = newdouble[1][0];  
12. double[][][] dists = newdouble[1][0][0];//這個陣列第一列只有下標為0的被用到，不知道為啥這麼設計
13. int attIndex = 0;//儲存被選擇到的屬性
14. int windowSize = attIndicesWindow.length;//儲存目前可選擇的屬性的數量
15. int k = m_KValue;//k代表還能選擇的屬性的數量
16. boolean gainFound = false;//是否發現了一個有資訊增益的節點
17. while ((windowSize > 0) && (k-- > 0 || !gainFound)) {//此迴圈退出條件有2個 1、沒有節點可以選了 2、已經選了k個屬性了並且找到了一個有用的屬性 換句話說，如果K次迭代沒有找到可以分裂的隨機節點，迴圈也會繼續下去