lmtrain.c

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

/*
 * MATLAB Compiler: 3.0
 * Date: Sun May 13 16:47:40 2007
 * Arguments: "-B" "macro_default" "-O" "all" "-O" "fold_scalar_mxarrays:on"
 * "-O" "fold_non_scalar_mxarrays:on" "-O" "optimize_integer_for_loops:on" "-O"
 * "array_indexing:on" "-O" "optimize_conditionals:on" "-M" "-silentsetup" "-d"
 * "d:/MATLAB6p5/work/nnToolKit/src" "-B" "csglcom:nnToolKit,nnToolKit,2.0"
 * "-B" "sgl" "-m" "-W" "main" "-L" "C" "-t" "-T" "link:exe" "-h"
 * "libmmfile.mlib" "-W" "mainhg" "libmwsglm.mlib" "-t" "-W"
 * "comhg:nnToolKit,nnToolKit,2.0" "-T" "link:lib" "-h" "libmmfile.mlib" "-i"
 * "-i" "D:/MATLAB6p5/work/nnToolKit/lmnet/LmSimu.m"
 * "D:/MATLAB6p5/work/nnToolKit/lmnet/LmTrain.m"
 * "D:/MATLAB6p5/work/nnToolKit/sofm/SofmSimu.m"
 * "D:/MATLAB6p5/work/nnToolKit/sofm/SofmTrain.m" 
 */
#include "lmtrain.h"
#include "deltalin.h"
#include "deltalog.h"
#include "deltatan.h"
#include "libmatlbm.h"
#include "libmmfile.h"
#include "libmwsglm.h"
#include "nntwarn.h"
#include "rands.h"
#include "trainlm.h"

static mxChar _array1_[3] = { 'O', 'F', 'F' };
static mxArray * _mxarray0_;
static mxArray * _mxarray2_;
static mxArray * _mxarray3_;
static mxArray * _mxarray4_;
static mxArray * _mxarray5_;
static mxArray * _mxarray6_;
static mxArray * _mxarray7_;
static mxArray * _mxarray8_;
static mxArray * _mxarray9_;

static mxChar _array11_[6] = { 't', 'a', 'n', 's', 'i', 'g' };
static mxArray * _mxarray10_;

static mxChar _array13_[7] = { 'p', 'u', 'r', 'e', 'l', 'i', 'n' };
static mxArray * _mxarray12_;

static mxChar _array15_[14] = { 'i', 'n', 'p', 'u', 't', '_', 'p',
                                'a', 'r', 'a', '%', 's', '%', 's' };
static mxArray * _mxarray14_;

static mxChar _array17_[4] = { '.', 't', 'x', 't' };
static mxArray * _mxarray16_;

static mxChar _array19_[1] = { 'r' };
static mxArray * _mxarray18_;

static mxChar _array21_[15] = { 'o', 'u', 't', 'p', 'u', 't', '_', 'p',
                                'a', 'r', 'a', '%', 's', '%', 's' };
static mxArray * _mxarray20_;

static mxChar _array23_[2] = { '%', 'f' };
static mxArray * _mxarray22_;

static mxChar _array25_[5] = { 'w', '%', 's', '%', 's' };
static mxArray * _mxarray24_;

static mxChar _array27_[5] = { '1', '.', 'd', 'a', 't' };
static mxArray * _mxarray26_;

static mxChar _array29_[1] = { 'w' };
static mxArray * _mxarray28_;

static mxChar _array31_[5] = { 'b', '%', 's', '%', 's' };
static mxArray * _mxarray30_;

static mxChar _array33_[5] = { '2', '.', 'd', 'a', 't' };
static mxArray * _mxarray32_;

static mxChar _array35_[6] = { '%', '9', '.', '4', 'f', ' ' };
static mxArray * _mxarray34_;

static mxChar _array37_[7] = { '%', '9', '.', '4', 'f', 0x005c, 'n' };
static mxArray * _mxarray36_;

