本文結構：
- 什么是感知器
- 有什么用
- 代碼實現
1. 什么是感知器
如下圖，這個神經網絡中，每個圓圈都是一個神經元，神經元也叫做感知器
只有一個隱藏層的神經網絡就能擬合任何一個函數，但是它需要很多很多的神經元。
而深層網絡用相對少的神經元就能擬合同樣的函數，但是層數增加了，不太容易訓練，需要大量的數據。
為了擬合一個函數，可以使用一個淺而寬的網絡，也可以使用一個深而窄的網絡，后者更節約資源。
下圖單挑出一個感知器來看：
向它輸入 inputs，經過 加權 求和，再作用上激活函數后，得到一個輸出值
感知器的激活函數可以有很多選擇，關于激活函數可以看 常用激活函數比較
2. 有什么用
用感知器可以實現 and 函數，or 函數，還可以擬合任何的線性函數，任何線性分類或線性回歸問題都可以用感知器來解決。
但是，感知器卻不能實現異或運算，如下圖所示，異或運算不是線性的，無法用一條直線把 0 和 1 分開。
xor
訓練權重和偏置的算法如下：
其中，t 是訓練樣本的實際值，y 是感知器的輸出值，即由 f 計算出來的。eta 稱為學習速率，是個常數，作用是控制每一步調整權的幅度。
3. 代碼實現
［main］
先訓練and感知器
and_perception = train_and_perceptron()
得到訓練后獲得的權重和偏置
print and_perception
weights :[0.1, 0.2]
bias :-0.200000
再去測試，看結果是否正確
print '1 and 1 = %d' % and_perception.predict([1, 1])
其中
［train_and_perceptron］
先創建感知器，輸入參數個數為2（因為and是二元函數），激活函數為f
p = Perceptron(2, f)
f 為
def f(x):
return 1 if x > 0 else 0
輸入訓練data，迭代10次, 學習速率為0.1
input_vecs, labels = get_training_dataset()
p.train(input_vecs, labels, 10, 0.1)
訓練data為
input_vecs = [[1,1], [0,0], [1,0], [0,1]]
labels = [1, 0, 0, 0]
關于
［train］
一共迭代 10 次，每次迭代時，
先計算感知器在當前權重下的輸出，然后更新weights
output = self.predict(input_vec)
self._update_weights(input_vec, output, label, rate)
其中
［_update_weights］
就是用訓練算法里面的兩個公式
delta = label - output
self.weights = map(
lambda (x, w): w + rate * delta * x,
zip(input_vec, self.weights) )
self.bias += rate * delta
當
［predict］
就用感知器的函數 f：
return self.activator(
reduce(lambda a, b: a + b,
map(lambda (x, w): x * w,
zip(input_vec, self.weights))
, 0.0) + self.bias)
完整代碼：
#!/usr/bin/python
#-*-coding:utf-8 -*-
class Perceptron(object):
def __init__(self, input_num, activator):
'''
初始化感知器，設置輸入參數的個數，以及激活函數。
激活函數的類型為double -> double
'''
self.activator = activator
# 權重向量初始化為0
self.weights = [0.0 for _ in range(input_num)]
# 偏置項初始化為0
self.bias = 0.0
def __str__(self):
'''
打印學習到的權重、偏置項
'''
return 'weights\t:%s\nbias\t:%f\n' % (self.weights, self.bias)
def predict(self, input_vec):
'''
輸入向量，輸出感知器的計算結果
'''
# 把input_vec[x1,x2,x3...]和weights[w1,w2,w3,...]打包在一起
# 變成[(x1,w1),(x2,w2),(x3,w3),...]
# 然后利用map函數計算[x1*w1, x2*w2, x3*w3]
# 最后利用reduce求和
return self.activator(
reduce(lambda a, b: a + b,
map(lambda (x, w): x * w,
zip(input_vec, self.weights))
, 0.0) + self.bias)
def train(self, input_vecs, labels, iteration, rate):
'''
輸入訓練數據：一組向量、與每個向量對應的label；以及訓練輪數、學習率
'''
for i in range(iteration):
self._one_iteration(input_vecs, labels, rate)
def _one_iteration(self, input_vecs, labels, rate):
'''
一次迭代，把所有的訓練數據過一遍
'''
# 把輸入和輸出打包在一起，成為樣本的列表[(input_vec, label), ...]
# 而每個訓練樣本是(input_vec, label)
samples = zip(input_vecs, labels)
# 對每個樣本，按照感知器規則更新權重
for (input_vec, label) in samples:
# 計算感知器在當前權重下的輸出
output = self.predict(input_vec)
# 更新權重
self._update_weights(input_vec, output, label, rate)
def _update_weights(self, input_vec, output, label, rate):
'''
按照感知器規則更新權重
'''
# 把input_vec[x1,x2,x3,...]和weights[w1,w2,w3,...]打包在一起
# 變成[(x1,w1),(x2,w2),(x3,w3),...]
# 然后利用感知器規則更新權重
delta = label - output
self.weights = map(
lambda (x, w): w + rate * delta * x,
zip(input_vec, self.weights) )
# 更新bias
self.bias += rate * delta
def f(x):
'''
定義激活函數f
'''
return 1 if x > 0 else 0
def get_training_dataset():
'''
基于and真值表構建訓練數據
'''
# 構建訓練數據
# 輸入向量列表
input_vecs = [[1,1], [0,0], [1,0], [0,1]]
# 期望的輸出列表，注意要與輸入一一對應
# [1,1] -> 1, [0,0] -> 0, [1,0] -> 0, [0,1] -> 0
labels = [1, 0, 0, 0]
return input_vecs, labels
def train_and_perceptron():
'''
使用and真值表訓練感知器
'''
# 創建感知器，輸入參數個數為2（因為and是二元函數），激活函數為f
p = Perceptron(2, f)
# 訓練，迭代10輪, 學習速率為0.1
input_vecs, labels = get_training_dataset()
p.train(input_vecs, labels, 10, 0.1)
#返回訓練好的感知器
return p
if __name__ == '__main__':
# 訓練and感知器
and_perception = train_and_perceptron()
# 打印訓練獲得的權重
print and_perception
# 測試
print '1 and 1 = %d' % and_perception.predict([1, 1])
print '0 and 0 = %d' % and_perception.predict([0, 0])
print '1 and 0 = %d' % and_perception.predict([1, 0])
print '0 and 1 = %d' % and_perception.predict([0, 1])
參考資料：
https://www.zybuluo.com/hanbingtao/note/433855
推薦閱讀 歷史技術博文鏈接匯總
也許可以找到你想要的
我是 不會停的蝸牛 Alice
85后全職主婦
喜歡人工智能，行動派
創造力，思考力，學習力提升修煉進行中
歡迎您的喜歡，關注和評論！
