本文章是由機器翻譯。

CLR

使用自我調整提升進行分類和預測

James McCaffrey

下載代碼示例

分類是一種電腦學習方法,它使用訓練資料生成模型(通常是單個複雜規則或數學等式),將資料項目分配給幾個不同類別中的一個。然後,可使用模型對類別未知的新資料項目進行預測。示例包括,根據各種醫療檢查資料預測患者是否患有癌症(是、否),根據申請者的財務歷史記錄預測貸款申請的風險類別(低、中、高)。

有許多不同的分類演算法和方法,包括樸素貝葉斯、神經網路和邏輯回歸。本文將介紹一種有趣的方法,這種方法稱為自我調整增強分類,與試圖確定單個複雜預測規則的方法不同,它使用訓練資料生成大量十分簡單的粗略經驗規則。然後,計算每個經驗規則的權重。對新輸入進行預測的過程包括:組合這些經驗規則,考慮每個簡單規則的權重,獲得一致的結果。「增強」一詞源于這樣一個事實:通過組合簡單規則可以增強(提高)這些規則的預測品質。

自我調整增強是一種元啟發式演算法。也就是說,自我調整增強是一組可用於創建特定分類演算法的準則。自我調整增強演算法有許多變體,並且有許多現有的獨立工具可實現某種形式的自我調整增強,那麼為什麼還要不厭其煩地從頭開始編寫自我調整增強分類的代碼呢?現有的自我調整增強分類工具可能很難或無法自訂,可能難以集成到軟體系統中,並且可能會導致版權或智慧財產權問題。

具體示例是瞭解什麼是自我調整增強的最佳途徑。请看一下图 1。演示程式需要解決的最終問題是,預測西雅圖球隊在即將到來的比賽中主場迎戰一支底特律球隊的輸贏,打賭的一致結果(分差)是西雅圖有微弱優勢(小)。圖 1 上部顯示 10 個結果已知的假設訓練資料項目。第一個訓練元組 (Detroit, Home, Large, Win) 表示在與底特律球隊進行的上次比賽中,西雅圖球隊在主場比賽,分差為大,西雅圖球隊在比賽中獲勝。


圖 1 自我調整增強分類和預測

演示程式的下一部分顯示 10 個訓練資料項目從字串資料轉換為從零開始的整數形式,以便更有效地進行處理,然後以矩陣形式存儲在電腦記憶體中。例如,(Detroit, Home, Large, Win) 存儲為 (3, 0, 2, 1)。請注意,本例中預測結果只有兩個值,即贏和輸。這稱為二進位分類問題。自我調整增強也可用在相關變數有三個或更多值的情況(多項分類)。大部分二進位分類方法將相關變數編碼為使用 (0, 1) 機制進行預測,但自我調整增強幾乎總是使用 (-1, +1) 機制,因為這種編碼方式可略微簡化某些演算法實現過程。請注意,所有獨立變數預測器值都是分類值(「Home」、「Medium」等)而非數值。當訓練資料有數值時,也可使用自我調整增強,稍後將進行介紹。

圖 1 的第三部分顯示從訓練資料生成了八個經驗規則。在自我調整增強術語中,經驗規則通常稱為弱學習器或弱分類器。第一個弱學習器是「IF Opponent IS Buffalo THEN Result IS Win」,以方便使用的形式表示,原始誤差率為 0.00。第二個弱學習器為「IF Opponent IS Chicago THEN Result IS Lose」,它更具說明性,誤差率為 0.33。此弱學習器從何而來?如果查看一下訓練資料,可以發現有三次對手為芝加哥。在這些訓練實例中,有兩次的結果為輸,因此該弱學習器的正確率為三分之二 (0.67),誤差率為三分之一 (0.33)。

請注意,並非所有訓練項預測器值都會生成弱學習器;當對手為亞特蘭大時,不存在任何規則。因為對手為亞特蘭大的培訓元組有兩個,其中一個的結果為贏,另一個的結果為輸,所以該學習器的誤差率為 0.50,這並不能提供任何有用的資訊。本文中演示的自我調整增強分類版本假定所有弱學習器的原始誤差率均小於 0.50。

圖 1 的下一部分說明自我調整增強演算法如何在幕後處理這些弱學習器以找到每個學習器的權重。這些權重用於衡量每個弱分類器的重要性,它們在自我調整增強術語中稱為 Alpha 值。確定 Alpha 值是自我調整增強的關鍵區段。弱學習器組及其 Alpha 權重構成了分類模型。