static mxChar _array39_[10] = { 'l', 'm', '_', 'e', 'r',
                                'r', '%', 's', '%', 's' };
static mxArray * _mxarray38_;

static mxChar _array41_[4] = { '.', 'd', 'a', 't' };
static mxArray * _mxarray40_;

static mxChar _array43_[8] = { '%', '1', '0', '.', '6', 'f', 0x005c, 'n' };
static mxArray * _mxarray42_;

static mxChar _array45_[3] = { 'a', 'l', 'l' };
static mxArray * _mxarray44_;

void InitializeModule_lmtrain(void) {
    _mxarray0_ = mclInitializeString(3, _array1_);
    _mxarray2_ = mclInitializeDouble(-1.0);
    _mxarray3_ = mclInitializeDouble(1.0);
    _mxarray4_ = mclInitializeDouble(25.0);
    _mxarray5_ = mclInitializeDouble(1000.0);
    _mxarray6_ = mclInitializeDouble(.001);
    _mxarray7_ = mclInitializeDouble(10.0);
    _mxarray8_ = mclInitializeDouble(.1);
    _mxarray9_ = mclInitializeDouble(1e+10);
    _mxarray10_ = mclInitializeString(6, _array11_);
    _mxarray12_ = mclInitializeString(7, _array13_);
    _mxarray14_ = mclInitializeString(14, _array15_);
    _mxarray16_ = mclInitializeString(4, _array17_);
    _mxarray18_ = mclInitializeString(1, _array19_);
    _mxarray20_ = mclInitializeString(15, _array21_);
    _mxarray22_ = mclInitializeString(2, _array23_);
    _mxarray24_ = mclInitializeString(5, _array25_);
    _mxarray26_ = mclInitializeString(5, _array27_);
    _mxarray28_ = mclInitializeString(1, _array29_);
    _mxarray30_ = mclInitializeString(5, _array31_);
    _mxarray32_ = mclInitializeString(5, _array33_);
    _mxarray34_ = mclInitializeString(6, _array35_);
    _mxarray36_ = mclInitializeString(7, _array37_);
    _mxarray38_ = mclInitializeString(10, _array39_);
    _mxarray40_ = mclInitializeString(4, _array41_);
    _mxarray42_ = mclInitializeString(8, _array43_);
    _mxarray44_ = mclInitializeString(3, _array45_);
}

void TerminateModule_lmtrain(void) {
    mxDestroyArray(_mxarray44_);
    mxDestroyArray(_mxarray42_);
    mxDestroyArray(_mxarray40_);
    mxDestroyArray(_mxarray38_);
    mxDestroyArray(_mxarray36_);
    mxDestroyArray(_mxarray34_);
    mxDestroyArray(_mxarray32_);
    mxDestroyArray(_mxarray30_);
    mxDestroyArray(_mxarray28_);
    mxDestroyArray(_mxarray26_);
    mxDestroyArray(_mxarray24_);
    mxDestroyArray(_mxarray22_);
    mxDestroyArray(_mxarray20_);
    mxDestroyArray(_mxarray18_);
    mxDestroyArray(_mxarray16_);
    mxDestroyArray(_mxarray14_);
    mxDestroyArray(_mxarray12_);
    mxDestroyArray(_mxarray10_);
    mxDestroyArray(_mxarray9_);
    mxDestroyArray(_mxarray8_);
    mxDestroyArray(_mxarray7_);
    mxDestroyArray(_mxarray6_);
    mxDestroyArray(_mxarray5_);
    mxDestroyArray(_mxarray4_);
    mxDestroyArray(_mxarray3_);
    mxDestroyArray(_mxarray2_);
    mxDestroyArray(_mxarray0_);
}

static mxArray * Mlmtrain(int nargout_,
                          mxArray * ModelNo,
                          mxArray * NetPara,
                          mxArray * TrainPara,
                          mxArray * InputFun,
                          mxArray * OutputFun,
                          mxArray * DataDir);

