写在前面:感知器有一个问题,当面对的数据集不是线性可分的时候,『感知器规则』可能无法收敛,这意味着我们永远也无法完成一个感知器的训练。为了解决这个问题,我们使用一个可导的线性函数来替代感知器的阶跃函数,这种感知器就叫做线性单元。线性单元在面对线性不可分的数据集时,会收敛到一个最佳的近似值。
此篇文章涉及到的主要知识点是线性单元模型的实现,与感知器对比,只有激活函数的不同。本段代码中的线性函数是f(x)=x,大家可以自行更改激活函数,比如更改为sigmod函数。
代码如下(python3)
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
from __future__ import print_function
from functools import reduce
class VectorOp(object):
"""
实现向量计算操作
"""
def dot(x, y):
"""
计算两个向量x和y的内积
"""
# 首先把x[x1,x2,x3...]和y[y1,y2,y3,...]按元素相乘
# 变成[x1*y1, x2*y2, x3*y3]
# 然后利用reduce求和
return reduce(lambda a, b: a + b, VectorOp.element_multiply(x, y), 0.0)
@staticmethod
def element_multiply(x, y):
"""
将两个向量x和y按元素相乘
"""
# 首先把x[x1,x2,x3...]和y[y1,y2,y3,...]打包在一起
# 变成[(x1,y1),(x2,y2),(x3,y3),...]
# 然后利用map函数计算[x1*y1, x2*y2, x3*y3]
return list(map(lambda x_y: x_y[0] * x_y[1], zip(x, y)))
@staticmethod
def element_add(x, y):
"""
将两个向量x和y按元素相加
"""
# 首先把x[x1,x2,x3...]和y[y1,y2,y3,...]打包在一起
# 变成[(x1,y1),(x2,y2),(x3,y3),...]
# 然后利用map函数计算[x1+y1, x2+y2, x3+y3]
return list(map(lambda x_y: x_y[0] + x_y[1], zip(x, y)))
@staticmethod
def scala_multiply(v, s):
"""
将向量v中的每个元素和标量s相乘
"""
return map(lambda e: e * s, v)
class Perceptron(object):
def __init__(self, input_num, activator):
"""
初始化感知器,设置输入参数的个数,以及激活函数。
激活函数的类型为double -> double
"""
self.activator = activator
# 权重向量初始化为0
self.weights = [0.0] * 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,...]的内积
# 然后加上bias
return self.activator(
VectorOp.dot(input_vec, self.weights) + 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):
"""
按照感知器规则更新权重
"""
# 首先计算本次更新的delta
# 然后把input_vec[x1,x2,x3,...]向量中的每个值乘上delta,得到每个权重更新
# 最后再把权重更新按元素加到原先的weights[w1,w2,w3,...]上
delta = label - output
self.weights = VectorOp.element_add(
self.weights, VectorOp.scala_multiply(input_vec, rate * delta))
# 更新bias
self.bias += rate * delta
#定义激活函数f
f = lambda x: x
class LinearUnit(Perceptron):
def __init__(self, input_num):
'''初始化线性单元,设置输入参数的个数'''
Perceptron.__init__(self, input_num, f)
def get_training_dataset():
'''
捏造5个人的收入数据
'''
# 构建训练数据
# 输入向量列表,每一项是工作年限
input_vecs = [[5], [3], [8], [1.4], [10.1]]
# 期望的输出列表,月薪,注意要与输入一一对应
labels = [5500, 2300, 7600, 1800, 11400]
return input_vecs, labels
def train_linear_unit():
'''
使用数据训练线性单元
'''
# 创建感知器,输入参数的特征数为1(工作年限)
lu = LinearUnit(1)
# 训练,迭代10轮, 学习速率为0.01
input_vecs, labels = get_training_dataset()
lu.train(input_vecs, labels, 10, 0.01)
#返回训练好的线性单元
return lu
def plot(linear_unit):
import matplotlib.pyplot as plt
input_vecs, labels = get_training_dataset()
fig = plt.figure()
ax = fig.add_subplot(111)
ax.scatter(map(lambda x: x[0], input_vecs), labels)
weights = linear_unit.weights
bias = linear_unit.bias
x = range(0,12,1)
y = map(lambda x:weights[0] * x + bias, x)
ax.plot(x, y)
plt.show()
if __name__ == '__main__':
'''训练线性单元'''
linear_unit = train_linear_unit()
# 打印训练获得的权重
print (linear_unit)
# 测试
print ('Work 3.4 years, monthly salary = %.2f' % linear_unit.predict([3.4]))
print ('Work 15 years, monthly salary = %.2f' % linear_unit.predict([15]))
print ('Work 1.5 years, monthly salary = %.2f' % linear_unit.predict([1.5]))
print ('Work 6.3 years, monthly salary = %.2f' % linear_unit.predict([6.3]))
plot(linear_unit)