演示程式的最後一部分介紹用於針對西雅圖球隊進行預測的分類模型,對手為底特律球隊,場地為主場,分差為小。如果看一下所生成的弱學習器組,可以看到有三個學習器適用: [2] IF Opponent IS Detroit THEN Result IS Win (+1), [3] IF Field IS Home THEN Result IS Win (+1), and [5] IF Spread IS Small THEN Result IS Lose (-1).為弱學習器 2、3 和 5 計算出的 Alpha 值分別為 0.63、3.15 和 4.49。由此得出,一致預測 = (0.63)(+1) + (3.15)(+1) + (4.49)(-1) = -0.72(經過四捨五入),因為值為負,所以表示結果為輸。請注意,即使三個弱學習器中有兩個(2 和 3)預測贏,但弱學習器 5 的較大 Alpha 值超過了這兩個贏預測,因而得到的總體預測為輸。

在接下來的幾部分中,我將詳細說明演示程式的工作原理,以便你可以向 .NET 系統或應用程式添加預測功能。本文假定你具備 C 系列語言高級程式設計技能,對自我調整增強分類一無所知。我使用 C# 編寫演示程式碼,但是這些說明應為你提供足夠資訊,使你可以將該代碼重構為其他語言(如 Visual Basic .NET 或 Python 等)。演示程式的代碼太長,無法在本文中完全列出, archive.msdn.microsoft.com/mag201304AdaptiveBoost 提供了完整的原始程式碼。

自我調整增強演算法

自我調整增強分類的核心是一個常式,該常式檢查每個弱學習器並向其分配一個 Alpha 權重。這種演算法十分複雜,最好通過一個具體示例加以說明。假設有 10 個訓練元組和 8 個弱學習器,如圖 1 所示。每個訓練元組都分配有一個權重,權重在自我調整增強文獻資料中通常稱為 D。D 權重的總和為 1.0,這使 D 值成為一種分佈。最初,所有訓練資料項目都分配有相同的 D 權重;在本例中為 0.10,因為共有 10 個數據項:

[0] (D = 0.10) Detroit   Home   Large    Win
[1] (D = 0.10) Detroit   Away   Medium   Win
[2] (D = 0.10) Buffalo   Home   Small    Win
[3] (D = 0.10) Buffalo   Home   Medium   Win
[4] (D = 0.10) Atlanta   Away   Large    Win
[5] (D = 0.10) Chicago   Home   Medium   Win
[6] (D = 0.10) Chicago   Away   Small    Lose
[7] (D = 0.10) Chicago   Home   Small    Lose
[8] (D = 0.10) Atlanta   Away   Medium   Lose
[9] (D = 0.10) Detroit   Away   Large    Lose

每個學習器都有一個 epsilon 值和一個 Alpha 值。 epsilon 值是用於計算 Alpha 值的加權誤差率。 最初,所有學習器都有未知 Alpha 值(假設 a = 0.00)和未知 epsilon 值(假設 e = -1.0):

[0] (a = 0.00) (e = -1.0) IF Opponent IS Buffalo THEN Result IS Win
[1] (a = 0.00) (e = -1.0) IF Opponent IS Chicago THEN Result IS Lose
[2] (a = 0.00) (e = -1.0) IF Opponent IS Detroit THEN Result IS Win
[3] (a = 0.00) (e = -1.0) IF Field IS Home THEN Result IS Win
[4] (a = 0.00) (e = -1.0) IF Field IS Away THEN Result IS Lose
[5] (a = 0.00) (e = -1.0) IF Spread IS Small THEN Result IS Lose
[6] (a = 0.00) (e = -1.0) IF Spread IS Medium THEN Result IS Win
[7] (a = 0.00) (e = -1.0) IF Spread IS Large THEN Result IS Win

在偽代碼中,找到每個學習器的 Alpha 權重的演算法如下:

set t=0
while not done loop
  update all learners' epsilons (weighted errors)
  find best (smallest epsilon) unused learner
  compute and save the alpha of best learner using its epsilon
  update the D weights for each training item using the best learner
  normalize the D weights so they sum to 1.0
  ++t
end loop

主處理迴圈在以下情況下中止:所有弱學習器均已處理並分配有 Alpha 權重;迴圈計數器變數超過某個最大值;最佳未用弱學習器的加權誤差率 epsilon 達到某個值(如 0.45 或 0.49),這表示沒有剩下任何相對較好的未用學習器可供處理。

