{
if( !at )
{
- transpose(temp_u, _u);
- temp_v.copyTo(_vt);
+ if( _u.needed() )
+ transpose(temp_u, _u);
+ if( _vt.needed() )
+ temp_v.copyTo(_vt);
}
else
{
- transpose(temp_v, _u);
- temp_u.copyTo(_vt);
+ if( _u.needed() )
+ transpose(temp_v, _u);
+ if( _vt.needed() )
+ temp_u.copyTo(_vt);
}
}
}
// copy or use the software.
//
//
-// Intel License Agreement
+// License Agreement
+// For Open Source Computer Vision Library
//
// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// 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
+// * The name of the copyright holders 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
# include "opencv2/core.hpp"
#endif
-#include "opencv2/core/core_c.h"
-#include <limits.h>
-
#ifdef __cplusplus
+#include <float.h>
#include <map>
#include <iostream>
-// 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
+namespace cv
+{
-#define CV_IS_ROW_SAMPLE(flags) ((flags) & CV_ROW_SAMPLE)
+namespace ml
+{
-struct CvVectors
+/* Variable type */
+enum
{
- int type;
- int dims, count;
- CvVectors* next;
- union
- {
- uchar** ptr;
- float** fl;
- double** db;
- } data;
+ VAR_NUMERICAL =0,
+ VAR_ORDERED =0,
+ VAR_CATEGORICAL =1
};
-#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
+enum
{
- double min_val;
- double max_val;
- double step;
-}
-CvParamLattice;
+ TEST_ERROR = 0,
+ TRAIN_ERROR = 1
+};
-CV_INLINE CvParamLattice cvParamLattice( double min_val, double max_val,
- double log_step )
+enum
{
- 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;
-}
+ ROW_SAMPLE = 0,
+ COL_SAMPLE = 1
+};
-CV_INLINE CvParamLattice cvDefaultParamLattice( void )
+class CV_EXPORTS_W_MAP ParamGrid
{
- CvParamLattice pl = {0,0,0};
- return pl;
-}
-#endif
+public:
+ ParamGrid();
+ ParamGrid(double _minVal, double _maxVal, double _logStep);
-/* 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"
-#define CV_TYPE_NAME_ML_ERTREES "opencv-ml-extremely-randomized-trees"
-#define CV_TYPE_NAME_ML_GBT "opencv-ml-gradient-boosting-trees"
-
-#define CV_TRAIN_ERROR 0
-#define CV_TEST_ERROR 1
-
-class CV_EXPORTS_W CvStatModel
+ CV_PROP_RW double minVal;
+ CV_PROP_RW double maxVal;
+ CV_PROP_RW double logStep;
+};
+
+
+class CV_EXPORTS TrainData
{
public:
- CvStatModel();
- virtual ~CvStatModel();
-
+ static inline float missingValue() { return FLT_MAX; }
+ virtual ~TrainData();
+
+ virtual int getLayout() const = 0;
+ virtual int getNTrainSamples() const = 0;
+ virtual int getNTestSamples() const = 0;
+ virtual int getNSamples() const = 0;
+ virtual int getNVars() const = 0;
+ virtual int getNAllVars() const = 0;
+
+ virtual void getSample(InputArray varIdx, int sidx, float* buf) const = 0;
+ virtual Mat getSamples() const = 0;
+ virtual Mat getMissing() const = 0;
+ virtual Mat getTrainSamples(int layout=ROW_SAMPLE,
+ bool compressSamples=true,
+ bool compressVars=true) const = 0;
+ virtual Mat getTrainResponses() const = 0;
+ virtual Mat getTrainNormCatResponses() const = 0;
+ virtual Mat getTestResponses() const = 0;
+ virtual Mat getTestNormCatResponses() const = 0;
+ virtual Mat getResponses() const = 0;
+ virtual Mat getNormCatResponses() const = 0;
+ virtual Mat getSampleWeights() const = 0;
+ virtual Mat getTrainSampleWeights() const = 0;
+ virtual Mat getTestSampleWeights() const = 0;
+ virtual Mat getVarIdx() const = 0;
+ virtual Mat getVarType() const = 0;
+ virtual int getResponseType() const = 0;
+ virtual Mat getTrainSampleIdx() const = 0;
+ virtual Mat getTestSampleIdx() const = 0;
+ virtual void getValues(int vi, InputArray sidx, float* values) const = 0;
+ virtual void getNormCatValues(int vi, InputArray sidx, int* values) const = 0;
+ virtual Mat getDefaultSubstValues() const = 0;
+
+ virtual int getCatCount(int vi) const = 0;
+ virtual Mat getClassLabels() const = 0;
+
+ virtual Mat getCatOfs() const = 0;
+ virtual Mat getCatMap() const = 0;
+
+ virtual void setTrainTestSplit(int count, bool shuffle=true) = 0;
+ virtual void setTrainTestSplitRatio(float ratio, bool shuffle=true) = 0;
+ virtual void shuffleTrainTest() = 0;
+
+ static Mat getSubVector(const Mat& vec, const Mat& idx);
+ static Ptr<TrainData> loadFromCSV(const String& filename,
+ int headerLineCount,
+ int responseStartIdx=-1,
+ int responseEndIdx=-1,
+ const String& varTypeSpec=String(),
+ char delimiter=',',
+ char missch='?');
+ static Ptr<TrainData> create(InputArray samples, int layout, InputArray responses,
+ InputArray varIdx=noArray(), InputArray sampleIdx=noArray(),
+ InputArray sampleWeights=noArray(), InputArray varType=noArray());
+};
+
+
+class CV_EXPORTS_W StatModel : public Algorithm
+{
+public:
+ enum { UPDATE_MODEL = 1, RAW_OUTPUT=1, COMPRESSED_INPUT=2, PREPROCESSED_INPUT=4 };
+ virtual ~StatModel();
virtual void clear();
- CV_WRAP virtual void save( const char* filename, const char* name=0 ) const;
- CV_WRAP virtual void load( const char* filename, const char* name=0 );
+ virtual int getVarCount() const = 0;
+
+ virtual bool isTrained() const = 0;
+ virtual bool isClassifier() const = 0;
- virtual void write( CvFileStorage* storage, const char* name ) const;
- virtual void read( CvFileStorage* storage, CvFileNode* node );
+ virtual bool train( const Ptr<TrainData>& trainData, int flags=0 ) = 0;
+ virtual float calcError( const Ptr<TrainData>& data, bool test, OutputArray resp ) const;
+ virtual float predict( InputArray samples, OutputArray results=noArray(), int flags=0 ) const = 0;
+
+ template<typename _Tp> static Ptr<_Tp> load(const String& filename)
+ {
+ FileStorage fs(filename, FileStorage::READ);
+ Ptr<_Tp> p = _Tp::create();
+ p->read(fs.getFirstTopLevelNode());
+ return p->isTrained() ? p : Ptr<_Tp>();
+ }
-protected:
- const char* default_model_name;
+ virtual void save(const String& filename) const;
+ virtual String getDefaultModelName() const = 0;
};
/****************************************************************************************\
the accuracy estimate being computed by cross-validation.
The grid is logarithmic, so <step> must be greater then 1. */
-class CvMLData;
-
-struct CV_EXPORTS_W_MAP 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 );
- //CvParamGrid( int param_id );
- bool check() const;
-
- CV_PROP_RW double min_val;
- CV_PROP_RW double max_val;
- CV_PROP_RW double step;
-};
-
-inline CvParamGrid::CvParamGrid( double _min_val, double _max_val, double _log_step )
-{
- min_val = _min_val;
- max_val = _max_val;
- step = _log_step;
-}
-
-class CV_EXPORTS_W CvNormalBayesClassifier : public CvStatModel
+class CV_EXPORTS_W NormalBayesClassifier : public StatModel
{
public:
- CV_WRAP CvNormalBayesClassifier();
- virtual ~CvNormalBayesClassifier();
-
- CvNormalBayesClassifier( const CvMat* trainData, const CvMat* responses,
- const CvMat* varIdx=0, const CvMat* sampleIdx=0 );
-
- virtual bool train( const CvMat* trainData, const CvMat* responses,
- const CvMat* varIdx = 0, const CvMat* sampleIdx=0, bool update=false );
-
- virtual float predict( const CvMat* samples, CV_OUT CvMat* results=0, CV_OUT CvMat* results_prob=0 ) const;
- CV_WRAP virtual void clear();
-
- CV_WRAP CvNormalBayesClassifier( const cv::Mat& trainData, const cv::Mat& responses,
- const cv::Mat& varIdx=cv::Mat(), const cv::Mat& sampleIdx=cv::Mat() );
- CV_WRAP virtual bool train( const cv::Mat& trainData, const cv::Mat& responses,
- const cv::Mat& varIdx = cv::Mat(), const cv::Mat& sampleIdx=cv::Mat(),
- bool update=false );
- CV_WRAP virtual float predict( const cv::Mat& samples, CV_OUT cv::Mat* results=0, CV_OUT cv::Mat* results_prob=0 ) const;
-
- virtual void write( CvFileStorage* storage, const char* name ) const;
- 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;
-};
+ virtual ~NormalBayesClassifier();
+ virtual float predictProb( InputArray inputs, OutputArray outputs,
+ OutputArray outputProbs, int flags=0 ) const = 0;
+ static Ptr<NormalBayesClassifier> create();
+};
/****************************************************************************************\
* K-Nearest Neighbour Classifier *
\****************************************************************************************/
// k Nearest Neighbors
-class CV_EXPORTS_W CvKNearest : public CvStatModel
+class CV_EXPORTS_W KNearest : public StatModel
{
public:
-
- CV_WRAP CvKNearest();
- virtual ~CvKNearest();
-
- CvKNearest( const CvMat* trainData, const CvMat* responses,
- const CvMat* sampleIdx=0, bool isRegression=false, int max_k=32 );
-
- virtual bool train( const CvMat* trainData, const CvMat* responses,
- const CvMat* sampleIdx=0, bool is_regression=false,
- int maxK=32, bool updateBase=false );
-
- virtual float find_nearest( const CvMat* samples, int k, CV_OUT CvMat* results=0,
- const float** neighbors=0, CV_OUT CvMat* neighborResponses=0, CV_OUT CvMat* dist=0 ) const;
-
- CV_WRAP CvKNearest( const cv::Mat& trainData, const cv::Mat& responses,
- const cv::Mat& sampleIdx=cv::Mat(), bool isRegression=false, int max_k=32 );
-
- CV_WRAP virtual bool train( const cv::Mat& trainData, const cv::Mat& responses,
- const cv::Mat& sampleIdx=cv::Mat(), bool isRegression=false,
- int maxK=32, bool updateBase=false );
-
- virtual float find_nearest( const cv::Mat& samples, int k, cv::Mat* results=0,
- const float** neighbors=0, cv::Mat* neighborResponses=0,
- cv::Mat* dist=0 ) const;
- CV_WRAP virtual float find_nearest( const cv::Mat& samples, int k, CV_OUT cv::Mat& results,
- CV_OUT cv::Mat& neighborResponses, CV_OUT cv::Mat& dists) const;
-
- virtual void clear();
- int get_max_k() const;
- int get_var_count() const;
- int get_sample_count() const;
- bool is_regression() const;
-
- 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;
-
-protected:
-
- int max_k, var_count;
- int total;
- bool regression;
- CvVectors* samples;
+ virtual void setDefaultK(int k) = 0;
+ virtual int getDefaultK() const = 0;
+ virtual float findNearest( InputArray samples, int k,
+ OutputArray results,
+ OutputArray neighborResponses=noArray(),
+ OutputArray dist=noArray() ) const = 0;
+ static Ptr<KNearest> create(bool isclassifier=true);
};
/****************************************************************************************\
* Support Vector Machines *
\****************************************************************************************/
-// SVM training parameters
-struct CV_EXPORTS_W_MAP CvSVMParams
-{
- CvSVMParams();
- CvSVMParams( int svm_type, int kernel_type,
- double degree, double gamma, double coef0,
- double Cvalue, double nu, double p,
- CvMat* class_weights, CvTermCriteria term_crit );
-
- CV_PROP_RW int svm_type;
- CV_PROP_RW int kernel_type;
- CV_PROP_RW double degree; // for poly
- CV_PROP_RW double gamma; // for poly/rbf/sigmoid/chi2
- CV_PROP_RW double coef0; // for poly/sigmoid
-
- CV_PROP_RW double C; // for CV_SVM_C_SVC, CV_SVM_EPS_SVR and CV_SVM_NU_SVR
- CV_PROP_RW double nu; // for CV_SVM_NU_SVC, CV_SVM_ONE_CLASS, and CV_SVM_NU_SVR
- CV_PROP_RW double p; // for CV_SVM_EPS_SVR
- CvMat* class_weights; // for CV_SVM_C_SVC
- CV_PROP_RW 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_intersec( int vcount, int var_count, const float** vecs,
- const float* another, float* results );
- virtual void calc_chi2( int vec_count, int vec_size, const float** vecs,
- const float* another, float* results );
- 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
+// SVM model
+class CV_EXPORTS_W SVM : public StatModel
{
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;
-};
+ class CV_EXPORTS_W_MAP Params
+ {
+ public:
+ Params();
+ Params( int svm_type, int kernel_type,
+ double degree, double gamma, double coef0,
+ double Cvalue, double nu, double p,
+ const Mat& classWeights, TermCriteria termCrit );
+
+ CV_PROP_RW int svmType;
+ CV_PROP_RW int kernelType;
+ CV_PROP_RW double gamma, coef0, degree;
+
+ CV_PROP_RW double C; // for CV_SVM_C_SVC, CV_SVM_EPS_SVR and CV_SVM_NU_SVR
+ CV_PROP_RW double nu; // for CV_SVM_NU_SVC, CV_SVM_ONE_CLASS, and CV_SVM_NU_SVR
+ CV_PROP_RW double p; // for CV_SVM_EPS_SVR
+ CV_PROP_RW Mat classWeights; // for CV_SVM_C_SVC
+ CV_PROP_RW TermCriteria termCrit; // termination criteria
+ };
+ class CV_EXPORTS Kernel : public Algorithm
+ {
+ public:
+ virtual ~Kernel();
+ virtual int getType() const = 0;
+ virtual void calc( int vcount, int n, const float* vecs, const float* another, float* results ) = 0;
+ };
-// SVM model
-class CV_EXPORTS_W 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, CHI2=4, INTER=5 };
+ enum { CUSTOM=-1, LINEAR=0, POLY=1, RBF=2, SIGMOID=3, CHI2=4, INTER=5 };
// SVM params type
enum { C=0, GAMMA=1, P=2, NU=3, COEF=4, DEGREE=5 };
- CV_WRAP CvSVM();
- virtual ~CvSVM();
-
- CvSVM( const CvMat* trainData, const CvMat* responses,
- const CvMat* varIdx=0, const CvMat* sampleIdx=0,
- CvSVMParams params=CvSVMParams() );
-
- virtual bool train( const CvMat* trainData, const CvMat* responses,
- const CvMat* varIdx=0, const CvMat* sampleIdx=0,
- CvSVMParams params=CvSVMParams() );
-
- virtual bool train_auto( const CvMat* trainData, const CvMat* responses,
- const CvMat* varIdx, const CvMat* sampleIdx, CvSVMParams params,
- int kfold = 10,
- CvParamGrid Cgrid = get_default_grid(CvSVM::C),
- CvParamGrid gammaGrid = get_default_grid(CvSVM::GAMMA),
- CvParamGrid pGrid = get_default_grid(CvSVM::P),
- CvParamGrid nuGrid = get_default_grid(CvSVM::NU),
- CvParamGrid coeffGrid = get_default_grid(CvSVM::COEF),
- CvParamGrid degreeGrid = get_default_grid(CvSVM::DEGREE),
- bool balanced=false );
-
- virtual float predict( const CvMat* sample, bool returnDFVal=false ) const;
- virtual float predict( const CvMat* samples, CV_OUT CvMat* results, bool returnDFVal=false ) const;
-
- CV_WRAP CvSVM( const cv::Mat& trainData, const cv::Mat& responses,
- const cv::Mat& varIdx=cv::Mat(), const cv::Mat& sampleIdx=cv::Mat(),
- CvSVMParams params=CvSVMParams() );
-
- CV_WRAP virtual bool train( const cv::Mat& trainData, const cv::Mat& responses,
- const cv::Mat& varIdx=cv::Mat(), const cv::Mat& sampleIdx=cv::Mat(),
- CvSVMParams params=CvSVMParams() );
-
- CV_WRAP virtual bool train_auto( const cv::Mat& trainData, const cv::Mat& responses,
- const cv::Mat& varIdx, const cv::Mat& sampleIdx, CvSVMParams params,
- int k_fold = 10,
- CvParamGrid Cgrid = CvSVM::get_default_grid(CvSVM::C),
- CvParamGrid gammaGrid = CvSVM::get_default_grid(CvSVM::GAMMA),
- CvParamGrid pGrid = CvSVM::get_default_grid(CvSVM::P),
- CvParamGrid nuGrid = CvSVM::get_default_grid(CvSVM::NU),
- CvParamGrid coeffGrid = CvSVM::get_default_grid(CvSVM::COEF),
- CvParamGrid degreeGrid = CvSVM::get_default_grid(CvSVM::DEGREE),
- bool balanced=false);
- CV_WRAP virtual float predict( const cv::Mat& sample, bool returnDFVal=false ) const;
- CV_WRAP_AS(predict_all) virtual void predict( cv::InputArray samples, cv::OutputArray results ) const;
-
- CV_WRAP virtual int get_support_vector_count() const;
- virtual const float* get_support_vector(int i) const;
- virtual CvSVMParams get_params() const { return params; }
- CV_WRAP virtual void clear();
-
- virtual const CvSVMDecisionFunc* get_decision_function() const { return decision_func; }
-
- static CvParamGrid get_default_grid( int param_id );
-
- virtual void write( CvFileStorage* storage, const char* name ) const;
- virtual void read( CvFileStorage* storage, CvFileNode* node );
- CV_WRAP 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 float predict( const float* row_sample, int row_len, bool returnDFVal=false ) const;
-
- virtual void write_params( CvFileStorage* fs ) const;
- virtual void read_params( CvFileStorage* fs, CvFileNode* node );
-
- void optimize_linear_svm();
-
- 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;
-
-private:
- CvSVM(const CvSVM&);
- CvSVM& operator = (const CvSVM&);
+ virtual ~SVM();
+
+ virtual bool trainAuto( const Ptr<TrainData>& data, int kFold = 10,
+ ParamGrid Cgrid = SVM::getDefaultGrid(SVM::C),
+ ParamGrid gammaGrid = SVM::getDefaultGrid(SVM::GAMMA),
+ ParamGrid pGrid = SVM::getDefaultGrid(SVM::P),
+ ParamGrid nuGrid = SVM::getDefaultGrid(SVM::NU),
+ ParamGrid coeffGrid = SVM::getDefaultGrid(SVM::COEF),
+ ParamGrid degreeGrid = SVM::getDefaultGrid(SVM::DEGREE),
+ bool balanced=false) = 0;
+
+ CV_WRAP virtual Mat getSupportVectors() const = 0;
+
+ virtual void setParams(const Params& p, const Ptr<Kernel>& customKernel=Ptr<Kernel>()) = 0;
+ virtual Params getParams() const = 0;
+ virtual Ptr<Kernel> getKernel() const = 0;
+ virtual double getDecisionFunction(int i, OutputArray alpha, OutputArray svidx) const = 0;
+
+ static ParamGrid getDefaultGrid( int param_id );
+ static Ptr<SVM> create(const Params& p=Params(), const Ptr<Kernel>& customKernel=Ptr<Kernel>());
};
/****************************************************************************************\
* Expectation - Maximization *
\****************************************************************************************/
-namespace cv
-{
-class CV_EXPORTS_W EM : public Algorithm
+class CV_EXPORTS_W EM : public StatModel
{
public:
// Type of covariation matrices
// The initial step
enum {START_E_STEP=1, START_M_STEP=2, START_AUTO_STEP=0};
- CV_WRAP EM(int nclusters=EM::DEFAULT_NCLUSTERS, int covMatType=EM::COV_MAT_DIAGONAL,
- const TermCriteria& termCrit=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS,
- EM::DEFAULT_MAX_ITERS, FLT_EPSILON));
-
- virtual ~EM();
- CV_WRAP virtual void clear();
-
- CV_WRAP virtual bool train(InputArray samples,
- OutputArray logLikelihoods=noArray(),
- OutputArray labels=noArray(),
- OutputArray probs=noArray());
-
- CV_WRAP virtual bool trainE(InputArray samples,
- InputArray means0,
- InputArray covs0=noArray(),
- InputArray weights0=noArray(),
- OutputArray logLikelihoods=noArray(),
- OutputArray labels=noArray(),
- OutputArray probs=noArray());
-
- CV_WRAP virtual bool trainM(InputArray samples,
- InputArray probs0,
- OutputArray logLikelihoods=noArray(),
- OutputArray labels=noArray(),
- OutputArray probs=noArray());
-
- CV_WRAP Vec2d predict(InputArray sample,
- OutputArray probs=noArray()) const;
-
- CV_WRAP bool isTrained() const;
-
- AlgorithmInfo* info() const;
- virtual void read(const FileNode& fn);
-
-protected:
-
- virtual void setTrainData(int startStep, const Mat& samples,
- const Mat* probs0,
- const Mat* means0,
- const std::vector<Mat>* covs0,
- const Mat* weights0);
-
- bool doTrain(int startStep,
- OutputArray logLikelihoods,
- OutputArray labels,
- OutputArray probs);
- virtual void eStep();
- virtual void mStep();
-
- void clusterTrainSamples();
- void decomposeCovs();
- void computeLogWeightDivDet();
-
- Vec2d computeProbabilities(const Mat& sample, Mat* probs) const;
-
- // all inner matrices have type CV_64FC1
- CV_PROP_RW int nclusters;
- CV_PROP_RW int covMatType;
- CV_PROP_RW int maxIters;
- CV_PROP_RW double epsilon;
-
- Mat trainSamples;
- Mat trainProbs;
- Mat trainLogLikelihoods;
- Mat trainLabels;
-
- CV_PROP Mat weights;
- CV_PROP Mat means;
- CV_PROP std::vector<Mat> covs;
-
- std::vector<Mat> covsEigenValues;
- std::vector<Mat> covsRotateMats;
- std::vector<Mat> invCovsEigenValues;
- Mat logWeightDivDet;
-};
-} // namespace cv
-
-/****************************************************************************************\
-* Decision Tree *
-\****************************************************************************************/\
-struct CvPair16u32s
-{
- unsigned short* u;
- int* i;
-};
-
-
-#define CV_DTREE_CAT_DIR(idx,subset) \
- (2*((subset[(idx)>>5]&(1 << ((idx) & 31)))==0)-1)
-
-struct CvDTreeSplit
-{
- int var_idx;
- int condensed_idx;
- int inversed;
- float quality;
- CvDTreeSplit* next;
- union
+ class CV_EXPORTS_W_MAP Params
{
- int subset[2];
- struct
- {
- float c;
- int split_point;
- }
- ord;
+ public:
+ explicit Params(int nclusters=DEFAULT_NCLUSTERS, int covMatType=EM::COV_MAT_DIAGONAL,
+ const TermCriteria& termCrit=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS,
+ EM::DEFAULT_MAX_ITERS, 1e-6));
+ int nclusters;
+ int covMatType;
+ TermCriteria termCrit;
};
-};
-
-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; }
-};
+ virtual void setParams(const Params& p) = 0;
+ virtual Params getParams() const = 0;
+ virtual Mat getWeights() const = 0;
+ virtual Mat getMeans() const = 0;
+ virtual void getCovs(std::vector<Mat>& covs) const = 0;
-struct CV_EXPORTS_W_MAP CvDTreeParams
-{
- CV_PROP_RW int max_categories;
- CV_PROP_RW int max_depth;
- CV_PROP_RW int min_sample_count;
- CV_PROP_RW int cv_folds;
- CV_PROP_RW bool use_surrogates;
- CV_PROP_RW bool use_1se_rule;
- CV_PROP_RW bool truncate_pruned_tree;
- CV_PROP_RW float regression_accuracy;
- const float* priors;
-
- CvDTreeParams();
- 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 );
-};
+ CV_WRAP virtual Vec2d predict2(InputArray sample, OutputArray probs) const = 0;
+ virtual bool train( const Ptr<TrainData>& trainData, int flags=0 ) = 0;
-struct CV_EXPORTS CvDTreeTrainData
-{
- CvDTreeTrainData();
- CvDTreeTrainData( const CvMat* trainData, int tflag,
- const CvMat* responses, const CvMat* varIdx=0,
- const CvMat* sampleIdx=0, const CvMat* varType=0,
- const CvMat* missingDataMask=0,
- const CvDTreeParams& params=CvDTreeParams(),
- bool _shared=false, bool _add_labels=false );
- virtual ~CvDTreeTrainData();
-
- virtual void set_data( const CvMat* trainData, int tflag,
- const CvMat* responses, const CvMat* varIdx=0,
- const CvMat* sampleIdx=0, const CvMat* varType=0,
- const CvMat* missingDataMask=0,
- const CvDTreeParams& params=CvDTreeParams(),
- bool _shared=false, bool _add_labels=false,
- bool _update_data=false );
- virtual void do_responses_copy();
-
- 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 ) const;
- 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 {return work_var_count;}
-
- virtual const float* get_ord_responses( CvDTreeNode* n, float* values_buf, int* sample_indices_buf );
- virtual const int* get_class_labels( CvDTreeNode* n, int* labels_buf );
- virtual const int* get_cv_labels( CvDTreeNode* n, int* labels_buf );
- virtual const int* get_sample_indices( CvDTreeNode* n, int* indices_buf );
- virtual const int* get_cat_var_data( CvDTreeNode* n, int vi, int* cat_values_buf );
- virtual void get_ord_var_data( CvDTreeNode* n, int vi, float* ord_values_buf, int* sorted_indices_buf,
- const float** ord_values, const int** sorted_indices, int* sample_indices_buf );
- 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, work_var_count;
- bool have_labels, have_priors;
- bool is_classifier;
- int tflag;
-
- const CvMat* train_data;
- const CvMat* responses;
- CvMat* responses_copy; // used in Boosting
-
- int buf_count, buf_size; // buf_size is obsolete, please do not use it, use expression ((int64)buf->rows * (int64)buf->cols / buf_count) instead
- bool shared;
- int is_buf_16u;
-
- CvMat* cat_count;
- CvMat* cat_ofs;
- CvMat* cat_map;
-
- CvMat* counts;
- CvMat* buf;
- inline size_t get_length_subbuf() const
- {
- size_t res = (size_t)(work_var_count + 1) * (size_t)sample_count;
- return res;
- }
+ static Ptr<EM> train(InputArray samples,
+ OutputArray logLikelihoods=noArray(),
+ OutputArray labels=noArray(),
+ OutputArray probs=noArray(),
+ const Params& params=Params());
- CvMat* direction;
- CvMat* split_buf;
+ static Ptr<EM> train_startWithE(InputArray samples, InputArray means0,
+ InputArray covs0=noArray(),
+ InputArray weights0=noArray(),
+ OutputArray logLikelihoods=noArray(),
+ OutputArray labels=noArray(),
+ OutputArray probs=noArray(),
+ const Params& params=Params());
- 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;
-
- cv::RNG* rng;
-};
-
-class CvDTree;
-class CvForestTree;
-
-namespace cv
-{
- struct DTreeBestSplitFinder;
- struct ForestTreeBestSplitFinder;
-}
-
-class CV_EXPORTS_W CvDTree : public CvStatModel
-{
-public:
- CV_WRAP CvDTree();
- virtual ~CvDTree();
-
- virtual bool train( const CvMat* trainData, int tflag,
- const CvMat* responses, const CvMat* varIdx=0,
- const CvMat* sampleIdx=0, const CvMat* varType=0,
- const CvMat* missingDataMask=0,
- CvDTreeParams params=CvDTreeParams() );
-
- virtual bool train( CvMLData* trainData, CvDTreeParams params=CvDTreeParams() );
-
- // type in {CV_TRAIN_ERROR, CV_TEST_ERROR}
- virtual float calc_error( CvMLData* trainData, int type, std::vector<float> *resp = 0 );
-
- virtual bool train( CvDTreeTrainData* trainData, const CvMat* subsampleIdx );
-
- virtual CvDTreeNode* predict( const CvMat* sample, const CvMat* missingDataMask=0,
- bool preprocessedInput=false ) const;
-
- CV_WRAP virtual bool train( const cv::Mat& trainData, int tflag,
- const cv::Mat& responses, const cv::Mat& varIdx=cv::Mat(),
- const cv::Mat& sampleIdx=cv::Mat(), const cv::Mat& varType=cv::Mat(),
- const cv::Mat& missingDataMask=cv::Mat(),
- CvDTreeParams params=CvDTreeParams() );
-
- CV_WRAP virtual CvDTreeNode* predict( const cv::Mat& sample, const cv::Mat& missingDataMask=cv::Mat(),
- bool preprocessedInput=false ) const;
- CV_WRAP virtual cv::Mat getVarImportance();
-
- virtual const CvMat* get_var_importance();
- CV_WRAP virtual void clear();
-
- virtual void read( CvFileStorage* fs, CvFileNode* node );
- virtual void write( CvFileStorage* fs, const char* name ) const;
-
- // 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;
-
- const CvDTreeNode* get_root() const;
- int get_pruned_tree_idx() const;
- CvDTreeTrainData* get_data();
-
-protected:
- friend struct cv::DTreeBestSplitFinder;
-
- 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,
- float init_quality = 0, CvDTreeSplit* _split = 0, uchar* ext_buf = 0 );
- virtual CvDTreeSplit* find_split_cat_class( CvDTreeNode* n, int vi,
- float init_quality = 0, CvDTreeSplit* _split = 0, uchar* ext_buf = 0 );
- virtual CvDTreeSplit* find_split_ord_reg( CvDTreeNode* n, int vi,
- float init_quality = 0, CvDTreeSplit* _split = 0, uchar* ext_buf = 0 );
- virtual CvDTreeSplit* find_split_cat_reg( CvDTreeNode* n, int vi,
- float init_quality = 0, CvDTreeSplit* _split = 0, uchar* ext_buf = 0 );
- virtual CvDTreeSplit* find_surrogate_split_ord( CvDTreeNode* n, int vi, uchar* ext_buf = 0 );
- virtual CvDTreeSplit* find_surrogate_split_cat( CvDTreeNode* n, int vi, uchar* ext_buf = 0 );
- 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 ) const;
- virtual void write_split( CvFileStorage* fs, CvDTreeSplit* split ) const;
- 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 ) const;
- virtual void read_tree_nodes( CvFileStorage* fs, CvFileNode* node );
-
- CvDTreeNode* root;
- CvMat* var_importance;
- CvDTreeTrainData* data;
- CvMat train_data_hdr, responses_hdr;
- cv::Mat train_data_mat, responses_mat;
-
-public:
- int pruned_tree_idx;
+ static Ptr<EM> train_startWithM(InputArray samples, InputArray probs0,
+ OutputArray logLikelihoods=noArray(),
+ OutputArray labels=noArray(),
+ OutputArray probs=noArray(),
+ const Params& params=Params());
+ static Ptr<EM> create(const Params& params=Params());
};
/****************************************************************************************\
-* Random Trees Classifier *
+* Decision Tree *
\****************************************************************************************/
-class CvRTrees;
-
-class CV_EXPORTS CvForestTree: public CvDTree
+class CV_EXPORTS_W DTrees : public StatModel
{
public:
- CvForestTree();
- virtual ~CvForestTree();
+ enum { PREDICT_AUTO=0, PREDICT_SUM=(1<<8), PREDICT_MAX_VOTE=(2<<8), PREDICT_MASK=(3<<8) };
- virtual bool train( CvDTreeTrainData* trainData, 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 );
+ class CV_EXPORTS_W_MAP Params
+ {
+ public:
+ Params();
+ Params( int maxDepth, int minSampleCount,
+ double regressionAccuracy, bool useSurrogates,
+ int maxCategories, int CVFolds,
+ bool use1SERule, bool truncatePrunedTree,
+ const Mat& priors );
+
+ CV_PROP_RW int maxCategories;
+ CV_PROP_RW int maxDepth;
+ CV_PROP_RW int minSampleCount;
+ CV_PROP_RW int CVFolds;
+ CV_PROP_RW bool useSurrogates;
+ CV_PROP_RW bool use1SERule;
+ CV_PROP_RW bool truncatePrunedTree;
+ CV_PROP_RW float regressionAccuracy;
+ CV_PROP_RW Mat priors;
+ };
- /* dummy methods to avoid warnings: BEGIN */
- virtual bool train( const CvMat* trainData, int tflag,
- const CvMat* responses, const CvMat* varIdx=0,
- const CvMat* sampleIdx=0, const CvMat* varType=0,
- const CvMat* missingDataMask=0,
- CvDTreeParams params=CvDTreeParams() );
+ class CV_EXPORTS Node
+ {
+ public:
+ Node();
+ double value;
+ int classIdx;
- virtual bool train( CvDTreeTrainData* trainData, 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 */
+ int parent;
+ int left;
+ int right;
+ int defaultDir;
-protected:
- friend struct cv::ForestTreeBestSplitFinder;
+ int split;
+ };
- virtual CvDTreeSplit* find_best_split( CvDTreeNode* n );
- CvRTrees* forest;
-};
+ class CV_EXPORTS Split
+ {
+ public:
+ Split();
+ int varIdx;
+ bool inversed;
+ float quality;
+ int next;
+ float c;
+ int subsetOfs;
+ };
+ virtual ~DTrees();
-struct CV_EXPORTS_W_MAP CvRTParams : public CvDTreeParams
-{
- //Parameters for the forest
- CV_PROP_RW bool calc_var_importance; // true <=> RF processes variable importance
- CV_PROP_RW int nactive_vars;
- CV_PROP_RW CvTermCriteria term_crit;
-
- CvRTParams();
- 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 );
-};
+ virtual void setDParams(const Params& p);
+ virtual Params getDParams() const;
+ virtual const std::vector<int>& getRoots() const = 0;
+ virtual const std::vector<Node>& getNodes() const = 0;
+ virtual const std::vector<Split>& getSplits() const = 0;
+ virtual const std::vector<int>& getSubsets() const = 0;
-class CV_EXPORTS_W CvRTrees : public CvStatModel
-{
-public:
- CV_WRAP CvRTrees();
- virtual ~CvRTrees();
- virtual bool train( const CvMat* trainData, int tflag,
- const CvMat* responses, const CvMat* varIdx=0,
- const CvMat* sampleIdx=0, const CvMat* varType=0,
- const CvMat* missingDataMask=0,
- CvRTParams params=CvRTParams() );
-
- virtual bool train( CvMLData* data, CvRTParams params=CvRTParams() );
- virtual float predict( const CvMat* sample, const CvMat* missing = 0 ) const;
- virtual float predict_prob( const CvMat* sample, const CvMat* missing = 0 ) const;
-
- CV_WRAP virtual bool train( const cv::Mat& trainData, int tflag,
- const cv::Mat& responses, const cv::Mat& varIdx=cv::Mat(),
- const cv::Mat& sampleIdx=cv::Mat(), const cv::Mat& varType=cv::Mat(),
- const cv::Mat& missingDataMask=cv::Mat(),
- CvRTParams params=CvRTParams() );
- CV_WRAP virtual float predict( const cv::Mat& sample, const cv::Mat& missing = cv::Mat() ) const;
- CV_WRAP virtual float predict_prob( const cv::Mat& sample, const cv::Mat& missing = cv::Mat() ) const;
- CV_WRAP virtual cv::Mat getVarImportance();
-
- CV_WRAP 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 float calc_error( CvMLData* data, int type , std::vector<float>* resp = 0 ); // type in {CV_TRAIN_ERROR, CV_TEST_ERROR}
-
- virtual float get_train_error();
-
- virtual void read( CvFileStorage* fs, CvFileNode* node );
- virtual void write( CvFileStorage* fs, const char* name ) const;
-
- CvMat* get_active_var_mask();
- CvRNG* get_rng();
-
- int get_tree_count() const;
- CvForestTree* get_tree(int i) const;
-
-protected:
- virtual cv::String getName() const;
-
- virtual bool grow_forest( const CvTermCriteria term_crit );
-
- // array of the trees of the forest
- CvForestTree** trees;
- CvDTreeTrainData* data;
- CvMat train_data_hdr, responses_hdr;
- cv::Mat train_data_mat, responses_mat;
- int ntrees;
- int nclasses;
- double oob_error;
- CvMat* var_importance;
- int nsamples;
-
- cv::RNG* rng;
- CvMat* active_var_mask;
+ static Ptr<DTrees> create(const Params& params=Params());
};
/****************************************************************************************\
-* Extremely randomized trees Classifier *
+* Random Trees Classifier *
\****************************************************************************************/
-struct CV_EXPORTS CvERTreeTrainData : public CvDTreeTrainData
-{
- virtual void set_data( const CvMat* trainData, int tflag,
- const CvMat* responses, const CvMat* varIdx=0,
- const CvMat* sampleIdx=0, const CvMat* varType=0,
- const CvMat* missingDataMask=0,
- const CvDTreeParams& params=CvDTreeParams(),
- bool _shared=false, bool _add_labels=false,
- bool _update_data=false );
- virtual void get_ord_var_data( CvDTreeNode* n, int vi, float* ord_values_buf, int* missing_buf,
- const float** ord_values, const int** missing, int* sample_buf = 0 );
- virtual const int* get_sample_indices( CvDTreeNode* n, int* indices_buf );
- virtual const int* get_cv_labels( CvDTreeNode* n, int* labels_buf );
- virtual const int* get_cat_var_data( CvDTreeNode* n, int vi, int* cat_values_buf );
- 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 );
- const CvMat* missing_mask;
-};
-
-class CV_EXPORTS CvForestERTree : public CvForestTree
-{
-protected:
- virtual double calc_node_dir( CvDTreeNode* node );
- virtual CvDTreeSplit* find_split_ord_class( CvDTreeNode* n, int vi,
- float init_quality = 0, CvDTreeSplit* _split = 0, uchar* ext_buf = 0 );
- virtual CvDTreeSplit* find_split_cat_class( CvDTreeNode* n, int vi,
- float init_quality = 0, CvDTreeSplit* _split = 0, uchar* ext_buf = 0 );
- virtual CvDTreeSplit* find_split_ord_reg( CvDTreeNode* n, int vi,
- float init_quality = 0, CvDTreeSplit* _split = 0, uchar* ext_buf = 0 );
- virtual CvDTreeSplit* find_split_cat_reg( CvDTreeNode* n, int vi,
- float init_quality = 0, CvDTreeSplit* _split = 0, uchar* ext_buf = 0 );
- virtual void split_node_data( CvDTreeNode* n );
-};
-class CV_EXPORTS_W CvERTrees : public CvRTrees
+class CV_EXPORTS_W RTrees : public DTrees
{
public:
- CV_WRAP CvERTrees();
- virtual ~CvERTrees();
- virtual bool train( const CvMat* trainData, int tflag,
- const CvMat* responses, const CvMat* varIdx=0,
- const CvMat* sampleIdx=0, const CvMat* varType=0,
- const CvMat* missingDataMask=0,
- CvRTParams params=CvRTParams());
- CV_WRAP virtual bool train( const cv::Mat& trainData, int tflag,
- const cv::Mat& responses, const cv::Mat& varIdx=cv::Mat(),
- const cv::Mat& sampleIdx=cv::Mat(), const cv::Mat& varType=cv::Mat(),
- const cv::Mat& missingDataMask=cv::Mat(),
- CvRTParams params=CvRTParams());
- virtual bool train( CvMLData* data, CvRTParams params=CvRTParams() );
-protected:
- virtual cv::String getName() const;
- virtual bool grow_forest( const CvTermCriteria term_crit );
-};
+ class CV_EXPORTS_W_MAP Params : public DTrees::Params
+ {
+ public:
+ Params();
+ Params( int maxDepth, int minSampleCount,
+ double regressionAccuracy, bool useSurrogates,
+ int maxCategories, const Mat& priors,
+ bool calcVarImportance, int nactiveVars,
+ TermCriteria termCrit );
+
+ CV_PROP_RW bool calcVarImportance; // true <=> RF processes variable importance
+ CV_PROP_RW int nactiveVars;
+ CV_PROP_RW TermCriteria termCrit;
+ };
+ virtual void setRParams(const Params& p) = 0;
+ virtual Params getRParams() const = 0;
-/****************************************************************************************\
-* Boosted tree classifier *
-\****************************************************************************************/
+ virtual Mat getVarImportance() const = 0;
-struct CV_EXPORTS_W_MAP CvBoostParams : public CvDTreeParams
-{
- CV_PROP_RW int boost_type;
- CV_PROP_RW int weak_count;
- CV_PROP_RW int split_criteria;
- CV_PROP_RW 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 );
+ static Ptr<RTrees> create(const Params& params=Params());
};
+/****************************************************************************************\
+* Boosted tree classifier *
+\****************************************************************************************/
-class CvBoost;
-
-class CV_EXPORTS CvBoostTree: public CvDTree
+class CV_EXPORTS_W Boost : public DTrees
{
public:
- CvBoostTree();
- virtual ~CvBoostTree();
-
- virtual bool train( CvDTreeTrainData* trainData,
- 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* trainData, int tflag,
- const CvMat* responses, const CvMat* varIdx=0,
- const CvMat* sampleIdx=0, const CvMat* varType=0,
- const CvMat* missingDataMask=0,
- CvDTreeParams params=CvDTreeParams() );
- virtual bool train( CvDTreeTrainData* trainData, 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, uchar* ext_buf = 0 );
- virtual CvDTreeSplit* find_surrogate_split_cat( CvDTreeNode* n, int vi, uchar* ext_buf = 0 );
- virtual CvDTreeSplit* find_split_ord_class( CvDTreeNode* n, int vi,
- float init_quality = 0, CvDTreeSplit* _split = 0, uchar* ext_buf = 0 );
- virtual CvDTreeSplit* find_split_cat_class( CvDTreeNode* n, int vi,
- float init_quality = 0, CvDTreeSplit* _split = 0, uchar* ext_buf = 0 );
- virtual CvDTreeSplit* find_split_ord_reg( CvDTreeNode* n, int vi,
- float init_quality = 0, CvDTreeSplit* _split = 0, uchar* ext_buf = 0 );
- virtual CvDTreeSplit* find_split_cat_reg( CvDTreeNode* n, int vi,
- float init_quality = 0, CvDTreeSplit* _split = 0, uchar* ext_buf = 0 );
- virtual void calc_node_value( CvDTreeNode* n );
- virtual double calc_node_dir( CvDTreeNode* n );
-
- CvBoost* ensemble;
-};
-
+ class CV_EXPORTS_W_MAP Params : public DTrees::Params
+ {
+ public:
+ CV_PROP_RW int boostType;
+ CV_PROP_RW int weakCount;
+ CV_PROP_RW double weightTrimRate;
+
+ Params();
+ Params( int boostType, int weakCount, double weightTrimRate,
+ int maxDepth, bool useSurrogates, const Mat& priors );
+ };
-class CV_EXPORTS_W 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 };
-
- CV_WRAP CvBoost();
- virtual ~CvBoost();
-
- CvBoost( const CvMat* trainData, int tflag,
- const CvMat* responses, const CvMat* varIdx=0,
- const CvMat* sampleIdx=0, const CvMat* varType=0,
- const CvMat* missingDataMask=0,
- CvBoostParams params=CvBoostParams() );
-
- virtual bool train( const CvMat* trainData, int tflag,
- const CvMat* responses, const CvMat* varIdx=0,
- const CvMat* sampleIdx=0, const CvMat* varType=0,
- const CvMat* missingDataMask=0,
- CvBoostParams params=CvBoostParams(),
- bool update=false );
-
- virtual bool train( CvMLData* data,
- 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, bool return_sum=false ) const;
-
- CV_WRAP CvBoost( const cv::Mat& trainData, int tflag,
- const cv::Mat& responses, const cv::Mat& varIdx=cv::Mat(),
- const cv::Mat& sampleIdx=cv::Mat(), const cv::Mat& varType=cv::Mat(),
- const cv::Mat& missingDataMask=cv::Mat(),
- CvBoostParams params=CvBoostParams() );
-
- CV_WRAP virtual bool train( const cv::Mat& trainData, int tflag,
- const cv::Mat& responses, const cv::Mat& varIdx=cv::Mat(),
- const cv::Mat& sampleIdx=cv::Mat(), const cv::Mat& varType=cv::Mat(),
- const cv::Mat& missingDataMask=cv::Mat(),
- CvBoostParams params=CvBoostParams(),
- bool update=false );
-
- CV_WRAP virtual float predict( const cv::Mat& sample, const cv::Mat& missing=cv::Mat(),
- const cv::Range& slice=cv::Range::all(), bool rawMode=false,
- bool returnSum=false ) const;
-
- virtual float calc_error( CvMLData* _data, int type , std::vector<float> *resp = 0 ); // type in {CV_TRAIN_ERROR, CV_TEST_ERROR}
-
- CV_WRAP virtual void prune( CvSlice slice );
-
- CV_WRAP virtual void clear();
-
- virtual void write( CvFileStorage* storage, const char* name ) const;
- virtual void read( CvFileStorage* storage, CvFileNode* node );
- virtual const CvMat* get_active_vars(bool absolute_idx=true);
-
- CvSeq* get_weak_predictors();
-
- CvMat* get_weights();
- CvMat* get_subtree_weights();
- CvMat* get_weak_response();
- const CvBoostParams& get_params() const;
- const CvDTreeTrainData* get_data() 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 ) const;
- virtual void read_params( CvFileStorage* fs, CvFileNode* node );
-
- virtual void initialize_weights(double (&p)[2]);
-
- CvDTreeTrainData* data;
- CvMat train_data_hdr, responses_hdr;
- cv::Mat train_data_mat, responses_mat;
- CvBoostParams params;
- CvSeq* weak;
-
- CvMat* active_vars;
- CvMat* active_vars_abs;
- bool have_active_cat_vars;
-
- CvMat* orig_response;
- CvMat* sum_response;
- CvMat* weak_eval;
- CvMat* subsample_mask;
- CvMat* weights;
- CvMat* subtree_weights;
- bool have_subsample;
-};
+ virtual ~Boost();
+ virtual Params getBParams() const = 0;
+ virtual void setBParams(const Params& p) = 0;
+ static Ptr<Boost> create(const Params& params=Params());
+};
/****************************************************************************************\
* Gradient Boosted Trees *
\****************************************************************************************/
-// DataType: STRUCT CvGBTreesParams
-// Parameters of GBT (Gradient Boosted trees model), including single
-// tree settings and ensemble parameters.
-//
-// weak_count - count of trees in the ensemble
-// loss_function_type - loss function used for ensemble training
-// subsample_portion - portion of whole training set used for
-// every single tree training.
-// subsample_portion value is in (0.0, 1.0].
-// subsample_portion == 1.0 when whole dataset is
-// used on each step. Count of sample used on each
-// step is computed as
-// int(total_samples_count * subsample_portion).
-// shrinkage - regularization parameter.
-// Each tree prediction is multiplied on shrinkage value.
-
-
-struct CV_EXPORTS_W_MAP CvGBTreesParams : public CvDTreeParams
-{
- CV_PROP_RW int weak_count;
- CV_PROP_RW int loss_function_type;
- CV_PROP_RW float subsample_portion;
- CV_PROP_RW float shrinkage;
-
- CvGBTreesParams();
- CvGBTreesParams( int loss_function_type, int weak_count, float shrinkage,
- float subsample_portion, int max_depth, bool use_surrogates );
-};
-
-// DataType: CLASS CvGBTrees
-// Gradient Boosting Trees (GBT) algorithm implementation.
-//
-// data - training dataset
-// params - parameters of the CvGBTrees
-// weak - array[0..(class_count-1)] of CvSeq
-// for storing tree ensembles
-// orig_response - original responses of the training set samples
-// sum_response - predicitons of the current model on the training dataset.
-// this matrix is updated on every iteration.
-// sum_response_tmp - predicitons of the model on the training set on the next
-// step. On every iteration values of sum_responses_tmp are
-// computed via sum_responses values. When the current
-// step is complete sum_response values become equal to
-// sum_responses_tmp.
-// sampleIdx - indices of samples used for training the ensemble.
-// CvGBTrees training procedure takes a set of samples
-// (train_data) and a set of responses (responses).
-// Only pairs (train_data[i], responses[i]), where i is
-// in sample_idx are used for training the ensemble.
-// subsample_train - indices of samples used for training a single decision
-// tree on the current step. This indices are countered
-// relatively to the sample_idx, so that pairs
-// (train_data[sample_idx[i]], responses[sample_idx[i]])
-// are used for training a decision tree.
-// Training set is randomly splited
-// in two parts (subsample_train and subsample_test)
-// on every iteration accordingly to the portion parameter.
-// subsample_test - relative indices of samples from the training set,
-// which are not used for training a tree on the current
-// step.
-// missing - mask of the missing values in the training set. This
-// matrix has the same size as train_data. 1 - missing
-// value, 0 - not a missing value.
-// class_labels - output class labels map.
-// rng - random number generator. Used for spliting the
-// training set.
-// class_count - count of output classes.
-// class_count == 1 in the case of regression,
-// and > 1 in the case of classification.
-// delta - Huber loss function parameter.
-// base_value - start point of the gradient descent procedure.
-// model prediction is
-// f(x) = f_0 + sum_{i=1..weak_count-1}(f_i(x)), where
-// f_0 is the base value.
-
-
-
-class CV_EXPORTS_W CvGBTrees : public CvStatModel
+class CV_EXPORTS_W GBTrees : public DTrees
{
public:
+ struct CV_EXPORTS_W_MAP Params : public DTrees::Params
+ {
+ CV_PROP_RW int weakCount;
+ CV_PROP_RW int lossFunctionType;
+ CV_PROP_RW float subsamplePortion;
+ CV_PROP_RW float shrinkage;
+
+ Params();
+ Params( int lossFunctionType, int weakCount, float shrinkage,
+ float subsamplePortion, int maxDepth, bool useSurrogates );
+ };
- /*
- // DataType: ENUM
- // Loss functions implemented in CvGBTrees.
- //
- // SQUARED_LOSS
- // problem: regression
- // loss = (x - x')^2
- //
- // ABSOLUTE_LOSS
- // problem: regression
- // loss = abs(x - x')
- //
- // HUBER_LOSS
- // problem: regression
- // loss = delta*( abs(x - x') - delta/2), if abs(x - x') > delta
- // 1/2*(x - x')^2, if abs(x - x') <= delta,
- // where delta is the alpha-quantile of pseudo responses from
- // the training set.
- //
- // DEVIANCE_LOSS
- // problem: classification
- //
- */
enum {SQUARED_LOSS=0, ABSOLUTE_LOSS, HUBER_LOSS=3, DEVIANCE_LOSS};
+ virtual ~GBTrees();
+ virtual void setK(int k) = 0;
- /*
- // Default constructor. Creates a model only (without training).
- // Should be followed by one form of the train(...) function.
- //
- // API
- // CvGBTrees();
-
- // INPUT
- // OUTPUT
- // RESULT
- */
- CV_WRAP CvGBTrees();
-
-
- /*
- // Full form constructor. Creates a gradient boosting model and does the
- // train.
- //
- // API
- // CvGBTrees( const CvMat* trainData, int tflag,
- const CvMat* responses, const CvMat* varIdx=0,
- const CvMat* sampleIdx=0, const CvMat* varType=0,
- const CvMat* missingDataMask=0,
- CvGBTreesParams params=CvGBTreesParams() );
-
- // INPUT
- // trainData - a set of input feature vectors.
- // size of matrix is
- // <count of samples> x <variables count>
- // or <variables count> x <count of samples>
- // depending on the tflag parameter.
- // matrix values are float.
- // tflag - a flag showing how do samples stored in the
- // trainData matrix row by row (tflag=CV_ROW_SAMPLE)
- // or column by column (tflag=CV_COL_SAMPLE).
- // responses - a vector of responses corresponding to the samples
- // in trainData.
- // varIdx - indices of used variables. zero value means that all
- // variables are active.
- // sampleIdx - indices of used samples. zero value means that all
- // samples from trainData are in the training set.
- // varType - vector of <variables count> length. gives every
- // variable type CV_VAR_CATEGORICAL or CV_VAR_ORDERED.
- // varType = 0 means all variables are numerical.
- // missingDataMask - a mask of misiing values in trainData.
- // missingDataMask = 0 means that there are no missing
- // values.
- // params - parameters of GTB algorithm.
- // OUTPUT
- // RESULT
- */
- CvGBTrees( const CvMat* trainData, int tflag,
- const CvMat* responses, const CvMat* varIdx=0,
- const CvMat* sampleIdx=0, const CvMat* varType=0,
- const CvMat* missingDataMask=0,
- CvGBTreesParams params=CvGBTreesParams() );
-
-
- /*
- // Destructor.
- */
- virtual ~CvGBTrees();
-
-
- /*
- // Gradient tree boosting model training
- //
- // API
- // virtual bool train( const CvMat* trainData, int tflag,
- const CvMat* responses, const CvMat* varIdx=0,
- const CvMat* sampleIdx=0, const CvMat* varType=0,
- const CvMat* missingDataMask=0,
- CvGBTreesParams params=CvGBTreesParams(),
- bool update=false );
-
- // INPUT
- // trainData - a set of input feature vectors.
- // size of matrix is
- // <count of samples> x <variables count>
- // or <variables count> x <count of samples>
- // depending on the tflag parameter.
- // matrix values are float.
- // tflag - a flag showing how do samples stored in the
- // trainData matrix row by row (tflag=CV_ROW_SAMPLE)
- // or column by column (tflag=CV_COL_SAMPLE).
- // responses - a vector of responses corresponding to the samples
- // in trainData.
- // varIdx - indices of used variables. zero value means that all
- // variables are active.
- // sampleIdx - indices of used samples. zero value means that all
- // samples from trainData are in the training set.
- // varType - vector of <variables count> length. gives every
- // variable type CV_VAR_CATEGORICAL or CV_VAR_ORDERED.
- // varType = 0 means all variables are numerical.
- // missingDataMask - a mask of misiing values in trainData.
- // missingDataMask = 0 means that there are no missing
- // values.
- // params - parameters of GTB algorithm.
- // update - is not supported now. (!)
- // OUTPUT
- // RESULT
- // Error state.
- */
- virtual bool train( const CvMat* trainData, int tflag,
- const CvMat* responses, const CvMat* varIdx=0,
- const CvMat* sampleIdx=0, const CvMat* varType=0,
- const CvMat* missingDataMask=0,
- CvGBTreesParams params=CvGBTreesParams(),
- bool update=false );
-
-
- /*
- // Gradient tree boosting model training
- //
- // API
- // virtual bool train( CvMLData* data,
- CvGBTreesParams params=CvGBTreesParams(),
- bool update=false ) {return false;}
-
- // INPUT
- // data - training set.
- // params - parameters of GTB algorithm.
- // update - is not supported now. (!)
- // OUTPUT
- // RESULT
- // Error state.
- */
- virtual bool train( CvMLData* data,
- CvGBTreesParams params=CvGBTreesParams(),
- bool update=false );
-
-
- /*
- // Response value prediction
- //
- // API
- // virtual float predict_serial( const CvMat* sample, const CvMat* missing=0,
- CvMat* weak_responses=0, CvSlice slice = CV_WHOLE_SEQ,
- int k=-1 ) const;
-
- // INPUT
- // sample - input sample of the same type as in the training set.
- // missing - missing values mask. missing=0 if there are no
- // missing values in sample vector.
- // weak_responses - predictions of all of the trees.
- // not implemented (!)
- // slice - part of the ensemble used for prediction.
- // slice = CV_WHOLE_SEQ when all trees are used.
- // k - number of ensemble used.
- // k is in {-1,0,1,..,<count of output classes-1>}.
- // in the case of classification problem
- // <count of output classes-1> ensembles are built.
- // If k = -1 ordinary prediction is the result,
- // otherwise function gives the prediction of the
- // k-th ensemble only.
- // OUTPUT
- // RESULT
- // Predicted value.
- */
- virtual float predict_serial( const CvMat* sample, const CvMat* missing=0,
- CvMat* weakResponses=0, CvSlice slice = CV_WHOLE_SEQ,
- int k=-1 ) const;
-
- /*
- // Response value prediction.
- // Parallel version (in the case of TBB existence)
- //
- // API
- // virtual float predict( const CvMat* sample, const CvMat* missing=0,
- CvMat* weak_responses=0, CvSlice slice = CV_WHOLE_SEQ,
- int k=-1 ) const;
-
- // INPUT
- // sample - input sample of the same type as in the training set.
- // missing - missing values mask. missing=0 if there are no
- // missing values in sample vector.
- // weak_responses - predictions of all of the trees.
- // not implemented (!)
- // slice - part of the ensemble used for prediction.
- // slice = CV_WHOLE_SEQ when all trees are used.
- // k - number of ensemble used.
- // k is in {-1,0,1,..,<count of output classes-1>}.
- // in the case of classification problem
- // <count of output classes-1> ensembles are built.
- // If k = -1 ordinary prediction is the result,
- // otherwise function gives the prediction of the
- // k-th ensemble only.
- // OUTPUT
- // RESULT
- // Predicted value.
- */
- virtual float predict( const CvMat* sample, const CvMat* missing=0,
- CvMat* weakResponses=0, CvSlice slice = CV_WHOLE_SEQ,
- int k=-1 ) const;
-
- /*
- // Deletes all the data.
- //
- // API
- // virtual void clear();
-
- // INPUT
- // OUTPUT
- // delete data, weak, orig_response, sum_response,
- // weak_eval, subsample_train, subsample_test,
- // sample_idx, missing, lass_labels
- // delta = 0.0
- // RESULT
- */
- CV_WRAP virtual void clear();
-
- /*
- // Compute error on the train/test set.
- //
- // API
- // virtual float calc_error( CvMLData* _data, int type,
- // std::vector<float> *resp = 0 );
- //
- // INPUT
- // data - dataset
- // type - defines which error is to compute: train (CV_TRAIN_ERROR) or
- // test (CV_TEST_ERROR).
- // OUTPUT
- // resp - vector of predicitons
- // RESULT
- // Error value.
- */
- virtual float calc_error( CvMLData* _data, int type,
- std::vector<float> *resp = 0 );
-
- /*
- //
- // Write parameters of the gtb model and data. Write learned model.
- //
- // API
- // virtual void write( CvFileStorage* fs, const char* name ) const;
- //
- // INPUT
- // fs - file storage to read parameters from.
- // name - model name.
- // OUTPUT
- // RESULT
- */
- virtual void write( CvFileStorage* fs, const char* name ) const;
-
-
- /*
- //
- // Read parameters of the gtb model and data. Read learned model.
- //
- // API
- // virtual void read( CvFileStorage* fs, CvFileNode* node );
- //
- // INPUT
- // fs - file storage to read parameters from.
- // node - file node.
- // OUTPUT
- // RESULT
- */
- virtual void read( CvFileStorage* fs, CvFileNode* node );
-
-
- // new-style C++ interface
- CV_WRAP CvGBTrees( const cv::Mat& trainData, int tflag,
- const cv::Mat& responses, const cv::Mat& varIdx=cv::Mat(),
- const cv::Mat& sampleIdx=cv::Mat(), const cv::Mat& varType=cv::Mat(),
- const cv::Mat& missingDataMask=cv::Mat(),
- CvGBTreesParams params=CvGBTreesParams() );
-
- CV_WRAP virtual bool train( const cv::Mat& trainData, int tflag,
- const cv::Mat& responses, const cv::Mat& varIdx=cv::Mat(),
- const cv::Mat& sampleIdx=cv::Mat(), const cv::Mat& varType=cv::Mat(),
- const cv::Mat& missingDataMask=cv::Mat(),
- CvGBTreesParams params=CvGBTreesParams(),
- bool update=false );
-
- CV_WRAP virtual float predict( const cv::Mat& sample, const cv::Mat& missing=cv::Mat(),
- const cv::Range& slice = cv::Range::all(),
- int k=-1 ) const;
-
-protected:
-
- /*
- // Compute the gradient vector components.
- //
- // API
- // virtual void find_gradient( const int k = 0);
-
- // INPUT
- // k - used for classification problem, determining current
- // tree ensemble.
- // OUTPUT
- // changes components of data->responses
- // which correspond to samples used for training
- // on the current step.
- // RESULT
- */
- virtual void find_gradient( const int k = 0);
-
-
- /*
- //
- // Change values in tree leaves according to the used loss function.
- //
- // API
- // virtual void change_values(CvDTree* tree, const int k = 0);
- //
- // INPUT
- // tree - decision tree to change.
- // k - used for classification problem, determining current
- // tree ensemble.
- // OUTPUT
- // changes 'value' fields of the trees' leaves.
- // changes sum_response_tmp.
- // RESULT
- */
- virtual void change_values(CvDTree* tree, const int k = 0);
-
-
- /*
- //
- // Find optimal constant prediction value according to the used loss
- // function.
- // The goal is to find a constant which gives the minimal summary loss
- // on the _Idx samples.
- //
- // API
- // virtual float find_optimal_value( const CvMat* _Idx );
- //
- // INPUT
- // _Idx - indices of the samples from the training set.
- // OUTPUT
- // RESULT
- // optimal constant value.
- */
- virtual float find_optimal_value( const CvMat* _Idx );
-
-
- /*
- //
- // Randomly split the whole training set in two parts according
- // to params.portion.
- //
- // API
- // virtual void do_subsample();
- //
- // INPUT
- // OUTPUT
- // subsample_train - indices of samples used for training
- // subsample_test - indices of samples used for test
- // RESULT
- */
- virtual void do_subsample();
-
-
- /*
- //
- // Internal recursive function giving an array of subtree tree leaves.
- //
- // API
- // void leaves_get( CvDTreeNode** leaves, int& count, CvDTreeNode* node );
- //
- // INPUT
- // node - current leaf.
- // OUTPUT
- // count - count of leaves in the subtree.
- // leaves - array of pointers to leaves.
- // RESULT
- */
- void leaves_get( CvDTreeNode** leaves, int& count, CvDTreeNode* node );
-
-
- /*
- //
- // Get leaves of the tree.
- //
- // API
- // CvDTreeNode** GetLeaves( const CvDTree* dtree, int& len );
- //
- // INPUT
- // dtree - decision tree.
- // OUTPUT
- // len - count of the leaves.
- // RESULT
- // CvDTreeNode** - array of pointers to leaves.
- */
- CvDTreeNode** GetLeaves( const CvDTree* dtree, int& len );
-
-
- /*
- //
- // Is it a regression or a classification.
- //
- // API
- // bool problem_type();
- //
- // INPUT
- // OUTPUT
- // RESULT
- // false if it is a classification problem,
- // true - if regression.
- */
- virtual bool problem_type() const;
-
-
- /*
- //
- // Write parameters of the gtb model.
- //
- // API
- // virtual void write_params( CvFileStorage* fs ) const;
- //
- // INPUT
- // fs - file storage to write parameters to.
- // OUTPUT
- // RESULT
- */
- virtual void write_params( CvFileStorage* fs ) const;
-
-
- /*
- //
- // Read parameters of the gtb model and data.
- //
- // API
- // virtual void read_params( CvFileStorage* fs );
- //
- // INPUT
- // fs - file storage to read parameters from.
- // OUTPUT
- // params - parameters of the gtb model.
- // data - contains information about the structure
- // of the data set (count of variables,
- // their types, etc.).
- // class_labels - output class labels map.
- // RESULT
- */
- virtual void read_params( CvFileStorage* fs, CvFileNode* fnode );
- int get_len(const CvMat* mat) const;
-
-
- CvDTreeTrainData* data;
- CvGBTreesParams params;
-
- CvSeq** weak;
- CvMat* orig_response;
- CvMat* sum_response;
- CvMat* sum_response_tmp;
- CvMat* sample_idx;
- CvMat* subsample_train;
- CvMat* subsample_test;
- CvMat* missing;
- CvMat* class_labels;
-
- cv::RNG* rng;
-
- int class_count;
- float delta;
- float base_value;
+ virtual float predictSerial( InputArray samples,
+ OutputArray weakResponses, int flags) const;
+ static Ptr<GBTrees> create(const Params& p);
};
-
-
/****************************************************************************************\
* Artificial Neural Networks (ANN) *
\****************************************************************************************/
/////////////////////////////////// Multi-Layer Perceptrons //////////////////////////////
-struct CV_EXPORTS_W_MAP 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 };
-
- CV_PROP_RW CvTermCriteria term_crit;
- CV_PROP_RW int train_method;
-
- // backpropagation parameters
- CV_PROP_RW double bp_dw_scale, bp_moment_scale;
-
- // rprop parameters
- CV_PROP_RW double rp_dw0, rp_dw_plus, rp_dw_minus, rp_dw_min, rp_dw_max;
-};
-
-
-class CV_EXPORTS_W CvANN_MLP : public CvStatModel
+class CV_EXPORTS_W ANN_MLP : public StatModel
{
public:
- CV_WRAP CvANN_MLP();
- CvANN_MLP( const CvMat* layerSizes,
- int activateFunc=CvANN_MLP::SIGMOID_SYM,
- double fparam1=0, double fparam2=0 );
-
- virtual ~CvANN_MLP();
-
- virtual void create( const CvMat* layerSizes,
- int activateFunc=CvANN_MLP::SIGMOID_SYM,
- double fparam1=0, double fparam2=0 );
-
- virtual int train( const CvMat* inputs, const CvMat* outputs,
- const CvMat* sampleWeights, const CvMat* sampleIdx=0,
- CvANN_MLP_TrainParams params = CvANN_MLP_TrainParams(),
- int flags=0 );
- virtual float predict( const CvMat* inputs, CV_OUT CvMat* outputs ) const;
+ struct CV_EXPORTS_W_MAP Params
+ {
+ Params();
+ Params( TermCriteria termCrit, int trainMethod, double param1, double param2=0 );
- CV_WRAP CvANN_MLP( const cv::Mat& layerSizes,
- int activateFunc=CvANN_MLP::SIGMOID_SYM,
- double fparam1=0, double fparam2=0 );
+ enum { BACKPROP=0, RPROP=1 };
- CV_WRAP virtual void create( const cv::Mat& layerSizes,
- int activateFunc=CvANN_MLP::SIGMOID_SYM,
- double fparam1=0, double fparam2=0 );
+ CV_PROP_RW TermCriteria termCrit;
+ CV_PROP_RW int trainMethod;
- CV_WRAP virtual int train( const cv::Mat& inputs, const cv::Mat& outputs,
- const cv::Mat& sampleWeights, const cv::Mat& sampleIdx=cv::Mat(),
- CvANN_MLP_TrainParams params = CvANN_MLP_TrainParams(),
- int flags=0 );
+ // backpropagation parameters
+ CV_PROP_RW double bpDWScale, bpMomentScale;
- CV_WRAP virtual float predict( const cv::Mat& inputs, CV_OUT cv::Mat& outputs ) const;
+ // rprop parameters
+ CV_PROP_RW double rpDW0, rpDWPlus, rpDWMinus, rpDWMin, rpDWMax;
+ };
- CV_WRAP virtual void clear();
+ virtual ~ANN_MLP();
// 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 ) const;
+ virtual Mat getLayerSizes() const = 0;
+ virtual Mat getWeights(int layerIdx) const = 0;
+ virtual void setParams(const Params& p) = 0;
+ virtual Params getParams() const = 0;
- 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;
- }
-
- virtual void calc_activ_func_deriv( CvMat* xf, CvMat* deriv, const double* bias ) const;
-
-protected:
-
- virtual bool prepare_to_train( const CvMat* _inputs, const CvMat* _outputs,
- const CvMat* _sample_weights, const CvMat* sampleIdx,
- 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 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 ) const;
- 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;
- cv::RNG* rng;
+ static Ptr<ANN_MLP> create(InputArray layerSizes=noArray(),
+ const Params& params=Params(),
+ int activateFunc=ANN_MLP::SIGMOID_SYM,
+ double fparam1=0, double fparam2=0);
};
/****************************************************************************************\
/* 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) );
+CV_EXPORTS void randMVNormal( InputArray mean, InputArray cov, int nsamples, OutputArray samples);
/* 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
+CV_EXPORTS void randGaussMixture( InputArray means, InputArray covs, InputArray weights,
+ int nsamples, OutputArray samples, OutputArray sampClasses );
/* creates test set */
-CVAPI(void) cvCreateTestSet( int type, CvMat** samples,
- int num_samples,
- int num_features,
- CvMat** responses,
- int num_classes, ... );
-
-/****************************************************************************************\
-* Data *
-\****************************************************************************************/
-
-#define CV_COUNT 0
-#define CV_PORTION 1
-
-struct CV_EXPORTS CvTrainTestSplit
-{
- CvTrainTestSplit();
- CvTrainTestSplit( int train_sample_count, bool mix = true);
- CvTrainTestSplit( float train_sample_portion, bool mix = true);
-
- union
- {
- int count;
- float portion;
- } train_sample_part;
- int train_sample_part_mode;
-
- bool mix;
-};
-
-class CV_EXPORTS CvMLData
-{
-public:
- CvMLData();
- virtual ~CvMLData();
-
- // returns:
- // 0 - OK
- // -1 - file can not be opened or is not correct
- int read_csv( const char* filename );
-
- const CvMat* get_values() const;
- const CvMat* get_responses();
- const CvMat* get_missing() const;
-
- void set_header_lines_number( int n );
- int get_header_lines_number() const;
-
- void set_response_idx( int idx ); // old response become predictors, new response_idx = idx
- // if idx < 0 there will be no response
- int get_response_idx() const;
-
- void set_train_test_split( const CvTrainTestSplit * spl );
- const CvMat* get_train_sample_idx() const;
- const CvMat* get_test_sample_idx() const;
- void mix_train_and_test_idx();
-
- const CvMat* get_var_idx();
- void chahge_var_idx( int vi, bool state ); // misspelled (saved for back compitability),
- // use change_var_idx
- void change_var_idx( int vi, bool state ); // state == true to set vi-variable as predictor
-
- const CvMat* get_var_types();
- int get_var_type( int var_idx ) const;
- // following 2 methods enable to change vars type
- // use these methods to assign CV_VAR_CATEGORICAL type for categorical variable
- // with numerical labels; in the other cases var types are correctly determined automatically
- void set_var_types( const char* str ); // str examples:
- // "ord[0-17],cat[18]", "ord[0,2,4,10-12], cat[1,3,5-9,13,14]",
- // "cat", "ord" (all vars are categorical/ordered)
- void change_var_type( int var_idx, int type); // type in { CV_VAR_ORDERED, CV_VAR_CATEGORICAL }
-
- void set_delimiter( char ch );
- char get_delimiter() const;
-
- void set_miss_ch( char ch );
- char get_miss_ch() const;
-
- const std::map<cv::String, int>& get_class_labels_map() const;
-
-protected:
- virtual void clear();
-
- void str_to_flt_elem( const char* token, float& flt_elem, int& type);
- void free_train_test_idx();
-
- char delimiter;
- char miss_ch;
- //char flt_separator;
+CV_EXPORTS void createConcentricSpheresTestSet( int nsamples, int nfeatures, int nclasses,
+ OutputArray samples, OutputArray responses);
- CvMat* values;
- CvMat* missing;
- CvMat* var_types;
- CvMat* var_idx_mask;
-
- CvMat* response_out; // header
- CvMat* var_idx_out; // mat
- CvMat* var_types_out; // mat
-
- int header_lines_number;
-
- int response_idx;
-
- int train_sample_count;
- bool mix;
-
- int total_class_count;
- std::map<cv::String, int> class_map;
-
- CvMat* train_sample_idx;
- CvMat* test_sample_idx;
- int* sample_idx; // data of train_sample_idx and test_sample_idx
-
- cv::RNG* rng;
-};
-
-
-namespace cv
-{
-
-typedef CvStatModel StatModel;
-typedef CvParamGrid ParamGrid;
-typedef CvNormalBayesClassifier NormalBayesClassifier;
-typedef CvKNearest KNearest;
-typedef CvSVMParams SVMParams;
-typedef CvSVMKernel SVMKernel;
-typedef CvSVMSolver SVMSolver;
-typedef CvSVM SVM;
-typedef CvDTreeParams DTreeParams;
-typedef CvMLData TrainData;
-typedef CvDTree DecisionTree;
-typedef CvForestTree ForestTree;
-typedef CvRTParams RandomTreeParams;
-typedef CvRTrees RandomTrees;
-typedef CvERTreeTrainData ERTreeTRainData;
-typedef CvForestERTree ERTree;
-typedef CvERTrees ERTrees;
-typedef CvBoostParams BoostParams;
-typedef CvBoostTree BoostTree;
-typedef CvBoost Boost;
-typedef CvANN_MLP_TrainParams ANN_MLP_TrainParams;
-typedef CvANN_MLP NeuralNet_MLP;
-typedef CvGBTreesParams GradientBoostingTreeParams;
-typedef CvGBTrees GradientBoostingTrees;
-
-template<> CV_EXPORTS void DefaultDeleter<CvDTreeSplit>::operator ()(CvDTreeSplit* obj) const;
-
-CV_EXPORTS bool initModule_ml(void);
+}
}
#endif // __cplusplus
#include "precomp.hpp"
-CvANN_MLP_TrainParams::CvANN_MLP_TrainParams()
+namespace cv { namespace ml {
+
+ANN_MLP::~ANN_MLP() {}
+
+ANN_MLP::Params::Params()
{
- term_crit = cvTermCriteria( CV_TERMCRIT_ITER + CV_TERMCRIT_EPS, 1000, 0.01 );
- train_method = RPROP;
- bp_dw_scale = bp_moment_scale = 0.1;
- rp_dw0 = 0.1; rp_dw_plus = 1.2; rp_dw_minus = 0.5;
- rp_dw_min = FLT_EPSILON; rp_dw_max = 50.;
+ termCrit = TermCriteria( TermCriteria::COUNT + TermCriteria::EPS, 1000, 0.01 );
+ trainMethod = RPROP;
+ bpDWScale = bpMomentScale = 0.1;
+ rpDW0 = 0.1; rpDWPlus = 1.2; rpDWMinus = 0.5;
+ rpDWMin = FLT_EPSILON; rpDWMax = 50.;
}
-CvANN_MLP_TrainParams::CvANN_MLP_TrainParams( CvTermCriteria _term_crit,
- int _train_method,
- double _param1, double _param2 )
+ANN_MLP::Params::Params( TermCriteria _termCrit, int _trainMethod, double _param1, double _param2 )
{
- term_crit = _term_crit;
- train_method = _train_method;
- bp_dw_scale = bp_moment_scale = 0.1;
- rp_dw0 = 1.; rp_dw_plus = 1.2; rp_dw_minus = 0.5;
- rp_dw_min = FLT_EPSILON; rp_dw_max = 50.;
+ termCrit = _termCrit;
+ trainMethod = _trainMethod;
+ bpDWScale = bpMomentScale = 0.1;
+ rpDW0 = 1.; rpDWPlus = 1.2; rpDWMinus = 0.5;
+ rpDWMin = FLT_EPSILON; rpDWMax = 50.;
- if( train_method == RPROP )
+ if( trainMethod == RPROP )
{
- rp_dw0 = _param1;
- if( rp_dw0 < FLT_EPSILON )
- rp_dw0 = 1.;
- rp_dw_min = _param2;
- rp_dw_min = MAX( rp_dw_min, 0 );
+ rpDW0 = _param1;
+ if( rpDW0 < FLT_EPSILON )
+ rpDW0 = 1.;
+ rpDWMin = _param2;
+ rpDWMin = std::max( rpDWMin, 0. );
}
- else if( train_method == BACKPROP )
+ else if( trainMethod == BACKPROP )
{
- bp_dw_scale = _param1;
- if( bp_dw_scale <= 0 )
- bp_dw_scale = 0.1;
- bp_dw_scale = MAX( bp_dw_scale, 1e-3 );
- bp_dw_scale = MIN( bp_dw_scale, 1 );
- bp_moment_scale = _param2;
- if( bp_moment_scale < 0 )
- bp_moment_scale = 0.1;
- bp_moment_scale = MIN( bp_moment_scale, 1 );
+ bpDWScale = _param1;
+ if( bpDWScale <= 0 )
+ bpDWScale = 0.1;
+ bpDWScale = std::max( bpDWScale, 1e-3 );
+ bpDWScale = std::min( bpDWScale, 1. );
+ bpMomentScale = _param2;
+ if( bpMomentScale < 0 )
+ bpMomentScale = 0.1;
+ bpMomentScale = std::min( bpMomentScale, 1. );
}
else
- train_method = RPROP;
-}
-
-
-CvANN_MLP_TrainParams::~CvANN_MLP_TrainParams()
-{
-}
-
-
-CvANN_MLP::CvANN_MLP()
-{
- layer_sizes = wbuf = 0;
- min_val = max_val = min_val1 = max_val1 = 0.;
- weights = 0;
- rng = &cv::theRNG();
- default_model_name = "my_nn";
- clear();
-}
-
-
-CvANN_MLP::CvANN_MLP( const CvMat* _layer_sizes,
- int _activ_func,
- double _f_param1, double _f_param2 )
-{
- layer_sizes = wbuf = 0;
- min_val = max_val = min_val1 = max_val1 = 0.;
- weights = 0;
- rng = &cv::theRNG();
- default_model_name = "my_nn";
- create( _layer_sizes, _activ_func, _f_param1, _f_param2 );
-}
-
-
-CvANN_MLP::~CvANN_MLP()
-{
- clear();
-}
-
-
-void CvANN_MLP::clear()
-{
- cvReleaseMat( &layer_sizes );
- cvReleaseMat( &wbuf );
- cvFree( &weights );
- activ_func = SIGMOID_SYM;
- f_param1 = f_param2 = 1;
- max_buf_sz = 1 << 12;
+ trainMethod = RPROP;
}
-void CvANN_MLP::set_activ_func( int _activ_func, double _f_param1, double _f_param2 )
+class ANN_MLPImpl : public ANN_MLP
{
- CV_FUNCNAME( "CvANN_MLP::set_activ_func" );
-
- __BEGIN__;
-
- if( _activ_func < 0 || _activ_func > GAUSSIAN )
- CV_ERROR( CV_StsOutOfRange, "Unknown activation function" );
-
- activ_func = _activ_func;
-
- switch( activ_func )
+public:
+ ANN_MLPImpl()
{
- case SIGMOID_SYM:
- max_val = 0.95; min_val = -max_val;
- max_val1 = 0.98; min_val1 = -max_val1;
- if( fabs(_f_param1) < FLT_EPSILON )
- _f_param1 = 2./3;
- if( fabs(_f_param2) < FLT_EPSILON )
- _f_param2 = 1.7159;
- break;
- case GAUSSIAN:
- max_val = 1.; min_val = 0.05;
- max_val1 = 1.; min_val1 = 0.02;
- if( fabs(_f_param1) < FLT_EPSILON )
- _f_param1 = 1.;
- if( fabs(_f_param2) < FLT_EPSILON )
- _f_param2 = 1.;
- break;
- default:
- min_val = max_val = min_val1 = max_val1 = 0.;
- _f_param1 = 1.;
- _f_param2 = 0.;
+ clear();
}
- f_param1 = _f_param1;
- f_param2 = _f_param2;
-
- __END__;
-}
-
-
-void CvANN_MLP::init_weights()
-{
- int i, j, k;
-
- for( i = 1; i < layer_sizes->cols; i++ )
+ ANN_MLPImpl( const Mat& _layer_sizes, int _activ_func,
+ double _f_param1, double _f_param2 )
{
- int n1 = layer_sizes->data.i[i-1];
- int n2 = layer_sizes->data.i[i];
- double val = 0, G = n2 > 2 ? 0.7*pow((double)n1,1./(n2-1)) : 1.;
- double* w = weights[i];
-
- // initialize weights using Nguyen-Widrow algorithm
- for( j = 0; j < n2; j++ )
- {
- double s = 0;
- for( k = 0; k <= n1; k++ )
- {
- val = rng->uniform(0., 1.)*2-1.;
- w[k*n2 + j] = val;
- s += fabs(val);
- }
-
- if( i < layer_sizes->cols - 1 )
- {
- s = 1./(s - fabs(val));
- for( k = 0; k <= n1; k++ )
- w[k*n2 + j] *= s;
- w[n1*n2 + j] *= G*(-1+j*2./n2);
- }
- }
+ clear();
+ create( _layer_sizes, _activ_func, _f_param1, _f_param2 );
}
-}
+ virtual ~ANN_MLPImpl() {}
-void CvANN_MLP::create( const CvMat* _layer_sizes, int _activ_func,
- double _f_param1, double _f_param2 )
-{
- CV_FUNCNAME( "CvANN_MLP::create" );
-
- __BEGIN__;
-
- int i, l_step, l_count, buf_sz = 0;
- int *l_src, *l_dst;
-
- clear();
-
- if( !CV_IS_MAT(_layer_sizes) ||
- (_layer_sizes->cols != 1 && _layer_sizes->rows != 1) ||
- CV_MAT_TYPE(_layer_sizes->type) != CV_32SC1 )
- CV_ERROR( CV_StsBadArg,
- "The array of layer neuron counters must be an integer vector" );
-
- CV_CALL( set_activ_func( _activ_func, _f_param1, _f_param2 ));
-
- l_count = _layer_sizes->rows + _layer_sizes->cols - 1;
- l_src = _layer_sizes->data.i;
- l_step = CV_IS_MAT_CONT(_layer_sizes->type) ? 1 :
- _layer_sizes->step / sizeof(l_src[0]);
- CV_CALL( layer_sizes = cvCreateMat( 1, l_count, CV_32SC1 ));
- l_dst = layer_sizes->data.i;
-
- max_count = 0;
- for( i = 0; i < l_count; i++ )
+ void clear()
{
- int n = l_src[i*l_step];
- if( n < 1 + (0 < i && i < l_count-1))
- CV_ERROR( CV_StsOutOfRange,
- "there should be at least one input and one output "
- "and every hidden layer must have more than 1 neuron" );
- l_dst[i] = n;
- max_count = MAX( max_count, n );
- if( i > 0 )
- buf_sz += (l_dst[i-1]+1)*n;
+ min_val = max_val = min_val1 = max_val1 = 0.;
+ rng = RNG(-1);
+ weights.clear();
+ trained = false;
}
- buf_sz += (l_dst[0] + l_dst[l_count-1]*2)*2;
-
- CV_CALL( wbuf = cvCreateMat( 1, buf_sz, CV_64F ));
- CV_CALL( weights = (double**)cvAlloc( (l_count+2)*sizeof(weights[0]) ));
+ int layer_count() const { return (int)layer_sizes.size(); }
- weights[0] = wbuf->data.db;
- weights[1] = weights[0] + l_dst[0]*2;
- for( i = 1; i < l_count; i++ )
- weights[i+1] = weights[i] + (l_dst[i-1] + 1)*l_dst[i];
- weights[l_count+1] = weights[l_count] + l_dst[l_count-1]*2;
+ void set_activ_func( int _activ_func, double _f_param1, double _f_param2 )
+ {
+ if( _activ_func < 0 || _activ_func > GAUSSIAN )
+ CV_Error( CV_StsOutOfRange, "Unknown activation function" );
- __END__;
-}
+ activ_func = _activ_func;
+ switch( activ_func )
+ {
+ case SIGMOID_SYM:
+ max_val = 0.95; min_val = -max_val;
+ max_val1 = 0.98; min_val1 = -max_val1;
+ if( fabs(_f_param1) < FLT_EPSILON )
+ _f_param1 = 2./3;
+ if( fabs(_f_param2) < FLT_EPSILON )
+ _f_param2 = 1.7159;
+ break;
+ case GAUSSIAN:
+ max_val = 1.; min_val = 0.05;
+ max_val1 = 1.; min_val1 = 0.02;
+ if( fabs(_f_param1) < FLT_EPSILON )
+ _f_param1 = 1.;
+ if( fabs(_f_param2) < FLT_EPSILON )
+ _f_param2 = 1.;
+ break;
+ default:
+ min_val = max_val = min_val1 = max_val1 = 0.;
+ _f_param1 = 1.;
+ _f_param2 = 0.;
+ }
-float CvANN_MLP::predict( const CvMat* _inputs, CvMat* _outputs ) const
-{
- int i, j, n, dn = 0, l_count, dn0, buf_sz, min_buf_sz;
-
- if( !layer_sizes )
- CV_Error( CV_StsError, "The network has not been initialized" );
-
- if( !CV_IS_MAT(_inputs) || !CV_IS_MAT(_outputs) ||
- !CV_ARE_TYPES_EQ(_inputs,_outputs) ||
- (CV_MAT_TYPE(_inputs->type) != CV_32FC1 &&
- CV_MAT_TYPE(_inputs->type) != CV_64FC1) ||
- _inputs->rows != _outputs->rows )
- CV_Error( CV_StsBadArg, "Both input and output must be floating-point matrices "
- "of the same type and have the same number of rows" );
-
- if( _inputs->cols != layer_sizes->data.i[0] )
- CV_Error( CV_StsBadSize, "input matrix must have the same number of columns as "
- "the number of neurons in the input layer" );
-
- if( _outputs->cols != layer_sizes->data.i[layer_sizes->cols - 1] )
- CV_Error( CV_StsBadSize, "output matrix must have the same number of columns as "
- "the number of neurons in the output layer" );
- n = dn0 = _inputs->rows;
- min_buf_sz = 2*max_count;
- buf_sz = n*min_buf_sz;
-
- if( buf_sz > max_buf_sz )
- {
- dn0 = max_buf_sz/min_buf_sz;
- dn0 = MAX( dn0, 1 );
- buf_sz = dn0*min_buf_sz;
+ f_param1 = _f_param1;
+ f_param2 = _f_param2;
}
- cv::AutoBuffer<double> buf(buf_sz);
- l_count = layer_sizes->cols;
- for( i = 0; i < n; i += dn )
+ void init_weights()
{
- CvMat hdr[2], _w, *layer_in = &hdr[0], *layer_out = &hdr[1], *temp;
- dn = MIN( dn0, n - i );
+ int i, j, k, l_count = layer_count();
- cvGetRows( _inputs, layer_in, i, i + dn );
- cvInitMatHeader( layer_out, dn, layer_in->cols, CV_64F, &buf[0] );
-
- scale_input( layer_in, layer_out );
- CV_SWAP( layer_in, layer_out, temp );
-
- for( j = 1; j < l_count; j++ )
+ for( i = 1; i < l_count; i++ )
{
- double* data = buf + (j&1 ? max_count*dn0 : 0);
- int cols = layer_sizes->data.i[j];
+ int n1 = layer_sizes[i-1];
+ int n2 = layer_sizes[i];
+ double val = 0, G = n2 > 2 ? 0.7*pow((double)n1,1./(n2-1)) : 1.;
+ double* w = weights[i].ptr<double>();
- cvInitMatHeader( layer_out, dn, cols, CV_64F, data );
- cvInitMatHeader( &_w, layer_in->cols, layer_out->cols, CV_64F, weights[j] );
- cvGEMM( layer_in, &_w, 1, 0, 0, layer_out );
- calc_activ_func( layer_out, _w.data.db + _w.rows*_w.cols );
+ // initialize weights using Nguyen-Widrow algorithm
+ for( j = 0; j < n2; j++ )
+ {
+ double s = 0;
+ for( k = 0; k <= n1; k++ )
+ {
+ val = rng.uniform(0., 1.)*2-1.;
+ w[k*n2 + j] = val;
+ s += fabs(val);
+ }
- CV_SWAP( layer_in, layer_out, temp );
+ if( i < l_count - 1 )
+ {
+ s = 1./(s - fabs(val));
+ for( k = 0; k <= n1; k++ )
+ w[k*n2 + j] *= s;
+ w[n1*n2 + j] *= G*(-1+j*2./n2);
+ }
+ }
}
-
- cvGetRows( _outputs, layer_out, i, i + dn );
- scale_output( layer_in, layer_out );
}
- return 0.f;
-}
-
-
-void CvANN_MLP::scale_input( const CvMat* _src, CvMat* _dst ) const
-{
- int i, j, cols = _src->cols;
- double* dst = _dst->data.db;
- const double* w = weights[0];
- int step = _src->step;
-
- if( CV_MAT_TYPE( _src->type ) == CV_32F )
- {
- const float* src = _src->data.fl;
- step /= sizeof(src[0]);
-
- for( i = 0; i < _src->rows; i++, src += step, dst += cols )
- for( j = 0; j < cols; j++ )
- dst[j] = src[j]*w[j*2] + w[j*2+1];
- }
- else
+ void create( InputArray _layer_sizes, int _activ_func,
+ double _f_param1, double _f_param2 )
{
- const double* src = _src->data.db;
- step /= sizeof(src[0]);
+ clear();
- for( i = 0; i < _src->rows; i++, src += step, dst += cols )
- for( j = 0; j < cols; j++ )
- dst[j] = src[j]*w[j*2] + w[j*2+1];
- }
-}
+ _layer_sizes.copyTo(layer_sizes);
+ int l_count = layer_count();
+ set_activ_func( _activ_func, _f_param1, _f_param2 );
-void CvANN_MLP::scale_output( const CvMat* _src, CvMat* _dst ) const
-{
- int i, j, cols = _src->cols;
- const double* src = _src->data.db;
- const double* w = weights[layer_sizes->cols];
- int step = _dst->step;
-
- if( CV_MAT_TYPE( _dst->type ) == CV_32F )
- {
- float* dst = _dst->data.fl;
- step /= sizeof(dst[0]);
+ weights.resize(l_count + 2);
+ max_lsize = 0;
- for( i = 0; i < _src->rows; i++, src += cols, dst += step )
- for( j = 0; j < cols; j++ )
- dst[j] = (float)(src[j]*w[j*2] + w[j*2+1]);
- }
- else
- {
- double* dst = _dst->data.db;
- step /= sizeof(dst[0]);
+ if( l_count > 0 )
+ {
+ for( int i = 0; i < l_count; i++ )
+ {
+ int n = layer_sizes[i];
+ if( n < 1 + (0 < i && i < l_count-1))
+ CV_Error( CV_StsOutOfRange,
+ "there should be at least one input and one output "
+ "and every hidden layer must have more than 1 neuron" );
+ max_lsize = std::max( max_lsize, n );
+ if( i > 0 )
+ weights[i].create(layer_sizes[i-1]+1, n, CV_64F);
+ }
- for( i = 0; i < _src->rows; i++, src += cols, dst += step )
- for( j = 0; j < cols; j++ )
- dst[j] = src[j]*w[j*2] + w[j*2+1];
+ int ninputs = layer_sizes.front();
+ int noutputs = layer_sizes.back();
+ weights[0].create(1, ninputs*2, CV_64F);
+ weights[l_count].create(1, noutputs*2, CV_64F);
+ weights[l_count+1].create(1, noutputs*2, CV_64F);
+ }
}
-}
-
-void CvANN_MLP::calc_activ_func( CvMat* sums, const double* bias ) const
-{
- int i, j, n = sums->rows, cols = sums->cols;
- double* data = sums->data.db;
- double scale = 0, scale2 = f_param2;
-
- switch( activ_func )
+ float predict( InputArray _inputs, OutputArray _outputs, int ) const
{
- case IDENTITY:
- scale = 1.;
- break;
- case SIGMOID_SYM:
- scale = -f_param1;
- break;
- case GAUSSIAN:
- scale = -f_param1*f_param1;
- break;
- default:
- ;
- }
+ if( !trained )
+ CV_Error( CV_StsError, "The network has not been trained or loaded" );
- assert( CV_IS_MAT_CONT(sums->type) );
+ Mat inputs = _inputs.getMat();
+ int type = inputs.type(), l_count = layer_count();
+ int n = inputs.rows, dn0 = n;
- if( activ_func != GAUSSIAN )
- {
- for( i = 0; i < n; i++, data += cols )
- for( j = 0; j < cols; j++ )
- data[j] = (data[j] + bias[j])*scale;
+ CV_Assert( (type == CV_32F || type == CV_64F) && inputs.cols == layer_sizes[0] );
+ _outputs.create(n, layer_sizes[l_count-1], type);
- if( activ_func == IDENTITY )
- return;
- }
- else
- {
- for( i = 0; i < n; i++, data += cols )
- for( j = 0; j < cols; j++ )
- {
- double t = data[j] + bias[j];
- data[j] = t*t*scale;
- }
- }
-
- cvExp( sums, sums );
+ Mat outputs = _outputs.getMat();
- n *= cols;
- data -= n;
+ int min_buf_sz = 2*max_lsize;
+ int buf_sz = n*min_buf_sz;
- switch( activ_func )
- {
- case SIGMOID_SYM:
- for( i = 0; i <= n - 4; i += 4 )
+ if( buf_sz > max_buf_sz )
{
- double x0 = 1.+data[i], x1 = 1.+data[i+1], x2 = 1.+data[i+2], x3 = 1.+data[i+3];
- double a = x0*x1, b = x2*x3, d = scale2/(a*b), t0, t1;
- a *= d; b *= d;
- t0 = (2 - x0)*b*x1; t1 = (2 - x1)*b*x0;
- data[i] = t0; data[i+1] = t1;
- t0 = (2 - x2)*a*x3; t1 = (2 - x3)*a*x2;
- data[i+2] = t0; data[i+3] = t1;
+ dn0 = max_buf_sz/min_buf_sz;
+ dn0 = std::max( dn0, 1 );
+ buf_sz = dn0*min_buf_sz;
}
- for( ; i < n; i++ )
+ cv::AutoBuffer<double> _buf(buf_sz);
+ double* buf = _buf;
+
+ int dn = 0;
+ for( int i = 0; i < n; i += dn )
{
- double t = scale2*(1. - data[i])/(1. + data[i]);
- data[i] = t;
- }
- break;
+ dn = std::min( dn0, n - i );
- case GAUSSIAN:
- for( i = 0; i < n; i++ )
- data[i] = scale2*data[i];
- break;
+ Mat layer_in = inputs.rowRange(i, i + dn);
+ Mat layer_out( dn, layer_in.cols, CV_64F, buf);
- default:
- ;
- }
-}
+ scale_input( layer_in, layer_out );
+ layer_in = layer_out;
+ for( int j = 1; j < l_count; j++ )
+ {
+ double* data = buf + ((j&1) ? max_lsize*dn0 : 0);
+ int cols = layer_sizes[j];
-void CvANN_MLP::calc_activ_func_deriv( CvMat* _xf, CvMat* _df,
- const double* bias ) const
-{
- int i, j, n = _xf->rows, cols = _xf->cols;
- double* xf = _xf->data.db;
- double* df = _df->data.db;
- double scale, scale2 = f_param2;
- assert( CV_IS_MAT_CONT( _xf->type & _df->type ) );
+ layer_out = Mat(dn, cols, CV_64F, data);
+ Mat w = weights[i].rowRange(0, layer_in.cols);
+ gemm(layer_in, w, 1, noArray(), 0, layer_out);
+ calc_activ_func( layer_out, weights[i] );
- if( activ_func == IDENTITY )
- {
- for( i = 0; i < n; i++, xf += cols, df += cols )
- for( j = 0; j < cols; j++ )
- {
- xf[j] += bias[j];
- df[j] = 1;
- }
- return;
- }
- else if( activ_func == GAUSSIAN )
- {
- scale = -f_param1*f_param1;
- scale2 *= scale;
- for( i = 0; i < n; i++, xf += cols, df += cols )
- for( j = 0; j < cols; j++ )
- {
- double t = xf[j] + bias[j];
- df[j] = t*2*scale2;
- xf[j] = t*t*scale;
+ layer_in = layer_out;
}
- cvExp( _xf, _xf );
- n *= cols;
- xf -= n; df -= n;
+ layer_out = outputs.rowRange(i, i + dn);
+ scale_output( layer_in, layer_out );
+ }
- for( i = 0; i < n; i++ )
- df[i] *= xf[i];
+ return 0.f;
}
- else
+
+ void scale_input( const Mat& _src, Mat& _dst ) const
{
- scale = f_param1;
- for( i = 0; i < n; i++, xf += cols, df += cols )
- for( j = 0; j < cols; j++ )
+ int cols = _src.cols;
+ const double* w = weights[0].ptr<double>();
+
+ if( _src.type() == CV_32F )
+ {
+ for( int i = 0; i < _src.rows; i++ )
{
- xf[j] = (xf[j] + bias[j])*scale;
- df[j] = -fabs(xf[j]);
+ const float* src = _src.ptr<float>(i);
+ double* dst = _dst.ptr<double>(i);
+ for( int j = 0; j < cols; j++ )
+ dst[j] = src[j]*w[j*2] + w[j*2+1];
}
-
- cvExp( _df, _df );
-
- n *= cols;
- xf -= n; df -= n;
-
- // ((1+exp(-ax))^-1)'=a*((1+exp(-ax))^-2)*exp(-ax);
- // ((1-exp(-ax))/(1+exp(-ax)))'=(a*exp(-ax)*(1+exp(-ax)) + a*exp(-ax)*(1-exp(-ax)))/(1+exp(-ax))^2=
- // 2*a*exp(-ax)/(1+exp(-ax))^2
- scale *= 2*f_param2;
- for( i = 0; i < n; i++ )
+ }
+ else
{
- int s0 = xf[i] > 0 ? 1 : -1;
- double t0 = 1./(1. + df[i]);
- double t1 = scale*df[i]*t0*t0;
- t0 *= scale2*(1. - df[i])*s0;
- df[i] = t1;
- xf[i] = t0;
+ for( int i = 0; i < _src.rows; i++ )
+ {
+ const float* src = _src.ptr<float>(i);
+ double* dst = _dst.ptr<double>(i);
+ for( int j = 0; j < cols; j++ )
+ dst[j] = src[j]*w[j*2] + w[j*2+1];
+ }
}
}
-}
-
-
-void CvANN_MLP::calc_input_scale( const CvVectors* vecs, int flags )
-{
- bool reset_weights = (flags & UPDATE_WEIGHTS) == 0;
- bool no_scale = (flags & NO_INPUT_SCALE) != 0;
- double* scale = weights[0];
- int count = vecs->count;
- if( reset_weights )
+ void scale_output( const Mat& _src, Mat& _dst ) const
{
- int i, j, vcount = layer_sizes->data.i[0];
- int type = vecs->type;
- double a = no_scale ? 1. : 0.;
+ int cols = _src.cols;
+ const double* w = weights[layer_count()].ptr<double>();
- for( j = 0; j < vcount; j++ )
- scale[2*j] = a, scale[j*2+1] = 0.;
-
- if( no_scale )
- return;
-
- for( i = 0; i < count; i++ )
+ if( _dst.type() == CV_32F )
{
- const float* f = vecs->data.fl[i];
- const double* d = vecs->data.db[i];
- for( j = 0; j < vcount; j++ )
+ for( int i = 0; i < _src.rows; i++ )
{
- double t = type == CV_32F ? (double)f[j] : d[j];
- scale[j*2] += t;
- scale[j*2+1] += t*t;
+ const double* src = _src.ptr<double>(i);
+ float* dst = _dst.ptr<float>(i);
+ for( int j = 0; j < cols; j++ )
+ dst[j] = (float)(src[j]*w[j*2] + w[j*2+1]);
}
}
-
- for( j = 0; j < vcount; j++ )
+ else
{
- double s = scale[j*2], s2 = scale[j*2+1];
- double m = s/count, sigma2 = s2/count - m*m;
- scale[j*2] = sigma2 < DBL_EPSILON ? 1 : 1./sqrt(sigma2);
- scale[j*2+1] = -m*scale[j*2];
+ for( int i = 0; i < _src.rows; i++ )
+ {
+ const double* src = _src.ptr<double>(i);
+ double* dst = _dst.ptr<double>(i);
+ for( int j = 0; j < cols; j++ )
+ dst[j] = src[j]*w[j*2] + w[j*2+1];
+ }
}
}
-}
-
-
-void CvANN_MLP::calc_output_scale( const CvVectors* vecs, int flags )
-{
- int i, j, vcount = layer_sizes->data.i[layer_sizes->cols-1];
- int type = vecs->type;
- double m = min_val, M = max_val, m1 = min_val1, M1 = max_val1;
- bool reset_weights = (flags & UPDATE_WEIGHTS) == 0;
- bool no_scale = (flags & NO_OUTPUT_SCALE) != 0;
- int l_count = layer_sizes->cols;
- double* scale = weights[l_count];
- double* inv_scale = weights[l_count+1];
- int count = vecs->count;
-
- CV_FUNCNAME( "CvANN_MLP::calc_output_scale" );
- __BEGIN__;
-
- if( reset_weights )
+ void calc_activ_func( Mat& sums, const Mat& w ) const
{
- double a0 = no_scale ? 1 : DBL_MAX, b0 = no_scale ? 0 : -DBL_MAX;
+ const double* bias = w.ptr<double>(w.rows-1);
+ int i, j, n = sums.rows, cols = sums.cols;
+ double scale = 0, scale2 = f_param2;
- for( j = 0; j < vcount; j++ )
+ switch( activ_func )
{
- scale[2*j] = inv_scale[2*j] = a0;
- scale[j*2+1] = inv_scale[2*j+1] = b0;
+ case IDENTITY:
+ scale = 1.;
+ break;
+ case SIGMOID_SYM:
+ scale = -f_param1;
+ break;
+ case GAUSSIAN:
+ scale = -f_param1*f_param1;
+ break;
+ default:
+ ;
}
- if( no_scale )
- EXIT;
- }
-
- for( i = 0; i < count; i++ )
- {
- const float* f = vecs->data.fl[i];
- const double* d = vecs->data.db[i];
+ CV_Assert( sums.isContinuous() );
- for( j = 0; j < vcount; j++ )
+ if( activ_func != GAUSSIAN )
{
- double t = type == CV_32F ? (double)f[j] : d[j];
-
- if( reset_weights )
+ for( i = 0; i < n; i++ )
{
- double mj = scale[j*2], Mj = scale[j*2+1];
- if( mj > t ) mj = t;
- if( Mj < t ) Mj = t;
-
- scale[j*2] = mj;
- scale[j*2+1] = Mj;
+ double* data = sums.ptr<double>(i);
+ for( j = 0; j < cols; j++ )
+ data[j] = (data[j] + bias[j])*scale;
}
- else
+
+ if( activ_func == IDENTITY )
+ return;
+ }
+ else
+ {
+ for( i = 0; i < n; i++ )
{
- t = t*inv_scale[j*2] + inv_scale[2*j+1];
- if( t < m1 || t > M1 )
- CV_ERROR( CV_StsOutOfRange,
- "Some of new output training vector components run exceed the original range too much" );
+ double* data = sums.ptr<double>(i);
+ for( j = 0; j < cols; j++ )
+ {
+ double t = data[j] + bias[j];
+ data[j] = t*t*scale;
+ }
}
}
- }
- if( reset_weights )
- for( j = 0; j < vcount; j++ )
+ exp( sums, sums );
+
+ if( sums.isContinuous() )
{
- // map mj..Mj to m..M
- double mj = scale[j*2], Mj = scale[j*2+1];
- double a, b;
- double delta = Mj - mj;
- if( delta < DBL_EPSILON )
- a = 1, b = (M + m - Mj - mj)*0.5;
- else
- a = (M - m)/delta, b = m - mj*a;
- inv_scale[j*2] = a; inv_scale[j*2+1] = b;
- a = 1./a; b = -b*a;
- scale[j*2] = a; scale[j*2+1] = b;
+ cols *= n;
+ n = 1;
}
- __END__;
-}
+ switch( activ_func )
+ {
+ case SIGMOID_SYM:
+ for( i = 0; i < n; i++ )
+ {
+ double* data = sums.ptr<double>(i);
+ for( j = 0; j < cols; j++ )
+ {
+ double t = scale2*(1. - data[j])/(1. + data[j]);
+ data[j] = t;
+ }
+ }
+ break;
+ case GAUSSIAN:
+ for( i = 0; i < n; j++ )
+ {
+ double* data = sums.ptr<double>(i);
+ for( j = 0; j < cols; j++ )
+ data[j] = scale2*data[j];
+ }
+ break;
-bool CvANN_MLP::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 )
-{
- bool ok = false;
- CvMat* sample_idx = 0;
- CvVectors ivecs, ovecs;
- double* sw = 0;
- int count = 0;
-
- CV_FUNCNAME( "CvANN_MLP::prepare_to_train" );
-
- ivecs.data.ptr = ovecs.data.ptr = 0;
- assert( _ivecs && _ovecs );
-
- __BEGIN__;
-
- const int* sidx = 0;
- int i, sw_type = 0, sw_count = 0;
- int sw_step = 0;
- double sw_sum = 0;
-
- if( !layer_sizes )
- CV_ERROR( CV_StsError,
- "The network has not been created. Use method create or the appropriate constructor" );
-
- if( !CV_IS_MAT(_inputs) || (CV_MAT_TYPE(_inputs->type) != CV_32FC1 &&
- CV_MAT_TYPE(_inputs->type) != CV_64FC1) || _inputs->cols != layer_sizes->data.i[0] )
- CV_ERROR( CV_StsBadArg,
- "input training data should be a floating-point matrix with"
- "the number of rows equal to the number of training samples and "
- "the number of columns equal to the size of 0-th (input) layer" );
-
- if( !CV_IS_MAT(_outputs) || (CV_MAT_TYPE(_outputs->type) != CV_32FC1 &&
- CV_MAT_TYPE(_outputs->type) != CV_64FC1) ||
- _outputs->cols != layer_sizes->data.i[layer_sizes->cols - 1] )
- CV_ERROR( CV_StsBadArg,
- "output training data should be a floating-point matrix with"
- "the number of rows equal to the number of training samples and "
- "the number of columns equal to the size of last (output) layer" );
-
- if( _inputs->rows != _outputs->rows )
- CV_ERROR( CV_StsUnmatchedSizes, "The numbers of input and output samples do not match" );
-
- if( _sample_idx )
- {
- CV_CALL( sample_idx = cvPreprocessIndexArray( _sample_idx, _inputs->rows ));
- sidx = sample_idx->data.i;
- count = sample_idx->cols + sample_idx->rows - 1;
+ default:
+ ;
+ }
}
- else
- count = _inputs->rows;
- if( _sample_weights )
+ void calc_activ_func_deriv( Mat& _xf, Mat& _df, const Mat& w ) const
{
- if( !CV_IS_MAT(_sample_weights) )
- CV_ERROR( CV_StsBadArg, "sample_weights (if passed) must be a valid matrix" );
-
- sw_type = CV_MAT_TYPE(_sample_weights->type);
- sw_count = _sample_weights->cols + _sample_weights->rows - 1;
-
- if( (sw_type != CV_32FC1 && sw_type != CV_64FC1) ||
- (_sample_weights->cols != 1 && _sample_weights->rows != 1) ||
- (sw_count != count && sw_count != _inputs->rows) )
- CV_ERROR( CV_StsBadArg,
- "sample_weights must be 1d floating-point vector containing weights "
- "of all or selected training samples" );
+ const double* bias = w.ptr<double>(w.rows-1);
+ int i, j, n = _xf.rows, cols = _xf.cols;
- sw_step = CV_IS_MAT_CONT(_sample_weights->type) ? 1 :
- _sample_weights->step/CV_ELEM_SIZE(sw_type);
+ if( activ_func == IDENTITY )
+ {
+ for( i = 0; i < n; i++ )
+ {
+ double* xf = _xf.ptr<double>(i);
+ double* df = _df.ptr<double>(i);
- CV_CALL( sw = (double*)cvAlloc( count*sizeof(sw[0]) ));
- }
+ for( j = 0; j < cols; j++ )
+ {
+ xf[j] += bias[j];
+ df[j] = 1;
+ }
+ }
+ }
+ else if( activ_func == GAUSSIAN )
+ {
+ double scale = -f_param1*f_param1;
+ double scale2 = scale*f_param2;
+ for( i = 0; i < n; i++ )
+ {
+ double* xf = _xf.ptr<double>(i);
+ double* df = _df.ptr<double>(i);
- CV_CALL( ivecs.data.ptr = (uchar**)cvAlloc( count*sizeof(ivecs.data.ptr[0]) ));
- CV_CALL( ovecs.data.ptr = (uchar**)cvAlloc( count*sizeof(ovecs.data.ptr[0]) ));
+ for( j = 0; j < cols; j++ )
+ {
+ double t = xf[j] + bias[j];
+ df[j] = t*2*scale2;
+ xf[j] = t*t*scale;
+ }
+ }
+ exp( _xf, _xf );
- ivecs.type = CV_MAT_TYPE(_inputs->type);
- ovecs.type = CV_MAT_TYPE(_outputs->type);
- ivecs.count = ovecs.count = count;
+ for( i = 0; i < n; i++ )
+ {
+ double* xf = _xf.ptr<double>(i);
+ double* df = _df.ptr<double>(i);
- for( i = 0; i < count; i++ )
- {
- int idx = sidx ? sidx[i] : i;
- ivecs.data.ptr[i] = _inputs->data.ptr + idx*_inputs->step;
- ovecs.data.ptr[i] = _outputs->data.ptr + idx*_outputs->step;
- if( sw )
- {
- int si = sw_count == count ? i : idx;
- double w = sw_type == CV_32FC1 ?
- (double)_sample_weights->data.fl[si*sw_step] :
- _sample_weights->data.db[si*sw_step];
- sw[i] = w;
- if( w < 0 )
- CV_ERROR( CV_StsOutOfRange, "some of sample weights are negative" );
- sw_sum += w;
+ for( j = 0; j < cols; j++ )
+ df[j] *= xf[j];
+ }
}
- }
+ else
+ {
+ double scale = f_param1;
+ double scale2 = f_param2;
- // normalize weights
- if( sw )
- {
- sw_sum = sw_sum > DBL_EPSILON ? 1./sw_sum : 0;
- for( i = 0; i < count; i++ )
- sw[i] *= sw_sum;
- }
+ for( i = 0; i < n; i++ )
+ {
+ double* xf = _xf.ptr<double>(i);
+ double* df = _df.ptr<double>(i);
- calc_input_scale( &ivecs, _flags );
- CV_CALL( calc_output_scale( &ovecs, _flags ));
+ for( j = 0; j < cols; j++ )
+ {
+ xf[j] = (xf[j] + bias[j])*scale;
+ df[j] = -fabs(xf[j]);
+ }
+ }
- ok = true;
+ exp( _df, _df );
- __END__;
+ // ((1+exp(-ax))^-1)'=a*((1+exp(-ax))^-2)*exp(-ax);
+ // ((1-exp(-ax))/(1+exp(-ax)))'=(a*exp(-ax)*(1+exp(-ax)) + a*exp(-ax)*(1-exp(-ax)))/(1+exp(-ax))^2=
+ // 2*a*exp(-ax)/(1+exp(-ax))^2
+ scale *= 2*f_param2;
+ for( i = 0; i < n; i++ )
+ {
+ double* xf = _xf.ptr<double>(i);
+ double* df = _df.ptr<double>(i);
- if( !ok )
- {
- cvFree( &ivecs.data.ptr );
- cvFree( &ovecs.data.ptr );
- cvFree( &sw );
+ for( j = 0; j < cols; j++ )
+ {
+ int s0 = xf[j] > 0 ? 1 : -1;
+ double t0 = 1./(1. + df[j]);
+ double t1 = scale*df[j]*t0*t0;
+ t0 *= scale2*(1. - df[j])*s0;
+ df[j] = t1;
+ xf[j] = t0;
+ }
+ }
+ }
}
- cvReleaseMat( &sample_idx );
- *_ivecs = ivecs;
- *_ovecs = ovecs;
- *_sw = sw;
-
- return ok;
-}
+ void calc_input_scale( const Mat& inputs, int flags )
+ {
+ bool reset_weights = (flags & UPDATE_WEIGHTS) == 0;
+ bool no_scale = (flags & NO_INPUT_SCALE) != 0;
+ double* scale = weights[0].ptr<double>();
+ int count = inputs.rows;
+ if( reset_weights )
+ {
+ int i, j, vcount = layer_sizes[0];
+ int type = inputs.type();
+ double a = no_scale ? 1. : 0.;
-int CvANN_MLP::train( const CvMat* _inputs, const CvMat* _outputs,
- const CvMat* _sample_weights, const CvMat* _sample_idx,
- CvANN_MLP_TrainParams _params, int flags )
-{
- const int MAX_ITER = 1000;
- const double DEFAULT_EPSILON = FLT_EPSILON;
+ for( j = 0; j < vcount; j++ )
+ scale[2*j] = a, scale[j*2+1] = 0.;
- double* sw = 0;
- CvVectors x0, u;
- int iter = -1;
+ if( no_scale )
+ return;
- x0.data.ptr = u.data.ptr = 0;
+ for( i = 0; i < count; i++ )
+ {
+ const uchar* p = inputs.ptr(i);
+ const float* f = (const float*)p;
+ const double* d = (const double*)p;
+ for( j = 0; j < vcount; j++ )
+ {
+ double t = type == CV_32F ? (double)f[j] : d[j];
+ scale[j*2] += t;
+ scale[j*2+1] += t*t;
+ }
+ }
- CV_FUNCNAME( "CvANN_MLP::train" );
+ for( j = 0; j < vcount; j++ )
+ {
+ double s = scale[j*2], s2 = scale[j*2+1];
+ double m = s/count, sigma2 = s2/count - m*m;
+ scale[j*2] = sigma2 < DBL_EPSILON ? 1 : 1./sqrt(sigma2);
+ scale[j*2+1] = -m*scale[j*2];
+ }
+ }
+ }
- __BEGIN__;
+ void calc_output_scale( const Mat& outputs, int flags )
+ {
+ int i, j, vcount = layer_sizes.back();
+ int type = outputs.type();
+ double m = min_val, M = max_val, m1 = min_val1, M1 = max_val1;
+ bool reset_weights = (flags & UPDATE_WEIGHTS) == 0;
+ bool no_scale = (flags & NO_OUTPUT_SCALE) != 0;
+ int l_count = layer_count();
+ double* scale = weights[l_count].ptr<double>();
+ double* inv_scale = weights[l_count+1].ptr<double>();
+ int count = outputs.rows;
+
+ if( reset_weights )
+ {
+ double a0 = no_scale ? 1 : DBL_MAX, b0 = no_scale ? 0 : -DBL_MAX;
- int max_iter;
- double epsilon;
+ for( j = 0; j < vcount; j++ )
+ {
+ scale[2*j] = inv_scale[2*j] = a0;
+ scale[j*2+1] = inv_scale[2*j+1] = b0;
+ }
- params = _params;
+ if( no_scale )
+ return;
+ }
- // initialize training data
- CV_CALL( prepare_to_train( _inputs, _outputs, _sample_weights,
- _sample_idx, &x0, &u, &sw, flags ));
+ for( i = 0; i < count; i++ )
+ {
+ const uchar* p = outputs.ptr(i);
+ const float* f = (const float*)p;
+ const double* d = (const double*)p;
- // ... and link weights
- if( !(flags & UPDATE_WEIGHTS) )
- init_weights();
+ for( j = 0; j < vcount; j++ )
+ {
+ double t = type == CV_32F ? (double)f[j] : d[j];
- max_iter = params.term_crit.type & CV_TERMCRIT_ITER ? params.term_crit.max_iter : MAX_ITER;
- max_iter = MAX( max_iter, 1 );
+ if( reset_weights )
+ {
+ double mj = scale[j*2], Mj = scale[j*2+1];
+ if( mj > t ) mj = t;
+ if( Mj < t ) Mj = t;
- epsilon = params.term_crit.type & CV_TERMCRIT_EPS ? params.term_crit.epsilon : DEFAULT_EPSILON;
- epsilon = MAX(epsilon, DBL_EPSILON);
+ scale[j*2] = mj;
+ scale[j*2+1] = Mj;
+ }
+ else
+ {
+ t = t*inv_scale[j*2] + inv_scale[2*j+1];
+ if( t < m1 || t > M1 )
+ CV_Error( CV_StsOutOfRange,
+ "Some of new output training vector components run exceed the original range too much" );
+ }
+ }
+ }
- params.term_crit.type = CV_TERMCRIT_ITER + CV_TERMCRIT_EPS;
- params.term_crit.max_iter = max_iter;
- params.term_crit.epsilon = epsilon;
+ if( reset_weights )
+ for( j = 0; j < vcount; j++ )
+ {
+ // map mj..Mj to m..M
+ double mj = scale[j*2], Mj = scale[j*2+1];
+ double a, b;
+ double delta = Mj - mj;
+ if( delta < DBL_EPSILON )
+ a = 1, b = (M + m - Mj - mj)*0.5;
+ else
+ a = (M - m)/delta, b = m - mj*a;
+ inv_scale[j*2] = a; inv_scale[j*2+1] = b;
+ a = 1./a; b = -b*a;
+ scale[j*2] = a; scale[j*2+1] = b;
+ }
+ }
- if( params.train_method == CvANN_MLP_TrainParams::BACKPROP )
+ void prepare_to_train( const Mat& inputs, const Mat& outputs,
+ Mat& sample_weights, int flags )
{
- CV_CALL( iter = train_backprop( x0, u, sw ));
+ if( layer_sizes.empty() )
+ CV_Error( CV_StsError,
+ "The network has not been created. Use method create or the appropriate constructor" );
+
+ if( (inputs.type() != CV_32F && inputs.type() != CV_64F) ||
+ inputs.cols != layer_sizes[0] )
+ CV_Error( CV_StsBadArg,
+ "input training data should be a floating-point matrix with "
+ "the number of rows equal to the number of training samples and "
+ "the number of columns equal to the size of 0-th (input) layer" );
+
+ if( (outputs.type() != CV_32F && outputs.type() != CV_64F) ||
+ outputs.cols != layer_sizes.back() )
+ CV_Error( CV_StsBadArg,
+ "output training data should be a floating-point matrix with "
+ "the number of rows equal to the number of training samples and "
+ "the number of columns equal to the size of last (output) layer" );
+
+ if( inputs.rows != outputs.rows )
+ CV_Error( CV_StsUnmatchedSizes, "The numbers of input and output samples do not match" );
+
+ Mat temp;
+ double s = sum(sample_weights)[0];
+ sample_weights.convertTo(temp, CV_64F, 1./s);
+ sample_weights = temp;
+
+ calc_input_scale( inputs, flags );
+ calc_output_scale( outputs, flags );
}
- else
+
+ void setParams( const Params& _params )
{
- CV_CALL( iter = train_rprop( x0, u, sw ));
+ params = _params;
}
- __END__;
-
- cvFree( &x0.data.ptr );
- cvFree( &u.data.ptr );
- cvFree( &sw );
-
- return iter;
-}
+ Params getParams() const
+ {
+ return params;
+ }
+ bool train( const Ptr<TrainData>& trainData, int flags )
+ {
+ const int MAX_ITER = 1000;
+ const double DEFAULT_EPSILON = FLT_EPSILON;
-int CvANN_MLP::train_backprop( CvVectors x0, CvVectors u, const double* sw )
-{
- CvMat* dw = 0;
- CvMat* buf = 0;
- double **x = 0, **df = 0;
- CvMat* _idx = 0;
- int iter = -1, count = x0.count;
+ // initialize training data
+ Mat inputs = trainData->getTrainSamples();
+ Mat outputs = trainData->getTrainResponses();
+ Mat sw = trainData->getTrainSampleWeights();
+ prepare_to_train( inputs, outputs, sw, flags );
- CV_FUNCNAME( "CvANN_MLP::train_backprop" );
+ // ... and link weights
+ if( !(flags & UPDATE_WEIGHTS) )
+ init_weights();
- __BEGIN__;
+ TermCriteria termcrit;
+ termcrit.type = TermCriteria::COUNT + TermCriteria::EPS;
+ termcrit.maxCount = std::max((params.termCrit.type & CV_TERMCRIT_ITER ? params.termCrit.maxCount : MAX_ITER), 1);
+ termcrit.epsilon = std::max((params.termCrit.type & CV_TERMCRIT_EPS ? params.termCrit.epsilon : DEFAULT_EPSILON), DBL_EPSILON);
- int i, j, k, ivcount, ovcount, l_count, total = 0, max_iter;
- double *buf_ptr;
- double prev_E = DBL_MAX*0.5, E = 0, epsilon;
+ int iter = params.trainMethod == Params::BACKPROP ?
+ train_backprop( inputs, outputs, sw, termcrit ) :
+ train_rprop( inputs, outputs, sw, termcrit );
- max_iter = params.term_crit.max_iter*count;
- epsilon = params.term_crit.epsilon*count;
+ return iter;
+ }
- l_count = layer_sizes->cols;
- ivcount = layer_sizes->data.i[0];
- ovcount = layer_sizes->data.i[l_count-1];
+ int train_backprop( const Mat& inputs, const Mat& outputs, const Mat& _sw, TermCriteria termCrit )
+ {
+ int i, j, k;
+ double prev_E = DBL_MAX*0.5, E = 0;
+ int itype = inputs.type(), otype = outputs.type();
- // allocate buffers
- for( i = 0; i < l_count; i++ )
- total += layer_sizes->data.i[i] + 1;
+ int count = inputs.rows;
- CV_CALL( dw = cvCreateMat( wbuf->rows, wbuf->cols, wbuf->type ));
- cvZero( dw );
- CV_CALL( buf = cvCreateMat( 1, (total + max_count)*2, CV_64F ));
- CV_CALL( _idx = cvCreateMat( 1, count, CV_32SC1 ));
- for( i = 0; i < count; i++ )
- _idx->data.i[i] = i;
+ int iter = -1, max_iter = termCrit.maxCount*count;
+ double epsilon = termCrit.epsilon*count;
- CV_CALL( x = (double**)cvAlloc( total*2*sizeof(x[0]) ));
- df = x + total;
- buf_ptr = buf->data.db;
+ int l_count = layer_count();
+ int ivcount = layer_sizes[0];
+ int ovcount = layer_sizes.back();
- for( j = 0; j < l_count; j++ )
- {
- x[j] = buf_ptr;
- df[j] = x[j] + layer_sizes->data.i[j];
- buf_ptr += (df[j] - x[j])*2;
- }
+ // allocate buffers
+ vector<vector<double> > x(l_count);
+ vector<vector<double> > df(l_count);
+ vector<Mat> dw(l_count);
- // run back-propagation loop
- /*
- y_i = w_i*x_{i-1}
- x_i = f(y_i)
- E = 1/2*||u - x_N||^2
- grad_N = (x_N - u)*f'(y_i)
- dw_i(t) = momentum*dw_i(t-1) + dw_scale*x_{i-1}*grad_i
- w_i(t+1) = w_i(t) + dw_i(t)
- grad_{i-1} = w_i^t*grad_i
- */
- for( iter = 0; iter < max_iter; iter++ )
- {
- int idx = iter % count;
- double* w = weights[0];
- double sweight = sw ? count*sw[idx] : 1.;
- CvMat _w, _dw, hdr1, hdr2, ghdr1, ghdr2, _df;
- CvMat *x1 = &hdr1, *x2 = &hdr2, *grad1 = &ghdr1, *grad2 = &ghdr2, *temp;
+ for( i = 0; i < l_count; i++ )
+ {
+ int n = layer_sizes[i];
+ x[i].resize(n);
+ df[i].resize(n);
+ dw[i].create(weights[i].size(), CV_64F);
+ }
- if( idx == 0 )
+ Mat _idx_m(1, count, CV_32S);
+ int* _idx = _idx_m.ptr<int>();
+ for( i = 0; i < count; i++ )
+ _idx[i] = i;
+
+ AutoBuffer<double> _buf(max_lsize*2);
+ double* buf[] = { _buf, (double*)_buf + max_lsize };
+
+ const double* sw = _sw.empty() ? 0 : _sw.ptr<double>();
+
+ // run back-propagation loop
+ /*
+ y_i = w_i*x_{i-1}
+ x_i = f(y_i)
+ E = 1/2*||u - x_N||^2
+ grad_N = (x_N - u)*f'(y_i)
+ dw_i(t) = momentum*dw_i(t-1) + dw_scale*x_{i-1}*grad_i
+ w_i(t+1) = w_i(t) + dw_i(t)
+ grad_{i-1} = w_i^t*grad_i
+ */
+ for( iter = 0; iter < max_iter; iter++ )
{
- //printf("%d. E = %g\n", iter/count, E);
- if( fabs(prev_E - E) < epsilon )
- break;
- prev_E = E;
- E = 0;
+ int idx = iter % count;
+ double sweight = sw ? count*sw[idx] : 1.;
- // shuffle indices
- for( i = 0; i < count; i++ )
+ if( idx == 0 )
{
- int tt;
- j = (*rng)(count);
- k = (*rng)(count);
- CV_SWAP( _idx->data.i[j], _idx->data.i[k], tt );
+ //printf("%d. E = %g\n", iter/count, E);
+ if( fabs(prev_E - E) < epsilon )
+ break;
+ prev_E = E;
+ E = 0;
+
+ // shuffle indices
+ for( i = 0; i < count; i++ )
+ {
+ j = rng.uniform(0, count);
+ k = rng.uniform(0, count);
+ std::swap(_idx[j], _idx[k]);
+ }
}
- }
- idx = _idx->data.i[idx];
+ idx = _idx[idx];
- if( x0.type == CV_32F )
- {
- const float* x0data = x0.data.fl[idx];
- for( j = 0; j < ivcount; j++ )
- x[0][j] = x0data[j]*w[j*2] + w[j*2 + 1];
- }
- else
- {
- const double* x0data = x0.data.db[idx];
+ const uchar* x0data_p = inputs.ptr(idx);
+ const float* x0data_f = (const float*)x0data_p;
+ const double* x0data_d = (const double*)x0data_p;
+
+ double* w = weights[0].ptr<double>();
for( j = 0; j < ivcount; j++ )
- x[0][j] = x0data[j]*w[j*2] + w[j*2 + 1];
- }
+ x[0][j] = (itype == CV_32F ? (double)x0data_f[j] : x0data_d[j])*w[j*2] + w[j*2 + 1];
- cvInitMatHeader( x1, 1, ivcount, CV_64F, x[0] );
+ Mat x1( 1, ivcount, CV_64F, &x[0][0] );
- // forward pass, compute y[i]=w*x[i-1], x[i]=f(y[i]), df[i]=f'(y[i])
- for( i = 1; i < l_count; i++ )
- {
- cvInitMatHeader( x2, 1, layer_sizes->data.i[i], CV_64F, x[i] );
- cvInitMatHeader( &_w, x1->cols, x2->cols, CV_64F, weights[i] );
- cvGEMM( x1, &_w, 1, 0, 0, x2 );
- _df = *x2;
- _df.data.db = df[i];
- calc_activ_func_deriv( x2, &_df, _w.data.db + _w.rows*_w.cols );
- CV_SWAP( x1, x2, temp );
- }
+ // forward pass, compute y[i]=w*x[i-1], x[i]=f(y[i]), df[i]=f'(y[i])
+ for( i = 1; i < l_count; i++ )
+ {
+ int n = layer_sizes[i];
+ Mat x2(1, n, CV_64F, &x[i][0] );
+ Mat _w = weights[i].rowRange(0, x1.cols);
+ gemm(x1, _w, 1, noArray(), 0, x2);
+ Mat _df(1, n, CV_64F, &df[i][0] );
+ calc_activ_func_deriv( x2, _df, weights[i] );
+ x1 = x2;
+ }
- cvInitMatHeader( grad1, 1, ovcount, CV_64F, buf_ptr );
- *grad2 = *grad1;
- grad2->data.db = buf_ptr + max_count;
+ Mat grad1( 1, ovcount, CV_64F, buf[l_count&1] );
+ w = weights[l_count+1].ptr<double>();
- w = weights[l_count+1];
+ // calculate error
+ const uchar* udata_p = outputs.ptr(idx);
+ const float* udata_f = (const float*)udata_p;
+ const double* udata_d = (const double*)udata_p;
- // calculate error
- if( u.type == CV_32F )
- {
- const float* udata = u.data.fl[idx];
+ double* gdata = grad1.ptr<double>();
for( k = 0; k < ovcount; k++ )
{
- double t = udata[k]*w[k*2] + w[k*2+1] - x[l_count-1][k];
- grad1->data.db[k] = t*sweight;
+ double t = (otype == CV_32F ? (double)udata_f[k] : udata_d[k])*w[k*2] + w[k*2+1] - x[l_count-1][k];
+ gdata[k] = t*sweight;
E += t*t;
}
- }
- else
- {
- const double* udata = u.data.db[idx];
- for( k = 0; k < ovcount; k++ )
- {
- double t = udata[k]*w[k*2] + w[k*2+1] - x[l_count-1][k];
- grad1->data.db[k] = t*sweight;
- E += t*t;
- }
- }
- E *= sweight;
+ E *= sweight;
- // backward pass, update weights
- for( i = l_count-1; i > 0; i-- )
- {
- int n1 = layer_sizes->data.i[i-1], n2 = layer_sizes->data.i[i];
- cvInitMatHeader( &_df, 1, n2, CV_64F, df[i] );
- cvMul( grad1, &_df, grad1 );
- cvInitMatHeader( &_w, n1+1, n2, CV_64F, weights[i] );
- cvInitMatHeader( &_dw, n1+1, n2, CV_64F, dw->data.db + (weights[i] - weights[0]) );
- cvInitMatHeader( x1, n1+1, 1, CV_64F, x[i-1] );
- x[i-1][n1] = 1.;
- cvGEMM( x1, grad1, params.bp_dw_scale, &_dw, params.bp_moment_scale, &_dw );
- cvAdd( &_w, &_dw, &_w );
- if( i > 1 )
+ // backward pass, update weights
+ for( i = l_count-1; i > 0; i-- )
{
- grad2->cols = n1;
- _w.rows = n1;
- cvGEMM( grad1, &_w, 1, 0, 0, grad2, CV_GEMM_B_T );
+ int n1 = layer_sizes[i-1], n2 = layer_sizes[i];
+ Mat _df(1, n2, CV_64F, &df[i][0]);
+ multiply( grad1, _df, grad1 );
+ Mat _x(n1+1, 1, CV_64F, &x[i-1][0]);
+ x[i-1][n1] = 1.;
+ gemm( _x, grad1, params.bpDWScale, dw[i], params.bpMomentScale, dw[i] );
+ add( weights[i], dw[i], weights[i] );
+ if( i > 1 )
+ {
+ Mat grad2(1, n1, CV_64F, buf[i&1]);
+ Mat _w = weights[i].rowRange(0, n1);
+ gemm( grad1, _w, 1, noArray(), 0, grad2, GEMM_2_T );
+ grad1 = grad2;
+ }
}
- CV_SWAP( grad1, grad2, temp );
}
- }
-
- iter /= count;
-
- __END__;
-
- cvReleaseMat( &dw );
- cvReleaseMat( &buf );
- cvReleaseMat( &_idx );
- cvFree( &x );
- return iter;
-}
-
-struct rprop_loop : cv::ParallelLoopBody {
- rprop_loop(const CvANN_MLP* _point, double**& _weights, int& _count, int& _ivcount, CvVectors* _x0,
- int& _l_count, CvMat*& _layer_sizes, int& _ovcount, int& _max_count,
- CvVectors* _u, const double*& _sw, double& _inv_count, CvMat*& _dEdw, int& _dcount0, double* _E, int _buf_sz)
- {
- point = _point;
- weights = _weights;
- count = _count;
- ivcount = _ivcount;
- x0 = _x0;
- l_count = _l_count;
- layer_sizes = _layer_sizes;
- ovcount = _ovcount;
- max_count = _max_count;
- u = _u;
- sw = _sw;
- inv_count = _inv_count;
- dEdw = _dEdw;
- dcount0 = _dcount0;
- E = _E;
- buf_sz = _buf_sz;
- }
-
- const CvANN_MLP* point;
- double** weights;
- int count;
- int ivcount;
- CvVectors* x0;
- int l_count;
- CvMat* layer_sizes;
- int ovcount;
- int max_count;
- CvVectors* u;
- const double* sw;
- double inv_count;
- CvMat* dEdw;
- int dcount0;
- double* E;
- int buf_sz;
-
-
- void operator()( const cv::Range& range ) const
- {
- double* buf_ptr;
- double** x = 0;
- double **df = 0;
- int total = 0;
-
- for(int i = 0; i < l_count; i++ )
- total += layer_sizes->data.i[i];
- CvMat* buf;
- buf = cvCreateMat( 1, buf_sz, CV_64F );
- x = (double**)cvAlloc( total*2*sizeof(x[0]) );
- df = x + total;
- buf_ptr = buf->data.db;
- for(int i = 0; i < l_count; i++ )
- {
- x[i] = buf_ptr;
- df[i] = x[i] + layer_sizes->data.i[i]*dcount0;
- buf_ptr += (df[i] - x[i])*2;
+ iter /= count;
+ return iter;
}
- for(int si = range.start; si < range.end; si++ )
- {
- if (si % dcount0 != 0) continue;
- int n1, n2, k;
- double* w;
- CvMat _w, _dEdw, hdr1, hdr2, ghdr1, ghdr2, _df;
- CvMat *x1, *x2, *grad1, *grad2, *temp;
- int dcount = 0;
-
- dcount = MIN(count - si , dcount0 );
- w = weights[0];
- grad1 = &ghdr1; grad2 = &ghdr2;
- x1 = &hdr1; x2 = &hdr2;
-
- // grab and preprocess input data
- if( x0->type == CV_32F )
+ struct RPropLoop : public ParallelLoopBody
{
- for(int i = 0; i < dcount; i++ )
- {
- const float* x0data = x0->data.fl[si+i];
- double* xdata = x[0]+i*ivcount;
- for(int j = 0; j < ivcount; j++ )
- xdata[j] = x0data[j]*w[j*2] + w[j*2+1];
- }
- }
- else
- for(int i = 0; i < dcount; i++ )
- {
- const double* x0data = x0->data.db[si+i];
- double* xdata = x[0]+i*ivcount;
- for(int j = 0; j < ivcount; j++ )
- xdata[j] = x0data[j]*w[j*2] + w[j*2+1];
- }
- cvInitMatHeader( x1, dcount, ivcount, CV_64F, x[0] );
-
- // forward pass, compute y[i]=w*x[i-1], x[i]=f(y[i]), df[i]=f'(y[i])
- for(int i = 1; i < l_count; i++ )
+ RPropLoop(ANN_MLPImpl* _ann,
+ const Mat& _inputs, const Mat& _outputs, const Mat& _sw,
+ int _dcount0, vector<Mat>& _dEdw, double* _E)
{
- cvInitMatHeader( x2, dcount, layer_sizes->data.i[i], CV_64F, x[i] );
- cvInitMatHeader( &_w, x1->cols, x2->cols, CV_64F, weights[i] );
- cvGEMM( x1, &_w, 1, 0, 0, x2 );
- _df = *x2;
- _df.data.db = df[i];
- point->calc_activ_func_deriv( x2, &_df, _w.data.db + _w.rows*_w.cols );
- CV_SWAP( x1, x2, temp );
+ ann = _ann;
+ inputs = _inputs;
+ outputs = _outputs;
+ sw = _sw.ptr<double>();
+ dcount0 = _dcount0;
+ dEdw = &_dEdw;
+ pE = _E;
}
- cvInitMatHeader( grad1, dcount, ovcount, CV_64F, buf_ptr );
- w = weights[l_count+1];
- grad2->data.db = buf_ptr + max_count*dcount;
+ ANN_MLPImpl* ann;
+ vector<Mat>* dEdw;
+ Mat inputs, outputs;
+ const double* sw;
+ int dcount0;
+ double* pE;
- // calculate error
- if( u->type == CV_32F )
- for(int i = 0; i < dcount; i++ )
+ void operator()( const Range& range ) const
+ {
+ double inv_count = 1./inputs.rows;
+ int ivcount = ann->layer_sizes.front();
+ int ovcount = ann->layer_sizes.back();
+ int itype = inputs.type(), otype = outputs.type();
+ int count = inputs.rows;
+ int i, j, k, l_count = ann->layer_count();
+ vector<vector<double> > x(l_count);
+ vector<vector<double> > df(l_count);
+ vector<double> _buf(ann->max_lsize*dcount0*2);
+ double* buf[] = { &_buf[0], &_buf[ann->max_lsize*dcount0] };
+ double E = 0;
+
+ for( i = 0; i < l_count; i++ )
{
- const float* udata = u->data.fl[si+i];
- const double* xdata = x[l_count-1] + i*ovcount;
- double* gdata = grad1->data.db + i*ovcount;
- double sweight = sw ? sw[si+i] : inv_count, E1 = 0;
-
- for(int j = 0; j < ovcount; j++ )
- {
- double t = udata[j]*w[j*2] + w[j*2+1] - xdata[j];
- gdata[j] = t*sweight;
- E1 += t*t;
- }
- *E += sweight*E1;
+ x[i].resize(ann->layer_sizes[i]*dcount0);
+ df[i].resize(ann->layer_sizes[i]*dcount0);
}
- else
- for(int i = 0; i < dcount; i++ )
+
+ for( int si = range.start; si < range.end; si++ )
{
- const double* udata = u->data.db[si+i];
- const double* xdata = x[l_count-1] + i*ovcount;
- double* gdata = grad1->data.db + i*ovcount;
- double sweight = sw ? sw[si+i] : inv_count, E1 = 0;
+ int i0 = si*dcount0, i1 = std::min((si + 1)*dcount0, count);
+ int dcount = i1 - i0;
+ const double* w = ann->weights[0].ptr<double>();
- for(int j = 0; j < ovcount; j++ )
+ // grab and preprocess input data
+ for( i = 0; i < dcount; i++ )
{
- double t = udata[j]*w[j*2] + w[j*2+1] - xdata[j];
- gdata[j] = t*sweight;
- E1 += t*t;
- }
- *E += sweight*E1;
- }
-
- // backward pass, update dEdw
- static cv::Mutex mutex;
-
- for(int i = l_count-1; i > 0; i-- )
- {
- n1 = layer_sizes->data.i[i-1]; n2 = layer_sizes->data.i[i];
- cvInitMatHeader( &_df, dcount, n2, CV_64F, df[i] );
- cvMul( grad1, &_df, grad1 );
+ const uchar* x0data_p = inputs.ptr(i0 + i);
+ const float* x0data_f = (const float*)x0data_p;
+ const double* x0data_d = (const double*)x0data_p;
- {
- cv::AutoLock lock(mutex);
- cvInitMatHeader( &_dEdw, n1, n2, CV_64F, dEdw->data.db+(weights[i]-weights[0]) );
- cvInitMatHeader( x1, dcount, n1, CV_64F, x[i-1] );
- cvGEMM( x1, grad1, 1, &_dEdw, 1, &_dEdw, CV_GEMM_A_T );
+ double* xdata = &x[0][i*ivcount];
+ for( j = 0; j < ivcount; j++ )
+ xdata[j] = (itype == CV_32F ? (double)x0data_f[j] : x0data_d[j])*w[j*2] + w[j*2+1];
+ }
+ Mat x1(dcount, ivcount, CV_64F, &x[0][0]);
- // update bias part of dEdw
- for( k = 0; k < dcount; k++ )
+ // forward pass, compute y[i]=w*x[i-1], x[i]=f(y[i]), df[i]=f'(y[i])
+ for( i = 1; i < l_count; i++ )
{
- double* dst = _dEdw.data.db + n1*n2;
- const double* src = grad1->data.db + k*n2;
- for(int j = 0; j < n2; j++ )
- dst[j] += src[j];
+ Mat x2( dcount, ann->layer_sizes[i], CV_64F, &x[i][0] );
+ Mat _w = ann->weights[i].rowRange(0, x1.cols);
+ gemm( x1, _w, 1, noArray(), 0, x2 );
+ Mat _df( x2.size(), CV_64F, &df[i][0] );
+ ann->calc_activ_func_deriv( x2, _df, ann->weights[i] );
+ x1 = x2;
}
- if (i > 1)
- cvInitMatHeader( &_w, n1, n2, CV_64F, weights[i] );
- }
-
- cvInitMatHeader( grad2, dcount, n1, CV_64F, grad2->data.db );
- if( i > 1 )
- cvGEMM( grad1, &_w, 1, 0, 0, grad2, CV_GEMM_B_T );
- CV_SWAP( grad1, grad2, temp );
- }
- }
- cvFree(&x);
- cvReleaseMat( &buf );
-}
-
-};
-
-
-int CvANN_MLP::train_rprop( CvVectors x0, CvVectors u, const double* sw )
-{
- const int max_buf_size = 1 << 16;
- CvMat* dw = 0;
- CvMat* dEdw = 0;
- CvMat* prev_dEdw_sign = 0;
- CvMat* buf = 0;
- double **x = 0, **df = 0;
- int iter = -1, count = x0.count;
-
- CV_FUNCNAME( "CvANN_MLP::train" );
-
- __BEGIN__;
-
- int i, ivcount, ovcount, l_count, total = 0, max_iter, buf_sz, dcount0;
- double *buf_ptr;
- double prev_E = DBL_MAX*0.5, epsilon;
- double dw_plus, dw_minus, dw_min, dw_max;
- double inv_count;
-
- max_iter = params.term_crit.max_iter;
- epsilon = params.term_crit.epsilon;
- dw_plus = params.rp_dw_plus;
- dw_minus = params.rp_dw_minus;
- dw_min = params.rp_dw_min;
- dw_max = params.rp_dw_max;
-
- l_count = layer_sizes->cols;
- ivcount = layer_sizes->data.i[0];
- ovcount = layer_sizes->data.i[l_count-1];
-
- // allocate buffers
- for( i = 0; i < l_count; i++ )
- total += layer_sizes->data.i[i];
-
- CV_CALL( dw = cvCreateMat( wbuf->rows, wbuf->cols, wbuf->type ));
- cvSet( dw, cvScalarAll(params.rp_dw0) );
- CV_CALL( dEdw = cvCreateMat( wbuf->rows, wbuf->cols, wbuf->type ));
- cvZero( dEdw );
- CV_CALL( prev_dEdw_sign = cvCreateMat( wbuf->rows, wbuf->cols, CV_8SC1 ));
- cvZero( prev_dEdw_sign );
-
- inv_count = 1./count;
- dcount0 = max_buf_size/(2*total);
- dcount0 = MAX( dcount0, 1 );
- dcount0 = MIN( dcount0, count );
- buf_sz = dcount0*(total + max_count)*2;
-
- CV_CALL( buf = cvCreateMat( 1, buf_sz, CV_64F ));
-
- CV_CALL( x = (double**)cvAlloc( total*2*sizeof(x[0]) ));
- df = x + total;
- buf_ptr = buf->data.db;
-
- for( i = 0; i < l_count; i++ )
- {
- x[i] = buf_ptr;
- df[i] = x[i] + layer_sizes->data.i[i]*dcount0;
- buf_ptr += (df[i] - x[i])*2;
- }
-
- // run rprop loop
- /*
- y_i(t) = w_i(t)*x_{i-1}(t)
- x_i(t) = f(y_i(t))
- E = sum_over_all_samples(1/2*||u - x_N||^2)
- grad_N = (x_N - u)*f'(y_i)
+ Mat grad1(dcount, ovcount, CV_64F, buf[l_count & 1]);
- MIN(dw_i{jk}(t)*dw_plus, dw_max), if dE/dw_i{jk}(t)*dE/dw_i{jk}(t-1) > 0
- dw_i{jk}(t) = MAX(dw_i{jk}(t)*dw_minus, dw_min), if dE/dw_i{jk}(t)*dE/dw_i{jk}(t-1) < 0
- dw_i{jk}(t-1) else
+ w = ann->weights[l_count+1].ptr<double>();
- if (dE/dw_i{jk}(t)*dE/dw_i{jk}(t-1) < 0)
- dE/dw_i{jk}(t)<-0
- else
- w_i{jk}(t+1) = w_i{jk}(t) + dw_i{jk}(t)
- grad_{i-1}(t) = w_i^t(t)*grad_i(t)
- */
- for( iter = 0; iter < max_iter; iter++ )
- {
- int n1, n2, j, k;
- double E = 0;
-
- // first, iterate through all the samples and compute dEdw
- cv::parallel_for_(cv::Range(0, count),
- rprop_loop(this, weights, count, ivcount, &x0, l_count, layer_sizes,
- ovcount, max_count, &u, sw, inv_count, dEdw, dcount0, &E, buf_sz)
- );
+ // calculate error
+ for( i = 0; i < dcount; i++ )
+ {
+ const uchar* udata_p = outputs.ptr(i0+i);
+ const float* udata_f = (const float*)udata_p;
+ const double* udata_d = (const double*)udata_p;
- // now update weights
- for( i = 1; i < l_count; i++ )
- {
- n1 = layer_sizes->data.i[i-1]; n2 = layer_sizes->data.i[i];
- for( k = 0; k <= n1; k++ )
- {
- double* wk = weights[i]+k*n2;
- size_t delta = wk - weights[0];
- double* dwk = dw->data.db + delta;
- double* dEdwk = dEdw->data.db + delta;
- char* prevEk = (char*)(prev_dEdw_sign->data.ptr + delta);
+ const double* xdata = &x[l_count-1][i*ovcount];
+ double* gdata = grad1.ptr<double>(i);
+ double sweight = sw ? sw[si+i] : inv_count, E1 = 0;
- for( j = 0; j < n2; j++ )
- {
- double Eval = dEdwk[j];
- double dval = dwk[j];
- double wval = wk[j];
- int s = CV_SIGN(Eval);
- int ss = prevEk[j]*s;
- if( ss > 0 )
+ for( j = 0; j < ovcount; j++ )
{
- dval *= dw_plus;
- dval = MIN( dval, dw_max );
- dwk[j] = dval;
- wk[j] = wval + dval*s;
+ double t = (otype == CV_32F ? (double)udata_f[j] : udata_d[j])*w[j*2] + w[j*2+1] - xdata[j];
+ gdata[j] = t*sweight;
+ E1 += t*t;
}
- else if( ss < 0 )
+ E += sweight*E1;
+ }
+
+ for( i = l_count-1; i > 0; i-- )
+ {
+ int n1 = ann->layer_sizes[i-1], n2 = ann->layer_sizes[i];
+ Mat _df(dcount, n2, CV_64F, &df[i][0]);
+ multiply(grad1, _df, grad1);
+
{
- dval *= dw_minus;
- dval = MAX( dval, dw_min );
- prevEk[j] = 0;
- dwk[j] = dval;
- wk[j] = wval + dval*s;
+ AutoLock lock(ann->mtx);
+ Mat _dEdw = dEdw->at(i).rowRange(0, n1);
+ x1 = Mat(dcount, n1, CV_64F, &x[i-1][0]);
+ gemm(x1, grad1, 1, _dEdw, 1, _dEdw, GEMM_1_T);
+
+ // update bias part of dEdw
+ double* dst = dEdw->at(i).ptr<double>(n1);
+ for( k = 0; k < dcount; k++ )
+ {
+ const double* src = grad1.ptr<double>(k);
+ for( j = 0; j < n2; j++ )
+ dst[j] += src[j];
+ }
}
- else
+
+ Mat grad2( dcount, n1, CV_64F, buf[i&1] );
+ if( i > 1 )
{
- prevEk[j] = (char)s;
- wk[j] = wval + dval*s;
+ Mat _w = ann->weights[i].rowRange(0, n1);
+ gemm(grad1, _w, 1, noArray(), 0, grad2, GEMM_2_T);
}
- dEdwk[j] = 0.;
+ grad1 = grad2;
}
}
+ {
+ AutoLock lock(ann->mtx);
+ *pE += E;
+ }
}
+ };
- //printf("%d. E = %g\n", iter, E);
- if( fabs(prev_E - E) < epsilon )
- break;
- prev_E = E;
- E = 0;
- }
-
- __END__;
-
- cvReleaseMat( &dw );
- cvReleaseMat( &dEdw );
- cvReleaseMat( &prev_dEdw_sign );
- cvReleaseMat( &buf );
- cvFree( &x );
-
- return iter;
-}
-
-
-void CvANN_MLP::write_params( CvFileStorage* fs ) const
-{
- //CV_FUNCNAME( "CvANN_MLP::write_params" );
-
- __BEGIN__;
-
- const char* activ_func_name = activ_func == IDENTITY ? "IDENTITY" :
- activ_func == SIGMOID_SYM ? "SIGMOID_SYM" :
- activ_func == GAUSSIAN ? "GAUSSIAN" : 0;
-
- if( activ_func_name )
- cvWriteString( fs, "activation_function", activ_func_name );
- else
- cvWriteInt( fs, "activation_function", activ_func );
-
- if( activ_func != IDENTITY )
+ int train_rprop( const Mat& inputs, const Mat& outputs, const Mat& _sw, TermCriteria termCrit )
{
- cvWriteReal( fs, "f_param1", f_param1 );
- cvWriteReal( fs, "f_param2", f_param2 );
- }
-
- cvWriteReal( fs, "min_val", min_val );
- cvWriteReal( fs, "max_val", max_val );
- cvWriteReal( fs, "min_val1", min_val1 );
- cvWriteReal( fs, "max_val1", max_val1 );
-
- cvStartWriteStruct( fs, "training_params", CV_NODE_MAP );
- if( params.train_method == CvANN_MLP_TrainParams::BACKPROP )
- {
- cvWriteString( fs, "train_method", "BACKPROP" );
- cvWriteReal( fs, "dw_scale", params.bp_dw_scale );
- cvWriteReal( fs, "moment_scale", params.bp_moment_scale );
- }
- else if( params.train_method == CvANN_MLP_TrainParams::RPROP )
- {
- cvWriteString( fs, "train_method", "RPROP" );
- cvWriteReal( fs, "dw0", params.rp_dw0 );
- cvWriteReal( fs, "dw_plus", params.rp_dw_plus );
- cvWriteReal( fs, "dw_minus", params.rp_dw_minus );
- cvWriteReal( fs, "dw_min", params.rp_dw_min );
- cvWriteReal( fs, "dw_max", params.rp_dw_max );
- }
+ const int max_buf_size = 1 << 16;
+ int i, iter = -1, count = inputs.rows;
- cvStartWriteStruct( fs, "term_criteria", CV_NODE_MAP + CV_NODE_FLOW );
- if( params.term_crit.type & CV_TERMCRIT_EPS )
- cvWriteReal( fs, "epsilon", params.term_crit.epsilon );
- if( params.term_crit.type & CV_TERMCRIT_ITER )
- cvWriteInt( fs, "iterations", params.term_crit.max_iter );
- cvEndWriteStruct( fs );
+ double prev_E = DBL_MAX*0.5;
- cvEndWriteStruct( fs );
+ int max_iter = termCrit.maxCount;
+ double epsilon = termCrit.epsilon;
+ double dw_plus = params.rpDWPlus;
+ double dw_minus = params.rpDWMinus;
+ double dw_min = params.rpDWMin;
+ double dw_max = params.rpDWMax;
- __END__;
-}
+ int l_count = layer_count();
+ // allocate buffers
+ vector<Mat> dw(l_count), dEdw(l_count), prev_dEdw_sign(l_count);
-void CvANN_MLP::write( CvFileStorage* fs, const char* name ) const
-{
- CV_FUNCNAME( "CvANN_MLP::write" );
-
- __BEGIN__;
-
- int i, l_count = layer_sizes->cols;
-
- if( !layer_sizes )
- CV_ERROR( CV_StsError, "The network has not been initialized" );
+ int total = 0;
+ for( i = 0; i < l_count; i++ )
+ {
+ total += layer_sizes[i];
+ dw[i].create(weights[i].size(), CV_64F);
+ dw[i].setTo(Scalar::all(params.rpDW0));
+ prev_dEdw_sign[i] = Mat::zeros(weights[i].size(), CV_8S);
+ dEdw[i] = Mat::zeros(weights[i].size(), CV_64F);
+ }
- cvStartWriteStruct( fs, name, CV_NODE_MAP, CV_TYPE_NAME_ML_ANN_MLP );
+ int dcount0 = max_buf_size/(2*total);
+ dcount0 = std::max( dcount0, 1 );
+ dcount0 = std::min( dcount0, count );
+ int chunk_count = (count + dcount0 - 1)/dcount0;
+
+ // run rprop loop
+ /*
+ y_i(t) = w_i(t)*x_{i-1}(t)
+ x_i(t) = f(y_i(t))
+ E = sum_over_all_samples(1/2*||u - x_N||^2)
+ grad_N = (x_N - u)*f'(y_i)
+
+ std::min(dw_i{jk}(t)*dw_plus, dw_max), if dE/dw_i{jk}(t)*dE/dw_i{jk}(t-1) > 0
+ dw_i{jk}(t) = std::max(dw_i{jk}(t)*dw_minus, dw_min), if dE/dw_i{jk}(t)*dE/dw_i{jk}(t-1) < 0
+ dw_i{jk}(t-1) else
+
+ if (dE/dw_i{jk}(t)*dE/dw_i{jk}(t-1) < 0)
+ dE/dw_i{jk}(t)<-0
+ else
+ w_i{jk}(t+1) = w_i{jk}(t) + dw_i{jk}(t)
+ grad_{i-1}(t) = w_i^t(t)*grad_i(t)
+ */
+ for( iter = 0; iter < max_iter; iter++ )
+ {
+ double E = 0;
- cvWrite( fs, "layer_sizes", layer_sizes );
+ for( i = 0; i < l_count; i++ )
+ dEdw[i].setTo(Scalar::all(0));
- write_params( fs );
+ // first, iterate through all the samples and compute dEdw
+ RPropLoop invoker(this, inputs, outputs, _sw, dcount0, dEdw, &E);
+ parallel_for_(Range(0, chunk_count), invoker);
+ //invoker(Range(0, chunk_count));
- cvStartWriteStruct( fs, "input_scale", CV_NODE_SEQ + CV_NODE_FLOW );
- cvWriteRawData( fs, weights[0], layer_sizes->data.i[0]*2, "d" );
- cvEndWriteStruct( fs );
+ // now update weights
+ for( i = 1; i < l_count; i++ )
+ {
+ int n1 = layer_sizes[i-1], n2 = layer_sizes[i];
+ for( int k = 0; k <= n1; k++ )
+ {
+ CV_Assert(weights[i].size() == Size(n2, n1+1));
+ double* wk = weights[i].ptr<double>(k);
+ double* dwk = dw[i].ptr<double>(k);
+ double* dEdwk = dEdw[i].ptr<double>(k);
+ schar* prevEk = prev_dEdw_sign[i].ptr<schar>(k);
- cvStartWriteStruct( fs, "output_scale", CV_NODE_SEQ + CV_NODE_FLOW );
- cvWriteRawData( fs, weights[l_count], layer_sizes->data.i[l_count-1]*2, "d" );
- cvEndWriteStruct( fs );
+ for( int j = 0; j < n2; j++ )
+ {
+ double Eval = dEdwk[j];
+ double dval = dwk[j];
+ double wval = wk[j];
+ int s = CV_SIGN(Eval);
+ int ss = prevEk[j]*s;
+ if( ss > 0 )
+ {
+ dval *= dw_plus;
+ dval = std::min( dval, dw_max );
+ dwk[j] = dval;
+ wk[j] = wval + dval*s;
+ }
+ else if( ss < 0 )
+ {
+ dval *= dw_minus;
+ dval = std::max( dval, dw_min );
+ prevEk[j] = 0;
+ dwk[j] = dval;
+ wk[j] = wval + dval*s;
+ }
+ else
+ {
+ prevEk[j] = (schar)s;
+ wk[j] = wval + dval*s;
+ }
+ dEdwk[j] = 0.;
+ }
+ }
+ }
- cvStartWriteStruct( fs, "inv_output_scale", CV_NODE_SEQ + CV_NODE_FLOW );
- cvWriteRawData( fs, weights[l_count+1], layer_sizes->data.i[l_count-1]*2, "d" );
- cvEndWriteStruct( fs );
+ //printf("%d. E = %g\n", iter, E);
+ if( fabs(prev_E - E) < epsilon )
+ break;
+ prev_E = E;
+ }
- cvStartWriteStruct( fs, "weights", CV_NODE_SEQ );
- for( i = 1; i < l_count; i++ )
- {
- cvStartWriteStruct( fs, 0, CV_NODE_SEQ + CV_NODE_FLOW );
- cvWriteRawData( fs, weights[i], (layer_sizes->data.i[i-1]+1)*layer_sizes->data.i[i], "d" );
- cvEndWriteStruct( fs );
+ return iter;
}
- cvEndWriteStruct( fs );
-
- __END__;
-}
-
+ void write_params( FileStorage& fs ) const
+ {
+ const char* activ_func_name = activ_func == IDENTITY ? "IDENTITY" :
+ activ_func == SIGMOID_SYM ? "SIGMOID_SYM" :
+ activ_func == GAUSSIAN ? "GAUSSIAN" : 0;
-void CvANN_MLP::read_params( CvFileStorage* fs, CvFileNode* node )
-{
- //CV_FUNCNAME( "CvANN_MLP::read_params" );
+ if( activ_func_name )
+ fs << "activation_function" << activ_func_name;
+ else
+ fs << "activation_function_id" << activ_func;
- __BEGIN__;
+ if( activ_func != IDENTITY )
+ {
+ fs << "f_param1" << f_param1;
+ fs << "f_param2" << f_param2;
+ }
- const char* activ_func_name = cvReadStringByName( fs, node, "activation_function", 0 );
- CvFileNode* tparams_node;
+ fs << "min_val" << min_val << "max_val" << max_val << "min_val1" << min_val1 << "max_val1" << max_val1;
- if( activ_func_name )
- activ_func = strcmp( activ_func_name, "SIGMOID_SYM" ) == 0 ? SIGMOID_SYM :
- strcmp( activ_func_name, "IDENTITY" ) == 0 ? IDENTITY :
- strcmp( activ_func_name, "GAUSSIAN" ) == 0 ? GAUSSIAN : 0;
- else
- activ_func = cvReadIntByName( fs, node, "activation_function" );
+ fs << "training_params" << "{";
+ if( params.trainMethod == Params::BACKPROP )
+ {
+ fs << "train_method" << "BACKPROP";
+ fs << "dw_scale" << params.bpDWScale;
+ fs << "moment_scale" << params.bpMomentScale;
+ }
+ else if( params.trainMethod == Params::RPROP )
+ {
+ fs << "train_method" << "RPROP";
+ fs << "dw0" << params.rpDW0;
+ fs << "dw_plus" << params.rpDWPlus;
+ fs << "dw_minus" << params.rpDWMinus;
+ fs << "dw_min" << params.rpDWMin;
+ fs << "dw_max" << params.rpDWMax;
+ }
+ else
+ CV_Error(CV_StsError, "Unknown training method");
+
+ fs << "term_criteria" << "{";
+ if( params.termCrit.type & TermCriteria::EPS )
+ fs << "epsilon" << params.termCrit.epsilon;
+ if( params.termCrit.type & TermCriteria::COUNT )
+ fs << "iterations" << params.termCrit.maxCount;
+ fs << "}" << "}";
+ }
+
+ void write( FileStorage& fs ) const
+ {
+ if( layer_sizes.empty() )
+ return;
+ int i, l_count = layer_count();
- f_param1 = cvReadRealByName( fs, node, "f_param1", 0 );
- f_param2 = cvReadRealByName( fs, node, "f_param2", 0 );
+ fs << "layer_sizes" << layer_sizes;
+
+ write_params( fs );
- set_activ_func( activ_func, f_param1, f_param2 );
+ size_t esz = weights[0].elemSize();
- min_val = cvReadRealByName( fs, node, "min_val", 0. );
- max_val = cvReadRealByName( fs, node, "max_val", 1. );
- min_val1 = cvReadRealByName( fs, node, "min_val1", 0. );
- max_val1 = cvReadRealByName( fs, node, "max_val1", 1. );
+ fs << "input_scale" << "[";
+ fs.writeRaw("d", weights[0].data, weights[0].total()*esz);
- tparams_node = cvGetFileNodeByName( fs, node, "training_params" );
- params = CvANN_MLP_TrainParams();
+ fs << "]" << "output_scale" << "[";
+ fs.writeRaw("d", weights[l_count].data, weights[l_count].total()*esz);
- if( tparams_node )
- {
- const char* tmethod_name = cvReadStringByName( fs, tparams_node, "train_method", "" );
- CvFileNode* tcrit_node;
+ fs << "]" << "inv_output_scale" << "[";
+ fs.writeRaw("d", weights[l_count+1].data, weights[l_count+1].total()*esz);
- if( strcmp( tmethod_name, "BACKPROP" ) == 0 )
+ fs << "]" << "weights" << "[";
+ for( i = 1; i < l_count; i++ )
{
- params.train_method = CvANN_MLP_TrainParams::BACKPROP;
- params.bp_dw_scale = cvReadRealByName( fs, tparams_node, "dw_scale", 0 );
- params.bp_moment_scale = cvReadRealByName( fs, tparams_node, "moment_scale", 0 );
+ fs << "[";
+ fs.writeRaw("d", weights[i].data, weights[i].total()*esz);
+ fs << "]";
}
- else if( strcmp( tmethod_name, "RPROP" ) == 0 )
+ fs << "]";
+ }
+
+ void read_params( const FileNode& fn )
+ {
+ String activ_func_name = (String)fn["activation_function"];
+ if( !activ_func_name.empty() )
{
- params.train_method = CvANN_MLP_TrainParams::RPROP;
- params.rp_dw0 = cvReadRealByName( fs, tparams_node, "dw0", 0 );
- params.rp_dw_plus = cvReadRealByName( fs, tparams_node, "dw_plus", 0 );
- params.rp_dw_minus = cvReadRealByName( fs, tparams_node, "dw_minus", 0 );
- params.rp_dw_min = cvReadRealByName( fs, tparams_node, "dw_min", 0 );
- params.rp_dw_max = cvReadRealByName( fs, tparams_node, "dw_max", 0 );
+ activ_func = activ_func_name == "SIGMOID_SYM" ? SIGMOID_SYM :
+ activ_func_name == "IDENTITY" ? IDENTITY :
+ activ_func_name == "GAUSSIAN" ? GAUSSIAN : -1;
+ CV_Assert( activ_func >= 0 );
}
-
- tcrit_node = cvGetFileNodeByName( fs, tparams_node, "term_criteria" );
- if( tcrit_node )
+ else
+ activ_func = (int)fn["activation_function_id"];
+
+ f_param1 = (double)fn["f_param1"];
+ f_param2 = (double)fn["f_param2"];
+
+ set_activ_func( activ_func, f_param1, f_param2 );
+
+ min_val = (double)fn["min_val"];
+ max_val = (double)fn["max_val"];
+ min_val1 = (double)fn["min_val1"];
+ max_val1 = (double)fn["max_val1"];
+
+ FileNode tpn = fn["training_params"];
+ params = Params();
+
+ if( !tpn.empty() )
{
- params.term_crit.epsilon = cvReadRealByName( fs, tcrit_node, "epsilon", -1 );
- params.term_crit.max_iter = cvReadIntByName( fs, tcrit_node, "iterations", -1 );
- params.term_crit.type = (params.term_crit.epsilon >= 0 ? CV_TERMCRIT_EPS : 0) +
- (params.term_crit.max_iter >= 0 ? CV_TERMCRIT_ITER : 0);
+ String tmethod_name = (String)tpn["train_method"];
+
+ if( tmethod_name == "BACKPROP" )
+ {
+ params.trainMethod = Params::BACKPROP;
+ params.bpDWScale = (double)tpn["dw_scale"];
+ params.bpMomentScale = (double)tpn["moment_scale"];
+ }
+ else if( tmethod_name == "RPROP" )
+ {
+ params.trainMethod = Params::RPROP;
+ params.rpDW0 = (double)tpn["dw0"];
+ params.rpDWPlus = (double)tpn["dw_plus"];
+ params.rpDWMinus = (double)tpn["dw_minus"];
+ params.rpDWMin = (double)tpn["dw_min"];
+ params.rpDWMax = (double)tpn["dw_max"];
+ }
+ else
+ CV_Error(CV_StsParseError, "Unknown training method (should be BACKPROP or RPROP)");
+
+ FileNode tcn = tpn["term_criteria"];
+ if( !tcn.empty() )
+ {
+ FileNode tcn_e = tcn["epsilon"];
+ FileNode tcn_i = tcn["iterations"];
+ params.termCrit.type = 0;
+ if( !tcn_e.empty() )
+ {
+ params.termCrit.type |= TermCriteria::EPS;
+ params.termCrit.epsilon = (double)tcn_e;
+ }
+ if( !tcn_i.empty() )
+ {
+ params.termCrit.type |= TermCriteria::COUNT;
+ params.termCrit.maxCount = (int)tcn_i;
+ }
+ }
}
}
+
+ void read( const FileNode& fn )
+ {
+ clear();
- __END__;
-}
-
-
-void CvANN_MLP::read( CvFileStorage* fs, CvFileNode* node )
-{
- CvMat* _layer_sizes = 0;
-
- CV_FUNCNAME( "CvANN_MLP::read" );
-
- __BEGIN__;
+ vector<int> _layer_sizes;
+ fn["layer_sizes"] >> _layer_sizes;
+ create( _layer_sizes, SIGMOID_SYM, 0, 0 );
- CvFileNode* w;
- CvSeqReader reader;
- int i, l_count;
+ int i, l_count = layer_count();
+ read_params(fn);
- _layer_sizes = (CvMat*)cvReadByName( fs, node, "layer_sizes" );
- CV_CALL( create( _layer_sizes, SIGMOID_SYM, 0, 0 ));
- l_count = layer_sizes->cols;
+ size_t esz = weights[0].elemSize();
- CV_CALL( read_params( fs, node ));
+ FileNode w = fn["input_scale"];
+ w.readRaw("d", weights[0].data, weights[0].total()*esz);
- w = cvGetFileNodeByName( fs, node, "input_scale" );
- if( !w || CV_NODE_TYPE(w->tag) != CV_NODE_SEQ ||
- w->data.seq->total != layer_sizes->data.i[0]*2 )
- CV_ERROR( CV_StsParseError, "input_scale tag is not found or is invalid" );
+ w = fn["output_scale"];
+ w.readRaw("d", weights[l_count].data, weights[l_count].total()*esz);
- CV_CALL( cvReadRawData( fs, w, weights[0], "d" ));
+ w = fn["inv_output_scale"];
+ w.readRaw("d", weights[l_count+1].data, weights[l_count+1].total()*esz);
- w = cvGetFileNodeByName( fs, node, "output_scale" );
- if( !w || CV_NODE_TYPE(w->tag) != CV_NODE_SEQ ||
- w->data.seq->total != layer_sizes->data.i[l_count-1]*2 )
- CV_ERROR( CV_StsParseError, "output_scale tag is not found or is invalid" );
+ FileNodeIterator w_it = fn["weights"].begin();
- CV_CALL( cvReadRawData( fs, w, weights[l_count], "d" ));
+ for( i = 1; i < l_count; i++, ++w_it )
+ (*w_it).readRaw("d", weights[i].data, weights[i].total()*esz);
+ trained = true;
+ }
- w = cvGetFileNodeByName( fs, node, "inv_output_scale" );
- if( !w || CV_NODE_TYPE(w->tag) != CV_NODE_SEQ ||
- w->data.seq->total != layer_sizes->data.i[l_count-1]*2 )
- CV_ERROR( CV_StsParseError, "inv_output_scale tag is not found or is invalid" );
+ Mat getLayerSizes() const
+ {
+ return Mat_<int>(layer_sizes, true);
+ }
- CV_CALL( cvReadRawData( fs, w, weights[l_count+1], "d" ));
+ Mat getWeights(int layerIdx) const
+ {
+ CV_Assert( 0 <= layerIdx && layerIdx < (int)weights.size() );
+ return weights[layerIdx];
+ }
- w = cvGetFileNodeByName( fs, node, "weights" );
- if( !w || CV_NODE_TYPE(w->tag) != CV_NODE_SEQ ||
- w->data.seq->total != l_count - 1 )
- CV_ERROR( CV_StsParseError, "weights tag is not found or is invalid" );
+ bool isTrained() const
+ {
+ return trained;
+ }
- cvStartReadSeq( w->data.seq, &reader );
+ bool isClassifier() const
+ {
+ return false;
+ }
- for( i = 1; i < l_count; i++ )
+ int getVarCount() const
{
- w = (CvFileNode*)reader.ptr;
- CV_CALL( cvReadRawData( fs, w, weights[i], "d" ));
- CV_NEXT_SEQ_ELEM( reader.seq->elem_size, reader );
+ return layer_sizes.empty() ? 0 : layer_sizes[0];
}
- __END__;
-}
+ String getDefaultModelName() const
+ {
+ return "opencv_ml_ann_mlp";
+ }
-using namespace cv;
+ vector<int> layer_sizes;
+ vector<Mat> weights;
+ double f_param1, f_param2;
+ double min_val, max_val, min_val1, max_val1;
+ int activ_func;
+ int max_lsize, max_buf_sz;
+ Params params;
+ RNG rng;
+ Mutex mtx;
+ bool trained;
+};
-CvANN_MLP::CvANN_MLP( const Mat& _layer_sizes, int _activ_func,
- double _f_param1, double _f_param2 )
-{
- layer_sizes = wbuf = 0;
- min_val = max_val = min_val1 = max_val1 = 0.;
- weights = 0;
- rng = &cv::theRNG();
- default_model_name = "my_nn";
- create( _layer_sizes, _activ_func, _f_param1, _f_param2 );
-}
-void CvANN_MLP::create( const Mat& _layer_sizes, int _activ_func,
- double _f_param1, double _f_param2 )
+Ptr<ANN_MLP> ANN_MLP::create(InputArray _layerSizes,
+ const ANN_MLP::Params& params,
+ int activateFunc,
+ double fparam1, double fparam2)
{
- CvMat cvlayer_sizes = _layer_sizes;
- create( &cvlayer_sizes, _activ_func, _f_param1, _f_param2 );
-}
+ Mat layerSizes = _layerSizes.getMat();
+ Ptr<ANN_MLPImpl> ann = makePtr<ANN_MLPImpl>(layerSizes, activateFunc, fparam1, fparam2);
+ ann->setParams(params);
-int CvANN_MLP::train( const Mat& _inputs, const Mat& _outputs,
- const Mat& _sample_weights, const Mat& _sample_idx,
- CvANN_MLP_TrainParams _params, int flags )
-{
- CvMat inputs = _inputs, outputs = _outputs, sweights = _sample_weights, sidx = _sample_idx;
- return train(&inputs, &outputs, sweights.data.ptr ? &sweights : 0,
- sidx.data.ptr ? &sidx : 0, _params, flags);
+ return ann;
}
-float CvANN_MLP::predict( const Mat& _inputs, Mat& _outputs ) const
-{
- CV_Assert(layer_sizes != 0);
- _outputs.create(_inputs.rows, layer_sizes->data.i[layer_sizes->cols-1], _inputs.type());
- CvMat inputs = _inputs, outputs = _outputs;
-
- return predict(&inputs, &outputs);
-}
+}}
/* End of file. */
// copy or use the software.
//
//
-// Intel License Agreement
+// License Agreement
+// For Open Source Computer Vision Library
//
// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Copyright (C) 2014, Itseez Inc, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// 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
+// * The name of the copyright holders 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
#include "precomp.hpp"
+namespace cv { namespace ml {
+
static inline double
log_ratio( double val )
{
const double eps = 1e-5;
-
- val = MAX( val, eps );
- val = MIN( val, 1. - eps );
+ val = std::max( val, eps );
+ val = std::min( val, 1. - eps );
return log( val/(1. - val) );
}
-CvBoostParams::CvBoostParams()
-{
- boost_type = CvBoost::REAL;
- weak_count = 100;
- weight_trim_rate = 0.95;
- cv_folds = 0;
- max_depth = 1;
-}
-
-
-CvBoostParams::CvBoostParams( int _boost_type, int _weak_count,
- double _weight_trim_rate, int _max_depth,
- bool _use_surrogates, const float* _priors )
-{
- boost_type = _boost_type;
- weak_count = _weak_count;
- weight_trim_rate = _weight_trim_rate;
- split_criteria = CvBoost::DEFAULT;
- cv_folds = 0;
- max_depth = _max_depth;
- use_surrogates = _use_surrogates;
- priors = _priors;
-}
-
-
-
-///////////////////////////////// CvBoostTree ///////////////////////////////////
-
-CvBoostTree::CvBoostTree()
-{
- ensemble = 0;
-}
-
-
-CvBoostTree::~CvBoostTree()
-{
- clear();
-}
-
-
-void
-CvBoostTree::clear()
-{
- CvDTree::clear();
- ensemble = 0;
-}
-
-
-bool
-CvBoostTree::train( CvDTreeTrainData* _train_data,
- const CvMat* _subsample_idx, CvBoost* _ensemble )
-{
- clear();
- ensemble = _ensemble;
- data = _train_data;
- data->shared = true;
- return do_train( _subsample_idx );
-}
-
-
-bool
-CvBoostTree::train( const CvMat*, int, const CvMat*, const CvMat*,
- const CvMat*, const CvMat*, const CvMat*, CvDTreeParams )
-{
- assert(0);
- return false;
-}
-
-
-bool
-CvBoostTree::train( CvDTreeTrainData*, const CvMat* )
-{
- assert(0);
- return false;
-}
-
-
-void
-CvBoostTree::scale( double _scale )
-{
- CvDTreeNode* node = root;
-
- // traverse the tree and scale all the node values
- for(;;)
- {
- CvDTreeNode* parent;
- for(;;)
- {
- node->value *= _scale;
- if( !node->left )
- break;
- node = node->left;
- }
-
- for( parent = node->parent; parent && parent->right == node;
- node = parent, parent = parent->parent )
- ;
-
- if( !parent )
- break;
-
- node = parent->right;
- }
-}
-
+Boost::~Boost() {}
-void
-CvBoostTree::try_split_node( CvDTreeNode* node )
+Boost::Params::Params()
{
- CvDTree::try_split_node( node );
-
- if( !node->left )
- {
- // if the node has not been split,
- // store the responses for the corresponding training samples
- double* weak_eval = ensemble->get_weak_response()->data.db;
- cv::AutoBuffer<int> inn_buf(node->sample_count);
- const int* labels = data->get_cv_labels( node, (int*)inn_buf );
- int i, count = node->sample_count;
- double value = node->value;
-
- for( i = 0; i < count; i++ )
- weak_eval[labels[i]] = value;
- }
+ boostType = Boost::REAL;
+ weakCount = 100;
+ weightTrimRate = 0.95;
+ CVFolds = 0;
+ maxDepth = 1;
}
-double
-CvBoostTree::calc_node_dir( CvDTreeNode* node )
+Boost::Params::Params( int _boostType, int _weak_count,
+ double _weightTrimRate, int _maxDepth,
+ bool _use_surrogates, const Mat& _priors )
{
- char* dir = (char*)data->direction->data.ptr;
- const double* weights = ensemble->get_subtree_weights()->data.db;
- int i, n = node->sample_count, vi = node->split->var_idx;
- double L, R;
-
- assert( !node->split->inversed );
-
- if( data->get_var_type(vi) >= 0 ) // split on categorical var
- {
- cv::AutoBuffer<int> inn_buf(n);
- const int* cat_labels = data->get_cat_var_data( node, vi, (int*)inn_buf );
- const int* subset = node->split->subset;
- double sum = 0, sum_abs = 0;
-
- for( i = 0; i < n; i++ )
- {
- int idx = ((cat_labels[i] == 65535) && data->is_buf_16u) ? -1 : cat_labels[i];
- double w = weights[i];
- int d = idx >= 0 ? CV_DTREE_CAT_DIR(idx,subset) : 0;
- sum += d*w; sum_abs += (d & 1)*w;
- dir[i] = (char)d;
- }
-
- R = (sum_abs + sum) * 0.5;
- L = (sum_abs - sum) * 0.5;
- }
- else // split on ordered var
- {
- cv::AutoBuffer<uchar> inn_buf(2*n*sizeof(int)+n*sizeof(float));
- float* values_buf = (float*)(uchar*)inn_buf;
- int* sorted_indices_buf = (int*)(values_buf + n);
- int* sample_indices_buf = sorted_indices_buf + n;
- const float* values = 0;
- const int* sorted_indices = 0;
- data->get_ord_var_data( node, vi, values_buf, sorted_indices_buf, &values, &sorted_indices, sample_indices_buf );
- int split_point = node->split->ord.split_point;
- int n1 = node->get_num_valid(vi);
-
- assert( 0 <= split_point && split_point < n1-1 );
- L = R = 0;
-
- for( i = 0; i <= split_point; i++ )
- {
- int idx = sorted_indices[i];
- double w = weights[idx];
- dir[idx] = (char)-1;
- L += w;
- }
-
- for( ; i < n1; i++ )
- {
- int idx = sorted_indices[i];
- double w = weights[idx];
- dir[idx] = (char)1;
- R += w;
- }
-
- for( ; i < n; i++ )
- dir[sorted_indices[i]] = (char)0;
- }
-
- node->maxlr = MAX( L, R );
- return node->split->quality/(L + R);
+ boostType = _boostType;
+ weakCount = _weak_count;
+ weightTrimRate = _weightTrimRate;
+ CVFolds = 0;
+ maxDepth = _maxDepth;
+ useSurrogates = _use_surrogates;
+ priors = _priors;
}
-CvDTreeSplit*
-CvBoostTree::find_split_ord_class( CvDTreeNode* node, int vi, float init_quality,
- CvDTreeSplit* _split, uchar* _ext_buf )
-{
- const float epsilon = FLT_EPSILON*2;
-
- const double* weights = ensemble->get_subtree_weights()->data.db;
- int n = node->sample_count;
- int n1 = node->get_num_valid(vi);
-
- cv::AutoBuffer<uchar> inn_buf;
- if( !_ext_buf )
- inn_buf.allocate(n*(3*sizeof(int)+sizeof(float)));
- uchar* ext_buf = _ext_buf ? _ext_buf : (uchar*)inn_buf;
- float* values_buf = (float*)ext_buf;
- int* sorted_indices_buf = (int*)(values_buf + n);
- int* sample_indices_buf = sorted_indices_buf + n;
- const float* values = 0;
- const int* sorted_indices = 0;
- data->get_ord_var_data( node, vi, values_buf, sorted_indices_buf, &values, &sorted_indices, sample_indices_buf );
- int* responses_buf = sorted_indices_buf + n;
- const int* responses = data->get_class_labels( node, responses_buf );
- const double* rcw0 = weights + n;
- double lcw[2] = {0,0}, rcw[2];
- int i, best_i = -1;
- double best_val = init_quality;
- int boost_type = ensemble->get_params().boost_type;
- int split_criteria = ensemble->get_params().split_criteria;
-
- rcw[0] = rcw0[0]; rcw[1] = rcw0[1];
- for( i = n1; i < n; i++ )
- {
- int idx = sorted_indices[i];
- double w = weights[idx];
- rcw[responses[idx]] -= w;
- }
-
- if( split_criteria != CvBoost::GINI && split_criteria != CvBoost::MISCLASS )
- split_criteria = boost_type == CvBoost::DISCRETE ? CvBoost::MISCLASS : CvBoost::GINI;
-
- if( split_criteria == CvBoost::GINI )
- {
- double L = 0, R = rcw[0] + rcw[1];
- double lsum2 = 0, rsum2 = rcw[0]*rcw[0] + rcw[1]*rcw[1];
-
- for( i = 0; i < n1 - 1; i++ )
- {
- int idx = sorted_indices[i];
- double w = weights[idx], w2 = w*w;
- double lv, rv;
- idx = responses[idx];
- L += w; R -= w;
- lv = lcw[idx]; rv = rcw[idx];
- lsum2 += 2*lv*w + w2;
- rsum2 -= 2*rv*w - w2;
- lcw[idx] = lv + w; rcw[idx] = rv - w;
-
- if( values[i] + epsilon < values[i+1] )
- {
- double val = (lsum2*R + rsum2*L)/(L*R);
- if( best_val < val )
- {
- best_val = val;
- best_i = i;
- }
- }
- }
- }
- else
- {
- for( i = 0; i < n1 - 1; i++ )
- {
- int idx = sorted_indices[i];
- double w = weights[idx];
- idx = responses[idx];
- lcw[idx] += w;
- rcw[idx] -= w;
-
- if( values[i] + epsilon < values[i+1] )
- {
- double val = lcw[0] + rcw[1], val2 = lcw[1] + rcw[0];
- val = MAX(val, val2);
- if( best_val < val )
- {
- best_val = val;
- best_i = i;
- }
- }
- }
- }
-
- CvDTreeSplit* split = 0;
- if( best_i >= 0 )
- {
- split = _split ? _split : data->new_split_ord( 0, 0.0f, 0, 0, 0.0f );
- split->var_idx = vi;
- split->ord.c = (values[best_i] + values[best_i+1])*0.5f;
- split->ord.split_point = best_i;
- split->inversed = 0;
- split->quality = (float)best_val;
- }
- return split;
-}
-
-template<typename T>
-class LessThanPtr
+class DTreesImplForBoost : public DTreesImpl
{
public:
- bool operator()(T* a, T* b) const { return *a < *b; }
-};
-
-CvDTreeSplit*
-CvBoostTree::find_split_cat_class( CvDTreeNode* node, int vi, float init_quality, CvDTreeSplit* _split, uchar* _ext_buf )
-{
- int ci = data->get_var_type(vi);
- int n = node->sample_count;
- int mi = data->cat_count->data.i[ci];
-
- int base_size = (2*mi+3)*sizeof(double) + mi*sizeof(double*);
- cv::AutoBuffer<uchar> inn_buf((2*mi+3)*sizeof(double) + mi*sizeof(double*));
- if( !_ext_buf)
- inn_buf.allocate( base_size + 2*n*sizeof(int) );
- uchar* base_buf = (uchar*)inn_buf;
- uchar* ext_buf = _ext_buf ? _ext_buf : base_buf + base_size;
-
- int* cat_labels_buf = (int*)ext_buf;
- const int* cat_labels = data->get_cat_var_data(node, vi, cat_labels_buf);
- int* responses_buf = cat_labels_buf + n;
- const int* responses = data->get_class_labels(node, responses_buf);
- double lcw[2]={0,0}, rcw[2]={0,0};
-
- double* cjk = (double*)cv::alignPtr(base_buf,sizeof(double))+2;
- const double* weights = ensemble->get_subtree_weights()->data.db;
- double** dbl_ptr = (double**)(cjk + 2*mi);
- int i, j, k, idx;
- double L = 0, R;
- double best_val = init_quality;
- int best_subset = -1, subset_i;
- int boost_type = ensemble->get_params().boost_type;
- int split_criteria = ensemble->get_params().split_criteria;
-
- // init array of counters:
- // c_{jk} - number of samples that have vi-th input variable = j and response = k.
- for( j = -1; j < mi; j++ )
- cjk[j*2] = cjk[j*2+1] = 0;
-
- for( i = 0; i < n; i++ )
- {
- double w = weights[i];
- j = ((cat_labels[i] == 65535) && data->is_buf_16u) ? -1 : cat_labels[i];
- k = responses[i];
- cjk[j*2 + k] += w;
- }
-
- for( j = 0; j < mi; j++ )
- {
- rcw[0] += cjk[j*2];
- rcw[1] += cjk[j*2+1];
- dbl_ptr[j] = cjk + j*2 + 1;
- }
-
- R = rcw[0] + rcw[1];
-
- if( split_criteria != CvBoost::GINI && split_criteria != CvBoost::MISCLASS )
- split_criteria = boost_type == CvBoost::DISCRETE ? CvBoost::MISCLASS : CvBoost::GINI;
-
- // sort rows of c_jk by increasing c_j,1
- // (i.e. by the weight of samples in j-th category that belong to class 1)
- std::sort(dbl_ptr, dbl_ptr + mi, LessThanPtr<double>());
-
- for( subset_i = 0; subset_i < mi-1; subset_i++ )
- {
- idx = (int)(dbl_ptr[subset_i] - cjk)/2;
- const double* crow = cjk + idx*2;
- double w0 = crow[0], w1 = crow[1];
- double weight = w0 + w1;
-
- if( weight < FLT_EPSILON )
- continue;
-
- lcw[0] += w0; rcw[0] -= w0;
- lcw[1] += w1; rcw[1] -= w1;
-
- if( split_criteria == CvBoost::GINI )
- {
- double lsum2 = lcw[0]*lcw[0] + lcw[1]*lcw[1];
- double rsum2 = rcw[0]*rcw[0] + rcw[1]*rcw[1];
-
- L += weight;
- R -= weight;
-
- if( L > FLT_EPSILON && R > FLT_EPSILON )
- {
- double val = (lsum2*R + rsum2*L)/(L*R);
- if( best_val < val )
- {
- best_val = val;
- best_subset = subset_i;
- }
- }
- }
- else
- {
- double val = lcw[0] + rcw[1];
- double val2 = lcw[1] + rcw[0];
-
- val = MAX(val, val2);
- if( best_val < val )
- {
- best_val = val;
- best_subset = subset_i;
- }
- }
- }
-
- CvDTreeSplit* split = 0;
- if( best_subset >= 0 )
- {
- split = _split ? _split : data->new_split_cat( 0, -1.0f);
- split->var_idx = vi;
- split->quality = (float)best_val;
- memset( split->subset, 0, (data->max_c_count + 31)/32 * sizeof(int));
- for( i = 0; i <= best_subset; i++ )
- {
- idx = (int)(dbl_ptr[i] - cjk) >> 1;
- split->subset[idx >> 5] |= 1 << (idx & 31);
- }
- }
- return split;
-}
-
-
-CvDTreeSplit*
-CvBoostTree::find_split_ord_reg( CvDTreeNode* node, int vi, float init_quality, CvDTreeSplit* _split, uchar* _ext_buf )
-{
- const float epsilon = FLT_EPSILON*2;
- const double* weights = ensemble->get_subtree_weights()->data.db;
- int n = node->sample_count;
- int n1 = node->get_num_valid(vi);
-
- cv::AutoBuffer<uchar> inn_buf;
- if( !_ext_buf )
- inn_buf.allocate(2*n*(sizeof(int)+sizeof(float)));
- uchar* ext_buf = _ext_buf ? _ext_buf : (uchar*)inn_buf;
-
- float* values_buf = (float*)ext_buf;
- int* indices_buf = (int*)(values_buf + n);
- int* sample_indices_buf = indices_buf + n;
- const float* values = 0;
- const int* indices = 0;
- data->get_ord_var_data( node, vi, values_buf, indices_buf, &values, &indices, sample_indices_buf );
- float* responses_buf = (float*)(indices_buf + n);
- const float* responses = data->get_ord_responses( node, responses_buf, sample_indices_buf );
-
- int i, best_i = -1;
- double L = 0, R = weights[n];
- double best_val = init_quality, lsum = 0, rsum = node->value*R;
-
- // compensate for missing values
- for( i = n1; i < n; i++ )
- {
- int idx = indices[i];
- double w = weights[idx];
- rsum -= responses[idx]*w;
- R -= w;
- }
+ DTreesImplForBoost() {}
+ virtual ~DTreesImplForBoost() {}
- // find the optimal split
- for( i = 0; i < n1 - 1; i++ )
- {
- int idx = indices[i];
- double w = weights[idx];
- double t = responses[idx]*w;
- L += w; R -= w;
- lsum += t; rsum -= t;
-
- if( values[i] + epsilon < values[i+1] )
- {
- double val = (lsum*lsum*R + rsum*rsum*L)/(L*R);
- if( best_val < val )
- {
- best_val = val;
- best_i = i;
- }
- }
- }
+ bool isClassifier() const { return true; }
- CvDTreeSplit* split = 0;
- if( best_i >= 0 )
+ void setBParams(const Boost::Params& p)
{
- split = _split ? _split : data->new_split_ord( 0, 0.0f, 0, 0, 0.0f );
- split->var_idx = vi;
- split->ord.c = (values[best_i] + values[best_i+1])*0.5f;
- split->ord.split_point = best_i;
- split->inversed = 0;
- split->quality = (float)best_val;
+ bparams = p;
}
- return split;
-}
-
-CvDTreeSplit*
-CvBoostTree::find_split_cat_reg( CvDTreeNode* node, int vi, float init_quality, CvDTreeSplit* _split, uchar* _ext_buf )
-{
- const double* weights = ensemble->get_subtree_weights()->data.db;
- int ci = data->get_var_type(vi);
- int n = node->sample_count;
- int mi = data->cat_count->data.i[ci];
- int base_size = (2*mi+3)*sizeof(double) + mi*sizeof(double*);
- cv::AutoBuffer<uchar> inn_buf(base_size);
- if( !_ext_buf )
- inn_buf.allocate(base_size + n*(2*sizeof(int) + sizeof(float)));
- uchar* base_buf = (uchar*)inn_buf;
- uchar* ext_buf = _ext_buf ? _ext_buf : base_buf + base_size;
-
- int* cat_labels_buf = (int*)ext_buf;
- const int* cat_labels = data->get_cat_var_data(node, vi, cat_labels_buf);
- float* responses_buf = (float*)(cat_labels_buf + n);
- int* sample_indices_buf = (int*)(responses_buf + n);
- const float* responses = data->get_ord_responses(node, responses_buf, sample_indices_buf);
-
- double* sum = (double*)cv::alignPtr(base_buf,sizeof(double)) + 1;
- double* counts = sum + mi + 1;
- double** sum_ptr = (double**)(counts + mi);
- double L = 0, R = 0, best_val = init_quality, lsum = 0, rsum = 0;
- int i, best_subset = -1, subset_i;
-
- for( i = -1; i < mi; i++ )
- sum[i] = counts[i] = 0;
-
- // calculate sum response and weight of each category of the input var
- for( i = 0; i < n; i++ )
+ Boost::Params getBParams() const
{
- int idx = ((cat_labels[i] == 65535) && data->is_buf_16u) ? -1 : cat_labels[i];
- double w = weights[i];
- double s = sum[idx] + responses[i]*w;
- double nc = counts[idx] + w;
- sum[idx] = s;
- counts[idx] = nc;
+ return bparams;
}
- // calculate average response in each category
- for( i = 0; i < mi; i++ )
+ void clear()
{
- R += counts[i];
- rsum += sum[i];
- sum[i] = fabs(counts[i]) > DBL_EPSILON ? sum[i]/counts[i] : 0;
- sum_ptr[i] = sum + i;
+ DTreesImpl::clear();
}
- std::sort(sum_ptr, sum_ptr + mi, LessThanPtr<double>());
-
- // revert back to unnormalized sums
- // (there should be a very little loss in accuracy)
- for( i = 0; i < mi; i++ )
- sum[i] *= counts[i];
-
- for( subset_i = 0; subset_i < mi-1; subset_i++ )
+ void startTraining( const Ptr<TrainData>& trainData, int flags )
{
- int idx = (int)(sum_ptr[subset_i] - sum);
- double ni = counts[idx];
+ DTreesImpl::startTraining(trainData, flags);
- if( ni > FLT_EPSILON )
+ if( bparams.boostType != Boost::DISCRETE )
{
- double s = sum[idx];
- lsum += s; L += ni;
- rsum -= s; R -= ni;
+ _isClassifier = false;
+ int i, n = (int)w->cat_responses.size();
+ w->ord_responses.resize(n);
- if( L > FLT_EPSILON && R > FLT_EPSILON )
+ double a = -1, b = 1;
+ if( bparams.boostType == Boost::REAL )
+ a = 0;
+ else if( bparams.boostType == Boost::LOGIT )
{
- double val = (lsum*lsum*R + rsum*rsum*L)/(L*R);
- if( best_val < val )
- {
- best_val = val;
- best_subset = subset_i;
- }
+ sumResult.assign(w->sidx.size(), 0.);
+ a = -2, b = 2;
}
- }
- }
- CvDTreeSplit* split = 0;
- if( best_subset >= 0 )
- {
- split = _split ? _split : data->new_split_cat( 0, -1.0f);
- split->var_idx = vi;
- split->quality = (float)best_val;
- memset( split->subset, 0, (data->max_c_count + 31)/32 * sizeof(int));
- for( i = 0; i <= best_subset; i++ )
- {
- int idx = (int)(sum_ptr[i] - sum);
- split->subset[idx >> 5] |= 1 << (idx & 31);
- }
- }
- return split;
-}
-
-
-CvDTreeSplit*
-CvBoostTree::find_surrogate_split_ord( CvDTreeNode* node, int vi, uchar* _ext_buf )
-{
- const float epsilon = FLT_EPSILON*2;
- int n = node->sample_count;
- cv::AutoBuffer<uchar> inn_buf;
- if( !_ext_buf )
- inn_buf.allocate(n*(2*sizeof(int)+sizeof(float)));
- uchar* ext_buf = _ext_buf ? _ext_buf : (uchar*)inn_buf;
- float* values_buf = (float*)ext_buf;
- int* indices_buf = (int*)(values_buf + n);
- int* sample_indices_buf = indices_buf + n;
- const float* values = 0;
- const int* indices = 0;
- data->get_ord_var_data( node, vi, values_buf, indices_buf, &values, &indices, sample_indices_buf );
-
- const double* weights = ensemble->get_subtree_weights()->data.db;
- const char* dir = (char*)data->direction->data.ptr;
- int n1 = node->get_num_valid(vi);
- // LL - number of samples that both the primary and the surrogate splits send to the left
- // LR - ... primary split sends to the left and the surrogate split sends to the right
- // RL - ... primary split sends to the right and the surrogate split sends to the left
- // RR - ... both send to the right
- int i, best_i = -1, best_inversed = 0;
- double best_val;
- double LL = 0, RL = 0, LR, RR;
- double worst_val = node->maxlr;
- double sum = 0, sum_abs = 0;
- best_val = worst_val;
-
- for( i = 0; i < n1; i++ )
- {
- int idx = indices[i];
- double w = weights[idx];
- int d = dir[idx];
- sum += d*w; sum_abs += (d & 1)*w;
- }
-
- // sum_abs = R + L; sum = R - L
- RR = (sum_abs + sum)*0.5;
- LR = (sum_abs - sum)*0.5;
-
- // initially all the samples are sent to the right by the surrogate split,
- // LR of them are sent to the left by primary split, and RR - to the right.
- // now iteratively compute LL, LR, RL and RR for every possible surrogate split value.
- for( i = 0; i < n1 - 1; i++ )
- {
- int idx = indices[i];
- double w = weights[idx];
- int d = dir[idx];
-
- if( d < 0 )
- {
- LL += w; LR -= w;
- if( LL + RR > best_val && values[i] + epsilon < values[i+1] )
- {
- best_val = LL + RR;
- best_i = i; best_inversed = 0;
- }
- }
- else if( d > 0 )
- {
- RL += w; RR -= w;
- if( RL + LR > best_val && values[i] + epsilon < values[i+1] )
- {
- best_val = RL + LR;
- best_i = i; best_inversed = 1;
- }
+ for( i = 0; i < n; i++ )
+ w->ord_responses[i] = w->cat_responses[i] > 0 ? b : a;
}
- }
-
- return best_i >= 0 && best_val > node->maxlr ? data->new_split_ord( vi,
- (values[best_i] + values[best_i+1])*0.5f, best_i,
- best_inversed, (float)best_val ) : 0;
-}
-
-
-CvDTreeSplit*
-CvBoostTree::find_surrogate_split_cat( CvDTreeNode* node, int vi, uchar* _ext_buf )
-{
- const char* dir = (char*)data->direction->data.ptr;
- const double* weights = ensemble->get_subtree_weights()->data.db;
- int n = node->sample_count;
- int i, mi = data->cat_count->data.i[data->get_var_type(vi)];
-
- int base_size = (2*mi+3)*sizeof(double);
- cv::AutoBuffer<uchar> inn_buf(base_size);
- if( !_ext_buf )
- inn_buf.allocate(base_size + n*sizeof(int));
- uchar* ext_buf = _ext_buf ? _ext_buf : (uchar*)inn_buf;
- int* cat_labels_buf = (int*)ext_buf;
- const int* cat_labels = data->get_cat_var_data(node, vi, cat_labels_buf);
-
- // LL - number of samples that both the primary and the surrogate splits send to the left
- // LR - ... primary split sends to the left and the surrogate split sends to the right
- // RL - ... primary split sends to the right and the surrogate split sends to the left
- // RR - ... both send to the right
- CvDTreeSplit* split = data->new_split_cat( vi, 0 );
- double best_val = 0;
- double* lc = (double*)cv::alignPtr(cat_labels_buf + n, sizeof(double)) + 1;
- double* rc = lc + mi + 1;
-
- for( i = -1; i < mi; i++ )
- lc[i] = rc[i] = 0;
-
- // 1. for each category calculate the weight of samples
- // sent to the left (lc) and to the right (rc) by the primary split
- for( i = 0; i < n; i++ )
- {
- int idx = ((cat_labels[i] == 65535) && data->is_buf_16u) ? -1 : cat_labels[i];
- double w = weights[i];
- int d = dir[i];
- double sum = lc[idx] + d*w;
- double sum_abs = rc[idx] + (d & 1)*w;
- lc[idx] = sum; rc[idx] = sum_abs;
- }
-
- for( i = 0; i < mi; i++ )
- {
- double sum = lc[i];
- double sum_abs = rc[i];
- lc[i] = (sum_abs - sum) * 0.5;
- rc[i] = (sum_abs + sum) * 0.5;
- }
- // 2. now form the split.
- // in each category send all the samples to the same direction as majority
- for( i = 0; i < mi; i++ )
- {
- double lval = lc[i], rval = rc[i];
- if( lval > rval )
- {
- split->subset[i >> 5] |= 1 << (i & 31);
- best_val += lval;
- }
- else
- best_val += rval;
+ normalizeWeights();
}
- split->quality = (float)best_val;
- if( split->quality <= node->maxlr )
- cvSetRemoveByPtr( data->split_heap, split ), split = 0;
-
- return split;
-}
-
-
-void
-CvBoostTree::calc_node_value( CvDTreeNode* node )
-{
- int i, n = node->sample_count;
- const double* weights = ensemble->get_weights()->data.db;
- cv::AutoBuffer<uchar> inn_buf(n*(sizeof(int) + ( data->is_classifier ? sizeof(int) : sizeof(int) + sizeof(float))));
- int* labels_buf = (int*)(uchar*)inn_buf;
- const int* labels = data->get_cv_labels(node, labels_buf);
- double* subtree_weights = ensemble->get_subtree_weights()->data.db;
- double rcw[2] = {0,0};
- int boost_type = ensemble->get_params().boost_type;
-
- if( data->is_classifier )
+ void normalizeWeights()
{
- int* _responses_buf = labels_buf + n;
- const int* _responses = data->get_class_labels(node, _responses_buf);
- int m = data->get_num_classes();
- int* cls_count = data->counts->data.i;
- for( int k = 0; k < m; k++ )
- cls_count[k] = 0;
-
+ int i, n = (int)w->sidx.size();
+ double sumw = 0, a, b;
for( i = 0; i < n; i++ )
+ sumw += w->sample_weights[w->sidx[i]];
+ if( sumw > DBL_EPSILON )
{
- int idx = labels[i];
- double w = weights[idx];
- int r = _responses[i];
- rcw[r] += w;
- cls_count[r]++;
- subtree_weights[i] = w;
- }
-
- node->class_idx = rcw[1] > rcw[0];
-
- if( boost_type == CvBoost::DISCRETE )
- {
- // ignore cat_map for responses, and use {-1,1},
- // as the whole ensemble response is computes as sign(sum_i(weak_response_i)
- node->value = node->class_idx*2 - 1;
+ a = 1./sumw;
+ b = 0;
}
else
- {
- double p = rcw[1]/(rcw[0] + rcw[1]);
- assert( boost_type == CvBoost::REAL );
-
- // store log-ratio of the probability
- node->value = 0.5*log_ratio(p);
- }
- }
- else
- {
- // in case of regression tree:
- // * node value is 1/n*sum_i(Y_i), where Y_i is i-th response,
- // n is the number of samples in the node.
- // * node risk is the sum of squared errors: sum_i((Y_i - <node_value>)^2)
- double sum = 0, sum2 = 0, iw;
- float* values_buf = (float*)(labels_buf + n);
- int* sample_indices_buf = (int*)(values_buf + n);
- const float* values = data->get_ord_responses(node, values_buf, sample_indices_buf);
-
- for( i = 0; i < n; i++ )
- {
- int idx = labels[i];
- double w = weights[idx]/*priors[values[i] > 0]*/;
- double t = values[i];
- rcw[0] += w;
- subtree_weights[i] = w;
- sum += t*w;
- sum2 += t*t*w;
- }
-
- iw = 1./rcw[0];
- node->value = sum*iw;
- node->node_risk = sum2 - (sum*iw)*sum;
-
- // renormalize the risk, as in try_split_node the unweighted formula
- // sqrt(risk)/n is used, rather than sqrt(risk)/sum(weights_i)
- node->node_risk *= n*iw*n*iw;
- }
-
- // store summary weights
- subtree_weights[n] = rcw[0];
- subtree_weights[n+1] = rcw[1];
-}
-
-
-void CvBoostTree::read( CvFileStorage* fs, CvFileNode* fnode, CvBoost* _ensemble, CvDTreeTrainData* _data )
-{
- CvDTree::read( fs, fnode, _data );
- ensemble = _ensemble;
-}
-
-void CvBoostTree::read( CvFileStorage*, CvFileNode* )
-{
- assert(0);
-}
-
-void CvBoostTree::read( CvFileStorage* _fs, CvFileNode* _node,
- CvDTreeTrainData* _data )
-{
- CvDTree::read( _fs, _node, _data );
-}
-
-
-/////////////////////////////////// CvBoost /////////////////////////////////////
-
-CvBoost::CvBoost()
-{
- data = 0;
- weak = 0;
- default_model_name = "my_boost_tree";
-
- active_vars = active_vars_abs = orig_response = sum_response = weak_eval =
- subsample_mask = weights = subtree_weights = 0;
- have_active_cat_vars = have_subsample = false;
-
- clear();
-}
-
-
-void CvBoost::prune( CvSlice slice )
-{
- if( weak && weak->total > 0 )
- {
- CvSeqReader reader;
- int i, count = cvSliceLength( slice, weak );
-
- cvStartReadSeq( weak, &reader );
- cvSetSeqReaderPos( &reader, slice.start_index );
-
- for( i = 0; i < count; i++ )
- {
- CvBoostTree* w;
- CV_READ_SEQ_ELEM( w, reader );
- delete w;
- }
-
- cvSeqRemoveSlice( weak, slice );
- }
-}
-
-
-void CvBoost::clear()
-{
- if( weak )
- {
- prune( CV_WHOLE_SEQ );
- cvReleaseMemStorage( &weak->storage );
- }
- if( data )
- delete data;
- weak = 0;
- data = 0;
- cvReleaseMat( &active_vars );
- cvReleaseMat( &active_vars_abs );
- cvReleaseMat( &orig_response );
- cvReleaseMat( &sum_response );
- cvReleaseMat( &weak_eval );
- cvReleaseMat( &subsample_mask );
- cvReleaseMat( &weights );
- cvReleaseMat( &subtree_weights );
-
- have_subsample = false;
-}
-
-
-CvBoost::~CvBoost()
-{
- clear();
-}
-
-
-CvBoost::CvBoost( const CvMat* _train_data, int _tflag,
- const CvMat* _responses, const CvMat* _var_idx,
- const CvMat* _sample_idx, const CvMat* _var_type,
- const CvMat* _missing_mask, CvBoostParams _params )
-{
- weak = 0;
- data = 0;
- default_model_name = "my_boost_tree";
-
- active_vars = active_vars_abs = orig_response = sum_response = weak_eval =
- subsample_mask = weights = subtree_weights = 0;
-
- train( _train_data, _tflag, _responses, _var_idx, _sample_idx,
- _var_type, _missing_mask, _params );
-}
-
-
-bool
-CvBoost::set_params( const CvBoostParams& _params )
-{
- bool ok = false;
-
- CV_FUNCNAME( "CvBoost::set_params" );
-
- __BEGIN__;
-
- params = _params;
- if( params.boost_type != DISCRETE && params.boost_type != REAL &&
- params.boost_type != LOGIT && params.boost_type != GENTLE )
- CV_ERROR( CV_StsBadArg, "Unknown/unsupported boosting type" );
-
- params.weak_count = MAX( params.weak_count, 1 );
- params.weight_trim_rate = MAX( params.weight_trim_rate, 0. );
- params.weight_trim_rate = MIN( params.weight_trim_rate, 1. );
- if( params.weight_trim_rate < FLT_EPSILON )
- params.weight_trim_rate = 1.f;
-
- if( params.boost_type == DISCRETE &&
- params.split_criteria != GINI && params.split_criteria != MISCLASS )
- params.split_criteria = MISCLASS;
- if( params.boost_type == REAL &&
- params.split_criteria != GINI && params.split_criteria != MISCLASS )
- params.split_criteria = GINI;
- if( (params.boost_type == LOGIT || params.boost_type == GENTLE) &&
- params.split_criteria != SQERR )
- params.split_criteria = SQERR;
-
- ok = true;
-
- __END__;
-
- return ok;
-}
-
-
-bool
-CvBoost::train( const CvMat* _train_data, int _tflag,
- const CvMat* _responses, const CvMat* _var_idx,
- const CvMat* _sample_idx, const CvMat* _var_type,
- const CvMat* _missing_mask,
- CvBoostParams _params, bool _update )
-{
- bool ok = false;
- CvMemStorage* storage = 0;
-
- CV_FUNCNAME( "CvBoost::train" );
-
- __BEGIN__;
-
- int i;
-
- set_params( _params );
-
- cvReleaseMat( &active_vars );
- cvReleaseMat( &active_vars_abs );
-
- if( !_update || !data )
- {
- clear();
- data = new CvDTreeTrainData( _train_data, _tflag, _responses, _var_idx,
- _sample_idx, _var_type, _missing_mask, _params, true, true );
-
- if( data->get_num_classes() != 2 )
- CV_ERROR( CV_StsNotImplemented,
- "Boosted trees can only be used for 2-class classification." );
- CV_CALL( storage = cvCreateMemStorage() );
- weak = cvCreateSeq( 0, sizeof(CvSeq), sizeof(CvBoostTree*), storage );
- storage = 0;
- }
- else
- {
- data->set_data( _train_data, _tflag, _responses, _var_idx,
- _sample_idx, _var_type, _missing_mask, _params, true, true, true );
- }
-
- if ( (_params.boost_type == LOGIT) || (_params.boost_type == GENTLE) )
- data->do_responses_copy();
-
- update_weights( 0 );
-
- for( i = 0; i < params.weak_count; i++ )
- {
- CvBoostTree* tree = new CvBoostTree;
- if( !tree->train( data, subsample_mask, this ) )
- {
- delete tree;
- break;
- }
- //cvCheckArr( get_weak_response());
- cvSeqPush( weak, &tree );
- update_weights( tree );
- trim_weights();
- if( cvCountNonZero(subsample_mask) == 0 )
- break;
- }
-
- if(weak->total > 0)
- {
- get_active_vars(); // recompute active_vars* maps and condensed_idx's in the splits.
- data->is_classifier = true;
- data->free_train_data();
- ok = true;
- }
- else
- clear();
-
- __END__;
-
- return ok;
-}
-
-bool CvBoost::train( CvMLData* _data,
- CvBoostParams _params,
- bool update )
-{
- bool result = false;
-
- CV_FUNCNAME( "CvBoost::train" );
-
- __BEGIN__;
-
- const CvMat* values = _data->get_values();
- const CvMat* response = _data->get_responses();
- const CvMat* missing = _data->get_missing();
- const CvMat* var_types = _data->get_var_types();
- const CvMat* train_sidx = _data->get_train_sample_idx();
- const CvMat* var_idx = _data->get_var_idx();
-
- CV_CALL( result = train( values, CV_ROW_SAMPLE, response, var_idx,
- train_sidx, var_types, missing, _params, update ) );
-
- __END__;
-
- return result;
-}
-
-void CvBoost::initialize_weights(double (&p)[2])
-{
- p[0] = 1.;
- p[1] = 1.;
-}
-
-void
-CvBoost::update_weights( CvBoostTree* tree )
-{
- CV_FUNCNAME( "CvBoost::update_weights" );
-
- __BEGIN__;
-
- int i, n = data->sample_count;
- double sumw = 0.;
- int step = 0;
- float* fdata = 0;
- int *sample_idx_buf;
- const int* sample_idx = 0;
- cv::AutoBuffer<uchar> inn_buf;
- size_t _buf_size = (params.boost_type == LOGIT) || (params.boost_type == GENTLE) ? (size_t)(data->sample_count)*sizeof(int) : 0;
- if( !tree )
- _buf_size += n*sizeof(int);
- else
- {
- if( have_subsample )
- _buf_size += data->get_length_subbuf()*(sizeof(float)+sizeof(uchar));
+ {
+ a = 0;
+ b = 1;
+ }
+ for( i = 0; i < n; i++ )
+ {
+ double& wval = w->sample_weights[w->sidx[i]];
+ wval = wval*a + b;
+ }
}
- inn_buf.allocate(_buf_size);
- uchar* cur_buf_pos = (uchar*)inn_buf;
- if ( (params.boost_type == LOGIT) || (params.boost_type == GENTLE) )
+ void endTraining()
{
- step = CV_IS_MAT_CONT(data->responses_copy->type) ?
- 1 : data->responses_copy->step / CV_ELEM_SIZE(data->responses_copy->type);
- fdata = data->responses_copy->data.fl;
- sample_idx_buf = (int*)cur_buf_pos;
- cur_buf_pos = (uchar*)(sample_idx_buf + data->sample_count);
- sample_idx = data->get_sample_indices( data->data_root, sample_idx_buf );
+ DTreesImpl::endTraining();
+ vector<double> e;
+ std::swap(sumResult, e);
}
- CvMat* dtree_data_buf = data->buf;
- size_t length_buf_row = data->get_length_subbuf();
- if( !tree ) // before training the first tree, initialize weights and other parameters
+
+ void scaleTree( int root, double scale )
{
- int* class_labels_buf = (int*)cur_buf_pos;
- cur_buf_pos = (uchar*)(class_labels_buf + n);
- const int* class_labels = data->get_class_labels(data->data_root, class_labels_buf);
- // in case of logitboost and gentle adaboost each weak tree is a regression tree,
- // so we need to convert class labels to floating-point values
-
- double w0 = 1./ n;
- double p[2] = { 1., 1. };
- initialize_weights(p);
-
- cvReleaseMat( &orig_response );
- cvReleaseMat( &sum_response );
- cvReleaseMat( &weak_eval );
- cvReleaseMat( &subsample_mask );
- cvReleaseMat( &weights );
- cvReleaseMat( &subtree_weights );
-
- CV_CALL( orig_response = cvCreateMat( 1, n, CV_32S ));
- CV_CALL( weak_eval = cvCreateMat( 1, n, CV_64F ));
- CV_CALL( subsample_mask = cvCreateMat( 1, n, CV_8U ));
- CV_CALL( weights = cvCreateMat( 1, n, CV_64F ));
- CV_CALL( subtree_weights = cvCreateMat( 1, n + 2, CV_64F ));
-
- if( data->have_priors )
- {
- // compute weight scale for each class from their prior probabilities
- int c1 = 0;
- for( i = 0; i < n; i++ )
- c1 += class_labels[i];
- p[0] = data->priors->data.db[0]*(c1 < n ? 1./(n - c1) : 0.);
- p[1] = data->priors->data.db[1]*(c1 > 0 ? 1./c1 : 0.);
- p[0] /= p[0] + p[1];
- p[1] = 1. - p[0];
- }
+ int nidx = root, pidx = 0;
+ Node *node = 0;
- if (data->is_buf_16u)
+ // traverse the tree and save all the nodes in depth-first order
+ for(;;)
{
- unsigned short* labels = (unsigned short*)(dtree_data_buf->data.s + data->data_root->buf_idx*length_buf_row +
- data->data_root->offset + (data->work_var_count-1)*data->sample_count);
- for( i = 0; i < n; i++ )
+ for(;;)
{
- // save original categorical responses {0,1}, convert them to {-1,1}
- orig_response->data.i[i] = class_labels[i]*2 - 1;
- // make all the samples active at start.
- // later, in trim_weights() deactivate/reactive again some, if need
- subsample_mask->data.ptr[i] = (uchar)1;
- // make all the initial weights the same.
- weights->data.db[i] = w0*p[class_labels[i]];
- // set the labels to find (from within weak tree learning proc)
- // the particular sample weight, and where to store the response.
- labels[i] = (unsigned short)i;
+ node = &nodes[nidx];
+ node->value *= scale;
+ if( node->left < 0 )
+ break;
+ nidx = node->left;
}
- }
- else
- {
- int* labels = dtree_data_buf->data.i + data->data_root->buf_idx*length_buf_row +
- data->data_root->offset + (data->work_var_count-1)*data->sample_count;
- for( i = 0; i < n; i++ )
- {
- // save original categorical responses {0,1}, convert them to {-1,1}
- orig_response->data.i[i] = class_labels[i]*2 - 1;
- // make all the samples active at start.
- // later, in trim_weights() deactivate/reactive again some, if need
- subsample_mask->data.ptr[i] = (uchar)1;
- // make all the initial weights the same.
- weights->data.db[i] = w0*p[class_labels[i]];
- // set the labels to find (from within weak tree learning proc)
- // the particular sample weight, and where to store the response.
- labels[i] = i;
- }
+ for( pidx = node->parent; pidx >= 0 && nodes[pidx].right == nidx;
+ nidx = pidx, pidx = nodes[pidx].parent )
+ ;
+
+ if( pidx < 0 )
+ break;
+
+ nidx = nodes[pidx].right;
}
+ }
- if( params.boost_type == LOGIT )
+ void calcValue( int nidx, const vector<int>& _sidx )
+ {
+ DTreesImpl::calcValue(nidx, _sidx);
+ WNode* node = &w->wnodes[nidx];
+ if( bparams.boostType == Boost::DISCRETE )
{
- CV_CALL( sum_response = cvCreateMat( 1, n, CV_64F ));
-
- for( i = 0; i < n; i++ )
- {
- sum_response->data.db[i] = 0;
- fdata[sample_idx[i]*step] = orig_response->data.i[i] > 0 ? 2.f : -2.f;
- }
-
- // in case of logitboost each weak tree is a regression tree.
- // the target function values are recalculated for each of the trees
- data->is_classifier = false;
+ node->value = node->class_idx == 0 ? -1 : 1;
}
- else if( params.boost_type == GENTLE )
+ else if( bparams.boostType == Boost::REAL )
{
- for( i = 0; i < n; i++ )
- fdata[sample_idx[i]*step] = (float)orig_response->data.i[i];
-
- data->is_classifier = false;
+ double p = node->value;
+ node->value = 0.5*log_ratio(p);
}
}
- else
- {
- // at this moment, for all the samples that participated in the training of the most
- // recent weak classifier we know the responses. For other samples we need to compute them
- if( have_subsample )
- {
- float* values = (float*)cur_buf_pos;
- cur_buf_pos = (uchar*)(values + data->get_length_subbuf());
- uchar* missing = cur_buf_pos;
- cur_buf_pos = missing + data->get_length_subbuf() * (size_t)CV_ELEM_SIZE(data->buf->type);
- CvMat _sample, _mask;
+ bool train( const Ptr<TrainData>& trainData, int flags )
+ {
+ Params dp(bparams.maxDepth, bparams.minSampleCount, bparams.regressionAccuracy,
+ bparams.useSurrogates, bparams.maxCategories, 0,
+ false, false, bparams.priors);
+ setDParams(dp);
+ startTraining(trainData, flags);
+ int treeidx, ntrees = bparams.weakCount >= 0 ? bparams.weakCount : 10000;
+ vector<int> sidx = w->sidx;
- // invert the subsample mask
- cvXorS( subsample_mask, cvScalar(1.), subsample_mask );
- data->get_vectors( subsample_mask, values, missing, 0 );
+ for( treeidx = 0; treeidx < ntrees; treeidx++ )
+ {
+ int root = addTree( sidx );
+ if( root < 0 )
+ return false;
+ updateWeightsAndTrim( treeidx, sidx );
+ }
+ endTraining();
+ return true;
+ }
- _sample = cvMat( 1, data->var_count, CV_32F );
- _mask = cvMat( 1, data->var_count, CV_8U );
+ void updateWeightsAndTrim( int treeidx, vector<int>& sidx )
+ {
+ int i, n = (int)w->sidx.size();
+ int nvars = (int)varIdx.size();
+ double sumw = 0.;
+ cv::AutoBuffer<double> buf(n*3 + nvars);
+ double* result = buf;
+ float* sbuf = (float*)(result + n*3);
+ Mat sample(1, nvars, CV_32F, sbuf);
+ int predictFlags = bparams.boostType == Boost::DISCRETE ? (PREDICT_MAX_VOTE | RAW_OUTPUT) : PREDICT_SUM;
+ predictFlags |= COMPRESSED_INPUT;
- // run tree through all the non-processed samples
- for( i = 0; i < n; i++ )
- if( subsample_mask->data.ptr[i] )
- {
- _sample.data.fl = values;
- _mask.data.ptr = missing;
- values += _sample.cols;
- missing += _mask.cols;
- weak_eval->data.db[i] = tree->predict( &_sample, &_mask, true )->value;
- }
+ for( i = 0; i < n; i++ )
+ {
+ w->data->getSample(varIdx, w->sidx[i], sbuf );
+ result[i] = predictTrees(Range(treeidx, treeidx+1), sample, predictFlags);
}
// now update weights and other parameters for each type of boosting
- if( params.boost_type == DISCRETE )
+ if( bparams.boostType == Boost::DISCRETE )
{
// Discrete AdaBoost:
// weak_eval[i] (=f(x_i)) is in {-1,1}
// err = sum(w_i*(f(x_i) != y_i))/sum(w_i)
// C = log((1-err)/err)
// w_i *= exp(C*(f(x_i) != y_i))
-
- double C, err = 0.;
- double scale[] = { 1., 0. };
+ double err = 0.;
for( i = 0; i < n; i++ )
{
- double w = weights->data.db[i];
- sumw += w;
- err += w*(weak_eval->data.db[i] != orig_response->data.i[i]);
+ int si = w->sidx[i];
+ double wval = w->sample_weights[si];
+ sumw += wval;
+ err += wval*(result[i] != w->cat_responses[si]);
}
if( sumw != 0 )
err /= sumw;
- C = err = -log_ratio( err );
- scale[1] = exp(err);
+ double C = -log_ratio( err );
+ double scale = std::exp(C);
sumw = 0;
for( i = 0; i < n; i++ )
{
- double w = weights->data.db[i]*
- scale[weak_eval->data.db[i] != orig_response->data.i[i]];
- sumw += w;
- weights->data.db[i] = w;
+ int si = w->sidx[i];
+ double wval = w->sample_weights[si];
+ if( result[i] != w->cat_responses[si] )
+ wval *= scale;
+ sumw += wval;
+ w->sample_weights[si] = wval;
}
- tree->scale( C );
+ scaleTree(roots[treeidx], C);
}
- else if( params.boost_type == REAL )
+ else if( bparams.boostType == Boost::REAL || bparams.boostType == Boost::GENTLE )
{
// Real AdaBoost:
// weak_eval[i] = f(x_i) = 0.5*log(p(x_i)/(1-p(x_i))), p(x_i)=P(y=1|x_i)
// w_i *= exp(-y_i*f(x_i))
- for( i = 0; i < n; i++ )
- weak_eval->data.db[i] *= -orig_response->data.i[i];
-
- cvExp( weak_eval, weak_eval );
-
+ // Gentle AdaBoost:
+ // weak_eval[i] = f(x_i) in [-1,1]
+ // w_i *= exp(-y_i*f(x_i))
for( i = 0; i < n; i++ )
{
- double w = weights->data.db[i]*weak_eval->data.db[i];
- sumw += w;
- weights->data.db[i] = w;
+ int si = w->sidx[i];
+ double wval = w->sample_weights[si]*std::exp(-result[i]*w->ord_responses[si]);
+ sumw += wval;
+ w->sample_weights[si] = wval;
}
}
- else if( params.boost_type == LOGIT )
+ else if( bparams.boostType == Boost::LOGIT )
{
// LogitBoost:
// weak_eval[i] = f(x_i) in [-z_max,z_max]
// w_i = p(x_i)*1(1 - p(x_i))
// z_i = ((y_i+1)/2 - p(x_i))/(p(x_i)*(1 - p(x_i)))
// store z_i to the data->data_root as the new target responses
-
const double lb_weight_thresh = FLT_EPSILON;
const double lb_z_max = 10.;
- /*float* responses_buf = data->get_resp_float_buf();
- const float* responses = 0;
- data->get_ord_responses(data->data_root, responses_buf, &responses);*/
-
- /*if( weak->total == 7 )
- putchar('*');*/
-
- for( i = 0; i < n; i++ )
- {
- double s = sum_response->data.db[i] + 0.5*weak_eval->data.db[i];
- sum_response->data.db[i] = s;
- weak_eval->data.db[i] = -2*s;
- }
-
- cvExp( weak_eval, weak_eval );
for( i = 0; i < n; i++ )
{
- double p = 1./(1. + weak_eval->data.db[i]);
- double w = p*(1 - p), z;
- w = MAX( w, lb_weight_thresh );
- weights->data.db[i] = w;
- sumw += w;
- if( orig_response->data.i[i] > 0 )
+ int si = w->sidx[i];
+ sumResult[i] += 0.5*result[i];
+ double p = 1./(1 + std::exp(-2*sumResult[i]));
+ double wval = std::max( p*(1 - p), lb_weight_thresh ), z;
+ w->sample_weights[si] = wval;
+ sumw += wval;
+ if( w->ord_responses[si] > 0 )
{
z = 1./p;
- fdata[sample_idx[i]*step] = (float)MIN(z, lb_z_max);
+ w->ord_responses[si] = std::min(z, lb_z_max);
}
else
{
z = 1./(1-p);
- fdata[sample_idx[i]*step] = (float)-MIN(z, lb_z_max);
+ w->ord_responses[si] = -std::min(z, lb_z_max);
}
}
}
else
- {
- // Gentle AdaBoost:
- // weak_eval[i] = f(x_i) in [-1,1]
- // w_i *= exp(-y_i*f(x_i))
- assert( params.boost_type == GENTLE );
-
- for( i = 0; i < n; i++ )
- weak_eval->data.db[i] *= -orig_response->data.i[i];
-
- cvExp( weak_eval, weak_eval );
-
- for( i = 0; i < n; i++ )
- {
- double w = weights->data.db[i] * weak_eval->data.db[i];
- weights->data.db[i] = w;
- sumw += w;
- }
- }
- }
-
- // renormalize weights
- if( sumw > FLT_EPSILON )
- {
- sumw = 1./sumw;
- for( i = 0; i < n; ++i )
- weights->data.db[i] *= sumw;
- }
-
- __END__;
-}
-
-
-void
-CvBoost::trim_weights()
-{
- //CV_FUNCNAME( "CvBoost::trim_weights" );
-
- __BEGIN__;
-
- int i, count = data->sample_count, nz_count = 0;
- double sum, threshold;
-
- if( params.weight_trim_rate <= 0. || params.weight_trim_rate >= 1. )
- EXIT;
-
- // use weak_eval as temporary buffer for sorted weights
- cvCopy( weights, weak_eval );
-
- std::sort(weak_eval->data.db, weak_eval->data.db + count);
-
- // as weight trimming occurs immediately after updating the weights,
- // where they are renormalized, we assume that the weight sum = 1.
- sum = 1. - params.weight_trim_rate;
-
- for( i = 0; i < count; i++ )
- {
- double w = weak_eval->data.db[i];
- if( sum <= 0 )
- break;
- sum -= w;
- }
-
- threshold = i < count ? weak_eval->data.db[i] : DBL_MAX;
-
- for( i = 0; i < count; i++ )
- {
- double w = weights->data.db[i];
- int f = w >= threshold;
- subsample_mask->data.ptr[i] = (uchar)f;
- nz_count += f;
- }
-
- have_subsample = nz_count < count;
-
- __END__;
-}
-
-
-const CvMat*
-CvBoost::get_active_vars( bool absolute_idx )
-{
- CvMat* mask = 0;
- CvMat* inv_map = 0;
- CvMat* result = 0;
+ CV_Error(CV_StsNotImplemented, "Unknown boosting type");
+
+ // renormalize weights
+ if( sumw > FLT_EPSILON )
+ normalizeWeights();
- CV_FUNCNAME( "CvBoost::get_active_vars" );
+ if( bparams.weightTrimRate <= 0. || bparams.weightTrimRate >= 1. )
+ return;
- __BEGIN__;
+ for( i = 0; i < n; i++ )
+ result[i] = w->sample_weights[w->sidx[i]];
+ std::sort(result, result + n);
- if( !weak )
- CV_ERROR( CV_StsError, "The boosted tree ensemble has not been trained yet" );
+ // as weight trimming occurs immediately after updating the weights,
+ // where they are renormalized, we assume that the weight sum = 1.
+ sumw = 1. - bparams.weightTrimRate;
- if( !active_vars || !active_vars_abs )
- {
- CvSeqReader reader;
- int i, j, nactive_vars;
- CvBoostTree* wtree;
- const CvDTreeNode* node;
-
- assert(!active_vars && !active_vars_abs);
- mask = cvCreateMat( 1, data->var_count, CV_8U );
- inv_map = cvCreateMat( 1, data->var_count, CV_32S );
- cvZero( mask );
- cvSet( inv_map, cvScalar(-1) );
-
- // first pass: compute the mask of used variables
- cvStartReadSeq( weak, &reader );
- for( i = 0; i < weak->total; i++ )
+ for( i = 0; i < n; i++ )
{
- CV_READ_SEQ_ELEM(wtree, reader);
-
- node = wtree->get_root();
- assert( node != 0 );
- for(;;)
- {
- const CvDTreeNode* parent;
- for(;;)
- {
- CvDTreeSplit* split = node->split;
- for( ; split != 0; split = split->next )
- mask->data.ptr[split->var_idx] = 1;
- if( !node->left )
- break;
- node = node->left;
- }
-
- for( parent = node->parent; parent && parent->right == node;
- node = parent, parent = parent->parent )
- ;
-
- if( !parent )
- break;
-
- node = parent->right;
- }
+ double wval = result[i];
+ if( sumw <= 0 )
+ break;
+ sumw -= wval;
}
- nactive_vars = cvCountNonZero(mask);
+ double threshold = i < n ? result[i] : DBL_MAX;
+ sidx.clear();
- //if ( nactive_vars > 0 )
+ for( i = 0; i < n; i++ )
{
- active_vars = cvCreateMat( 1, nactive_vars, CV_32S );
- active_vars_abs = cvCreateMat( 1, nactive_vars, CV_32S );
-
- have_active_cat_vars = false;
-
- for( i = j = 0; i < data->var_count; i++ )
- {
- if( mask->data.ptr[i] )
- {
- active_vars->data.i[j] = i;
- active_vars_abs->data.i[j] = data->var_idx ? data->var_idx->data.i[i] : i;
- inv_map->data.i[i] = j;
- if( data->var_type->data.i[i] >= 0 )
- have_active_cat_vars = true;
- j++;
- }
- }
-
-
- // second pass: now compute the condensed indices
- cvStartReadSeq( weak, &reader );
- for( i = 0; i < weak->total; i++ )
- {
- CV_READ_SEQ_ELEM(wtree, reader);
- node = wtree->get_root();
- for(;;)
- {
- const CvDTreeNode* parent;
- for(;;)
- {
- CvDTreeSplit* split = node->split;
- for( ; split != 0; split = split->next )
- {
- split->condensed_idx = inv_map->data.i[split->var_idx];
- assert( split->condensed_idx >= 0 );
- }
-
- if( !node->left )
- break;
- node = node->left;
- }
-
- for( parent = node->parent; parent && parent->right == node;
- node = parent, parent = parent->parent )
- ;
-
- if( !parent )
- break;
-
- node = parent->right;
- }
- }
+ int si = w->sidx[i];
+ if( w->sample_weights[si] >= threshold )
+ sidx.push_back(si);
}
}
- result = absolute_idx ? active_vars_abs : active_vars;
-
- __END__;
-
- cvReleaseMat( &mask );
- cvReleaseMat( &inv_map );
-
- return result;
-}
-
-
-float
-CvBoost::predict( const CvMat* _sample, const CvMat* _missing,
- CvMat* weak_responses, CvSlice slice,
- bool raw_mode, bool return_sum ) const
-{
- float value = -FLT_MAX;
-
- CvSeqReader reader;
- double sum = 0;
- int wstep = 0;
- const float* sample_data;
-
- if( !weak )
- CV_Error( CV_StsError, "The boosted tree ensemble has not been trained yet" );
-
- if( !CV_IS_MAT(_sample) || CV_MAT_TYPE(_sample->type) != CV_32FC1 ||
- (_sample->cols != 1 && _sample->rows != 1) ||
- (_sample->cols + _sample->rows - 1 != data->var_all && !raw_mode) ||
- (active_vars && _sample->cols + _sample->rows - 1 != active_vars->cols && raw_mode) )
- CV_Error( CV_StsBadArg,
- "the input sample must be 1d floating-point vector with the same "
- "number of elements as the total number of variables or "
- "as the number of variables used for training" );
-
- if( _missing )
+ float predictTrees( const Range& range, const Mat& sample, int flags0 ) const
{
- if( !CV_IS_MAT(_missing) || !CV_IS_MASK_ARR(_missing) ||
- !CV_ARE_SIZES_EQ(_missing, _sample) )
- CV_Error( CV_StsBadArg,
- "the missing data mask must be 8-bit vector of the same size as input sample" );
+ int flags = (flags0 & ~PREDICT_MASK) | PREDICT_SUM;
+ float val = DTreesImpl::predictTrees(range, sample, flags);
+ if( flags != flags0 )
+ {
+ int ival = (int)(val > 0);
+ if( !(flags0 & RAW_OUTPUT) )
+ ival = classLabels[ival];
+ val = (float)ival;
+ }
+ return val;
}
- int i, weak_count = cvSliceLength( slice, weak );
- if( weak_count >= weak->total )
+ void writeTrainingParams( FileStorage& fs ) const
{
- weak_count = weak->total;
- slice.start_index = 0;
- }
+ fs << "boosting_type" <<
+ (bparams.boostType == Boost::DISCRETE ? "DiscreteAdaboost" :
+ bparams.boostType == Boost::REAL ? "RealAdaboost" :
+ bparams.boostType == Boost::LOGIT ? "LogitBoost" :
+ bparams.boostType == Boost::GENTLE ? "GentleAdaboost" : "Unknown");
- if( weak_responses )
- {
- if( !CV_IS_MAT(weak_responses) ||
- CV_MAT_TYPE(weak_responses->type) != CV_32FC1 ||
- (weak_responses->cols != 1 && weak_responses->rows != 1) ||
- weak_responses->cols + weak_responses->rows - 1 != weak_count )
- CV_Error( CV_StsBadArg,
- "The output matrix of weak classifier responses must be valid "
- "floating-point vector of the same number of components as the length of input slice" );
- wstep = CV_IS_MAT_CONT(weak_responses->type) ? 1 : weak_responses->step/sizeof(float);
+ DTreesImpl::writeTrainingParams(fs);
+ fs << "weight_trimming_rate" << bparams.weightTrimRate;
}
- int var_count = active_vars->cols;
- const int* vtype = data->var_type->data.i;
- const int* cmap = data->cat_map->data.i;
- const int* cofs = data->cat_ofs->data.i;
-
- cv::Mat sample = cv::cvarrToMat(_sample);
- cv::Mat missing;
- if(!_missing)
- missing = cv::cvarrToMat(_missing);
-
- // if need, preprocess the input vector
- if( !raw_mode )
+ void write( FileStorage& fs ) const
{
- int sstep, mstep = 0;
- const float* src_sample;
- const uchar* src_mask = 0;
- float* dst_sample;
- uchar* dst_mask;
- const int* vidx = active_vars->data.i;
- const int* vidx_abs = active_vars_abs->data.i;
- bool have_mask = _missing != 0;
+ if( roots.empty() )
+ CV_Error( CV_StsBadArg, "RTrees have not been trained" );
- sample = cv::Mat(1, var_count, CV_32FC1);
- missing = cv::Mat(1, var_count, CV_8UC1);
+ writeParams(fs);
- dst_sample = sample.ptr<float>();
- dst_mask = missing.ptr<uchar>();
+ int k, ntrees = (int)roots.size();
- src_sample = _sample->data.fl;
- sstep = CV_IS_MAT_CONT(_sample->type) ? 1 : _sample->step/sizeof(src_sample[0]);
+ fs << "ntrees" << ntrees
+ << "trees" << "[";
- if( _missing )
+ for( k = 0; k < ntrees; k++ )
{
- src_mask = _missing->data.ptr;
- mstep = CV_IS_MAT_CONT(_missing->type) ? 1 : _missing->step;
- }
-
- for( i = 0; i < var_count; i++ )
- {
- int idx = vidx[i], idx_abs = vidx_abs[i];
- float val = src_sample[idx_abs*sstep];
- int ci = vtype[idx];
- uchar m = src_mask ? src_mask[idx_abs*mstep] : (uchar)0;
-
- if( ci >= 0 )
- {
- int a = cofs[ci], b = (ci+1 >= data->cat_ofs->cols) ? data->cat_map->cols : cofs[ci+1],
- c = a;
- int ival = cvRound(val);
- if ( (ival != val) && (!m) )
- CV_Error( CV_StsBadArg,
- "one of input categorical variable is not an integer" );
-
- while( a < b )
- {
- c = (a + b) >> 1;
- if( ival < cmap[c] )
- b = c;
- else if( ival > cmap[c] )
- a = c+1;
- else
- break;
- }
-
- if( c < 0 || ival != cmap[c] )
- {
- m = 1;
- have_mask = true;
- }
- else
- {
- val = (float)(c - cofs[ci]);
- }
- }
-
- dst_sample[i] = val;
- dst_mask[i] = m;
+ fs << "{";
+ writeTree(fs, roots[k]);
+ fs << "}";
}
- if( !have_mask )
- missing.release();
- }
- else
- {
- if( !CV_IS_MAT_CONT(_sample->type & (_missing ? _missing->type : -1)) )
- CV_Error( CV_StsBadArg, "In raw mode the input vectors must be continuous" );
+ fs << "]";
}
- cvStartReadSeq( weak, &reader );
- cvSetSeqReaderPos( &reader, slice.start_index );
-
- sample_data = sample.ptr<float>();
-
- if( !have_active_cat_vars && missing.empty() && !weak_responses )
- {
- for( i = 0; i < weak_count; i++ )
- {
- CvBoostTree* wtree;
- const CvDTreeNode* node;
- CV_READ_SEQ_ELEM( wtree, reader );
-
- node = wtree->get_root();
- while( node->left )
- {
- CvDTreeSplit* split = node->split;
- int vi = split->condensed_idx;
- float val = sample_data[vi];
- int dir = val <= split->ord.c ? -1 : 1;
- if( split->inversed )
- dir = -dir;
- node = dir < 0 ? node->left : node->right;
- }
- sum += node->value;
- }
- }
- else
+ void readParams( const FileNode& fn )
{
- const int* avars = active_vars->data.i;
- const uchar* m = !missing.empty() ? missing.ptr<uchar>() : 0;
-
- // full-featured version
- for( i = 0; i < weak_count; i++ )
- {
- CvBoostTree* wtree;
- const CvDTreeNode* node;
- CV_READ_SEQ_ELEM( wtree, reader );
-
- node = wtree->get_root();
- while( node->left )
- {
- const CvDTreeSplit* split = node->split;
- int dir = 0;
- for( ; !dir && split != 0; split = split->next )
- {
- int vi = split->condensed_idx;
- int ci = vtype[avars[vi]];
- float val = sample_data[vi];
- if( m && m[vi] )
- continue;
- if( ci < 0 ) // ordered
- dir = val <= split->ord.c ? -1 : 1;
- else // categorical
- {
- int c = cvRound(val);
- dir = CV_DTREE_CAT_DIR(c, split->subset);
- }
- if( split->inversed )
- dir = -dir;
- }
+ DTreesImpl::readParams(fn);
+ bparams.maxDepth = params0.maxDepth;
+ bparams.minSampleCount = params0.minSampleCount;
+ bparams.regressionAccuracy = params0.regressionAccuracy;
+ bparams.useSurrogates = params0.useSurrogates;
+ bparams.maxCategories = params0.maxCategories;
+ bparams.priors = params0.priors;
- if( !dir )
- {
- int diff = node->right->sample_count - node->left->sample_count;
- dir = diff < 0 ? -1 : 1;
- }
- node = dir < 0 ? node->left : node->right;
- }
- if( weak_responses )
- weak_responses->data.fl[i*wstep] = (float)node->value;
- sum += node->value;
- }
+ FileNode tparams_node = fn["training_params"];
+ String bts = (String)tparams_node["boosting_type"];
+ bparams.boostType = (bts == "DiscreteAdaboost" ? Boost::DISCRETE :
+ bts == "RealAdaboost" ? Boost::REAL :
+ bts == "LogitBoost" ? Boost::LOGIT :
+ bts == "GentleAdaboost" ? Boost::GENTLE : -1);
+ _isClassifier = bparams.boostType == Boost::DISCRETE;
+ bparams.weightTrimRate = (double)tparams_node["weight_trimming_rate"];
}
- if( return_sum )
- value = (float)sum;
- else
+ void read( const FileNode& fn )
{
- int cls_idx = sum >= 0;
- if( raw_mode )
- value = (float)cls_idx;
- else
- value = (float)cmap[cofs[vtype[data->var_count]] + cls_idx];
- }
+ clear();
- return value;
-}
+ int ntrees = (int)fn["ntrees"];
+ readParams(fn);
-float CvBoost::calc_error( CvMLData* _data, int type, std::vector<float> *resp )
-{
- float err = 0;
- const CvMat* values = _data->get_values();
- const CvMat* response = _data->get_responses();
- const CvMat* missing = _data->get_missing();
- const CvMat* sample_idx = (type == CV_TEST_ERROR) ? _data->get_test_sample_idx() : _data->get_train_sample_idx();
- const CvMat* var_types = _data->get_var_types();
- int* sidx = sample_idx ? sample_idx->data.i : 0;
- int r_step = CV_IS_MAT_CONT(response->type) ?
- 1 : response->step / CV_ELEM_SIZE(response->type);
- bool is_classifier = var_types->data.ptr[var_types->cols-1] == CV_VAR_CATEGORICAL;
- int sample_count = sample_idx ? sample_idx->cols : 0;
- sample_count = (type == CV_TRAIN_ERROR && sample_count == 0) ? values->rows : sample_count;
- float* pred_resp = 0;
- if( resp && (sample_count > 0) )
- {
- resp->resize( sample_count );
- pred_resp = &((*resp)[0]);
- }
- if ( is_classifier )
- {
- for( int i = 0; i < sample_count; i++ )
- {
- CvMat sample, miss;
- int si = sidx ? sidx[i] : i;
- cvGetRow( values, &sample, si );
- if( missing )
- cvGetRow( missing, &miss, si );
- float r = (float)predict( &sample, missing ? &miss : 0 );
- if( pred_resp )
- pred_resp[i] = r;
- int d = fabs((double)r - response->data.fl[si*r_step]) <= FLT_EPSILON ? 0 : 1;
- err += d;
- }
- err = sample_count ? err / (float)sample_count * 100 : -FLT_MAX;
- }
- else
- {
- for( int i = 0; i < sample_count; i++ )
+ FileNode trees_node = fn["trees"];
+ FileNodeIterator it = trees_node.begin();
+ CV_Assert( ntrees == (int)trees_node.size() );
+
+ for( int treeidx = 0; treeidx < ntrees; treeidx++, ++it )
{
- CvMat sample, miss;
- int si = sidx ? sidx[i] : i;
- cvGetRow( values, &sample, si );
- if( missing )
- cvGetRow( missing, &miss, si );
- float r = (float)predict( &sample, missing ? &miss : 0 );
- if( pred_resp )
- pred_resp[i] = r;
- float d = r - response->data.fl[si*r_step];
- err += d*d;
+ FileNode nfn = (*it)["nodes"];
+ readTree(nfn);
}
- err = sample_count ? err / (float)sample_count : -FLT_MAX;
}
- return err;
-}
-
-void CvBoost::write_params( CvFileStorage* fs ) const
-{
- const char* boost_type_str =
- params.boost_type == DISCRETE ? "DiscreteAdaboost" :
- params.boost_type == REAL ? "RealAdaboost" :
- params.boost_type == LOGIT ? "LogitBoost" :
- params.boost_type == GENTLE ? "GentleAdaboost" : 0;
-
- const char* split_crit_str =
- params.split_criteria == DEFAULT ? "Default" :
- params.split_criteria == GINI ? "Gini" :
- params.boost_type == MISCLASS ? "Misclassification" :
- params.boost_type == SQERR ? "SquaredErr" : 0;
-
- if( boost_type_str )
- cvWriteString( fs, "boosting_type", boost_type_str );
- else
- cvWriteInt( fs, "boosting_type", params.boost_type );
-
- if( split_crit_str )
- cvWriteString( fs, "splitting_criteria", split_crit_str );
- else
- cvWriteInt( fs, "splitting_criteria", params.split_criteria );
-
- cvWriteInt( fs, "ntrees", weak->total );
- cvWriteReal( fs, "weight_trimming_rate", params.weight_trim_rate );
-
- data->write_params( fs );
-}
+
+ Boost::Params bparams;
+ vector<double> sumResult;
+};
-void CvBoost::read_params( CvFileStorage* fs, CvFileNode* fnode )
+class BoostImpl : public Boost
{
- CV_FUNCNAME( "CvBoost::read_params" );
-
- __BEGIN__;
-
- CvFileNode* temp;
-
- if( !fnode || !CV_NODE_IS_MAP(fnode->tag) )
- return;
-
- data = new CvDTreeTrainData();
- CV_CALL( data->read_params(fs, fnode));
- data->shared = true;
-
- params.max_depth = data->params.max_depth;
- params.min_sample_count = data->params.min_sample_count;
- params.max_categories = data->params.max_categories;
- params.priors = data->params.priors;
- params.regression_accuracy = data->params.regression_accuracy;
- params.use_surrogates = data->params.use_surrogates;
+public:
+ BoostImpl() {}
+ virtual ~BoostImpl() {}
- temp = cvGetFileNodeByName( fs, fnode, "boosting_type" );
- if( !temp )
- return;
+ String getDefaultModelName() const { return "opencv_ml_boost"; }
- if( temp && CV_NODE_IS_STRING(temp->tag) )
+ bool train( const Ptr<TrainData>& trainData, int flags )
{
- const char* boost_type_str = cvReadString( temp, "" );
- params.boost_type = strcmp( boost_type_str, "DiscreteAdaboost" ) == 0 ? DISCRETE :
- strcmp( boost_type_str, "RealAdaboost" ) == 0 ? REAL :
- strcmp( boost_type_str, "LogitBoost" ) == 0 ? LOGIT :
- strcmp( boost_type_str, "GentleAdaboost" ) == 0 ? GENTLE : -1;
+ return impl.train(trainData, flags);
}
- else
- params.boost_type = cvReadInt( temp, -1 );
-
- if( params.boost_type < DISCRETE || params.boost_type > GENTLE )
- CV_ERROR( CV_StsBadArg, "Unknown boosting type" );
- temp = cvGetFileNodeByName( fs, fnode, "splitting_criteria" );
- if( temp && CV_NODE_IS_STRING(temp->tag) )
+ float predict( InputArray samples, OutputArray results, int flags ) const
{
- const char* split_crit_str = cvReadString( temp, "" );
- params.split_criteria = strcmp( split_crit_str, "Default" ) == 0 ? DEFAULT :
- strcmp( split_crit_str, "Gini" ) == 0 ? GINI :
- strcmp( split_crit_str, "Misclassification" ) == 0 ? MISCLASS :
- strcmp( split_crit_str, "SquaredErr" ) == 0 ? SQERR : -1;
+ return impl.predict(samples, results, flags);
}
- else
- params.split_criteria = cvReadInt( temp, -1 );
-
- if( params.split_criteria < DEFAULT || params.boost_type > SQERR )
- CV_ERROR( CV_StsBadArg, "Unknown boosting type" );
-
- params.weak_count = cvReadIntByName( fs, fnode, "ntrees" );
- params.weight_trim_rate = cvReadRealByName( fs, fnode, "weight_trimming_rate", 0. );
-
- __END__;
-}
-
-
-
-void
-CvBoost::read( CvFileStorage* fs, CvFileNode* node )
-{
- CV_FUNCNAME( "CvBoost::read" );
-
- __BEGIN__;
-
- CvSeqReader reader;
- CvFileNode* trees_fnode;
- CvMemStorage* storage;
- int i, ntrees;
-
- clear();
- read_params( fs, node );
-
- if( !data )
- EXIT;
- trees_fnode = cvGetFileNodeByName( fs, node, "trees" );
- if( !trees_fnode || !CV_NODE_IS_SEQ(trees_fnode->tag) )
- CV_ERROR( CV_StsParseError, "<trees> tag is missing" );
-
- cvStartReadSeq( trees_fnode->data.seq, &reader );
- ntrees = trees_fnode->data.seq->total;
-
- if( ntrees != params.weak_count )
- CV_ERROR( CV_StsUnmatchedSizes,
- "The number of trees stored does not match <ntrees> tag value" );
-
- CV_CALL( storage = cvCreateMemStorage() );
- weak = cvCreateSeq( 0, sizeof(CvSeq), sizeof(CvBoostTree*), storage );
-
- for( i = 0; i < ntrees; i++ )
+ void write( FileStorage& fs ) const
{
- CvBoostTree* tree = new CvBoostTree();
- CV_CALL(tree->read( fs, (CvFileNode*)reader.ptr, this, data ));
- CV_NEXT_SEQ_ELEM( reader.seq->elem_size, reader );
- cvSeqPush( weak, &tree );
+ impl.write(fs);
}
- get_active_vars();
-
- __END__;
-}
-
-
-void
-CvBoost::write( CvFileStorage* fs, const char* name ) const
-{
- CV_FUNCNAME( "CvBoost::write" );
-
- __BEGIN__;
-
- CvSeqReader reader;
- int i;
-
- cvStartWriteStruct( fs, name, CV_NODE_MAP, CV_TYPE_NAME_ML_BOOSTING );
- if( !weak )
- CV_ERROR( CV_StsBadArg, "The classifier has not been trained yet" );
-
- write_params( fs );
- cvStartWriteStruct( fs, "trees", CV_NODE_SEQ );
-
- cvStartReadSeq( weak, &reader );
-
- for( i = 0; i < weak->total; i++ )
+ void read( const FileNode& fn )
{
- CvBoostTree* tree;
- CV_READ_SEQ_ELEM( tree, reader );
- cvStartWriteStruct( fs, 0, CV_NODE_MAP );
- tree->write( fs );
- cvEndWriteStruct( fs );
+ impl.read(fn);
}
- cvEndWriteStruct( fs );
- cvEndWriteStruct( fs );
-
- __END__;
-}
-
-
-CvMat*
-CvBoost::get_weights()
-{
- return weights;
-}
-
-
-CvMat*
-CvBoost::get_subtree_weights()
-{
- return subtree_weights;
-}
-
-
-CvMat*
-CvBoost::get_weak_response()
-{
- return weak_eval;
-}
-
-
-const CvBoostParams&
-CvBoost::get_params() const
-{
- return params;
-}
+ void setBParams(const Params& p) { impl.setBParams(p); }
+ Params getBParams() const { return impl.getBParams(); }
-CvSeq* CvBoost::get_weak_predictors()
-{
- return weak;
-}
+ int getVarCount() const { return impl.getVarCount(); }
-const CvDTreeTrainData* CvBoost::get_data() const
-{
- return data;
-}
+ bool isTrained() const { return impl.isTrained(); }
+ bool isClassifier() const { return impl.isClassifier(); }
-using namespace cv;
+ const vector<int>& getRoots() const { return impl.getRoots(); }
+ const vector<Node>& getNodes() const { return impl.getNodes(); }
+ const vector<Split>& getSplits() const { return impl.getSplits(); }
+ const vector<int>& getSubsets() const { return impl.getSubsets(); }
-CvBoost::CvBoost( const Mat& _train_data, int _tflag,
- const Mat& _responses, const Mat& _var_idx,
- const Mat& _sample_idx, const Mat& _var_type,
- const Mat& _missing_mask,
- CvBoostParams _params )
-{
- weak = 0;
- data = 0;
- default_model_name = "my_boost_tree";
- active_vars = active_vars_abs = orig_response = sum_response = weak_eval =
- subsample_mask = weights = subtree_weights = 0;
-
- train( _train_data, _tflag, _responses, _var_idx, _sample_idx,
- _var_type, _missing_mask, _params );
-}
+ DTreesImplForBoost impl;
+};
-bool
-CvBoost::train( const Mat& _train_data, int _tflag,
- const Mat& _responses, const Mat& _var_idx,
- const Mat& _sample_idx, const Mat& _var_type,
- const Mat& _missing_mask,
- CvBoostParams _params, bool _update )
+Ptr<Boost> Boost::create(const Params& params)
{
- train_data_hdr = _train_data;
- train_data_mat = _train_data;
- responses_hdr = _responses;
- responses_mat = _responses;
-
- CvMat vidx = _var_idx, sidx = _sample_idx, vtype = _var_type, mmask = _missing_mask;
-
- return train(&train_data_hdr, _tflag, &responses_hdr, vidx.data.ptr ? &vidx : 0,
- sidx.data.ptr ? &sidx : 0, vtype.data.ptr ? &vtype : 0,
- mmask.data.ptr ? &mmask : 0, _params, _update);
+ Ptr<BoostImpl> p = makePtr<BoostImpl>();
+ p->setBParams(params);
+ return p;
}
-float
-CvBoost::predict( const Mat& _sample, const Mat& _missing,
- const Range& slice, bool raw_mode, bool return_sum ) const
-{
- CvMat sample = _sample, mmask = _missing;
- /*if( weak_responses )
- {
- int weak_count = cvSliceLength( slice, weak );
- if( weak_count >= weak->total )
- {
- weak_count = weak->total;
- slice.start_index = 0;
- }
-
- if( !(weak_responses->data && weak_responses->type() == CV_32FC1 &&
- (weak_responses->cols == 1 || weak_responses->rows == 1) &&
- weak_responses->cols + weak_responses->rows - 1 == weak_count) )
- weak_responses->create(weak_count, 1, CV_32FC1);
- pwr = &(wr = *weak_responses);
- }*/
- return predict(&sample, _missing.empty() ? 0 : &mmask, 0,
- slice == Range::all() ? CV_WHOLE_SEQ : cvSlice(slice.start, slice.end),
- raw_mode, return_sum);
-}
+}}
/* End of file. */
+++ /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*/
-
-#include "precomp.hpp"
-
-#if 0
-/****************************************************************************************\
-* Auxilary functions declarations *
-\****************************************************************************************/
-/*---------------------- functions for the CNN classifier ------------------------------*/
-static float icvCNNModelPredict(
- const CvStatModel* cnn_model,
- const CvMat* image,
- CvMat* probs CV_DEFAULT(0) );
-
-static void icvCNNModelUpdate(
- CvStatModel* cnn_model, const CvMat* images, 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));
-
-static void icvCNNModelRelease( CvStatModel** cnn_model );
-
-static void icvTrainCNNetwork( CvCNNetwork* network,
- const float** images,
- const CvMat* responses,
- const CvMat* etalons,
- int grad_estim_type,
- int max_iter,
- int start_iter );
-
-/*------------------------- functions for the CNN network ------------------------------*/
-static void icvCNNetworkAddLayer( CvCNNetwork* network, CvCNNLayer* layer );
-static void icvCNNetworkRelease( CvCNNetwork** network );
-
-/* In all layer functions we denote input by X and output by Y, where
- X and Y are column-vectors, so that
- length(X)==<n_input_planes>*<input_height>*<input_width>,
- length(Y)==<n_output_planes>*<output_height>*<output_width>.
-*/
-/*------------------------ functions for convolutional layer ---------------------------*/
-static void icvCNNConvolutionRelease( CvCNNLayer** p_layer );
-
-static void icvCNNConvolutionForward( CvCNNLayer* layer, const CvMat* X, CvMat* Y );
-
-static void icvCNNConvolutionBackward( CvCNNLayer* layer, int t,
- const CvMat* X, const CvMat* dE_dY, CvMat* dE_dX );
-
-/*------------------------ functions for sub-sampling layer ----------------------------*/
-static void icvCNNSubSamplingRelease( CvCNNLayer** p_layer );
-
-static void icvCNNSubSamplingForward( CvCNNLayer* layer, const CvMat* X, CvMat* Y );
-
-static void icvCNNSubSamplingBackward( CvCNNLayer* layer, int t,
- const CvMat* X, const CvMat* dE_dY, CvMat* dE_dX );
-
-/*------------------------ functions for full connected layer --------------------------*/
-static void icvCNNFullConnectRelease( CvCNNLayer** p_layer );
-
-static void icvCNNFullConnectForward( CvCNNLayer* layer, const CvMat* X, CvMat* Y );
-
-static void icvCNNFullConnectBackward( CvCNNLayer* layer, int,
- const CvMat*, const CvMat* dE_dY, CvMat* dE_dX );
-
-/****************************************************************************************\
-* Functions implementations *
-\****************************************************************************************/
-
-#define ICV_CHECK_CNN_NETWORK(network) \
-{ \
- CvCNNLayer* first_layer, *layer, *last_layer; \
- int n_layers, i; \
- if( !network ) \
- CV_ERROR( CV_StsNullPtr, \
- "Null <network> pointer. Network must be created by user." ); \
- n_layers = network->n_layers; \
- first_layer = last_layer = network->layers; \
- for( i = 0, layer = first_layer; i < n_layers && layer; i++ ) \
- { \
- if( !ICV_IS_CNN_LAYER(layer) ) \
- CV_ERROR( CV_StsNullPtr, "Invalid network" ); \
- last_layer = layer; \
- layer = layer->next_layer; \
- } \
- \
- if( i == 0 || i != n_layers || first_layer->prev_layer || layer ) \
- CV_ERROR( CV_StsNullPtr, "Invalid network" ); \
- \
- if( first_layer->n_input_planes != 1 ) \
- CV_ERROR( CV_StsBadArg, "First layer must contain only one input plane" ); \
- \
- if( img_size != first_layer->input_height*first_layer->input_width ) \
- CV_ERROR( CV_StsBadArg, "Invalid input sizes of the first layer" ); \
- \
- if( params->etalons->cols != last_layer->n_output_planes* \
- last_layer->output_height*last_layer->output_width ) \
- CV_ERROR( CV_StsBadArg, "Invalid output sizes of the last layer" ); \
-}
-
-#define ICV_CHECK_CNN_MODEL_PARAMS(params) \
-{ \
- if( !params ) \
- CV_ERROR( CV_StsNullPtr, "Null <params> pointer" ); \
- \
- if( !ICV_IS_MAT_OF_TYPE(params->etalons, CV_32FC1) ) \
- CV_ERROR( CV_StsBadArg, "<etalons> must be CV_32FC1 type" ); \
- if( params->etalons->rows != cnn_model->cls_labels->cols ) \
- CV_ERROR( CV_StsBadArg, "Invalid <etalons> size" ); \
- \
- if( params->grad_estim_type != CV_CNN_GRAD_ESTIM_RANDOM && \
- params->grad_estim_type != CV_CNN_GRAD_ESTIM_BY_WORST_IMG ) \
- CV_ERROR( CV_StsBadArg, "Invalid <grad_estim_type>" ); \
- \
- if( params->start_iter < 0 ) \
- CV_ERROR( CV_StsBadArg, "Parameter <start_iter> must be positive or zero" ); \
- \
- if( params->max_iter < 1 ) \
- params->max_iter = 1; \
-}
-
-/****************************************************************************************\
-* Classifier functions *
-\****************************************************************************************/
-ML_IMPL CvStatModel*
-cvTrainCNNClassifier( const CvMat* _train_data, int tflag,
- const CvMat* _responses,
- const CvStatModelParams* _params,
- const CvMat*, const CvMat* _sample_idx, const CvMat*, const CvMat* )
-{
- CvCNNStatModel* cnn_model = 0;
- const float** out_train_data = 0;
- CvMat* responses = 0;
-
- CV_FUNCNAME("cvTrainCNNClassifier");
- __BEGIN__;
-
- int n_images;
- int img_size;
- CvCNNStatModelParams* params = (CvCNNStatModelParams*)_params;
-
- CV_CALL(cnn_model = (CvCNNStatModel*)cvCreateStatModel(
- CV_STAT_MODEL_MAGIC_VAL|CV_CNN_MAGIC_VAL, sizeof(CvCNNStatModel),
- icvCNNModelRelease, icvCNNModelPredict, icvCNNModelUpdate ));
-
- CV_CALL(cvPrepareTrainData( "cvTrainCNNClassifier",
- _train_data, tflag, _responses, CV_VAR_CATEGORICAL,
- 0, _sample_idx, false, &out_train_data,
- &n_images, &img_size, &img_size, &responses,
- &cnn_model->cls_labels, 0 ));
-
- ICV_CHECK_CNN_MODEL_PARAMS(params);
- ICV_CHECK_CNN_NETWORK(params->network);
-
- cnn_model->network = params->network;
- CV_CALL(cnn_model->etalons = (CvMat*)cvClone( params->etalons ));
-
- CV_CALL( icvTrainCNNetwork( cnn_model->network, out_train_data, responses,
- cnn_model->etalons, params->grad_estim_type, params->max_iter,
- params->start_iter ));
-
- __END__;
-
- if( cvGetErrStatus() < 0 && cnn_model )
- {
- cnn_model->release( (CvStatModel**)&cnn_model );
- }
- cvFree( &out_train_data );
- cvReleaseMat( &responses );
-
- return (CvStatModel*)cnn_model;
-}
-
-/****************************************************************************************/
-static void icvTrainCNNetwork( CvCNNetwork* network,
- const float** images,
- const CvMat* responses,
- const CvMat* etalons,
- int grad_estim_type,
- int max_iter,
- int start_iter )
-{
- CvMat** X = 0;
- CvMat** dE_dX = 0;
- const int n_layers = network->n_layers;
- int k;
-
- CV_FUNCNAME("icvTrainCNNetwork");
- __BEGIN__;
-
- CvCNNLayer* first_layer = network->layers;
- const int img_height = first_layer->input_height;
- const int img_width = first_layer->input_width;
- const int img_size = img_width*img_height;
- const int n_images = responses->cols;
- CvMat image = cvMat( 1, img_size, CV_32FC1 );
- CvCNNLayer* layer;
- int n;
- CvRNG rng = cvRNG(-1);
-
- CV_CALL(X = (CvMat**)cvAlloc( (n_layers+1)*sizeof(CvMat*) ));
- CV_CALL(dE_dX = (CvMat**)cvAlloc( (n_layers+1)*sizeof(CvMat*) ));
- memset( X, 0, (n_layers+1)*sizeof(CvMat*) );
- memset( dE_dX, 0, (n_layers+1)*sizeof(CvMat*) );
-
- CV_CALL(X[0] = cvCreateMat( img_height*img_width,1,CV_32FC1 ));
- CV_CALL(dE_dX[0] = cvCreateMat( 1, X[0]->rows, CV_32FC1 ));
- for( k = 0, layer = first_layer; k < n_layers; k++, layer = layer->next_layer )
- {
- CV_CALL(X[k+1] = cvCreateMat( layer->n_output_planes*layer->output_height*
- layer->output_width, 1, CV_32FC1 ));
- CV_CALL(dE_dX[k+1] = cvCreateMat( 1, X[k+1]->rows, CV_32FC1 ));
- }
-
- for( n = 1; n <= max_iter; n++ )
- {
- float loss, max_loss = 0;
- int i;
- int worst_img_idx = -1;
- int* right_etal_idx = responses->data.i;
- CvMat etalon;
-
- // Find the worst image (which produces the greatest loss) or use the random image
- if( grad_estim_type == CV_CNN_GRAD_ESTIM_BY_WORST_IMG )
- {
- for( i = 0; i < n_images; i++, right_etal_idx++ )
- {
- image.data.fl = (float*)images[i];
- cvTranspose( &image, X[0] );
-
- for( k = 0, layer = first_layer; k < n_layers; k++, layer = layer->next_layer )
- CV_CALL(layer->forward( layer, X[k], X[k+1] ));
-
- cvTranspose( X[n_layers], dE_dX[n_layers] );
- cvGetRow( etalons, &etalon, *right_etal_idx );
- loss = (float)cvNorm( dE_dX[n_layers], &etalon );
- if( loss > max_loss )
- {
- max_loss = loss;
- worst_img_idx = i;
- }
- }
- }
- else
- worst_img_idx = cvRandInt(&rng) % n_images;
-
- // Train network on the worst image
- // 1) Compute the network output on the <image>
- image.data.fl = (float*)images[worst_img_idx];
- CV_CALL(cvTranspose( &image, X[0] ));
-
- for( k = 0, layer = first_layer; k < n_layers - 1; k++, layer = layer->next_layer )
- CV_CALL(layer->forward( layer, X[k], X[k+1] ));
- CV_CALL(layer->forward( layer, X[k], X[k+1] ));
-
- // 2) Compute the gradient
- cvTranspose( X[n_layers], dE_dX[n_layers] );
- cvGetRow( etalons, &etalon, responses->data.i[worst_img_idx] );
- cvSub( dE_dX[n_layers], &etalon, dE_dX[n_layers] );
-
- // 3) Update weights by the gradient descent
- for( k = n_layers; k > 0; k--, layer = layer->prev_layer )
- CV_CALL(layer->backward( layer, n + start_iter, X[k-1], dE_dX[k], dE_dX[k-1] ));
- }
-
- __END__;
-
- for( k = 0; k <= n_layers; k++ )
- {
- cvReleaseMat( &X[k] );
- cvReleaseMat( &dE_dX[k] );
- }
- cvFree( &X );
- cvFree( &dE_dX );
-}
-
-/****************************************************************************************/
-static float icvCNNModelPredict( const CvStatModel* model,
- const CvMat* _image,
- CvMat* probs )
-{
- CvMat** X = 0;
- float* img_data = 0;
- int n_layers = 0;
- int best_etal_idx = -1;
- int k;
-
- CV_FUNCNAME("icvCNNModelPredict");
- __BEGIN__;
-
- CvCNNStatModel* cnn_model = (CvCNNStatModel*)model;
- CvCNNLayer* first_layer, *layer = 0;
- int img_height, img_width, img_size;
- int nclasses, i;
- float loss, min_loss = FLT_MAX;
- float* probs_data;
- CvMat etalon, image;
-
- if( !CV_IS_CNN(model) )
- CV_ERROR( CV_StsBadArg, "Invalid model" );
-
- nclasses = cnn_model->cls_labels->cols;
- n_layers = cnn_model->network->n_layers;
- first_layer = cnn_model->network->layers;
- img_height = first_layer->input_height;
- img_width = first_layer->input_width;
- img_size = img_height*img_width;
-
- cvPreparePredictData( _image, img_size, 0, nclasses, probs, &img_data );
-
- CV_CALL(X = (CvMat**)cvAlloc( (n_layers+1)*sizeof(CvMat*) ));
- memset( X, 0, (n_layers+1)*sizeof(CvMat*) );
-
- CV_CALL(X[0] = cvCreateMat( img_size,1,CV_32FC1 ));
- for( k = 0, layer = first_layer; k < n_layers; k++, layer = layer->next_layer )
- {
- CV_CALL(X[k+1] = cvCreateMat( layer->n_output_planes*layer->output_height*
- layer->output_width, 1, CV_32FC1 ));
- }
-
- image = cvMat( 1, img_size, CV_32FC1, img_data );
- cvTranspose( &image, X[0] );
- for( k = 0, layer = first_layer; k < n_layers; k++, layer = layer->next_layer )
- CV_CALL(layer->forward( layer, X[k], X[k+1] ));
-
- probs_data = probs ? probs->data.fl : 0;
- etalon = cvMat( cnn_model->etalons->cols, 1, CV_32FC1, cnn_model->etalons->data.fl );
- for( i = 0; i < nclasses; i++, etalon.data.fl += cnn_model->etalons->cols )
- {
- loss = (float)cvNorm( X[n_layers], &etalon );
- if( loss < min_loss )
- {
- min_loss = loss;
- best_etal_idx = i;
- }
- if( probs )
- *probs_data++ = -loss;
- }
-
- if( probs )
- {
- cvExp( probs, probs );
- CvScalar sum = cvSum( probs );
- cvConvertScale( probs, probs, 1./sum.val[0] );
- }
-
- __END__;
-
- for( k = 0; k <= n_layers; k++ )
- cvReleaseMat( &X[k] );
- cvFree( &X );
- if( img_data != _image->data.fl )
- cvFree( &img_data );
-
- return ((float) ((CvCNNStatModel*)model)->cls_labels->data.i[best_etal_idx]);
-}
-
-/****************************************************************************************/
-static void icvCNNModelUpdate(
- CvStatModel* _cnn_model, const CvMat* _train_data, int tflag,
- const CvMat* _responses, const CvStatModelParams* _params,
- const CvMat*, const CvMat* _sample_idx,
- const CvMat*, const CvMat* )
-{
- const float** out_train_data = 0;
- CvMat* responses = 0;
- CvMat* cls_labels = 0;
-
- CV_FUNCNAME("icvCNNModelUpdate");
- __BEGIN__;
-
- int n_images, img_size, i;
- CvCNNStatModelParams* params = (CvCNNStatModelParams*)_params;
- CvCNNStatModel* cnn_model = (CvCNNStatModel*)_cnn_model;
-
- if( !CV_IS_CNN(cnn_model) )
- CV_ERROR( CV_StsBadArg, "Invalid model" );
-
- CV_CALL(cvPrepareTrainData( "cvTrainCNNClassifier",
- _train_data, tflag, _responses, CV_VAR_CATEGORICAL,
- 0, _sample_idx, false, &out_train_data,
- &n_images, &img_size, &img_size, &responses,
- &cls_labels, 0, 0 ));
-
- ICV_CHECK_CNN_MODEL_PARAMS(params);
-
- // Number of classes must be the same as when classifiers was created
- if( !CV_ARE_SIZES_EQ(cls_labels, cnn_model->cls_labels) )
- CV_ERROR( CV_StsBadArg, "Number of classes must be left unchanged" );
- for( i = 0; i < cls_labels->cols; i++ )
- {
- if( cls_labels->data.i[i] != cnn_model->cls_labels->data.i[i] )
- CV_ERROR( CV_StsBadArg, "Number of classes must be left unchanged" );
- }
-
- CV_CALL( icvTrainCNNetwork( cnn_model->network, out_train_data, responses,
- cnn_model->etalons, params->grad_estim_type, params->max_iter,
- params->start_iter ));
-
- __END__;
-
- cvFree( &out_train_data );
- cvReleaseMat( &responses );
-}
-
-/****************************************************************************************/
-static void icvCNNModelRelease( CvStatModel** cnn_model )
-{
- CV_FUNCNAME("icvCNNModelRelease");
- __BEGIN__;
-
- CvCNNStatModel* cnn;
- if( !cnn_model )
- CV_ERROR( CV_StsNullPtr, "Null double pointer" );
-
- cnn = *(CvCNNStatModel**)cnn_model;
-
- cvReleaseMat( &cnn->cls_labels );
- cvReleaseMat( &cnn->etalons );
- cnn->network->release( &cnn->network );
-
- cvFree( &cnn );
-
- __END__;
-
-}
-
-/****************************************************************************************\
-* Network functions *
-\****************************************************************************************/
-ML_IMPL CvCNNetwork* cvCreateCNNetwork( CvCNNLayer* first_layer )
-{
- CvCNNetwork* network = 0;
-
- CV_FUNCNAME( "cvCreateCNNetwork" );
- __BEGIN__;
-
- if( !ICV_IS_CNN_LAYER(first_layer) )
- CV_ERROR( CV_StsBadArg, "Invalid layer" );
-
- CV_CALL(network = (CvCNNetwork*)cvAlloc( sizeof(CvCNNetwork) ));
- memset( network, 0, sizeof(CvCNNetwork) );
-
- network->layers = first_layer;
- network->n_layers = 1;
- network->release = icvCNNetworkRelease;
- network->add_layer = icvCNNetworkAddLayer;
-
- __END__;
-
- if( cvGetErrStatus() < 0 && network )
- cvFree( &network );
-
- return network;
-
-}
-
-/****************************************************************************************/
-static void icvCNNetworkAddLayer( CvCNNetwork* network, CvCNNLayer* layer )
-{
- CV_FUNCNAME( "icvCNNetworkAddLayer" );
- __BEGIN__;
-
- CvCNNLayer* prev_layer;
-
- if( network == NULL )
- CV_ERROR( CV_StsNullPtr, "Null <network> pointer" );
-
- prev_layer = network->layers;
- while( prev_layer->next_layer )
- prev_layer = prev_layer->next_layer;
-
- if( ICV_IS_CNN_FULLCONNECT_LAYER(layer) )
- {
- if( layer->n_input_planes != prev_layer->output_width*prev_layer->output_height*
- prev_layer->n_output_planes )
- CV_ERROR( CV_StsBadArg, "Unmatched size of the new layer" );
- if( layer->input_height != 1 || layer->output_height != 1 ||
- layer->input_width != 1 || layer->output_width != 1 )
- CV_ERROR( CV_StsBadArg, "Invalid size of the new layer" );
- }
- else if( ICV_IS_CNN_CONVOLUTION_LAYER(layer) || ICV_IS_CNN_SUBSAMPLING_LAYER(layer) )
- {
- if( prev_layer->n_output_planes != layer->n_input_planes ||
- prev_layer->output_height != layer->input_height ||
- prev_layer->output_width != layer->input_width )
- CV_ERROR( CV_StsBadArg, "Unmatched size of the new layer" );
- }
- else
- CV_ERROR( CV_StsBadArg, "Invalid layer" );
-
- layer->prev_layer = prev_layer;
- prev_layer->next_layer = layer;
- network->n_layers++;
-
- __END__;
-}
-
-/****************************************************************************************/
-static void icvCNNetworkRelease( CvCNNetwork** network_pptr )
-{
- CV_FUNCNAME( "icvReleaseCNNetwork" );
- __BEGIN__;
-
- CvCNNetwork* network = 0;
- CvCNNLayer* layer = 0, *next_layer = 0;
- int k;
-
- if( network_pptr == NULL )
- CV_ERROR( CV_StsBadArg, "Null double pointer" );
- if( *network_pptr == NULL )
- return;
-
- network = *network_pptr;
- layer = network->layers;
- if( layer == NULL )
- CV_ERROR( CV_StsBadArg, "CNN is empty (does not contain any layer)" );
-
- // k is the number of the layer to be deleted
- for( k = 0; k < network->n_layers && layer; k++ )
- {
- next_layer = layer->next_layer;
- layer->release( &layer );
- layer = next_layer;
- }
-
- if( k != network->n_layers || layer)
- CV_ERROR( CV_StsBadArg, "Invalid network" );
-
- cvFree( &network );
-
- __END__;
-}
-
-/****************************************************************************************\
-* Layer functions *
-\****************************************************************************************/
-static CvCNNLayer* icvCreateCNNLayer( int layer_type, int header_size,
- int n_input_planes, int input_height, int input_width,
- int n_output_planes, int output_height, int output_width,
- float init_learn_rate, int learn_rate_decrease_type,
- CvCNNLayerRelease release, CvCNNLayerForward forward, CvCNNLayerBackward backward )
-{
- CvCNNLayer* layer = 0;
-
- CV_FUNCNAME("icvCreateCNNLayer");
- __BEGIN__;
-
- CV_ASSERT( release && forward && backward )
- CV_ASSERT( header_size >= sizeof(CvCNNLayer) )
-
- if( n_input_planes < 1 || n_output_planes < 1 ||
- input_height < 1 || input_width < 1 ||
- output_height < 1 || output_width < 1 ||
- input_height < output_height ||
- input_width < output_width )
- CV_ERROR( CV_StsBadArg, "Incorrect input or output parameters" );
- if( init_learn_rate < FLT_EPSILON )
- CV_ERROR( CV_StsBadArg, "Initial learning rate must be positive" );
- if( learn_rate_decrease_type != CV_CNN_LEARN_RATE_DECREASE_HYPERBOLICALLY &&
- learn_rate_decrease_type != CV_CNN_LEARN_RATE_DECREASE_SQRT_INV &&
- learn_rate_decrease_type != CV_CNN_LEARN_RATE_DECREASE_LOG_INV )
- CV_ERROR( CV_StsBadArg, "Invalid type of learning rate dynamics" );
-
- CV_CALL(layer = (CvCNNLayer*)cvAlloc( header_size ));
- memset( layer, 0, header_size );
-
- layer->flags = ICV_CNN_LAYER|layer_type;
- CV_ASSERT( ICV_IS_CNN_LAYER(layer) )
-
- layer->n_input_planes = n_input_planes;
- layer->input_height = input_height;
- layer->input_width = input_width;
-
- layer->n_output_planes = n_output_planes;
- layer->output_height = output_height;
- layer->output_width = output_width;
-
- layer->init_learn_rate = init_learn_rate;
- layer->learn_rate_decrease_type = learn_rate_decrease_type;
-
- layer->release = release;
- layer->forward = forward;
- layer->backward = backward;
-
- __END__;
-
- if( cvGetErrStatus() < 0 && layer)
- cvFree( &layer );
-
- return layer;
-}
-
-/****************************************************************************************/
-ML_IMPL 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, CvMat* weights )
-
-{
- CvCNNConvolutionLayer* layer = 0;
-
- CV_FUNCNAME("cvCreateCNNConvolutionLayer");
- __BEGIN__;
-
- const int output_height = input_height - K + 1;
- const int output_width = input_width - K + 1;
-
- if( K < 1 || init_learn_rate <= 0 )
- CV_ERROR( CV_StsBadArg, "Incorrect parameters" );
-
- CV_CALL(layer = (CvCNNConvolutionLayer*)icvCreateCNNLayer( ICV_CNN_CONVOLUTION_LAYER,
- sizeof(CvCNNConvolutionLayer), n_input_planes, input_height, input_width,
- n_output_planes, output_height, output_width,
- init_learn_rate, learn_rate_decrease_type,
- icvCNNConvolutionRelease, icvCNNConvolutionForward, icvCNNConvolutionBackward ));
-
- layer->K = K;
- CV_CALL(layer->weights = cvCreateMat( n_output_planes, K*K+1, CV_32FC1 ));
- CV_CALL(layer->connect_mask = cvCreateMat( n_output_planes, n_input_planes, CV_8UC1));
-
- if( weights )
- {
- if( !ICV_IS_MAT_OF_TYPE( weights, CV_32FC1 ) )
- CV_ERROR( CV_StsBadSize, "Type of initial weights matrix must be CV_32FC1" );
- if( !CV_ARE_SIZES_EQ( weights, layer->weights ) )
- CV_ERROR( CV_StsBadSize, "Invalid size of initial weights matrix" );
- CV_CALL(cvCopy( weights, layer->weights ));
- }
- else
- {
- CvRNG rng = cvRNG( 0xFFFFFFFF );
- cvRandArr( &rng, layer->weights, CV_RAND_UNI, cvRealScalar(-1), cvRealScalar(1) );
- }
-
- if( connect_mask )
- {
- if( !ICV_IS_MAT_OF_TYPE( connect_mask, CV_8UC1 ) )
- CV_ERROR( CV_StsBadSize, "Type of connection matrix must be CV_32FC1" );
- if( !CV_ARE_SIZES_EQ( connect_mask, layer->connect_mask ) )
- CV_ERROR( CV_StsBadSize, "Invalid size of connection matrix" );
- CV_CALL(cvCopy( connect_mask, layer->connect_mask ));
- }
- else
- CV_CALL(cvSet( layer->connect_mask, cvRealScalar(1) ));
-
- __END__;
-
- if( cvGetErrStatus() < 0 && layer )
- {
- cvReleaseMat( &layer->weights );
- cvReleaseMat( &layer->connect_mask );
- cvFree( &layer );
- }
-
- return (CvCNNLayer*)layer;
-}
-
-/****************************************************************************************/
-ML_IMPL 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 )
-
-{
- CvCNNSubSamplingLayer* layer = 0;
-
- CV_FUNCNAME("cvCreateCNNSubSamplingLayer");
- __BEGIN__;
-
- const int output_height = input_height/sub_samp_scale;
- const int output_width = input_width/sub_samp_scale;
- const int n_output_planes = n_input_planes;
-
- if( sub_samp_scale < 1 || a <= 0 || s <= 0)
- CV_ERROR( CV_StsBadArg, "Incorrect parameters" );
-
- CV_CALL(layer = (CvCNNSubSamplingLayer*)icvCreateCNNLayer( ICV_CNN_SUBSAMPLING_LAYER,
- sizeof(CvCNNSubSamplingLayer), n_input_planes, input_height, input_width,
- n_output_planes, output_height, output_width,
- init_learn_rate, learn_rate_decrease_type,
- icvCNNSubSamplingRelease, icvCNNSubSamplingForward, icvCNNSubSamplingBackward ));
-
- layer->sub_samp_scale = sub_samp_scale;
- layer->a = a;
- layer->s = s;
-
- CV_CALL(layer->sumX =
- cvCreateMat( n_output_planes*output_width*output_height, 1, CV_32FC1 ));
- CV_CALL(layer->exp2ssumWX =
- cvCreateMat( n_output_planes*output_width*output_height, 1, CV_32FC1 ));
-
- cvZero( layer->sumX );
- cvZero( layer->exp2ssumWX );
-
- CV_CALL(layer->weights = cvCreateMat( n_output_planes, 2, CV_32FC1 ));
- if( weights )
- {
- if( !ICV_IS_MAT_OF_TYPE( weights, CV_32FC1 ) )
- CV_ERROR( CV_StsBadSize, "Type of initial weights matrix must be CV_32FC1" );
- if( !CV_ARE_SIZES_EQ( weights, layer->weights ) )
- CV_ERROR( CV_StsBadSize, "Invalid size of initial weights matrix" );
- CV_CALL(cvCopy( weights, layer->weights ));
- }
- else
- {
- CvRNG rng = cvRNG( 0xFFFFFFFF );
- cvRandArr( &rng, layer->weights, CV_RAND_UNI, cvRealScalar(-1), cvRealScalar(1) );
- }
-
- __END__;
-
- if( cvGetErrStatus() < 0 && layer )
- {
- cvReleaseMat( &layer->exp2ssumWX );
- cvFree( &layer );
- }
-
- return (CvCNNLayer*)layer;
-}
-
-/****************************************************************************************/
-ML_IMPL CvCNNLayer* cvCreateCNNFullConnectLayer(
- int n_inputs, int n_outputs, float a, float s,
- float init_learn_rate, int learn_rate_decrease_type, CvMat* weights )
-{
- CvCNNFullConnectLayer* layer = 0;
-
- CV_FUNCNAME("cvCreateCNNFullConnectLayer");
- __BEGIN__;
-
- if( a <= 0 || s <= 0 || init_learn_rate <= 0)
- CV_ERROR( CV_StsBadArg, "Incorrect parameters" );
-
- CV_CALL(layer = (CvCNNFullConnectLayer*)icvCreateCNNLayer( ICV_CNN_FULLCONNECT_LAYER,
- sizeof(CvCNNFullConnectLayer), n_inputs, 1, 1, n_outputs, 1, 1,
- init_learn_rate, learn_rate_decrease_type,
- icvCNNFullConnectRelease, icvCNNFullConnectForward, icvCNNFullConnectBackward ));
-
- layer->a = a;
- layer->s = s;
-
- CV_CALL(layer->exp2ssumWX = cvCreateMat( n_outputs, 1, CV_32FC1 ));
- cvZero( layer->exp2ssumWX );
-
- CV_CALL(layer->weights = cvCreateMat( n_outputs, n_inputs+1, CV_32FC1 ));
- if( weights )
- {
- if( !ICV_IS_MAT_OF_TYPE( weights, CV_32FC1 ) )
- CV_ERROR( CV_StsBadSize, "Type of initial weights matrix must be CV_32FC1" );
- if( !CV_ARE_SIZES_EQ( weights, layer->weights ) )
- CV_ERROR( CV_StsBadSize, "Invalid size of initial weights matrix" );
- CV_CALL(cvCopy( weights, layer->weights ));
- }
- else
- {
- CvRNG rng = cvRNG( 0xFFFFFFFF );
- cvRandArr( &rng, layer->weights, CV_RAND_UNI, cvRealScalar(-1), cvRealScalar(1) );
- }
-
- __END__;
-
- if( cvGetErrStatus() < 0 && layer )
- {
- cvReleaseMat( &layer->exp2ssumWX );
- cvReleaseMat( &layer->weights );
- cvFree( &layer );
- }
-
- return (CvCNNLayer*)layer;
-}
-
-
-/****************************************************************************************\
-* Layer FORWARD functions *
-\****************************************************************************************/
-static void icvCNNConvolutionForward( CvCNNLayer* _layer,
- const CvMat* X,
- CvMat* Y )
-{
- CV_FUNCNAME("icvCNNConvolutionForward");
-
- if( !ICV_IS_CNN_CONVOLUTION_LAYER(_layer) )
- CV_ERROR( CV_StsBadArg, "Invalid layer" );
-
- {__BEGIN__;
-
- const CvCNNConvolutionLayer* layer = (CvCNNConvolutionLayer*) _layer;
-
- const int K = layer->K;
- const int n_weights_for_Yplane = K*K + 1;
-
- const int nXplanes = layer->n_input_planes;
- const int Xheight = layer->input_height;
- const int Xwidth = layer->input_width ;
- const int Xsize = Xwidth*Xheight;
-
- const int nYplanes = layer->n_output_planes;
- const int Yheight = layer->output_height;
- const int Ywidth = layer->output_width;
- const int Ysize = Ywidth*Yheight;
-
- int xx, yy, ni, no, kx, ky;
- float *Yplane = 0, *Xplane = 0, *w = 0;
- uchar* connect_mask_data = 0;
-
- CV_ASSERT( X->rows == nXplanes*Xsize && X->cols == 1 );
- CV_ASSERT( Y->rows == nYplanes*Ysize && Y->cols == 1 );
-
- cvSetZero( Y );
-
- Yplane = Y->data.fl;
- connect_mask_data = layer->connect_mask->data.ptr;
- w = layer->weights->data.fl;
- for( no = 0; no < nYplanes; no++, Yplane += Ysize, w += n_weights_for_Yplane )
- {
- Xplane = X->data.fl;
- for( ni = 0; ni < nXplanes; ni++, Xplane += Xsize, connect_mask_data++ )
- {
- if( *connect_mask_data )
- {
- float* Yelem = Yplane;
-
- // Xheight-K+1 == Yheight && Xwidth-K+1 == Ywidth
- for( yy = 0; yy < Xheight-K+1; yy++ )
- {
- for( xx = 0; xx < Xwidth-K+1; xx++, Yelem++ )
- {
- float* templ = Xplane+yy*Xwidth+xx;
- float WX = 0;
- for( ky = 0; ky < K; ky++, templ += Xwidth-K )
- {
- for( kx = 0; kx < K; kx++, templ++ )
- {
- WX += *templ*w[ky*K+kx];
- }
- }
- *Yelem += WX + w[K*K];
- }
- }
- }
- }
- }
- }__END__;
-}
-
-/****************************************************************************************/
-static void icvCNNSubSamplingForward( CvCNNLayer* _layer,
- const CvMat* X,
- CvMat* Y )
-{
- CV_FUNCNAME("icvCNNSubSamplingForward");
-
- if( !ICV_IS_CNN_SUBSAMPLING_LAYER(_layer) )
- CV_ERROR( CV_StsBadArg, "Invalid layer" );
-
- {__BEGIN__;
-
- const CvCNNSubSamplingLayer* layer = (CvCNNSubSamplingLayer*) _layer;
-
- const int sub_sampl_scale = layer->sub_samp_scale;
- const int nplanes = layer->n_input_planes;
-
- const int Xheight = layer->input_height;
- const int Xwidth = layer->input_width ;
- const int Xsize = Xwidth*Xheight;
-
- const int Yheight = layer->output_height;
- const int Ywidth = layer->output_width;
- const int Ysize = Ywidth*Yheight;
-
- int xx, yy, ni, kx, ky;
- float* sumX_data = 0, *w = 0;
- CvMat sumX_sub_col, exp2ssumWX_sub_col;
-
- CV_ASSERT(X->rows == nplanes*Xsize && X->cols == 1);
- CV_ASSERT(layer->exp2ssumWX->cols == 1 && layer->exp2ssumWX->rows == nplanes*Ysize);
-
- // update inner variable layer->exp2ssumWX, which will be used in back-progation
- cvZero( layer->sumX );
- cvZero( layer->exp2ssumWX );
-
- for( ky = 0; ky < sub_sampl_scale; ky++ )
- for( kx = 0; kx < sub_sampl_scale; kx++ )
- {
- float* Xplane = X->data.fl;
- sumX_data = layer->sumX->data.fl;
- for( ni = 0; ni < nplanes; ni++, Xplane += Xsize )
- {
- for( yy = 0; yy < Yheight; yy++ )
- for( xx = 0; xx < Ywidth; xx++, sumX_data++ )
- *sumX_data += Xplane[((yy+ky)*Xwidth+(xx+kx))];
- }
- }
-
- w = layer->weights->data.fl;
- cvGetRows( layer->sumX, &sumX_sub_col, 0, Ysize );
- cvGetRows( layer->exp2ssumWX, &exp2ssumWX_sub_col, 0, Ysize );
- for( ni = 0; ni < nplanes; ni++, w += 2 )
- {
- CV_CALL(cvConvertScale( &sumX_sub_col, &exp2ssumWX_sub_col, w[0], w[1] ));
- sumX_sub_col.data.fl += Ysize;
- exp2ssumWX_sub_col.data.fl += Ysize;
- }
-
- CV_CALL(cvScale( layer->exp2ssumWX, layer->exp2ssumWX, 2.0*layer->s ));
- CV_CALL(cvExp( layer->exp2ssumWX, layer->exp2ssumWX ));
- CV_CALL(cvMinS( layer->exp2ssumWX, FLT_MAX, layer->exp2ssumWX ));
-//#ifdef _DEBUG
- {
- float* exp2ssumWX_data = layer->exp2ssumWX->data.fl;
- for( ni = 0; ni < layer->exp2ssumWX->rows; ni++, exp2ssumWX_data++ )
- {
- if( *exp2ssumWX_data == FLT_MAX )
- cvSetErrStatus( 1 );
- }
- }
-//#endif
- // compute the output variable Y == ( a - 2a/(layer->exp2ssumWX + 1))
- CV_CALL(cvAddS( layer->exp2ssumWX, cvRealScalar(1), Y ));
- CV_CALL(cvDiv( 0, Y, Y, -2.0*layer->a ));
- CV_CALL(cvAddS( Y, cvRealScalar(layer->a), Y ));
-
- }__END__;
-}
-
-/****************************************************************************************/
-static void icvCNNFullConnectForward( CvCNNLayer* _layer, const CvMat* X, CvMat* Y )
-{
- CV_FUNCNAME("icvCNNFullConnectForward");
-
- if( !ICV_IS_CNN_FULLCONNECT_LAYER(_layer) )
- CV_ERROR( CV_StsBadArg, "Invalid layer" );
-
- {__BEGIN__;
-
- const CvCNNFullConnectLayer* layer = (CvCNNFullConnectLayer*)_layer;
- CvMat* weights = layer->weights;
- CvMat sub_weights, bias;
-
- CV_ASSERT(X->cols == 1 && X->rows == layer->n_input_planes);
- CV_ASSERT(Y->cols == 1 && Y->rows == layer->n_output_planes);
-
- CV_CALL(cvGetSubRect( weights, &sub_weights,
- cvRect(0, 0, weights->cols-1, weights->rows )));
- CV_CALL(cvGetCol( weights, &bias, weights->cols-1));
-
- // update inner variable layer->exp2ssumWX, which will be used in Back-Propagation
- CV_CALL(cvGEMM( &sub_weights, X, 2*layer->s, &bias, 2*layer->s, layer->exp2ssumWX ));
- CV_CALL(cvExp( layer->exp2ssumWX, layer->exp2ssumWX ));
- CV_CALL(cvMinS( layer->exp2ssumWX, FLT_MAX, layer->exp2ssumWX ));
-//#ifdef _DEBUG
- {
- float* exp2ssumWX_data = layer->exp2ssumWX->data.fl;
- int i;
- for( i = 0; i < layer->exp2ssumWX->rows; i++, exp2ssumWX_data++ )
- {
- if( *exp2ssumWX_data == FLT_MAX )
- cvSetErrStatus( 1 );
- }
- }
-//#endif
- // compute the output variable Y == ( a - 2a/(layer->exp2ssumWX + 1))
- CV_CALL(cvAddS( layer->exp2ssumWX, cvRealScalar(1), Y ));
- CV_CALL(cvDiv( 0, Y, Y, -2.0*layer->a ));
- CV_CALL(cvAddS( Y, cvRealScalar(layer->a), Y ));
-
- }__END__;
-}
-
-/****************************************************************************************\
-* Layer BACKWARD functions *
-\****************************************************************************************/
-
-/* <dE_dY>, <dE_dX> should be row-vectors.
- Function computes partial derivatives <dE_dX>
- of the loss function with respect to the planes components
- of the previous layer (X).
- It is a basic function for back propagation method.
- Input parameter <dE_dY> is the partial derivative of the
- loss function with respect to the planes components
- of the current layer. */
-static void icvCNNConvolutionBackward(
- CvCNNLayer* _layer, int t, const CvMat* X, const CvMat* dE_dY, CvMat* dE_dX )
-{
- CvMat* dY_dX = 0;
- CvMat* dY_dW = 0;
- CvMat* dE_dW = 0;
-
- CV_FUNCNAME("icvCNNConvolutionBackward");
-
- if( !ICV_IS_CNN_CONVOLUTION_LAYER(_layer) )
- CV_ERROR( CV_StsBadArg, "Invalid layer" );
-
- {__BEGIN__;
-
- const CvCNNConvolutionLayer* layer = (CvCNNConvolutionLayer*) _layer;
-
- const int K = layer->K;
-
- const int n_X_planes = layer->n_input_planes;
- const int X_plane_height = layer->input_height;
- const int X_plane_width = layer->input_width;
- const int X_plane_size = X_plane_height*X_plane_width;
-
- const int n_Y_planes = layer->n_output_planes;
- const int Y_plane_height = layer->output_height;
- const int Y_plane_width = layer->output_width;
- const int Y_plane_size = Y_plane_height*Y_plane_width;
-
- int no, ni, yy, xx, ky, kx;
- int X_idx = 0, Y_idx = 0;
-
- float *X_plane = 0, *w = 0;
-
- CvMat* weights = layer->weights;
-
- CV_ASSERT( t >= 1 );
- CV_ASSERT( n_Y_planes == weights->rows );
-
- dY_dX = cvCreateMat( n_Y_planes*Y_plane_size, X->rows, CV_32FC1 );
- dY_dW = cvCreateMat( dY_dX->rows, weights->cols*weights->rows, CV_32FC1 );
- dE_dW = cvCreateMat( 1, dY_dW->cols, CV_32FC1 );
-
- cvZero( dY_dX );
- cvZero( dY_dW );
-
- // compute gradient of the loss function with respect to X and W
- for( no = 0; no < n_Y_planes; no++, Y_idx += Y_plane_size )
- {
- w = weights->data.fl + no*(K*K+1);
- X_idx = 0;
- X_plane = X->data.fl;
- for( ni = 0; ni < n_X_planes; ni++, X_plane += X_plane_size )
- {
- if( layer->connect_mask->data.ptr[ni*n_Y_planes+no] )
- {
- for( yy = 0; yy < X_plane_height - K + 1; yy++ )
- {
- for( xx = 0; xx < X_plane_width - K + 1; xx++ )
- {
- for( ky = 0; ky < K; ky++ )
- {
- for( kx = 0; kx < K; kx++ )
- {
- CV_MAT_ELEM(*dY_dX, float, Y_idx+yy*Y_plane_width+xx,
- X_idx+(yy+ky)*X_plane_width+(xx+kx)) = w[ky*K+kx];
-
- // dY_dWi, i=1,...,K*K
- CV_MAT_ELEM(*dY_dW, float, Y_idx+yy*Y_plane_width+xx,
- no*(K*K+1)+ky*K+kx) +=
- X_plane[(yy+ky)*X_plane_width+(xx+kx)];
- }
- }
- // dY_dW(K*K+1)==1 because W(K*K+1) is bias
- CV_MAT_ELEM(*dY_dW, float, Y_idx+yy*Y_plane_width+xx,
- no*(K*K+1)+K*K) += 1;
- }
- }
- }
- X_idx += X_plane_size;
- }
- }
-
- CV_CALL(cvMatMul( dE_dY, dY_dW, dE_dW ));
- CV_CALL(cvMatMul( dE_dY, dY_dX, dE_dX ));
-
- // update weights
- {
- CvMat dE_dW_mat;
- float eta;
- if( layer->learn_rate_decrease_type == CV_CNN_LEARN_RATE_DECREASE_LOG_INV )
- eta = -layer->init_learn_rate/logf(1+(float)t);
- else if( layer->learn_rate_decrease_type == CV_CNN_LEARN_RATE_DECREASE_SQRT_INV )
- eta = -layer->init_learn_rate/sqrtf((float)t);
- else
- eta = -layer->init_learn_rate/(float)t;
- cvReshape( dE_dW, &dE_dW_mat, 0, weights->rows );
- cvScaleAdd( &dE_dW_mat, cvRealScalar(eta), weights, weights );
- }
-
- }__END__;
-
- cvReleaseMat( &dY_dX );
- cvReleaseMat( &dY_dW );
- cvReleaseMat( &dE_dW );
-}
-
-/****************************************************************************************/
-static void icvCNNSubSamplingBackward(
- CvCNNLayer* _layer, int t, const CvMat*, const CvMat* dE_dY, CvMat* dE_dX )
-{
- // derivative of activation function
- CvMat* dY_dX_elems = 0; // elements of matrix dY_dX
- CvMat* dY_dW_elems = 0; // elements of matrix dY_dW
- CvMat* dE_dW = 0;
-
- CV_FUNCNAME("icvCNNSubSamplingBackward");
-
- if( !ICV_IS_CNN_SUBSAMPLING_LAYER(_layer) )
- CV_ERROR( CV_StsBadArg, "Invalid layer" );
-
- {__BEGIN__;
-
- const CvCNNSubSamplingLayer* layer = (CvCNNSubSamplingLayer*) _layer;
-
- const int Xwidth = layer->input_width;
- const int Ywidth = layer->output_width;
- const int Yheight = layer->output_height;
- const int Ysize = Ywidth * Yheight;
- const int scale = layer->sub_samp_scale;
- const int k_max = layer->n_output_planes * Yheight;
-
- int k, i, j, m;
- float* dY_dX_current_elem = 0, *dE_dX_start = 0, *dE_dW_data = 0, *w = 0;
- CvMat dy_dw0, dy_dw1;
- CvMat activ_func_der, sumX_row;
- CvMat dE_dY_sub_row, dY_dX_sub_col, dy_dw0_sub_row, dy_dw1_sub_row;
-
- CV_CALL(dY_dX_elems = cvCreateMat( layer->sumX->rows, 1, CV_32FC1 ));
- CV_CALL(dY_dW_elems = cvCreateMat( 2, layer->sumX->rows, CV_32FC1 ));
- CV_CALL(dE_dW = cvCreateMat( 1, 2*layer->n_output_planes, CV_32FC1 ));
-
- // compute derivative of activ.func.
- // ==<dY_dX_elems> = 4as*(layer->exp2ssumWX)/(layer->exp2ssumWX + 1)^2
- CV_CALL(cvAddS( layer->exp2ssumWX, cvRealScalar(1), dY_dX_elems ));
- CV_CALL(cvPow( dY_dX_elems, dY_dX_elems, -2.0 ));
- CV_CALL(cvMul( dY_dX_elems, layer->exp2ssumWX, dY_dX_elems, 4.0*layer->a*layer->s ));
-
- // compute <dE_dW>
- // a) compute <dY_dW_elems>
- cvReshape( dY_dX_elems, &activ_func_der, 0, 1 );
- cvGetRow( dY_dW_elems, &dy_dw0, 0 );
- cvGetRow( dY_dW_elems, &dy_dw1, 1 );
- CV_CALL(cvCopy( &activ_func_der, &dy_dw0 ));
- CV_CALL(cvCopy( &activ_func_der, &dy_dw1 ));
-
- cvReshape( layer->sumX, &sumX_row, 0, 1 );
- cvMul( &dy_dw0, &sumX_row, &dy_dw0 );
-
- // b) compute <dE_dW> = <dE_dY>*<dY_dW_elems>
- cvGetCols( dE_dY, &dE_dY_sub_row, 0, Ysize );
- cvGetCols( &dy_dw0, &dy_dw0_sub_row, 0, Ysize );
- cvGetCols( &dy_dw1, &dy_dw1_sub_row, 0, Ysize );
- dE_dW_data = dE_dW->data.fl;
- for( i = 0; i < layer->n_output_planes; i++ )
- {
- *dE_dW_data++ = (float)cvDotProduct( &dE_dY_sub_row, &dy_dw0_sub_row );
- *dE_dW_data++ = (float)cvDotProduct( &dE_dY_sub_row, &dy_dw1_sub_row );
-
- dE_dY_sub_row.data.fl += Ysize;
- dy_dw0_sub_row.data.fl += Ysize;
- dy_dw1_sub_row.data.fl += Ysize;
- }
-
- // compute <dY_dX> = layer->weights*<dY_dX>
- w = layer->weights->data.fl;
- cvGetRows( dY_dX_elems, &dY_dX_sub_col, 0, Ysize );
- for( i = 0; i < layer->n_input_planes; i++, w++, dY_dX_sub_col.data.fl += Ysize )
- CV_CALL(cvConvertScale( &dY_dX_sub_col, &dY_dX_sub_col, (float)*w ));
-
- // compute <dE_dX>
- CV_CALL(cvReshape( dY_dX_elems, dY_dX_elems, 0, 1 ));
- CV_CALL(cvMul( dY_dX_elems, dE_dY, dY_dX_elems ));
-
- dY_dX_current_elem = dY_dX_elems->data.fl;
- dE_dX_start = dE_dX->data.fl;
- for( k = 0; k < k_max; k++ )
- {
- for( i = 0; i < Ywidth; i++, dY_dX_current_elem++ )
- {
- float* dE_dX_current_elem = dE_dX_start;
- for( j = 0; j < scale; j++, dE_dX_current_elem += Xwidth - scale )
- {
- for( m = 0; m < scale; m++, dE_dX_current_elem++ )
- *dE_dX_current_elem = *dY_dX_current_elem;
- }
- dE_dX_start += scale;
- }
- dE_dX_start += Xwidth * (scale - 1);
- }
-
- // update weights
- {
- CvMat dE_dW_mat, *weights = layer->weights;
- float eta;
- if( layer->learn_rate_decrease_type == CV_CNN_LEARN_RATE_DECREASE_LOG_INV )
- eta = -layer->init_learn_rate/logf(1+(float)t);
- else if( layer->learn_rate_decrease_type == CV_CNN_LEARN_RATE_DECREASE_SQRT_INV )
- eta = -layer->init_learn_rate/sqrtf((float)t);
- else
- eta = -layer->init_learn_rate/(float)t;
- cvReshape( dE_dW, &dE_dW_mat, 0, weights->rows );
- cvScaleAdd( &dE_dW_mat, cvRealScalar(eta), weights, weights );
- }
-
- }__END__;
-
- cvReleaseMat( &dY_dX_elems );
- cvReleaseMat( &dY_dW_elems );
- cvReleaseMat( &dE_dW );
-}
-
-/****************************************************************************************/
-/* <dE_dY>, <dE_dX> should be row-vectors.
- Function computes partial derivatives <dE_dX>, <dE_dW>
- of the loss function with respect to the planes components
- of the previous layer (X) and the weights of the current layer (W)
- and updates weights od the current layer by using <dE_dW>.
- It is a basic function for back propagation method.
- Input parameter <dE_dY> is the partial derivative of the
- loss function with respect to the planes components
- of the current layer. */
-static void icvCNNFullConnectBackward( CvCNNLayer* _layer,
- int t,
- const CvMat* X,
- const CvMat* dE_dY,
- CvMat* dE_dX )
-{
- CvMat* dE_dY_activ_func_der = 0;
- CvMat* dE_dW = 0;
-
- CV_FUNCNAME( "icvCNNFullConnectBackward" );
-
- if( !ICV_IS_CNN_FULLCONNECT_LAYER(_layer) )
- CV_ERROR( CV_StsBadArg, "Invalid layer" );
-
- {__BEGIN__;
-
- const CvCNNFullConnectLayer* layer = (CvCNNFullConnectLayer*)_layer;
- const int n_outputs = layer->n_output_planes;
- const int n_inputs = layer->n_input_planes;
-
- int i;
- float* dE_dY_activ_func_der_data;
- CvMat* weights = layer->weights;
- CvMat sub_weights, Xtemplate, Xrow, exp2ssumWXrow;
-
- CV_ASSERT(X->cols == 1 && X->rows == n_inputs);
- CV_ASSERT(dE_dY->rows == 1 && dE_dY->cols == n_outputs );
- CV_ASSERT(dE_dX->rows == 1 && dE_dX->cols == n_inputs );
-
- // we violate the convetion about vector's orientation because
- // here is more convenient to make this parameter a row-vector
- CV_CALL(dE_dY_activ_func_der = cvCreateMat( 1, n_outputs, CV_32FC1 ));
- CV_CALL(dE_dW = cvCreateMat( 1, weights->rows*weights->cols, CV_32FC1 ));
-
- // 1) compute gradients dE_dX and dE_dW
- // activ_func_der == 4as*(layer->exp2ssumWX)/(layer->exp2ssumWX + 1)^2
- CV_CALL(cvReshape( layer->exp2ssumWX, &exp2ssumWXrow, 0, layer->exp2ssumWX->cols ));
- CV_CALL(cvAddS( &exp2ssumWXrow, cvRealScalar(1), dE_dY_activ_func_der ));
- CV_CALL(cvPow( dE_dY_activ_func_der, dE_dY_activ_func_der, -2.0 ));
- CV_CALL(cvMul( dE_dY_activ_func_der, &exp2ssumWXrow, dE_dY_activ_func_der,
- 4.0*layer->a*layer->s ));
- CV_CALL(cvMul( dE_dY, dE_dY_activ_func_der, dE_dY_activ_func_der ));
-
- // sub_weights = d(W*(X|1))/dX
- CV_CALL(cvGetSubRect( weights, &sub_weights,
- cvRect(0, 0, weights->cols-1, weights->rows) ));
- CV_CALL(cvMatMul( dE_dY_activ_func_der, &sub_weights, dE_dX ));
-
- cvReshape( X, &Xrow, 0, 1 );
- dE_dY_activ_func_der_data = dE_dY_activ_func_der->data.fl;
- Xtemplate = cvMat( 1, n_inputs, CV_32FC1, dE_dW->data.fl );
- for( i = 0; i < n_outputs; i++, Xtemplate.data.fl += n_inputs + 1 )
- {
- CV_CALL(cvConvertScale( &Xrow, &Xtemplate, *dE_dY_activ_func_der_data ));
- Xtemplate.data.fl[n_inputs] = *dE_dY_activ_func_der_data++;
- }
-
- // 2) update weights
- {
- CvMat dE_dW_mat;
- float eta;
- if( layer->learn_rate_decrease_type == CV_CNN_LEARN_RATE_DECREASE_LOG_INV )
- eta = -layer->init_learn_rate/logf(1+(float)t);
- else if( layer->learn_rate_decrease_type == CV_CNN_LEARN_RATE_DECREASE_SQRT_INV )
- eta = -layer->init_learn_rate/sqrtf((float)t);
- else
- eta = -layer->init_learn_rate/(float)t;
- cvReshape( dE_dW, &dE_dW_mat, 0, n_outputs );
- cvScaleAdd( &dE_dW_mat, cvRealScalar(eta), weights, weights );
- }
-
- }__END__;
-
- cvReleaseMat( &dE_dY_activ_func_der );
- cvReleaseMat( &dE_dW );
-}
-
-/****************************************************************************************\
-* Layer RELEASE functions *
-\****************************************************************************************/
-static void icvCNNConvolutionRelease( CvCNNLayer** p_layer )
-{
- CV_FUNCNAME("icvCNNConvolutionRelease");
- __BEGIN__;
-
- CvCNNConvolutionLayer* layer = 0;
-
- if( !p_layer )
- CV_ERROR( CV_StsNullPtr, "Null double pointer" );
-
- layer = *(CvCNNConvolutionLayer**)p_layer;
-
- if( !layer )
- return;
- if( !ICV_IS_CNN_CONVOLUTION_LAYER(layer) )
- CV_ERROR( CV_StsBadArg, "Invalid layer" );
-
- cvReleaseMat( &layer->weights );
- cvReleaseMat( &layer->connect_mask );
- cvFree( p_layer );
-
- __END__;
-}
-
-/****************************************************************************************/
-static void icvCNNSubSamplingRelease( CvCNNLayer** p_layer )
-{
- CV_FUNCNAME("icvCNNSubSamplingRelease");
- __BEGIN__;
-
- CvCNNSubSamplingLayer* layer = 0;
-
- if( !p_layer )
- CV_ERROR( CV_StsNullPtr, "Null double pointer" );
-
- layer = *(CvCNNSubSamplingLayer**)p_layer;
-
- if( !layer )
- return;
- if( !ICV_IS_CNN_SUBSAMPLING_LAYER(layer) )
- CV_ERROR( CV_StsBadArg, "Invalid layer" );
-
- cvReleaseMat( &layer->exp2ssumWX );
- cvReleaseMat( &layer->weights );
- cvFree( p_layer );
-
- __END__;
-}
-
-/****************************************************************************************/
-static void icvCNNFullConnectRelease( CvCNNLayer** p_layer )
-{
- CV_FUNCNAME("icvCNNFullConnectRelease");
- __BEGIN__;
-
- CvCNNFullConnectLayer* layer = 0;
-
- if( !p_layer )
- CV_ERROR( CV_StsNullPtr, "Null double pointer" );
-
- layer = *(CvCNNFullConnectLayer**)p_layer;
-
- if( !layer )
- return;
- if( !ICV_IS_CNN_FULLCONNECT_LAYER(layer) )
- CV_ERROR( CV_StsBadArg, "Invalid layer" );
-
- cvReleaseMat( &layer->exp2ssumWX );
- cvReleaseMat( &layer->weights );
- cvFree( p_layer );
-
- __END__;
-}
-
-/****************************************************************************************\
-* Read/Write CNN classifier *
-\****************************************************************************************/
-static int icvIsCNNModel( const void* ptr )
-{
- return CV_IS_CNN(ptr);
-}
-
-/****************************************************************************************/
-static void icvReleaseCNNModel( void** ptr )
-{
- CV_FUNCNAME("icvReleaseCNNModel");
- __BEGIN__;
-
- if( !ptr )
- CV_ERROR( CV_StsNullPtr, "NULL double pointer" );
- CV_ASSERT(CV_IS_CNN(*ptr));
-
- icvCNNModelRelease( (CvStatModel**)ptr );
-
- __END__;
-}
-
-/****************************************************************************************/
-static CvCNNLayer* icvReadCNNLayer( CvFileStorage* fs, CvFileNode* node )
-{
- CvCNNLayer* layer = 0;
- CvMat* weights = 0;
- CvMat* connect_mask = 0;
-
- CV_FUNCNAME("icvReadCNNLayer");
- __BEGIN__;
-
- int n_input_planes, input_height, input_width;
- int n_output_planes, output_height, output_width;
- int learn_type, layer_type;
- float init_learn_rate;
-
- CV_CALL(n_input_planes = cvReadIntByName( fs, node, "n_input_planes", -1 ));
- CV_CALL(input_height = cvReadIntByName( fs, node, "input_height", -1 ));
- CV_CALL(input_width = cvReadIntByName( fs, node, "input_width", -1 ));
- CV_CALL(n_output_planes = cvReadIntByName( fs, node, "n_output_planes", -1 ));
- CV_CALL(output_height = cvReadIntByName( fs, node, "output_height", -1 ));
- CV_CALL(output_width = cvReadIntByName( fs, node, "output_width", -1 ));
- CV_CALL(layer_type = cvReadIntByName( fs, node, "layer_type", -1 ));
-
- CV_CALL(init_learn_rate = (float)cvReadRealByName( fs, node, "init_learn_rate", -1 ));
- CV_CALL(learn_type = cvReadIntByName( fs, node, "learn_rate_decrease_type", -1 ));
- CV_CALL(weights = (CvMat*)cvReadByName( fs, node, "weights" ));
-
- if( n_input_planes < 0 || input_height < 0 || input_width < 0 ||
- n_output_planes < 0 || output_height < 0 || output_width < 0 ||
- init_learn_rate < 0 || learn_type < 0 || layer_type < 0 || !weights )
- CV_ERROR( CV_StsParseError, "" );
-
- if( layer_type == ICV_CNN_CONVOLUTION_LAYER )
- {
- const int K = input_height - output_height + 1;
- if( K <= 0 || K != input_width - output_width + 1 )
- CV_ERROR( CV_StsBadArg, "Invalid <K>" );
-
- CV_CALL(connect_mask = (CvMat*)cvReadByName( fs, node, "connect_mask" ));
- if( !connect_mask )
- CV_ERROR( CV_StsParseError, "Missing <connect mask>" );
-
- CV_CALL(layer = cvCreateCNNConvolutionLayer(
- n_input_planes, input_height, input_width, n_output_planes, K,
- init_learn_rate, learn_type, connect_mask, weights ));
- }
- else if( layer_type == ICV_CNN_SUBSAMPLING_LAYER )
- {
- float a, s;
- const int sub_samp_scale = input_height/output_height;
-
- if( sub_samp_scale <= 0 || sub_samp_scale != input_width/output_width )
- CV_ERROR( CV_StsBadArg, "Invalid <sub_samp_scale>" );
-
- CV_CALL(a = (float)cvReadRealByName( fs, node, "a", -1 ));
- CV_CALL(s = (float)cvReadRealByName( fs, node, "s", -1 ));
- if( a < 0 || s < 0 )
- CV_ERROR( CV_StsParseError, "Missing <a> or <s>" );
-
- CV_CALL(layer = cvCreateCNNSubSamplingLayer(
- n_input_planes, input_height, input_width, sub_samp_scale,
- a, s, init_learn_rate, learn_type, weights ));
- }
- else if( layer_type == ICV_CNN_FULLCONNECT_LAYER )
- {
- float a, s;
- CV_CALL(a = (float)cvReadRealByName( fs, node, "a", -1 ));
- CV_CALL(s = (float)cvReadRealByName( fs, node, "s", -1 ));
- if( a < 0 || s < 0 )
- CV_ERROR( CV_StsParseError, "" );
- if( input_height != 1 || input_width != 1 ||
- output_height != 1 || output_width != 1 )
- CV_ERROR( CV_StsBadArg, "" );
-
- CV_CALL(layer = cvCreateCNNFullConnectLayer( n_input_planes, n_output_planes,
- a, s, init_learn_rate, learn_type, weights ));
- }
- else
- CV_ERROR( CV_StsBadArg, "Invalid <layer_type>" );
-
- __END__;
-
- if( cvGetErrStatus() < 0 && layer )
- layer->release( &layer );
-
- cvReleaseMat( &weights );
- cvReleaseMat( &connect_mask );
-
- return layer;
-}
-
-/****************************************************************************************/
-static void icvWriteCNNLayer( CvFileStorage* fs, CvCNNLayer* layer )
-{
- CV_FUNCNAME ("icvWriteCNNLayer");
- __BEGIN__;
-
- if( !ICV_IS_CNN_LAYER(layer) )
- CV_ERROR( CV_StsBadArg, "Invalid layer" );
-
- CV_CALL( cvStartWriteStruct( fs, NULL, CV_NODE_MAP, "opencv-ml-cnn-layer" ));
-
- CV_CALL(cvWriteInt( fs, "n_input_planes", layer->n_input_planes ));
- CV_CALL(cvWriteInt( fs, "input_height", layer->input_height ));
- CV_CALL(cvWriteInt( fs, "input_width", layer->input_width ));
- CV_CALL(cvWriteInt( fs, "n_output_planes", layer->n_output_planes ));
- CV_CALL(cvWriteInt( fs, "output_height", layer->output_height ));
- CV_CALL(cvWriteInt( fs, "output_width", layer->output_width ));
- CV_CALL(cvWriteInt( fs, "learn_rate_decrease_type", layer->learn_rate_decrease_type));
- CV_CALL(cvWriteReal( fs, "init_learn_rate", layer->init_learn_rate ));
- CV_CALL(cvWrite( fs, "weights", layer->weights ));
-
- if( ICV_IS_CNN_CONVOLUTION_LAYER( layer ))
- {
- CvCNNConvolutionLayer* l = (CvCNNConvolutionLayer*)layer;
- CV_CALL(cvWriteInt( fs, "layer_type", ICV_CNN_CONVOLUTION_LAYER ));
- CV_CALL(cvWrite( fs, "connect_mask", l->connect_mask ));
- }
- else if( ICV_IS_CNN_SUBSAMPLING_LAYER( layer ) )
- {
- CvCNNSubSamplingLayer* l = (CvCNNSubSamplingLayer*)layer;
- CV_CALL(cvWriteInt( fs, "layer_type", ICV_CNN_SUBSAMPLING_LAYER ));
- CV_CALL(cvWriteReal( fs, "a", l->a ));
- CV_CALL(cvWriteReal( fs, "s", l->s ));
- }
- else if( ICV_IS_CNN_FULLCONNECT_LAYER( layer ) )
- {
- CvCNNFullConnectLayer* l = (CvCNNFullConnectLayer*)layer;
- CV_CALL(cvWriteInt( fs, "layer_type", ICV_CNN_FULLCONNECT_LAYER ));
- CV_CALL(cvWriteReal( fs, "a", l->a ));
- CV_CALL(cvWriteReal( fs, "s", l->s ));
- }
- else
- CV_ERROR( CV_StsBadArg, "Invalid layer" );
-
- CV_CALL( cvEndWriteStruct( fs )); //"opencv-ml-cnn-layer"
-
- __END__;
-}
-
-/****************************************************************************************/
-static void* icvReadCNNModel( CvFileStorage* fs, CvFileNode* root_node )
-{
- CvCNNStatModel* cnn = 0;
- CvCNNLayer* layer = 0;
-
- CV_FUNCNAME("icvReadCNNModel");
- __BEGIN__;
-
- CvFileNode* node;
- CvSeq* seq;
- CvSeqReader reader;
- int i;
-
- CV_CALL(cnn = (CvCNNStatModel*)cvCreateStatModel(
- CV_STAT_MODEL_MAGIC_VAL|CV_CNN_MAGIC_VAL, sizeof(CvCNNStatModel),
- icvCNNModelRelease, icvCNNModelPredict, icvCNNModelUpdate ));
-
- CV_CALL(cnn->etalons = (CvMat*)cvReadByName( fs, root_node, "etalons" ));
- CV_CALL(cnn->cls_labels = (CvMat*)cvReadByName( fs, root_node, "cls_labels" ));
-
- if( !cnn->etalons || !cnn->cls_labels )
- CV_ERROR( CV_StsParseError, "No <etalons> or <cls_labels> in CNN model" );
-
- CV_CALL( node = cvGetFileNodeByName( fs, root_node, "network" ));
- seq = node->data.seq;
- if( !CV_NODE_IS_SEQ(node->tag) )
- CV_ERROR( CV_StsBadArg, "" );
-
- CV_CALL( cvStartReadSeq( seq, &reader, 0 ));
- CV_CALL(layer = icvReadCNNLayer( fs, (CvFileNode*)reader.ptr ));
- CV_CALL(cnn->network = cvCreateCNNetwork( layer ));
-
- for( i = 1; i < seq->total; i++ )
- {
- CV_NEXT_SEQ_ELEM( seq->elem_size, reader );
- CV_CALL(layer = icvReadCNNLayer( fs, (CvFileNode*)reader.ptr ));
- CV_CALL(cnn->network->add_layer( cnn->network, layer ));
- }
-
- __END__;
-
- if( cvGetErrStatus() < 0 )
- {
- if( cnn ) cnn->release( (CvStatModel**)&cnn );
- if( layer ) layer->release( &layer );
- }
- return (void*)cnn;
-}
-
-/****************************************************************************************/
-static void
-icvWriteCNNModel( CvFileStorage* fs, const char* name,
- const void* struct_ptr, CvAttrList )
-
-{
- CV_FUNCNAME ("icvWriteCNNModel");
- __BEGIN__;
-
- CvCNNStatModel* cnn = (CvCNNStatModel*)struct_ptr;
- int n_layers, i;
- CvCNNLayer* layer;
-
- if( !CV_IS_CNN(cnn) )
- CV_ERROR( CV_StsBadArg, "Invalid pointer" );
-
- n_layers = cnn->network->n_layers;
-
- CV_CALL( cvStartWriteStruct( fs, name, CV_NODE_MAP, CV_TYPE_NAME_ML_CNN ));
-
- CV_CALL(cvWrite( fs, "etalons", cnn->etalons ));
- CV_CALL(cvWrite( fs, "cls_labels", cnn->cls_labels ));
-
- CV_CALL( cvStartWriteStruct( fs, "network", CV_NODE_SEQ ));
-
- layer = cnn->network->layers;
- for( i = 0; i < n_layers && layer; i++, layer = layer->next_layer )
- CV_CALL(icvWriteCNNLayer( fs, layer ));
- if( i < n_layers || layer )
- CV_ERROR( CV_StsBadArg, "Invalid network" );
-
- CV_CALL( cvEndWriteStruct( fs )); //"network"
- CV_CALL( cvEndWriteStruct( fs )); //"opencv-ml-cnn"
-
- __END__;
-}
-
-static int icvRegisterCNNStatModelType()
-{
- CvTypeInfo info;
-
- info.header_size = sizeof( info );
- info.is_instance = icvIsCNNModel;
- info.release = icvReleaseCNNModel;
- info.read = icvReadCNNModel;
- info.write = icvWriteCNNModel;
- info.clone = NULL;
- info.type_name = CV_TYPE_NAME_ML_CNN;
- cvRegisterType( &info );
-
- return 1;
-} // End of icvRegisterCNNStatModelType
-
-static int cnn = icvRegisterCNNStatModelType();
-
-#endif
-
-// End of file
#include "precomp.hpp"
#include <ctype.h>
+#include <algorithm>
+#include <iterator>
-#define MISS_VAL FLT_MAX
-#define CV_VAR_MISS 0
+namespace cv { namespace ml {
-CvTrainTestSplit::CvTrainTestSplit()
-{
- train_sample_part_mode = CV_COUNT;
- train_sample_part.count = -1;
- mix = false;
-}
+static const float MISSED_VAL = TrainData::missingValue();
+static const int VAR_MISSED = VAR_ORDERED;
-CvTrainTestSplit::CvTrainTestSplit( int _train_sample_count, bool _mix )
-{
- train_sample_part_mode = CV_COUNT;
- train_sample_part.count = _train_sample_count;
- mix = _mix;
-}
+TrainData::~TrainData() {}
-CvTrainTestSplit::CvTrainTestSplit( float _train_sample_portion, bool _mix )
+Mat TrainData::getSubVector(const Mat& vec, const Mat& idx)
{
- train_sample_part_mode = CV_PORTION;
- train_sample_part.portion = _train_sample_portion;
- mix = _mix;
-}
-
-////////////////
+ if( idx.empty() )
+ return vec;
+ int i, j, n = idx.checkVector(1, CV_32S);
+ int type = vec.type();
+ CV_Assert( type == CV_32S || type == CV_32F || type == CV_64F );
+ int dims = 1, m;
-CvMLData::CvMLData()
-{
- values = missing = var_types = var_idx_mask = response_out = var_idx_out = var_types_out = 0;
- train_sample_idx = test_sample_idx = 0;
- header_lines_number = 0;
- sample_idx = 0;
- response_idx = -1;
-
- train_sample_count = -1;
-
- delimiter = ',';
- miss_ch = '?';
- //flt_separator = '.';
-
- rng = &cv::theRNG();
-}
+ if( vec.cols == 1 || vec.rows == 1 )
+ {
+ dims = 1;
+ m = vec.cols + vec.rows - 1;
+ }
+ else
+ {
+ dims = vec.cols;
+ m = vec.rows;
+ }
-CvMLData::~CvMLData()
-{
- clear();
-}
+ Mat subvec;
-void CvMLData::free_train_test_idx()
-{
- cvReleaseMat( &train_sample_idx );
- cvReleaseMat( &test_sample_idx );
- sample_idx = 0;
+ if( vec.cols == m )
+ subvec.create(dims, n, type);
+ else
+ subvec.create(n, dims, type);
+ if( type == CV_32S )
+ for( i = 0; i < n; i++ )
+ {
+ int k = idx.at<int>(i);
+ CV_Assert( 0 <= k && k < m );
+ if( dims == 1 )
+ subvec.at<int>(i) = vec.at<int>(k);
+ else
+ for( j = 0; j < dims; j++ )
+ subvec.at<int>(i, j) = vec.at<int>(k, j);
+ }
+ else if( type == CV_32F )
+ for( i = 0; i < n; i++ )
+ {
+ int k = idx.at<int>(i);
+ CV_Assert( 0 <= k && k < m );
+ if( dims == 1 )
+ subvec.at<float>(i) = vec.at<float>(k);
+ else
+ for( j = 0; j < dims; j++ )
+ subvec.at<float>(i, j) = vec.at<float>(k, j);
+ }
+ else
+ for( i = 0; i < n; i++ )
+ {
+ int k = idx.at<int>(i);
+ CV_Assert( 0 <= k && k < m );
+ if( dims == 1 )
+ subvec.at<double>(i) = vec.at<double>(k);
+ else
+ for( j = 0; j < dims; j++ )
+ subvec.at<double>(i, j) = vec.at<double>(k, j);
+ }
+ return subvec;
}
-void CvMLData::clear()
+class TrainDataImpl : public TrainData
{
- class_map.clear();
+public:
+ typedef std::map<String, int> MapType;
- cvReleaseMat( &values );
- cvReleaseMat( &missing );
- cvReleaseMat( &var_types );
- cvReleaseMat( &var_idx_mask );
-
- cvReleaseMat( &response_out );
- cvReleaseMat( &var_idx_out );
- cvReleaseMat( &var_types_out );
+ TrainDataImpl()
+ {
+ file = 0;
+ clear();
+ }
- free_train_test_idx();
+ virtual ~TrainDataImpl() { closeFile(); }
- total_class_count = 0;
+ int getLayout() const { return layout; }
+ int getNSamples() const
+ {
+ return !sampleIdx.empty() ? (int)sampleIdx.total() :
+ layout == ROW_SAMPLE ? samples.rows : samples.cols;
+ }
+ int getNTrainSamples() const
+ {
+ return !trainSampleIdx.empty() ? (int)trainSampleIdx.total() : getNSamples();
+ }
+ int getNTestSamples() const
+ {
+ return !testSampleIdx.empty() ? (int)testSampleIdx.total() : 0;
+ }
+ int getNVars() const
+ {
+ return !varIdx.empty() ? (int)varIdx.total() : getNAllVars();
+ }
+ int getNAllVars() const
+ {
+ return layout == ROW_SAMPLE ? samples.cols : samples.rows;
+ }
- response_idx = -1;
+ Mat getSamples() const { return samples; }
+ Mat getResponses() const { return responses; }
+ Mat getMissing() const { return missing; }
+ Mat getVarIdx() const { return varIdx; }
+ Mat getVarType() const { return varType; }
+ int getResponseType() const
+ {
+ return classLabels.empty() ? VAR_ORDERED : VAR_CATEGORICAL;
+ }
+ Mat getTrainSampleIdx() const { return !trainSampleIdx.empty() ? trainSampleIdx : sampleIdx; }
+ Mat getTestSampleIdx() const { return testSampleIdx; }
+ Mat getSampleWeights() const
+ {
+ return sampleWeights;
+ }
+ Mat getTrainSampleWeights() const
+ {
+ return getSubVector(sampleWeights, getTrainSampleIdx());
+ }
+ Mat getTestSampleWeights() const
+ {
+ Mat idx = getTestSampleIdx();
+ return idx.empty() ? Mat() : getSubVector(sampleWeights, idx);
+ }
+ Mat getTrainResponses() const
+ {
+ return getSubVector(responses, getTrainSampleIdx());
+ }
+ Mat getTrainNormCatResponses() const
+ {
+ return getSubVector(normCatResponses, getTrainSampleIdx());
+ }
+ Mat getTestResponses() const
+ {
+ Mat idx = getTestSampleIdx();
+ return idx.empty() ? Mat() : getSubVector(responses, idx);
+ }
+ Mat getTestNormCatResponses() const
+ {
+ Mat idx = getTestSampleIdx();
+ return idx.empty() ? Mat() : getSubVector(normCatResponses, idx);
+ }
+ Mat getNormCatResponses() const { return normCatResponses; }
+ Mat getClassLabels() const { return classLabels; }
+ Mat getClassCounters() const { return classCounters; }
+ int getCatCount(int vi) const
+ {
+ int n = (int)catOfs.total();
+ CV_Assert( 0 <= vi && vi < n );
+ Vec2i ofs = catOfs.at<Vec2i>(vi);
+ return ofs[1] - ofs[0];
+ }
- train_sample_count = -1;
-}
+ Mat getCatOfs() const { return catOfs; }
+ Mat getCatMap() const { return catMap; }
+ Mat getDefaultSubstValues() const { return missingSubst; }
-void CvMLData::set_header_lines_number( int idx )
-{
- header_lines_number = std::max(0, idx);
-}
+ void closeFile() { if(file) fclose(file); file=0; }
+ void clear()
+ {
+ closeFile();
+ samples.release();
+ missing.release();
+ varType.release();
+ responses.release();
+ sampleIdx.release();
+ trainSampleIdx.release();
+ testSampleIdx.release();
+ normCatResponses.release();
+ classLabels.release();
+ classCounters.release();
+ catMap.release();
+ catOfs.release();
+ nameMap = MapType();
+ layout = ROW_SAMPLE;
+ }
-int CvMLData::get_header_lines_number() const
-{
- return header_lines_number;
-}
+ typedef std::map<int, int> CatMapHash;
-static char *fgets_chomp(char *str, int n, FILE *stream)
-{
- char *head = fgets(str, n, stream);
- if( head )
+ void setData(InputArray _samples, int _layout, InputArray _responses,
+ InputArray _varIdx, InputArray _sampleIdx, InputArray _sampleWeights,
+ InputArray _varType, InputArray _missing)
{
- for(char *tail = head + strlen(head) - 1; tail >= head; --tail)
- {
- if( *tail != '\r' && *tail != '\n' )
- break;
- *tail = '\0';
- }
- }
- return head;
-}
+ clear();
+ CV_Assert(_layout == ROW_SAMPLE || _layout == COL_SAMPLE );
+ samples = _samples.getMat();
+ layout = _layout;
+ responses = _responses.getMat();
+ varIdx = _varIdx.getMat();
+ sampleIdx = _sampleIdx.getMat();
+ sampleWeights = _sampleWeights.getMat();
+ varType = _varType.getMat();
+ missing = _missing.getMat();
-int CvMLData::read_csv(const char* filename)
-{
- const int M = 1000000;
- const char str_delimiter[3] = { ' ', delimiter, '\0' };
- FILE* file = 0;
- CvMemStorage* storage;
- CvSeq* seq;
- char *ptr;
- float* el_ptr;
- CvSeqReader reader;
- int cols_count = 0;
- uchar *var_types_ptr = 0;
+ int nsamples = layout == ROW_SAMPLE ? samples.rows : samples.cols;
+ int ninputvars = layout == ROW_SAMPLE ? samples.cols : samples.rows;
+ int i, noutputvars = 0;
- clear();
+ CV_Assert( samples.type() == CV_32F || samples.type() == CV_32S );
- file = fopen( filename, "rt" );
+ if( !sampleIdx.empty() )
+ {
+ CV_Assert( (sampleIdx.checkVector(1, CV_32S, true) > 0 &&
+ checkRange(sampleIdx, true, 0, 0, nsamples-1)) ||
+ sampleIdx.checkVector(1, CV_8U, true) == nsamples );
+ if( sampleIdx.type() == CV_8U )
+ sampleIdx = convertMaskToIdx(sampleIdx);
+ }
- if( !file )
- return -1;
+ if( !sampleWeights.empty() )
+ {
+ CV_Assert( sampleWeights.checkVector(1, CV_32F, true) == nsamples );
+ }
+ else
+ {
+ sampleWeights = Mat::ones(nsamples, 1, CV_32F);
+ }
- std::vector<char> _buf(M);
- char* buf = &_buf[0];
+ if( !varIdx.empty() )
+ {
+ CV_Assert( (varIdx.checkVector(1, CV_32S, true) > 0 &&
+ checkRange(varIdx, true, 0, 0, ninputvars)) ||
+ varIdx.checkVector(1, CV_8U, true) == ninputvars );
+ if( varIdx.type() == CV_8U )
+ varIdx = convertMaskToIdx(varIdx);
+ varIdx = varIdx.clone();
+ std::sort(varIdx.ptr<int>(), varIdx.ptr<int>() + varIdx.total());
+ }
- // skip header lines
- for( int i = 0; i < header_lines_number; i++ )
- {
- if( fgets( buf, M, file ) == 0 )
+ if( !responses.empty() )
{
- fclose(file);
- return -1;
+ CV_Assert( responses.type() == CV_32F || responses.type() == CV_32S );
+ if( (responses.cols == 1 || responses.rows == 1) && (int)responses.total() == nsamples )
+ noutputvars = 1;
+ else
+ {
+ CV_Assert( (layout == ROW_SAMPLE && responses.rows == nsamples) ||
+ (layout == COL_SAMPLE && responses.cols == nsamples) );
+ noutputvars = layout == ROW_SAMPLE ? responses.cols : responses.rows;
+ }
+ if( !responses.isContinuous() || (layout == COL_SAMPLE && noutputvars > 1) )
+ {
+ Mat temp;
+ transpose(responses, temp);
+ responses = temp;
+ }
}
- }
- // read the first data line and determine the number of variables
- if( !fgets_chomp( buf, M, file ))
- {
- fclose(file);
- return -1;
- }
+ int nvars = ninputvars + noutputvars;
- ptr = buf;
- while( *ptr == ' ' )
- ptr++;
- for( ; *ptr != '\0'; )
- {
- if(*ptr == delimiter || *ptr == ' ')
+ if( !varType.empty() )
{
- cols_count++;
- ptr++;
- while( *ptr == ' ' ) ptr++;
+ CV_Assert( varType.checkVector(1, CV_8U, true) == nvars &&
+ checkRange(varType, true, 0, VAR_ORDERED, VAR_CATEGORICAL+1) );
}
else
- ptr++;
- }
+ {
+ varType.create(1, nvars, CV_8U);
+ varType = Scalar::all(VAR_ORDERED);
+ if( noutputvars == 1 )
+ varType.at<uchar>(ninputvars) = responses.type() < CV_32F ? VAR_CATEGORICAL : VAR_ORDERED;
+ }
- cols_count++;
+ if( noutputvars > 1 )
+ {
+ for( i = 0; i < noutputvars; i++ )
+ CV_Assert( varType.at<uchar>(ninputvars + i) == VAR_ORDERED );
+ }
- if ( cols_count == 0)
- {
- fclose(file);
- return -1;
- }
+ catOfs = Mat::zeros(1, nvars, CV_32SC2);
+ missingSubst = Mat::zeros(1, nvars, CV_32F);
- // create temporary memory storage to store the whole database
- el_ptr = new float[cols_count];
- storage = cvCreateMemStorage();
- seq = cvCreateSeq( 0, sizeof(*seq), cols_count*sizeof(float), storage );
+ vector<int> labels, counters, sortbuf, tempCatMap;
+ vector<Vec2i> tempCatOfs;
+ CatMapHash ofshash;
- var_types = cvCreateMat( 1, cols_count, CV_8U );
- cvZero( var_types );
- var_types_ptr = var_types->data.ptr;
+ AutoBuffer<uchar> buf(nsamples);
+ Mat non_missing(layout == ROW_SAMPLE ? Size(1, nsamples) : Size(nsamples, 1), CV_8U, (uchar*)buf);
+ bool haveMissing = !missing.empty();
+ if( haveMissing )
+ {
+ CV_Assert( missing.size() == samples.size() && missing.type() == CV_8U );
+ }
- for(;;)
- {
- char *token = NULL;
- int type;
- token = strtok(buf, str_delimiter);
- if (!token)
- break;
- for (int i = 0; i < cols_count-1; i++)
+ // we iterate through all the variables. For each categorical variable we build a map
+ // in order to convert input values of the variable into normalized values (0..catcount_vi-1)
+ // often many categorical variables are similar, so we compress the map - try to re-use
+ // maps for different variables if they are identical
+ for( i = 0; i < ninputvars; i++ )
{
- str_to_flt_elem( token, el_ptr[i], type);
- var_types_ptr[i] |= type;
- token = strtok(NULL, str_delimiter);
- if (!token)
+ Mat values_i = layout == ROW_SAMPLE ? samples.col(i) : samples.row(i);
+
+ if( varType.at<uchar>(i) == VAR_CATEGORICAL )
+ {
+ preprocessCategorical(values_i, 0, labels, 0, sortbuf);
+ missingSubst.at<float>(i) = -1.f;
+ int j, m = (int)labels.size();
+ CV_Assert( m > 0 );
+ int a = labels.front(), b = labels.back();
+ const int* currmap = &labels[0];
+ int hashval = ((unsigned)a*127 + (unsigned)b)*127 + m;
+ CatMapHash::iterator it = ofshash.find(hashval);
+ if( it != ofshash.end() )
+ {
+ int vi = it->second;
+ Vec2i ofs0 = tempCatOfs[vi];
+ int m0 = ofs0[1] - ofs0[0];
+ const int* map0 = &tempCatMap[ofs0[0]];
+ if( m0 == m && map0[0] == a && map0[m0-1] == b )
+ {
+ for( j = 0; j < m; j++ )
+ if( map0[j] != currmap[j] )
+ break;
+ if( j == m )
+ {
+ // re-use the map
+ tempCatOfs.push_back(ofs0);
+ continue;
+ }
+ }
+ }
+ else
+ ofshash[hashval] = i;
+ Vec2i ofs;
+ ofs[0] = (int)tempCatMap.size();
+ ofs[1] = ofs[0] + m;
+ tempCatOfs.push_back(ofs);
+ std::copy(labels.begin(), labels.end(), std::back_inserter(tempCatMap));
+ }
+ else if( haveMissing )
{
- fclose(file);
- delete [] el_ptr;
- return -1;
+ tempCatOfs.push_back(Vec2i(0, 0));
+ /*Mat missing_i = layout == ROW_SAMPLE ? missing.col(i) : missing.row(i);
+ compare(missing_i, Scalar::all(0), non_missing, CMP_EQ);
+ missingSubst.at<float>(i) = (float)(mean(values_i, non_missing)[0]);*/
+ missingSubst.at<float>(i) = 0.f;
}
}
- str_to_flt_elem( token, el_ptr[cols_count-1], type);
- var_types_ptr[cols_count-1] |= type;
- cvSeqPush( seq, el_ptr );
- if( !fgets_chomp( buf, M, file ) )
- break;
- }
- fclose(file);
- values = cvCreateMat( seq->total, cols_count, CV_32FC1 );
- missing = cvCreateMat( seq->total, cols_count, CV_8U );
- var_idx_mask = cvCreateMat( 1, values->cols, CV_8UC1 );
- cvSet( var_idx_mask, cvRealScalar(1) );
- train_sample_count = seq->total;
-
- cvStartReadSeq( seq, &reader );
- for(int i = 0; i < seq->total; i++ )
- {
- const float* sdata = (float*)reader.ptr;
- float* ddata = values->data.fl + cols_count*i;
- uchar* dm = missing->data.ptr + cols_count*i;
+ if( !tempCatOfs.empty() )
+ {
+ Mat(tempCatOfs).copyTo(catOfs);
+ Mat(tempCatMap).copyTo(catMap);
+ }
- for( int j = 0; j < cols_count; j++ )
+ if( varType.at<uchar>(ninputvars) == VAR_CATEGORICAL )
{
- ddata[j] = sdata[j];
- dm[j] = ( fabs( MISS_VAL - sdata[j] ) <= FLT_EPSILON );
+ preprocessCategorical(responses, &normCatResponses, labels, &counters, sortbuf);
+ Mat(labels).copyTo(classLabels);
+ Mat(counters).copyTo(classCounters);
}
- CV_NEXT_SEQ_ELEM( seq->elem_size, reader );
}
- if ( cvNorm( missing, 0, CV_L1 ) <= FLT_EPSILON )
- cvReleaseMat( &missing );
+ Mat convertMaskToIdx(const Mat& mask)
+ {
+ int i, j, nz = countNonZero(mask), n = mask.cols + mask.rows - 1;
+ Mat idx(1, nz, CV_32S);
+ for( i = j = 0; i < n; i++ )
+ if( mask.at<uchar>(i) )
+ idx.at<int>(j++) = i;
+ return idx;
+ }
- cvReleaseMemStorage( &storage );
- delete []el_ptr;
- return 0;
-}
+ struct CmpByIdx
+ {
+ CmpByIdx(const int* _data, int _step) : data(_data), step(_step) {}
+ bool operator ()(int i, int j) const { return data[i*step] < data[j*step]; }
+ const int* data;
+ int step;
+ };
+
+ void preprocessCategorical(const Mat& data, Mat* normdata, vector<int>& labels,
+ vector<int>* counters, vector<int>& sortbuf)
+ {
+ CV_Assert((data.cols == 1 || data.rows == 1) && (data.type() == CV_32S || data.type() == CV_32F));
+ int* odata = 0;
+ int ostep = 0;
-const CvMat* CvMLData::get_values() const
-{
- return values;
-}
+ if(normdata)
+ {
+ normdata->create(data.size(), CV_32S);
+ odata = normdata->ptr<int>();
+ ostep = normdata->isContinuous() ? 1 : (int)normdata->step1();
+ }
-const CvMat* CvMLData::get_missing() const
-{
- CV_FUNCNAME( "CvMLData::get_missing" );
- __BEGIN__;
+ int i, n = data.cols + data.rows - 1;
+ sortbuf.resize(n*2);
+ int* idx = &sortbuf[0];
+ int* idata = (int*)data.ptr<int>();
+ int istep = data.isContinuous() ? 1 : (int)data.step1();
- if ( !values )
- CV_ERROR( CV_StsInternal, "data is empty" );
+ if( data.type() == CV_32F )
+ {
+ idata = idx + n;
+ const float* fdata = data.ptr<float>();
+ for( i = 0; i < n; i++ )
+ {
+ if( fdata[i*istep] == MISSED_VAL )
+ idata[i] = -1;
+ else
+ {
+ idata[i] = cvRound(fdata[i*istep]);
+ CV_Assert( (float)idata[i] == fdata[i*istep] );
+ }
+ }
+ istep = 1;
+ }
- __END__;
+ for( i = 0; i < n; i++ )
+ idx[i] = i;
- return missing;
-}
+ std::sort(idx, idx + n, CmpByIdx(idata, istep));
-const std::map<cv::String, int>& CvMLData::get_class_labels_map() const
-{
- return class_map;
-}
+ int clscount = 1;
+ for( i = 1; i < n; i++ )
+ clscount += idata[idx[i]*istep] != idata[idx[i-1]*istep];
-void CvMLData::str_to_flt_elem( const char* token, float& flt_elem, int& type)
-{
+ int clslabel = -1;
+ int prev = ~idata[idx[0]*istep];
+ int previdx = 0;
- char* stopstring = NULL;
- flt_elem = (float)strtod( token, &stopstring );
- assert( stopstring );
- type = CV_VAR_ORDERED;
- if ( *stopstring == miss_ch && strlen(stopstring) == 1 ) // missed value
- {
- flt_elem = MISS_VAL;
- type = CV_VAR_MISS;
- }
- else
- {
- if ( (*stopstring != 0) && (*stopstring != '\n') && (strcmp(stopstring, "\r\n") != 0) ) // class label
+ labels.resize(clscount);
+ if(counters)
+ counters->resize(clscount);
+
+ for( i = 0; i < n; i++ )
{
- int idx = class_map[token];
- if ( idx == 0)
+ int l = idata[idx[i]*istep];
+ if( l != prev )
{
- total_class_count++;
- idx = total_class_count;
- class_map[token] = idx;
+ clslabel++;
+ labels[clslabel] = l;
+ int k = i - previdx;
+ if( clslabel > 0 && counters )
+ counters->at(clslabel-1) = k;
+ prev = l;
+ previdx = i;
}
- flt_elem = (float)idx;
- type = CV_VAR_CATEGORICAL;
+ if(odata)
+ odata[idx[i]*ostep] = clslabel;
}
+ if(counters)
+ counters->at(clslabel) = i - previdx;
}
-}
-void CvMLData::set_delimiter(char ch)
-{
- CV_FUNCNAME( "CvMLData::set_delimited" );
- __BEGIN__;
-
- if (ch == miss_ch /*|| ch == flt_separator*/)
- CV_ERROR(CV_StsBadArg, "delimited, miss_character and flt_separator must be different");
-
- delimiter = ch;
-
- __END__;
-}
+ bool loadCSV(const String& filename, int headerLines,
+ int responseStartIdx, int responseEndIdx,
+ const String& varTypeSpec, char delimiter, char missch)
+ {
+ const int M = 1000000;
+ const char delimiters[3] = { ' ', delimiter, '\0' };
+ int nvars = 0;
+ bool varTypesSet = false;
-char CvMLData::get_delimiter() const
-{
- return delimiter;
-}
+ clear();
-void CvMLData::set_miss_ch(char ch)
-{
- CV_FUNCNAME( "CvMLData::set_miss_ch" );
- __BEGIN__;
+ file = fopen( filename.c_str(), "rt" );
- if (ch == delimiter/* || ch == flt_separator*/)
- CV_ERROR(CV_StsBadArg, "delimited, miss_character and flt_separator must be different");
+ if( !file )
+ return false;
- miss_ch = ch;
+ std::vector<char> _buf(M);
+ std::vector<float> allresponses;
+ std::vector<float> rowvals;
+ std::vector<uchar> vtypes, rowtypes;
+ bool haveMissed = false;
+ char* buf = &_buf[0];
- __END__;
-}
+ int i, ridx0 = responseStartIdx, ridx1 = responseEndIdx;
+ int ninputvars = 0, noutputvars = 0;
-char CvMLData::get_miss_ch() const
-{
- return miss_ch;
-}
+ Mat tempSamples, tempMissing, tempResponses;
+ MapType tempNameMap;
+ int catCounter = 1;
-void CvMLData::set_response_idx( int idx )
-{
- CV_FUNCNAME( "CvMLData::set_response_idx" );
- __BEGIN__;
+ // skip header lines
+ int lineno = 0;
+ for(;;lineno++)
+ {
+ if( !fgets(buf, M, file) )
+ break;
+ if(lineno < headerLines )
+ continue;
+ // trim trailing spaces
+ int idx = (int)strlen(buf)-1;
+ while( idx >= 0 && isspace(buf[idx]) )
+ buf[idx--] = '\0';
+ // skip spaces in the beginning
+ char* ptr = buf;
+ while( *ptr != '\0' && isspace(*ptr) )
+ ptr++;
+ // skip commented off lines
+ if(*ptr == '#')
+ continue;
+ rowvals.clear();
+ rowtypes.clear();
+
+ char* token = strtok(buf, delimiters);
+ if (!token)
+ break;
- if ( !values )
- CV_ERROR( CV_StsInternal, "data is empty" );
+ for(;;)
+ {
+ float val=0.f; int tp = 0;
+ decodeElem( token, val, tp, missch, tempNameMap, catCounter );
+ if( tp == VAR_MISSED )
+ haveMissed = true;
+ rowvals.push_back(val);
+ rowtypes.push_back(tp);
+ token = strtok(NULL, delimiters);
+ if (!token)
+ break;
+ }
- if ( idx >= values->cols)
- CV_ERROR( CV_StsBadArg, "idx value is not correct" );
+ if( nvars == 0 )
+ {
+ if( rowvals.empty() )
+ CV_Error(CV_StsBadArg, "invalid CSV format; no data found");
+ nvars = (int)rowvals.size();
+ if( !varTypeSpec.empty() && varTypeSpec.size() > 0 )
+ {
+ setVarTypes(varTypeSpec, nvars, vtypes);
+ varTypesSet = true;
+ }
+ else
+ vtypes = rowtypes;
- if ( response_idx >= 0 )
- chahge_var_idx( response_idx, true );
- if ( idx >= 0 )
- chahge_var_idx( idx, false );
- response_idx = idx;
+ ridx0 = ridx0 >= 0 ? ridx0 : ridx0 == -1 ? nvars - 1 : -1;
+ ridx1 = ridx1 >= 0 ? ridx1 : ridx0 >= 0 ? ridx0+1 : -1;
+ CV_Assert(ridx1 > ridx0);
+ noutputvars = ridx0 >= 0 ? ridx1 - ridx0 : 0;
+ ninputvars = nvars - noutputvars;
+ }
+ else
+ CV_Assert( nvars == (int)rowvals.size() );
- __END__;
-}
+ // check var types
+ for( i = 0; i < nvars; i++ )
+ {
+ CV_Assert( (!varTypesSet && vtypes[i] == rowtypes[i]) ||
+ (varTypesSet && (vtypes[i] == rowtypes[i] || rowtypes[i] == VAR_ORDERED)) );
+ }
-int CvMLData::get_response_idx() const
-{
- CV_FUNCNAME( "CvMLData::get_response_idx" );
- __BEGIN__;
+ if( ridx0 >= 0 )
+ {
+ for( i = ridx1; i < nvars; i++ )
+ std::swap(rowvals[i], rowvals[i-noutputvars]);
+ for( i = ninputvars; i < nvars; i++ )
+ allresponses.push_back(rowvals[i]);
+ rowvals.pop_back();
+ }
+ Mat rmat(1, ninputvars, CV_32F, &rowvals[0]);
+ tempSamples.push_back(rmat);
+ }
- if ( !values )
- CV_ERROR( CV_StsInternal, "data is empty" );
- __END__;
- return response_idx;
-}
+ closeFile();
-void CvMLData::change_var_type( int var_idx, int type )
-{
- CV_FUNCNAME( "CvMLData::change_var_type" );
- __BEGIN__;
+ int nsamples = tempSamples.rows;
+ if( nsamples == 0 )
+ return false;
- int var_count = 0;
+ if( haveMissed )
+ compare(tempSamples, MISSED_VAL, tempMissing, CMP_EQ);
- if ( !values )
- CV_ERROR( CV_StsInternal, "data is empty" );
+ if( ridx0 >= 0 )
+ {
+ for( i = ridx1; i < nvars; i++ )
+ std::swap(vtypes[i], vtypes[i-noutputvars]);
+ if( noutputvars > 1 )
+ {
+ for( i = ninputvars; i < nvars; i++ )
+ if( vtypes[i] == VAR_CATEGORICAL )
+ CV_Error(CV_StsBadArg,
+ "If responses are vector values, not scalars, they must be marked as ordered responses");
+ }
+ }
- var_count = values->cols;
+ if( !varTypesSet && noutputvars == 1 && vtypes[ninputvars] == VAR_ORDERED )
+ {
+ for( i = 0; i < nsamples; i++ )
+ if( allresponses[i] != cvRound(allresponses[i]) )
+ break;
+ if( i == nsamples )
+ vtypes[ninputvars] = VAR_CATEGORICAL;
+ }
- if ( var_idx < 0 || var_idx >= var_count)
- CV_ERROR( CV_StsBadArg, "var_idx is not correct" );
+ Mat(nsamples, noutputvars, CV_32F, &allresponses[0]).copyTo(tempResponses);
+ setData(tempSamples, ROW_SAMPLE, tempResponses, noArray(), noArray(),
+ noArray(), Mat(vtypes).clone(), tempMissing);
+ bool ok = !samples.empty();
+ if(ok)
+ std::swap(tempNameMap, nameMap);
+ return ok;
+ }
- if ( type != CV_VAR_ORDERED && type != CV_VAR_CATEGORICAL)
- CV_ERROR( CV_StsBadArg, "type is not correct" );
+ void decodeElem( const char* token, float& elem, int& type,
+ char missch, MapType& namemap, int& counter ) const
+ {
+ char* stopstring = NULL;
+ elem = (float)strtod( token, &stopstring );
+ if( *stopstring == missch && strlen(stopstring) == 1 ) // missed value
+ {
+ elem = MISSED_VAL;
+ type = VAR_MISSED;
+ }
+ else if( *stopstring != '\0' )
+ {
+ MapType::iterator it = namemap.find(token);
+ if( it == namemap.end() )
+ {
+ elem = (float)counter;
+ namemap[token] = counter++;
+ }
+ else
+ elem = (float)it->second;
+ type = VAR_CATEGORICAL;
+ }
+ else
+ type = VAR_ORDERED;
+ }
- assert( var_types );
- if ( var_types->data.ptr[var_idx] == CV_VAR_CATEGORICAL && type == CV_VAR_ORDERED)
- CV_ERROR( CV_StsBadArg, "it`s impossible to assign CV_VAR_ORDERED type to categorical variable" );
- var_types->data.ptr[var_idx] = (uchar)type;
+ void setVarTypes( const String& s, int nvars, std::vector<uchar>& vtypes ) const
+ {
+ const char* errmsg = "type spec is not correct; it should have format \"cat\", \"ord\" or "
+ "\"ord[n1,n2-n3,n4-n5,...]cat[m1-m2,m3,m4-m5,...]\", where n's and m's are 0-based variable indices";
+ const char* str = s.c_str();
+ int specCounter = 0;
- __END__;
+ vtypes.resize(nvars);
- return;
-}
+ for( int k = 0; k < 2; k++ )
+ {
+ const char* ptr = strstr(str, k == 0 ? "ord" : "cat");
+ int tp = k == 0 ? VAR_ORDERED : VAR_CATEGORICAL;
+ if( ptr ) // parse ord/cat str
+ {
+ char* stopstring = NULL;
-void CvMLData::set_var_types( const char* str )
-{
- CV_FUNCNAME( "CvMLData::set_var_types" );
- __BEGIN__;
+ if( ptr[3] == '\0' )
+ {
+ for( int i = 0; i < nvars; i++ )
+ vtypes[i] = (uchar)tp;
+ specCounter = nvars;
+ break;
+ }
- const char* ord = 0, *cat = 0;
- int var_count = 0, set_var_type_count = 0;
- if ( !values )
- CV_ERROR( CV_StsInternal, "data is empty" );
+ if ( ptr[3] != '[')
+ CV_Error( CV_StsBadArg, errmsg );
- var_count = values->cols;
+ ptr += 4; // pass "ord["
+ do
+ {
+ int b1 = (int)strtod( ptr, &stopstring );
+ if( *stopstring == 0 || (*stopstring != ',' && *stopstring != ']' && *stopstring != '-') )
+ CV_Error( CV_StsBadArg, errmsg );
+ ptr = stopstring + 1;
+ if( (stopstring[0] == ',') || (stopstring[0] == ']'))
+ {
+ CV_Assert( 0 <= b1 && b1 < nvars );
+ vtypes[b1] = (uchar)tp;
+ specCounter++;
+ }
+ else
+ {
+ if( stopstring[0] == '-')
+ {
+ int b2 = (int)strtod( ptr, &stopstring);
+ if ( (*stopstring == 0) || (*stopstring != ',' && *stopstring != ']') )
+ CV_Error( CV_StsBadArg, errmsg );
+ ptr = stopstring + 1;
+ CV_Assert( 0 <= b1 && b1 <= b2 && b2 < nvars );
+ for (int i = b1; i <= b2; i++)
+ vtypes[i] = (uchar)tp;
+ specCounter += b2 - b1 + 1;
+ }
+ else
+ CV_Error( CV_StsBadArg, errmsg );
- assert( var_types );
+ }
+ }
+ while(*stopstring != ']');
- ord = strstr( str, "ord" );
- cat = strstr( str, "cat" );
- if ( !ord && !cat )
- CV_ERROR( CV_StsBadArg, "types string is not correct" );
+ if( stopstring[1] != '\0' && stopstring[1] != ',')
+ CV_Error( CV_StsBadArg, errmsg );
+ }
+ }
- if ( !ord && strlen(cat) == 3 ) // str == "cat"
- {
- cvSet( var_types, cvScalarAll(CV_VAR_CATEGORICAL) );
- return;
+ if( specCounter != nvars )
+ CV_Error( CV_StsBadArg, "type of some variables is not specified" );
}
- if ( !cat && strlen(ord) == 3 ) // str == "ord"
+ void setTrainTestSplitRatio(float ratio, bool shuffle)
{
- cvSet( var_types, cvScalarAll(CV_VAR_ORDERED) );
- return;
+ CV_Assert( 0 <= ratio && ratio <= 1 );
+ setTrainTestSplit(cvRound(getNSamples()*ratio), shuffle);
}
- if ( ord ) // parse ord str
+ void setTrainTestSplit(int count, bool shuffle)
{
- char* stopstring = NULL;
- if ( ord[3] != '[')
- CV_ERROR( CV_StsBadArg, "types string is not correct" );
+ int i, nsamples = getNSamples();
+ CV_Assert( 0 <= count < nsamples );
+
+ trainSampleIdx.release();
+ testSampleIdx.release();
- ord += 4; // pass "ord["
- do
+ if( count == 0 )
+ trainSampleIdx = sampleIdx;
+ else if( count == nsamples )
+ testSampleIdx = sampleIdx;
+ else
{
- int b1 = (int)strtod( ord, &stopstring );
- if ( *stopstring == 0 || (*stopstring != ',' && *stopstring != ']' && *stopstring != '-') )
- CV_ERROR( CV_StsBadArg, "types string is not correct" );
- ord = stopstring + 1;
- if ( (stopstring[0] == ',') || (stopstring[0] == ']'))
+ Mat mask(1, nsamples, CV_8U);
+ uchar* mptr = mask.data;
+ for( i = 0; i < nsamples; i++ )
+ mptr[i] = (uchar)(i < count);
+ trainSampleIdx.create(1, count, CV_32S);
+ testSampleIdx.create(1, nsamples - count, CV_32S);
+ int j0 = 0, j1 = 0;
+ const int* sptr = !sampleIdx.empty() ? sampleIdx.ptr<int>() : 0;
+ int* trainptr = trainSampleIdx.ptr<int>();
+ int* testptr = testSampleIdx.ptr<int>();
+ for( i = 0; i < nsamples; i++ )
{
- if ( var_types->data.ptr[b1] == CV_VAR_CATEGORICAL)
- CV_ERROR( CV_StsBadArg, "it`s impossible to assign CV_VAR_ORDERED type to categorical variable" );
- var_types->data.ptr[b1] = CV_VAR_ORDERED;
- set_var_type_count++;
- }
- else
- {
- if ( stopstring[0] == '-')
- {
- int b2 = (int)strtod( ord, &stopstring);
- if ( (*stopstring == 0) || (*stopstring != ',' && *stopstring != ']') )
- CV_ERROR( CV_StsBadArg, "types string is not correct" );
- ord = stopstring + 1;
- for (int i = b1; i <= b2; i++)
- {
- if ( var_types->data.ptr[i] == CV_VAR_CATEGORICAL)
- CV_ERROR( CV_StsBadArg, "it`s impossible to assign CV_VAR_ORDERED type to categorical variable" );
- var_types->data.ptr[i] = CV_VAR_ORDERED;
- }
- set_var_type_count += b2 - b1 + 1;
- }
+ int idx = sptr ? sptr[i] : i;
+ if( mptr[i] )
+ trainptr[j0++] = idx;
else
- CV_ERROR( CV_StsBadArg, "types string is not correct" );
-
+ testptr[j1++] = idx;
}
+ if( shuffle )
+ shuffleTrainTest();
}
- while (*stopstring != ']');
-
- if ( stopstring[1] != '\0' && stopstring[1] != ',')
- CV_ERROR( CV_StsBadArg, "types string is not correct" );
}
- if ( cat ) // parse cat str
+ void shuffleTrainTest()
{
- char* stopstring = NULL;
- if ( cat[3] != '[')
- CV_ERROR( CV_StsBadArg, "types string is not correct" );
-
- cat += 4; // pass "cat["
- do
+ if( !trainSampleIdx.empty() && !testSampleIdx.empty() )
{
- int b1 = (int)strtod( cat, &stopstring );
- if ( *stopstring == 0 || (*stopstring != ',' && *stopstring != ']' && *stopstring != '-') )
- CV_ERROR( CV_StsBadArg, "types string is not correct" );
- cat = stopstring + 1;
- if ( (stopstring[0] == ',') || (stopstring[0] == ']'))
- {
- var_types->data.ptr[b1] = CV_VAR_CATEGORICAL;
- set_var_type_count++;
- }
- else
+ int i, nsamples = getNSamples(), ntrain = getNTrainSamples(), ntest = getNTestSamples();
+ int* trainIdx = trainSampleIdx.ptr<int>();
+ int* testIdx = testSampleIdx.ptr<int>();
+ RNG& rng = theRNG();
+
+ for( i = 0; i < nsamples; i++)
{
- if ( stopstring[0] == '-')
+ int a = rng.uniform(0, nsamples);
+ int b = rng.uniform(0, nsamples);
+ int* ptra = trainIdx;
+ int* ptrb = trainIdx;
+ if( a >= ntrain )
{
- int b2 = (int)strtod( cat, &stopstring);
- if ( (*stopstring == 0) || (*stopstring != ',' && *stopstring != ']') )
- CV_ERROR( CV_StsBadArg, "types string is not correct" );
- cat = stopstring + 1;
- for (int i = b1; i <= b2; i++)
- var_types->data.ptr[i] = CV_VAR_CATEGORICAL;
- set_var_type_count += b2 - b1 + 1;
+ ptra = testIdx;
+ a -= ntrain;
+ CV_Assert( a < ntest );
}
- else
- CV_ERROR( CV_StsBadArg, "types string is not correct" );
-
+ if( b >= ntrain )
+ {
+ ptrb = testIdx;
+ b -= ntrain;
+ CV_Assert( b < ntest );
+ }
+ std::swap(ptra[a], ptrb[b]);
}
}
- while (*stopstring != ']');
-
- if ( stopstring[1] != '\0' && stopstring[1] != ',')
- CV_ERROR( CV_StsBadArg, "types string is not correct" );
- }
-
- if (set_var_type_count != var_count)
- CV_ERROR( CV_StsBadArg, "types string is not correct" );
-
- __END__;
-}
-
-const CvMat* CvMLData::get_var_types()
-{
- CV_FUNCNAME( "CvMLData::get_var_types" );
- __BEGIN__;
-
- uchar *var_types_out_ptr = 0;
- int avcount, vt_size;
- if ( !values )
- CV_ERROR( CV_StsInternal, "data is empty" );
-
- assert( var_idx_mask );
-
- avcount = cvFloor( cvNorm( var_idx_mask, 0, CV_L1 ) );
- vt_size = avcount + (response_idx >= 0);
-
- if ( avcount == values->cols || (avcount == values->cols-1 && response_idx == values->cols-1) )
- return var_types;
-
- if ( !var_types_out || ( var_types_out && var_types_out->cols != vt_size ) )
- {
- cvReleaseMat( &var_types_out );
- var_types_out = cvCreateMat( 1, vt_size, CV_8UC1 );
}
- var_types_out_ptr = var_types_out->data.ptr;
- for( int i = 0; i < var_types->cols; i++)
+ Mat getTrainSamples(int _layout,
+ bool compressSamples,
+ bool compressVars) const
{
- if (i == response_idx || !var_idx_mask->data.ptr[i]) continue;
- *var_types_out_ptr = var_types->data.ptr[i];
- var_types_out_ptr++;
- }
- if ( response_idx >= 0 )
- *var_types_out_ptr = var_types->data.ptr[response_idx];
-
- __END__;
-
- return var_types_out;
-}
-
-int CvMLData::get_var_type( int var_idx ) const
-{
- return var_types->data.ptr[var_idx];
-}
-
-const CvMat* CvMLData::get_responses()
-{
- CV_FUNCNAME( "CvMLData::get_responses_ptr" );
- __BEGIN__;
-
- int var_count = 0;
-
- if ( !values )
- CV_ERROR( CV_StsInternal, "data is empty" );
- var_count = values->cols;
-
- if ( response_idx < 0 || response_idx >= var_count )
- return 0;
- if ( !response_out )
- response_out = cvCreateMatHeader( values->rows, 1, CV_32FC1 );
- else
- cvInitMatHeader( response_out, values->rows, 1, CV_32FC1);
- cvGetCol( values, response_out, response_idx );
-
- __END__;
-
- return response_out;
-}
-
-void CvMLData::set_train_test_split( const CvTrainTestSplit * spl)
-{
- CV_FUNCNAME( "CvMLData::set_division" );
- __BEGIN__;
-
- int sample_count = 0;
+ if( samples.empty() )
+ return samples;
+
+ if( (!compressSamples || (trainSampleIdx.empty() && sampleIdx.empty())) &&
+ (!compressVars || varIdx.empty()) &&
+ layout == _layout )
+ return samples;
+
+ int drows = getNTrainSamples(), dcols = getNVars();
+ Mat sidx = getTrainSampleIdx(), vidx = getVarIdx();
+ const float* src0 = samples.ptr<float>();
+ const int* sptr = !sidx.empty() ? sidx.ptr<int>() : 0;
+ const int* vptr = !vidx.empty() ? vidx.ptr<int>() : 0;
+ size_t sstep0 = samples.step/samples.elemSize();
+ size_t sstep = layout == ROW_SAMPLE ? sstep0 : 1;
+ size_t vstep = layout == ROW_SAMPLE ? 1 : sstep0;
+
+ if( _layout == COL_SAMPLE )
+ {
+ std::swap(drows, dcols);
+ std::swap(sptr, vptr);
+ std::swap(sstep, vstep);
+ }
- if ( !values )
- CV_ERROR( CV_StsInternal, "data is empty" );
+ Mat dsamples(drows, dcols, CV_32F);
- sample_count = values->rows;
+ for( int i = 0; i < drows; i++ )
+ {
+ const float* src = src0 + (sptr ? sptr[i] : i)*sstep;
+ float* dst = dsamples.ptr<float>(i);
- float train_sample_portion;
+ for( int j = 0; j < dcols; j++ )
+ dst[j] = src[(vptr ? vptr[j] : j)*vstep];
+ }
- if (spl->train_sample_part_mode == CV_COUNT)
- {
- train_sample_count = spl->train_sample_part.count;
- if (train_sample_count > sample_count)
- CV_ERROR( CV_StsBadArg, "train samples count is not correct" );
- train_sample_count = train_sample_count<=0 ? sample_count : train_sample_count;
- }
- else // dtype.train_sample_part_mode == CV_PORTION
- {
- train_sample_portion = spl->train_sample_part.portion;
- if ( train_sample_portion > 1)
- CV_ERROR( CV_StsBadArg, "train samples count is not correct" );
- train_sample_portion = train_sample_portion <= FLT_EPSILON ||
- 1 - train_sample_portion <= FLT_EPSILON ? 1 : train_sample_portion;
- train_sample_count = std::max(1, cvFloor( train_sample_portion * sample_count ));
+ return dsamples;
}
- if ( train_sample_count == sample_count )
+ void getValues( int vi, InputArray _sidx, float* values ) const
{
- free_train_test_idx();
- return;
+ Mat sidx = _sidx.getMat();
+ int i, n, nsamples = getNSamples();
+ CV_Assert( 0 <= vi && vi < getNAllVars() );
+ CV_Assert( (n = sidx.checkVector(1, CV_32S)) >= 0 );
+ const int* s = n > 0 ? sidx.ptr<int>() : 0;
+ if( n == 0 )
+ n = nsamples;
+
+ size_t step = samples.step/samples.elemSize();
+ size_t sstep = layout == ROW_SAMPLE ? step : 1;
+ size_t vstep = layout == ROW_SAMPLE ? 1 : step;
+
+ const float* src = samples.ptr<float>() + vi*vstep;
+ float subst = missingSubst.at<float>(vi);
+ for( i = 0; i < n; i++ )
+ {
+ int j = i;
+ if( s )
+ {
+ j = s[i];
+ CV_DbgAssert( 0 <= j && j < nsamples );
+ }
+ values[i] = src[j*sstep];
+ if( values[i] == MISSED_VAL )
+ values[i] = subst;
+ }
}
- if ( train_sample_idx && train_sample_idx->cols != train_sample_count )
- free_train_test_idx();
-
- if ( !sample_idx)
+ void getNormCatValues( int vi, InputArray _sidx, int* values ) const
{
- int test_sample_count = sample_count- train_sample_count;
- sample_idx = (int*)cvAlloc( sample_count * sizeof(sample_idx[0]) );
- for (int i = 0; i < sample_count; i++ )
- sample_idx[i] = i;
- train_sample_idx = cvCreateMatHeader( 1, train_sample_count, CV_32SC1 );
- *train_sample_idx = cvMat( 1, train_sample_count, CV_32SC1, &sample_idx[0] );
-
- CV_Assert(test_sample_count > 0);
- test_sample_idx = cvCreateMatHeader( 1, test_sample_count, CV_32SC1 );
- *test_sample_idx = cvMat( 1, test_sample_count, CV_32SC1, &sample_idx[train_sample_count] );
- }
-
- mix = spl->mix;
- if ( mix )
- mix_train_and_test_idx();
-
- __END__;
-}
-
-const CvMat* CvMLData::get_train_sample_idx() const
-{
- CV_FUNCNAME( "CvMLData::get_train_sample_idx" );
- __BEGIN__;
-
- if ( !values )
- CV_ERROR( CV_StsInternal, "data is empty" );
- __END__;
-
- return train_sample_idx;
-}
+ float* fvalues = (float*)values;
+ getValues(vi, _sidx, fvalues);
+ int i, n = (int)_sidx.total();
+ Vec2i ofs = catOfs.at<Vec2i>(vi);
+ int m = ofs[1] - ofs[0];
-const CvMat* CvMLData::get_test_sample_idx() const
-{
- CV_FUNCNAME( "CvMLData::get_test_sample_idx" );
- __BEGIN__;
-
- if ( !values )
- CV_ERROR( CV_StsInternal, "data is empty" );
- __END__;
-
- return test_sample_idx;
-}
-
-void CvMLData::mix_train_and_test_idx()
-{
- CV_FUNCNAME( "CvMLData::mix_train_and_test_idx" );
- __BEGIN__;
+ CV_Assert( m > 0 ); // if m==0, vi is an ordered variable
+ const int* cmap = &catMap.at<int>(ofs[0]);
+ bool fastMap = (m == cmap[m] - cmap[0]);
- if ( !values )
- CV_ERROR( CV_StsInternal, "data is empty" );
- __END__;
-
- if ( !sample_idx)
- return;
-
- if ( train_sample_count > 0 && train_sample_count < values->rows )
- {
- int n = values->rows;
- for (int i = 0; i < n; i++)
+ if( fastMap )
{
- int a = (*rng)(n);
- int b = (*rng)(n);
- int t;
- CV_SWAP( sample_idx[a], sample_idx[b], t );
+ for( i = 0; i < n; i++ )
+ {
+ int val = cvRound(fvalues[i]);
+ int idx = val - cmap[0];
+ CV_Assert(cmap[idx] == val);
+ values[i] = idx;
+ }
}
- }
-}
-
-const CvMat* CvMLData::get_var_idx()
-{
- CV_FUNCNAME( "CvMLData::get_var_idx" );
- __BEGIN__;
-
- int avcount = 0;
-
- if ( !values )
- CV_ERROR( CV_StsInternal, "data is empty" );
-
- assert( var_idx_mask );
-
- avcount = cvFloor( cvNorm( var_idx_mask, 0, CV_L1 ) );
- int* vidx;
+ else
+ {
+ for( i = 0; i < n; i++ )
+ {
+ int val = cvRound(fvalues[i]);
+ int a = 0, b = m, c = -1;
- if ( avcount == values->cols )
- return 0;
+ while( a < b )
+ {
+ c = (a + b) >> 1;
+ if( val < cmap[c] )
+ b = c;
+ else if( val > cmap[c] )
+ a = c+1;
+ else
+ break;
+ }
- if ( !var_idx_out || ( var_idx_out && var_idx_out->cols != avcount ) )
- {
- cvReleaseMat( &var_idx_out );
- var_idx_out = cvCreateMat( 1, avcount, CV_32SC1);
- if ( response_idx >=0 )
- var_idx_mask->data.ptr[response_idx] = 0;
+ CV_DbgAssert( c >= 0 && val == cmap[c] );
+ values[i] = c;
+ }
+ }
}
- vidx = var_idx_out->data.i;
-
- for(int i = 0; i < var_idx_mask->cols; i++)
- if ( var_idx_mask->data.ptr[i] )
+ void getSample(InputArray _vidx, int sidx, float* buf) const
+ {
+ CV_Assert(buf != 0 && 0 <= sidx && sidx < getNSamples());
+ Mat vidx = _vidx.getMat();
+ int i, n, nvars = getNAllVars();
+ CV_Assert( (n = vidx.checkVector(1, CV_32S)) >= 0 );
+ const int* vptr = n > 0 ? vidx.ptr<int>() : 0;
+ if( n == 0 )
+ n = nvars;
+
+ size_t step = samples.step/samples.elemSize();
+ size_t sstep = layout == ROW_SAMPLE ? step : 1;
+ size_t vstep = layout == ROW_SAMPLE ? 1 : step;
+
+ const float* src = samples.ptr<float>() + sidx*sstep;
+ for( i = 0; i < n; i++ )
{
- *vidx = i;
- vidx++;
+ int j = i;
+ if( vptr )
+ {
+ j = vptr[i];
+ CV_DbgAssert( 0 <= j && j < nvars );
+ }
+ buf[i] = src[j*vstep];
}
+ }
- __END__;
-
- return var_idx_out;
-}
+ FILE* file;
+ int layout;
+ Mat samples, missing, varType, varIdx, responses, missingSubst;
+ Mat sampleIdx, trainSampleIdx, testSampleIdx;
+ Mat sampleWeights, catMap, catOfs;
+ Mat normCatResponses, classLabels, classCounters;
+ MapType nameMap;
+};
-void CvMLData::chahge_var_idx( int vi, bool state )
+Ptr<TrainData> TrainData::loadFromCSV(const String& filename,
+ int headerLines,
+ int responseStartIdx,
+ int responseEndIdx,
+ const String& varTypeSpec,
+ char delimiter, char missch)
{
- change_var_idx( vi, state );
+ Ptr<TrainDataImpl> td = makePtr<TrainDataImpl>();
+ if(!td->loadCSV(filename, headerLines, responseStartIdx, responseEndIdx, varTypeSpec, delimiter, missch))
+ td.release();
+ return td;
}
-void CvMLData::change_var_idx( int vi, bool state )
+Ptr<TrainData> TrainData::create(InputArray samples, int layout, InputArray responses,
+ InputArray varIdx, InputArray sampleIdx, InputArray sampleWeights,
+ InputArray varType)
{
- CV_FUNCNAME( "CvMLData::change_var_idx" );
- __BEGIN__;
-
- int var_count = 0;
-
- if ( !values )
- CV_ERROR( CV_StsInternal, "data is empty" );
-
- var_count = values->cols;
-
- if ( vi < 0 || vi >= var_count)
- CV_ERROR( CV_StsBadArg, "variable index is not correct" );
-
- assert( var_idx_mask );
- var_idx_mask->data.ptr[vi] = state;
-
- __END__;
+ Ptr<TrainDataImpl> td = makePtr<TrainDataImpl>();
+ td->setData(samples, layout, responses, varIdx, sampleIdx, sampleWeights, varType, noArray());
+ return td;
}
+}}
+
/* End of file. */
namespace cv
{
+namespace ml
+{
const double minEigenValue = DBL_EPSILON;
-///////////////////////////////////////////////////////////////////////////////////////////////////////
-
-EM::EM(int _nclusters, int _covMatType, const TermCriteria& _termCrit)
+EM::Params::Params(int _nclusters, int _covMatType, const TermCriteria& _termCrit)
{
nclusters = _nclusters;
covMatType = _covMatType;
- maxIters = (_termCrit.type & TermCriteria::MAX_ITER) ? _termCrit.maxCount : DEFAULT_MAX_ITERS;
- epsilon = (_termCrit.type & TermCriteria::EPS) ? _termCrit.epsilon : 0;
+ termCrit = _termCrit;
}
-EM::~EM()
+class CV_EXPORTS EMImpl : public EM
{
- //clear();
-}
+public:
+ EMImpl(const Params& _params)
+ {
+ setParams(_params);
+ }
-void EM::clear()
-{
- trainSamples.release();
- trainProbs.release();
- trainLogLikelihoods.release();
- trainLabels.release();
+ virtual ~EMImpl() {}
+
+ void setParams(const Params& _params)
+ {
+ params = _params;
+ CV_Assert(params.nclusters > 1);
+ CV_Assert(params.covMatType == COV_MAT_SPHERICAL ||
+ params.covMatType == COV_MAT_DIAGONAL ||
+ params.covMatType == COV_MAT_GENERIC);
+ }
+
+ Params getParams() const
+ {
+ return params;
+ }
- weights.release();
- means.release();
- covs.clear();
+ void clear()
+ {
+ trainSamples.release();
+ trainProbs.release();
+ trainLogLikelihoods.release();
+ trainLabels.release();
- covsEigenValues.clear();
- invCovsEigenValues.clear();
- covsRotateMats.clear();
+ weights.release();
+ means.release();
+ covs.clear();
- logWeightDivDet.release();
-}
+ covsEigenValues.clear();
+ invCovsEigenValues.clear();
+ covsRotateMats.clear();
+ logWeightDivDet.release();
+ }
-bool EM::train(InputArray samples,
+ bool train(const Ptr<TrainData>& data, int)
+ {
+ Mat samples = data->getTrainSamples(), labels;
+ return train_(samples, labels, noArray(), noArray());
+ }
+
+ bool train_(InputArray samples,
OutputArray logLikelihoods,
OutputArray labels,
OutputArray probs)
-{
- Mat samplesMat = samples.getMat();
- setTrainData(START_AUTO_STEP, samplesMat, 0, 0, 0, 0);
- return doTrain(START_AUTO_STEP, logLikelihoods, labels, probs);
-}
+ {
+ Mat samplesMat = samples.getMat();
+ setTrainData(START_AUTO_STEP, samplesMat, 0, 0, 0, 0);
+ return doTrain(START_AUTO_STEP, logLikelihoods, labels, probs);
+ }
-bool EM::trainE(InputArray samples,
+ bool trainE(InputArray samples,
InputArray _means0,
InputArray _covs0,
InputArray _weights0,
OutputArray logLikelihoods,
OutputArray labels,
OutputArray probs)
-{
- Mat samplesMat = samples.getMat();
- std::vector<Mat> covs0;
- _covs0.getMatVector(covs0);
+ {
+ Mat samplesMat = samples.getMat();
+ std::vector<Mat> covs0;
+ _covs0.getMatVector(covs0);
- Mat means0 = _means0.getMat(), weights0 = _weights0.getMat();
+ Mat means0 = _means0.getMat(), weights0 = _weights0.getMat();
- setTrainData(START_E_STEP, samplesMat, 0, !_means0.empty() ? &means0 : 0,
- !_covs0.empty() ? &covs0 : 0, !_weights0.empty() ? &weights0 : 0);
- return doTrain(START_E_STEP, logLikelihoods, labels, probs);
-}
+ setTrainData(START_E_STEP, samplesMat, 0, !_means0.empty() ? &means0 : 0,
+ !_covs0.empty() ? &covs0 : 0, !_weights0.empty() ? &weights0 : 0);
+ return doTrain(START_E_STEP, logLikelihoods, labels, probs);
+ }
-bool EM::trainM(InputArray samples,
+ bool trainM(InputArray samples,
InputArray _probs0,
OutputArray logLikelihoods,
OutputArray labels,
OutputArray probs)
-{
- Mat samplesMat = samples.getMat();
- Mat probs0 = _probs0.getMat();
-
- setTrainData(START_M_STEP, samplesMat, !_probs0.empty() ? &probs0 : 0, 0, 0, 0);
- return doTrain(START_M_STEP, logLikelihoods, labels, probs);
-}
-
-
-Vec2d EM::predict(InputArray _sample, OutputArray _probs) const
-{
- Mat sample = _sample.getMat();
- CV_Assert(isTrained());
-
- CV_Assert(!sample.empty());
- if(sample.type() != CV_64FC1)
{
- Mat tmp;
- sample.convertTo(tmp, CV_64FC1);
- sample = tmp;
- }
- sample = sample.reshape(1, 1);
+ Mat samplesMat = samples.getMat();
+ Mat probs0 = _probs0.getMat();
- Mat probs;
- if( _probs.needed() )
- {
- _probs.create(1, nclusters, CV_64FC1);
- probs = _probs.getMat();
+ setTrainData(START_M_STEP, samplesMat, !_probs0.empty() ? &probs0 : 0, 0, 0, 0);
+ return doTrain(START_M_STEP, logLikelihoods, labels, probs);
}
- return computeProbabilities(sample, !probs.empty() ? &probs : 0);
-}
-
-bool EM::isTrained() const
-{
- return !means.empty();
-}
+ float predict(InputArray _inputs, OutputArray _outputs, int) const
+ {
+ bool needprobs = _outputs.needed();
+ Mat samples = _inputs.getMat(), probs, probsrow;
+ int ptype = CV_32F;
+ float firstres = 0.f;
+ int i, nsamples = samples.rows;
+ if( needprobs )
+ {
+ if( _outputs.fixedType() )
+ ptype = _outputs.type();
+ _outputs.create(samples.rows, params.nclusters, ptype);
+ }
+ else
+ nsamples = std::min(nsamples, 1);
-static
-void checkTrainData(int startStep, const Mat& samples,
- int nclusters, int covMatType, const Mat* probs, const Mat* means,
- const std::vector<Mat>* covs, const Mat* weights)
-{
- // Check samples.
- CV_Assert(!samples.empty());
- CV_Assert(samples.channels() == 1);
-
- int nsamples = samples.rows;
- int dim = samples.cols;
-
- // Check training params.
- CV_Assert(nclusters > 0);
- CV_Assert(nclusters <= nsamples);
- CV_Assert(startStep == EM::START_AUTO_STEP ||
- startStep == EM::START_E_STEP ||
- startStep == EM::START_M_STEP);
- CV_Assert(covMatType == EM::COV_MAT_GENERIC ||
- covMatType == EM::COV_MAT_DIAGONAL ||
- covMatType == EM::COV_MAT_SPHERICAL);
-
- CV_Assert(!probs ||
- (!probs->empty() &&
- probs->rows == nsamples && probs->cols == nclusters &&
- (probs->type() == CV_32FC1 || probs->type() == CV_64FC1)));
-
- CV_Assert(!weights ||
- (!weights->empty() &&
- (weights->cols == 1 || weights->rows == 1) && static_cast<int>(weights->total()) == nclusters &&
- (weights->type() == CV_32FC1 || weights->type() == CV_64FC1)));
-
- CV_Assert(!means ||
- (!means->empty() &&
- means->rows == nclusters && means->cols == dim &&
- means->channels() == 1));
-
- CV_Assert(!covs ||
- (!covs->empty() &&
- static_cast<int>(covs->size()) == nclusters));
- if(covs)
- {
- const Size covSize(dim, dim);
- for(size_t i = 0; i < covs->size(); i++)
+ for( i = 0; i < nsamples; i++ )
{
- const Mat& m = (*covs)[i];
- CV_Assert(!m.empty() && m.size() == covSize && (m.channels() == 1));
+ if( needprobs )
+ probsrow = probs.row(i);
+ Vec2d res = computeProbabilities(samples.row(i), needprobs ? &probsrow : 0, ptype);
+ if( i == 0 )
+ firstres = (float)res[1];
}
+ return firstres;
}
- if(startStep == EM::START_E_STEP)
- {
- CV_Assert(means);
- }
- else if(startStep == EM::START_M_STEP)
+ Vec2d predict2(InputArray _sample, OutputArray _probs) const
{
- CV_Assert(probs);
- }
-}
-
-static
-void preprocessSampleData(const Mat& src, Mat& dst, int dstType, bool isAlwaysClone)
-{
- if(src.type() == dstType && !isAlwaysClone)
- dst = src;
- else
- src.convertTo(dst, dstType);
-}
+ int ptype = CV_32F;
+ Mat sample = _sample.getMat();
+ CV_Assert(isTrained());
-static
-void preprocessProbability(Mat& probs)
-{
- max(probs, 0., probs);
+ CV_Assert(!sample.empty());
+ if(sample.type() != CV_64FC1)
+ {
+ Mat tmp;
+ sample.convertTo(tmp, CV_64FC1);
+ sample = tmp;
+ }
+ sample.reshape(1, 1);
- const double uniformProbability = (double)(1./probs.cols);
- for(int y = 0; y < probs.rows; y++)
- {
- Mat sampleProbs = probs.row(y);
+ Mat probs;
+ if( _probs.needed() )
+ {
+ if( _probs.fixedType() )
+ ptype = _probs.type();
+ _probs.create(1, params.nclusters, ptype);
+ probs = _probs.getMat();
+ }
- double maxVal = 0;
- minMaxLoc(sampleProbs, 0, &maxVal);
- if(maxVal < FLT_EPSILON)
- sampleProbs.setTo(uniformProbability);
- else
- normalize(sampleProbs, sampleProbs, 1, 0, NORM_L1);
+ return computeProbabilities(sample, !probs.empty() ? &probs : 0, ptype);
}
-}
-void EM::setTrainData(int startStep, const Mat& samples,
- const Mat* probs0,
- const Mat* means0,
- const std::vector<Mat>* covs0,
- const Mat* weights0)
-{
- clear();
-
- checkTrainData(startStep, samples, nclusters, covMatType, probs0, means0, covs0, weights0);
-
- bool isKMeansInit = (startStep == EM::START_AUTO_STEP) || (startStep == EM::START_E_STEP && (covs0 == 0 || weights0 == 0));
- // Set checked data
- preprocessSampleData(samples, trainSamples, isKMeansInit ? CV_32FC1 : CV_64FC1, false);
-
- // set probs
- if(probs0 && startStep == EM::START_M_STEP)
+ bool isTrained() const
{
- preprocessSampleData(*probs0, trainProbs, CV_64FC1, true);
- preprocessProbability(trainProbs);
+ return !means.empty();
}
- // set weights
- if(weights0 && (startStep == EM::START_E_STEP && covs0))
+ bool isClassifier() const
{
- weights0->convertTo(weights, CV_64FC1);
- weights = weights.reshape(1,1);
- preprocessProbability(weights);
+ return true;
}
- // set means
- if(means0 && (startStep == EM::START_E_STEP/* || startStep == EM::START_AUTO_STEP*/))
- means0->convertTo(means, isKMeansInit ? CV_32FC1 : CV_64FC1);
-
- // set covs
- if(covs0 && (startStep == EM::START_E_STEP && weights0))
+ int getVarCount() const
{
- covs.resize(nclusters);
- for(size_t i = 0; i < covs0->size(); i++)
- (*covs0)[i].convertTo(covs[i], CV_64FC1);
+ return means.cols;
}
-}
-void EM::decomposeCovs()
-{
- CV_Assert(!covs.empty());
- covsEigenValues.resize(nclusters);
- if(covMatType == EM::COV_MAT_GENERIC)
- covsRotateMats.resize(nclusters);
- invCovsEigenValues.resize(nclusters);
- for(int clusterIndex = 0; clusterIndex < nclusters; clusterIndex++)
+ String getDefaultModelName() const
{
- CV_Assert(!covs[clusterIndex].empty());
-
- SVD svd(covs[clusterIndex], SVD::MODIFY_A + SVD::FULL_UV);
+ return "opencv_ml_em";
+ }
- if(covMatType == EM::COV_MAT_SPHERICAL)
+ static void checkTrainData(int startStep, const Mat& samples,
+ int nclusters, int covMatType, const Mat* probs, const Mat* means,
+ const std::vector<Mat>* covs, const Mat* weights)
+ {
+ // Check samples.
+ CV_Assert(!samples.empty());
+ CV_Assert(samples.channels() == 1);
+
+ int nsamples = samples.rows;
+ int dim = samples.cols;
+
+ // Check training params.
+ CV_Assert(nclusters > 0);
+ CV_Assert(nclusters <= nsamples);
+ CV_Assert(startStep == START_AUTO_STEP ||
+ startStep == START_E_STEP ||
+ startStep == START_M_STEP);
+ CV_Assert(covMatType == COV_MAT_GENERIC ||
+ covMatType == COV_MAT_DIAGONAL ||
+ covMatType == COV_MAT_SPHERICAL);
+
+ CV_Assert(!probs ||
+ (!probs->empty() &&
+ probs->rows == nsamples && probs->cols == nclusters &&
+ (probs->type() == CV_32FC1 || probs->type() == CV_64FC1)));
+
+ CV_Assert(!weights ||
+ (!weights->empty() &&
+ (weights->cols == 1 || weights->rows == 1) && static_cast<int>(weights->total()) == nclusters &&
+ (weights->type() == CV_32FC1 || weights->type() == CV_64FC1)));
+
+ CV_Assert(!means ||
+ (!means->empty() &&
+ means->rows == nclusters && means->cols == dim &&
+ means->channels() == 1));
+
+ CV_Assert(!covs ||
+ (!covs->empty() &&
+ static_cast<int>(covs->size()) == nclusters));
+ if(covs)
{
- double maxSingularVal = svd.w.at<double>(0);
- covsEigenValues[clusterIndex] = Mat(1, 1, CV_64FC1, Scalar(maxSingularVal));
+ const Size covSize(dim, dim);
+ for(size_t i = 0; i < covs->size(); i++)
+ {
+ const Mat& m = (*covs)[i];
+ CV_Assert(!m.empty() && m.size() == covSize && (m.channels() == 1));
+ }
}
- else if(covMatType == EM::COV_MAT_DIAGONAL)
+
+ if(startStep == START_E_STEP)
{
- covsEigenValues[clusterIndex] = svd.w;
+ CV_Assert(means);
}
- else //EM::COV_MAT_GENERIC
+ else if(startStep == START_M_STEP)
{
- covsEigenValues[clusterIndex] = svd.w;
- covsRotateMats[clusterIndex] = svd.u;
+ CV_Assert(probs);
}
- max(covsEigenValues[clusterIndex], minEigenValue, covsEigenValues[clusterIndex]);
- invCovsEigenValues[clusterIndex] = 1./covsEigenValues[clusterIndex];
}
-}
-
-void EM::clusterTrainSamples()
-{
- int nsamples = trainSamples.rows;
-
- // Cluster samples, compute/update means
- // Convert samples and means to 32F, because kmeans requires this type.
- Mat trainSamplesFlt, meansFlt;
- if(trainSamples.type() != CV_32FC1)
- trainSamples.convertTo(trainSamplesFlt, CV_32FC1);
- else
- trainSamplesFlt = trainSamples;
- if(!means.empty())
+ static void preprocessSampleData(const Mat& src, Mat& dst, int dstType, bool isAlwaysClone)
{
- if(means.type() != CV_32FC1)
- means.convertTo(meansFlt, CV_32FC1);
+ if(src.type() == dstType && !isAlwaysClone)
+ dst = src;
else
- meansFlt = means;
+ src.convertTo(dst, dstType);
}
- Mat labels;
- kmeans(trainSamplesFlt, nclusters, labels, TermCriteria(TermCriteria::COUNT, means.empty() ? 10 : 1, 0.5), 10, KMEANS_PP_CENTERS, meansFlt);
-
- // Convert samples and means back to 64F.
- CV_Assert(meansFlt.type() == CV_32FC1);
- if(trainSamples.type() != CV_64FC1)
+ static void preprocessProbability(Mat& probs)
{
- Mat trainSamplesBuffer;
- trainSamplesFlt.convertTo(trainSamplesBuffer, CV_64FC1);
- trainSamples = trainSamplesBuffer;
- }
- meansFlt.convertTo(means, CV_64FC1);
+ max(probs, 0., probs);
- // Compute weights and covs
- weights = Mat(1, nclusters, CV_64FC1, Scalar(0));
- covs.resize(nclusters);
- for(int clusterIndex = 0; clusterIndex < nclusters; clusterIndex++)
- {
- Mat clusterSamples;
- for(int sampleIndex = 0; sampleIndex < nsamples; sampleIndex++)
+ const double uniformProbability = (double)(1./probs.cols);
+ for(int y = 0; y < probs.rows; y++)
{
- if(labels.at<int>(sampleIndex) == clusterIndex)
- {
- const Mat sample = trainSamples.row(sampleIndex);
- clusterSamples.push_back(sample);
- }
- }
- CV_Assert(!clusterSamples.empty());
+ Mat sampleProbs = probs.row(y);
- calcCovarMatrix(clusterSamples, covs[clusterIndex], means.row(clusterIndex),
- CV_COVAR_NORMAL + CV_COVAR_ROWS + CV_COVAR_USE_AVG + CV_COVAR_SCALE, CV_64FC1);
- weights.at<double>(clusterIndex) = static_cast<double>(clusterSamples.rows)/static_cast<double>(nsamples);
+ double maxVal = 0;
+ minMaxLoc(sampleProbs, 0, &maxVal);
+ if(maxVal < FLT_EPSILON)
+ sampleProbs.setTo(uniformProbability);
+ else
+ normalize(sampleProbs, sampleProbs, 1, 0, NORM_L1);
+ }
}
- decomposeCovs();
-}
+ void setTrainData(int startStep, const Mat& samples,
+ const Mat* probs0,
+ const Mat* means0,
+ const std::vector<Mat>* covs0,
+ const Mat* weights0)
+ {
+ int nclusters = params.nclusters, covMatType = params.covMatType;
+ clear();
-void EM::computeLogWeightDivDet()
-{
- CV_Assert(!covsEigenValues.empty());
+ checkTrainData(startStep, samples, nclusters, covMatType, probs0, means0, covs0, weights0);
- Mat logWeights;
- cv::max(weights, DBL_MIN, weights);
- log(weights, logWeights);
+ bool isKMeansInit = (startStep == START_AUTO_STEP) || (startStep == START_E_STEP && (covs0 == 0 || weights0 == 0));
+ // Set checked data
+ preprocessSampleData(samples, trainSamples, isKMeansInit ? CV_32FC1 : CV_64FC1, false);
- logWeightDivDet.create(1, nclusters, CV_64FC1);
- // note: logWeightDivDet = log(weight_k) - 0.5 * log(|det(cov_k)|)
+ // set probs
+ if(probs0 && startStep == START_M_STEP)
+ {
+ preprocessSampleData(*probs0, trainProbs, CV_64FC1, true);
+ preprocessProbability(trainProbs);
+ }
- for(int clusterIndex = 0; clusterIndex < nclusters; clusterIndex++)
- {
- double logDetCov = 0.;
- const int evalCount = static_cast<int>(covsEigenValues[clusterIndex].total());
- for(int di = 0; di < evalCount; di++)
- logDetCov += std::log(covsEigenValues[clusterIndex].at<double>(covMatType != EM::COV_MAT_SPHERICAL ? di : 0));
+ // set weights
+ if(weights0 && (startStep == START_E_STEP && covs0))
+ {
+ weights0->convertTo(weights, CV_64FC1);
+ weights.reshape(1,1);
+ preprocessProbability(weights);
+ }
- logWeightDivDet.at<double>(clusterIndex) = logWeights.at<double>(clusterIndex) - 0.5 * logDetCov;
+ // set means
+ if(means0 && (startStep == START_E_STEP/* || startStep == START_AUTO_STEP*/))
+ means0->convertTo(means, isKMeansInit ? CV_32FC1 : CV_64FC1);
+
+ // set covs
+ if(covs0 && (startStep == START_E_STEP && weights0))
+ {
+ covs.resize(nclusters);
+ for(size_t i = 0; i < covs0->size(); i++)
+ (*covs0)[i].convertTo(covs[i], CV_64FC1);
+ }
}
-}
-bool EM::doTrain(int startStep, OutputArray logLikelihoods, OutputArray labels, OutputArray probs)
-{
- int dim = trainSamples.cols;
- // Precompute the empty initial train data in the cases of EM::START_E_STEP and START_AUTO_STEP
- if(startStep != EM::START_M_STEP)
+ void decomposeCovs()
{
- if(covs.empty())
+ int nclusters = params.nclusters, covMatType = params.covMatType;
+ CV_Assert(!covs.empty());
+ covsEigenValues.resize(nclusters);
+ if(covMatType == COV_MAT_GENERIC)
+ covsRotateMats.resize(nclusters);
+ invCovsEigenValues.resize(nclusters);
+ for(int clusterIndex = 0; clusterIndex < nclusters; clusterIndex++)
{
- CV_Assert(weights.empty());
- clusterTrainSamples();
+ CV_Assert(!covs[clusterIndex].empty());
+
+ SVD svd(covs[clusterIndex], SVD::MODIFY_A + SVD::FULL_UV);
+
+ if(covMatType == COV_MAT_SPHERICAL)
+ {
+ double maxSingularVal = svd.w.at<double>(0);
+ covsEigenValues[clusterIndex] = Mat(1, 1, CV_64FC1, Scalar(maxSingularVal));
+ }
+ else if(covMatType == COV_MAT_DIAGONAL)
+ {
+ covsEigenValues[clusterIndex] = svd.w;
+ }
+ else //COV_MAT_GENERIC
+ {
+ covsEigenValues[clusterIndex] = svd.w;
+ covsRotateMats[clusterIndex] = svd.u;
+ }
+ max(covsEigenValues[clusterIndex], minEigenValue, covsEigenValues[clusterIndex]);
+ invCovsEigenValues[clusterIndex] = 1./covsEigenValues[clusterIndex];
}
}
- if(!covs.empty() && covsEigenValues.empty() )
+ void clusterTrainSamples()
{
- CV_Assert(invCovsEigenValues.empty());
- decomposeCovs();
- }
+ int nclusters = params.nclusters;
+ int nsamples = trainSamples.rows;
- if(startStep == EM::START_M_STEP)
- mStep();
+ // Cluster samples, compute/update means
- double trainLogLikelihood, prevTrainLogLikelihood = 0.;
- for(int iter = 0; ; iter++)
- {
- eStep();
- trainLogLikelihood = sum(trainLogLikelihoods)[0];
+ // Convert samples and means to 32F, because kmeans requires this type.
+ Mat trainSamplesFlt, meansFlt;
+ if(trainSamples.type() != CV_32FC1)
+ trainSamples.convertTo(trainSamplesFlt, CV_32FC1);
+ else
+ trainSamplesFlt = trainSamples;
+ if(!means.empty())
+ {
+ if(means.type() != CV_32FC1)
+ means.convertTo(meansFlt, CV_32FC1);
+ else
+ meansFlt = means;
+ }
+
+ Mat labels;
+ kmeans(trainSamplesFlt, nclusters, labels,
+ TermCriteria(TermCriteria::COUNT, means.empty() ? 10 : 1, 0.5),
+ 10, KMEANS_PP_CENTERS, meansFlt);
- if(iter >= maxIters - 1)
- break;
+ // Convert samples and means back to 64F.
+ CV_Assert(meansFlt.type() == CV_32FC1);
+ if(trainSamples.type() != CV_64FC1)
+ {
+ Mat trainSamplesBuffer;
+ trainSamplesFlt.convertTo(trainSamplesBuffer, CV_64FC1);
+ trainSamples = trainSamplesBuffer;
+ }
+ meansFlt.convertTo(means, CV_64FC1);
- double trainLogLikelihoodDelta = trainLogLikelihood - prevTrainLogLikelihood;
- if( iter != 0 &&
- (trainLogLikelihoodDelta < -DBL_EPSILON ||
- trainLogLikelihoodDelta < epsilon * std::fabs(trainLogLikelihood)))
- break;
+ // Compute weights and covs
+ weights = Mat(1, nclusters, CV_64FC1, Scalar(0));
+ covs.resize(nclusters);
+ for(int clusterIndex = 0; clusterIndex < nclusters; clusterIndex++)
+ {
+ Mat clusterSamples;
+ for(int sampleIndex = 0; sampleIndex < nsamples; sampleIndex++)
+ {
+ if(labels.at<int>(sampleIndex) == clusterIndex)
+ {
+ const Mat sample = trainSamples.row(sampleIndex);
+ clusterSamples.push_back(sample);
+ }
+ }
+ CV_Assert(!clusterSamples.empty());
- mStep();
+ calcCovarMatrix(clusterSamples, covs[clusterIndex], means.row(clusterIndex),
+ CV_COVAR_NORMAL + CV_COVAR_ROWS + CV_COVAR_USE_AVG + CV_COVAR_SCALE, CV_64FC1);
+ weights.at<double>(clusterIndex) = static_cast<double>(clusterSamples.rows)/static_cast<double>(nsamples);
+ }
- prevTrainLogLikelihood = trainLogLikelihood;
+ decomposeCovs();
}
- if( trainLogLikelihood <= -DBL_MAX/10000. )
+ void computeLogWeightDivDet()
{
- clear();
- return false;
+ int nclusters = params.nclusters;
+ CV_Assert(!covsEigenValues.empty());
+
+ Mat logWeights;
+ cv::max(weights, DBL_MIN, weights);
+ log(weights, logWeights);
+
+ logWeightDivDet.create(1, nclusters, CV_64FC1);
+ // note: logWeightDivDet = log(weight_k) - 0.5 * log(|det(cov_k)|)
+
+ for(int clusterIndex = 0; clusterIndex < nclusters; clusterIndex++)
+ {
+ double logDetCov = 0.;
+ const int evalCount = static_cast<int>(covsEigenValues[clusterIndex].total());
+ for(int di = 0; di < evalCount; di++)
+ logDetCov += std::log(covsEigenValues[clusterIndex].at<double>(params.covMatType != COV_MAT_SPHERICAL ? di : 0));
+
+ logWeightDivDet.at<double>(clusterIndex) = logWeights.at<double>(clusterIndex) - 0.5 * logDetCov;
+ }
}
- // postprocess covs
- covs.resize(nclusters);
- for(int clusterIndex = 0; clusterIndex < nclusters; clusterIndex++)
+ bool doTrain(int startStep, OutputArray logLikelihoods, OutputArray labels, OutputArray probs)
{
- if(covMatType == EM::COV_MAT_SPHERICAL)
+ int nclusters = params.nclusters;
+ int dim = trainSamples.cols;
+ // Precompute the empty initial train data in the cases of START_E_STEP and START_AUTO_STEP
+ if(startStep != START_M_STEP)
{
- covs[clusterIndex].create(dim, dim, CV_64FC1);
- setIdentity(covs[clusterIndex], Scalar(covsEigenValues[clusterIndex].at<double>(0)));
+ if(covs.empty())
+ {
+ CV_Assert(weights.empty());
+ clusterTrainSamples();
+ }
}
- else if(covMatType == EM::COV_MAT_DIAGONAL)
+
+ if(!covs.empty() && covsEigenValues.empty() )
{
- covs[clusterIndex] = Mat::diag(covsEigenValues[clusterIndex]);
+ CV_Assert(invCovsEigenValues.empty());
+ decomposeCovs();
}
- }
- if(labels.needed())
- trainLabels.copyTo(labels);
- if(probs.needed())
- trainProbs.copyTo(probs);
- if(logLikelihoods.needed())
- trainLogLikelihoods.copyTo(logLikelihoods);
+ if(startStep == START_M_STEP)
+ mStep();
- trainSamples.release();
- trainProbs.release();
- trainLabels.release();
- trainLogLikelihoods.release();
+ double trainLogLikelihood, prevTrainLogLikelihood = 0.;
+ int maxIters = (params.termCrit.type & TermCriteria::MAX_ITER) ?
+ params.termCrit.maxCount : DEFAULT_MAX_ITERS;
+ double epsilon = (params.termCrit.type & TermCriteria::EPS) ? params.termCrit.epsilon : 0.;
- return true;
-}
+ for(int iter = 0; ; iter++)
+ {
+ eStep();
+ trainLogLikelihood = sum(trainLogLikelihoods)[0];
-Vec2d EM::computeProbabilities(const Mat& sample, Mat* probs) const
-{
- // L_ik = log(weight_k) - 0.5 * log(|det(cov_k)|) - 0.5 *(x_i - mean_k)' cov_k^(-1) (x_i - mean_k)]
- // q = arg(max_k(L_ik))
- // probs_ik = exp(L_ik - L_iq) / (1 + sum_j!=q (exp(L_ij - L_iq))
- // see Alex Smola's blog http://blog.smola.org/page/2 for
- // details on the log-sum-exp trick
-
- CV_Assert(!means.empty());
- CV_Assert(sample.type() == CV_64FC1);
- CV_Assert(sample.rows == 1);
- CV_Assert(sample.cols == means.cols);
-
- int dim = sample.cols;
-
- Mat L(1, nclusters, CV_64FC1);
- int label = 0;
- for(int clusterIndex = 0; clusterIndex < nclusters; clusterIndex++)
- {
- const Mat centeredSample = sample - means.row(clusterIndex);
+ if(iter >= maxIters - 1)
+ break;
+
+ double trainLogLikelihoodDelta = trainLogLikelihood - prevTrainLogLikelihood;
+ if( iter != 0 &&
+ (trainLogLikelihoodDelta < -DBL_EPSILON ||
+ trainLogLikelihoodDelta < epsilon * std::fabs(trainLogLikelihood)))
+ break;
- Mat rotatedCenteredSample = covMatType != EM::COV_MAT_GENERIC ?
- centeredSample : centeredSample * covsRotateMats[clusterIndex];
+ mStep();
- double Lval = 0;
- for(int di = 0; di < dim; di++)
+ prevTrainLogLikelihood = trainLogLikelihood;
+ }
+
+ if( trainLogLikelihood <= -DBL_MAX/10000. )
{
- double w = invCovsEigenValues[clusterIndex].at<double>(covMatType != EM::COV_MAT_SPHERICAL ? di : 0);
- double val = rotatedCenteredSample.at<double>(di);
- Lval += w * val * val;
+ clear();
+ return false;
}
- CV_DbgAssert(!logWeightDivDet.empty());
- L.at<double>(clusterIndex) = logWeightDivDet.at<double>(clusterIndex) - 0.5 * Lval;
- if(L.at<double>(clusterIndex) > L.at<double>(label))
- label = clusterIndex;
- }
+ // postprocess covs
+ covs.resize(nclusters);
+ for(int clusterIndex = 0; clusterIndex < nclusters; clusterIndex++)
+ {
+ if(params.covMatType == COV_MAT_SPHERICAL)
+ {
+ covs[clusterIndex].create(dim, dim, CV_64FC1);
+ setIdentity(covs[clusterIndex], Scalar(covsEigenValues[clusterIndex].at<double>(0)));
+ }
+ else if(params.covMatType == COV_MAT_DIAGONAL)
+ {
+ covs[clusterIndex] = Mat::diag(covsEigenValues[clusterIndex]);
+ }
+ }
- double maxLVal = L.at<double>(label);
- Mat expL_Lmax = L; // exp(L_ij - L_iq)
- for(int i = 0; i < L.cols; i++)
- expL_Lmax.at<double>(i) = std::exp(L.at<double>(i) - maxLVal);
- double expDiffSum = sum(expL_Lmax)[0]; // sum_j(exp(L_ij - L_iq))
+ if(labels.needed())
+ trainLabels.copyTo(labels);
+ if(probs.needed())
+ trainProbs.copyTo(probs);
+ if(logLikelihoods.needed())
+ trainLogLikelihoods.copyTo(logLikelihoods);
- if(probs)
- {
- probs->create(1, nclusters, CV_64FC1);
- double factor = 1./expDiffSum;
- expL_Lmax *= factor;
- expL_Lmax.copyTo(*probs);
- }
+ trainSamples.release();
+ trainProbs.release();
+ trainLabels.release();
+ trainLogLikelihoods.release();
- Vec2d res;
- res[0] = std::log(expDiffSum) + maxLVal - 0.5 * dim * CV_LOG2PI;
- res[1] = label;
+ return true;
+ }
- return res;
-}
+ Vec2d computeProbabilities(const Mat& sample, Mat* probs, int ptype) const
+ {
+ // L_ik = log(weight_k) - 0.5 * log(|det(cov_k)|) - 0.5 *(x_i - mean_k)' cov_k^(-1) (x_i - mean_k)]
+ // q = arg(max_k(L_ik))
+ // probs_ik = exp(L_ik - L_iq) / (1 + sum_j!=q (exp(L_ij - L_iq))
+ // see Alex Smola's blog http://blog.smola.org/page/2 for
+ // details on the log-sum-exp trick
+
+ int nclusters = params.nclusters, covMatType = params.covMatType;
+ int stype = sample.type();
+ CV_Assert(!means.empty());
+ CV_Assert((stype == CV_32F || stype == CV_64F) && (ptype == CV_32F || ptype == CV_64F));
+ CV_Assert(sample.size() == Size(means.cols, 1));
+
+ int dim = sample.cols;
+
+ Mat L(1, nclusters, CV_64FC1), centeredSample(1, dim, CV_64F);
+ int i, label = 0;
+ for(int clusterIndex = 0; clusterIndex < nclusters; clusterIndex++)
+ {
+ const double* mptr = means.ptr<double>(clusterIndex);
+ double* dptr = centeredSample.ptr<double>();
+ if( stype == CV_32F )
+ {
+ const float* sptr = sample.ptr<float>();
+ for( i = 0; i < dim; i++ )
+ dptr[i] = sptr[i] - mptr[i];
+ }
+ else
+ {
+ const double* sptr = sample.ptr<double>();
+ for( i = 0; i < dim; i++ )
+ dptr[i] = sptr[i] - mptr[i];
+ }
-void EM::eStep()
-{
- // Compute probs_ik from means_k, covs_k and weights_k.
- trainProbs.create(trainSamples.rows, nclusters, CV_64FC1);
- trainLabels.create(trainSamples.rows, 1, CV_32SC1);
- trainLogLikelihoods.create(trainSamples.rows, 1, CV_64FC1);
+ Mat rotatedCenteredSample = covMatType != COV_MAT_GENERIC ?
+ centeredSample : centeredSample * covsRotateMats[clusterIndex];
- computeLogWeightDivDet();
+ double Lval = 0;
+ for(int di = 0; di < dim; di++)
+ {
+ double w = invCovsEigenValues[clusterIndex].at<double>(covMatType != COV_MAT_SPHERICAL ? di : 0);
+ double val = rotatedCenteredSample.at<double>(di);
+ Lval += w * val * val;
+ }
+ CV_DbgAssert(!logWeightDivDet.empty());
+ L.at<double>(clusterIndex) = logWeightDivDet.at<double>(clusterIndex) - 0.5 * Lval;
- CV_DbgAssert(trainSamples.type() == CV_64FC1);
- CV_DbgAssert(means.type() == CV_64FC1);
+ if(L.at<double>(clusterIndex) > L.at<double>(label))
+ label = clusterIndex;
+ }
- for(int sampleIndex = 0; sampleIndex < trainSamples.rows; sampleIndex++)
- {
- Mat sampleProbs = trainProbs.row(sampleIndex);
- Vec2d res = computeProbabilities(trainSamples.row(sampleIndex), &sampleProbs);
- trainLogLikelihoods.at<double>(sampleIndex) = res[0];
- trainLabels.at<int>(sampleIndex) = static_cast<int>(res[1]);
- }
-}
+ double maxLVal = L.at<double>(label);
+ double expDiffSum = 0;
+ for( i = 0; i < L.cols; i++ )
+ {
+ double v = std::exp(L.at<double>(i) - maxLVal);
+ L.at<double>(i) = v;
+ expDiffSum += v; // sum_j(exp(L_ij - L_iq))
+ }
-void EM::mStep()
-{
- // Update means_k, covs_k and weights_k from probs_ik
- int dim = trainSamples.cols;
+ if(probs)
+ L.convertTo(*probs, ptype, 1./expDiffSum);
- // Update weights
- // not normalized first
- reduce(trainProbs, weights, 0, CV_REDUCE_SUM);
+ Vec2d res;
+ res[0] = std::log(expDiffSum) + maxLVal - 0.5 * dim * CV_LOG2PI;
+ res[1] = label;
- // Update means
- means.create(nclusters, dim, CV_64FC1);
- means = Scalar(0);
+ return res;
+ }
- const double minPosWeight = trainSamples.rows * DBL_EPSILON;
- double minWeight = DBL_MAX;
- int minWeightClusterIndex = -1;
- for(int clusterIndex = 0; clusterIndex < nclusters; clusterIndex++)
+ void eStep()
{
- if(weights.at<double>(clusterIndex) <= minPosWeight)
- continue;
+ // Compute probs_ik from means_k, covs_k and weights_k.
+ trainProbs.create(trainSamples.rows, params.nclusters, CV_64FC1);
+ trainLabels.create(trainSamples.rows, 1, CV_32SC1);
+ trainLogLikelihoods.create(trainSamples.rows, 1, CV_64FC1);
- if(weights.at<double>(clusterIndex) < minWeight)
- {
- minWeight = weights.at<double>(clusterIndex);
- minWeightClusterIndex = clusterIndex;
- }
+ computeLogWeightDivDet();
+
+ CV_DbgAssert(trainSamples.type() == CV_64FC1);
+ CV_DbgAssert(means.type() == CV_64FC1);
- Mat clusterMean = means.row(clusterIndex);
for(int sampleIndex = 0; sampleIndex < trainSamples.rows; sampleIndex++)
- clusterMean += trainProbs.at<double>(sampleIndex, clusterIndex) * trainSamples.row(sampleIndex);
- clusterMean /= weights.at<double>(clusterIndex);
+ {
+ Mat sampleProbs = trainProbs.row(sampleIndex);
+ Vec2d res = computeProbabilities(trainSamples.row(sampleIndex), &sampleProbs, CV_64F);
+ trainLogLikelihoods.at<double>(sampleIndex) = res[0];
+ trainLabels.at<int>(sampleIndex) = static_cast<int>(res[1]);
+ }
}
- // Update covsEigenValues and invCovsEigenValues
- covs.resize(nclusters);
- covsEigenValues.resize(nclusters);
- if(covMatType == EM::COV_MAT_GENERIC)
- covsRotateMats.resize(nclusters);
- invCovsEigenValues.resize(nclusters);
- for(int clusterIndex = 0; clusterIndex < nclusters; clusterIndex++)
+ void mStep()
{
- if(weights.at<double>(clusterIndex) <= minPosWeight)
- continue;
-
- if(covMatType != EM::COV_MAT_SPHERICAL)
- covsEigenValues[clusterIndex].create(1, dim, CV_64FC1);
- else
- covsEigenValues[clusterIndex].create(1, 1, CV_64FC1);
-
- if(covMatType == EM::COV_MAT_GENERIC)
- covs[clusterIndex].create(dim, dim, CV_64FC1);
+ // Update means_k, covs_k and weights_k from probs_ik
+ int nclusters = params.nclusters;
+ int covMatType = params.covMatType;
+ int dim = trainSamples.cols;
+
+ // Update weights
+ // not normalized first
+ reduce(trainProbs, weights, 0, CV_REDUCE_SUM);
+
+ // Update means
+ means.create(nclusters, dim, CV_64FC1);
+ means = Scalar(0);
+
+ const double minPosWeight = trainSamples.rows * DBL_EPSILON;
+ double minWeight = DBL_MAX;
+ int minWeightClusterIndex = -1;
+ for(int clusterIndex = 0; clusterIndex < nclusters; clusterIndex++)
+ {
+ if(weights.at<double>(clusterIndex) <= minPosWeight)
+ continue;
- Mat clusterCov = covMatType != EM::COV_MAT_GENERIC ?
- covsEigenValues[clusterIndex] : covs[clusterIndex];
+ if(weights.at<double>(clusterIndex) < minWeight)
+ {
+ minWeight = weights.at<double>(clusterIndex);
+ minWeightClusterIndex = clusterIndex;
+ }
- clusterCov = Scalar(0);
+ Mat clusterMean = means.row(clusterIndex);
+ for(int sampleIndex = 0; sampleIndex < trainSamples.rows; sampleIndex++)
+ clusterMean += trainProbs.at<double>(sampleIndex, clusterIndex) * trainSamples.row(sampleIndex);
+ clusterMean /= weights.at<double>(clusterIndex);
+ }
- Mat centeredSample;
- for(int sampleIndex = 0; sampleIndex < trainSamples.rows; sampleIndex++)
+ // Update covsEigenValues and invCovsEigenValues
+ covs.resize(nclusters);
+ covsEigenValues.resize(nclusters);
+ if(covMatType == COV_MAT_GENERIC)
+ covsRotateMats.resize(nclusters);
+ invCovsEigenValues.resize(nclusters);
+ for(int clusterIndex = 0; clusterIndex < nclusters; clusterIndex++)
{
- centeredSample = trainSamples.row(sampleIndex) - means.row(clusterIndex);
+ if(weights.at<double>(clusterIndex) <= minPosWeight)
+ continue;
- if(covMatType == EM::COV_MAT_GENERIC)
- clusterCov += trainProbs.at<double>(sampleIndex, clusterIndex) * centeredSample.t() * centeredSample;
+ if(covMatType != COV_MAT_SPHERICAL)
+ covsEigenValues[clusterIndex].create(1, dim, CV_64FC1);
else
+ covsEigenValues[clusterIndex].create(1, 1, CV_64FC1);
+
+ if(covMatType == COV_MAT_GENERIC)
+ covs[clusterIndex].create(dim, dim, CV_64FC1);
+
+ Mat clusterCov = covMatType != COV_MAT_GENERIC ?
+ covsEigenValues[clusterIndex] : covs[clusterIndex];
+
+ clusterCov = Scalar(0);
+
+ Mat centeredSample;
+ for(int sampleIndex = 0; sampleIndex < trainSamples.rows; sampleIndex++)
{
- double p = trainProbs.at<double>(sampleIndex, clusterIndex);
- for(int di = 0; di < dim; di++ )
+ centeredSample = trainSamples.row(sampleIndex) - means.row(clusterIndex);
+
+ if(covMatType == COV_MAT_GENERIC)
+ clusterCov += trainProbs.at<double>(sampleIndex, clusterIndex) * centeredSample.t() * centeredSample;
+ else
{
- double val = centeredSample.at<double>(di);
- clusterCov.at<double>(covMatType != EM::COV_MAT_SPHERICAL ? di : 0) += p*val*val;
+ double p = trainProbs.at<double>(sampleIndex, clusterIndex);
+ for(int di = 0; di < dim; di++ )
+ {
+ double val = centeredSample.at<double>(di);
+ clusterCov.at<double>(covMatType != COV_MAT_SPHERICAL ? di : 0) += p*val*val;
+ }
}
}
- }
- if(covMatType == EM::COV_MAT_SPHERICAL)
- clusterCov /= dim;
+ if(covMatType == COV_MAT_SPHERICAL)
+ clusterCov /= dim;
+
+ clusterCov /= weights.at<double>(clusterIndex);
+
+ // Update covsRotateMats for COV_MAT_GENERIC only
+ if(covMatType == COV_MAT_GENERIC)
+ {
+ SVD svd(covs[clusterIndex], SVD::MODIFY_A + SVD::FULL_UV);
+ covsEigenValues[clusterIndex] = svd.w;
+ covsRotateMats[clusterIndex] = svd.u;
+ }
- clusterCov /= weights.at<double>(clusterIndex);
+ max(covsEigenValues[clusterIndex], minEigenValue, covsEigenValues[clusterIndex]);
- // Update covsRotateMats for EM::COV_MAT_GENERIC only
- if(covMatType == EM::COV_MAT_GENERIC)
+ // update invCovsEigenValues
+ invCovsEigenValues[clusterIndex] = 1./covsEigenValues[clusterIndex];
+ }
+
+ for(int clusterIndex = 0; clusterIndex < nclusters; clusterIndex++)
{
- SVD svd(covs[clusterIndex], SVD::MODIFY_A + SVD::FULL_UV);
- covsEigenValues[clusterIndex] = svd.w;
- covsRotateMats[clusterIndex] = svd.u;
+ if(weights.at<double>(clusterIndex) <= minPosWeight)
+ {
+ Mat clusterMean = means.row(clusterIndex);
+ means.row(minWeightClusterIndex).copyTo(clusterMean);
+ covs[minWeightClusterIndex].copyTo(covs[clusterIndex]);
+ covsEigenValues[minWeightClusterIndex].copyTo(covsEigenValues[clusterIndex]);
+ if(covMatType == COV_MAT_GENERIC)
+ covsRotateMats[minWeightClusterIndex].copyTo(covsRotateMats[clusterIndex]);
+ invCovsEigenValues[minWeightClusterIndex].copyTo(invCovsEigenValues[clusterIndex]);
+ }
}
- max(covsEigenValues[clusterIndex], minEigenValue, covsEigenValues[clusterIndex]);
+ // Normalize weights
+ weights /= trainSamples.rows;
+ }
- // update invCovsEigenValues
- invCovsEigenValues[clusterIndex] = 1./covsEigenValues[clusterIndex];
+ void write_params(FileStorage& fs) const
+ {
+ fs << "nclusters" << params.nclusters;
+ fs << "cov_mat_type" << (params.covMatType == COV_MAT_SPHERICAL ? String("spherical") :
+ params.covMatType == COV_MAT_DIAGONAL ? String("diagonal") :
+ params.covMatType == COV_MAT_GENERIC ? String("generic") :
+ format("unknown_%d", params.covMatType));
+ writeTermCrit(fs, params.termCrit);
}
- for(int clusterIndex = 0; clusterIndex < nclusters; clusterIndex++)
+ void write(FileStorage& fs) const
{
- if(weights.at<double>(clusterIndex) <= minPosWeight)
- {
- Mat clusterMean = means.row(clusterIndex);
- means.row(minWeightClusterIndex).copyTo(clusterMean);
- covs[minWeightClusterIndex].copyTo(covs[clusterIndex]);
- covsEigenValues[minWeightClusterIndex].copyTo(covsEigenValues[clusterIndex]);
- if(covMatType == EM::COV_MAT_GENERIC)
- covsRotateMats[minWeightClusterIndex].copyTo(covsRotateMats[clusterIndex]);
- invCovsEigenValues[minWeightClusterIndex].copyTo(invCovsEigenValues[clusterIndex]);
- }
+ fs << "training_params" << "{";
+ write_params(fs);
+ fs << "}";
+ fs << "weights" << weights;
+ fs << "means" << means;
+
+ size_t i, n = covs.size();
+
+ fs << "covs" << "[";
+ for( i = 0; i < n; i++ )
+ fs << covs[i];
+ fs << "]";
+ }
+
+ void read_params(const FileNode& fn)
+ {
+ Params _params;
+ _params.nclusters = (int)fn["nclusters"];
+ String s = (String)fn["cov_mat_type"];
+ _params.covMatType = s == "spherical" ? COV_MAT_SPHERICAL :
+ s == "diagonal" ? COV_MAT_DIAGONAL :
+ s == "generic" ? COV_MAT_GENERIC : -1;
+ CV_Assert(_params.covMatType >= 0);
+ _params.termCrit = readTermCrit(fn);
+ setParams(_params);
+ }
+
+ void read(const FileNode& fn)
+ {
+ clear();
+ read_params(fn["training_params"]);
+
+ fn["weights"] >> weights;
+ fn["means"] >> means;
+
+ FileNode cfn = fn["covs"];
+ FileNodeIterator cfn_it = cfn.begin();
+ int i, n = (int)cfn.size();
+ covs.resize(n);
+
+ for( i = 0; i < n; i++, ++cfn_it )
+ (*cfn_it) >> covs[i];
+
+ decomposeCovs();
+ computeLogWeightDivDet();
}
- // Normalize weights
- weights /= trainSamples.rows;
+ Mat getWeights() const { return weights; }
+ Mat getMeans() const { return means; }
+ void getCovs(std::vector<Mat>& _covs) const
+ {
+ _covs.resize(covs.size());
+ std::copy(covs.begin(), covs.end(), _covs.begin());
+ }
+
+ Params params;
+
+ // all inner matrices have type CV_64FC1
+ Mat trainSamples;
+ Mat trainProbs;
+ Mat trainLogLikelihoods;
+ Mat trainLabels;
+
+ Mat weights;
+ Mat means;
+ std::vector<Mat> covs;
+
+ std::vector<Mat> covsEigenValues;
+ std::vector<Mat> covsRotateMats;
+ std::vector<Mat> invCovsEigenValues;
+ Mat logWeightDivDet;
+};
+
+
+Ptr<EM> EM::train(InputArray samples, OutputArray logLikelihoods,
+ OutputArray labels, OutputArray probs,
+ const EM::Params& params)
+{
+ Ptr<EMImpl> em = makePtr<EMImpl>(params);
+ if(!em->train_(samples, logLikelihoods, labels, probs))
+ em.release();
+ return em;
}
-void EM::read(const FileNode& fn)
+Ptr<EM> EM::train_startWithE(InputArray samples, InputArray means0,
+ InputArray covs0, InputArray weights0,
+ OutputArray logLikelihoods, OutputArray labels,
+ OutputArray probs, const EM::Params& params)
{
- Algorithm::read(fn);
+ Ptr<EMImpl> em = makePtr<EMImpl>(params);
+ if(!em->trainE(samples, means0, covs0, weights0, logLikelihoods, labels, probs))
+ em.release();
+ return em;
+}
- decomposeCovs();
- computeLogWeightDivDet();
+Ptr<EM> EM::train_startWithM(InputArray samples, InputArray probs0,
+ OutputArray logLikelihoods, OutputArray labels,
+ OutputArray probs, const EM::Params& params)
+{
+ Ptr<EMImpl> em = makePtr<EMImpl>(params);
+ if(!em->trainM(samples, probs0, logLikelihoods, labels, probs))
+ em.release();
+ return em;
}
+Ptr<EM> EM::create(const Params& params)
+{
+ return makePtr<EMImpl>(params);
+}
+
+}
} // namespace cv
/* End of file. */
+++ /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*/
-
-#include "precomp.hpp"
-
-static const float ord_nan = FLT_MAX*0.5f;
-static const int min_block_size = 1 << 16;
-static const int block_size_delta = 1 << 10;
-
-template<typename T>
-class LessThanPtr
-{
-public:
- bool operator()(T* a, T* b) const { return *a < *b; }
-};
-
-class LessThanPairs
-{
-public:
- bool operator()(const CvPair16u32s& a, const CvPair16u32s& b) const { return *a.i < *b.i; }
-};
-
-void CvERTreeTrainData::set_data( const CvMat* _train_data, int _tflag,
- const CvMat* _responses, const CvMat* _var_idx, const CvMat* _sample_idx,
- const CvMat* _var_type, const CvMat* _missing_mask, const CvDTreeParams& _params,
- bool _shared, bool _add_labels, bool _update_data )
-{
- CvMat* sample_indices = 0;
- CvMat* var_type0 = 0;
- CvMat* tmp_map = 0;
- int** int_ptr = 0;
- CvPair16u32s* pair16u32s_ptr = 0;
- CvDTreeTrainData* data = 0;
- float *_fdst = 0;
- int *_idst = 0;
- unsigned short* udst = 0;
- int* idst = 0;
-
- CV_FUNCNAME( "CvERTreeTrainData::set_data" );
-
- __BEGIN__;
-
- int sample_all = 0, r_type, cv_n;
- int total_c_count = 0;
- int tree_block_size, temp_block_size, max_split_size, nv_size, cv_size = 0;
- int ds_step, dv_step, ms_step = 0, mv_step = 0; // {data|mask}{sample|var}_step
- int vi, i, size;
- char err[100];
- const int *sidx = 0, *vidx = 0;
-
- uint64 effective_buf_size = 0;
- int effective_buf_height = 0, effective_buf_width = 0;
-
- if ( _params.use_surrogates )
- CV_ERROR(CV_StsBadArg, "CvERTrees do not support surrogate splits");
-
- if( _update_data && data_root )
- {
- CV_ERROR(CV_StsBadArg, "CvERTrees do not support data update");
- }
-
- clear();
-
- var_all = 0;
- rng = &cv::theRNG();
-
- CV_CALL( set_params( _params ));
-
- // check parameter types and sizes
- CV_CALL( cvCheckTrainData( _train_data, _tflag, _missing_mask, &var_all, &sample_all ));
-
- train_data = _train_data;
- responses = _responses;
- missing_mask = _missing_mask;
-
- if( _tflag == CV_ROW_SAMPLE )
- {
- ds_step = _train_data->step/CV_ELEM_SIZE(_train_data->type);
- dv_step = 1;
- if( _missing_mask )
- ms_step = _missing_mask->step, mv_step = 1;
- }
- else
- {
- dv_step = _train_data->step/CV_ELEM_SIZE(_train_data->type);
- ds_step = 1;
- if( _missing_mask )
- mv_step = _missing_mask->step, ms_step = 1;
- }
- tflag = _tflag;
-
- sample_count = sample_all;
- var_count = var_all;
-
- if( _sample_idx )
- {
- CV_CALL( sample_indices = cvPreprocessIndexArray( _sample_idx, sample_all ));
- sidx = sample_indices->data.i;
- sample_count = sample_indices->rows + sample_indices->cols - 1;
- }
-
- if( _var_idx )
- {
- CV_CALL( var_idx = cvPreprocessIndexArray( _var_idx, var_all ));
- vidx = var_idx->data.i;
- var_count = var_idx->rows + var_idx->cols - 1;
- }
-
- if( !CV_IS_MAT(_responses) ||
- (CV_MAT_TYPE(_responses->type) != CV_32SC1 &&
- CV_MAT_TYPE(_responses->type) != CV_32FC1) ||
- (_responses->rows != 1 && _responses->cols != 1) ||
- _responses->rows + _responses->cols - 1 != sample_all )
- CV_ERROR( CV_StsBadArg, "The array of _responses must be an integer or "
- "floating-point vector containing as many elements as "
- "the total number of samples in the training data matrix" );
-
- is_buf_16u = false;
- if ( sample_count < 65536 )
- is_buf_16u = true;
-
- r_type = CV_VAR_CATEGORICAL;
- if( _var_type )
- CV_CALL( var_type0 = cvPreprocessVarType( _var_type, var_idx, var_count, &r_type ));
-
- CV_CALL( var_type = cvCreateMat( 1, var_count+2, CV_32SC1 ));
-
- cat_var_count = 0;
- ord_var_count = -1;
-
- is_classifier = r_type == CV_VAR_CATEGORICAL;
-
- // step 0. calc the number of categorical vars
- for( vi = 0; vi < var_count; vi++ )
- {
- char vt = var_type0 ? var_type0->data.ptr[vi] : CV_VAR_ORDERED;
- var_type->data.i[vi] = vt == CV_VAR_CATEGORICAL ? cat_var_count++ : ord_var_count--;
- }
-
- ord_var_count = ~ord_var_count;
- cv_n = params.cv_folds;
- // set the two last elements of var_type array to be able
- // to locate responses and cross-validation labels using
- // the corresponding get_* functions.
- var_type->data.i[var_count] = cat_var_count;
- var_type->data.i[var_count+1] = cat_var_count+1;
-
- // in case of single ordered predictor we need dummy cv_labels
- // for safe split_node_data() operation
- have_labels = cv_n > 0 || (ord_var_count == 1 && cat_var_count == 0) || _add_labels;
-
- work_var_count = cat_var_count + (is_classifier ? 1 : 0) + (have_labels ? 1 : 0);
-
- shared = _shared;
- buf_count = shared ? 2 : 1;
-
- buf_size = -1; // the member buf_size is obsolete
-
- effective_buf_size = (uint64)(work_var_count + 1)*(uint64)sample_count * buf_count; // this is the total size of "CvMat buf" to be allocated
- effective_buf_width = sample_count;
- effective_buf_height = work_var_count+1;
-
- if (effective_buf_width >= effective_buf_height)
- effective_buf_height *= buf_count;
- else
- effective_buf_width *= buf_count;
-
- if ((uint64)effective_buf_width * (uint64)effective_buf_height != effective_buf_size)
- {
- CV_Error(CV_StsBadArg, "The memory buffer cannot be allocated since its size exceeds integer fields limit");
- }
-
- if ( is_buf_16u )
- {
- CV_CALL( buf = cvCreateMat( effective_buf_height, effective_buf_width, CV_16UC1 ));
- CV_CALL( pair16u32s_ptr = (CvPair16u32s*)cvAlloc( sample_count*sizeof(pair16u32s_ptr[0]) ));
- }
- else
- {
- CV_CALL( buf = cvCreateMat( effective_buf_height, effective_buf_width, CV_32SC1 ));
- CV_CALL( int_ptr = (int**)cvAlloc( sample_count*sizeof(int_ptr[0]) ));
- }
-
- size = is_classifier ? cat_var_count+1 : cat_var_count;
- size = !size ? 1 : size;
- CV_CALL( cat_count = cvCreateMat( 1, size, CV_32SC1 ));
- CV_CALL( cat_ofs = cvCreateMat( 1, size, CV_32SC1 ));
-
- size = is_classifier ? (cat_var_count + 1)*params.max_categories : cat_var_count*params.max_categories;
- size = !size ? 1 : size;
- CV_CALL( cat_map = cvCreateMat( 1, size, CV_32SC1 ));
-
- // now calculate the maximum size of split,
- // create memory storage that will keep nodes and splits of the decision tree
- // allocate root node and the buffer for the whole training data
- max_split_size = cvAlign(sizeof(CvDTreeSplit) +
- (MAX(0,sample_count - 33)/32)*sizeof(int),sizeof(void*));
- tree_block_size = MAX((int)sizeof(CvDTreeNode)*8, max_split_size);
- tree_block_size = MAX(tree_block_size + block_size_delta, min_block_size);
- CV_CALL( tree_storage = cvCreateMemStorage( tree_block_size ));
- CV_CALL( node_heap = cvCreateSet( 0, sizeof(*node_heap), sizeof(CvDTreeNode), tree_storage ));
-
- nv_size = var_count*sizeof(int);
- nv_size = cvAlign(MAX( nv_size, (int)sizeof(CvSetElem) ), sizeof(void*));
-
- temp_block_size = nv_size;
-
- if( cv_n )
- {
- if( sample_count < cv_n*MAX(params.min_sample_count,10) )
- CV_ERROR( CV_StsOutOfRange,
- "The many folds in cross-validation for such a small dataset" );
-
- cv_size = cvAlign( cv_n*(sizeof(int) + sizeof(double)*2), sizeof(double) );
- temp_block_size = MAX(temp_block_size, cv_size);
- }
-
- temp_block_size = MAX( temp_block_size + block_size_delta, min_block_size );
- CV_CALL( temp_storage = cvCreateMemStorage( temp_block_size ));
- CV_CALL( nv_heap = cvCreateSet( 0, sizeof(*nv_heap), nv_size, temp_storage ));
- if( cv_size )
- CV_CALL( cv_heap = cvCreateSet( 0, sizeof(*cv_heap), cv_size, temp_storage ));
-
- CV_CALL( data_root = new_node( 0, sample_count, 0, 0 ));
-
- max_c_count = 1;
-
- _fdst = 0;
- _idst = 0;
- if (ord_var_count)
- _fdst = (float*)cvAlloc(sample_count*sizeof(_fdst[0]));
- if (is_buf_16u && (cat_var_count || is_classifier))
- _idst = (int*)cvAlloc(sample_count*sizeof(_idst[0]));
-
- // transform the training data to convenient representation
- for( vi = 0; vi <= var_count; vi++ )
- {
- int ci;
- const uchar* mask = 0;
- int m_step = 0, step;
- const int* idata = 0;
- const float* fdata = 0;
- int num_valid = 0;
-
- if( vi < var_count ) // analyze i-th input variable
- {
- int vi0 = vidx ? vidx[vi] : vi;
- ci = get_var_type(vi);
- step = ds_step; m_step = ms_step;
- if( CV_MAT_TYPE(_train_data->type) == CV_32SC1 )
- idata = _train_data->data.i + vi0*dv_step;
- else
- fdata = _train_data->data.fl + vi0*dv_step;
- if( _missing_mask )
- mask = _missing_mask->data.ptr + vi0*mv_step;
- }
- else // analyze _responses
- {
- ci = cat_var_count;
- step = CV_IS_MAT_CONT(_responses->type) ?
- 1 : _responses->step / CV_ELEM_SIZE(_responses->type);
- if( CV_MAT_TYPE(_responses->type) == CV_32SC1 )
- idata = _responses->data.i;
- else
- fdata = _responses->data.fl;
- }
-
- if( (vi < var_count && ci>=0) ||
- (vi == var_count && is_classifier) ) // process categorical variable or response
- {
- int c_count, prev_label;
- int* c_map;
-
- if (is_buf_16u)
- udst = (unsigned short*)(buf->data.s + ci*sample_count);
- else
- idst = buf->data.i + ci*sample_count;
-
- // copy data
- for( i = 0; i < sample_count; i++ )
- {
- int val = INT_MAX, si = sidx ? sidx[i] : i;
- if( !mask || !mask[(size_t)si*m_step] )
- {
- if( idata )
- val = idata[(size_t)si*step];
- else
- {
- float t = fdata[(size_t)si*step];
- val = cvRound(t);
- if( val != t )
- {
- sprintf( err, "%d-th value of %d-th (categorical) "
- "variable is not an integer", i, vi );
- CV_ERROR( CV_StsBadArg, err );
- }
- }
-
- if( val == INT_MAX )
- {
- sprintf( err, "%d-th value of %d-th (categorical) "
- "variable is too large", i, vi );
- CV_ERROR( CV_StsBadArg, err );
- }
- num_valid++;
- }
- if (is_buf_16u)
- {
- _idst[i] = val;
- pair16u32s_ptr[i].u = udst + i;
- pair16u32s_ptr[i].i = _idst + i;
- }
- else
- {
- idst[i] = val;
- int_ptr[i] = idst + i;
- }
- }
-
- c_count = num_valid > 0;
-
- if (is_buf_16u)
- {
- std::sort(pair16u32s_ptr, pair16u32s_ptr + sample_count, LessThanPairs());
- // count the categories
- for( i = 1; i < num_valid; i++ )
- if (*pair16u32s_ptr[i].i != *pair16u32s_ptr[i-1].i)
- c_count ++ ;
- }
- else
- {
- std::sort(int_ptr, int_ptr + sample_count, LessThanPtr<int>());
- // count the categories
- for( i = 1; i < num_valid; i++ )
- c_count += *int_ptr[i] != *int_ptr[i-1];
- }
-
- if( vi > 0 )
- max_c_count = MAX( max_c_count, c_count );
- cat_count->data.i[ci] = c_count;
- cat_ofs->data.i[ci] = total_c_count;
-
- // resize cat_map, if need
- if( cat_map->cols < total_c_count + c_count )
- {
- tmp_map = cat_map;
- CV_CALL( cat_map = cvCreateMat( 1,
- MAX(cat_map->cols*3/2,total_c_count+c_count), CV_32SC1 ));
- for( i = 0; i < total_c_count; i++ )
- cat_map->data.i[i] = tmp_map->data.i[i];
- cvReleaseMat( &tmp_map );
- }
-
- c_map = cat_map->data.i + total_c_count;
- total_c_count += c_count;
-
- c_count = -1;
- if (is_buf_16u)
- {
- // compact the class indices and build the map
- prev_label = ~*pair16u32s_ptr[0].i;
- for( i = 0; i < num_valid; i++ )
- {
- int cur_label = *pair16u32s_ptr[i].i;
- if( cur_label != prev_label )
- c_map[++c_count] = prev_label = cur_label;
- *pair16u32s_ptr[i].u = (unsigned short)c_count;
- }
- // replace labels for missing values with 65535
- for( ; i < sample_count; i++ )
- *pair16u32s_ptr[i].u = 65535;
- }
- else
- {
- // compact the class indices and build the map
- prev_label = ~*int_ptr[0];
- for( i = 0; i < num_valid; i++ )
- {
- int cur_label = *int_ptr[i];
- if( cur_label != prev_label )
- c_map[++c_count] = prev_label = cur_label;
- *int_ptr[i] = c_count;
- }
- // replace labels for missing values with -1
- for( ; i < sample_count; i++ )
- *int_ptr[i] = -1;
- }
- }
- else if( ci < 0 ) // process ordered variable
- {
- for( i = 0; i < sample_count; i++ )
- {
- float val = ord_nan;
- int si = sidx ? sidx[i] : i;
- if( !mask || !mask[(size_t)si*m_step] )
- {
- if( idata )
- val = (float)idata[(size_t)si*step];
- else
- val = fdata[(size_t)si*step];
-
- if( fabs(val) >= ord_nan )
- {
- sprintf( err, "%d-th value of %d-th (ordered) "
- "variable (=%g) is too large", i, vi, val );
- CV_ERROR( CV_StsBadArg, err );
- }
- num_valid++;
- }
- }
- }
- if( vi < var_count )
- data_root->set_num_valid(vi, num_valid);
- }
-
- // set sample labels
- if (is_buf_16u)
- udst = (unsigned short*)(buf->data.s + get_work_var_count()*sample_count);
- else
- idst = buf->data.i + get_work_var_count()*sample_count;
-
- for (i = 0; i < sample_count; i++)
- {
- if (udst)
- udst[i] = sidx ? (unsigned short)sidx[i] : (unsigned short)i;
- else
- idst[i] = sidx ? sidx[i] : i;
- }
-
- if( cv_n )
- {
- unsigned short* usdst = 0;
- int* idst2 = 0;
-
- if (is_buf_16u)
- {
- usdst = (unsigned short*)(buf->data.s + (get_work_var_count()-1)*sample_count);
- for( i = vi = 0; i < sample_count; i++ )
- {
- usdst[i] = (unsigned short)vi++;
- vi &= vi < cv_n ? -1 : 0;
- }
-
- for( i = 0; i < sample_count; i++ )
- {
- int a = (*rng)(sample_count);
- int b = (*rng)(sample_count);
- unsigned short unsh = (unsigned short)vi;
- CV_SWAP( usdst[a], usdst[b], unsh );
- }
- }
- else
- {
- idst2 = buf->data.i + (get_work_var_count()-1)*sample_count;
- for( i = vi = 0; i < sample_count; i++ )
- {
- idst2[i] = vi++;
- vi &= vi < cv_n ? -1 : 0;
- }
-
- for( i = 0; i < sample_count; i++ )
- {
- int a = (*rng)(sample_count);
- int b = (*rng)(sample_count);
- CV_SWAP( idst2[a], idst2[b], vi );
- }
- }
- }
-
- if ( cat_map )
- cat_map->cols = MAX( total_c_count, 1 );
-
- max_split_size = cvAlign(sizeof(CvDTreeSplit) +
- (MAX(0,max_c_count - 33)/32)*sizeof(int),sizeof(void*));
- CV_CALL( split_heap = cvCreateSet( 0, sizeof(*split_heap), max_split_size, tree_storage ));
-
- have_priors = is_classifier && params.priors;
- if( is_classifier )
- {
- int m = get_num_classes();
- double sum = 0;
- CV_CALL( priors = cvCreateMat( 1, m, CV_64F ));
- for( i = 0; i < m; i++ )
- {
- double val = have_priors ? params.priors[i] : 1.;
- if( val <= 0 )
- CV_ERROR( CV_StsOutOfRange, "Every class weight should be positive" );
- priors->data.db[i] = val;
- sum += val;
- }
-
- // normalize weights
- if( have_priors )
- cvScale( priors, priors, 1./sum );
-
- CV_CALL( priors_mult = cvCloneMat( priors ));
- CV_CALL( counts = cvCreateMat( 1, m, CV_32SC1 ));
- }
-
- CV_CALL( direction = cvCreateMat( 1, sample_count, CV_8UC1 ));
- CV_CALL( split_buf = cvCreateMat( 1, sample_count, CV_32SC1 ));
-
- __END__;
-
- if( data )
- delete data;
-
- if (_fdst)
- cvFree( &_fdst );
- if (_idst)
- cvFree( &_idst );
- cvFree( &int_ptr );
- cvReleaseMat( &var_type0 );
- cvReleaseMat( &sample_indices );
- cvReleaseMat( &tmp_map );
-}
-
-void CvERTreeTrainData::get_ord_var_data( CvDTreeNode* n, int vi, float* ord_values_buf, int* missing_buf,
- const float** ord_values, const int** missing, int* sample_indices_buf )
-{
- int vidx = var_idx ? var_idx->data.i[vi] : vi;
- int node_sample_count = n->sample_count;
- // may use missing_buf as buffer for sample indices!
- const int* sample_indices = get_sample_indices(n, sample_indices_buf ? sample_indices_buf : missing_buf);
-
- int td_step = train_data->step/CV_ELEM_SIZE(train_data->type);
- int m_step = missing_mask ? missing_mask->step/CV_ELEM_SIZE(missing_mask->type) : 1;
- if( tflag == CV_ROW_SAMPLE )
- {
- for( int i = 0; i < node_sample_count; i++ )
- {
- int idx = sample_indices[i];
- missing_buf[i] = missing_mask ? *(missing_mask->data.ptr + idx * m_step + vi) : 0;
- ord_values_buf[i] = *(train_data->data.fl + idx * td_step + vidx);
- }
- }
- else
- for( int i = 0; i < node_sample_count; i++ )
- {
- int idx = sample_indices[i];
- missing_buf[i] = missing_mask ? *(missing_mask->data.ptr + vi* m_step + idx) : 0;
- ord_values_buf[i] = *(train_data->data.fl + vidx* td_step + idx);
- }
- *ord_values = ord_values_buf;
- *missing = missing_buf;
-}
-
-
-const int* CvERTreeTrainData::get_sample_indices( CvDTreeNode* n, int* indices_buf )
-{
- return get_cat_var_data( n, var_count + (is_classifier ? 1 : 0) + (have_labels ? 1 : 0), indices_buf );
-}
-
-
-const int* CvERTreeTrainData::get_cv_labels( CvDTreeNode* n, int* labels_buf )
-{
- if (have_labels)
- return get_cat_var_data( n, var_count + (is_classifier ? 1 : 0), labels_buf );
- return 0;
-}
-
-
-const int* CvERTreeTrainData::get_cat_var_data( CvDTreeNode* n, int vi, int* cat_values_buf )
-{
- int ci = get_var_type( vi);
- const int* cat_values = 0;
- if( !is_buf_16u )
- cat_values = buf->data.i + n->buf_idx*get_length_subbuf() + ci*sample_count + n->offset;
- else {
- const unsigned short* short_values = (const unsigned short*)(buf->data.s + n->buf_idx*get_length_subbuf() +
- ci*sample_count + n->offset);
- for( int i = 0; i < n->sample_count; i++ )
- cat_values_buf[i] = short_values[i];
- cat_values = cat_values_buf;
- }
- return cat_values;
-}
-
-void CvERTreeTrainData::get_vectors( const CvMat* _subsample_idx,
- float* values, uchar* missing,
- float* _responses, bool get_class_idx )
-{
- CvMat* subsample_idx = 0;
- CvMat* subsample_co = 0;
-
- cv::AutoBuffer<uchar> inn_buf(sample_count*(sizeof(float) + sizeof(int)));
-
- CV_FUNCNAME( "CvERTreeTrainData::get_vectors" );
-
- __BEGIN__;
-
- int i, vi, total = sample_count, count = total, cur_ofs = 0;
- int* sidx = 0;
- int* co = 0;
-
- if( _subsample_idx )
- {
- CV_CALL( subsample_idx = cvPreprocessIndexArray( _subsample_idx, sample_count ));
- sidx = subsample_idx->data.i;
- CV_CALL( subsample_co = cvCreateMat( 1, sample_count*2, CV_32SC1 ));
- co = subsample_co->data.i;
- cvZero( subsample_co );
- count = subsample_idx->cols + subsample_idx->rows - 1;
- for( i = 0; i < count; i++ )
- co[sidx[i]*2]++;
- for( i = 0; i < total; i++ )
- {
- int count_i = co[i*2];
- if( count_i )
- {
- co[i*2+1] = cur_ofs*var_count;
- cur_ofs += count_i;
- }
- }
- }
-
- if( missing )
- memset( missing, 1, count*var_count );
-
- for( vi = 0; vi < var_count; vi++ )
- {
- int ci = get_var_type(vi);
- if( ci >= 0 ) // categorical
- {
- float* dst = values + vi;
- uchar* m = missing ? missing + vi : 0;
- int* lbls_buf = (int*)(uchar*)inn_buf;
- const int* src = get_cat_var_data(data_root, vi, lbls_buf);
-
- for( i = 0; i < count; i++, dst += var_count )
- {
- int idx = sidx ? sidx[i] : i;
- int val = src[idx];
- *dst = (float)val;
- if( m )
- {
- *m = (!is_buf_16u && val < 0) || (is_buf_16u && (val == 65535));
- m += var_count;
- }
- }
- }
- else // ordered
- {
- int* mis_buf = (int*)(uchar*)inn_buf;
- const float *dst = 0;
- const int* mis = 0;
- get_ord_var_data(data_root, vi, values + vi, mis_buf, &dst, &mis, 0);
- for (int si = 0; si < total; si++)
- *(missing + vi + si) = mis[si] == 0 ? 0 : 1;
- }
- }
-
- // copy responses
- if( _responses )
- {
- if( is_classifier )
- {
- int* lbls_buf = (int*)(uchar*)inn_buf;
- const int* src = get_class_labels(data_root, lbls_buf);
- for( i = 0; i < count; i++ )
- {
- int idx = sidx ? sidx[i] : i;
- int val = get_class_idx ? src[idx] :
- cat_map->data.i[cat_ofs->data.i[cat_var_count]+src[idx]];
- _responses[i] = (float)val;
- }
- }
- else
- {
- float* _values_buf = (float*)(uchar*)inn_buf;
- int* sample_idx_buf = (int*)(_values_buf + sample_count);
- const float* _values = get_ord_responses(data_root, _values_buf, sample_idx_buf);
- for( i = 0; i < count; i++ )
- {
- int idx = sidx ? sidx[i] : i;
- _responses[i] = _values[idx];
- }
- }
- }
-
- __END__;
-
- cvReleaseMat( &subsample_idx );
- cvReleaseMat( &subsample_co );
-}
-
-CvDTreeNode* CvERTreeTrainData::subsample_data( const CvMat* _subsample_idx )
-{
- CvDTreeNode* root = 0;
-
- CV_FUNCNAME( "CvERTreeTrainData::subsample_data" );
-
- __BEGIN__;
-
- if( !data_root )
- CV_ERROR( CV_StsError, "No training data has been set" );
-
- if( !_subsample_idx )
- {
- // make a copy of the root node
- CvDTreeNode temp;
- int i;
- root = new_node( 0, 1, 0, 0 );
- temp = *root;
- *root = *data_root;
- root->num_valid = temp.num_valid;
- if( root->num_valid )
- {
- for( i = 0; i < var_count; i++ )
- root->num_valid[i] = data_root->num_valid[i];
- }
- root->cv_Tn = temp.cv_Tn;
- root->cv_node_risk = temp.cv_node_risk;
- root->cv_node_error = temp.cv_node_error;
- }
- else
- CV_ERROR( CV_StsError, "_subsample_idx must be null for extra-trees" );
- __END__;
-
- return root;
-}
-
-double CvForestERTree::calc_node_dir( CvDTreeNode* node )
-{
- char* dir = (char*)data->direction->data.ptr;
- int i, n = node->sample_count, vi = node->split->var_idx;
- double L, R;
-
- assert( !node->split->inversed );
-
- if( data->get_var_type(vi) >= 0 ) // split on categorical var
- {
- cv::AutoBuffer<uchar> inn_buf(n*sizeof(int)*(!data->have_priors ? 1 : 2));
- int* labels_buf = (int*)(uchar*)inn_buf;
- const int* labels = data->get_cat_var_data( node, vi, labels_buf );
- const int* subset = node->split->subset;
- if( !data->have_priors )
- {
- int sum = 0, sum_abs = 0;
-
- for( i = 0; i < n; i++ )
- {
- int idx = labels[i];
- int d = ( ((idx >= 0)&&(!data->is_buf_16u)) || ((idx != 65535)&&(data->is_buf_16u)) ) ?
- CV_DTREE_CAT_DIR(idx,subset) : 0;
- sum += d; sum_abs += d & 1;
- dir[i] = (char)d;
- }
-
- R = (sum_abs + sum) >> 1;
- L = (sum_abs - sum) >> 1;
- }
- else
- {
- const double* priors = data->priors_mult->data.db;
- double sum = 0, sum_abs = 0;
- int *responses_buf = labels_buf + n;
- const int* responses = data->get_class_labels(node, responses_buf);
-
- for( i = 0; i < n; i++ )
- {
- int idx = labels[i];
- double w = priors[responses[i]];
- int d = idx >= 0 ? CV_DTREE_CAT_DIR(idx,subset) : 0;
- sum += d*w; sum_abs += (d & 1)*w;
- dir[i] = (char)d;
- }
-
- R = (sum_abs + sum) * 0.5;
- L = (sum_abs - sum) * 0.5;
- }
- }
- else // split on ordered var
- {
- float split_val = node->split->ord.c;
- cv::AutoBuffer<uchar> inn_buf(n*(sizeof(int)*(!data->have_priors ? 1 : 2) + sizeof(float)));
- float* val_buf = (float*)(uchar*)inn_buf;
- int* missing_buf = (int*)(val_buf + n);
- const float* val = 0;
- const int* missing = 0;
- data->get_ord_var_data( node, vi, val_buf, missing_buf, &val, &missing, 0 );
-
- if( !data->have_priors )
- {
- L = R = 0;
- for( i = 0; i < n; i++ )
- {
- if ( missing[i] )
- dir[i] = (char)0;
- else
- {
- if ( val[i] < split_val)
- {
- dir[i] = (char)-1;
- L++;
- }
- else
- {
- dir[i] = (char)1;
- R++;
- }
- }
- }
- }
- else
- {
- const double* priors = data->priors_mult->data.db;
- int* responses_buf = missing_buf + n;
- const int* responses = data->get_class_labels(node, responses_buf);
- L = R = 0;
- for( i = 0; i < n; i++ )
- {
- if ( missing[i] )
- dir[i] = (char)0;
- else
- {
- double w = priors[responses[i]];
- if ( val[i] < split_val)
- {
- dir[i] = (char)-1;
- L += w;
- }
- else
- {
- dir[i] = (char)1;
- R += w;
- }
- }
- }
- }
- }
-
- node->maxlr = MAX( L, R );
- return node->split->quality/(L + R);
-}
-
-CvDTreeSplit* CvForestERTree::find_split_ord_class( CvDTreeNode* node, int vi, float init_quality, CvDTreeSplit* _split,
- uchar* _ext_buf )
-{
- const float epsilon = FLT_EPSILON*2;
- const float split_delta = (1 + FLT_EPSILON) * FLT_EPSILON;
-
- int n = node->sample_count;
- int m = data->get_num_classes();
-
- cv::AutoBuffer<uchar> inn_buf;
- if( !_ext_buf )
- inn_buf.allocate(n*(2*sizeof(int) + sizeof(float)));
- uchar* ext_buf = _ext_buf ? _ext_buf : (uchar*)inn_buf;
- float* values_buf = (float*)ext_buf;
- int* missing_buf = (int*)(values_buf + n);
- const float* values = 0;
- const int* missing = 0;
- data->get_ord_var_data( node, vi, values_buf, missing_buf, &values, &missing, 0 );
- int* responses_buf = missing_buf + n;
- const int* responses = data->get_class_labels( node, responses_buf );
-
- double lbest_val = 0, rbest_val = 0, best_val = init_quality, split_val = 0;
- const double* priors = data->have_priors ? data->priors_mult->data.db : 0;
- bool is_find_split = false;
- float pmin, pmax;
- int smpi = 0;
- while ( missing[smpi] && (smpi < n) )
- smpi++;
- assert(smpi < n);
-
- pmin = values[smpi];
- pmax = pmin;
- for (; smpi < n; smpi++)
- {
- float ptemp = values[smpi];
- int ms = missing[smpi];
- if (ms) continue;
- if ( ptemp < pmin)
- pmin = ptemp;
- if ( ptemp > pmax)
- pmax = ptemp;
- }
- float fdiff = pmax-pmin;
- if (fdiff > epsilon)
- {
- is_find_split = true;
- cv::RNG* rng = data->rng;
- split_val = pmin + rng->uniform(0.f, 1.f) * fdiff ;
- if (split_val - pmin <= FLT_EPSILON)
- split_val = pmin + split_delta;
- if (pmax - split_val <= FLT_EPSILON)
- split_val = pmax - split_delta;
-
- // calculate Gini index
- if ( !priors )
- {
- cv::AutoBuffer<int> lrc(m*2);
- int *lc = lrc, *rc = lc + m;
- int L = 0, R = 0;
-
- // init arrays of class instance counters on both sides of the split
- for(int i = 0; i < m; i++ )
- {
- lc[i] = 0;
- rc[i] = 0;
- }
- for( int si = 0; si < n; si++ )
- {
- int r = responses[si];
- float val = values[si];
- int ms = missing[si];
- if (ms) continue;
- if ( val < split_val )
- {
- lc[r]++;
- L++;
- }
- else
- {
- rc[r]++;
- R++;
- }
- }
- for (int i = 0; i < m; i++)
- {
- lbest_val += lc[i]*lc[i];
- rbest_val += rc[i]*rc[i];
- }
- best_val = (lbest_val*R + rbest_val*L) / ((double)(L*R));
- }
- else
- {
- cv::AutoBuffer<double> lrc(m*2);
- double *lc = lrc, *rc = lc + m;
- double L = 0, R = 0;
-
- // init arrays of class instance counters on both sides of the split
- for(int i = 0; i < m; i++ )
- {
- lc[i] = 0;
- rc[i] = 0;
- }
- for( int si = 0; si < n; si++ )
- {
- int r = responses[si];
- float val = values[si];
- int ms = missing[si];
- double p = priors[r];
- if (ms) continue;
- if ( val < split_val )
- {
- lc[r] += p;
- L += p;
- }
- else
- {
- rc[r] += p;
- R += p;
- }
- }
- for (int i = 0; i < m; i++)
- {
- lbest_val += lc[i]*lc[i];
- rbest_val += rc[i]*rc[i];
- }
- best_val = (lbest_val*R + rbest_val*L) / (L*R);
- }
-
- }
-
- CvDTreeSplit* split = 0;
- if( is_find_split )
- {
- split = _split ? _split : data->new_split_ord( 0, 0.0f, 0, 0, 0.0f );
- split->var_idx = vi;
- split->ord.c = (float)split_val;
- split->ord.split_point = -1;
- split->inversed = 0;
- split->quality = (float)best_val;
- }
- return split;
-}
-
-CvDTreeSplit* CvForestERTree::find_split_cat_class( CvDTreeNode* node, int vi, float init_quality, CvDTreeSplit* _split,
- uchar* _ext_buf )
-{
- int ci = data->get_var_type(vi);
- int n = node->sample_count;
- int cm = data->get_num_classes();
- int vm = data->cat_count->data.i[ci];
- double best_val = init_quality;
- CvDTreeSplit *split = 0;
-
- if ( vm > 1 )
- {
- cv::AutoBuffer<int> inn_buf;
- if( !_ext_buf )
- inn_buf.allocate(2*n);
- int* ext_buf = _ext_buf ? (int*)_ext_buf : (int*)inn_buf;
-
- const int* labels = data->get_cat_var_data( node, vi, ext_buf );
- const int* responses = data->get_class_labels( node, ext_buf + n );
-
- const double* priors = data->have_priors ? data->priors_mult->data.db : 0;
-
- // create random class mask
- cv::AutoBuffer<int> valid_cidx(vm);
- for (int i = 0; i < vm; i++)
- {
- valid_cidx[i] = -1;
- }
- for (int si = 0; si < n; si++)
- {
- int c = labels[si];
- if ( ((c == 65535) && data->is_buf_16u) || ((c<0) && (!data->is_buf_16u)) )
- continue;
- valid_cidx[c]++;
- }
-
- int valid_ccount = 0;
- for (int i = 0; i < vm; i++)
- if (valid_cidx[i] >= 0)
- {
- valid_cidx[i] = valid_ccount;
- valid_ccount++;
- }
- if (valid_ccount > 1)
- {
- CvRNG* rng = forest->get_rng();
- int l_cval_count = 1 + cvRandInt(rng) % (valid_ccount-1);
-
- CvMat* var_class_mask = cvCreateMat( 1, valid_ccount, CV_8UC1 );
- CvMat submask;
- memset(var_class_mask->data.ptr, 0, valid_ccount*CV_ELEM_SIZE(var_class_mask->type));
- cvGetCols( var_class_mask, &submask, 0, l_cval_count );
- cvSet( &submask, cvScalar(1) );
- for (int i = 0; i < valid_ccount; i++)
- {
- uchar temp;
- int i1 = cvRandInt( rng ) % valid_ccount;
- int i2 = cvRandInt( rng ) % valid_ccount;
- CV_SWAP( var_class_mask->data.ptr[i1], var_class_mask->data.ptr[i2], temp );
- }
-
- split = _split ? _split : data->new_split_cat( 0, -1.0f );
- split->var_idx = vi;
- memset( split->subset, 0, (data->max_c_count + 31)/32 * sizeof(int));
-
- // calculate Gini index
- double lbest_val = 0, rbest_val = 0;
- if( !priors )
- {
- cv::AutoBuffer<int> lrc(cm*2);
- int *lc = lrc, *rc = lc + cm;
- int L = 0, R = 0;
- // init arrays of class instance counters on both sides of the split
- for(int i = 0; i < cm; i++ )
- {
- lc[i] = 0;
- rc[i] = 0;
- }
- for( int si = 0; si < n; si++ )
- {
- int r = responses[si];
- int var_class_idx = labels[si];
- if ( ((var_class_idx == 65535) && data->is_buf_16u) || ((var_class_idx<0) && (!data->is_buf_16u)) )
- continue;
- int mask_class_idx = valid_cidx[var_class_idx];
- if (var_class_mask->data.ptr[mask_class_idx])
- {
- lc[r]++;
- L++;
- split->subset[var_class_idx >> 5] |= 1 << (var_class_idx & 31);
- }
- else
- {
- rc[r]++;
- R++;
- }
- }
- for (int i = 0; i < cm; i++)
- {
- lbest_val += lc[i]*lc[i];
- rbest_val += rc[i]*rc[i];
- }
- best_val = (lbest_val*R + rbest_val*L) / ((double)(L*R));
- }
- else
- {
- cv::AutoBuffer<int> lrc(cm*2);
- int *lc = lrc, *rc = lc + cm;
- double L = 0, R = 0;
- // init arrays of class instance counters on both sides of the split
- for(int i = 0; i < cm; i++ )
- {
- lc[i] = 0;
- rc[i] = 0;
- }
- for( int si = 0; si < n; si++ )
- {
- int r = responses[si];
- int var_class_idx = labels[si];
- if ( ((var_class_idx == 65535) && data->is_buf_16u) || ((var_class_idx<0) && (!data->is_buf_16u)) )
- continue;
- double p = priors[si];
- int mask_class_idx = valid_cidx[var_class_idx];
-
- if (var_class_mask->data.ptr[mask_class_idx])
- {
- lc[r]+=(int)p;
- L+=p;
- split->subset[var_class_idx >> 5] |= 1 << (var_class_idx & 31);
- }
- else
- {
- rc[r]+=(int)p;
- R+=p;
- }
- }
- for (int i = 0; i < cm; i++)
- {
- lbest_val += lc[i]*lc[i];
- rbest_val += rc[i]*rc[i];
- }
- best_val = (lbest_val*R + rbest_val*L) / (L*R);
- }
- split->quality = (float)best_val;
-
- cvReleaseMat(&var_class_mask);
- }
- }
-
- return split;
-}
-
-CvDTreeSplit* CvForestERTree::find_split_ord_reg( CvDTreeNode* node, int vi, float init_quality, CvDTreeSplit* _split,
- uchar* _ext_buf )
-{
- const float epsilon = FLT_EPSILON*2;
- const float split_delta = (1 + FLT_EPSILON) * FLT_EPSILON;
- int n = node->sample_count;
- cv::AutoBuffer<uchar> inn_buf;
- if( !_ext_buf )
- inn_buf.allocate(n*(2*sizeof(int) + 2*sizeof(float)));
- uchar* ext_buf = _ext_buf ? _ext_buf : (uchar*)inn_buf;
- float* values_buf = (float*)ext_buf;
- int* missing_buf = (int*)(values_buf + n);
- const float* values = 0;
- const int* missing = 0;
- data->get_ord_var_data( node, vi, values_buf, missing_buf, &values, &missing, 0 );
- float* responses_buf = (float*)(missing_buf + n);
- int* sample_indices_buf = (int*)(responses_buf + n);
- const float* responses = data->get_ord_responses( node, responses_buf, sample_indices_buf );
-
- double best_val = init_quality, split_val = 0, lsum = 0, rsum = 0;
- int L = 0, R = 0;
-
- bool is_find_split = false;
- float pmin, pmax;
- int smpi = 0;
- while ( missing[smpi] && (smpi < n) )
- smpi++;
-
- assert(smpi < n);
-
- pmin = values[smpi];
- pmax = pmin;
- for (; smpi < n; smpi++)
- {
- float ptemp = values[smpi];
- int m = missing[smpi];
- if (m) continue;
- if ( ptemp < pmin)
- pmin = ptemp;
- if ( ptemp > pmax)
- pmax = ptemp;
- }
- float fdiff = pmax-pmin;
- if (fdiff > epsilon)
- {
- is_find_split = true;
- cv::RNG* rng = data->rng;
- split_val = pmin + rng->uniform(0.f, 1.f) * fdiff ;
- if (split_val - pmin <= FLT_EPSILON)
- split_val = pmin + split_delta;
- if (pmax - split_val <= FLT_EPSILON)
- split_val = pmax - split_delta;
-
- for (int si = 0; si < n; si++)
- {
- float r = responses[si];
- float val = values[si];
- int m = missing[si];
- if (m) continue;
- if (val < split_val)
- {
- lsum += r;
- L++;
- }
- else
- {
- rsum += r;
- R++;
- }
- }
- best_val = (lsum*lsum*R + rsum*rsum*L)/((double)L*R);
- }
-
- CvDTreeSplit* split = 0;
- if( is_find_split )
- {
- split = _split ? _split : data->new_split_ord( 0, 0.0f, 0, 0, 0.0f );
- split->var_idx = vi;
- split->ord.c = (float)split_val;
- split->ord.split_point = -1;
- split->inversed = 0;
- split->quality = (float)best_val;
- }
- return split;
-}
-
-CvDTreeSplit* CvForestERTree::find_split_cat_reg( CvDTreeNode* node, int vi, float init_quality, CvDTreeSplit* _split,
- uchar* _ext_buf )
-{
- int ci = data->get_var_type(vi);
- int n = node->sample_count;
- int vm = data->cat_count->data.i[ci];
- double best_val = init_quality;
- CvDTreeSplit *split = 0;
- float lsum = 0, rsum = 0;
-
- if ( vm > 1 )
- {
- int base_size = vm*sizeof(int);
- cv::AutoBuffer<uchar> inn_buf(base_size);
- if( !_ext_buf )
- inn_buf.allocate(base_size + n*(2*sizeof(int) + sizeof(float)));
- uchar* base_buf = (uchar*)inn_buf;
- uchar* ext_buf = _ext_buf ? _ext_buf : base_buf + base_size;
- int* labels_buf = (int*)ext_buf;
- const int* labels = data->get_cat_var_data( node, vi, labels_buf );
- float* responses_buf = (float*)(labels_buf + n);
- int* sample_indices_buf = (int*)(responses_buf + n);
- const float* responses = data->get_ord_responses( node, responses_buf, sample_indices_buf );
-
- // create random class mask
- int *valid_cidx = (int*)base_buf;
- for (int i = 0; i < vm; i++)
- {
- valid_cidx[i] = -1;
- }
- for (int si = 0; si < n; si++)
- {
- int c = labels[si];
- if ( ((c == 65535) && data->is_buf_16u) || ((c<0) && (!data->is_buf_16u)) )
- continue;
- valid_cidx[c]++;
- }
-
- int valid_ccount = 0;
- for (int i = 0; i < vm; i++)
- if (valid_cidx[i] >= 0)
- {
- valid_cidx[i] = valid_ccount;
- valid_ccount++;
- }
- if (valid_ccount > 1)
- {
- CvRNG* rng = forest->get_rng();
- int l_cval_count = 1 + cvRandInt(rng) % (valid_ccount-1);
-
- CvMat* var_class_mask = cvCreateMat( 1, valid_ccount, CV_8UC1 );
- CvMat submask;
- memset(var_class_mask->data.ptr, 0, valid_ccount*CV_ELEM_SIZE(var_class_mask->type));
- cvGetCols( var_class_mask, &submask, 0, l_cval_count );
- cvSet( &submask, cvScalar(1) );
- for (int i = 0; i < valid_ccount; i++)
- {
- uchar temp;
- int i1 = cvRandInt( rng ) % valid_ccount;
- int i2 = cvRandInt( rng ) % valid_ccount;
- CV_SWAP( var_class_mask->data.ptr[i1], var_class_mask->data.ptr[i2], temp );
- }
-
- split = _split ? _split : data->new_split_cat( 0, -1.0f);
- split->var_idx = vi;
- memset( split->subset, 0, (data->max_c_count + 31)/32 * sizeof(int));
-
- int L = 0, R = 0;
- for( int si = 0; si < n; si++ )
- {
- float r = responses[si];
- int var_class_idx = labels[si];
- if ( ((var_class_idx == 65535) && data->is_buf_16u) || ((var_class_idx<0) && (!data->is_buf_16u)) )
- continue;
- int mask_class_idx = valid_cidx[var_class_idx];
- if (var_class_mask->data.ptr[mask_class_idx])
- {
- lsum += r;
- L++;
- split->subset[var_class_idx >> 5] |= 1 << (var_class_idx & 31);
- }
- else
- {
- rsum += r;
- R++;
- }
- }
- best_val = (lsum*lsum*R + rsum*rsum*L)/((double)L*R);
-
- split->quality = (float)best_val;
-
- cvReleaseMat(&var_class_mask);
- }
- }
-
- return split;
-}
-
-void CvForestERTree::split_node_data( CvDTreeNode* node )
-{
- int vi, i, n = node->sample_count, nl, nr, scount = data->sample_count;
- char* dir = (char*)data->direction->data.ptr;
- CvDTreeNode *left = 0, *right = 0;
- int new_buf_idx = data->get_child_buf_idx( node );
- CvMat* buf = data->buf;
- size_t length_buf_row = data->get_length_subbuf();
- cv::AutoBuffer<int> temp_buf(n);
-
- complete_node_dir(node);
-
- for( i = nl = nr = 0; i < n; i++ )
- {
- int d = dir[i];
- nr += d;
- nl += d^1;
- }
-
- bool split_input_data;
- node->left = left = data->new_node( node, nl, new_buf_idx, node->offset );
- node->right = right = data->new_node( node, nr, new_buf_idx, node->offset + nl );
-
- split_input_data = node->depth + 1 < data->params.max_depth &&
- (node->left->sample_count > data->params.min_sample_count ||
- node->right->sample_count > data->params.min_sample_count);
-
- cv::AutoBuffer<uchar> inn_buf(n*(sizeof(int)+sizeof(float)));
- // split ordered vars
- for( vi = 0; vi < data->var_count; vi++ )
- {
- int ci = data->get_var_type(vi);
- if (ci >= 0) continue;
-
- int n1 = node->get_num_valid(vi), nr1 = 0;
- float* values_buf = (float*)(uchar*)inn_buf;
- int* missing_buf = (int*)(values_buf + n);
- const float* values = 0;
- const int* missing = 0;
- data->get_ord_var_data( node, vi, values_buf, missing_buf, &values, &missing, 0 );
-
- for( i = 0; i < n; i++ )
- nr1 += ((!missing[i]) & dir[i]);
- left->set_num_valid(vi, n1 - nr1);
- right->set_num_valid(vi, nr1);
- }
- // split categorical vars, responses and cv_labels using new_idx relocation table
- for( vi = 0; vi < data->get_work_var_count() + data->ord_var_count; vi++ )
- {
- int ci = data->get_var_type(vi);
- if (ci < 0) continue;
-
- int n1 = node->get_num_valid(vi), nr1 = 0;
- const int* src_lbls = data->get_cat_var_data(node, vi, (int*)(uchar*)inn_buf);
-
- for(i = 0; i < n; i++)
- temp_buf[i] = src_lbls[i];
-
- if (data->is_buf_16u)
- {
- unsigned short *ldst = (unsigned short *)(buf->data.s + left->buf_idx*length_buf_row +
- ci*scount + left->offset);
- unsigned short *rdst = (unsigned short *)(buf->data.s + right->buf_idx*length_buf_row +
- ci*scount + right->offset);
-
- for( i = 0; i < n; i++ )
- {
- int d = dir[i];
- int idx = temp_buf[i];
- if (d)
- {
- *rdst = (unsigned short)idx;
- rdst++;
- nr1 += (idx != 65535);
- }
- else
- {
- *ldst = (unsigned short)idx;
- ldst++;
- }
- }
-
- if( vi < data->var_count )
- {
- left->set_num_valid(vi, n1 - nr1);
- right->set_num_valid(vi, nr1);
- }
- }
- else
- {
- int *ldst = buf->data.i + left->buf_idx*length_buf_row +
- ci*scount + left->offset;
- int *rdst = buf->data.i + right->buf_idx*length_buf_row +
- ci*scount + right->offset;
-
- for( i = 0; i < n; i++ )
- {
- int d = dir[i];
- int idx = temp_buf[i];
- if (d)
- {
- *rdst = idx;
- rdst++;
- nr1 += (idx >= 0);
- }
- else
- {
- *ldst = idx;
- ldst++;
- }
-
- }
-
- if( vi < data->var_count )
- {
- left->set_num_valid(vi, n1 - nr1);
- right->set_num_valid(vi, nr1);
- }
- }
- }
-
- // split sample indices
- int *sample_idx_src_buf = (int*)(uchar*)inn_buf;
- const int* sample_idx_src = 0;
- if (split_input_data)
- {
- sample_idx_src = data->get_sample_indices(node, sample_idx_src_buf);
-
- for(i = 0; i < n; i++)
- temp_buf[i] = sample_idx_src[i];
-
- int pos = data->get_work_var_count();
-
- if (data->is_buf_16u)
- {
- unsigned short* ldst = (unsigned short*)(buf->data.s + left->buf_idx*length_buf_row +
- pos*scount + left->offset);
- unsigned short* rdst = (unsigned short*)(buf->data.s + right->buf_idx*length_buf_row +
- pos*scount + right->offset);
-
- for (i = 0; i < n; i++)
- {
- int d = dir[i];
- unsigned short idx = (unsigned short)temp_buf[i];
- if (d)
- {
- *rdst = idx;
- rdst++;
- }
- else
- {
- *ldst = idx;
- ldst++;
- }
- }
- }
- else
- {
- int* ldst = buf->data.i + left->buf_idx*length_buf_row +
- pos*scount + left->offset;
- int* rdst = buf->data.i + right->buf_idx*length_buf_row +
- pos*scount + right->offset;
- for (i = 0; i < n; i++)
- {
- int d = dir[i];
- int idx = temp_buf[i];
- if (d)
- {
- *rdst = idx;
- rdst++;
- }
- else
- {
- *ldst = idx;
- ldst++;
- }
- }
- }
- }
-
- // deallocate the parent node data that is not needed anymore
- data->free_node_data(node);
-}
-
-CvERTrees::CvERTrees()
-{
-}
-
-CvERTrees::~CvERTrees()
-{
-}
-
-cv::String CvERTrees::getName() const
-{
- return CV_TYPE_NAME_ML_ERTREES;
-}
-
-bool CvERTrees::train( const CvMat* _train_data, int _tflag,
- const CvMat* _responses, const CvMat* _var_idx,
- const CvMat* _sample_idx, const CvMat* _var_type,
- const CvMat* _missing_mask, CvRTParams params )
-{
- bool result = false;
-
- CV_FUNCNAME("CvERTrees::train");
- __BEGIN__
- int var_count = 0;
-
- clear();
-
- CvDTreeParams tree_params( params.max_depth, params.min_sample_count,
- params.regression_accuracy, params.use_surrogates, params.max_categories,
- params.cv_folds, params.use_1se_rule, false, params.priors );
-
- data = new CvERTreeTrainData();
- CV_CALL(data->set_data( _train_data, _tflag, _responses, _var_idx,
- _sample_idx, _var_type, _missing_mask, tree_params, true));
-
- var_count = data->var_count;
- if( params.nactive_vars > var_count )
- params.nactive_vars = var_count;
- else if( params.nactive_vars == 0 )
- params.nactive_vars = (int)sqrt((double)var_count);
- else if( params.nactive_vars < 0 )
- CV_ERROR( CV_StsBadArg, "<nactive_vars> must be non-negative" );
-
- // Create mask of active variables at the tree nodes
- CV_CALL(active_var_mask = cvCreateMat( 1, var_count, CV_8UC1 ));
- if( params.calc_var_importance )
- {
- CV_CALL(var_importance = cvCreateMat( 1, var_count, CV_32FC1 ));
- cvZero(var_importance);
- }
- { // initialize active variables mask
- CvMat submask1, submask2;
- CV_Assert( (active_var_mask->cols >= 1) && (params.nactive_vars > 0) && (params.nactive_vars <= active_var_mask->cols) );
- cvGetCols( active_var_mask, &submask1, 0, params.nactive_vars );
- cvSet( &submask1, cvScalar(1) );
- if( params.nactive_vars < active_var_mask->cols )
- {
- cvGetCols( active_var_mask, &submask2, params.nactive_vars, var_count );
- cvZero( &submask2 );
- }
- }
-
- CV_CALL(result = grow_forest( params.term_crit ));
-
- result = true;
-
- __END__
- return result;
-
-}
-
-bool CvERTrees::train( CvMLData* _data, CvRTParams params)
-{
- bool result = false;
-
- CV_FUNCNAME( "CvERTrees::train" );
-
- __BEGIN__;
-
- CV_CALL( result = CvRTrees::train( _data, params) );
-
- __END__;
-
- return result;
-}
-
-bool CvERTrees::grow_forest( const CvTermCriteria term_crit )
-{
- bool result = false;
-
- CvMat* sample_idx_for_tree = 0;
-
- CV_FUNCNAME("CvERTrees::grow_forest");
- __BEGIN__;
-
- const int max_ntrees = term_crit.max_iter;
- const double max_oob_err = term_crit.epsilon;
-
- const int dims = data->var_count;
- float maximal_response = 0;
-
- CvMat* oob_sample_votes = 0;
- CvMat* oob_responses = 0;
-
- float* oob_samples_perm_ptr= 0;
-
- float* samples_ptr = 0;
- uchar* missing_ptr = 0;
- float* true_resp_ptr = 0;
- bool is_oob_or_vimportance = ((max_oob_err > 0) && (term_crit.type != CV_TERMCRIT_ITER)) || var_importance;
-
- // oob_predictions_sum[i] = sum of predicted values for the i-th sample
- // oob_num_of_predictions[i] = number of summands
- // (number of predictions for the i-th sample)
- // initialize these variable to avoid warning C4701
- CvMat oob_predictions_sum = cvMat( 1, 1, CV_32FC1 );
- CvMat oob_num_of_predictions = cvMat( 1, 1, CV_32FC1 );
-
- nsamples = data->sample_count;
- nclasses = data->get_num_classes();
-
- if ( is_oob_or_vimportance )
- {
- if( data->is_classifier )
- {
- CV_CALL(oob_sample_votes = cvCreateMat( nsamples, nclasses, CV_32SC1 ));
- cvZero(oob_sample_votes);
- }
- else
- {
- // oob_responses[0,i] = oob_predictions_sum[i]
- // = sum of predicted values for the i-th sample
- // oob_responses[1,i] = oob_num_of_predictions[i]
- // = number of summands (number of predictions for the i-th sample)
- CV_CALL(oob_responses = cvCreateMat( 2, nsamples, CV_32FC1 ));
- cvZero(oob_responses);
- cvGetRow( oob_responses, &oob_predictions_sum, 0 );
- cvGetRow( oob_responses, &oob_num_of_predictions, 1 );
- }
-
- CV_CALL(oob_samples_perm_ptr = (float*)cvAlloc( sizeof(float)*nsamples*dims ));
- CV_CALL(samples_ptr = (float*)cvAlloc( sizeof(float)*nsamples*dims ));
- CV_CALL(missing_ptr = (uchar*)cvAlloc( sizeof(uchar)*nsamples*dims ));
- CV_CALL(true_resp_ptr = (float*)cvAlloc( sizeof(float)*nsamples ));
-
- CV_CALL(data->get_vectors( 0, samples_ptr, missing_ptr, true_resp_ptr ));
- {
- double minval, maxval;
- CvMat responses = cvMat(1, nsamples, CV_32FC1, true_resp_ptr);
- cvMinMaxLoc( &responses, &minval, &maxval );
- maximal_response = (float)MAX( MAX( fabs(minval), fabs(maxval) ), 0 );
- }
- }
-
- trees = (CvForestTree**)cvAlloc( sizeof(trees[0])*max_ntrees );
- memset( trees, 0, sizeof(trees[0])*max_ntrees );
-
- CV_CALL(sample_idx_for_tree = cvCreateMat( 1, nsamples, CV_32SC1 ));
-
- for (int i = 0; i < nsamples; i++)
- sample_idx_for_tree->data.i[i] = i;
- ntrees = 0;
- while( ntrees < max_ntrees )
- {
- int i, oob_samples_count = 0;
- double ncorrect_responses = 0; // used for estimation of variable importance
- CvForestTree* tree = 0;
-
- trees[ntrees] = new CvForestERTree();
- tree = (CvForestERTree*)trees[ntrees];
- CV_CALL(tree->train( data, 0, this ));
-
- if ( is_oob_or_vimportance )
- {
- CvMat sample, missing;
- // form array of OOB samples indices and get these samples
- sample = cvMat( 1, dims, CV_32FC1, samples_ptr );
- missing = cvMat( 1, dims, CV_8UC1, missing_ptr );
-
- oob_error = 0;
- for( i = 0; i < nsamples; i++,
- sample.data.fl += dims, missing.data.ptr += dims )
- {
- CvDTreeNode* predicted_node = 0;
-
- // predict oob samples
- if( !predicted_node )
- CV_CALL(predicted_node = tree->predict(&sample, &missing, true));
-
- if( !data->is_classifier ) //regression
- {
- double avg_resp, resp = predicted_node->value;
- oob_predictions_sum.data.fl[i] += (float)resp;
- oob_num_of_predictions.data.fl[i] += 1;
-
- // compute oob error
- avg_resp = oob_predictions_sum.data.fl[i]/oob_num_of_predictions.data.fl[i];
- avg_resp -= true_resp_ptr[i];
- oob_error += avg_resp*avg_resp;
- resp = (resp - true_resp_ptr[i])/maximal_response;
- ncorrect_responses += exp( -resp*resp );
- }
- else //classification
- {
- double prdct_resp;
- CvPoint max_loc;
- CvMat votes;
-
- cvGetRow(oob_sample_votes, &votes, i);
- votes.data.i[predicted_node->class_idx]++;
-
- // compute oob error
- cvMinMaxLoc( &votes, 0, 0, 0, &max_loc );
-
- prdct_resp = data->cat_map->data.i[max_loc.x];
- oob_error += (fabs(prdct_resp - true_resp_ptr[i]) < FLT_EPSILON) ? 0 : 1;
-
- ncorrect_responses += cvRound(predicted_node->value - true_resp_ptr[i]) == 0;
- }
- oob_samples_count++;
- }
- if( oob_samples_count > 0 )
- oob_error /= (double)oob_samples_count;
-
- // estimate variable importance
- if( var_importance && oob_samples_count > 0 )
- {
- int m;
-
- memcpy( oob_samples_perm_ptr, samples_ptr, dims*nsamples*sizeof(float));
- for( m = 0; m < dims; m++ )
- {
- double ncorrect_responses_permuted = 0;
- // randomly permute values of the m-th variable in the oob samples
- float* mth_var_ptr = oob_samples_perm_ptr + m;
-
- for( i = 0; i < nsamples; i++ )
- {
- int i1, i2;
- float temp;
-
- i1 = (*rng)(nsamples);
- i2 = (*rng)(nsamples);
- CV_SWAP( mth_var_ptr[i1*dims], mth_var_ptr[i2*dims], temp );
-
- // turn values of (m-1)-th variable, that were permuted
- // at the previous iteration, untouched
- if( m > 1 )
- oob_samples_perm_ptr[i*dims+m-1] = samples_ptr[i*dims+m-1];
- }
-
- // predict "permuted" cases and calculate the number of votes for the
- // correct class in the variable-m-permuted oob data
- sample = cvMat( 1, dims, CV_32FC1, oob_samples_perm_ptr );
- missing = cvMat( 1, dims, CV_8UC1, missing_ptr );
- for( i = 0; i < nsamples; i++,
- sample.data.fl += dims, missing.data.ptr += dims )
- {
- double predct_resp, true_resp;
-
- predct_resp = tree->predict(&sample, &missing, true)->value;
- true_resp = true_resp_ptr[i];
- if( data->is_classifier )
- ncorrect_responses_permuted += cvRound(true_resp - predct_resp) == 0;
- else
- {
- true_resp = (true_resp - predct_resp)/maximal_response;
- ncorrect_responses_permuted += exp( -true_resp*true_resp );
- }
- }
- var_importance->data.fl[m] += (float)(ncorrect_responses
- - ncorrect_responses_permuted);
- }
- }
- }
- ntrees++;
- if( term_crit.type != CV_TERMCRIT_ITER && oob_error < max_oob_err )
- break;
- }
- if( var_importance )
- {
- for ( int vi = 0; vi < var_importance->cols; vi++ )
- var_importance->data.fl[vi] = ( var_importance->data.fl[vi] > 0 ) ?
- var_importance->data.fl[vi] : 0;
- cvNormalize( var_importance, var_importance, 1., 0, CV_L1 );
- }
-
- result = true;
-
- cvFree( &oob_samples_perm_ptr );
- cvFree( &samples_ptr );
- cvFree( &missing_ptr );
- cvFree( &true_resp_ptr );
-
- cvReleaseMat( &sample_idx_for_tree );
-
- cvReleaseMat( &oob_sample_votes );
- cvReleaseMat( &oob_responses );
-
- __END__;
-
- return result;
-}
-
-using namespace cv;
-
-bool CvERTrees::train( const Mat& _train_data, int _tflag,
- const Mat& _responses, const Mat& _var_idx,
- const Mat& _sample_idx, const Mat& _var_type,
- const Mat& _missing_mask, CvRTParams params )
-{
- train_data_hdr = _train_data;
- train_data_mat = _train_data;
- responses_hdr = _responses;
- responses_mat = _responses;
-
- CvMat vidx = _var_idx, sidx = _sample_idx, vtype = _var_type, mmask = _missing_mask;
-
- return train(&train_data_hdr, _tflag, &responses_hdr, vidx.data.ptr ? &vidx : 0,
- sidx.data.ptr ? &sidx : 0, vtype.data.ptr ? &vtype : 0,
- mmask.data.ptr ? &mmask : 0, params);
-}
-
-// End of file.
+++ /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*/
-
-#include "precomp.hpp"
-
-#if 0
-
-ML_IMPL int
-icvCmpIntegers (const void* a, const void* b) {return *(const int*)a - *(const int*)b;}
-
-/****************************************************************************************\
-* Cross-validation algorithms realizations *
-\****************************************************************************************/
-
-// Return pointer to trainIdx. Function DOES NOT FILL this matrix!
-ML_IMPL
-const CvMat* cvCrossValGetTrainIdxMatrix (const CvStatModel* estimateModel)
-{
- CvMat* result = NULL;
-
- CV_FUNCNAME ("cvCrossValGetTrainIdxMatrix");
- __BEGIN__
-
- if (!CV_IS_CROSSVAL(estimateModel))
- {
- CV_ERROR (CV_StsBadArg, "Pointer point to not CvCrossValidationModel");
- }
-
- result = ((CvCrossValidationModel*)estimateModel)->sampleIdxTrain;
-
- __END__
-
- return result;
-} // End of cvCrossValGetTrainIdxMatrix
-
-/****************************************************************************************/
-// Return pointer to checkIdx. Function DOES NOT FILL this matrix!
-ML_IMPL
-const CvMat* cvCrossValGetCheckIdxMatrix (const CvStatModel* estimateModel)
-{
- CvMat* result = NULL;
-
- CV_FUNCNAME ("cvCrossValGetCheckIdxMatrix");
- __BEGIN__
-
- if (!CV_IS_CROSSVAL (estimateModel))
- {
- CV_ERROR (CV_StsBadArg, "Pointer point to not CvCrossValidationModel");
- }
-
- result = ((CvCrossValidationModel*)estimateModel)->sampleIdxEval;
-
- __END__
-
- return result;
-} // End of cvCrossValGetCheckIdxMatrix
-
-/****************************************************************************************/
-// Create new Idx-matrix for next classifiers training and return code of result.
-// Result is 0 if function can't make next step (error input or folds are finished),
-// it is 1 if all was correct, and it is 2 if current fold wasn't' checked.
-ML_IMPL
-int cvCrossValNextStep (CvStatModel* estimateModel)
-{
- int result = 0;
-
- CV_FUNCNAME ("cvCrossValGetNextTrainIdx");
- __BEGIN__
-
- CvCrossValidationModel* crVal = (CvCrossValidationModel*) estimateModel;
- int k, fold;
-
- if (!CV_IS_CROSSVAL (estimateModel))
- {
- CV_ERROR (CV_StsBadArg, "Pointer point to not CvCrossValidationModel");
- }
-
- fold = ++crVal->current_fold;
-
- if (fold >= crVal->folds_all)
- {
- if (fold == crVal->folds_all)
- EXIT;
- else
- {
- CV_ERROR (CV_StsInternal, "All iterations has end long ago");
- }
- }
-
- k = crVal->folds[fold + 1] - crVal->folds[fold];
- crVal->sampleIdxTrain->data.i = crVal->sampleIdxAll + crVal->folds[fold + 1];
- crVal->sampleIdxTrain->cols = crVal->samples_all - k;
- crVal->sampleIdxEval->data.i = crVal->sampleIdxAll + crVal->folds[fold];
- crVal->sampleIdxEval->cols = k;
-
- if (crVal->is_checked)
- {
- crVal->is_checked = 0;
- result = 1;
- }
- else
- {
- result = 2;
- }
-
- __END__
-
- return result;
-}
-
-/****************************************************************************************/
-// Do checking part of loop of cross-validations metod.
-ML_IMPL
-void cvCrossValCheckClassifier (CvStatModel* estimateModel,
- const CvStatModel* model,
- const CvMat* trainData,
- int sample_t_flag,
- const CvMat* trainClasses)
-{
- CV_FUNCNAME ("cvCrossValCheckClassifier ");
- __BEGIN__
-
- CvCrossValidationModel* crVal = (CvCrossValidationModel*) estimateModel;
- int i, j, k;
- int* data;
- float* responses_fl;
- int step;
- float* responses_result;
- int* responses_i;
- double te, te1;
- double sum_c, sum_p, sum_pp, sum_cp, sum_cc, sq_err;
-
-// Check input data to correct values.
- if (!CV_IS_CROSSVAL (estimateModel))
- {
- CV_ERROR (CV_StsBadArg,"First parameter point to not CvCrossValidationModel");
- }
- if (!CV_IS_STAT_MODEL (model))
- {
- CV_ERROR (CV_StsBadArg, "Second parameter point to not CvStatModel");
- }
- if (!CV_IS_MAT (trainData))
- {
- CV_ERROR (CV_StsBadArg, "Third parameter point to not CvMat");
- }
- if (!CV_IS_MAT (trainClasses))
- {
- CV_ERROR (CV_StsBadArg, "Fifth parameter point to not CvMat");
- }
- if (crVal->is_checked)
- {
- CV_ERROR (CV_StsInternal, "This iterations already was checked");
- }
-
-// Initialize.
- k = crVal->sampleIdxEval->cols;
- data = crVal->sampleIdxEval->data.i;
-
-// Eval tested feature vectors.
- CV_CALL (cvStatModelMultiPredict (model, trainData, sample_t_flag,
- crVal->predict_results, NULL, crVal->sampleIdxEval));
-// Count number if correct results.
- responses_result = crVal->predict_results->data.fl;
- if (crVal->is_regression)
- {
- sum_c = sum_p = sum_pp = sum_cp = sum_cc = sq_err = 0;
- if (CV_MAT_TYPE (trainClasses->type) == CV_32FC1)
- {
- responses_fl = trainClasses->data.fl;
- step = trainClasses->rows == 1 ? 1 : trainClasses->step / sizeof(float);
- for (i = 0; i < k; i++)
- {
- te = responses_result[*data];
- te1 = responses_fl[*data * step];
- sum_c += te1;
- sum_p += te;
- sum_cc += te1 * te1;
- sum_pp += te * te;
- sum_cp += te1 * te;
- te -= te1;
- sq_err += te * te;
-
- data++;
- }
- }
- else
- {
- responses_i = trainClasses->data.i;
- step = trainClasses->rows == 1 ? 1 : trainClasses->step / sizeof(int);
- for (i = 0; i < k; i++)
- {
- te = responses_result[*data];
- te1 = responses_i[*data * step];
- sum_c += te1;
- sum_p += te;
- sum_cc += te1 * te1;
- sum_pp += te * te;
- sum_cp += te1 * te;
- te -= te1;
- sq_err += te * te;
-
- data++;
- }
- }
- // Fixing new internal values of accuracy.
- crVal->sum_correct += sum_c;
- crVal->sum_predict += sum_p;
- crVal->sum_cc += sum_cc;
- crVal->sum_pp += sum_pp;
- crVal->sum_cp += sum_cp;
- crVal->sq_error += sq_err;
- }
- else
- {
- if (CV_MAT_TYPE (trainClasses->type) == CV_32FC1)
- {
- responses_fl = trainClasses->data.fl;
- step = trainClasses->rows == 1 ? 1 : trainClasses->step / sizeof(float);
- for (i = 0, j = 0; i < k; i++)
- {
- if (cvRound (responses_result[*data]) == cvRound (responses_fl[*data * step]))
- j++;
- data++;
- }
- }
- else
- {
- responses_i = trainClasses->data.i;
- step = trainClasses->rows == 1 ? 1 : trainClasses->step / sizeof(int);
- for (i = 0, j = 0; i < k; i++)
- {
- if (cvRound (responses_result[*data]) == responses_i[*data * step])
- j++;
- data++;
- }
- }
- // Fixing new internal values of accuracy.
- crVal->correct_results += j;
- }
-// Fixing that this fold already checked.
- crVal->all_results += k;
- crVal->is_checked = 1;
-
- __END__
-} // End of cvCrossValCheckClassifier
-
-/****************************************************************************************/
-// Return current accuracy.
-ML_IMPL
-float cvCrossValGetResult (const CvStatModel* estimateModel,
- float* correlation)
-{
- float result = 0;
-
- CV_FUNCNAME ("cvCrossValGetResult");
- __BEGIN__
-
- double te, te1;
- CvCrossValidationModel* crVal = (CvCrossValidationModel*)estimateModel;
-
- if (!CV_IS_CROSSVAL (estimateModel))
- {
- CV_ERROR (CV_StsBadArg, "Pointer point to not CvCrossValidationModel");
- }
-
- if (crVal->all_results)
- {
- if (crVal->is_regression)
- {
- result = ((float)crVal->sq_error) / crVal->all_results;
- if (correlation)
- {
- te = crVal->all_results * crVal->sum_cp -
- crVal->sum_correct * crVal->sum_predict;
- te *= te;
- te1 = (crVal->all_results * crVal->sum_cc -
- crVal->sum_correct * crVal->sum_correct) *
- (crVal->all_results * crVal->sum_pp -
- crVal->sum_predict * crVal->sum_predict);
- *correlation = (float)(te / te1);
-
- }
- }
- else
- {
- result = ((float)crVal->correct_results) / crVal->all_results;
- }
- }
-
- __END__
-
- return result;
-}
-
-/****************************************************************************************/
-// Reset cross-validation EstimateModel to state the same as it was immidiatly after
-// its creating.
-ML_IMPL
-void cvCrossValReset (CvStatModel* estimateModel)
-{
- CV_FUNCNAME ("cvCrossValReset");
- __BEGIN__
-
- CvCrossValidationModel* crVal = (CvCrossValidationModel*)estimateModel;
-
- if (!CV_IS_CROSSVAL (estimateModel))
- {
- CV_ERROR (CV_StsBadArg, "Pointer point to not CvCrossValidationModel");
- }
-
- crVal->current_fold = -1;
- crVal->is_checked = 1;
- crVal->all_results = 0;
- crVal->correct_results = 0;
- crVal->sq_error = 0;
- crVal->sum_correct = 0;
- crVal->sum_predict = 0;
- crVal->sum_cc = 0;
- crVal->sum_pp = 0;
- crVal->sum_cp = 0;
-
- __END__
-}
-
-/****************************************************************************************/
-// This function is standart CvStatModel field to release cross-validation EstimateModel.
-ML_IMPL
-void cvReleaseCrossValidationModel (CvStatModel** model)
-{
- CvCrossValidationModel* pModel;
-
- CV_FUNCNAME ("cvReleaseCrossValidationModel");
- __BEGIN__
-
- if (!model)
- {
- CV_ERROR (CV_StsNullPtr, "");
- }
-
- pModel = (CvCrossValidationModel*)*model;
- if (!pModel)
- {
- return;
- }
- if (!CV_IS_CROSSVAL (pModel))
- {
- CV_ERROR (CV_StsBadArg, "");
- }
-
- cvFree (&pModel->sampleIdxAll);
- cvFree (&pModel->folds);
- cvReleaseMat (&pModel->sampleIdxEval);
- cvReleaseMat (&pModel->sampleIdxTrain);
- cvReleaseMat (&pModel->predict_results);
-
- cvFree (model);
-
- __END__
-} // End of cvReleaseCrossValidationModel.
-
-/****************************************************************************************/
-// This function create cross-validation EstimateModel.
-ML_IMPL CvStatModel*
-cvCreateCrossValidationEstimateModel(
- int samples_all,
- const CvStatModelParams* estimateParams,
- const CvMat* sampleIdx)
-{
- CvStatModel* model = NULL;
- CvCrossValidationModel* crVal = NULL;
-
- CV_FUNCNAME ("cvCreateCrossValidationEstimateModel");
- __BEGIN__
-
- int k_fold = 10;
-
- int i, j, k, s_len;
- int samples_selected;
- CvRNG rng;
- CvRNG* prng;
- int* res_s_data;
- int* te_s_data;
- int* folds;
-
- rng = cvRNG(cvGetTickCount());
- cvRandInt (&rng); cvRandInt (&rng); cvRandInt (&rng); cvRandInt (&rng);
-// Check input parameters.
- if (estimateParams)
- k_fold = ((CvCrossValidationParams*)estimateParams)->k_fold;
- if (!k_fold)
- {
- CV_ERROR (CV_StsBadArg, "Error in parameters of cross-validation (k_fold == 0)!");
- }
- if (samples_all <= 0)
- {
- CV_ERROR (CV_StsBadArg, "<samples_all> should be positive!");
- }
-
-// Alloc memory and fill standart StatModel's fields.
- CV_CALL (crVal = (CvCrossValidationModel*)cvCreateStatModel (
- CV_STAT_MODEL_MAGIC_VAL | CV_CROSSVAL_MAGIC_VAL,
- sizeof(CvCrossValidationModel),
- cvReleaseCrossValidationModel,
- NULL, NULL));
- crVal->current_fold = -1;
- crVal->folds_all = k_fold;
- if (estimateParams && ((CvCrossValidationParams*)estimateParams)->is_regression)
- crVal->is_regression = 1;
- else
- crVal->is_regression = 0;
- if (estimateParams && ((CvCrossValidationParams*)estimateParams)->rng)
- prng = ((CvCrossValidationParams*)estimateParams)->rng;
- else
- prng = &rng;
-
- // Check and preprocess sample indices.
- if (sampleIdx)
- {
- int s_step;
- int s_type = 0;
-
- if (!CV_IS_MAT (sampleIdx))
- CV_ERROR (CV_StsBadArg, "Invalid sampleIdx array");
-
- if (sampleIdx->rows != 1 && sampleIdx->cols != 1)
- CV_ERROR (CV_StsBadSize, "sampleIdx array must be 1-dimensional");
-
- s_len = sampleIdx->rows + sampleIdx->cols - 1;
- s_step = sampleIdx->rows == 1 ?
- 1 : sampleIdx->step / CV_ELEM_SIZE(sampleIdx->type);
-
- s_type = CV_MAT_TYPE (sampleIdx->type);
-
- switch (s_type)
- {
- case CV_8UC1:
- case CV_8SC1:
- {
- uchar* s_data = sampleIdx->data.ptr;
-
- // sampleIdx is array of 1's and 0's -
- // i.e. it is a mask of the selected samples
- if( s_len != samples_all )
- CV_ERROR (CV_StsUnmatchedSizes,
- "Sample mask should contain as many elements as the total number of samples");
-
- samples_selected = 0;
- for (i = 0; i < s_len; i++)
- samples_selected += s_data[i * s_step] != 0;
-
- if (samples_selected == 0)
- CV_ERROR (CV_StsOutOfRange, "No samples is selected!");
- }
- s_len = samples_selected;
- break;
- case CV_32SC1:
- if (s_len > samples_all)
- CV_ERROR (CV_StsOutOfRange,
- "sampleIdx array may not contain more elements than the total number of samples");
- samples_selected = s_len;
- break;
- default:
- CV_ERROR (CV_StsUnsupportedFormat, "Unsupported sampleIdx array data type "
- "(it should be 8uC1, 8sC1 or 32sC1)");
- }
-
- // Alloc additional memory for internal Idx and fill it.
-/*!!*/ CV_CALL (res_s_data = crVal->sampleIdxAll =
- (int*)cvAlloc (2 * s_len * sizeof(int)));
-
- if (s_type < CV_32SC1)
- {
- uchar* s_data = sampleIdx->data.ptr;
- for (i = 0; i < s_len; i++)
- if (s_data[i * s_step])
- {
- *res_s_data++ = i;
- }
- res_s_data = crVal->sampleIdxAll;
- }
- else
- {
- int* s_data = sampleIdx->data.i;
- int out_of_order = 0;
-
- for (i = 0; i < s_len; i++)
- {
- res_s_data[i] = s_data[i * s_step];
- if (i > 0 && res_s_data[i] < res_s_data[i - 1])
- out_of_order = 1;
- }
-
- if (out_of_order)
- qsort (res_s_data, s_len, sizeof(res_s_data[0]), icvCmpIntegers);
-
- if (res_s_data[0] < 0 ||
- res_s_data[s_len - 1] >= samples_all)
- CV_ERROR (CV_StsBadArg, "There are out-of-range sample indices");
- for (i = 1; i < s_len; i++)
- if (res_s_data[i] <= res_s_data[i - 1])
- CV_ERROR (CV_StsBadArg, "There are duplicated");
- }
- }
- else // if (sampleIdx)
- {
- // Alloc additional memory for internal Idx and fill it.
- s_len = samples_all;
- CV_CALL (res_s_data = crVal->sampleIdxAll = (int*)cvAlloc (2 * s_len * sizeof(int)));
- for (i = 0; i < s_len; i++)
- {
- *res_s_data++ = i;
- }
- res_s_data = crVal->sampleIdxAll;
- } // if (sampleIdx) ... else
-
-// Resort internal Idx.
- te_s_data = res_s_data + s_len;
- for (i = s_len; i > 1; i--)
- {
- j = cvRandInt (prng) % i;
- k = *(--te_s_data);
- *te_s_data = res_s_data[j];
- res_s_data[j] = k;
- }
-
-// Duplicate resorted internal Idx.
-// It will be used to simplify operation of getting trainIdx.
- te_s_data = res_s_data + s_len;
- for (i = 0; i < s_len; i++)
- {
- *te_s_data++ = *res_s_data++;
- }
-
-// Cut sampleIdxAll to parts.
- if (k_fold > 0)
- {
- if (k_fold > s_len)
- {
- CV_ERROR (CV_StsBadArg,
- "Error in parameters of cross-validation ('k_fold' > #samples)!");
- }
- folds = crVal->folds = (int*) cvAlloc ((k_fold + 1) * sizeof (int));
- *folds++ = 0;
- for (i = 1; i < k_fold; i++)
- {
- *folds++ = cvRound (i * s_len * 1. / k_fold);
- }
- *folds = s_len;
- folds = crVal->folds;
-
- crVal->max_fold_size = (s_len - 1) / k_fold + 1;
- }
- else
- {
- k = -k_fold;
- crVal->max_fold_size = k;
- if (k >= s_len)
- {
- CV_ERROR (CV_StsBadArg,
- "Error in parameters of cross-validation (-'k_fold' > #samples)!");
- }
- crVal->folds_all = k = (s_len - 1) / k + 1;
-
- folds = crVal->folds = (int*) cvAlloc ((k + 1) * sizeof (int));
- for (i = 0; i < k; i++)
- {
- *folds++ = -i * k_fold;
- }
- *folds = s_len;
- folds = crVal->folds;
- }
-
-// Prepare other internal fields to working.
- CV_CALL (crVal->predict_results = cvCreateMat (1, samples_all, CV_32FC1));
- CV_CALL (crVal->sampleIdxEval = cvCreateMatHeader (1, 1, CV_32SC1));
- CV_CALL (crVal->sampleIdxTrain = cvCreateMatHeader (1, 1, CV_32SC1));
- crVal->sampleIdxEval->cols = 0;
- crVal->sampleIdxTrain->cols = 0;
- crVal->samples_all = s_len;
- crVal->is_checked = 1;
-
- crVal->getTrainIdxMat = cvCrossValGetTrainIdxMatrix;
- crVal->getCheckIdxMat = cvCrossValGetCheckIdxMatrix;
- crVal->nextStep = cvCrossValNextStep;
- crVal->check = cvCrossValCheckClassifier;
- crVal->getResult = cvCrossValGetResult;
- crVal->reset = cvCrossValReset;
-
- model = (CvStatModel*)crVal;
-
- __END__
-
- if (!model)
- {
- cvReleaseCrossValidationModel ((CvStatModel**)&crVal);
- }
-
- return model;
-} // End of cvCreateCrossValidationEstimateModel
-
-
-/****************************************************************************************\
-* Extended interface with backcalls for models *
-\****************************************************************************************/
-ML_IMPL float
-cvCrossValidation (const CvMat* trueData,
- int tflag,
- const CvMat* trueClasses,
- CvStatModel* (*createClassifier) (const CvMat*,
- int,
- const CvMat*,
- const CvClassifierTrainParams*,
- const CvMat*,
- const CvMat*,
- const CvMat*,
- const CvMat*),
- const CvClassifierTrainParams* estimateParams,
- const CvClassifierTrainParams* trainParams,
- const CvMat* compIdx,
- const CvMat* sampleIdx,
- CvStatModel** pCrValModel,
- const CvMat* typeMask,
- const CvMat* missedMeasurementMask)
-{
- CvCrossValidationModel* crVal = NULL;
- float result = 0;
- CvStatModel* pClassifier = NULL;
-
- CV_FUNCNAME ("cvCrossValidation");
- __BEGIN__
-
- const CvMat* trainDataIdx;
- int samples_all;
-
-// checking input data
- if ((createClassifier) == NULL)
- {
- CV_ERROR (CV_StsNullPtr, "Null pointer to functiion which create classifier");
- }
- if (pCrValModel && *pCrValModel && !CV_IS_CROSSVAL(*pCrValModel))
- {
- CV_ERROR (CV_StsBadArg,
- "<pCrValModel> point to not cross-validation model");
- }
-
-// initialization
- if (pCrValModel && *pCrValModel)
- {
- crVal = (CvCrossValidationModel*)*pCrValModel;
- crVal->reset ((CvStatModel*)crVal);
- }
- else
- {
- samples_all = ((tflag) ? trueData->rows : trueData->cols);
- CV_CALL (crVal = (CvCrossValidationModel*)
- cvCreateCrossValidationEstimateModel (samples_all, estimateParams, sampleIdx));
- }
-
- CV_CALL (trainDataIdx = crVal->getTrainIdxMat ((CvStatModel*)crVal));
-
-// operation loop
- for (; crVal->nextStep((CvStatModel*)crVal) != 0; )
- {
- CV_CALL (pClassifier = createClassifier (trueData, tflag, trueClasses,
- trainParams, compIdx, trainDataIdx, typeMask, missedMeasurementMask));
- CV_CALL (crVal->check ((CvStatModel*)crVal, pClassifier,
- trueData, tflag, trueClasses));
-
- pClassifier->release (&pClassifier);
- }
-
-// Get result and fill output field.
- CV_CALL (result = crVal->getResult ((CvStatModel*)crVal, 0));
-
- if (pCrValModel && !*pCrValModel)
- *pCrValModel = (CvStatModel*)crVal;
-
- __END__
-
-// Free all memory that should be freed.
- if (pClassifier)
- pClassifier->release (&pClassifier);
- if (crVal && (!pCrValModel || !*pCrValModel))
- crVal->release ((CvStatModel**)&crVal);
-
- return result;
-} // End of cvCrossValidation
-
-#endif
-
-/* End of file */
#include "precomp.hpp"
#include <time.h>
+#if 0
+
#define pCvSeq CvSeq*
#define pCvDTreeNode CvDTreeNode*
return predict(&_sample, _missing.empty() ? 0 : &miss, 0,
slice==cv::Range::all() ? CV_WHOLE_SEQ : cvSlice(slice.start, slice.end), k);
}
+
+#endif
+
#include "precomp.hpp"
+namespace cv { namespace ml {
-CvStatModel::CvStatModel()
+ParamGrid::ParamGrid() { minVal = maxVal = 0.; logStep = 1; }
+ParamGrid::ParamGrid(double _minVal, double _maxVal, double _logStep)
{
- default_model_name = "my_stat_model";
+ minVal = std::min(_minVal, _maxVal);
+ maxVal = std::max(_minVal, _maxVal);
+ logStep = std::max(_logStep, 1.);
}
+StatModel::~StatModel() {}
+void StatModel::clear() {}
-CvStatModel::~CvStatModel()
-{
- clear();
-}
-
-
-void CvStatModel::clear()
-{
-}
+int StatModel::getVarCount() const { return 0; }
-
-void CvStatModel::save( const char* filename, const char* name ) const
+bool StatModel::train( const Ptr<TrainData>&, int )
{
- CvFileStorage* fs = 0;
-
- CV_FUNCNAME( "CvStatModel::save" );
-
- __BEGIN__;
-
- CV_CALL( fs = cvOpenFileStorage( filename, 0, CV_STORAGE_WRITE ));
- if( !fs )
- CV_ERROR( CV_StsError, "Could not open the file storage. Check the path and permissions" );
-
- write( fs, name ? name : default_model_name );
-
- __END__;
-
- cvReleaseFileStorage( &fs );
+ CV_Error(CV_StsNotImplemented, "");
+ return false;
}
-
-void CvStatModel::load( const char* filename, const char* name )
+float StatModel::calcError( const Ptr<TrainData>& data, bool testerr, OutputArray _resp ) const
{
- CvFileStorage* fs = 0;
+ Mat samples = data->getSamples();
+ int layout = data->getLayout();
+ Mat sidx = testerr ? data->getTestSampleIdx() : data->getTrainSampleIdx();
+ const int* sidx_ptr = sidx.ptr<int>();
+ int i, n = (int)sidx.total();
+ bool isclassifier = isClassifier();
+ Mat responses = data->getResponses();
- CV_FUNCNAME( "CvStatModel::load" );
+ if( n == 0 )
+ n = data->getNSamples();
- __BEGIN__;
+ if( n == 0 )
+ return -FLT_MAX;
- CvFileNode* model_node = 0;
+ Mat resp;
+ if( _resp.needed() )
+ resp.create(n, 1, CV_32F);
- CV_CALL( fs = cvOpenFileStorage( filename, 0, CV_STORAGE_READ ));
- if( !fs )
- EXIT;
-
- if( name )
- model_node = cvGetFileNodeByName( fs, 0, name );
- else
+ double err = 0;
+ for( i = 0; i < n; i++ )
{
- CvFileNode* root = cvGetRootFileNode( fs );
- if( root->data.seq->total > 0 )
- model_node = (CvFileNode*)cvGetSeqElem( root->data.seq, 0 );
- }
+ int si = sidx_ptr ? sidx_ptr[i] : i;
+ Mat sample = layout == ROW_SAMPLE ? samples.row(si) : samples.col(si);
+ float val = predict(sample);
+ float val0 = responses.at<float>(si);
- read( fs, model_node );
-
- __END__;
-
- cvReleaseFileStorage( &fs );
-}
+ if( isclassifier )
+ err += fabs(val - val0) > FLT_EPSILON;
+ else
+ err += (val - val0)*(val - val0);
+ if( resp.data )
+ resp.at<float>(i) = val;
+ /*if( i < 100 )
+ {
+ printf("%d. ref %.1f vs pred %.1f\n", i, val0, val);
+ }*/
+ }
+ if( _resp.needed() )
+ resp.copyTo(_resp);
-void CvStatModel::write( CvFileStorage*, const char* ) const
-{
- OPENCV_ERROR( CV_StsNotImplemented, "CvStatModel::write", "" );
+ return err / n * (isclassifier ? 100 : 1);
}
-
-void CvStatModel::read( CvFileStorage*, CvFileNode* )
+void StatModel::save(const String& filename) const
{
- OPENCV_ERROR( CV_StsNotImplemented, "CvStatModel::read", "" );
+ FileStorage fs(filename, FileStorage::WRITE);
+ fs << getDefaultModelName() << "{";
+ write(fs);
+ fs << "}";
}
-
/* Calculates upper triangular matrix S, where A is a symmetrical matrix A=S'*S */
-static void cvChol( CvMat* A, CvMat* S )
+static void Cholesky( const Mat& A, Mat& S )
{
- int dim = A->rows;
+ CV_Assert(A.type() == CV_32F);
+
+ int dim = A.rows;
+ S.create(dim, dim, CV_32F);
int i, j, k;
- float sum;
for( i = 0; i < dim; i++ )
{
for( j = 0; j < i; j++ )
- CV_MAT_ELEM(*S, float, i, j) = 0;
+ S.at<float>(i,j) = 0.f;
- sum = 0;
+ float sum = 0.f;
for( k = 0; k < i; k++ )
- sum += CV_MAT_ELEM(*S, float, k, i) * CV_MAT_ELEM(*S, float, k, i);
+ {
+ float val = S.at<float>(k,i);
+ sum += val*val;
+ }
- CV_MAT_ELEM(*S, float, i, i) = (float)sqrt(CV_MAT_ELEM(*A, float, i, i) - sum);
+ S.at<float>(i,i) = std::sqrt(std::max(A.at<float>(i,i) - sum, 0.f));
+ float ival = 1.f/S.at<float>(i, i);
for( j = i + 1; j < dim; j++ )
{
sum = 0;
for( k = 0; k < i; k++ )
- sum += CV_MAT_ELEM(*S, float, k, i) * CV_MAT_ELEM(*S, float, k, j);
-
- CV_MAT_ELEM(*S, float, i, j) =
- (CV_MAT_ELEM(*A, float, i, j) - sum) / CV_MAT_ELEM(*S, float, i, i);
+ sum += S.at<float>(k, i) * S.at<float>(k, j);
+ S.at<float>(i, j) = (A.at<float>(i, j) - sum)*ival;
}
}
}
/* Generates <sample> from multivariate normal distribution, where <mean> - is an
average row vector, <cov> - symmetric covariation matrix */
-CV_IMPL void cvRandMVNormal( CvMat* mean, CvMat* cov, CvMat* sample, CvRNG* rng )
-{
- int dim = sample->cols;
- int amount = sample->rows;
-
- CvRNG state = rng ? *rng : cvRNG( cvGetTickCount() );
- cvRandArr(&state, sample, CV_RAND_NORMAL, cvScalarAll(0), cvScalarAll(1) );
-
- CvMat* utmat = cvCreateMat(dim, dim, sample->type);
- CvMat* vect = cvCreateMatHeader(1, dim, sample->type);
-
- cvChol(cov, utmat);
-
- int i;
- for( i = 0; i < amount; i++ )
- {
- cvGetRow(sample, vect, i);
- cvMatMulAdd(vect, utmat, mean, vect);
- }
-
- cvReleaseMat(&vect);
- cvReleaseMat(&utmat);
-}
-
-
-/* Generates <sample> of <amount> points from a discrete variate xi,
- where Pr{xi = k} == probs[k], 0 < k < len - 1. */
-static void cvRandSeries( float probs[], int len, int sample[], int amount )
-{
- CvMat* univals = cvCreateMat(1, amount, CV_32FC1);
- float* knots = (float*)cvAlloc( len * sizeof(float) );
-
- int i, j;
-
- CvRNG state = cvRNG(-1);
- cvRandArr(&state, univals, CV_RAND_UNI, cvScalarAll(0), cvScalarAll(1) );
-
- knots[0] = probs[0];
- for( i = 1; i < len; i++ )
- knots[i] = knots[i - 1] + probs[i];
-
- for( i = 0; i < amount; i++ )
- for( j = 0; j < len; j++ )
- {
- if ( CV_MAT_ELEM(*univals, float, 0, i) <= knots[j] )
- {
- sample[i] = j;
- break;
- }
- }
-
- cvFree(&knots);
-}
-
-/* Generates <sample> from gaussian mixture distribution */
-CV_IMPL void cvRandGaussMixture( CvMat* means[],
- CvMat* covs[],
- float weights[],
- int clsnum,
- CvMat* sample,
- CvMat* sampClasses )
-{
- int dim = sample->cols;
- int amount = sample->rows;
-
- int i, clss;
-
- int* sample_clsnum = (int*)cvAlloc( amount * sizeof(int) );
- CvMat** utmats = (CvMat**)cvAlloc( clsnum * sizeof(CvMat*) );
- CvMat* vect = cvCreateMatHeader(1, dim, CV_32FC1);
-
- CvMat* classes;
- if( sampClasses )
- classes = sampClasses;
- else
- classes = cvCreateMat(1, amount, CV_32FC1);
-
- CvRNG state = cvRNG(-1);
- cvRandArr(&state, sample, CV_RAND_NORMAL, cvScalarAll(0), cvScalarAll(1));
-
- cvRandSeries(weights, clsnum, sample_clsnum, amount);
-
- for( i = 0; i < clsnum; i++ )
- {
- utmats[i] = cvCreateMat(dim, dim, CV_32FC1);
- cvChol(covs[i], utmats[i]);
- }
-
- for( i = 0; i < amount; i++ )
- {
- CV_MAT_ELEM(*classes, float, 0, i) = (float)sample_clsnum[i];
- cvGetRow(sample, vect, i);
- clss = sample_clsnum[i];
- cvMatMulAdd(vect, utmats[clss], means[clss], vect);
- }
-
- if( !sampClasses )
- cvReleaseMat(&classes);
- for( i = 0; i < clsnum; i++ )
- cvReleaseMat(&utmats[i]);
- cvFree(&utmats);
- cvFree(&sample_clsnum);
- cvReleaseMat(&vect);
-}
-
-
-CvMat* icvGenerateRandomClusterCenters ( int seed, const CvMat* data,
- int num_of_clusters, CvMat* _centers )
-{
- CvMat* centers = _centers;
-
- CV_FUNCNAME("icvGenerateRandomClusterCenters");
- __BEGIN__;
-
- CvRNG rng;
- CvMat data_comp, centers_comp;
- CvPoint minLoc, maxLoc; // Not used, just for function "cvMinMaxLoc"
- double minVal, maxVal;
- int i;
- int dim = data ? data->cols : 0;
-
- if( ICV_IS_MAT_OF_TYPE(data, CV_32FC1) )
- {
- if( _centers && !ICV_IS_MAT_OF_TYPE (_centers, CV_32FC1) )
- {
- CV_ERROR(CV_StsBadArg,"");
- }
- else if( !_centers )
- CV_CALL(centers = cvCreateMat (num_of_clusters, dim, CV_32FC1));
- }
- else if( ICV_IS_MAT_OF_TYPE(data, CV_64FC1) )
- {
- if( _centers && !ICV_IS_MAT_OF_TYPE (_centers, CV_64FC1) )
- {
- CV_ERROR(CV_StsBadArg,"");
- }
- else if( !_centers )
- CV_CALL(centers = cvCreateMat (num_of_clusters, dim, CV_64FC1));
- }
- else
- CV_ERROR (CV_StsBadArg,"");
-
- if( num_of_clusters < 1 )
- CV_ERROR (CV_StsBadArg,"");
-
- rng = cvRNG(seed);
- for (i = 0; i < dim; i++)
- {
- CV_CALL(cvGetCol (data, &data_comp, i));
- CV_CALL(cvMinMaxLoc (&data_comp, &minVal, &maxVal, &minLoc, &maxLoc));
- CV_CALL(cvGetCol (centers, ¢ers_comp, i));
- CV_CALL(cvRandArr (&rng, ¢ers_comp, CV_RAND_UNI, cvScalarAll(minVal), cvScalarAll(maxVal)));
- }
-
- __END__;
-
- if( (cvGetErrStatus () < 0) || (centers != _centers) )
- cvReleaseMat (¢ers);
-
- return _centers ? _centers : centers;
-} // end of icvGenerateRandomClusterCenters
-
-// By S. Dilman - begin -
-
-#define ICV_RAND_MAX 4294967296 // == 2^32
-
-// static void cvRandRoundUni (CvMat* center,
-// float radius_small,
-// float radius_large,
-// CvMat* desired_matrix,
-// CvRNG* rng_state_ptr)
-// {
-// float rad, norm, coefficient;
-// int dim, size, i, j;
-// CvMat *cov, sample;
-// CvRNG rng_local;
-
-// CV_FUNCNAME("cvRandRoundUni");
-// __BEGIN__
-
-// rng_local = *rng_state_ptr;
-
-// CV_ASSERT ((radius_small >= 0) &&
-// (radius_large > 0) &&
-// (radius_small <= radius_large));
-// CV_ASSERT (center && desired_matrix && rng_state_ptr);
-// CV_ASSERT (center->rows == 1);
-// CV_ASSERT (center->cols == desired_matrix->cols);
-
-// dim = desired_matrix->cols;
-// size = desired_matrix->rows;
-// cov = cvCreateMat (dim, dim, CV_32FC1);
-// cvSetIdentity (cov);
-// cvRandMVNormal (center, cov, desired_matrix, &rng_local);
-
-// for (i = 0; i < size; i++)
-// {
-// rad = (float)(cvRandReal(&rng_local)*(radius_large - radius_small) + radius_small);
-// cvGetRow (desired_matrix, &sample, i);
-// norm = (float) cvNorm (&sample, 0, CV_L2);
-// coefficient = rad / norm;
-// for (j = 0; j < dim; j++)
-// CV_MAT_ELEM (sample, float, 0, j) *= coefficient;
-// }
-
-// __END__
-
-// }
-
-// By S. Dilman - end -
-
-static int CV_CDECL
-icvCmpIntegers( const void* a, const void* b )
-{
- return *(const int*)a - *(const int*)b;
-}
-
-
-static int CV_CDECL
-icvCmpIntegersPtr( const void* _a, const void* _b )
-{
- int a = **(const int**)_a;
- int b = **(const int**)_b;
- return (a < b ? -1 : 0)|(a > b);
-}
-
-
-static int icvCmpSparseVecElems( const void* a, const void* b )
-{
- return ((CvSparseVecElem32f*)a)->idx - ((CvSparseVecElem32f*)b)->idx;
-}
-
-
-CvMat*
-cvPreprocessIndexArray( const CvMat* idx_arr, int data_arr_size, bool check_for_duplicates )
-{
- CvMat* idx = 0;
-
- CV_FUNCNAME( "cvPreprocessIndexArray" );
-
- __BEGIN__;
-
- int i, idx_total, idx_selected = 0, step, type, prev = INT_MIN, is_sorted = 1;
- uchar* srcb = 0;
- int* srci = 0;
- int* dsti;
-
- if( !CV_IS_MAT(idx_arr) )
- CV_ERROR( CV_StsBadArg, "Invalid index array" );
-
- if( idx_arr->rows != 1 && idx_arr->cols != 1 )
- CV_ERROR( CV_StsBadSize, "the index array must be 1-dimensional" );
-
- idx_total = idx_arr->rows + idx_arr->cols - 1;
- srcb = idx_arr->data.ptr;
- srci = idx_arr->data.i;
-
- type = CV_MAT_TYPE(idx_arr->type);
- step = CV_IS_MAT_CONT(idx_arr->type) ? 1 : idx_arr->step/CV_ELEM_SIZE(type);
-
- switch( type )
- {
- case CV_8UC1:
- case CV_8SC1:
- // idx_arr is array of 1's and 0's -
- // i.e. it is a mask of the selected components
- if( idx_total != data_arr_size )
- CV_ERROR( CV_StsUnmatchedSizes,
- "Component mask should contain as many elements as the total number of input variables" );
-
- for( i = 0; i < idx_total; i++ )
- idx_selected += srcb[i*step] != 0;
-
- if( idx_selected == 0 )
- CV_ERROR( CV_StsOutOfRange, "No components/input_variables is selected!" );
-
- break;
- case CV_32SC1:
- // idx_arr is array of integer indices of selected components
- if( idx_total > data_arr_size )
- CV_ERROR( CV_StsOutOfRange,
- "index array may not contain more elements than the total number of input variables" );
- idx_selected = idx_total;
- // check if sorted already
- for( i = 0; i < idx_total; i++ )
- {
- int val = srci[i*step];
- if( val >= prev )
- {
- is_sorted = 0;
- break;
- }
- prev = val;
- }
- break;
- default:
- CV_ERROR( CV_StsUnsupportedFormat, "Unsupported index array data type "
- "(it should be 8uC1, 8sC1 or 32sC1)" );
- }
-
- CV_CALL( idx = cvCreateMat( 1, idx_selected, CV_32SC1 ));
- dsti = idx->data.i;
-
- if( type < CV_32SC1 )
- {
- for( i = 0; i < idx_total; i++ )
- if( srcb[i*step] )
- *dsti++ = i;
- }
- else
- {
- for( i = 0; i < idx_total; i++ )
- dsti[i] = srci[i*step];
-
- if( !is_sorted )
- qsort( dsti, idx_total, sizeof(dsti[0]), icvCmpIntegers );
-
- if( dsti[0] < 0 || dsti[idx_total-1] >= data_arr_size )
- CV_ERROR( CV_StsOutOfRange, "the index array elements are out of range" );
-
- if( check_for_duplicates )
- {
- for( i = 1; i < idx_total; i++ )
- if( dsti[i] <= dsti[i-1] )
- CV_ERROR( CV_StsBadArg, "There are duplicated index array elements" );
- }
- }
-
- __END__;
-
- if( cvGetErrStatus() < 0 )
- cvReleaseMat( &idx );
-
- return idx;
-}
-
-
-CvMat*
-cvPreprocessVarType( const CvMat* var_type, const CvMat* var_idx,
- int var_count, int* response_type )
-{
- CvMat* out_var_type = 0;
- CV_FUNCNAME( "cvPreprocessVarType" );
-
- if( response_type )
- *response_type = -1;
-
- __BEGIN__;
-
- int i, tm_size, tm_step;
- //int* map = 0;
- const uchar* src;
- uchar* dst;
-
- if( !CV_IS_MAT(var_type) )
- CV_ERROR( var_type ? CV_StsBadArg : CV_StsNullPtr, "Invalid or absent var_type array" );
-
- if( var_type->rows != 1 && var_type->cols != 1 )
- CV_ERROR( CV_StsBadSize, "var_type array must be 1-dimensional" );
-
- if( !CV_IS_MASK_ARR(var_type))
- CV_ERROR( CV_StsUnsupportedFormat, "type mask must be 8uC1 or 8sC1 array" );
-
- tm_size = var_type->rows + var_type->cols - 1;
- tm_step = var_type->rows == 1 ? 1 : var_type->step/CV_ELEM_SIZE(var_type->type);
-
- if( /*tm_size != var_count &&*/ tm_size != var_count + 1 )
- CV_ERROR( CV_StsBadArg,
- "type mask must be of <input var count> + 1 size" );
-
- if( response_type && tm_size > var_count )
- *response_type = var_type->data.ptr[var_count*tm_step] != 0;
-
- if( var_idx )
- {
- if( !CV_IS_MAT(var_idx) || CV_MAT_TYPE(var_idx->type) != CV_32SC1 ||
- (var_idx->rows != 1 && var_idx->cols != 1) || !CV_IS_MAT_CONT(var_idx->type) )
- CV_ERROR( CV_StsBadArg, "var index array should be continuous 1-dimensional integer vector" );
- if( var_idx->rows + var_idx->cols - 1 > var_count )
- CV_ERROR( CV_StsBadSize, "var index array is too large" );
- //map = var_idx->data.i;
- var_count = var_idx->rows + var_idx->cols - 1;
- }
-
- CV_CALL( out_var_type = cvCreateMat( 1, var_count, CV_8UC1 ));
- src = var_type->data.ptr;
- dst = out_var_type->data.ptr;
-
- for( i = 0; i < var_count; i++ )
- {
- //int idx = map ? map[i] : i;
- assert( (unsigned)/*idx*/i < (unsigned)tm_size );
- dst[i] = (uchar)(src[/*idx*/i*tm_step] != 0);
- }
-
- __END__;
-
- return out_var_type;
-}
-
-
-CvMat*
-cvPreprocessOrderedResponses( const CvMat* responses, const CvMat* sample_idx, int sample_all )
-{
- CvMat* out_responses = 0;
-
- CV_FUNCNAME( "cvPreprocessOrderedResponses" );
-
- __BEGIN__;
-
- int i, r_type, r_step;
- const int* map = 0;
- float* dst;
- int sample_count = sample_all;
-
- if( !CV_IS_MAT(responses) )
- CV_ERROR( CV_StsBadArg, "Invalid response array" );
-
- if( responses->rows != 1 && responses->cols != 1 )
- CV_ERROR( CV_StsBadSize, "Response array must be 1-dimensional" );
-
- if( responses->rows + responses->cols - 1 != sample_count )
- CV_ERROR( CV_StsUnmatchedSizes,
- "Response array must contain as many elements as the total number of samples" );
-
- r_type = CV_MAT_TYPE(responses->type);
- if( r_type != CV_32FC1 && r_type != CV_32SC1 )
- CV_ERROR( CV_StsUnsupportedFormat, "Unsupported response type" );
-
- r_step = responses->step ? responses->step / CV_ELEM_SIZE(responses->type) : 1;
-
- if( r_type == CV_32FC1 && CV_IS_MAT_CONT(responses->type) && !sample_idx )
- {
- out_responses = cvCloneMat( responses );
- EXIT;
- }
-
- if( sample_idx )
- {
- if( !CV_IS_MAT(sample_idx) || CV_MAT_TYPE(sample_idx->type) != CV_32SC1 ||
- (sample_idx->rows != 1 && sample_idx->cols != 1) || !CV_IS_MAT_CONT(sample_idx->type) )
- CV_ERROR( CV_StsBadArg, "sample index array should be continuous 1-dimensional integer vector" );
- if( sample_idx->rows + sample_idx->cols - 1 > sample_count )
- CV_ERROR( CV_StsBadSize, "sample index array is too large" );
- map = sample_idx->data.i;
- sample_count = sample_idx->rows + sample_idx->cols - 1;
- }
-
- CV_CALL( out_responses = cvCreateMat( 1, sample_count, CV_32FC1 ));
-
- dst = out_responses->data.fl;
- if( r_type == CV_32FC1 )
- {
- const float* src = responses->data.fl;
- for( i = 0; i < sample_count; i++ )
- {
- int idx = map ? map[i] : i;
- assert( (unsigned)idx < (unsigned)sample_all );
- dst[i] = src[idx*r_step];
- }
- }
- else
- {
- const int* src = responses->data.i;
- for( i = 0; i < sample_count; i++ )
- {
- int idx = map ? map[i] : i;
- assert( (unsigned)idx < (unsigned)sample_all );
- dst[i] = (float)src[idx*r_step];
- }
- }
-
- __END__;
-
- return out_responses;
-}
-
-CvMat*
-cvPreprocessCategoricalResponses( const CvMat* responses,
- const CvMat* sample_idx, int sample_all,
- CvMat** out_response_map, CvMat** class_counts )
-{
- CvMat* out_responses = 0;
- int** response_ptr = 0;
-
- CV_FUNCNAME( "cvPreprocessCategoricalResponses" );
-
- if( out_response_map )
- *out_response_map = 0;
-
- if( class_counts )
- *class_counts = 0;
-
- __BEGIN__;
-
- int i, r_type, r_step;
- int cls_count = 1, prev_cls, prev_i;
- const int* map = 0;
- const int* srci;
- const float* srcfl;
- int* dst;
- int* cls_map;
- int* cls_counts = 0;
- int sample_count = sample_all;
-
- if( !CV_IS_MAT(responses) )
- CV_ERROR( CV_StsBadArg, "Invalid response array" );
-
- if( responses->rows != 1 && responses->cols != 1 )
- CV_ERROR( CV_StsBadSize, "Response array must be 1-dimensional" );
-
- if( responses->rows + responses->cols - 1 != sample_count )
- CV_ERROR( CV_StsUnmatchedSizes,
- "Response array must contain as many elements as the total number of samples" );
-
- r_type = CV_MAT_TYPE(responses->type);
- if( r_type != CV_32FC1 && r_type != CV_32SC1 )
- CV_ERROR( CV_StsUnsupportedFormat, "Unsupported response type" );
-
- r_step = responses->rows == 1 ? 1 : responses->step / CV_ELEM_SIZE(responses->type);
-
- if( sample_idx )
- {
- if( !CV_IS_MAT(sample_idx) || CV_MAT_TYPE(sample_idx->type) != CV_32SC1 ||
- (sample_idx->rows != 1 && sample_idx->cols != 1) || !CV_IS_MAT_CONT(sample_idx->type) )
- CV_ERROR( CV_StsBadArg, "sample index array should be continuous 1-dimensional integer vector" );
- if( sample_idx->rows + sample_idx->cols - 1 > sample_count )
- CV_ERROR( CV_StsBadSize, "sample index array is too large" );
- map = sample_idx->data.i;
- sample_count = sample_idx->rows + sample_idx->cols - 1;
- }
-
- CV_CALL( out_responses = cvCreateMat( 1, sample_count, CV_32SC1 ));
-
- if( !out_response_map )
- CV_ERROR( CV_StsNullPtr, "out_response_map pointer is NULL" );
-
- CV_CALL( response_ptr = (int**)cvAlloc( sample_count*sizeof(response_ptr[0])));
-
- srci = responses->data.i;
- srcfl = responses->data.fl;
- dst = out_responses->data.i;
-
- for( i = 0; i < sample_count; i++ )
- {
- int idx = map ? map[i] : i;
- assert( (unsigned)idx < (unsigned)sample_all );
- if( r_type == CV_32SC1 )
- dst[i] = srci[idx*r_step];
- else
- {
- float rf = srcfl[idx*r_step];
- int ri = cvRound(rf);
- if( ri != rf )
- {
- char buf[100];
- sprintf( buf, "response #%d is not integral", idx );
- CV_ERROR( CV_StsBadArg, buf );
- }
- dst[i] = ri;
- }
- response_ptr[i] = dst + i;
- }
-
- qsort( response_ptr, sample_count, sizeof(int*), icvCmpIntegersPtr );
-
- // count the classes
- for( i = 1; i < sample_count; i++ )
- cls_count += *response_ptr[i] != *response_ptr[i-1];
-
- if( cls_count < 2 )
- CV_ERROR( CV_StsBadArg, "There is only a single class" );
-
- CV_CALL( *out_response_map = cvCreateMat( 1, cls_count, CV_32SC1 ));
-
- if( class_counts )
- {
- CV_CALL( *class_counts = cvCreateMat( 1, cls_count, CV_32SC1 ));
- cls_counts = (*class_counts)->data.i;
- }
-
- // compact the class indices and build the map
- prev_cls = ~*response_ptr[0];
- cls_count = -1;
- cls_map = (*out_response_map)->data.i;
-
- for( i = 0, prev_i = -1; i < sample_count; i++ )
- {
- int cur_cls = *response_ptr[i];
- if( cur_cls != prev_cls )
- {
- if( cls_counts && cls_count >= 0 )
- cls_counts[cls_count] = i - prev_i;
- cls_map[++cls_count] = prev_cls = cur_cls;
- prev_i = i;
- }
- *response_ptr[i] = cls_count;
- }
-
- if( cls_counts )
- cls_counts[cls_count] = i - prev_i;
-
- __END__;
-
- cvFree( &response_ptr );
-
- return out_responses;
-}
-
-
-const float**
-cvGetTrainSamples( const CvMat* train_data, int tflag,
- const CvMat* var_idx, const CvMat* sample_idx,
- int* _var_count, int* _sample_count,
- bool always_copy_data )
+void randMVNormal( InputArray _mean, InputArray _cov, int nsamples, OutputArray _samples )
{
- float** samples = 0;
-
- CV_FUNCNAME( "cvGetTrainSamples" );
-
- __BEGIN__;
-
- int i, j, var_count, sample_count, s_step, v_step;
- bool copy_data;
- const float* data;
- const int *s_idx, *v_idx;
+ Mat mean = _mean.getMat(), cov = _cov.getMat();
+ int dim = (int)mean.total();
- if( !CV_IS_MAT(train_data) )
- CV_ERROR( CV_StsBadArg, "Invalid or NULL training data matrix" );
+ _samples.create(nsamples, dim, CV_32F);
+ Mat samples = _samples.getMat();
+ randu(samples, 0., 1.);
- var_count = var_idx ? var_idx->cols + var_idx->rows - 1 :
- tflag == CV_ROW_SAMPLE ? train_data->cols : train_data->rows;
- sample_count = sample_idx ? sample_idx->cols + sample_idx->rows - 1 :
- tflag == CV_ROW_SAMPLE ? train_data->rows : train_data->cols;
+ Mat utmat;
+ Cholesky(cov, utmat);
+ int flags = mean.cols == 1 ? 0 : GEMM_3_T;
- if( _var_count )
- *_var_count = var_count;
-
- if( _sample_count )
- *_sample_count = sample_count;
-
- copy_data = tflag != CV_ROW_SAMPLE || var_idx || always_copy_data;
-
- CV_CALL( samples = (float**)cvAlloc(sample_count*sizeof(samples[0]) +
- (copy_data ? 1 : 0)*var_count*sample_count*sizeof(samples[0][0])) );
- data = train_data->data.fl;
- s_step = train_data->step / sizeof(samples[0][0]);
- v_step = 1;
- s_idx = sample_idx ? sample_idx->data.i : 0;
- v_idx = var_idx ? var_idx->data.i : 0;
-
- if( !copy_data )
+ for( int i = 0; i < nsamples; i++ )
{
- for( i = 0; i < sample_count; i++ )
- samples[i] = (float*)(data + (s_idx ? s_idx[i] : i)*s_step);
- }
- else
- {
- samples[0] = (float*)(samples + sample_count);
- if( tflag != CV_ROW_SAMPLE )
- CV_SWAP( s_step, v_step, i );
-
- for( i = 0; i < sample_count; i++ )
- {
- float* dst = samples[i] = samples[0] + i*var_count;
- const float* src = data + (s_idx ? s_idx[i] : i)*s_step;
-
- if( !v_idx )
- for( j = 0; j < var_count; j++ )
- dst[j] = src[j*v_step];
- else
- for( j = 0; j < var_count; j++ )
- dst[j] = src[v_idx[j]*v_step];
- }
+ Mat sample = samples.row(i);
+ gemm(sample, utmat, 1, mean, 1, sample, flags);
}
-
- __END__;
-
- return (const float**)samples;
}
-
-void
-cvCheckTrainData( const CvMat* train_data, int tflag,
- const CvMat* missing_mask,
- int* var_all, int* sample_all )
-{
- CV_FUNCNAME( "cvCheckTrainData" );
-
- if( var_all )
- *var_all = 0;
-
- if( sample_all )
- *sample_all = 0;
-
- __BEGIN__;
-
- // check parameter types and sizes
- if( !CV_IS_MAT(train_data) || CV_MAT_TYPE(train_data->type) != CV_32FC1 )
- CV_ERROR( CV_StsBadArg, "train data must be floating-point matrix" );
-
- if( missing_mask )
- {
- if( !CV_IS_MAT(missing_mask) || !CV_IS_MASK_ARR(missing_mask) ||
- !CV_ARE_SIZES_EQ(train_data, missing_mask) )
- CV_ERROR( CV_StsBadArg,
- "missing value mask must be 8-bit matrix of the same size as training data" );
- }
-
- if( tflag != CV_ROW_SAMPLE && tflag != CV_COL_SAMPLE )
- CV_ERROR( CV_StsBadArg,
- "Unknown training data layout (must be CV_ROW_SAMPLE or CV_COL_SAMPLE)" );
-
- if( var_all )
- *var_all = tflag == CV_ROW_SAMPLE ? train_data->cols : train_data->rows;
-
- if( sample_all )
- *sample_all = tflag == CV_ROW_SAMPLE ? train_data->rows : train_data->cols;
-
- __END__;
-}
-
-
-int
-cvPrepareTrainData( const char* /*funcname*/,
- const CvMat* train_data, int tflag,
- const CvMat* responses, int response_type,
- const CvMat* var_idx,
- const CvMat* sample_idx,
- bool always_copy_data,
- const float*** out_train_samples,
- int* _sample_count,
- int* _var_count,
- int* _var_all,
- CvMat** out_responses,
- CvMat** out_response_map,
- CvMat** out_var_idx,
- CvMat** out_sample_idx )
-{
- int ok = 0;
- CvMat* _var_idx = 0;
- CvMat* _sample_idx = 0;
- CvMat* _responses = 0;
- int sample_all = 0, sample_count = 0, var_all = 0, var_count = 0;
-
- CV_FUNCNAME( "cvPrepareTrainData" );
-
- // step 0. clear all the output pointers to ensure we do not try
- // to call free() with uninitialized pointers
- if( out_responses )
- *out_responses = 0;
-
- if( out_response_map )
- *out_response_map = 0;
-
- if( out_var_idx )
- *out_var_idx = 0;
-
- if( out_sample_idx )
- *out_sample_idx = 0;
-
- if( out_train_samples )
- *out_train_samples = 0;
-
- if( _sample_count )
- *_sample_count = 0;
-
- if( _var_count )
- *_var_count = 0;
-
- if( _var_all )
- *_var_all = 0;
-
- __BEGIN__;
-
- if( !out_train_samples )
- CV_ERROR( CV_StsBadArg, "output pointer to train samples is NULL" );
-
- CV_CALL( cvCheckTrainData( train_data, tflag, 0, &var_all, &sample_all ));
-
- if( sample_idx )
- CV_CALL( _sample_idx = cvPreprocessIndexArray( sample_idx, sample_all ));
- if( var_idx )
- CV_CALL( _var_idx = cvPreprocessIndexArray( var_idx, var_all ));
-
- if( responses )
- {
- if( !out_responses )
- CV_ERROR( CV_StsNullPtr, "output response pointer is NULL" );
-
- if( response_type == CV_VAR_NUMERICAL )
- {
- CV_CALL( _responses = cvPreprocessOrderedResponses( responses,
- _sample_idx, sample_all ));
- }
- else
- {
- CV_CALL( _responses = cvPreprocessCategoricalResponses( responses,
- _sample_idx, sample_all, out_response_map, 0 ));
- }
- }
-
- CV_CALL( *out_train_samples =
- cvGetTrainSamples( train_data, tflag, _var_idx, _sample_idx,
- &var_count, &sample_count, always_copy_data ));
-
- ok = 1;
-
- __END__;
-
- if( ok )
- {
- if( out_responses )
- *out_responses = _responses, _responses = 0;
-
- if( out_var_idx )
- *out_var_idx = _var_idx, _var_idx = 0;
-
- if( out_sample_idx )
- *out_sample_idx = _sample_idx, _sample_idx = 0;
-
- if( _sample_count )
- *_sample_count = sample_count;
-
- if( _var_count )
- *_var_count = var_count;
-
- if( _var_all )
- *_var_all = var_all;
- }
- else
- {
- if( out_response_map )
- cvReleaseMat( out_response_map );
- cvFree( out_train_samples );
- }
-
- if( _responses != responses )
- cvReleaseMat( &_responses );
- cvReleaseMat( &_var_idx );
- cvReleaseMat( &_sample_idx );
-
- return ok;
-}
-
-
-typedef struct CvSampleResponsePair
-{
- const float* sample;
- const uchar* mask;
- int response;
- int index;
-}
-CvSampleResponsePair;
-
-
-static int
-CV_CDECL icvCmpSampleResponsePairs( const void* a, const void* b )
-{
- int ra = ((const CvSampleResponsePair*)a)->response;
- int rb = ((const CvSampleResponsePair*)b)->response;
- int ia = ((const CvSampleResponsePair*)a)->index;
- int ib = ((const CvSampleResponsePair*)b)->index;
-
- return ra < rb ? -1 : ra > rb ? 1 : ia - ib;
- //return (ra > rb ? -1 : 0)|(ra < rb);
-}
-
-
-void
-cvSortSamplesByClasses( const float** samples, const CvMat* classes,
- int* class_ranges, const uchar** mask )
-{
- CvSampleResponsePair* pairs = 0;
- CV_FUNCNAME( "cvSortSamplesByClasses" );
-
- __BEGIN__;
-
- int i, k = 0, sample_count;
-
- if( !samples || !classes || !class_ranges )
- CV_ERROR( CV_StsNullPtr, "INTERNAL ERROR: some of the args are NULL pointers" );
-
- if( classes->rows != 1 || CV_MAT_TYPE(classes->type) != CV_32SC1 )
- CV_ERROR( CV_StsBadArg, "classes array must be a single row of integers" );
-
- sample_count = classes->cols;
- CV_CALL( pairs = (CvSampleResponsePair*)cvAlloc( (sample_count+1)*sizeof(pairs[0])));
-
- for( i = 0; i < sample_count; i++ )
- {
- pairs[i].sample = samples[i];
- pairs[i].mask = (mask) ? (mask[i]) : 0;
- pairs[i].response = classes->data.i[i];
- pairs[i].index = i;
- assert( classes->data.i[i] >= 0 );
- }
-
- qsort( pairs, sample_count, sizeof(pairs[0]), icvCmpSampleResponsePairs );
- pairs[sample_count].response = -1;
- class_ranges[0] = 0;
-
- for( i = 0; i < sample_count; i++ )
- {
- samples[i] = pairs[i].sample;
- if (mask)
- mask[i] = pairs[i].mask;
- classes->data.i[i] = pairs[i].response;
-
- if( pairs[i].response != pairs[i+1].response )
- class_ranges[++k] = i+1;
- }
-
- __END__;
-
- cvFree( &pairs );
-}
-
-
-void
-cvPreparePredictData( const CvArr* _sample, int dims_all,
- const CvMat* comp_idx, int class_count,
- const CvMat* prob, float** _row_sample,
- int as_sparse )
-{
- float* row_sample = 0;
- int* inverse_comp_idx = 0;
-
- CV_FUNCNAME( "cvPreparePredictData" );
-
- __BEGIN__;
-
- const CvMat* sample = (const CvMat*)_sample;
- float* sample_data;
- int sample_step;
- int is_sparse = CV_IS_SPARSE_MAT(sample);
- int d, sizes[CV_MAX_DIM];
- int i, dims_selected;
- int vec_size;
-
- if( !is_sparse && !CV_IS_MAT(sample) )
- CV_ERROR( !sample ? CV_StsNullPtr : CV_StsBadArg, "The sample is not a valid vector" );
-
- if( cvGetElemType( sample ) != CV_32FC1 )
- CV_ERROR( CV_StsUnsupportedFormat, "Input sample must have 32fC1 type" );
-
- CV_CALL( d = cvGetDims( sample, sizes ));
-
- if( !((is_sparse && d == 1) || (!is_sparse && d == 2 && (sample->rows == 1 || sample->cols == 1))) )
- CV_ERROR( CV_StsBadSize, "Input sample must be 1-dimensional vector" );
-
- if( d == 1 )
- sizes[1] = 1;
-
- if( sizes[0] + sizes[1] - 1 != dims_all )
- CV_ERROR( CV_StsUnmatchedSizes,
- "The sample size is different from what has been used for training" );
-
- if( !_row_sample )
- CV_ERROR( CV_StsNullPtr, "INTERNAL ERROR: The row_sample pointer is NULL" );
-
- if( comp_idx && (!CV_IS_MAT(comp_idx) || comp_idx->rows != 1 ||
- CV_MAT_TYPE(comp_idx->type) != CV_32SC1) )
- CV_ERROR( CV_StsBadArg, "INTERNAL ERROR: invalid comp_idx" );
-
- dims_selected = comp_idx ? comp_idx->cols : dims_all;
-
- if( prob )
- {
- if( !CV_IS_MAT(prob) )
- CV_ERROR( CV_StsBadArg, "The output matrix of probabilities is invalid" );
-
- if( (prob->rows != 1 && prob->cols != 1) ||
- (CV_MAT_TYPE(prob->type) != CV_32FC1 &&
- CV_MAT_TYPE(prob->type) != CV_64FC1) )
- CV_ERROR( CV_StsBadSize,
- "The matrix of probabilities must be 1-dimensional vector of 32fC1 type" );
-
- if( prob->rows + prob->cols - 1 != class_count )
- CV_ERROR( CV_StsUnmatchedSizes,
- "The vector of probabilities must contain as many elements as "
- "the number of classes in the training set" );
- }
-
- vec_size = !as_sparse ? dims_selected*sizeof(row_sample[0]) :
- (dims_selected + 1)*sizeof(CvSparseVecElem32f);
-
- if( CV_IS_MAT(sample) )
- {
- sample_data = sample->data.fl;
- sample_step = CV_IS_MAT_CONT(sample->type) ? 1 : sample->step/sizeof(row_sample[0]);
-
- if( !comp_idx && CV_IS_MAT_CONT(sample->type) && !as_sparse )
- *_row_sample = sample_data;
- else
- {
- CV_CALL( row_sample = (float*)cvAlloc( vec_size ));
-
- if( !comp_idx )
- for( i = 0; i < dims_selected; i++ )
- row_sample[i] = sample_data[sample_step*i];
- else
- {
- int* comp = comp_idx->data.i;
- for( i = 0; i < dims_selected; i++ )
- row_sample[i] = sample_data[sample_step*comp[i]];
- }
-
- *_row_sample = row_sample;
- }
-
- if( as_sparse )
- {
- const float* src = (const float*)row_sample;
- CvSparseVecElem32f* dst = (CvSparseVecElem32f*)row_sample;
-
- dst[dims_selected].idx = -1;
- for( i = dims_selected - 1; i >= 0; i-- )
- {
- dst[i].idx = i;
- dst[i].val = src[i];
- }
- }
- }
- else
- {
- CvSparseNode* node;
- CvSparseMatIterator mat_iterator;
- const CvSparseMat* sparse = (const CvSparseMat*)sample;
- assert( is_sparse );
-
- node = cvInitSparseMatIterator( sparse, &mat_iterator );
- CV_CALL( row_sample = (float*)cvAlloc( vec_size ));
-
- if( comp_idx )
- {
- CV_CALL( inverse_comp_idx = (int*)cvAlloc( dims_all*sizeof(int) ));
- memset( inverse_comp_idx, -1, dims_all*sizeof(int) );
- for( i = 0; i < dims_selected; i++ )
- inverse_comp_idx[comp_idx->data.i[i]] = i;
- }
-
- if( !as_sparse )
- {
- memset( row_sample, 0, vec_size );
-
- for( ; node != 0; node = cvGetNextSparseNode(&mat_iterator) )
- {
- int idx = *CV_NODE_IDX( sparse, node );
- if( inverse_comp_idx )
- {
- idx = inverse_comp_idx[idx];
- if( idx < 0 )
- continue;
- }
- row_sample[idx] = *(float*)CV_NODE_VAL( sparse, node );
- }
- }
- else
- {
- CvSparseVecElem32f* ptr = (CvSparseVecElem32f*)row_sample;
-
- for( ; node != 0; node = cvGetNextSparseNode(&mat_iterator) )
- {
- int idx = *CV_NODE_IDX( sparse, node );
- if( inverse_comp_idx )
- {
- idx = inverse_comp_idx[idx];
- if( idx < 0 )
- continue;
- }
- ptr->idx = idx;
- ptr->val = *(float*)CV_NODE_VAL( sparse, node );
- ptr++;
- }
-
- qsort( row_sample, ptr - (CvSparseVecElem32f*)row_sample,
- sizeof(ptr[0]), icvCmpSparseVecElems );
- ptr->idx = -1;
- }
-
- *_row_sample = row_sample;
- }
-
- __END__;
-
- if( inverse_comp_idx )
- cvFree( &inverse_comp_idx );
-
- if( cvGetErrStatus() < 0 && _row_sample )
- {
- cvFree( &row_sample );
- *_row_sample = 0;
- }
-}
-
-
-static void
-icvConvertDataToSparse( const uchar* src, int src_step, int src_type,
- uchar* dst, int dst_step, int dst_type,
- CvSize size, int* idx )
-{
- CV_FUNCNAME( "icvConvertDataToSparse" );
-
- __BEGIN__;
-
- int i, j;
- src_type = CV_MAT_TYPE(src_type);
- dst_type = CV_MAT_TYPE(dst_type);
-
- if( CV_MAT_CN(src_type) != 1 || CV_MAT_CN(dst_type) != 1 )
- CV_ERROR( CV_StsUnsupportedFormat, "The function supports only single-channel arrays" );
-
- if( src_step == 0 )
- src_step = CV_ELEM_SIZE(src_type);
-
- if( dst_step == 0 )
- dst_step = CV_ELEM_SIZE(dst_type);
-
- // if there is no "idx" and if both arrays are continuous,
- // do the whole processing (copying or conversion) in a single loop
- if( !idx && CV_ELEM_SIZE(src_type)*size.width == src_step &&
- CV_ELEM_SIZE(dst_type)*size.width == dst_step )
- {
- size.width *= size.height;
- size.height = 1;
- }
-
- if( src_type == dst_type )
- {
- int full_width = CV_ELEM_SIZE(dst_type)*size.width;
-
- if( full_width == sizeof(int) ) // another common case: copy int's or float's
- for( i = 0; i < size.height; i++, src += src_step )
- *(int*)(dst + dst_step*(idx ? idx[i] : i)) = *(int*)src;
- else
- for( i = 0; i < size.height; i++, src += src_step )
- memcpy( dst + dst_step*(idx ? idx[i] : i), src, full_width );
- }
- else if( src_type == CV_32SC1 && (dst_type == CV_32FC1 || dst_type == CV_64FC1) )
- for( i = 0; i < size.height; i++, src += src_step )
- {
- uchar* _dst = dst + dst_step*(idx ? idx[i] : i);
- if( dst_type == CV_32FC1 )
- for( j = 0; j < size.width; j++ )
- ((float*)_dst)[j] = (float)((int*)src)[j];
- else
- for( j = 0; j < size.width; j++ )
- ((double*)_dst)[j] = ((int*)src)[j];
- }
- else if( (src_type == CV_32FC1 || src_type == CV_64FC1) && dst_type == CV_32SC1 )
- for( i = 0; i < size.height; i++, src += src_step )
- {
- uchar* _dst = dst + dst_step*(idx ? idx[i] : i);
- if( src_type == CV_32FC1 )
- for( j = 0; j < size.width; j++ )
- ((int*)_dst)[j] = cvRound(((float*)src)[j]);
- else
- for( j = 0; j < size.width; j++ )
- ((int*)_dst)[j] = cvRound(((double*)src)[j]);
- }
- else if( (src_type == CV_32FC1 && dst_type == CV_64FC1) ||
- (src_type == CV_64FC1 && dst_type == CV_32FC1) )
- for( i = 0; i < size.height; i++, src += src_step )
- {
- uchar* _dst = dst + dst_step*(idx ? idx[i] : i);
- if( src_type == CV_32FC1 )
- for( j = 0; j < size.width; j++ )
- ((double*)_dst)[j] = ((float*)src)[j];
- else
- for( j = 0; j < size.width; j++ )
- ((float*)_dst)[j] = (float)((double*)src)[j];
- }
- else
- CV_ERROR( CV_StsUnsupportedFormat, "Unsupported combination of input and output vectors" );
-
- __END__;
-}
-
-
-void
-cvWritebackLabels( const CvMat* labels, CvMat* dst_labels,
- const CvMat* centers, CvMat* dst_centers,
- const CvMat* probs, CvMat* dst_probs,
- const CvMat* sample_idx, int samples_all,
- const CvMat* comp_idx, int dims_all )
-{
- CV_FUNCNAME( "cvWritebackLabels" );
-
- __BEGIN__;
-
- int samples_selected = samples_all, dims_selected = dims_all;
-
- if( dst_labels && !CV_IS_MAT(dst_labels) )
- CV_ERROR( CV_StsBadArg, "Array of output labels is not a valid matrix" );
-
- if( dst_centers )
- if( !ICV_IS_MAT_OF_TYPE(dst_centers, CV_32FC1) &&
- !ICV_IS_MAT_OF_TYPE(dst_centers, CV_64FC1) )
- CV_ERROR( CV_StsBadArg, "Array of cluster centers is not a valid matrix" );
-
- if( dst_probs && !CV_IS_MAT(dst_probs) )
- CV_ERROR( CV_StsBadArg, "Probability matrix is not valid" );
-
- if( sample_idx )
- {
- CV_ASSERT( sample_idx->rows == 1 && CV_MAT_TYPE(sample_idx->type) == CV_32SC1 );
- samples_selected = sample_idx->cols;
- }
-
- if( comp_idx )
- {
- CV_ASSERT( comp_idx->rows == 1 && CV_MAT_TYPE(comp_idx->type) == CV_32SC1 );
- dims_selected = comp_idx->cols;
- }
-
- if( dst_labels && (!labels || labels->data.ptr != dst_labels->data.ptr) )
- {
- if( !labels )
- CV_ERROR( CV_StsNullPtr, "NULL labels" );
-
- CV_ASSERT( labels->rows == 1 );
-
- if( dst_labels->rows != 1 && dst_labels->cols != 1 )
- CV_ERROR( CV_StsBadSize, "Array of output labels should be 1d vector" );
-
- if( dst_labels->rows + dst_labels->cols - 1 != samples_all )
- CV_ERROR( CV_StsUnmatchedSizes,
- "Size of vector of output labels is not equal to the total number of input samples" );
-
- CV_ASSERT( labels->cols == samples_selected );
-
- CV_CALL( icvConvertDataToSparse( labels->data.ptr, labels->step, labels->type,
- dst_labels->data.ptr, dst_labels->step, dst_labels->type,
- cvSize( 1, samples_selected ), sample_idx ? sample_idx->data.i : 0 ));
- }
-
- if( dst_centers && (!centers || centers->data.ptr != dst_centers->data.ptr) )
- {
- int i;
-
- if( !centers )
- CV_ERROR( CV_StsNullPtr, "NULL centers" );
-
- if( centers->rows != dst_centers->rows )
- CV_ERROR( CV_StsUnmatchedSizes, "Invalid number of rows in matrix of output centers" );
-
- if( dst_centers->cols != dims_all )
- CV_ERROR( CV_StsUnmatchedSizes,
- "Number of columns in matrix of output centers is "
- "not equal to the total number of components in the input samples" );
-
- CV_ASSERT( centers->cols == dims_selected );
-
- for( i = 0; i < centers->rows; i++ )
- CV_CALL( icvConvertDataToSparse( centers->data.ptr + i*centers->step, 0, centers->type,
- dst_centers->data.ptr + i*dst_centers->step, 0, dst_centers->type,
- cvSize( 1, dims_selected ), comp_idx ? comp_idx->data.i : 0 ));
- }
-
- if( dst_probs && (!probs || probs->data.ptr != dst_probs->data.ptr) )
- {
- if( !probs )
- CV_ERROR( CV_StsNullPtr, "NULL probs" );
-
- if( probs->cols != dst_probs->cols )
- CV_ERROR( CV_StsUnmatchedSizes, "Invalid number of columns in output probability matrix" );
-
- if( dst_probs->rows != samples_all )
- CV_ERROR( CV_StsUnmatchedSizes,
- "Number of rows in output probability matrix is "
- "not equal to the total number of input samples" );
-
- CV_ASSERT( probs->rows == samples_selected );
-
- CV_CALL( icvConvertDataToSparse( probs->data.ptr, probs->step, probs->type,
- dst_probs->data.ptr, dst_probs->step, dst_probs->type,
- cvSize( probs->cols, samples_selected ),
- sample_idx ? sample_idx->data.i : 0 ));
- }
-
- __END__;
-}
-
-#if 0
-CV_IMPL void
-cvStatModelMultiPredict( const CvStatModel* stat_model,
- const CvArr* predict_input,
- int flags, CvMat* predict_output,
- CvMat* probs, const CvMat* sample_idx )
-{
- CvMemStorage* storage = 0;
- CvMat* sample_idx_buffer = 0;
- CvSparseMat** sparse_rows = 0;
- int samples_selected = 0;
-
- CV_FUNCNAME( "cvStatModelMultiPredict" );
-
- __BEGIN__;
-
- int i;
- int predict_output_step = 1, sample_idx_step = 1;
- int type;
- int d, sizes[CV_MAX_DIM];
- int tflag = flags == CV_COL_SAMPLE;
- int samples_all, dims_all;
- int is_sparse = CV_IS_SPARSE_MAT(predict_input);
- CvMat predict_input_part;
- CvArr* sample = &predict_input_part;
- CvMat probs_part;
- CvMat* probs1 = probs ? &probs_part : 0;
-
- if( !CV_IS_STAT_MODEL(stat_model) )
- CV_ERROR( !stat_model ? CV_StsNullPtr : CV_StsBadArg, "Invalid statistical model" );
-
- if( !stat_model->predict )
- CV_ERROR( CV_StsNotImplemented, "There is no \"predict\" method" );
-
- if( !predict_input || !predict_output )
- CV_ERROR( CV_StsNullPtr, "NULL input or output matrices" );
-
- if( !is_sparse && !CV_IS_MAT(predict_input) )
- CV_ERROR( CV_StsBadArg, "predict_input should be a matrix or a sparse matrix" );
-
- if( !CV_IS_MAT(predict_output) )
- CV_ERROR( CV_StsBadArg, "predict_output should be a matrix" );
-
- type = cvGetElemType( predict_input );
- if( type != CV_32FC1 ||
- (CV_MAT_TYPE(predict_output->type) != CV_32FC1 &&
- CV_MAT_TYPE(predict_output->type) != CV_32SC1 ))
- CV_ERROR( CV_StsUnsupportedFormat, "The input or output matrix has unsupported format" );
-
- CV_CALL( d = cvGetDims( predict_input, sizes ));
- if( d > 2 )
- CV_ERROR( CV_StsBadSize, "The input matrix should be 1- or 2-dimensional" );
-
- if( !tflag )
- {
- samples_all = samples_selected = sizes[0];
- dims_all = sizes[1];
- }
- else
- {
- samples_all = samples_selected = sizes[1];
- dims_all = sizes[0];
- }
-
- if( sample_idx )
- {
- if( !CV_IS_MAT(sample_idx) )
- CV_ERROR( CV_StsBadArg, "Invalid sample_idx matrix" );
-
- if( sample_idx->cols != 1 && sample_idx->rows != 1 )
- CV_ERROR( CV_StsBadSize, "sample_idx must be 1-dimensional matrix" );
-
- samples_selected = sample_idx->rows + sample_idx->cols - 1;
-
- if( CV_MAT_TYPE(sample_idx->type) == CV_32SC1 )
- {
- if( samples_selected > samples_all )
- CV_ERROR( CV_StsBadSize, "sample_idx is too large vector" );
- }
- else if( samples_selected != samples_all )
- CV_ERROR( CV_StsUnmatchedSizes, "sample_idx has incorrect size" );
-
- sample_idx_step = sample_idx->step ?
- sample_idx->step / CV_ELEM_SIZE(sample_idx->type) : 1;
- }
-
- if( predict_output->rows != 1 && predict_output->cols != 1 )
- CV_ERROR( CV_StsBadSize, "predict_output should be a 1-dimensional matrix" );
-
- if( predict_output->rows + predict_output->cols - 1 != samples_all )
- CV_ERROR( CV_StsUnmatchedSizes, "predict_output and predict_input have uncoordinated sizes" );
-
- predict_output_step = predict_output->step ?
- predict_output->step / CV_ELEM_SIZE(predict_output->type) : 1;
-
- if( probs )
- {
- if( !CV_IS_MAT(probs) )
- CV_ERROR( CV_StsBadArg, "Invalid matrix of probabilities" );
-
- if( probs->rows != samples_all )
- CV_ERROR( CV_StsUnmatchedSizes,
- "matrix of probabilities must have as many rows as the total number of samples" );
-
- if( CV_MAT_TYPE(probs->type) != CV_32FC1 )
- CV_ERROR( CV_StsUnsupportedFormat, "matrix of probabilities must have 32fC1 type" );
- }
-
- if( is_sparse )
- {
- CvSparseNode* node;
- CvSparseMatIterator mat_iterator;
- CvSparseMat* sparse = (CvSparseMat*)predict_input;
-
- if( sample_idx && CV_MAT_TYPE(sample_idx->type) == CV_32SC1 )
- {
- CV_CALL( sample_idx_buffer = cvCreateMat( 1, samples_all, CV_8UC1 ));
- cvZero( sample_idx_buffer );
- for( i = 0; i < samples_selected; i++ )
- sample_idx_buffer->data.ptr[sample_idx->data.i[i*sample_idx_step]] = 1;
- samples_selected = samples_all;
- sample_idx = sample_idx_buffer;
- sample_idx_step = 1;
- }
-
- CV_CALL( sparse_rows = (CvSparseMat**)cvAlloc( samples_selected*sizeof(sparse_rows[0])));
- for( i = 0; i < samples_selected; i++ )
- {
- if( sample_idx && sample_idx->data.ptr[i*sample_idx_step] == 0 )
- continue;
- CV_CALL( sparse_rows[i] = cvCreateSparseMat( 1, &dims_all, type ));
- if( !storage )
- storage = sparse_rows[i]->heap->storage;
- else
- {
- // hack: to decrease memory footprint, make all the sparse matrices
- // reside in the same storage
- int elem_size = sparse_rows[i]->heap->elem_size;
- cvReleaseMemStorage( &sparse_rows[i]->heap->storage );
- sparse_rows[i]->heap = cvCreateSet( 0, sizeof(CvSet), elem_size, storage );
- }
- }
-
- // put each row (or column) of predict_input into separate sparse matrix.
- node = cvInitSparseMatIterator( sparse, &mat_iterator );
- for( ; node != 0; node = cvGetNextSparseNode( &mat_iterator ))
- {
- int* idx = CV_NODE_IDX( sparse, node );
- int idx0 = idx[tflag ^ 1];
- int idx1 = idx[tflag];
-
- if( sample_idx && sample_idx->data.ptr[idx0*sample_idx_step] == 0 )
- continue;
-
- assert( sparse_rows[idx0] != 0 );
- *(float*)cvPtrND( sparse, &idx1, 0, 1, 0 ) = *(float*)CV_NODE_VAL( sparse, node );
- }
- }
-
- for( i = 0; i < samples_selected; i++ )
- {
- int idx = i;
- float response;
-
- if( sample_idx )
- {
- if( CV_MAT_TYPE(sample_idx->type) == CV_32SC1 )
- {
- idx = sample_idx->data.i[i*sample_idx_step];
- if( (unsigned)idx >= (unsigned)samples_all )
- CV_ERROR( CV_StsOutOfRange, "Some of sample_idx elements are out of range" );
- }
- else if( CV_MAT_TYPE(sample_idx->type) == CV_8UC1 &&
- sample_idx->data.ptr[i*sample_idx_step] == 0 )
- continue;
- }
-
- if( !is_sparse )
- {
- if( !tflag )
- cvGetRow( predict_input, &predict_input_part, idx );
- else
- {
- cvGetCol( predict_input, &predict_input_part, idx );
- }
- }
- else
- sample = sparse_rows[idx];
-
- if( probs )
- cvGetRow( probs, probs1, idx );
-
- CV_CALL( response = stat_model->predict( stat_model, (CvMat*)sample, probs1 ));
-
- if( CV_MAT_TYPE(predict_output->type) == CV_32FC1 )
- predict_output->data.fl[idx*predict_output_step] = response;
- else
- {
- CV_ASSERT( cvRound(response) == response );
- predict_output->data.i[idx*predict_output_step] = cvRound(response);
- }
- }
-
- __END__;
-
- if( sparse_rows )
- {
- int i;
- for( i = 0; i < samples_selected; i++ )
- if( sparse_rows[i] )
- {
- sparse_rows[i]->heap->storage = 0;
- cvReleaseSparseMat( &sparse_rows[i] );
- }
- cvFree( &sparse_rows );
- }
-
- cvReleaseMat( &sample_idx_buffer );
- cvReleaseMemStorage( &storage );
-}
-#endif
-
-// By P. Yarykin - begin -
-
-void cvCombineResponseMaps (CvMat* _responses,
- const CvMat* old_response_map,
- CvMat* new_response_map,
- CvMat** out_response_map)
-{
- int** old_data = NULL;
- int** new_data = NULL;
-
- CV_FUNCNAME ("cvCombineResponseMaps");
- __BEGIN__
-
- int i,j;
- int old_n, new_n, out_n;
- int samples, free_response;
- int* first;
- int* responses;
- int* out_data;
-
- if( out_response_map )
- *out_response_map = 0;
-
-// Check input data.
- if ((!ICV_IS_MAT_OF_TYPE (_responses, CV_32SC1)) ||
- (!ICV_IS_MAT_OF_TYPE (old_response_map, CV_32SC1)) ||
- (!ICV_IS_MAT_OF_TYPE (new_response_map, CV_32SC1)))
- {
- CV_ERROR (CV_StsBadArg, "Some of input arguments is not the CvMat")
- }
-
-// Prepare sorted responses.
- first = new_response_map->data.i;
- new_n = new_response_map->cols;
- CV_CALL (new_data = (int**)cvAlloc (new_n * sizeof (new_data[0])));
- for (i = 0; i < new_n; i++)
- new_data[i] = first + i;
- qsort (new_data, new_n, sizeof(int*), icvCmpIntegersPtr);
-
- first = old_response_map->data.i;
- old_n = old_response_map->cols;
- CV_CALL (old_data = (int**)cvAlloc (old_n * sizeof (old_data[0])));
- for (i = 0; i < old_n; i++)
- old_data[i] = first + i;
- qsort (old_data, old_n, sizeof(int*), icvCmpIntegersPtr);
-
-// Count the number of different responses.
- for (i = 0, j = 0, out_n = 0; i < old_n && j < new_n; out_n++)
- {
- if (*old_data[i] == *new_data[j])
- {
- i++;
- j++;
- }
- else if (*old_data[i] < *new_data[j])
- i++;
- else
- j++;
- }
- out_n += old_n - i + new_n - j;
-
-// Create and fill the result response maps.
- CV_CALL (*out_response_map = cvCreateMat (1, out_n, CV_32SC1));
- out_data = (*out_response_map)->data.i;
- memcpy (out_data, first, old_n * sizeof (int));
-
- free_response = old_n;
- for (i = 0, j = 0; i < old_n && j < new_n; )
- {
- if (*old_data[i] == *new_data[j])
- {
- *new_data[j] = (int)(old_data[i] - first);
- i++;
- j++;
- }
- else if (*old_data[i] < *new_data[j])
- i++;
- else
- {
- out_data[free_response] = *new_data[j];
- *new_data[j] = free_response++;
- j++;
- }
- }
- for (; j < new_n; j++)
- {
- out_data[free_response] = *new_data[j];
- *new_data[j] = free_response++;
- }
- CV_ASSERT (free_response == out_n);
-
-// Change <responses> according to out response map.
- samples = _responses->cols + _responses->rows - 1;
- responses = _responses->data.i;
- first = new_response_map->data.i;
- for (i = 0; i < samples; i++)
- {
- responses[i] = first[responses[i]];
- }
-
- __END__
-
- cvFree(&old_data);
- cvFree(&new_data);
-
-}
-
-
-static int icvGetNumberOfCluster( double* prob_vector, int num_of_clusters, float r,
- float outlier_thresh, int normalize_probs )
-{
- int max_prob_loc = 0;
-
- CV_FUNCNAME("icvGetNumberOfCluster");
- __BEGIN__;
-
- double prob, maxprob, sum;
- int i;
-
- CV_ASSERT(prob_vector);
- CV_ASSERT(num_of_clusters >= 0);
-
- maxprob = prob_vector[0];
- max_prob_loc = 0;
- sum = maxprob;
- for( i = 1; i < num_of_clusters; i++ )
- {
- prob = prob_vector[i];
- sum += prob;
- if( prob > maxprob )
- {
- max_prob_loc = i;
- maxprob = prob;
- }
- }
- if( normalize_probs && fabs(sum - 1.) > FLT_EPSILON )
- {
- for( i = 0; i < num_of_clusters; i++ )
- prob_vector[i] /= sum;
- }
- if( fabs(r - 1.) > FLT_EPSILON && fabs(sum - 1.) < outlier_thresh )
- max_prob_loc = -1;
-
- __END__;
-
- return max_prob_loc;
-
-} // End of icvGetNumberOfCluster
-
-
-void icvFindClusterLabels( const CvMat* probs, float outlier_thresh, float r,
- const CvMat* labels )
-{
- CvMat* counts = 0;
-
- CV_FUNCNAME("icvFindClusterLabels");
- __BEGIN__;
-
- int nclusters, nsamples;
- int i, j;
- double* probs_data;
-
- CV_ASSERT( ICV_IS_MAT_OF_TYPE(probs, CV_64FC1) );
- CV_ASSERT( ICV_IS_MAT_OF_TYPE(labels, CV_32SC1) );
-
- nclusters = probs->cols;
- nsamples = probs->rows;
- CV_ASSERT( nsamples == labels->cols );
-
- CV_CALL( counts = cvCreateMat( 1, nclusters + 1, CV_32SC1 ) );
- CV_CALL( cvSetZero( counts ));
- for( i = 0; i < nsamples; i++ )
- {
- labels->data.i[i] = icvGetNumberOfCluster( probs->data.db + i*probs->cols,
- nclusters, r, outlier_thresh, 1 );
- counts->data.i[labels->data.i[i] + 1]++;
- }
- CV_ASSERT((int)cvSum(counts).val[0] == nsamples);
- // Filling empty clusters with the vector, that has the maximal probability
- for( j = 0; j < nclusters; j++ ) // outliers are ignored
- {
- int maxprob_loc = -1;
- double maxprob = 0;
-
- if( counts->data.i[j+1] ) // j-th class is not empty
- continue;
- // look for the presentative, which is not lonely in it's cluster
- // and that has a maximal probability among all these vectors
- probs_data = probs->data.db;
- for( i = 0; i < nsamples; i++, probs_data++ )
- {
- int label = labels->data.i[i];
- double prob;
- if( counts->data.i[label+1] == 0 ||
- (counts->data.i[label+1] <= 1 && label != -1) )
- continue;
- prob = *probs_data;
- if( prob >= maxprob )
- {
- maxprob = prob;
- maxprob_loc = i;
- }
- }
- // maxprob_loc == 0 <=> number of vectors less then number of clusters
- CV_ASSERT( maxprob_loc >= 0 );
- counts->data.i[labels->data.i[maxprob_loc] + 1]--;
- labels->data.i[maxprob_loc] = j;
- counts->data.i[j + 1]++;
- }
-
- __END__;
-
- cvReleaseMat( &counts );
-} // End of icvFindClusterLabels
+}}
/* End of file */
// copy or use the software.
//
//
-// Intel License Agreement
+// License Agreement
+// For Open Source Computer Vision Library
//
// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Copyright (C) 2014, Itseez Inc, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// 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
+// * The name of the copyright holders 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
#include "precomp.hpp"
/****************************************************************************************\
-* K-Nearest Neighbors Classifier *
+* K-Nearest Neighbors Classifier *
\****************************************************************************************/
-// k Nearest Neighbors
-CvKNearest::CvKNearest()
-{
- samples = 0;
- clear();
-}
-
-
-CvKNearest::~CvKNearest()
-{
- clear();
-}
-
+namespace cv {
+namespace ml {
-CvKNearest::CvKNearest( const CvMat* _train_data, const CvMat* _responses,
- const CvMat* _sample_idx, bool _is_regression, int _max_k )
+class KNearestImpl : public KNearest
{
- samples = 0;
- train( _train_data, _responses, _sample_idx, _is_regression, _max_k, false );
-}
-
-
-void CvKNearest::clear()
-{
- while( samples )
+public:
+ KNearestImpl(bool __isClassifier=true)
{
- CvVectors* next_samples = samples->next;
- cvFree( &samples->data.fl );
- cvFree( &samples );
- samples = next_samples;
+ defaultK = 3;
+ _isClassifier = __isClassifier;
}
- var_count = 0;
- total = 0;
- max_k = 0;
-}
-
-
-int CvKNearest::get_max_k() const { return max_k; }
-int CvKNearest::get_var_count() const { return var_count; }
+ virtual ~KNearestImpl() {}
-bool CvKNearest::is_regression() const { return regression; }
+ bool isClassifier() const { return _isClassifier; }
+ bool isTrained() const { return !samples.empty(); }
-int CvKNearest::get_sample_count() const { return total; }
+ String getDefaultModelName() const { return "opencv_ml_knn"; }
-bool CvKNearest::train( const CvMat* _train_data, const CvMat* _responses,
- const CvMat* _sample_idx, bool _is_regression,
- int _max_k, bool _update_base )
-{
- bool ok = false;
- CvMat* responses = 0;
-
- CV_FUNCNAME( "CvKNearest::train" );
-
- __BEGIN__;
-
- CvVectors* _samples = 0;
- float** _data = 0;
- int _count = 0, _dims = 0, _dims_all = 0, _rsize = 0;
-
- if( !_update_base )
- clear();
-
- // Prepare training data and related parameters.
- // Treat categorical responses as ordered - to prevent class label compression and
- // to enable entering new classes in the updates
- CV_CALL( cvPrepareTrainData( "CvKNearest::train", _train_data, CV_ROW_SAMPLE,
- _responses, CV_VAR_ORDERED, 0, _sample_idx, true, (const float***)&_data,
- &_count, &_dims, &_dims_all, &responses, 0, 0 ));
-
- if( !responses )
- CV_ERROR( CV_StsNoMem, "Could not allocate memory for responses" );
-
- if( _update_base && _dims != var_count )
- CV_ERROR( CV_StsBadArg, "The newly added data have different dimensionality" );
-
- if( !_update_base )
+ void clear()
{
- if( _max_k < 1 )
- CV_ERROR( CV_StsOutOfRange, "max_k must be a positive number" );
-
- regression = _is_regression;
- var_count = _dims;
- max_k = _max_k;
+ samples.release();
+ responses.release();
}
- _rsize = _count*sizeof(float);
- CV_CALL( _samples = (CvVectors*)cvAlloc( sizeof(*_samples) + _rsize ));
- _samples->next = samples;
- _samples->type = CV_32F;
- _samples->data.fl = _data;
- _samples->count = _count;
- total += _count;
+ int getVarCount() const { return samples.cols; }
- samples = _samples;
- memcpy( _samples + 1, responses->data.fl, _rsize );
+ bool train( const Ptr<TrainData>& data, int flags )
+ {
+ Mat new_samples = data->getTrainSamples(ROW_SAMPLE);
+ Mat new_responses;
+ data->getTrainResponses().convertTo(new_responses, CV_32F);
+ bool update = (flags & UPDATE_MODEL) != 0 && !samples.empty();
+
+ CV_Assert( new_samples.type() == CV_32F );
- ok = true;
+ if( !update )
+ {
+ clear();
+ }
+ else
+ {
+ CV_Assert( new_samples.cols == samples.cols &&
+ new_responses.cols == responses.cols );
+ }
- __END__;
+ samples.push_back(new_samples);
+ responses.push_back(new_responses);
- if( responses && responses->data.ptr != _responses->data.ptr )
- cvReleaseMat(&responses);
+ return true;
+ }
- return ok;
-}
+ void findNearestCore( const Mat& _samples, int k0, const Range& range,
+ Mat* results, Mat* neighbor_responses,
+ Mat* dists, float* presult ) const
+ {
+ int testidx, baseidx, i, j, d = samples.cols, nsamples = samples.rows;
+ int testcount = range.end - range.start;
+ int k = std::min(k0, nsamples);
+ AutoBuffer<float> buf(testcount*k*2);
+ float* dbuf = buf;
+ float* rbuf = dbuf + testcount*k;
+ const float* rptr = responses.ptr<float>();
-void CvKNearest::find_neighbors_direct( const CvMat* _samples, int k, int start, int end,
- float* neighbor_responses, const float** neighbors, float* dist ) const
-{
- int i, j, count = end - start, k1 = 0, k2 = 0, d = var_count;
- CvVectors* s = samples;
+ for( testidx = 0; testidx < testcount; testidx++ )
+ {
+ for( i = 0; i < k; i++ )
+ {
+ dbuf[testidx*k + i] = FLT_MAX;
+ rbuf[testidx*k + i] = 0.f;
+ }
+ }
- for( ; s != 0; s = s->next )
- {
- int n = s->count;
- for( j = 0; j < n; j++ )
+ for( baseidx = 0; baseidx < nsamples; baseidx++ )
{
- for( i = 0; i < count; i++ )
+ for( testidx = 0; testidx < testcount; testidx++ )
{
- double sum = 0;
- Cv32suf si;
- const float* v = s->data.fl[j];
- const float* u = (float*)(_samples->data.ptr + _samples->step*(start + i));
- Cv32suf* dd = (Cv32suf*)(dist + i*k);
- float* nr;
- const float** nn;
- int t, ii, ii1;
-
- for( t = 0; t <= d - 4; t += 4 )
+ const float* v = samples.ptr<float>(baseidx);
+ const float* u = _samples.ptr<float>(testidx + range.start);
+
+ float s = 0;
+ for( i = 0; i <= d - 4; i += 4 )
{
- double t0 = u[t] - v[t], t1 = u[t+1] - v[t+1];
- double t2 = u[t+2] - v[t+2], t3 = u[t+3] - v[t+3];
- sum += t0*t0 + t1*t1 + t2*t2 + t3*t3;
+ float t0 = u[i] - v[i], t1 = u[i+1] - v[i+1];
+ float t2 = u[i+2] - v[i+2], t3 = u[i+3] - v[i+3];
+ s += t0*t0 + t1*t1 + t2*t2 + t3*t3;
}
- for( ; t < d; t++ )
+ for( ; i < d; i++ )
{
- double t0 = u[t] - v[t];
- sum += t0*t0;
+ float t0 = u[i] - v[i];
+ s += t0*t0;
}
- si.f = (float)sum;
- for( ii = k1-1; ii >= 0; ii-- )
- if( si.i > dd[ii].i )
+ Cv32suf si;
+ si.f = (float)s;
+ Cv32suf* dd = (Cv32suf*)(&dbuf[testidx*k]);
+ float* nr = &rbuf[testidx*k];
+
+ for( i = k; i > 0; i-- )
+ if( si.i >= dd[i-1].i )
break;
- if( ii >= k-1 )
+ if( i >= k )
continue;
- nr = neighbor_responses + i*k;
- nn = neighbors ? neighbors + (start + i)*k : 0;
- for( ii1 = k2 - 1; ii1 > ii; ii1-- )
+ for( j = k-2; j >= i; j-- )
{
- dd[ii1+1].i = dd[ii1].i;
- nr[ii1+1] = nr[ii1];
- if( nn ) nn[ii1+1] = nn[ii1];
+ dd[j+1].i = dd[j].i;
+ nr[j+1] = nr[j];
}
- dd[ii+1].i = si.i;
- nr[ii+1] = ((float*)(s + 1))[j];
- if( nn )
- nn[ii+1] = v;
+ dd[i].i = si.i;
+ nr[i] = rptr[baseidx];
}
- k1 = MIN( k1+1, k );
- k2 = MIN( k1, k-1 );
}
- }
-}
+ float result = 0.f;
+ float inv_scale = 1./k;
-float CvKNearest::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
-{
- float result = 0.f;
- int i, j, j1, count = end - start;
- double inv_scale = 1./k1;
- int rstep = _results && !CV_IS_MAT_CONT(_results->type) ? _results->step/sizeof(result) : 1;
-
- for( i = 0; i < count; i++ )
- {
- const Cv32suf* nr = (const Cv32suf*)(neighbor_responses + i*k);
- float* dst;
- float r;
- if( _results || start+i == 0 )
+ for( testidx = 0; testidx < testcount; testidx++ )
{
- if( regression )
+ if( neighbor_responses )
{
- double s = 0;
- for( j = 0; j < k1; j++ )
- s += nr[j].f;
- r = (float)(s*inv_scale);
+ float* nr = neighbor_responses->ptr<float>(testidx + range.start);
+ for( j = 0; j < k; j++ )
+ nr[j] = rbuf[testidx*k + j];
+ for( ; j < k0; j++ )
+ nr[j] = 0.f;
}
- else
- {
- int prev_start = 0, best_count = 0, cur_count;
- Cv32suf best_val;
- for( j = 0; j < k1; j++ )
- sort_buf[j].i = nr[j].i;
+ if( dists )
+ {
+ float* dptr = dists->ptr<float>(testidx + range.start);
+ for( j = 0; j < k; j++ )
+ dptr[j] = dbuf[testidx*k + j];
+ for( ; j < k0; j++ )
+ dptr[j] = 0.f;
+ }
- for( j = k1-1; j > 0; j-- )
+ if( results || testidx+range.start == 0 )
+ {
+ if( !_isClassifier || k == 1 )
{
- bool swap_fl = false;
- for( j1 = 0; j1 < j; j1++ )
- if( sort_buf[j1].i > sort_buf[j1+1].i )
+ float s = 0.f;
+ for( j = 0; j < k; j++ )
+ s += rbuf[testidx*k + j];
+ result = (float)(s*inv_scale);
+ }
+ else
+ {
+ float* rp = rbuf + testidx*k;
+ for( j = k-1; j > 0; j-- )
+ {
+ bool swap_fl = false;
+ for( i = 0; i < j; i++ )
{
- int t;
- CV_SWAP( sort_buf[j1].i, sort_buf[j1+1].i, t );
- swap_fl = true;
+ if( rp[i] > rp[i+1] )
+ {
+ std::swap(rp[i], rp[i+1]);
+ swap_fl = true;
+ }
}
- if( !swap_fl )
- break;
- }
+ if( !swap_fl )
+ break;
+ }
- best_val.i = 0;
- for( j = 1; j <= k1; j++ )
- if( j == k1 || sort_buf[j].i != sort_buf[j-1].i )
+ result = rp[0];
+ int prev_start = 0;
+ int best_count = 0;
+ for( j = 1; j <= k; j++ )
{
- cur_count = j - prev_start;
- if( best_count < cur_count )
+ if( j == k || rp[j] != rp[j-1] )
{
- best_count = cur_count;
- best_val.i = sort_buf[j-1].i;
+ int count = j - prev_start;
+ if( best_count < count )
+ {
+ best_count = count;
+ result = rp[j-1];
+ }
+ prev_start = j;
}
- prev_start = j;
}
- r = best_val.f;
+ }
+ if( results )
+ results->at<float>(testidx + range.start) = result;
+ if( presult && testidx+range.start == 0 )
+ *presult = result;
}
-
- if( start+i == 0 )
- result = r;
-
- if( _results )
- _results->data.fl[(start + i)*rstep] = r;
}
+ }
- if( _neighbor_responses )
+ struct findKNearestInvoker : public ParallelLoopBody
+ {
+ findKNearestInvoker(const KNearestImpl* _p, int _k, const Mat& __samples,
+ Mat* __results, Mat* __neighbor_responses, Mat* __dists, float* _presult)
{
- dst = (float*)(_neighbor_responses->data.ptr +
- (start + i)*_neighbor_responses->step);
- for( j = 0; j < k1; j++ )
- dst[j] = nr[j].f;
- for( ; j < k; j++ )
- dst[j] = 0.f;
+ p = _p;
+ k = _k;
+ _samples = &__samples;
+ _results = __results;
+ _neighbor_responses = __neighbor_responses;
+ _dists = __dists;
+ presult = _presult;
}
- if( _dist )
+ void operator()( const Range& range ) const
{
- dst = (float*)(_dist->data.ptr + (start + i)*_dist->step);
- for( j = 0; j < k1; j++ )
- dst[j] = dist[j + i*k];
- for( ; j < k; j++ )
- dst[j] = 0.f;
+ int delta = std::min(range.end - range.start, 256);
+ for( int start = range.start; start < range.end; start += delta )
+ {
+ p->findNearestCore( *_samples, k, Range(start, std::min(start + delta, range.end)),
+ _results, _neighbor_responses, _dists, presult );
+ }
}
- }
- return result;
-}
-
-struct P1 : cv::ParallelLoopBody {
- P1(const CvKNearest* _pointer, int _buf_sz, int _k, const CvMat* __samples, const float** __neighbors,
- int _k1, CvMat* __results, CvMat* __neighbor_responses, CvMat* __dist, float* _result)
- {
- pointer = _pointer;
- k = _k;
- _samples = __samples;
- _neighbors = __neighbors;
- k1 = _k1;
- _results = __results;
- _neighbor_responses = __neighbor_responses;
- _dist = __dist;
- result = _result;
- buf_sz = _buf_sz;
- }
-
- const CvKNearest* pointer;
- int k;
- const CvMat* _samples;
- const float** _neighbors;
- int k1;
- CvMat* _results;
- CvMat* _neighbor_responses;
- CvMat* _dist;
- float* result;
- int buf_sz;
-
- void operator()( const cv::Range& range ) const
- {
- cv::AutoBuffer<float> buf(buf_sz);
- for(int i = range.start; i < range.end; i += 1 )
+ const KNearestImpl* p;
+ int k;
+ const Mat* _samples;
+ Mat* _results;
+ Mat* _neighbor_responses;
+ Mat* _dists;
+ float* presult;
+ };
+
+ float findNearest( InputArray _samples, int k,
+ OutputArray _results,
+ OutputArray _neighborResponses,
+ OutputArray _dists ) const
{
- float* neighbor_responses = &buf[0];
- float* dist = neighbor_responses + 1*k;
- Cv32suf* sort_buf = (Cv32suf*)(dist + 1*k);
-
- pointer->find_neighbors_direct( _samples, k, i, i + 1,
- neighbor_responses, _neighbors, dist );
+ float result = 0.f;
+ CV_Assert( 0 < k );
- float r = pointer->write_results( k, k1, i, i + 1, neighbor_responses, dist,
- _results, _neighbor_responses, _dist, sort_buf );
+ Mat test_samples = _samples.getMat();
+ CV_Assert( test_samples.type() == CV_32F && test_samples.cols == samples.cols );
+ int testcount = test_samples.rows;
- if( i == 0 )
- *result = r;
- }
- }
-
-};
-
-float CvKNearest::find_nearest( const CvMat* _samples, int k, CvMat* _results,
- const float** _neighbors, CvMat* _neighbor_responses, CvMat* _dist ) const
-{
- float result = 0.f;
- const int max_blk_count = 128, max_buf_sz = 1 << 12;
-
- if( !samples )
- CV_Error( CV_StsError, "The search tree must be constructed first using train method" );
-
- if( !CV_IS_MAT(_samples) ||
- CV_MAT_TYPE(_samples->type) != CV_32FC1 ||
- _samples->cols != var_count )
- CV_Error( CV_StsBadArg, "Input samples must be floating-point matrix (<num_samples>x<var_count>)" );
-
- if( _results && (!CV_IS_MAT(_results) ||
- (_results->cols != 1 && _results->rows != 1) ||
- _results->cols + _results->rows - 1 != _samples->rows) )
- CV_Error( CV_StsBadArg,
- "The results must be 1d vector containing as much elements as the number of samples" );
-
- if( _results && CV_MAT_TYPE(_results->type) != CV_32FC1 &&
- (CV_MAT_TYPE(_results->type) != CV_32SC1 || regression))
- CV_Error( CV_StsUnsupportedFormat,
- "The results must be floating-point or integer (in case of classification) vector" );
+ if( testcount == 0 )
+ {
+ _results.release();
+ _neighborResponses.release();
+ _dists.release();
+ return 0.f;
+ }
- if( k < 1 || k > max_k )
- CV_Error( CV_StsOutOfRange, "k must be within 1..max_k range" );
+ Mat res, nr, d, *pres = 0, *pnr = 0, *pd = 0;
+ if( _results.needed() )
+ {
+ _results.create(testcount, 1, CV_32F);
+ pres = &(res = _results.getMat());
+ }
+ if( _neighborResponses.needed() )
+ {
+ _neighborResponses.create(testcount, k, CV_32F);
+ pnr = &(nr = _neighborResponses.getMat());
+ }
+ if( _dists.needed() )
+ {
+ _dists.create(testcount, k, CV_32F);
+ pd = &(d = _dists.getMat());
+ }
- if( _neighbor_responses )
- {
- if( !CV_IS_MAT(_neighbor_responses) || CV_MAT_TYPE(_neighbor_responses->type) != CV_32FC1 ||
- _neighbor_responses->rows != _samples->rows || _neighbor_responses->cols != k )
- CV_Error( CV_StsBadArg,
- "The neighbor responses (if present) must be floating-point matrix of <num_samples> x <k> size" );
+ findKNearestInvoker invoker(this, k, test_samples, pres, pnr, pd, &result);
+ parallel_for_(Range(0, testcount), invoker);
+ //invoker(Range(0, testcount));
+ return result;
}
- if( _dist )
+ float predict(InputArray inputs, OutputArray outputs, int) const
{
- if( !CV_IS_MAT(_dist) || CV_MAT_TYPE(_dist->type) != CV_32FC1 ||
- _dist->rows != _samples->rows || _dist->cols != k )
- CV_Error( CV_StsBadArg,
- "The distances from the neighbors (if present) must be floating-point matrix of <num_samples> x <k> size" );
+ return findNearest( inputs, defaultK, outputs, noArray(), noArray() );
}
- int count = _samples->rows;
- int count_scale = k*2;
- int blk_count0 = MIN( count, max_blk_count );
- int buf_sz = MIN( blk_count0 * count_scale, max_buf_sz );
- blk_count0 = MAX( buf_sz/count_scale, 1 );
- blk_count0 += blk_count0 % 2;
- blk_count0 = MIN( blk_count0, count );
- buf_sz = blk_count0 * count_scale + k;
- int k1 = get_sample_count();
- k1 = MIN( k1, k );
-
- cv::parallel_for_(cv::Range(0, count), P1(this, buf_sz, k, _samples, _neighbors, k1,
- _results, _neighbor_responses, _dist, &result)
- );
-
- return result;
-}
-
-
-using namespace cv;
-
-CvKNearest::CvKNearest( const Mat& _train_data, const Mat& _responses,
- const Mat& _sample_idx, bool _is_regression, int _max_k )
-{
- samples = 0;
- train(_train_data, _responses, _sample_idx, _is_regression, _max_k, false );
-}
-
-bool CvKNearest::train( const Mat& _train_data, const Mat& _responses,
- const Mat& _sample_idx, bool _is_regression,
- int _max_k, bool _update_base )
-{
- CvMat tdata = _train_data, responses = _responses, sidx = _sample_idx;
-
- return train(&tdata, &responses, sidx.data.ptr ? &sidx : 0, _is_regression, _max_k, _update_base );
-}
-
-
-float CvKNearest::find_nearest( const Mat& _samples, int k, Mat* _results,
- const float** _neighbors, Mat* _neighbor_responses,
- Mat* _dist ) const
-{
- CvMat s = _samples, results, *presults = 0, nresponses, *pnresponses = 0, dist, *pdist = 0;
-
- if( _results )
+ void write( FileStorage& fs ) const
{
- if(!(_results->data && (_results->type() == CV_32F ||
- (_results->type() == CV_32S && regression)) &&
- (_results->cols == 1 || _results->rows == 1) &&
- _results->cols + _results->rows - 1 == _samples.rows) )
- _results->create(_samples.rows, 1, CV_32F);
- presults = &(results = *_results);
- }
+ fs << "is_classifier" << (int)_isClassifier;
- if( _neighbor_responses )
- {
- if(!(_neighbor_responses->data && _neighbor_responses->type() == CV_32F &&
- _neighbor_responses->cols == k && _neighbor_responses->rows == _samples.rows) )
- _neighbor_responses->create(_samples.rows, k, CV_32F);
- pnresponses = &(nresponses = *_neighbor_responses);
+ fs << "samples" << samples;
+ fs << "responses" << responses;
}
- if( _dist )
+ void read( const FileNode& fn )
{
- if(!(_dist->data && _dist->type() == CV_32F &&
- _dist->cols == k && _dist->rows == _samples.rows) )
- _dist->create(_samples.rows, k, CV_32F);
- pdist = &(dist = *_dist);
+ clear();
+ _isClassifier = (int)fn["is_classifier"] != 0;
+
+ fn["samples"] >> samples;
+ fn["responses"] >> responses;
}
- return find_nearest(&s, k, presults, _neighbors, pnresponses, pdist );
-}
+ void setDefaultK(int _k) { defaultK = _k; }
+ int getDefaultK() const { return defaultK; }
+ Mat samples;
+ Mat responses;
+ bool _isClassifier;
+ int defaultK;
+};
-float CvKNearest::find_nearest( const cv::Mat& _samples, int k, CV_OUT cv::Mat& results,
- CV_OUT cv::Mat& neighborResponses, CV_OUT cv::Mat& dists) const
+Ptr<KNearest> KNearest::create(bool isClassifier)
{
- return find_nearest(_samples, k, &results, 0, &neighborResponses, &dists);
+ return makePtr<KNearestImpl>(isClassifier);
+}
+
+}
}
/* End of file */
+++ /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.
-//
-//
-// License Agreement
-// For Open Source Computer Vision Library
-//
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
-// Copyright (C) 2009, Willow Garage Inc., 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 the copyright holders 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*/
-
-#include "precomp.hpp"
-
-namespace cv
-{
-
-CV_INIT_ALGORITHM(EM, "StatModel.EM",
- obj.info()->addParam(obj, "nclusters", obj.nclusters);
- obj.info()->addParam(obj, "covMatType", obj.covMatType);
- obj.info()->addParam(obj, "maxIters", obj.maxIters);
- obj.info()->addParam(obj, "epsilon", obj.epsilon);
- obj.info()->addParam(obj, "weights", obj.weights, true);
- obj.info()->addParam(obj, "means", obj.means, true);
- obj.info()->addParam(obj, "covs", obj.covs, true))
-
-bool initModule_ml(void)
-{
- Ptr<Algorithm> em = createEM_ptr_hidden();
- return em->info() != 0;
-}
-
-}
#include "precomp.hpp"
-CvNormalBayesClassifier::CvNormalBayesClassifier()
-{
- var_count = var_all = 0;
- var_idx = 0;
- cls_labels = 0;
- count = 0;
- sum = 0;
- productsum = 0;
- avg = 0;
- inv_eigen_values = 0;
- cov_rotate_mats = 0;
- c = 0;
- default_model_name = "my_nb";
-}
+namespace cv {
+namespace ml {
+NormalBayesClassifier::~NormalBayesClassifier() {}
-void CvNormalBayesClassifier::clear()
+class NormalBayesClassifierImpl : public NormalBayesClassifier
{
- if( cls_labels )
+public:
+ NormalBayesClassifierImpl()
{
- for( int cls = 0; cls < cls_labels->cols; cls++ )
- {
- cvReleaseMat( &count[cls] );
- cvReleaseMat( &sum[cls] );
- cvReleaseMat( &productsum[cls] );
- cvReleaseMat( &avg[cls] );
- cvReleaseMat( &inv_eigen_values[cls] );
- cvReleaseMat( &cov_rotate_mats[cls] );
- }
+ nallvars = 0;
}
- cvReleaseMat( &cls_labels );
- cvReleaseMat( &var_idx );
- cvReleaseMat( &c );
- cvFree( &count );
-}
-
-
-CvNormalBayesClassifier::~CvNormalBayesClassifier()
-{
- clear();
-}
-
-
-CvNormalBayesClassifier::CvNormalBayesClassifier(
- const CvMat* _train_data, const CvMat* _responses,
- const CvMat* _var_idx, const CvMat* _sample_idx )
-{
- var_count = var_all = 0;
- var_idx = 0;
- cls_labels = 0;
- count = 0;
- sum = 0;
- productsum = 0;
- avg = 0;
- inv_eigen_values = 0;
- cov_rotate_mats = 0;
- c = 0;
- default_model_name = "my_nb";
-
- train( _train_data, _responses, _var_idx, _sample_idx );
-}
-
-
-bool CvNormalBayesClassifier::train( const CvMat* _train_data, const CvMat* _responses,
- const CvMat* _var_idx, const CvMat* _sample_idx, bool update )
-{
- const float min_variation = FLT_EPSILON;
- bool result = false;
- CvMat* responses = 0;
- const float** train_data = 0;
- CvMat* __cls_labels = 0;
- CvMat* __var_idx = 0;
- CvMat* cov = 0;
-
- CV_FUNCNAME( "CvNormalBayesClassifier::train" );
-
- __BEGIN__;
-
- int cls, nsamples = 0, _var_count = 0, _var_all = 0, nclasses = 0;
- int s, c1, c2;
- const int* responses_data;
-
- CV_CALL( cvPrepareTrainData( 0,
- _train_data, CV_ROW_SAMPLE, _responses, CV_VAR_CATEGORICAL,
- _var_idx, _sample_idx, false, &train_data,
- &nsamples, &_var_count, &_var_all, &responses,
- &__cls_labels, &__var_idx ));
-
- if( !update )
+ bool train( const Ptr<TrainData>& trainData, int flags )
{
- const size_t mat_size = sizeof(CvMat*);
- size_t data_size;
-
- clear();
-
- var_idx = __var_idx;
- cls_labels = __cls_labels;
- __var_idx = __cls_labels = 0;
- var_count = _var_count;
- var_all = _var_all;
+ const float min_variation = FLT_EPSILON;
+ Mat responses = trainData->getNormCatResponses();
+ Mat __cls_labels = trainData->getClassLabels();
+ Mat __var_idx = trainData->getVarIdx();
+ Mat samples = trainData->getTrainSamples();
+ int nclasses = (int)__cls_labels.total();
- nclasses = cls_labels->cols;
- data_size = nclasses*6*mat_size;
+ int nvars = trainData->getNVars();
+ int s, c1, c2, cls;
- CV_CALL( count = (CvMat**)cvAlloc( data_size ));
- memset( count, 0, data_size );
+ int __nallvars = trainData->getNAllVars();
+ bool update = (flags & UPDATE_MODEL) != 0;
- sum = count + nclasses;
- productsum = sum + nclasses;
- avg = productsum + nclasses;
- inv_eigen_values= avg + nclasses;
- cov_rotate_mats = inv_eigen_values + nclasses;
+ if( !update )
+ {
+ nallvars = __nallvars;
+ count.resize(nclasses);
+ sum.resize(nclasses);
+ productsum.resize(nclasses);
+ avg.resize(nclasses);
+ inv_eigen_values.resize(nclasses);
+ cov_rotate_mats.resize(nclasses);
+
+ for( cls = 0; cls < nclasses; cls++ )
+ {
+ count[cls] = Mat::zeros( 1, nvars, CV_32SC1 );
+ sum[cls] = Mat::zeros( 1, nvars, CV_64FC1 );
+ productsum[cls] = Mat::zeros( nvars, nvars, CV_64FC1 );
+ avg[cls] = Mat::zeros( 1, nvars, CV_64FC1 );
+ inv_eigen_values[cls] = Mat::zeros( 1, nvars, CV_64FC1 );
+ cov_rotate_mats[cls] = Mat::zeros( nvars, nvars, CV_64FC1 );
+ }
- CV_CALL( c = cvCreateMat( 1, nclasses, CV_64FC1 ));
+ var_idx = __var_idx;
+ cls_labels = __cls_labels;
- for( cls = 0; cls < nclasses; cls++ )
+ c.create(1, nclasses, CV_64FC1);
+ }
+ else
{
- CV_CALL(count[cls] = cvCreateMat( 1, var_count, CV_32SC1 ));
- CV_CALL(sum[cls] = cvCreateMat( 1, var_count, CV_64FC1 ));
- CV_CALL(productsum[cls] = cvCreateMat( var_count, var_count, CV_64FC1 ));
- CV_CALL(avg[cls] = cvCreateMat( 1, var_count, CV_64FC1 ));
- CV_CALL(inv_eigen_values[cls] = cvCreateMat( 1, var_count, CV_64FC1 ));
- CV_CALL(cov_rotate_mats[cls] = cvCreateMat( var_count, var_count, CV_64FC1 ));
- CV_CALL(cvZero( count[cls] ));
- CV_CALL(cvZero( sum[cls] ));
- CV_CALL(cvZero( productsum[cls] ));
- CV_CALL(cvZero( avg[cls] ));
- CV_CALL(cvZero( inv_eigen_values[cls] ));
- CV_CALL(cvZero( cov_rotate_mats[cls] ));
+ // check that the new training data has the same dimensionality etc.
+ if( nallvars != __nallvars ||
+ var_idx.size() != __var_idx.size() ||
+ norm(var_idx, __var_idx, NORM_INF) != 0 ||
+ cls_labels.size() != __cls_labels.size() ||
+ norm(cls_labels, __cls_labels, NORM_INF) != 0 )
+ CV_Error( CV_StsBadArg,
+ "The new training data is inconsistent with the original training data; varIdx and the class labels should be the same" );
}
- }
- else
- {
- // check that the new training data has the same dimensionality etc.
- if( _var_count != var_count || _var_all != var_all || !((!_var_idx && !var_idx) ||
- (_var_idx && var_idx && cvNorm(_var_idx,var_idx,CV_C) < DBL_EPSILON)) )
- CV_ERROR( CV_StsBadArg,
- "The new training data is inconsistent with the original training data" );
-
- if( cls_labels->cols != __cls_labels->cols ||
- cvNorm(cls_labels, __cls_labels, CV_C) > DBL_EPSILON )
- CV_ERROR( CV_StsNotImplemented,
- "In the current implementation the new training data must have absolutely "
- "the same set of class labels as used in the original training data" );
-
- nclasses = cls_labels->cols;
- }
- responses_data = responses->data.i;
- CV_CALL( cov = cvCreateMat( _var_count, _var_count, CV_64FC1 ));
+ Mat cov( nvars, nvars, CV_64FC1 );
+ int nsamples = samples.rows;
- /* process train data (count, sum , productsum) */
- for( s = 0; s < nsamples; s++ )
- {
- cls = responses_data[s];
- int* count_data = count[cls]->data.i;
- double* sum_data = sum[cls]->data.db;
- double* prod_data = productsum[cls]->data.db;
- const float* train_vec = train_data[s];
-
- for( c1 = 0; c1 < _var_count; c1++, prod_data += _var_count )
+ // process train data (count, sum , productsum)
+ for( s = 0; s < nsamples; s++ )
{
- double val1 = train_vec[c1];
- sum_data[c1] += val1;
- count_data[c1]++;
- for( c2 = c1; c2 < _var_count; c2++ )
- prod_data[c2] += train_vec[c2]*val1;
- }
- }
- cvReleaseMat( &responses );
- responses = 0;
+ cls = responses.at<int>(s);
+ int* count_data = count[cls].ptr<int>();
+ double* sum_data = sum[cls].ptr<double>();
+ double* prod_data = productsum[cls].ptr<double>();
+ const float* train_vec = samples.ptr<float>(s);
- /* calculate avg, covariance matrix, c */
- for( cls = 0; cls < nclasses; cls++ )
- {
- double det = 1;
- int i, j;
- CvMat* w = inv_eigen_values[cls];
- int* count_data = count[cls]->data.i;
- double* avg_data = avg[cls]->data.db;
- double* sum1 = sum[cls]->data.db;
+ for( c1 = 0; c1 < nvars; c1++, prod_data += nvars )
+ {
+ double val1 = train_vec[c1];
+ sum_data[c1] += val1;
+ count_data[c1]++;
+ for( c2 = c1; c2 < nvars; c2++ )
+ prod_data[c2] += train_vec[c2]*val1;
+ }
+ }
- cvCompleteSymm( productsum[cls], 0 );
+ Mat vt;
- for( j = 0; j < _var_count; j++ )
+ // calculate avg, covariance matrix, c
+ for( cls = 0; cls < nclasses; cls++ )
{
- int n = count_data[j];
- avg_data[j] = n ? sum1[j] / n : 0.;
- }
+ double det = 1;
+ int i, j;
+ Mat& w = inv_eigen_values[cls];
+ int* count_data = count[cls].ptr<int>();
+ double* avg_data = avg[cls].ptr<double>();
+ double* sum1 = sum[cls].ptr<double>();
- count_data = count[cls]->data.i;
- avg_data = avg[cls]->data.db;
- sum1 = sum[cls]->data.db;
+ completeSymm(productsum[cls], 0);
- for( i = 0; i < _var_count; i++ )
- {
- double* avg2_data = avg[cls]->data.db;
- double* sum2 = sum[cls]->data.db;
- double* prod_data = productsum[cls]->data.db + i*_var_count;
- double* cov_data = cov->data.db + i*_var_count;
- double s1val = sum1[i];
- double avg1 = avg_data[i];
- int _count = count_data[i];
-
- for( j = 0; j <= i; j++ )
+ for( j = 0; j < nvars; j++ )
{
- double avg2 = avg2_data[j];
- double cov_val = prod_data[j] - avg1 * sum2[j] - avg2 * s1val + avg1 * avg2 * _count;
- cov_val = (_count > 1) ? cov_val / (_count - 1) : cov_val;
- cov_data[j] = cov_val;
+ int n = count_data[j];
+ avg_data[j] = n ? sum1[j] / n : 0.;
}
- }
-
- CV_CALL( cvCompleteSymm( cov, 1 ));
- CV_CALL( cvSVD( cov, w, cov_rotate_mats[cls], 0, CV_SVD_U_T ));
- CV_CALL( cvMaxS( w, min_variation, w ));
- for( j = 0; j < _var_count; j++ )
- det *= w->data.db[j];
-
- CV_CALL( cvDiv( NULL, w, w ));
- c->data.db[cls] = det > 0 ? log(det) : -700;
- }
- result = true;
+ count_data = count[cls].ptr<int>();
+ avg_data = avg[cls].ptr<double>();
+ sum1 = sum[cls].ptr<double>();
- __END__;
+ for( i = 0; i < nvars; i++ )
+ {
+ double* avg2_data = avg[cls].ptr<double>();
+ double* sum2 = sum[cls].ptr<double>();
+ double* prod_data = productsum[cls].ptr<double>(i);
+ double* cov_data = cov.ptr<double>(i);
+ double s1val = sum1[i];
+ double avg1 = avg_data[i];
+ int _count = count_data[i];
+
+ for( j = 0; j <= i; j++ )
+ {
+ double avg2 = avg2_data[j];
+ double cov_val = prod_data[j] - avg1 * sum2[j] - avg2 * s1val + avg1 * avg2 * _count;
+ cov_val = (_count > 1) ? cov_val / (_count - 1) : cov_val;
+ cov_data[j] = cov_val;
+ }
+ }
- if( !result || cvGetErrStatus() < 0 )
- clear();
+ completeSymm( cov, 1 );
- cvReleaseMat( &cov );
- cvReleaseMat( &__cls_labels );
- cvReleaseMat( &__var_idx );
- cvFree( &train_data );
+ SVD::compute(cov, w, cov_rotate_mats[cls], noArray());
+ transpose(cov_rotate_mats[cls], cov_rotate_mats[cls]);
+ cv::max(w, min_variation, w);
+ for( j = 0; j < nvars; j++ )
+ det *= w.at<double>(j);
- return result;
-}
+ divide(1., w, w);
+ c.at<double>(cls) = det > 0 ? log(det) : -700;
+ }
-struct predict_body : cv::ParallelLoopBody {
- predict_body(CvMat* _c, CvMat** _cov_rotate_mats, CvMat** _inv_eigen_values, CvMat** _avg,
- const CvMat* _samples, const int* _vidx, CvMat* _cls_labels,
- CvMat* _results, float* _value, int _var_count1, CvMat* _results_prob
- )
- {
- c = _c;
- cov_rotate_mats = _cov_rotate_mats;
- inv_eigen_values = _inv_eigen_values;
- avg = _avg;
- samples = _samples;
- vidx = _vidx;
- cls_labels = _cls_labels;
- results = _results;
- value = _value;
- var_count1 = _var_count1;
- results_prob = _results_prob;
- }
-
- CvMat* c;
- CvMat** cov_rotate_mats;
- CvMat** inv_eigen_values;
- CvMat** avg;
- const CvMat* samples;
- const int* vidx;
- CvMat* cls_labels;
-
- CvMat* results_prob;
- CvMat* results;
- float* value;
- int var_count1;
-
- void operator()( const cv::Range& range ) const
- {
-
- int cls = -1;
- int rtype = 0, rstep = 0, rptype = 0, rpstep = 0;
- int nclasses = cls_labels->cols;
- int _var_count = avg[0]->cols;
- double probability = 0;
-
- if (results)
- {
- rtype = CV_MAT_TYPE(results->type);
- rstep = CV_IS_MAT_CONT(results->type) ? 1 : results->step/CV_ELEM_SIZE(rtype);
+ return true;
}
- if (results_prob)
- {
- rptype = CV_MAT_TYPE(results_prob->type);
- rpstep = CV_IS_MAT_CONT(results_prob->type) ? 1 : results_prob->step/CV_ELEM_SIZE(rptype);
- }
- // allocate memory and initializing headers for calculating
- cv::AutoBuffer<double> buffer(nclasses + var_count1);
- CvMat diff = cvMat( 1, var_count1, CV_64FC1, &buffer[0] );
- for(int k = range.start; k < range.end; k += 1 )
+ class NBPredictBody : public ParallelLoopBody
{
- int ival;
- double opt = FLT_MAX;
-
- for(int i = 0; i < nclasses; i++ )
+ public:
+ NBPredictBody( const Mat& _c, const vector<Mat>& _cov_rotate_mats,
+ const vector<Mat>& _inv_eigen_values,
+ const vector<Mat>& _avg,
+ const Mat& _samples, const Mat& _vidx, const Mat& _cls_labels,
+ Mat& _results, Mat& _results_prob, bool _rawOutput )
{
- double cur = c->data.db[i];
- CvMat* u = cov_rotate_mats[i];
- CvMat* w = inv_eigen_values[i];
+ c = &_c;
+ cov_rotate_mats = &_cov_rotate_mats;
+ inv_eigen_values = &_inv_eigen_values;
+ avg = &_avg;
+ samples = &_samples;
+ vidx = &_vidx;
+ cls_labels = &_cls_labels;
+ results = &_results;
+ results_prob = _results_prob.data ? &_results_prob : 0;
+ rawOutput = _rawOutput;
+ }
- const double* avg_data = avg[i]->data.db;
- const float* x = (const float*)(samples->data.ptr + samples->step*k);
+ const Mat* c;
+ const vector<Mat>* cov_rotate_mats;
+ const vector<Mat>* inv_eigen_values;
+ const vector<Mat>* avg;
+ const Mat* samples;
+ const Mat* vidx;
+ const Mat* cls_labels;
- // cov = u w u' --> cov^(-1) = u w^(-1) u'
- for(int j = 0; j < _var_count; j++ )
- diff.data.db[j] = avg_data[j] - x[vidx ? vidx[j] : j];
+ Mat* results_prob;
+ Mat* results;
+ float* value;
+ bool rawOutput;
- cvGEMM( &diff, u, 1, 0, 0, &diff, CV_GEMM_B_T );
- for(int j = 0; j < _var_count; j++ )
+ void operator()( const Range& range ) const
+ {
+ int cls = -1;
+ int rtype = 0, rptype = 0;
+ size_t rstep = 0, rpstep = 0;
+ int nclasses = (int)cls_labels->total();
+ int nvars = avg->at(0).cols;
+ double probability = 0;
+ const int* vptr = vidx && !vidx->empty() ? vidx->ptr<int>() : 0;
+
+ if (results)
{
- double d = diff.data.db[j];
- cur += d*d*w->data.db[j];
+ rtype = results->type();
+ rstep = results->isContinuous() ? 1 : results->step/results->elemSize();
}
-
- if( cur < opt )
+ if (results_prob)
{
- cls = i;
- opt = cur;
+ rptype = results_prob->type();
+ rpstep = results_prob->isContinuous() ? 1 : results_prob->step/results_prob->elemSize();
+ }
+ // allocate memory and initializing headers for calculating
+ cv::AutoBuffer<double> _buffer(nvars*2);
+ double* _diffin = _buffer;
+ double* _diffout = _buffer + nvars;
+ Mat diffin( 1, nvars, CV_64FC1, _diffin );
+ Mat diffout( 1, nvars, CV_64FC1, _diffout );
+
+ for(int k = range.start; k < range.end; k++ )
+ {
+ double opt = FLT_MAX;
+
+ for(int i = 0; i < nclasses; i++ )
+ {
+ double cur = c->at<double>(i);
+ const Mat& u = cov_rotate_mats->at(i);
+ const Mat& w = inv_eigen_values->at(i);
+
+ const double* avg_data = avg->at(i).ptr<double>();
+ const float* x = samples->ptr<float>(k);
+
+ // cov = u w u' --> cov^(-1) = u w^(-1) u'
+ for(int j = 0; j < nvars; j++ )
+ _diffin[j] = avg_data[j] - x[vptr ? vptr[j] : j];
+
+ gemm( diffin, u, 1, noArray(), 0, diffout, GEMM_2_T );
+ for(int j = 0; j < nvars; j++ )
+ {
+ double d = _diffout[j];
+ cur += d*d*w.ptr<double>()[j];
+ }
+
+ if( cur < opt )
+ {
+ cls = i;
+ opt = cur;
+ }
+ probability = exp( -0.5 * cur );
+
+ if( results_prob )
+ {
+ if ( rptype == CV_32FC1 )
+ results_prob->ptr<float>()[k*rpstep + i] = (float)probability;
+ else
+ results_prob->ptr<double>()[k*rpstep + i] = probability;
+ }
+ }
+
+ int ival = rawOutput ? cls : cls_labels->at<int>(cls);
+ if( results )
+ {
+ if( rtype == CV_32SC1 )
+ results->ptr<int>()[k*rstep] = ival;
+ else
+ results->ptr<float>()[k*rstep] = (float)ival;
+ }
}
- /* probability = exp( -0.5 * cur ) */
- probability = exp( -0.5 * cur );
- }
-
- ival = cls_labels->data.i[cls];
- if( results )
- {
- if( rtype == CV_32SC1 )
- results->data.i[k*rstep] = ival;
- else
- results->data.fl[k*rstep] = (float)ival;
- }
- if ( results_prob )
- {
- if ( rptype == CV_32FC1 )
- results_prob->data.fl[k*rpstep] = (float)probability;
- else
- results_prob->data.db[k*rpstep] = probability;
}
- if( k == 0 )
- *value = (float)ival;
- }
- }
-};
-
-
-float CvNormalBayesClassifier::predict( const CvMat* samples, CvMat* results, CvMat* results_prob ) const
-{
- float value = 0;
+ };
- if( !CV_IS_MAT(samples) || CV_MAT_TYPE(samples->type) != CV_32FC1 || samples->cols != var_all )
- CV_Error( CV_StsBadArg,
- "The input samples must be 32f matrix with the number of columns = var_all" );
-
- if( samples->rows > 1 && !results )
- CV_Error( CV_StsNullPtr,
- "When the number of input samples is >1, the output vector of results must be passed" );
-
- if( results )
+ float predict( InputArray _samples, OutputArray _results, int flags ) const
{
- if( !CV_IS_MAT(results) || (CV_MAT_TYPE(results->type) != CV_32FC1 &&
- CV_MAT_TYPE(results->type) != CV_32SC1) ||
- (results->cols != 1 && results->rows != 1) ||
- results->cols + results->rows - 1 != samples->rows )
- CV_Error( CV_StsBadArg, "The output array must be integer or floating-point vector "
- "with the number of elements = number of rows in the input matrix" );
+ return predictProb(_samples, _results, noArray(), flags);
}
- if( results_prob )
+ float predictProb( InputArray _samples, OutputArray _results, OutputArray _resultsProb, int flags ) const
{
- if( !CV_IS_MAT(results_prob) || (CV_MAT_TYPE(results_prob->type) != CV_32FC1 &&
- CV_MAT_TYPE(results_prob->type) != CV_64FC1) ||
- (results_prob->cols != 1 && results_prob->rows != 1) ||
- results_prob->cols + results_prob->rows - 1 != samples->rows )
- CV_Error( CV_StsBadArg, "The output array must be double or float vector "
- "with the number of elements = number of rows in the input matrix" );
- }
+ int value=0;
+ Mat samples = _samples.getMat(), results, resultsProb;
+ int nsamples = samples.rows, nclasses = (int)cls_labels.total();
+ bool rawOutput = (flags & RAW_OUTPUT) != 0;
- const int* vidx = var_idx ? var_idx->data.i : 0;
+ if( samples.type() != CV_32F || samples.cols != nallvars )
+ CV_Error( CV_StsBadArg,
+ "The input samples must be 32f matrix with the number of columns = nallvars" );
- cv::parallel_for_(cv::Range(0, samples->rows),
- predict_body(c, cov_rotate_mats, inv_eigen_values, avg, samples,
- vidx, cls_labels, results, &value, var_count, results_prob));
+ if( samples.rows > 1 && _results.needed() )
+ CV_Error( CV_StsNullPtr,
+ "When the number of input samples is >1, the output vector of results must be passed" );
- return value;
-}
+ if( _results.needed() )
+ {
+ _results.create(nsamples, 1, CV_32S);
+ results = _results.getMat();
+ }
+ else
+ results = Mat(1, 1, CV_32S, &value);
+ if( _resultsProb.needed() )
+ {
+ _resultsProb.create(nsamples, nclasses, CV_32F);
+ resultsProb = _resultsProb.getMat();
+ }
-void CvNormalBayesClassifier::write( CvFileStorage* fs, const char* name ) const
-{
- CV_FUNCNAME( "CvNormalBayesClassifier::write" );
+ cv::parallel_for_(cv::Range(0, nsamples),
+ NBPredictBody(c, cov_rotate_mats, inv_eigen_values, avg, samples,
+ var_idx, cls_labels, results, resultsProb, rawOutput));
+
+ return (float)value;
+ }
- __BEGIN__;
+ void write( FileStorage& fs ) const
+ {
+ int nclasses = (int)cls_labels.total(), i;
- int nclasses, i;
+ fs << "var_count" << (var_idx.empty() ? nallvars : (int)var_idx.total());
+ fs << "var_all" << nallvars;
- nclasses = cls_labels->cols;
+ if( !var_idx.empty() )
+ fs << "var_idx" << var_idx;
+ fs << "cls_labels" << cls_labels;
- cvStartWriteStruct( fs, name, CV_NODE_MAP, CV_TYPE_NAME_ML_NBAYES );
+ fs << "count" << "[";
+ for( i = 0; i < nclasses; i++ )
+ fs << count[i];
- CV_CALL( cvWriteInt( fs, "var_count", var_count ));
- CV_CALL( cvWriteInt( fs, "var_all", var_all ));
+ fs << "]" << "sum" << "[";
+ for( i = 0; i < nclasses; i++ )
+ fs << sum[i];
- if( var_idx )
- CV_CALL( cvWrite( fs, "var_idx", var_idx ));
- CV_CALL( cvWrite( fs, "cls_labels", cls_labels ));
+ fs << "]" << "productsum" << "[";
+ for( i = 0; i < nclasses; i++ )
+ fs << productsum[i];
- CV_CALL( cvStartWriteStruct( fs, "count", CV_NODE_SEQ ));
- for( i = 0; i < nclasses; i++ )
- CV_CALL( cvWrite( fs, NULL, count[i] ));
- CV_CALL( cvEndWriteStruct( fs ));
+ fs << "]" << "avg" << "[";
+ for( i = 0; i < nclasses; i++ )
+ fs << avg[i];
- CV_CALL( cvStartWriteStruct( fs, "sum", CV_NODE_SEQ ));
- for( i = 0; i < nclasses; i++ )
- CV_CALL( cvWrite( fs, NULL, sum[i] ));
- CV_CALL( cvEndWriteStruct( fs ));
+ fs << "]" << "inv_eigen_values" << "[";
+ for( i = 0; i < nclasses; i++ )
+ fs << inv_eigen_values[i];
- CV_CALL( cvStartWriteStruct( fs, "productsum", CV_NODE_SEQ ));
- for( i = 0; i < nclasses; i++ )
- CV_CALL( cvWrite( fs, NULL, productsum[i] ));
- CV_CALL( cvEndWriteStruct( fs ));
+ fs << "]" << "cov_rotate_mats" << "[";
+ for( i = 0; i < nclasses; i++ )
+ fs << cov_rotate_mats[i];
- CV_CALL( cvStartWriteStruct( fs, "avg", CV_NODE_SEQ ));
- for( i = 0; i < nclasses; i++ )
- CV_CALL( cvWrite( fs, NULL, avg[i] ));
- CV_CALL( cvEndWriteStruct( fs ));
+ fs << "]";
- CV_CALL( cvStartWriteStruct( fs, "inv_eigen_values", CV_NODE_SEQ ));
- for( i = 0; i < nclasses; i++ )
- CV_CALL( cvWrite( fs, NULL, inv_eigen_values[i] ));
- CV_CALL( cvEndWriteStruct( fs ));
+ fs << "c" << c;
+ }
- CV_CALL( cvStartWriteStruct( fs, "cov_rotate_mats", CV_NODE_SEQ ));
- for( i = 0; i < nclasses; i++ )
- CV_CALL( cvWrite( fs, NULL, cov_rotate_mats[i] ));
- CV_CALL( cvEndWriteStruct( fs ));
+ void read( const FileNode& fn )
+ {
+ clear();
- CV_CALL( cvWrite( fs, "c", c ));
+ fn["var_all"] >> nallvars;
- cvEndWriteStruct( fs );
+ if( nallvars <= 0 )
+ CV_Error( CV_StsParseError,
+ "The field \"var_count\" of NBayes classifier is missing or non-positive" );
- __END__;
-}
+ fn["var_idx"] >> var_idx;
+ fn["cls_labels"] >> cls_labels;
+ int nclasses = (int)cls_labels.total(), i;
-void CvNormalBayesClassifier::read( CvFileStorage* fs, CvFileNode* root_node )
-{
- bool ok = false;
- CV_FUNCNAME( "CvNormalBayesClassifier::read" );
-
- __BEGIN__;
-
- int nclasses, i;
- size_t data_size;
- CvFileNode* node;
- CvSeq* seq;
- CvSeqReader reader;
-
- clear();
-
- CV_CALL( var_count = cvReadIntByName( fs, root_node, "var_count", -1 ));
- CV_CALL( var_all = cvReadIntByName( fs, root_node, "var_all", -1 ));
- CV_CALL( var_idx = (CvMat*)cvReadByName( fs, root_node, "var_idx" ));
- CV_CALL( cls_labels = (CvMat*)cvReadByName( fs, root_node, "cls_labels" ));
- if( !cls_labels )
- CV_ERROR( CV_StsParseError, "No \"cls_labels\" in NBayes classifier" );
- if( cls_labels->cols < 1 )
- CV_ERROR( CV_StsBadArg, "Number of classes is less 1" );
- if( var_count <= 0 )
- CV_ERROR( CV_StsParseError,
- "The field \"var_count\" of NBayes classifier is missing" );
- nclasses = cls_labels->cols;
-
- data_size = nclasses*6*sizeof(CvMat*);
- CV_CALL( count = (CvMat**)cvAlloc( data_size ));
- memset( count, 0, data_size );
-
- sum = count + nclasses;
- productsum = sum + nclasses;
- avg = productsum + nclasses;
- inv_eigen_values = avg + nclasses;
- cov_rotate_mats = inv_eigen_values + nclasses;
-
- CV_CALL( node = cvGetFileNodeByName( fs, root_node, "count" ));
- seq = node->data.seq;
- if( !CV_NODE_IS_SEQ(node->tag) || seq->total != nclasses)
- CV_ERROR( CV_StsBadArg, "" );
- CV_CALL( cvStartReadSeq( seq, &reader, 0 ));
- for( i = 0; i < nclasses; i++ )
- {
- CV_CALL( count[i] = (CvMat*)cvRead( fs, (CvFileNode*)reader.ptr ));
- CV_NEXT_SEQ_ELEM( seq->elem_size, reader );
- }
+ if( cls_labels.empty() || nclasses < 1 )
+ CV_Error( CV_StsParseError, "No or invalid \"cls_labels\" in NBayes classifier" );
- CV_CALL( node = cvGetFileNodeByName( fs, root_node, "sum" ));
- seq = node->data.seq;
- if( !CV_NODE_IS_SEQ(node->tag) || seq->total != nclasses)
- CV_ERROR( CV_StsBadArg, "" );
- CV_CALL( cvStartReadSeq( seq, &reader, 0 ));
- for( i = 0; i < nclasses; i++ )
- {
- CV_CALL( sum[i] = (CvMat*)cvRead( fs, (CvFileNode*)reader.ptr ));
- CV_NEXT_SEQ_ELEM( seq->elem_size, reader );
- }
+ FileNodeIterator
+ count_it = fn["count"].begin(),
+ sum_it = fn["sum"].begin(),
+ productsum_it = fn["productsum"].begin(),
+ avg_it = fn["avg"].begin(),
+ inv_eigen_values_it = fn["inv_eigen_values"].begin(),
+ cov_rotate_mats_it = fn["cov_rotate_mats"].begin();
- CV_CALL( node = cvGetFileNodeByName( fs, root_node, "productsum" ));
- seq = node->data.seq;
- if( !CV_NODE_IS_SEQ(node->tag) || seq->total != nclasses)
- CV_ERROR( CV_StsBadArg, "" );
- CV_CALL( cvStartReadSeq( seq, &reader, 0 ));
- for( i = 0; i < nclasses; i++ )
- {
- CV_CALL( productsum[i] = (CvMat*)cvRead( fs, (CvFileNode*)reader.ptr ));
- CV_NEXT_SEQ_ELEM( seq->elem_size, reader );
- }
+ count.resize(nclasses);
+ sum.resize(nclasses);
+ productsum.resize(nclasses);
+ avg.resize(nclasses);
+ inv_eigen_values.resize(nclasses);
+ cov_rotate_mats.resize(nclasses);
- CV_CALL( node = cvGetFileNodeByName( fs, root_node, "avg" ));
- seq = node->data.seq;
- if( !CV_NODE_IS_SEQ(node->tag) || seq->total != nclasses)
- CV_ERROR( CV_StsBadArg, "" );
- CV_CALL( cvStartReadSeq( seq, &reader, 0 ));
- for( i = 0; i < nclasses; i++ )
- {
- CV_CALL( avg[i] = (CvMat*)cvRead( fs, (CvFileNode*)reader.ptr ));
- CV_NEXT_SEQ_ELEM( seq->elem_size, reader );
- }
+ for( i = 0; i < nclasses; i++, ++count_it, ++sum_it, ++productsum_it, ++avg_it,
+ ++inv_eigen_values_it, ++cov_rotate_mats_it )
+ {
+ *count_it >> count[i];
+ *sum_it >> sum[i];
+ *productsum_it >> productsum[i];
+ *avg_it >> avg[i];
+ *inv_eigen_values_it >> inv_eigen_values[i];
+ *cov_rotate_mats_it >> cov_rotate_mats[i];
+ }
- CV_CALL( node = cvGetFileNodeByName( fs, root_node, "inv_eigen_values" ));
- seq = node->data.seq;
- if( !CV_NODE_IS_SEQ(node->tag) || seq->total != nclasses)
- CV_ERROR( CV_StsBadArg, "" );
- CV_CALL( cvStartReadSeq( seq, &reader, 0 ));
- for( i = 0; i < nclasses; i++ )
- {
- CV_CALL( inv_eigen_values[i] = (CvMat*)cvRead( fs, (CvFileNode*)reader.ptr ));
- CV_NEXT_SEQ_ELEM( seq->elem_size, reader );
+ fn["c"] >> c;
}
- CV_CALL( node = cvGetFileNodeByName( fs, root_node, "cov_rotate_mats" ));
- seq = node->data.seq;
- if( !CV_NODE_IS_SEQ(node->tag) || seq->total != nclasses)
- CV_ERROR( CV_StsBadArg, "" );
- CV_CALL( cvStartReadSeq( seq, &reader, 0 ));
- for( i = 0; i < nclasses; i++ )
+ void clear()
{
- CV_CALL( cov_rotate_mats[i] = (CvMat*)cvRead( fs, (CvFileNode*)reader.ptr ));
- CV_NEXT_SEQ_ELEM( seq->elem_size, reader );
+ count.clear();
+ sum.clear();
+ productsum.clear();
+ avg.clear();
+ inv_eigen_values.clear();
+ cov_rotate_mats.clear();
+
+ var_idx.release();
+ cls_labels.release();
+ c.release();
+ nallvars = 0;
}
- CV_CALL( c = (CvMat*)cvReadByName( fs, root_node, "c" ));
-
- ok = true;
+ bool isTrained() const { return !avg.empty(); }
+ bool isClassifier() const { return true; }
+ int getVarCount() const { return nallvars; }
+ String getDefaultModelName() const { return "opencv_ml_nbayes"; }
- __END__;
-
- if( !ok )
- clear();
-}
+ int nallvars;
+ Mat var_idx, cls_labels, c;
+ vector<Mat> count, sum, productsum, avg, inv_eigen_values, cov_rotate_mats;
+};
-using namespace cv;
-CvNormalBayesClassifier::CvNormalBayesClassifier( const Mat& _train_data, const Mat& _responses,
- const Mat& _var_idx, const Mat& _sample_idx )
+Ptr<NormalBayesClassifier> NormalBayesClassifier::create()
{
- var_count = var_all = 0;
- var_idx = 0;
- cls_labels = 0;
- count = 0;
- sum = 0;
- productsum = 0;
- avg = 0;
- inv_eigen_values = 0;
- cov_rotate_mats = 0;
- c = 0;
- default_model_name = "my_nb";
-
- CvMat tdata = _train_data, responses = _responses, vidx = _var_idx, sidx = _sample_idx;
- train(&tdata, &responses, vidx.data.ptr ? &vidx : 0,
- sidx.data.ptr ? &sidx : 0);
+ Ptr<NormalBayesClassifierImpl> p = makePtr<NormalBayesClassifierImpl>();
+ return p;
}
-bool CvNormalBayesClassifier::train( const Mat& _train_data, const Mat& _responses,
- const Mat& _var_idx, const Mat& _sample_idx, bool update )
-{
- CvMat tdata = _train_data, responses = _responses, vidx = _var_idx, sidx = _sample_idx;
- return train(&tdata, &responses, vidx.data.ptr ? &vidx : 0,
- sidx.data.ptr ? &sidx : 0, update);
}
-
-float CvNormalBayesClassifier::predict( const Mat& _samples, Mat* _results, Mat* _results_prob ) const
-{
- CvMat samples = _samples, results, *presults = 0, results_prob, *presults_prob = 0;
-
- if( _results )
- {
- if( !(_results->data && _results->type() == CV_32F &&
- (_results->cols == 1 || _results->rows == 1) &&
- _results->cols + _results->rows - 1 == _samples.rows) )
- _results->create(_samples.rows, 1, CV_32F);
- presults = &(results = *_results);
- }
-
- if( _results_prob )
- {
- if( !(_results_prob->data && _results_prob->type() == CV_64F &&
- (_results_prob->cols == 1 || _results_prob->rows == 1) &&
- _results_prob->cols + _results_prob->rows - 1 == _samples.rows) )
- _results_prob->create(_samples.rows, 1, CV_64F);
- presults_prob = &(results_prob = *_results_prob);
- }
-
- return predict(&samples, presults, presults_prob);
}
/* End of file. */
//
//M*/
-#ifndef __OPENCV_PRECOMP_H__
-#define __OPENCV_PRECOMP_H__
+#ifndef __OPENCV_ML_PRECOMP_HPP__
+#define __OPENCV_ML_PRECOMP_HPP__
#include "opencv2/core.hpp"
#include "opencv2/ml.hpp"
#include <stdio.h>
#include <string.h>
#include <time.h>
+#include <vector>
-#define ML_IMPL CV_IMPL
-#define __BEGIN__ __CV_BEGIN__
-#define __END__ __CV_END__
-#define EXIT __CV_EXIT__
-
-#define CV_MAT_ELEM_FLAG( mat, type, comp, vect, tflag ) \
- (( tflag == CV_ROW_SAMPLE ) \
- ? (CV_MAT_ELEM( mat, type, comp, vect )) \
- : (CV_MAT_ELEM( mat, type, vect, comp )))
-
-/* Convert matrix to vector */
-#define ICV_MAT2VEC( mat, vdata, vstep, num ) \
- if( MIN( (mat).rows, (mat).cols ) != 1 ) \
- CV_ERROR( CV_StsBadArg, "" ); \
- (vdata) = ((mat).data.ptr); \
- if( (mat).rows == 1 ) \
- { \
- (vstep) = CV_ELEM_SIZE( (mat).type ); \
- (num) = (mat).cols; \
- } \
- else \
- { \
- (vstep) = (mat).step; \
- (num) = (mat).rows; \
- }
+/****************************************************************************************\
+ * Main struct definitions *
+ \****************************************************************************************/
-/* get raw data */
-#define ICV_RAWDATA( mat, flags, rdata, sstep, cstep, m, n ) \
- (rdata) = (mat).data.ptr; \
- if( CV_IS_ROW_SAMPLE( flags ) ) \
- { \
- (sstep) = (mat).step; \
- (cstep) = CV_ELEM_SIZE( (mat).type ); \
- (m) = (mat).rows; \
- (n) = (mat).cols; \
- } \
- else \
- { \
- (cstep) = (mat).step; \
- (sstep) = CV_ELEM_SIZE( (mat).type ); \
- (n) = (mat).rows; \
- (m) = (mat).cols; \
- }
+/* log(2*PI) */
+#define CV_LOG2PI (1.8378770664093454835606594728112)
-#define ICV_IS_MAT_OF_TYPE( mat, mat_type) \
- (CV_IS_MAT( mat ) && CV_MAT_TYPE( mat->type ) == (mat_type) && \
- (mat)->cols > 0 && (mat)->rows > 0)
-
-/*
- uchar* data; int sstep, cstep; - trainData->data
- uchar* classes; int clstep; int ncl;- trainClasses
- uchar* tmask; int tmstep; int ntm; - typeMask
- uchar* missed;int msstep, mcstep; -missedMeasurements...
- int mm, mn; == m,n == size,dim
- uchar* sidx;int sistep; - sampleIdx
- uchar* cidx;int cistep; - compIdx
- int k, l; == n,m == dim,size (length of cidx, sidx)
- int m, n; == size,dim
-*/
-#define ICV_DECLARE_TRAIN_ARGS() \
- uchar* data; \
- int sstep, cstep; \
- uchar* classes; \
- int clstep; \
- int ncl; \
- uchar* tmask; \
- int tmstep; \
- int ntm; \
- uchar* missed; \
- int msstep, mcstep; \
- int mm, mn; \
- uchar* sidx; \
- int sistep; \
- uchar* cidx; \
- int cistep; \
- int k, l; \
- int m, n; \
- \
- data = classes = tmask = missed = sidx = cidx = NULL; \
- sstep = cstep = clstep = ncl = tmstep = ntm = msstep = mcstep = mm = mn = 0; \
- sistep = cistep = k = l = m = n = 0;
-
-#define ICV_TRAIN_DATA_REQUIRED( param, flags ) \
- if( !ICV_IS_MAT_OF_TYPE( (param), CV_32FC1 ) ) \
- { \
- CV_ERROR( CV_StsBadArg, "Invalid " #param " parameter" ); \
- } \
- else \
- { \
- ICV_RAWDATA( *(param), (flags), data, sstep, cstep, m, n ); \
- k = n; \
- l = m; \
- }
+namespace cv
+{
+namespace ml
+{
+ using std::vector;
-#define ICV_TRAIN_CLASSES_REQUIRED( param ) \
- if( !ICV_IS_MAT_OF_TYPE( (param), CV_32FC1 ) ) \
- { \
- CV_ERROR( CV_StsBadArg, "Invalid " #param " parameter" ); \
- } \
- else \
- { \
- ICV_MAT2VEC( *(param), classes, clstep, ncl ); \
- if( m != ncl ) \
- { \
- CV_ERROR( CV_StsBadArg, "Unmatched sizes" ); \
- } \
- }
+ #define CV_DTREE_CAT_DIR(idx,subset) \
+ (2*((subset[(idx)>>5]&(1 << ((idx) & 31)))==0)-1)
-#define ICV_ARG_NULL( param ) \
- if( (param) != NULL ) \
- { \
- CV_ERROR( CV_StsBadArg, #param " parameter must be NULL" ); \
- }
+ template<typename _Tp> struct cmp_lt_idx
+ {
+ cmp_lt_idx(const _Tp* _arr) : arr(_arr) {}
+ bool operator ()(int a, int b) const { return arr[a] < arr[b]; }
+ const _Tp* arr;
+ };
-#define ICV_MISSED_MEASUREMENTS_OPTIONAL( param, flags ) \
- if( param ) \
- { \
- if( !ICV_IS_MAT_OF_TYPE( param, CV_8UC1 ) ) \
- { \
- CV_ERROR( CV_StsBadArg, "Invalid " #param " parameter" ); \
- } \
- else \
- { \
- ICV_RAWDATA( *(param), (flags), missed, msstep, mcstep, mm, mn ); \
- if( mm != m || mn != n ) \
- { \
- CV_ERROR( CV_StsBadArg, "Unmatched sizes" ); \
- } \
- } \
- }
+ template<typename _Tp> struct cmp_lt_ptr
+ {
+ cmp_lt_ptr() {}
+ bool operator ()(const _Tp* a, const _Tp* b) const { return *a < *b; }
+ };
-#define ICV_COMP_IDX_OPTIONAL( param ) \
- if( param ) \
- { \
- if( !ICV_IS_MAT_OF_TYPE( param, CV_32SC1 ) ) \
- { \
- CV_ERROR( CV_StsBadArg, "Invalid " #param " parameter" ); \
- } \
- else \
- { \
- ICV_MAT2VEC( *(param), cidx, cistep, k ); \
- if( k > n ) \
- CV_ERROR( CV_StsBadArg, "Invalid " #param " parameter" ); \
- } \
+ static inline void setRangeVector(std::vector<int>& vec, int n)
+ {
+ vec.resize(n);
+ for( int i = 0; i < n; i++ )
+ vec[i] = i;
}
-#define ICV_SAMPLE_IDX_OPTIONAL( param ) \
- if( param ) \
- { \
- if( !ICV_IS_MAT_OF_TYPE( param, CV_32SC1 ) ) \
- { \
- CV_ERROR( CV_StsBadArg, "Invalid " #param " parameter" ); \
- } \
- else \
- { \
- ICV_MAT2VEC( *sampleIdx, sidx, sistep, l ); \
- if( l > m ) \
- CV_ERROR( CV_StsBadArg, "Invalid " #param " parameter" ); \
- } \
+ static inline void writeTermCrit(FileStorage& fs, const TermCriteria& termCrit)
+ {
+ if( (termCrit.type & TermCriteria::EPS) != 0 )
+ fs << "epsilon" << termCrit.epsilon;
+ if( (termCrit.type & TermCriteria::COUNT) != 0 )
+ fs << "iterations" << termCrit.maxCount;
}
-/****************************************************************************************/
-#define ICV_CONVERT_FLOAT_ARRAY_TO_MATRICE( array, matrice ) \
-{ \
- CvMat a, b; \
- int dims = (matrice)->cols; \
- int nsamples = (matrice)->rows; \
- int type = CV_MAT_TYPE((matrice)->type); \
- int i, offset = dims; \
- \
- CV_ASSERT( type == CV_32FC1 || type == CV_64FC1 ); \
- offset *= ((type == CV_32FC1) ? sizeof(float) : sizeof(double));\
- \
- b = cvMat( 1, dims, CV_32FC1 ); \
- cvGetRow( matrice, &a, 0 ); \
- for( i = 0; i < nsamples; i++, a.data.ptr += offset ) \
- { \
- b.data.fl = (float*)array[i]; \
- CV_CALL( cvConvert( &b, &a ) ); \
- } \
-}
-
-/****************************************************************************************\
-* Auxiliary functions declarations *
-\****************************************************************************************/
-
-/* Generates a set of classes centers in quantity <num_of_clusters> that are generated as
- uniform random vectors in parallelepiped, where <data> is concentrated. Vectors in
- <data> should have horizontal orientation. If <centers> != NULL, the function doesn't
- allocate any memory and stores generated centers in <centers>, returns <centers>.
- If <centers> == NULL, the function allocates memory and creates the matrice. Centers
- are supposed to be oriented horizontally. */
-CvMat* icvGenerateRandomClusterCenters( int seed,
- const CvMat* data,
- int num_of_clusters,
- CvMat* centers CV_DEFAULT(0));
-
-/* Fills the <labels> using <probs> by choosing the maximal probability. Outliers are
- fixed by <oulier_tresh> and have cluster label (-1). Function also controls that there
- weren't "empty" clusters by filling empty clusters with the maximal probability vector.
- If probs_sums != NULL, filles it with the sums of probabilities for each sample (it is
- useful for normalizing probabilities' matrice of FCM) */
-void icvFindClusterLabels( const CvMat* probs, float outlier_thresh, float r,
- const CvMat* labels );
-
-typedef struct CvSparseVecElem32f
-{
- int idx;
- float val;
-}
-CvSparseVecElem32f;
-
-/* Prepare training data and related parameters */
-#define CV_TRAIN_STATMODEL_DEFRAGMENT_TRAIN_DATA 1
-#define CV_TRAIN_STATMODEL_SAMPLES_AS_ROWS 2
-#define CV_TRAIN_STATMODEL_SAMPLES_AS_COLUMNS 4
-#define CV_TRAIN_STATMODEL_CATEGORICAL_RESPONSE 8
-#define CV_TRAIN_STATMODEL_ORDERED_RESPONSE 16
-#define CV_TRAIN_STATMODEL_RESPONSES_ON_OUTPUT 32
-#define CV_TRAIN_STATMODEL_ALWAYS_COPY_TRAIN_DATA 64
-#define CV_TRAIN_STATMODEL_SPARSE_AS_SPARSE 128
-
-int
-cvPrepareTrainData( const char* /*funcname*/,
- const CvMat* train_data, int tflag,
- const CvMat* responses, int response_type,
- const CvMat* var_idx,
- const CvMat* sample_idx,
- bool always_copy_data,
- const float*** out_train_samples,
- int* _sample_count,
- int* _var_count,
- int* _var_all,
- CvMat** out_responses,
- CvMat** out_response_map,
- CvMat** out_var_idx,
- CvMat** out_sample_idx=0 );
-
-void
-cvSortSamplesByClasses( const float** samples, const CvMat* classes,
- int* class_ranges, const uchar** mask CV_DEFAULT(0) );
-
-void
-cvCombineResponseMaps (CvMat* _responses,
- const CvMat* old_response_map,
- CvMat* new_response_map,
- CvMat** out_response_map);
-
-void
-cvPreparePredictData( const CvArr* sample, int dims_all, const CvMat* comp_idx,
- int class_count, const CvMat* prob, float** row_sample,
- int as_sparse CV_DEFAULT(0) );
-
-/* copies clustering [or batch "predict"] results
- (labels and/or centers and/or probs) back to the output arrays */
-void
-cvWritebackLabels( const CvMat* labels, CvMat* dst_labels,
- const CvMat* centers, CvMat* dst_centers,
- const CvMat* probs, CvMat* dst_probs,
- const CvMat* sample_idx, int samples_all,
- const CvMat* comp_idx, int dims_all );
-#define cvWritebackResponses cvWritebackLabels
-
-#define XML_FIELD_NAME "_name"
-CvFileNode* icvFileNodeGetChild(CvFileNode* father, const char* name);
-CvFileNode* icvFileNodeGetChildArrayElem(CvFileNode* father, const char* name,int index);
-CvFileNode* icvFileNodeGetNext(CvFileNode* n, const char* name);
-
-
-void cvCheckTrainData( const CvMat* train_data, int tflag,
- const CvMat* missing_mask,
- int* var_all, int* sample_all );
-
-CvMat* cvPreprocessIndexArray( const CvMat* idx_arr, int data_arr_size, bool check_for_duplicates=false );
-
-CvMat* cvPreprocessVarType( const CvMat* type_mask, const CvMat* var_idx,
- int var_all, int* response_type );
-
-CvMat* cvPreprocessOrderedResponses( const CvMat* responses,
- const CvMat* sample_idx, int sample_all );
-
-CvMat* cvPreprocessCategoricalResponses( const CvMat* responses,
- const CvMat* sample_idx, int sample_all,
- CvMat** out_response_map, CvMat** class_counts=0 );
-
-const float** cvGetTrainSamples( const CvMat* train_data, int tflag,
- const CvMat* var_idx, const CvMat* sample_idx,
- int* _var_count, int* _sample_count,
- bool always_copy_data=false );
-
-namespace cv
-{
- struct DTreeBestSplitFinder
+ static inline TermCriteria readTermCrit(const FileNode& fn)
{
- DTreeBestSplitFinder(){ splitSize = 0, tree = 0; node = 0; }
- DTreeBestSplitFinder( CvDTree* _tree, CvDTreeNode* _node);
- DTreeBestSplitFinder( const DTreeBestSplitFinder& finder, Split );
- virtual ~DTreeBestSplitFinder() {}
- virtual void operator()(const BlockedRange& range);
- void join( DTreeBestSplitFinder& rhs );
- Ptr<CvDTreeSplit> bestSplit;
- Ptr<CvDTreeSplit> split;
- int splitSize;
- CvDTree* tree;
- CvDTreeNode* node;
- };
+ TermCriteria termCrit;
+ double epsilon = (double)fn["epsilon"];
+ if( epsilon > 0 )
+ {
+ termCrit.type |= TermCriteria::EPS;
+ termCrit.epsilon = epsilon;
+ }
+ int iters = (double)fn["iterations"];
+ if( iters > 0 )
+ {
+ termCrit.type |= TermCriteria::COUNT;
+ termCrit.maxCount = iters;
+ }
+ return termCrit;
+ }
- struct ForestTreeBestSplitFinder : DTreeBestSplitFinder
+ class DTreesImpl : public DTrees
{
- ForestTreeBestSplitFinder() : DTreeBestSplitFinder() {}
- ForestTreeBestSplitFinder( CvForestTree* _tree, CvDTreeNode* _node );
- ForestTreeBestSplitFinder( const ForestTreeBestSplitFinder& finder, Split );
- virtual void operator()(const BlockedRange& range);
+ public:
+ struct WNode
+ {
+ WNode()
+ {
+ class_idx = sample_count = depth = complexity = 0;
+ parent = left = right = split = defaultDir = -1;
+ Tn = INT_MAX;
+ value = maxlr = alpha = node_risk = tree_risk = tree_error = 0.;
+ }
+
+ int class_idx;
+ int Tn;
+ double value;
+
+ int parent;
+ int left;
+ int right;
+ int defaultDir;
+
+ int split;
+
+ int sample_count;
+ int depth;
+ double maxlr;
+
+ // global pruning data
+ int complexity;
+ double alpha;
+ double node_risk, tree_risk, tree_error;
+ };
+
+ struct WSplit
+ {
+ WSplit()
+ {
+ varIdx = inversed = next = 0;
+ quality = c = 0.f;
+ subsetOfs = -1;
+ }
+
+ int varIdx;
+ int inversed;
+ float quality;
+ int next;
+ float c;
+ int subsetOfs;
+ };
+
+ struct WorkData
+ {
+ WorkData(const Ptr<TrainData>& _data);
+
+ Ptr<TrainData> data;
+ vector<WNode> wnodes;
+ vector<WSplit> wsplits;
+ vector<int> wsubsets;
+ vector<int> cv_Tn;
+ vector<double> cv_node_risk;
+ vector<double> cv_node_error;
+ vector<int> cv_labels;
+ vector<double> sample_weights;
+ vector<int> cat_responses;
+ vector<double> ord_responses;
+ vector<int> sidx;
+ int maxSubsetSize;
+ };
+
+ DTreesImpl();
+ virtual ~DTreesImpl();
+ virtual void clear();
+
+ String getDefaultModelName() const { return "opencv_ml_dtree"; }
+ bool isTrained() const { return !roots.empty(); }
+ bool isClassifier() const { return _isClassifier; }
+ int getVarCount() const { return varType.empty() ? 0 : (int)(varType.size() - 1); }
+ int getCatCount(int vi) const { return catOfs[vi][1] - catOfs[vi][0]; }
+ int getSubsetSize(int vi) const { return (getCatCount(vi) + 31)/32; }
+
+ virtual void setDParams(const Params& _params);
+ virtual Params getDParams() const;
+ virtual void startTraining( const Ptr<TrainData>& trainData, int flags );
+ virtual void endTraining();
+ virtual void initCompVarIdx();
+ virtual bool train( const Ptr<TrainData>& trainData, int flags );
+
+ virtual int addTree( const vector<int>& sidx );
+ virtual int addNodeAndTrySplit( int parent, const vector<int>& sidx );
+ virtual const vector<int>& getActiveVars();
+ virtual int findBestSplit( const vector<int>& _sidx );
+ virtual void calcValue( int nidx, const vector<int>& _sidx );
+
+ virtual WSplit findSplitOrdClass( int vi, const vector<int>& _sidx, double initQuality );
+
+ // simple k-means, slightly modified to take into account the "weight" (L1-norm) of each vector.
+ virtual void clusterCategories( const double* vectors, int n, int m, double* csums, int k, int* labels );
+ virtual WSplit findSplitCatClass( int vi, const vector<int>& _sidx, double initQuality, int* subset );
+
+ virtual WSplit findSplitOrdReg( int vi, const vector<int>& _sidx, double initQuality );
+ virtual WSplit findSplitCatReg( int vi, const vector<int>& _sidx, double initQuality, int* subset );
+
+ virtual int calcDir( int splitidx, const vector<int>& _sidx, vector<int>& _sleft, vector<int>& _sright );
+ virtual int pruneCV( int root );
+
+ virtual double updateTreeRNC( int root, double T, int fold );
+ virtual bool cutTree( int root, double T, int fold, double min_alpha );
+ virtual float predictTrees( const Range& range, const Mat& sample, int flags ) const;
+ virtual float predict( InputArray inputs, OutputArray outputs, int flags ) const;
+
+ virtual void writeTrainingParams( FileStorage& fs ) const;
+ virtual void writeParams( FileStorage& fs ) const;
+ virtual void writeSplit( FileStorage& fs, int splitidx ) const;
+ virtual void writeNode( FileStorage& fs, int nidx, int depth ) const;
+ virtual void writeTree( FileStorage& fs, int root ) const;
+ virtual void write( FileStorage& fs ) const;
+
+ virtual void readParams( const FileNode& fn );
+ virtual int readSplit( const FileNode& fn );
+ virtual int readNode( const FileNode& fn );
+ virtual int readTree( const FileNode& fn );
+ virtual void read( const FileNode& fn );
+
+ virtual const std::vector<int>& getRoots() const { return roots; }
+ virtual const std::vector<Node>& getNodes() const { return nodes; }
+ virtual const std::vector<Split>& getSplits() const { return splits; }
+ virtual const std::vector<int>& getSubsets() const { return subsets; }
+
+ Params params0, params;
+
+ vector<int> varIdx;
+ vector<int> compVarIdx;
+ vector<uchar> varType;
+ vector<Vec2i> catOfs;
+ vector<int> catMap;
+ vector<int> roots;
+ vector<Node> nodes;
+ vector<Split> splits;
+ vector<int> subsets;
+ vector<int> classLabels;
+ vector<float> missingSubst;
+ bool _isClassifier;
+
+ Ptr<WorkData> w;
};
-}
-#endif /* __ML_H__ */
+}}
+
+#endif /* __OPENCV_ML_PRECOMP_HPP__ */
// copy or use the software.
//
//
-// Intel License Agreement
+// License Agreement
+// For Open Source Computer Vision Library
//
// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Copyright (C) 2014, Itseez Inc, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// 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
+// * The name of the copyright holders 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
#include "precomp.hpp"
-CvForestTree::CvForestTree()
-{
- forest = NULL;
-}
-
-
-CvForestTree::~CvForestTree()
-{
- clear();
-}
+namespace cv {
+namespace ml {
-
-bool CvForestTree::train( CvDTreeTrainData* _data,
- const CvMat* _subsample_idx,
- CvRTrees* _forest )
+//////////////////////////////////////////////////////////////////////////////////////////
+// Random trees //
+//////////////////////////////////////////////////////////////////////////////////////////
+RTrees::Params::Params()
+ : DTrees::Params(5, 10, 0.f, false, 10, 0, false, false, Mat())
{
- clear();
- forest = _forest;
-
- data = _data;
- data->shared = true;
- return do_train(_subsample_idx);
+ calcVarImportance = false;
+ nactiveVars = 0;
+ termCrit = TermCriteria(TermCriteria::EPS + TermCriteria::COUNT, 50, 0.1);
}
-
-bool
-CvForestTree::train( const CvMat*, int, const CvMat*, const CvMat*,
- const CvMat*, const CvMat*, const CvMat*, CvDTreeParams )
+RTrees::Params::Params( int _maxDepth, int _minSampleCount,
+ double _regressionAccuracy, bool _useSurrogates,
+ int _maxCategories, const Mat& _priors,
+ bool _calcVarImportance, int _nactiveVars,
+ TermCriteria _termCrit )
+ : DTrees::Params(_maxDepth, _minSampleCount, _regressionAccuracy, _useSurrogates,
+ _maxCategories, 0, false, false, _priors)
{
- assert(0);
- return false;
+ calcVarImportance = _calcVarImportance;
+ nactiveVars = _nactiveVars;
+ termCrit = _termCrit;
}
-bool
-CvForestTree::train( CvDTreeTrainData*, const CvMat* )
+class DTreesImplForRTrees : public DTreesImpl
{
- assert(0);
- return false;
-}
-
-
+public:
+ DTreesImplForRTrees() {}
+ virtual ~DTreesImplForRTrees() {}
-namespace cv
-{
-
-ForestTreeBestSplitFinder::ForestTreeBestSplitFinder( CvForestTree* _tree, CvDTreeNode* _node ) :
- DTreeBestSplitFinder(_tree, _node) {}
-
-ForestTreeBestSplitFinder::ForestTreeBestSplitFinder( const ForestTreeBestSplitFinder& finder, Split spl ) :
- DTreeBestSplitFinder( finder, spl ) {}
-
-void ForestTreeBestSplitFinder::operator()(const BlockedRange& range)
-{
- int vi, vi1 = range.begin(), vi2 = range.end();
- int n = node->sample_count;
- CvDTreeTrainData* data = tree->get_data();
- AutoBuffer<uchar> inn_buf(2*n*(sizeof(int) + sizeof(float)));
-
- CvForestTree* ftree = (CvForestTree*)tree;
- const CvMat* active_var_mask = ftree->forest->get_active_var_mask();
-
- for( vi = vi1; vi < vi2; vi++ )
+ void setRParams(const RTrees::Params& p)
{
- CvDTreeSplit *res;
- int ci = data->var_type->data.i[vi];
- if( node->num_valid[vi] <= 1
- || (active_var_mask && !active_var_mask->data.ptr[vi]) )
- continue;
-
- if( data->is_classifier )
- {
- if( ci >= 0 )
- res = ftree->find_split_cat_class( node, vi, bestSplit->quality, split, (uchar*)inn_buf );
- else
- res = ftree->find_split_ord_class( node, vi, bestSplit->quality, split, (uchar*)inn_buf );
- }
- else
- {
- if( ci >= 0 )
- res = ftree->find_split_cat_reg( node, vi, bestSplit->quality, split, (uchar*)inn_buf );
- else
- res = ftree->find_split_ord_reg( node, vi, bestSplit->quality, split, (uchar*)inn_buf );
- }
-
- if( res && bestSplit->quality < split->quality )
- memcpy( bestSplit.get(), split.get(), splitSize );
+ rparams = p;
}
-}
-}
-CvDTreeSplit* CvForestTree::find_best_split( CvDTreeNode* node )
-{
- CvMat* active_var_mask = 0;
- if( forest )
+ RTrees::Params getRParams() const
{
- int var_count;
- CvRNG* rng = forest->get_rng();
-
- active_var_mask = forest->get_active_var_mask();
- var_count = active_var_mask->cols;
-
- CV_Assert( var_count == data->var_count );
-
- for( int vi = 0; vi < var_count; vi++ )
- {
- uchar temp;
- int i1 = cvRandInt(rng) % var_count;
- int i2 = cvRandInt(rng) % var_count;
- CV_SWAP( active_var_mask->data.ptr[i1],
- active_var_mask->data.ptr[i2], temp );
- }
+ return rparams;
}
- cv::ForestTreeBestSplitFinder finder( this, node );
-
- cv::parallel_reduce(cv::BlockedRange(0, data->var_count), finder);
-
- CvDTreeSplit *bestSplit = 0;
- if( finder.bestSplit->quality > 0 )
+ void clear()
{
- bestSplit = data->new_split_cat( 0, -1.0f );
- memcpy( bestSplit, finder.bestSplit, finder.splitSize );
+ DTreesImpl::clear();
+ oobError = 0.;
+ rng = RNG(-1);
}
- return bestSplit;
-}
-
-void CvForestTree::read( CvFileStorage* fs, CvFileNode* fnode, CvRTrees* _forest, CvDTreeTrainData* _data )
-{
- CvDTree::read( fs, fnode, _data );
- forest = _forest;
-}
-
-
-void CvForestTree::read( CvFileStorage*, CvFileNode* )
-{
- assert(0);
-}
-
-void CvForestTree::read( CvFileStorage* _fs, CvFileNode* _node,
- CvDTreeTrainData* _data )
-{
- CvDTree::read( _fs, _node, _data );
-}
-
-
-//////////////////////////////////////////////////////////////////////////////////////////
-// Random trees //
-//////////////////////////////////////////////////////////////////////////////////////////
-CvRTParams::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::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);
-}
-
-CvRTrees::CvRTrees()
-{
- nclasses = 0;
- oob_error = 0;
- ntrees = 0;
- trees = NULL;
- data = NULL;
- active_var_mask = NULL;
- var_importance = NULL;
- rng = &cv::theRNG();
- default_model_name = "my_random_trees";
-}
-
-
-void CvRTrees::clear()
-{
- int k;
- for( k = 0; k < ntrees; k++ )
- delete trees[k];
- cvFree( &trees );
-
- delete data;
- data = 0;
-
- cvReleaseMat( &active_var_mask );
- cvReleaseMat( &var_importance );
- ntrees = 0;
-}
-
-
-CvRTrees::~CvRTrees()
-{
- clear();
-}
-
-cv::String CvRTrees::getName() const
-{
- return CV_TYPE_NAME_ML_RTREES;
-}
-
-CvMat* CvRTrees::get_active_var_mask()
-{
- return active_var_mask;
-}
-
-
-CvRNG* CvRTrees::get_rng()
-{
- return &rng->state;
-}
-
-bool CvRTrees::train( const CvMat* _train_data, int _tflag,
- const CvMat* _responses, const CvMat* _var_idx,
- const CvMat* _sample_idx, const CvMat* _var_type,
- const CvMat* _missing_mask, CvRTParams params )
-{
- clear();
-
- CvDTreeParams tree_params( params.max_depth, params.min_sample_count,
- params.regression_accuracy, params.use_surrogates, params.max_categories,
- params.cv_folds, params.use_1se_rule, false, params.priors );
-
- data = new CvDTreeTrainData();
- data->set_data( _train_data, _tflag, _responses, _var_idx,
- _sample_idx, _var_type, _missing_mask, tree_params, true);
-
- int var_count = data->var_count;
- if( params.nactive_vars > var_count )
- params.nactive_vars = var_count;
- else if( params.nactive_vars == 0 )
- params.nactive_vars = (int)sqrt((double)var_count);
- else if( params.nactive_vars < 0 )
- CV_Error( CV_StsBadArg, "<nactive_vars> must be non-negative" );
-
- // Create mask of active variables at the tree nodes
- active_var_mask = cvCreateMat( 1, var_count, CV_8UC1 );
- if( params.calc_var_importance )
+ const vector<int>& getActiveVars()
{
- var_importance = cvCreateMat( 1, var_count, CV_32FC1 );
- cvZero(var_importance);
- }
- { // initialize active variables mask
- CvMat submask1, submask2;
- CV_Assert( (active_var_mask->cols >= 1) && (params.nactive_vars > 0) && (params.nactive_vars <= active_var_mask->cols) );
- cvGetCols( active_var_mask, &submask1, 0, params.nactive_vars );
- cvSet( &submask1, cvScalar(1) );
- if( params.nactive_vars < active_var_mask->cols )
+ int i, nvars = (int)allVars.size(), m = (int)activeVars.size();
+ for( i = 0; i < nvars; i++ )
{
- cvGetCols( active_var_mask, &submask2, params.nactive_vars, var_count );
- cvZero( &submask2 );
+ int i1 = rng.uniform(0, nvars);
+ int i2 = rng.uniform(0, nvars);
+ std::swap(allVars[i1], allVars[i2]);
}
+ for( i = 0; i < m; i++ )
+ activeVars[i] = allVars[i];
+ return activeVars;
}
- return grow_forest( params.term_crit );
-}
-
-bool CvRTrees::train( CvMLData* _data, CvRTParams params )
-{
- const CvMat* values = _data->get_values();
- const CvMat* response = _data->get_responses();
- const CvMat* missing = _data->get_missing();
- const CvMat* var_types = _data->get_var_types();
- const CvMat* train_sidx = _data->get_train_sample_idx();
- const CvMat* var_idx = _data->get_var_idx();
-
- return train( values, CV_ROW_SAMPLE, response, var_idx,
- train_sidx, var_types, missing, params );
-}
-
-bool CvRTrees::grow_forest( const CvTermCriteria term_crit )
-{
- CvMat* sample_idx_mask_for_tree = 0;
- CvMat* sample_idx_for_tree = 0;
-
- const int max_ntrees = term_crit.max_iter;
- const double max_oob_err = term_crit.epsilon;
-
- const int dims = data->var_count;
- float maximal_response = 0;
-
- CvMat* oob_sample_votes = 0;
- CvMat* oob_responses = 0;
-
- float* oob_samples_perm_ptr= 0;
-
- float* samples_ptr = 0;
- uchar* missing_ptr = 0;
- float* true_resp_ptr = 0;
- bool is_oob_or_vimportance = (max_oob_err > 0 && term_crit.type != CV_TERMCRIT_ITER) || var_importance;
-
- // oob_predictions_sum[i] = sum of predicted values for the i-th sample
- // oob_num_of_predictions[i] = number of summands
- // (number of predictions for the i-th sample)
- // initialize these variable to avoid warning C4701
- CvMat oob_predictions_sum = cvMat( 1, 1, CV_32FC1 );
- CvMat oob_num_of_predictions = cvMat( 1, 1, CV_32FC1 );
-
- nsamples = data->sample_count;
- nclasses = data->get_num_classes();
-
- if ( is_oob_or_vimportance )
+ void startTraining( const Ptr<TrainData>& trainData, int flags )
{
- if( data->is_classifier )
- {
- oob_sample_votes = cvCreateMat( nsamples, nclasses, CV_32SC1 );
- cvZero(oob_sample_votes);
- }
- else
- {
- // oob_responses[0,i] = oob_predictions_sum[i]
- // = sum of predicted values for the i-th sample
- // oob_responses[1,i] = oob_num_of_predictions[i]
- // = number of summands (number of predictions for the i-th sample)
- oob_responses = cvCreateMat( 2, nsamples, CV_32FC1 );
- cvZero(oob_responses);
- cvGetRow( oob_responses, &oob_predictions_sum, 0 );
- cvGetRow( oob_responses, &oob_num_of_predictions, 1 );
- }
-
- oob_samples_perm_ptr = (float*)cvAlloc( sizeof(float)*nsamples*dims );
- samples_ptr = (float*)cvAlloc( sizeof(float)*nsamples*dims );
- missing_ptr = (uchar*)cvAlloc( sizeof(uchar)*nsamples*dims );
- true_resp_ptr = (float*)cvAlloc( sizeof(float)*nsamples );
-
- data->get_vectors( 0, samples_ptr, missing_ptr, true_resp_ptr );
-
- double minval, maxval;
- CvMat responses = cvMat(1, nsamples, CV_32FC1, true_resp_ptr);
- cvMinMaxLoc( &responses, &minval, &maxval );
- maximal_response = (float)MAX( MAX( fabs(minval), fabs(maxval) ), 0 );
+ DTreesImpl::startTraining(trainData, flags);
+ int nvars = w->data->getNVars();
+ int i, m = rparams.nactiveVars > 0 ? rparams.nactiveVars : cvRound(std::sqrt((double)nvars));
+ m = std::min(std::max(m, 1), nvars);
+ allVars.resize(nvars);
+ activeVars.resize(m);
+ for( i = 0; i < nvars; i++ )
+ allVars[i] = varIdx[i];
}
- trees = (CvForestTree**)cvAlloc( sizeof(trees[0])*max_ntrees );
- memset( trees, 0, sizeof(trees[0])*max_ntrees );
-
- sample_idx_mask_for_tree = cvCreateMat( 1, nsamples, CV_8UC1 );
- sample_idx_for_tree = cvCreateMat( 1, nsamples, CV_32SC1 );
-
- ntrees = 0;
- while( ntrees < max_ntrees )
+ void endTraining()
{
- int i, oob_samples_count = 0;
- double ncorrect_responses = 0; // used for estimation of variable importance
- CvForestTree* tree = 0;
+ DTreesImpl::endTraining();
+ vector<int> a, b;
+ std::swap(allVars, a);
+ std::swap(activeVars, b);
+ }
- cvZero( sample_idx_mask_for_tree );
- for(i = 0; i < nsamples; i++ ) //form sample for creation one tree
+ bool train( const Ptr<TrainData>& trainData, int flags )
+ {
+ Params dp(rparams.maxDepth, rparams.minSampleCount, rparams.regressionAccuracy,
+ rparams.useSurrogates, rparams.maxCategories, rparams.CVFolds,
+ rparams.use1SERule, rparams.truncatePrunedTree, rparams.priors);
+ setDParams(dp);
+ startTraining(trainData, flags);
+ int treeidx, ntrees = (rparams.termCrit.type & TermCriteria::COUNT) != 0 ?
+ rparams.termCrit.maxCount : 10000;
+ int i, j, k, vi, vi_, n = (int)w->sidx.size();
+ int nclasses = (int)classLabels.size();
+ double eps = (rparams.termCrit.type & TermCriteria::EPS) != 0 &&
+ rparams.termCrit.epsilon > 0 ? rparams.termCrit.epsilon : 0.;
+ vector<int> sidx(n);
+ vector<uchar> oobmask(n);
+ vector<int> oobidx;
+ vector<int> oobperm;
+ vector<double> oobres(n, 0.);
+ vector<int> oobcount(n, 0);
+ vector<int> oobvotes(n*nclasses, 0);
+ int nvars = w->data->getNVars();
+ int nallvars = w->data->getNAllVars();
+ const int* vidx = !varIdx.empty() ? &varIdx[0] : 0;
+ vector<float> samplebuf(nallvars);
+ Mat samples = w->data->getSamples();
+ float* psamples = samples.ptr<float>();
+ size_t sstep0 = samples.step1(), sstep1 = 1;
+ Mat sample0, sample(nallvars, 1, CV_32F, &samplebuf[0]);
+ int predictFlags = _isClassifier ? (PREDICT_MAX_VOTE + RAW_OUTPUT) : PREDICT_SUM;
+
+ bool calcOOBError = eps > 0 || rparams.calcVarImportance;
+ double max_response = 0.;
+
+ if( w->data->getLayout() == COL_SAMPLE )
+ std::swap(sstep0, sstep1);
+
+ if( !_isClassifier )
{
- int idx = (*rng)(nsamples);
- sample_idx_for_tree->data.i[i] = idx;
- sample_idx_mask_for_tree->data.ptr[idx] = 0xFF;
+ for( i = 0; i < n; i++ )
+ {
+ double val = std::abs(w->ord_responses[w->sidx[i]]);
+ max_response = std::max(max_response, val);
+ }
}
- trees[ntrees] = new CvForestTree();
- tree = trees[ntrees];
- tree->train( data, sample_idx_for_tree, this );
+ if( rparams.calcVarImportance )
+ varImportance.resize(nallvars, 0.f);
- if ( is_oob_or_vimportance )
+ for( treeidx = 0; treeidx < ntrees; treeidx++ )
{
- CvMat sample, missing;
- // form array of OOB samples indices and get these samples
- sample = cvMat( 1, dims, CV_32FC1, samples_ptr );
- missing = cvMat( 1, dims, CV_8UC1, missing_ptr );
-
- oob_error = 0;
- for( i = 0; i < nsamples; i++,
- sample.data.fl += dims, missing.data.ptr += dims )
- {
- CvDTreeNode* predicted_node = 0;
- // check if the sample is OOB
- if( sample_idx_mask_for_tree->data.ptr[i] )
- continue;
-
- // predict oob samples
- if( !predicted_node )
- predicted_node = tree->predict(&sample, &missing, true);
-
- if( !data->is_classifier ) //regression
- {
- double avg_resp, resp = predicted_node->value;
- oob_predictions_sum.data.fl[i] += (float)resp;
- oob_num_of_predictions.data.fl[i] += 1;
-
- // compute oob error
- avg_resp = oob_predictions_sum.data.fl[i]/oob_num_of_predictions.data.fl[i];
- avg_resp -= true_resp_ptr[i];
- oob_error += avg_resp*avg_resp;
- resp = (resp - true_resp_ptr[i])/maximal_response;
- ncorrect_responses += exp( -resp*resp );
- }
- else //classification
- {
- double prdct_resp;
- CvPoint max_loc;
- CvMat votes;
-
- cvGetRow(oob_sample_votes, &votes, i);
- votes.data.i[predicted_node->class_idx]++;
-
- // compute oob error
- cvMinMaxLoc( &votes, 0, 0, 0, &max_loc );
+ putchar('.'); fflush(stdout);
+ for( i = 0; i < n; i++ )
+ oobmask[i] = (uchar)1;
- prdct_resp = data->cat_map->data.i[max_loc.x];
- oob_error += (fabs(prdct_resp - true_resp_ptr[i]) < FLT_EPSILON) ? 0 : 1;
-
- ncorrect_responses += cvRound(predicted_node->value - true_resp_ptr[i]) == 0;
- }
- oob_samples_count++;
+ for( i = 0; i < n; i++ )
+ {
+ j = rng.uniform(0, n);
+ sidx[i] = w->sidx[j];
+ oobmask[j] = (uchar)0;
}
- if( oob_samples_count > 0 )
- oob_error /= (double)oob_samples_count;
+ int root = addTree( sidx );
+ if( root < 0 )
+ return false;
- // estimate variable importance
- if( var_importance && oob_samples_count > 0 )
+ if( calcOOBError )
{
- int m;
+ oobidx.clear();
+ for( i = 0; i < n; i++ )
+ {
+ if( !oobmask[i] )
+ oobidx.push_back(i);
+ }
+ int n_oob = (int)oobidx.size();
+ // if there is no out-of-bag samples, we can not compute OOB error
+ // nor update the variable importance vector; so we proceed to the next tree
+ if( n_oob == 0 )
+ continue;
+ double ncorrect_responses = 0.;
- memcpy( oob_samples_perm_ptr, samples_ptr, dims*nsamples*sizeof(float));
- for( m = 0; m < dims; m++ )
+ oobError = 0.;
+ for( i = 0; i < n_oob; i++ )
{
- double ncorrect_responses_permuted = 0;
- // randomly permute values of the m-th variable in the oob samples
- float* mth_var_ptr = oob_samples_perm_ptr + m;
+ j = oobidx[i];
+ sample = Mat( nallvars, 1, CV_32F, psamples + sstep0*w->sidx[j], sstep1*sizeof(psamples[0]) );
- for( i = 0; i < nsamples; i++ )
+ double val = predictTrees(Range(treeidx, treeidx+1), sample, predictFlags);
+ if( !_isClassifier )
{
- int i1, i2;
- float temp;
-
- if( sample_idx_mask_for_tree->data.ptr[i] ) //the sample is not OOB
- continue;
- i1 = (*rng)(nsamples);
- i2 = (*rng)(nsamples);
- CV_SWAP( mth_var_ptr[i1*dims], mth_var_ptr[i2*dims], temp );
-
- // turn values of (m-1)-th variable, that were permuted
- // at the previous iteration, untouched
- if( m > 1 )
- oob_samples_perm_ptr[i*dims+m-1] = samples_ptr[i*dims+m-1];
+ oobres[j] += val;
+ oobcount[j]++;
+ double true_val = w->ord_responses[w->sidx[j]];
+ double a = oobres[j]/oobcount[j] - true_val;
+ oobError += a*a;
+ val = (val - true_val)/max_response;
+ ncorrect_responses += std::exp( -val*val );
}
-
- // predict "permuted" cases and calculate the number of votes for the
- // correct class in the variable-m-permuted oob data
- sample = cvMat( 1, dims, CV_32FC1, oob_samples_perm_ptr );
- missing = cvMat( 1, dims, CV_8UC1, missing_ptr );
- for( i = 0; i < nsamples; i++,
- sample.data.fl += dims, missing.data.ptr += dims )
+ else
{
- double predct_resp, true_resp;
+ int ival = cvRound(val);
+ int* votes = &oobvotes[j*nclasses];
+ votes[ival]++;
+ int best_class = 0;
+ for( k = 1; k < nclasses; k++ )
+ if( votes[best_class] < votes[k] )
+ best_class = k;
+ int diff = best_class != w->cat_responses[w->sidx[j]];
+ oobError += diff;
+ ncorrect_responses += diff == 0;
+ }
+ }
+
+ oobError /= n_oob;
+ if( rparams.calcVarImportance && n_oob > 1 )
+ {
+ oobperm.resize(n_oob);
+ for( i = 0; i < n_oob; i++ )
+ oobperm[i] = oobidx[i];
- if( sample_idx_mask_for_tree->data.ptr[i] ) //the sample is not OOB
- continue;
+ for( vi_ = 0; vi_ < nvars; vi_++ )
+ {
+ vi = vidx ? vidx[vi_] : vi_;
+ double ncorrect_responses_permuted = 0;
+ for( i = 0; i < n_oob; i++ )
+ {
+ int i1 = rng.uniform(0, n_oob);
+ int i2 = rng.uniform(0, n_oob);
+ std::swap(i1, i2);
+ }
- predct_resp = tree->predict(&sample, &missing, true)->value;
- true_resp = true_resp_ptr[i];
- if( data->is_classifier )
- ncorrect_responses_permuted += cvRound(true_resp - predct_resp) == 0;
- else
+ for( i = 0; i < n_oob; i++ )
{
- true_resp = (true_resp - predct_resp)/maximal_response;
- ncorrect_responses_permuted += exp( -true_resp*true_resp );
+ j = oobidx[i];
+ int vj = oobperm[i];
+ sample0 = Mat( nallvars, 1, CV_32F, psamples + sstep0*w->sidx[j], sstep1*sizeof(psamples[0]) );
+ for( k = 0; k < nallvars; k++ )
+ sample.at<float>(k) = sample0.at<float>(k);
+ sample.at<float>(vi) = psamples[sstep0*w->sidx[vj] + sstep1*vi];
+
+ double val = predictTrees(Range(treeidx, treeidx+1), sample, predictFlags);
+ if( !_isClassifier )
+ {
+ val = (val - w->ord_responses[w->sidx[j]])/max_response;
+ ncorrect_responses_permuted += exp( -val*val );
+ }
+ else
+ ncorrect_responses_permuted += cvRound(val) == w->cat_responses[w->sidx[j]];
}
+ varImportance[vi] += (float)(ncorrect_responses - ncorrect_responses_permuted);
}
- var_importance->data.fl[m] += (float)(ncorrect_responses
- - ncorrect_responses_permuted);
}
}
+ if( calcOOBError && oobError < eps )
+ break;
}
- ntrees++;
- if( term_crit.type != CV_TERMCRIT_ITER && oob_error < max_oob_err )
- break;
- }
-
- if( var_importance )
- {
- for ( int vi = 0; vi < var_importance->cols; vi++ )
- var_importance->data.fl[vi] = ( var_importance->data.fl[vi] > 0 ) ?
- var_importance->data.fl[vi] : 0;
- cvNormalize( var_importance, var_importance, 1., 0, CV_L1 );
- }
-
- cvFree( &oob_samples_perm_ptr );
- cvFree( &samples_ptr );
- cvFree( &missing_ptr );
- cvFree( &true_resp_ptr );
-
- cvReleaseMat( &sample_idx_mask_for_tree );
- cvReleaseMat( &sample_idx_for_tree );
-
- cvReleaseMat( &oob_sample_votes );
- cvReleaseMat( &oob_responses );
+ printf("done!\n");
- return true;
-}
-
-
-const CvMat* CvRTrees::get_var_importance()
-{
- return var_importance;
-}
-
-
-float CvRTrees::get_proximity( const CvMat* sample1, const CvMat* sample2,
- const CvMat* missing1, const CvMat* missing2 ) const
-{
- float result = 0;
-
- for( int i = 0; i < ntrees; i++ )
- result += trees[i]->predict( sample1, missing1 ) ==
- trees[i]->predict( sample2, missing2 ) ? 1 : 0;
- result = result/(float)ntrees;
-
- return result;
-}
-
-float CvRTrees::calc_error( CvMLData* _data, int type , std::vector<float> *resp )
-{
- float err = 0;
- const CvMat* values = _data->get_values();
- const CvMat* response = _data->get_responses();
- const CvMat* missing = _data->get_missing();
- const CvMat* sample_idx = (type == CV_TEST_ERROR) ? _data->get_test_sample_idx() : _data->get_train_sample_idx();
- const CvMat* var_types = _data->get_var_types();
- int* sidx = sample_idx ? sample_idx->data.i : 0;
- int r_step = CV_IS_MAT_CONT(response->type) ?
- 1 : response->step / CV_ELEM_SIZE(response->type);
- bool is_classifier = var_types->data.ptr[var_types->cols-1] == CV_VAR_CATEGORICAL;
- int sample_count = sample_idx ? sample_idx->cols : 0;
- sample_count = (type == CV_TRAIN_ERROR && sample_count == 0) ? values->rows : sample_count;
- float* pred_resp = 0;
- if( resp && (sample_count > 0) )
- {
- resp->resize( sample_count );
- pred_resp = &((*resp)[0]);
- }
- if ( is_classifier )
- {
- for( int i = 0; i < sample_count; i++ )
+ if( rparams.calcVarImportance )
{
- CvMat sample, miss;
- int si = sidx ? sidx[i] : i;
- cvGetRow( values, &sample, si );
- if( missing )
- cvGetRow( missing, &miss, si );
- float r = (float)predict( &sample, missing ? &miss : 0 );
- if( pred_resp )
- pred_resp[i] = r;
- int d = fabs((double)r - response->data.fl[si*r_step]) <= FLT_EPSILON ? 0 : 1;
- err += d;
+ for( vi_ = 0; vi_ < nallvars; vi_++ )
+ varImportance[vi_] = std::max(varImportance[vi_], 0.f);
+ normalize(varImportance, varImportance, 1., 0, NORM_L1);
}
- err = sample_count ? err / (float)sample_count * 100 : -FLT_MAX;
+ endTraining();
+ return true;
}
- else
+
+ void writeTrainingParams( FileStorage& fs ) const
{
- for( int i = 0; i < sample_count; i++ )
- {
- CvMat sample, miss;
- int si = sidx ? sidx[i] : i;
- cvGetRow( values, &sample, si );
- if( missing )
- cvGetRow( missing, &miss, si );
- float r = (float)predict( &sample, missing ? &miss : 0 );
- if( pred_resp )
- pred_resp[i] = r;
- float d = r - response->data.fl[si*r_step];
- err += d*d;
- }
- err = sample_count ? err / (float)sample_count : -FLT_MAX;
+ DTreesImpl::writeTrainingParams(fs);
+ fs << "nactive_vars" << rparams.nactiveVars;
}
- return err;
-}
-
-float CvRTrees::get_train_error()
-{
- float err = -1;
-
- int sample_count = data->sample_count;
- int var_count = data->var_count;
-
- float *values_ptr = (float*)cvAlloc( sizeof(float)*sample_count*var_count );
- uchar *missing_ptr = (uchar*)cvAlloc( sizeof(uchar)*sample_count*var_count );
- float *responses_ptr = (float*)cvAlloc( sizeof(float)*sample_count );
-
- data->get_vectors( 0, values_ptr, missing_ptr, responses_ptr);
- if (data->is_classifier)
+ void write( FileStorage& fs ) const
{
- int err_count = 0;
- float *vp = values_ptr;
- uchar *mp = missing_ptr;
- for (int si = 0; si < sample_count; si++, vp += var_count, mp += var_count)
- {
- CvMat sample = cvMat( 1, var_count, CV_32FC1, vp );
- CvMat missing = cvMat( 1, var_count, CV_8UC1, mp );
- float r = predict( &sample, &missing );
- if (fabs(r - responses_ptr[si]) >= FLT_EPSILON)
- err_count++;
- }
- err = (float)err_count / (float)sample_count;
- }
- else
- CV_Error( CV_StsBadArg, "This method is not supported for regression problems" );
+ if( roots.empty() )
+ CV_Error( CV_StsBadArg, "RTrees have not been trained" );
- cvFree( &values_ptr );
- cvFree( &missing_ptr );
- cvFree( &responses_ptr );
+ writeParams(fs);
- return err;
-}
+ fs << "oob_error" << oobError;
+ if( !varImportance.empty() )
+ fs << "var_importance" << varImportance;
+ int k, ntrees = (int)roots.size();
-float CvRTrees::predict( const CvMat* sample, const CvMat* missing ) const
-{
- double result = -1;
- int k;
+ fs << "ntrees" << ntrees
+ << "trees" << "[";
- if( nclasses > 0 ) //classification
- {
- int max_nvotes = 0;
- cv::AutoBuffer<int> _votes(nclasses);
- int* votes = _votes;
- memset( votes, 0, sizeof(*votes)*nclasses );
for( k = 0; k < ntrees; k++ )
{
- CvDTreeNode* predicted_node = trees[k]->predict( sample, missing );
- int nvotes;
- int class_idx = predicted_node->class_idx;
- CV_Assert( 0 <= class_idx && class_idx < nclasses );
-
- nvotes = ++votes[class_idx];
- if( nvotes > max_nvotes )
- {
- max_nvotes = nvotes;
- result = predicted_node->value;
- }
+ fs << "{";
+ writeTree(fs, roots[k]);
+ fs << "}";
}
- }
- else // regression
- {
- result = 0;
- for( k = 0; k < ntrees; k++ )
- result += trees[k]->predict( sample, missing )->value;
- result /= (double)ntrees;
- }
- return (float)result;
-}
+ fs << "]";
+ }
-float CvRTrees::predict_prob( const CvMat* sample, const CvMat* missing) const
-{
- if( nclasses == 2 ) //classification
+ void readParams( const FileNode& fn )
{
- cv::AutoBuffer<int> _votes(nclasses);
- int* votes = _votes;
- memset( votes, 0, sizeof(*votes)*nclasses );
- for( int k = 0; k < ntrees; k++ )
- {
- CvDTreeNode* predicted_node = trees[k]->predict( sample, missing );
- int class_idx = predicted_node->class_idx;
- CV_Assert( 0 <= class_idx && class_idx < nclasses );
-
- ++votes[class_idx];
- }
-
- return float(votes[1])/ntrees;
+ DTreesImpl::readParams(fn);
+ rparams.maxDepth = params0.maxDepth;
+ rparams.minSampleCount = params0.minSampleCount;
+ rparams.regressionAccuracy = params0.regressionAccuracy;
+ rparams.useSurrogates = params0.useSurrogates;
+ rparams.maxCategories = params0.maxCategories;
+ rparams.priors = params0.priors;
+
+ FileNode tparams_node = fn["training_params"];
+ rparams.nactiveVars = (int)tparams_node["nactive_vars"];
}
- else // regression
- CV_Error(CV_StsBadArg, "This function works for binary classification problems only...");
-
- return -1;
-}
-
-void CvRTrees::write( CvFileStorage* fs, const char* name ) const
-{
- int k;
- if( ntrees < 1 || !trees || nsamples < 1 )
- CV_Error( CV_StsBadArg, "Invalid CvRTrees object" );
-
- cv::String modelNodeName = this->getName();
- cvStartWriteStruct( fs, name, CV_NODE_MAP, modelNodeName.c_str() );
-
- cvWriteInt( fs, "nclasses", nclasses );
- cvWriteInt( fs, "nsamples", nsamples );
- cvWriteInt( fs, "nactive_vars", (int)cvSum(active_var_mask).val[0] );
- cvWriteReal( fs, "oob_error", oob_error );
+ void read( const FileNode& fn )
+ {
+ clear();
- if( var_importance )
- cvWrite( fs, "var_importance", var_importance );
+ //int nclasses = (int)fn["nclasses"];
+ //int nsamples = (int)fn["nsamples"];
+ oobError = (double)fn["oob_error"];
+ int ntrees = (int)fn["ntrees"];
- cvWriteInt( fs, "ntrees", ntrees );
+ fn["var_importance"] >> varImportance;
- data->write_params( fs );
+ readParams(fn);
- cvStartWriteStruct( fs, "trees", CV_NODE_SEQ );
+ FileNode trees_node = fn["trees"];
+ FileNodeIterator it = trees_node.begin();
+ CV_Assert( ntrees == (int)trees_node.size() );
- for( k = 0; k < ntrees; k++ )
- {
- cvStartWriteStruct( fs, 0, CV_NODE_MAP );
- trees[k]->write( fs );
- cvEndWriteStruct( fs );
+ for( int treeidx = 0; treeidx < ntrees; treeidx++, ++it )
+ {
+ FileNode nfn = (*it)["nodes"];
+ readTree(nfn);
+ }
}
- cvEndWriteStruct( fs ); //trees
- cvEndWriteStruct( fs ); //CV_TYPE_NAME_ML_RTREES
-}
+ RTrees::Params rparams;
+ double oobError;
+ vector<float> varImportance;
+ vector<int> allVars, activeVars;
+ RNG rng;
+};
-void CvRTrees::read( CvFileStorage* fs, CvFileNode* fnode )
+class RTreesImpl : public RTrees
{
- int nactive_vars, var_count, k;
- CvSeqReader reader;
- CvFileNode* trees_fnode = 0;
+public:
+ RTreesImpl() {}
+ virtual ~RTreesImpl() {}
- clear();
+ String getDefaultModelName() const { return "opencv_ml_rtrees"; }
- nclasses = cvReadIntByName( fs, fnode, "nclasses", -1 );
- nsamples = cvReadIntByName( fs, fnode, "nsamples" );
- nactive_vars = cvReadIntByName( fs, fnode, "nactive_vars", -1 );
- oob_error = cvReadRealByName(fs, fnode, "oob_error", -1 );
- ntrees = cvReadIntByName( fs, fnode, "ntrees", -1 );
-
- var_importance = (CvMat*)cvReadByName( fs, fnode, "var_importance" );
-
- if( nclasses < 0 || nsamples <= 0 || nactive_vars < 0 || oob_error < 0 || ntrees <= 0)
- CV_Error( CV_StsParseError, "Some <nclasses>, <nsamples>, <var_count>, "
- "<nactive_vars>, <oob_error>, <ntrees> of tags are missing" );
-
- rng = &cv::theRNG();
-
- trees = (CvForestTree**)cvAlloc( sizeof(trees[0])*ntrees );
- memset( trees, 0, sizeof(trees[0])*ntrees );
-
- data = new CvDTreeTrainData();
- data->read_params( fs, fnode );
- data->shared = true;
-
- trees_fnode = cvGetFileNodeByName( fs, fnode, "trees" );
- if( !trees_fnode || !CV_NODE_IS_SEQ(trees_fnode->tag) )
- CV_Error( CV_StsParseError, "<trees> tag is missing" );
-
- cvStartReadSeq( trees_fnode->data.seq, &reader );
- if( reader.seq->total != ntrees )
- CV_Error( CV_StsParseError,
- "<ntrees> is not equal to the number of trees saved in file" );
-
- for( k = 0; k < ntrees; k++ )
+ bool train( const Ptr<TrainData>& trainData, int flags )
{
- trees[k] = new CvForestTree();
- trees[k]->read( fs, (CvFileNode*)reader.ptr, this, data );
- CV_NEXT_SEQ_ELEM( reader.seq->elem_size, reader );
+ return impl.train(trainData, flags);
}
- var_count = data->var_count;
- active_var_mask = cvCreateMat( 1, var_count, CV_8UC1 );
+ float predict( InputArray samples, OutputArray results, int flags ) const
{
- // initialize active variables mask
- CvMat submask1;
- cvGetCols( active_var_mask, &submask1, 0, nactive_vars );
- cvSet( &submask1, cvScalar(1) );
-
- if( nactive_vars < var_count )
- {
- CvMat submask2;
- cvGetCols( active_var_mask, &submask2, nactive_vars, var_count );
- cvZero( &submask2 );
- }
+ return impl.predict(samples, results, flags);
}
-}
-
-
-int CvRTrees::get_tree_count() const
-{
- return ntrees;
-}
-CvForestTree* CvRTrees::get_tree(int i) const
-{
- return (unsigned)i < (unsigned)ntrees ? trees[i] : 0;
-}
+ void write( FileStorage& fs ) const
+ {
+ impl.write(fs);
+ }
+
+ void read( const FileNode& fn )
+ {
+ impl.read(fn);
+ }
-using namespace cv;
+ void setRParams(const Params& p) { impl.setRParams(p); }
+ Params getRParams() const { return impl.getRParams(); }
-bool CvRTrees::train( const Mat& _train_data, int _tflag,
- const Mat& _responses, const Mat& _var_idx,
- const Mat& _sample_idx, const Mat& _var_type,
- const Mat& _missing_mask, CvRTParams _params )
-{
- train_data_hdr = _train_data;
- train_data_mat = _train_data;
- responses_hdr = _responses;
- responses_mat = _responses;
+ Mat getVarImportance() const { return Mat_<float>(impl.varImportance, true); }
+ int getVarCount() const { return impl.getVarCount(); }
- CvMat vidx = _var_idx, sidx = _sample_idx, vtype = _var_type, mmask = _missing_mask;
+ bool isTrained() const { return impl.isTrained(); }
+ bool isClassifier() const { return impl.isClassifier(); }
- return train(&train_data_hdr, _tflag, &responses_hdr, vidx.data.ptr ? &vidx : 0,
- sidx.data.ptr ? &sidx : 0, vtype.data.ptr ? &vtype : 0,
- mmask.data.ptr ? &mmask : 0, _params);
-}
+ const vector<int>& getRoots() const { return impl.getRoots(); }
+ const vector<Node>& getNodes() const { return impl.getNodes(); }
+ const vector<Split>& getSplits() const { return impl.getSplits(); }
+ const vector<int>& getSubsets() const { return impl.getSubsets(); }
+ DTreesImplForRTrees impl;
+};
-float CvRTrees::predict( const Mat& _sample, const Mat& _missing ) const
-{
- CvMat sample = _sample, mmask = _missing;
- return predict(&sample, mmask.data.ptr ? &mmask : 0);
-}
-float CvRTrees::predict_prob( const Mat& _sample, const Mat& _missing) const
+Ptr<RTrees> RTrees::create(const Params& params)
{
- CvMat sample = _sample, mmask = _missing;
- return predict_prob(&sample, mmask.data.ptr ? &mmask : 0);
+ Ptr<RTreesImpl> p = makePtr<RTreesImpl>();
+ p->setRParams(params);
+ return p;
}
-Mat CvRTrees::getVarImportance()
-{
- return cvarrToMat(get_var_importance());
-}
+}}
// End of file.
// copy or use the software.
//
//
-// Intel License Agreement
+// License Agreement
+// For Open Source Computer Vision Library
//
// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Copyright (C) 2014, Itseez Inc, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// 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
+// * The name of the copyright holders 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
#include "precomp.hpp"
+#include <stdarg.h>
+#include <ctype.h>
+
/****************************************************************************************\
COPYRIGHT NOTICE
----------------
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
\****************************************************************************************/
-using namespace cv;
-
-#define CV_SVM_MIN_CACHE_SIZE (40 << 20) /* 40Mb */
+namespace cv { namespace ml {
-#include <stdarg.h>
-#include <ctype.h>
-
-#if 1
typedef float Qfloat;
-#define QFLOAT_TYPE CV_32F
-#else
-typedef double Qfloat;
-#define QFLOAT_TYPE CV_64F
-#endif
+const int QFLOAT_TYPE = DataDepth<Qfloat>::value;
// Param Grid
-bool CvParamGrid::check() const
-{
- bool ok = false;
-
- CV_FUNCNAME( "CvParamGrid::check" );
- __BEGIN__;
-
- if( min_val > max_val )
- CV_ERROR( CV_StsBadArg, "Lower bound of the grid must be less then the upper one" );
- if( min_val < DBL_EPSILON )
- CV_ERROR( CV_StsBadArg, "Lower bound of the grid must be positive" );
- if( step < 1. + FLT_EPSILON )
- CV_ERROR( CV_StsBadArg, "Grid step must greater then 1" );
-
- ok = true;
-
- __END__;
-
- return ok;
-}
-
-CvParamGrid CvSVM::get_default_grid( int param_id )
+static void checkParamGrid(const ParamGrid& pg)
{
- CvParamGrid grid;
- if( param_id == CvSVM::C )
- {
- grid.min_val = 0.1;
- grid.max_val = 500;
- grid.step = 5; // total iterations = 5
- }
- else if( param_id == CvSVM::GAMMA )
- {
- grid.min_val = 1e-5;
- grid.max_val = 0.6;
- grid.step = 15; // total iterations = 4
- }
- else if( param_id == CvSVM::P )
- {
- grid.min_val = 0.01;
- grid.max_val = 100;
- grid.step = 7; // total iterations = 4
- }
- else if( param_id == CvSVM::NU )
- {
- grid.min_val = 0.01;
- grid.max_val = 0.2;
- grid.step = 3; // total iterations = 3
- }
- else if( param_id == CvSVM::COEF )
- {
- grid.min_val = 0.1;
- grid.max_val = 300;
- grid.step = 14; // total iterations = 3
- }
- else if( param_id == CvSVM::DEGREE )
- {
- grid.min_val = 0.01;
- grid.max_val = 4;
- grid.step = 7; // total iterations = 3
- }
- else
- cvError( CV_StsBadArg, "CvSVM::get_default_grid", "Invalid type of parameter "
- "(use one of CvSVM::C, CvSVM::GAMMA et al.)", __FILE__, __LINE__ );
- return grid;
+ if( pg.minVal > pg.maxVal )
+ CV_Error( CV_StsBadArg, "Lower bound of the grid must be less then the upper one" );
+ if( pg.minVal < DBL_EPSILON )
+ CV_Error( CV_StsBadArg, "Lower bound of the grid must be positive" );
+ if( pg.logStep < 1. + FLT_EPSILON )
+ CV_Error( CV_StsBadArg, "Grid step must greater then 1" );
}
// SVM training parameters
-CvSVMParams::CvSVMParams() :
- svm_type(CvSVM::C_SVC), kernel_type(CvSVM::RBF), degree(0),
- gamma(1), coef0(0), C(1), nu(0), p(0), class_weights(0)
+SVM::Params::Params()
{
- term_crit = cvTermCriteria( CV_TERMCRIT_ITER+CV_TERMCRIT_EPS, 1000, FLT_EPSILON );
+ svmType = SVM::C_SVC;
+ kernelType = SVM::RBF;
+ degree = 0;
+ gamma = 1;
+ coef0 = 0;
+ C = 1;
+ nu = 0;
+ p = 0;
+ termCrit = TermCriteria( CV_TERMCRIT_ITER+CV_TERMCRIT_EPS, 1000, FLT_EPSILON );
}
-CvSVMParams::CvSVMParams( int _svm_type, int _kernel_type,
- double _degree, double _gamma, double _coef0,
- double _Con, double _nu, double _p,
- CvMat* _class_weights, CvTermCriteria _term_crit ) :
- svm_type(_svm_type), kernel_type(_kernel_type),
- degree(_degree), gamma(_gamma), coef0(_coef0),
- C(_Con), nu(_nu), p(_p), class_weights(_class_weights), term_crit(_term_crit)
+SVM::Params::Params( int _svmType, int _kernelType,
+ double _degree, double _gamma, double _coef0,
+ double _Con, double _nu, double _p,
+ const Mat& _classWeights, TermCriteria _termCrit )
{
+ svmType = _svmType;
+ kernelType = _kernelType;
+ degree = _degree;
+ gamma = _gamma;
+ coef0 = _coef0;
+ C = _Con;
+ nu = _nu;
+ p = _p;
+ classWeights = _classWeights;
+ termCrit = _termCrit;
}
+SVM::Kernel::~Kernel() {}
/////////////////////////////////////// SVM kernel ///////////////////////////////////////
-
-CvSVMKernel::CvSVMKernel()
-{
- clear();
-}
-
-
-void CvSVMKernel::clear()
+class SVMKernelImpl : public SVM::Kernel
{
- params = 0;
- calc_func = 0;
-}
-
-
-CvSVMKernel::~CvSVMKernel()
-{
-}
-
-
-CvSVMKernel::CvSVMKernel( const CvSVMParams* _params, Calc _calc_func )
-{
- clear();
- create( _params, _calc_func );
-}
-
-
-bool CvSVMKernel::create( const CvSVMParams* _params, Calc _calc_func )
-{
- clear();
- params = _params;
- calc_func = _calc_func;
-
- if( !calc_func )
- calc_func = params->kernel_type == CvSVM::RBF ? &CvSVMKernel::calc_rbf :
- params->kernel_type == CvSVM::POLY ? &CvSVMKernel::calc_poly :
- params->kernel_type == CvSVM::SIGMOID ? &CvSVMKernel::calc_sigmoid :
- params->kernel_type == CvSVM::CHI2 ? &CvSVMKernel::calc_chi2 :
- params->kernel_type == CvSVM::INTER ? &CvSVMKernel::calc_intersec :
- &CvSVMKernel::calc_linear;
-
- return true;
-}
-
-
-void CvSVMKernel::calc_non_rbf_base( int vcount, int var_count, const float** vecs,
- const float* another, Qfloat* results,
- double alpha, double beta )
-{
- int j, k;
- for( j = 0; j < vcount; j++ )
+public:
+ SVMKernelImpl()
{
- const float* sample = vecs[j];
- double s = 0;
- for( k = 0; k <= var_count - 4; k += 4 )
- s += sample[k]*another[k] + sample[k+1]*another[k+1] +
- sample[k+2]*another[k+2] + sample[k+3]*another[k+3];
- for( ; k < var_count; k++ )
- s += sample[k]*another[k];
- results[j] = (Qfloat)(s*alpha + beta);
}
-}
-
-
-void CvSVMKernel::calc_linear( int vcount, int var_count, const float** vecs,
- const float* another, Qfloat* results )
-{
- calc_non_rbf_base( vcount, var_count, vecs, another, results, 1, 0 );
-}
-
-
-void CvSVMKernel::calc_poly( int vcount, int var_count, const float** vecs,
- const float* another, Qfloat* results )
-{
- CvMat R = cvMat( 1, vcount, QFLOAT_TYPE, results );
- calc_non_rbf_base( vcount, var_count, vecs, another, results, params->gamma, params->coef0 );
- if( vcount > 0 )
- cvPow( &R, &R, params->degree );
-}
-
-void CvSVMKernel::calc_sigmoid( int vcount, int var_count, const float** vecs,
- const float* another, Qfloat* results )
-{
- int j;
- calc_non_rbf_base( vcount, var_count, vecs, another, results,
- -2*params->gamma, -2*params->coef0 );
- // TODO: speedup this
- for( j = 0; j < vcount; j++ )
+ SVMKernelImpl( const SVM::Params& _params )
{
- Qfloat t = results[j];
- double e = exp(-fabs(t));
- if( t > 0 )
- results[j] = (Qfloat)((1. - e)/(1. + e));
- else
- results[j] = (Qfloat)((e - 1.)/(e + 1.));
+ params = _params;
}
-}
-
-
-void CvSVMKernel::calc_rbf( int vcount, int var_count, const float** vecs,
- const float* another, Qfloat* results )
-{
- CvMat R = cvMat( 1, vcount, QFLOAT_TYPE, results );
- double gamma = -params->gamma;
- int j, k;
- for( j = 0; j < vcount; j++ )
+ virtual ~SVMKernelImpl()
{
- const float* sample = vecs[j];
- double s = 0;
-
- for( k = 0; k <= var_count - 4; k += 4 )
- {
- double t0 = sample[k] - another[k];
- double t1 = sample[k+1] - another[k+1];
-
- s += t0*t0 + t1*t1;
-
- t0 = sample[k+2] - another[k+2];
- t1 = sample[k+3] - another[k+3];
+ }
- s += t0*t0 + t1*t1;
- }
+ int getType() const
+ {
+ return params.kernelType;
+ }
- for( ; k < var_count; k++ )
+ void calc_non_rbf_base( int vcount, int var_count, const float* vecs,
+ const float* another, Qfloat* results,
+ double alpha, double beta )
+ {
+ int j, k;
+ for( j = 0; j < vcount; j++ )
{
- double t0 = sample[k] - another[k];
- s += t0*t0;
+ const float* sample = &vecs[j*var_count];
+ double s = 0;
+ for( k = 0; k <= var_count - 4; k += 4 )
+ s += sample[k]*another[k] + sample[k+1]*another[k+1] +
+ sample[k+2]*another[k+2] + sample[k+3]*another[k+3];
+ for( ; k < var_count; k++ )
+ s += sample[k]*another[k];
+ results[j] = (Qfloat)(s*alpha + beta);
}
- results[j] = (Qfloat)(s*gamma);
}
- if( vcount > 0 )
- cvExp( &R, &R );
-}
-
-/// Histogram intersection kernel
-void CvSVMKernel::calc_intersec( int vcount, int var_count, const float** vecs,
- const float* another, Qfloat* results )
-{
- int j, k;
- for( j = 0; j < vcount; j++ )
+ void calc_linear( int vcount, int var_count, const float* vecs,
+ const float* another, Qfloat* results )
{
- const float* sample = vecs[j];
- double s = 0;
- for( k = 0; k <= var_count - 4; k += 4 )
- s += std::min(sample[k],another[k]) + std::min(sample[k+1],another[k+1]) +
- std::min(sample[k+2],another[k+2]) + std::min(sample[k+3],another[k+3]);
- for( ; k < var_count; k++ )
- s += std::min(sample[k],another[k]);
- results[j] = (Qfloat)(s);
+ calc_non_rbf_base( vcount, var_count, vecs, another, results, 1, 0 );
}
-}
-/// Exponential chi2 kernel
-void CvSVMKernel::calc_chi2( int vcount, int var_count, const float** vecs,
- const float* another, Qfloat* results )
-{
- CvMat R = cvMat( 1, vcount, QFLOAT_TYPE, results );
- double gamma = -params->gamma;
- int j, k;
- for( j = 0; j < vcount; j++ )
+ void calc_poly( int vcount, int var_count, const float* vecs,
+ const float* another, Qfloat* results )
{
- const float* sample = vecs[j];
- double chi2 = 0;
- for(k = 0 ; k < var_count; k++ )
+ Mat R( 1, vcount, QFLOAT_TYPE, results );
+ calc_non_rbf_base( vcount, var_count, vecs, another, results, params.gamma, params.coef0 );
+ if( vcount > 0 )
+ pow( R, params.degree, R );
+ }
+
+ void calc_sigmoid( int vcount, int var_count, const float* vecs,
+ const float* another, Qfloat* results )
{
- double d = sample[k]-another[k];
- double devisor = sample[k]+another[k];
- /// if devisor == 0, the Chi2 distance would be zero, but calculation would rise an error because of deviding by zero
- if (devisor != 0)
+ int j;
+ calc_non_rbf_base( vcount, var_count, vecs, another, results,
+ -2*params.gamma, -2*params.coef0 );
+ // TODO: speedup this
+ for( j = 0; j < vcount; j++ )
{
- chi2 += d*d/devisor;
+ Qfloat t = results[j];
+ Qfloat e = std::exp(-std::abs(t));
+ if( t > 0 )
+ results[j] = (Qfloat)((1. - e)/(1. + e));
+ else
+ results[j] = (Qfloat)((e - 1.)/(e + 1.));
}
}
- results[j] = (Qfloat) (gamma*chi2);
- }
- if( vcount > 0 )
- cvExp( &R, &R );
-}
-
-void CvSVMKernel::calc( int vcount, int var_count, const float** vecs,
- const float* another, Qfloat* results )
-{
- const Qfloat max_val = (Qfloat)(FLT_MAX*1e-3);
- int j;
- (this->*calc_func)( vcount, var_count, vecs, another, results );
- for( j = 0; j < vcount; j++ )
+ void calc_rbf( int vcount, int var_count, const float* vecs,
+ const float* another, Qfloat* results )
{
- if( results[j] > max_val )
- results[j] = max_val;
- }
-}
-
-
-// Generalized SMO+SVMlight algorithm
-// Solves:
-//
-// min [0.5(\alpha^T Q \alpha) + b^T \alpha]
-//
-// y^T \alpha = \delta
-// y_i = +1 or -1
-// 0 <= alpha_i <= Cp for y_i = 1
-// 0 <= alpha_i <= Cn for y_i = -1
-//
-// Given:
-//
-// Q, b, y, Cp, Cn, and an initial feasible point \alpha
-// l is the size of vectors and matrices
-// eps is the stopping criterion
-//
-// solution will be put in \alpha, objective value will be put in obj
-//
-
-void CvSVMSolver::clear()
-{
- G = 0;
- alpha = 0;
- y = 0;
- b = 0;
- buf[0] = buf[1] = 0;
- cvReleaseMemStorage( &storage );
- kernel = 0;
- select_working_set_func = 0;
- calc_rho_func = 0;
-
- rows = 0;
- samples = 0;
- get_row_func = 0;
-}
-
-
-CvSVMSolver::CvSVMSolver()
-{
- storage = 0;
- clear();
-}
-
-
-CvSVMSolver::~CvSVMSolver()
-{
- clear();
-}
+ double gamma = -params.gamma;
+ int j, k;
+ for( j = 0; j < vcount; j++ )
+ {
+ const float* sample = &vecs[j*var_count];
+ double s = 0;
-CvSVMSolver::CvSVMSolver( int _sample_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 )
-{
- storage = 0;
- create( _sample_count, _var_count, _samples, _y, _alpha_count, _alpha, _Cp, _Cn,
- _storage, _kernel, _get_row, _select_working_set, _calc_rho );
-}
+ for( k = 0; k <= var_count - 4; k += 4 )
+ {
+ double t0 = sample[k] - another[k];
+ double t1 = sample[k+1] - another[k+1];
+ s += t0*t0 + t1*t1;
-bool CvSVMSolver::create( int _sample_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 )
-{
- bool ok = false;
- int i, svm_type;
-
- CV_FUNCNAME( "CvSVMSolver::create" );
-
- __BEGIN__;
-
- int rows_hdr_size;
-
- clear();
-
- sample_count = _sample_count;
- var_count = _var_count;
- samples = _samples;
- y = _y;
- alpha_count = _alpha_count;
- alpha = _alpha;
- kernel = _kernel;
-
- C[0] = _Cn;
- C[1] = _Cp;
- eps = kernel->params->term_crit.epsilon;
- max_iter = kernel->params->term_crit.max_iter;
- storage = cvCreateChildMemStorage( _storage );
-
- b = (double*)cvMemStorageAlloc( storage, alpha_count*sizeof(b[0]));
- alpha_status = (schar*)cvMemStorageAlloc( storage, alpha_count*sizeof(alpha_status[0]));
- G = (double*)cvMemStorageAlloc( storage, alpha_count*sizeof(G[0]));
- for( i = 0; i < 2; i++ )
- buf[i] = (Qfloat*)cvMemStorageAlloc( storage, sample_count*2*sizeof(buf[i][0]) );
- svm_type = kernel->params->svm_type;
-
- select_working_set_func = _select_working_set;
- if( !select_working_set_func )
- select_working_set_func = svm_type == CvSVM::NU_SVC || svm_type == CvSVM::NU_SVR ?
- &CvSVMSolver::select_working_set_nu_svm : &CvSVMSolver::select_working_set;
-
- calc_rho_func = _calc_rho;
- if( !calc_rho_func )
- calc_rho_func = svm_type == CvSVM::NU_SVC || svm_type == CvSVM::NU_SVR ?
- &CvSVMSolver::calc_rho_nu_svm : &CvSVMSolver::calc_rho;
-
- get_row_func = _get_row;
- if( !get_row_func )
- get_row_func = params->svm_type == CvSVM::EPS_SVR ||
- params->svm_type == CvSVM::NU_SVR ? &CvSVMSolver::get_row_svr :
- params->svm_type == CvSVM::C_SVC ||
- params->svm_type == CvSVM::NU_SVC ? &CvSVMSolver::get_row_svc :
- &CvSVMSolver::get_row_one_class;
-
- cache_line_size = sample_count*sizeof(Qfloat);
- // cache size = max(num_of_samples^2*sizeof(Qfloat)*0.25, 64Kb)
- // (assuming that for large training sets ~25% of Q matrix is used)
- cache_size = MAX( cache_line_size*sample_count/4, CV_SVM_MIN_CACHE_SIZE );
-
- // the size of Q matrix row headers
- rows_hdr_size = sample_count*sizeof(rows[0]);
- if( rows_hdr_size > storage->block_size )
- CV_ERROR( CV_StsOutOfRange, "Too small storage block size" );
-
- lru_list.prev = lru_list.next = &lru_list;
- rows = (CvSVMKernelRow*)cvMemStorageAlloc( storage, rows_hdr_size );
- memset( rows, 0, rows_hdr_size );
-
- ok = true;
-
- __END__;
-
- return ok;
-}
+ t0 = sample[k+2] - another[k+2];
+ t1 = sample[k+3] - another[k+3];
+ s += t0*t0 + t1*t1;
+ }
-float* CvSVMSolver::get_row_base( int i, bool* _existed )
-{
- int i1 = i < sample_count ? i : i - sample_count;
- CvSVMKernelRow* row = rows + i1;
- bool existed = row->data != 0;
- Qfloat* data;
+ for( ; k < var_count; k++ )
+ {
+ double t0 = sample[k] - another[k];
+ s += t0*t0;
+ }
+ results[j] = (Qfloat)(s*gamma);
+ }
- if( existed || cache_size <= 0 )
- {
- CvSVMKernelRow* del_row = existed ? row : lru_list.prev;
- data = del_row->data;
- assert( data != 0 );
-
- // delete row from the LRU list
- del_row->data = 0;
- del_row->prev->next = del_row->next;
- del_row->next->prev = del_row->prev;
+ if( vcount > 0 )
+ {
+ Mat R( 1, vcount, QFLOAT_TYPE, results );
+ exp( R, R );
+ }
}
- else
+
+ /// Histogram intersection kernel
+ void calc_intersec( int vcount, int var_count, const float* vecs,
+ const float* another, Qfloat* results )
{
- data = (Qfloat*)cvMemStorageAlloc( storage, cache_line_size );
- cache_size -= cache_line_size;
+ int j, k;
+ for( j = 0; j < vcount; j++ )
+ {
+ const float* sample = &vecs[j*var_count];
+ double s = 0;
+ for( k = 0; k <= var_count - 4; k += 4 )
+ s += std::min(sample[k],another[k]) + std::min(sample[k+1],another[k+1]) +
+ std::min(sample[k+2],another[k+2]) + std::min(sample[k+3],another[k+3]);
+ for( ; k < var_count; k++ )
+ s += std::min(sample[k],another[k]);
+ results[j] = (Qfloat)(s);
+ }
}
- // insert row into the LRU list
- row->data = data;
- row->prev = &lru_list;
- row->next = lru_list.next;
- row->prev->next = row->next->prev = row;
-
- if( !existed )
+ /// Exponential chi2 kernel
+ void calc_chi2( int vcount, int var_count, const float* vecs,
+ const float* another, Qfloat* results )
{
- kernel->calc( sample_count, var_count, samples, samples[i1], row->data );
+ Mat R( 1, vcount, QFLOAT_TYPE, results );
+ double gamma = -params.gamma;
+ int j, k;
+ for( j = 0; j < vcount; j++ )
+ {
+ const float* sample = &vecs[j*var_count];
+ double chi2 = 0;
+ for(k = 0 ; k < var_count; k++ )
+ {
+ double d = sample[k]-another[k];
+ double devisor = sample[k]+another[k];
+ /// if devisor == 0, the Chi2 distance would be zero,
+ // but calculation would rise an error because of deviding by zero
+ if (devisor != 0)
+ {
+ chi2 += d*d/devisor;
+ }
+ }
+ results[j] = (Qfloat) (gamma*chi2);
+ }
+ if( vcount > 0 )
+ exp( R, R );
}
-
- if( _existed )
- *_existed = existed;
-
- return row->data;
-}
-
-
-float* CvSVMSolver::get_row_svc( int i, float* row, float*, bool existed )
-{
- if( !existed )
+
+ void calc( int vcount, int var_count, const float* vecs,
+ const float* another, Qfloat* results )
{
- const schar* _y = y;
- int j, len = sample_count;
- assert( _y && i < sample_count );
-
- if( _y[i] > 0 )
+ switch( params.kernelType )
{
- for( j = 0; j < len; j++ )
- row[j] = _y[j]*row[j];
+ case SVM::LINEAR:
+ calc_linear(vcount, var_count, vecs, another, results);
+ break;
+ case SVM::RBF:
+ calc_rbf(vcount, var_count, vecs, another, results);
+ break;
+ case SVM::POLY:
+ calc_poly(vcount, var_count, vecs, another, results);
+ break;
+ case SVM::SIGMOID:
+ calc_sigmoid(vcount, var_count, vecs, another, results);
+ break;
+ case SVM::CHI2:
+ calc_chi2(vcount, var_count, vecs, another, results);
+ break;
+ case SVM::INTER:
+ calc_intersec(vcount, var_count, vecs, another, results);
+ break;
+ default:
+ CV_Error(CV_StsBadArg, "Unknown kernel type");
}
- else
+ const Qfloat max_val = (Qfloat)(FLT_MAX*1e-3);
+ for( int j = 0; j < vcount; j++ )
{
- for( j = 0; j < len; j++ )
- row[j] = -_y[j]*row[j];
+ if( results[j] > max_val )
+ results[j] = max_val;
}
}
- return row;
-}
-
-
-float* CvSVMSolver::get_row_one_class( int, float* row, float*, bool )
-{
- return row;
-}
-
-float* CvSVMSolver::get_row_svr( int i, float* row, float* dst, bool )
-{
- int j, len = sample_count;
- Qfloat* dst_pos = dst;
- Qfloat* dst_neg = dst + len;
- if( i >= len )
- {
- Qfloat* temp;
- CV_SWAP( dst_pos, dst_neg, temp );
- }
+ SVM::Params params;
+};
- for( j = 0; j < len; j++ )
- {
- Qfloat t = row[j];
- dst_pos[j] = t;
- dst_neg[j] = -t;
- }
- return dst;
-}
+/////////////////////////////////////////////////////////////////////////
-float* CvSVMSolver::get_row( int i, float* dst )
+static void sortSamplesByClasses( const Mat& _samples, const Mat& _responses,
+ vector<int>& sidx_all, vector<int>& class_ranges )
{
- bool existed = false;
- float* row = get_row_base( i, &existed );
- return (this->*get_row_func)( i, row, dst, existed );
-}
-
-
-#undef is_upper_bound
-#define is_upper_bound(i) (alpha_status[i] > 0)
+ int i, nsamples = _samples.rows;
+ CV_Assert( _responses.isContinuous() && _responses.checkVector(1, CV_32S) == nsamples );
-#undef is_lower_bound
-#define is_lower_bound(i) (alpha_status[i] < 0)
+ setRangeVector(sidx_all, nsamples);
-#undef is_free
-#define is_free(i) (alpha_status[i] == 0)
+ const int* rptr = _responses.ptr<int>();
+ std::sort(sidx_all.begin(), sidx_all.end(), cmp_lt_idx<int>(rptr));
+ class_ranges.clear();
+ class_ranges.push_back(0);
-#undef get_C
-#define get_C(i) (C[y[i]>0])
-
-#undef update_alpha_status
-#define update_alpha_status(i) \
- alpha_status[i] = (schar)(alpha[i] >= get_C(i) ? 1 : alpha[i] <= 0 ? -1 : 0)
-
-#undef reconstruct_gradient
-#define reconstruct_gradient() /* empty for now */
+ for( i = 0; i < nsamples; i++ )
+ {
+ if( i == nsamples-1 || rptr[sidx_all[i]] != rptr[sidx_all[i+1]] )
+ class_ranges.push_back(i+1);
+ }
+}
+
+//////////////////////// SVM implementation //////////////////////////////
+SVM::~SVM() {}
-bool CvSVMSolver::solve_generic( CvSVMSolutionInfo& si )
+class SVMImpl : public SVM
{
- int iter = 0;
- int i, j, k;
-
- // 1. initialize gradient and alpha status
- for( i = 0; i < alpha_count; i++ )
+public:
+ struct DecisionFunc
{
- update_alpha_status(i);
- G[i] = b[i];
- if( fabs(G[i]) > 1e200 )
- return false;
- }
+ DecisionFunc(double _rho, int _ofs) : rho(_rho), ofs(_ofs) {}
+ DecisionFunc() : rho(0.), ofs(0) {}
+ double rho;
+ int ofs;
+ };
- for( i = 0; i < alpha_count; i++ )
+ virtual ParamGrid getDefaultGrid( int param_id ) const
{
- if( !is_lower_bound(i) )
+ ParamGrid grid;
+ if( param_id == SVM::C )
{
- const Qfloat *Q_i = get_row( i, buf[0] );
- double alpha_i = alpha[i];
-
- for( j = 0; j < alpha_count; j++ )
- G[j] += alpha_i*Q_i[j];
+ grid.minVal = 0.1;
+ grid.maxVal = 500;
+ grid.logStep = 5; // total iterations = 5
}
- }
-
- // 2. optimization loop
- for(;;)
- {
- const Qfloat *Q_i, *Q_j;
- double C_i, C_j;
- double old_alpha_i, old_alpha_j, alpha_i, alpha_j;
- double delta_alpha_i, delta_alpha_j;
-
-#ifdef _DEBUG
- for( i = 0; i < alpha_count; i++ )
+ else if( param_id == SVM::GAMMA )
{
- if( fabs(G[i]) > 1e+300 )
- return false;
-
- if( fabs(alpha[i]) > 1e16 )
- return false;
+ grid.minVal = 1e-5;
+ grid.maxVal = 0.6;
+ grid.logStep = 15; // total iterations = 4
+ }
+ else if( param_id == SVM::P )
+ {
+ grid.minVal = 0.01;
+ grid.maxVal = 100;
+ grid.logStep = 7; // total iterations = 4
+ }
+ else if( param_id == SVM::NU )
+ {
+ grid.minVal = 0.01;
+ grid.maxVal = 0.2;
+ grid.logStep = 3; // total iterations = 3
+ }
+ else if( param_id == SVM::COEF )
+ {
+ grid.minVal = 0.1;
+ grid.maxVal = 300;
+ grid.logStep = 14; // total iterations = 3
+ }
+ else if( param_id == SVM::DEGREE )
+ {
+ grid.minVal = 0.01;
+ grid.maxVal = 4;
+ grid.logStep = 7; // total iterations = 3
+ }
+ else
+ cvError( CV_StsBadArg, "SVM::getDefaultGrid", "Invalid type of parameter "
+ "(use one of SVM::C, SVM::GAMMA et al.)", __FILE__, __LINE__ );
+ return grid;
+ }
+
+
+ // Generalized SMO+SVMlight algorithm
+ // Solves:
+ //
+ // min [0.5(\alpha^T Q \alpha) + b^T \alpha]
+ //
+ // y^T \alpha = \delta
+ // y_i = +1 or -1
+ // 0 <= alpha_i <= Cp for y_i = 1
+ // 0 <= alpha_i <= Cn for y_i = -1
+ //
+ // Given:
+ //
+ // Q, b, y, Cp, Cn, and an initial feasible point \alpha
+ // l is the size of vectors and matrices
+ // eps is the stopping criterion
+ //
+ // solution will be put in \alpha, objective value will be put in obj
+ //
+ class Solver
+ {
+ public:
+ enum { MIN_CACHE_SIZE = (40 << 20) /* 40Mb */, MAX_CACHE_SIZE = (500 << 20) /* 500Mb */ };
+
+ typedef bool (Solver::*SelectWorkingSet)( int& i, int& j );
+ typedef Qfloat* (Solver::*GetRow)( int i, Qfloat* row, Qfloat* dst, bool existed );
+ typedef void (Solver::*CalcRho)( double& rho, double& r );
+
+ struct KernelRow
+ {
+ KernelRow() { idx = -1; prev = next = 0; }
+ KernelRow(int _idx, int _prev, int _next) : idx(_idx), prev(_prev), next(_next) {}
+ int idx;
+ int prev;
+ int next;
+ };
+
+ struct SolutionInfo
+ {
+ SolutionInfo() { obj = rho = upper_bound_p = upper_bound_n = r = 0; }
+ double obj;
+ double rho;
+ double upper_bound_p;
+ double upper_bound_n;
+ double r; // for Solver_NU
+ };
+
+ void clear()
+ {
+ alpha_vec = 0;
+ select_working_set_func = 0;
+ calc_rho_func = 0;
+ get_row_func = 0;
+ lru_cache.clear();
}
-#endif
-
- if( (this->*select_working_set_func)( i, j ) != 0 || iter++ >= max_iter )
- break;
-
- Q_i = get_row( i, buf[0] );
- Q_j = get_row( j, buf[1] );
-
- C_i = get_C(i);
- C_j = get_C(j);
-
- alpha_i = old_alpha_i = alpha[i];
- alpha_j = old_alpha_j = alpha[j];
- if( y[i] != y[j] )
+ Solver( const Mat& _samples, const vector<schar>& _y,
+ vector<double>& _alpha, const vector<double>& _b,
+ double _Cp, double _Cn,
+ const Ptr<SVM::Kernel>& _kernel, GetRow _get_row,
+ SelectWorkingSet _select_working_set, CalcRho _calc_rho,
+ TermCriteria _termCrit )
{
- double denom = Q_i[i]+Q_j[j]+2*Q_i[j];
- double delta = (-G[i]-G[j])/MAX(fabs(denom),FLT_EPSILON);
- double diff = alpha_i - alpha_j;
- alpha_i += delta;
- alpha_j += delta;
+ clear();
+
+ samples = _samples;
+ sample_count = samples.rows;
+ var_count = samples.cols;
+
+ y_vec = _y;
+ alpha_vec = &_alpha;
+ alpha_count = (int)alpha_vec->size();
+ b_vec = _b;
+ kernel = _kernel;
+
+ C[0] = _Cn;
+ C[1] = _Cp;
+ eps = _termCrit.epsilon;
+ max_iter = _termCrit.maxCount;
+
+ G_vec.resize(alpha_count);
+ alpha_status_vec.resize(alpha_count);
+ buf[0].resize(sample_count*2);
+ buf[1].resize(sample_count*2);
+
+ select_working_set_func = _select_working_set;
+ CV_Assert(select_working_set_func != 0);
+
+ calc_rho_func = _calc_rho;
+ CV_Assert(calc_rho_func != 0);
+
+ get_row_func = _get_row;
+ CV_Assert(get_row_func != 0);
+
+ // assume that for large training sets ~25% of Q matrix is used
+ int64 csize = (int64)sample_count*sample_count/4;
+ csize = std::max(csize, (int64)(MIN_CACHE_SIZE/sizeof(Qfloat)) );
+ csize = std::min(csize, (int64)(MAX_CACHE_SIZE/sizeof(Qfloat)) );
+ max_cache_size = (int)((csize + sample_count-1)/sample_count);
+ max_cache_size = std::min(std::max(max_cache_size, 1), sample_count);
+ cache_size = 0;
+
+ lru_cache.clear();
+ lru_cache.resize(sample_count+1, KernelRow(-1, 0, 0));
+ lru_first = lru_last = 0;
+ lru_cache_data.create(max_cache_size, sample_count, QFLOAT_TYPE);
+ }
- if( diff > 0 && alpha_j < 0 )
+ Qfloat* get_row_base( int i, bool* _existed )
+ {
+ int i1 = i < sample_count ? i : i - sample_count;
+ KernelRow& kr = lru_cache[i1+1];
+ if( _existed )
+ *_existed = kr.idx >= 0;
+ if( kr.idx < 0 )
{
- alpha_j = 0;
- alpha_i = diff;
+ if( cache_size < max_cache_size )
+ {
+ kr.idx = cache_size;
+ cache_size++;
+ }
+ else
+ {
+ KernelRow& last = lru_cache[lru_last];
+ kr.idx = last.idx;
+ last.idx = -1;
+ lru_cache[last.prev].next = 0;
+ lru_last = last.prev;
+ }
+ kernel->calc( sample_count, var_count, samples.ptr<float>(),
+ samples.ptr<float>(i1), lru_cache_data.ptr<Qfloat>(kr.idx) );
}
- else if( diff <= 0 && alpha_i < 0 )
+ else
{
- alpha_i = 0;
- alpha_j = -diff;
+ if( kr.next )
+ lru_cache[kr.next].prev = kr.prev;
+ else
+ lru_last = kr.prev;
+ if( kr.prev )
+ lru_cache[kr.prev].next = kr.next;
+ else
+ lru_first = kr.next;
}
+ kr.next = lru_first;
+ kr.prev = 0;
+ lru_first = i1+1;
- if( diff > C_i - C_j && alpha_i > C_i )
- {
- alpha_i = C_i;
- alpha_j = C_i - diff;
- }
- else if( diff <= C_i - C_j && alpha_j > C_j )
- {
- alpha_j = C_j;
- alpha_i = C_j + diff;
- }
+ return lru_cache_data.ptr<Qfloat>(kr.idx);
}
- else
- {
- double denom = Q_i[i]+Q_j[j]-2*Q_i[j];
- double delta = (G[i]-G[j])/MAX(fabs(denom),FLT_EPSILON);
- double sum = alpha_i + alpha_j;
- alpha_i -= delta;
- alpha_j += delta;
- if( sum > C_i && alpha_i > C_i )
- {
- alpha_i = C_i;
- alpha_j = sum - C_i;
- }
- else if( sum <= C_i && alpha_j < 0)
+ Qfloat* get_row_svc( int i, Qfloat* row, Qfloat*, bool existed )
+ {
+ if( !existed )
{
- alpha_j = 0;
- alpha_i = sum;
- }
+ const schar* _y = &y_vec[0];
+ int j, len = sample_count;
- if( sum > C_j && alpha_j > C_j )
- {
- alpha_j = C_j;
- alpha_i = sum - C_j;
- }
- else if( sum <= C_j && alpha_i < 0 )
- {
- alpha_i = 0;
- alpha_j = sum;
+ if( _y[i] > 0 )
+ {
+ for( j = 0; j < len; j++ )
+ row[j] = _y[j]*row[j];
+ }
+ else
+ {
+ for( j = 0; j < len; j++ )
+ row[j] = -_y[j]*row[j];
+ }
}
+ return row;
}
- // update alpha
- alpha[i] = alpha_i;
- alpha[j] = alpha_j;
- update_alpha_status(i);
- update_alpha_status(j);
-
- // update G
- delta_alpha_i = alpha_i - old_alpha_i;
- delta_alpha_j = alpha_j - old_alpha_j;
+ Qfloat* get_row_one_class( int, Qfloat* row, Qfloat*, bool )
+ {
+ return row;
+ }
- for( k = 0; k < alpha_count; k++ )
- G[k] += Q_i[k]*delta_alpha_i + Q_j[k]*delta_alpha_j;
- }
+ Qfloat* get_row_svr( int i, Qfloat* row, Qfloat* dst, bool )
+ {
+ int j, len = sample_count;
+ Qfloat* dst_pos = dst;
+ Qfloat* dst_neg = dst + len;
+ if( i >= len )
+ std::swap(dst_pos, dst_neg);
- // calculate rho
- (this->*calc_rho_func)( si.rho, si.r );
+ for( j = 0; j < len; j++ )
+ {
+ Qfloat t = row[j];
+ dst_pos[j] = t;
+ dst_neg[j] = -t;
+ }
+ return dst;
+ }
- // calculate objective value
- for( i = 0, si.obj = 0; i < alpha_count; i++ )
- si.obj += alpha[i] * (G[i] + b[i]);
+ Qfloat* get_row( int i, float* dst )
+ {
+ bool existed = false;
+ float* row = get_row_base( i, &existed );
+ return (this->*get_row_func)( i, row, dst, existed );
+ }
- si.obj *= 0.5;
+ #undef is_upper_bound
+ #define is_upper_bound(i) (alpha_status[i] > 0)
- si.upper_bound_p = C[1];
- si.upper_bound_n = C[0];
+ #undef is_lower_bound
+ #define is_lower_bound(i) (alpha_status[i] < 0)
- return true;
-}
+ #undef is_free
+ #define is_free(i) (alpha_status[i] == 0)
+ #undef get_C
+ #define get_C(i) (C[y[i]>0])
-// return 1 if already optimal, return 0 otherwise
-bool
-CvSVMSolver::select_working_set( int& out_i, int& out_j )
-{
- // return i,j which maximize -grad(f)^T d , under constraint
- // if alpha_i == C, d != +1
- // if alpha_i == 0, d != -1
- double Gmax1 = -DBL_MAX; // max { -grad(f)_i * d | y_i*d = +1 }
- int Gmax1_idx = -1;
+ #undef update_alpha_status
+ #define update_alpha_status(i) \
+ alpha_status[i] = (schar)(alpha[i] >= get_C(i) ? 1 : alpha[i] <= 0 ? -1 : 0)
- double Gmax2 = -DBL_MAX; // max { -grad(f)_i * d | y_i*d = -1 }
- int Gmax2_idx = -1;
+ #undef reconstruct_gradient
+ #define reconstruct_gradient() /* empty for now */
- int i;
+ bool solve_generic( SolutionInfo& si )
+ {
+ const schar* y = &y_vec[0];
+ double* alpha = &alpha_vec->at(0);
+ schar* alpha_status = &alpha_status_vec[0];
+ double* G = &G_vec[0];
+ double* b = &b_vec[0];
- for( i = 0; i < alpha_count; i++ )
- {
- double t;
+ int iter = 0;
+ int i, j, k;
- if( y[i] > 0 ) // y = +1
- {
- if( !is_upper_bound(i) && (t = -G[i]) > Gmax1 ) // d = +1
- {
- Gmax1 = t;
- Gmax1_idx = i;
- }
- if( !is_lower_bound(i) && (t = G[i]) > Gmax2 ) // d = -1
+ // 1. initialize gradient and alpha status
+ for( i = 0; i < alpha_count; i++ )
{
- Gmax2 = t;
- Gmax2_idx = i;
+ update_alpha_status(i);
+ G[i] = b[i];
+ if( fabs(G[i]) > 1e200 )
+ return false;
}
- }
- else // y = -1
- {
- if( !is_upper_bound(i) && (t = -G[i]) > Gmax2 ) // d = +1
+
+ for( i = 0; i < alpha_count; i++ )
{
- Gmax2 = t;
- Gmax2_idx = i;
+ if( !is_lower_bound(i) )
+ {
+ const Qfloat *Q_i = get_row( i, &buf[0][0] );
+ double alpha_i = alpha[i];
+
+ for( j = 0; j < alpha_count; j++ )
+ G[j] += alpha_i*Q_i[j];
+ }
}
- if( !is_lower_bound(i) && (t = G[i]) > Gmax1 ) // d = -1
+
+ // 2. optimization loop
+ for(;;)
{
- Gmax1 = t;
- Gmax1_idx = i;
- }
- }
- }
+ const Qfloat *Q_i, *Q_j;
+ double C_i, C_j;
+ double old_alpha_i, old_alpha_j, alpha_i, alpha_j;
+ double delta_alpha_i, delta_alpha_j;
- out_i = Gmax1_idx;
- out_j = Gmax2_idx;
-
- return Gmax1 + Gmax2 < eps;
-}
+ #ifdef _DEBUG
+ for( i = 0; i < alpha_count; i++ )
+ {
+ if( fabs(G[i]) > 1e+300 )
+ return false;
+ if( fabs(alpha[i]) > 1e16 )
+ return false;
+ }
+ #endif
-void
-CvSVMSolver::calc_rho( double& rho, double& r )
-{
- int i, nr_free = 0;
- double ub = DBL_MAX, lb = -DBL_MAX, sum_free = 0;
+ if( (this->*select_working_set_func)( i, j ) != 0 || iter++ >= max_iter )
+ break;
- for( i = 0; i < alpha_count; i++ )
- {
- double yG = y[i]*G[i];
+ Q_i = get_row( i, &buf[0][0] );
+ Q_j = get_row( j, &buf[1][0] );
- if( is_lower_bound(i) )
- {
- if( y[i] > 0 )
- ub = MIN(ub,yG);
- else
- lb = MAX(lb,yG);
- }
- else if( is_upper_bound(i) )
- {
- if( y[i] < 0)
- ub = MIN(ub,yG);
- else
- lb = MAX(lb,yG);
- }
- else
- {
- ++nr_free;
- sum_free += yG;
- }
- }
+ C_i = get_C(i);
+ C_j = get_C(j);
- rho = nr_free > 0 ? sum_free/nr_free : (ub + lb)*0.5;
- r = 0;
-}
+ alpha_i = old_alpha_i = alpha[i];
+ alpha_j = old_alpha_j = alpha[j];
+ if( y[i] != y[j] )
+ {
+ double denom = Q_i[i]+Q_j[j]+2*Q_i[j];
+ double delta = (-G[i]-G[j])/MAX(fabs(denom),FLT_EPSILON);
+ double diff = alpha_i - alpha_j;
+ alpha_i += delta;
+ alpha_j += delta;
-bool
-CvSVMSolver::select_working_set_nu_svm( int& out_i, int& out_j )
-{
- // return i,j which maximize -grad(f)^T d , under constraint
- // if alpha_i == C, d != +1
- // if alpha_i == 0, d != -1
- double Gmax1 = -DBL_MAX; // max { -grad(f)_i * d | y_i = +1, d = +1 }
- int Gmax1_idx = -1;
+ if( diff > 0 && alpha_j < 0 )
+ {
+ alpha_j = 0;
+ alpha_i = diff;
+ }
+ else if( diff <= 0 && alpha_i < 0 )
+ {
+ alpha_i = 0;
+ alpha_j = -diff;
+ }
- double Gmax2 = -DBL_MAX; // max { -grad(f)_i * d | y_i = +1, d = -1 }
- int Gmax2_idx = -1;
+ if( diff > C_i - C_j && alpha_i > C_i )
+ {
+ alpha_i = C_i;
+ alpha_j = C_i - diff;
+ }
+ else if( diff <= C_i - C_j && alpha_j > C_j )
+ {
+ alpha_j = C_j;
+ alpha_i = C_j + diff;
+ }
+ }
+ else
+ {
+ double denom = Q_i[i]+Q_j[j]-2*Q_i[j];
+ double delta = (G[i]-G[j])/MAX(fabs(denom),FLT_EPSILON);
+ double sum = alpha_i + alpha_j;
+ alpha_i -= delta;
+ alpha_j += delta;
- double Gmax3 = -DBL_MAX; // max { -grad(f)_i * d | y_i = -1, d = +1 }
- int Gmax3_idx = -1;
+ if( sum > C_i && alpha_i > C_i )
+ {
+ alpha_i = C_i;
+ alpha_j = sum - C_i;
+ }
+ else if( sum <= C_i && alpha_j < 0)
+ {
+ alpha_j = 0;
+ alpha_i = sum;
+ }
- double Gmax4 = -DBL_MAX; // max { -grad(f)_i * d | y_i = -1, d = -1 }
- int Gmax4_idx = -1;
+ if( sum > C_j && alpha_j > C_j )
+ {
+ alpha_j = C_j;
+ alpha_i = sum - C_j;
+ }
+ else if( sum <= C_j && alpha_i < 0 )
+ {
+ alpha_i = 0;
+ alpha_j = sum;
+ }
+ }
- int i;
+ // update alpha
+ alpha[i] = alpha_i;
+ alpha[j] = alpha_j;
+ update_alpha_status(i);
+ update_alpha_status(j);
- for( i = 0; i < alpha_count; i++ )
- {
- double t;
+ // update G
+ delta_alpha_i = alpha_i - old_alpha_i;
+ delta_alpha_j = alpha_j - old_alpha_j;
- if( y[i] > 0 ) // y == +1
- {
- if( !is_upper_bound(i) && (t = -G[i]) > Gmax1 ) // d = +1
- {
- Gmax1 = t;
- Gmax1_idx = i;
- }
- if( !is_lower_bound(i) && (t = G[i]) > Gmax2 ) // d = -1
- {
- Gmax2 = t;
- Gmax2_idx = i;
- }
- }
- else // y == -1
- {
- if( !is_upper_bound(i) && (t = -G[i]) > Gmax3 ) // d = +1
- {
- Gmax3 = t;
- Gmax3_idx = i;
- }
- if( !is_lower_bound(i) && (t = G[i]) > Gmax4 ) // d = -1
- {
- Gmax4 = t;
- Gmax4_idx = i;
+ for( k = 0; k < alpha_count; k++ )
+ G[k] += Q_i[k]*delta_alpha_i + Q_j[k]*delta_alpha_j;
}
- }
- }
-
- if( MAX(Gmax1 + Gmax2, Gmax3 + Gmax4) < eps )
- return 1;
- if( Gmax1 + Gmax2 > Gmax3 + Gmax4 )
- {
- out_i = Gmax1_idx;
- out_j = Gmax2_idx;
- }
- else
- {
- out_i = Gmax3_idx;
- out_j = Gmax4_idx;
- }
- return 0;
-}
+ // calculate rho
+ (this->*calc_rho_func)( si.rho, si.r );
+ // calculate objective value
+ for( i = 0, si.obj = 0; i < alpha_count; i++ )
+ si.obj += alpha[i] * (G[i] + b[i]);
-void
-CvSVMSolver::calc_rho_nu_svm( double& rho, double& r )
-{
- int nr_free1 = 0, nr_free2 = 0;
- double ub1 = DBL_MAX, ub2 = DBL_MAX;
- double lb1 = -DBL_MAX, lb2 = -DBL_MAX;
- double sum_free1 = 0, sum_free2 = 0;
- double r1, r2;
+ si.obj *= 0.5;
- int i;
+ si.upper_bound_p = C[1];
+ si.upper_bound_n = C[0];
- for( i = 0; i < alpha_count; i++ )
- {
- double G_i = G[i];
- if( y[i] > 0 )
- {
- if( is_lower_bound(i) )
- ub1 = MIN( ub1, G_i );
- else if( is_upper_bound(i) )
- lb1 = MAX( lb1, G_i );
- else
- {
- ++nr_free1;
- sum_free1 += G_i;
- }
- }
- else
- {
- if( is_lower_bound(i) )
- ub2 = MIN( ub2, G_i );
- else if( is_upper_bound(i) )
- lb2 = MAX( lb2, G_i );
- else
- {
- ++nr_free2;
- sum_free2 += G_i;
- }
+ return true;
}
- }
-
- r1 = nr_free1 > 0 ? sum_free1/nr_free1 : (ub1 + lb1)*0.5;
- r2 = nr_free2 > 0 ? sum_free2/nr_free2 : (ub2 + lb2)*0.5;
-
- rho = (r1 - r2)*0.5;
- r = (r1 + r2)*0.5;
-}
-
-/*
-///////////////////////// construct and solve various formulations ///////////////////////
-*/
-
-bool CvSVMSolver::solve_c_svc( int _sample_count, int _var_count, const float** _samples, schar* _y,
- double _Cp, double _Cn, CvMemStorage* _storage,
- CvSVMKernel* _kernel, double* _alpha, CvSVMSolutionInfo& _si )
-{
- int i;
-
- if( !create( _sample_count, _var_count, _samples, _y, _sample_count,
- _alpha, _Cp, _Cn, _storage, _kernel, &CvSVMSolver::get_row_svc,
- &CvSVMSolver::select_working_set, &CvSVMSolver::calc_rho ))
- return false;
-
- for( i = 0; i < sample_count; i++ )
- {
- alpha[i] = 0;
- b[i] = -1;
- }
-
- if( !solve_generic( _si ))
- return false;
-
- for( i = 0; i < sample_count; i++ )
- alpha[i] *= y[i];
-
- return true;
-}
-
-
-bool CvSVMSolver::solve_nu_svc( int _sample_count, int _var_count, const float** _samples, schar* _y,
- CvMemStorage* _storage, CvSVMKernel* _kernel,
- double* _alpha, CvSVMSolutionInfo& _si )
-{
- int i;
- double sum_pos, sum_neg, inv_r;
-
- if( !create( _sample_count, _var_count, _samples, _y, _sample_count,
- _alpha, 1., 1., _storage, _kernel, &CvSVMSolver::get_row_svc,
- &CvSVMSolver::select_working_set_nu_svm, &CvSVMSolver::calc_rho_nu_svm ))
- return false;
-
- sum_pos = kernel->params->nu * sample_count * 0.5;
- sum_neg = kernel->params->nu * sample_count * 0.5;
-
- for( i = 0; i < sample_count; i++ )
- {
- if( y[i] > 0 )
+ // return 1 if already optimal, return 0 otherwise
+ bool select_working_set( int& out_i, int& out_j )
{
- alpha[i] = MIN(1.0, sum_pos);
- sum_pos -= alpha[i];
- }
- else
- {
- alpha[i] = MIN(1.0, sum_neg);
- sum_neg -= alpha[i];
- }
- b[i] = 0;
- }
+ // return i,j which maximize -grad(f)^T d , under constraint
+ // if alpha_i == C, d != +1
+ // if alpha_i == 0, d != -1
+ double Gmax1 = -DBL_MAX; // max { -grad(f)_i * d | y_i*d = +1 }
+ int Gmax1_idx = -1;
- if( !solve_generic( _si ))
- return false;
+ double Gmax2 = -DBL_MAX; // max { -grad(f)_i * d | y_i*d = -1 }
+ int Gmax2_idx = -1;
- inv_r = 1./_si.r;
+ const schar* y = &y_vec[0];
+ const schar* alpha_status = &alpha_status_vec[0];
+ const double* G = &G_vec[0];
- for( i = 0; i < sample_count; i++ )
- alpha[i] *= y[i]*inv_r;
-
- _si.rho *= inv_r;
- _si.obj *= (inv_r*inv_r);
- _si.upper_bound_p = inv_r;
- _si.upper_bound_n = inv_r;
-
- return true;
-}
-
-
-bool CvSVMSolver::solve_one_class( int _sample_count, int _var_count, const float** _samples,
- CvMemStorage* _storage, CvSVMKernel* _kernel,
- double* _alpha, CvSVMSolutionInfo& _si )
-{
- int i, n;
- double nu = _kernel->params->nu;
-
- if( !create( _sample_count, _var_count, _samples, 0, _sample_count,
- _alpha, 1., 1., _storage, _kernel, &CvSVMSolver::get_row_one_class,
- &CvSVMSolver::select_working_set, &CvSVMSolver::calc_rho ))
- return false;
-
- y = (schar*)cvMemStorageAlloc( storage, sample_count*sizeof(y[0]) );
- n = cvRound( nu*sample_count );
-
- for( i = 0; i < sample_count; i++ )
- {
- y[i] = 1;
- b[i] = 0;
- alpha[i] = i < n ? 1 : 0;
- }
-
- if( n < sample_count )
- alpha[n] = nu * sample_count - n;
- else
- alpha[n-1] = nu * sample_count - (n-1);
-
- return solve_generic(_si);
-}
-
-
-bool CvSVMSolver::solve_eps_svr( int _sample_count, int _var_count, const float** _samples,
- const float* _y, CvMemStorage* _storage,
- CvSVMKernel* _kernel, double* _alpha, CvSVMSolutionInfo& _si )
-{
- int i;
- double p = _kernel->params->p, kernel_param_c = _kernel->params->C;
-
- if( !create( _sample_count, _var_count, _samples, 0,
- _sample_count*2, 0, kernel_param_c, kernel_param_c, _storage, _kernel, &CvSVMSolver::get_row_svr,
- &CvSVMSolver::select_working_set, &CvSVMSolver::calc_rho ))
- return false;
-
- y = (schar*)cvMemStorageAlloc( storage, sample_count*2*sizeof(y[0]) );
- alpha = (double*)cvMemStorageAlloc( storage, alpha_count*sizeof(alpha[0]) );
-
- for( i = 0; i < sample_count; i++ )
- {
- alpha[i] = 0;
- b[i] = p - _y[i];
- y[i] = 1;
-
- alpha[i+sample_count] = 0;
- b[i+sample_count] = p + _y[i];
- y[i+sample_count] = -1;
- }
-
- if( !solve_generic( _si ))
- return false;
-
- for( i = 0; i < sample_count; i++ )
- _alpha[i] = alpha[i] - alpha[i+sample_count];
-
- return true;
-}
-
-
-bool CvSVMSolver::solve_nu_svr( int _sample_count, int _var_count, const float** _samples,
- const float* _y, CvMemStorage* _storage,
- CvSVMKernel* _kernel, double* _alpha, CvSVMSolutionInfo& _si )
-{
- int i;
- double kernel_param_c = _kernel->params->C, sum;
-
- if( !create( _sample_count, _var_count, _samples, 0,
- _sample_count*2, 0, 1., 1., _storage, _kernel, &CvSVMSolver::get_row_svr,
- &CvSVMSolver::select_working_set_nu_svm, &CvSVMSolver::calc_rho_nu_svm ))
- return false;
-
- y = (schar*)cvMemStorageAlloc( storage, sample_count*2*sizeof(y[0]) );
- alpha = (double*)cvMemStorageAlloc( storage, alpha_count*sizeof(alpha[0]) );
- sum = kernel_param_c * _kernel->params->nu * sample_count * 0.5;
-
- for( i = 0; i < sample_count; i++ )
- {
- alpha[i] = alpha[i + sample_count] = MIN(sum, kernel_param_c);
- sum -= alpha[i];
-
- b[i] = -_y[i];
- y[i] = 1;
-
- b[i + sample_count] = _y[i];
- y[i + sample_count] = -1;
- }
-
- if( !solve_generic( _si ))
- return false;
-
- for( i = 0; i < sample_count; i++ )
- _alpha[i] = alpha[i] - alpha[i+sample_count];
-
- return true;
-}
-
-
-//////////////////////////////////////////////////////////////////////////////////////////
-
-CvSVM::CvSVM()
-{
- decision_func = 0;
- class_labels = 0;
- class_weights = 0;
- storage = 0;
- var_idx = 0;
- kernel = 0;
- solver = 0;
- default_model_name = "my_svm";
-
- clear();
-}
-
-
-CvSVM::~CvSVM()
-{
- clear();
-}
-
-
-void CvSVM::clear()
-{
- cvFree( &decision_func );
- cvReleaseMat( &class_labels );
- cvReleaseMat( &class_weights );
- cvReleaseMemStorage( &storage );
- cvReleaseMat( &var_idx );
- delete kernel;
- delete solver;
- kernel = 0;
- solver = 0;
- var_all = 0;
- sv = 0;
- sv_total = 0;
-}
-
-
-CvSVM::CvSVM( const CvMat* _train_data, const CvMat* _responses,
- const CvMat* _var_idx, const CvMat* _sample_idx, CvSVMParams _params )
-{
- decision_func = 0;
- class_labels = 0;
- class_weights = 0;
- storage = 0;
- var_idx = 0;
- kernel = 0;
- solver = 0;
- default_model_name = "my_svm";
-
- train( _train_data, _responses, _var_idx, _sample_idx, _params );
-}
-
-
-int CvSVM::get_support_vector_count() const
-{
- return sv_total;
-}
-
-
-const float* CvSVM::get_support_vector(int i) const
-{
- return sv && (unsigned)i < (unsigned)sv_total ? sv[i] : 0;
-}
-
-bool CvSVM::set_params( const CvSVMParams& _params )
-{
- bool ok = false;
-
- CV_FUNCNAME( "CvSVM::set_params" );
-
- __BEGIN__;
-
- int kernel_type, svm_type;
-
- params = _params;
-
- kernel_type = params.kernel_type;
- svm_type = params.svm_type;
-
- if( kernel_type != LINEAR && kernel_type != POLY &&
- kernel_type != SIGMOID && kernel_type != RBF &&
- kernel_type != INTER && kernel_type != CHI2)
- CV_ERROR( CV_StsBadArg, "Unknown/unsupported kernel type" );
-
- if( kernel_type == LINEAR )
- params.gamma = 1;
- else if( params.gamma <= 0 )
- CV_ERROR( CV_StsOutOfRange, "gamma parameter of the kernel must be positive" );
-
- if( kernel_type != SIGMOID && kernel_type != POLY )
- params.coef0 = 0;
- else if( params.coef0 < 0 )
- CV_ERROR( CV_StsOutOfRange, "The kernel parameter <coef0> must be positive or zero" );
-
- if( kernel_type != POLY )
- params.degree = 0;
- else if( params.degree <= 0 )
- CV_ERROR( CV_StsOutOfRange, "The kernel parameter <degree> must be positive" );
-
- if( svm_type != C_SVC && svm_type != NU_SVC &&
- svm_type != ONE_CLASS && svm_type != EPS_SVR &&
- svm_type != NU_SVR )
- CV_ERROR( CV_StsBadArg, "Unknown/unsupported SVM type" );
-
- if( svm_type == ONE_CLASS || svm_type == NU_SVC )
- params.C = 0;
- else if( params.C <= 0 )
- CV_ERROR( CV_StsOutOfRange, "The parameter C must be positive" );
-
- if( svm_type == C_SVC || svm_type == EPS_SVR )
- params.nu = 0;
- else if( params.nu <= 0 || params.nu >= 1 )
- CV_ERROR( CV_StsOutOfRange, "The parameter nu must be between 0 and 1" );
-
- if( svm_type != EPS_SVR )
- params.p = 0;
- else if( params.p <= 0 )
- CV_ERROR( CV_StsOutOfRange, "The parameter p must be positive" );
-
- if( svm_type != C_SVC )
- params.class_weights = 0;
-
- params.term_crit = cvCheckTermCriteria( params.term_crit, DBL_EPSILON, INT_MAX );
- params.term_crit.epsilon = MAX( params.term_crit.epsilon, DBL_EPSILON );
- ok = true;
-
- __END__;
-
- return ok;
-}
-
-
-
-void CvSVM::create_kernel()
-{
- kernel = new CvSVMKernel(¶ms,0);
-}
-
-
-void CvSVM::create_solver( )
-{
- solver = new CvSVMSolver;
-}
-
-
-// switching function
-bool CvSVM::train1( int sample_count, int var_count, const float** samples,
- const void* _responses, double Cp, double Cn,
- CvMemStorage* _storage, double* alpha, double& rho )
-{
- bool ok = false;
-
- //CV_FUNCNAME( "CvSVM::train1" );
-
- __BEGIN__;
-
- CvSVMSolutionInfo si;
- int svm_type = params.svm_type;
-
- si.rho = 0;
-
- ok = svm_type == C_SVC ? solver->solve_c_svc( sample_count, var_count, samples, (schar*)_responses,
- Cp, Cn, _storage, kernel, alpha, si ) :
- svm_type == NU_SVC ? solver->solve_nu_svc( sample_count, var_count, samples, (schar*)_responses,
- _storage, kernel, alpha, si ) :
- svm_type == ONE_CLASS ? solver->solve_one_class( sample_count, var_count, samples,
- _storage, kernel, alpha, si ) :
- svm_type == EPS_SVR ? solver->solve_eps_svr( sample_count, var_count, samples, (float*)_responses,
- _storage, kernel, alpha, si ) :
- svm_type == NU_SVR ? solver->solve_nu_svr( sample_count, var_count, samples, (float*)_responses,
- _storage, kernel, alpha, si ) : false;
-
- rho = si.rho;
-
- __END__;
-
- return ok;
-}
-
-
-bool CvSVM::do_train( int svm_type, int sample_count, int var_count, const float** samples,
- const CvMat* responses, CvMemStorage* temp_storage, double* alpha )
-{
- bool ok = false;
-
- CV_FUNCNAME( "CvSVM::do_train" );
-
- __BEGIN__;
-
- CvSVMDecisionFunc* df = 0;
- const int sample_size = var_count*sizeof(samples[0][0]);
- int i, j, k;
-
- cvClearMemStorage( storage );
-
- if( svm_type == ONE_CLASS || svm_type == EPS_SVR || svm_type == NU_SVR )
- {
- int sv_count = 0;
-
- CV_CALL( decision_func = df =
- (CvSVMDecisionFunc*)cvAlloc( sizeof(df[0]) ));
-
- df->rho = 0;
- if( !train1( sample_count, var_count, samples, svm_type == ONE_CLASS ? 0 :
- responses->data.i, 0, 0, temp_storage, alpha, df->rho ))
- EXIT;
-
- for( i = 0; i < sample_count; i++ )
- sv_count += fabs(alpha[i]) > 0;
-
- CV_Assert(sv_count != 0);
-
- sv_total = df->sv_count = sv_count;
- CV_CALL( df->alpha = (double*)cvMemStorageAlloc( storage, sv_count*sizeof(df->alpha[0])) );
- CV_CALL( sv = (float**)cvMemStorageAlloc( storage, sv_count*sizeof(sv[0])));
-
- for( i = k = 0; i < sample_count; i++ )
- {
- if( fabs(alpha[i]) > 0 )
+ for( int i = 0; i < alpha_count; i++ )
{
- CV_CALL( sv[k] = (float*)cvMemStorageAlloc( storage, sample_size ));
- memcpy( sv[k], samples[i], sample_size );
- df->alpha[k++] = alpha[i];
- }
- }
- }
- else
- {
- int class_count = class_labels->cols;
- int* sv_tab = 0;
- const float** temp_samples = 0;
- int* class_ranges = 0;
- schar* temp_y = 0;
- assert( svm_type == CvSVM::C_SVC || svm_type == CvSVM::NU_SVC );
-
- if( svm_type == CvSVM::C_SVC && params.class_weights )
- {
- const CvMat* cw = params.class_weights;
-
- if( !CV_IS_MAT(cw) || (cw->cols != 1 && cw->rows != 1) ||
- cw->rows + cw->cols - 1 != class_count ||
- (CV_MAT_TYPE(cw->type) != CV_32FC1 && CV_MAT_TYPE(cw->type) != CV_64FC1) )
- CV_ERROR( CV_StsBadArg, "params.class_weights must be 1d floating-point vector "
- "containing as many elements as the number of classes" );
+ double t;
- CV_CALL( class_weights = cvCreateMat( cw->rows, cw->cols, CV_64F ));
- CV_CALL( cvConvert( cw, class_weights ));
- CV_CALL( cvScale( class_weights, class_weights, params.C ));
- }
-
- CV_CALL( decision_func = df = (CvSVMDecisionFunc*)cvAlloc(
- (class_count*(class_count-1)/2)*sizeof(df[0])));
-
- CV_CALL( sv_tab = (int*)cvMemStorageAlloc( temp_storage, sample_count*sizeof(sv_tab[0]) ));
- memset( sv_tab, 0, sample_count*sizeof(sv_tab[0]) );
- CV_CALL( class_ranges = (int*)cvMemStorageAlloc( temp_storage,
- (class_count + 1)*sizeof(class_ranges[0])));
- CV_CALL( temp_samples = (const float**)cvMemStorageAlloc( temp_storage,
- sample_count*sizeof(temp_samples[0])));
- CV_CALL( temp_y = (schar*)cvMemStorageAlloc( temp_storage, sample_count));
-
- class_ranges[class_count] = 0;
- cvSortSamplesByClasses( samples, responses, class_ranges, 0 );
- //check that while cross-validation there were the samples from all the classes
- if( class_ranges[class_count] <= 0 )
- CV_ERROR( CV_StsBadArg, "While cross-validation one or more of the classes have "
- "been fell out of the sample. Try to enlarge <CvSVMParams::k_fold>" );
-
- if( svm_type == NU_SVC )
- {
- // check if nu is feasible
- for(i = 0; i < class_count; i++ )
- {
- int ci = class_ranges[i+1] - class_ranges[i];
- for( j = i+1; j< class_count; j++ )
+ if( y[i] > 0 ) // y = +1
{
- int cj = class_ranges[j+1] - class_ranges[j];
- if( params.nu*(ci + cj)*0.5 > MIN( ci, cj ) )
+ if( !is_upper_bound(i) && (t = -G[i]) > Gmax1 ) // d = +1
+ {
+ Gmax1 = t;
+ Gmax1_idx = i;
+ }
+ if( !is_lower_bound(i) && (t = G[i]) > Gmax2 ) // d = -1
+ {
+ Gmax2 = t;
+ Gmax2_idx = i;
+ }
+ }
+ else // y = -1
+ {
+ if( !is_upper_bound(i) && (t = -G[i]) > Gmax2 ) // d = +1
+ {
+ Gmax2 = t;
+ Gmax2_idx = i;
+ }
+ if( !is_lower_bound(i) && (t = G[i]) > Gmax1 ) // d = -1
{
- // !!!TODO!!! add some diagnostic
- EXIT; // exit immediately; will release the model and return NULL pointer
+ Gmax1 = t;
+ Gmax1_idx = i;
}
}
}
+
+ out_i = Gmax1_idx;
+ out_j = Gmax2_idx;
+
+ return Gmax1 + Gmax2 < eps;
}
- // train n*(n-1)/2 classifiers
- for( i = 0; i < class_count; i++ )
+ void calc_rho( double& rho, double& r )
{
- for( j = i+1; j < class_count; j++, df++ )
+ int nr_free = 0;
+ double ub = DBL_MAX, lb = -DBL_MAX, sum_free = 0;
+ const schar* y = &y_vec[0];
+ const schar* alpha_status = &alpha_status_vec[0];
+ const double* G = &G_vec[0];
+
+ for( int i = 0; i < alpha_count; i++ )
{
- int si = class_ranges[i], ci = class_ranges[i+1] - si;
- int sj = class_ranges[j], cj = class_ranges[j+1] - sj;
- double Cp = params.C, Cn = Cp;
- int k1 = 0, sv_count = 0;
+ double yG = y[i]*G[i];
- for( k = 0; k < ci; k++ )
+ if( is_lower_bound(i) )
{
- temp_samples[k] = samples[si + k];
- temp_y[k] = 1;
+ if( y[i] > 0 )
+ ub = MIN(ub,yG);
+ else
+ lb = MAX(lb,yG);
}
-
- for( k = 0; k < cj; k++ )
+ else if( is_upper_bound(i) )
{
- temp_samples[ci + k] = samples[sj + k];
- temp_y[ci + k] = -1;
+ if( y[i] < 0)
+ ub = MIN(ub,yG);
+ else
+ lb = MAX(lb,yG);
}
-
- if( class_weights )
+ else
{
- Cp = class_weights->data.db[i];
- Cn = class_weights->data.db[j];
+ ++nr_free;
+ sum_free += yG;
}
+ }
+
+ rho = nr_free > 0 ? sum_free/nr_free : (ub + lb)*0.5;
+ r = 0;
+ }
+
+ bool select_working_set_nu_svm( int& out_i, int& out_j )
+ {
+ // return i,j which maximize -grad(f)^T d , under constraint
+ // if alpha_i == C, d != +1
+ // if alpha_i == 0, d != -1
+ double Gmax1 = -DBL_MAX; // max { -grad(f)_i * d | y_i = +1, d = +1 }
+ int Gmax1_idx = -1;
- if( !train1( ci + cj, var_count, temp_samples, temp_y,
- Cp, Cn, temp_storage, alpha, df->rho ))
- EXIT;
+ double Gmax2 = -DBL_MAX; // max { -grad(f)_i * d | y_i = +1, d = -1 }
+ int Gmax2_idx = -1;
- for( k = 0; k < ci + cj; k++ )
- sv_count += fabs(alpha[k]) > 0;
+ double Gmax3 = -DBL_MAX; // max { -grad(f)_i * d | y_i = -1, d = +1 }
+ int Gmax3_idx = -1;
- df->sv_count = sv_count;
+ double Gmax4 = -DBL_MAX; // max { -grad(f)_i * d | y_i = -1, d = -1 }
+ int Gmax4_idx = -1;
- CV_CALL( df->alpha = (double*)cvMemStorageAlloc( temp_storage,
- sv_count*sizeof(df->alpha[0])));
- CV_CALL( df->sv_index = (int*)cvMemStorageAlloc( temp_storage,
- sv_count*sizeof(df->sv_index[0])));
+ const schar* y = &y_vec[0];
+ const schar* alpha_status = &alpha_status_vec[0];
+ const double* G = &G_vec[0];
- for( k = 0; k < ci; k++ )
+ for( int i = 0; i < alpha_count; i++ )
+ {
+ double t;
+
+ if( y[i] > 0 ) // y == +1
{
- if( fabs(alpha[k]) > 0 )
+ if( !is_upper_bound(i) && (t = -G[i]) > Gmax1 ) // d = +1
+ {
+ Gmax1 = t;
+ Gmax1_idx = i;
+ }
+ if( !is_lower_bound(i) && (t = G[i]) > Gmax2 ) // d = -1
{
- sv_tab[si + k] = 1;
- df->sv_index[k1] = si + k;
- df->alpha[k1++] = alpha[k];
+ Gmax2 = t;
+ Gmax2_idx = i;
}
}
-
- for( k = 0; k < cj; k++ )
+ else // y == -1
{
- if( fabs(alpha[ci + k]) > 0 )
+ if( !is_upper_bound(i) && (t = -G[i]) > Gmax3 ) // d = +1
+ {
+ Gmax3 = t;
+ Gmax3_idx = i;
+ }
+ if( !is_lower_bound(i) && (t = G[i]) > Gmax4 ) // d = -1
{
- sv_tab[sj + k] = 1;
- df->sv_index[k1] = sj + k;
- df->alpha[k1++] = alpha[ci + k];
+ Gmax4 = t;
+ Gmax4_idx = i;
}
}
}
- }
-
- // allocate support vectors and initialize sv_tab
- for( i = 0, k = 0; i < sample_count; i++ )
- {
- if( sv_tab[i] )
- sv_tab[i] = ++k;
- }
- sv_total = k;
- CV_CALL( sv = (float**)cvMemStorageAlloc( storage, sv_total*sizeof(sv[0])));
+ if( MAX(Gmax1 + Gmax2, Gmax3 + Gmax4) < eps )
+ return 1;
- for( i = 0, k = 0; i < sample_count; i++ )
- {
- if( sv_tab[i] )
+ if( Gmax1 + Gmax2 > Gmax3 + Gmax4 )
{
- CV_CALL( sv[k] = (float*)cvMemStorageAlloc( storage, sample_size ));
- memcpy( sv[k], samples[i], sample_size );
- k++;
+ out_i = Gmax1_idx;
+ out_j = Gmax2_idx;
}
+ else
+ {
+ out_i = Gmax3_idx;
+ out_j = Gmax4_idx;
+ }
+ return 0;
}
- df = (CvSVMDecisionFunc*)decision_func;
-
- // set sv pointers
- for( i = 0; i < class_count; i++ )
+ void calc_rho_nu_svm( double& rho, double& r )
{
- for( j = i+1; j < class_count; j++, df++ )
+ int nr_free1 = 0, nr_free2 = 0;
+ double ub1 = DBL_MAX, ub2 = DBL_MAX;
+ double lb1 = -DBL_MAX, lb2 = -DBL_MAX;
+ double sum_free1 = 0, sum_free2 = 0;
+
+ const schar* y = &y_vec[0];
+ const schar* alpha_status = &alpha_status_vec[0];
+ const double* G = &G_vec[0];
+
+ for( int i = 0; i < alpha_count; i++ )
{
- for( k = 0; k < df->sv_count; k++ )
+ double G_i = G[i];
+ if( y[i] > 0 )
{
- df->sv_index[k] = sv_tab[df->sv_index[k]]-1;
- assert( (unsigned)df->sv_index[k] < (unsigned)sv_total );
+ if( is_lower_bound(i) )
+ ub1 = MIN( ub1, G_i );
+ else if( is_upper_bound(i) )
+ lb1 = MAX( lb1, G_i );
+ else
+ {
+ ++nr_free1;
+ sum_free1 += G_i;
+ }
+ }
+ else
+ {
+ if( is_lower_bound(i) )
+ ub2 = MIN( ub2, G_i );
+ else if( is_upper_bound(i) )
+ lb2 = MAX( lb2, G_i );
+ else
+ {
+ ++nr_free2;
+ sum_free2 += G_i;
+ }
}
}
- }
- }
-
- optimize_linear_svm();
- ok = true;
-
- __END__;
-
- return ok;
-}
-
-
-void CvSVM::optimize_linear_svm()
-{
- // we optimize only linear SVM: compress all the support vectors into one.
- if( params.kernel_type != LINEAR )
- return;
-
- int class_count = class_labels ? class_labels->cols :
- params.svm_type == CvSVM::ONE_CLASS ? 1 : 0;
- int i, df_count = class_count > 1 ? class_count*(class_count-1)/2 : 1;
- CvSVMDecisionFunc* df = decision_func;
+ double r1 = nr_free1 > 0 ? sum_free1/nr_free1 : (ub1 + lb1)*0.5;
+ double r2 = nr_free2 > 0 ? sum_free2/nr_free2 : (ub2 + lb2)*0.5;
- for( i = 0; i < df_count; i++ )
- {
- int sv_count = df[i].sv_count;
- if( sv_count != 1 )
- break;
- }
-
- // if every decision functions uses a single support vector;
- // it's already compressed. skip it then.
- if( i == df_count )
- return;
-
- int var_count = get_var_count();
- cv::AutoBuffer<double> vbuf(var_count);
- double* v = vbuf;
- float** new_sv = (float**)cvMemStorageAlloc(storage, df_count*sizeof(new_sv[0]));
-
- for( i = 0; i < df_count; i++ )
- {
- new_sv[i] = (float*)cvMemStorageAlloc(storage, var_count*sizeof(new_sv[i][0]));
- float* dst = new_sv[i];
- memset(v, 0, var_count*sizeof(v[0]));
- int j, k, sv_count = df[i].sv_count;
- for( j = 0; j < sv_count; j++ )
- {
- const float* src = class_count > 1 && df[i].sv_index ? sv[df[i].sv_index[j]] : sv[j];
- double a = df[i].alpha[j];
- for( k = 0; k < var_count; k++ )
- v[k] += src[k]*a;
+ rho = (r1 - r2)*0.5;
+ r = (r1 + r2)*0.5;
}
- for( k = 0; k < var_count; k++ )
- dst[k] = (float)v[k];
- df[i].sv_count = 1;
- df[i].alpha[0] = 1.;
- if( class_count > 1 && df[i].sv_index )
- df[i].sv_index[0] = i;
- }
-
- sv = new_sv;
- sv_total = df_count;
-}
-
-
-bool CvSVM::train( const CvMat* _train_data, const CvMat* _responses,
- const CvMat* _var_idx, const CvMat* _sample_idx, CvSVMParams _params )
-{
- bool ok = false;
- CvMat* responses = 0;
- CvMemStorage* temp_storage = 0;
- const float** samples = 0;
-
- CV_FUNCNAME( "CvSVM::train" );
-
- __BEGIN__;
-
- int svm_type, sample_count, var_count, sample_size;
- int block_size = 1 << 16;
- double* alpha;
-
- clear();
- CV_CALL( set_params( _params ));
-
- svm_type = _params.svm_type;
-
- /* Prepare training data and related parameters */
- CV_CALL( cvPrepareTrainData( "CvSVM::train", _train_data, CV_ROW_SAMPLE,
- svm_type != CvSVM::ONE_CLASS ? _responses : 0,
- svm_type == CvSVM::C_SVC ||
- svm_type == CvSVM::NU_SVC ? CV_VAR_CATEGORICAL :
- CV_VAR_ORDERED, _var_idx, _sample_idx,
- false, &samples, &sample_count, &var_count, &var_all,
- &responses, &class_labels, &var_idx ));
-
-
- sample_size = var_count*sizeof(samples[0][0]);
-
- // make the storage block size large enough to fit all
- // the temporary vectors and output support vectors.
- block_size = MAX( block_size, sample_count*(int)sizeof(CvSVMKernelRow));
- block_size = MAX( block_size, sample_count*2*(int)sizeof(double) + 1024 );
- block_size = MAX( block_size, sample_size*2 + 1024 );
- CV_CALL( storage = cvCreateMemStorage(block_size + sizeof(CvMemBlock) + sizeof(CvSeqBlock)));
- CV_CALL( temp_storage = cvCreateChildMemStorage(storage));
- CV_CALL( alpha = (double*)cvMemStorageAlloc(temp_storage, sample_count*sizeof(double)));
+ /*
+ ///////////////////////// construct and solve various formulations ///////////////////////
+ */
+ static bool solve_c_svc( const Mat& _samples, const vector<schar>& _y,
+ double _Cp, double _Cn, const Ptr<SVM::Kernel>& _kernel,
+ vector<double>& _alpha, SolutionInfo& _si, TermCriteria termCrit )
+ {
+ int sample_count = _samples.rows;
- create_kernel();
- create_solver();
+ _alpha.assign(sample_count, 0.);
+ vector<double> _b(sample_count, -1.);
- if( !do_train( svm_type, sample_count, var_count, samples, responses, temp_storage, alpha ))
- EXIT;
+ Solver solver( _samples, _y, _alpha, _b, _Cp, _Cn, _kernel,
+ &Solver::get_row_svc,
+ &Solver::select_working_set,
+ &Solver::calc_rho,
+ termCrit );
- ok = true; // model has been trained succesfully
+ if( !solver.solve_generic( _si ))
+ return false;
- __END__;
+ for( int i = 0; i < sample_count; i++ )
+ _alpha[i] *= _y[i];
- delete solver;
- solver = 0;
- cvReleaseMemStorage( &temp_storage );
- cvReleaseMat( &responses );
- cvFree( &samples );
+ return true;
+ }
- if( cvGetErrStatus() < 0 || !ok )
- clear();
- return ok;
-}
+ static bool solve_nu_svc( const Mat& _samples, const vector<schar>& _y,
+ double nu, const Ptr<SVM::Kernel>& _kernel,
+ vector<double>& _alpha, SolutionInfo& _si,
+ TermCriteria termCrit )
+ {
+ int sample_count = _samples.rows;
-struct indexedratio
-{
- double val;
- int ind;
- int count_smallest, count_biggest;
- void eval() { val = (double) count_smallest/(count_smallest+count_biggest); }
-};
+ _alpha.resize(sample_count);
+ vector<double> _b(sample_count, 0.);
-static int CV_CDECL
-icvCmpIndexedratio( const void* a, const void* b )
-{
- return ((const indexedratio*)a)->val < ((const indexedratio*)b)->val ? -1
- : ((const indexedratio*)a)->val > ((const indexedratio*)b)->val ? 1
- : 0;
-}
+ double sum_pos = nu * sample_count * 0.5;
+ double sum_neg = nu * sample_count * 0.5;
-bool CvSVM::train_auto( const CvMat* _train_data, const CvMat* _responses,
- const CvMat* _var_idx, const CvMat* _sample_idx, CvSVMParams _params, int k_fold,
- CvParamGrid C_grid, CvParamGrid gamma_grid, CvParamGrid p_grid,
- CvParamGrid nu_grid, CvParamGrid coef_grid, CvParamGrid degree_grid,
- bool balanced)
-{
- bool ok = false;
- CvMat* responses = 0;
- CvMat* responses_local = 0;
- CvMemStorage* temp_storage = 0;
- const float** samples = 0;
- const float** samples_local = 0;
-
- CV_FUNCNAME( "CvSVM::train_auto" );
- __BEGIN__;
-
- int svm_type, sample_count, var_count, sample_size;
- int block_size = 1 << 16;
- double* alpha;
- RNG* rng = &theRNG();
-
- // all steps are logarithmic and must be > 1
- double degree_step = 10, g_step = 10, coef_step = 10, C_step = 10, nu_step = 10, p_step = 10;
- double gamma = 0, curr_c = 0, degree = 0, coef = 0, p = 0, nu = 0;
- double best_degree = 0, best_gamma = 0, best_coef = 0, best_C = 0, best_nu = 0, best_p = 0;
- float min_error = FLT_MAX, error;
-
- if( _params.svm_type == CvSVM::ONE_CLASS )
- {
- if(!train( _train_data, _responses, _var_idx, _sample_idx, _params ))
- EXIT;
- return true;
- }
+ for( int i = 0; i < sample_count; i++ )
+ {
+ double a;
+ if( _y[i] > 0 )
+ {
+ a = std::min(1.0, sum_pos);
+ sum_pos -= a;
+ }
+ else
+ {
+ a = std::min(1.0, sum_neg);
+ sum_neg -= a;
+ }
+ _alpha[i] = a;
+ }
- clear();
+ Solver solver( _samples, _y, _alpha, _b, 1., 1., _kernel,
+ &Solver::get_row_svc,
+ &Solver::select_working_set_nu_svm,
+ &Solver::calc_rho_nu_svm,
+ termCrit );
- if( k_fold < 2 )
- CV_ERROR( CV_StsBadArg, "Parameter <k_fold> must be > 1" );
+ if( !solver.solve_generic( _si ))
+ return false;
- CV_CALL(set_params( _params ));
- svm_type = _params.svm_type;
+ double inv_r = 1./_si.r;
- // All the parameters except, possibly, <coef0> are positive.
- // <coef0> is nonnegative
- if( C_grid.step <= 1 )
- {
- C_grid.min_val = C_grid.max_val = params.C;
- C_grid.step = 10;
- }
- else
- CV_CALL(C_grid.check());
+ for( int i = 0; i < sample_count; i++ )
+ _alpha[i] *= _y[i]*inv_r;
- if( gamma_grid.step <= 1 )
- {
- gamma_grid.min_val = gamma_grid.max_val = params.gamma;
- gamma_grid.step = 10;
- }
- else
- CV_CALL(gamma_grid.check());
+ _si.rho *= inv_r;
+ _si.obj *= (inv_r*inv_r);
+ _si.upper_bound_p = inv_r;
+ _si.upper_bound_n = inv_r;
- if( p_grid.step <= 1 )
- {
- p_grid.min_val = p_grid.max_val = params.p;
- p_grid.step = 10;
- }
- else
- CV_CALL(p_grid.check());
+ return true;
+ }
- if( nu_grid.step <= 1 )
- {
- nu_grid.min_val = nu_grid.max_val = params.nu;
- nu_grid.step = 10;
- }
- else
- CV_CALL(nu_grid.check());
+ static bool solve_one_class( const Mat& _samples, double nu,
+ const Ptr<SVM::Kernel>& _kernel,
+ vector<double>& _alpha, SolutionInfo& _si,
+ TermCriteria termCrit )
+ {
+ int sample_count = _samples.rows;
+ vector<schar> _y(sample_count, 1);
+ vector<double> _b(sample_count, 0.);
- if( coef_grid.step <= 1 )
- {
- coef_grid.min_val = coef_grid.max_val = params.coef0;
- coef_grid.step = 10;
- }
- else
- CV_CALL(coef_grid.check());
+ int i, n = cvRound( nu*sample_count );
- if( degree_grid.step <= 1 )
- {
- degree_grid.min_val = degree_grid.max_val = params.degree;
- degree_grid.step = 10;
- }
- else
- CV_CALL(degree_grid.check());
-
- // these parameters are not used:
- if( params.kernel_type != CvSVM::POLY )
- degree_grid.min_val = degree_grid.max_val = params.degree;
- if( params.kernel_type == CvSVM::LINEAR )
- gamma_grid.min_val = gamma_grid.max_val = params.gamma;
- if( params.kernel_type != CvSVM::POLY && params.kernel_type != CvSVM::SIGMOID )
- coef_grid.min_val = coef_grid.max_val = params.coef0;
- if( svm_type == CvSVM::NU_SVC || svm_type == CvSVM::ONE_CLASS )
- C_grid.min_val = C_grid.max_val = params.C;
- if( svm_type == CvSVM::C_SVC || svm_type == CvSVM::EPS_SVR )
- nu_grid.min_val = nu_grid.max_val = params.nu;
- if( svm_type != CvSVM::EPS_SVR )
- p_grid.min_val = p_grid.max_val = params.p;
-
- CV_ASSERT( g_step > 1 && degree_step > 1 && coef_step > 1);
- CV_ASSERT( p_step > 1 && C_step > 1 && nu_step > 1 );
-
- /* Prepare training data and related parameters */
- CV_CALL(cvPrepareTrainData( "CvSVM::train_auto", _train_data, CV_ROW_SAMPLE,
- svm_type != CvSVM::ONE_CLASS ? _responses : 0,
- svm_type == CvSVM::C_SVC ||
- svm_type == CvSVM::NU_SVC ? CV_VAR_CATEGORICAL :
- CV_VAR_ORDERED, _var_idx, _sample_idx,
- false, &samples, &sample_count, &var_count, &var_all,
- &responses, &class_labels, &var_idx ));
-
- sample_size = var_count*sizeof(samples[0][0]);
-
- // make the storage block size large enough to fit all
- // the temporary vectors and output support vectors.
- block_size = MAX( block_size, sample_count*(int)sizeof(CvSVMKernelRow));
- block_size = MAX( block_size, sample_count*2*(int)sizeof(double) + 1024 );
- block_size = MAX( block_size, sample_size*2 + 1024 );
-
- CV_CALL( storage = cvCreateMemStorage(block_size + sizeof(CvMemBlock) + sizeof(CvSeqBlock)));
- CV_CALL(temp_storage = cvCreateChildMemStorage(storage));
- CV_CALL(alpha = (double*)cvMemStorageAlloc(temp_storage, sample_count*sizeof(double)));
-
- create_kernel();
- create_solver();
+ _alpha.resize(sample_count);
+ for( i = 0; i < sample_count; i++ )
+ _alpha[i] = i < n ? 1 : 0;
- {
- const int testset_size = sample_count/k_fold;
- const int trainset_size = sample_count - testset_size;
- const int last_testset_size = sample_count - testset_size*(k_fold-1);
- const int last_trainset_size = sample_count - last_testset_size;
- const bool is_regression = (svm_type == EPS_SVR) || (svm_type == NU_SVR);
+ if( n < sample_count )
+ _alpha[n] = nu * sample_count - n;
+ else
+ _alpha[n-1] = nu * sample_count - (n-1);
- size_t resp_elem_size = CV_ELEM_SIZE(responses->type);
- size_t size = 2*last_trainset_size*sizeof(samples[0]);
+ Solver solver( _samples, _y, _alpha, _b, 1., 1., _kernel,
+ &Solver::get_row_one_class,
+ &Solver::select_working_set,
+ &Solver::calc_rho,
+ termCrit );
- samples_local = (const float**) cvAlloc( size );
- memset( samples_local, 0, size );
+ return solver.solve_generic(_si);
+ }
- responses_local = cvCreateMat( 1, trainset_size, CV_MAT_TYPE(responses->type) );
- cvZero( responses_local );
+ static bool solve_eps_svr( const Mat& _samples, const vector<float>& _yf,
+ double p, double C, const Ptr<SVM::Kernel>& _kernel,
+ vector<double>& _alpha, SolutionInfo& _si,
+ TermCriteria termCrit )
+ {
+ int sample_count = _samples.rows;
+ int alpha_count = sample_count*2;
- // randomly permute samples and responses
- for(int i = 0; i < sample_count; i++ )
- {
- int i1 = (*rng)(sample_count);
- int i2 = (*rng)(sample_count);
- const float* temp;
- float t;
- int y;
-
- CV_SWAP( samples[i1], samples[i2], temp );
- if( is_regression )
- CV_SWAP( responses->data.fl[i1], responses->data.fl[i2], t );
- else
- CV_SWAP( responses->data.i[i1], responses->data.i[i2], y );
- }
+ CV_Assert( (int)_yf.size() == sample_count );
- if (!is_regression && class_labels->cols==2 && balanced)
- {
- // count class samples
- int num_0=0,num_1=0;
- for (int i=0; i<sample_count; ++i)
- {
- if (responses->data.i[i]==class_labels->data.i[0])
- ++num_0;
- else
- ++num_1;
- }
+ _alpha.assign(alpha_count, 0.);
+ vector<schar> _y(alpha_count);
+ vector<double> _b(alpha_count);
- int label_smallest_class;
- int label_biggest_class;
- if (num_0 < num_1)
- {
- label_biggest_class = class_labels->data.i[1];
- label_smallest_class = class_labels->data.i[0];
- }
- else
- {
- label_biggest_class = class_labels->data.i[0];
- label_smallest_class = class_labels->data.i[1];
- int y;
- CV_SWAP(num_0,num_1,y);
- }
- const double class_ratio = (double) num_0/sample_count;
- // calculate class ratio of each fold
- indexedratio *ratios=0;
- ratios = (indexedratio*) cvAlloc(k_fold*sizeof(*ratios));
- for (int k=0, i_begin=0; k<k_fold; ++k, i_begin+=testset_size)
- {
- int count0=0;
- int count1=0;
- int i_end = i_begin + (k<k_fold-1 ? testset_size : last_testset_size);
- for (int i=i_begin; i<i_end; ++i)
+ for( int i = 0; i < sample_count; i++ )
{
- if (responses->data.i[i]==label_smallest_class)
- ++count0;
- else
- ++count1;
- }
- ratios[k].ind = k;
- ratios[k].count_smallest = count0;
- ratios[k].count_biggest = count1;
- ratios[k].eval();
- }
- // initial distance
- qsort(ratios, k_fold, sizeof(ratios[0]), icvCmpIndexedratio);
- double old_dist = 0.0;
- for (int k=0; k<k_fold; ++k)
- old_dist += cv::abs(ratios[k].val-class_ratio);
- double new_dist = 1.0;
- // iterate to make the folds more balanced
- while (new_dist > 0.0)
- {
- if (ratios[0].count_biggest==0 || ratios[k_fold-1].count_smallest==0)
- break; // we are not able to swap samples anymore
- // what if we swap the samples, calculate the new distance
- ratios[0].count_smallest++;
- ratios[0].count_biggest--;
- ratios[0].eval();
- ratios[k_fold-1].count_smallest--;
- ratios[k_fold-1].count_biggest++;
- ratios[k_fold-1].eval();
- qsort(ratios, k_fold, sizeof(ratios[0]), icvCmpIndexedratio);
- new_dist = 0.0;
- for (int k=0; k<k_fold; ++k)
- new_dist += cv::abs(ratios[k].val-class_ratio);
- if (new_dist < old_dist)
- {
- // swapping really improves, so swap the samples
- // index of the biggest_class sample from the minimum ratio fold
- int i1 = ratios[0].ind * testset_size;
- for ( ; i1<sample_count; ++i1)
- {
- if (responses->data.i[i1]==label_biggest_class)
- break;
- }
- // index of the smallest_class sample from the maximum ratio fold
- int i2 = ratios[k_fold-1].ind * testset_size;
- for ( ; i2<sample_count; ++i2)
- {
- if (responses->data.i[i2]==label_smallest_class)
- break;
- }
- // swap
- const float* temp;
- int y;
- CV_SWAP( samples[i1], samples[i2], temp );
- CV_SWAP( responses->data.i[i1], responses->data.i[i2], y );
- old_dist = new_dist;
- }
- else
- break; // does not improve, so break the loop
- }
- cvFree(&ratios);
- }
+ _b[i] = p - _yf[i];
+ _y[i] = 1;
- int* cls_lbls = class_labels ? class_labels->data.i : 0;
- curr_c = C_grid.min_val;
- do
- {
- params.C = curr_c;
- gamma = gamma_grid.min_val;
- do
- {
- params.gamma = gamma;
- p = p_grid.min_val;
- do
- {
- params.p = p;
- nu = nu_grid.min_val;
- do
- {
- params.nu = nu;
- coef = coef_grid.min_val;
- do
- {
- params.coef0 = coef;
- degree = degree_grid.min_val;
- do
- {
- params.degree = degree;
-
- float** test_samples_ptr = (float**)samples;
- uchar* true_resp = responses->data.ptr;
- int test_size = testset_size;
- int train_size = trainset_size;
-
- error = 0;
- for(int k = 0; k < k_fold; k++ )
- {
- memcpy( samples_local, samples, sizeof(samples[0])*test_size*k );
- memcpy( samples_local + test_size*k, test_samples_ptr + test_size,
- sizeof(samples[0])*(sample_count - testset_size*(k+1)) );
+ _b[i+sample_count] = p + _yf[i];
+ _y[i+sample_count] = -1;
+ }
- memcpy( responses_local->data.ptr, responses->data.ptr, resp_elem_size*test_size*k );
- memcpy( responses_local->data.ptr + resp_elem_size*test_size*k,
- true_resp + resp_elem_size*test_size,
- resp_elem_size*(sample_count - testset_size*(k+1)) );
+ Solver solver( _samples, _y, _alpha, _b, C, C, _kernel,
+ &Solver::get_row_svr,
+ &Solver::select_working_set,
+ &Solver::calc_rho,
+ termCrit );
- if( k == k_fold - 1 )
- {
- test_size = last_testset_size;
- train_size = last_trainset_size;
- responses_local->cols = last_trainset_size;
- }
+ if( !solver.solve_generic( _si ))
+ return false;
- // Train SVM on <train_size> samples
- if( !do_train( svm_type, train_size, var_count,
- (const float**)samples_local, responses_local, temp_storage, alpha ) )
- EXIT;
+ for( int i = 0; i < sample_count; i++ )
+ _alpha[i] -= _alpha[i+sample_count];
- // Compute test set error on <test_size> samples
- for(int i = 0; i < test_size; i++, true_resp += resp_elem_size, test_samples_ptr++ )
- {
- float resp = predict( *test_samples_ptr, var_count );
- error += is_regression ? powf( resp - *(float*)true_resp, 2 )
- : ((int)resp != cls_lbls[*(int*)true_resp]);
- }
- }
- if( min_error > error )
- {
- min_error = error;
- best_degree = degree;
- best_gamma = gamma;
- best_coef = coef;
- best_C = curr_c;
- best_nu = nu;
- best_p = p;
- }
- degree *= degree_grid.step;
- }
- while( degree < degree_grid.max_val );
- coef *= coef_grid.step;
- }
- while( coef < coef_grid.max_val );
- nu *= nu_grid.step;
- }
- while( nu < nu_grid.max_val );
- p *= p_grid.step;
+ return true;
}
- while( p < p_grid.max_val );
- gamma *= gamma_grid.step;
- }
- while( gamma < gamma_grid.max_val );
- curr_c *= C_grid.step;
- }
- while( curr_c < C_grid.max_val );
- }
- min_error /= (float) sample_count;
- params.C = best_C;
- params.nu = best_nu;
- params.p = best_p;
- params.gamma = best_gamma;
- params.degree = best_degree;
- params.coef0 = best_coef;
+ static bool solve_nu_svr( const Mat& _samples, const vector<float>& _yf,
+ double nu, double C, const Ptr<SVM::Kernel>& _kernel,
+ vector<double>& _alpha, SolutionInfo& _si,
+ TermCriteria termCrit )
+ {
+ int sample_count = _samples.rows;
+ int alpha_count = sample_count*2;
+ double sum = C * nu * sample_count * 0.5;
- CV_CALL(ok = do_train( svm_type, sample_count, var_count, samples, responses, temp_storage, alpha ));
+ CV_Assert( (int)_yf.size() == sample_count );
- __END__;
+ _alpha.resize(alpha_count);
+ vector<schar> _y(alpha_count);
+ vector<double> _b(alpha_count);
- delete solver;
- solver = 0;
- cvReleaseMemStorage( &temp_storage );
- cvReleaseMat( &responses );
- cvReleaseMat( &responses_local );
- cvFree( &samples );
- cvFree( &samples_local );
+ for( int i = 0; i < sample_count; i++ )
+ {
+ _alpha[i] = _alpha[i + sample_count] = std::min(sum, C);
+ sum -= _alpha[i];
- if( cvGetErrStatus() < 0 || !ok )
- clear();
+ _b[i] = -_yf[i];
+ _y[i] = 1;
- return ok;
-}
+ _b[i + sample_count] = _yf[i];
+ _y[i + sample_count] = -1;
+ }
-float CvSVM::predict( const float* row_sample, int row_len, bool returnDFVal ) const
-{
- assert( kernel );
- assert( row_sample );
+ Solver solver( _samples, _y, _alpha, _b, 1., 1., _kernel,
+ &Solver::get_row_svr,
+ &Solver::select_working_set_nu_svm,
+ &Solver::calc_rho_nu_svm,
+ termCrit );
- int var_count = get_var_count();
- assert( row_len == var_count );
- (void)row_len;
+ if( !solver.solve_generic( _si ))
+ return false;
- int class_count = class_labels ? class_labels->cols :
- params.svm_type == ONE_CLASS ? 1 : 0;
+ for( int i = 0; i < sample_count; i++ )
+ _alpha[i] -= _alpha[i+sample_count];
- float result = 0;
- cv::AutoBuffer<float> _buffer(sv_total + (class_count+1)*2);
- float* buffer = _buffer;
+ return true;
+ }
- if( params.svm_type == EPS_SVR ||
- params.svm_type == NU_SVR ||
- params.svm_type == ONE_CLASS )
+ int sample_count;
+ int var_count;
+ int cache_size;
+ int max_cache_size;
+ Mat samples;
+ SVM::Params params;
+ vector<KernelRow> lru_cache;
+ int lru_first;
+ int lru_last;
+ Mat lru_cache_data;
+
+ int alpha_count;
+
+ vector<double> G_vec;
+ vector<double>* alpha_vec;
+ vector<schar> y_vec;
+ // -1 - lower bound, 0 - free, 1 - upper bound
+ vector<schar> alpha_status_vec;
+ vector<double> b_vec;
+
+ vector<Qfloat> buf[2];
+ double eps;
+ int max_iter;
+ double C[2]; // C[0] == Cn, C[1] == Cp
+ Ptr<SVM::Kernel> kernel;
+
+ SelectWorkingSet select_working_set_func;
+ CalcRho calc_rho_func;
+ GetRow get_row_func;
+ };
+
+ //////////////////////////////////////////////////////////////////////////////////////////
+ SVMImpl()
{
- CvSVMDecisionFunc* df = (CvSVMDecisionFunc*)decision_func;
- int i, sv_count = df->sv_count;
- double sum = -df->rho;
-
- kernel->calc( sv_count, var_count, (const float**)sv, row_sample, buffer );
- for( i = 0; i < sv_count; i++ )
- sum += buffer[i]*df->alpha[i];
-
- result = params.svm_type == ONE_CLASS ? (float)(sum > 0) : (float)sum;
+ clear();
}
- else if( params.svm_type == C_SVC ||
- params.svm_type == NU_SVC )
+
+ ~SVMImpl()
{
- CvSVMDecisionFunc* df = (CvSVMDecisionFunc*)decision_func;
- int* vote = (int*)(buffer + sv_total);
- int i, j, k;
+ clear();
+ }
- memset( vote, 0, class_count*sizeof(vote[0]));
- kernel->calc( sv_total, var_count, (const float**)sv, row_sample, buffer );
- double sum = 0.;
+ void clear()
+ {
+ decision_func.clear();
+ df_alpha.clear();
+ df_index.clear();
+ sv.release();
+ }
- for( i = 0; i < class_count; i++ )
- {
- for( j = i+1; j < class_count; j++, df++ )
- {
- sum = -df->rho;
- int sv_count = df->sv_count;
- for( k = 0; k < sv_count; k++ )
- sum += df->alpha[k]*buffer[df->sv_index[k]];
+ Mat getSupportVectors() const
+ {
+ return sv;
+ }
- vote[sum > 0 ? i : j]++;
- }
- }
+ void setParams( const Params& _params, const Ptr<Kernel>& _kernel )
+ {
+ params = _params;
- for( i = 1, k = 0; i < class_count; i++ )
- {
- if( vote[i] > vote[k] )
- k = i;
- }
- result = returnDFVal && class_count == 2 ? (float)sum : (float)(class_labels->data.i[k]);
- }
- else
- CV_Error( CV_StsBadArg, "INTERNAL ERROR: Unknown SVM type, "
- "the SVM structure is probably corrupted" );
+ int kernelType = params.kernelType;
+ int svmType = params.svmType;
- return result;
-}
+ if( kernelType != LINEAR && kernelType != POLY &&
+ kernelType != SIGMOID && kernelType != RBF &&
+ kernelType != INTER && kernelType != CHI2)
+ CV_Error( CV_StsBadArg, "Unknown/unsupported kernel type" );
-float CvSVM::predict( const CvMat* sample, bool returnDFVal ) const
-{
- float result = 0;
- float* row_sample = 0;
+ if( kernelType == LINEAR )
+ params.gamma = 1;
+ else if( params.gamma <= 0 )
+ CV_Error( CV_StsOutOfRange, "gamma parameter of the kernel must be positive" );
- CV_FUNCNAME( "CvSVM::predict" );
+ if( kernelType != SIGMOID && kernelType != POLY )
+ params.coef0 = 0;
+ else if( params.coef0 < 0 )
+ CV_Error( CV_StsOutOfRange, "The kernel parameter <coef0> must be positive or zero" );
- __BEGIN__;
+ if( kernelType != POLY )
+ params.degree = 0;
+ else if( params.degree <= 0 )
+ CV_Error( CV_StsOutOfRange, "The kernel parameter <degree> must be positive" );
- int class_count;
+ if( svmType != C_SVC && svmType != NU_SVC &&
+ svmType != ONE_CLASS && svmType != EPS_SVR &&
+ svmType != NU_SVR )
+ CV_Error( CV_StsBadArg, "Unknown/unsupported SVM type" );
- if( !kernel )
- CV_ERROR( CV_StsBadArg, "The SVM should be trained first" );
+ if( svmType == ONE_CLASS || svmType == NU_SVC )
+ params.C = 0;
+ else if( params.C <= 0 )
+ CV_Error( CV_StsOutOfRange, "The parameter C must be positive" );
- class_count = class_labels ? class_labels->cols :
- params.svm_type == ONE_CLASS ? 1 : 0;
+ if( svmType == C_SVC || svmType == EPS_SVR )
+ params.nu = 0;
+ else if( params.nu <= 0 || params.nu >= 1 )
+ CV_Error( CV_StsOutOfRange, "The parameter nu must be between 0 and 1" );
- CV_CALL( cvPreparePredictData( sample, var_all, var_idx,
- class_count, 0, &row_sample ));
- result = predict( row_sample, get_var_count(), returnDFVal );
+ if( svmType != EPS_SVR )
+ params.p = 0;
+ else if( params.p <= 0 )
+ CV_Error( CV_StsOutOfRange, "The parameter p must be positive" );
- __END__;
+ if( svmType != C_SVC )
+ params.classWeights.release();
- if( sample && (!CV_IS_MAT(sample) || sample->data.fl != row_sample) )
- cvFree( &row_sample );
+ termCrit = params.termCrit;
+ if( !(termCrit.type & TermCriteria::EPS) )
+ termCrit.epsilon = DBL_EPSILON;
+ termCrit.epsilon = std::max(termCrit.epsilon, DBL_EPSILON);
+ if( !(termCrit.type & TermCriteria::COUNT) )
+ termCrit.maxCount = INT_MAX;
+ termCrit.maxCount = std::max(termCrit.maxCount, 1);
- return result;
-}
+ if( _kernel )
+ kernel = _kernel;
+ else
+ kernel = makePtr<SVMKernelImpl>(params);
+ }
-struct predict_body_svm : ParallelLoopBody {
- predict_body_svm(const CvSVM* _pointer, float* _result, const CvMat* _samples, CvMat* _results, bool _returnDFVal)
+ Params getParams() const
{
- pointer = _pointer;
- result = _result;
- samples = _samples;
- results = _results;
- returnDFVal = _returnDFVal;
+ return params;
}
- const CvSVM* pointer;
- float* result;
- const CvMat* samples;
- CvMat* results;
- bool returnDFVal;
-
- void operator()( const cv::Range& range ) const
+ Ptr<Kernel> getKernel() const
{
- for(int i = range.start; i < range.end; i++ )
- {
- CvMat sample;
- cvGetRow( samples, &sample, i );
- int r = (int)pointer->predict(&sample, returnDFVal);
- if (results)
- results->data.fl[i] = (float)r;
- if (i == 0)
- *result = (float)r;
+ return kernel;
}
+
+ int getSVCount(int i) const
+ {
+ return (i < (int)(decision_func.size()-1) ? decision_func[i+1].ofs :
+ (int)df_index.size()) - decision_func[i].ofs;
}
-};
-float CvSVM::predict(const CvMat* samples, CV_OUT CvMat* results, bool returnDFVal) const
-{
- float result = 0;
- cv::parallel_for_(cv::Range(0, samples->rows),
- predict_body_svm(this, &result, samples, results, returnDFVal)
- );
- return result;
-}
+ bool do_train( const Mat& _samples, const Mat& _responses )
+ {
+ int svmType = params.svmType;
+ int i, j, k, sample_count = _samples.rows;
+ vector<double> _alpha;
+ Solver::SolutionInfo sinfo;
-void CvSVM::predict( cv::InputArray _samples, cv::OutputArray _results ) const
-{
- _results.create(_samples.size().height, 1, CV_32F);
- CvMat samples = _samples.getMat(), results = _results.getMat();
- predict(&samples, &results);
-}
+ CV_Assert( _samples.type() == CV_32F );
+ var_count = _samples.cols;
-CvSVM::CvSVM( const Mat& _train_data, const Mat& _responses,
- const Mat& _var_idx, const Mat& _sample_idx, CvSVMParams _params )
-{
- decision_func = 0;
- class_labels = 0;
- class_weights = 0;
- storage = 0;
- var_idx = 0;
- kernel = 0;
- solver = 0;
- default_model_name = "my_svm";
-
- train( _train_data, _responses, _var_idx, _sample_idx, _params );
-}
+ if( svmType == ONE_CLASS || svmType == EPS_SVR || svmType == NU_SVR )
+ {
+ int sv_count = 0;
+ decision_func.clear();
-bool CvSVM::train( const Mat& _train_data, const Mat& _responses,
- const Mat& _var_idx, const Mat& _sample_idx, CvSVMParams _params )
-{
- CvMat tdata = _train_data, responses = _responses, vidx = _var_idx, sidx = _sample_idx;
- return train(&tdata, &responses, vidx.data.ptr ? &vidx : 0, sidx.data.ptr ? &sidx : 0, _params);
-}
+ vector<float> _yf;
+ if( !_responses.empty() )
+ _responses.convertTo(_yf, CV_32F);
+ bool ok =
+ (svmType == ONE_CLASS ? Solver::solve_one_class( _samples, params.nu, kernel, _alpha, sinfo, termCrit ) :
+ svmType == EPS_SVR ? Solver::solve_eps_svr( _samples, _yf, params.p, params.C, kernel, _alpha, sinfo, termCrit ) :
+ svmType == NU_SVR ? Solver::solve_nu_svr( _samples, _yf, params.nu, params.C, kernel, _alpha, sinfo, termCrit ) : false);
-bool CvSVM::train_auto( const Mat& _train_data, const Mat& _responses,
- const Mat& _var_idx, const Mat& _sample_idx, CvSVMParams _params, int k_fold,
- CvParamGrid C_grid, CvParamGrid gamma_grid, CvParamGrid p_grid,
- CvParamGrid nu_grid, CvParamGrid coef_grid, CvParamGrid degree_grid, bool balanced )
-{
- CvMat tdata = _train_data, responses = _responses, vidx = _var_idx, sidx = _sample_idx;
- return train_auto(&tdata, &responses, vidx.data.ptr ? &vidx : 0,
- sidx.data.ptr ? &sidx : 0, _params, k_fold, C_grid, gamma_grid, p_grid,
- nu_grid, coef_grid, degree_grid, balanced);
-}
+ if( !ok )
+ return false;
-float CvSVM::predict( const Mat& _sample, bool returnDFVal ) const
-{
- CvMat sample = _sample;
- return predict(&sample, returnDFVal);
-}
+ for( i = 0; i < sample_count; i++ )
+ sv_count += fabs(_alpha[i]) > 0;
+ CV_Assert(sv_count != 0);
-void CvSVM::write_params( CvFileStorage* fs ) const
-{
- //CV_FUNCNAME( "CvSVM::write_params" );
+ sv.create(sv_count, _samples.cols, CV_32F);
+ df_alpha.resize(sv_count);
+ df_index.resize(sv_count);
- __BEGIN__;
+ for( i = k = 0; i < sample_count; i++ )
+ {
+ if( std::abs(_alpha[i]) > 0 )
+ {
+ _samples.row(i).copyTo(sv.row(k));
+ df_alpha[k] = _alpha[i];
+ df_index[k] = k;
+ k++;
+ }
+ }
- int svm_type = params.svm_type;
- int kernel_type = params.kernel_type;
+ decision_func.push_back(DecisionFunc(sinfo.rho, 0));
+ }
+ else
+ {
+ int class_count = (int)class_labels.total();
+ vector<int> svidx, sidx, sidx_all, sv_tab(sample_count, 0);
+ Mat temp_samples, class_weights;
+ vector<int> class_ranges;
+ vector<schar> temp_y;
+ double nu = params.nu;
+ CV_Assert( svmType == C_SVC || svmType == NU_SVC );
+
+ if( svmType == C_SVC && !params.classWeights.empty() )
+ {
+ const Mat cw = params.classWeights;
- const char* svm_type_str =
- svm_type == CvSVM::C_SVC ? "C_SVC" :
- svm_type == CvSVM::NU_SVC ? "NU_SVC" :
- svm_type == CvSVM::ONE_CLASS ? "ONE_CLASS" :
- svm_type == CvSVM::EPS_SVR ? "EPS_SVR" :
- svm_type == CvSVM::NU_SVR ? "NU_SVR" : 0;
- const char* kernel_type_str =
- kernel_type == CvSVM::LINEAR ? "LINEAR" :
- kernel_type == CvSVM::POLY ? "POLY" :
- kernel_type == CvSVM::RBF ? "RBF" :
- kernel_type == CvSVM::SIGMOID ? "SIGMOID" : 0;
+ if( (cw.cols != 1 && cw.rows != 1) ||
+ (int)cw.total() != class_count ||
+ (cw.type() != CV_32F && cw.type() != CV_64F) )
+ CV_Error( CV_StsBadArg, "params.class_weights must be 1d floating-point vector "
+ "containing as many elements as the number of classes" );
- if( svm_type_str )
- cvWriteString( fs, "svm_type", svm_type_str );
- else
- cvWriteInt( fs, "svm_type", svm_type );
+ cw.convertTo(class_weights, CV_64F, params.C);
+ //normalize(cw, class_weights, params.C, 0, NORM_L1, CV_64F);
+ }
- // save kernel
- cvStartWriteStruct( fs, "kernel", CV_NODE_MAP + CV_NODE_FLOW );
+ decision_func.clear();
+ df_alpha.clear();
+ df_index.clear();
- if( kernel_type_str )
- cvWriteString( fs, "type", kernel_type_str );
- else
- cvWriteInt( fs, "type", kernel_type );
+ sortSamplesByClasses( _samples, _responses, sidx_all, class_ranges );
- if( kernel_type == CvSVM::POLY || !kernel_type_str )
- cvWriteReal( fs, "degree", params.degree );
+ //check that while cross-validation there were the samples from all the classes
+ if( class_ranges[class_count] <= 0 )
+ CV_Error( CV_StsBadArg, "While cross-validation one or more of the classes have "
+ "been fell out of the sample. Try to enlarge <CvSVMParams::k_fold>" );
- if( kernel_type != CvSVM::LINEAR || !kernel_type_str )
- cvWriteReal( fs, "gamma", params.gamma );
+ if( svmType == NU_SVC )
+ {
+ // check if nu is feasible
+ for( i = 0; i < class_count; i++ )
+ {
+ int ci = class_ranges[i+1] - class_ranges[i];
+ for( j = i+1; j< class_count; j++ )
+ {
+ int cj = class_ranges[j+1] - class_ranges[j];
+ if( nu*(ci + cj)*0.5 > std::min( ci, cj ) )
+ // TODO: add some diagnostic
+ return false;
+ }
+ }
+ }
- if( kernel_type == CvSVM::POLY || kernel_type == CvSVM::SIGMOID || !kernel_type_str )
- cvWriteReal( fs, "coef0", params.coef0 );
+ size_t samplesize = _samples.cols*_samples.elemSize();
- cvEndWriteStruct(fs);
+ // train n*(n-1)/2 classifiers
+ for( i = 0; i < class_count; i++ )
+ {
+ for( j = i+1; j < class_count; j++ )
+ {
+ int si = class_ranges[i], ci = class_ranges[i+1] - si;
+ int sj = class_ranges[j], cj = class_ranges[j+1] - sj;
+ double Cp = params.C, Cn = Cp;
- if( svm_type == CvSVM::C_SVC || svm_type == CvSVM::EPS_SVR ||
- svm_type == CvSVM::NU_SVR || !svm_type_str )
- cvWriteReal( fs, "C", params.C );
+ temp_samples.create(ci + cj, _samples.cols, _samples.type());
+ sidx.resize(ci + cj);
+ temp_y.resize(ci + cj);
- if( svm_type == CvSVM::NU_SVC || svm_type == CvSVM::ONE_CLASS ||
- svm_type == CvSVM::NU_SVR || !svm_type_str )
- cvWriteReal( fs, "nu", params.nu );
+ // form input for the binary classification problem
+ for( k = 0; k < ci+cj; k++ )
+ {
+ int idx = k < ci ? si+k : sj+k-ci;
+ memcpy(temp_samples.ptr(k), _samples.ptr(sidx_all[idx]), samplesize);
+ sidx[k] = sidx_all[idx];
+ temp_y[k] = k < ci ? 1 : -1;
+ }
- if( svm_type == CvSVM::EPS_SVR || !svm_type_str )
- cvWriteReal( fs, "p", params.p );
+ if( !class_weights.empty() )
+ {
+ Cp = class_weights.at<double>(i);
+ Cn = class_weights.at<double>(j);
+ }
- cvStartWriteStruct( fs, "term_criteria", CV_NODE_MAP + CV_NODE_FLOW );
- if( params.term_crit.type & CV_TERMCRIT_EPS )
- cvWriteReal( fs, "epsilon", params.term_crit.epsilon );
- if( params.term_crit.type & CV_TERMCRIT_ITER )
- cvWriteInt( fs, "iterations", params.term_crit.max_iter );
- cvEndWriteStruct( fs );
+ DecisionFunc df;
+ bool ok = params.svmType == C_SVC ?
+ Solver::solve_c_svc( temp_samples, temp_y, Cp, Cn,
+ kernel, _alpha, sinfo, termCrit ) :
+ params.svmType == NU_SVC ?
+ Solver::solve_nu_svc( temp_samples, temp_y, params.nu,
+ kernel, _alpha, sinfo, termCrit ) :
+ false;
+ if( !ok )
+ return false;
+ df.rho = sinfo.rho;
+ df.ofs = (int)df_index.size();
+ decision_func.push_back(df);
+
+ for( k = 0; k < ci + cj; k++ )
+ {
+ if( std::abs(_alpha[k]) > 0 )
+ {
+ int idx = k < ci ? si+k : sj+k-ci;
+ sv_tab[sidx_all[idx]] = 1;
+ df_index.push_back(sidx_all[idx]);
+ df_alpha.push_back(_alpha[k]);
+ }
+ }
+ }
+ }
- __END__;
-}
+ // allocate support vectors and initialize sv_tab
+ for( i = 0, k = 0; i < sample_count; i++ )
+ {
+ if( sv_tab[i] )
+ sv_tab[i] = ++k;
+ }
+ int sv_total = k;
+ sv.create(sv_total, _samples.cols, _samples.type());
-static bool isSvmModelApplicable(int sv_total, int var_all, int var_count, int class_count)
-{
- return (sv_total > 0 && var_count > 0 && var_count <= var_all && class_count >= 0);
-}
+ for( i = 0; i < sample_count; i++ )
+ {
+ if( !sv_tab[i] )
+ continue;
+ memcpy(sv.ptr(sv_tab[i]-1), _samples.ptr(i), samplesize);
+ }
+ // set sv pointers
+ int n = (int)df_index.size();
+ for( i = 0; i < n; i++ )
+ {
+ CV_Assert( sv_tab[df_index[i]] > 0 );
+ df_index[i] = sv_tab[df_index[i]] - 1;
+ }
+ }
-void CvSVM::write( CvFileStorage* fs, const char* name ) const
-{
- CV_FUNCNAME( "CvSVM::write" );
+ optimize_linear_svm();
+ return true;
+ }
- __BEGIN__;
+ void optimize_linear_svm()
+ {
+ // we optimize only linear SVM: compress all the support vectors into one.
+ if( params.kernelType != LINEAR )
+ return;
- int i, var_count = get_var_count(), df_count;
- int class_count = class_labels ? class_labels->cols :
- params.svm_type == CvSVM::ONE_CLASS ? 1 : 0;
- const CvSVMDecisionFunc* df = decision_func;
- if( !isSvmModelApplicable(sv_total, var_all, var_count, class_count) )
- CV_ERROR( CV_StsParseError, "SVM model data is invalid, check sv_count, var_* and class_count tags" );
+ int i, df_count = (int)decision_func.size();
- cvStartWriteStruct( fs, name, CV_NODE_MAP, CV_TYPE_NAME_ML_SVM );
+ for( i = 0; i < df_count; i++ )
+ {
+ if( getSVCount(i) != 1 )
+ break;
+ }
- write_params( fs );
+ // if every decision functions uses a single support vector;
+ // it's already compressed. skip it then.
+ if( i == df_count )
+ return;
- cvWriteInt( fs, "var_all", var_all );
- cvWriteInt( fs, "var_count", var_count );
+ AutoBuffer<double> vbuf(var_count);
+ double* v = vbuf;
+ Mat new_sv(df_count, var_count, CV_32F);
- if( class_count )
- {
- cvWriteInt( fs, "class_count", class_count );
+ vector<DecisionFunc> new_df;
- if( class_labels )
- cvWrite( fs, "class_labels", class_labels );
+ for( i = 0; i < df_count; i++ )
+ {
+ float* dst = new_sv.ptr<float>(i);
+ memset(v, 0, var_count*sizeof(v[0]));
+ int j, k, sv_count = getSVCount(i);
+ const DecisionFunc& df = decision_func[i];
+ const int* sv_index = &df_index[df.ofs];
+ const double* sv_alpha = &df_alpha[df.ofs];
+ for( j = 0; j < sv_count; j++ )
+ {
+ const float* src = sv.ptr<float>(sv_index[j]);
+ double a = sv_alpha[j];
+ for( k = 0; k < var_count; k++ )
+ v[k] += src[k]*a;
+ }
+ for( k = 0; k < var_count; k++ )
+ dst[k] = (float)v[k];
+ new_df.push_back(DecisionFunc(df.rho, i));
+ }
- if( class_weights )
- cvWrite( fs, "class_weights", class_weights );
+ setRangeVector(df_index, df_count);
+ df_alpha.assign(df_count, 1.);
+ std::swap(sv, new_sv);
+ std::swap(decision_func, new_df);
}
- if( var_idx )
- cvWrite( fs, "var_idx", var_idx );
-
- // write the joint collection of support vectors
- cvWriteInt( fs, "sv_total", sv_total );
- cvStartWriteStruct( fs, "support_vectors", CV_NODE_SEQ );
- for( i = 0; i < sv_total; i++ )
+ bool train( const Ptr<TrainData>& data, int )
{
- cvStartWriteStruct( fs, 0, CV_NODE_SEQ + CV_NODE_FLOW );
- cvWriteRawData( fs, sv[i], var_count, "f" );
- cvEndWriteStruct( fs );
- }
-
- cvEndWriteStruct( fs );
+ clear();
- // write decision functions
- df_count = class_count > 1 ? class_count*(class_count-1)/2 : 1;
- df = decision_func;
+ int svmType = params.svmType;
+ Mat samples = data->getTrainSamples();
+ Mat responses;
- cvStartWriteStruct( fs, "decision_functions", CV_NODE_SEQ );
- for( i = 0; i < df_count; i++ )
- {
- int sv_count = df[i].sv_count;
- cvStartWriteStruct( fs, 0, CV_NODE_MAP );
- cvWriteInt( fs, "sv_count", sv_count );
- cvWriteReal( fs, "rho", df[i].rho );
- cvStartWriteStruct( fs, "alpha", CV_NODE_SEQ+CV_NODE_FLOW );
- cvWriteRawData( fs, df[i].alpha, df[i].sv_count, "d" );
- cvEndWriteStruct( fs );
- if( class_count > 1 )
+ if( svmType == C_SVC || svmType == NU_SVC )
{
- cvStartWriteStruct( fs, "index", CV_NODE_SEQ+CV_NODE_FLOW );
- cvWriteRawData( fs, df[i].sv_index, df[i].sv_count, "i" );
- cvEndWriteStruct( fs );
+ responses = data->getTrainNormCatResponses();
+ class_labels = data->getClassLabels();
}
else
- CV_ASSERT( sv_count == sv_total );
- cvEndWriteStruct( fs );
- }
- cvEndWriteStruct( fs );
- cvEndWriteStruct( fs );
-
- __END__;
-}
-
+ responses = data->getTrainResponses();
-void CvSVM::read_params( CvFileStorage* fs, CvFileNode* svm_node )
-{
- CV_FUNCNAME( "CvSVM::read_params" );
+ if( !do_train( samples, responses ))
+ {
+ clear();
+ return false;
+ }
- __BEGIN__;
+ return true;
+ }
- int svm_type, kernel_type;
- CvSVMParams _params;
+ bool trainAuto( const Ptr<TrainData>& data, int k_fold,
+ ParamGrid C_grid, ParamGrid gamma_grid, ParamGrid p_grid,
+ ParamGrid nu_grid, ParamGrid coef_grid, ParamGrid degree_grid,
+ bool balanced )
+ {
+ int svmType = params.svmType;
+ RNG rng(-1);
- CvFileNode* tmp_node = cvGetFileNodeByName( fs, svm_node, "svm_type" );
- CvFileNode* kernel_node;
- if( !tmp_node )
- CV_ERROR( CV_StsBadArg, "svm_type tag is not found" );
+ if( svmType == ONE_CLASS )
+ // current implementation of "auto" svm does not support the 1-class case.
+ return train( data, 0 );
- if( CV_NODE_TYPE(tmp_node->tag) == CV_NODE_INT )
- svm_type = cvReadInt( tmp_node, -1 );
- else
- {
- const char* svm_type_str = cvReadString( tmp_node, "" );
- svm_type =
- strcmp( svm_type_str, "C_SVC" ) == 0 ? CvSVM::C_SVC :
- strcmp( svm_type_str, "NU_SVC" ) == 0 ? CvSVM::NU_SVC :
- strcmp( svm_type_str, "ONE_CLASS" ) == 0 ? CvSVM::ONE_CLASS :
- strcmp( svm_type_str, "EPS_SVR" ) == 0 ? CvSVM::EPS_SVR :
- strcmp( svm_type_str, "NU_SVR" ) == 0 ? CvSVM::NU_SVR : -1;
-
- if( svm_type < 0 )
- CV_ERROR( CV_StsParseError, "Missing of invalid SVM type" );
- }
+ clear();
- kernel_node = cvGetFileNodeByName( fs, svm_node, "kernel" );
- if( !kernel_node )
- CV_ERROR( CV_StsParseError, "SVM kernel tag is not found" );
+ CV_Assert( k_fold >= 2 );
+
+ // All the parameters except, possibly, <coef0> are positive.
+ // <coef0> is nonnegative
+ #define CHECK_GRID(grid, param) \
+ if( grid.logStep <= 1 ) \
+ { \
+ grid.minVal = grid.maxVal = params.param; \
+ grid.logStep = 10; \
+ } \
+ else \
+ checkParamGrid(grid)
+
+ CHECK_GRID(C_grid, C);
+ CHECK_GRID(gamma_grid, gamma);
+ CHECK_GRID(p_grid, p);
+ CHECK_GRID(nu_grid, nu);
+ CHECK_GRID(coef_grid, coef0);
+ CHECK_GRID(degree_grid, degree);
+
+ // these parameters are not used:
+ if( params.kernelType != POLY )
+ degree_grid.minVal = degree_grid.maxVal = params.degree;
+ if( params.kernelType == LINEAR )
+ gamma_grid.minVal = gamma_grid.maxVal = params.gamma;
+ if( params.kernelType != POLY && params.kernelType != SIGMOID )
+ coef_grid.minVal = coef_grid.maxVal = params.coef0;
+ if( svmType == NU_SVC || svmType == ONE_CLASS )
+ C_grid.minVal = C_grid.maxVal = params.C;
+ if( svmType == C_SVC || svmType == EPS_SVR )
+ nu_grid.minVal = nu_grid.maxVal = params.nu;
+ if( svmType != EPS_SVR )
+ p_grid.minVal = p_grid.maxVal = params.p;
+
+ Mat samples = data->getTrainSamples();
+ Mat responses;
+ bool is_classification = false;
+ Mat class_labels0 = class_labels;
+ int class_count = (int)class_labels.total();
+
+ if( svmType == C_SVC || svmType == NU_SVC )
+ {
+ responses = data->getTrainNormCatResponses();
+ class_labels = data->getClassLabels();
+ is_classification = true;
- tmp_node = cvGetFileNodeByName( fs, kernel_node, "type" );
- if( !tmp_node )
- CV_ERROR( CV_StsParseError, "SVM kernel type tag is not found" );
+ vector<int> temp_class_labels;
+ setRangeVector(temp_class_labels, class_count);
- if( CV_NODE_TYPE(tmp_node->tag) == CV_NODE_INT )
- kernel_type = cvReadInt( tmp_node, -1 );
- else
- {
- const char* kernel_type_str = cvReadString( tmp_node, "" );
- kernel_type =
- strcmp( kernel_type_str, "LINEAR" ) == 0 ? CvSVM::LINEAR :
- strcmp( kernel_type_str, "POLY" ) == 0 ? CvSVM::POLY :
- strcmp( kernel_type_str, "RBF" ) == 0 ? CvSVM::RBF :
- strcmp( kernel_type_str, "SIGMOID" ) == 0 ? CvSVM::SIGMOID : -1;
-
- if( kernel_type < 0 )
- CV_ERROR( CV_StsParseError, "Missing of invalid SVM kernel type" );
- }
+ // temporarily replace class labels with 0, 1, ..., NCLASSES-1
+ Mat(temp_class_labels).copyTo(class_labels);
+ }
+ else
+ responses = data->getTrainResponses();
- _params.svm_type = svm_type;
- _params.kernel_type = kernel_type;
- _params.degree = cvReadRealByName( fs, kernel_node, "degree", 0 );
- _params.gamma = cvReadRealByName( fs, kernel_node, "gamma", 0 );
- _params.coef0 = cvReadRealByName( fs, kernel_node, "coef0", 0 );
+ CV_Assert(samples.type() == CV_32F);
- _params.C = cvReadRealByName( fs, svm_node, "C", 0 );
- _params.nu = cvReadRealByName( fs, svm_node, "nu", 0 );
- _params.p = cvReadRealByName( fs, svm_node, "p", 0 );
- _params.class_weights = 0;
+ int sample_count = samples.rows;
+ var_count = samples.cols;
+ size_t sample_size = var_count*samples.elemSize();
- tmp_node = cvGetFileNodeByName( fs, svm_node, "term_criteria" );
- if( tmp_node )
- {
- _params.term_crit.epsilon = cvReadRealByName( fs, tmp_node, "epsilon", -1. );
- _params.term_crit.max_iter = cvReadIntByName( fs, tmp_node, "iterations", -1 );
- _params.term_crit.type = (_params.term_crit.epsilon >= 0 ? CV_TERMCRIT_EPS : 0) +
- (_params.term_crit.max_iter >= 0 ? CV_TERMCRIT_ITER : 0);
- }
- else
- _params.term_crit = cvTermCriteria( CV_TERMCRIT_EPS + CV_TERMCRIT_ITER, 1000, FLT_EPSILON );
+ vector<int> sidx;
+ setRangeVector(sidx, sample_count);
- set_params( _params );
+ int i, j, k;
- __END__;
-}
+ // randomly permute training samples
+ for( i = 0; i < sample_count; i++ )
+ {
+ int i1 = rng.uniform(0, sample_count);
+ int i2 = rng.uniform(0, sample_count);
+ std::swap(sidx[i1], sidx[i2]);
+ }
-void CvSVM::read( CvFileStorage* fs, CvFileNode* svm_node )
-{
- const double not_found_dbl = DBL_MAX;
+ if( is_classification && class_count == 2 && balanced )
+ {
+ // reshuffle the training set in such a way that
+ // instances of each class are divided more or less evenly
+ // between the k_fold parts.
+ vector<int> sidx0, sidx1;
- CV_FUNCNAME( "CvSVM::read" );
+ for( i = 0; i < sample_count; i++ )
+ {
+ if( responses.at<int>(sidx[i]) == 0 )
+ sidx0.push_back(sidx[i]);
+ else
+ sidx1.push_back(sidx[i]);
+ }
- __BEGIN__;
+ int n0 = (int)sidx0.size(), n1 = (int)sidx1.size();
+ int a0 = 0, a1 = 0;
+ sidx.clear();
+ for( k = 0; k < k_fold; k++ )
+ {
+ int b0 = ((k+1)*n0 + k_fold/2)/k_fold, b1 = ((k+1)*n1 + k_fold/2)/k_fold;
+ int a = (int)sidx.size(), b = a + (b0 - a0) + (b1 - a1);
+ for( i = a0; i < b0; i++ )
+ sidx.push_back(sidx0[i]);
+ for( i = a1; i < b1; i++ )
+ sidx.push_back(sidx1[i]);
+ for( i = 0; i < (b - a); i++ )
+ {
+ int i1 = rng.uniform(a, b);
+ int i2 = rng.uniform(a, b);
+ std::swap(sidx[i1], sidx[i2]);
+ }
+ a0 = b0; a1 = b1;
+ }
+ }
- int i, var_count, df_count, class_count;
- int block_size = 1 << 16, sv_size;
- CvFileNode *sv_node, *df_node;
- CvSVMDecisionFunc* df;
- CvSeqReader reader;
+ int test_sample_count = (sample_count + k_fold/2)/k_fold;
+ int train_sample_count = sample_count - test_sample_count;
- if( !svm_node )
- CV_ERROR( CV_StsParseError, "The requested element is not found" );
+ Params best_params = params;
+ double min_error = FLT_MAX;
- clear();
+ int rtype = responses.type();
- // read SVM parameters
- read_params( fs, svm_node );
+ Mat temp_train_samples(train_sample_count, var_count, CV_32F);
+ Mat temp_test_samples(test_sample_count, var_count, CV_32F);
+ Mat temp_train_responses(train_sample_count, 1, rtype);
+ Mat temp_test_responses;
- // and top-level data
- sv_total = cvReadIntByName( fs, svm_node, "sv_total", -1 );
- var_all = cvReadIntByName( fs, svm_node, "var_all", -1 );
- var_count = cvReadIntByName( fs, svm_node, "var_count", var_all );
- class_count = cvReadIntByName( fs, svm_node, "class_count", 0 );
+ #define FOR_IN_GRID(var, grid) \
+ for( params.var = grid.minVal; params.var == grid.minVal || params.var < grid.maxVal; params.var *= grid.logStep )
- if( !isSvmModelApplicable(sv_total, var_all, var_count, class_count) )
- CV_ERROR( CV_StsParseError, "SVM model data is invalid, check sv_count, var_* and class_count tags" );
+ FOR_IN_GRID(C, C_grid)
+ FOR_IN_GRID(gamma, gamma_grid)
+ FOR_IN_GRID(p, p_grid)
+ FOR_IN_GRID(nu, nu_grid)
+ FOR_IN_GRID(coef0, coef_grid)
+ FOR_IN_GRID(degree, degree_grid)
+ {
+ double error = 0;
+ for( k = 0; k < k_fold; k++ )
+ {
+ int start = (k*sample_count + k_fold/2)/k_fold;
+ for( i = 0; i < train_sample_count; i++ )
+ {
+ j = sidx[(i+start)%sample_count];
+ memcpy(temp_train_samples.ptr(i), samples.ptr(j), sample_size);
+ if( is_classification )
+ temp_train_responses.at<int>(i) = responses.at<int>(j);
+ else if( !responses.empty() )
+ temp_train_responses.at<float>(i) = responses.at<float>(j);
+ }
- CV_CALL( class_labels = (CvMat*)cvReadByName( fs, svm_node, "class_labels" ));
- CV_CALL( class_weights = (CvMat*)cvReadByName( fs, svm_node, "class_weights" ));
- CV_CALL( var_idx = (CvMat*)cvReadByName( fs, svm_node, "var_idx" ));
+ // Train SVM on <train_size> samples
+ if( !do_train( temp_train_samples, temp_train_responses ))
+ continue;
- if( class_count > 1 && (!class_labels ||
- !CV_IS_MAT(class_labels) || class_labels->cols != class_count))
- CV_ERROR( CV_StsParseError, "Array of class labels is missing or invalid" );
+ for( i = 0; i < test_sample_count; i++ )
+ {
+ j = sidx[(i+start+train_sample_count) % sample_count];
+ memcpy(temp_train_samples.ptr(i), samples.ptr(j), sample_size);
+ }
- if( var_count < var_all && (!var_idx || !CV_IS_MAT(var_idx) || var_idx->cols != var_count) )
- CV_ERROR( CV_StsParseError, "var_idx array is missing or invalid" );
+ predict(temp_test_samples, temp_test_responses, 0);
+ for( i = 0; i < test_sample_count; i++ )
+ {
+ float val = temp_test_responses.at<float>(i);
+ j = sidx[(i+start+train_sample_count) % sample_count];
+ if( is_classification )
+ error += (float)(val != responses.at<int>(j));
+ else
+ {
+ val -= responses.at<float>(j);
+ error += val*val;
+ }
+ }
+ }
+ if( min_error > error )
+ {
+ min_error = error;
+ best_params = params;
+ }
+ }
- // read support vectors
- sv_node = cvGetFileNodeByName( fs, svm_node, "support_vectors" );
- if( !sv_node || !CV_NODE_IS_SEQ(sv_node->tag))
- CV_ERROR( CV_StsParseError, "Missing or invalid sequence of support vectors" );
+ params = best_params;
+ class_labels = class_labels0;
+ return do_train( samples, responses );
+ }
- block_size = MAX( block_size, sv_total*(int)sizeof(CvSVMKernelRow));
- block_size = MAX( block_size, sv_total*2*(int)sizeof(double));
- block_size = MAX( block_size, var_all*(int)sizeof(double));
+ struct PredictBody : ParallelLoopBody
+ {
+ PredictBody( const SVMImpl* _svm, const Mat& _samples, Mat& _results, bool _returnDFVal )
+ {
+ svm = _svm;
+ results = &_results;
+ samples = &_samples;
+ returnDFVal = _returnDFVal;
+ }
- CV_CALL( storage = cvCreateMemStorage(block_size + sizeof(CvMemBlock) + sizeof(CvSeqBlock)));
- CV_CALL( sv = (float**)cvMemStorageAlloc( storage,
- sv_total*sizeof(sv[0]) ));
+ void operator()( const Range& range ) const
+ {
+ int svmType = svm->params.svmType;
+ int sv_total = svm->sv.rows;
+ int class_count = !svm->class_labels.empty() ? svm->class_labels.cols : svmType == ONE_CLASS ? 1 : 0;
- CV_CALL( cvStartReadSeq( sv_node->data.seq, &reader, 0 ));
- sv_size = var_count*sizeof(sv[0][0]);
+ AutoBuffer<float> _buffer(sv_total + (class_count+1)*2);
+ float* buffer = _buffer;
- for( i = 0; i < sv_total; i++ )
- {
- CvFileNode* sv_elem = (CvFileNode*)reader.ptr;
- CV_ASSERT( var_count == 1 || (CV_NODE_IS_SEQ(sv_elem->tag) &&
- sv_elem->data.seq->total == var_count) );
+ int i, j, dfi, k, si;
- CV_CALL( sv[i] = (float*)cvMemStorageAlloc( storage, sv_size ));
- CV_CALL( cvReadRawData( fs, sv_elem, sv[i], "f" ));
- CV_NEXT_SEQ_ELEM( sv_node->data.seq->elem_size, reader );
- }
+ if( svmType == EPS_SVR || svmType == NU_SVR || svmType == ONE_CLASS )
+ {
+ for( si = range.start; si < range.end; si++ )
+ {
+ const float* row_sample = samples->ptr<float>(si);
+ svm->kernel->calc( sv_total, svm->var_count, svm->sv.ptr<float>(), row_sample, buffer );
+
+ const SVMImpl::DecisionFunc* df = &svm->decision_func[0];
+ double sum = -df->rho;
+ for( i = 0; i < sv_total; i++ )
+ sum += buffer[i]*svm->df_alpha[i];
+ float result = svm->params.svmType == ONE_CLASS && !returnDFVal ? (float)(sum > 0) : (float)sum;
+ results->at<float>(si) = result;
+ }
+ }
+ else if( svmType == C_SVC || svmType == NU_SVC )
+ {
+ int* vote = (int*)(buffer + sv_total);
- // read decision functions
- df_count = class_count > 1 ? class_count*(class_count-1)/2 : 1;
- df_node = cvGetFileNodeByName( fs, svm_node, "decision_functions" );
- if( !df_node || !CV_NODE_IS_SEQ(df_node->tag) ||
- df_node->data.seq->total != df_count )
- CV_ERROR( CV_StsParseError, "decision_functions is missing or is not a collection "
- "or has a wrong number of elements" );
+ for( si = range.start; si < range.end; si++ )
+ {
+ svm->kernel->calc( sv_total, svm->var_count, svm->sv.ptr<float>(),
+ samples->ptr<float>(si), buffer );
+ double sum = 0.;
- CV_CALL( df = decision_func = (CvSVMDecisionFunc*)cvAlloc( df_count*sizeof(df[0]) ));
- cvStartReadSeq( df_node->data.seq, &reader, 0 );
+ memset( vote, 0, class_count*sizeof(vote[0]));
- for( i = 0; i < df_count; i++ )
- {
- CvFileNode* df_elem = (CvFileNode*)reader.ptr;
- CvFileNode* alpha_node = cvGetFileNodeByName( fs, df_elem, "alpha" );
+ for( i = dfi = 0; i < class_count; i++ )
+ {
+ for( j = i+1; j < class_count; j++, dfi++ )
+ {
+ const DecisionFunc& df = svm->decision_func[dfi];
+ sum = -df.rho;
+ int sv_count = svm->getSVCount(dfi);
+ const double* alpha = &svm->df_alpha[df.ofs];
+ const int* sv_index = &svm->df_index[df.ofs];
+ for( k = 0; k < sv_count; k++ )
+ sum += alpha[k]*buffer[sv_index[k]];
+
+ vote[sum > 0 ? i : j]++;
+ }
+ }
- int sv_count = cvReadIntByName( fs, df_elem, "sv_count", -1 );
- if( sv_count <= 0 )
- CV_ERROR( CV_StsParseError, "sv_count is missing or non-positive" );
- df[i].sv_count = sv_count;
+ for( i = 1, k = 0; i < class_count; i++ )
+ {
+ if( vote[i] > vote[k] )
+ k = i;
+ }
+ float result = returnDFVal && class_count == 2 ?
+ (float)sum : (float)(svm->class_labels.at<int>(k));
+ results->at<float>(si) = result;
+ }
+ }
+ else
+ CV_Error( CV_StsBadArg, "INTERNAL ERROR: Unknown SVM type, "
+ "the SVM structure is probably corrupted" );
+ }
- df[i].rho = cvReadRealByName( fs, df_elem, "rho", not_found_dbl );
- if( fabs(df[i].rho - not_found_dbl) < DBL_EPSILON )
- CV_ERROR( CV_StsParseError, "rho is missing" );
+ const SVMImpl* svm;
+ const Mat* samples;
+ Mat* results;
+ bool returnDFVal;
+ };
- if( !alpha_node )
- CV_ERROR( CV_StsParseError, "alpha is missing in the decision function" );
+ float predict( InputArray _samples, OutputArray _results, int flags ) const
+ {
+ float result = 0;
+ Mat samples = _samples.getMat(), results;
+ int nsamples = samples.rows;
+ bool returnDFVal = (flags & RAW_OUTPUT) != 0;
- CV_CALL( df[i].alpha = (double*)cvMemStorageAlloc( storage,
- sv_count*sizeof(df[i].alpha[0])));
- CV_ASSERT( sv_count == 1 || (CV_NODE_IS_SEQ(alpha_node->tag) &&
- alpha_node->data.seq->total == sv_count) );
- CV_CALL( cvReadRawData( fs, alpha_node, df[i].alpha, "d" ));
+ CV_Assert( samples.cols == var_count && samples.type() == CV_32F );
- if( class_count > 1 )
+ if( _results.needed() )
+ {
+ _results.create( nsamples, 1, samples.type() );
+ results = _results.getMat();
+ }
+ else
{
- CvFileNode* index_node = cvGetFileNodeByName( fs, df_elem, "index" );
- if( !index_node )
- CV_ERROR( CV_StsParseError, "index is missing in the decision function" );
- CV_CALL( df[i].sv_index = (int*)cvMemStorageAlloc( storage,
- sv_count*sizeof(df[i].sv_index[0])));
- CV_ASSERT( sv_count == 1 || (CV_NODE_IS_SEQ(index_node->tag) &&
- index_node->data.seq->total == sv_count) );
- CV_CALL( cvReadRawData( fs, index_node, df[i].sv_index, "i" ));
+ CV_Assert( nsamples == 1 );
+ results = Mat(1, 1, CV_32F, &result);
}
+
+ PredictBody invoker(this, samples, results, returnDFVal);
+ if( nsamples < 10 )
+ invoker(Range(0, nsamples));
else
- df[i].sv_index = 0;
+ parallel_for_(Range(0, nsamples), invoker);
+ return result;
+ }
- CV_NEXT_SEQ_ELEM( df_node->data.seq->elem_size, reader );
+ double getDecisionFunction(int i, OutputArray _alpha, OutputArray _svidx ) const
+ {
+ CV_Assert( 0 <= i && i < (int)decision_func.size());
+ const DecisionFunc& df = decision_func[i];
+ int count = getSVCount(i);
+ Mat(1, count, CV_64F, (double*)&df_alpha[df.ofs]).copyTo(_alpha);
+ Mat(1, count, CV_32S, (int*)&df_index[df.ofs]).copyTo(_svidx);
+ return df.rho;
}
- if( cvReadIntByName(fs, svm_node, "optimize_linear", 1) != 0 )
- optimize_linear_svm();
- create_kernel();
+ void write_params( FileStorage& fs ) const
+ {
+ int svmType = params.svmType;
+ int kernelType = params.kernelType;
- __END__;
-}
+ String svm_type_str =
+ svmType == C_SVC ? "C_SVC" :
+ svmType == NU_SVC ? "NU_SVC" :
+ svmType == ONE_CLASS ? "ONE_CLASS" :
+ svmType == EPS_SVR ? "EPS_SVR" :
+ svmType == NU_SVR ? "NU_SVR" : format("Uknown_%d", svmType);
+ String kernel_type_str =
+ kernelType == LINEAR ? "LINEAR" :
+ kernelType == POLY ? "POLY" :
+ kernelType == RBF ? "RBF" :
+ kernelType == SIGMOID ? "SIGMOID" : format("Unknown_%d", kernelType);
-#if 0
+ fs << "svmType" << svm_type_str;
-static void*
-icvCloneSVM( const void* _src )
-{
- CvSVMModel* dst = 0;
+ // save kernel
+ fs << "kernel" << "{" << "type" << kernel_type_str;
- CV_FUNCNAME( "icvCloneSVM" );
+ if( kernelType == POLY )
+ fs << "degree" << params.degree;
- __BEGIN__;
+ if( kernelType != LINEAR )
+ fs << "gamma" << params.gamma;
- const CvSVMModel* src = (const CvSVMModel*)_src;
- int var_count, class_count;
- int i, sv_total, df_count;
- int sv_size;
+ if( kernelType == POLY || kernelType == SIGMOID )
+ fs << "coef0" << params.coef0;
- if( !CV_IS_SVM(src) )
- CV_ERROR( !src ? CV_StsNullPtr : CV_StsBadArg, "Input pointer is NULL or invalid" );
+ fs << "}";
- // 0. create initial CvSVMModel structure
- CV_CALL( dst = icvCreateSVM() );
- dst->params = src->params;
- dst->params.weight_labels = 0;
- dst->params.weights = 0;
+ if( svmType == C_SVC || svmType == EPS_SVR || svmType == NU_SVR )
+ fs << "C" << params.C;
- dst->var_all = src->var_all;
- if( src->class_labels )
- dst->class_labels = cvCloneMat( src->class_labels );
- if( src->class_weights )
- dst->class_weights = cvCloneMat( src->class_weights );
- if( src->comp_idx )
- dst->comp_idx = cvCloneMat( src->comp_idx );
+ if( svmType == NU_SVC || svmType == ONE_CLASS || svmType == NU_SVR )
+ fs << "nu" << params.nu;
- var_count = src->comp_idx ? src->comp_idx->cols : src->var_all;
- class_count = src->class_labels ? src->class_labels->cols :
- src->params.svm_type == CvSVM::ONE_CLASS ? 1 : 0;
- sv_total = dst->sv_total = src->sv_total;
- CV_CALL( dst->storage = cvCreateMemStorage( src->storage->block_size ));
- CV_CALL( dst->sv = (float**)cvMemStorageAlloc( dst->storage,
- sv_total*sizeof(dst->sv[0]) ));
+ if( svmType == EPS_SVR )
+ fs << "p" << params.p;
- sv_size = var_count*sizeof(dst->sv[0][0]);
+ fs << "term_criteria" << "{:";
+ if( params.termCrit.type & TermCriteria::EPS )
+ fs << "epsilon" << params.termCrit.epsilon;
+ if( params.termCrit.type & TermCriteria::COUNT )
+ fs << "iterations" << params.termCrit.maxCount;
+ fs << "}";
+ }
- for( i = 0; i < sv_total; i++ )
+ bool isTrained() const
{
- CV_CALL( dst->sv[i] = (float*)cvMemStorageAlloc( dst->storage, sv_size ));
- memcpy( dst->sv[i], src->sv[i], sv_size );
+ return !sv.empty();
}
- df_count = class_count > 1 ? class_count*(class_count-1)/2 : 1;
+ bool isClassifier() const
+ {
+ return params.svmType == C_SVC || params.svmType == NU_SVC || params.svmType == ONE_CLASS;
+ }
- CV_CALL( dst->decision_func = cvAlloc( df_count*sizeof(CvSVMDecisionFunc) ));
+ int getVarCount() const
+ {
+ return var_count;
+ }
- for( i = 0; i < df_count; i++ )
+ String getDefaultModelName() const
{
- const CvSVMDecisionFunc *sdf =
- (const CvSVMDecisionFunc*)src->decision_func+i;
- CvSVMDecisionFunc *ddf =
- (CvSVMDecisionFunc*)dst->decision_func+i;
- int sv_count = sdf->sv_count;
- ddf->sv_count = sv_count;
- ddf->rho = sdf->rho;
- CV_CALL( ddf->alpha = (double*)cvMemStorageAlloc( dst->storage,
- sv_count*sizeof(ddf->alpha[0])));
- memcpy( ddf->alpha, sdf->alpha, sv_count*sizeof(ddf->alpha[0]));
-
- if( class_count > 1 )
- {
- CV_CALL( ddf->sv_index = (int*)cvMemStorageAlloc( dst->storage,
- sv_count*sizeof(ddf->sv_index[0])));
- memcpy( ddf->sv_index, sdf->sv_index, sv_count*sizeof(ddf->sv_index[0]));
- }
- else
- ddf->sv_index = 0;
+ return "opencv_ml_svm";
}
- __END__;
+ void write( FileStorage& fs ) const
+ {
+ int class_count = !class_labels.empty() ? (int)class_labels.total() :
+ params.svmType == ONE_CLASS ? 1 : 0;
+ if( !isTrained() )
+ CV_Error( CV_StsParseError, "SVM model data is invalid, check sv_count, var_* and class_count tags" );
- if( cvGetErrStatus() < 0 && dst )
- icvReleaseSVM( &dst );
+ write_params( fs );
- return dst;
-}
+ fs << "var_count" << var_count;
-static int icvRegisterSVMType()
-{
- CvTypeInfo info;
- memset( &info, 0, sizeof(info) );
-
- info.flags = 0;
- info.header_size = sizeof( info );
- info.is_instance = icvIsSVM;
- info.release = (CvReleaseFunc)icvReleaseSVM;
- info.read = icvReadSVM;
- info.write = icvWriteSVM;
- info.clone = icvCloneSVM;
- info.type_name = CV_TYPE_NAME_ML_SVM;
- cvRegisterType( &info );
-
- return 1;
-}
+ if( class_count > 0 )
+ {
+ fs << "class_count" << class_count;
+ if( !class_labels.empty() )
+ fs << "class_labels" << class_labels;
-static int svm = icvRegisterSVMType();
-
-/* The function trains SVM model with optimal parameters, obtained by using cross-validation.
-The parameters to be estimated should be indicated by setting theirs values to FLT_MAX.
-The optimal parameters are saved in <model_params> */
-CV_IMPL CvStatModel*
-cvTrainSVM_CrossValidation( const CvMat* train_data, int tflag,
- const CvMat* responses,
- CvStatModelParams* model_params,
- const CvStatModelParams* cross_valid_params,
- const CvMat* comp_idx,
- const CvMat* sample_idx,
- const CvParamGrid* degree_grid,
- const CvParamGrid* gamma_grid,
- const CvParamGrid* coef_grid,
- const CvParamGrid* C_grid,
- const CvParamGrid* nu_grid,
- const CvParamGrid* p_grid )
-{
- CvStatModel* svm = 0;
-
- CV_FUNCNAME("cvTainSVMCrossValidation");
- __BEGIN__;
-
- double degree_step = 7,
- g_step = 15,
- coef_step = 14,
- C_step = 20,
- nu_step = 5,
- p_step = 7; // all steps must be > 1
- double degree_begin = 0.01, degree_end = 2;
- double g_begin = 1e-5, g_end = 0.5;
- double coef_begin = 0.1, coef_end = 300;
- double C_begin = 0.1, C_end = 6000;
- double nu_begin = 0.01, nu_end = 0.4;
- double p_begin = 0.01, p_end = 100;
-
- double rate = 0, gamma = 0, C = 0, degree = 0, coef = 0, p = 0, nu = 0;
-
- double best_rate = 0;
- double best_degree = degree_begin;
- double best_gamma = g_begin;
- double best_coef = coef_begin;
- double best_C = C_begin;
- double best_nu = nu_begin;
- double best_p = p_begin;
-
- CvSVMModelParams svm_params, *psvm_params;
- CvCrossValidationParams* cv_params = (CvCrossValidationParams*)cross_valid_params;
- int svm_type, kernel;
- int is_regression;
-
- if( !model_params )
- CV_ERROR( CV_StsBadArg, "" );
- if( !cv_params )
- CV_ERROR( CV_StsBadArg, "" );
-
- svm_params = *(CvSVMModelParams*)model_params;
- psvm_params = (CvSVMModelParams*)model_params;
- svm_type = svm_params.svm_type;
- kernel = svm_params.kernel_type;
-
- svm_params.degree = svm_params.degree > 0 ? svm_params.degree : 1;
- svm_params.gamma = svm_params.gamma > 0 ? svm_params.gamma : 1;
- svm_params.coef0 = svm_params.coef0 > 0 ? svm_params.coef0 : 1e-6;
- svm_params.C = svm_params.C > 0 ? svm_params.C : 1;
- svm_params.nu = svm_params.nu > 0 ? svm_params.nu : 1;
- svm_params.p = svm_params.p > 0 ? svm_params.p : 1;
-
- if( degree_grid )
- {
- if( !(degree_grid->max_val == 0 && degree_grid->min_val == 0 &&
- degree_grid->step == 0) )
- {
- if( degree_grid->min_val > degree_grid->max_val )
- CV_ERROR( CV_StsBadArg,
- "low bound of grid should be less then the upper one");
- if( degree_grid->step <= 1 )
- CV_ERROR( CV_StsBadArg, "grid step should be greater 1" );
- degree_begin = degree_grid->min_val;
- degree_end = degree_grid->max_val;
- degree_step = degree_grid->step;
+ if( !params.classWeights.empty() )
+ fs << "class_weights" << params.classWeights;
}
- }
- else
- degree_begin = degree_end = svm_params.degree;
- if( gamma_grid )
- {
- if( !(gamma_grid->max_val == 0 && gamma_grid->min_val == 0 &&
- gamma_grid->step == 0) )
+ // write the joint collection of support vectors
+ int i, sv_total = sv.rows;
+ fs << "sv_total" << sv_total;
+ fs << "support_vectors" << "[";
+ for( i = 0; i < sv_total; i++ )
{
- if( gamma_grid->min_val > gamma_grid->max_val )
- CV_ERROR( CV_StsBadArg,
- "low bound of grid should be less then the upper one");
- if( gamma_grid->step <= 1 )
- CV_ERROR( CV_StsBadArg, "grid step should be greater 1" );
- g_begin = gamma_grid->min_val;
- g_end = gamma_grid->max_val;
- g_step = gamma_grid->step;
+ fs << "[:";
+ fs.writeRaw("f", sv.ptr(i), sv.cols*sv.elemSize());
+ fs << "]";
}
- }
- else
- g_begin = g_end = svm_params.gamma;
+ fs << "]";
- if( coef_grid )
- {
- if( !(coef_grid->max_val == 0 && coef_grid->min_val == 0 &&
- coef_grid->step == 0) )
- {
- if( coef_grid->min_val > coef_grid->max_val )
- CV_ERROR( CV_StsBadArg,
- "low bound of grid should be less then the upper one");
- if( coef_grid->step <= 1 )
- CV_ERROR( CV_StsBadArg, "grid step should be greater 1" );
- coef_begin = coef_grid->min_val;
- coef_end = coef_grid->max_val;
- coef_step = coef_grid->step;
- }
- }
- else
- coef_begin = coef_end = svm_params.coef0;
+ // write decision functions
+ int df_count = (int)decision_func.size();
- if( C_grid )
- {
- if( !(C_grid->max_val == 0 && C_grid->min_val == 0 && C_grid->step == 0))
+ fs << "decision_functions" << "[";
+ for( i = 0; i < df_count; i++ )
{
- if( C_grid->min_val > C_grid->max_val )
- CV_ERROR( CV_StsBadArg,
- "low bound of grid should be less then the upper one");
- if( C_grid->step <= 1 )
- CV_ERROR( CV_StsBadArg, "grid step should be greater 1" );
- C_begin = C_grid->min_val;
- C_end = C_grid->max_val;
- C_step = C_grid->step;
+ const DecisionFunc& df = decision_func[i];
+ int sv_count = getSVCount(i);
+ fs << "{" << "sv_count" << sv_count
+ << "rho" << df.rho
+ << "alpha" << "[:";
+ fs.writeRaw("d", (const uchar*)&df_alpha[df.ofs], sv_count*sizeof(df_alpha[0]));
+ fs << "]";
+ if( class_count > 2 )
+ {
+ fs << "index" << "[:";
+ fs.writeRaw("i", (const uchar*)&df_index[df.ofs], sv_count*sizeof(df_index[0]));
+ fs << "]";
+ }
+ else
+ CV_Assert( sv_count == sv_total );
+ fs << "}";
}
+ fs << "]";
}
- else
- C_begin = C_end = svm_params.C;
- if( nu_grid )
+ void read_params( const FileNode& fn )
{
- if(!(nu_grid->max_val == 0 && nu_grid->min_val == 0 && nu_grid->step==0))
- {
- if( nu_grid->min_val > nu_grid->max_val )
- CV_ERROR( CV_StsBadArg,
- "low bound of grid should be less then the upper one");
- if( nu_grid->step <= 1 )
- CV_ERROR( CV_StsBadArg, "grid step should be greater 1" );
- nu_begin = nu_grid->min_val;
- nu_end = nu_grid->max_val;
- nu_step = nu_grid->step;
- }
- }
- else
- nu_begin = nu_end = svm_params.nu;
+ Params _params;
- if( p_grid )
- {
- if( !(p_grid->max_val == 0 && p_grid->min_val == 0 && p_grid->step == 0))
+ String svm_type_str = (String)fn["svmType"];
+ int svmType =
+ svm_type_str == "C_SVC" ? C_SVC :
+ svm_type_str == "NU_SVC" ? NU_SVC :
+ svm_type_str == "ONE_CLASS" ? ONE_CLASS :
+ svm_type_str == "EPS_SVR" ? EPS_SVR :
+ svm_type_str == "NU_SVR" ? NU_SVR : -1;
+
+ if( svmType < 0 )
+ CV_Error( CV_StsParseError, "Missing of invalid SVM type" );
+
+ FileNode kernel_node = fn["kernel"];
+ if( kernel_node.empty() )
+ CV_Error( CV_StsParseError, "SVM kernel tag is not found" );
+
+ String kernel_type_str = (String)kernel_node["type"];
+ int kernelType =
+ kernel_type_str == "LINEAR" ? LINEAR :
+ kernel_type_str == "POLY" ? POLY :
+ kernel_type_str == "RBF" ? RBF :
+ kernel_type_str == "SIGMOID" ? SIGMOID : -1;
+
+ if( kernelType < 0 )
+ CV_Error( CV_StsParseError, "Missing of invalid SVM kernel type" );
+
+ _params.svmType = svmType;
+ _params.kernelType = kernelType;
+ _params.degree = (double)kernel_node["degree"];
+ _params.gamma = (double)kernel_node["gamma"];
+ _params.coef0 = (double)kernel_node["coef0"];
+
+ _params.C = (double)fn["C"];
+ _params.nu = (double)fn["nu"];
+ _params.p = (double)fn["p"];
+ _params.classWeights = Mat();
+
+ FileNode tcnode = fn["term_criteria"];
+ if( !tcnode.empty() )
{
- if( p_grid->min_val > p_grid->max_val )
- CV_ERROR( CV_StsBadArg,
- "low bound of grid should be less then the upper one");
- if( p_grid->step <= 1 )
- CV_ERROR( CV_StsBadArg, "grid step should be greater 1" );
- p_begin = p_grid->min_val;
- p_end = p_grid->max_val;
- p_step = p_grid->step;
+ _params.termCrit.epsilon = (double)tcnode["epsilon"];
+ _params.termCrit.maxCount = (int)tcnode["iterations"];
+ _params.termCrit.type = (_params.termCrit.epsilon > 0 ? TermCriteria::EPS : 0) +
+ (_params.termCrit.maxCount > 0 ? TermCriteria::COUNT : 0);
}
+ else
+ _params.termCrit = TermCriteria( TermCriteria::EPS + TermCriteria::COUNT, 1000, FLT_EPSILON );
+
+ setParams( _params, Ptr<Kernel>() );
}
- else
- p_begin = p_end = svm_params.p;
- // these parameters are not used:
- if( kernel != CvSVM::POLY )
- degree_begin = degree_end = svm_params.degree;
+ void read( const FileNode& fn )
+ {
+ clear();
- if( kernel == CvSVM::LINEAR )
- g_begin = g_end = svm_params.gamma;
+ // read SVM parameters
+ read_params( fn );
- if( kernel != CvSVM::POLY && kernel != CvSVM::SIGMOID )
- coef_begin = coef_end = svm_params.coef0;
+ // and top-level data
+ int i, sv_total = (int)fn["sv_total"];
+ var_count = (int)fn["var_count"];
+ int class_count = (int)fn["class_count"];
- if( svm_type == CvSVM::NU_SVC || svm_type == CvSVM::ONE_CLASS )
- C_begin = C_end = svm_params.C;
+ if( sv_total <= 0 || var_count <= 0 )
+ CV_Error( CV_StsParseError, "SVM model data is invalid, check sv_count, var_* and class_count tags" );
- if( svm_type == CvSVM::C_SVC || svm_type == CvSVM::EPS_SVR )
- nu_begin = nu_end = svm_params.nu;
+ FileNode m = fn["class_labels"];
+ if( !m.empty() )
+ m >> class_labels;
+ m = fn["class_weights"];
+ if( !m.empty() )
+ m >> params.classWeights;
- if( svm_type != CvSVM::EPS_SVR )
- p_begin = p_end = svm_params.p;
+ if( class_count > 1 && (class_labels.empty() || (int)class_labels.total() != class_count))
+ CV_Error( CV_StsParseError, "Array of class labels is missing or invalid" );
- is_regression = cv_params->is_regression;
- best_rate = is_regression ? FLT_MAX : 0;
+ // read support vectors
+ FileNode sv_node = fn["support_vectors"];
- assert( g_step > 1 && degree_step > 1 && coef_step > 1);
- assert( p_step > 1 && C_step > 1 && nu_step > 1 );
+ CV_Assert((int)sv_node.size() == sv_total);
+ sv.create(sv_total, var_count, CV_32F);
- for( degree = degree_begin; degree <= degree_end; degree *= degree_step )
- {
- svm_params.degree = degree;
- //printf("degree = %.3f\n", degree );
- for( gamma= g_begin; gamma <= g_end; gamma *= g_step )
- {
- svm_params.gamma = gamma;
- //printf(" gamma = %.3f\n", gamma );
- for( coef = coef_begin; coef <= coef_end; coef *= coef_step )
+ FileNodeIterator sv_it = sv_node.begin();
+ for( i = 0; i < sv_total; i++, ++sv_it )
{
- svm_params.coef0 = coef;
- //printf(" coef = %.3f\n", coef );
- for( C = C_begin; C <= C_end; C *= C_step )
- {
- svm_params.C = C;
- //printf(" C = %.3f\n", C );
- for( nu = nu_begin; nu <= nu_end; nu *= nu_step )
- {
- svm_params.nu = nu;
- //printf(" nu = %.3f\n", nu );
- for( p = p_begin; p <= p_end; p *= p_step )
- {
- int well;
- svm_params.p = p;
- //printf(" p = %.3f\n", p );
-
- CV_CALL(rate = cvCrossValidation( train_data, tflag, responses, &cvTrainSVM,
- cross_valid_params, (CvStatModelParams*)&svm_params, comp_idx, sample_idx ));
-
- well = rate > best_rate && !is_regression || rate < best_rate && is_regression;
- if( well || (rate == best_rate && C < best_C) )
- {
- best_rate = rate;
- best_degree = degree;
- best_gamma = gamma;
- best_coef = coef;
- best_C = C;
- best_nu = nu;
- best_p = p;
- }
- //printf(" rate = %.2f\n", rate );
- }
- }
- }
+ (*sv_it).readRaw("f", sv.ptr(i), var_count*sv.elemSize());
}
- }
- }
- //printf("The best:\nrate = %.2f%% degree = %f gamma = %f coef = %f c = %f nu = %f p = %f\n",
- // best_rate, best_degree, best_gamma, best_coef, best_C, best_nu, best_p );
- psvm_params->C = best_C;
- psvm_params->nu = best_nu;
- psvm_params->p = best_p;
- psvm_params->gamma = best_gamma;
- psvm_params->degree = best_degree;
- psvm_params->coef0 = best_coef;
+ // read decision functions
+ int df_count = class_count > 1 ? class_count*(class_count-1)/2 : 1;
+ FileNode df_node = fn["decision_functions"];
+
+ CV_Assert((int)df_node.size() == df_count);
- CV_CALL(svm = cvTrainSVM( train_data, tflag, responses, model_params, comp_idx, sample_idx ));
+ FileNodeIterator df_it = df_node.begin();
+ for( i = 0; i < df_count; i++, ++df_it )
+ {
+ FileNode dfi = *df_it;
+ DecisionFunc df;
+ int sv_count = (int)dfi["sv_count"];
+ int ofs = (int)df_index.size();
+ df.rho = (double)dfi["rho"];
+ df.ofs = ofs;
+ df_index.resize(ofs + sv_count);
+ df_alpha.resize(ofs + sv_count);
+ dfi["alpha"].readRaw("d", (uchar*)&df_alpha[ofs], sv_count*sizeof(df_alpha[0]));
+ if( class_count > 2 )
+ dfi["index"].readRaw("i", (uchar*)&df_index[ofs], sv_count*sizeof(df_index[0]));
+ decision_func.push_back(df);
+ }
+ if( class_count <= 2 )
+ setRangeVector(df_index, sv_total);
+ if( (int)fn["optimize_linear"] != 0 )
+ optimize_linear_svm();
+ }
+
+ Params params;
+ TermCriteria termCrit;
+ Mat class_labels;
+ int var_count;
+ Mat sv;
+ vector<DecisionFunc> decision_func;
+ vector<double> df_alpha;
+ vector<int> df_index;
+
+ Ptr<Kernel> kernel;
+};
- __END__;
- return svm;
+Ptr<SVM> SVM::create(const Params& params, const Ptr<SVM::Kernel>& kernel)
+{
+ Ptr<SVMImpl> p = makePtr<SVMImpl>();
+ p->setParams(params, kernel);
+ return p;
}
-#endif
+}
+}
/* End of file. */
#include "precomp.hpp"
-typedef struct CvDI
+namespace cv { namespace ml {
+
+struct PairDI
{
double d;
int i;
-} CvDI;
+};
-static int CV_CDECL
-icvCmpDI( const void* a, const void* b, void* )
+struct CmpPairDI
{
- const CvDI* e1 = (const CvDI*) a;
- const CvDI* e2 = (const CvDI*) b;
-
- return (e1->d < e2->d) ? -1 : (e1->d > e2->d);
-}
+ bool operator ()(const PairDI& e1, const PairDI& e2) const
+ {
+ return (e1.d < e2.d) || (e1.d == e2.d && e1.i < e2.i);
+ }
+};
-CV_IMPL void
-cvCreateTestSet( int type, CvMat** samples,
- int num_samples,
- int num_features,
- CvMat** responses,
- int num_classes, ... )
+void createConcentricSpheresTestSet( int num_samples, int num_features, int num_classes,
+ OutputArray _samples, OutputArray _responses)
{
- CvMat* mean = NULL;
- CvMat* cov = NULL;
- CvMemStorage* storage = NULL;
-
- CV_FUNCNAME( "cvCreateTestSet" );
+ if( num_samples < 1 )
+ CV_Error( CV_StsBadArg, "num_samples parameter must be positive" );
- __BEGIN__;
+ if( num_features < 1 )
+ CV_Error( CV_StsBadArg, "num_features parameter must be positive" );
- if( samples )
- *samples = NULL;
- if( responses )
- *responses = NULL;
+ if( num_classes < 1 )
+ CV_Error( CV_StsBadArg, "num_classes parameter must be positive" );
- if( type != CV_TS_CONCENTRIC_SPHERES )
- CV_ERROR( CV_StsBadArg, "Invalid type parameter" );
+ int i, cur_class;
- if( !samples )
- CV_ERROR( CV_StsNullPtr, "samples parameter must be not NULL" );
+ _samples.create( num_samples, num_features, CV_32F );
+ _responses.create( 1, num_samples, CV_32S );
- if( !responses )
- CV_ERROR( CV_StsNullPtr, "responses parameter must be not NULL" );
+ Mat responses = _responses.getMat();
- if( num_samples < 1 )
- CV_ERROR( CV_StsBadArg, "num_samples parameter must be positive" );
+ Mat mean = Mat::zeros(1, num_features, CV_32F);
+ Mat cov = Mat::eye(num_features, num_features, CV_32F);
- if( num_features < 1 )
- CV_ERROR( CV_StsBadArg, "num_features parameter must be positive" );
+ // fill the feature values matrix with random numbers drawn from standard normal distribution
+ randMVNormal( mean, cov, num_samples, _samples );
+ Mat samples = _samples.getMat();
- if( num_classes < 1 )
- CV_ERROR( CV_StsBadArg, "num_classes parameter must be positive" );
+ // calculate distances from the origin to the samples and put them
+ // into the sequence along with indices
+ std::vector<PairDI> dis(samples.rows);
- if( type == CV_TS_CONCENTRIC_SPHERES )
+ for( i = 0; i < samples.rows; i++ )
{
- CvSeqWriter writer;
- CvSeqReader reader;
- CvMat sample;
- CvDI elem;
- CvSeq* seq = NULL;
- int i, cur_class;
-
- CV_CALL( *samples = cvCreateMat( num_samples, num_features, CV_32FC1 ) );
- CV_CALL( *responses = cvCreateMat( 1, num_samples, CV_32SC1 ) );
- CV_CALL( mean = cvCreateMat( 1, num_features, CV_32FC1 ) );
- CV_CALL( cvSetZero( mean ) );
- CV_CALL( cov = cvCreateMat( num_features, num_features, CV_32FC1 ) );
- CV_CALL( cvSetIdentity( cov ) );
-
- /* fill the feature values matrix with random numbers drawn from standard
- normal distribution */
- CV_CALL( cvRandMVNormal( mean, cov, *samples ) );
-
- /* calculate distances from the origin to the samples and put them
- into the sequence along with indices */
- CV_CALL( storage = cvCreateMemStorage() );
- CV_CALL( cvStartWriteSeq( 0, sizeof( CvSeq ), sizeof( CvDI ), storage, &writer ));
- for( i = 0; i < (*samples)->rows; ++i )
- {
- CV_CALL( cvGetRow( *samples, &sample, i ));
- elem.i = i;
- CV_CALL( elem.d = cvNorm( &sample, NULL, CV_L2 ));
- CV_WRITE_SEQ_ELEM( elem, writer );
- }
- CV_CALL( seq = cvEndWriteSeq( &writer ) );
-
- /* sort the sequence in a distance ascending order */
- CV_CALL( cvSeqSort( seq, icvCmpDI, NULL ) );
-
- /* assign class labels */
- num_classes = MIN( num_samples, num_classes );
- CV_CALL( cvStartReadSeq( seq, &reader ) );
- CV_READ_SEQ_ELEM( elem, reader );
- for( i = 0, cur_class = 0; i < num_samples; ++cur_class )
- {
- int last_idx;
- double max_dst;
-
- last_idx = num_samples * (cur_class + 1) / num_classes - 1;
- CV_CALL( max_dst = (*((CvDI*) cvGetSeqElem( seq, last_idx ))).d );
- max_dst = MAX( max_dst, elem.d );
-
- for( ; elem.d <= max_dst && i < num_samples; ++i )
- {
- CV_MAT_ELEM( **responses, int, 0, elem.i ) = cur_class;
- if( i < num_samples - 1 )
- {
- CV_READ_SEQ_ELEM( elem, reader );
- }
- }
- }
+ PairDI& elem = dis[i];
+ elem.i = i;
+ elem.d = norm(samples.row(i), NORM_L2);
}
- __END__;
+ std::sort(dis.begin(), dis.end(), CmpPairDI());
- if( cvGetErrStatus() < 0 )
+ // assign class labels
+ num_classes = std::min( num_samples, num_classes );
+ for( i = 0, cur_class = 0; i < num_samples; ++cur_class )
{
- if( samples )
- cvReleaseMat( samples );
- if( responses )
- cvReleaseMat( responses );
+ int last_idx = num_samples * (cur_class + 1) / num_classes - 1;
+ double max_dst = dis[last_idx].d;
+ max_dst = std::max( max_dst, dis[i].d );
+
+ for( ; i < num_samples && dis[i].d <= max_dst; ++i )
+ responses.at<int>(i) = cur_class;
}
- cvReleaseMat( &mean );
- cvReleaseMat( &cov );
- cvReleaseMemStorage( &storage );
}
+}}
+
/* End of file. */
// copy or use the software.
//
//
-// Intel License Agreement
+// License Agreement
+// For Open Source Computer Vision Library
//
// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Copyright (C) 2014, Itseez Inc, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// 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
+// * The name of the copyright holders 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
#include "precomp.hpp"
#include <ctype.h>
-using namespace cv;
+namespace cv {
+namespace ml {
-static const float ord_nan = FLT_MAX*0.5f;
-static const int min_block_size = 1 << 16;
-static const int block_size_delta = 1 << 10;
+using std::vector;
-CvDTreeTrainData::CvDTreeTrainData()
-{
- var_idx = var_type = cat_count = cat_ofs = cat_map =
- priors = priors_mult = counts = direction = split_buf = responses_copy = 0;
- buf = 0;
- tree_storage = temp_storage = 0;
-
- clear();
-}
+DTrees::~DTrees() {}
-
-CvDTreeTrainData::CvDTreeTrainData( const CvMat* _train_data, int _tflag,
- const CvMat* _responses, const CvMat* _var_idx,
- const CvMat* _sample_idx, const CvMat* _var_type,
- const CvMat* _missing_mask, const CvDTreeParams& _params,
- bool _shared, bool _add_labels )
+void DTrees::setDParams(const DTrees::Params&)
{
- var_idx = var_type = cat_count = cat_ofs = cat_map =
- priors = priors_mult = counts = direction = split_buf = responses_copy = 0;
- buf = 0;
-
- tree_storage = temp_storage = 0;
-
- set_data( _train_data, _tflag, _responses, _var_idx, _sample_idx,
- _var_type, _missing_mask, _params, _shared, _add_labels );
+ CV_Error(CV_StsNotImplemented, "");
}
-
-CvDTreeTrainData::~CvDTreeTrainData()
+DTrees::Params DTrees::getDParams() const
{
- clear();
+ CV_Error(CV_StsNotImplemented, "");
+ return DTrees::Params();
}
-
-bool CvDTreeTrainData::set_params( const CvDTreeParams& _params )
+DTrees::Params::Params()
{
- bool ok = false;
-
- CV_FUNCNAME( "CvDTreeTrainData::set_params" );
-
- __BEGIN__;
-
- // set parameters
- params = _params;
-
- if( params.max_categories < 2 )
- CV_ERROR( CV_StsOutOfRange, "params.max_categories should be >= 2" );
- params.max_categories = MIN( params.max_categories, 15 );
-
- if( params.max_depth < 0 )
- CV_ERROR( CV_StsOutOfRange, "params.max_depth should be >= 0" );
- params.max_depth = MIN( params.max_depth, 25 );
-
- params.min_sample_count = MAX(params.min_sample_count,1);
-
- if( params.cv_folds < 0 )
- CV_ERROR( CV_StsOutOfRange,
- "params.cv_folds should be =0 (the tree is not pruned) "
- "or n>0 (tree is pruned using n-fold cross-validation)" );
-
- if( params.cv_folds == 1 )
- params.cv_folds = 0;
-
- if( params.regression_accuracy < 0 )
- CV_ERROR( CV_StsOutOfRange, "params.regression_accuracy should be >= 0" );
-
- ok = true;
-
- __END__;
-
- return ok;
+ maxDepth = INT_MAX;
+ minSampleCount = 10;
+ regressionAccuracy = 0.01f;
+ useSurrogates = false;
+ maxCategories = 10;
+ CVFolds = 10;
+ use1SERule = true;
+ truncatePrunedTree = true;
+ priors = Mat();
}
-template<typename T>
-class LessThanPtr
+DTrees::Params::Params( int _maxDepth, int _minSampleCount,
+ double _regressionAccuracy, bool _useSurrogates,
+ int _maxCategories, int _CVFolds,
+ bool _use1SERule, bool _truncatePrunedTree,
+ const Mat& _priors )
{
-public:
- bool operator()(T* a, T* b) const { return *a < *b; }
-};
+ maxDepth = _maxDepth;
+ minSampleCount = _minSampleCount;
+ regressionAccuracy = (float)_regressionAccuracy;
+ useSurrogates = _useSurrogates;
+ maxCategories = _maxCategories;
+ CVFolds = _CVFolds;
+ use1SERule = _use1SERule;
+ truncatePrunedTree = _truncatePrunedTree;
+ priors = _priors;
+}
-template<typename T, typename Idx>
-class LessThanIdx
+DTrees::Node::Node()
{
-public:
- LessThanIdx( const T* _arr ) : arr(_arr) {}
- bool operator()(Idx a, Idx b) const { return arr[a] < arr[b]; }
- const T* arr;
-};
+ classIdx = 0;
+ value = 0;
+ parent = left = right = split = defaultDir = -1;
+}
-class LessThanPairs
-{
-public:
- bool operator()(const CvPair16u32s& a, const CvPair16u32s& b) const { return *a.i < *b.i; }
-};
-
-void CvDTreeTrainData::set_data( const CvMat* _train_data, int _tflag,
- const CvMat* _responses, const CvMat* _var_idx, const CvMat* _sample_idx,
- const CvMat* _var_type, const CvMat* _missing_mask, const CvDTreeParams& _params,
- bool _shared, bool _add_labels, bool _update_data )
+DTrees::Split::Split()
{
- CvMat* sample_indices = 0;
- CvMat* var_type0 = 0;
- CvMat* tmp_map = 0;
- int** int_ptr = 0;
- CvPair16u32s* pair16u32s_ptr = 0;
- CvDTreeTrainData* data = 0;
- float *_fdst = 0;
- int *_idst = 0;
- unsigned short* udst = 0;
- int* idst = 0;
-
- CV_FUNCNAME( "CvDTreeTrainData::set_data" );
-
- __BEGIN__;
-
- int sample_all = 0, r_type, cv_n;
- int total_c_count = 0;
- int tree_block_size, temp_block_size, max_split_size, nv_size, cv_size = 0;
- int ds_step, dv_step, ms_step = 0, mv_step = 0; // {data|mask}{sample|var}_step
- int vi, i, size;
- char err[100];
- const int *sidx = 0, *vidx = 0;
-
- uint64 effective_buf_size = 0;
- int effective_buf_height = 0, effective_buf_width = 0;
-
- if( _update_data && data_root )
- {
- data = new CvDTreeTrainData( _train_data, _tflag, _responses, _var_idx,
- _sample_idx, _var_type, _missing_mask, _params, _shared, _add_labels );
-
- // compare new and old train data
- if( !(data->var_count == var_count &&
- cvNorm( data->var_type, var_type, CV_C ) < FLT_EPSILON &&
- cvNorm( data->cat_count, cat_count, CV_C ) < FLT_EPSILON &&
- cvNorm( data->cat_map, cat_map, CV_C ) < FLT_EPSILON) )
- CV_ERROR( CV_StsBadArg,
- "The new training data must have the same types and the input and output variables "
- "and the same categories for categorical variables" );
-
- cvReleaseMat( &priors );
- cvReleaseMat( &priors_mult );
- cvReleaseMat( &buf );
- cvReleaseMat( &direction );
- cvReleaseMat( &split_buf );
- cvReleaseMemStorage( &temp_storage );
-
- priors = data->priors; data->priors = 0;
- priors_mult = data->priors_mult; data->priors_mult = 0;
- buf = data->buf; data->buf = 0;
- buf_count = data->buf_count; buf_size = data->buf_size;
- sample_count = data->sample_count;
-
- direction = data->direction; data->direction = 0;
- split_buf = data->split_buf; data->split_buf = 0;
- temp_storage = data->temp_storage; data->temp_storage = 0;
- nv_heap = data->nv_heap; cv_heap = data->cv_heap;
-
- data_root = new_node( 0, sample_count, 0, 0 );
- EXIT;
- }
-
- clear();
-
- var_all = 0;
- rng = &cv::theRNG();
-
- CV_CALL( set_params( _params ));
-
- // check parameter types and sizes
- CV_CALL( cvCheckTrainData( _train_data, _tflag, _missing_mask, &var_all, &sample_all ));
+ varIdx = 0;
+ inversed = false;
+ quality = 0.f;
+ next = -1;
+ c = 0.f;
+ subsetOfs = 0;
+}
- train_data = _train_data;
- responses = _responses;
- if( _tflag == CV_ROW_SAMPLE )
+DTreesImpl::WorkData::WorkData(const Ptr<TrainData>& _data)
+{
+ data = _data;
+ vector<int> subsampleIdx;
+ Mat sidx0 = _data->getTrainSampleIdx();
+ if( !sidx0.empty() )
{
- ds_step = _train_data->step/CV_ELEM_SIZE(_train_data->type);
- dv_step = 1;
- if( _missing_mask )
- ms_step = _missing_mask->step, mv_step = 1;
+ sidx0.copyTo(sidx);
+ std::sort(sidx.begin(), sidx.end());
}
else
{
- dv_step = _train_data->step/CV_ELEM_SIZE(_train_data->type);
- ds_step = 1;
- if( _missing_mask )
- mv_step = _missing_mask->step, ms_step = 1;
- }
- tflag = _tflag;
-
- sample_count = sample_all;
- var_count = var_all;
-
- if( _sample_idx )
- {
- CV_CALL( sample_indices = cvPreprocessIndexArray( _sample_idx, sample_all ));
- sidx = sample_indices->data.i;
- sample_count = sample_indices->rows + sample_indices->cols - 1;
+ int n = _data->getNSamples();
+ setRangeVector(sidx, n);
}
- if( _var_idx )
- {
- CV_CALL( var_idx = cvPreprocessIndexArray( _var_idx, var_all ));
- vidx = var_idx->data.i;
- var_count = var_idx->rows + var_idx->cols - 1;
- }
-
- is_buf_16u = false;
- if ( sample_count < 65536 )
- is_buf_16u = true;
+ maxSubsetSize = 0;
+}
- if( !CV_IS_MAT(_responses) ||
- (CV_MAT_TYPE(_responses->type) != CV_32SC1 &&
- CV_MAT_TYPE(_responses->type) != CV_32FC1) ||
- (_responses->rows != 1 && _responses->cols != 1) ||
- _responses->rows + _responses->cols - 1 != sample_all )
- CV_ERROR( CV_StsBadArg, "The array of _responses must be an integer or "
- "floating-point vector containing as many elements as "
- "the total number of samples in the training data matrix" );
+DTreesImpl::DTreesImpl() {}
+DTreesImpl::~DTreesImpl() {}
+void DTreesImpl::clear()
+{
+ varIdx.clear();
+ compVarIdx.clear();
+ varType.clear();
+ catOfs.clear();
+ catMap.clear();
+ roots.clear();
+ nodes.clear();
+ splits.clear();
+ subsets.clear();
+ classLabels.clear();
- r_type = CV_VAR_CATEGORICAL;
- if( _var_type )
- CV_CALL( var_type0 = cvPreprocessVarType( _var_type, var_idx, var_count, &r_type ));
+ w.release();
+ _isClassifier = false;
+}
- CV_CALL( var_type = cvCreateMat( 1, var_count+2, CV_32SC1 ));
+void DTreesImpl::startTraining( const Ptr<TrainData>& data, int )
+{
+ clear();
+ w = makePtr<WorkData>(data);
- cat_var_count = 0;
- ord_var_count = -1;
+ Mat vtype = data->getVarType();
+ vtype.copyTo(varType);
- is_classifier = r_type == CV_VAR_CATEGORICAL;
+ data->getCatOfs().copyTo(catOfs);
+ data->getCatMap().copyTo(catMap);
+ data->getDefaultSubstValues().copyTo(missingSubst);
- // step 0. calc the number of categorical vars
- for( vi = 0; vi < var_count; vi++ )
- {
- char vt = var_type0 ? var_type0->data.ptr[vi] : CV_VAR_ORDERED;
- var_type->data.i[vi] = vt == CV_VAR_CATEGORICAL ? cat_var_count++ : ord_var_count--;
- }
+ int nallvars = data->getNAllVars();
- ord_var_count = ~ord_var_count;
- cv_n = params.cv_folds;
- // set the two last elements of var_type array to be able
- // to locate responses and cross-validation labels using
- // the corresponding get_* functions.
- var_type->data.i[var_count] = cat_var_count;
- var_type->data.i[var_count+1] = cat_var_count+1;
+ Mat vidx0 = data->getVarIdx();
+ if( !vidx0.empty() )
+ vidx0.copyTo(varIdx);
+ else
+ setRangeVector(varIdx, nallvars);
- // in case of single ordered predictor we need dummy cv_labels
- // for safe split_node_data() operation
- have_labels = cv_n > 0 || (ord_var_count == 1 && cat_var_count == 0) || _add_labels;
+ initCompVarIdx();
- work_var_count = var_count + (is_classifier ? 1 : 0) // for responses class_labels
- + (have_labels ? 1 : 0); // for cv_labels
+ w->maxSubsetSize = 0;
- shared = _shared;
- buf_count = shared ? 2 : 1;
+ int i, nvars = (int)varIdx.size();
+ for( i = 0; i < nvars; i++ )
+ w->maxSubsetSize = std::max(w->maxSubsetSize, getCatCount(varIdx[i]));
- buf_size = -1; // the member buf_size is obsolete
+ w->maxSubsetSize = std::max((w->maxSubsetSize + 31)/32, 1);
- effective_buf_size = (uint64)(work_var_count + 1)*(uint64)sample_count * buf_count; // this is the total size of "CvMat buf" to be allocated
- effective_buf_width = sample_count;
- effective_buf_height = work_var_count+1;
+ data->getSampleWeights().copyTo(w->sample_weights);
- if (effective_buf_width >= effective_buf_height)
- effective_buf_height *= buf_count;
- else
- effective_buf_width *= buf_count;
+ _isClassifier = data->getResponseType() == VAR_CATEGORICAL;
- if ((uint64)effective_buf_width * (uint64)effective_buf_height != effective_buf_size)
+ if( _isClassifier )
{
- CV_Error(CV_StsBadArg, "The memory buffer cannot be allocated since its size exceeds integer fields limit");
- }
+ data->getNormCatResponses().copyTo(w->cat_responses);
+ data->getClassLabels().copyTo(classLabels);
+ int nclasses = (int)classLabels.size();
+ Mat class_weights = params.priors;
+ if( !class_weights.empty() )
+ {
+ if( class_weights.type() != CV_64F || !class_weights.isContinuous() )
+ {
+ Mat temp;
+ class_weights.convertTo(temp, CV_64F);
+ class_weights = temp;
+ }
+ CV_Assert( class_weights.checkVector(1, CV_64F) == nclasses );
+ int nsamples = (int)w->cat_responses.size();
+ const double* cw = class_weights.ptr<double>();
+ CV_Assert( (int)w->sample_weights.size() == nsamples );
- if ( is_buf_16u )
- {
- CV_CALL( buf = cvCreateMat( effective_buf_height, effective_buf_width, CV_16UC1 ));
- CV_CALL( pair16u32s_ptr = (CvPair16u32s*)cvAlloc( sample_count*sizeof(pair16u32s_ptr[0]) ));
+ for( i = 0; i < nsamples; i++ )
+ {
+ int ci = w->cat_responses[i];
+ CV_Assert( 0 <= ci && ci < nclasses );
+ w->sample_weights[i] *= cw[ci];
+ }
+ }
}
else
+ data->getResponses().copyTo(w->ord_responses);
+}
+
+
+void DTreesImpl::initCompVarIdx()
+{
+ int nallvars = (int)varType.size();
+ compVarIdx.assign(nallvars, -1);
+ int i, nvars = (int)varIdx.size(), prevIdx = -1;
+ for( i = 0; i < nvars; i++ )
{
- CV_CALL( buf = cvCreateMat( effective_buf_height, effective_buf_width, CV_32SC1 ));
- CV_CALL( int_ptr = (int**)cvAlloc( sample_count*sizeof(int_ptr[0]) ));
+ int vi = varIdx[i];
+ CV_Assert( 0 <= vi && vi < nallvars && vi > prevIdx );
+ prevIdx = vi;
+ compVarIdx[vi] = i;
}
+}
+
+void DTreesImpl::endTraining()
+{
+ w.release();
+}
- size = is_classifier ? (cat_var_count+1) : cat_var_count;
- size = !size ? 1 : size;
- CV_CALL( cat_count = cvCreateMat( 1, size, CV_32SC1 ));
- CV_CALL( cat_ofs = cvCreateMat( 1, size, CV_32SC1 ));
+bool DTreesImpl::train( const Ptr<TrainData>& trainData, int flags )
+{
+ startTraining(trainData, flags);
+ bool ok = addTree( w->sidx ) >= 0;
+ w.release();
+ endTraining();
+ return ok;
+}
- size = is_classifier ? (cat_var_count + 1)*params.max_categories : cat_var_count*params.max_categories;
- size = !size ? 1 : size;
- CV_CALL( cat_map = cvCreateMat( 1, size, CV_32SC1 ));
+const vector<int>& DTreesImpl::getActiveVars()
+{
+ return varIdx;
+}
- // now calculate the maximum size of split,
- // create memory storage that will keep nodes and splits of the decision tree
- // allocate root node and the buffer for the whole training data
- max_split_size = cvAlign(sizeof(CvDTreeSplit) +
- (MAX(0,sample_count - 33)/32)*sizeof(int),sizeof(void*));
- tree_block_size = MAX((int)sizeof(CvDTreeNode)*8, max_split_size);
- tree_block_size = MAX(tree_block_size + block_size_delta, min_block_size);
- CV_CALL( tree_storage = cvCreateMemStorage( tree_block_size ));
- CV_CALL( node_heap = cvCreateSet( 0, sizeof(*node_heap), sizeof(CvDTreeNode), tree_storage ));
+int DTreesImpl::addTree(const vector<int>& sidx )
+{
+ size_t n = (params.maxDepth > 0 ? (1 << params.maxDepth) : 1024) + w->wnodes.size();
- nv_size = var_count*sizeof(int);
- nv_size = cvAlign(MAX( nv_size, (int)sizeof(CvSetElem) ), sizeof(void*));
+ w->wnodes.reserve(n);
+ w->wsplits.reserve(n);
+ w->wsubsets.reserve(n*w->maxSubsetSize);
+ w->wnodes.clear();
+ w->wsplits.clear();
+ w->wsubsets.clear();
- temp_block_size = nv_size;
+ int cv_n = params.CVFolds;
- if( cv_n )
+ if( cv_n > 0 )
{
- if( sample_count < cv_n*MAX(params.min_sample_count,10) )
- CV_ERROR( CV_StsOutOfRange,
- "The many folds in cross-validation for such a small dataset" );
-
- cv_size = cvAlign( cv_n*(sizeof(int) + sizeof(double)*2), sizeof(double) );
- temp_block_size = MAX(temp_block_size, cv_size);
+ w->cv_Tn.resize(n*cv_n);
+ w->cv_node_error.resize(n*cv_n);
+ w->cv_node_risk.resize(n*cv_n);
}
- temp_block_size = MAX( temp_block_size + block_size_delta, min_block_size );
- CV_CALL( temp_storage = cvCreateMemStorage( temp_block_size ));
- CV_CALL( nv_heap = cvCreateSet( 0, sizeof(*nv_heap), nv_size, temp_storage ));
- if( cv_size )
- CV_CALL( cv_heap = cvCreateSet( 0, sizeof(*cv_heap), cv_size, temp_storage ));
-
- CV_CALL( data_root = new_node( 0, sample_count, 0, 0 ));
+ // build the tree recursively
+ int w_root = addNodeAndTrySplit(-1, sidx);
+ int maxdepth = INT_MAX;//pruneCV(root);
- max_c_count = 1;
+ int w_nidx = w_root, pidx = -1, depth = 0;
+ int root = (int)nodes.size();
- _fdst = 0;
- _idst = 0;
- if (ord_var_count)
- _fdst = (float*)cvAlloc(sample_count*sizeof(_fdst[0]));
- if (is_buf_16u && (cat_var_count || is_classifier))
- _idst = (int*)cvAlloc(sample_count*sizeof(_idst[0]));
-
- // transform the training data to convenient representation
- for( vi = 0; vi <= var_count; vi++ )
+ for(;;)
{
- int ci;
- const uchar* mask = 0;
- int64 m_step = 0, step;
- const int* idata = 0;
- const float* fdata = 0;
- int num_valid = 0;
-
- if( vi < var_count ) // analyze i-th input variable
- {
- int vi0 = vidx ? vidx[vi] : vi;
- ci = get_var_type(vi);
- step = ds_step; m_step = ms_step;
- if( CV_MAT_TYPE(_train_data->type) == CV_32SC1 )
- idata = _train_data->data.i + vi0*dv_step;
- else
- fdata = _train_data->data.fl + vi0*dv_step;
- if( _missing_mask )
- mask = _missing_mask->data.ptr + vi0*mv_step;
- }
- else // analyze _responses
- {
- ci = cat_var_count;
- step = CV_IS_MAT_CONT(_responses->type) ?
- 1 : _responses->step / CV_ELEM_SIZE(_responses->type);
- if( CV_MAT_TYPE(_responses->type) == CV_32SC1 )
- idata = _responses->data.i;
- else
- fdata = _responses->data.fl;
- }
+ const WNode& wnode = w->wnodes[w_nidx];
+ Node node;
+ node.parent = pidx;
+ node.classIdx = wnode.class_idx;
+ node.value = wnode.value;
+ node.defaultDir = wnode.defaultDir;
- if( (vi < var_count && ci>=0) ||
- (vi == var_count && is_classifier) ) // process categorical variable or response
+ int wsplit_idx = wnode.split;
+ if( wsplit_idx >= 0 )
{
- int c_count, prev_label;
- int* c_map;
-
- if (is_buf_16u)
- udst = (unsigned short*)(buf->data.s + vi*sample_count);
- else
- idst = buf->data.i + vi*sample_count;
-
- // copy data
- for( i = 0; i < sample_count; i++ )
- {
- int val = INT_MAX, si = sidx ? sidx[i] : i;
- if( !mask || !mask[(size_t)si*m_step] )
- {
- if( idata )
- val = idata[(size_t)si*step];
- else
- {
- float t = fdata[(size_t)si*step];
- val = cvRound(t);
- if( fabs(t - val) > FLT_EPSILON )
- {
- sprintf( err, "%d-th value of %d-th (categorical) "
- "variable is not an integer", i, vi );
- CV_ERROR( CV_StsBadArg, err );
- }
- }
-
- if( val == INT_MAX )
- {
- sprintf( err, "%d-th value of %d-th (categorical) "
- "variable is too large", i, vi );
- CV_ERROR( CV_StsBadArg, err );
- }
- num_valid++;
- }
- if (is_buf_16u)
- {
- _idst[i] = val;
- pair16u32s_ptr[i].u = udst + i;
- pair16u32s_ptr[i].i = _idst + i;
- }
- else
- {
- idst[i] = val;
- int_ptr[i] = idst + i;
- }
- }
-
- c_count = num_valid > 0;
- if (is_buf_16u)
- {
- std::sort(pair16u32s_ptr, pair16u32s_ptr + sample_count, LessThanPairs());
- // count the categories
- for( i = 1; i < num_valid; i++ )
- if (*pair16u32s_ptr[i].i != *pair16u32s_ptr[i-1].i)
- c_count ++ ;
- }
- else
- {
- std::sort(int_ptr, int_ptr + sample_count, LessThanPtr<int>());
- // count the categories
- for( i = 1; i < num_valid; i++ )
- c_count += *int_ptr[i] != *int_ptr[i-1];
- }
-
- if( vi > 0 )
- max_c_count = MAX( max_c_count, c_count );
- cat_count->data.i[ci] = c_count;
- cat_ofs->data.i[ci] = total_c_count;
-
- // resize cat_map, if need
- if( cat_map->cols < total_c_count + c_count )
- {
- tmp_map = cat_map;
- CV_CALL( cat_map = cvCreateMat( 1,
- MAX(cat_map->cols*3/2,total_c_count+c_count), CV_32SC1 ));
- for( i = 0; i < total_c_count; i++ )
- cat_map->data.i[i] = tmp_map->data.i[i];
- cvReleaseMat( &tmp_map );
- }
-
- c_map = cat_map->data.i + total_c_count;
- total_c_count += c_count;
-
- c_count = -1;
- if (is_buf_16u)
- {
- // compact the class indices and build the map
- prev_label = ~*pair16u32s_ptr[0].i;
- for( i = 0; i < num_valid; i++ )
- {
- int cur_label = *pair16u32s_ptr[i].i;
- if( cur_label != prev_label )
- c_map[++c_count] = prev_label = cur_label;
- *pair16u32s_ptr[i].u = (unsigned short)c_count;
- }
- // replace labels for missing values with -1
- for( ; i < sample_count; i++ )
- *pair16u32s_ptr[i].u = 65535;
- }
- else
+ const WSplit& wsplit = w->wsplits[wsplit_idx];
+ Split split;
+ split.c = wsplit.c;
+ split.quality = wsplit.quality;
+ split.inversed = wsplit.inversed;
+ split.varIdx = wsplit.varIdx;
+ split.subsetOfs = -1;
+ if( wsplit.subsetOfs >= 0 )
{
- // compact the class indices and build the map
- prev_label = ~*int_ptr[0];
- for( i = 0; i < num_valid; i++ )
- {
- int cur_label = *int_ptr[i];
- if( cur_label != prev_label )
- c_map[++c_count] = prev_label = cur_label;
- *int_ptr[i] = c_count;
- }
- // replace labels for missing values with -1
- for( ; i < sample_count; i++ )
- *int_ptr[i] = -1;
+ int ssize = getSubsetSize(split.varIdx);
+ split.subsetOfs = (int)subsets.size();
+ subsets.resize(split.subsetOfs + ssize);
+ memcpy(&subsets[split.subsetOfs], &w->wsubsets[wsplit.subsetOfs], ssize*sizeof(int));
}
+ node.split = (int)splits.size();
+ splits.push_back(split);
}
- else if( ci < 0 ) // process ordered variable
+ int nidx = (int)nodes.size();
+ nodes.push_back(node);
+ if( pidx >= 0 )
{
- if (is_buf_16u)
- udst = (unsigned short*)(buf->data.s + vi*sample_count);
- else
- idst = buf->data.i + vi*sample_count;
-
- for( i = 0; i < sample_count; i++ )
+ int w_pidx = w->wnodes[w_nidx].parent;
+ if( w->wnodes[w_pidx].left == w_nidx )
{
- float val = ord_nan;
- int si = sidx ? sidx[i] : i;
- if( !mask || !mask[(size_t)si*m_step] )
- {
- if( idata )
- val = (float)idata[(size_t)si*step];
- else
- val = fdata[(size_t)si*step];
-
- if( fabs(val) >= ord_nan )
- {
- sprintf( err, "%d-th value of %d-th (ordered) "
- "variable (=%g) is too large", i, vi, val );
- CV_ERROR( CV_StsBadArg, err );
- }
- num_valid++;
- }
-
- if (is_buf_16u)
- udst[i] = (unsigned short)i; // TODO: memory corruption may be here
- else
- idst[i] = i;
- _fdst[i] = val;
-
+ nodes[pidx].left = nidx;
}
- if (is_buf_16u)
- std::sort(udst, udst + sample_count, LessThanIdx<float, unsigned short>(_fdst));
else
- std::sort(idst, idst + sample_count, LessThanIdx<float, int>(_fdst));
- }
-
- if( vi < var_count )
- data_root->set_num_valid(vi, num_valid);
- }
-
- // set sample labels
- if (is_buf_16u)
- udst = (unsigned short*)(buf->data.s + work_var_count*sample_count);
- else
- idst = buf->data.i + work_var_count*sample_count;
-
- for (i = 0; i < sample_count; i++)
- {
- if (udst)
- udst[i] = sidx ? (unsigned short)sidx[i] : (unsigned short)i;
- else
- idst[i] = sidx ? sidx[i] : i;
- }
-
- if( cv_n )
- {
- unsigned short* usdst = 0;
- int* idst2 = 0;
-
- if (is_buf_16u)
- {
- usdst = (unsigned short*)(buf->data.s + (get_work_var_count()-1)*sample_count);
- for( i = vi = 0; i < sample_count; i++ )
{
- usdst[i] = (unsigned short)vi++;
- vi &= vi < cv_n ? -1 : 0;
+ CV_Assert(w->wnodes[w_pidx].right == w_nidx);
+ nodes[pidx].right = nidx;
}
+ }
- for( i = 0; i < sample_count; i++ )
- {
- int a = (*rng)(sample_count);
- int b = (*rng)(sample_count);
- unsigned short unsh = (unsigned short)vi;
- CV_SWAP( usdst[a], usdst[b], unsh );
- }
+ if( wnode.left >= 0 && depth+1 < maxdepth )
+ {
+ w_nidx = wnode.left;
+ pidx = nidx;
+ depth++;
}
else
{
- idst2 = buf->data.i + (get_work_var_count()-1)*sample_count;
- for( i = vi = 0; i < sample_count; i++ )
- {
- idst2[i] = vi++;
- vi &= vi < cv_n ? -1 : 0;
- }
-
- for( i = 0; i < sample_count; i++ )
+ int w_pidx = wnode.parent;
+ while( w_pidx >= 0 && w->wnodes[w_pidx].right == w_nidx )
{
- int a = (*rng)(sample_count);
- int b = (*rng)(sample_count);
- CV_SWAP( idst2[a], idst2[b], vi );
+ w_nidx = w_pidx;
+ w_pidx = w->wnodes[w_pidx].parent;
+ nidx = pidx;
+ pidx = nodes[pidx].parent;
+ depth--;
}
- }
- }
- if ( cat_map )
- cat_map->cols = MAX( total_c_count, 1 );
-
- max_split_size = cvAlign(sizeof(CvDTreeSplit) +
- (MAX(0,max_c_count - 33)/32)*sizeof(int),sizeof(void*));
- CV_CALL( split_heap = cvCreateSet( 0, sizeof(*split_heap), max_split_size, tree_storage ));
+ if( w_pidx < 0 )
+ break;
- have_priors = is_classifier && params.priors;
- if( is_classifier )
- {
- int m = get_num_classes();
- double sum = 0;
- CV_CALL( priors = cvCreateMat( 1, m, CV_64F ));
- for( i = 0; i < m; i++ )
- {
- double val = have_priors ? params.priors[i] : 1.;
- if( val <= 0 )
- CV_ERROR( CV_StsOutOfRange, "Every class weight should be positive" );
- priors->data.db[i] = val;
- sum += val;
+ w_nidx = w->wnodes[w_pidx].right;
+ CV_Assert( w_nidx >= 0 );
}
-
- // normalize weights
- if( have_priors )
- cvScale( priors, priors, 1./sum );
-
- CV_CALL( priors_mult = cvCloneMat( priors ));
- CV_CALL( counts = cvCreateMat( 1, m, CV_32SC1 ));
}
-
-
- CV_CALL( direction = cvCreateMat( 1, sample_count, CV_8UC1 ));
- CV_CALL( split_buf = cvCreateMat( 1, sample_count, CV_32SC1 ));
-
- __END__;
-
- if( data )
- delete data;
-
- if (_fdst)
- cvFree( &_fdst );
- if (_idst)
- cvFree( &_idst );
- cvFree( &int_ptr );
- cvFree( &pair16u32s_ptr);
- cvReleaseMat( &var_type0 );
- cvReleaseMat( &sample_indices );
- cvReleaseMat( &tmp_map );
+ roots.push_back(root);
+ return root;
}
-void CvDTreeTrainData::do_responses_copy()
+DTrees::Params DTreesImpl::getDParams() const
{
- responses_copy = cvCreateMat( responses->rows, responses->cols, responses->type );
- cvCopy( responses, responses_copy);
- responses = responses_copy;
+ return params0;
}
-CvDTreeNode* CvDTreeTrainData::subsample_data( const CvMat* _subsample_idx )
+void DTreesImpl::setDParams(const Params& _params)
{
- CvDTreeNode* root = 0;
- CvMat* isubsample_idx = 0;
- CvMat* subsample_co = 0;
+ params0 = params = _params;
+ if( params.maxCategories < 2 )
+ CV_Error( CV_StsOutOfRange, "params.max_categories should be >= 2" );
+ params.maxCategories = std::min( params.maxCategories, 15 );
- bool isMakeRootCopy = true;
+ if( params.maxDepth < 0 )
+ CV_Error( CV_StsOutOfRange, "params.max_depth should be >= 0" );
+ params.maxDepth = std::min( params.maxDepth, 25 );
- CV_FUNCNAME( "CvDTreeTrainData::subsample_data" );
+ params.minSampleCount = std::max(params.minSampleCount, 1);
- __BEGIN__;
+ if( params.CVFolds < 0 )
+ CV_Error( CV_StsOutOfRange,
+ "params.CVFolds should be =0 (the tree is not pruned) "
+ "or n>0 (tree is pruned using n-fold cross-validation)" );
- if( !data_root )
- CV_ERROR( CV_StsError, "No training data has been set" );
+ if( params.CVFolds == 1 )
+ params.CVFolds = 0;
+
+ if( params.regressionAccuracy < 0 )
+ CV_Error( CV_StsOutOfRange, "params.regression_accuracy should be >= 0" );
+}
- if( _subsample_idx )
- {
- CV_CALL( isubsample_idx = cvPreprocessIndexArray( _subsample_idx, sample_count ));
+int DTreesImpl::addNodeAndTrySplit( int parent, const vector<int>& sidx )
+{
+ w->wnodes.push_back(WNode());
+ int nidx = (int)(w->wnodes.size() - 1);
+ WNode& node = w->wnodes.back();
- if( isubsample_idx->cols + isubsample_idx->rows - 1 == sample_count )
- {
- const int* sidx = isubsample_idx->data.i;
- for( int i = 0; i < sample_count; i++ )
- {
- if( sidx[i] != i )
- {
- isMakeRootCopy = false;
- break;
- }
- }
- }
- else
- isMakeRootCopy = false;
- }
+ node.parent = parent;
+ node.depth = parent >= 0 ? w->wnodes[parent].depth + 1 : 0;
+ int nfolds = params.CVFolds;
- if( isMakeRootCopy )
+ if( nfolds > 0 )
{
- // make a copy of the root node
- CvDTreeNode temp;
- int i;
- root = new_node( 0, 1, 0, 0 );
- temp = *root;
- *root = *data_root;
- root->num_valid = temp.num_valid;
- if( root->num_valid )
- {
- for( i = 0; i < var_count; i++ )
- root->num_valid[i] = data_root->num_valid[i];
- }
- root->cv_Tn = temp.cv_Tn;
- root->cv_node_risk = temp.cv_node_risk;
- root->cv_node_error = temp.cv_node_error;
+ w->cv_Tn.resize((nidx+1)*nfolds);
+ w->cv_node_error.resize((nidx+1)*nfolds);
+ w->cv_node_risk.resize((nidx+1)*nfolds);
}
- else
- {
- int* sidx = isubsample_idx->data.i;
- // co - array of count/offset pairs (to handle duplicated values in _subsample_idx)
- int* co, cur_ofs = 0;
- int vi, i;
- int workVarCount = get_work_var_count();
- int count = isubsample_idx->rows + isubsample_idx->cols - 1;
-
- root = new_node( 0, count, 1, 0 );
-
- CV_CALL( subsample_co = cvCreateMat( 1, sample_count*2, CV_32SC1 ));
- cvZero( subsample_co );
- co = subsample_co->data.i;
- for( i = 0; i < count; i++ )
- co[sidx[i]*2]++;
- for( i = 0; i < sample_count; i++ )
- {
- if( co[i*2] )
- {
- co[i*2+1] = cur_ofs;
- cur_ofs += co[i*2];
- }
- else
- co[i*2+1] = -1;
- }
-
- cv::AutoBuffer<uchar> inn_buf(sample_count*(2*sizeof(int) + sizeof(float)));
- for( vi = 0; vi < workVarCount; vi++ )
- {
- int ci = get_var_type(vi);
- if( ci >= 0 || vi >= var_count )
- {
- int num_valid = 0;
- const int* src = CvDTreeTrainData::get_cat_var_data( data_root, vi, (int*)(uchar*)inn_buf );
+ int i, n = node.sample_count = (int)sidx.size();
+ bool can_split = true;
+ vector<int> sleft, sright;
- if (is_buf_16u)
- {
- unsigned short* udst = (unsigned short*)(buf->data.s + root->buf_idx*get_length_subbuf() +
- vi*sample_count + root->offset);
- for( i = 0; i < count; i++ )
- {
- int val = src[sidx[i]];
- udst[i] = (unsigned short)val;
- num_valid += val >= 0;
- }
- }
- else
- {
- int* idst = buf->data.i + root->buf_idx*get_length_subbuf() +
- vi*sample_count + root->offset;
- for( i = 0; i < count; i++ )
- {
- int val = src[sidx[i]];
- idst[i] = val;
- num_valid += val >= 0;
- }
- }
+ calcValue( nidx, sidx );
- if( vi < var_count )
- root->set_num_valid(vi, num_valid);
- }
- else
- {
- int *src_idx_buf = (int*)(uchar*)inn_buf;
- float *src_val_buf = (float*)(src_idx_buf + sample_count);
- int* sample_indices_buf = (int*)(src_val_buf + sample_count);
- const int* src_idx = 0;
- const float* src_val = 0;
- get_ord_var_data( data_root, vi, src_val_buf, src_idx_buf, &src_val, &src_idx, sample_indices_buf );
- int j = 0, idx, count_i;
- int num_valid = data_root->get_num_valid(vi);
-
- if (is_buf_16u)
- {
- unsigned short* udst_idx = (unsigned short*)(buf->data.s + root->buf_idx*get_length_subbuf() +
- vi*sample_count + data_root->offset);
- for( i = 0; i < num_valid; i++ )
- {
- idx = src_idx[i];
- count_i = co[idx*2];
- if( count_i )
- for( cur_ofs = co[idx*2+1]; count_i > 0; count_i--, j++, cur_ofs++ )
- udst_idx[j] = (unsigned short)cur_ofs;
- }
+ if( n <= params.minSampleCount || node.depth >= params.maxDepth )
+ can_split = false;
+ else if( _isClassifier )
+ {
+ const int* responses = &w->cat_responses[0];
+ const int* s = &sidx[0];
+ int first = responses[s[0]];
+ for( i = 1; i < n; i++ )
+ if( responses[s[i]] != first )
+ break;
+ if( i == n )
+ can_split = false;
+ }
+ else
+ {
+ if( sqrt(node.node_risk) < params.regressionAccuracy )
+ can_split = false;
+ }
- root->set_num_valid(vi, j);
+ if( can_split )
+ node.split = findBestSplit( sidx );
- for( ; i < sample_count; i++ )
- {
- idx = src_idx[i];
- count_i = co[idx*2];
- if( count_i )
- for( cur_ofs = co[idx*2+1]; count_i > 0; count_i--, j++, cur_ofs++ )
- udst_idx[j] = (unsigned short)cur_ofs;
- }
- }
- else
- {
- int* idst_idx = buf->data.i + root->buf_idx*get_length_subbuf() +
- vi*sample_count + root->offset;
- for( i = 0; i < num_valid; i++ )
- {
- idx = src_idx[i];
- count_i = co[idx*2];
- if( count_i )
- for( cur_ofs = co[idx*2+1]; count_i > 0; count_i--, j++, cur_ofs++ )
- idst_idx[j] = cur_ofs;
- }
+ //printf("depth=%d, nidx=%d, parent=%d, n=%d, %s, value=%.1f, risk=%.1f\n", node.depth, nidx, node.parent, n, (node.split < 0 ? "leaf" : varType[w->wsplits[node.split].varIdx] == VAR_CATEGORICAL ? "cat" : "ord"), node.value, node.node_risk);
- root->set_num_valid(vi, j);
+ if( node.split >= 0 )
+ {
+ node.defaultDir = calcDir( node.split, sidx, sleft, sright );
+ if( params.useSurrogates )
+ CV_Error( CV_StsNotImplemented, "surrogate splits are not implemented yet");
- for( ; i < sample_count; i++ )
- {
- idx = src_idx[i];
- count_i = co[idx*2];
- if( count_i )
- for( cur_ofs = co[idx*2+1]; count_i > 0; count_i--, j++, cur_ofs++ )
- idst_idx[j] = cur_ofs;
- }
- }
- }
- }
- // sample indices subsampling
- const int* sample_idx_src = get_sample_indices(data_root, (int*)(uchar*)inn_buf);
- if (is_buf_16u)
- {
- unsigned short* sample_idx_dst = (unsigned short*)(buf->data.s + root->buf_idx*get_length_subbuf() +
- workVarCount*sample_count + root->offset);
- for (i = 0; i < count; i++)
- sample_idx_dst[i] = (unsigned short)sample_idx_src[sidx[i]];
- }
- else
- {
- int* sample_idx_dst = buf->data.i + root->buf_idx*get_length_subbuf() +
- workVarCount*sample_count + root->offset;
- for (i = 0; i < count; i++)
- sample_idx_dst[i] = sample_idx_src[sidx[i]];
- }
+ w->wnodes[nidx].left = addNodeAndTrySplit( nidx, sleft );
+ w->wnodes[nidx].right = addNodeAndTrySplit( nidx, sright );
}
- __END__;
-
- cvReleaseMat( &isubsample_idx );
- cvReleaseMat( &subsample_co );
-
- return root;
+ return nidx;
}
-
-void CvDTreeTrainData::get_vectors( const CvMat* _subsample_idx,
- float* values, uchar* missing,
- float* _responses, bool get_class_idx )
+int DTreesImpl::findBestSplit( const vector<int>& _sidx )
{
- CvMat* subsample_idx = 0;
- CvMat* subsample_co = 0;
-
- CV_FUNCNAME( "CvDTreeTrainData::get_vectors" );
-
- __BEGIN__;
+ const vector<int>& activeVars = getActiveVars();
+ int splitidx = -1;
+ int vi_, nv = (int)activeVars.size();
+ AutoBuffer<int> buf(w->maxSubsetSize*2);
+ int *subset = buf, *best_subset = subset + w->maxSubsetSize;
+ WSplit split, best_split;
+ best_split.quality = 0.;
- int i, vi, total = sample_count, count = total, cur_ofs = 0;
- int* sidx = 0;
- int* co = 0;
-
- cv::AutoBuffer<uchar> inn_buf(sample_count*(2*sizeof(int) + sizeof(float)));
- if( _subsample_idx )
+ for( vi_ = 0; vi_ < nv; vi_++ )
{
- CV_CALL( subsample_idx = cvPreprocessIndexArray( _subsample_idx, sample_count ));
- sidx = subsample_idx->data.i;
- CV_CALL( subsample_co = cvCreateMat( 1, sample_count*2, CV_32SC1 ));
- co = subsample_co->data.i;
- cvZero( subsample_co );
- count = subsample_idx->cols + subsample_idx->rows - 1;
- for( i = 0; i < count; i++ )
- co[sidx[i]*2]++;
- for( i = 0; i < total; i++ )
+ int vi = activeVars[vi_];
+ if( varType[vi] == VAR_CATEGORICAL )
{
- int count_i = co[i*2];
- if( count_i )
- {
- co[i*2+1] = cur_ofs*var_count;
- cur_ofs += count_i;
- }
+ if( _isClassifier )
+ split = findSplitCatClass(vi, _sidx, 0, subset);
+ else
+ split = findSplitCatReg(vi, _sidx, 0, subset);
}
- }
-
- if( missing )
- memset( missing, 1, count*var_count );
-
- for( vi = 0; vi < var_count; vi++ )
- {
- int ci = get_var_type(vi);
- if( ci >= 0 ) // categorical
+ else
{
- float* dst = values + vi;
- uchar* m = missing ? missing + vi : 0;
- const int* src = get_cat_var_data(data_root, vi, (int*)(uchar*)inn_buf);
-
- for( i = 0; i < count; i++, dst += var_count )
- {
- int idx = sidx ? sidx[i] : i;
- int val = src[idx];
- *dst = (float)val;
- if( m )
- {
- *m = (!is_buf_16u && val < 0) || (is_buf_16u && (val == 65535));
- m += var_count;
- }
- }
+ if( _isClassifier )
+ split = findSplitOrdClass(vi, _sidx, 0);
+ else
+ split = findSplitOrdReg(vi, _sidx, 0);
}
- else // ordered
+ if( split.quality > best_split.quality )
{
- float* dst = values + vi;
- uchar* m = missing ? missing + vi : 0;
- int count1 = data_root->get_num_valid(vi);
- float *src_val_buf = (float*)(uchar*)inn_buf;
- int* src_idx_buf = (int*)(src_val_buf + sample_count);
- int* sample_indices_buf = src_idx_buf + sample_count;
- const float *src_val = 0;
- const int* src_idx = 0;
- get_ord_var_data(data_root, vi, src_val_buf, src_idx_buf, &src_val, &src_idx, sample_indices_buf);
-
- for( i = 0; i < count1; i++ )
- {
- int idx = src_idx[i];
- int count_i = 1;
- if( co )
- {
- count_i = co[idx*2];
- cur_ofs = co[idx*2+1];
- }
- else
- cur_ofs = idx*var_count;
- if( count_i )
- {
- float val = src_val[i];
- for( ; count_i > 0; count_i--, cur_ofs += var_count )
- {
- dst[cur_ofs] = val;
- if( m )
- m[cur_ofs] = 0;
- }
- }
- }
- }
- }
-
- // copy responses
- if( _responses )
- {
- if( is_classifier )
- {
- const int* src = get_class_labels(data_root, (int*)(uchar*)inn_buf);
- for( i = 0; i < count; i++ )
- {
- int idx = sidx ? sidx[i] : i;
- int val = get_class_idx ? src[idx] :
- cat_map->data.i[cat_ofs->data.i[cat_var_count]+src[idx]];
- _responses[i] = (float)val;
- }
- }
- else
- {
- float* val_buf = (float*)(uchar*)inn_buf;
- int* sample_idx_buf = (int*)(val_buf + sample_count);
- const float* _values = get_ord_responses(data_root, val_buf, sample_idx_buf);
- for( i = 0; i < count; i++ )
- {
- int idx = sidx ? sidx[i] : i;
- _responses[i] = _values[idx];
- }
- }
- }
-
- __END__;
-
- cvReleaseMat( &subsample_idx );
- cvReleaseMat( &subsample_co );
-}
-
-
-CvDTreeNode* CvDTreeTrainData::new_node( CvDTreeNode* parent, int count,
- int storage_idx, int offset )
-{
- CvDTreeNode* node = (CvDTreeNode*)cvSetNew( node_heap );
-
- node->sample_count = count;
- node->depth = parent ? parent->depth + 1 : 0;
- node->parent = parent;
- node->left = node->right = 0;
- node->split = 0;
- node->value = 0;
- node->class_idx = 0;
- node->maxlr = 0.;
-
- node->buf_idx = storage_idx;
- node->offset = offset;
- if( nv_heap )
- node->num_valid = (int*)cvSetNew( nv_heap );
- else
- node->num_valid = 0;
- node->alpha = node->node_risk = node->tree_risk = node->tree_error = 0.;
- node->complexity = 0;
-
- if( params.cv_folds > 0 && cv_heap )
- {
- int cv_n = params.cv_folds;
- node->Tn = INT_MAX;
- node->cv_Tn = (int*)cvSetNew( cv_heap );
- node->cv_node_risk = (double*)cvAlignPtr(node->cv_Tn + cv_n, sizeof(double));
- node->cv_node_error = node->cv_node_risk + cv_n;
- }
- else
- {
- node->Tn = 0;
- node->cv_Tn = 0;
- node->cv_node_risk = 0;
- node->cv_node_error = 0;
- }
-
- return node;
-}
-
-
-CvDTreeSplit* CvDTreeTrainData::new_split_ord( int vi, float cmp_val,
- int split_point, int inversed, float quality )
-{
- CvDTreeSplit* split = (CvDTreeSplit*)cvSetNew( split_heap );
- split->var_idx = vi;
- split->condensed_idx = INT_MIN;
- split->ord.c = cmp_val;
- split->ord.split_point = split_point;
- split->inversed = inversed;
- split->quality = quality;
- split->next = 0;
-
- return split;
-}
-
-
-CvDTreeSplit* CvDTreeTrainData::new_split_cat( int vi, float quality )
-{
- CvDTreeSplit* split = (CvDTreeSplit*)cvSetNew( split_heap );
- int i, n = (max_c_count + 31)/32;
-
- split->var_idx = vi;
- split->condensed_idx = INT_MIN;
- split->inversed = 0;
- split->quality = quality;
- for( i = 0; i < n; i++ )
- split->subset[i] = 0;
- split->next = 0;
-
- return split;
-}
-
-
-void CvDTreeTrainData::free_node( CvDTreeNode* node )
-{
- CvDTreeSplit* split = node->split;
- free_node_data( node );
- while( split )
- {
- CvDTreeSplit* next = split->next;
- cvSetRemoveByPtr( split_heap, split );
- split = next;
- }
- node->split = 0;
- cvSetRemoveByPtr( node_heap, node );
-}
-
-
-void CvDTreeTrainData::free_node_data( CvDTreeNode* node )
-{
- if( node->num_valid )
- {
- cvSetRemoveByPtr( nv_heap, node->num_valid );
- node->num_valid = 0;
- }
- // do not free cv_* fields, as all the cross-validation related data is released at once.
-}
-
-
-void CvDTreeTrainData::free_train_data()
-{
- cvReleaseMat( &counts );
- cvReleaseMat( &buf );
- cvReleaseMat( &direction );
- cvReleaseMat( &split_buf );
- cvReleaseMemStorage( &temp_storage );
- cvReleaseMat( &responses_copy );
- cv_heap = nv_heap = 0;
-}
-
-
-void CvDTreeTrainData::clear()
-{
- free_train_data();
-
- cvReleaseMemStorage( &tree_storage );
-
- cvReleaseMat( &var_idx );
- cvReleaseMat( &var_type );
- cvReleaseMat( &cat_count );
- cvReleaseMat( &cat_ofs );
- cvReleaseMat( &cat_map );
- cvReleaseMat( &priors );
- cvReleaseMat( &priors_mult );
-
- node_heap = split_heap = 0;
-
- sample_count = var_all = var_count = max_c_count = ord_var_count = cat_var_count = 0;
- have_labels = have_priors = is_classifier = false;
-
- buf_count = buf_size = 0;
- shared = false;
-
- data_root = 0;
-
- rng = &cv::theRNG();
-}
-
-
-int CvDTreeTrainData::get_num_classes() const
-{
- return is_classifier ? cat_count->data.i[cat_var_count] : 0;
-}
-
-
-int CvDTreeTrainData::get_var_type(int vi) const
-{
- return var_type->data.i[vi];
-}
-
-void CvDTreeTrainData::get_ord_var_data( CvDTreeNode* n, int vi, float* ord_values_buf, int* sorted_indices_buf,
- const float** ord_values, const int** sorted_indices, int* sample_indices_buf )
-{
- int vidx = var_idx ? var_idx->data.i[vi] : vi;
- int node_sample_count = n->sample_count;
- int td_step = train_data->step/CV_ELEM_SIZE(train_data->type);
-
- const int* sample_indices = get_sample_indices(n, sample_indices_buf);
-
- if( !is_buf_16u )
- *sorted_indices = buf->data.i + n->buf_idx*get_length_subbuf() +
- vi*sample_count + n->offset;
- else {
- const unsigned short* short_indices = (const unsigned short*)(buf->data.s + n->buf_idx*get_length_subbuf() +
- vi*sample_count + n->offset );
- for( int i = 0; i < node_sample_count; i++ )
- sorted_indices_buf[i] = short_indices[i];
- *sorted_indices = sorted_indices_buf;
- }
-
- if( tflag == CV_ROW_SAMPLE )
- {
- for( int i = 0; i < node_sample_count &&
- ((((*sorted_indices)[i] >= 0) && !is_buf_16u) || (((*sorted_indices)[i] != 65535) && is_buf_16u)); i++ )
- {
- int idx = (*sorted_indices)[i];
- idx = sample_indices[idx];
- ord_values_buf[i] = *(train_data->data.fl + idx * td_step + vidx);
- }
- }
- else
- for( int i = 0; i < node_sample_count &&
- ((((*sorted_indices)[i] >= 0) && !is_buf_16u) || (((*sorted_indices)[i] != 65535) && is_buf_16u)); i++ )
- {
- int idx = (*sorted_indices)[i];
- idx = sample_indices[idx];
- ord_values_buf[i] = *(train_data->data.fl + vidx* td_step + idx);
- }
-
- *ord_values = ord_values_buf;
-}
-
-
-const int* CvDTreeTrainData::get_class_labels( CvDTreeNode* n, int* labels_buf )
-{
- if (is_classifier)
- return get_cat_var_data( n, var_count, labels_buf);
- return 0;
-}
-
-const int* CvDTreeTrainData::get_sample_indices( CvDTreeNode* n, int* indices_buf )
-{
- return get_cat_var_data( n, get_work_var_count(), indices_buf );
-}
-
-const float* CvDTreeTrainData::get_ord_responses( CvDTreeNode* n, float* values_buf, int*sample_indices_buf )
-{
- int _sample_count = n->sample_count;
- int r_step = CV_IS_MAT_CONT(responses->type) ? 1 : responses->step/CV_ELEM_SIZE(responses->type);
- const int* indices = get_sample_indices(n, sample_indices_buf);
-
- for( int i = 0; i < _sample_count &&
- (((indices[i] >= 0) && !is_buf_16u) || ((indices[i] != 65535) && is_buf_16u)); i++ )
- {
- int idx = indices[i];
- values_buf[i] = *(responses->data.fl + idx * r_step);
- }
-
- return values_buf;
-}
-
-
-const int* CvDTreeTrainData::get_cv_labels( CvDTreeNode* n, int* labels_buf )
-{
- if (have_labels)
- return get_cat_var_data( n, get_work_var_count()- 1, labels_buf);
- return 0;
-}
-
-
-const int* CvDTreeTrainData::get_cat_var_data( CvDTreeNode* n, int vi, int* cat_values_buf)
-{
- const int* cat_values = 0;
- if( !is_buf_16u )
- cat_values = buf->data.i + n->buf_idx*get_length_subbuf() +
- vi*sample_count + n->offset;
- else {
- const unsigned short* short_values = (const unsigned short*)(buf->data.s + n->buf_idx*get_length_subbuf() +
- vi*sample_count + n->offset);
- for( int i = 0; i < n->sample_count; i++ )
- cat_values_buf[i] = short_values[i];
- cat_values = cat_values_buf;
- }
- return cat_values;
-}
-
-
-int CvDTreeTrainData::get_child_buf_idx( CvDTreeNode* n )
-{
- int idx = n->buf_idx + 1;
- if( idx >= buf_count )
- idx = shared ? 1 : 0;
- return idx;
-}
-
-
-void CvDTreeTrainData::write_params( CvFileStorage* fs ) const
-{
- CV_FUNCNAME( "CvDTreeTrainData::write_params" );
-
- __BEGIN__;
-
- int vi, vcount = var_count;
-
- cvWriteInt( fs, "is_classifier", is_classifier ? 1 : 0 );
- cvWriteInt( fs, "var_all", var_all );
- cvWriteInt( fs, "var_count", var_count );
- cvWriteInt( fs, "ord_var_count", ord_var_count );
- cvWriteInt( fs, "cat_var_count", cat_var_count );
-
- cvStartWriteStruct( fs, "training_params", CV_NODE_MAP );
- cvWriteInt( fs, "use_surrogates", params.use_surrogates ? 1 : 0 );
-
- if( is_classifier )
- {
- cvWriteInt( fs, "max_categories", params.max_categories );
- }
- else
- {
- cvWriteReal( fs, "regression_accuracy", params.regression_accuracy );
- }
-
- cvWriteInt( fs, "max_depth", params.max_depth );
- cvWriteInt( fs, "min_sample_count", params.min_sample_count );
- cvWriteInt( fs, "cross_validation_folds", params.cv_folds );
-
- if( params.cv_folds > 1 )
- {
- cvWriteInt( fs, "use_1se_rule", params.use_1se_rule ? 1 : 0 );
- cvWriteInt( fs, "truncate_pruned_tree", params.truncate_pruned_tree ? 1 : 0 );
- }
-
- if( priors )
- cvWrite( fs, "priors", priors );
-
- cvEndWriteStruct( fs );
-
- if( var_idx )
- cvWrite( fs, "var_idx", var_idx );
-
- cvStartWriteStruct( fs, "var_type", CV_NODE_SEQ+CV_NODE_FLOW );
-
- for( vi = 0; vi < vcount; vi++ )
- cvWriteInt( fs, 0, var_type->data.i[vi] >= 0 );
-
- cvEndWriteStruct( fs );
-
- if( cat_count && (cat_var_count > 0 || is_classifier) )
- {
- CV_ASSERT( cat_count != 0 );
- cvWrite( fs, "cat_count", cat_count );
- cvWrite( fs, "cat_map", cat_map );
- }
-
- __END__;
-}
-
-
-void CvDTreeTrainData::read_params( CvFileStorage* fs, CvFileNode* node )
-{
- CV_FUNCNAME( "CvDTreeTrainData::read_params" );
-
- __BEGIN__;
-
- CvFileNode *tparams_node, *vartype_node;
- CvSeqReader reader;
- int vi, max_split_size, tree_block_size;
-
- is_classifier = (cvReadIntByName( fs, node, "is_classifier" ) != 0);
- var_all = cvReadIntByName( fs, node, "var_all" );
- var_count = cvReadIntByName( fs, node, "var_count", var_all );
- cat_var_count = cvReadIntByName( fs, node, "cat_var_count" );
- ord_var_count = cvReadIntByName( fs, node, "ord_var_count" );
-
- tparams_node = cvGetFileNodeByName( fs, node, "training_params" );
-
- if( tparams_node ) // training parameters are not necessary
- {
- params.use_surrogates = cvReadIntByName( fs, tparams_node, "use_surrogates", 1 ) != 0;
-
- if( is_classifier )
- {
- params.max_categories = cvReadIntByName( fs, tparams_node, "max_categories" );
- }
- else
- {
- params.regression_accuracy =
- (float)cvReadRealByName( fs, tparams_node, "regression_accuracy" );
- }
-
- params.max_depth = cvReadIntByName( fs, tparams_node, "max_depth" );
- params.min_sample_count = cvReadIntByName( fs, tparams_node, "min_sample_count" );
- params.cv_folds = cvReadIntByName( fs, tparams_node, "cross_validation_folds" );
-
- if( params.cv_folds > 1 )
- {
- params.use_1se_rule = cvReadIntByName( fs, tparams_node, "use_1se_rule" ) != 0;
- params.truncate_pruned_tree =
- cvReadIntByName( fs, tparams_node, "truncate_pruned_tree" ) != 0;
- }
-
- priors = (CvMat*)cvReadByName( fs, tparams_node, "priors" );
- if( priors )
- {
- if( !CV_IS_MAT(priors) )
- CV_ERROR( CV_StsParseError, "priors must stored as a matrix" );
- priors_mult = cvCloneMat( priors );
- }
- }
-
- CV_CALL( var_idx = (CvMat*)cvReadByName( fs, node, "var_idx" ));
- if( var_idx )
- {
- if( !CV_IS_MAT(var_idx) ||
- (var_idx->cols != 1 && var_idx->rows != 1) ||
- var_idx->cols + var_idx->rows - 1 != var_count ||
- CV_MAT_TYPE(var_idx->type) != CV_32SC1 )
- CV_ERROR( CV_StsParseError,
- "var_idx (if exist) must be valid 1d integer vector containing <var_count> elements" );
-
- for( vi = 0; vi < var_count; vi++ )
- if( (unsigned)var_idx->data.i[vi] >= (unsigned)var_all )
- CV_ERROR( CV_StsOutOfRange, "some of var_idx elements are out of range" );
- }
-
- ////// read var type
- CV_CALL( var_type = cvCreateMat( 1, var_count + 2, CV_32SC1 ));
-
- cat_var_count = 0;
- ord_var_count = -1;
- vartype_node = cvGetFileNodeByName( fs, node, "var_type" );
-
- if( vartype_node && CV_NODE_TYPE(vartype_node->tag) == CV_NODE_INT && var_count == 1 )
- var_type->data.i[0] = vartype_node->data.i ? cat_var_count++ : ord_var_count--;
- else
- {
- if( !vartype_node || CV_NODE_TYPE(vartype_node->tag) != CV_NODE_SEQ ||
- vartype_node->data.seq->total != var_count )
- CV_ERROR( CV_StsParseError, "var_type must exist and be a sequence of 0's and 1's" );
-
- cvStartReadSeq( vartype_node->data.seq, &reader );
-
- for( vi = 0; vi < var_count; vi++ )
- {
- CvFileNode* n = (CvFileNode*)reader.ptr;
- if( CV_NODE_TYPE(n->tag) != CV_NODE_INT || (n->data.i & ~1) )
- CV_ERROR( CV_StsParseError, "var_type must exist and be a sequence of 0's and 1's" );
- var_type->data.i[vi] = n->data.i ? cat_var_count++ : ord_var_count--;
- CV_NEXT_SEQ_ELEM( reader.seq->elem_size, reader );
- }
- }
- var_type->data.i[var_count] = cat_var_count;
-
- ord_var_count = ~ord_var_count;
- //////
-
- if( cat_var_count > 0 || is_classifier )
- {
- int ccount, total_c_count = 0;
- CV_CALL( cat_count = (CvMat*)cvReadByName( fs, node, "cat_count" ));
- CV_CALL( cat_map = (CvMat*)cvReadByName( fs, node, "cat_map" ));
-
- if( !CV_IS_MAT(cat_count) || !CV_IS_MAT(cat_map) ||
- (cat_count->cols != 1 && cat_count->rows != 1) ||
- CV_MAT_TYPE(cat_count->type) != CV_32SC1 ||
- cat_count->cols + cat_count->rows - 1 != cat_var_count + is_classifier ||
- (cat_map->cols != 1 && cat_map->rows != 1) ||
- CV_MAT_TYPE(cat_map->type) != CV_32SC1 )
- CV_ERROR( CV_StsParseError,
- "Both cat_count and cat_map must exist and be valid 1d integer vectors of an appropriate size" );
-
- ccount = cat_var_count + is_classifier;
-
- CV_CALL( cat_ofs = cvCreateMat( 1, ccount + 1, CV_32SC1 ));
- cat_ofs->data.i[0] = 0;
- max_c_count = 1;
-
- for( vi = 0; vi < ccount; vi++ )
- {
- int val = cat_count->data.i[vi];
- if( val <= 0 )
- CV_ERROR( CV_StsOutOfRange, "some of cat_count elements are out of range" );
- max_c_count = MAX( max_c_count, val );
- cat_ofs->data.i[vi+1] = total_c_count += val;
- }
-
- if( cat_map->cols + cat_map->rows - 1 != total_c_count )
- CV_ERROR( CV_StsBadSize,
- "cat_map vector length is not equal to the total number of categories in all categorical vars" );
- }
-
- max_split_size = cvAlign(sizeof(CvDTreeSplit) +
- (MAX(0,max_c_count - 33)/32)*sizeof(int),sizeof(void*));
-
- tree_block_size = MAX((int)sizeof(CvDTreeNode)*8, max_split_size);
- tree_block_size = MAX(tree_block_size + block_size_delta, min_block_size);
- CV_CALL( tree_storage = cvCreateMemStorage( tree_block_size ));
- CV_CALL( node_heap = cvCreateSet( 0, sizeof(node_heap[0]),
- sizeof(CvDTreeNode), tree_storage ));
- CV_CALL( split_heap = cvCreateSet( 0, sizeof(split_heap[0]),
- max_split_size, tree_storage ));
-
- __END__;
-}
-
-/////////////////////// Decision Tree /////////////////////////
-CvDTreeParams::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::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)
-{}
-
-CvDTree::CvDTree()
-{
- data = 0;
- var_importance = 0;
- default_model_name = "my_tree";
-
- clear();
-}
-
-
-void CvDTree::clear()
-{
- cvReleaseMat( &var_importance );
- if( data )
- {
- if( !data->shared )
- delete data;
- else
- free_tree();
- data = 0;
- }
- root = 0;
- pruned_tree_idx = -1;
-}
-
-
-CvDTree::~CvDTree()
-{
- clear();
-}
-
-
-const CvDTreeNode* CvDTree::get_root() const
-{
- return root;
-}
-
-
-int CvDTree::get_pruned_tree_idx() const
-{
- return pruned_tree_idx;
-}
-
-
-CvDTreeTrainData* CvDTree::get_data()
-{
- return data;
-}
-
-
-bool CvDTree::train( const CvMat* _train_data, int _tflag,
- const CvMat* _responses, const CvMat* _var_idx,
- const CvMat* _sample_idx, const CvMat* _var_type,
- const CvMat* _missing_mask, CvDTreeParams _params )
-{
- bool result = false;
-
- CV_FUNCNAME( "CvDTree::train" );
-
- __BEGIN__;
-
- clear();
- data = new CvDTreeTrainData( _train_data, _tflag, _responses,
- _var_idx, _sample_idx, _var_type,
- _missing_mask, _params, false );
- CV_CALL( result = do_train(0) );
-
- __END__;
-
- return result;
-}
-
-bool CvDTree::train( const Mat& _train_data, int _tflag,
- const Mat& _responses, const Mat& _var_idx,
- const Mat& _sample_idx, const Mat& _var_type,
- const Mat& _missing_mask, CvDTreeParams _params )
-{
- train_data_hdr = _train_data;
- train_data_mat = _train_data;
- responses_hdr = _responses;
- responses_mat = _responses;
-
- CvMat vidx=_var_idx, sidx=_sample_idx, vtype=_var_type, mmask=_missing_mask;
-
- return train(&train_data_hdr, _tflag, &responses_hdr, vidx.data.ptr ? &vidx : 0, sidx.data.ptr ? &sidx : 0,
- vtype.data.ptr ? &vtype : 0, mmask.data.ptr ? &mmask : 0, _params);
-}
-
-
-bool CvDTree::train( CvMLData* _data, CvDTreeParams _params )
-{
- bool result = false;
-
- CV_FUNCNAME( "CvDTree::train" );
-
- __BEGIN__;
-
- const CvMat* values = _data->get_values();
- const CvMat* response = _data->get_responses();
- const CvMat* missing = _data->get_missing();
- const CvMat* var_types = _data->get_var_types();
- const CvMat* train_sidx = _data->get_train_sample_idx();
- const CvMat* var_idx = _data->get_var_idx();
-
- CV_CALL( result = train( values, CV_ROW_SAMPLE, response, var_idx,
- train_sidx, var_types, missing, _params ) );
-
- __END__;
-
- return result;
-}
-
-bool CvDTree::train( CvDTreeTrainData* _data, const CvMat* _subsample_idx )
-{
- bool result = false;
-
- CV_FUNCNAME( "CvDTree::train" );
-
- __BEGIN__;
-
- clear();
- data = _data;
- data->shared = true;
- CV_CALL( result = do_train(_subsample_idx));
-
- __END__;
-
- return result;
-}
-
-
-bool CvDTree::do_train( const CvMat* _subsample_idx )
-{
- bool result = false;
-
- CV_FUNCNAME( "CvDTree::do_train" );
-
- __BEGIN__;
-
- root = data->subsample_data( _subsample_idx );
-
- CV_CALL( try_split_node(root));
-
- if( root->split )
- {
- CV_Assert( root->left );
- CV_Assert( root->right );
-
- if( data->params.cv_folds > 0 )
- CV_CALL( prune_cv() );
-
- if( !data->shared )
- data->free_train_data();
-
- result = true;
- }
-
- __END__;
-
- return result;
-}
-
-
-void CvDTree::try_split_node( CvDTreeNode* node )
-{
- CvDTreeSplit* best_split = 0;
- int i, n = node->sample_count, vi;
- bool can_split = true;
- double quality_scale;
-
- calc_node_value( node );
-
- if( node->sample_count <= data->params.min_sample_count ||
- node->depth >= data->params.max_depth )
- can_split = false;
-
- if( can_split && data->is_classifier )
- {
- // check if we have a "pure" node,
- // we assume that cls_count is filled by calc_node_value()
- int* cls_count = data->counts->data.i;
- int nz = 0, m = data->get_num_classes();
- for( i = 0; i < m; i++ )
- nz += cls_count[i] != 0;
- if( nz == 1 ) // there is only one class
- can_split = false;
- }
- else if( can_split )
- {
- if( sqrt(node->node_risk)/n < data->params.regression_accuracy )
- can_split = false;
- }
-
- if( can_split )
- {
- best_split = find_best_split(node);
- // TODO: check the split quality ...
- node->split = best_split;
- }
- if( !can_split || !best_split )
- {
- data->free_node_data(node);
- return;
- }
-
- quality_scale = calc_node_dir( node );
- if( data->params.use_surrogates )
- {
- // find all the surrogate splits
- // and sort them by their similarity to the primary one
- for( vi = 0; vi < data->var_count; vi++ )
- {
- CvDTreeSplit* split;
- int ci = data->get_var_type(vi);
-
- if( vi == best_split->var_idx )
- continue;
-
- if( ci >= 0 )
- split = find_surrogate_split_cat( node, vi );
- else
- split = find_surrogate_split_ord( node, vi );
-
- if( split )
- {
- // insert the split
- CvDTreeSplit* prev_split = node->split;
- split->quality = (float)(split->quality*quality_scale);
-
- while( prev_split->next &&
- prev_split->next->quality > split->quality )
- prev_split = prev_split->next;
- split->next = prev_split->next;
- prev_split->next = split;
- }
- }
- }
- split_node_data( node );
- try_split_node( node->left );
- try_split_node( node->right );
-}
-
-
-// calculate direction (left(-1),right(1),missing(0))
-// for each sample using the best split
-// the function returns scale coefficients for surrogate split quality factors.
-// the scale is applied to normalize surrogate split quality relatively to the
-// best (primary) split quality. That is, if a surrogate split is absolutely
-// identical to the primary split, its quality will be set to the maximum value =
-// quality of the primary split; otherwise, it will be lower.
-// besides, the function compute node->maxlr,
-// minimum possible quality (w/o considering the above mentioned scale)
-// for a surrogate split. Surrogate splits with quality less than node->maxlr
-// are not discarded.
-double CvDTree::calc_node_dir( CvDTreeNode* node )
-{
- char* dir = (char*)data->direction->data.ptr;
- int i, n = node->sample_count, vi = node->split->var_idx;
- double L, R;
-
- assert( !node->split->inversed );
-
- if( data->get_var_type(vi) >= 0 ) // split on categorical var
- {
- cv::AutoBuffer<int> inn_buf(n*(!data->have_priors ? 1 : 2));
- int* labels_buf = (int*)inn_buf;
- const int* labels = data->get_cat_var_data( node, vi, labels_buf );
- const int* subset = node->split->subset;
- if( !data->have_priors )
- {
- int sum = 0, sum_abs = 0;
-
- for( i = 0; i < n; i++ )
- {
- int idx = labels[i];
- int d = ( ((idx >= 0)&&(!data->is_buf_16u)) || ((idx != 65535)&&(data->is_buf_16u)) ) ?
- CV_DTREE_CAT_DIR(idx,subset) : 0;
- sum += d; sum_abs += d & 1;
- dir[i] = (char)d;
- }
-
- R = (sum_abs + sum) >> 1;
- L = (sum_abs - sum) >> 1;
- }
- else
- {
- const double* priors = data->priors_mult->data.db;
- double sum = 0, sum_abs = 0;
- int* responses_buf = labels_buf + n;
- const int* responses = data->get_class_labels(node, responses_buf);
-
- for( i = 0; i < n; i++ )
- {
- int idx = labels[i];
- double w = priors[responses[i]];
- int d = idx >= 0 ? CV_DTREE_CAT_DIR(idx,subset) : 0;
- sum += d*w; sum_abs += (d & 1)*w;
- dir[i] = (char)d;
- }
-
- R = (sum_abs + sum) * 0.5;
- L = (sum_abs - sum) * 0.5;
- }
- }
- else // split on ordered var
- {
- int split_point = node->split->ord.split_point;
- int n1 = node->get_num_valid(vi);
- cv::AutoBuffer<uchar> inn_buf(n*(sizeof(int)*(data->have_priors ? 3 : 2) + sizeof(float)));
- float* val_buf = (float*)(uchar*)inn_buf;
- int* sorted_buf = (int*)(val_buf + n);
- int* sample_idx_buf = sorted_buf + n;
- const float* val = 0;
- const int* sorted = 0;
- data->get_ord_var_data( node, vi, val_buf, sorted_buf, &val, &sorted, sample_idx_buf);
-
- assert( 0 <= split_point && split_point < n1-1 );
-
- if( !data->have_priors )
- {
- for( i = 0; i <= split_point; i++ )
- dir[sorted[i]] = (char)-1;
- for( ; i < n1; i++ )
- dir[sorted[i]] = (char)1;
- for( ; i < n; i++ )
- dir[sorted[i]] = (char)0;
-
- L = split_point-1;
- R = n1 - split_point + 1;
- }
- else
- {
- const double* priors = data->priors_mult->data.db;
- int* responses_buf = sample_idx_buf + n;
- const int* responses = data->get_class_labels(node, responses_buf);
- L = R = 0;
-
- for( i = 0; i <= split_point; i++ )
- {
- int idx = sorted[i];
- double w = priors[responses[idx]];
- dir[idx] = (char)-1;
- L += w;
- }
-
- for( ; i < n1; i++ )
- {
- int idx = sorted[i];
- double w = priors[responses[idx]];
- dir[idx] = (char)1;
- R += w;
- }
-
- for( ; i < n; i++ )
- dir[sorted[i]] = (char)0;
- }
- }
- node->maxlr = MAX( L, R );
- return node->split->quality/(L + R);
-}
-
-
-namespace cv
-{
-
-template<> CV_EXPORTS void DefaultDeleter<CvDTreeSplit>::operator ()(CvDTreeSplit* obj) const
-{
- fastFree(obj);
-}
-
-DTreeBestSplitFinder::DTreeBestSplitFinder( CvDTree* _tree, CvDTreeNode* _node)
-{
- tree = _tree;
- node = _node;
- splitSize = tree->get_data()->split_heap->elem_size;
-
- bestSplit.reset((CvDTreeSplit*)fastMalloc(splitSize));
- memset(bestSplit.get(), 0, splitSize);
- bestSplit->quality = -1;
- bestSplit->condensed_idx = INT_MIN;
- split.reset((CvDTreeSplit*)fastMalloc(splitSize));
- memset(split.get(), 0, splitSize);
- //haveSplit = false;
-}
-
-DTreeBestSplitFinder::DTreeBestSplitFinder( const DTreeBestSplitFinder& finder, Split )
-{
- tree = finder.tree;
- node = finder.node;
- splitSize = tree->get_data()->split_heap->elem_size;
-
- bestSplit.reset((CvDTreeSplit*)fastMalloc(splitSize));
- memcpy(bestSplit.get(), finder.bestSplit.get(), splitSize);
- split.reset((CvDTreeSplit*)fastMalloc(splitSize));
- memset(split.get(), 0, splitSize);
-}
-
-void DTreeBestSplitFinder::operator()(const BlockedRange& range)
-{
- int vi, vi1 = range.begin(), vi2 = range.end();
- int n = node->sample_count;
- CvDTreeTrainData* data = tree->get_data();
- AutoBuffer<uchar> inn_buf(2*n*(sizeof(int) + sizeof(float)));
-
- for( vi = vi1; vi < vi2; vi++ )
- {
- CvDTreeSplit *res;
- int ci = data->get_var_type(vi);
- if( node->get_num_valid(vi) <= 1 )
- continue;
-
- if( data->is_classifier )
- {
- if( ci >= 0 )
- res = tree->find_split_cat_class( node, vi, bestSplit->quality, split, (uchar*)inn_buf );
- else
- res = tree->find_split_ord_class( node, vi, bestSplit->quality, split, (uchar*)inn_buf );
- }
- else
- {
- if( ci >= 0 )
- res = tree->find_split_cat_reg( node, vi, bestSplit->quality, split, (uchar*)inn_buf );
- else
- res = tree->find_split_ord_reg( node, vi, bestSplit->quality, split, (uchar*)inn_buf );
- }
-
- if( res && bestSplit->quality < split->quality )
- memcpy( bestSplit.get(), split.get(), splitSize );
- }
-}
-
-void DTreeBestSplitFinder::join( DTreeBestSplitFinder& rhs )
-{
- if( bestSplit->quality < rhs.bestSplit->quality )
- memcpy( bestSplit.get(), rhs.bestSplit.get(), splitSize );
-}
-}
-
-
-CvDTreeSplit* CvDTree::find_best_split( CvDTreeNode* node )
-{
- DTreeBestSplitFinder finder( this, node );
-
- cv::parallel_reduce(cv::BlockedRange(0, data->var_count), finder);
-
- CvDTreeSplit *bestSplit = 0;
- if( finder.bestSplit->quality > 0 )
- {
- bestSplit = data->new_split_cat( 0, -1.0f );
- memcpy( bestSplit, finder.bestSplit, finder.splitSize );
- }
-
- return bestSplit;
-}
-
-CvDTreeSplit* CvDTree::find_split_ord_class( CvDTreeNode* node, int vi,
- float init_quality, CvDTreeSplit* _split, uchar* _ext_buf )
-{
- const float epsilon = FLT_EPSILON*2;
- int n = node->sample_count;
- int n1 = node->get_num_valid(vi);
- int m = data->get_num_classes();
-
- int base_size = 2*m*sizeof(int);
- cv::AutoBuffer<uchar> inn_buf(base_size);
- if( !_ext_buf )
- inn_buf.allocate(base_size + n*(3*sizeof(int)+sizeof(float)));
- uchar* base_buf = (uchar*)inn_buf;
- uchar* ext_buf = _ext_buf ? _ext_buf : base_buf + base_size;
- float* values_buf = (float*)ext_buf;
- int* sorted_indices_buf = (int*)(values_buf + n);
- int* sample_indices_buf = sorted_indices_buf + n;
- const float* values = 0;
- const int* sorted_indices = 0;
- data->get_ord_var_data( node, vi, values_buf, sorted_indices_buf, &values,
- &sorted_indices, sample_indices_buf );
- int* responses_buf = sample_indices_buf + n;
- const int* responses = data->get_class_labels( node, responses_buf );
-
- const int* rc0 = data->counts->data.i;
- int* lc = (int*)base_buf;
- int* rc = lc + m;
- int i, best_i = -1;
- double lsum2 = 0, rsum2 = 0, best_val = init_quality;
- const double* priors = data->have_priors ? data->priors_mult->data.db : 0;
-
- // init arrays of class instance counters on both sides of the split
- for( i = 0; i < m; i++ )
- {
- lc[i] = 0;
- rc[i] = rc0[i];
- }
-
- // compensate for missing values
- for( i = n1; i < n; i++ )
- {
- rc[responses[sorted_indices[i]]]--;
- }
-
- if( !priors )
- {
- int L = 0, R = n1;
-
- for( i = 0; i < m; i++ )
- rsum2 += (double)rc[i]*rc[i];
-
- for( i = 0; i < n1 - 1; i++ )
- {
- int idx = responses[sorted_indices[i]];
- int lv, rv;
- L++; R--;
- lv = lc[idx]; rv = rc[idx];
- lsum2 += lv*2 + 1;
- rsum2 -= rv*2 - 1;
- lc[idx] = lv + 1; rc[idx] = rv - 1;
-
- if( values[i] + epsilon < values[i+1] )
- {
- double val = (lsum2*R + rsum2*L)/((double)L*R);
- if( best_val < val )
- {
- best_val = val;
- best_i = i;
- }
- }
- }
- }
- else
- {
- double L = 0, R = 0;
- for( i = 0; i < m; i++ )
- {
- double wv = rc[i]*priors[i];
- R += wv;
- rsum2 += wv*wv;
- }
-
- for( i = 0; i < n1 - 1; i++ )
- {
- int idx = responses[sorted_indices[i]];
- int lv, rv;
- double p = priors[idx], p2 = p*p;
- L += p; R -= p;
- lv = lc[idx]; rv = rc[idx];
- lsum2 += p2*(lv*2 + 1);
- rsum2 -= p2*(rv*2 - 1);
- lc[idx] = lv + 1; rc[idx] = rv - 1;
-
- if( values[i] + epsilon < values[i+1] )
- {
- double val = (lsum2*R + rsum2*L)/((double)L*R);
- if( best_val < val )
- {
- best_val = val;
- best_i = i;
- }
- }
- }
- }
-
- CvDTreeSplit* split = 0;
- if( best_i >= 0 )
- {
- split = _split ? _split : data->new_split_ord( 0, 0.0f, 0, 0, 0.0f );
- split->var_idx = vi;
- split->ord.c = (values[best_i] + values[best_i+1])*0.5f;
- split->ord.split_point = best_i;
- split->inversed = 0;
- split->quality = (float)best_val;
- }
- return split;
-}
-
-
-void CvDTree::cluster_categories( const int* vectors, int n, int m,
- int* csums, int k, int* labels )
-{
- // TODO: consider adding priors (class weights) and sample weights to the clustering algorithm
- int iters = 0, max_iters = 100;
- int i, j, idx;
- cv::AutoBuffer<double> buf(n + k);
- double *v_weights = buf, *c_weights = buf + n;
- bool modified = true;
- RNG* r = data->rng;
-
- // assign labels randomly
- for( i = 0; i < n; i++ )
- {
- int sum = 0;
- const int* v = vectors + i*m;
- labels[i] = i < k ? i : r->uniform(0, k);
-
- // compute weight of each vector
- for( j = 0; j < m; j++ )
- sum += v[j];
- v_weights[i] = sum ? 1./sum : 0.;
- }
-
- for( i = 0; i < n; i++ )
- {
- int i1 = (*r)(n);
- int i2 = (*r)(n);
- CV_SWAP( labels[i1], labels[i2], j );
- }
-
- for( iters = 0; iters <= max_iters; iters++ )
- {
- // calculate csums
- for( i = 0; i < k; i++ )
- {
- for( j = 0; j < m; j++ )
- csums[i*m + j] = 0;
- }
-
- for( i = 0; i < n; i++ )
- {
- const int* v = vectors + i*m;
- int* s = csums + labels[i]*m;
- for( j = 0; j < m; j++ )
- s[j] += v[j];
- }
-
- // exit the loop here, when we have up-to-date csums
- if( iters == max_iters || !modified )
- break;
-
- modified = false;
-
- // calculate weight of each cluster
- for( i = 0; i < k; i++ )
- {
- const int* s = csums + i*m;
- int sum = 0;
- for( j = 0; j < m; j++ )
- sum += s[j];
- c_weights[i] = sum ? 1./sum : 0;
- }
-
- // now for each vector determine the closest cluster
- for( i = 0; i < n; i++ )
- {
- const int* v = vectors + i*m;
- double alpha = v_weights[i];
- double min_dist2 = DBL_MAX;
- int min_idx = -1;
-
- for( idx = 0; idx < k; idx++ )
- {
- const int* s = csums + idx*m;
- double dist2 = 0., beta = c_weights[idx];
- for( j = 0; j < m; j++ )
- {
- double t = v[j]*alpha - s[j]*beta;
- dist2 += t*t;
- }
- if( min_dist2 > dist2 )
- {
- min_dist2 = dist2;
- min_idx = idx;
- }
- }
-
- if( min_idx != labels[i] )
- modified = true;
- labels[i] = min_idx;
- }
- }
-}
-
-
-CvDTreeSplit* CvDTree::find_split_cat_class( CvDTreeNode* node, int vi, float init_quality,
- CvDTreeSplit* _split, uchar* _ext_buf )
-{
- int ci = data->get_var_type(vi);
- int n = node->sample_count;
- int m = data->get_num_classes();
- int _mi = data->cat_count->data.i[ci], mi = _mi;
-
- int base_size = m*(3 + mi)*sizeof(int) + (mi+1)*sizeof(double);
- if( m > 2 && mi > data->params.max_categories )
- base_size += (m*std::min(data->params.max_categories, n) + mi)*sizeof(int);
- else
- base_size += mi*sizeof(int*);
- cv::AutoBuffer<uchar> inn_buf(base_size);
- if( !_ext_buf )
- inn_buf.allocate(base_size + 2*n*sizeof(int));
- uchar* base_buf = (uchar*)inn_buf;
- uchar* ext_buf = _ext_buf ? _ext_buf : base_buf + base_size;
-
- int* lc = (int*)base_buf;
- int* rc = lc + m;
- int* _cjk = rc + m*2, *cjk = _cjk;
- double* c_weights = (double*)alignPtr(cjk + m*mi, sizeof(double));
-
- int* labels_buf = (int*)ext_buf;
- const int* labels = data->get_cat_var_data(node, vi, labels_buf);
- int* responses_buf = labels_buf + n;
- const int* responses = data->get_class_labels(node, responses_buf);
-
- int* cluster_labels = 0;
- int** int_ptr = 0;
- int i, j, k, idx;
- double L = 0, R = 0;
- double best_val = init_quality;
- int prevcode = 0, best_subset = -1, subset_i, subset_n, subtract = 0;
- const double* priors = data->priors_mult->data.db;
-
- // init array of counters:
- // c_{jk} - number of samples that have vi-th input variable = j and response = k.
- for( j = -1; j < mi; j++ )
- for( k = 0; k < m; k++ )
- cjk[j*m + k] = 0;
-
- for( i = 0; i < n; i++ )
- {
- j = ( labels[i] == 65535 && data->is_buf_16u) ? -1 : labels[i];
- k = responses[i];
- cjk[j*m + k]++;
- }
-
- if( m > 2 )
- {
- if( mi > data->params.max_categories )
- {
- mi = MIN(data->params.max_categories, n);
- cjk = (int*)(c_weights + _mi);
- cluster_labels = cjk + m*mi;
- cluster_categories( _cjk, _mi, m, cjk, mi, cluster_labels );
- }
- subset_i = 1;
- subset_n = 1 << mi;
- }
- else
- {
- assert( m == 2 );
- int_ptr = (int**)(c_weights + _mi);
- for( j = 0; j < mi; j++ )
- int_ptr[j] = cjk + j*2 + 1;
- std::sort(int_ptr, int_ptr + mi, LessThanPtr<int>());
- subset_i = 0;
- subset_n = mi;
- }
-
- for( k = 0; k < m; k++ )
- {
- int sum = 0;
- for( j = 0; j < mi; j++ )
- sum += cjk[j*m + k];
- rc[k] = sum;
- lc[k] = 0;
- }
-
- for( j = 0; j < mi; j++ )
- {
- double sum = 0;
- for( k = 0; k < m; k++ )
- sum += cjk[j*m + k]*priors[k];
- c_weights[j] = sum;
- R += c_weights[j];
- }
-
- for( ; subset_i < subset_n; subset_i++ )
- {
- double weight;
- int* crow;
- double lsum2 = 0, rsum2 = 0;
-
- if( m == 2 )
- idx = (int)(int_ptr[subset_i] - cjk)/2;
- else
- {
- int graycode = (subset_i>>1)^subset_i;
- int diff = graycode ^ prevcode;
-
- // determine index of the changed bit.
- Cv32suf u;
- idx = diff >= (1 << 16) ? 16 : 0;
- u.f = (float)(((diff >> 16) | diff) & 65535);
- idx += (u.i >> 23) - 127;
- subtract = graycode < prevcode;
- prevcode = graycode;
- }
-
- crow = cjk + idx*m;
- weight = c_weights[idx];
- if( weight < FLT_EPSILON )
- continue;
-
- if( !subtract )
- {
- for( k = 0; k < m; k++ )
- {
- int t = crow[k];
- int lval = lc[k] + t;
- int rval = rc[k] - t;
- double p = priors[k], p2 = p*p;
- lsum2 += p2*lval*lval;
- rsum2 += p2*rval*rval;
- lc[k] = lval; rc[k] = rval;
- }
- L += weight;
- R -= weight;
- }
- else
- {
- for( k = 0; k < m; k++ )
- {
- int t = crow[k];
- int lval = lc[k] - t;
- int rval = rc[k] + t;
- double p = priors[k], p2 = p*p;
- lsum2 += p2*lval*lval;
- rsum2 += p2*rval*rval;
- lc[k] = lval; rc[k] = rval;
- }
- L -= weight;
- R += weight;
- }
-
- if( L > FLT_EPSILON && R > FLT_EPSILON )
- {
- double val = (lsum2*R + rsum2*L)/((double)L*R);
- if( best_val < val )
- {
- best_val = val;
- best_subset = subset_i;
- }
- }
- }
-
- CvDTreeSplit* split = 0;
- if( best_subset >= 0 )
- {
- split = _split ? _split : data->new_split_cat( 0, -1.0f );
- split->var_idx = vi;
- split->quality = (float)best_val;
- memset( split->subset, 0, (data->max_c_count + 31)/32 * sizeof(int));
- if( m == 2 )
- {
- for( i = 0; i <= best_subset; i++ )
- {
- idx = (int)(int_ptr[i] - cjk) >> 1;
- split->subset[idx >> 5] |= 1 << (idx & 31);
- }
- }
- else
- {
- for( i = 0; i < _mi; i++ )
- {
- idx = cluster_labels ? cluster_labels[i] : i;
- if( best_subset & (1 << idx) )
- split->subset[i >> 5] |= 1 << (i & 31);
- }
- }
- }
- return split;
-}
-
-
-CvDTreeSplit* CvDTree::find_split_ord_reg( CvDTreeNode* node, int vi, float init_quality, CvDTreeSplit* _split, uchar* _ext_buf )
-{
- const float epsilon = FLT_EPSILON*2;
- int n = node->sample_count;
- int n1 = node->get_num_valid(vi);
-
- cv::AutoBuffer<uchar> inn_buf;
- if( !_ext_buf )
- inn_buf.allocate(2*n*(sizeof(int) + sizeof(float)));
- uchar* ext_buf = _ext_buf ? _ext_buf : (uchar*)inn_buf;
- float* values_buf = (float*)ext_buf;
- int* sorted_indices_buf = (int*)(values_buf + n);
- int* sample_indices_buf = sorted_indices_buf + n;
- const float* values = 0;
- const int* sorted_indices = 0;
- data->get_ord_var_data( node, vi, values_buf, sorted_indices_buf, &values, &sorted_indices, sample_indices_buf );
- float* responses_buf = (float*)(sample_indices_buf + n);
- const float* responses = data->get_ord_responses( node, responses_buf, sample_indices_buf );
-
- int i, best_i = -1;
- double best_val = init_quality, lsum = 0, rsum = node->value*n;
- int L = 0, R = n1;
-
- // compensate for missing values
- for( i = n1; i < n; i++ )
- rsum -= responses[sorted_indices[i]];
-
- // find the optimal split
- for( i = 0; i < n1 - 1; i++ )
- {
- float t = responses[sorted_indices[i]];
- L++; R--;
- lsum += t;
- rsum -= t;
-
- if( values[i] + epsilon < values[i+1] )
- {
- double val = (lsum*lsum*R + rsum*rsum*L)/((double)L*R);
- if( best_val < val )
- {
- best_val = val;
- best_i = i;
- }
- }
- }
-
- CvDTreeSplit* split = 0;
- if( best_i >= 0 )
- {
- split = _split ? _split : data->new_split_ord( 0, 0.0f, 0, 0, 0.0f );
- split->var_idx = vi;
- split->ord.c = (values[best_i] + values[best_i+1])*0.5f;
- split->ord.split_point = best_i;
- split->inversed = 0;
- split->quality = (float)best_val;
- }
- return split;
-}
-
-CvDTreeSplit* CvDTree::find_split_cat_reg( CvDTreeNode* node, int vi, float init_quality, CvDTreeSplit* _split, uchar* _ext_buf )
-{
- int ci = data->get_var_type(vi);
- int n = node->sample_count;
- int mi = data->cat_count->data.i[ci];
-
- int base_size = (mi+2)*sizeof(double) + (mi+1)*(sizeof(int) + sizeof(double*));
- cv::AutoBuffer<uchar> inn_buf(base_size);
- if( !_ext_buf )
- inn_buf.allocate(base_size + n*(2*sizeof(int) + sizeof(float)));
- uchar* base_buf = (uchar*)inn_buf;
- uchar* ext_buf = _ext_buf ? _ext_buf : base_buf + base_size;
- int* labels_buf = (int*)ext_buf;
- const int* labels = data->get_cat_var_data(node, vi, labels_buf);
- float* responses_buf = (float*)(labels_buf + n);
- int* sample_indices_buf = (int*)(responses_buf + n);
- const float* responses = data->get_ord_responses(node, responses_buf, sample_indices_buf);
-
- double* sum = (double*)cv::alignPtr(base_buf,sizeof(double)) + 1;
- int* counts = (int*)(sum + mi) + 1;
- double** sum_ptr = (double**)(counts + mi);
- int i, L = 0, R = 0;
- double best_val = init_quality, lsum = 0, rsum = 0;
- int best_subset = -1, subset_i;
-
- for( i = -1; i < mi; i++ )
- sum[i] = counts[i] = 0;
-
- // calculate sum response and weight of each category of the input var
- for( i = 0; i < n; i++ )
- {
- int idx = ( (labels[i] == 65535) && data->is_buf_16u ) ? -1 : labels[i];
- double s = sum[idx] + responses[i];
- int nc = counts[idx] + 1;
- sum[idx] = s;
- counts[idx] = nc;
- }
-
- // calculate average response in each category
- for( i = 0; i < mi; i++ )
- {
- R += counts[i];
- rsum += sum[i];
- sum[i] /= MAX(counts[i],1);
- sum_ptr[i] = sum + i;
- }
-
- std::sort(sum_ptr, sum_ptr + mi, LessThanPtr<double>());
-
- // revert back to unnormalized sums
- // (there should be a very little loss of accuracy)
- for( i = 0; i < mi; i++ )
- sum[i] *= counts[i];
-
- for( subset_i = 0; subset_i < mi-1; subset_i++ )
- {
- int idx = (int)(sum_ptr[subset_i] - sum);
- int ni = counts[idx];
-
- if( ni )
- {
- double s = sum[idx];
- lsum += s; L += ni;
- rsum -= s; R -= ni;
-
- if( L && R )
- {
- double val = (lsum*lsum*R + rsum*rsum*L)/((double)L*R);
- if( best_val < val )
- {
- best_val = val;
- best_subset = subset_i;
- }
- }
- }
- }
-
- CvDTreeSplit* split = 0;
- if( best_subset >= 0 )
- {
- split = _split ? _split : data->new_split_cat( 0, -1.0f);
- split->var_idx = vi;
- split->quality = (float)best_val;
- memset( split->subset, 0, (data->max_c_count + 31)/32 * sizeof(int));
- for( i = 0; i <= best_subset; i++ )
- {
- int idx = (int)(sum_ptr[i] - sum);
- split->subset[idx >> 5] |= 1 << (idx & 31);
- }
- }
- return split;
-}
-
-CvDTreeSplit* CvDTree::find_surrogate_split_ord( CvDTreeNode* node, int vi, uchar* _ext_buf )
-{
- const float epsilon = FLT_EPSILON*2;
- const char* dir = (char*)data->direction->data.ptr;
- int n = node->sample_count, n1 = node->get_num_valid(vi);
- cv::AutoBuffer<uchar> inn_buf;
- if( !_ext_buf )
- inn_buf.allocate( n*(sizeof(int)*(data->have_priors ? 3 : 2) + sizeof(float)) );
- uchar* ext_buf = _ext_buf ? _ext_buf : (uchar*)inn_buf;
- float* values_buf = (float*)ext_buf;
- int* sorted_indices_buf = (int*)(values_buf + n);
- int* sample_indices_buf = sorted_indices_buf + n;
- const float* values = 0;
- const int* sorted_indices = 0;
- data->get_ord_var_data( node, vi, values_buf, sorted_indices_buf, &values, &sorted_indices, sample_indices_buf );
- // LL - number of samples that both the primary and the surrogate splits send to the left
- // LR - ... primary split sends to the left and the surrogate split sends to the right
- // RL - ... primary split sends to the right and the surrogate split sends to the left
- // RR - ... both send to the right
- int i, best_i = -1, best_inversed = 0;
- double best_val;
-
- if( !data->have_priors )
- {
- int LL = 0, RL = 0, LR, RR;
- int worst_val = cvFloor(node->maxlr), _best_val = worst_val;
- int sum = 0, sum_abs = 0;
-
- for( i = 0; i < n1; i++ )
- {
- int d = dir[sorted_indices[i]];
- sum += d; sum_abs += d & 1;
- }
-
- // sum_abs = R + L; sum = R - L
- RR = (sum_abs + sum) >> 1;
- LR = (sum_abs - sum) >> 1;
-
- // initially all the samples are sent to the right by the surrogate split,
- // LR of them are sent to the left by primary split, and RR - to the right.
- // now iteratively compute LL, LR, RL and RR for every possible surrogate split value.
- for( i = 0; i < n1 - 1; i++ )
- {
- int d = dir[sorted_indices[i]];
-
- if( d < 0 )
- {
- LL++; LR--;
- if( LL + RR > _best_val && values[i] + epsilon < values[i+1] )
- {
- best_val = LL + RR;
- best_i = i; best_inversed = 0;
- }
- }
- else if( d > 0 )
- {
- RL++; RR--;
- if( RL + LR > _best_val && values[i] + epsilon < values[i+1] )
- {
- best_val = RL + LR;
- best_i = i; best_inversed = 1;
- }
- }
- }
- best_val = _best_val;
- }
- else
- {
- double LL = 0, RL = 0, LR, RR;
- double worst_val = node->maxlr;
- double sum = 0, sum_abs = 0;
- const double* priors = data->priors_mult->data.db;
- int* responses_buf = sample_indices_buf + n;
- const int* responses = data->get_class_labels(node, responses_buf);
- best_val = worst_val;
-
- for( i = 0; i < n1; i++ )
- {
- int idx = sorted_indices[i];
- double w = priors[responses[idx]];
- int d = dir[idx];
- sum += d*w; sum_abs += (d & 1)*w;
- }
-
- // sum_abs = R + L; sum = R - L
- RR = (sum_abs + sum)*0.5;
- LR = (sum_abs - sum)*0.5;
-
- // initially all the samples are sent to the right by the surrogate split,
- // LR of them are sent to the left by primary split, and RR - to the right.
- // now iteratively compute LL, LR, RL and RR for every possible surrogate split value.
- for( i = 0; i < n1 - 1; i++ )
- {
- int idx = sorted_indices[i];
- double w = priors[responses[idx]];
- int d = dir[idx];
-
- if( d < 0 )
- {
- LL += w; LR -= w;
- if( LL + RR > best_val && values[i] + epsilon < values[i+1] )
- {
- best_val = LL + RR;
- best_i = i; best_inversed = 0;
- }
- }
- else if( d > 0 )
- {
- RL += w; RR -= w;
- if( RL + LR > best_val && values[i] + epsilon < values[i+1] )
- {
- best_val = RL + LR;
- best_i = i; best_inversed = 1;
- }
- }
- }
- }
- return best_i >= 0 && best_val > node->maxlr ? data->new_split_ord( vi,
- (values[best_i] + values[best_i+1])*0.5f, best_i, best_inversed, (float)best_val ) : 0;
-}
-
-
-CvDTreeSplit* CvDTree::find_surrogate_split_cat( CvDTreeNode* node, int vi, uchar* _ext_buf )
-{
- const char* dir = (char*)data->direction->data.ptr;
- int n = node->sample_count;
- int i, mi = data->cat_count->data.i[data->get_var_type(vi)], l_win = 0;
-
- int base_size = (2*(mi+1)+1)*sizeof(double) + (!data->have_priors ? 2*(mi+1)*sizeof(int) : 0);
- cv::AutoBuffer<uchar> inn_buf(base_size);
- if( !_ext_buf )
- inn_buf.allocate(base_size + n*(sizeof(int) + (data->have_priors ? sizeof(int) : 0)));
- uchar* base_buf = (uchar*)inn_buf;
- uchar* ext_buf = _ext_buf ? _ext_buf : base_buf + base_size;
-
- int* labels_buf = (int*)ext_buf;
- const int* labels = data->get_cat_var_data(node, vi, labels_buf);
- // LL - number of samples that both the primary and the surrogate splits send to the left
- // LR - ... primary split sends to the left and the surrogate split sends to the right
- // RL - ... primary split sends to the right and the surrogate split sends to the left
- // RR - ... both send to the right
- CvDTreeSplit* split = data->new_split_cat( vi, 0 );
- double best_val = 0;
- double* lc = (double*)cv::alignPtr(base_buf,sizeof(double)) + 1;
- double* rc = lc + mi + 1;
-
- for( i = -1; i < mi; i++ )
- lc[i] = rc[i] = 0;
-
- // for each category calculate the weight of samples
- // sent to the left (lc) and to the right (rc) by the primary split
- if( !data->have_priors )
- {
- int* _lc = (int*)rc + 1;
- int* _rc = _lc + mi + 1;
-
- for( i = -1; i < mi; i++ )
- _lc[i] = _rc[i] = 0;
-
- for( i = 0; i < n; i++ )
- {
- int idx = ( (labels[i] == 65535) && (data->is_buf_16u) ) ? -1 : labels[i];
- int d = dir[i];
- int sum = _lc[idx] + d;
- int sum_abs = _rc[idx] + (d & 1);
- _lc[idx] = sum; _rc[idx] = sum_abs;
- }
-
- for( i = 0; i < mi; i++ )
- {
- int sum = _lc[i];
- int sum_abs = _rc[i];
- lc[i] = (sum_abs - sum) >> 1;
- rc[i] = (sum_abs + sum) >> 1;
- }
- }
- else
- {
- const double* priors = data->priors_mult->data.db;
- int* responses_buf = labels_buf + n;
- const int* responses = data->get_class_labels(node, responses_buf);
-
- for( i = 0; i < n; i++ )
- {
- int idx = ( (labels[i] == 65535) && (data->is_buf_16u) ) ? -1 : labels[i];
- double w = priors[responses[i]];
- int d = dir[i];
- double sum = lc[idx] + d*w;
- double sum_abs = rc[idx] + (d & 1)*w;
- lc[idx] = sum; rc[idx] = sum_abs;
- }
-
- for( i = 0; i < mi; i++ )
- {
- double sum = lc[i];
- double sum_abs = rc[i];
- lc[i] = (sum_abs - sum) * 0.5;
- rc[i] = (sum_abs + sum) * 0.5;
- }
- }
-
- // 2. now form the split.
- // in each category send all the samples to the same direction as majority
- for( i = 0; i < mi; i++ )
- {
- double lval = lc[i], rval = rc[i];
- if( lval > rval )
- {
- split->subset[i >> 5] |= 1 << (i & 31);
- best_val += lval;
- l_win++;
+ best_split = split;
+ std::swap(subset, best_subset);
}
- else
- best_val += rval;
}
- split->quality = (float)best_val;
- if( split->quality <= node->maxlr || l_win == 0 || l_win == mi )
- cvSetRemoveByPtr( data->split_heap, split ), split = 0;
+ if( best_split.quality > 0 )
+ {
+ int best_vi = best_split.varIdx;
+ CV_Assert( compVarIdx[best_split.varIdx] >= 0 && best_vi >= 0 );
+ int i, prevsz = (int)w->wsubsets.size(), ssize = getSubsetSize(best_vi);
+ w->wsubsets.resize(prevsz + ssize);
+ for( i = 0; i < ssize; i++ )
+ w->wsubsets[prevsz + i] = best_subset[i];
+ best_split.subsetOfs = prevsz;
+ w->wsplits.push_back(best_split);
+ splitidx = (int)(w->wsplits.size()-1);
+ }
- return split;
+ return splitidx;
}
-
-void CvDTree::calc_node_value( CvDTreeNode* node )
+void DTreesImpl::calcValue( int nidx, const vector<int>& _sidx )
{
- int i, j, k, n = node->sample_count, cv_n = data->params.cv_folds;
- int m = data->get_num_classes();
+ WNode* node = &w->wnodes[nidx];
+ int i, j, k, n = (int)_sidx.size(), cv_n = params.CVFolds;
+ int m = (int)classLabels.size();
- int base_size = data->is_classifier ? m*cv_n*sizeof(int) : 2*cv_n*sizeof(double)+cv_n*sizeof(int);
- int ext_size = n*(sizeof(int) + (data->is_classifier ? sizeof(int) : sizeof(int)+sizeof(float)));
- cv::AutoBuffer<uchar> inn_buf(base_size + ext_size);
- uchar* base_buf = (uchar*)inn_buf;
- uchar* ext_buf = base_buf + base_size;
+ cv::AutoBuffer<double> buf(std::max(m, 3)*(cv_n+1));
- int* cv_labels_buf = (int*)ext_buf;
- const int* cv_labels = data->get_cv_labels(node, cv_labels_buf);
+ if( cv_n > 0 )
+ {
+ size_t sz = w->cv_Tn.size();
+ w->cv_Tn.resize(sz + cv_n);
+ w->cv_node_risk.resize(sz + cv_n);
+ w->cv_node_error.resize(sz + cv_n);
+ }
- if( data->is_classifier )
+ if( _isClassifier )
{
// in case of classification tree:
// * node value is the label of the class that has the largest weight in the node.
// misclassified samples with cv_labels(*)==j.
// compute the number of instances of each class
- int* cls_count = data->counts->data.i;
- int* responses_buf = cv_labels_buf + n;
- const int* responses = data->get_class_labels(node, responses_buf);
- int* cv_cls_count = (int*)base_buf;
+ double* cls_count = buf;
+ double* cv_cls_count = cls_count + m;
+
double max_val = -1, total_weight = 0;
int max_k = -1;
- double* priors = data->priors_mult->data.db;
for( k = 0; k < m; k++ )
cls_count[k] = 0;
if( cv_n == 0 )
{
for( i = 0; i < n; i++ )
- cls_count[responses[i]]++;
+ {
+ int si = _sidx[i];
+ cls_count[w->cat_responses[si]] += w->sample_weights[si];
+ }
}
else
{
for( i = 0; i < n; i++ )
{
- j = cv_labels[i]; k = responses[i];
- cv_cls_count[j*m + k]++;
+ int si = _sidx[i];
+ j = w->cv_labels[si]; k = w->cat_responses[si];
+ cv_cls_count[j*m + k] += w->sample_weights[si];
}
for( j = 0; j < cv_n; j++ )
cls_count[k] += cv_cls_count[j*m + k];
}
- if( data->have_priors && node->parent == 0 )
- {
- // compute priors_mult from priors, take the sample ratio into account.
- double sum = 0;
- for( k = 0; k < m; k++ )
- {
- int n_k = cls_count[k];
- priors[k] = data->priors->data.db[k]*(n_k ? 1./n_k : 0.);
- sum += priors[k];
- }
- sum = 1./sum;
- for( k = 0; k < m; k++ )
- priors[k] *= sum;
- }
-
for( k = 0; k < m; k++ )
{
- double val = cls_count[k]*priors[k];
+ double val = cls_count[k];
total_weight += val;
if( max_val < val )
{
}
node->class_idx = max_k;
- node->value = data->cat_map->data.i[
- data->cat_ofs->data.i[data->cat_var_count] + max_k];
+ node->value = classLabels[max_k];
node->node_risk = total_weight - max_val;
for( j = 0; j < cv_n; j++ )
for( k = 0; k < m; k++ )
{
- double w = priors[k];
- double val_k = cv_cls_count[j*m + k]*w;
- double val = cls_count[k]*w - val_k;
+ double val_k = cv_cls_count[j*m + k];
+ double val = cls_count[k] - val_k;
sum_k += val_k;
sum += val;
if( max_val < val )
}
}
- node->cv_Tn[j] = INT_MAX;
- node->cv_node_risk[j] = sum - max_val;
- node->cv_node_error[j] = sum_k - max_val_k;
+ w->cv_Tn[nidx*cv_n + j] = INT_MAX;
+ w->cv_node_risk[nidx*cv_n + j] = sum - max_val;
+ w->cv_node_error[nidx*cv_n + j] = sum_k - max_val_k;
}
}
else
// where node_value_j is the node value calculated
// as described in the previous bullet, and summation is done
// over the samples with cv_labels(*)==j.
-
- double sum = 0, sum2 = 0;
- float* values_buf = (float*)(cv_labels_buf + n);
- int* sample_indices_buf = (int*)(values_buf + n);
- const float* values = data->get_ord_responses(node, values_buf, sample_indices_buf);
- double *cv_sum = 0, *cv_sum2 = 0;
- int* cv_count = 0;
+ double sum = 0, sum2 = 0, sumw = 0;
if( cv_n == 0 )
{
for( i = 0; i < n; i++ )
{
- double t = values[i];
- sum += t;
- sum2 += t*t;
+ int si = _sidx[i];
+ double wval = w->sample_weights[si];
+ double t = w->ord_responses[si];
+ sum += t*wval;
+ sum2 += t*t*wval;
+ sumw += wval;
}
}
else
{
- cv_sum = (double*)base_buf;
- cv_sum2 = cv_sum + cv_n;
- cv_count = (int*)(cv_sum2 + cv_n);
+ double *cv_sum = buf, *cv_sum2 = cv_sum + cv_n;
+ double* cv_count = (double*)(cv_sum2 + cv_n);
for( j = 0; j < cv_n; j++ )
{
for( i = 0; i < n; i++ )
{
- j = cv_labels[i];
- double t = values[i];
- double s = cv_sum[j] + t;
- double s2 = cv_sum2[j] + t*t;
- int nc = cv_count[j] + 1;
- cv_sum[j] = s;
- cv_sum2[j] = s2;
- cv_count[j] = nc;
+ int si = _sidx[i];
+ j = w->cv_labels[si];
+ double wval = w->sample_weights[si];
+ double t = w->ord_responses[si];
+ cv_sum[j] += t*wval;
+ cv_sum2[j] += t*t*wval;
+ cv_count[j] += wval;
}
-
+
for( j = 0; j < cv_n; j++ )
{
sum += cv_sum[j];
sum2 += cv_sum2[j];
+ sumw += cv_count[j];
+ }
+
+ for( j = 0; j < cv_n; j++ )
+ {
+ double s = sum - cv_sum[j], si = sum - s;
+ double s2 = sum2 - cv_sum2[j], s2i = sum2 - s2;
+ double c = cv_count[j], ci = sumw - c;
+ double r = si/std::max(ci, DBL_EPSILON);
+ w->cv_node_risk[nidx*cv_n + j] = s2i - r*r*ci;
+ w->cv_node_error[nidx*cv_n + j] = s2 - 2*r*s + c*r*r;
+ w->cv_Tn[nidx*cv_n + j] = INT_MAX;
}
}
+
+ node->node_risk = sum2 - (sum/sumw)*sum;
+ node->value = sum/sumw;
+ }
+}
- node->node_risk = sum2 - (sum/n)*sum;
- node->value = sum/n;
+DTreesImpl::WSplit DTreesImpl::findSplitOrdClass( int vi, const vector<int>& _sidx, double initQuality )
+{
+ const double epsilon = FLT_EPSILON*2;
+ int n = (int)_sidx.size();
+ int m = (int)classLabels.size();
- for( j = 0; j < cv_n; j++ )
+ cv::AutoBuffer<uchar> buf(n*(sizeof(float) + sizeof(int)) + m*2*sizeof(double));
+ const int* sidx = &_sidx[0];
+ const int* responses = &w->cat_responses[0];
+ const double* weights = &w->sample_weights[0];
+ double* lcw = (double*)(uchar*)buf;
+ double* rcw = lcw + m;
+ float* values = (float*)(rcw + m);
+ int* sorted_idx = (int*)(values + n);
+ int i, best_i = -1;
+ double best_val = initQuality;
+
+ for( i = 0; i < m; i++ )
+ lcw[i] = rcw[i] = 0.;
+
+ w->data->getValues( vi, _sidx, values );
+
+ for( i = 0; i < n; i++ )
+ {
+ sorted_idx[i] = i;
+ int si = sidx[i];
+ rcw[responses[si]] += weights[si];
+ }
+
+ std::sort(sorted_idx, sorted_idx + n, cmp_lt_idx<float>(values));
+
+ double L = 0, R = 0, lsum2 = 0, rsum2 = 0;
+ for( i = 0; i < m; i++ )
+ {
+ double wval = rcw[i];
+ R += wval;
+ rsum2 += wval*wval;
+ }
+
+ for( i = 0; i < n - 1; i++ )
+ {
+ int curr = sorted_idx[i];
+ int next = sorted_idx[i+1];
+ int si = sidx[curr];
+ double wval = weights[si], w2 = wval*wval;
+ L += wval; R -= wval;
+ int idx = responses[si];
+ double lv = lcw[idx], rv = rcw[idx];
+ lsum2 += 2*lv*wval + w2;
+ rsum2 -= 2*rv*wval - w2;
+ lcw[idx] = lv + wval; rcw[idx] = rv - wval;
+
+ if( values[curr] + epsilon < values[next] )
{
- double s = cv_sum[j], si = sum - s;
- double s2 = cv_sum2[j], s2i = sum2 - s2;
- int c = cv_count[j], ci = n - c;
- double r = si/MAX(ci,1);
- node->cv_node_risk[j] = s2i - r*r*ci;
- node->cv_node_error[j] = s2 - 2*r*s + c*r*r;
- node->cv_Tn[j] = INT_MAX;
+ double val = (lsum2*R + rsum2*L)/(L*R);
+ if( best_val < val )
+ {
+ best_val = val;
+ best_i = i;
+ }
}
}
-}
+ WSplit split;
+ if( best_i >= 0 )
+ {
+ split.varIdx = vi;
+ split.c = (values[sorted_idx[best_i]] + values[sorted_idx[best_i+1]])*0.5f;
+ split.inversed = 0;
+ split.quality = (float)best_val;
+ }
+ return split;
+}
-void CvDTree::complete_node_dir( CvDTreeNode* node )
+// simple k-means, slightly modified to take into account the "weight" (L1-norm) of each vector.
+void DTreesImpl::clusterCategories( const double* vectors, int n, int m, double* csums, int k, int* labels )
{
- int vi, i, n = node->sample_count, nl, nr, d0 = 0, d1 = -1;
- int nz = n - node->get_num_valid(node->split->var_idx);
- char* dir = (char*)data->direction->data.ptr;
+ int iters = 0, max_iters = 100;
+ int i, j, idx;
+ cv::AutoBuffer<double> buf(n + k);
+ double *v_weights = buf, *c_weights = buf + n;
+ bool modified = true;
+ RNG r(-1);
+
+ // assign labels randomly
+ for( i = 0; i < n; i++ )
+ {
+ int sum = 0;
+ const double* v = vectors + i*m;
+ labels[i] = i < k ? i : r.uniform(0, k);
- // try to complete direction using surrogate splits
- if( nz && data->params.use_surrogates )
+ // compute weight of each vector
+ for( j = 0; j < m; j++ )
+ sum += v[j];
+ v_weights[i] = sum ? 1./sum : 0.;
+ }
+
+ for( i = 0; i < n; i++ )
+ {
+ int i1 = r.uniform(0, n);
+ int i2 = r.uniform(0, n);
+ std::swap( labels[i1], labels[i2] );
+ }
+
+ for( iters = 0; iters <= max_iters; iters++ )
{
- cv::AutoBuffer<uchar> inn_buf(n*(2*sizeof(int)+sizeof(float)));
- CvDTreeSplit* split = node->split->next;
- for( ; split != 0 && nz; split = split->next )
+ // calculate csums
+ for( i = 0; i < k; i++ )
+ {
+ for( j = 0; j < m; j++ )
+ csums[i*m + j] = 0;
+ }
+
+ for( i = 0; i < n; i++ )
{
- int inversed_mask = split->inversed ? -1 : 0;
- vi = split->var_idx;
+ const double* v = vectors + i*m;
+ double* s = csums + labels[i]*m;
+ for( j = 0; j < m; j++ )
+ s[j] += v[j];
+ }
- if( data->get_var_type(vi) >= 0 ) // split on categorical var
- {
- int* labels_buf = (int*)(uchar*)inn_buf;
- const int* labels = data->get_cat_var_data(node, vi, labels_buf);
- const int* subset = split->subset;
+ // exit the loop here, when we have up-to-date csums
+ if( iters == max_iters || !modified )
+ break;
- for( i = 0; i < n; i++ )
- {
- int idx = labels[i];
- if( !dir[i] && ( ((idx >= 0)&&(!data->is_buf_16u)) || ((idx != 65535)&&(data->is_buf_16u)) ))
+ modified = false;
- {
- int d = CV_DTREE_CAT_DIR(idx,subset);
- dir[i] = (char)((d ^ inversed_mask) - inversed_mask);
- if( --nz )
- break;
- }
- }
- }
- else // split on ordered var
+ // calculate weight of each cluster
+ for( i = 0; i < k; i++ )
+ {
+ const double* s = csums + i*m;
+ double sum = 0;
+ for( j = 0; j < m; j++ )
+ sum += s[j];
+ c_weights[i] = sum ? 1./sum : 0;
+ }
+
+ // now for each vector determine the closest cluster
+ for( i = 0; i < n; i++ )
+ {
+ const double* v = vectors + i*m;
+ double alpha = v_weights[i];
+ double min_dist2 = DBL_MAX;
+ int min_idx = -1;
+
+ for( idx = 0; idx < k; idx++ )
{
- float* values_buf = (float*)(uchar*)inn_buf;
- int* sorted_indices_buf = (int*)(values_buf + n);
- int* sample_indices_buf = sorted_indices_buf + n;
- const float* values = 0;
- const int* sorted_indices = 0;
- data->get_ord_var_data( node, vi, values_buf, sorted_indices_buf, &values, &sorted_indices, sample_indices_buf );
- int split_point = split->ord.split_point;
- int n1 = node->get_num_valid(vi);
-
- assert( 0 <= split_point && split_point < n-1 );
-
- for( i = 0; i < n1; i++ )
+ const double* s = csums + idx*m;
+ double dist2 = 0., beta = c_weights[idx];
+ for( j = 0; j < m; j++ )
{
- int idx = sorted_indices[i];
- if( !dir[idx] )
- {
- int d = i <= split_point ? -1 : 1;
- dir[idx] = (char)((d ^ inversed_mask) - inversed_mask);
- if( --nz )
- break;
- }
+ double t = v[j]*alpha - s[j]*beta;
+ dist2 += t*t;
+ }
+ if( min_dist2 > dist2 )
+ {
+ min_dist2 = dist2;
+ min_idx = idx;
}
}
+
+ if( min_idx != labels[i] )
+ modified = true;
+ labels[i] = min_idx;
}
}
+}
- // find the default direction for the rest
- if( nz )
+DTreesImpl::WSplit DTreesImpl::findSplitCatClass( int vi, const vector<int>& _sidx,
+ double initQuality, int* subset )
+{
+ int _mi = getCatCount(vi), mi = _mi;
+ int n = (int)_sidx.size();
+ int m = (int)classLabels.size();
+
+ int base_size = m*(3 + mi) + mi + 1;
+ if( m > 2 && mi > params.maxCategories )
+ base_size += m*std::min(params.maxCategories, n) + mi;
+ else
+ base_size += mi;
+ AutoBuffer<double> buf(base_size + n);
+
+ double* lc = (double*)buf;
+ double* rc = lc + m;
+ double* _cjk = rc + m*2, *cjk = _cjk;
+ double* c_weights = cjk + m*mi;
+
+ int* labels = (int*)(buf + base_size);
+ w->data->getNormCatValues(vi, _sidx, labels);
+ const int* responses = &w->cat_responses[0];
+ const double* weights = &w->sample_weights[0];
+
+ int* cluster_labels = 0;
+ double** dbl_ptr = 0;
+ int i, j, k, si, idx;
+ double L = 0, R = 0;
+ double best_val = initQuality;
+ int prevcode = 0, best_subset = -1, subset_i, subset_n, subtract = 0;
+
+ // init array of counters:
+ // c_{jk} - number of samples that have vi-th input variable = j and response = k.
+ for( j = -1; j < mi; j++ )
+ for( k = 0; k < m; k++ )
+ cjk[j*m + k] = 0;
+
+ for( i = 0; i < n; i++ )
{
- for( i = nr = 0; i < n; i++ )
- nr += dir[i] > 0;
- nl = n - nr - nz;
- d0 = nl > nr ? -1 : nr > nl;
+ si = _sidx[i];
+ j = labels[i];
+ k = responses[si];
+ cjk[j*m + k] += weights[si];
}
- // make sure that every sample is directed either to the left or to the right
- for( i = 0; i < n; i++ )
+ if( m > 2 )
{
- int d = dir[i];
- if( !d )
+ if( mi > params.maxCategories )
{
- d = d0;
- if( !d )
- d = d1, d1 = -d1;
+ mi = std::min(params.maxCategories, n);
+ cjk = c_weights + _mi;
+ cluster_labels = (int*)(cjk + m*mi);
+ clusterCategories( _cjk, _mi, m, cjk, mi, cluster_labels );
}
- d = d > 0;
- dir[i] = (char)d; // remap (-1,1) to (0,1)
+ subset_i = 1;
+ subset_n = 1 << mi;
}
-}
-
-
-void CvDTree::split_node_data( CvDTreeNode* node )
-{
- int vi, i, n = node->sample_count, nl, nr, scount = data->sample_count;
- char* dir = (char*)data->direction->data.ptr;
- CvDTreeNode *left = 0, *right = 0;
- int* new_idx = data->split_buf->data.i;
- int new_buf_idx = data->get_child_buf_idx( node );
- int work_var_count = data->get_work_var_count();
- CvMat* buf = data->buf;
- size_t length_buf_row = data->get_length_subbuf();
- cv::AutoBuffer<uchar> inn_buf(n*(3*sizeof(int) + sizeof(float)));
- int* temp_buf = (int*)(uchar*)inn_buf;
-
- complete_node_dir(node);
-
- for( i = nl = nr = 0; i < n; i++ )
+ else
{
- int d = dir[i];
- // initialize new indices for splitting ordered variables
- new_idx[i] = (nl & (d-1)) | (nr & -d); // d ? ri : li
- nr += d;
- nl += d^1;
+ assert( m == 2 );
+ dbl_ptr = (double**)(c_weights + _mi);
+ for( j = 0; j < mi; j++ )
+ dbl_ptr[j] = cjk + j*2 + 1;
+ std::sort(dbl_ptr, dbl_ptr + mi, cmp_lt_ptr<double>());
+ subset_i = 0;
+ subset_n = mi;
}
- bool split_input_data;
- node->left = left = data->new_node( node, nl, new_buf_idx, node->offset );
- node->right = right = data->new_node( node, nr, new_buf_idx, node->offset + nl );
+ for( k = 0; k < m; k++ )
+ {
+ double sum = 0;
+ for( j = 0; j < mi; j++ )
+ sum += cjk[j*m + k];
+ CV_Assert(sum > 0);
+ rc[k] = sum;
+ lc[k] = 0;
+ }
- split_input_data = node->depth + 1 < data->params.max_depth &&
- (node->left->sample_count > data->params.min_sample_count ||
- node->right->sample_count > data->params.min_sample_count);
+ for( j = 0; j < mi; j++ )
+ {
+ double sum = 0;
+ for( k = 0; k < m; k++ )
+ sum += cjk[j*m + k];
+ c_weights[j] = sum;
+ R += c_weights[j];
+ }
- // split ordered variables, keep both halves sorted.
- for( vi = 0; vi < data->var_count; vi++ )
+ for( ; subset_i < subset_n; subset_i++ )
{
- int ci = data->get_var_type(vi);
+ double lsum2 = 0, rsum2 = 0;
- if( ci >= 0 || !split_input_data )
- continue;
+ if( m == 2 )
+ idx = (int)(dbl_ptr[subset_i] - cjk)/2;
+ else
+ {
+ int graycode = (subset_i>>1)^subset_i;
+ int diff = graycode ^ prevcode;
- int n1 = node->get_num_valid(vi);
- float* src_val_buf = (float*)(uchar*)(temp_buf + n);
- int* src_sorted_idx_buf = (int*)(src_val_buf + n);
- int* src_sample_idx_buf = src_sorted_idx_buf + n;
- const float* src_val = 0;
- const int* src_sorted_idx = 0;
- data->get_ord_var_data(node, vi, src_val_buf, src_sorted_idx_buf, &src_val, &src_sorted_idx, src_sample_idx_buf);
+ // determine index of the changed bit.
+ Cv32suf u;
+ idx = diff >= (1 << 16) ? 16 : 0;
+ u.f = (float)(((diff >> 16) | diff) & 65535);
+ idx += (u.i >> 23) - 127;
+ subtract = graycode < prevcode;
+ prevcode = graycode;
+ }
- for(i = 0; i < n; i++)
- temp_buf[i] = src_sorted_idx[i];
+ double* crow = cjk + idx*m;
+ double weight = c_weights[idx];
+ if( weight < FLT_EPSILON )
+ continue;
- if (data->is_buf_16u)
+ if( !subtract )
{
- unsigned short *ldst, *rdst, *ldst0, *rdst0;
- //unsigned short tl, tr;
- ldst0 = ldst = (unsigned short*)(buf->data.s + left->buf_idx*length_buf_row +
- vi*scount + left->offset);
- rdst0 = rdst = (unsigned short*)(ldst + nl);
-
- // split sorted
- for( i = 0; i < n1; i++ )
+ for( k = 0; k < m; k++ )
{
- int idx = temp_buf[i];
- int d = dir[idx];
- idx = new_idx[idx];
- if (d)
- {
- *rdst = (unsigned short)idx;
- rdst++;
- }
- else
- {
- *ldst = (unsigned short)idx;
- ldst++;
- }
+ double t = crow[k];
+ double lval = lc[k] + t;
+ double rval = rc[k] - t;
+ lsum2 += lval*lval;
+ rsum2 += rval*rval;
+ lc[k] = lval; rc[k] = rval;
+ }
+ L += weight;
+ R -= weight;
+ }
+ else
+ {
+ for( k = 0; k < m; k++ )
+ {
+ double t = crow[k];
+ double lval = lc[k] - t;
+ double rval = rc[k] + t;
+ lsum2 += lval*lval;
+ rsum2 += rval*rval;
+ lc[k] = lval; rc[k] = rval;
}
+ L -= weight;
+ R += weight;
+ }
- left->set_num_valid(vi, (int)(ldst - ldst0));
- right->set_num_valid(vi, (int)(rdst - rdst0));
+ if( L > FLT_EPSILON && R > FLT_EPSILON )
+ {
+ double val = (lsum2*R + rsum2*L)/(L*R);
+ if( best_val < val )
+ {
+ best_val = val;
+ best_subset = subset_i;
+ }
+ }
+ }
- // split missing
- for( ; i < n; i++ )
+ WSplit split;
+ if( best_subset >= 0 )
+ {
+ split.varIdx = vi;
+ split.quality = (float)best_val;
+ memset( subset, 0, getSubsetSize(vi) * sizeof(int) );
+ if( m == 2 )
+ {
+ for( i = 0; i <= best_subset; i++ )
{
- int idx = temp_buf[i];
- int d = dir[idx];
- idx = new_idx[idx];
- if (d)
- {
- *rdst = (unsigned short)idx;
- rdst++;
- }
- else
- {
- *ldst = (unsigned short)idx;
- ldst++;
- }
+ idx = (int)(dbl_ptr[i] - cjk) >> 1;
+ subset[idx >> 5] |= 1 << (idx & 31);
}
}
else
{
- int *ldst0, *ldst, *rdst0, *rdst;
- ldst0 = ldst = buf->data.i + left->buf_idx*length_buf_row +
- vi*scount + left->offset;
- rdst0 = rdst = buf->data.i + right->buf_idx*length_buf_row +
- vi*scount + right->offset;
-
- // split sorted
- for( i = 0; i < n1; i++ )
+ for( i = 0; i < _mi; i++ )
{
- int idx = temp_buf[i];
- int d = dir[idx];
- idx = new_idx[idx];
- if (d)
- {
- *rdst = idx;
- rdst++;
- }
- else
- {
- *ldst = idx;
- ldst++;
- }
+ idx = cluster_labels ? cluster_labels[i] : i;
+ if( best_subset & (1 << idx) )
+ subset[i >> 5] |= 1 << (i & 31);
}
+ }
+ }
+ return split;
+}
+
+DTreesImpl::WSplit DTreesImpl::findSplitOrdReg( int vi, const vector<int>& _sidx, double initQuality )
+{
+ const float epsilon = FLT_EPSILON*2;
+ const double* weights = &w->sample_weights[0];
+ int n = (int)_sidx.size();
+
+ AutoBuffer<uchar> buf(n*(sizeof(int) + sizeof(float)));
+
+ float* values = (float*)(uchar*)buf;
+ int* sorted_idx = (int*)(values + n);
+ w->data->getValues(vi, _sidx, values);
+ const double* responses = &w->ord_responses[0];
- left->set_num_valid(vi, (int)(ldst - ldst0));
- right->set_num_valid(vi, (int)(rdst - rdst0));
+ int i, si, best_i = -1;
+ double L = 0, R = 0;
+ double best_val = initQuality, lsum = 0, rsum = 0;
+
+ for( i = 0; i < n; i++ )
+ {
+ sorted_idx[i] = i;
+ si = _sidx[i];
+ R += weights[si];
+ rsum += weights[si]*responses[si];
+ }
+
+ std::sort(sorted_idx, sorted_idx + n, cmp_lt_idx<float>(values));
+
+ // find the optimal split
+ for( i = 0; i < n - 1; i++ )
+ {
+ int curr = sorted_idx[i];
+ int next = sorted_idx[i+1];
+ si = _sidx[curr];
+ double wval = weights[si];
+ double t = responses[si]*wval;
+ L += wval; R -= wval;
+ lsum += t; rsum -= t;
- // split missing
- for( ; i < n; i++ )
+ if( values[curr] + epsilon < values[next] )
+ {
+ double val = (lsum*lsum*R + rsum*rsum*L)/(L*R);
+ if( best_val < val )
{
- int idx = temp_buf[i];
- int d = dir[idx];
- idx = new_idx[idx];
- if (d)
- {
- *rdst = idx;
- rdst++;
- }
- else
- {
- *ldst = idx;
- ldst++;
- }
+ best_val = val;
+ best_i = i;
}
}
}
- // split categorical vars, responses and cv_labels using new_idx relocation table
- for( vi = 0; vi < work_var_count; vi++ )
+ WSplit split;
+ if( best_i >= 0 )
{
- int ci = data->get_var_type(vi);
- int n1 = node->get_num_valid(vi), nr1 = 0;
+ split.varIdx = vi;
+ split.c = (values[sorted_idx[best_i]] + values[sorted_idx[best_i+1]])*0.5f;
+ split.inversed = 0;
+ split.quality = (float)best_val;
+ }
+ return split;
+}
- if( ci < 0 || (vi < data->var_count && !split_input_data) )
- continue;
+DTreesImpl::WSplit DTreesImpl::findSplitCatReg( int vi, const vector<int>& _sidx,
+ double initQuality, int* subset )
+{
+ const double* weights = &w->sample_weights[0];
+ const double* responses = &w->ord_responses[0];
+ int n = (int)_sidx.size();
+ int mi = getCatCount(vi);
- int *src_lbls_buf = temp_buf + n;
- const int* src_lbls = data->get_cat_var_data(node, vi, src_lbls_buf);
+ AutoBuffer<double> buf(3*mi + 3 + n);
+ double* sum = (double*)buf + 1;
+ double* counts = sum + mi + 1;
+ double** sum_ptr = (double**)(counts + mi);
+ int* cat_labels = (int*)(sum_ptr + mi);
- for(i = 0; i < n; i++)
- temp_buf[i] = src_lbls[i];
+ w->data->getNormCatValues(vi, _sidx, cat_labels);
- if (data->is_buf_16u)
- {
- unsigned short *ldst = (unsigned short *)(buf->data.s + left->buf_idx*length_buf_row +
- vi*scount + left->offset);
- unsigned short *rdst = (unsigned short *)(buf->data.s + right->buf_idx*length_buf_row +
- vi*scount + right->offset);
+ double L = 0, R = 0, best_val = initQuality, lsum = 0, rsum = 0;
+ int i, si, best_subset = -1, subset_i;
- for( i = 0; i < n; i++ )
- {
- int d = dir[i];
- int idx = temp_buf[i];
- if (d)
- {
- *rdst = (unsigned short)idx;
- rdst++;
- nr1 += (idx != 65535 )&d;
- }
- else
- {
- *ldst = (unsigned short)idx;
- ldst++;
- }
- }
+ for( i = -1; i < mi; i++ )
+ sum[i] = counts[i] = 0;
- if( vi < data->var_count )
- {
- left->set_num_valid(vi, n1 - nr1);
- right->set_num_valid(vi, nr1);
- }
- }
- else
- {
- int *ldst = buf->data.i + left->buf_idx*length_buf_row +
- vi*scount + left->offset;
- int *rdst = buf->data.i + right->buf_idx*length_buf_row +
- vi*scount + right->offset;
+ // calculate sum response and weight of each category of the input var
+ for( i = 0; i < n; i++ )
+ {
+ int idx = cat_labels[i];
+ si = _sidx[i];
+ double wval = weights[si];
+ sum[idx] += responses[si]*wval;
+ counts[idx] += wval;
+ }
- for( i = 0; i < n; i++ )
- {
- int d = dir[i];
- int idx = temp_buf[i];
- if (d)
- {
- *rdst = idx;
- rdst++;
- nr1 += (idx >= 0)&d;
- }
- else
- {
- *ldst = idx;
- ldst++;
- }
+ // calculate average response in each category
+ for( i = 0; i < mi; i++ )
+ {
+ R += counts[i];
+ rsum += sum[i];
+ sum[i] = fabs(counts[i]) > DBL_EPSILON ? sum[i]/counts[i] : 0;
+ sum_ptr[i] = sum + i;
+ }
- }
+ std::sort(sum_ptr, sum_ptr + mi, cmp_lt_ptr<double>());
- if( vi < data->var_count )
+ // revert back to unnormalized sums
+ // (there should be a very little loss in accuracy)
+ for( i = 0; i < mi; i++ )
+ sum[i] *= counts[i];
+
+ for( subset_i = 0; subset_i < mi-1; subset_i++ )
+ {
+ int idx = (int)(sum_ptr[subset_i] - sum);
+ double ni = counts[idx];
+
+ if( ni > FLT_EPSILON )
+ {
+ double s = sum[idx];
+ lsum += s; L += ni;
+ rsum -= s; R -= ni;
+
+ if( L > FLT_EPSILON && R > FLT_EPSILON )
{
- left->set_num_valid(vi, n1 - nr1);
- right->set_num_valid(vi, nr1);
+ double val = (lsum*lsum*R + rsum*rsum*L)/(L*R);
+ if( best_val < val )
+ {
+ best_val = val;
+ best_subset = subset_i;
+ }
}
}
}
+
+ WSplit split;
+ if( best_subset >= 0 )
+ {
+ split.varIdx = vi;
+ split.quality = (float)best_val;
+ memset( subset, 0, getSubsetSize(vi) * sizeof(int));
+ for( i = 0; i <= best_subset; i++ )
+ {
+ int idx = (int)(sum_ptr[i] - sum);
+ subset[idx >> 5] |= 1 << (idx & 31);
+ }
+ }
+ return split;
+}
+int DTreesImpl::calcDir( int splitidx, const vector<int>& _sidx,
+ vector<int>& _sleft, vector<int>& _sright )
+{
+ WSplit split = w->wsplits[splitidx];
+ int i, si, n = (int)_sidx.size(), vi = split.varIdx;
+ _sleft.reserve(n);
+ _sright.reserve(n);
+ _sleft.clear();
+ _sright.clear();
- // split sample indices
- int *sample_idx_src_buf = temp_buf + n;
- const int* sample_idx_src = data->get_sample_indices(node, sample_idx_src_buf);
-
- for(i = 0; i < n; i++)
- temp_buf[i] = sample_idx_src[i];
+ AutoBuffer<float> buf(n);
+ int mi = getCatCount(vi);
+ double wleft = 0, wright = 0;
+ const double* weights = &w->sample_weights[0];
- int pos = data->get_work_var_count();
- if (data->is_buf_16u)
+ if( mi <= 0 ) // split on an ordered variable
{
- unsigned short* ldst = (unsigned short*)(buf->data.s + left->buf_idx*length_buf_row +
- pos*scount + left->offset);
- unsigned short* rdst = (unsigned short*)(buf->data.s + right->buf_idx*length_buf_row +
- pos*scount + right->offset);
- for (i = 0; i < n; i++)
+ float c = split.c;
+ float* values = buf;
+ w->data->getValues(vi, _sidx, values);
+
+ for( i = 0; i < n; i++ )
{
- int d = dir[i];
- unsigned short idx = (unsigned short)temp_buf[i];
- if (d)
+ si = _sidx[i];
+ if( values[i] <= c )
{
- *rdst = idx;
- rdst++;
+ _sleft.push_back(si);
+ wleft += weights[si];
}
else
{
- *ldst = idx;
- ldst++;
+ _sright.push_back(si);
+ wright += weights[si];
}
}
}
else
{
- int* ldst = buf->data.i + left->buf_idx*length_buf_row +
- pos*scount + left->offset;
- int* rdst = buf->data.i + right->buf_idx*length_buf_row +
- pos*scount + right->offset;
- for (i = 0; i < n; i++)
+ const int* subset = &w->wsubsets[split.subsetOfs];
+ int* cat_labels = (int*)(float*)buf;
+ w->data->getNormCatValues(vi, _sidx, cat_labels);
+
+ for( i = 0; i < n; i++ )
{
- int d = dir[i];
- int idx = temp_buf[i];
- if (d)
+ si = _sidx[i];
+ unsigned u = cat_labels[i];
+ if( CV_DTREE_CAT_DIR(u, subset) < 0 )
{
- *rdst = idx;
- rdst++;
+ _sleft.push_back(si);
+ wleft += weights[si];
}
else
{
- *ldst = idx;
- ldst++;
+ _sright.push_back(si);
+ wright += weights[si];
}
}
}
-
- // deallocate the parent node data that is not needed anymore
- data->free_node_data(node);
-}
-
-float CvDTree::calc_error( CvMLData* _data, int type, std::vector<float> *resp )
-{
- float err = 0;
- const CvMat* values = _data->get_values();
- const CvMat* response = _data->get_responses();
- const CvMat* missing = _data->get_missing();
- const CvMat* sample_idx = (type == CV_TEST_ERROR) ? _data->get_test_sample_idx() : _data->get_train_sample_idx();
- const CvMat* var_types = _data->get_var_types();
- int* sidx = sample_idx ? sample_idx->data.i : 0;
- int r_step = CV_IS_MAT_CONT(response->type) ?
- 1 : response->step / CV_ELEM_SIZE(response->type);
- bool is_classifier = var_types->data.ptr[var_types->cols-1] == CV_VAR_CATEGORICAL;
- int sample_count = sample_idx ? sample_idx->cols : 0;
- sample_count = (type == CV_TRAIN_ERROR && sample_count == 0) ? values->rows : sample_count;
- float* pred_resp = 0;
- if( resp && (sample_count > 0) )
- {
- resp->resize( sample_count );
- pred_resp = &((*resp)[0]);
- }
-
- if ( is_classifier )
- {
- for( int i = 0; i < sample_count; i++ )
- {
- CvMat sample, miss;
- int si = sidx ? sidx[i] : i;
- cvGetRow( values, &sample, si );
- if( missing )
- cvGetRow( missing, &miss, si );
- float r = (float)predict( &sample, missing ? &miss : 0 )->value;
- if( pred_resp )
- pred_resp[i] = r;
- int d = fabs((double)r - response->data.fl[(size_t)si*r_step]) <= FLT_EPSILON ? 0 : 1;
- err += d;
- }
- err = sample_count ? err / (float)sample_count * 100 : -FLT_MAX;
- }
- else
- {
- for( int i = 0; i < sample_count; i++ )
- {
- CvMat sample, miss;
- int si = sidx ? sidx[i] : i;
- cvGetRow( values, &sample, si );
- if( missing )
- cvGetRow( missing, &miss, si );
- float r = (float)predict( &sample, missing ? &miss : 0 )->value;
- if( pred_resp )
- pred_resp[i] = r;
- float d = r - response->data.fl[(size_t)si*r_step];
- err += d*d;
- }
- err = sample_count ? err / (float)sample_count : -FLT_MAX;
- }
- return err;
+ CV_Assert( (int)_sleft.size() < n && (int)_sright.size() < n );
+ return wleft > wright ? -1 : 1;
}
-void CvDTree::prune_cv()
+int DTreesImpl::pruneCV( int root )
{
- CvMat* ab = 0;
- CvMat* temp = 0;
- CvMat* err_jk = 0;
+ vector<double> ab;
// 1. build tree sequence for each cv fold, calculate error_{Tj,beta_k}.
// 2. choose the best tree index (if need, apply 1SE rule).
// 3. store the best index and cut the branches.
- CV_FUNCNAME( "CvDTree::prune_cv" );
-
- __BEGIN__;
-
- int ti, j, tree_count = 0, cv_n = data->params.cv_folds, n = root->sample_count;
+ int ti, tree_count = 0, j, cv_n = params.CVFolds, n = w->wnodes[root].sample_count;
// currently, 1SE for regression is not implemented
- bool use_1se = data->params.use_1se_rule != 0 && data->is_classifier;
- double* err;
+ bool use_1se = params.use1SERule != 0 && _isClassifier;
double min_err = 0, min_err_se = 0;
int min_idx = -1;
- CV_CALL( ab = cvCreateMat( 1, 256, CV_64F ));
-
// build the main tree sequence, calculate alpha's
for(;;tree_count++)
{
- double min_alpha = update_tree_rnc(tree_count, -1);
- if( cut_tree(tree_count, -1, min_alpha) )
+ double min_alpha = updateTreeRNC(root, tree_count, -1);
+ if( cutTree(root, tree_count, -1, min_alpha) )
break;
- if( ab->cols <= tree_count )
- {
- CV_CALL( temp = cvCreateMat( 1, ab->cols*3/2, CV_64F ));
- for( ti = 0; ti < ab->cols; ti++ )
- temp->data.db[ti] = ab->data.db[ti];
- cvReleaseMat( &ab );
- ab = temp;
- temp = 0;
- }
-
- ab->data.db[tree_count] = min_alpha;
+ ab.push_back(min_alpha);
}
- ab->data.db[0] = 0.;
-
if( tree_count > 0 )
{
+ ab[0] = 0.;
+
for( ti = 1; ti < tree_count-1; ti++ )
- ab->data.db[ti] = sqrt(ab->data.db[ti]*ab->data.db[ti+1]);
- ab->data.db[tree_count-1] = DBL_MAX*0.5;
+ ab[ti] = std::sqrt(ab[ti]*ab[ti+1]);
+ ab[tree_count-1] = DBL_MAX*0.5;
- CV_CALL( err_jk = cvCreateMat( cv_n, tree_count, CV_64F ));
- err = err_jk->data.db;
+ Mat err_jk(cv_n, tree_count, CV_64F);
for( j = 0; j < cv_n; j++ )
{
int tj = 0, tk = 0;
- for( ; tk < tree_count; tj++ )
+ for( ; tj < tree_count; tj++ )
{
- double min_alpha = update_tree_rnc(tj, j);
- if( cut_tree(tj, j, min_alpha) )
+ double min_alpha = updateTreeRNC(root, tj, j);
+ if( cutTree(root, tj, j, min_alpha) )
min_alpha = DBL_MAX;
for( ; tk < tree_count; tk++ )
{
- if( ab->data.db[tk] > min_alpha )
+ if( ab[tk] > min_alpha )
break;
- err[j*tree_count + tk] = root->tree_error;
+ err_jk.at<double>(j, tk) = w->wnodes[root].tree_error;
}
}
}
{
double sum_err = 0;
for( j = 0; j < cv_n; j++ )
- sum_err += err[j*tree_count + ti];
+ sum_err += err_jk.at<double>(j, ti);
if( ti == 0 || sum_err < min_err )
{
min_err = sum_err;
}
}
- pruned_tree_idx = min_idx;
- free_prune_data(data->params.truncate_pruned_tree != 0);
-
- __END__;
-
- cvReleaseMat( &err_jk );
- cvReleaseMat( &ab );
- cvReleaseMat( &temp );
+ return min_idx;
}
-
-double CvDTree::update_tree_rnc( int T, int fold )
+double DTreesImpl::updateTreeRNC( int root, double T, int fold )
{
- CvDTreeNode* node = root;
+ int nidx = root, pidx = -1, cv_n = params.CVFolds;
double min_alpha = DBL_MAX;
for(;;)
{
- CvDTreeNode* parent;
+ WNode *node = 0, *parent = 0;
+
for(;;)
{
- int t = fold >= 0 ? node->cv_Tn[fold] : node->Tn;
- if( t <= T || !node->left )
+ node = &w->wnodes[nidx];
+ double t = fold >= 0 ? w->cv_Tn[nidx*cv_n + fold] : node->Tn;
+ if( t <= T || node->left < 0 )
{
node->complexity = 1;
node->tree_risk = node->node_risk;
node->tree_error = 0.;
if( fold >= 0 )
{
- node->tree_risk = node->cv_node_risk[fold];
- node->tree_error = node->cv_node_error[fold];
+ node->tree_risk = w->cv_node_risk[nidx*cv_n + fold];
+ node->tree_error = w->cv_node_error[nidx*cv_n + fold];
}
break;
}
- node = node->left;
+ nidx = node->left;
}
- for( parent = node->parent; parent && parent->right == node;
- node = parent, parent = parent->parent )
+ for( pidx = node->parent; pidx >= 0 && w->wnodes[pidx].right == nidx;
+ nidx = pidx, pidx = w->wnodes[pidx].parent )
{
+ node = &w->wnodes[nidx];
+ parent = &w->wnodes[pidx];
parent->complexity += node->complexity;
parent->tree_risk += node->tree_risk;
parent->tree_error += node->tree_error;
- parent->alpha = ((fold >= 0 ? parent->cv_node_risk[fold] : parent->node_risk)
- - parent->tree_risk)/(parent->complexity - 1);
- min_alpha = MIN( min_alpha, parent->alpha );
+ parent->alpha = ((fold >= 0 ? w->cv_node_risk[pidx*cv_n + fold] : parent->node_risk)
+ - parent->tree_risk)/(parent->complexity - 1);
+ min_alpha = std::min( min_alpha, parent->alpha );
}
- if( !parent )
+ if( pidx < 0 )
break;
+ node = &w->wnodes[nidx];
+ parent = &w->wnodes[pidx];
parent->complexity = node->complexity;
parent->tree_risk = node->tree_risk;
parent->tree_error = node->tree_error;
- node = parent->right;
+ nidx = parent->right;
}
return min_alpha;
}
-
-int CvDTree::cut_tree( int T, int fold, double min_alpha )
+bool DTreesImpl::cutTree( int root, double T, int fold, double min_alpha )
{
- CvDTreeNode* node = root;
- if( !node->left )
- return 1;
+ int cv_n = params.CVFolds, nidx = root, pidx = -1;
+ WNode* node = &w->wnodes[root];
+ if( node->left < 0 )
+ return true;
for(;;)
{
- CvDTreeNode* parent;
for(;;)
{
- int t = fold >= 0 ? node->cv_Tn[fold] : node->Tn;
- if( t <= T || !node->left )
+ node = &w->wnodes[nidx];
+ double t = fold >= 0 ? w->cv_Tn[nidx*cv_n + fold] : node->Tn;
+ if( t <= T || node->left < 0 )
break;
if( node->alpha <= min_alpha + FLT_EPSILON )
{
if( fold >= 0 )
- node->cv_Tn[fold] = T;
+ w->cv_Tn[nidx*cv_n + fold] = T;
else
node->Tn = T;
- if( node == root )
- return 1;
+ if( nidx == root )
+ return true;
break;
}
- node = node->left;
+ nidx = node->left;
}
-
- for( parent = node->parent; parent && parent->right == node;
- node = parent, parent = parent->parent )
+
+ for( pidx = node->parent; pidx >= 0 && w->wnodes[pidx].right == nidx;
+ nidx = pidx, pidx = w->wnodes[pidx].parent )
;
-
- if( !parent )
+
+ if( pidx < 0 )
break;
-
- node = parent->right;
+
+ nidx = w->wnodes[pidx].right;
}
-
- return 0;
+
+ return false;
}
-
-void CvDTree::free_prune_data(bool _cut_tree)
+float DTreesImpl::predictTrees( const Range& range, const Mat& sample, int flags ) const
{
- CvDTreeNode* node = root;
-
- for(;;)
- {
- CvDTreeNode* parent;
- for(;;)
- {
- // do not call cvSetRemoveByPtr( cv_heap, node->cv_Tn )
- // as we will clear the whole cross-validation heap at the end
- node->cv_Tn = 0;
- node->cv_node_error = node->cv_node_risk = 0;
- if( !node->left )
- break;
- node = node->left;
- }
-
- for( parent = node->parent; parent && parent->right == node;
- node = parent, parent = parent->parent )
- {
- if( _cut_tree && parent->Tn <= pruned_tree_idx )
- {
- data->free_node( parent->left );
- data->free_node( parent->right );
- parent->left = parent->right = 0;
- }
- }
+ CV_Assert( sample.type() == CV_32F );
- if( !parent )
- break;
-
- node = parent->right;
- }
-
- if( data->cv_heap )
- cvClearSet( data->cv_heap );
-}
+ int predictType = flags & PREDICT_MASK;
+ int nvars = (int)varIdx.size();
+ if( nvars == 0 )
+ nvars = (int)varType.size();
+ int i, ncats = (int)catOfs.size(), nclasses = (int)classLabels.size();
+ int catbufsize = ncats > 0 ? nvars : 0;
+ AutoBuffer<int> buf(nclasses + catbufsize + 1);
+ int* votes = buf;
+ int* catbuf = votes + nclasses;
+ const int* cvidx = (flags & (COMPRESSED_INPUT|PREPROCESSED_INPUT)) == 0 && !varIdx.empty() ? &compVarIdx[0] : 0;
+ const uchar* vtype = &varType[0];
+ const Vec2i* cofs = !catOfs.empty() ? &catOfs[0] : 0;
+ const int* cmap = !catMap.empty() ? &catMap[0] : 0;
+ const float* psample = sample.ptr<float>();
+ const float* missingSubstPtr = !missingSubst.empty() ? &missingSubst[0] : 0;
+ size_t sstep = sample.isContinuous() ? 1 : sample.step/sizeof(float);
+ double sum = 0.;
+ int lastClassIdx = -1;
+ const float MISSED_VAL = TrainData::missingValue();
+ for( i = 0; i < catbufsize; i++ )
+ catbuf[i] = -1;
-void CvDTree::free_tree()
-{
- if( root && data && data->shared )
+ if( predictType == PREDICT_AUTO )
{
- pruned_tree_idx = INT_MIN;
- free_prune_data(true);
- data->free_node(root);
- root = 0;
+ predictType = !_isClassifier || (classLabels.size() == 2 && (flags & RAW_OUTPUT) != 0) ?
+ PREDICT_SUM : PREDICT_MAX_VOTE;
}
-}
-
-CvDTreeNode* CvDTree::predict( const CvMat* _sample,
- const CvMat* _missing, bool preprocessed_input ) const
-{
- cv::AutoBuffer<int> catbuf;
-
- int i, mstep = 0;
- const uchar* m = 0;
- CvDTreeNode* node = root;
-
- if( !node )
- CV_Error( CV_StsError, "The tree has not been trained yet" );
-
- if( !CV_IS_MAT(_sample) || CV_MAT_TYPE(_sample->type) != CV_32FC1 ||
- (_sample->cols != 1 && _sample->rows != 1) ||
- (_sample->cols + _sample->rows - 1 != data->var_all && !preprocessed_input) ||
- (_sample->cols + _sample->rows - 1 != data->var_count && preprocessed_input) )
- CV_Error( CV_StsBadArg,
- "the input sample must be 1d floating-point vector with the same "
- "number of elements as the total number of variables used for training" );
- const float* sample = _sample->data.fl;
- int step = CV_IS_MAT_CONT(_sample->type) ? 1 : _sample->step/sizeof(sample[0]);
-
- if( data->cat_count && !preprocessed_input ) // cache for categorical variables
+ if( predictType == PREDICT_MAX_VOTE )
{
- int n = data->cat_count->cols;
- catbuf.allocate(n);
- for( i = 0; i < n; i++ )
- catbuf[i] = -1;
+ for( i = 0; i < nclasses; i++ )
+ votes[i] = 0;
}
- if( _missing )
+ for( int ridx = range.start; ridx < range.end; ridx++ )
{
- if( !CV_IS_MAT(_missing) || !CV_IS_MASK_ARR(_missing) ||
- !CV_ARE_SIZES_EQ(_missing, _sample) )
- CV_Error( CV_StsBadArg,
- "the missing data mask must be 8-bit vector of the same size as input sample" );
- m = _missing->data.ptr;
- mstep = CV_IS_MAT_CONT(_missing->type) ? 1 : _missing->step/sizeof(m[0]);
- }
-
- const int* vtype = data->var_type->data.i;
- const int* vidx = data->var_idx && !preprocessed_input ? data->var_idx->data.i : 0;
- const int* cmap = data->cat_map ? data->cat_map->data.i : 0;
- const int* cofs = data->cat_ofs ? data->cat_ofs->data.i : 0;
+ int nidx = roots[ridx], prev = nidx, c = 0;
- while( node->Tn > pruned_tree_idx && node->left )
- {
- CvDTreeSplit* split = node->split;
- int dir = 0;
- for( ; !dir && split != 0; split = split->next )
+ for(;;)
{
- int vi = split->var_idx;
- int ci = vtype[vi];
- i = vidx ? vidx[vi] : vi;
- float val = sample[(size_t)i*step];
- if( m && m[(size_t)i*mstep] )
- continue;
- if( ci < 0 ) // ordered
- dir = val <= split->ord.c ? -1 : 1;
- else // categorical
+ prev = nidx;
+ const Node& node = nodes[nidx];
+ if( node.split < 0 )
+ break;
+ const Split& split = splits[node.split];
+ int vi = split.varIdx;
+ int ci = cvidx ? cvidx[vi] : vi;
+ float val = psample[ci*sstep];
+ if( val == MISSED_VAL )
+ {
+ if( !missingSubstPtr )
+ {
+ nidx = node.defaultDir < 0 ? node.left : node.right;
+ continue;
+ }
+ val = missingSubstPtr[vi];
+ }
+
+ if( vtype[vi] == VAR_ORDERED )
+ nidx = val <= split.c ? node.left : node.right;
+ else
{
- int c;
- if( preprocessed_input )
+ if( flags & PREPROCESSED_INPUT )
c = cvRound(val);
else
{
c = catbuf[ci];
if( c < 0 )
{
- int a = c = cofs[ci];
- int b = (ci+1 >= data->cat_ofs->cols) ? data->cat_map->cols : cofs[ci+1];
+ int a = c = cofs[vi][0];
+ int b = cofs[vi][1];
int ival = cvRound(val);
if( ival != val )
CV_Error( CV_StsBadArg,
- "one of input categorical variable is not an integer" );
+ "one of input categorical variable is not an integer" );
- int sh = 0;
while( a < b )
{
- sh++;
c = (a + b) >> 1;
if( ival < cmap[c] )
b = c;
break;
}
- if( c < 0 || ival != cmap[c] )
- continue;
+ CV_Assert( c >= 0 && ival == cmap[c] );
- catbuf[ci] = c -= cofs[ci];
+ c -= cofs[vi][0];
+ catbuf[ci] = c;
}
+ const int* subset = &subsets[split.subsetOfs];
+ unsigned u = c;
+ nidx = CV_DTREE_CAT_DIR(u, subset) < 0 ? node.left : node.right;
}
- c = ( (c == 65535) && data->is_buf_16u ) ? -1 : c;
- dir = CV_DTREE_CAT_DIR(c, split->subset);
}
+ }
- if( split->inversed )
- dir = -dir;
+ if( predictType == PREDICT_SUM )
+ sum += nodes[prev].value;
+ else
+ {
+ lastClassIdx = nodes[prev].classIdx;
+ votes[lastClassIdx]++;
}
+ }
- if( !dir )
+ if( predictType == PREDICT_MAX_VOTE )
+ {
+ int best_idx = lastClassIdx;
+ if( range.end - range.start > 1 )
{
- double diff = node->right->sample_count - node->left->sample_count;
- dir = diff < 0 ? -1 : 1;
+ best_idx = 0;
+ for( i = 1; i < nclasses; i++ )
+ if( votes[best_idx] < votes[i] )
+ best_idx = i;
}
- node = dir < 0 ? node->left : node->right;
+ sum = (flags & RAW_OUTPUT) ? (float)best_idx : classLabels[best_idx];
}
- return node;
+ return (float)sum;
}
-CvDTreeNode* CvDTree::predict( const Mat& _sample, const Mat& _missing, bool preprocessed_input ) const
+float DTreesImpl::predict( InputArray _samples, OutputArray _results, int flags ) const
{
- CvMat sample = _sample, mmask = _missing;
- return predict(&sample, mmask.data.ptr ? &mmask : 0, preprocessed_input);
-}
+ CV_Assert( !roots.empty() );
+ Mat samples = _samples.getMat(), results;
+ int i, nsamples = samples.rows;
+ int rtype = CV_32F;
+ bool needresults = _results.needed();
+ float retval = 0.f;
+ bool iscls = isClassifier();
+ float scale = !iscls ? 1.f/(int)roots.size() : 1.f;
+ if( iscls && (flags & PREDICT_MASK) == PREDICT_MAX_VOTE )
+ rtype = CV_32S;
-const CvMat* CvDTree::get_var_importance()
-{
- if( !var_importance )
+ if( needresults )
{
- CvDTreeNode* node = root;
- double* importance;
- if( !node )
- return 0;
- var_importance = cvCreateMat( 1, data->var_count, CV_64F );
- cvZero( var_importance );
- importance = var_importance->data.db;
+ _results.create(nsamples, 1, rtype);
+ results = _results.getMat();
+ }
+ else
+ nsamples = std::min(nsamples, 1);
- for(;;)
+ for( i = 0; i < nsamples; i++ )
+ {
+ float val = predictTrees( Range(0, (int)roots.size()), samples.row(i), flags )*scale;
+ if( needresults )
{
- CvDTreeNode* parent;
- for( ;; node = node->left )
- {
- CvDTreeSplit* split = node->split;
+ if( rtype == CV_32F )
+ results.at<float>(i) = val;
+ else
+ results.at<int>(i) = cvRound(val);
+ }
+ if( i == 0 )
+ retval = val;
+ }
+ return retval;
+}
- if( !node->left || node->Tn <= pruned_tree_idx )
- break;
+void DTreesImpl::writeTrainingParams(FileStorage& fs) const
+{
+ fs << "use_surrogates" << (params0.useSurrogates ? 1 : 0);
+ fs << "max_categories" << params0.maxCategories;
+ fs << "regression_accuracy" << params0.regressionAccuracy;
- for( ; split != 0; split = split->next )
- importance[split->var_idx] += split->quality;
- }
+ fs << "max_depth" << params0.maxDepth;
+ fs << "min_sample_count" << params0.minSampleCount;
+ fs << "cross_validation_folds" << params0.CVFolds;
- for( parent = node->parent; parent && parent->right == node;
- node = parent, parent = parent->parent )
- ;
+ if( params0.CVFolds > 1 )
+ fs << "use_1se_rule" << (params0.use1SERule ? 1 : 0);
- if( !parent )
- break;
+ if( !params0.priors.empty() )
+ fs << "priors" << params0.priors;
+}
- node = parent->right;
- }
+void DTreesImpl::writeParams(FileStorage& fs) const
+{
+ fs << "is_classifier" << isClassifier();
+ fs << "var_all" << (int)varType.size();
+ fs << "var_count" << getVarCount();
- cvNormalize( var_importance, var_importance, 1., 0, CV_L1 );
- }
+ int ord_var_count = 0, cat_var_count = 0;
+ int i, n = (int)varType.size();
+ for( i = 0; i < n; i++ )
+ if( varType[i] == VAR_ORDERED )
+ ord_var_count++;
+ else
+ cat_var_count++;
+ fs << "ord_var_count" << ord_var_count;
+ fs << "cat_var_count" << cat_var_count;
- return var_importance;
-}
+ fs << "training_params" << "{";
+ writeTrainingParams(fs);
+
+ fs << "}";
+ if( !varIdx.empty() )
+ fs << "var_idx" << varIdx;
-void CvDTree::write_split( CvFileStorage* fs, CvDTreeSplit* split ) const
+ fs << "var_type" << varType;
+
+ if( !catOfs.empty() )
+ fs << "cat_ofs" << catOfs;
+ if( !catMap.empty() )
+ fs << "cat_map" << catMap;
+ if( !classLabels.empty() )
+ fs << "class_labels" << classLabels;
+ if( !missingSubst.empty() )
+ fs << "missing_subst" << missingSubst;
+}
+
+void DTreesImpl::writeSplit( FileStorage& fs, int splitidx ) const
{
- int ci;
+ const Split& split = splits[splitidx];
+
+ fs << "{:";
- cvStartWriteStruct( fs, 0, CV_NODE_MAP + CV_NODE_FLOW );
- cvWriteInt( fs, "var", split->var_idx );
- cvWriteReal( fs, "quality", split->quality );
+ int vi = split.varIdx;
+ fs << "var" << vi;
+ fs << "quality" << split.quality;
- ci = data->get_var_type(split->var_idx);
- if( ci >= 0 ) // split on a categorical var
+ if( varType[vi] == VAR_CATEGORICAL ) // split on a categorical var
{
- int i, n = data->cat_count->data.i[ci], to_right = 0, default_dir;
+ int i, n = getCatCount(vi), to_right = 0;
+ const int* subset = &subsets[split.subsetOfs];
for( i = 0; i < n; i++ )
- to_right += CV_DTREE_CAT_DIR(i,split->subset) > 0;
+ to_right += CV_DTREE_CAT_DIR(i, subset) > 0;
// ad-hoc rule when to use inverse categorical split notation
// to achieve more compact and clear representation
- default_dir = to_right <= 1 || to_right <= MIN(3, n/2) || to_right <= n/3 ? -1 : 1;
+ int default_dir = to_right <= 1 || to_right <= std::min(3, n/2) || to_right <= n/3 ? -1 : 1;
- cvStartWriteStruct( fs, default_dir*(split->inversed ? -1 : 1) > 0 ?
- "in" : "not_in", CV_NODE_SEQ+CV_NODE_FLOW );
+ fs << (default_dir*(split.inversed ? -1 : 1) > 0 ? "in" : "not_in") << "[:";
for( i = 0; i < n; i++ )
{
- int dir = CV_DTREE_CAT_DIR(i,split->subset);
+ int dir = CV_DTREE_CAT_DIR(i, subset);
if( dir*default_dir < 0 )
- cvWriteInt( fs, 0, i );
+ fs << i;
}
- cvEndWriteStruct( fs );
+
+ fs << "]";
}
else
- cvWriteReal( fs, !split->inversed ? "le" : "gt", split->ord.c );
+ fs << (!split.inversed ? "le" : "gt") << split.c;
- cvEndWriteStruct( fs );
+ fs << "}";
}
-
-void CvDTree::write_node( CvFileStorage* fs, CvDTreeNode* node ) const
+void DTreesImpl::writeNode( FileStorage& fs, int nidx, int depth ) const
{
- CvDTreeSplit* split;
-
- cvStartWriteStruct( fs, 0, CV_NODE_MAP );
-
- cvWriteInt( fs, "depth", node->depth );
- cvWriteInt( fs, "sample_count", node->sample_count );
- cvWriteReal( fs, "value", node->value );
+ const Node& node = nodes[nidx];
+ fs << "{";
+ fs << "depth" << depth;
+ fs << "value" << node.value;
- if( data->is_classifier )
- cvWriteInt( fs, "norm_class_idx", node->class_idx );
+ if( _isClassifier )
+ fs << "norm_class_idx" << node.classIdx;
- cvWriteInt( fs, "Tn", node->Tn );
- cvWriteInt( fs, "complexity", node->complexity );
- cvWriteReal( fs, "alpha", node->alpha );
- cvWriteReal( fs, "node_risk", node->node_risk );
- cvWriteReal( fs, "tree_risk", node->tree_risk );
- cvWriteReal( fs, "tree_error", node->tree_error );
-
- if( node->left )
+ if( node.split >= 0 )
{
- cvStartWriteStruct( fs, "splits", CV_NODE_SEQ );
+ fs << "splits" << "[";
- for( split = node->split; split != 0; split = split->next )
- write_split( fs, split );
+ for( int splitidx = node.split; splitidx >= 0; splitidx = splits[splitidx].next )
+ writeSplit( fs, splitidx );
- cvEndWriteStruct( fs );
+ fs << "]";
}
- cvEndWriteStruct( fs );
+ fs << "}";
}
-
-void CvDTree::write_tree_nodes( CvFileStorage* fs ) const
+void DTreesImpl::writeTree( FileStorage& fs, int root ) const
{
- //CV_FUNCNAME( "CvDTree::write_tree_nodes" );
+ fs << "nodes" << "[";
- __BEGIN__;
-
- CvDTreeNode* node = root;
+ int nidx = root, pidx = 0, depth = 0;
+ const Node *node = 0;
// traverse the tree and save all the nodes in depth-first order
for(;;)
{
- CvDTreeNode* parent;
for(;;)
{
- write_node( fs, node );
- if( !node->left )
+ writeNode( fs, nidx, depth );
+ node = &nodes[nidx];
+ if( node->left < 0 )
break;
- node = node->left;
+ nidx = node->left;
+ depth++;
}
- for( parent = node->parent; parent && parent->right == node;
- node = parent, parent = parent->parent )
- ;
+ for( pidx = node->parent; pidx >= 0 && nodes[pidx].right == nidx;
+ nidx = pidx, pidx = nodes[pidx].parent )
+ depth--;
- if( !parent )
+ if( pidx < 0 )
break;
- node = parent->right;
+ nidx = nodes[pidx].right;
}
- __END__;
+ fs << "]";
}
-
-void CvDTree::write( CvFileStorage* fs, const char* name ) const
+void DTreesImpl::write( FileStorage& fs ) const
{
- //CV_FUNCNAME( "CvDTree::write" );
-
- __BEGIN__;
-
- cvStartWriteStruct( fs, name, CV_NODE_MAP, CV_TYPE_NAME_ML_TREE );
-
- //get_var_importance();
- data->write_params( fs );
- //if( var_importance )
- //cvWrite( fs, "var_importance", var_importance );
- write( fs );
-
- cvEndWriteStruct( fs );
-
- __END__;
+ writeParams(fs);
+ writeTree(fs, roots[0]);
}
-
-void CvDTree::write( CvFileStorage* fs ) const
+void DTreesImpl::readParams( const FileNode& fn )
{
- //CV_FUNCNAME( "CvDTree::write" );
+ _isClassifier = (int)fn["is_classifier"] != 0;
+ /*int var_all = (int)fn["var_all"];
+ int var_count = (int)fn["var_count"];
+ int cat_var_count = (int)fn["cat_var_count"];
+ int ord_var_count = (int)fn["ord_var_count"];*/
- __BEGIN__;
+ FileNode tparams_node = fn["training_params"];
- cvWriteInt( fs, "best_tree_idx", pruned_tree_idx );
+ params0 = Params();
- cvStartWriteStruct( fs, "nodes", CV_NODE_SEQ );
- write_tree_nodes( fs );
- cvEndWriteStruct( fs );
+ if( !tparams_node.empty() ) // training parameters are not necessary
+ {
+ params0.useSurrogates = (int)tparams_node["use_surrogates"] != 0;
+ params0.maxCategories = (int)tparams_node["max_categories"];
+ params0.regressionAccuracy = (float)tparams_node["regression_accuracy"];
- __END__;
-}
+ params0.maxDepth = (int)tparams_node["max_depth"];
+ params0.minSampleCount = (int)tparams_node["min_sample_count"];
+ params0.CVFolds = (int)tparams_node["cross_validation_folds"];
+ if( params0.CVFolds > 1 )
+ {
+ params.use1SERule = (int)tparams_node["use_1se_rule"] != 0;
+ }
-CvDTreeSplit* CvDTree::read_split( CvFileStorage* fs, CvFileNode* fnode )
-{
- CvDTreeSplit* split = 0;
+ tparams_node["priors"] >> params0.priors;
+ }
- CV_FUNCNAME( "CvDTree::read_split" );
+ fn["var_idx"] >> varIdx;
+ fn["var_type"] >> varType;
- __BEGIN__;
+ fn["cat_ofs"] >> catOfs;
+ fn["cat_map"] >> catMap;
+ fn["missing_subst"] >> missingSubst;
+ fn["class_labels"] >> classLabels;
- int vi, ci;
+ initCompVarIdx();
+ setDParams(params0);
+}
- if( !fnode || CV_NODE_TYPE(fnode->tag) != CV_NODE_MAP )
- CV_ERROR( CV_StsParseError, "some of the splits are not stored properly" );
+int DTreesImpl::readSplit( const FileNode& fn )
+{
+ Split split;
- vi = cvReadIntByName( fs, fnode, "var", -1 );
- if( (unsigned)vi >= (unsigned)data->var_count )
- CV_ERROR( CV_StsOutOfRange, "Split variable index is out of range" );
+ int vi = (int)fn["var"];
+ CV_Assert( 0 <= vi && vi <= (int)varType.size() );
+ split.varIdx = vi;
- ci = data->get_var_type(vi);
- if( ci >= 0 ) // split on categorical var
+ if( varType[vi] == VAR_CATEGORICAL ) // split on categorical var
{
- int i, n = data->cat_count->data.i[ci], inversed = 0, val;
- CvSeqReader reader;
- CvFileNode* inseq;
- split = data->new_split_cat( vi, 0 );
- inseq = cvGetFileNodeByName( fs, fnode, "in" );
- if( !inseq )
+ int i, val, ssize = getSubsetSize(vi);
+ split.subsetOfs = (int)subsets.size();
+ for( i = 0; i < ssize; i++ )
+ subsets.push_back(0);
+ int* subset = &subsets[split.subsetOfs];
+ FileNode fns = fn["in"];
+ if( fns.empty() )
{
- inseq = cvGetFileNodeByName( fs, fnode, "not_in" );
- inversed = 1;
+ fns = fn["not_in"];
+ split.inversed = true;
}
- if( !inseq ||
- (CV_NODE_TYPE(inseq->tag) != CV_NODE_SEQ && CV_NODE_TYPE(inseq->tag) != CV_NODE_INT))
- CV_ERROR( CV_StsParseError,
- "Either 'in' or 'not_in' tags should be inside a categorical split data" );
- if( CV_NODE_TYPE(inseq->tag) == CV_NODE_INT )
+ if( fns.isInt() )
{
- val = inseq->data.i;
- if( (unsigned)val >= (unsigned)n )
- CV_ERROR( CV_StsOutOfRange, "some of in/not_in elements are out of range" );
-
- split->subset[val >> 5] |= 1 << (val & 31);
+ val = (int)fns;
+ subset[val >> 5] |= 1 << (val & 31);
}
else
{
- cvStartReadSeq( inseq->data.seq, &reader );
-
- for( i = 0; i < reader.seq->total; i++ )
+ FileNodeIterator it = fns.begin();
+ int n = (int)fns.size();
+ for( i = 0; i < n; i++, ++it )
{
- CvFileNode* inode = (CvFileNode*)reader.ptr;
- val = inode->data.i;
- if( CV_NODE_TYPE(inode->tag) != CV_NODE_INT || (unsigned)val >= (unsigned)n )
- CV_ERROR( CV_StsOutOfRange, "some of in/not_in elements are out of range" );
-
- split->subset[val >> 5] |= 1 << (val & 31);
- CV_NEXT_SEQ_ELEM( reader.seq->elem_size, reader );
+ val = (int)*it;
+ subset[val >> 5] |= 1 << (val & 31);
}
}
// for categorical splits we do not use inversed splits,
// instead we inverse the variable set in the split
- if( inversed )
- for( i = 0; i < (n + 31) >> 5; i++ )
- split->subset[i] ^= -1;
+ if( split.inversed )
+ {
+ for( i = 0; i < ssize; i++ )
+ subset[i] ^= -1;
+ split.inversed = false;
+ }
}
else
{
- CvFileNode* cmp_node;
- split = data->new_split_ord( vi, 0, 0, 0, 0 );
-
- cmp_node = cvGetFileNodeByName( fs, fnode, "le" );
- if( !cmp_node )
+ FileNode cmpNode = fn["le"];
+ if( cmpNode.empty() )
{
- cmp_node = cvGetFileNodeByName( fs, fnode, "gt" );
- split->inversed = 1;
+ cmpNode = fn["gt"];
+ split.inversed = true;
}
-
- split->ord.c = (float)cvReadReal( cmp_node );
+ split.c = (float)cmpNode;
}
+
+ split.quality = (float)fn["quality"];
+ splits.push_back(split);
- split->quality = (float)cvReadRealByName( fs, fnode, "quality" );
-
- __END__;
-
- return split;
+ return (int)(splits.size() - 1);
}
-
-CvDTreeNode* CvDTree::read_node( CvFileStorage* fs, CvFileNode* fnode, CvDTreeNode* parent )
+int DTreesImpl::readNode( const FileNode& fn )
{
- CvDTreeNode* node = 0;
-
- CV_FUNCNAME( "CvDTree::read_node" );
-
- __BEGIN__;
-
- CvFileNode* splits;
- int i, depth;
-
- if( !fnode || CV_NODE_TYPE(fnode->tag) != CV_NODE_MAP )
- CV_ERROR( CV_StsParseError, "some of the tree elements are not stored properly" );
-
- CV_CALL( node = data->new_node( parent, 0, 0, 0 ));
- depth = cvReadIntByName( fs, fnode, "depth", -1 );
- if( depth != node->depth )
- CV_ERROR( CV_StsParseError, "incorrect node depth" );
-
- node->sample_count = cvReadIntByName( fs, fnode, "sample_count" );
- node->value = cvReadRealByName( fs, fnode, "value" );
- if( data->is_classifier )
- node->class_idx = cvReadIntByName( fs, fnode, "norm_class_idx" );
+ Node node;
+ node.value = (double)fn["value"];
- node->Tn = cvReadIntByName( fs, fnode, "Tn" );
- node->complexity = cvReadIntByName( fs, fnode, "complexity" );
- node->alpha = cvReadRealByName( fs, fnode, "alpha" );
- node->node_risk = cvReadRealByName( fs, fnode, "node_risk" );
- node->tree_risk = cvReadRealByName( fs, fnode, "tree_risk" );
- node->tree_error = cvReadRealByName( fs, fnode, "tree_error" );
+ if( _isClassifier )
+ node.classIdx = (int)fn["norm_class_idx"];
- splits = cvGetFileNodeByName( fs, fnode, "splits" );
- if( splits )
+ FileNode sfn = fn["splits"];
+ if( !sfn.empty() )
{
- CvSeqReader reader;
- CvDTreeSplit* last_split = 0;
+ int i, n = (int)sfn.size(), prevsplit = -1;
+ FileNodeIterator it = sfn.begin();
- if( CV_NODE_TYPE(splits->tag) != CV_NODE_SEQ )
- CV_ERROR( CV_StsParseError, "splits tag must stored as a sequence" );
-
- cvStartReadSeq( splits->data.seq, &reader );
- for( i = 0; i < reader.seq->total; i++ )
+ for( i = 0; i < n; i++, ++it )
{
- CvDTreeSplit* split;
- CV_CALL( split = read_split( fs, (CvFileNode*)reader.ptr ));
- if( !last_split )
- node->split = last_split = split;
+ int splitidx = readSplit(*it);
+ if( splitidx < 0 )
+ break;
+ if( prevsplit < 0 )
+ node.split = splitidx;
else
- last_split = last_split->next = split;
-
- CV_NEXT_SEQ_ELEM( reader.seq->elem_size, reader );
+ splits[prevsplit].next = splitidx;
+ prevsplit = splitidx;
}
}
-
- __END__;
-
- return node;
+ nodes.push_back(node);
+ return (int)(nodes.size() - 1);
}
-
-void CvDTree::read_tree_nodes( CvFileStorage* fs, CvFileNode* fnode )
+int DTreesImpl::readTree( const FileNode& fn )
{
- CV_FUNCNAME( "CvDTree::read_tree_nodes" );
-
- __BEGIN__;
-
- CvSeqReader reader;
- CvDTreeNode _root;
- CvDTreeNode* parent = &_root;
- int i;
- parent->left = parent->right = parent->parent = 0;
+ int i, n = (int)fn.size(), root = -1, pidx = -1;
+ FileNodeIterator it = fn.begin();
- cvStartReadSeq( fnode->data.seq, &reader );
-
- for( i = 0; i < reader.seq->total; i++ )
+ for( i = 0; i < n; i++, ++it )
{
- CvDTreeNode* node;
-
- CV_CALL( node = read_node( fs, (CvFileNode*)reader.ptr, parent != &_root ? parent : 0 ));
- if( !parent->left )
- parent->left = node;
+ int nidx = readNode(*it);
+ if( nidx < 0 )
+ break;
+ Node& node = nodes[nidx];
+ node.parent = pidx;
+ if( pidx < 0 )
+ root = nidx;
else
- parent->right = node;
- if( node->split )
- parent = node;
+ {
+ Node& parent = nodes[pidx];
+ if( parent.left < 0 )
+ parent.left = nidx;
+ else
+ parent.right = nidx;
+ }
+ if( node.split >= 0 )
+ pidx = nidx;
else
{
- while( parent && parent->right )
- parent = parent->parent;
+ while( pidx >= 0 && nodes[pidx].right >= 0 )
+ pidx = nodes[pidx].parent;
}
-
- CV_NEXT_SEQ_ELEM( reader.seq->elem_size, reader );
}
-
- root = _root.left;
-
- __END__;
-}
-
-
-void CvDTree::read( CvFileStorage* fs, CvFileNode* fnode )
-{
- CvDTreeTrainData* _data = new CvDTreeTrainData();
- _data->read_params( fs, fnode );
-
- read( fs, fnode, _data );
- get_var_importance();
+ roots.push_back(root);
+ return root;
}
-
-// a special entry point for reading weak decision trees from the tree ensembles
-void CvDTree::read( CvFileStorage* fs, CvFileNode* node, CvDTreeTrainData* _data )
+void DTreesImpl::read( const FileNode& fn )
{
- CV_FUNCNAME( "CvDTree::read" );
-
- __BEGIN__;
-
- CvFileNode* tree_nodes;
-
clear();
- data = _data;
+ readParams(fn);
- tree_nodes = cvGetFileNodeByName( fs, node, "nodes" );
- if( !tree_nodes || CV_NODE_TYPE(tree_nodes->tag) != CV_NODE_SEQ )
- CV_ERROR( CV_StsParseError, "nodes tag is missing" );
-
- pruned_tree_idx = cvReadIntByName( fs, node, "best_tree_idx", -1 );
- read_tree_nodes( fs, tree_nodes );
-
- __END__;
+ FileNode fnodes = fn["nodes"];
+ CV_Assert( !fnodes.empty() );
+ readTree(fnodes);
}
-Mat CvDTree::getVarImportance()
+Ptr<DTrees> DTrees::create(const DTrees::Params& params)
{
- return cvarrToMat(get_var_importance());
+ Ptr<DTreesImpl> p = makePtr<DTreesImpl>();
+ p->setDParams(params);
+ return p;
+}
+
+}
}
/* End of file. */
using namespace std;
using namespace cv;
+using cv::ml::TrainData;
+using cv::ml::EM;
+using cv::ml::KNearest;
static
void defaultDistribs( Mat& means, vector<Mat>& covs, int type=CV_32FC1 )
generateData( testData, testLabels, sizes, means, covs, CV_32FC1, CV_32FC1 );
int code = cvtest::TS::OK;
- KNearest knearest;
- knearest.train( trainData, trainLabels );
- knearest.find_nearest( testData, 4, &bestLabels );
+ Ptr<KNearest> knearest = KNearest::create(true);
+ knearest->train(TrainData::create(trainData, cv::ml::ROW_SAMPLE, trainLabels), 0);;
+ knearest->findNearest( testData, 4, bestLabels);
float err;
if( !calcErr( bestLabels, testLabels, sizes, err, true ) )
{
cv::Mat labels;
float err;
- cv::EM em(params.nclusters, params.covMatType, params.termCrit);
+ Ptr<EM> em;
+ EM::Params emp(params.nclusters, params.covMatType, params.termCrit);
if( params.startStep == EM::START_AUTO_STEP )
- em.train( trainData, noArray(), labels );
+ em = EM::train( trainData, noArray(), labels, noArray(), emp );
else if( params.startStep == EM::START_E_STEP )
- em.trainE( trainData, *params.means, *params.covs, *params.weights, noArray(), labels );
+ em = EM::train_startWithE( trainData, *params.means, *params.covs,
+ *params.weights, noArray(), labels, noArray(), emp );
else if( params.startStep == EM::START_M_STEP )
- em.trainM( trainData, *params.probs, noArray(), labels );
+ em = EM::train_startWithM( trainData, *params.probs,
+ noArray(), labels, noArray(), emp );
// check train error
if( !calcErr( labels, trainLabels, sizes, err , false, false ) )
{
Mat sample = testData.row(i);
Mat probs;
- labels.at<int>(i) = static_cast<int>(em.predict( sample, probs )[1]);
+ labels.at<int>(i) = static_cast<int>(em->predict2( sample, probs )[1]);
}
if( !calcErr( labels, testLabels, sizes, err, false, false ) )
{
int code = cvtest::TS::OK;
int caseIndex = 0;
{
- params.startStep = cv::EM::START_AUTO_STEP;
- params.covMatType = cv::EM::COV_MAT_GENERIC;
+ params.startStep = EM::START_AUTO_STEP;
+ params.covMatType = EM::COV_MAT_GENERIC;
int currCode = runCase(caseIndex++, params, trainData, trainLabels, testData, testLabels, sizes);
code = currCode == cvtest::TS::OK ? code : currCode;
}
{
- params.startStep = cv::EM::START_AUTO_STEP;
- params.covMatType = cv::EM::COV_MAT_DIAGONAL;
+ params.startStep = EM::START_AUTO_STEP;
+ params.covMatType = EM::COV_MAT_DIAGONAL;
int currCode = runCase(caseIndex++, params, trainData, trainLabels, testData, testLabels, sizes);
code = currCode == cvtest::TS::OK ? code : currCode;
}
{
- params.startStep = cv::EM::START_AUTO_STEP;
- params.covMatType = cv::EM::COV_MAT_SPHERICAL;
+ params.startStep = EM::START_AUTO_STEP;
+ params.covMatType = EM::COV_MAT_SPHERICAL;
int currCode = runCase(caseIndex++, params, trainData, trainLabels, testData, testLabels, sizes);
code = currCode == cvtest::TS::OK ? code : currCode;
}
{
- params.startStep = cv::EM::START_M_STEP;
- params.covMatType = cv::EM::COV_MAT_GENERIC;
+ params.startStep = EM::START_M_STEP;
+ params.covMatType = EM::COV_MAT_GENERIC;
int currCode = runCase(caseIndex++, params, trainData, trainLabels, testData, testLabels, sizes);
code = currCode == cvtest::TS::OK ? code : currCode;
}
{
- params.startStep = cv::EM::START_M_STEP;
- params.covMatType = cv::EM::COV_MAT_DIAGONAL;
+ params.startStep = EM::START_M_STEP;
+ params.covMatType = EM::COV_MAT_DIAGONAL;
int currCode = runCase(caseIndex++, params, trainData, trainLabels, testData, testLabels, sizes);
code = currCode == cvtest::TS::OK ? code : currCode;
}
{
- params.startStep = cv::EM::START_M_STEP;
- params.covMatType = cv::EM::COV_MAT_SPHERICAL;
+ params.startStep = EM::START_M_STEP;
+ params.covMatType = EM::COV_MAT_SPHERICAL;
int currCode = runCase(caseIndex++, params, trainData, trainLabels, testData, testLabels, sizes);
code = currCode == cvtest::TS::OK ? code : currCode;
}
{
- params.startStep = cv::EM::START_E_STEP;
- params.covMatType = cv::EM::COV_MAT_GENERIC;
+ params.startStep = EM::START_E_STEP;
+ params.covMatType = EM::COV_MAT_GENERIC;
int currCode = runCase(caseIndex++, params, trainData, trainLabels, testData, testLabels, sizes);
code = currCode == cvtest::TS::OK ? code : currCode;
}
{
- params.startStep = cv::EM::START_E_STEP;
- params.covMatType = cv::EM::COV_MAT_DIAGONAL;
+ params.startStep = EM::START_E_STEP;
+ params.covMatType = EM::COV_MAT_DIAGONAL;
int currCode = runCase(caseIndex++, params, trainData, trainLabels, testData, testLabels, sizes);
code = currCode == cvtest::TS::OK ? code : currCode;
}
{
- params.startStep = cv::EM::START_E_STEP;
- params.covMatType = cv::EM::COV_MAT_SPHERICAL;
+ params.startStep = EM::START_E_STEP;
+ params.covMatType = EM::COV_MAT_SPHERICAL;
int currCode = runCase(caseIndex++, params, trainData, trainLabels, testData, testLabels, sizes);
code = currCode == cvtest::TS::OK ? code : currCode;
}
{
int code = cvtest::TS::OK;
const int nclusters = 2;
- cv::EM em(nclusters);
Mat samples = Mat(3,1,CV_64FC1);
samples.at<double>(0,0) = 1;
Mat labels;
- em.train(samples, labels);
+ Ptr<EM> em = EM::train(samples, noArray(), labels, noArray(), EM::Params(nclusters));
Mat firstResult(samples.rows, 1, CV_32SC1);
for( int i = 0; i < samples.rows; i++)
- firstResult.at<int>(i) = static_cast<int>(em.predict(samples.row(i))[1]);
+ firstResult.at<int>(i) = static_cast<int>(em->predict2(samples.row(i), noArray())[1]);
// Write out
string filename = cv::tempfile(".xml");
try
{
fs << "em" << "{";
- em.write(fs);
+ em->write(fs);
fs << "}";
}
catch(...)
}
}
- em.clear();
+ em.release();
// Read in
+ try
{
- FileStorage fs = FileStorage(filename, FileStorage::READ);
- CV_Assert(fs.isOpened());
- FileNode fn = fs["em"];
- try
- {
- em.read(fn);
- }
- catch(...)
- {
- ts->printf( cvtest::TS::LOG, "Crash in read method.\n" );
- ts->set_failed_test_info( cvtest::TS::FAIL_EXCEPTION );
- }
+ em = StatModel::load<EM>(filename);
+ }
+ catch(...)
+ {
+ ts->printf( cvtest::TS::LOG, "Crash in read method.\n" );
+ ts->set_failed_test_info( cvtest::TS::FAIL_EXCEPTION );
}
remove( filename.c_str() );
int errCaseCount = 0;
for( int i = 0; i < samples.rows; i++)
- errCaseCount = std::abs(em.predict(samples.row(i))[1] - firstResult.at<int>(i)) < FLT_EPSILON ? 0 : 1;
+ errCaseCount = std::abs(em->predict2(samples.row(i), noArray())[1] - firstResult.at<int>(i)) < FLT_EPSILON ? 0 : 1;
if( errCaseCount > 0 )
{
// 1. estimates distributions of "spam" / "not spam"
// 2. predict classID using Bayes classifier for estimated distributions.
- CvMLData data;
string dataFilename = string(ts->get_data_path()) + "spambase.data";
+ Ptr<TrainData> data = TrainData::loadFromCSV(dataFilename, 0);
- if(data.read_csv(dataFilename.c_str()) != 0)
+ if( data.empty() )
{
ts->printf(cvtest::TS::LOG, "File with spambase dataset cann't be read.\n");
ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_TEST_DATA);
}
- Mat values = cv::cvarrToMat(data.get_values());
- CV_Assert(values.cols == 58);
- int responseIndex = 57;
-
- Mat samples = values.colRange(0, responseIndex);
- Mat responses = values.col(responseIndex);
+ Mat samples = data->getSamples();
+ CV_Assert(samples.cols == 57);
+ Mat responses = data->getResponses();
vector<int> trainSamplesMask(samples.rows, 0);
int trainSamplesCount = (int)(0.5f * samples.rows);
std::swap(trainSamplesMask[i1], trainSamplesMask[i2]);
}
- EM model0(3), model1(3);
Mat samples0, samples1;
for(int i = 0; i < samples.rows; i++)
{
samples1.push_back(sample);
}
}
- model0.train(samples0);
- model1.train(samples1);
+ Ptr<EM> model0 = EM::train(samples0, noArray(), noArray(), noArray(), EM::Params(3));
+ Ptr<EM> model1 = EM::train(samples1, noArray(), noArray(), noArray(), EM::Params(3));
Mat trainConfusionMat(2, 2, CV_32SC1, Scalar(0)),
testConfusionMat(2, 2, CV_32SC1, Scalar(0));
for(int i = 0; i < samples.rows; i++)
{
Mat sample = samples.row(i);
- double sampleLogLikelihoods0 = model0.predict(sample)[0];
- double sampleLogLikelihoods1 = model1.predict(sample)[0];
+ double sampleLogLikelihoods0 = model0->predict2(sample, noArray())[0];
+ double sampleLogLikelihoods1 = model1->predict2(sample, noArray())[0];
int classID = sampleLogLikelihoods0 >= lambda * sampleLogLikelihoods1 ? 0 : 1;
#include "test_precomp.hpp"
+#if 0
+
#include <string>
#include <fstream>
#include <iostream>
/////////////////////////////////////////////////////////////////////////////
TEST(ML_GBTrees, regression) { CV_GBTreesTest test; test.safe_run(); }
+
+#endif
for (int k = 0; k < icount; k++)
{
#endif
- data.mix_train_and_test_idx();
+ data->shuffleTrainTest();
code = train( testCaseIdx );
#ifdef GET_STAT
float case_result = get_error();
{
resultNode["mean"] >> mean;
resultNode["sigma"] >> sigma;
- float curErr = get_error( testCaseIdx, CV_TEST_ERROR );
+ model->save(format("/Users/vp/tmp/dtree/testcase_%02d.cur.yml", testCaseIdx));
+ float curErr = get_test_error( testCaseIdx );
const int coeff = 4;
- ts->printf( cvtest::TS::LOG, "Test case = %d; test error = %f; mean error = %f (diff=%f), %d*sigma = %f",
+ ts->printf( cvtest::TS::LOG, "Test case = %d; test error = %f; mean error = %f (diff=%f), %d*sigma = %f\n",
testCaseIdx, curErr, mean, abs( curErr - mean), coeff, coeff*sigma );
if ( abs( curErr - mean) > coeff*sigma )
{
TEST(ML_DTree, regression) { CV_AMLTest test( CV_DTREE ); test.safe_run(); }
TEST(ML_Boost, regression) { CV_AMLTest test( CV_BOOST ); test.safe_run(); }
TEST(ML_RTrees, regression) { CV_AMLTest test( CV_RTREES ); test.safe_run(); }
-TEST(ML_ERTrees, regression) { CV_AMLTest test( CV_ERTREES ); test.safe_run(); }
+TEST(DISABLED_ML_ERTrees, regression) { CV_AMLTest test( CV_ERTREES ); test.safe_run(); }
/* End of file. */
using namespace cv;
using namespace std;
-// auxiliary functions
-// 1. nbayes
-void nbayes_check_data( CvMLData* _data )
-{
- if( _data->get_missing() )
- CV_Error( CV_StsBadArg, "missing values are not supported" );
- const CvMat* var_types = _data->get_var_types();
- bool is_classifier = var_types->data.ptr[var_types->cols-1] == CV_VAR_CATEGORICAL;
-
- Mat _var_types = cvarrToMat(var_types);
- if( ( fabs( cvtest::norm( _var_types, Mat::zeros(_var_types.dims, _var_types.size, _var_types.type()), CV_L1 ) -
- (var_types->rows + var_types->cols - 2)*CV_VAR_ORDERED - CV_VAR_CATEGORICAL ) > FLT_EPSILON ) ||
- !is_classifier )
- CV_Error( CV_StsBadArg, "incorrect types of predictors or responses" );
-}
-bool nbayes_train( CvNormalBayesClassifier* nbayes, CvMLData* _data )
-{
- nbayes_check_data( _data );
- const CvMat* values = _data->get_values();
- const CvMat* responses = _data->get_responses();
- const CvMat* train_sidx = _data->get_train_sample_idx();
- const CvMat* var_idx = _data->get_var_idx();
- return nbayes->train( values, responses, var_idx, train_sidx );
-}
-float nbayes_calc_error( CvNormalBayesClassifier* nbayes, CvMLData* _data, int type, vector<float> *resp )
-{
- float err = 0;
- nbayes_check_data( _data );
- const CvMat* values = _data->get_values();
- const CvMat* response = _data->get_responses();
- const CvMat* sample_idx = (type == CV_TEST_ERROR) ? _data->get_test_sample_idx() : _data->get_train_sample_idx();
- int* sidx = sample_idx ? sample_idx->data.i : 0;
- int r_step = CV_IS_MAT_CONT(response->type) ?
- 1 : response->step / CV_ELEM_SIZE(response->type);
- int sample_count = sample_idx ? sample_idx->cols : 0;
- sample_count = (type == CV_TRAIN_ERROR && sample_count == 0) ? values->rows : sample_count;
- float* pred_resp = 0;
- if( resp && (sample_count > 0) )
- {
- resp->resize( sample_count );
- pred_resp = &((*resp)[0]);
- }
-
- for( int i = 0; i < sample_count; i++ )
- {
- CvMat sample;
- int si = sidx ? sidx[i] : i;
- cvGetRow( values, &sample, si );
- float r = (float)nbayes->predict( &sample, 0 );
- if( pred_resp )
- pred_resp[i] = r;
- int d = fabs((double)r - response->data.fl[si*r_step]) <= FLT_EPSILON ? 0 : 1;
- err += d;
- }
- err = sample_count ? err / (float)sample_count * 100 : -FLT_MAX;
- return err;
-}
-
-// 2. knearest
-void knearest_check_data_and_get_predictors( CvMLData* _data, CvMat* _predictors )
-{
- const CvMat* values = _data->get_values();
- const CvMat* var_idx = _data->get_var_idx();
- if( var_idx->cols + var_idx->rows != values->cols )
- CV_Error( CV_StsBadArg, "var_idx is not supported" );
- if( _data->get_missing() )
- CV_Error( CV_StsBadArg, "missing values are not supported" );
- int resp_idx = _data->get_response_idx();
- if( resp_idx == 0)
- cvGetCols( values, _predictors, 1, values->cols );
- else if( resp_idx == values->cols - 1 )
- cvGetCols( values, _predictors, 0, values->cols - 1 );
- else
- CV_Error( CV_StsBadArg, "responses must be in the first or last column; other cases are not supported" );
-}
-bool knearest_train( CvKNearest* knearest, CvMLData* _data )
-{
- const CvMat* responses = _data->get_responses();
- const CvMat* train_sidx = _data->get_train_sample_idx();
- bool is_regression = _data->get_var_type( _data->get_response_idx() ) == CV_VAR_ORDERED;
- CvMat predictors;
- knearest_check_data_and_get_predictors( _data, &predictors );
- return knearest->train( &predictors, responses, train_sidx, is_regression );
-}
-float knearest_calc_error( CvKNearest* knearest, CvMLData* _data, int k, int type, vector<float> *resp )
-{
- float err = 0;
- const CvMat* response = _data->get_responses();
- const CvMat* sample_idx = (type == CV_TEST_ERROR) ? _data->get_test_sample_idx() : _data->get_train_sample_idx();
- int* sidx = sample_idx ? sample_idx->data.i : 0;
- int r_step = CV_IS_MAT_CONT(response->type) ?
- 1 : response->step / CV_ELEM_SIZE(response->type);
- bool is_regression = _data->get_var_type( _data->get_response_idx() ) == CV_VAR_ORDERED;
- CvMat predictors;
- knearest_check_data_and_get_predictors( _data, &predictors );
- int sample_count = sample_idx ? sample_idx->cols : 0;
- sample_count = (type == CV_TRAIN_ERROR && sample_count == 0) ? predictors.rows : sample_count;
- float* pred_resp = 0;
- if( resp && (sample_count > 0) )
- {
- resp->resize( sample_count );
- pred_resp = &((*resp)[0]);
- }
- if ( !is_regression )
- {
- for( int i = 0; i < sample_count; i++ )
- {
- CvMat sample;
- int si = sidx ? sidx[i] : i;
- cvGetRow( &predictors, &sample, si );
- float r = knearest->find_nearest( &sample, k );
- if( pred_resp )
- pred_resp[i] = r;
- int d = fabs((double)r - response->data.fl[si*r_step]) <= FLT_EPSILON ? 0 : 1;
- err += d;
- }
- err = sample_count ? err / (float)sample_count * 100 : -FLT_MAX;
- }
- else
- {
- for( int i = 0; i < sample_count; i++ )
- {
- CvMat sample;
- int si = sidx ? sidx[i] : i;
- cvGetRow( &predictors, &sample, si );
- float r = knearest->find_nearest( &sample, k );
- if( pred_resp )
- pred_resp[i] = r;
- float d = r - response->data.fl[si*r_step];
- err += d*d;
- }
- err = sample_count ? err / (float)sample_count : -FLT_MAX;
- }
- return err;
-}
-
-// 3. svm
int str_to_svm_type(String& str)
{
if( !str.compare("C_SVC") )
- return CvSVM::C_SVC;
+ return SVM::C_SVC;
if( !str.compare("NU_SVC") )
- return CvSVM::NU_SVC;
+ return SVM::NU_SVC;
if( !str.compare("ONE_CLASS") )
- return CvSVM::ONE_CLASS;
+ return SVM::ONE_CLASS;
if( !str.compare("EPS_SVR") )
- return CvSVM::EPS_SVR;
+ return SVM::EPS_SVR;
if( !str.compare("NU_SVR") )
- return CvSVM::NU_SVR;
+ return SVM::NU_SVR;
CV_Error( CV_StsBadArg, "incorrect svm type string" );
return -1;
}
int str_to_svm_kernel_type( String& str )
{
if( !str.compare("LINEAR") )
- return CvSVM::LINEAR;
+ return SVM::LINEAR;
if( !str.compare("POLY") )
- return CvSVM::POLY;
+ return SVM::POLY;
if( !str.compare("RBF") )
- return CvSVM::RBF;
+ return SVM::RBF;
if( !str.compare("SIGMOID") )
- return CvSVM::SIGMOID;
+ return SVM::SIGMOID;
CV_Error( CV_StsBadArg, "incorrect svm type string" );
return -1;
}
-void svm_check_data( CvMLData* _data )
-{
- if( _data->get_missing() )
- CV_Error( CV_StsBadArg, "missing values are not supported" );
- const CvMat* var_types = _data->get_var_types();
- for( int i = 0; i < var_types->cols-1; i++ )
- if (var_types->data.ptr[i] == CV_VAR_CATEGORICAL)
- {
- char msg[50];
- sprintf( msg, "incorrect type of %d-predictor", i );
- CV_Error( CV_StsBadArg, msg );
- }
-}
-bool svm_train( CvSVM* svm, CvMLData* _data, CvSVMParams _params )
-{
- svm_check_data(_data);
- const CvMat* _train_data = _data->get_values();
- const CvMat* _responses = _data->get_responses();
- const CvMat* _var_idx = _data->get_var_idx();
- const CvMat* _sample_idx = _data->get_train_sample_idx();
- return svm->train( _train_data, _responses, _var_idx, _sample_idx, _params );
-}
-bool svm_train_auto( CvSVM* svm, CvMLData* _data, CvSVMParams _params,
- int k_fold, CvParamGrid C_grid, CvParamGrid gamma_grid,
- CvParamGrid p_grid, CvParamGrid nu_grid, CvParamGrid coef_grid,
- CvParamGrid degree_grid )
-{
- svm_check_data(_data);
- const CvMat* _train_data = _data->get_values();
- const CvMat* _responses = _data->get_responses();
- const CvMat* _var_idx = _data->get_var_idx();
- const CvMat* _sample_idx = _data->get_train_sample_idx();
- return svm->train_auto( _train_data, _responses, _var_idx,
- _sample_idx, _params, k_fold, C_grid, gamma_grid, p_grid, nu_grid, coef_grid, degree_grid );
-}
-float svm_calc_error( CvSVM* svm, CvMLData* _data, int type, vector<float> *resp )
+
+Ptr<SVM> svm_train_auto( Ptr<TrainData> _data, SVM::Params _params,
+ int k_fold, ParamGrid C_grid, ParamGrid gamma_grid,
+ ParamGrid p_grid, ParamGrid nu_grid, ParamGrid coef_grid,
+ ParamGrid degree_grid )
{
- svm_check_data(_data);
- float err = 0;
- const CvMat* values = _data->get_values();
- const CvMat* response = _data->get_responses();
- const CvMat* sample_idx = (type == CV_TEST_ERROR) ? _data->get_test_sample_idx() : _data->get_train_sample_idx();
- const CvMat* var_types = _data->get_var_types();
- int* sidx = sample_idx ? sample_idx->data.i : 0;
- int r_step = CV_IS_MAT_CONT(response->type) ?
- 1 : response->step / CV_ELEM_SIZE(response->type);
- bool is_classifier = var_types->data.ptr[var_types->cols-1] == CV_VAR_CATEGORICAL;
- int sample_count = sample_idx ? sample_idx->cols : 0;
- sample_count = (type == CV_TRAIN_ERROR && sample_count == 0) ? values->rows : sample_count;
- float* pred_resp = 0;
- if( resp && (sample_count > 0) )
- {
- resp->resize( sample_count );
- pred_resp = &((*resp)[0]);
- }
- if ( is_classifier )
- {
- for( int i = 0; i < sample_count; i++ )
- {
- CvMat sample;
- int si = sidx ? sidx[i] : i;
- cvGetRow( values, &sample, si );
- float r = svm->predict( &sample );
- if( pred_resp )
- pred_resp[i] = r;
- int d = fabs((double)r - response->data.fl[si*r_step]) <= FLT_EPSILON ? 0 : 1;
- err += d;
- }
- err = sample_count ? err / (float)sample_count * 100 : -FLT_MAX;
- }
- else
- {
- for( int i = 0; i < sample_count; i++ )
- {
- CvMat sample;
- int si = sidx ? sidx[i] : i;
- cvGetRow( values, &sample, si );
- float r = svm->predict( &sample );
- if( pred_resp )
- pred_resp[i] = r;
- float d = r - response->data.fl[si*r_step];
- err += d*d;
- }
- err = sample_count ? err / (float)sample_count : -FLT_MAX;
- }
- return err;
+ Mat _train_data = _data->getSamples();
+ Mat _responses = _data->getResponses();
+ Mat _var_idx = _data->getVarIdx();
+ Mat _sample_idx = _data->getTrainSampleIdx();
+
+ Ptr<SVM> svm = SVM::create(_params);
+ if( svm->trainAuto( _data, k_fold, C_grid, gamma_grid, p_grid, nu_grid, coef_grid, degree_grid ) )
+ return svm;
+ return Ptr<SVM>();
}
// 4. em
int str_to_ann_train_method( String& str )
{
if( !str.compare("BACKPROP") )
- return CvANN_MLP_TrainParams::BACKPROP;
+ return ANN_MLP::Params::BACKPROP;
if( !str.compare("RPROP") )
- return CvANN_MLP_TrainParams::RPROP;
+ return ANN_MLP::Params::RPROP;
CV_Error( CV_StsBadArg, "incorrect ann train method string" );
return -1;
}
-void ann_check_data_and_get_predictors( CvMLData* _data, CvMat* _inputs )
+
+void ann_check_data( Ptr<TrainData> _data )
{
- const CvMat* values = _data->get_values();
- const CvMat* var_idx = _data->get_var_idx();
- if( var_idx->cols + var_idx->rows != values->cols )
+ Mat values = _data->getSamples();
+ Mat var_idx = _data->getVarIdx();
+ int nvars = (int)var_idx.total();
+ if( nvars != 0 && nvars != values.cols )
CV_Error( CV_StsBadArg, "var_idx is not supported" );
- if( _data->get_missing() )
+ if( !_data->getMissing().empty() )
CV_Error( CV_StsBadArg, "missing values are not supported" );
- int resp_idx = _data->get_response_idx();
- if( resp_idx == 0)
- cvGetCols( values, _inputs, 1, values->cols );
- else if( resp_idx == values->cols - 1 )
- cvGetCols( values, _inputs, 0, values->cols - 1 );
- else
- CV_Error( CV_StsBadArg, "outputs must be in the first or last column; other cases are not supported" );
}
-void ann_get_new_responses( CvMLData* _data, Mat& new_responses, map<int, int>& cls_map )
+
+// unroll the categorical responses to binary vectors
+Mat ann_get_new_responses( Ptr<TrainData> _data, map<int, int>& cls_map )
{
- const CvMat* train_sidx = _data->get_train_sample_idx();
- int* train_sidx_ptr = train_sidx->data.i;
- const CvMat* responses = _data->get_responses();
- float* responses_ptr = responses->data.fl;
- int r_step = CV_IS_MAT_CONT(responses->type) ?
- 1 : responses->step / CV_ELEM_SIZE(responses->type);
+ Mat train_sidx = _data->getTrainSampleIdx();
+ int* train_sidx_ptr = train_sidx.ptr<int>();
+ Mat responses = _data->getResponses();
int cls_count = 0;
// construct cls_map
cls_map.clear();
- for( int si = 0; si < train_sidx->cols; si++ )
+ int nresponses = (int)responses.total();
+ int si, n = !train_sidx.empty() ? (int)train_sidx.total() : nresponses;
+
+ for( si = 0; si < n; si++ )
{
- int sidx = train_sidx_ptr[si];
- int r = cvRound(responses_ptr[sidx*r_step]);
- CV_DbgAssert( fabs(responses_ptr[sidx*r_step]-r) < FLT_EPSILON );
- int cls_map_size = (int)cls_map.size();
- cls_map[r];
- if ( (int)cls_map.size() > cls_map_size )
+ int sidx = train_sidx_ptr ? train_sidx_ptr[si] : si;
+ int r = cvRound(responses.at<float>(sidx));
+ CV_DbgAssert( fabs(responses.at<float>(sidx) - r) < FLT_EPSILON );
+ map<int,int>::iterator it = cls_map.find(r);
+ if( it == cls_map.end() )
cls_map[r] = cls_count++;
}
- new_responses.create( responses->rows, cls_count, CV_32F );
- new_responses.setTo( 0 );
- for( int si = 0; si < train_sidx->cols; si++ )
+ Mat new_responses = Mat::zeros( nresponses, cls_count, CV_32F );
+ for( si = 0; si < n; si++ )
{
- int sidx = train_sidx_ptr[si];
- int r = cvRound(responses_ptr[sidx*r_step]);
+ int sidx = train_sidx_ptr ? train_sidx_ptr[si] : si;
+ int r = cvRound(responses.at<float>(sidx));
int cidx = cls_map[r];
- new_responses.ptr<float>(sidx)[cidx] = 1;
+ new_responses.at<float>(sidx, cidx) = 1.f;
}
+ return new_responses;
}
-int ann_train( CvANN_MLP* ann, CvMLData* _data, Mat& new_responses, CvANN_MLP_TrainParams _params, int flags = 0 )
-{
- const CvMat* train_sidx = _data->get_train_sample_idx();
- CvMat predictors;
- ann_check_data_and_get_predictors( _data, &predictors );
- CvMat _new_responses = CvMat( new_responses );
- return ann->train( &predictors, &_new_responses, 0, train_sidx, _params, flags );
-}
-float ann_calc_error( CvANN_MLP* ann, CvMLData* _data, map<int, int>& cls_map, int type , vector<float> *resp_labels )
+
+float ann_calc_error( Ptr<StatModel> ann, Ptr<TrainData> _data, map<int, int>& cls_map, int type, vector<float> *resp_labels )
{
float err = 0;
- const CvMat* responses = _data->get_responses();
- const CvMat* sample_idx = (type == CV_TEST_ERROR) ? _data->get_test_sample_idx() : _data->get_train_sample_idx();
- int* sidx = sample_idx ? sample_idx->data.i : 0;
- int r_step = CV_IS_MAT_CONT(responses->type) ?
- 1 : responses->step / CV_ELEM_SIZE(responses->type);
- CvMat predictors;
- ann_check_data_and_get_predictors( _data, &predictors );
- int sample_count = sample_idx ? sample_idx->cols : 0;
- sample_count = (type == CV_TRAIN_ERROR && sample_count == 0) ? predictors.rows : sample_count;
+ Mat samples = _data->getSamples();
+ Mat responses = _data->getResponses();
+ Mat sample_idx = (type == CV_TEST_ERROR) ? _data->getTestSampleIdx() : _data->getTrainSampleIdx();
+ int* sidx = !sample_idx.empty() ? sample_idx.ptr<int>() : 0;
+ ann_check_data( _data );
+ int sample_count = (int)sample_idx.total();
+ sample_count = (type == CV_TRAIN_ERROR && sample_count == 0) ? samples.rows : sample_count;
float* pred_resp = 0;
vector<float> innresp;
if( sample_count > 0 )
}
int cls_count = (int)cls_map.size();
Mat output( 1, cls_count, CV_32FC1 );
- CvMat _output = CvMat(output);
+
for( int i = 0; i < sample_count; i++ )
{
- CvMat sample;
int si = sidx ? sidx[i] : i;
- cvGetRow( &predictors, &sample, si );
- ann->predict( &sample, &_output );
- CvPoint best_cls;
- cvMinMaxLoc( &_output, 0, 0, 0, &best_cls, 0 );
- int r = cvRound(responses->data.fl[si*r_step]);
- CV_DbgAssert( fabs(responses->data.fl[si*r_step]-r) < FLT_EPSILON );
+ Mat sample = samples.row(si);
+ ann->predict( sample, output );
+ Point best_cls;
+ minMaxLoc(output, 0, 0, 0, &best_cls, 0);
+ int r = cvRound(responses.at<float>(si));
+ CV_DbgAssert( fabs(responses.at<float>(si) - r) < FLT_EPSILON );
r = cls_map[r];
int d = best_cls.x == r ? 0 : 1;
err += d;
int str_to_boost_type( String& str )
{
if ( !str.compare("DISCRETE") )
- return CvBoost::DISCRETE;
+ return Boost::DISCRETE;
if ( !str.compare("REAL") )
- return CvBoost::REAL;
+ return Boost::REAL;
if ( !str.compare("LOGIT") )
- return CvBoost::LOGIT;
+ return Boost::LOGIT;
if ( !str.compare("GENTLE") )
- return CvBoost::GENTLE;
+ return Boost::GENTLE;
CV_Error( CV_StsBadArg, "incorrect boost type string" );
return -1;
}
RNG& rng = theRNG();
initSeed = rng.state;
-
rng.state = seeds[rng(seedCount)];
modelName = _modelName;
- nbayes = 0;
- knearest = 0;
- svm = 0;
- ann = 0;
- dtree = 0;
- boost = 0;
- rtrees = 0;
- ertrees = 0;
- if( !modelName.compare(CV_NBAYES) )
- nbayes = new CvNormalBayesClassifier;
- else if( !modelName.compare(CV_KNEAREST) )
- knearest = new CvKNearest;
- else if( !modelName.compare(CV_SVM) )
- svm = new CvSVM;
- else if( !modelName.compare(CV_ANN) )
- ann = new CvANN_MLP;
- else if( !modelName.compare(CV_DTREE) )
- dtree = new CvDTree;
- else if( !modelName.compare(CV_BOOST) )
- boost = new CvBoost;
- else if( !modelName.compare(CV_RTREES) )
- rtrees = new CvRTrees;
- else if( !modelName.compare(CV_ERTREES) )
- ertrees = new CvERTrees;
}
CV_MLBaseTest::~CV_MLBaseTest()
{
if( validationFS.isOpened() )
validationFS.release();
- if( nbayes )
- delete nbayes;
- if( knearest )
- delete knearest;
- if( svm )
- delete svm;
- if( ann )
- delete ann;
- if( dtree )
- delete dtree;
- if( boost )
- delete boost;
- if( rtrees )
- delete rtrees;
- if( ertrees )
- delete ertrees;
theRNG().state = initSeed;
}
-int CV_MLBaseTest::read_params( CvFileStorage* _fs )
+int CV_MLBaseTest::read_params( CvFileStorage* __fs )
{
- if( !_fs )
+ FileStorage _fs(__fs, false);
+ if( !_fs.isOpened() )
test_case_count = -1;
else
{
- CvFileNode* fn = cvGetRootFileNode( _fs, 0 );
- fn = (CvFileNode*)cvGetSeqElem( fn->data.seq, 0 );
- fn = cvGetFileNodeByName( _fs, fn, "run_params" );
- CvSeq* dataSetNamesSeq = cvGetFileNodeByName( _fs, fn, modelName.c_str() )->data.seq;
- test_case_count = dataSetNamesSeq ? dataSetNamesSeq->total : -1;
+ FileNode fn = _fs.getFirstTopLevelNode()["run_params"][modelName];
+ test_case_count = (int)fn.size();
+ if( test_case_count <= 0 )
+ test_case_count = -1;
if( test_case_count > 0 )
{
dataSetNames.resize( test_case_count );
- vector<string>::iterator it = dataSetNames.begin();
- for( int i = 0; i < test_case_count; i++, it++ )
- *it = ((CvFileNode*)cvGetSeqElem( dataSetNamesSeq, i ))->data.str.ptr;
+ FileNodeIterator it = fn.begin();
+ for( int i = 0; i < test_case_count; i++, ++it )
+ {
+ dataSetNames[i] = (string)*it;
+ }
}
}
return cvtest::TS::OK;;
int CV_MLBaseTest::prepare_test_case( int test_case_idx )
{
- int trainSampleCount, respIdx;
- String varTypes;
clear();
string dataPath = ts->get_data_path();
string dataName = dataSetNames[test_case_idx],
filename = dataPath + dataName + ".data";
- if ( data.read_csv( filename.c_str() ) != 0)
- {
- char msg[100];
- sprintf( msg, "file %s can not be read", filename.c_str() );
- ts->printf( cvtest::TS::LOG, msg );
- return cvtest::TS::FAIL_INVALID_TEST_DATA;
- }
FileNode dataParamsNode = validationFS.getFirstTopLevelNode()["validation"][modelName][dataName]["data_params"];
CV_DbgAssert( !dataParamsNode.empty() );
CV_DbgAssert( !dataParamsNode["LS"].empty() );
- dataParamsNode["LS"] >> trainSampleCount;
- CvTrainTestSplit spl( trainSampleCount );
- data.set_train_test_split( &spl );
+ int trainSampleCount = (int)dataParamsNode["LS"];
CV_DbgAssert( !dataParamsNode["resp_idx"].empty() );
- dataParamsNode["resp_idx"] >> respIdx;
- data.set_response_idx( respIdx );
+ int respIdx = (int)dataParamsNode["resp_idx"];
CV_DbgAssert( !dataParamsNode["types"].empty() );
- dataParamsNode["types"] >> varTypes;
- data.set_var_types( varTypes.c_str() );
+ String varTypes = (String)dataParamsNode["types"];
+ data = TrainData::loadFromCSV(filename, 0, respIdx, respIdx+1, varTypes);
+ if( data.empty() )
+ {
+ ts->printf( cvtest::TS::LOG, "file %s can not be read\n", filename.c_str() );
+ return cvtest::TS::FAIL_INVALID_TEST_DATA;
+ }
+
+ data->setTrainTestSplit(trainSampleCount);
return cvtest::TS::OK;
}
FileNode modelParamsNode =
validationFS.getFirstTopLevelNode()["validation"][modelName][dataSetNames[testCaseIdx]]["model_params"];
- if( !modelName.compare(CV_NBAYES) )
- is_trained = nbayes_train( nbayes, &data );
- else if( !modelName.compare(CV_KNEAREST) )
+ if( modelName == CV_NBAYES )
+ model = NormalBayesClassifier::create();
+ else if( modelName == CV_KNEAREST )
{
- assert( 0 );
- //is_trained = knearest->train( &data );
+ model = KNearest::create();
}
- else if( !modelName.compare(CV_SVM) )
+ else if( modelName == CV_SVM )
{
String svm_type_str, kernel_type_str;
modelParamsNode["svm_type"] >> svm_type_str;
modelParamsNode["kernel_type"] >> kernel_type_str;
- CvSVMParams params;
- params.svm_type = str_to_svm_type( svm_type_str );
- params.kernel_type = str_to_svm_kernel_type( kernel_type_str );
+ SVM::Params params;
+ params.svmType = str_to_svm_type( svm_type_str );
+ params.kernelType = str_to_svm_kernel_type( kernel_type_str );
modelParamsNode["degree"] >> params.degree;
modelParamsNode["gamma"] >> params.gamma;
modelParamsNode["coef0"] >> params.coef0;
modelParamsNode["C"] >> params.C;
modelParamsNode["nu"] >> params.nu;
modelParamsNode["p"] >> params.p;
- is_trained = svm_train( svm, &data, params );
+ model = SVM::create(params);
}
- else if( !modelName.compare(CV_EM) )
+ else if( modelName == CV_EM )
{
assert( 0 );
}
- else if( !modelName.compare(CV_ANN) )
+ else if( modelName == CV_ANN )
{
String train_method_str;
double param1, param2;
modelParamsNode["train_method"] >> train_method_str;
modelParamsNode["param1"] >> param1;
modelParamsNode["param2"] >> param2;
- Mat new_responses;
- ann_get_new_responses( &data, new_responses, cls_map );
- int layer_sz[] = { data.get_values()->cols - 1, 100, 100, (int)cls_map.size() };
- CvMat layer_sizes =
- cvMat( 1, (int)(sizeof(layer_sz)/sizeof(layer_sz[0])), CV_32S, layer_sz );
- ann->create( &layer_sizes );
- is_trained = ann_train( ann, &data, new_responses, CvANN_MLP_TrainParams(cvTermCriteria(CV_TERMCRIT_ITER,300,0.01),
- str_to_ann_train_method(train_method_str), param1, param2) ) >= 0;
+ Mat new_responses = ann_get_new_responses( data, cls_map );
+ // binarize the responses
+ data = TrainData::create(data->getSamples(), data->getLayout(), new_responses,
+ data->getVarIdx(), data->getTrainSampleIdx());
+ int layer_sz[] = { data->getNAllVars(), 100, 100, (int)cls_map.size() };
+ Mat layer_sizes( 1, (int)(sizeof(layer_sz)/sizeof(layer_sz[0])), CV_32S, layer_sz );
+ model = ANN_MLP::create(layer_sizes, ANN_MLP::Params(TermCriteria(TermCriteria::COUNT,300,0.01),
+ str_to_ann_train_method(train_method_str), param1, param2));
}
- else if( !modelName.compare(CV_DTREE) )
+ else if( modelName == CV_DTREE )
{
int MAX_DEPTH, MIN_SAMPLE_COUNT, MAX_CATEGORIES, CV_FOLDS;
float REG_ACCURACY = 0;
- bool USE_SURROGATE, IS_PRUNED;
+ bool USE_SURROGATE = false, IS_PRUNED;
modelParamsNode["max_depth"] >> MAX_DEPTH;
modelParamsNode["min_sample_count"] >> MIN_SAMPLE_COUNT;
- modelParamsNode["use_surrogate"] >> USE_SURROGATE;
+ //modelParamsNode["use_surrogate"] >> USE_SURROGATE;
modelParamsNode["max_categories"] >> MAX_CATEGORIES;
modelParamsNode["cv_folds"] >> CV_FOLDS;
modelParamsNode["is_pruned"] >> IS_PRUNED;
- is_trained = dtree->train( &data,
- CvDTreeParams(MAX_DEPTH, MIN_SAMPLE_COUNT, REG_ACCURACY, USE_SURROGATE,
- MAX_CATEGORIES, CV_FOLDS, false, IS_PRUNED, 0 )) != 0;
+ model = DTrees::create(DTrees::Params(MAX_DEPTH, MIN_SAMPLE_COUNT, REG_ACCURACY, USE_SURROGATE,
+ MAX_CATEGORIES, CV_FOLDS, false, IS_PRUNED, Mat() ));
}
- else if( !modelName.compare(CV_BOOST) )
+ else if( modelName == CV_BOOST )
{
int BOOST_TYPE, WEAK_COUNT, MAX_DEPTH;
float WEIGHT_TRIM_RATE;
- bool USE_SURROGATE;
+ bool USE_SURROGATE = false;
String typeStr;
modelParamsNode["type"] >> typeStr;
BOOST_TYPE = str_to_boost_type( typeStr );
modelParamsNode["weak_count"] >> WEAK_COUNT;
modelParamsNode["weight_trim_rate"] >> WEIGHT_TRIM_RATE;
modelParamsNode["max_depth"] >> MAX_DEPTH;
- modelParamsNode["use_surrogate"] >> USE_SURROGATE;
- is_trained = boost->train( &data,
- CvBoostParams(BOOST_TYPE, WEAK_COUNT, WEIGHT_TRIM_RATE, MAX_DEPTH, USE_SURROGATE, 0) ) != 0;
+ //modelParamsNode["use_surrogate"] >> USE_SURROGATE;
+ model = Boost::create( Boost::Params(BOOST_TYPE, WEAK_COUNT, WEIGHT_TRIM_RATE, MAX_DEPTH, USE_SURROGATE, Mat()) );
}
- else if( !modelName.compare(CV_RTREES) )
+ else if( modelName == CV_RTREES )
{
int MAX_DEPTH, MIN_SAMPLE_COUNT, MAX_CATEGORIES, CV_FOLDS, NACTIVE_VARS, MAX_TREES_NUM;
float REG_ACCURACY = 0, OOB_EPS = 0.0;
- bool USE_SURROGATE, IS_PRUNED;
+ bool USE_SURROGATE = false, IS_PRUNED;
modelParamsNode["max_depth"] >> MAX_DEPTH;
modelParamsNode["min_sample_count"] >> MIN_SAMPLE_COUNT;
- modelParamsNode["use_surrogate"] >> USE_SURROGATE;
+ //modelParamsNode["use_surrogate"] >> USE_SURROGATE;
modelParamsNode["max_categories"] >> MAX_CATEGORIES;
modelParamsNode["cv_folds"] >> CV_FOLDS;
modelParamsNode["is_pruned"] >> IS_PRUNED;
modelParamsNode["nactive_vars"] >> NACTIVE_VARS;
modelParamsNode["max_trees_num"] >> MAX_TREES_NUM;
- is_trained = rtrees->train( &data, CvRTParams( MAX_DEPTH, MIN_SAMPLE_COUNT, REG_ACCURACY,
- USE_SURROGATE, MAX_CATEGORIES, 0, true, // (calc_var_importance == true) <=> RF processes variable importance
- NACTIVE_VARS, MAX_TREES_NUM, OOB_EPS, CV_TERMCRIT_ITER)) != 0;
- }
- else if( !modelName.compare(CV_ERTREES) )
- {
- int MAX_DEPTH, MIN_SAMPLE_COUNT, MAX_CATEGORIES, CV_FOLDS, NACTIVE_VARS, MAX_TREES_NUM;
- float REG_ACCURACY = 0, OOB_EPS = 0.0;
- bool USE_SURROGATE, IS_PRUNED;
- modelParamsNode["max_depth"] >> MAX_DEPTH;
- modelParamsNode["min_sample_count"] >> MIN_SAMPLE_COUNT;
- modelParamsNode["use_surrogate"] >> USE_SURROGATE;
- modelParamsNode["max_categories"] >> MAX_CATEGORIES;
- modelParamsNode["cv_folds"] >> CV_FOLDS;
- modelParamsNode["is_pruned"] >> IS_PRUNED;
- modelParamsNode["nactive_vars"] >> NACTIVE_VARS;
- modelParamsNode["max_trees_num"] >> MAX_TREES_NUM;
- is_trained = ertrees->train( &data, CvRTParams( MAX_DEPTH, MIN_SAMPLE_COUNT, REG_ACCURACY,
- USE_SURROGATE, MAX_CATEGORIES, 0, false, // (calc_var_importance == true) <=> RF processes variable importance
- NACTIVE_VARS, MAX_TREES_NUM, OOB_EPS, CV_TERMCRIT_ITER)) != 0;
+ model = RTrees::create(RTrees::Params( MAX_DEPTH, MIN_SAMPLE_COUNT, REG_ACCURACY,
+ USE_SURROGATE, MAX_CATEGORIES, Mat(), true, // (calc_var_importance == true) <=> RF processes variable importance
+ NACTIVE_VARS, TermCriteria(TermCriteria::COUNT, MAX_TREES_NUM, OOB_EPS)));
}
+ if( !model.empty() )
+ is_trained = model->train(data, 0);
+
if( !is_trained )
{
ts->printf( cvtest::TS::LOG, "in test case %d model training was failed", testCaseIdx );
return cvtest::TS::OK;
}
-float CV_MLBaseTest::get_error( int /*testCaseIdx*/, int type, vector<float> *resp )
+float CV_MLBaseTest::get_test_error( int /*testCaseIdx*/, vector<float> *resp )
{
+ int type = CV_TEST_ERROR;
float err = 0;
- if( !modelName.compare(CV_NBAYES) )
- err = nbayes_calc_error( nbayes, &data, type, resp );
- else if( !modelName.compare(CV_KNEAREST) )
- {
- assert( 0 );
- /*testCaseIdx = 0;
- int k = 2;
- validationFS.getFirstTopLevelNode()["validation"][modelName][dataSetNames[testCaseIdx]]["model_params"]["k"] >> k;
- err = knearest->calc_error( &data, k, type, resp );*/
- }
- else if( !modelName.compare(CV_SVM) )
- err = svm_calc_error( svm, &data, type, resp );
- else if( !modelName.compare(CV_EM) )
+ Mat _resp;
+ if( modelName == CV_EM )
assert( 0 );
- else if( !modelName.compare(CV_ANN) )
- err = ann_calc_error( ann, &data, cls_map, type, resp );
- else if( !modelName.compare(CV_DTREE) )
- err = dtree->calc_error( &data, type, resp );
- else if( !modelName.compare(CV_BOOST) )
- err = boost->calc_error( &data, type, resp );
- else if( !modelName.compare(CV_RTREES) )
- err = rtrees->calc_error( &data, type, resp );
- else if( !modelName.compare(CV_ERTREES) )
- err = ertrees->calc_error( &data, type, resp );
+ else if( modelName == CV_ANN )
+ err = ann_calc_error( model, data, cls_map, type, resp );
+ else if( modelName == CV_DTREE || modelName == CV_BOOST || modelName == CV_RTREES ||
+ modelName == CV_SVM || modelName == CV_NBAYES || modelName == CV_KNEAREST )
+ err = model->calcError( data, true, _resp );
+ if( !_resp.empty() && resp )
+ _resp.convertTo(*resp, CV_32F);
return err;
}
void CV_MLBaseTest::save( const char* filename )
{
- if( !modelName.compare(CV_NBAYES) )
- nbayes->save( filename );
- else if( !modelName.compare(CV_KNEAREST) )
- knearest->save( filename );
- else if( !modelName.compare(CV_SVM) )
- svm->save( filename );
- else if( !modelName.compare(CV_ANN) )
- ann->save( filename );
- else if( !modelName.compare(CV_DTREE) )
- dtree->save( filename );
- else if( !modelName.compare(CV_BOOST) )
- boost->save( filename );
- else if( !modelName.compare(CV_RTREES) )
- rtrees->save( filename );
- else if( !modelName.compare(CV_ERTREES) )
- ertrees->save( filename );
+ model->save( filename );
}
void CV_MLBaseTest::load( const char* filename )
{
- if( !modelName.compare(CV_NBAYES) )
- nbayes->load( filename );
- else if( !modelName.compare(CV_KNEAREST) )
- knearest->load( filename );
- else if( !modelName.compare(CV_SVM) )
- {
- delete svm;
- svm = new CvSVM;
- svm->load( filename );
- }
- else if( !modelName.compare(CV_ANN) )
- ann->load( filename );
- else if( !modelName.compare(CV_DTREE) )
- dtree->load( filename );
- else if( !modelName.compare(CV_BOOST) )
- boost->load( filename );
- else if( !modelName.compare(CV_RTREES) )
- rtrees->load( filename );
- else if( !modelName.compare(CV_ERTREES) )
- ertrees->load( filename );
+ if( modelName == CV_NBAYES )
+ model = StatModel::load<NormalBayesClassifier>( filename );
+ else if( modelName == CV_KNEAREST )
+ model = StatModel::load<KNearest>( filename );
+ else if( modelName == CV_SVM )
+ model = StatModel::load<SVM>( filename );
+ else if( modelName == CV_ANN )
+ model = StatModel::load<ANN_MLP>( filename );
+ else if( modelName == CV_DTREE )
+ model = StatModel::load<DTrees>( filename );
+ else if( modelName == CV_BOOST )
+ model = StatModel::load<Boost>( filename );
+ else if( modelName == CV_RTREES )
+ model = StatModel::load<RTrees>( filename );
+ else
+ CV_Error( CV_StsNotImplemented, "invalid stat model name");
}
/* End of file. */
#define CV_RTREES "rtrees"
#define CV_ERTREES "ertrees"
+enum { CV_TRAIN_ERROR=0, CV_TEST_ERROR=1 };
+
+using cv::Ptr;
+using cv::ml::StatModel;
+using cv::ml::TrainData;
+using cv::ml::NormalBayesClassifier;
+using cv::ml::SVM;
+using cv::ml::KNearest;
+using cv::ml::ParamGrid;
+using cv::ml::ANN_MLP;
+using cv::ml::DTrees;
+using cv::ml::Boost;
+using cv::ml::RTrees;
+
class CV_MLBaseTest : public cvtest::BaseTest
{
public:
virtual int validate_test_results( int testCaseIdx ) = 0;
int train( int testCaseIdx );
- float get_error( int testCaseIdx, int type, std::vector<float> *resp = 0 );
+ float get_test_error( int testCaseIdx, std::vector<float> *resp = 0 );
void save( const char* filename );
void load( const char* filename );
- CvMLData data;
+ Ptr<TrainData> data;
std::string modelName, validationFN;
std::vector<std::string> dataSetNames;
cv::FileStorage validationFS;
- // MLL models
- CvNormalBayesClassifier* nbayes;
- CvKNearest* knearest;
- CvSVM* svm;
- CvANN_MLP* ann;
- CvDTree* dtree;
- CvBoost* boost;
- CvRTrees* rtrees;
- CvERTrees* ertrees;
+ Ptr<StatModel> model;
std::map<int, int> cls_map;
{
public:
CV_AMLTest( const char* _modelName );
+ virtual ~CV_AMLTest() {}
protected:
virtual int run_test_case( int testCaseIdx );
virtual int validate_test_results( int testCaseIdx );
{
public:
CV_SLMLTest( const char* _modelName );
+ virtual ~CV_SLMLTest() {}
protected:
virtual int run_test_case( int testCaseIdx );
virtual int validate_test_results( int testCaseIdx );
if( code == cvtest::TS::OK )
{
- data.mix_train_and_test_idx();
- code = train( testCaseIdx );
- if( code == cvtest::TS::OK )
- {
- get_error( testCaseIdx, CV_TEST_ERROR, &test_resps1 );
- fname1 = tempfile(".yml.gz");
- save( fname1.c_str() );
- load( fname1.c_str() );
- get_error( testCaseIdx, CV_TEST_ERROR, &test_resps2 );
- fname2 = tempfile(".yml.gz");
- save( fname2.c_str() );
- }
- else
- ts->printf( cvtest::TS::LOG, "model can not be trained" );
+ data->setTrainTestSplit(data->getNTrainSamples(), true);
+ code = train( testCaseIdx );
+ if( code == cvtest::TS::OK )
+ {
+ get_test_error( testCaseIdx, &test_resps1 );
+ fname1 = tempfile(".yml.gz");
+ save( fname1.c_str() );
+ load( fname1.c_str() );
+ get_test_error( testCaseIdx, &test_resps2 );
+ fname2 = tempfile(".yml.gz");
+ save( fname2.c_str() );
+ }
+ else
+ ts->printf( cvtest::TS::LOG, "model can not be trained" );
}
return code;
}
remove( fname2.c_str() );
}
- // 2. compare responses
- CV_Assert( test_resps1.size() == test_resps2.size() );
- vector<float>::const_iterator it1 = test_resps1.begin(), it2 = test_resps2.begin();
- for( ; it1 != test_resps1.end(); ++it1, ++it2 )
+ if( code >= 0 )
{
- if( fabs(*it1 - *it2) > FLT_EPSILON )
+ // 2. compare responses
+ CV_Assert( test_resps1.size() == test_resps2.size() );
+ vector<float>::const_iterator it1 = test_resps1.begin(), it2 = test_resps2.begin();
+ for( ; it1 != test_resps1.end(); ++it1, ++it2 )
{
- ts->printf( cvtest::TS::LOG, "in test case %d responses predicted before saving and after loading is different", testCaseIdx );
- code = cvtest::TS::FAIL_INVALID_OUTPUT;
+ if( fabs(*it1 - *it2) > FLT_EPSILON )
+ {
+ ts->printf( cvtest::TS::LOG, "in test case %d responses predicted before saving and after loading is different", testCaseIdx );
+ code = cvtest::TS::FAIL_INVALID_OUTPUT;
+ break;
+ }
}
}
return code;
TEST(ML_DTree, save_load) { CV_SLMLTest test( CV_DTREE ); test.safe_run(); }
TEST(ML_Boost, save_load) { CV_SLMLTest test( CV_BOOST ); test.safe_run(); }
TEST(ML_RTrees, save_load) { CV_SLMLTest test( CV_RTREES ); test.safe_run(); }
-TEST(ML_ERTrees, save_load) { CV_SLMLTest test( CV_ERTREES ); test.safe_run(); }
+TEST(DISABLED_ML_ERTrees, save_load) { CV_SLMLTest test( CV_ERTREES ); test.safe_run(); }
-TEST(ML_SVM, throw_exception_when_save_untrained_model)
+/*TEST(ML_SVM, throw_exception_when_save_untrained_model)
{
- SVM svm;
+ Ptr<cv::ml::SVM> svm;
string filename = tempfile("svm.xml");
ASSERT_THROW(svm.save(filename.c_str()), Exception);
remove(filename.c_str());
-}
+}*/
TEST(DISABLED_ML_SVM, linear_save_load)
{
- CvSVM svm1, svm2, svm3;
- svm1.load("SVM45_X_38-1.xml");
- svm2.load("SVM45_X_38-2.xml");
+ Ptr<cv::ml::SVM> svm1, svm2, svm3;
+
+ svm1 = StatModel::load<SVM>("SVM45_X_38-1.xml");
+ svm2 = StatModel::load<SVM>("SVM45_X_38-2.xml");
string tname = tempfile("a.xml");
- svm2.save(tname.c_str());
- svm3.load(tname.c_str());
+ svm2->save(tname);
+ svm3 = StatModel::load<SVM>(tname);
- ASSERT_EQ(svm1.get_var_count(), svm2.get_var_count());
- ASSERT_EQ(svm1.get_var_count(), svm3.get_var_count());
+ ASSERT_EQ(svm1->getVarCount(), svm2->getVarCount());
+ ASSERT_EQ(svm1->getVarCount(), svm3->getVarCount());
- int m = 10000, n = svm1.get_var_count();
+ int m = 10000, n = svm1->getVarCount();
Mat samples(m, n, CV_32F), r1, r2, r3;
randu(samples, 0., 1.);
- svm1.predict(samples, r1);
- svm2.predict(samples, r2);
- svm3.predict(samples, r3);
+ svm1->predict(samples, r1);
+ svm2->predict(samples, r2);
+ svm3->predict(samples, r3);
double eps = 1e-4;
- EXPECT_LE(cvtest::norm(r1, r2, NORM_INF), eps);
- EXPECT_LE(cvtest::norm(r1, r3, NORM_INF), eps);
+ EXPECT_LE(norm(r1, r2, NORM_INF), eps);
+ EXPECT_LE(norm(r1, r3, NORM_INF), eps);
remove(tname.c_str());
}
projects / platform / upstream / opencv.git / commitdiff