# 如何在Python中從頭開始實現感知器算法 > 原文： [https://machinelearningmastery.com/implement-perceptron-algorithm-scratch-python/](https://machinelearningmastery.com/implement-perceptron-algorithm-scratch-python/) Perceptron算法是最簡單的人工神經網絡。 它是單個神經元的模型，可用于兩類分類問題，并為以后開發更大的網絡提供基礎。 在本教程中，您將了解如何使用Python從頭開始實現Perceptron算法。 完成本教程后，您將了解： * 如何訓練Perceptron的網絡權重。 * 如何使用Perceptron進行預測。 * 如何針對真實世界的分類問題實現Perceptron算法。 讓我們開始吧。 * **2017年1月更新**：將cross_validation_split（）中的fold_size計算更改為始終為整數。修復了Python 3的問題。 * **更新Aug / 2018** ：經過測試和更新，可與Python 3.6配合使用。  如何在Python中從頭開始實現感知器算法 照片由 [Les Haines](https://www.flickr.com/photos/leshaines123/5835538829/) ，保留一些權利。 ## 描述 本節簡要介紹Perceptron算法和我們稍后將應用它的Sonar數據集。 ### 感知器算法 Perceptron的靈感來自于稱為神經元的單個神經細胞的信息處理。 神經元通過其樹突接受輸入信號，樹突將電信號傳遞到細胞體。 以類似的方式，Perceptron從訓練數據的示例接收輸入信號，我們對這些訓練數據進行加權并組合成稱為激活的線性方程。 ```py activation = sum(weight_i * x_i) + bias ``` 然后使用諸如步進傳遞函數的傳遞函數將激活變換為輸出值或預測。 ```py prediction = 1.0 if activation >= 0.0 else 0.0 ``` 通過這種方式，Perceptron是一個分類算法，用于解決兩個類（0和1）的問題，其中線性方程（如超平面）可以用來分離這兩個類。 它與線性回歸和邏輯回歸密切相關，以類似的方式進行預測（例如輸入的加權和）。 必須使用隨機梯度下降從訓練數據中估計Perceptron算法的權重。 ### 隨機梯度下降 梯度下降是通過遵循成本函數的梯度來最小化函數的過程。 這包括了解成本的形式以及衍生物，以便從給定的點知道梯度并且可以在該方向上移動，例如，向下走向最小值。 在機器學習中，我們可以使用一種技術來評估和更新稱為隨機梯度下降的每次迭代的權重，以最小化模型對我們的訓練數據的誤差。 此優化算法的工作方式是每個訓練實例一次顯示給模型一個。該模型對訓練實例進行預測，計算誤差并更新模型以減少下一次預測的誤差。 此過程可用于在模型中查找權重集，從而導致訓練數據上模型的最小誤差。 對于Perceptron算法，每次迭代使用以下等式更新權重（ **w** ）： ```py w = w + learning_rate * (expected - predicted) * x ``` **w** 的權重被優化， **learning_rate** 是你必須配置的學習率（例如0.01），**（預期 - 預測）**是預測誤差歸因于重量和 **x** 的訓練數據的模型是輸入值。 ### 聲納數據集 我們將在本教程中使用的數據集是Sonar數據集。 這是一個描述聲納啁啾返回彈跳不同服務的數據集。 60個輸入變量是不同角度的回報強度。這是一個二元分類問題，需要一個模型來區分巖石和金屬圓柱。 這是一個眾所周知的數據集。所有變量都是連續的，通常在0到1的范圍內。因此我們不必對輸入數據進行標準化，這通常是Perceptron算法的一個好習慣。輸出變量是我的字符串“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. 聲納數據集建模。 這些步驟將為您提供實施Perceptron算法并將其應用于您自己的分類預測建模問題的基礎。 ### 1.做出預測 第一步是開發一個可以進行預測的功能。 這在隨機梯度下降中的候選權重值的評估中以及在模型完成之后并且我們希望開始對測試數據或新數據進行預測時都需要。 下面是一個名為 **predict（）**的函數，它預測給定一組權重的行的輸出值。 第一個權重始終是偏差，因為它是獨立的，不負責特定的輸入值。 ```py # Make a prediction with weights def predict(row, weights): activation = weights[0] for i in range(len(row)-1): activation += weights[i + 1] * row[i] return 1.0 if activation >= 0.0 else 0.0 ``` 我們可以設計一個小數據集來測試我們的預測函數。 ```py X1 X2 Y 2.7810836 2.550537003 0 1.465489372 2.362125076 0 3.396561688 4.400293529 0 1.38807019 1.850220317 0 3.06407232 3.005305973 0 7.627531214 2.759262235 1 5.332441248 2.088626775 1 6.922596716 1.77106367 1 8.675418651 -0.242068655 1 7.673756466 3.508563011 1 ``` 我們還可以使用先前準備的權重來對此數據集進行預測。 綜合這些，我們可以測試下面的 **predict（）**函數。 ```py # Make a prediction with weights def predict(row, weights): activation = weights[0] for i in range(len(row)-1): activation += weights[i + 1] * row[i] return 1.0 if activation >= 0.0 else 0.0 # test predictions dataset = [[2.7810836,2.550537003,0], [1.465489372,2.362125076,0], [3.396561688,4.400293529,0], [1.38807019,1.850220317,0], [3.06407232,3.005305973,0], [7.627531214,2.759262235,1], [5.332441248,2.088626775,1], [6.922596716,1.77106367,1], [8.675418651,-0.242068655,1], [7.673756466,3.508563011,1]] weights = [-0.1, 0.20653640140000007, -0.23418117710000003] for row in dataset: prediction = predict(row, weights) print("Expected=%d, Predicted=%d" % (row[-1], prediction)) ``` 有兩個輸入值（ **X1** 和 **X2** ）和三個權重值（**偏差**， **w1** 和 **w2** ）。我們為此問題建模的激活方程是： ```py activation = (w1 * X1) + (w2 * X2) + bias ``` 或者，我們手動選擇具體的重量值： ```py activation = (0.206 * X1) + (-0.234 * X2) + -0.1 ``` 運行此函數，我們得到與預期輸出（ **y** ）值匹配的預測。 ```py Expected=0, Predicted=0 Expected=0, Predicted=0 Expected=0, Predicted=0 Expected=0, Predicted=0 Expected=0, Predicted=0 Expected=1, Predicted=1 Expected=1, Predicted=1 Expected=1, Predicted=1 Expected=1, Predicted=1 Expected=1, Predicted=1 ``` 現在我們準備實施隨機梯度下降來優化我們的重量值。 ### 2.訓練網絡權重 我們可以使用隨機梯度下降來估計訓練數據的權重值。 隨機梯度下降需要兩個參數： * **學習率**：用于限制每次更新時每個重量的校正量。 * **Epochs** ：更新體重時運行訓練數據的次數。 這些以及訓練數據將是該函數的參數。 我們需要在函數中執行3個循環： 1. 循環每個時代。 2. 循環遍歷訓練數據中的每一行以獲得一個迭代。 3. 循環遍歷每個權重并將其更新為一個迭代中的一行。 如您所見，我們更新訓練數據中每一行的每個權重，每個時期。 權重根據模型產生的錯誤進行更新。該誤差被計算為預期輸出值與用候選權重進行的預測之間的差異。 每個輸入屬性都有一個權重，這些權重以一致的方式更新，例如： ```py w(t+1)= w(t) + learning_rate * (expected(t) - predicted(t)) * x(t) ``` 偏差以類似的方式更新，除非沒有輸入，因為它與特定輸入值無關： ```py bias(t+1) = bias(t) + learning_rate * (expected(t) - predicted(t)) ``` 現在我們可以將所有這些放在一起。下面是一個名為 **train_weights（）**的函數，它使用隨機梯度下降計算訓練數據集的權重值。 ```py # Estimate Perceptron weights using stochastic gradient descent def train_weights(train, l_rate, n_epoch): weights = [0.0 for i in range(len(train[0]))] for epoch in range(n_epoch): sum_error = 0.0 for row in train: prediction = predict(row, weights) error = row[-1] - prediction sum_error += error**2 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] print('>epoch=%d, lrate=%.3f, error=%.3f' % (epoch, l_rate, sum_error)) return weights ``` 您可以看到我們還跟蹤每個時期的平方誤差（正值）的總和，以便我們可以在每個外部循環中打印出一條好消息。 我們可以在上面的同樣小的人為數據集上測試這個函數。 ```py # Make a prediction with weights def predict(row, weights): activation = weights[0] for i in range(len(row)-1): activation += weights[i + 1] * row[i] return 1.0 if activation >= 0.0 else 0.0 # Estimate Perceptron weights using stochastic gradient descent def train_weights(train, l_rate, n_epoch): weights = [0.0 for i in range(len(train[0]))] for epoch in range(n_epoch): sum_error = 0.0 for row in train: prediction = predict(row, weights) error = row[-1] - prediction sum_error += error**2 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] print('>epoch=%d, lrate=%.3f, error=%.3f' % (epoch, l_rate, sum_error)) return weights # Calculate weights dataset = [[2.7810836,2.550537003,0], [1.465489372,2.362125076,0], [3.396561688,4.400293529,0], [1.38807019,1.850220317,0], [3.06407232,3.005305973,0], [7.627531214,2.759262235,1], [5.332441248,2.088626775,1], [6.922596716,1.77106367,1], [8.675418651,-0.242068655,1], [7.673756466,3.508563011,1]] l_rate = 0.1 n_epoch = 5 weights = train_weights(dataset, l_rate, n_epoch) print(weights) ``` 我們使用0.1的學習率并且僅將模型訓練5個時期，或者將權重的5次暴露訓練到整個訓練數據集。 運行該示例在每個迭代打印一條消息，其中包含該迭代和最終權重集的總和平方誤差。 ```py >epoch=0, lrate=0.100, error=2.000 >epoch=1, lrate=0.100, error=1.000 >epoch=2, lrate=0.100, error=0.000 >epoch=3, lrate=0.100, error=0.000 >epoch=4, lrate=0.100, error=0.000 [-0.1, 0.20653640140000007, -0.23418117710000003] ``` 您可以通過算法快速了解問題是如何學習的。 現在，讓我們將這個算法應用于真實數據集。 ### 3.對聲納數據集進行建模 在本節中，我們將使用Sonar數據集上的隨機梯度下降來訓練Perceptron模型。 該示例假定數據集的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（）**輔助函數中提供。 我們將使用上面創建的 **predict（）和** **train_weights（）**函數來訓練模型和新的 **perceptron（）**函數將它們綁定在一起。 以下是完整的示例。 ```py # Perceptron Algorithm on the Sonar Dataset from random import seed from random import randrange from csv import reader # 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 # Make a prediction with weights def predict(row, weights): activation = weights[0] for i in range(len(row)-1): activation += weights[i + 1] * row[i] return 1.0 if activation >= 0.0 else 0.0 # Estimate Perceptron weights using stochastic gradient descent def train_weights(train, l_rate, n_epoch): weights = [0.0 for i in range(len(train[0]))] for epoch in range(n_epoch): for row in train: prediction = predict(row, weights) 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 Algorithm With Stochastic Gradient Descent def perceptron(train, test, l_rate, n_epoch): predictions = list() weights = train_weights(train, l_rate, n_epoch) for row in test: prediction = predict(row, weights) predictions.append(prediction) return(predictions) # Test the Perceptron algorithm on the sonar dataset seed(1) # load and prepare data filename = 'sonar.all-data.csv' dataset = load_csv(filename) for i in range(len(dataset[0])-1): str_column_to_float(dataset, i) # convert string class to integers str_column_to_int(dataset, len(dataset[0])-1) # evaluate algorithm n_folds = 3 l_rate = 0.01 n_epoch = 500 scores = evaluate_algorithm(dataset, perceptron, n_folds, l_rate, n_epoch) print('Scores: %s' % scores) print('Mean Accuracy: %.3f%%' % (sum(scores)/float(len(scores)))) ``` k值為3用于交叉驗證，每次迭代時評估每個折疊208/3 = 69.3或略低于70的記錄。通過一些實驗選擇了0.1和500個訓練時期的學習率。 您可以嘗試自己的配置，看看是否可以打敗我的分數。 運行此示例將打印3個交叉驗證折疊中每個折疊的分數，然后打印平均分類精度。 我們可以看到，如果我們僅使用零規則算法預測大多數類，則準確度約為72％，高于僅超過50％的基線值。 ```py Scores: [76.81159420289855, 69.56521739130434, 72.46376811594203] Mean Accuracy: 72.947% ``` ## 擴展 本節列出了您可能希望考慮探索的本教程的擴展。 * **調整示例**。調整學習率，時期數甚至數據準備方法以獲得數據集上的改進分數。 * **批隨機梯度下降**。更改隨機梯度下降算法以在每個時期累積更新，并且僅在時期結束時批量更新權重。 * **其他回歸問題**。將該技術應用于UCI機器學習庫中的其他分類問題。 **你有沒有探索過這些擴展？** 請在下面的評論中告訴我。 ## 評論 在本教程中，您了解了如何使用Python從頭開始使用隨機梯度下降來實現Perceptron算法。 你學到了 * 如何預測二元分類問題。 * 如何使用隨機梯度下降來優化一組權重。 * 如何將該技術應用于真實的分類預測建模問題。 **你有什么問題嗎？** 在下面的評論中提出您的問題，我會盡力回答。