机器学习之单层感知机前向传播和反向传播

前言
现如今机器学习非常火爆，闲来无事，看了下机器学习的相关书籍。最近对前向传播和反向传播做了一些总结归纳。当然这只是根据我个人的理解而定，如有出入，也请大家帮忙指正。

简单来说
对于单层感知机来说前项传播就是 y = wx+b 。可用如下图表示

反向传播就是 通过真实值和预测值的产生的误差返回去调整w和b的过程
用流程图来表示，如下

说到这里，正向传播就是y=wx+b，如此简单。
那么这个反向传播的这个loss如果得到呢？
在数据训练前我们会有 训练数据，我们叫输入值(就是x)，初始值(w,b),预测标签(label)
那么用y = wx+b 就可以得到 预测值y。那么loss = label-y。

说完了前向传播，我们再来说说这个反向传播。
现在我们已经拿到了loss了，如何将w,b更新上去呢？
我们将初始的w,b 定义成w0,b0 ,现在我们要得到的是w1,b1 。
按照t度下降的规则，我们可以得到,其中rate为步长
W1 = W0-rate*( Loss对w求导 )
B1 = B0 - rate*(Loss对B求导)
其中Loss对w求导的细则可以自己试着推导下(其中就是运用了复合函数的求导法则)，其推到结果如下
W1 = W0-rate * Loss * W0
B1 = B0-rate * Loss

那么我们的正向传播和反向传播算法就可以结合起来反复计算出W和B的最优解了

我们可以以最简单的与或运算来写代码实例

class neuron_tool(object):
    def __init__(self,init_weights,init_bais,active_func,rate):
        self.weights = init_weights
        self.bais = init_bais
        self.rate = rate
        self.func = active_func

    #输入input表示 [0,0]
    def forward(self,input):
        return input * self.weights  + self.bais

    #预测在外层包裹激活函数，wx
    def predict(self,input):
        return self.func( self.forward(input))

    #训练数据
    def train(self,dataset,times):
        inputs,labels = dataset
        for i in range(times):
            for input,label in zip(inputs,labels):
                output = self.predict(input)
                self.back_propagation(output,label)

    #根据w0,output,label,输入值 更新权重w1
    def back_propagation(self,output,label):
        loss = output - label
        self.weights = self.weights -  self.weights* loss  * self.rate
        self.bais = loss * self.rate




def active_fun(x):
    return 1 if x>=0.5 else 0

class dataset(object):

    def and_dataset(self):
        inputs = np.mat([[1, 1], [0, 0], [1, 0], [0, 1]])
        lables = [1, 0, 0, 0]
        return inputs,lables

    def or_dataset(self):
        inputs = np.mat([[1, 1], [0, 0], [1, 0], [0, 1]])
        lables = [1, 0, 1, 1]
        return inputs,lables

if __name__ == '__main__':
    #初始化权重
    weight = np.mat(np.ones((2, 1)))
    #初始化偏差
    bais = 0
    #初始化权重、偏差、激活函数、下降速度
    and_net = neuron_tool(weight,bais,active_fun,0.1)
    times = 1000
    and_net.train(dataset=dataset().and_dataset(),times=times)
    print('and [0,0] predict result is', and_net.predict([0,0]) )
    print('and [0,1] predict result is', and_net.predict([0,1]) )
    print('and [1,0] predict result is', and_net.predict([1,0]) )
    print('and [1,1] predict result is', and_net.predict([1,1]) )

    print('--------------------------------------------------')

    or_net = neuron_tool(weight,bais,active_fun,0.1)
    times = 1000
    or_net.train(dataset=dataset().or_dataset(),times=times)
    print('or [0,0] predict result is', or_net.predict([0,0]) )
    print('or [0,1] predict result is', or_net.predict([0,1]) )
    print('or [1,0] predict result is', or_net.predict([1,0]) )
    print('or [1,1] predict result is', or_net.predict([1,1]) )