/*M/////////////////////////////////////////////////////////////////////////////////////// // // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. // // By downloading, copying, installing or using the software you agree to this license. // If you do not agree to this license, do not download, install, // copy or use the software. // // // Intel License Agreement // // Copyright (C) 2000, Intel Corporation, all rights reserved. // Third party copyrights are property of their respective owners. // // Redistribution and use in source and binary forms, with or without modification, // are permitted provided that the following conditions are met: // // * Redistribution's of source code must retain the above copyright notice, // this list of conditions and the following disclaimer. // // * Redistribution's in binary form must reproduce the above copyright notice, // this list of conditions and the following disclaimer in the documentation // and/or other materials provided with the distribution. // // * The name of Intel Corporation may not be used to endorse or promote products // derived from this software without specific prior written permission. // // This software is provided by the copyright holders and contributors "as is" and // any express or implied warranties, including, but not limited to, the implied // warranties of merchantability and fitness for a particular purpose are disclaimed. // In no event shall the Intel Corporation or contributors be liable for any direct, // indirect, incidental, special, exemplary, or consequential damages // (including, but not limited to, procurement of substitute goods or services; // loss of use, data, or profits; or business interruption) however caused // and on any theory of liability, whether in contract, strict liability, // or tort (including negligence or otherwise) arising in any way out of // the use of this software, even if advised of the possibility of such damage. // //M*/ #ifndef __ML_H__ #define __ML_H__ // disable deprecation warning which appears in VisualStudio 8.0 #if _MSC_VER >= 1400 #pragma warning( disable : 4996 ) #endif #ifndef SKIP_INCLUDES #include "cxcore.h" #include #if defined WIN32 || defined WIN64 #include #endif #else // SKIP_INCLUDES #if defined WIN32 || defined WIN64 #define CV_CDECL __cdecl #define CV_STDCALL __stdcall #else #define CV_CDECL #define CV_STDCALL #endif #ifndef CV_EXTERN_C #ifdef __cplusplus #define CV_EXTERN_C extern "C" #define CV_DEFAULT(val) = val #else #define CV_EXTERN_C #define CV_DEFAULT(val) #endif #endif #ifndef CV_EXTERN_C_FUNCPTR #ifdef __cplusplus #define CV_EXTERN_C_FUNCPTR(x) extern "C" { typedef x; } #else #define CV_EXTERN_C_FUNCPTR(x) typedef x #endif #endif #ifndef CV_INLINE #if defined __cplusplus #define CV_INLINE inline #elif (defined WIN32 || defined WIN64) && !defined __GNUC__ #define CV_INLINE __inline #else #define CV_INLINE static #endif #endif /* CV_INLINE */ #if (defined WIN32 || defined WIN64) && defined CVAPI_EXPORTS #define CV_EXPORTS __declspec(dllexport) #else #define CV_EXPORTS #endif #ifndef CVAPI #define CVAPI(rettype) CV_EXTERN_C CV_EXPORTS rettype CV_CDECL #endif #endif // SKIP_INCLUDES #ifdef __cplusplus // Apple defines a check() macro somewhere in the debug headers // that interferes with a method definiton in this header #undef check /****************************************************************************************\ * Main struct definitions * \****************************************************************************************/ /* log(2*PI) */ #define CV_LOG2PI (1.8378770664093454835606594728112) /* columns of matrix are training samples */ #define CV_COL_SAMPLE 0 /* rows of matrix are training samples */ #define CV_ROW_SAMPLE 1 #define CV_IS_ROW_SAMPLE(flags) ((flags) & CV_ROW_SAMPLE) struct CvVectors { int type; int dims, count; CvVectors* next; union { uchar** ptr; float** fl; double** db; } data; }; #if 0 /* A structure, representing the lattice range of statmodel parameters. It is used for optimizing statmodel parameters by cross-validation method. The lattice is logarithmic, so must be greater then 1. */ typedef struct CvParamLattice { double min_val; double max_val; double step; } CvParamLattice; CV_INLINE CvParamLattice cvParamLattice( double min_val, double max_val, double log_step ) { CvParamLattice pl; pl.min_val = MIN( min_val, max_val ); pl.max_val = MAX( min_val, max_val ); pl.step = MAX( log_step, 1. ); return pl; } CV_INLINE CvParamLattice cvDefaultParamLattice( void ) { CvParamLattice pl = {0,0,0}; return pl; } #endif /* Variable type */ #define CV_VAR_NUMERICAL 0 #define CV_VAR_ORDERED 0 #define CV_VAR_CATEGORICAL 1 #define CV_TYPE_NAME_ML_SVM "opencv-ml-svm" #define CV_TYPE_NAME_ML_KNN "opencv-ml-knn" #define CV_TYPE_NAME_ML_NBAYES "opencv-ml-bayesian" #define CV_TYPE_NAME_ML_EM "opencv-ml-em" #define CV_TYPE_NAME_ML_BOOSTING "opencv-ml-boost-tree" #define CV_TYPE_NAME_ML_TREE "opencv-ml-tree" #define CV_TYPE_NAME_ML_ANN_MLP "opencv-ml-ann-mlp" #define CV_TYPE_NAME_ML_CNN "opencv-ml-cnn" #define CV_TYPE_NAME_ML_RTREES "opencv-ml-random-trees" class CV_EXPORTS CvStatModel { public: CvStatModel(); virtual ~CvStatModel(); virtual void clear(); virtual void save( const char* filename, const char* name=0 ); virtual void load( const char* filename, const char* name=0 ); virtual void write( CvFileStorage* storage, const char* name ); virtual void read( CvFileStorage* storage, CvFileNode* node ); protected: const char* default_model_name; }; /****************************************************************************************\ * Normal Bayes Classifier * \****************************************************************************************/ /* The structure, representing the grid range of statmodel parameters. It is used for optimizing statmodel accuracy by varying model parameters, the accuracy estimate being computed by cross-validation. The grid is logarithmic, so must be greater then 1. */ struct CV_EXPORTS CvParamGrid { // SVM params type enum { SVM_C=0, SVM_GAMMA=1, SVM_P=2, SVM_NU=3, SVM_COEF=4, SVM_DEGREE=5 }; CvParamGrid() { min_val = max_val = step = 0; } CvParamGrid( double _min_val, double _max_val, double log_step ) { min_val = _min_val; max_val = _max_val; step = log_step; } //CvParamGrid( int param_id ); bool check() const; double min_val; double max_val; double step; }; class CV_EXPORTS CvNormalBayesClassifier : public CvStatModel { public: CvNormalBayesClassifier(); virtual ~CvNormalBayesClassifier(); CvNormalBayesClassifier( const CvMat* _train_data, const CvMat* _responses, const CvMat* _var_idx=0, const CvMat* _sample_idx=0 ); virtual bool train( const CvMat* _train_data, const CvMat* _responses, const CvMat* _var_idx = 0, const CvMat* _sample_idx=0, bool update=false ); virtual float predict( const CvMat* _samples, CvMat* results=0 ) const; virtual void clear(); virtual void write( CvFileStorage* storage, const char* name ); virtual void read( CvFileStorage* storage, CvFileNode* node ); protected: int var_count, var_all; CvMat* var_idx; CvMat* cls_labels; CvMat** count; CvMat** sum; CvMat** productsum; CvMat** avg; CvMat** inv_eigen_values; CvMat** cov_rotate_mats; CvMat* c; }; /****************************************************************************************\ * K-Nearest Neighbour Classifier * \****************************************************************************************/ // k Nearest Neighbors class CV_EXPORTS CvKNearest : public CvStatModel { public: CvKNearest(); virtual ~CvKNearest(); CvKNearest( const CvMat* _train_data, const CvMat* _responses, const CvMat* _sample_idx=0, bool _is_regression=false, int max_k=32 ); virtual bool train( const CvMat* _train_data, const CvMat* _responses, const CvMat* _sample_idx=0, bool is_regression=false, int _max_k=32, bool _update_base=false ); virtual float find_nearest( const CvMat* _samples, int k, CvMat* results=0, const float** neighbors=0, CvMat* neighbor_responses=0, CvMat* dist=0 ) const; virtual void clear(); int get_max_k() const; int get_var_count() const; int get_sample_count() const; bool is_regression() const; protected: virtual float write_results( int k, int k1, int start, int end, const float* neighbor_responses, const float* dist, CvMat* _results, CvMat* _neighbor_responses, CvMat* _dist, Cv32suf* sort_buf ) const; virtual void find_neighbors_direct( const CvMat* _samples, int k, int start, int end, float* neighbor_responses, const float** neighbors, float* dist ) const; int max_k, var_count; int total; bool regression; CvVectors* samples; }; /****************************************************************************************\ * Support Vector Machines * \****************************************************************************************/ // SVM training parameters struct CV_EXPORTS CvSVMParams { CvSVMParams(); CvSVMParams( int _svm_type, int _kernel_type, double _degree, double _gamma, double _coef0, double _C, double _nu, double _p, CvMat* _class_weights, CvTermCriteria _term_crit ); int svm_type; int kernel_type; double degree; // for poly double gamma; // for poly/rbf/sigmoid double coef0; // for poly/sigmoid double C; // for CV_SVM_C_SVC, CV_SVM_EPS_SVR and CV_SVM_NU_SVR double nu; // for CV_SVM_NU_SVC, CV_SVM_ONE_CLASS, and CV_SVM_NU_SVR double p; // for CV_SVM_EPS_SVR CvMat* class_weights; // for CV_SVM_C_SVC CvTermCriteria term_crit; // termination criteria }; struct CV_EXPORTS CvSVMKernel { typedef void (CvSVMKernel::*Calc)( int vec_count, int vec_size, const float** vecs, const float* another, float* results ); CvSVMKernel(); CvSVMKernel( const CvSVMParams* _params, Calc _calc_func ); virtual bool create( const CvSVMParams* _params, Calc _calc_func ); virtual ~CvSVMKernel(); virtual void clear(); virtual void calc( int vcount, int n, const float** vecs, const float* another, float* results ); const CvSVMParams* params; Calc calc_func; virtual void calc_non_rbf_base( int vec_count, int vec_size, const float** vecs, const float* another, float* results, double alpha, double beta ); virtual void calc_linear( int vec_count, int vec_size, const float** vecs, const float* another, float* results ); virtual void calc_rbf( int vec_count, int vec_size, const float** vecs, const float* another, float* results ); virtual void calc_poly( int vec_count, int vec_size, const float** vecs, const float* another, float* results ); virtual void calc_sigmoid( int vec_count, int vec_size, const float** vecs, const float* another, float* results ); }; struct CvSVMKernelRow { CvSVMKernelRow* prev; CvSVMKernelRow* next; float* data; }; struct CvSVMSolutionInfo { double obj; double rho; double upper_bound_p; double upper_bound_n; double r; // for Solver_NU }; class CV_EXPORTS CvSVMSolver { public: typedef bool (CvSVMSolver::*SelectWorkingSet)( int& i, int& j ); typedef float* (CvSVMSolver::*GetRow)( int i, float* row, float* dst, bool existed ); typedef void (CvSVMSolver::*CalcRho)( double& rho, double& r ); CvSVMSolver(); CvSVMSolver( int count, int var_count, const float** samples, schar* y, int alpha_count, double* alpha, double Cp, double Cn, CvMemStorage* storage, CvSVMKernel* kernel, GetRow get_row, SelectWorkingSet select_working_set, CalcRho calc_rho ); virtual bool create( int count, int var_count, const float** samples, schar* y, int alpha_count, double* alpha, double Cp, double Cn, CvMemStorage* storage, CvSVMKernel* kernel, GetRow get_row, SelectWorkingSet select_working_set, CalcRho calc_rho ); virtual ~CvSVMSolver(); virtual void clear(); virtual bool solve_generic( CvSVMSolutionInfo& si ); virtual bool solve_c_svc( int count, int var_count, const float** samples, schar* y, double Cp, double Cn, CvMemStorage* storage, CvSVMKernel* kernel, double* alpha, CvSVMSolutionInfo& si ); virtual bool solve_nu_svc( int count, int var_count, const float** samples, schar* y, CvMemStorage* storage, CvSVMKernel* kernel, double* alpha, CvSVMSolutionInfo& si ); virtual bool solve_one_class( int count, int var_count, const float** samples, CvMemStorage* storage, CvSVMKernel* kernel, double* alpha, CvSVMSolutionInfo& si ); virtual bool solve_eps_svr( int count, int var_count, const float** samples, const float* y, CvMemStorage* storage, CvSVMKernel* kernel, double* alpha, CvSVMSolutionInfo& si ); virtual bool solve_nu_svr( int count, int var_count, const float** samples, const float* y, CvMemStorage* storage, CvSVMKernel* kernel, double* alpha, CvSVMSolutionInfo& si ); virtual float* get_row_base( int i, bool* _existed ); virtual float* get_row( int i, float* dst ); int sample_count; int var_count; int cache_size; int cache_line_size; const float** samples; const CvSVMParams* params; CvMemStorage* storage; CvSVMKernelRow lru_list; CvSVMKernelRow* rows; int alpha_count; double* G; double* alpha; // -1 - lower bound, 0 - free, 1 - upper bound schar* alpha_status; schar* y; double* b; float* buf[2]; double eps; int max_iter; double C[2]; // C[0] == Cn, C[1] == Cp CvSVMKernel* kernel; SelectWorkingSet select_working_set_func; CalcRho calc_rho_func; GetRow get_row_func; virtual bool select_working_set( int& i, int& j ); virtual bool select_working_set_nu_svm( int& i, int& j ); virtual void calc_rho( double& rho, double& r ); virtual void calc_rho_nu_svm( double& rho, double& r ); virtual float* get_row_svc( int i, float* row, float* dst, bool existed ); virtual float* get_row_one_class( int i, float* row, float* dst, bool existed ); virtual float* get_row_svr( int i, float* row, float* dst, bool existed ); }; struct CvSVMDecisionFunc { double rho; int sv_count; double* alpha; int* sv_index; }; // SVM model class CV_EXPORTS CvSVM : public CvStatModel { public: // SVM type enum { C_SVC=100, NU_SVC=101, ONE_CLASS=102, EPS_SVR=103, NU_SVR=104 }; // SVM kernel type enum { LINEAR=0, POLY=1, RBF=2, SIGMOID=3 }; // SVM params type enum { C=0, GAMMA=1, P=2, NU=3, COEF=4, DEGREE=5 }; CvSVM(); virtual ~CvSVM(); CvSVM( const CvMat* _train_data, const CvMat* _responses, const CvMat* _var_idx=0, const CvMat* _sample_idx=0, CvSVMParams _params=CvSVMParams() ); virtual bool train( const CvMat* _train_data, const CvMat* _responses, const CvMat* _var_idx=0, const CvMat* _sample_idx=0, CvSVMParams _params=CvSVMParams() ); virtual bool train_auto( const CvMat* _train_data, const CvMat* _responses, const CvMat* _var_idx, const CvMat* _sample_idx, CvSVMParams _params, int k_fold = 10, CvParamGrid C_grid = get_default_grid(CvSVM::C), CvParamGrid gamma_grid = get_default_grid(CvSVM::GAMMA), CvParamGrid p_grid = get_default_grid(CvSVM::P), CvParamGrid nu_grid = get_default_grid(CvSVM::NU), CvParamGrid coef_grid = get_default_grid(CvSVM::COEF), CvParamGrid degree_grid = get_default_grid(CvSVM::DEGREE) ); virtual float predict( const CvMat* _sample ) const; virtual int get_support_vector_count() const; virtual const float* get_support_vector(int i) const; virtual CvSVMParams get_params() const { return params; }; virtual void clear(); static CvParamGrid get_default_grid( int param_id ); virtual void write( CvFileStorage* storage, const char* name ); virtual void read( CvFileStorage* storage, CvFileNode* node ); int get_var_count() const { return var_idx ? var_idx->cols : var_all; } protected: virtual bool set_params( const CvSVMParams& _params ); virtual bool train1( int sample_count, int var_count, const float** samples, const void* _responses, double Cp, double Cn, CvMemStorage* _storage, double* alpha, double& rho ); virtual bool do_train( int svm_type, int sample_count, int var_count, const float** samples, const CvMat* _responses, CvMemStorage* _storage, double* alpha ); virtual void create_kernel(); virtual void create_solver(); virtual void write_params( CvFileStorage* fs ); virtual void read_params( CvFileStorage* fs, CvFileNode* node ); CvSVMParams params; CvMat* class_labels; int var_all; float** sv; int sv_total; CvMat* var_idx; CvMat* class_weights; CvSVMDecisionFunc* decision_func; CvMemStorage* storage; CvSVMSolver* solver; CvSVMKernel* kernel; }; /****************************************************************************************\ * Expectation - Maximization * \****************************************************************************************/ struct CV_EXPORTS CvEMParams { CvEMParams() : nclusters(10), cov_mat_type(1/*CvEM::COV_MAT_DIAGONAL*/), start_step(0/*CvEM::START_AUTO_STEP*/), probs(0), weights(0), means(0), covs(0) { term_crit=cvTermCriteria( CV_TERMCRIT_ITER+CV_TERMCRIT_EPS, 100, FLT_EPSILON ); } CvEMParams( int _nclusters, int _cov_mat_type=1/*CvEM::COV_MAT_DIAGONAL*/, int _start_step=0/*CvEM::START_AUTO_STEP*/, CvTermCriteria _term_crit=cvTermCriteria(CV_TERMCRIT_ITER+CV_TERMCRIT_EPS, 100, FLT_EPSILON), const CvMat* _probs=0, const CvMat* _weights=0, const CvMat* _means=0, const CvMat** _covs=0 ) : nclusters(_nclusters), cov_mat_type(_cov_mat_type), start_step(_start_step), probs(_probs), weights(_weights), means(_means), covs(_covs), term_crit(_term_crit) {} int nclusters; int cov_mat_type; int start_step; const CvMat* probs; const CvMat* weights; const CvMat* means; const CvMat** covs; CvTermCriteria term_crit; }; class CV_EXPORTS CvEM : public CvStatModel { public: // Type of covariation matrices enum { COV_MAT_SPHERICAL=0, COV_MAT_DIAGONAL=1, COV_MAT_GENERIC=2 }; // The initial step enum { START_E_STEP=1, START_M_STEP=2, START_AUTO_STEP=0 }; CvEM(); CvEM( const CvMat* samples, const CvMat* sample_idx=0, CvEMParams params=CvEMParams(), CvMat* labels=0 ); virtual ~CvEM(); virtual bool train( const CvMat* samples, const CvMat* sample_idx=0, CvEMParams params=CvEMParams(), CvMat* labels=0 ); virtual float predict( const CvMat* sample, CvMat* probs ) const; virtual void clear(); int get_nclusters() const; const CvMat* get_means() const; const CvMat** get_covs() const; const CvMat* get_weights() const; const CvMat* get_probs() const; inline double get_log_likelihood () const { return log_likelihood; }; protected: virtual void set_params( const CvEMParams& params, const CvVectors& train_data ); virtual void init_em( const CvVectors& train_data ); virtual double run_em( const CvVectors& train_data ); virtual void init_auto( const CvVectors& samples ); virtual void kmeans( const CvVectors& train_data, int nclusters, CvMat* labels, CvTermCriteria criteria, const CvMat* means ); CvEMParams params; double log_likelihood; CvMat* means; CvMat** covs; CvMat* weights; CvMat* probs; CvMat* log_weight_div_det; CvMat* inv_eigen_values; CvMat** cov_rotate_mats; }; /****************************************************************************************\ * Decision Tree * \****************************************************************************************/ struct CvPair32s32f { int i; float val; }; #define CV_DTREE_CAT_DIR(idx,subset) \ (2*((subset[(idx)>>5]&(1 << ((idx) & 31)))==0)-1) struct CvDTreeSplit { int var_idx; int inversed; float quality; CvDTreeSplit* next; union { int subset[2]; struct { float c; int split_point; } ord; }; }; struct CvDTreeNode { int class_idx; int Tn; double value; CvDTreeNode* parent; CvDTreeNode* left; CvDTreeNode* right; CvDTreeSplit* split; int sample_count; int depth; int* num_valid; int offset; int buf_idx; double maxlr; // global pruning data int complexity; double alpha; double node_risk, tree_risk, tree_error; // cross-validation pruning data int* cv_Tn; double* cv_node_risk; double* cv_node_error; int get_num_valid(int vi) { return num_valid ? num_valid[vi] : sample_count; } void set_num_valid(int vi, int n) { if( num_valid ) num_valid[vi] = n; } }; struct CV_EXPORTS CvDTreeParams { int max_categories; int max_depth; int min_sample_count; int cv_folds; bool use_surrogates; bool use_1se_rule; bool truncate_pruned_tree; float regression_accuracy; const float* priors; CvDTreeParams() : max_categories(10), max_depth(INT_MAX), min_sample_count(10), cv_folds(10), use_surrogates(true), use_1se_rule(true), truncate_pruned_tree(true), regression_accuracy(0.01f), priors(0) {} CvDTreeParams( int _max_depth, int _min_sample_count, float _regression_accuracy, bool _use_surrogates, int _max_categories, int _cv_folds, bool _use_1se_rule, bool _truncate_pruned_tree, const float* _priors ) : max_categories(_max_categories), max_depth(_max_depth), min_sample_count(_min_sample_count), cv_folds (_cv_folds), use_surrogates(_use_surrogates), use_1se_rule(_use_1se_rule), truncate_pruned_tree(_truncate_pruned_tree), regression_accuracy(_regression_accuracy), priors(_priors) {} }; struct CV_EXPORTS CvDTreeTrainData { CvDTreeTrainData(); CvDTreeTrainData( const CvMat* _train_data, int _tflag, const CvMat* _responses, const CvMat* _var_idx=0, const CvMat* _sample_idx=0, const CvMat* _var_type=0, const CvMat* _missing_mask=0, const CvDTreeParams& _params=CvDTreeParams(), bool _shared=false, bool _add_labels=false ); virtual ~CvDTreeTrainData(); virtual void set_data( const CvMat* _train_data, int _tflag, const CvMat* _responses, const CvMat* _var_idx=0, const CvMat* _sample_idx=0, const CvMat* _var_type=0, const CvMat* _missing_mask=0, const CvDTreeParams& _params=CvDTreeParams(), bool _shared=false, bool _add_labels=false, bool _update_data=false ); virtual void get_vectors( const CvMat* _subsample_idx, float* values, uchar* missing, float* responses, bool get_class_idx=false ); virtual CvDTreeNode* subsample_data( const CvMat* _subsample_idx ); virtual void write_params( CvFileStorage* fs ); virtual void read_params( CvFileStorage* fs, CvFileNode* node ); // release all the data virtual void clear(); int get_num_classes() const; int get_var_type(int vi) const; int get_work_var_count() const; virtual int* get_class_labels( CvDTreeNode* n ); virtual float* get_ord_responses( CvDTreeNode* n ); virtual int* get_labels( CvDTreeNode* n ); virtual int* get_cat_var_data( CvDTreeNode* n, int vi ); virtual CvPair32s32f* get_ord_var_data( CvDTreeNode* n, int vi ); virtual int get_child_buf_idx( CvDTreeNode* n ); //////////////////////////////////// virtual bool set_params( const CvDTreeParams& params ); virtual CvDTreeNode* new_node( CvDTreeNode* parent, int count, int storage_idx, int offset ); virtual CvDTreeSplit* new_split_ord( int vi, float cmp_val, int split_point, int inversed, float quality ); virtual CvDTreeSplit* new_split_cat( int vi, float quality ); virtual void free_node_data( CvDTreeNode* node ); virtual void free_train_data(); virtual void free_node( CvDTreeNode* node ); int sample_count, var_all, var_count, max_c_count; int ord_var_count, cat_var_count; bool have_labels, have_priors; bool is_classifier; int buf_count, buf_size; bool shared; CvMat* cat_count; CvMat* cat_ofs; CvMat* cat_map; CvMat* counts; CvMat* buf; CvMat* direction; CvMat* split_buf; CvMat* var_idx; CvMat* var_type; // i-th element = // k<0 - ordered // k>=0 - categorical, see k-th element of cat_* arrays CvMat* priors; CvMat* priors_mult; CvDTreeParams params; CvMemStorage* tree_storage; CvMemStorage* temp_storage; CvDTreeNode* data_root; CvSet* node_heap; CvSet* split_heap; CvSet* cv_heap; CvSet* nv_heap; CvRNG rng; }; class CV_EXPORTS CvDTree : public CvStatModel { public: CvDTree(); virtual ~CvDTree(); virtual bool train( const CvMat* _train_data, int _tflag, const CvMat* _responses, const CvMat* _var_idx=0, const CvMat* _sample_idx=0, const CvMat* _var_type=0, const CvMat* _missing_mask=0, CvDTreeParams params=CvDTreeParams() ); virtual bool train( CvDTreeTrainData* _train_data, const CvMat* _subsample_idx ); virtual CvDTreeNode* predict( const CvMat* _sample, const CvMat* _missing_data_mask=0, bool preprocessed_input=false ) const; virtual const CvMat* get_var_importance(); virtual void clear(); virtual void read( CvFileStorage* fs, CvFileNode* node ); virtual void write( CvFileStorage* fs, const char* name ); // special read & write methods for trees in the tree ensembles virtual void read( CvFileStorage* fs, CvFileNode* node, CvDTreeTrainData* data ); virtual void write( CvFileStorage* fs ); const CvDTreeNode* get_root() const; int get_pruned_tree_idx() const; CvDTreeTrainData* get_data(); protected: virtual bool do_train( const CvMat* _subsample_idx ); virtual void try_split_node( CvDTreeNode* n ); virtual void split_node_data( CvDTreeNode* n ); virtual CvDTreeSplit* find_best_split( CvDTreeNode* n ); virtual CvDTreeSplit* find_split_ord_class( CvDTreeNode* n, int vi ); virtual CvDTreeSplit* find_split_cat_class( CvDTreeNode* n, int vi ); virtual CvDTreeSplit* find_split_ord_reg( CvDTreeNode* n, int vi ); virtual CvDTreeSplit* find_split_cat_reg( CvDTreeNode* n, int vi ); virtual CvDTreeSplit* find_surrogate_split_ord( CvDTreeNode* n, int vi ); virtual CvDTreeSplit* find_surrogate_split_cat( CvDTreeNode* n, int vi ); virtual double calc_node_dir( CvDTreeNode* node ); virtual void complete_node_dir( CvDTreeNode* node ); virtual void cluster_categories( const int* vectors, int vector_count, int var_count, int* sums, int k, int* cluster_labels ); virtual void calc_node_value( CvDTreeNode* node ); virtual void prune_cv(); virtual double update_tree_rnc( int T, int fold ); virtual int cut_tree( int T, int fold, double min_alpha ); virtual void free_prune_data(bool cut_tree); virtual void free_tree(); virtual void write_node( CvFileStorage* fs, CvDTreeNode* node ); virtual void write_split( CvFileStorage* fs, CvDTreeSplit* split ); virtual CvDTreeNode* read_node( CvFileStorage* fs, CvFileNode* node, CvDTreeNode* parent ); virtual CvDTreeSplit* read_split( CvFileStorage* fs, CvFileNode* node ); virtual void write_tree_nodes( CvFileStorage* fs ); virtual void read_tree_nodes( CvFileStorage* fs, CvFileNode* node ); CvDTreeNode* root; int pruned_tree_idx; CvMat* var_importance; CvDTreeTrainData* data; }; /****************************************************************************************\ * Random Trees Classifier * \****************************************************************************************/ class CvRTrees; class CV_EXPORTS CvForestTree: public CvDTree { public: CvForestTree(); virtual ~CvForestTree(); virtual bool train( CvDTreeTrainData* _train_data, const CvMat* _subsample_idx, CvRTrees* forest ); virtual int get_var_count() const {return data ? data->var_count : 0;} virtual void read( CvFileStorage* fs, CvFileNode* node, CvRTrees* forest, CvDTreeTrainData* _data ); /* dummy methods to avoid warnings: BEGIN */ virtual bool train( const CvMat* _train_data, int _tflag, const CvMat* _responses, const CvMat* _var_idx=0, const CvMat* _sample_idx=0, const CvMat* _var_type=0, const CvMat* _missing_mask=0, CvDTreeParams params=CvDTreeParams() ); virtual bool train( CvDTreeTrainData* _train_data, const CvMat* _subsample_idx ); virtual void read( CvFileStorage* fs, CvFileNode* node ); virtual void read( CvFileStorage* fs, CvFileNode* node, CvDTreeTrainData* data ); /* dummy methods to avoid warnings: END */ protected: virtual CvDTreeSplit* find_best_split( CvDTreeNode* n ); CvRTrees* forest; }; struct CV_EXPORTS CvRTParams : public CvDTreeParams { //Parameters for the forest bool calc_var_importance; // true <=> RF processes variable importance int nactive_vars; CvTermCriteria term_crit; CvRTParams() : CvDTreeParams( 5, 10, 0, false, 10, 0, false, false, 0 ), calc_var_importance(false), nactive_vars(0) { term_crit = cvTermCriteria( CV_TERMCRIT_ITER+CV_TERMCRIT_EPS, 50, 0.1 ); } CvRTParams( int _max_depth, int _min_sample_count, float _regression_accuracy, bool _use_surrogates, int _max_categories, const float* _priors, bool _calc_var_importance, int _nactive_vars, int max_num_of_trees_in_the_forest, float forest_accuracy, int termcrit_type ) : CvDTreeParams( _max_depth, _min_sample_count, _regression_accuracy, _use_surrogates, _max_categories, 0, false, false, _priors ), calc_var_importance(_calc_var_importance), nactive_vars(_nactive_vars) { term_crit = cvTermCriteria(termcrit_type, max_num_of_trees_in_the_forest, forest_accuracy); } }; class CV_EXPORTS CvRTrees : public CvStatModel { public: CvRTrees(); virtual ~CvRTrees(); virtual bool train( const CvMat* _train_data, int _tflag, const CvMat* _responses, const CvMat* _var_idx=0, const CvMat* _sample_idx=0, const CvMat* _var_type=0, const CvMat* _missing_mask=0, CvRTParams params=CvRTParams() ); virtual float predict( const CvMat* sample, const CvMat* missing = 0 ) const; virtual void clear(); virtual const CvMat* get_var_importance(); virtual float get_proximity( const CvMat* sample1, const CvMat* sample2, const CvMat* missing1 = 0, const CvMat* missing2 = 0 ) const; virtual void read( CvFileStorage* fs, CvFileNode* node ); virtual void write( CvFileStorage* fs, const char* name ); CvMat* get_active_var_mask(); CvRNG* get_rng(); int get_tree_count() const; CvForestTree* get_tree(int i) const; protected: bool grow_forest( const CvTermCriteria term_crit ); // array of the trees of the forest CvForestTree** trees; CvDTreeTrainData* data; int ntrees; int nclasses; double oob_error; CvMat* var_importance; int nsamples; CvRNG rng; CvMat* active_var_mask; }; /****************************************************************************************\ * Boosted tree classifier * \****************************************************************************************/ struct CV_EXPORTS CvBoostParams : public CvDTreeParams { int boost_type; int weak_count; int split_criteria; double weight_trim_rate; CvBoostParams(); CvBoostParams( int boost_type, int weak_count, double weight_trim_rate, int max_depth, bool use_surrogates, const float* priors ); }; class CvBoost; class CV_EXPORTS CvBoostTree: public CvDTree { public: CvBoostTree(); virtual ~CvBoostTree(); virtual bool train( CvDTreeTrainData* _train_data, const CvMat* subsample_idx, CvBoost* ensemble ); virtual void scale( double s ); virtual void read( CvFileStorage* fs, CvFileNode* node, CvBoost* ensemble, CvDTreeTrainData* _data ); virtual void clear(); /* dummy methods to avoid warnings: BEGIN */ virtual bool train( const CvMat* _train_data, int _tflag, const CvMat* _responses, const CvMat* _var_idx=0, const CvMat* _sample_idx=0, const CvMat* _var_type=0, const CvMat* _missing_mask=0, CvDTreeParams params=CvDTreeParams() ); virtual bool train( CvDTreeTrainData* _train_data, const CvMat* _subsample_idx ); virtual void read( CvFileStorage* fs, CvFileNode* node ); virtual void read( CvFileStorage* fs, CvFileNode* node, CvDTreeTrainData* data ); /* dummy methods to avoid warnings: END */ protected: virtual void try_split_node( CvDTreeNode* n ); virtual CvDTreeSplit* find_surrogate_split_ord( CvDTreeNode* n, int vi ); virtual CvDTreeSplit* find_surrogate_split_cat( CvDTreeNode* n, int vi ); virtual CvDTreeSplit* find_split_ord_class( CvDTreeNode* n, int vi ); virtual CvDTreeSplit* find_split_cat_class( CvDTreeNode* n, int vi ); virtual CvDTreeSplit* find_split_ord_reg( CvDTreeNode* n, int vi ); virtual CvDTreeSplit* find_split_cat_reg( CvDTreeNode* n, int vi ); virtual void calc_node_value( CvDTreeNode* n ); virtual double calc_node_dir( CvDTreeNode* n ); CvBoost* ensemble; }; class CV_EXPORTS CvBoost : public CvStatModel { public: // Boosting type enum { DISCRETE=0, REAL=1, LOGIT=2, GENTLE=3 }; // Splitting criteria enum { DEFAULT=0, GINI=1, MISCLASS=3, SQERR=4 }; CvBoost(); virtual ~CvBoost(); CvBoost( const CvMat* _train_data, int _tflag, const CvMat* _responses, const CvMat* _var_idx=0, const CvMat* _sample_idx=0, const CvMat* _var_type=0, const CvMat* _missing_mask=0, CvBoostParams params=CvBoostParams() ); virtual bool train( const CvMat* _train_data, int _tflag, const CvMat* _responses, const CvMat* _var_idx=0, const CvMat* _sample_idx=0, const CvMat* _var_type=0, const CvMat* _missing_mask=0, CvBoostParams params=CvBoostParams(), bool update=false ); virtual float predict( const CvMat* _sample, const CvMat* _missing=0, CvMat* weak_responses=0, CvSlice slice=CV_WHOLE_SEQ, bool raw_mode=false ) const; virtual void prune( CvSlice slice ); virtual void clear(); virtual void write( CvFileStorage* storage, const char* name ); virtual void read( CvFileStorage* storage, CvFileNode* node ); CvSeq* get_weak_predictors(); CvMat* get_weights(); CvMat* get_subtree_weights(); CvMat* get_weak_response(); const CvBoostParams& get_params() const; protected: virtual bool set_params( const CvBoostParams& _params ); virtual void update_weights( CvBoostTree* tree ); virtual void trim_weights(); virtual void write_params( CvFileStorage* fs ); virtual void read_params( CvFileStorage* fs, CvFileNode* node ); CvDTreeTrainData* data; CvBoostParams params; CvSeq* weak; CvMat* orig_response; CvMat* sum_response; CvMat* weak_eval; CvMat* subsample_mask; CvMat* weights; CvMat* subtree_weights; bool have_subsample; }; /****************************************************************************************\ * Artificial Neural Networks (ANN) * \****************************************************************************************/ /////////////////////////////////// Multi-Layer Perceptrons ////////////////////////////// struct CV_EXPORTS CvANN_MLP_TrainParams { CvANN_MLP_TrainParams(); CvANN_MLP_TrainParams( CvTermCriteria term_crit, int train_method, double param1, double param2=0 ); ~CvANN_MLP_TrainParams(); enum { BACKPROP=0, RPROP=1 }; CvTermCriteria term_crit; int train_method; // backpropagation parameters double bp_dw_scale, bp_moment_scale; // rprop parameters double rp_dw0, rp_dw_plus, rp_dw_minus, rp_dw_min, rp_dw_max; }; class CV_EXPORTS CvANN_MLP : public CvStatModel { public: CvANN_MLP(); CvANN_MLP( const CvMat* _layer_sizes, int _activ_func=SIGMOID_SYM, double _f_param1=0, double _f_param2=0 ); virtual ~CvANN_MLP(); virtual void create( const CvMat* _layer_sizes, int _activ_func=SIGMOID_SYM, double _f_param1=0, double _f_param2=0 ); virtual int train( const CvMat* _inputs, const CvMat* _outputs, const CvMat* _sample_weights, const CvMat* _sample_idx=0, CvANN_MLP_TrainParams _params = CvANN_MLP_TrainParams(), int flags=0 ); virtual float predict( const CvMat* _inputs, CvMat* _outputs ) const; virtual void clear(); // possible activation functions enum { IDENTITY = 0, SIGMOID_SYM = 1, GAUSSIAN = 2 }; // available training flags enum { UPDATE_WEIGHTS = 1, NO_INPUT_SCALE = 2, NO_OUTPUT_SCALE = 4 }; virtual void read( CvFileStorage* fs, CvFileNode* node ); virtual void write( CvFileStorage* storage, const char* name ); int get_layer_count() { return layer_sizes ? layer_sizes->cols : 0; } const CvMat* get_layer_sizes() { return layer_sizes; } double* get_weights(int layer) { return layer_sizes && weights && (unsigned)layer <= (unsigned)layer_sizes->cols ? weights[layer] : 0; } protected: virtual bool prepare_to_train( const CvMat* _inputs, const CvMat* _outputs, const CvMat* _sample_weights, const CvMat* _sample_idx, CvVectors* _ivecs, CvVectors* _ovecs, double** _sw, int _flags ); // sequential random backpropagation virtual int train_backprop( CvVectors _ivecs, CvVectors _ovecs, const double* _sw ); // RPROP algorithm virtual int train_rprop( CvVectors _ivecs, CvVectors _ovecs, const double* _sw ); virtual void calc_activ_func( CvMat* xf, const double* bias ) const; virtual void calc_activ_func_deriv( CvMat* xf, CvMat* deriv, const double* bias ) const; virtual void set_activ_func( int _activ_func=SIGMOID_SYM, double _f_param1=0, double _f_param2=0 ); virtual void init_weights(); virtual void scale_input( const CvMat* _src, CvMat* _dst ) const; virtual void scale_output( const CvMat* _src, CvMat* _dst ) const; virtual void calc_input_scale( const CvVectors* vecs, int flags ); virtual void calc_output_scale( const CvVectors* vecs, int flags ); virtual void write_params( CvFileStorage* fs ); virtual void read_params( CvFileStorage* fs, CvFileNode* node ); CvMat* layer_sizes; CvMat* wbuf; CvMat* sample_weights; double** weights; double f_param1, f_param2; double min_val, max_val, min_val1, max_val1; int activ_func; int max_count, max_buf_sz; CvANN_MLP_TrainParams params; CvRNG rng; }; #if 0 /****************************************************************************************\ * Convolutional Neural Network * \****************************************************************************************/ typedef struct CvCNNLayer CvCNNLayer; typedef struct CvCNNetwork CvCNNetwork; #define CV_CNN_LEARN_RATE_DECREASE_HYPERBOLICALLY 1 #define CV_CNN_LEARN_RATE_DECREASE_SQRT_INV 2 #define CV_CNN_LEARN_RATE_DECREASE_LOG_INV 3 #define CV_CNN_GRAD_ESTIM_RANDOM 0 #define CV_CNN_GRAD_ESTIM_BY_WORST_IMG 1 #define ICV_CNN_LAYER 0x55550000 #define ICV_CNN_CONVOLUTION_LAYER 0x00001111 #define ICV_CNN_SUBSAMPLING_LAYER 0x00002222 #define ICV_CNN_FULLCONNECT_LAYER 0x00003333 #define ICV_IS_CNN_LAYER( layer ) \ ( ((layer) != NULL) && ((((CvCNNLayer*)(layer))->flags & CV_MAGIC_MASK)\ == ICV_CNN_LAYER )) #define ICV_IS_CNN_CONVOLUTION_LAYER( layer ) \ ( (ICV_IS_CNN_LAYER( layer )) && (((CvCNNLayer*) (layer))->flags \ & ~CV_MAGIC_MASK) == ICV_CNN_CONVOLUTION_LAYER ) #define ICV_IS_CNN_SUBSAMPLING_LAYER( layer ) \ ( (ICV_IS_CNN_LAYER( layer )) && (((CvCNNLayer*) (layer))->flags \ & ~CV_MAGIC_MASK) == ICV_CNN_SUBSAMPLING_LAYER ) #define ICV_IS_CNN_FULLCONNECT_LAYER( layer ) \ ( (ICV_IS_CNN_LAYER( layer )) && (((CvCNNLayer*) (layer))->flags \ & ~CV_MAGIC_MASK) == ICV_CNN_FULLCONNECT_LAYER ) typedef void (CV_CDECL *CvCNNLayerForward) ( CvCNNLayer* layer, const CvMat* input, CvMat* output ); typedef void (CV_CDECL *CvCNNLayerBackward) ( CvCNNLayer* layer, int t, const CvMat* X, const CvMat* dE_dY, CvMat* dE_dX ); typedef void (CV_CDECL *CvCNNLayerRelease) (CvCNNLayer** layer); typedef void (CV_CDECL *CvCNNetworkAddLayer) (CvCNNetwork* network, CvCNNLayer* layer); typedef void (CV_CDECL *CvCNNetworkRelease) (CvCNNetwork** network); #define CV_CNN_LAYER_FIELDS() \ /* Indicator of the layer's type */ \ int flags; \ \ /* Number of input images */ \ int n_input_planes; \ /* Height of each input image */ \ int input_height; \ /* Width of each input image */ \ int input_width; \ \ /* Number of output images */ \ int n_output_planes; \ /* Height of each output image */ \ int output_height; \ /* Width of each output image */ \ int output_width; \ \ /* Learning rate at the first iteration */ \ float init_learn_rate; \ /* Dynamics of learning rate decreasing */ \ int learn_rate_decrease_type; \ /* Trainable weights of the layer (including bias) */ \ /* i-th row is a set of weights of the i-th output plane */ \ CvMat* weights; \ \ CvCNNLayerForward forward; \ CvCNNLayerBackward backward; \ CvCNNLayerRelease release; \ /* Pointers to the previous and next layers in the network */ \ CvCNNLayer* prev_layer; \ CvCNNLayer* next_layer typedef struct CvCNNLayer { CV_CNN_LAYER_FIELDS(); }CvCNNLayer; typedef struct CvCNNConvolutionLayer { CV_CNN_LAYER_FIELDS(); // Kernel size (height and width) for convolution. int K; // connections matrix, (i,j)-th element is 1 iff there is a connection between // i-th plane of the current layer and j-th plane of the previous layer; // (i,j)-th element is equal to 0 otherwise CvMat *connect_mask; // value of the learning rate for updating weights at the first iteration }CvCNNConvolutionLayer; typedef struct CvCNNSubSamplingLayer { CV_CNN_LAYER_FIELDS(); // ratio between the heights (or widths - ratios are supposed to be equal) // of the input and output planes int sub_samp_scale; // amplitude of sigmoid activation function float a; // scale parameter of sigmoid activation function float s; // exp2ssumWX = exp(2*(bias+w*(x1+...+x4))), where x1,...x4 are some elements of X // - is the vector used in computing of the activation function in backward CvMat* exp2ssumWX; // (x1+x2+x3+x4), where x1,...x4 are some elements of X // - is the vector used in computing of the activation function in backward CvMat* sumX; }CvCNNSubSamplingLayer; // Structure of the last layer. typedef struct CvCNNFullConnectLayer { CV_CNN_LAYER_FIELDS(); // amplitude of sigmoid activation function float a; // scale parameter of sigmoid activation function float s; // exp2ssumWX = exp(2**(W*X)) - is the vector used in computing of the // activation function and it's derivative by the formulae // activ.func. = (exp(2WX)-1)/(exp(2WX)+1) == - 2/( + 1) // (activ.func.)' = 4exp(2WX)/(exp(2WX)+1)^2 CvMat* exp2ssumWX; }CvCNNFullConnectLayer; typedef struct CvCNNetwork { int n_layers; CvCNNLayer* layers; CvCNNetworkAddLayer add_layer; CvCNNetworkRelease release; }CvCNNetwork; typedef struct CvCNNStatModel { CV_STAT_MODEL_FIELDS(); CvCNNetwork* network; // etalons are allocated as rows, the i-th etalon has label cls_labeles[i] CvMat* etalons; // classes labels CvMat* cls_labels; }CvCNNStatModel; typedef struct CvCNNStatModelParams { CV_STAT_MODEL_PARAM_FIELDS(); // network must be created by the functions cvCreateCNNetwork and CvCNNetwork* network; CvMat* etalons; // termination criteria int max_iter; int start_iter; int grad_estim_type; }CvCNNStatModelParams; CVAPI(CvCNNLayer*) cvCreateCNNConvolutionLayer( int n_input_planes, int input_height, int input_width, int n_output_planes, int K, float init_learn_rate, int learn_rate_decrease_type, CvMat* connect_mask CV_DEFAULT(0), CvMat* weights CV_DEFAULT(0) ); CVAPI(CvCNNLayer*) cvCreateCNNSubSamplingLayer( int n_input_planes, int input_height, int input_width, int sub_samp_scale, float a, float s, float init_learn_rate, int learn_rate_decrease_type, CvMat* weights CV_DEFAULT(0) ); CVAPI(CvCNNLayer*) cvCreateCNNFullConnectLayer( int n_inputs, int n_outputs, float a, float s, float init_learn_rate, int learning_type, CvMat* weights CV_DEFAULT(0) ); CVAPI(CvCNNetwork*) cvCreateCNNetwork( CvCNNLayer* first_layer ); CVAPI(CvStatModel*) cvTrainCNNClassifier( const CvMat* train_data, int tflag, const CvMat* responses, const CvStatModelParams* params, const CvMat* CV_DEFAULT(0), const CvMat* sample_idx CV_DEFAULT(0), const CvMat* CV_DEFAULT(0), const CvMat* CV_DEFAULT(0) ); /****************************************************************************************\ * Estimate classifiers algorithms * \****************************************************************************************/ typedef const CvMat* (CV_CDECL *CvStatModelEstimateGetMat) ( const CvStatModel* estimateModel ); typedef int (CV_CDECL *CvStatModelEstimateNextStep) ( CvStatModel* estimateModel ); typedef void (CV_CDECL *CvStatModelEstimateCheckClassifier) ( CvStatModel* estimateModel, const CvStatModel* model, const CvMat* features, int sample_t_flag, const CvMat* responses ); typedef void (CV_CDECL *CvStatModelEstimateCheckClassifierEasy) ( CvStatModel* estimateModel, const CvStatModel* model ); typedef float (CV_CDECL *CvStatModelEstimateGetCurrentResult) ( const CvStatModel* estimateModel, float* correlation ); typedef void (CV_CDECL *CvStatModelEstimateReset) ( CvStatModel* estimateModel ); //-------------------------------- Cross-validation -------------------------------------- #define CV_CROSS_VALIDATION_ESTIMATE_CLASSIFIER_PARAM_FIELDS() \ CV_STAT_MODEL_PARAM_FIELDS(); \ int k_fold; \ int is_regression; \ CvRNG* rng typedef struct CvCrossValidationParams { CV_CROSS_VALIDATION_ESTIMATE_CLASSIFIER_PARAM_FIELDS(); } CvCrossValidationParams; #define CV_CROSS_VALIDATION_ESTIMATE_CLASSIFIER_FIELDS() \ CvStatModelEstimateGetMat getTrainIdxMat; \ CvStatModelEstimateGetMat getCheckIdxMat; \ CvStatModelEstimateNextStep nextStep; \ CvStatModelEstimateCheckClassifier check; \ CvStatModelEstimateGetCurrentResult getResult; \ CvStatModelEstimateReset reset; \ int is_regression; \ int folds_all; \ int samples_all; \ int* sampleIdxAll; \ int* folds; \ int max_fold_size; \ int current_fold; \ int is_checked; \ CvMat* sampleIdxTrain; \ CvMat* sampleIdxEval; \ CvMat* predict_results; \ int correct_results; \ int all_results; \ double sq_error; \ double sum_correct; \ double sum_predict; \ double sum_cc; \ double sum_pp; \ double sum_cp typedef struct CvCrossValidationModel { CV_STAT_MODEL_FIELDS(); CV_CROSS_VALIDATION_ESTIMATE_CLASSIFIER_FIELDS(); } CvCrossValidationModel; CVAPI(CvStatModel*) cvCreateCrossValidationEstimateModel ( int samples_all, const CvStatModelParams* estimateParams CV_DEFAULT(0), const CvMat* sampleIdx CV_DEFAULT(0) ); CVAPI(float) cvCrossValidation( const CvMat* trueData, int tflag, const CvMat* trueClasses, CvStatModel* (*createClassifier)( const CvMat*, int, const CvMat*, const CvStatModelParams*, const CvMat*, const CvMat*, const CvMat*, const CvMat* ), const CvStatModelParams* estimateParams CV_DEFAULT(0), const CvStatModelParams* trainParams CV_DEFAULT(0), const CvMat* compIdx CV_DEFAULT(0), const CvMat* sampleIdx CV_DEFAULT(0), CvStatModel** pCrValModel CV_DEFAULT(0), const CvMat* typeMask CV_DEFAULT(0), const CvMat* missedMeasurementMask CV_DEFAULT(0) ); #endif /****************************************************************************************\ * Auxilary functions declarations * \****************************************************************************************/ /* Generates from multivariate normal distribution, where - is an average row vector, - symmetric covariation matrix */ CVAPI(void) cvRandMVNormal( CvMat* mean, CvMat* cov, CvMat* sample, CvRNG* rng CV_DEFAULT(0) ); /* Generates sample from gaussian mixture distribution */ CVAPI(void) cvRandGaussMixture( CvMat* means[], CvMat* covs[], float weights[], int clsnum, CvMat* sample, CvMat* sampClasses CV_DEFAULT(0) ); #define CV_TS_CONCENTRIC_SPHERES 0 /* creates test set */ CVAPI(void) cvCreateTestSet( int type, CvMat** samples, int num_samples, int num_features, CvMat** responses, int num_classes, ... ); /* Aij <- Aji for i > j if lower_to_upper != 0 for i < j if lower_to_upper = 0 */ CVAPI(void) cvCompleteSymm( CvMat* matrix, int lower_to_upper ); #endif #endif /*__ML_H__*/ /* End of file. */