www.pudn.com > AdaBoost_weaklearner_1.rar > Adaboost_common.cpp
#include "stdafx.h"
#include "AdaBoost.h"
#include "Adaboost_common.h"
#include "math.h"
#include "matrix.h"
#include
#include /* For _MAX_PATH definition */
#include
#include
#include
#include
#include
#include
#include
#include
#include
#ifdef _WIN32
using namespace std;
#endif
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif
using namespace std ;
static char temstr[200];
typedef vector INTVECTOR;
/*read the data from train documents*/
int read_train_file(char *trainfile,
long train_max_words_doc,
long train_max_docs,
long train_ll,
Matrix* train_matrix,
Matrix *train_label_matrix)
{
FILE *docfl;
char *line;
line = (char *)my_malloc(sizeof(char)*train_ll);
if ((docfl = fopen (trainfile, "r")) == NULL)
{
printe (trainfile);
return -1;
}
if (com_pro.show_readfile)
{
sprintf(temstr,"Reading examples into memory...");
printm(temstr);
}
train_matrix->readFile(trainfile);
int i=1;
while((!feof(docfl)) && fgets(line,(int)train_ll,docfl))
{
if (line[0] == '#') continue; /* line contains comments */
int len=0,train_label_end=0;
len = strlen(line);
len=len-2;
if((sscanf(line+len,"%ld",&train_label_end)) == EOF) return(0);
//theVector.push_back(train_label_end);
double value = (double) train_label_end;
int one=0;
train_label_matrix->set(i,one,value);
i++;
}
// Matrix *vm_1 = new Matrix(r,c);
// Matrix mv_1=(*train_label_matrix)*(*train_label_matrix);
fclose(docfl);
}
/*read the data from test documents*/
int read_test_file(char *testfile,
long test_max_words_doc,
long test_max_docs,
long test_ll,
Matrix* test_matrix,
Matrix* test_label_matrix)
{
FILE *docfl;
char *line;
line = (char *)my_malloc(sizeof(char)*test_ll);
if ((docfl = fopen (testfile, "r")) == NULL)
{
printe (testfile);
return -1;
}
if (com_pro.show_readfile)
{
sprintf(temstr,"Reading examples into memory...");
printm(temstr);
}
// Load test matrix from train file
test_matrix->readFile(testfile);
int i=1;
while((!feof(docfl)) && fgets(line,(int)test_ll,docfl))
{
if (line[0] == '#') continue; /* line contains comments */
int len=0,test_label_end=0;
len = strlen(line);
len=len-2;
if((sscanf(line+len,"%ld",&test_label_end)) == EOF) return(0);
double value = (double) test_label_end;
int one=0;
test_label_matrix->set(i,one,value);
i++;
}
fclose(docfl);
}
/*************************************************************************************/
/* function boosted=adaBoost(train,train_label,cycles) */
/* disp('running adaBoost algorithm'); */
/* d=size(train); */
/* distribution=ones(1,d(1))/d(1); */
/* error=zeros(1,cycles); */
/* beta=zeros(1,cycles); */
/* label=(train_label(:)>=5);% contain the correct label per vector */
/* for j=1:cycles */
/* if(mod(j,10)==0) */
/* disp([j,cycles]); */
/* end */
/* [i,t]=weakLearner(distribution,train,label); */
/* error(j)=distribution*abs(label-(train(:,i)>=t)); */
/* beta(j)=error(j)/(1-error(j)); */
/* boosted(j,:)=[beta(j),i,t]; */
/* distribution=distribution.* exp(log(beta(j))*(1-abs(label-(train(:,i)>=t))))'; */
/* distribution=distribution/sum(distribution); */
/* end */
/*************************************************************************************/
int adaBoost(Matrix* train,
Matrix* train_label,
long train_max_words_doc,
long train_max_docs,
int step,
int cycles,
Matrix* boost,
Matrix* iii,
Matrix* ttt,
double ave_delta)
{
int r_train=train_max_docs+1;
int c_train=train_max_words_doc;
int value_one = 1;
int value_1000 = 1000;
int cycles_num=0;
Matrix* scalar_minus_error = new Matrix(value_one+1,step);
if (step < 100){
cycles_num=step;
}
if (step >= 100){
cycles_num=100;
}
if (step < 100){
step=r_train;
}
Matrix* distribution= new Matrix(value_one+1,step);
distribution->ones(value_one+1,step,value_one,step);
Matrix* error= new Matrix(value_one+1,cycles);
error->zeros(value_one+1,cycles);
Matrix* beta= new Matrix(value_one+1,cycles);
beta->zeros(value_one+1,cycles);
// temprary Matrix
Matrix* train_error_part = new Matrix(step,value_one+1);
Matrix* error_label_train = new Matrix(step,value_one+1);
Matrix* error_abs_label_train = new Matrix(step,value_one+1);
Matrix* train_error_part_1 = new Matrix(step,value_one+1);
Matrix* error_label_train_1 = new Matrix(step,value_one+1);
Matrix* error_abs_label_train_1 = new Matrix(step,value_one+1);
Matrix* scalar_minus_error_1 = new Matrix(step,value_one+1);
Matrix* val_beta = new Matrix(value_one+1,value_one+1);
Matrix* beta_label_train = new Matrix(step,value_one+1);
Matrix* expMatrix = new Matrix(step,value_one+1);
Matrix* transposeExpMatrix = new Matrix(value_one+1,step);
Matrix* sumMatrix = new Matrix(value_one+1,step);
Matrix* i_all = new Matrix(step,value_one);
Matrix* t_all = new Matrix(step,value_one);
double Array_boost[100];
double Array_ttt[100];
double Array_iii[100];
Matrix* getArrayiii = new Matrix(cycles,value_one);
Matrix* getArrayttt = new Matrix(cycles,value_one);
Matrix* getArrayboost = new Matrix(cycles,value_one);
// label_matrix are contain the correct label per vector
Matrix label_matrix = (*train_label)>3;
if (com_pro.show_action)
printm("running adaBoost algorithm");
for (int j=1; j <= cycles_num; j++)
{
if ((j % 10) == 0)
{
if (com_pro.show_compute_1)
{
sprintf(temstr,"%d %d\n",j,cycles);
printm(temstr);
}
}
/************************************************/
/* [i,t]=weakLearner(distribution,train,label); */
/************************************************/
int i,t;
weakLearner(distribution,train,i_all,t_all,label_matrix,train_max_words_doc,train_max_docs,step, &i, &t,cycles,j,ave_delta);
/*if (com_pro.show_compute_1)
{
sprintf(temstr,"i: %.d\n",i);
printm(temstr);
}
if (com_pro.show_compute_1)
{
sprintf(temstr,"t: %.d\n",t);
printm(temstr);
}*/
/*****************************************************/
/* error(j)=distribution*abs(label-(train(:,i)>=t)); */
/*****************************************************/
// train(:,i)>=t)
train_error_part->specificPartOfMatrix(*train,step,i);
Matrix train_error = (*train_error_part)>t;
// (label-(train(:,i)>=t))
//Matrix error_label_train = (label_matrix)-(train_error);
error_label_train->matrixMinusMatrix(train_error,label_matrix);
// abs(label-(train(:,i)>=t))
error_abs_label_train->matrixAbs(*error_label_train);
// distribution*abs(label-(train(:,i)>=t))
Matrix error_tmp = (*distribution)*(*error_abs_label_train);
//error(j)=distribution*abs(label-(train(:,i)>=t));
error->copy(j-1,error_tmp);
/**********************************/
/* beta(j)=error(j)/(1-error(j)); */
/**********************************/
double k = 1;
scalar_minus_error->ScalarMinusMatrix(k,*error);
Matrix beta = (*error) / (*scalar_minus_error);
/*******************************/
/* boosted(j,:)=[beta(j),i,t]; */
/*******************************/
boost->copyToMatrix(j,beta);
iii->setValue(j,i);
ttt->setValue(j,t);
getArrayboost->matrixToArray(Array_boost,*boost);
getArrayiii->matrixToArray(Array_iii,*iii);
getArrayttt->matrixToArray(Array_ttt,*ttt);
/*********************************************************************************/
/* distribution=distribution.* exp(log(beta(j))*(1-abs(label-(train(:,i)>=t))))' */
/*********************************************************************************/
// (train(:,i)>=t)
train_error_part_1->specificPartOfMatrix(*train,step,i);
Matrix train_error_1 = (*train_error_part_1)>t;
// (label-(train(:,i)>=t))
//Matrix error_label_train_1 = (label_matrix)-(train_error_1);
error_label_train_1->matrixMinusMatrix(train_error_1,label_matrix);
// abs(label-(train(:,i)>=t))
error_abs_label_train_1->matrixAbs(*error_label_train_1);
// (1-abs(label-(train(:,i)>=t))))
scalar_minus_error_1->ScalarMinusMatrix(k,*error_abs_label_train_1);
// log(beta(j))
double y;
double val;
val_beta->getValue(j,&val,beta);
y = log(val);
// log(beta(j)) * (1-abs(label-(train(:,i)>=t))))
beta_label_train->ScalarMultiMatrix(y,*scalar_minus_error_1);
// exp(log(beta(j))*(1-abs(label-(train(:,i)>=t))))'
/*
int cycles_num=0;
if (step < 100){
cycles_num=20;
}
if (step >= 100){
cycles_num=100;
}
*/
expMatrix->matrixExp(*beta_label_train);
transposeExpMatrix->matrixTranspose(step,value_one,*expMatrix);
// distribution=distribution.* exp(log(beta(j))*(1-abs(label-(train(:,i)>=t))))';
distribution->MatrixMultiMatrix(*distribution,*transposeExpMatrix);
//distribution=distribution/sum(distribution);
double sum_distribution=0;
//double multi_step=0;
sumMatrix->matrixSumCol(&sum_distribution, *distribution);
distribution->matrixdDivisonScalar(sum_distribution,*distribution);
//multi_step= step / 100;
//distribution->MatrixMultiScalar(multi_step,*distribution);
//double distribution_value=0;
//Matrix *tmp = new Matrix(value_one,value_one);
//tmp->getValueSpecific(0,0,&distribution_value,*distribution);
/*if (com_pro.show_compute_1)
{
sprintf(temstr,"distribution value: %f\n",distribution_value);
printm(temstr);
}*/
//delete tmp;
}
// delete matrix
delete train_error_part;
delete error_label_train;
delete error_abs_label_train;
delete scalar_minus_error;
delete train_error_part_1;
delete error_label_train_1;
delete error_abs_label_train_1;
delete scalar_minus_error_1;
delete val_beta;
delete beta_label_train;
delete sumMatrix;
delete transposeExpMatrix;
delete expMatrix;
delete distribution;
delete error;
delete beta;
delete i_all;
delete t_all;
delete getArrayiii;
delete getArrayttt;
delete getArrayboost;
return(0);
}
/******************************************************************************************/
/* function [i,t] = weakLearner(distribution,train,label) */
/* %disp('run weakLearner'); */
/* for tt=1:(16*256-1) */
/* error(tt)=distribution*abs(label-(train(:,floor(tt/16)+1)>=16*(mod(tt,16)+1))); */
/* end */
/* [val,tt]=max(abs(error-0.5)); */
/* i=floor(tt/16)+1; */
/* t=16*(mod(tt,16)+1); */
/******************************************************************************************/
int weakLearner(Matrix* distribution,
Matrix* train,
Matrix* i_all,
Matrix* t_all,
Matrix label_matrix,
long train_max_words_doc,
long train_max_docs,
int step,
int *i,
int *t,
int cycles,
int j,
double ave_delta)
{
/*if (com_pro.show_action)
// printm("run weakLearner %d\n times, j");
if (com_pro.show_compute_1)
{
sprintf(temstr,"run weakLearn %.d\n times",j);
printm(temstr);
}*/
int r_train=train_max_docs+1;
int c_train=train_max_words_doc;
float sqrt_c_train_tmp=sqrt(c_train);
int sqrt_c_train = floor(sqrt_c_train_tmp);
int value_one = 1;
int modulus_number=0;
int floor_number=1;
int sizeOfsqrt_c_train=2*sqrt_c_train*(c_train- 1);
// double val_error;
int counter=1;
if (step < 100){
step=r_train;
}
// New temporary matrix's
Matrix* error = new Matrix(value_one,sizeOfsqrt_c_train);
Matrix* error_max = new Matrix(value_one,sizeOfsqrt_c_train);
//Matrix* matrix_val_error = new Matrix(value_one,value_one);
Matrix* get_i_all = new Matrix(step,value_one);
Matrix* get_t_all = new Matrix(step,value_one);
Matrix* Ava_data_matrix = new Matrix(step,c_train-1);
for (int tt=0; tt < 12*(c_train - 1); tt++)
{
Matrix* train_error_part = new Matrix(step,2);
Matrix* error_abs_label_train = new Matrix(step,2);
/***********************************************************************************/
/* error(tt)=distribution*abs(label-(train(:,floor(tt/16)+1)>=16*(mod(tt,16)+1))); */
/***********************************************************************************/
//16*(mod(tt,sqrt(c_train))+1)
//sqrt_c_train
modulus_number = 69 + (5 * (tt % 12)+1);
//floor(tt/sqrt(c_train))+1
floor_number=floor(tt / 11) + 1;
if (step < 100)
{
step=r_train;
}
train_error_part->specificPartOfMatrix(*train,step,floor_number-1);
// (train(:,floor(tt/16)+1)>=16*(mod(tt,16)+1))
Matrix train_error = (*train_error_part)>modulus_number;
// label-(train(:,floor(tt/16)+1)>=16*(mod(tt,16)+1))
Matrix error_label_train = (label_matrix)-(train_error);
// abs(label-(train(:,floor(tt/16)+1)>=16*(mod(tt,16)+1)))
error_abs_label_train->matrixAbs(error_label_train);
//error(tt)=distribution*abs(label-(train(:,floor(tt/16)+1)>=16*(mod(tt,16)+1)));
Matrix error_tmp = (*distribution)*(*error_abs_label_train);
error->copy(tt,error_tmp);
//free matrix
delete train_error_part;
delete error_abs_label_train;
}
//double error_train_array[432];
//Matrix* getArrayTrain_error = new Matrix(432,value_one);
//getArrayTrain_error->matrixToArrayold(error_train_array,*error);
//matrix_val_error->getValueSpecific(0,0,&val_error,*error);
//[val,tt]=max(abs(error-0.5));
double val=0;
int index=0;
double parameter_05 = 0.5;
Matrix* errorMinusScalar = new Matrix(value_one,sizeOfsqrt_c_train);
errorMinusScalar->matrixMinusSclar(parameter_05,*error);
Matrix* errorAbsMinusScalar = new Matrix(value_one,sizeOfsqrt_c_train);
errorAbsMinusScalar->matrixAbs(*errorMinusScalar);
error_max->matrixMax(&val,&index,*errorAbsMinusScalar);
/************************/
/* i=floor(tt/16)+1; */
/* t=16*(mod(tt,16)+1); */
/************************/
if (index > 400 && index < 500 ){
(*i) = floor(index/17)+1;
if (*i >= (c_train-1)){
*i = (c_train-10);
}
(*t) = 12 * ((index % 12) + 1);
}
if (index > 300 && index < 400 ){
(*i) = floor(index/12)+1;
if (*i >= (c_train-1)){
*i = (c_train-10);
}
(*t) = 12 * ((index % 12) + 1);
}
if (index > 200 && index < 300){
(*i) = floor(index/7)+1;
if (*i >= (c_train-1)){
*i = (c_train-10);
}
(*t) = 12 * ((index % 12) + 1);
}
if (index > 100 && index < 200){
(*i) = floor(index/5)+1;
if (*i >= (c_train-1)){
*i = (c_train-10);
}
(*t) = 12 * ((index % 12) + 1);
}
if (index > 0 && index < 100){
(*i) = floor(index/2)+1;
if (*i >= (c_train-1)){
*i = (c_train-10);
}
(*t) = 12 * ((index % 12) + 1);
}
i_all->setValue(j,*i);
if (j > 2)
{
get_i_all->matrixCompareAndSet(i,c_train,*i_all);
}
t_all->setValue(j,*t);
if (j > 1)
{
get_t_all->matrixCompareAndSetfor_t(j,t,c_train,*t_all);
}
(*t) = (*t) + ave_delta;
delete error_max;
delete error;
delete Ava_data_matrix;
delete errorMinusScalar;
delete errorAbsMinusScalar;
delete get_i_all;
delete get_t_all;
return (0);
}
/*************************************************************************************/
/* function [errorTrain,errorTest]=getError(boost,train,train_label,test,test_label) */
/* disp('run getError'); */
/* d=size(boost); */
/* num=size(train); */
/* prediction=zeros(num(1),1); */
/* % geting the train error */
/* for h=1:d(1) */
/* prediction=prediction-log(boost(h,1))*(train(:,boost(h,2))>=boost(h,3)); */
/* end */
/* temp=-sum(log(boost(:,1)))/2; */
/* errorTrain=sum(abs((train_label>=5)-(prediction>=temp)))/num(1); */
/* prediction=zeros(1000,1); */
/* % geting the test error */
/* for h=1:d(1) */
/* prediction=prediction-log(boost(h,1))*(test(:,boost(h,2))>=boost(h,3)); */
/* end */
/* errorTest=sum(abs((test_label>=5)-(prediction>=temp)))/1000; */
/*************************************************************************************/
int getError(Matrix* boost,
Matrix* iii,
Matrix* ttt,
Matrix* train_matrix,
Matrix* train_label_matrix,
Matrix* test_matrix,
Matrix* test_label_matrix,
Matrix* errorTrain,
Matrix* errorTest,
long train_max_words_doc,
long train_max_docs,
int step,
int cycles)
{
if (com_pro.show_action)
printm("run getError");
double value_one = 1;
double value_two = 2;
// d=size(boost);
int boost_row;
int boost_col;
Matrix* size = new Matrix(step,step);
size->matrixSize(&boost_row,&boost_col,*boost);
// num=size(train_matrix);
int train_row;
int train_col;
size->matrixSize(&train_row,&train_col,*train_matrix);
// num=size(test_matrix);
int test_row;
int test_col;
size->matrixSize(&test_row,&test_col,*test_matrix);
if (step < 100){
step=train_row;
}
// prediction=zeros(num(1),1);
Matrix* prediction_train = new Matrix(step,value_one+1);
delete(size);
// geting the train error
/*****************************************************************************/
/* for h=1:d(1) */
/* prediction=prediction-log(boost(h,1))*(train(:,boost(h,2))>=boost(h,3)) */
/* end */
/*****************************************************************************/
//for (int h=1; h <= boost_row; h++){
for (int h=1; h < boost_row; h++){
//boost(h,3)
double val_ttt=0;
Matrix* matrix_val_ttt = new Matrix(h,value_one);
matrix_val_ttt->getValueSpecific(h-1,0,&val_ttt,*ttt);
// boost(h,2)
double val_iii=0;
matrix_val_ttt->getValueSpecific(h-1,0,&val_iii,*iii);
// train(:,boost(h,2))
Matrix* partOfTrainMatrix = new Matrix(step,val_iii);
partOfTrainMatrix->specificPartOfMatrix(*train_matrix,step,val_iii);
// (train(:,boost(h,2))>=boost(h,3))
Matrix train_error_boost = (*partOfTrainMatrix) > val_ttt;
// (boost(h,1))
double val_boost=0;
matrix_val_ttt->getValueSpecific(h-1,0,&val_boost,*boost);
// log(boost(h,1))
double log_val_boost = log(val_boost);
// log(boost(h,1))*(train(:,boost(h,2))>=boost(h,3))
Matrix* boostMultiTrain = new Matrix(step, value_one+1);
boostMultiTrain->ScalarMultiMatrix(log_val_boost,train_error_boost);
// prediction-log(boost(h,1))*(train(:,boost(h,2))>=boost(h,3))
prediction_train->matrixMinusMatrix(*boostMultiTrain,*prediction_train);
//prediction_train->matrixMinusMatrix(*prediction_train,*boostMultiTrain);
//free matrix
delete matrix_val_ttt;
delete partOfTrainMatrix;
delete boostMultiTrain;
}
// double prediction_array[500];
// Matrix* getPredictionArray = new Matrix(step,value_one);
// getPredictionArray->matrixToArray(prediction_array,*prediction_train);
/*********************************/
/* temp=-sum(log(boost(:,1)))/2; */
/*********************************/
// log(boost(:,1))
Matrix* log_boost = new Matrix(boost_row,boost_col);
log_boost->matrixLog(*boost);
// sum(log(boost(:,1)))
double sum_log_boost = 0;
Matrix* sum_log_boost_matrix = new Matrix(boost_row,boost_col);
sum_log_boost_matrix->matrixSumRow(&sum_log_boost,*log_boost);
double temp = 0;
temp = -1 * (sum_log_boost/2);
//temp = -1*(sum_log_boost/5);
/********************************************************************/
/* errorTrain=sum(abs((train_label>=5)-(prediction>=temp)))/num(1); */
/********************************************************************/
// (prediction>=temp)
Matrix prediction_biger_temp = (*prediction_train) > temp;
// (train_label>=5)
Matrix *train_label = new Matrix(step,boost_col+1);
train_label->partOfMatrix(step,boost_col,*train_label_matrix);
Matrix train_label_biger_value = (*train_label) > 3;
// ((train_label>=5)-(prediction>=temp))
Matrix* train_label_minus_prediction = new Matrix(step,boost_col+1);
train_label_minus_prediction->matrixMinusMatrix(prediction_biger_temp,train_label_biger_value);
// abs((train_label>=5)-(prediction>=temp))
Matrix* abs_train_label_minus_prediction = new Matrix(step,boost_col+1);
abs_train_label_minus_prediction->matrixAbs(*train_label_minus_prediction);
// sum(abs((train_label>=5)-(prediction>=temp)))
double sum_abs_train_label_minus_prediction = 0;
Matrix* sum_abs_train_label_minus_prediction_matrix = new Matrix(step,boost_col+1);
sum_abs_train_label_minus_prediction_matrix->matrixSumRow(&sum_abs_train_label_minus_prediction,*abs_train_label_minus_prediction);
// errorTrain=sum(abs((train_label>=5)-(prediction>=temp)))/num(1)
errorTrain->scalarDivisonScalar(sum_abs_train_label_minus_prediction,step, *errorTrain);
prediction_train->zeros(step,value_one);
/*****************************/
/* prediction=zeros(1000,1); */
/*****************************/
Matrix* prediction_test = new Matrix(step,value_one+1);
if (step < 100){
step=test_row;
}
// geting the test error
/******************************************************************************/
/* for h=1:d(1) */
/* prediction=prediction-log(boost(h,1))*(test(:,boost(h,2))>=boost(h,3)); */
/* end */
/******************************************************************************/
for (int hh=1; hh < boost_row; hh++){
//boost(h,3)
// test(:,boost(h,2))
double val_ttt=0;
Matrix* matrix_val_ttt = new Matrix(hh,value_one);
matrix_val_ttt->getValueSpecific(hh-1,0,&val_ttt,*ttt);
// boost(h,2)
double val_iii=0;
matrix_val_ttt->getValueSpecific(hh-1,0,&val_iii,*iii);
Matrix* partOfTestMatrix = new Matrix(step,val_iii);
partOfTestMatrix->specificPartOfMatrix(*test_matrix,step,val_iii);
// (test(:,boost(h,2))>=boost(h,3))
Matrix test_error_boost = (*partOfTestMatrix) > val_ttt;
// (boost(h,1))
double val_boost=0;
matrix_val_ttt->getValueSpecific(hh-1,0,&val_boost,*boost);
// log(boost(h,1))
double log_val_boost = log(val_boost);
// log(boost(h,1))*(train(:,boost(h,2))>=boost(h,3))
Matrix* boostMultiTest = new Matrix(step,value_one+1);
boostMultiTest->ScalarMultiMatrix(log_val_boost,test_error_boost);
// prediction-log(boost(h,1))*(train(:,boost(h,2))>=boost(h,3))
prediction_test->matrixMinusMatrix(*boostMultiTest,*prediction_test);
//prediction_test->matrixMinusMatrix(*prediction_test,*boostMultiTest);
delete matrix_val_ttt;
delete partOfTestMatrix;
delete boostMultiTest;
}
//double predictionTest_array[500];
//Matrix* getPredictionTestArray = new Matrix(step,value_one);
//getPredictionTestArray->matrixToArray(predictionTest_array,*prediction_test);
/****************************************************************/
/* errorTest=sum(abs((test_label>=5)-(prediction>=temp)))/1000; */
/****************************************************************/
// (prediction>=temp)
Matrix prediction_biger_temp_test = (*prediction_test) > temp;
// (train_label>=5)
Matrix *test_label = new Matrix(step,boost_col+1);
test_label->partOfMatrix(step,boost_col,*test_label_matrix);
Matrix test_label_biger_value = (*test_label) > 3;
// ((train_label>=5)-(prediction>=temp))
Matrix* test_label_minus_prediction = new Matrix(step,boost_col+1);
test_label_minus_prediction->matrixMinusMatrix(prediction_biger_temp_test,test_label_biger_value);
// abs((train_label>=5)-(prediction>=temp))
Matrix* abs_test_label_minus_prediction = new Matrix(step,boost_col+1);
abs_test_label_minus_prediction->matrixAbs(*test_label_minus_prediction);
// sum(abs((train_label>=5)-(prediction>=temp)))
double sum_abs_test_label_minus_prediction = 0;
Matrix* sum_abs_test_label_minus_prediction_matrix = new Matrix(step,boost_col+1);
sum_abs_test_label_minus_prediction_matrix->matrixSumRow(&sum_abs_test_label_minus_prediction,*abs_test_label_minus_prediction);
// errorTrain=sum(abs((train_label>=5)-(prediction>=temp)))/num(1)
errorTest->scalarDivisonScalar(sum_abs_test_label_minus_prediction,test_row, *errorTest);
prediction_test->zeros(step,value_one);
//delete Matrix
delete prediction_train;
delete prediction_test;
delete train_label;
delete test_label;
delete log_boost;
delete sum_log_boost_matrix;
delete train_label_minus_prediction;
delete test_label_minus_prediction;
delete abs_train_label_minus_prediction;
delete abs_test_label_minus_prediction;
delete sum_abs_train_label_minus_prediction_matrix;
delete sum_abs_test_label_minus_prediction_matrix;
return (0);
}
/* grep through file and count number of lines, maximum number of spaces per line, and */
/* longest line. */
int nol_ll(char *file,long *nol,long *wol,long *ll)
{
FILE *fl;
int ic;
char c;
long current_length,current_wol;
if ((fl = fopen (file, "r")) == NULL)
{
printe (file);
return -1;
}
current_length=0;
current_wol=0;
(*ll)=0;
(*nol)=1;
(*wol)=0;
while((ic=getc(fl)) != EOF)
{
c=(char)ic;
current_length++;
if(c == ' ')
{
current_wol++;
}
if(c == '\n')
{
(*nol)++;
if(current_length>(*ll))
{
(*ll)=current_length;
}
if(current_wol>(*wol))
{
(*wol)=current_wol;
}
current_length=0;
current_wol=0;
}
}
fclose(fl);
}
long get_runtime()
{
clock_t start;
start = clock();
return((long)((double)start*100.0/(double)CLOCKS_PER_SEC));
}
int isnan(double a)
{
return(_isnan(a));
}
void * my_malloc(long size)
{
void *ptr;
ptr=(void *)malloc(size);
if(!ptr)
{
printe ("Out of memory!");
return (NULL);
}
return(ptr);
}
//print error on screen
void printe(char* str)
{
char err[200]="--error--";
strcat(err,str);
theApp.ShowM(err);
}
//print message on screen
void printm(char* str)
{
theApp.ShowM(str);
}
void SetInitParam()
{
com_param.biased_Hyperplane=1;
com_param.remove_inconsitant=0;
com_param.C =0.0;
com_param.cost_factor =1.0;
com_param.loo =0;
com_param.search_depth = 0;
com_param.rho = 1.0;
com_param.fraction =1.0;
com_param.rbf_gamma =1.0;
com_param.poly_c =0.0;
com_param.poly_s =1.0;
com_param.poly_degree =1;
com_param.kernel_type =0;
//com_param.user_u = pp4.m_strU ;
com_param.epsion =0.001;
com_param.iteration_time =100;
com_param.cache_size =40;
com_param.new_variable =com_param.maximum_size;
com_param.maximum_size =10;
com_param.final_test = 1;
com_param.blAadaboostresults=TRUE;
com_param.Running=FALSE;
com_param.Finished=TRUE;
com_param.Close=FALSE;
//prompt default values
com_pro.show_action=TRUE;
com_pro.show_compute_1=TRUE;
com_pro.show_compute_2=FALSE;
com_pro.show_compute_3=FALSE;
com_pro.show_other=FALSE;
com_pro.show_readfile=FALSE;
com_pro.show_writefile=FALSE;
com_pro.show_testresult=TRUE;
com_pro.show_trainresult=FALSE;
}
/******************** tmp code ****************************/
/*if (com_pro.show_compute_1)
{
sprintf(temstr,"index: %.d\n",index);
printm(temstr);
}
//i=floor(tt/16)+1;
if (index > 400 && index < 500 ){
(*i) = floor(index/17)+1;
if (*i == (c_train-1)){
*i = (c_train-10);
}
}
if (index > 300 && index < 400 ){
(*i) = floor(index/12)+1;
if (*i == (c_train-1)){
*i = (c_train-10);
}
}
if (index > 200 && index < 300){
(*i) = floor(index/7)+1;
if (*i == (c_train-1)){
*i = (c_train-10);
}
}
if (index > 100 && index < 200){
(*i) = floor(index/5)+1;
if (*i == (c_train-1)){
*i = (c_train-10);
}
}
if (index > 0 && index < 100){
(*i) = floor(index/2)+1;
if (*i == (c_train-1)){
*i = (c_train-10);
}
}
//Matrix* i_all = new Matrix(cycles,value_one);
i_all->setValue(j,*i);
if (j > 2)
{
get_i_all->matrixCompareAndSet(i,c_train,*i_all);
}
// Get the avarage of thr data
double Sum_ava_data=0;
Ava_data_matrix->matrixSumCol(&Sum_ava_data, *train);
(*t) = Sum_ava_data / (step * (c_train-2));
// if (step >= 300){
// (*t) = (*t) + 15;
// }
/*
//t=16*(mod(tt,16)+1);
//(*t) = sqrt_c_train * ((index % 16) + 1);
(*t) = 9 * ((index % 13) + 1);
t_all->setValue(j,*t);
if (j > 1)
{
get_t_all->matrixCompareAndSetfor_t(j,t,c_train,*t_all);
} */
/*
//(*i) = index;
// t=16*(mod(tt,4)+1);
int i_rand_tmp;
//int i_rand;
srand( (unsigned)time( NULL ) );
i_rand_tmp=rand();
if (i_rand_tmp > 100 && i_rand_tmp < 1000){
//i_rand=floor(i_rand_tmp/100)+1;
(*t)=floor(i_rand_tmp/10)+50;
if (*t < 75) {
(*t)=floor(i_rand_tmp/10)+70;
}
}
if (i_rand_tmp > 1000 && i_rand_tmp < 10000){
//i_rand=floor(i_rand_tmp/100)+1;
(*t)=floor(i_rand_tmp/100)+60;
if (*t > 105) {
(*t)=floor(i_rand_tmp/1000)+70;
}
if (*t < 75) {
(*t)=floor(i_rand_tmp/100)+70;
}
}
if (i_rand_tmp > 10000 && i_rand_tmp < 100000){
//i_rand=floor(i_rand_tmp/1000)+100;
(*t)=floor(i_rand_tmp/1000)+80;
if (*t > 105) {
(*t)=floor(i_rand_tmp/1000)+70;
}
}
if (*t < 75 ){
(*t) = (*t) + 10;
}
if (*t > 110) {
(*t)=(*t) - 10;
}
t_all->setValue(j,*t);
if (j > 1)
{
get_t_all->matrixCompareAndSetfor_t(j,t,c_train,*t_all);
}
(*t)=120;
*/
//(*t) = 3 * sqrt_c_train * ((index % sqrt_c_train) + 1);
//double error_train_array[443];
//Matrix* getArrayTrain_error = new Matrix(443,value_one);
//getArrayTrain_error->matrixToArrayold(error_train_array,*errorAbsMinusScalar);
/*
int parse_dataset(char *line,long *train_label,long*numwords,long train_max_words_doc)
{
register long wpos,pos;
//long wnum;
//double weight;
pos=0;
int len;
len = strlen(line);
len=len-2;
while(line[len])
{ // cut off comments
if(line[pos] == '#')
{
line[pos]=0;
}
else
{
pos++;
}
}
wpos=0;
if((sscanf(line,"%ld",train_label)) == EOF) return(0);
pos=0;
}
int read_documents(char *docfile,
DOC *docs,
long *label,
long max_words_doc,
long ll,
long *totwords,
long *totdoc)
{
char *line;
DOC doc;
long dnum=0,wpos,i,dpos=0,dneg=0,dunlab=0;
long doc_label;
FILE *docfl;
line = (char *)my_malloc(sizeof(char)*ll);
if ((docfl = fopen (docfile, "r")) == NULL)
{
printe (docfile);
return -1;
}
doc.words = (SVM_WORD *)my_malloc(sizeof(SVM_WORD)*(max_words_doc+10));
if (com_pro.show_readfile)
{
sprintf(temstr,"Reading examples into memory...");
printm(temstr);
}
dnum=0;
(*totwords)=0;
while((!feof(docfl)) && fgets(line,(int)ll,docfl)) {
if(line[0] == '#') continue; // line contains comments
if(!parse_document(line,&doc,&doc_label,&wpos,max_words_doc))
{
sprintf(temstr,"Parsing error in line %ld!",dnum);
printm(temstr);
}
label[dnum]=doc_label;
if(doc_label > 0) dpos++;
if (doc_label < 0) dneg++;
if (doc_label == 0) dunlab++;
if((wpos>1) && ((doc.words[wpos-2]).wnum>(*totwords)))
(*totwords)=(doc.words[wpos-2]).wnum;
docs[dnum].words = (SVM_WORD *)my_malloc(sizeof(SVM_WORD)*wpos);
docs[dnum].docnum=dnum;
for(i=0;i' ') pos++;
char sring_weight[5];
char NaN[5]="NaN";
int result;
while((sscanf(line+pos,"%ld:%lf",&wnum,&weight)!= EOF) && (wpos' ');
if(wnum<=0)
{
printe ("Feature numbers must be larger or equal to 1!!!");
sprintf(temstr,"LINE: %s",line);
printm(temstr);
return (0);
}
if((wpos>0) && ((doc->words[wpos-1]).wnum >= wnum))
{
printe ("Features must be in increasing order!!!");
sprintf(temstr,"LINE: %s",line);
printm(temstr);
return (0);
}
(doc->words[wpos]).wnum=wnum;
(doc->words[wpos]).weight=weight;
wpos++;
}
(doc->words[wpos]).wnum=0;
(*numwords)=wpos+1;
doc->docnum=-1;
//doc->twonorm_sq=sprod_ss(doc->words,doc->words);
return(1);
}
double Array_train[10];
double Array_test[10];
Matrix* getArrayTrain = new Matrix(10,one);
Matrix* getArrayTest = new Matrix(10,one);
getArrayTrain->matrixToArrayold(Array_train,*errorTrain_acc);
getArrayTest->matrixToArrayold(Array_test,*errorTest_acc);
*/