LinearModel Class Reference

#include <LinearModel.h>

Inheritance diagram for LinearModel:

List of all members.

Public Member Functions
	LinearModel ()
	~LinearModel ()
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
bool	m_tuneRigeModifiers
NumericalTools	solver
double *	m_ridgeModifiers

---

Detailed Description

Linear prediction model Based on simple linear regression on targets

Tunable parameters are the regularization constant It offers the possibility to tune the regularizer per feature

Definition at line 16 of file LinearModel.h.

---

Constructor & Destructor Documentation

LinearModel::LinearModel

(

)

Constructor

Definition at line 8 of file LinearModel.cpp.

{
    cout<<"LinearModel"<<endl;
    // init member vars
    m_x = 0;
    m_reg = 0;
    m_tuneRigeModifiers = false;
    m_ridgeModifiers = 0;
}

LinearModel::~LinearModel

(

)

Destructor

Definition at line 21 of file LinearModel.cpp.

{
    cout<<"descructor LinearModel"<<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;

    if ( m_ridgeModifiers )
        delete[] m_ridgeModifiers;
    m_ridgeModifiers = 0;
}

---

Member Function Documentation

void LinearModel::loadWeights

(

int

cross

)

[virtual]

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

Implements StandardAlgorithm.

Definition at line 150 of file LinearModel.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_reg, sizeof ( double ) );
    f.read ( ( char* ) &m_maxSwing, sizeof ( double ) );
    f.close();
}

void LinearModel::modelInit

(

)

[virtual]

Init the Linear Model

Implements StandardAlgorithm.

Definition at line 56 of file LinearModel.cpp.

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

    // 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];
    }

    if ( m_tuneRigeModifiers )
    {
        m_ridgeModifiers = new double[m_nFeatures];
        for ( int i=0;i<m_nFeatures;i++ )
        {
            m_ridgeModifiers[i] = 1.0;
            paramDoubleValues.push_back ( & ( m_ridgeModifiers[i] ) );
            char buf[1024];
            sprintf ( buf,"%d",i );
            paramDoubleNames.push_back ( "r"+string ( buf ) );
        }
    }
}

void LinearModel::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)
	target	The targets (can be cross validation targets)
	nSamples	The sample size (rows) in input
	crossRun	The cross validation run (for training)

Implements StandardAlgorithm.

Definition at line 118 of file LinearModel.cpp.

{
    // solve the linear system
    solver.RidgeRegressionMultisolutionSinglecall ( input, target, m_x[crossRun], nSamples, m_nFeatures, m_nClass*m_nDomain, m_reg, true, m_ridgeModifiers );
}

void LinearModel::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 92 of file LinearModel.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;
        }
    }
}

void LinearModel::readSpecificMaps

(

)

[virtual]

Read the Algorithm specific values from the description file

Implements StandardAlgorithm.

Definition at line 46 of file LinearModel.cpp.

{
    m_reg = m_doubleMap["initReg"];
    m_tuneRigeModifiers = m_boolMap["tuneRigeModifiers"];
}

void LinearModel::saveWeights

(

int

cross

)

[virtual]

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

Implements StandardAlgorithm.

Definition at line 128 of file LinearModel.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_reg, sizeof ( double ) );
    f.write ( ( char* ) &m_maxSwing, sizeof ( double ) );
    f.close();
}

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

Generates a template of the description file

Returns:

The template string

Definition at line 204 of file LinearModel.cpp.

{
    stringstream s;
    s<<"ALGORITHM=LinearModel"<<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<<endl;
    s<<"[double]"<<endl;
    s<<"initMaxSwing=1.0"<<endl;
    s<<"initReg=0.01"<<endl;
    s<<endl;
    s<<"[bool]"<<endl;
    s<<"tuneRigeModifiers=0"<<endl;
    s<<"enableClipping=1"<<endl;
    s<<"enableTuneSwing=0"<<endl;
    s<<endl;
    s<<"minimzeProbe="<< ( !blendStop ) <<endl;
    s<<"minimzeProbeClassificationError=0"<<endl;
    s<<"minimzeBlend="<<blendStop<<endl;
    s<<"minimzeBlendClassificationError=0"<<endl;
    s<<endl;
    s<<"[string]"<<endl;
    s<<"weightFile="<<"LinearModel_"<<nameID<<"_weights.dat"<<endl;
    s<<"fullPrediction=LinearModel_"<<nameID<<".dat"<<endl;

    return s.str();
}

---

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

• ELF/LinearModel.h
• ELF/LinearModel.cpp