迴圈內的第一步是更新所有 epsilon。 epsilon 值是錯誤分類的訓練元組的 D 權重總和。 對於學習器 [0] (IF Opponent IS Buffalo THEN Result IS Win),有兩個適用的訓練元組 [2] 和 [3],該規則在這兩個實例中是正確的,因此 epsilon 為 0.00。 對於學習器 [1] (IF Opponent IS Chicago THEN Result IS Lose),有三個適用的訓練元組 [5]、[6] 和 [7]。 其中,元組 [5] 不正確,因此 epsilon 只是元組 [5] 的 D 權重 = 0.10。

雖然並非顯而易見,但是如果仔細看一下計算 epsilon 的方法,你將發現 epsilon 值始終介於 0.0 與 0.5 之間。 在進行所有更新後,學習器的 epsilon 如下:

[0] (a = 0.00) (e = 0.00) IF Opponent IS Buffalo THEN Result IS Win
[1] (a = 0.00) (e = 0.10) IF Opponent IS Chicago THEN Result IS Lose
[2] (a = 0.00) (e = 0.10) IF Opponent IS Detroit THEN Result IS Win
[3] (a = 0.00) (e = 0.10) IF Field IS Home THEN Result IS Win
[4] (a = 0.00) (e = 0.20) IF Field IS Away THEN Result IS Lose
[5] (a = 0.00) (e = 0.10) IF Spread IS Small THEN Result IS Lose
[6] (a = 0.00) (e = 0.10) IF Spread IS Medium THEN Result IS Win
[7] (a = 0.00) (e = 0.10) IF Spread IS Large THEN Result IS Win

此時選擇了最佳學習器。 它就是學習器 [0],因為其 epsilon 最小,為 0.00。 關聯 Alpha 的計算方法如下:

alpha = 0.5 * log((1.0 - epsilon) / epsilon)

從自我調整增強理論上來說,這實際上是一個奇妙的等式。 其中,log 是自然(以 e 為底數)對數。 回想一下,Alpha 值是決定學習器重要性的權重。 上述等式旨在使較小的 epsilon(學習器誤差)值產生較大的 Alpha(學習器重要性)值。

在這一特定情況下,如果 epsilon 為 0,會產生問題,因此會出現除以 0 錯誤。 為避免這一問題,演示程式任意將任何值為 0 的 epsilon 轉換為 0.000001。 因此,學習器 [0] 的 Alpha 計算為 0.5 * log(0.999999 / 0.000001) = 6.91,該值分配給學習器 [0],並且學習器 [0] 標記為已完成。

演算法迴圈中的下一步是根據剛剛計算出的最佳學習器更新 D 訓練元組權重。 基本思路是,增加被最佳學習器錯誤分類的訓練元組的 D 權重,減少被最佳學習器正確分類的訓練元組的 D 權重。 乍一看,D 更新等式有些複雜:

D(new) = D(old) * exp(-alpha * actualY * predictedY)

最佳學習器是學習器 [0] (IF Opponent IS Buffalo THEN Result IS Win),其 Alpha 為 6.91。 在 10 個訓練元組中,學習器 [0] 適用于元組 [2] 和 [3],因此將更新這些 D 值。 對於訓練元組 [2]:

D(new) = 0.10 * exp(-6.91 * (+1) * (+1))
       = 0.10 * exp(-6.91)
       = 0.0000997758

訓練元組 [3] 的新 D 值的計算方法和結果與元組 [2] 相同。

在本例中,得到了一個很小的新 D 權重,因為這兩個訓練元組是被最佳學習器正確分類的。 請注意,如果實際 Y 值與預測 Y 值相同(同時為 -1 或同時為 +1),則相乘時會得到 +1,並且指數參數為負數(因為 -Alpha 始終為負),這會使產生的結果小於 1.0。 但是,如果實際 Y 值和預測 Y 值不同,其乘積為 -1,並且指數參數為正,這會產生大於 1.0 的數位(可能很大)。 這一 D 更新方法就是為何自我調整增強分類通常對相關變數值使用 -1 和 +1 而非 0 和 +1 的原因所在。

此時,初始近似 D 值(經過四捨五入)如下:

