如何用Python從頭開始實現堆棧泛化（Stacking） · Machine Learning Mastery 博客文章翻譯

# 如何用Python從頭開始實現堆棧泛化（Stacking） > 原文： [https://machinelearningmastery.com/implementing-stacking-scratch-python/](https://machinelearningmastery.com/implementing-stacking-scratch-python/) #### 使用Python從頭開始編寫堆棧集合，循序漸進。集合方法是提高機器學習問題預測表現的絕佳方法。堆疊泛化或堆疊是一種集合技術，它使用新模型來學習如何最佳地組合來自數據集上訓練的兩個或更多模型的預測。在本教程中，您將了解如何在Python中從頭開始實現堆疊。完成本教程后，您將了解： * 如何學習在數據集上組合多個模型的預測。 * 如何將疊加泛化應用于實際預測建模問題。讓我們開始吧。 * **2017年1月更新**：將cross_validation_split（）中的fold_size計算更改為始終為整數。修復了Python 3的問題。 * **更新Aug / 2018** ：經過測試和更新，可與Python 3.6配合使用。 ![How to Implementing Stacking From Scratch With Python](img/2960d608a0641f5cd292c91a7669c364.jpg) 如何使用Python從頭開始實現堆疊 [Kiran Foster](https://www.flickr.com/photos/rueful/7885846128/) 的照片，保留一些權利。 ## 描述本節簡要概述了本教程中使用的Stacked Generalization算法和Sonar數據集。 ### 疊加泛化算法堆疊泛化或堆疊是一種集合算法，其中訓練新模型以組合來自已經訓練的兩個或更多模型或您的數據集的預測。來自現有模型或子模型的預測使用新模型組合，并且因為這種堆疊通常被稱為混合，因為來自子模型的預測被混合在一起。通常使用簡單的線性方法將子模型的預測（例如簡單平均或投票）與使用線性回歸或邏輯回歸的加權和相結合。將預測結合起來的模型必須掌握問題的技巧，但不需要是最好的模型。這意味著您不需要專心調整子模型，只要模型顯示出優于基線預測的優勢。子模型產生不同的預測非常重要，即所謂的不相關預測。當組合的預測都是熟練的，但以不同的方式熟練時，堆疊效果最佳。這可以通過使用使用非常不同的內部表示（與實例相比的樹）和/或在訓練數據的不同表示或投影上訓練的模型的算法來實現。在本教程中，我們將考慮采用兩個非常不同且未調整的子模型，并將它們的預測與簡單的邏輯回歸算法相結合。 ### 聲納數據集我們將在本教程中使用的數據集是Sonar數據集。這是一個描述聲納啁啾返回從不同表面反彈的數據集。 60個輸入變量是不同角度的回報強度。這是一個二元分類問題，需要一個模型來區分巖石和金屬圓柱。共有208個觀測結果。這是一個眾所周知的數據集。所有變量都是連續的，通常在0到1的范圍內。輸出變量是我的字符串“M”和搖滾的“R”，需要將其轉換為整數1和0。通過預測數據集（M或礦）中具有最多觀測值的類，零規則算法可以實現約53％的準確度。您可以在 [UCI機器學習庫](https://archive.ics.uci.edu/ml/datasets/Connectionist+Bench+(Sonar,+Mines+vs.+Rocks))中了解有關此數據集的更多信息。免費下載數據集并將其放在工作目錄中，文件名為 **sonar.all-data.csv** 。 ## 教程本教程分為3個步驟： 1. 子模型和聚合器。 2. 結合預測。 3. 聲納數據集案例研究。這些步驟為您在自己的預測建模問題上理解和實現堆疊提供了基礎。 ### 1.子模型和聚合器我們將使用兩個模型作為子模型進行堆疊，使用線性模型作為聚合器模型。這部分分為3個部分： 1. 子模型＃1：k-Nearest Neighbors。 2. 子模型＃2：感知器。 3. 聚合器模型：Logistic回歸。每個模型將根據用于訓練模型的函數和用于進行預測的函數來描述。 #### 1.1子模型＃1：k-最近鄰居 k-Nearest Neighbors算法或kNN使用整個訓練數據集作為模型。因此，訓練模型涉及保留訓練數據集。下面是一個名為 **knn_model（）**的函數。 ```py # Prepare the kNN model def knn_model(train): return train ``` 進行預測涉及在訓練數據集中查找k個最相似的記錄并選擇最常見的類值。歐幾里德距離函數用于計算訓練數據集中新行數據和行之間的相似性。以下是涉及對kNN模型進行預測的這些輔助函數。函數 **euclidean_distance（）**計算兩行數據之間的距離， **get_neighbors（）**定位訓練數據集中所有鄰居的新行數據和 **knn_predict（）** 從鄰居做出新行數據的預測。 ```py # Calculate the Euclidean distance between two vectors def euclidean_distance(row1, row2): distance = 0.0 for i in range(len(row1)-1): distance += (row1[i] - row2[i])**2 return sqrt(distance) # Locate neighbors for a new row def get_neighbors(train, test_row, num_neighbors): distances = list() for train_row in train: dist = euclidean_distance(test_row, train_row) distances.append((train_row, dist)) distances.sort(key=lambda tup: tup[1]) neighbors = list() for i in range(num_neighbors): neighbors.append(distances[i][0]) return neighbors # Make a prediction with kNN def knn_predict(model, test_row, num_neighbors=2): neighbors = get_neighbors(model, test_row, num_neighbors) output_values = [row[-1] for row in neighbors] prediction = max(set(output_values), key=output_values.count) return prediction ``` 您可以看到鄰居數（k）設置為2作為 **knn_predict（）**函數的默認參數。這個數字是經過一些試驗和錯誤選擇的，沒有調整。現在我們已經有了kNN模型的構建塊，讓我們來看看Perceptron算法。 #### 1.2子模型＃2：感知器 Perceptron算法的模型是從訓練數據中學習的一組權重。為了訓練權重，需要對訓練數據進行許多預測以便計算誤差值。因此，模型訓練和預測都需要預測功能。下面是實現Perceptron算法的輔助函數。 **perceptron_model（）**函數在訓練數據集上訓練Perceptron模型， **perceptron_predict（）**用于對一行數據進行預測。 ```py # Make a prediction with weights def perceptron_predict(model, row): activation = model[0] for i in range(len(row)-1): activation += model[i + 1] * row[i] return 1.0 if activation >= 0.0 else 0.0 # Estimate Perceptron weights using stochastic gradient descent def perceptron_model(train, l_rate=0.01, n_epoch=5000): weights = [0.0 for i in range(len(train[0]))] for epoch in range(n_epoch): for row in train: prediction = perceptron_predict(weights, row) error = row[-1] - prediction weights[0] = weights[0] + l_rate * error for i in range(len(row)-1): weights[i + 1] = weights[i + 1] + l_rate * error * row[i] return weights ``` **perceptron_model（）**模型將學習率和訓練時期數指定為默認參數。同樣，這些參數是通過一些試驗和錯誤選擇的，但沒有在數據集上進行調整。我們現在已經實現了兩個子模型，讓我們看一下實現聚合器模型。 #### 1.3聚合器模型：Logistic回歸與Perceptron算法一樣，Logistic回歸使用一組稱為系數的權重作為模型的表示。與Perceptron算法一樣，通過迭代地對訓練數據進行預測并更新它們來學習系數。以下是用于實現邏輯回歸算法的輔助函數。 **logistic_regression_model（）**函數用于訓練訓練數據集上的系數， **logistic_regression_predict（）**用于對一行數據進行預測。 ```py # Make a prediction with coefficients def logistic_regression_predict(model, row): yhat = model[0] for i in range(len(row)-1): yhat += model[i + 1] * row[i] return 1.0 / (1.0 + exp(-yhat)) # Estimate logistic regression coefficients using stochastic gradient descent def logistic_regression_model(train, l_rate=0.01, n_epoch=5000): coef = [0.0 for i in range(len(train[0]))] for epoch in range(n_epoch): for row in train: yhat = logistic_regression_predict(coef, row) error = row[-1] - yhat coef[0] = coef[0] + l_rate * error * yhat * (1.0 - yhat) for i in range(len(row)-1): coef[i + 1] = coef[i + 1] + l_rate * error * yhat * (1.0 - yhat) * row[i] return coef ``` **logistic_regression_model（）**將學習率和時期數定義為默認參數，并且與其他算法一樣，這些參數在一些試驗和錯誤中被發現并且未被優化。現在我們已經實現了子模型和聚合器模型，讓我們看看如何組合多個模型的預測。 ### 2.結合預測對于機器學習算法，學習如何組合預測與從訓練數據集學習非常相似。可以根據子模型的預測構建新的訓練數據集，如下所示： * 每行代表訓練數據集中的一行。 * 第一列包含由第一個子模型制作的訓練數據集中每一行的預測，例如k-Nearest Neighbors。 * 第二列包含由第二個子模型制作的訓練數據集中每一行的預測，例如Perceptron算法。 * 第三列包含訓練數據集中行的預期輸出值。下面是構造的堆疊數據集的外觀設計示例： ```py kNN, Per, Y 0, 0 0 1, 0 1 0, 1 0 1, 1 1 0, 1 0 ``` 然后可以在該新數據集上訓練機器學習算法，例如邏輯回歸。實質上，這種新的元算法學習如何最好地組合來自多個子模型的預測。下面是一個名為 **to_stacked_row（）**的函數，它實現了為此堆疊數據集創建新行的過程。該函數將模型列表作為輸入，這些用于進行預測。該函數還將函數列表作為輸入，一個函數用于對每個模型進行預測。最后，包括訓練數據集中的單行。一行一列構造一個新行。使用每個模型和訓練數據行計算預測。然后將訓練數據集行的預期輸出值添加為行的最后一列。 ```py # Make predictions with sub-models and construct a new stacked row def to_stacked_row(models, predict_list, row): stacked_row = list() for i in range(len(models)): prediction = predict_list[i](models[i], row) stacked_row.append(prediction) stacked_row.append(row[-1]) return stacked_row ``` 在一些預測建模問題上，通過在訓練行和子模型做出的預測上訓練聚合模型，可以獲得更大的提升。這種改進為聚合器模型提供了訓練行中所有數據的上下文，以幫助確定如何以及何時最佳地組合子模型的預測。我們可以通過聚合訓練行（減去最后一列）和上面創建的堆疊行來更新我們的 **to_stacked_row（）**函數以包含它。以下是實現此改進的 **to_stacked_row（）**函數的更新版本。 ```py # Make predictions with sub-models and construct a new stacked row def to_stacked_row(models, predict_list, row): stacked_row = list() for i in range(len(models)): prediction = predict_list[i](models[i], row) stacked_row.append(prediction) stacked_row.append(row[-1]) return row[0:len(row)-1] + stacked_row ``` 在您的問題上嘗試兩種方法以查看哪種方法效果最好是個好主意。既然我們擁有堆疊泛化的所有部分，我們就可以將它應用于現實世界的問題。 ### 3.聲納數據集案例研究在本節中，我們將堆疊算法應用于Sonar數據集。該示例假定數據集的CSV副本位于當前工作目錄中，文件名為 **sonar.all-data.csv** 。首先加載數據集，將字符串值轉換為數字，并將輸出列從字符串轉換為0到1的整數值。這可以通過輔助函數 **load_csv（）**， **str_column_to_float（）**和 **str_column_to_int（）**加載和準備數據集。我們將使用k-fold交叉驗證來估計學習模型在看不見的數據上的表現。這意味著我們將構建和評估k模型并將表現估計為平均模型誤差。分類精度將用于評估模型。這些行為在 **cross_validation_split（）**， **accuracy_metric（）**和 **evaluate_algorithm（）**輔助函數中提供。我們將使用上面實現的k-Nearest Neighbors，Perceptron和Logistic回歸算法。我們還將使用我們的技術來創建上一步中定義的新堆疊數據集。開發了新的函數名 **stacking（）**。這個功能做了4件事： 1. 它首先訓練一個模型列表（kNN和Perceptron）。 2. 然后，它使用模型進行預測并創建新的堆疊數據集。 3. 然后，它在堆疊數據集上訓練聚合器模型（邏輯回歸）。 4. 然后，它使用子模型和聚合器模型對測試數據集進行預測。下面列出了完整的示例。 ```py # Test stacking on the sonar dataset from random import seed from random import randrange from csv import reader from math import sqrt from math import exp # Load a CSV file def load_csv(filename): dataset = list() with open(filename, 'r') as file: csv_reader = reader(file) for row in csv_reader: if not row: continue dataset.append(row) return dataset # Convert string column to float def str_column_to_float(dataset, column): for row in dataset: row[column] = float(row[column].strip()) # Convert string column to integer def str_column_to_int(dataset, column): class_values = [row[column] for row in dataset] unique = set(class_values) lookup = dict() for i, value in enumerate(unique): lookup[value] = i for row in dataset: row[column] = lookup[row[column]] return lookup # Split a dataset into k folds def cross_validation_split(dataset, n_folds): dataset_split = list() dataset_copy = list(dataset) fold_size = int(len(dataset) / n_folds) for i in range(n_folds): fold = list() while len(fold) < fold_size: index = randrange(len(dataset_copy)) fold.append(dataset_copy.pop(index)) dataset_split.append(fold) return dataset_split # Calculate accuracy percentage def accuracy_metric(actual, predicted): correct = 0 for i in range(len(actual)): if actual[i] == predicted[i]: correct += 1 return correct / float(len(actual)) * 100.0 # Evaluate an algorithm using a cross validation split def evaluate_algorithm(dataset, algorithm, n_folds, *args): folds = cross_validation_split(dataset, n_folds) scores = list() for fold in folds: train_set = list(folds) train_set.remove(fold) train_set = sum(train_set, []) test_set = list() for row in fold: row_copy = list(row) test_set.append(row_copy) row_copy[-1] = None predicted = algorithm(train_set, test_set, *args) actual = [row[-1] for row in fold] accuracy = accuracy_metric(actual, predicted) scores.append(accuracy) return scores # Calculate the Euclidean distance between two vectors def euclidean_distance(row1, row2): distance = 0.0 for i in range(len(row1)-1): distance += (row1[i] - row2[i])**2 return sqrt(distance) # Locate neighbors for a new row def get_neighbors(train, test_row, num_neighbors): distances = list() for train_row in train: dist = euclidean_distance(test_row, train_row) distances.append((train_row, dist)) distances.sort(key=lambda tup: tup[1]) neighbors = list() for i in range(num_neighbors): neighbors.append(distances[i][0]) return neighbors # Make a prediction with kNN def knn_predict(model, test_row, num_neighbors=2): neighbors = get_neighbors(model, test_row, num_neighbors) output_values = [row[-1] for row in neighbors] prediction = max(set(output_values), key=output_values.count) return prediction # Prepare the kNN model def knn_model(train): return train # Make a prediction with weights def perceptron_predict(model, row): activation = model[0] for i in range(len(row)-1): activation += model[i + 1] * row[i] return 1.0 if activation >= 0.0 else 0.0 # Estimate Perceptron weights using stochastic gradient descent def perceptron_model(train, l_rate=0.01, n_epoch=5000): weights = [0.0 for i in range(len(train[0]))] for epoch in range(n_epoch): for row in train: prediction = perceptron_predict(weights, row) error = row[-1] - prediction weights[0] = weights[0] + l_rate * error for i in range(len(row)-1): weights[i + 1] = weights[i + 1] + l_rate * error * row[i] return weights # Make a prediction with coefficients def logistic_regression_predict(model, row): yhat = model[0] for i in range(len(row)-1): yhat += model[i + 1] * row[i] return 1.0 / (1.0 + exp(-yhat)) # Estimate logistic regression coefficients using stochastic gradient descent def logistic_regression_model(train, l_rate=0.01, n_epoch=5000): coef = [0.0 for i in range(len(train[0]))] for epoch in range(n_epoch): for row in train: yhat = logistic_regression_predict(coef, row) error = row[-1] - yhat coef[0] = coef[0] + l_rate * error * yhat * (1.0 - yhat) for i in range(len(row)-1): coef[i + 1] = coef[i + 1] + l_rate * error * yhat * (1.0 - yhat) * row[i] return coef # Make predictions with sub-models and construct a new stacked row def to_stacked_row(models, predict_list, row): stacked_row = list() for i in range(len(models)): prediction = predict_list[i](models[i], row) stacked_row.append(prediction) stacked_row.append(row[-1]) return row[0:len(row)-1] + stacked_row # Stacked Generalization Algorithm def stacking(train, test): model_list = [knn_model, perceptron_model] predict_list = [knn_predict, perceptron_predict] models = list() for i in range(len(model_list)): model = model_list[i](train) models.append(model) stacked_dataset = list() for row in train: stacked_row = to_stacked_row(models, predict_list, row) stacked_dataset.append(stacked_row) stacked_model = logistic_regression_model(stacked_dataset) predictions = list() for row in test: stacked_row = to_stacked_row(models, predict_list, row) stacked_dataset.append(stacked_row) prediction = logistic_regression_predict(stacked_model, stacked_row) prediction = round(prediction) predictions.append(prediction) return predictions # Test stacking on the sonar dataset seed(1) # load and prepare data filename = 'sonar.all-data.csv' dataset = load_csv(filename) # convert string attributes to integers for i in range(len(dataset[0])-1): str_column_to_float(dataset, i) # convert class column to integers str_column_to_int(dataset, len(dataset[0])-1) n_folds = 3 scores = evaluate_algorithm(dataset, stacking, n_folds) print('Scores: %s' % scores) print('Mean Accuracy: %.3f%%' % (sum(scores)/float(len(scores)))) ``` k值為3用于交叉驗證，每次迭代時評估每個折疊208/3 = 69.3或略低于70的記錄。運行該示例將打印最終配置的分數和分數平均值。 ```py Scores: [78.26086956521739, 76.81159420289855, 69.56521739130434] Mean Accuracy: 74.879% ``` ## 擴展本節列出了您可能有興趣探索的本教程的擴展。 * **調諧算法**。本教程中用于子模型和聚合模型的算法未經過調整。探索備用配置，看看是否可以進一步提升表現。 * **預測相關性**。如果子模型的預測相關性較弱，則堆疊效果更好。實施計算以估計子模型的預測之間的相關性。 * **不同的子模型**。使用堆疊過程實現更多和不同的子模型。 * **不同的聚合模型**。嘗試使用更簡單的模型（如平均和投票）和更復雜的聚合模型來查看是否可以提高表現。 * **更多數據集**。將堆疊應用于UCI機器學習庫中的更多數據集。 **你有沒有探索過這些擴展？** 在下面的評論中分享您的經驗。 ## 評論在本教程中，您了解了如何在Python中從頭開始實現堆疊算法。具體來說，你學到了： * 如何組合多個模型的預測。 * 如何將堆疊應用于現實世界的預測建模問題。 **你有什么問題嗎？** 在下面的評論中提出您的問題，我會盡力回答。