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

Posted 2022-04-16 ITAK

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

$$f(x)=\\begincases1, & \\textif $w*x+b\\gt 0$ \\\\ 0, & \\text else \\\\ \\endcases$$

详细介绍：

下面是一个简单的感知器：

那么感知器是由如下几部分组成：

输入 x

用户的输入(训练的数据集)

输入权值 w

对于每一个输入，会有一个权值与之对应，用来控制结果

偏置项 b

就是上图中的 $w_0$

激活函数

就是对应的 $f()$,比如说求一个

and

运算的激活函数： $$f(x)=\\begincases1, & \\textif $x\\gt 0$ \\\\ 0, & \\text else \\\\ \\endcases$$

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