[0] (D = 0.1000) Detroit   Home   Large    Win
[1] (D = 0.1000) Detroit   Away   Medium   Win
[2] (D = 0.0001) Buffalo   Home   Small    Win
[3] (D = 0.0001) Buffalo   Home   Medium   Win
[4] (D = 0.1000) Atlanta   Away   Large    Win
[5] (D = 0.1000) Chicago   Home   Medium   Win
[6] (D = 0.1000) Chicago   Away   Small    Lose
[7] (D = 0.1000) Chicago   Home   Small    Lose
[8] (D = 0.1000) Atlanta   Away   Medium   Lose
[9] (D = 0.1000) Detroit   Away   Large    Lose

主演算法迴圈中的下一步是對 D 值進行正常化,使其總和為 1.0,具體方法是將每個初始 D 值除以其總和。 10 個 D 值的總和約為 0.8002,因此訓練元組 [0] 的正常化 D 值約為 0.1000/0.8002 = 0.1249。 最終更新後的 D 權重如下:

[0] (D = 0.1249) Detroit   Home   Large    Win
[1] (D = 0.1249) Detroit   Away   Medium   Win
[2] (D = 0.0001) Buffalo   Home   Small    Win
[3] (D = 0.0001) Buffalo   Home   Medium   Win
[4] (D = 0.1249) Atlanta   Away   Large    Win
[5] (D = 0.1249) Chicago   Home   Medium   Win
[6] (D = 0.1249) Chicago   Away   Small    Lose
[7] (D = 0.1249) Chicago   Home   Small    Lose
[8] (D = 0.1249) Atlanta   Away   Medium   Lose
[9] (D = 0.1249) Detroit   Away   Large    Lose

這裡的思路是,我們希望演算法現在以 [2] 和 [3] 之外的訓練元組為重點,因為學習器 [0] 已考慮了這兩個元組。 此時,演算法跳回迴圈頂部,根據新計算的 D 權重更新所有學習器的 epsilon 值,確定最佳未用學習器(學習器 [5]),計算最佳學習器的 Alpha 值 (4.49),更新適用訓練元組([2]、[6] 和 [7])的 D 值並計算所有訓練元組的正常化 D 值。

在本例中,該過程會一直執行,直到計算出所有八個弱學習器的 Alpha 值;但通常來說,並非所有弱學習器都一定會被視為良好學習器並分配有 Alpha 值。

程式的整體結構

圖 1 中所示的演示程式是單個 C# 主控台應用程式。 我使用的是 Visual Studio 2010,但是支援 Microsoft .NET Framework 2.0 或更高版本的任何 Visual Studio 版本都適用。 我創建了一個名為 AdaptiveBoosting 的新專案,然後在解決方案資源管理器視窗中將 Program.cs 重命名為更具描述性的 AdaptiveBoostingProgram.cs,這樣也會自動重命名類 Program。 除了對 System 和 Collections.Generic 命名空間的引用以外,我刪除了原始程式碼頂部由範本生成的所有 using 語句。 圖 2 列出了 Main 方法,其中刪除了部分 WriteLine 語句,進行了一些其他細微編輯工作,包含一個重要的程式定義類來定義弱學習器物件。

圖 2 程式的整體結構

