trainlm.c

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

     */
    }
    /*
     * if (~isa(mu_inc,'double')) | (~isreal(mu_inc)) | (any(size(mu_inc)) ~= 1) | ...
     */
    {
        mxArray * a_
          = mclInitialize(
              mclNot(mlfIsa(mclVv(mu_inc, "mu_inc"), _mxarray32_)));
        if (mlfTobool(a_)) {
            mlfAssign(&a_, mlfScalar(1));
        } else {
            mlfAssign(
              &a_, mclOr(a_, mclNot(mlfIsreal(mclVv(mu_inc, "mu_inc")))));
        }
        if (mlfTobool(a_)) {
            mlfAssign(&a_, mlfScalar(1));
        } else {
            mlfAssign(
              &a_,
              mclOr(
                a_,
                mclNe(
                  mlfAny(
                    mlfSize(mclValueVarargout(), mclVv(mu_inc, "mu_inc"), NULL),
                    NULL),
                  _mxarray20_)));
        }
        if (mlfTobool(a_)
            || mlfTobool(
                 mclOr(a_, mclLt(mclVv(mu_inc, "mu_inc"), _mxarray20_)))) {
            mxDestroyArray(a_);
            /*
             * (mu_inc < 1)
             * error('Mu_inc is not a real value greater than 1.')
             */
            mlfError(_mxarray46_, NULL);
        } else {
            mxDestroyArray(a_);
        }
    /*
     * end
     */
    }
    /*
     * if (~isa(mu_max,'double')) | (~isreal(mu_max)) | (any(size(mu_max)) ~= 1) | ...
     */
    {
        mxArray * a_
          = mclInitialize(
              mclNot(mlfIsa(mclVv(mu_max, "mu_max"), _mxarray32_)));
        if (mlfTobool(a_)) {
            mlfAssign(&a_, mlfScalar(1));
        } else {
            mlfAssign(
              &a_, mclOr(a_, mclNot(mlfIsreal(mclVv(mu_max, "mu_max")))));
        }
        if (mlfTobool(a_)) {
            mlfAssign(&a_, mlfScalar(1));
        } else {
            mlfAssign(
              &a_,
              mclOr(
                a_,
                mclNe(
                  mlfAny(
                    mlfSize(mclValueVarargout(), mclVv(mu_max, "mu_max"), NULL),
                    NULL),
                  _mxarray20_)));
        }
        if (mlfTobool(a_)
            || mlfTobool(
                 mclOr(a_, mclLe(mclVv(mu_max, "mu_max"), _mxarray19_)))) {
            mxDestroyArray(a_);
            /*
             * (mu_max <= 0)
             * error('Mu_max is not a positive real value.')
             */
            mlfError(_mxarray48_, NULL);
        } else {
            mxDestroyArray(a_);
        }
    /*
     * end
     */
    }
    /*
     * if (mu > mu_max)
     */
    if (mclGtBool(mclVv(mu, "mu"), mclVv(mu_max, "mu_max"))) {
        /*
         * error('Mu is greater than Mu_max.')
         */
        mlfError(_mxarray50_, NULL);
    /*
     * end
     */
    }
    /*
     * if (~isa(show,'double')) | (~isreal(show)) | (any(size(show)) ~= 1) | ...
     */
    {
        mxArray * a_
          = mclInitialize(mclNot(mlfIsa(mclVv(show, "show"), _mxarray32_)));
        if (mlfTobool(a_)) {
            mlfAssign(&a_, mlfScalar(1));
        } else {
            mlfAssign(&a_, mclOr(a_, mclNot(mlfIsreal(mclVv(show, "show")))));
        }
        if (mlfTobool(a_)) {
            mlfAssign(&a_, mlfScalar(1));
        } else {
            mlfAssign(
              &a_,
              mclOr(
                a_,
                mclNe(
                  mlfAny(
                    mlfSize(mclValueVarargout(), mclVv(show, "show"), NULL),
                    NULL),
                  _mxarray20_)));
        }
        if (mlfTobool(a_)) {
        } else {
            /*
             * (isfinite(show) & ((show < 1) | (round(show) ~= show)))
             */
            mxArray * b_ = mclInitialize(mlfIsfinite(mclVv(show, "show")));
            if (mlfTobool(b_)) {
                mxArray * b_0
                  = mclInitialize(mclLt(mclVv(show, "show"), _mxarray20_));
                if (mlfTobool(b_0)) {
                    mlfAssign(&b_0, mlfScalar(1));
                } else {
                    mlfAssign(
                      &b_0,
                      mclOr(
                        b_0,
                        mclNe(
                          mlfRound(mclVv(show, "show")), mclVv(show, "show"))));
                }
                mlfAssign(&b_, mclAnd(b_, b_0));
                mxDestroyArray(b_0);
            } else {
                mlfAssign(&b_, mlfScalar(0));
            }
            {
                mxLogical c_0 = mlfTobool(mclOr(a_, b_));
                mxDestroyArray(b_);
                if (c_0) {
                } else {
                    mxDestroyArray(a_);
                    goto done_;
                }
            }
        }
        mxDestroyArray(a_);
        /*
         * error('Show is not ''NaN'' or a positive integer.')
         */
        mlfError(_mxarray52_, NULL);
        /*
         * end
         */
        done_:;
    }
    /*
     * if (~isa(time,'double')) | (~isreal(time)) | (any(size(time)) ~= 1) | ...
     */
    {
        mxArray * a_
          = mclInitialize(mclNot(mlfIsa(mclVv(time, "time"), _mxarray32_)));
        if (mlfTobool(a_)) {
            mlfAssign(&a_, mlfScalar(1));
        } else {
            mlfAssign(&a_, mclOr(a_, mclNot(mlfIsreal(mclVv(time, "time")))));
        }
        if (mlfTobool(a_)) {
            mlfAssign(&a_, mlfScalar(1));
        } else {
            mlfAssign(
              &a_,
              mclOr(
                a_,
                mclNe(
                  mlfAny(
                    mlfSize(mclValueVarargout(), mclVv(time, "time"), NULL),
                    NULL),
                  _mxarray20_)));
        }
        if (mlfTobool(a_)
            || mlfTobool(mclOr(a_, mclLt(mclVv(time, "time"), _mxarray19_)))) {
            mxDestroyArray(a_);
            /*
             * (time < 0)
             * error('Time is not zero or a positive real value.')
             */
            mlfError(_mxarray54_, NULL);
        } else {
            mxDestroyArray(a_);
        }
    /*
     * end
     */
    }
    /*
     * 
     * % Constants
     * this = 'TRAINLM';
     */
    mlfAssign(&this, _mxarray56_);
    /*
     * doValidation = ~isempty(VV);
     */
    mlfAssign(&doValidation, mclNot(mlfIsempty(mclVa(VV, "VV"))));
    /*
     * doTest = ~isempty(TV);
     */
    mlfAssign(&doTest, mclNot(mlfIsempty(mclVa(TV, "TV"))));
    /*
     * 
     * % Initialize
     * flag_stop=0;
     */
    mlfAssign(&flag_stop, _mxarray19_);
    /*
     * stop = '';
     */
    mlfAssign(&stop, _mxarray58_);
    /*
     * startTime = clock;
     */
    mlfAssign(&startTime, mlfClock());
    /*
     * X = getx(net);
     */
    mlfAssign(&X, mlfGetx(mclVa(net, "net")));
    /*
     * numParameters = length(X);
     */
    mlfAssign(&numParameters, mlfScalar(mclLengthInt(mclVv(X, "X"))));
    /*
     * ii = sparse(1:numParameters,1:numParameters,ones(1,numParameters));
     */
    mlfAssign(
      &ii,
      mlfSparse(
        mlfColon(_mxarray20_, mclVv(numParameters, "numParameters"), NULL),
        mlfColon(_mxarray20_, mclVv(numParameters, "numParameters"), NULL),
        mlfOnes(_mxarray20_, mclVv(numParameters, "numParameters"), NULL),
        NULL,
        NULL,
        NULL));
    /*
     * [perf,El,Ac,N,Zb,Zi,Zl] = calcperf(net,X,Pd,Tl,Ai,Q,TS);
     */
    mlfAssign(
      &perf,
      mlfCalcperf(
        El,
        Ac,
        &N,
        &Zb,
        &Zi,
        &Zl,
        mclVa(net, "net"),
        mclVv(X, "X"),
        mclVa(Pd, "Pd"),
        mclVa(Tl, "Tl"),
        mclVa(Ai, "Ai"),
        mclVa(Q, "Q"),
        mclVa(TS, "TS")));
    /*
     * if (doValidation)
     */
    if (mlfTobool(mclVv(doValidation, "doValidation"))) {
        /*
         * VV.net = net;
         */
        mlfIndexAssign(&VV, ".net", mclVa(net, "net"));
        /*
         * vperf = calcperf(net,X,VV.Pd,VV.Tl,VV.Ai,VV.Q,VV.TS);
         */
        mlfAssign(
          &vperf,
          mclFeval(
            mclValueVarargout(),
            mlxCalcperf,
            mclVa(net, "net"),
            mclVv(X, "X"),
            mlfIndexRef(mclVa(VV, "VV"), ".Pd"),
            mlfIndexRef(mclVa(VV, "VV"), ".Tl"),
            mlfIndexRef(mclVa(VV, "VV"), ".Ai"),
            mlfIndexRef(mclVa(VV, "VV"), ".Q"),
            mlfIndexRef(mclVa(VV, "VV"), ".TS"),
            NULL));
        /*
         * VV.perf = vperf;
         */
        mlfIndexAssign(&VV, ".perf", mclVv(vperf, "vperf"));
        /*
         * VV.numFail = 0;
         */
        mlfIndexAssign(&VV, ".numFail", _mxarray19_);
    /*
     * end
     */
    }
    /*
     * tr = newtr(epochs,'perf','vperf','tperf','mu');
     */
    mlfAssign(
      tr,
      mlfNewtr(
        mclVv(epochs, "epochs"),
        _mxarray59_, _mxarray61_, _mxarray63_, _mxarray65_, NULL));
    /*
     * 
     * % Train
     * for epoch=0:epochs
     */
    {
        int v_ = mclForIntStart(0);
        int e_ = mclForIntEnd(mclVv(epochs, "epochs"));
        if (v_ > e_) {
            mlfAssign(&epoch, _mxarray67_);
        } else {
            /*
             * 
             * % Jacobian
             * [je,jj,normgX]=calcjejj(net,Pd,Zb,Zi,Zl,N,Ac,El,Q,TS,mem_reduc);
             * 
             * % Training Record
             * epochPlus1 = epoch+1;
             * tr.perf(epoch+1) = perf;
             * tr.mu(epoch+1) = mu;
             * if (doValidation)
             * tr.vperf(epochPlus1) = VV.perf;
             * end
             * if (doTest)
             * tr.tperf(epochPlus1) = calcperf(net,X,TV.Pd,TV.Tl,TV.Ai,TV.Q,TV.TS);
             * end
             * 
             * % Stopping Criteria
             * currentTime = etime(clock,startTime);
             * if (perf <= goal)
             * stop = 'Performance goal met.';
             * elseif (epoch == epochs)
             * stop = 'Maximum epoch reached, performance goal was not met.';
             * elseif (currentTime > time)
             * stop = 'Maximum time elapsed, performance goal was not met.';
             * elseif (normgX < min_grad)
             * stop = 'Minimum gradient reached, performance goal was not met.';
             * elseif (mu > mu_max)
             * stop = 'Maximum MU reached, performance goal was not met.';
             * elseif (doValidation) & (VV.numFail > max_fail)
             * stop = 'Validation stop.';
             * elseif flag_stop
             * stop = 'User stop.';
             * end
             * 
             * % Progress
             * if isfinite(show) & (~rem(epoch,show) | length(stop))
             * fprintf(this);
             * if isfinite(epochs) fprintf(', Epoch %g/%g',epoch, epochs); end
             * if isfinite(time) fprintf(', Time %4.1f%%',currentTime/time*100); end
             * if isfinite(goal) fprintf(', %s %g/%g',upper(net.performFcn),perf,goal); end
             * if isfinite(min_grad) fprintf(', Gradient %g/%g',normgX,min_grad); end
             * fprintf('\n')
             * flag_stop=plotperf(tr,goal,this,epoch);
             * if length(stop) fprintf('%s, %s\n\n',this,stop); end
             * end
             * 
             * % Stop when criteria indicate its time
             * if length(stop)
             * if (doValidation)
             * net = VV.net;
             * end
             * break
             * end
             * 
             * % Levenberg Marquardt
             * while (mu <= mu_m