+++ /dev/null
-/*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 <limits.h>
-
- #if defined WIN32 || defined WIN64
- #include <windows.h>
- #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 <trainData> matrix are training samples */
-#define CV_COL_SAMPLE 0
-
-/* rows of <trainData> 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 <step> 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 <step> 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();
-
- // TODO: implement non-default constructor!
- // see bug 1830346 on the sourceforge bug tracker
- //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;
-
-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<s>*(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*<s>*(W*X)) - is the vector used in computing of the
- // activation function and it's derivative by the formulae
- // activ.func. = <a>(exp(2<s>WX)-1)/(exp(2<s>WX)+1) == <a> - 2<a>/(<exp2ssumWX> + 1)
- // (activ.func.)' = 4<a><s>exp(2<s>WX)/(exp(2<s>WX)+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 <add_layer>
- 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 <sample> from multivariate normal distribution, where <mean> - is an
- average row vector, <cov> - 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. */
projects / opencv / blobdiff