using System;
using System.Collections.Generic;
namespace AdaptiveBoosting
{
  class Program
  {
    static void Main(string[] args)
    {
      try
      {
        Console.WriteLine("\nBegin adaptive boosting classification demo\n");
        string[] features = new string[] { "Opponent", "Field", "Spread",
          "Result" };
        string[][] values = new string[4][];
        values[0] = new string[] { "Atlanta", "Buffalo", "Chicago",
          "Detroit" }; // opponent
        values[1] = new string[] { "Home", "Away" };  // Field
        values[2] = new string[] { "Small ", "Medium", "Large " }; 
        // Note: Spaces added
        values[3] = new string[] { "Lose", "Win" }; 
        // The dependent/predicted variable
        string[][] rawTrain = new string[10][];
        rawTrain[0] = new string[] { "Detroit", "Home", "Large ", "Win" };
        rawTrain[1] = new string[] { "Detroit", "Away", "Medium", "Win" };
        rawTrain[2] = new string[] { "Buffalo", "Home", "Small ", "Win" };
        rawTrain[3] = new string[] { "Buffalo", "Home", "Medium", "Win" };
        rawTrain[4] = new string[] { "Atlanta", "Away", "Large ", "Win" };
        rawTrain[5] = new string[] { "Chicago", "Home", "Medium", "Win" };
        rawTrain[6] = new string[] { "Chicago", "Away", "Small ", "Lose" };
        rawTrain[7] = new string[] { "Chicago", "Home", "Small ", "Lose" };
        rawTrain[8] = new string[] { "Atlanta", "Away", "Medium", "Lose" };
        rawTrain[9] = new string[] { "Detroit", "Away", "Large ", "Lose" };
        Console.WriteLine("Raw (string) training data for team seattle:\n");
        Console.WriteLine("Opponent Field  Spread   Result");
        Console.WriteLine("===============================");
        ShowMatrix(rawTrain);
        Console.WriteLine("\nConverting and storing training data");
        int[][] train = RawTrainToInt(rawTrain, values);
        Console.WriteLine("Training data in int form:\n");
        ShowMatrix(train, true);
        Console.WriteLine(
          "\nCreating weak categorical stump learners from training data");
        List<Learner> learners = MakeLearners(values, train);
        Console.WriteLine("Completed.
Weak learners are:\n");
        for (int i = 0; i < learners.Count; ++i)
          Console.WriteLine("[" + i + "] " + Description(learners[i],
            features, values));
        Console.WriteLine("\nInitializing list of best learner indexes");
        List<int> bestLearners = new List<int>();  // Indexes of good weak learners
        Console.WriteLine(
          "\nUsing adaptive boosting to find best  learners and alphas");
        MakeModel(train, values, learners, bestLearners);
        Console.WriteLine("\nModel completed");
        int numGood = bestLearners.Count;
        Console.Write("Algorithm found " + numGood + " good learners ");
        Console.WriteLine("and associated alpha values");
        Console.WriteLine("\nThe good learners and their alpha value are:");
        for (int i = 0; i < bestLearners.Count; ++i)
        {
          int lrn = bestLearners[i];
          Console.Write("[" + lrn + "] " +
            learners[lrn].alpha.ToString("F2") + "  ");
        }
        Console.Write("\nPredicting outcome when Opponent = Detroit, ");
        Console.WriteLine("Field = Home, Spread = Small\n");
        int[] unknownTuple = new int[] { 3, 0, 0 }; // Detroit, Home, Small
        int Y = Classify(unknownTuple, learners, bestLearners);
        Console.Write("Predicted Y = " + Y + " => ");
        Console.WriteLine("seattle will " + YValueToString(Y, values));
        Console.WriteLine("\nEnd\n");
      }
      catch (Exception ex)
      {
        Console.WriteLine(ex.Message);
      }
    } // Main
    // (Many) static methods here
  } // Class Program
  public class Learner  // Weak learner
  {
    // Definition code here
  }
} // ns

Main 方法首先為特徵「Opponent」、「Field」、「Spread」和「Result」設置了硬編碼字串。 然後,Main 中的代碼為每個特徵設置了硬編碼值: “Atlanta,” “Buffalo,” “Chicago,” “Detroit,” “Home,” “Away,” “Small,” “Medium,” “Large,” “Lose” and “Win.” To keep my output tidy, I used a hack and inserted a blank space at the end of “Small” and “Large.”

為了簡單起見,訓練資料也硬編碼到演示程式中。 在許多情況下,訓練資料將存儲在一個文字檔或 SQL 表中。 在這些情況下,你可能希望考慮以程式設計方式掃描訓練資料以確定特徵名稱(可能來自文字檔標題列或 SQL 表列名稱)和特徵值。

方法 RawTrainToInt 將字串形式的訓練資料轉換為從零開始的整數,並將這些整數存儲到一個名為 train 的 int[][] 矩陣中。 RawTrainToInt 調用一個名為 ValueToInt 的協助程式。 train 矩陣的相關變數值 (Result) 存儲在最後一列中。 你可能希望將相關變數值單獨存儲在一個列陣列中。 在訓練資料集很大的情況下,可能無法在電腦記憶體中存儲整個訓練資料集。 這種情況下,必須通過外部資料存儲而不是內部矩陣進行流式處理。

演示程式使用方法 MakeLearners 和一個程式定義的類 Learner 確定弱學習器。 本文下一部分將詳細介紹該方法和該類。 在創建弱學習器後,演示程式調用方法 MakeModel。 如上一部分所示,MakeModel 是自我調整增強演算法的核心。 最終的結果是一個名為 bestLearners 的排序清單,其中包含分配有 Alpha 值的學習器的索引。

Main 方法最後預測具有以下一組輸入的 Seattle 的結果:Opponent 為「Detroit」、Field 為「Home」且 Spread 為「Small」。 在本例中,Classify 的傳回值為 -0.72,這解釋為「Lose」。

創建弱學習器

特定自我調整增強演算法的實現在某種程度上取決於弱學習器的特定定義。 程式定義的類 Learner 有六個欄位:

public int feature;
public int value;
public int predicted;
public double error;
public double epsilon;
public double alpha;

為了簡單起見,我使用公共作用域聲明瞭所有六個欄位。 feature 欄位存放一個整數,指示哪個獨立變數是學習器的關鍵。 例如,如果 feature 為 0,則弱學習器基於 opponent 的值。 value 欄位存放一個整數,指示 feature 的值。 例如,如果 value 為 3,則弱學習器基於條件「opponent is Detroit」。 predicted 欄位為 -1 或 +1,具體取決於 feature 值的實體類別是 Lose 還是 Win。

error 欄位是 double 類型,是與訓練資料的弱學習器關聯的原始誤差率。 例如,如果弱學習器的 feature = 0、value = 3 且 predicted = +1(表示如果 Opponent 為 Detroit 時,則結果為 Win),那麼圖 1 中訓練資料的原始誤差率為 0.33,因為有三分之一的訓練資料項目被錯誤預測。 請注意,原始誤差將同等對待每個訓練項。 結果證明,本文中所演示的自我調整增強演算法實際上並不需要原始誤差欄位,因此可忽略該欄位,但我認為此資訊很有用。

epsilon 欄位是加權誤差項。 弱學習器的 epsilon 是考慮分配給每個訓練項的內部 D 權重的誤差項。 自我調整增強演算法使用 epsilon 值計算 Alpha 權重。 總之,有兩組權重用在自我調整增強分類中。 Alpha 權重為每個弱學習器分配重要性,並用於確定總體預測。 epsilon 誤差是與弱學習器關聯的內部誤差,用於計算 Alpha 權重。 每個訓練元組都有一個內部權重(在自我調整增強文獻資料中稱為 D),用於計算 epsilon 誤差。

在偽代碼中,方法 MakeLearners 的工作原理如下所示:

initialize an empty result list of learners
for each feature loop
  for each value of curr feature loop
    scan training data to determine most likely -1, +1 result
    if no most likely result, skip curr value
    create a new learner object with feature, value, predicted
    add learner object to result list
  end each value
end each feature
for each learner in result list
  for each training data item
    if learner isn't applicable to data, skip curr data item
    compute raw error rate
    store raw error into learner
  end each training data item
end each learner

這裡的思路是,每個 feature 值(如「Atlanta」(opponent) 或「Medium」(point spread))都將根據訓練資料生成一個弱學習器規則,除非該值未顯示在訓練資料(例如「New York」的對手)中或者因與該值關聯的輸贏次數相同(例如,在演示資料中 opponent 為「Atlanta」時,輸贏各一次)而未生成最可能的結果。

總結

對本文介紹的演算法的一項重要變化是處理具有數值的資料。 例如,假設 point spread 特徵的值是數值(如 1.5、3.0 和 9.5),而不是分類值「Small」、「Medium」和「Large」。 與其他分類方法相比,自我調整增強分類的一個主要優勢在於,自我調整增強可以方便地直接處理分類和數值資料。 你可以創建一個一目了然的專用學習器類,類似于「if Spread is less than or equal to 5.5 then Result is Lose」;也可以創建一個比較複雜的學習器,使用以下程式碼:「if Spread is between 4.0 and 6.0 then Result is Win」。

在我看來,如果要預測的相關變數只有兩個可能的值,最合適使用自我調整增強分類。 不過,高級自我調整增強方法也可以處理多維分類。 如果要對此或一般自我調整增強的基礎理論進行深入研究,建議搜索一下研究人員 R. Schapire and Y. Freund.

電腦學習研究表明,沒有任何單一的最佳資料分類/預測方法。 但是自我調整增強是一種非常強大的方法,它可以形成向 .NET 軟體系統添加預測功能的基礎。

Dr. James McCaffrey   供職于 Volt Information Sciences Inc.,負責管理華盛頓地區雷蒙德市沃什灣 Microsoft 總部園區的軟體工程師技術培訓。 他參與過多項 Microsoft 產品的研發工作,其中包括 Internet Explorer 和 MSN Search。 他是《.NET Test Automation Recipes》(Apress,2006)的作者,你可以通過以下電子郵箱位址與他聯繫:jammc@microsoft.com

衷心感謝以下技術專家對本文的審閱: Darren Gehring (Microsoft)