LinearModelNonNeg Class Reference

#include <LinearModelNonNeg.h>

Inheritance diagram for LinearModelNonNeg:

List of all members.

Public Member Functions
	LinearModelNonNeg ()
	~LinearModelNonNeg ()
virtual void	modelInit ()
virtual void	modelUpdate (REAL *input, REAL *target, uint nSamples, uint crossRun)
virtual void	predictAllOutputs (REAL *rawInputs, REAL *outputs, uint nSamples, uint crossRun)
virtual void	readSpecificMaps ()
virtual void	saveWeights (int cross)
virtual void	loadWeights (int cross)
virtual void	loadMetaWeights (int cross)
Static Public Member Functions
static string	templateGenerator (int id, string preEffect, int nameID, bool blendStop)
Private Attributes
REAL **	m_x
double	m_reg
double	m_scale
double	m_bias
int	m_maxNonNegSolverIterations
NumericalTools	solver
double	m_initReg
double	m_initScale
double	m_initBias

---

Detailed Description

Linear prediction model with non-negativ solver Based on simple linear regression on targets

Tunable parameters are the regularization constant and the target offsets

Definition at line 15 of file LinearModelNonNeg.h.

---

Constructor & Destructor Documentation

LinearModelNonNeg::LinearModelNonNeg

(

)

Constructor

Definition at line 8 of file LinearModelNonNeg.cpp.

{
    cout<<"LinearModelNonNeg"<<endl;
    // init member vars
    m_x = 0;
    m_reg = 0;
    m_scale = 0;
    m_bias = 0;
    m_maxNonNegSolverIterations = 0;
    m_initReg = 0;
    m_initScale = 0;
    m_initBias = 0;
}

LinearModelNonNeg::~LinearModelNonNeg

(

)

Destructor

Definition at line 25 of file LinearModelNonNeg.cpp.

{
    cout<<"descructor LinearModelNonNeg"<<endl;
    for ( int i=0;i<m_nCross+1;i++ )
    {
        if ( m_x )
        {
            if ( m_x[i] )
                delete[] m_x[i];
            m_x[i] = 0;
        }
    }
    if ( m_x )
        delete[] m_x;
    m_x = 0;
}

---

Member Function Documentation

void LinearModelNonNeg::loadWeights

(

int

cross

)

[virtual]

Load the weights and all other parameters and make the model ready to predict

Implements StandardAlgorithm.

Definition at line 172 of file LinearModelNonNeg.cpp.

{
    char buf[1024];
    sprintf ( buf,"%02d",cross );
    string name = m_datasetPath + "/" + m_tempPath + "/" + m_weightFile + "." + buf;
    cout<<"Load:"<<name<<endl;
    fstream f ( name.c_str(), ios::in );
    if ( f.is_open() == false )
        assert ( false );
    f.read ( ( char* ) &m_nTrain, sizeof ( int ) );
    f.read ( ( char* ) &m_nFeatures, sizeof ( int ) );
    f.read ( ( char* ) &m_nClass, sizeof ( int ) );
    f.read ( ( char* ) &m_nDomain, sizeof ( int ) );

    m_x = new REAL*[m_nCross+1];
    for ( int i=0;i<m_nCross+1;i++ )
        m_x[i] = 0;
    m_x[cross] = new REAL[m_nFeatures * m_nClass * m_nDomain];

    f.read ( ( char* ) m_x[cross], sizeof ( REAL ) *m_nFeatures*m_nClass*m_nDomain );
    f.read ( ( char* ) &m_maxSwing, sizeof ( double ) );
    f.read ( ( char* ) &m_reg, sizeof ( double ) );
    f.read ( ( char* ) &m_bias, sizeof ( double ) );
    f.read ( ( char* ) &m_scale, sizeof ( double ) );
    f.close();
}

void LinearModelNonNeg::modelInit

(

)

[virtual]

Init the Linear Model

Implements StandardAlgorithm.

Definition at line 59 of file LinearModelNonNeg.cpp.

{
    // add the tunable parameter
    m_reg = m_initReg;
    paramDoubleValues.push_back ( &m_reg );
    paramDoubleNames.push_back ( "reg" );

    m_bias = m_initBias;
    paramDoubleValues.push_back ( &m_bias );
    paramDoubleNames.push_back ( "bias" );

    m_scale = m_initScale;
    paramDoubleValues.push_back ( &m_scale );
    paramDoubleNames.push_back ( "scale" );

    // alloc mem for weights
    if ( m_x == 0 )
    {
        m_x = new REAL*[m_nCross+1];
        for ( int i=0;i<m_nCross+1;i++ )
            m_x[i] = new REAL[m_nFeatures * m_nClass * m_nDomain];
    }
}

void LinearModelNonNeg::modelUpdate	(	REAL *	input,
		REAL *	target,
		uint	nSamples,
		uint	crossRun
	)			[virtual]

Make a model update, set the new cross validation set or set the whole training set for retraining

Parameters:

	input	Pointer to input (can be cross validation set, or whole training set) (rows x nFeatures) [col0;col1..]
	target	The targets (can be cross validation targets), [row0;row1..]
	nSamples	The sample size (rows) in input
	crossRun	The cross validation run (for training)

Implements StandardAlgorithm.

Definition at line 117 of file LinearModelNonNeg.cpp.

