我們在上篇筆記中介紹了感知機的理論知識，討論了感知機的由來、作業原理、求解策略、收斂性，這篇筆記中，我們親自動手寫代碼，使用感知機演算法解決實際問題，
先從一個最簡單的問題開始，用感知機演算法解決OR邏輯的分類，
import numpy as np
import matplotlib.pyplot as plt
x = [0,0,1,1]
y = [0,1,0,1]
plt.scatter(x[0],y[0], color="red",label="negative")
plt.scatter(x[1:],y[1:], color="green",label="positive")
plt.legend(loc="best")
plt.show()
下面我們來定義一個函式，用來判定一個樣本點是否被正確分類了，由于此例中樣本點是二維的，因此權重向量也相應的為二維，可以定義為\(w = (w_1, w_2)\)，在Python中可以使用串列來表達，例如w = [0, 0]，而樣本到超平面的距離自然就是w[0] * x[0] + w[1] * x[1] +b，下面給出完整的函式，
def decide(data,label,w,b):
result = w[0] * data[0] + w[1] * data[1] - b
print("result = ",result)
if np.sign(result) * label <= 0:
w[0] += 1 * (label - result) * data[0]
w[1] += 1 * (label - result) * data[1]
b += 1 * (label - result)*(-1)
return w,b
寫完核心函式后，我們還需要寫一個調度函式，這個函式提供遍歷每一個樣本點的功能，
def run(data, label):
w,b = [0,0],0
for epoch in range(10):
for item in zip(data, label):
dataset,labelset = item[0],item[1]
w,b = decide(dataset, labelset, w, b)
print("dataset = ",dataset, ",", "w = ",w,",","b = ",b)
print(w,b)
data = https://www.cnblogs.com/learn-the-hard-way/p/[(0,0),(0,1),(1,0),(1,1)]
label = [0,1,1,1]
run(data,label)
result = 0
dataset = (0, 0) , w = [0, 0] , b = 0
result = 0
dataset = (0, 1) , w = [0, 1] , b = -1
result = 1
dataset = (1, 0) , w = [0, 1] , b = -1
result = 2
dataset = (1, 1) , w = [0, 1] , b = -1
result = 1
dataset = (0, 0) , w = [0, 1] , b = 0
result = 1
dataset = (0, 1) , w = [0, 1] , b = 0
result = 0
dataset = (1, 0) , w = [1, 1] , b = -1
result = 3
dataset = (1, 1) , w = [1, 1] , b = -1
result = 1
dataset = (0, 0) , w = [1, 1] , b = 0
result = 1
dataset = (0, 1) , w = [1, 1] , b = 0
result = 1
后面的迭代這里省略不貼，引數穩定下來，演算法已經收斂
下面看一個來自UCI的資料集：PIMA糖尿病資料集，例子來自《機器學習演算法視角》第三章
import os
import pylab as pl
import numpy as np
import pandas as pd
os.chdir(r"DataSets\pima-indians-diabetes-database")
pima = np.loadtxt("pima.txt", delimiter=",", skiprows=1)
pima.shape
(768, 9)
indices0 = np.where(pima[:,8]==0)
indices1 = np.where(pima[:,8]==1)
pl.ion()
pl.plot(pima[indices0,0],pima[indices0,1],"go")
pl.plot(pima[indices1,0],pima[indices1,1],"rx")
pl.show()
資料預處理
1.將年齡離散化
pima[np.where(pima[:,7]<=30),7] = 1
pima[np.where((pima[:,7]>30) & (pima[:,7]<=40)),7] = 2
pima[np.where((pima[:,7]>40) & (pima[:,7]<=50)),7] = 3
pima[np.where((pima[:,7]>50) & (pima[:,7]<=60)),7] = 4
pima[np.where(pima[:,7]>60),7] = 5
2.將女性的懷孕次數大于8次的統一用8次代替
pima[np.where(pima[:,0]>8),0] = 8
3.將資料標準化處理
pima[:,:8] = pima[:,:8]-pima[:,:8].mean(axis=0)
pima[:,:8] = pima[:,:8]/pima[:,:8].var(axis=0)
4.切分訓練集和測驗集
trainin = pima[::2,:8]
testin = pima[1::2,:8]
traintgt = pima[::2,8:9]
testtgt = pima[1::2,8:9]
定義模型
class Perceptron:
def __init__(self, inputs, targets):
# 設定網路規模
# 記錄輸入向量的維度，神經元的維度要和它相等
if np.ndim(inputs) > 1:
self.nIn = np.shape(inputs)[1]
else:
self.nIn = 1
# 記錄目標向量的維度，神經元的個數要和它相等
if np.ndim(targets) > 1:
self.nOut = np.shape(targets)[1]
else:
self.nOut = 1
# 記錄輸入向量的樣本個數
self.nData = https://www.cnblogs.com/learn-the-hard-way/p/np.shape(inputs)[0]
# 初始化網路，這里加1是為了包含偏置項
self.weights = np.random.rand(self.nIn + 1, self.nOut) * 0.1 - 0.05
def train(self, inputs, targets, eta, epoch):
"""訓練環節"""
# 和前面處理偏置項同步地，這里對輸入樣本加一項-1，與W0相匹配
inputs = np.concatenate((inputs, -np.ones((self.nData,1))),axis=1)
for n in range(epoch):
self.activations = self.forward(inputs)
self.weights -= eta * np.dot(np.transpose(inputs), self.activations - targets)
return self.weights
def forward(self, inputs):
"""神經網路前向傳播環節"""
# 計算
activations = np.dot(inputs, self.weights)
# 判斷是否激活
return np.where(activations>0, 1, 0)
def confusion_matrix(self, inputs, targets):
# 計算混淆矩陣
inputs = np.concatenate((inputs, -np.ones((self.nData,1))),axis=1)
outputs = np.dot(inputs, self.weights)
nClasses = np.shape(targets)[1]
if nClasses == 1:
nClasses = 2
outputs = np.where(outputs<0, 1, 0)
else:
outputs = np.argmax(outputs, 1)
targets = np.argmax(targets, 1)
cm = np.zeros((nClasses, nClasses))
for i in range(nClasses):
for j in range(nClasses):
cm[i,j] = np.sum(np.where(outputs==i, 1,0) * np.where(targets==j, 1, 0))
print(cm)
print(np.trace(cm)/np.sum(cm))
print("Output after preprocessing of data")
p = Perceptron(trainin,traintgt)
p.train(trainin,traintgt,0.15,10000)
p.confusion_matrix(testin,testtgt)
Output after preprocessing of data
[[ 69. 86.]
[182. 47.]]
0.3020833333333333
這個案例使用感知機訓練得到的結果比較糟糕，這里只是作為展示演算法的例子，
最后看一個使用感知機演算法識別MNIST手寫數字的例子，代碼借鑒了Kaggle上的kernel，
step 1：首先匯入所需的包，并且設定好資料所在路徑
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
train = pd.read_csv(r"DataSets\Digit_Recognizer\train.csv", engine="python")
test = pd.read_csv(r"DataSets\Digit_Recognizer\test.csv", engine="python")
print("Training set has {0[0]} rows and {0[1]} columns".format(train.shape))
print("Test set has {0[0]} rows and {0[1]} columns".format(test.shape))
Training set has 42000 rows and 785 columns
Test set has 28000 rows and 784 columns
step 2：資料預處理
-
創建
label，它的size為 (42000, 1) -
創建
training set，size為(42000, 784) -
創建
weights，size為（10，784），這可能有點不好理解，我們知道，權重向量是描述神經元的，784是維度，表示一個輸入樣本有784維，相應的與它對接的神經元也要有784維，同時，要記住一個神經元只能輸出一個output，而在數字識別問題中，我們期待的是輸入一個樣本資料，能回傳10個數字，然后依概率判斷這個樣本是哪個數字的可能性最大，所以，我們需要10個神經元，這就是(10,784)的來歷，
trainlabels = train.label
trainlabels.shape
(42000,)
traindata = https://www.cnblogs.com/learn-the-hard-way/p/np.asmatrix(train.loc[:,"pixel0":])
traindata.shape
(42000, 784)
weights = np.zeros((10,784))
weights.shape
(10, 784)
這里可以先看一個樣本，找找感覺，注意原資料是壓縮成了784維的陣列，我們需要將它變回28*28的圖片
# 從矩陣中隨便取一行
samplerow = traindata[123:124]
# 重新變成28*28
samplerow = np.reshape(samplerow, (28,28))
plt.imshow(samplerow, cmap="hot")
step 3：訓練
這里我們對訓練資料集回圈若干次，然后重點關注錯誤率曲線
# 先創建一個串列，用來記錄每一輪訓練的錯誤率
errors = []
epoch = 20
for epoch in range(epoch):
err = 0
# 對每一個樣本（亦矩陣中的每一行）
for i, data in enumerate(traindata):
# 創建一個串列，用來記錄每個神經元輸出的值
output = []
# 對每個神經元都做點乘操作，并記錄下輸出值
for w in weights:
output.append(np.dot(data, w))
# 這里簡單的取輸出值最大者為最有可能的
guess = np.argmax(output)
# 實際的值為標簽串列中對應項
actual = trainlabels[i]
# 如果估計值和實際值不同，則分類錯誤，需要更新權重向量
if guess != actual:
weights[guess] = weights[guess] - data
weights[actual] = weights[actual] + data
err += 1
# 計算迭代完42000個樣本之后，錯誤率 = 錯誤次數/樣本個數
errors.append(err/42000)
x = list(range(20))
plt.plot(x, errors)
[<matplotlib.lines.Line2D at 0x5955c50>]
從圖可以看出，達到15次迭代時，錯誤率已經有上升的趨勢了，開始過擬合了，
感知機是一個非常簡單的演算法，以致于很難在真正的場景中使用感知機演算法，這里舉的3個例子，都旨在于動手寫代碼實作這個演算法，找找感覺，稍有經驗的讀者想必會好奇：為什么沒有使用Scikit-Learn這個包，這部分其實是筆者另有計劃，打算結合演算法寫Scikit-Learn的原始碼解讀筆記，當然，限于個人水平，不一定能決議到精髓，但勉力而為吧，下篇會寫Multi-Layer-Perceptron演算法的原理，在那里我們很容易看到，縱使是簡單的感知機，只要加一個隱層，就能大幅提升其分類能力，另外，也會抽空寫一篇感知機Sklearn原始碼解讀的文章，有任何問題，歡迎大家留言討論，
轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/62240.html
標籤：其他
上一篇：下圖抓支付鏈接，怎么抓
下一篇：C++模型部署影像預處理問題