_mexLocalFunctionTable _local_function_table_lmtrain
  = { 0, (mexFunctionTableEntry *)NULL };

/*
 * The function "mlfLmtrain" contains the normal interface for the "lmtrain"
 * M-function from file "d:\matlab6p5\work\nntoolkit\lmnet\lmtrain.m" (lines
 * 1-113). This function processes any input arguments and passes them to the
 * implementation version of the function, appearing above.
 */
mxArray * mlfLmtrain(mxArray * ModelNo,
                     mxArray * NetPara,
                     mxArray * TrainPara,
                     mxArray * InputFun,
                     mxArray * OutputFun,
                     mxArray * DataDir) {
    int nargout = 1;
    mxArray * retstr = NULL;
    mlfEnterNewContext(
      0, 6, ModelNo, NetPara, TrainPara, InputFun, OutputFun, DataDir);
    retstr
      = Mlmtrain(
          nargout, ModelNo, NetPara, TrainPara, InputFun, OutputFun, DataDir);
    mlfRestorePreviousContext(
      0, 6, ModelNo, NetPara, TrainPara, InputFun, OutputFun, DataDir);
    return mlfReturnValue(retstr);
}

/*
 * The function "mlxLmtrain" contains the feval interface for the "lmtrain"
 * M-function from file "d:\matlab6p5\work\nntoolkit\lmnet\lmtrain.m" (lines
 * 1-113). The feval function calls the implementation version of lmtrain
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
void mlxLmtrain(int nlhs, mxArray * plhs[], int nrhs, mxArray * prhs[]) {
    mxArray * mprhs[6];
    mxArray * mplhs[1];
    int i;
    if (nlhs > 1) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: lmtrain Line: 2 Column: "
            "1 The function \"lmtrain\" was called with mor"
            "e than the declared number of outputs (1)."),
          NULL);
    }
    if (nrhs > 6) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: lmtrain Line: 2 Column:"
            " 1 The function \"lmtrain\" was called with m"
            "ore than the declared number of inputs (6)."),
          NULL);
    }
    for (i = 0; i < 1; ++i) {
        mplhs[i] = NULL;
    }
    for (i = 0; i < 6 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 6; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(
      0, 6, mprhs[0], mprhs[1], mprhs[2], mprhs[3], mprhs[4], mprhs[5]);
    mplhs[0]
      = Mlmtrain(
          nlhs, mprhs[0], mprhs[1], mprhs[2], mprhs[3], mprhs[4], mprhs[5]);
    mlfRestorePreviousContext(
      0, 6, mprhs[0], mprhs[1], mprhs[2], mprhs[3], mprhs[4], mprhs[5]);
    plhs[0] = mplhs[0];
}

/*
 * The function "Mlmtrain" is the implementation version of the "lmtrain"
 * M-function from file "d:\matlab6p5\work\nntoolkit\lmnet\lmtrain.m" (lines
 * 1-113). It contains the actual compiled code for that M-function. It is a
 * static function and must only be called from one of the interface functions,
 * appearing below.
 */
/*
 * %此为BP网络训练程序
 * function retstr = LmTrain(ModelNo,NetPara,TrainPara,InputFun,OutputFun,DataDir)
 */
