tlm1.c

nnToolKit 神经网络工具包是基于 MATLAB 神经网络工具箱自行开发的一组神经网络算法函数库

    /*
     * 
     * % PRESENTATION PHASE
     * a1 = simuff(p,w1,b1,f1);
     */
    mlfAssign(
      &a1,
      mlfNSimuff(
        1,
        NULL,
        NULL,
        mclVa(p, "p"),
        mclVa(w1, "w1"),
        mclVa(*b1, "b1"),
        mclVa(f1, "f1"),
        NULL,
        NULL,
        NULL,
        NULL,
        NULL,
        NULL));
    /*
     * e = t-a1;
     */
    mlfAssign(&e, mclMinus(mclVa(t, "t"), mclVv(a1, "a1")));
    /*
     * SSE = sumsqr(e);
     */
    mlfAssign(&SSE, mlfSumsqr(mclVv(e, "e")));
    /*
     * 
     * % TRAINING RECORD
     * tr = zeros(1,me+1);
     */
    mlfAssign(
      tr, mlfZeros(_mxarray11_, mclPlus(mclVv(me, "me"), _mxarray11_), NULL));
    /*
     * tr(1) = SSE;
     */
    mclIntArrayAssign1(tr, mclVv(SSE, "SSE"), 1);
    /*
     * 
     * % PLOTTING FLAG
     * plottype = (r==1) & (s1==1);
     */
    mlfAssign(
      &plottype,
      mclAnd(
        mclEq(mclVv(r, "r"), _mxarray11_),
        mclEq(mclVv(s1, "s1"), _mxarray11_)));
    /*
     * 
     * % PLOTTING
     * newplot;
     */
    mclAssignAns(&ans, mlfNNewplot(0, NULL));
    /*
     * message = sprintf('TRAINLM: %%g/%g epochs, mu = %%g, SSE = %%g.\n',me);
     */
    mlfAssign(&message, mlfSprintf(NULL, _mxarray12_, mclVv(me, "me"), NULL));
    /*
     * fprintf(message,0,mu_init,SSE)
     */
    mclPrintAns(
      &ans,
      mlfNFprintf(
        0,
        mclVv(message, "message"),
        _mxarray14_,
        mclVv(mu_init, "mu_init"),
        mclVv(SSE, "SSE"),
        NULL));
    /*
     * if plottype
     */
    if (mlfTobool(mclVv(plottype, "plottype"))) {
        /*
         * h = plotfa(p,t,p,a1);
         */
        mlfAssign(
          &h,
          mlfNPlotfa(
            1, mclVa(p, "p"), mclVa(t, "t"), mclVa(p, "p"), mclVv(a1, "a1")));
    /*
     * else
     */
    } else {
        /*
         * h = ploterr(tr(1),eg);
         */
        mlfAssign(
          &h,
          mlfNPloterr(
            1, mclIntArrayRef1(mclVv(*tr, "tr"), 1), mclVv(eg, "eg"), NULL));
    /*
     * end
     */
    }
    /*
     * 
     * mu = mu_init;
     */
    mlfAssign(&mu, mclVv(mu_init, "mu_init"));
    /*
     * for i=1:me
     */
    {
        int v_ = mclForIntStart(1);
        int e_ = mclForIntEnd(mclVv(me, "me"));
        if (v_ > e_) {
            mlfAssign(i, _mxarray6_);
        } else {
            /*
             * 
             * % CHECK PHASE
             * if SSE < eg, i=i-1; break, end
             * 
             * % FIND JACOBIAN
             * d1 = feval(df1,a1);
             * ext_d1 = -nncpyd(d1);
             * j1 = learnlm(ext_p,ext_d1);
             * j = [j1, ext_d1'];
             * 
             * % CHECK MAGNITUDE OF GRADIENT
             * je = j' * e(:);
             * grad = norm(je);
             * if grad < grad_min, i=i-1; break, end
             * 
             * % INNER LOOP, INCREASE MU UNTIL THE ERRORS ARE REDUCED
             * jj = j'*j;
             * 
             * while (mu <= mu_max)
             * dx = -(jj+ii*mu) \ je;
             * dw1(:) = dx(w1_ind); db1 = dx(b1_ind);
             * new_w1 = w1 + dw1; new_b1 = b1 + db1;
             * 
             * % EVALUATE NEW NETWORK
             * a1 = simuff(p,new_w1,new_b1,f1);
             * new_e = t-a1;
             * new_SSE = sumsqr(new_e);
             * 
             * if (new_SSE < SSE), break, end
             * mu = mu * mu_inc;
             * end
             * if (mu > mu_max), i = i-1; break, end
             * mu = mu * mu_dec;
             * 
             * % UPDATE NETWORK
             * w1 = new_w1; b1 = new_b1;
             * e = new_e; SSE = new_SSE;
             * 
             * % TRAINING RECORD
             * tr(i+1) = SSE;
             * 
             * % PLOTTING
             * if rem(i,df) == 0
             * fprintf(message,i,mu,SSE)
             * if plottype
             * delete(h); h = plot(p,a1,'m'); drawnow;
             * else
             * h = ploterr(tr(1:(i+1)),eg,h);
             * end
             * end
             * end
             */
            for (; ; ) {
                mlfAssign(i, mlfScalar(v_));
                if (mclLtBool(mclVv(SSE, "SSE"), mclVv(eg, "eg"))) {
                    mlfAssign(i, mclMinus(mclVv(*i, "i"), _mxarray11_));
                    break;
                }
                mlfAssign(
                  &d1,
                  mlfFeval(
                    mclValueVarargout(),
                    mclVv(df1, "df1"),
                    mclVv(a1, "a1"),
                    NULL));
                mlfAssign(&ext_d1, mclUminus(mlfNncpyd(mclVv(d1, "d1"))));
                mlfAssign(
                  &j1,
                  mlfLearnlm(mclVv(ext_p, "ext_p"), mclVv(ext_d1, "ext_d1")));
                mlfAssign(
                  &j,
                  mlfHorzcat(
                    mclVv(j1, "j1"),
                    mlfCtranspose(mclVv(ext_d1, "ext_d1")),
                    NULL));
                mlfAssign(
                  &je,
                  mlf_times_transpose(
                    mclVv(j, "j"),
                    mclArrayRef1(mclVv(e, "e"), mlfCreateColonIndex()),
                    _mxarray15_));
                mlfAssign(&grad, mlfNorm(mclVv(je, "je"), NULL));
                if (mclLtBool(
                      mclVv(grad, "grad"), mclVv(grad_min, "grad_min"))) {
                    mlfAssign(i, mclMinus(mclVv(*i, "i"), _mxarray11_));
                    break;
                }
                mlfAssign(
                  &jj,
                  mlf_times_transpose(
                    mclVv(j, "j"), mclVv(j, "j"), _mxarray15_));
                while (mclLeBool(mclVv(mu, "mu"), mclVv(mu_max, "mu_max"))) {
                    mlfAssign(
                      &dx,
                      mlfMldivide(
                        mclUminus(
                          mclPlus(
                            mclVv(jj, "jj"),
                            mclMtimes(mclVv(ii, "ii"), mclVv(mu, "mu")))),
                        mclVv(je, "je")));
                    mclArrayAssign1(
                      &dw1,
                      mclArrayRef1(mclVv(dx, "dx"), mclVv(w1_ind, "w1_ind")),
                      mlfCreateColonIndex());
                    mlfAssign(
                      &db1,
                      mclArrayRef1(mclVv(dx, "dx"), mclVv(b1_ind, "b1_ind")));
                    mlfAssign(
                      &new_w1, mclPlus(mclVa(w1, "w1"), mclVv(dw1, "dw1")));
                    mlfAssign(
                      &new_b1, mclPlus(mclVa(*b1, "b1"), mclVv(db1, "db1")));
                    mlfAssign(
                      &a1,
                      mlfNSimuff(
                        1,
                        NULL,
                        NULL,
                        mclVa(p, "p"),
                        mclVv(new_w1, "new_w1"),
                        mclVv(new_b1, "new_b1"),
                        mclVa(f1, "f1"),
                        NULL,
                        NULL,
                        NULL,
                        NULL,
                        NULL,
                        NULL));
                    mlfAssign(&new_e, mclMinus(mclVa(t, "t"), mclVv(a1, "a1")));
                    mlfAssign(&new_SSE, mlfSumsqr(mclVv(new_e, "new_e")));
                    if (mclLtBool(
                          mclVv(new_SSE, "new_SSE"), mclVv(SSE, "SSE"))) {
                        break;
                    }
                    mlfAssign(
                      &mu, mclMtimes(mclVv(mu, "mu"), mclVv(mu_inc, "mu_inc")));
                }
                if (mclGtBool(mclVv(mu, "mu"), mclVv(mu_max, "mu_max"))) {
                    mlfAssign(i, mclMinus(mclVv(*i, "i"), _mxarray11_));
                    break;
                }
                mlfAssign(
                  &mu, mclMtimes(mclVv(mu, "mu"), mclVv(mu_dec, "mu_dec")));
                mlfAssign(&w1, mclVv(new_w1, "new_w1"));
                mlfAssign(b1, mclVv(new_b1, "new_b1"));
                mlfAssign(&e, mclVv(new_e, "new_e"));
                mlfAssign(&SSE, mclVv(new_SSE, "new_SSE"));
                mclArrayAssign1(
                  tr, mclVv(SSE, "SSE"), mclPlus(mclVv(*i, "i"), _mxarray11_));
                if (mclEqBool(
                      mlfRem(mclVv(*i, "i"), mclVv(df, "df")), _mxarray14_)) {
                    mclPrintAns(
                      &ans,
                      mlfNFprintf(
                        0,
                        mclVv(message, "message"),
                        mclVv(*i, "i"),
                        mclVv(mu, "mu"),
                        mclVv(SSE, "SSE"),
                        NULL));
                    if (mlfTobool(mclVv(plottype, "plottype"))) {
                        mlfDelete(mclVv(h, "h"), NULL);
                        mlfAssign(
                          &h,
                          mlfNPlot(
                            1,
                            mclVa(p, "p"), mclVv(a1, "a1"), _mxarray16_, NULL));
                        mlfDrawnow(NULL);
                    } else {
                        mlfAssign(
                          &h,
                          mlfNPloterr(
                            1,
                            mclArrayRef1(
                              mclVv(*tr, "tr"),
                              mlfColon(
                                _mxarray11_,
                                mclPlus(mclVv(*i, "i"), _mxarray11_),
                                NULL)),
                            mclVv(eg, "eg"),
                            mclVv(h, "h")));
                    }
                }
                if (v_ == e_) {
                    break;
                }
                ++v_;
            }
        }
    }
    /*
     * 
     * % TRAINING RECORD
     * tr = tr(1:(i+1));
     */
    mlfAssign(
      tr,
      mclArrayRef1(
        mclVv(*tr, "tr"),
        mlfColon(_mxarray11_, mclPlus(mclVv(*i, "i"), _mxarray11_), NULL)));
    /*
     * 
     * % PLOTTING
     * if rem(i,df) ~= 0
     */
    if (mclNeBool(mlfRem(mclVv(*i, "i"), mclVv(df, "df")), _mxarray14_)) {
        /*
         * fprintf(message,i,mu,SSE)
         */
        mclPrintAns(
          &ans,
          mlfNFprintf(
            0,
            mclVv(message, "message"),
            mclVv(*i, "i"),
            mclVv(mu, "mu"),
            mclVv(SSE, "SSE"),
            NULL));
        /*
         * if plottype
         */
        if (mlfTobool(mclVv(plottype, "plottype"))) {
            /*
             * delete(h);
             */
            mlfDelete(mclVv(h, "h"), NULL);
            /*
             * plot(p,a1,'m');
             */
            mclAssignAns(
              &ans,
              mlfNPlot(0, mclVa(p, "p"), mclVv(a1, "a1"), _mxarray16_, NULL));
            /*
             * drawnow;
             */
            mlfDrawnow(NULL);
        /*
         * else
         */
        } else {
            /*
             * ploterr(tr,eg,h);
             */
            mclAssignAns(
              &ans,
              mlfNPloterr(0, mclVv(*tr, "tr"), mclVv(eg, "eg"), mclVv(h, "h")));
        /*
         * end
         */
        }
    /*
     * end
     */
    }
    /*
     * 
     * % WARNINGS
     * if SSE > eg
     */
    if (mclGtBool(mclVv(SSE, "SSE"), mclVv(eg, "eg"))) {
        /*
         * disp(' ')
         */
        mlfDisp(_mxarray18_);
        /*
         * if (mu > mu_max)
         */
        if (mclGtBool(mclVv(mu, "mu"), mclVv(mu_max, "mu_max"))) {
            /*
             * disp('TRAINLM: Error gradient is too small to continue learning.')
             */
            mlfDisp(_mxarray20_);
        /*
         * else
         */
        } else {
            /*
             * disp('TRAINLM: Network error did not reach the error goal.')
             */
            mlfDisp(_mxarray22_);
        /*
         * end
         */
        }
        /*
         * disp('  Further training may be necessary, or try different')
         */
        mlfDisp(_mxarray24_);
        /*
         * disp('  initial weights and biases and/or more hidden layers.')
         */
        mlfDisp(_mxarray26_);
        /*
         * disp(' ')
         */
        mlfDisp(_mxarray18_);
    /*
     * end
     */
    }
    mclValidateOutput(w1, 1, nargout_, "w1", "tlm1");
    mclValidateOutput(*b1, 2, nargout_, "b1", "tlm1");
    mclValidateOutput(*i, 3, nargout_, "i", "tlm1");
    mclValidateOutput(*tr, 4, nargout_, "tr", "tlm1");
    mxDestroyArray(ans);
    mxDestroyArray(df);
    mxDestroyArray(me);
    mxDestroyArray(eg);
    mxDestroyArray(grad_min);
    mxDestroyArray(mu_init);
    mxDestroyArray(mu_inc);
    mxDestroyArray(mu_dec);
    mxDestroyArray(mu_max);
    mxDestroyArray(df1);
    mxDestroyArray(s1);
    mxDestroyArray(r);
    mxDestroyArray(w1_ind);
    mxDestroyArray(b1_ind);
    mxDestroyArray(ii);
    mxDestroyArray(dw1);
    mxDestroyArray(db1);
    mxDestroyArray(ext_p);
    mxDestroyArray(a1);
    mxDestroyArray(e);
    mxDestroyArray(SSE);
    mxDestroyArray(plottype);
    mxDestroyArray(message);
    mxDestroyArray(h);
    mxDestroyArray(mu);
    mxDestroyArray(d1);
    mxDestroyArray(ext_d1);
    mxDestroyArray(j1);
    mxDestroyArray(j);
    mxDestroyArray(je);
    mxDestroyArray(grad);
    mxDestroyArray(jj);
    mxDestroyArray(dx);
    mxDestroyArray(new_w1);
    mxDestroyArray(new_b1);
    mxDestroyArray(new_e);
    mxDestroyArray(new_SSE);
    mxDestroyArray(tp);
    mxDestroyArray(t);
    mxDestroyArray(p);
    mxDestroyArray(f1);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    return w1;
}