static void __fscanf_and_set( matrix_type * matrix , int row , int col , FILE * stream) {
double value;
if (fscanf(stream , "%lg" , &value) == 1)
matrix_iset( matrix , row , col , value );
else
util_abort("%s: reading of matrix failed at row:%d col:%d \n",__func__ , row , col);
}
void test_diag_std() {
const int N = 25;
double_vector_type * data = double_vector_alloc( 0,0);
rng_type * rng = rng_alloc(MZRAN , INIT_DEV_URANDOM );
matrix_type * m = matrix_alloc( N , N );
double sum1 = 0;
double sum2 = 0;
int i;
for (i=0; i < N; i++) {
double R = rng_get_double( rng );
matrix_iset(m , i , i , R);
double_vector_iset( data , i , R );
sum1 += R;
sum2 += R*R;
}
{
double mean = sum1 / N;
double std = sqrt( sum2 / N - mean * mean );
test_assert_double_equal( std , matrix_diag_std( m , mean ));
test_assert_double_equal( statistics_std( data ) , matrix_diag_std( m , mean ));
test_assert_double_equal( statistics_mean( data ) , mean );
}
matrix_free( m );
rng_free( rng );
}
void matrix_subtract_and_store_row_mean(matrix_type * matrix, matrix_type * row_mean) {
int i;
for ( i=0; i < matrix->rows; i++) {
double mean = matrix_get_row_sum(matrix , i) / matrix->columns;
matrix_shift_row( matrix , i , -mean);
matrix_iset(row_mean , i , 0, mean );
}
}
int main( int argc, char ** argv) {
rng_type * rng = rng_alloc( MZRAN , INIT_DEV_RANDOM );
matrix_type * A = matrix_alloc( 12 , 12 );
matrix_type * B = matrix_alloc( 12 , 12 );
matrix_random_init( A , rng );
matrix_assign( B , A );
matrix_pretty_print( A , " A " , "%8.4f" );
#ifdef WITH_LAPACK
matrix_inv( B );
printf("\n");
matrix_pretty_print( B , "inv(A)" , "%8.4f" );
matrix_inplace_matmul( B , A );
printf("\n");
matrix_pretty_print( B , " I " , "%8.4f" );
{
matrix_type * A3 = matrix_alloc(3,3);
matrix_random_init( A3 , rng );
matrix_iset( A3 , 0 , 0 , sin(0.98));
printf("matrix_det3:%g ",matrix_det3( A3 ));
printf("matrix_det:%g \n",matrix_det( A3 ));
}
{
matrix_type * A4 = matrix_alloc(4,4);
matrix_random_init( A4 , rng );
matrix_iset( A4 , 0 , 0 , sin(0.98));
printf("matrix_det4:%g ",matrix_det4( A4 ));
printf("matrix_det:%g \n",matrix_det( A4 ));
}
#endif
matrix_free( A );
matrix_free( B );
rng_free( rng );
}
void matrix_set(matrix_type * matrix, double value) {
int i,j;
for (j=0; j < matrix->columns; j++)
for (i=0; i < matrix->rows; i++)
matrix_iset(matrix , i , j , value);
}
void matrix_iset_safe(matrix_type * matrix , int i , int j, double value) {
matrix_assert_ij( matrix , i , j );
matrix_iset( matrix , i , j , value );
}
void stepwise_isetY0( stepwise_type * stepwise , int i , double value ) {
matrix_iset( stepwise->Y0, i , 0 , value );
}
static double stepwise_estimate__( stepwise_type * stepwise , bool_vector_type * active_rows) {
matrix_type * X;
matrix_type * E;
matrix_type * Y;
double y_mean = 0;
int nvar = matrix_get_columns( stepwise->X0 );
int nsample = matrix_get_rows( stepwise->X0 );
nsample = bool_vector_count_equal( active_rows , true );
nvar = bool_vector_count_equal( stepwise->active_set , true );
matrix_set( stepwise->beta , 0 ); // It is essential to make sure that old finite values in the beta0 vector do not hang around.
/*
Extracting the data used for regression, and storing them in the
temporary local matrices X and Y. Selecting data is based both on
which varibles are active (stepwise->active_set) and which rows
should be used for regression, versus which should be used for
validation (@active_rows).
*/
if ((nsample < matrix_get_rows( stepwise->X0 )) || (nvar < matrix_get_columns( stepwise->X0 ))) {
X = matrix_alloc( nsample , nvar );
E = matrix_alloc( nsample , nvar );
Y = matrix_alloc( nsample , 1);
{
int icol,irow; // Running over all values.
int arow,acol; // Running over active values.
arow = 0;
for (irow = 0; irow < matrix_get_rows( stepwise->X0 ); irow++) {
if (bool_vector_iget( active_rows , irow )) {
acol = 0;
for (icol = 0; icol < matrix_get_columns( stepwise->X0 ); icol++) {
if (bool_vector_iget( stepwise->active_set , icol )) {
matrix_iset( X , arow , acol , matrix_iget( stepwise->X0 , irow , icol ));
matrix_iset( E , arow , acol , matrix_iget( stepwise->E0 , irow , icol ));
acol++;
}
}
matrix_iset( Y , arow , 0 , matrix_iget( stepwise->Y0 , irow , 0 ));
arow++;
}
}
}
} else {
X = matrix_alloc_copy( stepwise->X0 );
E = matrix_alloc_copy( stepwise->E0 );
Y = matrix_alloc_copy( stepwise->Y0 );
}
{
if (stepwise->X_mean != NULL)
matrix_free( stepwise->X_mean);
stepwise->X_mean = matrix_alloc( 1 , nvar );
if (stepwise->X_norm != NULL)
matrix_free( stepwise->X_norm);
stepwise->X_norm = matrix_alloc( 1 , nvar );
matrix_type * beta = matrix_alloc( nvar , 1); /* This is the beta vector as estimated from the OLS estimator. */
regression_augmented_OLS( X , Y , E, beta );
/*
In this code block the beta/tmp_beta vector which is dense with
fewer elements than the full model is scattered into the beta0
vector which has full size and @nvar elements.
*/
{
int ivar,avar;
avar = 0;
for (ivar = 0; ivar < matrix_get_columns( stepwise->X0 ); ivar++) {
if (bool_vector_iget( stepwise->active_set , ivar )) {
matrix_iset( stepwise->beta , ivar , 0 , matrix_iget( beta , avar , 0));
avar++;
}
}
}
matrix_free( beta );
}
matrix_free( X );
matrix_free( E );
matrix_free( Y );
return y_mean;
}
void stepwise_estimate( stepwise_type * stepwise , double deltaR2_limit , int CV_blocks) {
int nvar = matrix_get_columns( stepwise->X0 );
int nsample = matrix_get_rows( stepwise->X0 );
double currentR2 = -1;
bool_vector_type * active_rows = bool_vector_alloc( nsample , true );
/*Reset beta*/
for (int i = 0; i < nvar; i++) {
matrix_iset(stepwise->beta, i , 0 , 0.0);
}
bool_vector_set_all( stepwise->active_set , false );
double MSE_min = 10000000;
double Prev_MSE_min = MSE_min;
double minR2 = -1;
while (true) {
int best_var = 0;
Prev_MSE_min = MSE_min;
/*
Go through all the inactive variables, and calculate the
resulting prediction error IF this particular variable is added;
keep track of the variable which gives the lowest prediction error.
*/
for (int ivar = 0; ivar < nvar; ivar++) {
if (!bool_vector_iget( stepwise->active_set , ivar)) {
double newR2 = stepwise_test_var(stepwise , ivar , CV_blocks);
if ((minR2 < 0) || (newR2 < minR2)) {
minR2 = newR2;
best_var = ivar;
}
}
}
/*
If the best relative improvement in prediction error is better
than @deltaR2_limit, the corresponding variable is added to the
active set, and we return to repeat the loop one more
time. Otherwise we just exit.
*/
{
MSE_min = minR2;
double deltaR2 = MSE_min / Prev_MSE_min;
if (( currentR2 < 0) || deltaR2 < deltaR2_limit) {
bool_vector_iset( stepwise->active_set , best_var , true );
currentR2 = minR2;
bool_vector_set_all(active_rows, true);
stepwise_estimate__( stepwise , active_rows );
} else {
/* The gain in prediction error is so small that we just leave the building. */
/* NB! Need one final compuation of beta (since the test_var function does not reset the last tested beta value !) */
bool_vector_set_all(active_rows, true);
stepwise_estimate__( stepwise , active_rows );
break;
}
if (bool_vector_count_equal( stepwise->active_set , true) == matrix_get_columns( stepwise->X0 )) {
stepwise_estimate__( stepwise , active_rows );
break; /* All variables are active. */
}
}
}
stepwise_set_R2(stepwise, currentR2);
bool_vector_free( active_rows );
}
void lars_isetX( lars_type * lars, int sample, int var , double value) {
matrix_iset( lars->X , sample , var , value );
}
void lars_estimate(lars_type * lars , int max_vars , double max_beta , bool verbose) {
int nvars = matrix_get_columns( lars->X );
int nsample = matrix_get_rows( lars->X );
matrix_type * X = matrix_alloc( nsample, nvars ); // Allocate local X and Y variables
matrix_type * Y = matrix_alloc( nsample, 1 ); // which will hold the normalized data
lars_estimate_init( lars , X , Y); // during the estimation process.
{
matrix_type * G = matrix_alloc_gram( X , true );
matrix_type * mu = matrix_alloc( nsample , 1 );
matrix_type * C = matrix_alloc( nvars , 1 );
matrix_type * Y_mu = matrix_alloc_copy( Y );
int_vector_type * active_set = int_vector_alloc(0,0);
int_vector_type * inactive_set = int_vector_alloc(0,0);
int active_size;
if ((max_vars <= 0) || (max_vars > nvars))
max_vars = nvars;
{
int i;
for (i=0; i < nvars; i++)
int_vector_iset( inactive_set , i , i );
}
matrix_set( mu , 0 );
while (true) {
double maxC = 0;
/*
The first step is to calculate the correlations between the
covariates, and the current residual. All the currently inactive
covariates are searched; the covariate with the greatest
correlation with (Y - mu) is selected and added to the active set.
*/
matrix_sub( Y_mu , Y , mu ); // Y_mu = Y - mu
matrix_dgemm( C , X , Y_mu , true , false , 1.0 , 0); // C = X' * Y_mu
{
int i;
int max_set_index = 0;
for (i=0; i < int_vector_size( inactive_set ); i++) {
int set_index = i;
int var_index = int_vector_iget( inactive_set , set_index );
double value = fabs( matrix_iget(C , var_index , 0) );
if (value > maxC) {
maxC = value;
max_set_index = set_index;
}
}
/*
Remove element corresponding to max_set_index from the
inactive set and add it to the active set:
*/
int_vector_append( active_set , int_vector_idel( inactive_set , max_set_index ));
}
active_size = int_vector_size( active_set );
/*
Now we have calculated the correlations between all the
covariates and the current residual @Y_mu. The correlations are
stored in the matrix @C. The value of the maximum correlation is
stored in @maxC.
Based on the value of @maxC we have added one new covariate to
the model, technically by moving the index from @inactive_set to
@active_set.
*/
/*****************************************************************/
{
matrix_type * weights = matrix_alloc( active_size , 1);
double scale;
/*****************************************************************/
/* This scope should compute and initialize the variables
@weights and @scale. */
{
matrix_type * subG = matrix_alloc( active_size , active_size );
matrix_type * STS = matrix_alloc( active_size , active_size );
matrix_type * sign_vector = matrix_alloc( active_size , 1);
int i , j;
/*
STS = S' o S where 'o' is the Schur product and S is given
by:
[ s1 s2 s3 s4 ]
S = [ s1 s2 s3 s4 ]
[ s1 s2 s3 s4 ]
[ s1 s2 s3 s4 ]
Where si is the sign of the correlation between (active)
variable 'i' and Y_mu.
*/
for (i=0; i < active_size ; i++) {
int vari = int_vector_iget( active_set , i );
double signi = sgn( matrix_iget( C , vari , 0));
matrix_iset( sign_vector , i , 0 , signi );
for (j=0; j < active_size; j++) {
int varj = int_vector_iget( active_set , j );
double signj = sgn( matrix_iget( C , varj , 0));
matrix_iset( STS , i , j , signi * signj );
}
}
// Extract the elements from G corresponding to active indices and
// copy to the matrix subG:
for (i=0; i < active_size ; i++) {
int ii = int_vector_iget( active_set , i );
for (j=0; j < active_size; j++) {
int jj = int_vector_iget( active_set , j );
matrix_iset( subG , i , j , matrix_iget(G , ii , jj));
}
}
// Weights
matrix_inplace_mul( subG , STS );
matrix_inv( subG );
{
matrix_type * ones = matrix_alloc( active_size , 1 );
matrix_type * GA1 = matrix_alloc( active_size , 1 );
matrix_set( ones , 1.0 );
matrix_matmul( GA1 , subG , ones );
scale = 1.0 / sqrt( matrix_get_column_sum( GA1 , 0 ));
matrix_mul( weights , GA1 , sign_vector );
matrix_scale( weights , scale );
matrix_free( GA1 );
matrix_free( ones );
}
matrix_free( sign_vector );
matrix_free( subG );
matrix_free( STS );
}
/******************************************************************/
/* The variables weight and scale have been calculated, proceed
to calculate the step length @gamma. */
{
int i;
double gamma;
{
matrix_type * u = matrix_alloc( nsample , 1 );
int j;
for (i=0; i < nsample; i++) {
double row_sum = 0;
for (j =0; j < active_size; j++)
row_sum += matrix_iget( X , i , int_vector_iget( active_set , j)) * matrix_iget(weights , j , 0 );
matrix_iset( u , i , 0 , row_sum );
}
gamma = maxC / scale;
if (active_size < matrix_get_columns( X )) {
matrix_type * equi_corr = matrix_alloc( nvars , 1 );
matrix_dgemm( equi_corr , X , u , true , false , 1.0 , 0); // equi_corr = X'·u
for (i=0; i < (nvars - active_size); i++) {
int var_index = int_vector_iget( inactive_set , i );
double gamma1 = (maxC - matrix_iget(C , var_index , 0 )) / ( scale - matrix_iget( equi_corr , var_index , 0));
double gamma2 = (maxC + matrix_iget(C , var_index , 0 )) / ( scale + matrix_iget( equi_corr , var_index , 0));
if ((gamma1 > 0) && (gamma1 < gamma))
gamma = gamma1;
if ((gamma2 > 0) && (gamma2 < gamma))
gamma = gamma2;
}
matrix_free( equi_corr );
}
/* Update the current estimated 'location' mu. */
matrix_scale( u , gamma );
matrix_inplace_add( mu , u );
matrix_free( u );
}
/*
We have calculated the step length @gamma, and the @weights. Update the @beta matrix.
*/
for (i=0; i < active_size; i++)
matrix_iset( lars->beta , int_vector_iget( active_set , i ) , active_size - 1 , gamma * matrix_iget( weights , i , 0));
if (active_size > 1)
for (i=0; i < nvars; i++)
matrix_iadd( lars->beta , i , active_size - 1 , matrix_iget( lars->beta , i , active_size - 2));
matrix_free( weights );
}
}
if (active_size == max_vars)
break;
if (max_beta > 0) {
double beta_norm2 = matrix_get_column_abssum( lars->beta , active_size - 1 );
if (beta_norm2 > max_beta) {
// We stop - we will use an interpolation between this beta estimate and
// the previous, to ensure that the |beta| = max_beta criteria is satisfied.
if (active_size >= 2) {
double beta_norm1 = matrix_get_column_abssum( lars->beta , active_size - 2 );
double s = (max_beta - beta_norm1)/(beta_norm2 - beta_norm1);
{
int j;
for (j=0; j < nvars; j++) {
double beta1 = matrix_iget( lars->beta , j , active_size - 2 );
double beta2 = matrix_iget( lars->beta , j , active_size - 1 );
matrix_iset( lars->beta , j , active_size - 1 , beta1 + s*(beta2 - beta1));
}
}
}
break;
}
}
}
matrix_free( G );
matrix_free( mu );
matrix_free( C );
matrix_free( Y_mu );
int_vector_free( active_set );
int_vector_free( inactive_set );
matrix_resize( lars->beta , nvars , active_size , true );
if (verbose)
matrix_pretty_fprint( lars->beta , "beta" , "%12.5f" , stdout );
lars_select_beta( lars , active_size - 1);
}
matrix_free( X );
matrix_free( Y );
}
void lars_isetY( lars_type * lars, int sample, double value) {
matrix_iset( lars->Y , sample , 0 , value );
}
