机器学习之感知器——and运算的实现

版权声明：编写不易，转载请注明出处，谢谢。 https://blog.csdn.net/qingshui23/article/details/78906393

概要：感知器是人工神经网络中的一种典型结构，它可以被视为一种最简单形式的前馈式人工神经网络，是一种二元线性分类器，把矩阵上的输入（实数值向量）映射到输出值 $f(x)$上（一个二元的值）。

$$f(x)=\begin{cases}1, & \text{if $w*x+b\gt 0$} \\ 0, & \text else \\ \end{cases}$$
详细介绍：下面是一个简单的感知器：

那么感知器是由如下几部分组成：
输入 x 用户的输入(训练的数据集)
输入权值 w 对于每一个输入，会有一个权值与之对应，用来控制结果
偏置项 b 就是上图中的 $w_0$
激活函数 就是对应的 $f()$,比如说求一个 and 运算的激活函数： $$f(x)=\begin{cases}1, & \text{if $x\gt 0$} \\ 0, & \text else \\ \end{cases}$$
输出 y 感知器的输出由如下公式推出 $$y = f(w*x)+b$$
语言： Python3
参考： @hanbingtao

用感知器实现 and 函数
代码：

class Perceptron(object):
    def __init__(self, num, activator):
        '''
           初始化感知器，设置输入参数的个数，以及激活函数。
           激活函数的类型为double -> double
       '''
        self.activator = activator
        #权重向量初始化为 0
        self.weights = [0.0 for _ in range(num)]
        self.bias = 0

    def __str__(self):
        '''
             打印学习到的权重、偏置项bias
        '''
        return 'weight: %s\n  bias: %f\n' % (self.weights, self.bias)

    def predict(self, input_vec):
        '''
            输入向量，输出感知器的计算结果
        '''
        # 利用map函数计算[x1*w1, x2*w2, x3*w3], 然后转化为列表
        # 最后利用 sum 求和

        return self.activator(
            sum(
                list(
                    map(
                        lambda x, y: x*y,
                        self.weights, input_vec
                    )
                )
            )
            + self.bias
        )
        #return self.activator(sum(tmp))

    def train(self, input_vecs, labels, iterations, rate):
        '''
           输入训练数据：一组向量、与每个向量对应的label；以及训练轮数、学习率
        '''
        for _ in range(iterations):
            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 = label - output
        self.weights = list(
            map(
                lambda x, y: x + y*rate*delta,
                self.weights, input_vec
            )
        )
        self.bias += rate * delta
''''
    以下代码为实现 and 函数
'''

def activate(x):
    if x > 0:
        return 1
    return 0

def get_train_dataset():
    #构建训练数据
    input_vecs = [ [0, 0], [0, 1], [1, 0], [1, 1] ]  #训练数据
    labels = [0, 0, 0, 1] #输出列表
    return  input_vecs, labels

def train_data():
    # 创建一个感知器
    perceptron = Perceptron(2, activate)

    input_vecs, labels = get_train_dataset()
    # 训练数据，然后迭代 20 轮，学习速率为 0.1
    perceptron.train(input_vecs, labels, 20, 0.1)
    return  perceptron

result = train_data()
print(result)

#测试真值表
print('1 and 1 = %d' % result.predict([1, 1]))
print('0 and 0 = %d' % result.predict([0, 0]))
print('1 and 0 = %d' % result.predict([1, 0]))
print('0 and 1 = %d' % result.predict([0, 1]))