static mxArray * Mlmtrain(int nargout_,
                          mxArray * ModelNo,
                          mxArray * NetPara,
                          mxArray * TrainPara,
                          mxArray * InputFun,
                          mxArray * OutputFun,
                          mxArray * DataDir) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_lmtrain);
    mxArray * retstr = NULL;
    mxArray * ferr = NULL;
    mxArray * fwb2 = NULL;
    mxArray * fww2 = NULL;
    mxArray * fwb1 = NULL;
    mxArray * fww1 = NULL;
    mxArray * errors = NULL;
    mxArray * epochs = NULL;
    mxArray * b2 = NULL;
    mxArray * w2 = NULL;
    mxArray * b1 = NULL;
    mxArray * w1 = NULL;
    mxArray * s2 = NULL;
    mxArray * q = NULL;
    mxArray * r = NULL;
    mxArray * t = NULL;
    mxArray * count = NULL;
    mxArray * p = NULL;
    mxArray * frout_para = NULL;
    mxArray * frin_para = NULL;
    mxArray * tp = NULL;
    mxArray * err_ratio = NULL;
    mxArray * mom_const = NULL;
    mxArray * lr_idec = NULL;
    mxArray * lr_inc = NULL;
    mxArray * lr = NULL;
    mxArray * eg = NULL;
    mxArray * me = NULL;
    mxArray * df = NULL;
    mxArray * data_num = NULL;
    mxArray * MidDim = NULL;
    mxArray * OutputDim = NULL;
    mxArray * InputDim = NULL;
    mxArray * olddir = NULL;
    mxArray * ans = NULL;
    mclCopyArray(&ModelNo);
    mclCopyArray(&NetPara);
    mclCopyArray(&TrainPara);
    mclCopyArray(&InputFun);
    mclCopyArray(&OutputFun);
    mclCopyArray(&DataDir);
    /*
     * NNTWARN OFF
     */
    mlfNntwarn(_mxarray0_);
    /*
     * 
     * retstr=-1;
     */
    mlfAssign(&retstr, _mxarray2_);
    /*
     * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
     * %ModelNo='1';
     * %NetPara(1)=7;
     * %NetPara(2)=1;
     * %NetPara(3)=28;
     * %NetPara(4)=10;
     * %TrainPara(1)=25;
     * %TrainPara(2)=1000;
     * %TrainPara(3)=0.001;
     * %TrainPara(4)=0.001;
     * %TrainPara(5)=0.001;
     * %TrainPara(6)=10;
     * %TrainPara(7)=0.1;
     * %TrainPara(8)=1e10;
     * %DataDir='.';
     * %InputFun = 'tansig';
     * %OutputFun = 'purelin';
     * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
     * 
     * %保留原目录
     * olddir=pwd;
     */
    mlfAssign(&olddir, mlfPwd());
    /*
     * %进入数据所在目录
     * cd(DataDir);
     */
    mclAssignAns(&ans, mlfNCd(0, mclVa(DataDir, "DataDir")));
    /*
     * 
     * deltalin(1);
     */
    mclAssignAns(&ans, mlfDeltalin(_mxarray3_, NULL, NULL));
    /*
     * deltalog(1);
     */
    mclAssignAns(&ans, mlfDeltalog(_mxarray3_, NULL, NULL));
    /*
     * deltatan(1);
     */
    mclAssignAns(&ans, mlfDeltatan(_mxarray3_, NULL, NULL));
    /*
     * % 网络参数
     * InputDim=NetPara(1);       %输入层节点数
     */
    mlfAssign(&InputDim, mclIntArrayRef1(mclVa(NetPara, "NetPara"), 1));
    /*
     * OutputDim=NetPara(2);      %输出层节点数
     */
    mlfAssign(&OutputDim, mclIntArrayRef1(mclVa(NetPara, "NetPara"), 2));
    /*
     * MidDim=NetPara(3);         %中间层节点数
     */
    mlfAssign(&MidDim, mclIntArrayRef1(mclVa(NetPara, "NetPara"), 3));
    /*
     * data_num=NetPara(4);       %训练数据组数
     */
    mlfAssign(&data_num, mclIntArrayRef1(mclVa(NetPara, "NetPara"), 4));
    /*
     * % 网络训练参数
     * if (TrainPara == -1)
     */
    if (mclEqBool(mclVa(TrainPara, "TrainPara"), _mxarray2_)) {
        /*
         * df = 25;            %显示间隔次数 25
         */
        mlfAssign(&df, _mxarray4_);
        /*
         * me = 1000;             %最大循环次数 1000
         */
        mlfAssign(&me, _mxarray5_);
        /*
         * eg = 0.001;             %目标误差 0.02
         */
        mlfAssign(&eg, _mxarray6_);
        /*
         *