单层感知器python_感知器（神经网络模型）python（一）

摘自百度百科

感知器(Perceptron)，是神经网络中的一个概念，在1950s由Frank Rosenblatt第一次引入。

单层感知器(Single Layer Perceptron)是最简单的神经网络。它包含输入层和输出层，而输入层和输出层是直接相连的。

与最早提出的MP模型不同，神经元突触权值可变，因此可以通过一定规则进行学习。可以快速、可靠地解决线性可分的问题。

感知器是生物神经细胞的简单抽象，如右图.神经细胞结构大致可分为：树突、突触、

神经细胞示意图

细胞体及轴突。单个神经细胞可被视为一种只有两种状态的机器——激动时为‘是’，而未激动时为‘否’。

单层感知器由一个线性组合器和一个二值阈值元件组成。

输入向量为x，权重向量为w，w0为偏执。

简单的理解可以解释为：将x0,x1······xn的变量输入，经过组合器的整合，输出1或者-1，也就是通过组合器对输入变量判断其正确与否。

而这个判断的依据就是权重w0,w1······wn。

因为线性组合器是实现加法的方式，根据向量的运算法则，所以以上公式的输入值可以理解为：

w0+x1w1+······+xnwn

扩展到多个数据，如下图：

其中偏振因子b，一般会用w0表示，这时会加入一个偏振输入变量x0,不过x0恒等于1,也就是以上所描述的公式。

感知机定义为：

二分类线性分类模型，其输入为实例的特征向量，输出为实例的类别，取+1或者-1值。

简单来说，就是在平面坐标轴画一条直线，把点分为两类。

一个感知机应该有如下几个部分：1、输入权值 2、偏置项 3、激活函数 4、输出

下面用简单例题更好地理解感知机：

用感知器实现and函数：我们设计一个感知器，让它来实现and运算。程序员都知道，and是一个二元函数(带有两个参数x1和x2)，下面是他们的真值表：

为了计算方便，我们用0表示false，用1表示true。这没什么难理解的，对于C语言程序员来说，这是天经地义的。

我们令

；而激活函数

就是阶跃函数，这时，感知器就相当于and函数。

输入上面真值表的第一行，即

根据阶跃函数公式：

，计算输出：

可以验证出表格中的数据

下面我们用感知器实现and函数

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

接下来，我们利用这个感知器类去实现and函数:

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])输出结果

是不是和表格一致呢~