可变学习速度的VLBP

最新推荐文章于 2021-02-01 14:41:38 发布

原创最新推荐文章于 2021-02-01 14:41:38 发布 · 983 阅读

4 ·

CC 4.0 BY-SA版权

神经网络专栏收录该内容

5 篇文章

订阅专栏

本文探讨了使用Python实现可变学习率的VLBP算法时遇到的问题。在学习率较小的情况下表现尚可，但当学习率增大到一定值后，算法的性能急剧下降。目前原因尚未明确，作者将问题记录下来以供后续研究。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

python代码实现效果很不好，当学习率不太大的时候还行，一旦大于一个值就完全崩了，暂时不知道什么问题，先贴在这

#coding=utf-8
import numpy as np
from math import e
import matplotlib.pyplot as plt
import scipy.io as sio

def logsig(x):
    return 1/(1+e**(-x))

if __name__=="__main__":

    er = 1.02
    lr = 2.2  # 学习率
    mc = 0.1  # 动量因子
    dec = 0.8# 乘上学习率的因子ρ
    inc=1.02#因子η

    W1=np.array([[2.0],[3.0]])
    b1=np.array([[-1.],[1.]])
    W2=np.array([[1.,1.]])
    b2=np.array([[-1.]])
    P=np.array([np.arange(-2,2,0.1)])
    #P=np.array([[1]])
    a0=P
    T=logsig(np.dot(W2,logsig(np.dot(W1,P)+b1))+b2)

    x = 1.0
    y = -2.0
    ep=100
    W1[0,0]=x
    W2[0,0]=y
    n1 = np.dot(W1, P)+b1
    a1 = logsig(n1)
    n2 = np.dot(W2, a1)+b2
    a2 = logsig(n2)



    xx=np.zeros([1,ep+1])
    yy=np.zeros([1,ep+1])
    ee = np.zeros([1, ep + 1])
    E=T-a2

    xx[0,0]=x
    yy[0,0]=y
    SSE=np.sum(E*E)
    ee[0,0]=SSE
    v1=np.zeros(W1.shape)
    v2=np.zeros(W2.shape)
    s2 = -2 * E * (1 - a2) * a2
    s1 = np.dot(W2.T, s2) * a1 * (1 - a1)
    MC=mc

    for i in range(1,ep+1):


        dW2 = np.dot(s2, a1.T)
        dW1 = np.dot(s1, a0.T)
        v1 = mc * v1 - lr * dW1
        v2 = mc * v2 - lr * dW2
        new_W1 = W1
        new_W2 = W2
        MC=mc

        newx = W1[0,0]+v1[0,0]
        new_W1[0,0] = newx

        newy = W2[0, 0] + v2[0, 0]
        new_W2[0, 0] = newy

        new_a1=logsig(np.dot(new_W1,a0)+b1)
        new_a2=logsig(np.dot(new_W2,new_a1)+b2)

        new_E=T-new_a2
        new_SSE=np.sum(new_E*new_E)

        #如果军方误差（在整个训练集上）权值在更新后增加了，且超过了某个设置的百分数（3%~5%）
        #则权值更新被取消，学习速度被乘上一个因子ρ(0<ρ<1),并且动量洗漱被设置为0
        if(new_SSE>SSE*er):
            lr=lr*dec
            MC=0
        #如果平方误差在权值更新后减少，则权值更新被接受，而且学习速度将被乘上一个因子η(η>1).
        # 如果mc被设置为0，则恢复到以前的值
        else:
            if (new_SSE < SSE):
                lr = lr * inc
                # 如果平方误差的增长小于ξ，则权值更新被接受，但学习速度保持不变。如果mc过去被设置为0，
                # 则恢复到以前的值

            W1 = new_W1
            W2 = new_W2
            a1 = new_a1
            a2 = new_a2
            x = newx
            y = newy
            E = new_E
            SSE = new_SSE
            s2 = -2 * E * (1 - a2) * a2
            s1 = np.dot(W2.T, s2) * a1 * (1 - a1)
        ee[0, i] = SSE
        xx[0, i] = x
        yy[0, i] = y

    data=sio.loadmat('nndbp1')
    p1=plt.subplot(121)
    p2=plt.subplot(122)
    x2=data['x2']
    y2=data['y2']
    E2=data['E2']
    x2,y2=np.meshgrid(x2,y2)
    p1.contour(x2,y2,E2)
    #p1.plot(xx[0,1:80],yy[0,1:80])
    p1.plot(xx[0,1:80],yy[0,1:80])
    p2.plot(ee[0,1:50])
    plt.show()