{
    REAL* tmpTargets = new REAL[nSamples*m_nClass*m_nDomain];
    REAL* x = new REAL[m_nFeatures];

    // set targets
    for ( int i=0;i<m_nClass*m_nDomain;i++ )
        for ( int j=0;j<nSamples;j++ )
            tmpTargets[i * nSamples + j] = target[j * m_nClass * m_nDomain + i] * m_scale + m_bias;

    // solve the linear systems (per output class)
    for ( int i=0;i<m_nClass*m_nDomain;i++ )
    {
        int nIter = solver.RidgeRegressionNonNegSinglecall ( input, tmpTargets+i*nSamples, x, nSamples, m_nFeatures, m_reg, 1e-10, m_maxNonNegSolverIterations );

        for ( int j=0;j<m_nFeatures;j++ )
            m_x[crossRun][j*m_nClass*m_nDomain+i] = x[j];
    }

    if ( tmpTargets )
        delete[] tmpTargets;
    tmpTargets = 0;
    if ( x )
        delete[] x;
    x = 0;
}

void LinearModelNonNeg::predictAllOutputs	(	REAL *	rawInputs,
		REAL *	outputs,
		uint	nSamples,
		uint	crossRun
	)			[virtual]

Prediction for outside use, predicts outputs based on raw input values

Parameters:

	rawInputs	The input feature, without normalization (raw)
	outputs	The output value (prediction of target)
	nSamples	The input size (number of rows)
	crossRun	Number of cross validation run (in training)

Implements StandardAlgorithm.

Definition at line 91 of file LinearModelNonNeg.cpp.

{
    for ( int i=0;i<nSamples;i++ )
    {
        for ( int j=0;j<m_nClass*m_nDomain;j++ )
        {
            REAL sum = 0.0;
            for ( int k=0;k<m_nFeatures;k++ )
            {
                REAL x = rawInputs[i*m_nFeatures + k];
                sum += x * m_x[crossRun][k*m_nClass*m_nDomain + j];
            }
            outputs[i*m_nClass*m_nDomain + j] = ( sum - m_bias ) / m_scale;
        }
    }
}

void LinearModelNonNeg::readSpecificMaps

(

)

[virtual]

Read the Algorithm specific values from the description file

Implements StandardAlgorithm.

Definition at line 46 of file LinearModelNonNeg.cpp.

{
    m_initReg = m_doubleMap["initReg"];
    m_initScale = m_doubleMap["initScale"];
    m_initBias = m_doubleMap["initBias"];

    m_maxNonNegSolverIterations = m_intMap["maxNonNegSolverIterations"];
}

void LinearModelNonNeg::saveWeights

(

int

cross

)

[virtual]

Save the weights and all other parameters for load the complete prediction model

Implements StandardAlgorithm.

Definition at line 148 of file LinearModelNonNeg.cpp.

{
    char buf[1024];
    sprintf ( buf,"%02d",cross );
    string name = m_datasetPath + "/" + m_tempPath + "/" + m_weightFile + "." + buf;
    if ( m_inRetraining )
        cout<<"Save:"<<name<<endl;
    fstream f ( name.c_str(), ios::out );
    f.write ( ( char* ) &m_nTrain, sizeof ( int ) );
    f.write ( ( char* ) &m_nFeatures, sizeof ( int ) );
    f.write ( ( char* ) &m_nClass, sizeof ( int ) );
    f.write ( ( char* ) &m_nDomain, sizeof ( int ) );
    f.write ( ( char* ) m_x[cross], sizeof ( REAL ) *m_nFeatures*m_nClass*m_nDomain );
    f.write ( ( char* ) &m_maxSwing, sizeof ( double ) );
    f.write ( ( char* ) &m_reg, sizeof ( double ) );
    f.write ( ( char* ) &m_bias, sizeof ( double ) );
    f.write ( ( char* ) &m_scale, sizeof ( double ) );
    f.close();
}

string LinearModelNonNeg::templateGenerator	(	int	id,
		string	preEffect,
		int	nameID,
		bool	blendStop
	)			[static]

Generates a template of the description file

Returns:

The template string

Definition at line 231 of file LinearModelNonNeg.cpp.

{
    stringstream s;
    s<<"ALGORITHM=LinearModelNonNeg"<<endl;
    s<<"ID="<<id<<endl;
    s<<"TRAIN_ON_FULLPREDICTOR="<<preEffect<<endl;
    s<<"DISABLE=0"<<endl;
    s<<endl;
    s<<"[int]"<<endl;
    s<<"maxTuninigEpochs=20"<<endl;
    s<<"maxNonNegSolverIterations=1000"<<endl;
    s<<endl;
    s<<"[double]"<<endl;
    s<<"initMaxSwing=0.5"<<endl;
    s<<"initReg=0.01"<<endl;
    s<<"initScale=1.0"<<endl;
    s<<"initBias=3.0"<<endl;
    s<<endl;
    s<<"[bool]"<<endl;
    s<<"enableClipping="<< ( !blendStop ) <<endl;
    s<<"enableTuneSwing=0"<<endl;
    s<<endl;
    s<<"minimzeProbe=0"<<endl;
    s<<"minimzeProbeClassificationError=0"<<endl;
    s<<"minimzeBlend="<<blendStop<<endl;
    s<<"minimzeBlendClassificationError=0"<<endl;
    s<<endl;
    s<<"[string]"<<endl;
    s<<"weightFile="<<"LinearModelNonNeg_"<<nameID<<"_weights.dat"<<endl;
    s<<"fullPrediction=LinearModelNonNeg_"<<nameID<<".dat"<<endl;

    return s.str();
}

---

The documentation for this class was generated from the following files:

• ELF/LinearModelNonNeg.h
• ELF/LinearModelNonNeg.cpp