单层感知器实验：

仅两个权值w：经过20+次迭代就可以出结果

步骤：

1. 初始化所有有用的值包括学习率，偏置，函数中的常数b 权值
2. 根据求和函数和阶跃函数得到第一次通过w初始值预测的函数y，十分不准确
3. 将这些值进行训练，得到梯度update

由于之前推导出w = w + (t – y)*x ，由于有两个权值，所以写出两个权值w对应的下一个w。

1. Train放入迭代中，进行多次迭代，训练出最终的y

Import random

import numpy as np

xh_number = 50

class my_Per:

    def __init__(self, lr=0.1):

        self.lr = lr

        self.errors = []  # 偏置量初始化设空

        self.b = random.random()  # b是随机产生的点，即实际的值

        self.w = [1, 2]  # 两个权值

    def train(self, Px, t):

        update = self.lr * (t - self.predict(Px))  # 每次训练的梯度

        self.b += update

        self.w[0] += update * Px[0]  # 一种方法是权值w个数较少时，这是权值的时候直接乘以Px

        self.w[1] += update * Px[1]

        # 可以先把梯度设置完，然后在带到主函数中去训练，也可以直接在train函数中循环w 然后输出，让他参与之后

        # 的函数调用

        '''self.b += update

        for i in range(500):

            self.w[i] += update * Px[i]

        return self.w'''

    def predict(self, Px):  # 激活函数函数

        number = self.w[0] * Px[0] + self.w[1] * Px[1] + self.b  # 求和

        return np.where(number >= 0, 1, 0)  # 激活函数 大于0的时候返回1，小于0返回0

    # 先通过求和函数计算出要求的函数 然后根据原始的权值进行计算，计算出第一次训练所得函数

    # 然后进入下面main函数的迭代中，持续训练。最终得到y的值

def main():

    P = [[-0.5, -0.5], [-0.5, 0.5], [0.3, -0.5], [0, 1]]   #

    T = [1.0, 1.0, 0, 0]

    my_per = my_Per(0.1)

    for i in range(xh_number):

        for j in range(4):

            Px = P[j]  # 将P数组中的值依次赋到Px中

            t = T[j]   # 实际函数。

            my_per.train(Px, t)  # 将值带入到train中训练

        print(-my_per.w[0] / my_per.w[1])

        print(-my_per.b / my_per.w[1])

    x = np.arange(-1, 1)

    y = -my_per.w[0] / my_per.w[1] * x - my_per.b / my_per.w[1]

    print(y)
        # 的函数调用

        '''self.b += update
        for i in range(500):
            self.w[i] += update * Px[i]
        return self.w'''

    def predict(self, Px):  # 激活函数函数
        number = self.w[0] * Px[0] + self.w[1] * Px[1] + self.b  # 求和
        return np.where(number >= 0, 1, 0)  # 激活函数 大于0的时候返回1，小于0返回0
    # 先通过求和函数计算出要求的函数 然后根据原始的权值进行计算，计算出第一次训练所得函数
    # 然后进入下面main函数的迭代中，持续训练。最终得到y的值


def main():
    P = [[-0.5, -0.5], [-0.5, 0.5], [0.3, -0.5], [0, 1]]   #
    T = [1.0, 1.0, 0, 0]
    my_per = my_Per(0.1)

    for i in range(xh_number):

        for j in range(4):
            Px = P[j]  # 将P数组中的值依次赋到Px中
            t = T[j]   # 实际函数。
            my_per.train(Px, t)  # 将值带入到train中训练
        print(-my_per.w[0] / my_per.w[1])
        print(-my_per.b / my_per.w[1])
    x = np.arange(-1, 1)
    y = -my_per.w[0] / my_per.w[1] * x - my_per.b / my_per.w[1]
    print(y)

W权值数量为3时：迭代所需次数50+