\r
// auxiliary functions\r
// 1. nbayes\r
-void nbayes_check_data( CvMLData* _data )
-{
- if( _data->get_missing() )
- CV_Error( CV_StsBadArg, "missing values are not supported" );
- const CvMat* var_types = _data->get_var_types();
- bool is_classifier = var_types->data.ptr[var_types->cols-1] == CV_VAR_CATEGORICAL;
+void nbayes_check_data( CvMLData* _data )\r
+{\r
+ if( _data->get_missing() )\r
+ CV_Error( CV_StsBadArg, "missing values are not supported" );\r
+ const CvMat* var_types = _data->get_var_types();\r
+ bool is_classifier = var_types->data.ptr[var_types->cols-1] == CV_VAR_CATEGORICAL;\r
if( ( fabs( cvNorm( var_types, 0, CV_L1 ) - \r
(var_types->rows + var_types->cols - 2)*CV_VAR_ORDERED - CV_VAR_CATEGORICAL ) > FLT_EPSILON ) ||\r
!is_classifier )\r
- CV_Error( CV_StsBadArg, "incorrect types of predictors or responses" );
-}
-bool nbayes_train( CvNormalBayesClassifier* nbayes, CvMLData* _data )
-{
+ CV_Error( CV_StsBadArg, "incorrect types of predictors or responses" );\r
+}\r
+bool nbayes_train( CvNormalBayesClassifier* nbayes, CvMLData* _data )\r
+{\r
nbayes_check_data( _data );\r
const CvMat* values = _data->get_values();\r
const CvMat* responses = _data->get_responses();\r
const CvMat* train_sidx = _data->get_train_sample_idx();\r
const CvMat* var_idx = _data->get_var_idx();\r
return nbayes->train( values, responses, var_idx, train_sidx );\r
-}
+}\r
float nbayes_calc_error( CvNormalBayesClassifier* nbayes, CvMLData* _data, int type, vector<float> *resp )\r
{\r
float err = 0;\r
nbayes_check_data( _data );\r
- const CvMat* values = _data->get_values();
- const CvMat* response = _data->get_responses();
+ const CvMat* values = _data->get_values();\r
+ const CvMat* response = _data->get_responses();\r
const CvMat* sample_idx = (type == CV_TEST_ERROR) ? _data->get_test_sample_idx() : _data->get_train_sample_idx();\r
int* sidx = sample_idx ? sample_idx->data.i : 0;\r
int r_step = CV_IS_MAT_CONT(response->type) ?\r
}\r
\r
// 2. knearest\r
-void knearest_check_data_and_get_predictors( CvMLData* _data, CvMat* _predictors )
-{
- const CvMat* values = _data->get_values();
- const CvMat* var_idx = _data->get_var_idx();
+void knearest_check_data_and_get_predictors( CvMLData* _data, CvMat* _predictors )\r
+{\r
+ const CvMat* values = _data->get_values();\r
+ const CvMat* var_idx = _data->get_var_idx();\r
if( var_idx->cols + var_idx->rows != values->cols )\r
CV_Error( CV_StsBadArg, "var_idx is not supported" );\r
if( _data->get_missing() )\r
cvGetCols( values, _predictors, 0, values->cols - 1 );\r
else\r
CV_Error( CV_StsBadArg, "responses must be in the first or last column; other cases are not supported" );\r
-}
-bool knearest_train( CvKNearest* knearest, CvMLData* _data )
-{
+}\r
+bool knearest_train( CvKNearest* knearest, CvMLData* _data )\r
+{\r
const CvMat* responses = _data->get_responses();\r
const CvMat* train_sidx = _data->get_train_sample_idx();\r
bool is_regression = _data->get_var_type( _data->get_response_idx() ) == CV_VAR_ORDERED;\r
CvMat predictors;\r
knearest_check_data_and_get_predictors( _data, &predictors );\r
- return knearest->train( &predictors, responses, train_sidx, is_regression );
-}
-float knearest_calc_error( CvKNearest* knearest, CvMLData* _data, int k, int type, vector<float> *resp )
-{
+ return knearest->train( &predictors, responses, train_sidx, is_regression );\r
+}\r
+float knearest_calc_error( CvKNearest* knearest, CvMLData* _data, int k, int type, vector<float> *resp )\r
+{\r
float err = 0;\r
const CvMat* response = _data->get_responses();\r
const CvMat* sample_idx = (type == CV_TEST_ERROR) ? _data->get_test_sample_idx() : _data->get_train_sample_idx();\r
}\r
err = sample_count ? err / (float)sample_count : -FLT_MAX; \r
}\r
- return err;
+ return err;\r
}\r
\r
// 3. svm\r
CV_Error( CV_StsBadArg, "incorrect svm type string" );\r
return -1;\r
}\r
-void svm_check_data( CvMLData* _data )
-{
- if( _data->get_missing() )
- CV_Error( CV_StsBadArg, "missing values are not supported" );
- const CvMat* var_types = _data->get_var_types();
- for( int i = 0; i < var_types->cols-1; i++ )
- if (var_types->data.ptr[i] == CV_VAR_CATEGORICAL)
- {
- char msg[50];
- sprintf( msg, "incorrect type of %d-predictor", i );
- CV_Error( CV_StsBadArg, msg );
- }
-}
-bool svm_train( CvSVM* svm, CvMLData* _data, CvSVMParams _params )
-{
- svm_check_data(_data);
- const CvMat* _train_data = _data->get_values();
- const CvMat* _responses = _data->get_responses();
- const CvMat* _var_idx = _data->get_var_idx();
- const CvMat* _sample_idx = _data->get_train_sample_idx();
- return svm->train( _train_data, _responses, _var_idx, _sample_idx, _params );
-}
-bool svm_train_auto( CvSVM* svm, CvMLData* _data, CvSVMParams _params,
- int k_fold, CvParamGrid C_grid, CvParamGrid gamma_grid,
- CvParamGrid p_grid, CvParamGrid nu_grid, CvParamGrid coef_grid,
- CvParamGrid degree_grid )
-{
- svm_check_data(_data);
- const CvMat* _train_data = _data->get_values();
- const CvMat* _responses = _data->get_responses();
- const CvMat* _var_idx = _data->get_var_idx();
- const CvMat* _sample_idx = _data->get_train_sample_idx();
- return svm->train_auto( _train_data, _responses, _var_idx,
- _sample_idx, _params, k_fold, C_grid, gamma_grid, p_grid, nu_grid, coef_grid, degree_grid );
-}
-float svm_calc_error( CvSVM* svm, CvMLData* _data, int type, vector<float> *resp )
-{
- svm_check_data(_data);
+void svm_check_data( CvMLData* _data )\r
+{\r
+ if( _data->get_missing() )\r
+ CV_Error( CV_StsBadArg, "missing values are not supported" );\r
+ const CvMat* var_types = _data->get_var_types();\r
+ for( int i = 0; i < var_types->cols-1; i++ )\r
+ if (var_types->data.ptr[i] == CV_VAR_CATEGORICAL)\r
+ {\r
+ char msg[50];\r
+ sprintf( msg, "incorrect type of %d-predictor", i );\r
+ CV_Error( CV_StsBadArg, msg );\r
+ }\r
+}\r
+bool svm_train( CvSVM* svm, CvMLData* _data, CvSVMParams _params )\r
+{\r
+ svm_check_data(_data);\r
+ const CvMat* _train_data = _data->get_values();\r
+ const CvMat* _responses = _data->get_responses();\r
+ const CvMat* _var_idx = _data->get_var_idx();\r
+ const CvMat* _sample_idx = _data->get_train_sample_idx();\r
+ return svm->train( _train_data, _responses, _var_idx, _sample_idx, _params );\r
+}\r
+bool svm_train_auto( CvSVM* svm, CvMLData* _data, CvSVMParams _params,\r
+ int k_fold, CvParamGrid C_grid, CvParamGrid gamma_grid,\r
+ CvParamGrid p_grid, CvParamGrid nu_grid, CvParamGrid coef_grid,\r
+ CvParamGrid degree_grid )\r
+{\r
+ svm_check_data(_data);\r
+ const CvMat* _train_data = _data->get_values();\r
+ const CvMat* _responses = _data->get_responses();\r
+ const CvMat* _var_idx = _data->get_var_idx();\r
+ const CvMat* _sample_idx = _data->get_train_sample_idx();\r
+ return svm->train_auto( _train_data, _responses, _var_idx, \r
+ _sample_idx, _params, k_fold, C_grid, gamma_grid, p_grid, nu_grid, coef_grid, degree_grid );\r
+}\r
+float svm_calc_error( CvSVM* svm, CvMLData* _data, int type, vector<float> *resp )\r
+{\r
+ svm_check_data(_data);\r
float err = 0;\r
const CvMat* values = _data->get_values();\r
const CvMat* response = _data->get_responses();\r
}\r
err = sample_count ? err / (float)sample_count : -FLT_MAX; \r
}\r
- return err;
+ return err;\r
}\r
\r
// 4. em\r
CV_Error( CV_StsBadArg, "incorrect ann train method string" );\r
return -1;\r
}\r
-void ann_check_data_and_get_predictors( CvMLData* _data, CvMat* _inputs )
-{
- const CvMat* values = _data->get_values();
- const CvMat* var_idx = _data->get_var_idx();
+void ann_check_data_and_get_predictors( CvMLData* _data, CvMat* _inputs )\r
+{\r
+ const CvMat* values = _data->get_values();\r
+ const CvMat* var_idx = _data->get_var_idx();\r
if( var_idx->cols + var_idx->rows != values->cols )\r
CV_Error( CV_StsBadArg, "var_idx is not supported" );\r
if( _data->get_missing() )\r
cvGetCols( values, _inputs, 0, values->cols - 1 );\r
else\r
CV_Error( CV_StsBadArg, "outputs must be in the first or last column; other cases are not supported" );\r
-}
-void ann_get_new_responses( CvMLData* _data, Mat& new_responses, map<int, int>& cls_map )
-{
- const CvMat* train_sidx = _data->get_train_sample_idx();
+}\r
+void ann_get_new_responses( CvMLData* _data, Mat& new_responses, map<int, int>& cls_map )\r
+{\r
+ const CvMat* train_sidx = _data->get_train_sample_idx();\r
int* train_sidx_ptr = train_sidx->data.i;\r
const CvMat* responses = _data->get_responses();\r
float* responses_ptr = responses->data.fl;\r
int r = cvRound(responses_ptr[sidx*r_step]);\r
int cidx = cls_map[r];\r
new_responses.ptr<float>(sidx)[cidx] = 1;\r
- }
-}
-int ann_train( CvANN_MLP* ann, CvMLData* _data, Mat& new_responses, CvANN_MLP_TrainParams _params, int flags = 0 )
-{
+ }\r
+}\r
+int ann_train( CvANN_MLP* ann, CvMLData* _data, Mat& new_responses, CvANN_MLP_TrainParams _params, int flags = 0 )\r
+{\r
const CvMat* train_sidx = _data->get_train_sample_idx();\r
CvMat predictors;\r
ann_check_data_and_get_predictors( _data, &predictors );\r
CvMat _new_responses = CvMat( new_responses );\r
- return ann->train( &predictors, &_new_responses, 0, train_sidx, _params, flags );
-}
-float ann_calc_error( CvANN_MLP* ann, CvMLData* _data, map<int, int>& cls_map, int type , vector<float> *resp_labels )
-{
+ return ann->train( &predictors, &_new_responses, 0, train_sidx, _params, flags );\r
+}\r
+float ann_calc_error( CvANN_MLP* ann, CvMLData* _data, map<int, int>& cls_map, int type , vector<float> *resp_labels )\r
+{\r
float err = 0;\r
const CvMat* responses = _data->get_responses();\r
const CvMat* sample_idx = (type == CV_TEST_ERROR) ? _data->get_test_sample_idx() : _data->get_train_sample_idx();\r
cvGetRow( &predictors, &sample, si ); \r
ann->predict( &sample, &_output );\r
CvPoint best_cls = {0,0};\r
- cvMinMaxLoc( &_output, 0, 0, 0, &best_cls, 0 );
- int r = cvRound(responses->data.fl[si*r_step]);
- CV_DbgAssert( fabs(responses->data.fl[si*r_step]-r) < FLT_EPSILON );
- r = cls_map[r];
- int d = best_cls.x == r ? 0 : 1;
+ cvMinMaxLoc( &_output, 0, 0, 0, &best_cls, 0 );\r
+ int r = cvRound(responses->data.fl[si*r_step]);\r
+ CV_DbgAssert( fabs(responses->data.fl[si*r_step]-r) < FLT_EPSILON );\r
+ r = cls_map[r];\r
+ int d = best_cls.x == r ? 0 : 1;\r
err += d;\r
pred_resp[i] = (float)best_cls.x;\r
}\r
err = sample_count ? err / (float)sample_count * 100 : -FLT_MAX;\r
- return err;
+ return err;\r
}\r
\r
// 6. dtree\r
\r
// ---------------------------------- MLBaseTest ---------------------------------------------------\r
\r
-CV_MLBaseTest::CV_MLBaseTest( const char* _modelName, const char* _testName, const char* _testFuncs ) :
-CvTest( _testName, _testFuncs )
-{
- modelName = _modelName;
+CV_MLBaseTest::CV_MLBaseTest( const char* _modelName, const char* _testName, const char* _testFuncs ) :\r
+CvTest( _testName, _testFuncs )\r
+{\r
+ int64 seeds[] = { 0x00009fff4f9c8d52,\r
+ 0x0000a17166072c7c,\r
+ 0x0201b32115cd1f9a,\r
+ 0x0513cb37abcd1234,\r
+ 0x0001a2b3c4d5f678\r
+ };\r
+\r
+ int seedCount = sizeof(seeds)/sizeof(seeds[0]);\r
+ RNG& rng = theRNG();\r
+\r
+ initSeed = rng.state;\r
+\r
+ rng.state = seeds[rng(seedCount)];\r
+\r
+ modelName = _modelName;\r
nbayes = 0;\r
knearest = 0;\r
svm = 0;\r
dtree = 0;\r
boost = 0;\r
rtrees = 0;\r
- ertrees = 0;
- if( !modelName.compare(CV_NBAYES) )
- nbayes = new CvNormalBayesClassifier;
- else if( !modelName.compare(CV_KNEAREST) )
- knearest = new CvKNearest;
- else if( !modelName.compare(CV_SVM) )
- svm = new CvSVM;
- else if( !modelName.compare(CV_EM) )
- em = new CvEM;
- else if( !modelName.compare(CV_ANN) )
- ann = new CvANN_MLP;
- else if( !modelName.compare(CV_DTREE) )
- dtree = new CvDTree;
- else if( !modelName.compare(CV_BOOST) )
- boost = new CvBoost;
- else if( !modelName.compare(CV_RTREES) )
- rtrees = new CvRTrees;
- else if( !modelName.compare(CV_ERTREES) )
- ertrees = new CvERTrees;
-}
+ ertrees = 0;\r
+ if( !modelName.compare(CV_NBAYES) )\r
+ nbayes = new CvNormalBayesClassifier;\r
+ else if( !modelName.compare(CV_KNEAREST) )\r
+ knearest = new CvKNearest;\r
+ else if( !modelName.compare(CV_SVM) )\r
+ svm = new CvSVM;\r
+ else if( !modelName.compare(CV_EM) )\r
+ em = new CvEM;\r
+ else if( !modelName.compare(CV_ANN) )\r
+ ann = new CvANN_MLP;\r
+ else if( !modelName.compare(CV_DTREE) )\r
+ dtree = new CvDTree;\r
+ else if( !modelName.compare(CV_BOOST) )\r
+ boost = new CvBoost;\r
+ else if( !modelName.compare(CV_RTREES) )\r
+ rtrees = new CvRTrees;\r
+ else if( !modelName.compare(CV_ERTREES) )\r
+ ertrees = new CvERTrees;\r
+}\r
\r
int CV_MLBaseTest::init( CvTS* system )\r
{\r
- clear();
- ts = system;
-
- string filename = ts->get_data_path();
- filename += get_validation_filename();
- validationFS.open( filename, FileStorage::READ );
+ clear();\r
+ ts = system;\r
+\r
+ string filename = ts->get_data_path();\r
+ filename += get_validation_filename();\r
+ validationFS.open( filename, FileStorage::READ );\r
return read_params( *validationFS );\r
}\r
\r
delete rtrees;\r
if( ertrees )\r
delete ertrees;\r
+ theRNG().state = initSeed;\r
}\r
\r
int CV_MLBaseTest::read_params( CvFileStorage* _fs )\r
return CvTS::OK;;\r
}\r
\r
-void CV_MLBaseTest::run( int start_from )
-{
- int code = CvTS::OK;
- start_from = 0;
- for (int i = 0; i < test_case_count; i++)
- {
- int temp_code = run_test_case( i );
- if (temp_code == CvTS::OK)
- temp_code = validate_test_results( i );
- if (temp_code != CvTS::OK)
- code = temp_code;
- }
- if ( test_case_count <= 0)
+void CV_MLBaseTest::run( int start_from )\r
+{\r
+ int code = CvTS::OK;\r
+ start_from = 0;\r
+ for (int i = 0; i < test_case_count; i++)\r
+ {\r
+ int temp_code = run_test_case( i );\r
+ if (temp_code == CvTS::OK)\r
+ temp_code = validate_test_results( i );\r
+ if (temp_code != CvTS::OK)\r
+ code = temp_code;\r
+ }\r
+ if ( test_case_count <= 0)\r
{\r
- ts->printf( CvTS::LOG, "validation file is not determined or not correct" );
+ ts->printf( CvTS::LOG, "validation file is not determined or not correct" );\r
code = CvTS::FAIL_INVALID_TEST_DATA;\r
- }
- ts->set_failed_test_info( code );
-}
-
-int CV_MLBaseTest::prepare_test_case( int test_case_idx )
-{
- int trainSampleCount, respIdx;
- string varTypes;
- clear();
-\r
- string dataPath = ts->get_data_path();
+ }\r
+ ts->set_failed_test_info( code );\r
+}\r
+\r
+int CV_MLBaseTest::prepare_test_case( int test_case_idx )\r
+{\r
+ int trainSampleCount, respIdx;\r
+ string varTypes;\r
+ clear();\r
+\r
+ string dataPath = ts->get_data_path();\r
if ( dataPath.empty() )\r
{\r
- ts->printf( CvTS::LOG, "data path is empty" );
+ ts->printf( CvTS::LOG, "data path is empty" );\r
return CvTS::FAIL_INVALID_TEST_DATA;\r
- }
-
- string dataName = dataSetNames[test_case_idx],
- filename = dataPath + dataName + ".data";
- if ( data.read_csv( filename.c_str() ) != 0)
+ }\r
+\r
+ string dataName = dataSetNames[test_case_idx],\r
+ filename = dataPath + dataName + ".data";\r
+ if ( data.read_csv( filename.c_str() ) != 0)\r
{\r
char msg[100];\r
sprintf( msg, "file %s can not be read", filename.c_str() );\r
- ts->printf( CvTS::LOG, msg );
+ ts->printf( CvTS::LOG, msg );\r
return CvTS::FAIL_INVALID_TEST_DATA;\r
- }
-
- FileNode dataParamsNode = validationFS.getFirstTopLevelNode()["validation"][modelName][dataName]["data_params"];
- CV_DbgAssert( !dataParamsNode.empty() );
-
- CV_DbgAssert( !dataParamsNode["LS"].empty() );
- dataParamsNode["LS"] >> trainSampleCount;
- CvTrainTestSplit spl( trainSampleCount );
- data.set_train_test_split( &spl );
-
- CV_DbgAssert( !dataParamsNode["resp_idx"].empty() );
- dataParamsNode["resp_idx"] >> respIdx;
- data.set_response_idx( respIdx );
-
- CV_DbgAssert( !dataParamsNode["types"].empty() );
- dataParamsNode["types"] >> varTypes;
- data.set_var_types( varTypes.c_str() );
-
- return CvTS::OK;
-}
-
-string& CV_MLBaseTest::get_validation_filename()
-{
- return validationFN;
-}
-
+ }\r
+\r
+ FileNode dataParamsNode = validationFS.getFirstTopLevelNode()["validation"][modelName][dataName]["data_params"];\r
+ CV_DbgAssert( !dataParamsNode.empty() );\r
+\r
+ CV_DbgAssert( !dataParamsNode["LS"].empty() );\r
+ dataParamsNode["LS"] >> trainSampleCount;\r
+ CvTrainTestSplit spl( trainSampleCount );\r
+ data.set_train_test_split( &spl );\r
+\r
+ CV_DbgAssert( !dataParamsNode["resp_idx"].empty() );\r
+ dataParamsNode["resp_idx"] >> respIdx;\r
+ data.set_response_idx( respIdx );\r
+\r
+ CV_DbgAssert( !dataParamsNode["types"].empty() );\r
+ dataParamsNode["types"] >> varTypes;\r
+ data.set_var_types( varTypes.c_str() );\r
+\r
+ return CvTS::OK;\r
+}\r
+\r
+string& CV_MLBaseTest::get_validation_filename()\r
+{\r
+ return validationFN;\r
+}\r
+\r
int CV_MLBaseTest::train( int testCaseIdx )\r
{\r
bool is_trained = false;\r
- FileNode modelParamsNode =
- validationFS.getFirstTopLevelNode()["validation"][modelName][dataSetNames[testCaseIdx]]["model_params"];
-\r
- if( !modelName.compare(CV_NBAYES) )
- is_trained = nbayes_train( nbayes, &data );
- else if( !modelName.compare(CV_KNEAREST) )
- {
- assert( 0 );
- //is_trained = knearest->train( &data );
- }
- else if( !modelName.compare(CV_SVM) )
- {
- string svm_type_str, kernel_type_str;
- modelParamsNode["svm_type"] >> svm_type_str;
- modelParamsNode["kernel_type"] >> kernel_type_str;
- CvSVMParams params;
- params.svm_type = str_to_svm_type( svm_type_str );
- params.kernel_type = str_to_svm_kernel_type( kernel_type_str );
- modelParamsNode["degree"] >> params.degree;
- modelParamsNode["gamma"] >> params.gamma;
- modelParamsNode["coef0"] >> params.coef0;
- modelParamsNode["C"] >> params.C;
- modelParamsNode["nu"] >> params.nu;
- modelParamsNode["p"] >> params.p;
- is_trained = svm_train( svm, &data, params );
- }
- else if( !modelName.compare(CV_EM) )
- {
- assert( 0 );
- }
- else if( !modelName.compare(CV_ANN) )
- {
- string train_method_str;
- double param1, param2;
- modelParamsNode["train_method"] >> train_method_str;
- modelParamsNode["param1"] >> param1;
- modelParamsNode["param2"] >> param2;
- Mat new_responses;
- ann_get_new_responses( &data, new_responses, cls_map );
- int layer_sz[] = { data.get_values()->cols - 1, 100, 100, (int)cls_map.size() };
- CvMat layer_sizes =
- cvMat( 1, (int)(sizeof(layer_sz)/sizeof(layer_sz[0])), CV_32S, layer_sz );
- ann->create( &layer_sizes );
- is_trained = ann_train( ann, &data, new_responses, CvANN_MLP_TrainParams(cvTermCriteria(CV_TERMCRIT_ITER,300,0.01),
- str_to_ann_train_method(train_method_str), param1, param2) ) >= 0;
- }
- else if( !modelName.compare(CV_DTREE) )
- {
+ FileNode modelParamsNode = \r
+ validationFS.getFirstTopLevelNode()["validation"][modelName][dataSetNames[testCaseIdx]]["model_params"];\r
+\r
+ if( !modelName.compare(CV_NBAYES) )\r
+ is_trained = nbayes_train( nbayes, &data );\r
+ else if( !modelName.compare(CV_KNEAREST) )\r
+ {\r
+ assert( 0 );\r
+ //is_trained = knearest->train( &data );\r
+ }\r
+ else if( !modelName.compare(CV_SVM) )\r
+ {\r
+ string svm_type_str, kernel_type_str;\r
+ modelParamsNode["svm_type"] >> svm_type_str;\r
+ modelParamsNode["kernel_type"] >> kernel_type_str;\r
+ CvSVMParams params;\r
+ params.svm_type = str_to_svm_type( svm_type_str );\r
+ params.kernel_type = str_to_svm_kernel_type( kernel_type_str );\r
+ modelParamsNode["degree"] >> params.degree;\r
+ modelParamsNode["gamma"] >> params.gamma;\r
+ modelParamsNode["coef0"] >> params.coef0;\r
+ modelParamsNode["C"] >> params.C;\r
+ modelParamsNode["nu"] >> params.nu;\r
+ modelParamsNode["p"] >> params.p;\r
+ is_trained = svm_train( svm, &data, params );\r
+ }\r
+ else if( !modelName.compare(CV_EM) )\r
+ {\r
+ assert( 0 );\r
+ }\r
+ else if( !modelName.compare(CV_ANN) )\r
+ {\r
+ string train_method_str;\r
+ double param1, param2;\r
+ modelParamsNode["train_method"] >> train_method_str;\r
+ modelParamsNode["param1"] >> param1;\r
+ modelParamsNode["param2"] >> param2;\r
+ Mat new_responses;\r
+ ann_get_new_responses( &data, new_responses, cls_map );\r
+ int layer_sz[] = { data.get_values()->cols - 1, 100, 100, (int)cls_map.size() };\r
+ CvMat layer_sizes =\r
+ cvMat( 1, (int)(sizeof(layer_sz)/sizeof(layer_sz[0])), CV_32S, layer_sz );\r
+ ann->create( &layer_sizes );\r
+ is_trained = ann_train( ann, &data, new_responses, CvANN_MLP_TrainParams(cvTermCriteria(CV_TERMCRIT_ITER,300,0.01),\r
+ str_to_ann_train_method(train_method_str), param1, param2) ) >= 0;\r
+ }\r
+ else if( !modelName.compare(CV_DTREE) )\r
+ {\r
int MAX_DEPTH, MIN_SAMPLE_COUNT, MAX_CATEGORIES, CV_FOLDS;\r
float REG_ACCURACY = 0;\r
- bool USE_SURROGATE, IS_PRUNED;
- modelParamsNode["max_depth"] >> MAX_DEPTH;
- modelParamsNode["min_sample_count"] >> MIN_SAMPLE_COUNT;
- modelParamsNode["use_surrogate"] >> USE_SURROGATE;
- modelParamsNode["max_categories"] >> MAX_CATEGORIES;
- modelParamsNode["cv_folds"] >> CV_FOLDS;
- modelParamsNode["is_pruned"] >> IS_PRUNED;
+ bool USE_SURROGATE, IS_PRUNED;\r
+ modelParamsNode["max_depth"] >> MAX_DEPTH;\r
+ modelParamsNode["min_sample_count"] >> MIN_SAMPLE_COUNT;\r
+ modelParamsNode["use_surrogate"] >> USE_SURROGATE;\r
+ modelParamsNode["max_categories"] >> MAX_CATEGORIES;\r
+ modelParamsNode["cv_folds"] >> CV_FOLDS;\r
+ modelParamsNode["is_pruned"] >> IS_PRUNED;\r
is_trained = dtree->train( &data, \r
CvDTreeParams(MAX_DEPTH, MIN_SAMPLE_COUNT, REG_ACCURACY, USE_SURROGATE,\r
MAX_CATEGORIES, CV_FOLDS, false, IS_PRUNED, 0 )) != 0;\r
- }
- else if( !modelName.compare(CV_BOOST) )
- {
+ }\r
+ else if( !modelName.compare(CV_BOOST) )\r
+ {\r
int BOOST_TYPE, WEAK_COUNT, MAX_DEPTH;\r
float WEIGHT_TRIM_RATE;\r
- bool USE_SURROGATE;
- string typeStr;
- modelParamsNode["type"] >> typeStr;
- BOOST_TYPE = str_to_boost_type( typeStr );
+ bool USE_SURROGATE;\r
+ string typeStr;\r
+ modelParamsNode["type"] >> typeStr;\r
+ BOOST_TYPE = str_to_boost_type( typeStr );\r
modelParamsNode["weak_count"] >> WEAK_COUNT;\r
modelParamsNode["weight_trim_rate"] >> WEIGHT_TRIM_RATE;\r
modelParamsNode["max_depth"] >> MAX_DEPTH;\r
modelParamsNode["use_surrogate"] >> USE_SURROGATE;\r
is_trained = boost->train( &data,\r
- CvBoostParams(BOOST_TYPE, WEAK_COUNT, WEIGHT_TRIM_RATE, MAX_DEPTH, USE_SURROGATE, 0) ) != 0;
- }
- else if( !modelName.compare(CV_RTREES) )
- {
+ CvBoostParams(BOOST_TYPE, WEAK_COUNT, WEIGHT_TRIM_RATE, MAX_DEPTH, USE_SURROGATE, 0) ) != 0;\r
+ }\r
+ else if( !modelName.compare(CV_RTREES) )\r
+ {\r
int MAX_DEPTH, MIN_SAMPLE_COUNT, MAX_CATEGORIES, CV_FOLDS, NACTIVE_VARS, MAX_TREES_NUM;\r
float REG_ACCURACY = 0, OOB_EPS = 0.0;\r
- bool USE_SURROGATE, IS_PRUNED;
- modelParamsNode["max_depth"] >> MAX_DEPTH;
- modelParamsNode["min_sample_count"] >> MIN_SAMPLE_COUNT;
- modelParamsNode["use_surrogate"] >> USE_SURROGATE;
- modelParamsNode["max_categories"] >> MAX_CATEGORIES;
- modelParamsNode["cv_folds"] >> CV_FOLDS;
- modelParamsNode["is_pruned"] >> IS_PRUNED;
- modelParamsNode["nactive_vars"] >> NACTIVE_VARS;
- modelParamsNode["max_trees_num"] >> MAX_TREES_NUM;
+ bool USE_SURROGATE, IS_PRUNED;\r
+ modelParamsNode["max_depth"] >> MAX_DEPTH;\r
+ modelParamsNode["min_sample_count"] >> MIN_SAMPLE_COUNT;\r
+ modelParamsNode["use_surrogate"] >> USE_SURROGATE;\r
+ modelParamsNode["max_categories"] >> MAX_CATEGORIES;\r
+ modelParamsNode["cv_folds"] >> CV_FOLDS;\r
+ modelParamsNode["is_pruned"] >> IS_PRUNED;\r
+ modelParamsNode["nactive_vars"] >> NACTIVE_VARS;\r
+ modelParamsNode["max_trees_num"] >> MAX_TREES_NUM;\r
is_trained = rtrees->train( &data, CvRTParams( MAX_DEPTH, MIN_SAMPLE_COUNT, REG_ACCURACY,\r
USE_SURROGATE, MAX_CATEGORIES, 0, true, // (calc_var_importance == true) <=> RF processes variable importance\r
- NACTIVE_VARS, MAX_TREES_NUM, OOB_EPS, CV_TERMCRIT_ITER)) != 0;
- }
- else if( !modelName.compare(CV_ERTREES) )
+ NACTIVE_VARS, MAX_TREES_NUM, OOB_EPS, CV_TERMCRIT_ITER)) != 0;\r
+ }\r
+ else if( !modelName.compare(CV_ERTREES) )\r
{\r
int MAX_DEPTH, MIN_SAMPLE_COUNT, MAX_CATEGORIES, CV_FOLDS, NACTIVE_VARS, MAX_TREES_NUM;\r
float REG_ACCURACY = 0, OOB_EPS = 0.0;\r
bool USE_SURROGATE, IS_PRUNED;\r
- modelParamsNode["max_depth"] >> MAX_DEPTH;
- modelParamsNode["min_sample_count"] >> MIN_SAMPLE_COUNT;
- modelParamsNode["use_surrogate"] >> USE_SURROGATE;
- modelParamsNode["max_categories"] >> MAX_CATEGORIES;
- modelParamsNode["cv_folds"] >> CV_FOLDS;
- modelParamsNode["is_pruned"] >> IS_PRUNED;
- modelParamsNode["nactive_vars"] >> NACTIVE_VARS;
- modelParamsNode["max_trees_num"] >> MAX_TREES_NUM;
+ modelParamsNode["max_depth"] >> MAX_DEPTH;\r
+ modelParamsNode["min_sample_count"] >> MIN_SAMPLE_COUNT;\r
+ modelParamsNode["use_surrogate"] >> USE_SURROGATE;\r
+ modelParamsNode["max_categories"] >> MAX_CATEGORIES;\r
+ modelParamsNode["cv_folds"] >> CV_FOLDS;\r
+ modelParamsNode["is_pruned"] >> IS_PRUNED;\r
+ modelParamsNode["nactive_vars"] >> NACTIVE_VARS;\r
+ modelParamsNode["max_trees_num"] >> MAX_TREES_NUM;\r
is_trained = ertrees->train( &data, CvRTParams( MAX_DEPTH, MIN_SAMPLE_COUNT, REG_ACCURACY,\r
USE_SURROGATE, MAX_CATEGORIES, 0, false, // (calc_var_importance == true) <=> RF processes variable importance\r
NACTIVE_VARS, MAX_TREES_NUM, OOB_EPS, CV_TERMCRIT_ITER)) != 0;\r
float CV_MLBaseTest::get_error( int testCaseIdx, int type, vector<float> *resp )\r
{\r
float err = 0;\r
- if( !modelName.compare(CV_NBAYES) )
- err = nbayes_calc_error( nbayes, &data, type, resp );
- else if( !modelName.compare(CV_KNEAREST) )
- {
- assert( 0 );
- testCaseIdx = 0;
- /*int k = 2;
- validationFS.getFirstTopLevelNode()["validation"][modelName][dataSetNames[testCaseIdx]]["model_params"]["k"] >> k;
- err = knearest->calc_error( &data, k, type, resp );*/
- }
- else if( !modelName.compare(CV_SVM) )
- err = svm_calc_error( svm, &data, type, resp );
- else if( !modelName.compare(CV_EM) )
- assert( 0 );
- else if( !modelName.compare(CV_ANN) )
- err = ann_calc_error( ann, &data, cls_map, type, resp );
- else if( !modelName.compare(CV_DTREE) )
- err = dtree->calc_error( &data, type, resp );
- else if( !modelName.compare(CV_BOOST) )
- err = boost->calc_error( &data, type, resp );
- else if( !modelName.compare(CV_RTREES) )
- err = rtrees->calc_error( &data, type, resp );
- else if( !modelName.compare(CV_ERTREES) )
+ if( !modelName.compare(CV_NBAYES) )\r
+ err = nbayes_calc_error( nbayes, &data, type, resp );\r
+ else if( !modelName.compare(CV_KNEAREST) )\r
+ {\r
+ assert( 0 );\r
+ testCaseIdx = 0;\r
+ /*int k = 2;\r
+ validationFS.getFirstTopLevelNode()["validation"][modelName][dataSetNames[testCaseIdx]]["model_params"]["k"] >> k;\r
+ err = knearest->calc_error( &data, k, type, resp );*/\r
+ }\r
+ else if( !modelName.compare(CV_SVM) )\r
+ err = svm_calc_error( svm, &data, type, resp );\r
+ else if( !modelName.compare(CV_EM) )\r
+ assert( 0 );\r
+ else if( !modelName.compare(CV_ANN) )\r
+ err = ann_calc_error( ann, &data, cls_map, type, resp );\r
+ else if( !modelName.compare(CV_DTREE) )\r
+ err = dtree->calc_error( &data, type, resp );\r
+ else if( !modelName.compare(CV_BOOST) )\r
+ err = boost->calc_error( &data, type, resp );\r
+ else if( !modelName.compare(CV_RTREES) )\r
+ err = rtrees->calc_error( &data, type, resp );\r
+ else if( !modelName.compare(CV_ERTREES) )\r
err = ertrees->calc_error( &data, type, resp );\r
return err;\r
}\r
\r
void CV_MLBaseTest::save( const char* filename )\r
{\r
- if( !modelName.compare(CV_NBAYES) )
- nbayes->save( filename );
- else if( !modelName.compare(CV_KNEAREST) )
- knearest->save( filename );
- else if( !modelName.compare(CV_SVM) )
- svm->save( filename );
- else if( !modelName.compare(CV_EM) )
- em->save( filename );
- else if( !modelName.compare(CV_ANN) )
- ann->save( filename );
- else if( !modelName.compare(CV_DTREE) )
- dtree->save( filename );
- else if( !modelName.compare(CV_BOOST) )
- boost->save( filename );
- else if( !modelName.compare(CV_RTREES) )
- rtrees->save( filename );
- else if( !modelName.compare(CV_ERTREES) )
+ if( !modelName.compare(CV_NBAYES) )\r
+ nbayes->save( filename );\r
+ else if( !modelName.compare(CV_KNEAREST) )\r
+ knearest->save( filename );\r
+ else if( !modelName.compare(CV_SVM) )\r
+ svm->save( filename );\r
+ else if( !modelName.compare(CV_EM) )\r
+ em->save( filename );\r
+ else if( !modelName.compare(CV_ANN) )\r
+ ann->save( filename );\r
+ else if( !modelName.compare(CV_DTREE) )\r
+ dtree->save( filename );\r
+ else if( !modelName.compare(CV_BOOST) )\r
+ boost->save( filename );\r
+ else if( !modelName.compare(CV_RTREES) )\r
+ rtrees->save( filename );\r
+ else if( !modelName.compare(CV_ERTREES) )\r
ertrees->save( filename );\r
}\r
\r
void CV_MLBaseTest::load( const char* filename )\r
{\r
- if( !modelName.compare(CV_NBAYES) )
- nbayes->load( filename );
- else if( !modelName.compare(CV_KNEAREST) )
- knearest->load( filename );
- else if( !modelName.compare(CV_SVM) )
- svm->load( filename );
- else if( !modelName.compare(CV_EM) )
- em->load( filename );
- else if( !modelName.compare(CV_ANN) )
- ann->load( filename );
- else if( !modelName.compare(CV_DTREE) )
- dtree->load( filename );
- else if( !modelName.compare(CV_BOOST) )
- boost->load( filename );
- else if( !modelName.compare(CV_RTREES) )
- rtrees->load( filename );
- else if( !modelName.compare(CV_ERTREES) )
+ if( !modelName.compare(CV_NBAYES) )\r
+ nbayes->load( filename );\r
+ else if( !modelName.compare(CV_KNEAREST) )\r
+ knearest->load( filename );\r
+ else if( !modelName.compare(CV_SVM) )\r
+ svm->load( filename );\r
+ else if( !modelName.compare(CV_EM) )\r
+ em->load( filename );\r
+ else if( !modelName.compare(CV_ANN) )\r
+ ann->load( filename );\r
+ else if( !modelName.compare(CV_DTREE) )\r
+ dtree->load( filename );\r
+ else if( !modelName.compare(CV_BOOST) )\r
+ boost->load( filename );\r
+ else if( !modelName.compare(CV_RTREES) )\r
+ rtrees->load( filename );\r
+ else if( !modelName.compare(CV_ERTREES) )\r
ertrees->load( filename );\r
}\r
\r
projects / profile / ivi / opencv.git / commitdiff