OpenCV 4.5.3(日本語機械翻訳)
ml.hpp
1 /*M///////////////////////////////////////////////////////////////////////////////////////
2 //
3 // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
4 //
5 // By downloading, copying, installing or using the software you agree to this license.
6 // If you do not agree to this license, do not download, install,
7 // copy or use the software.
8 //
9 //
10 // License Agreement
11 // For Open Source Computer Vision Library
12 //
13 // Copyright (C) 2000, Intel Corporation, all rights reserved.
14 // Copyright (C) 2013, OpenCV Foundation, all rights reserved.
15 // Copyright (C) 2014, Itseez Inc, all rights reserved.
16 // Third party copyrights are property of their respective owners.
17 //
18 // Redistribution and use in source and binary forms, with or without modification,
19 // are permitted provided that the following conditions are met:
20 //
21 // * Redistribution's of source code must retain the above copyright notice,
22 // this list of conditions and the following disclaimer.
23 //
24 // * Redistribution's in binary form must reproduce the above copyright notice,
25 // this list of conditions and the following disclaimer in the documentation
26 // and/or other materials provided with the distribution.
27 //
28 // * The name of the copyright holders may not be used to endorse or promote products
29 // derived from this software without specific prior written permission.
30 //
31 // This software is provided by the copyright holders and contributors "as is" and
32 // any express or implied warranties, including, but not limited to, the implied
33 // warranties of merchantability and fitness for a particular purpose are disclaimed.
34 // In no event shall the Intel Corporation or contributors be liable for any direct,
35 // indirect, incidental, special, exemplary, or consequential damages
36 // (including, but not limited to, procurement of substitute goods or services;
37 // loss of use, data, or profits; or business interruption) however caused
38 // and on any theory of liability, whether in contract, strict liability,
39 // or tort (including negligence or otherwise) arising in any way out of
40 // the use of this software, even if advised of the possibility of such damage.
41 //
42 //M*/
43
44 #ifndef OPENCV_ML_HPP
45 #define OPENCV_ML_HPP
46
47 #ifdef __cplusplus
48 # include "opencv2/core.hpp"
49 #endif
50
51 #ifdef __cplusplus
52
53 #include <float.h>
54 #include <map>
55 #include <iostream>
56
71 namespace cv
72{
73
74 namespace ml
75{
76
79
81 enum VariableTypes
82{
83 VAR_NUMERICAL =0,
84 VAR_ORDERED =0,
85 VAR_CATEGORICAL =1
86};
87
89 enum ErrorTypes
90{
91 TEST_ERROR = 0,
92 TRAIN_ERROR = 1
93};
94
96 enum SampleTypes
97{
98 ROW_SAMPLE = 0,
99 COL_SAMPLE = 1
100};
101
107 class CV_EXPORTS_W ParamGrid
108{
109 public:
111 ParamGrid();
113 ParamGrid(double _minVal, double _maxVal, double _logStep);
114
115 CV_PROP_RW double minVal;
116 CV_PROP_RW double maxVal;
125 CV_PROP_RW double logStep;
126
133 CV_WRAP static Ptr<ParamGrid> create(double minVal=0., double maxVal=0., double logstep=1.);
134};
135
145 class CV_EXPORTS_W TrainData
146{
147 public:
148 static inline float missingValue() { return FLT_MAX; }
149 virtual ~TrainData();
150
151 CV_WRAP virtual int getLayout() const = 0;
152 CV_WRAP virtual int getNTrainSamples() const = 0;
153 CV_WRAP virtual int getNTestSamples() const = 0;
154 CV_WRAP virtual int getNSamples() const = 0;
155 CV_WRAP virtual int getNVars() const = 0;
156 CV_WRAP virtual int getNAllVars() const = 0;
157
158 CV_WRAP virtual void getSample(InputArray varIdx, int sidx, float* buf) const = 0;
159 CV_WRAP virtual Mat getSamples() const = 0;
160 CV_WRAP virtual Mat getMissing() const = 0;
161
174 CV_WRAP virtual Mat getTrainSamples(int layout=ROW_SAMPLE,
175 bool compressSamples=true,
176 bool compressVars=true) const = 0;
177
183 CV_WRAP virtual Mat getTrainResponses() const = 0;
184
191 CV_WRAP virtual Mat getTrainNormCatResponses() const = 0;
192 CV_WRAP virtual Mat getTestResponses() const = 0;
193 CV_WRAP virtual Mat getTestNormCatResponses() const = 0;
194 CV_WRAP virtual Mat getResponses() const = 0;
195 CV_WRAP virtual Mat getNormCatResponses() const = 0;
196 CV_WRAP virtual Mat getSampleWeights() const = 0;
197 CV_WRAP virtual Mat getTrainSampleWeights() const = 0;
198 CV_WRAP virtual Mat getTestSampleWeights() const = 0;
199 CV_WRAP virtual Mat getVarIdx() const = 0;
200 CV_WRAP virtual Mat getVarType() const = 0;
201 CV_WRAP virtual Mat getVarSymbolFlags() const = 0;
202 CV_WRAP virtual int getResponseType() const = 0;
203 CV_WRAP virtual Mat getTrainSampleIdx() const = 0;
204 CV_WRAP virtual Mat getTestSampleIdx() const = 0;
205 CV_WRAP virtual void getValues(int vi, InputArray sidx, float* values) const = 0;
206 virtual void getNormCatValues(int vi, InputArray sidx, int* values) const = 0;
207 CV_WRAP virtual Mat getDefaultSubstValues() const = 0;
208
209 CV_WRAP virtual int getCatCount(int vi) const = 0;
210
215 CV_WRAP virtual Mat getClassLabels() const = 0;
216
217 CV_WRAP virtual Mat getCatOfs() const = 0;
218 CV_WRAP virtual Mat getCatMap() const = 0;
219
223 CV_WRAP virtual void setTrainTestSplit(int count, bool shuffle=true) = 0;
224
233 CV_WRAP virtual void setTrainTestSplitRatio(double ratio, bool shuffle=true) = 0;
234 CV_WRAP virtual void shuffleTrainTest() = 0;
235
237 CV_WRAP virtual Mat getTestSamples() const = 0;
238
240 CV_WRAP virtual void getNames(std::vector<String>& names) const = 0;
241
246 static CV_WRAP Mat getSubVector(const Mat& vec, const Mat& idx);
247
253 static CV_WRAP Mat getSubMatrix(const Mat& matrix, const Mat& idx, int layout);
254
284 static Ptr<TrainData> loadFromCSV(const String& filename,
285 int headerLineCount,
286 int responseStartIdx=-1,
287 int responseEndIdx=-1,
288 const String& varTypeSpec=String(),
289 char delimiter=',',
290 char missch='?');
291
311 CV_WRAP static Ptr<TrainData> create(InputArray samples, int layout, InputArray responses,
312 InputArray varIdx=noArray(), InputArray sampleIdx=noArray(),
313 InputArray sampleWeights=noArray(), InputArray varType=noArray());
314};
315
318 class CV_EXPORTS_W StatModel : public Algorithm
319{
320 public:
322 enum Flags {
323 UPDATE_MODEL = 1,
324 RAW_OUTPUT=1,
325 COMPRESSED_INPUT=2,
326 PREPROCESSED_INPUT=4
327 };
328
330 CV_WRAP virtual int getVarCount() const = 0;
331
332 CV_WRAP virtual bool empty() const CV_OVERRIDE;
333
335 CV_WRAP virtual bool isTrained() const = 0;
337 CV_WRAP virtual bool isClassifier() const = 0;
338
346 CV_WRAP virtual bool train( const Ptr<TrainData>& trainData, int flags=0 );
347
354 CV_WRAP virtual bool train( InputArray samples, int layout, InputArray responses );
355
369 CV_WRAP virtual float calcError( const Ptr<TrainData>& data, bool test, OutputArray resp ) const;
370
377 CV_WRAP virtual float predict( InputArray samples, OutputArray results=noArray(), int flags=0 ) const = 0;
378
383 template<typename _Tp> static Ptr<_Tp> train(const Ptr<TrainData>& data, int flags=0)
384 {
385 Ptr<_Tp> model = _Tp::create();
386 return !model.empty() && model->train(data, flags) ? model : Ptr<_Tp>();
387 }
388};
389
390 /****************************************************************************************\
391 * Normal Bayes Classifier *
392 \****************************************************************************************/
393
398 class CV_EXPORTS_W NormalBayesClassifier : public StatModel
399{
400 public:
409 CV_WRAP virtual float predictProb( InputArray inputs, OutputArray outputs,
410 OutputArray outputProbs, int flags=0 ) const = 0;
411
414 CV_WRAP static Ptr<NormalBayesClassifier> create();
415
425 CV_WRAP static Ptr<NormalBayesClassifier> load(const String& filepath , const String& nodeName = String());
426};
427
428 /****************************************************************************************\
429 * K-Nearest Neighbour Classifier *
430 \****************************************************************************************/
431
436 class CV_EXPORTS_W KNearest : public StatModel
437{
438 public:
439
442 CV_WRAP virtual int getDefaultK() const = 0;
444 CV_WRAP virtual void setDefaultK(int val) = 0;
445
448 CV_WRAP virtual bool getIsClassifier() const = 0;
450 CV_WRAP virtual void setIsClassifier(bool val) = 0;
451
454 CV_WRAP virtual int getEmax() const = 0;
456 CV_WRAP virtual void setEmax(int val) = 0;
457
460 CV_WRAP virtual int getAlgorithmType() const = 0;
462 CV_WRAP virtual void setAlgorithmType(int val) = 0;
463
490 CV_WRAP virtual float findNearest( InputArray samples, int k,
491 OutputArray results,
492 OutputArray neighborResponses=noArray(),
493 OutputArray dist=noArray() ) const = 0;
494
497 enum Types
498 {
499 BRUTE_FORCE=1,
500 KDTREE=2
501 };
502
507 CV_WRAP static Ptr<KNearest> create();
515 CV_WRAP static Ptr<KNearest> load(const String& filepath);
516};
517
518 /****************************************************************************************\
519 * Support Vector Machines *
520 \****************************************************************************************/
521
526 class CV_EXPORTS_W SVM : public StatModel
527{
528 public:
529
530 class CV_EXPORTS Kernel : public Algorithm
531 {
532 public:
533 virtual int getType() const = 0;
534 virtual void calc( int vcount, int n, const float* vecs, const float* another, float* results ) = 0;
535 };
536
540 CV_WRAP virtual int getType() const = 0;
542 CV_WRAP virtual void setType(int val) = 0;
543
547 CV_WRAP virtual double getGamma() const = 0;
549 CV_WRAP virtual void setGamma(double val) = 0;
550
554 CV_WRAP virtual double getCoef0() const = 0;
556 CV_WRAP virtual void setCoef0(double val) = 0;
557
561 CV_WRAP virtual double getDegree() const = 0;
563 CV_WRAP virtual void setDegree(double val) = 0;
564
568 CV_WRAP virtual double getC() const = 0;
570 CV_WRAP virtual void setC(double val) = 0;
571
575 CV_WRAP virtual double getNu() const = 0;
577 CV_WRAP virtual void setNu(double val) = 0;
578
582 CV_WRAP virtual double getP() const = 0;
584 CV_WRAP virtual void setP(double val) = 0;
585
592 CV_WRAP virtual cv::Mat getClassWeights() const = 0;
594 CV_WRAP virtual void setClassWeights(const cv::Mat &val) = 0;
595
601 CV_WRAP virtual cv::TermCriteria getTermCriteria() const = 0;
603 CV_WRAP virtual void setTermCriteria(const cv::TermCriteria &val) = 0;
604
607 CV_WRAP virtual int getKernelType() const = 0;
608
611 CV_WRAP virtual void setKernel(int kernelType) = 0;
612
615 virtual void setCustomKernel(const Ptr<Kernel> &_kernel) = 0;
616
618 enum Types {
621 C_SVC=100,
625 NU_SVC=101,
629 ONE_CLASS=102,
633 EPS_SVR=103,
636 NU_SVR=104
637 };
638
647 enum KernelTypes {
649 CUSTOM=-1,
652 LINEAR=0,
655 POLY=1,
658 RBF=2,
660 SIGMOID=3,
663 CHI2=4,
665 INTER=5
666 };
667
669 enum ParamTypes {
670 C=0,
671 GAMMA=1,
672 P=2,
673 NU=3,
674 COEF=4,
675 DEGREE=5
676 };
677
712 virtual bool trainAuto( const Ptr<TrainData>& data, int kFold = 10,
713 ParamGrid Cgrid = getDefaultGrid(C),
714 ParamGrid gammaGrid = getDefaultGrid(GAMMA),
715 ParamGrid pGrid = getDefaultGrid(P),
716 ParamGrid nuGrid = getDefaultGrid(NU),
717 ParamGrid coeffGrid = getDefaultGrid(COEF),
718 ParamGrid degreeGrid = getDefaultGrid(DEGREE),
719 bool balanced=false) = 0;
720
749 CV_WRAP virtual bool trainAuto(InputArray samples,
750 int layout,
751 InputArray responses,
752 int kFold = 10,
753 Ptr<ParamGrid> Cgrid = SVM::getDefaultGridPtr(SVM::C),
754 Ptr<ParamGrid> gammaGrid = SVM::getDefaultGridPtr(SVM::GAMMA),
755 Ptr<ParamGrid> pGrid = SVM::getDefaultGridPtr(SVM::P),
756 Ptr<ParamGrid> nuGrid = SVM::getDefaultGridPtr(SVM::NU),
757 Ptr<ParamGrid> coeffGrid = SVM::getDefaultGridPtr(SVM::COEF),
758 Ptr<ParamGrid> degreeGrid = SVM::getDefaultGridPtr(SVM::DEGREE),
759 bool balanced=false) = 0;
760
766 CV_WRAP virtual Mat getSupportVectors() const = 0;
767
774 CV_WRAP virtual Mat getUncompressedSupportVectors() const = 0;
775
791 CV_WRAP virtual double getDecisionFunction(int i, OutputArray alpha, OutputArray svidx) const = 0;
792
801 static ParamGrid getDefaultGrid( int param_id );
802
811 CV_WRAP static Ptr<ParamGrid> getDefaultGridPtr( int param_id );
812
816 CV_WRAP static Ptr<SVM> create();
817
825 CV_WRAP static Ptr<SVM> load(const String& filepath);
826};
827
828 /****************************************************************************************\
829 * Expectation - Maximization *
830 \****************************************************************************************/
831
836 class CV_EXPORTS_W EM : public StatModel
837{
838 public:
840 enum Types {
847 COV_MAT_SPHERICAL=0,
851 COV_MAT_DIAGONAL=1,
856 COV_MAT_GENERIC=2,
857 COV_MAT_DEFAULT=COV_MAT_DIAGONAL
858 };
859
861 enum {DEFAULT_NCLUSTERS=5, DEFAULT_MAX_ITERS=100};
862
864 enum {START_E_STEP=1, START_M_STEP=2, START_AUTO_STEP=0};
865
871 CV_WRAP virtual int getClustersNumber() const = 0;
873 CV_WRAP virtual void setClustersNumber(int val) = 0;
874
878 CV_WRAP virtual int getCovarianceMatrixType() const = 0;
880 CV_WRAP virtual void setCovarianceMatrixType(int val) = 0;
881
887 CV_WRAP virtual TermCriteria getTermCriteria() const = 0;
889 CV_WRAP virtual void setTermCriteria(const TermCriteria &val) = 0;
890
895 CV_WRAP virtual Mat getWeights() const = 0;
901 CV_WRAP virtual Mat getMeans() const = 0;
907 CV_WRAP virtual void getCovs(CV_OUT std::vector<Mat>& covs) const = 0;
908
916 CV_WRAP virtual float predict( InputArray samples, OutputArray results=noArray(), int flags=0 ) const CV_OVERRIDE = 0;
917
930 CV_WRAP virtual Vec2d predict2(InputArray sample, OutputArray probs) const = 0;
931
960 CV_WRAP virtual bool trainEM(InputArray samples,
961 OutputArray logLikelihoods=noArray(),
962 OutputArray labels=noArray(),
963 OutputArray probs=noArray()) = 0;
964
992 CV_WRAP virtual bool trainE(InputArray samples, InputArray means0,
993 InputArray covs0=noArray(),
994 InputArray weights0=noArray(),
995 OutputArray logLikelihoods=noArray(),
996 OutputArray labels=noArray(),
997 OutputArray probs=noArray()) = 0;
998
1017 CV_WRAP virtual bool trainM(InputArray samples, InputArray probs0,
1018 OutputArray logLikelihoods=noArray(),
1019 OutputArray labels=noArray(),
1020 OutputArray probs=noArray()) = 0;
1021
1026 CV_WRAP static Ptr<EM> create();
1027
1037 CV_WRAP static Ptr<EM> load(const String& filepath , const String& nodeName = String());
1038};
1039
1040 /****************************************************************************************\
1041 * Decision Tree *
1042 \****************************************************************************************/
1043
1053class CV_EXPORTS_W DTrees : public StatModel
1054{
1055 public:
1057 enum Flags { PREDICT_AUTO=0, PREDICT_SUM=(1<<8), PREDICT_MAX_VOTE=(2<<8), PREDICT_MASK=(3<<8) };
1058
1071 CV_WRAP virtual int getMaxCategories() const = 0;
1073 CV_WRAP virtual void setMaxCategories(int val) = 0;
1074
1081 CV_WRAP virtual int getMaxDepth() const = 0;
1083 CV_WRAP virtual void setMaxDepth(int val) = 0;
1084
1089 CV_WRAP virtual int getMinSampleCount() const = 0;
1091 CV_WRAP virtual void setMinSampleCount(int val) = 0;
1092
1097 CV_WRAP virtual int getCVFolds() const = 0;
1099 CV_WRAP virtual void setCVFolds(int val) = 0;
1100
1106 CV_WRAP virtual bool getUseSurrogates() const = 0;
1108 CV_WRAP virtual void setUseSurrogates(bool val) = 0;
1109
1114 CV_WRAP virtual bool getUse1SERule() const = 0;
1116 CV_WRAP virtual void setUse1SERule(bool val) = 0;
1117
1122 CV_WRAP virtual bool getTruncatePrunedTree() const = 0;
1124 CV_WRAP virtual void setTruncatePrunedTree(bool val) = 0;
1125
1131 CV_WRAP virtual float getRegressionAccuracy() const = 0;
1133 CV_WRAP virtual void setRegressionAccuracy(float val) = 0;
1134
1151 CV_WRAP virtual cv::Mat getPriors() const = 0;
1153 CV_WRAP virtual void setPriors(const cv::Mat &val) = 0;
1154
1157 class CV_EXPORTS Node
1158 {
1159 public:
1160 Node();
1161 double value;
1163 int classIdx;
1165 int parent;
1166 int left;
1167 int right;
1168 int defaultDir;
1170 int split;
1171 };
1172
1175 class CV_EXPORTS Split
1176 {
1177 public:
1178 Split();
1179 int varIdx;
1180 bool inversed;
1182 float quality;
1183 int next;
1184 float c;
1191 int subsetOfs;
1198 };
1199
1202 virtual const std::vector<int>& getRoots() const = 0;
1207 virtual const std::vector<Node>& getNodes() const = 0;
1212 virtual const std::vector<Split>& getSplits() const = 0;
1217 virtual const std::vector<int>& getSubsets() const = 0;
1218
1225 CV_WRAP static Ptr<DTrees> create();
1226
1236 CV_WRAP static Ptr<DTrees> load(const String& filepath , const String& nodeName = String());
1237};
1238
1239 /****************************************************************************************\
1240 * Random Trees Classifier *
1241 \****************************************************************************************/
1242
1247 class CV_EXPORTS_W RTrees : public DTrees
1248{
1249 public:
1250
1254 CV_WRAP virtual bool getCalculateVarImportance() const = 0;
1256 CV_WRAP virtual void setCalculateVarImportance(bool val) = 0;
1257
1263 CV_WRAP virtual int getActiveVarCount() const = 0;
1265 CV_WRAP virtual void setActiveVarCount(int val) = 0;
1266
1275 CV_WRAP virtual TermCriteria getTermCriteria() const = 0;
1277 CV_WRAP virtual void setTermCriteria(const TermCriteria &val) = 0;
1278
1284 CV_WRAP virtual Mat getVarImportance() const = 0;
1285
1295 CV_WRAP virtual void getVotes(InputArray samples, OutputArray results, int flags) const = 0;
1296
1300 #if CV_VERSION_MAJOR == 4
1301 CV_WRAP virtual double getOOBError() const { return 0; }
1302 #else
1303 /*CV_WRAP*/ virtual double getOOBError() const = 0;
1304 #endif
1305
1310 CV_WRAP static Ptr<RTrees> create();
1311
1321 CV_WRAP static Ptr<RTrees> load(const String& filepath , const String& nodeName = String());
1322};
1323
1324 /****************************************************************************************\
1325 * Boosted tree classifier *
1326 \****************************************************************************************/
1327
1332 class CV_EXPORTS_W Boost : public DTrees
1333{
1334 public:
1338 CV_WRAP virtual int getBoostType() const = 0;
1340 CV_WRAP virtual void setBoostType(int val) = 0;
1341
1345 CV_WRAP virtual int getWeakCount() const = 0;
1347 CV_WRAP virtual void setWeakCount(int val) = 0;
1348
1353 CV_WRAP virtual double getWeightTrimRate() const = 0;
1355 CV_WRAP virtual void setWeightTrimRate(double val) = 0;
1356
1359 enum Types {
1360 DISCRETE=0,
1361 REAL=1,
1363 LOGIT=2,
1364 GENTLE=3
1366 };
1367
1370 CV_WRAP static Ptr<Boost> create();
1371
1381 CV_WRAP static Ptr<Boost> load(const String& filepath , const String& nodeName = String());
1382};
1383
1384 /****************************************************************************************\
1385 * Gradient Boosted Trees *
1386 \****************************************************************************************/
1387
1388 /*class CV_EXPORTS_W GBTrees : public DTrees
1389 {
1390 public:
1391 struct CV_EXPORTS_W_MAP Params : public DTrees::Params
1392 {
1393 CV_PROP_RW int weakCount;
1394 CV_PROP_RW int lossFunctionType;
1395 CV_PROP_RW float subsamplePortion;
1396 CV_PROP_RW float shrinkage;
1397
1398 Params();
1399 Params( int lossFunctionType, int weakCount, float shrinkage,
1400 float subsamplePortion, int maxDepth, bool useSurrogates );
1401 };
1402
1403 enum {SQUARED_LOSS=0, ABSOLUTE_LOSS, HUBER_LOSS=3, DEVIANCE_LOSS};
1404
1405 virtual void setK(int k) = 0;
1406
1407 virtual float predictSerial( InputArray samples,
1408 OutputArray weakResponses, int flags) const = 0;
1409
1410 static Ptr<GBTrees> create(const Params& p);
1411 };*/
1412
1413 /****************************************************************************************\
1414 * Artificial Neural Networks (ANN) *
1415 \****************************************************************************************/
1416
1418
1431 class CV_EXPORTS_W ANN_MLP : public StatModel
1432{
1433 public:
1435 enum TrainingMethods {
1436 BACKPROP=0,
1437 RPROP = 1,
1438 ANNEAL = 2
1439 };
1440
1446 CV_WRAP virtual void setTrainMethod(int method, double param1 = 0, double param2 = 0) = 0;
1447
1449 CV_WRAP virtual int getTrainMethod() const = 0;
1450
1457 CV_WRAP virtual void setActivationFunction(int type, double param1 = 0, double param2 = 0) = 0;
1458
1463 CV_WRAP virtual void setLayerSizes(InputArray _layer_sizes) = 0;
1464
1469 CV_WRAP virtual cv::Mat getLayerSizes() const = 0;
1470
1476 CV_WRAP virtual TermCriteria getTermCriteria() const = 0;
1478 CV_WRAP virtual void setTermCriteria(TermCriteria val) = 0;
1479
1483 CV_WRAP virtual double getBackpropWeightScale() const = 0;
1485 CV_WRAP virtual void setBackpropWeightScale(double val) = 0;
1486
1492 CV_WRAP virtual double getBackpropMomentumScale() const = 0;
1494 CV_WRAP virtual void setBackpropMomentumScale(double val) = 0;
1495
1499 CV_WRAP virtual double getRpropDW0() const = 0;
1501 CV_WRAP virtual void setRpropDW0(double val) = 0;
1502
1506 CV_WRAP virtual double getRpropDWPlus() const = 0;
1508 CV_WRAP virtual void setRpropDWPlus(double val) = 0;
1509
1513 CV_WRAP virtual double getRpropDWMinus() const = 0;
1515 CV_WRAP virtual void setRpropDWMinus(double val) = 0;
1516
1520 CV_WRAP virtual double getRpropDWMin() const = 0;
1522 CV_WRAP virtual void setRpropDWMin(double val) = 0;
1523
1527 CV_WRAP virtual double getRpropDWMax() const = 0;
1529 CV_WRAP virtual void setRpropDWMax(double val) = 0;
1530
1534 CV_WRAP virtual double getAnnealInitialT() const = 0;
1536 CV_WRAP virtual void setAnnealInitialT(double val) = 0;
1537
1541 CV_WRAP virtual double getAnnealFinalT() const = 0;
1543 CV_WRAP virtual void setAnnealFinalT(double val) = 0;
1544
1548 CV_WRAP virtual double getAnnealCoolingRatio() const = 0;
1550 CV_WRAP virtual void setAnnealCoolingRatio(double val) = 0;
1551
1555 CV_WRAP virtual int getAnnealItePerStep() const = 0;
1557 CV_WRAP virtual void setAnnealItePerStep(int val) = 0;
1558
1560 virtual void setAnnealEnergyRNG(const RNG& rng) = 0;
1561
1563 enum ActivationFunctions {
1565 IDENTITY = 0,
1571 SIGMOID_SYM = 1,
1573 GAUSSIAN = 2,
1575 RELU = 3,
1577 LEAKYRELU= 4
1578 };
1579
1581 enum TrainFlags {
1584 UPDATE_WEIGHTS = 1,
1590 NO_INPUT_SCALE = 2,
1594 NO_OUTPUT_SCALE = 4
1595 };
1596
1597 CV_WRAP virtual Mat getWeights(int layerIdx) const = 0;
1598
1604 CV_WRAP static Ptr<ANN_MLP> create();
1605
1613 CV_WRAP static Ptr<ANN_MLP> load(const String& filepath);
1614
1615};
1616
1617 #ifndef DISABLE_OPENCV_3_COMPATIBILITY
1618 typedef ANN_MLP ANN_MLP_ANNEAL;
1619 #endif
1620
1621 /****************************************************************************************\
1622 * Logistic Regression *
1623 \****************************************************************************************/
1624
1629 class CV_EXPORTS_W LogisticRegression : public StatModel
1630{
1631 public:
1632
1635 CV_WRAP virtual double getLearningRate() const = 0;
1637 CV_WRAP virtual void setLearningRate(double val) = 0;
1638
1641 CV_WRAP virtual int getIterations() const = 0;
1643 CV_WRAP virtual void setIterations(int val) = 0;
1644
1647 CV_WRAP virtual int getRegularization() const = 0;
1649 CV_WRAP virtual void setRegularization(int val) = 0;
1650
1653 CV_WRAP virtual int getTrainMethod() const = 0;
1655 CV_WRAP virtual void setTrainMethod(int val) = 0;
1656
1661 CV_WRAP virtual int getMiniBatchSize() const = 0;
1663 CV_WRAP virtual void setMiniBatchSize(int val) = 0;
1664
1667 CV_WRAP virtual TermCriteria getTermCriteria() const = 0;
1669 CV_WRAP virtual void setTermCriteria(TermCriteria val) = 0;
1670
1672 enum RegKinds {
1673 REG_DISABLE = -1,
1674 REG_L1 = 0,
1675 REG_L2 = 1
1676 };
1677
1679 enum Methods {
1680 BATCH = 0,
1681 MINI_BATCH = 1
1682 };
1683
1691 CV_WRAP virtual float predict( InputArray samples, OutputArray results=noArray(), int flags=0 ) const CV_OVERRIDE = 0;
1692
1698 CV_WRAP virtual Mat get_learnt_thetas() const = 0;
1699
1704 CV_WRAP static Ptr<LogisticRegression> create();
1705
1715 CV_WRAP static Ptr<LogisticRegression> load(const String& filepath , const String& nodeName = String());
1716};
1717
1718
1719 /****************************************************************************************\
1720 * Stochastic Gradient Descent SVM Classifier *
1721 \****************************************************************************************/
1722
1796class CV_EXPORTS_W SVMSGD : public cv::ml::StatModel
1797{
1798 public:
1799
1802 enum SvmsgdType
1803 {
1804 SGD,
1805 ASGD
1806 };
1807
1809 enum MarginType
1810 {
1811 SOFT_MARGIN,
1812 HARD_MARGIN
1813 };
1814
1818 CV_WRAP virtual Mat getWeights() = 0;
1819
1823 CV_WRAP virtual float getShift() = 0;
1824
1829 CV_WRAP static Ptr<SVMSGD> create();
1830
1840 CV_WRAP static Ptr<SVMSGD> load(const String& filepath , const String& nodeName = String());
1841
1846 CV_WRAP virtual void setOptimalParameters(int svmsgdType = SVMSGD::ASGD, int marginType = SVMSGD::SOFT_MARGIN) = 0;
1847
1850 CV_WRAP virtual int getSvmsgdType() const = 0;
1852 CV_WRAP virtual void setSvmsgdType(int svmsgdType) = 0;
1853
1856 CV_WRAP virtual int getMarginType() const = 0;
1858 CV_WRAP virtual void setMarginType(int marginType) = 0;
1859
1862 CV_WRAP virtual float getMarginRegularization() const = 0;
1864 CV_WRAP virtual void setMarginRegularization(float marginRegularization) = 0;
1865
1868 CV_WRAP virtual float getInitialStepSize() const = 0;
1870 CV_WRAP virtual void setInitialStepSize(float InitialStepSize) = 0;
1871
1874 CV_WRAP virtual float getStepDecreasingPower() const = 0;
1876 CV_WRAP virtual void setStepDecreasingPower(float stepDecreasingPower) = 0;
1877
1882 CV_WRAP virtual TermCriteria getTermCriteria() const = 0;
1884 CV_WRAP virtual void setTermCriteria(const cv::TermCriteria &val) = 0;
1885};
1886
1887
1888 /****************************************************************************************\
1889 * Auxiliary functions declarations *
1890 \****************************************************************************************/
1891
1899CV_EXPORTS void randMVNormal( InputArray mean, InputArray cov, int nsamples, OutputArray samples);
1900
1902CV_EXPORTS void createConcentricSpheresTestSet( int nsamples, int nfeatures, int nclasses,
1903 OutputArray samples, OutputArray responses);
1904
1905
1906 /****************************************************************************************\
1907 * Simulated annealing solver *
1908 \****************************************************************************************/
1909
1910 #ifdef CV_DOXYGEN
1915 struct SimulatedAnnealingSolverSystem
1916{
1918 double energy() const;
1920 void changeState();
1922 void reverseState();
1923};
1924 #endif // CV_DOXYGEN
1925
1938 template<class SimulatedAnnealingSolverSystem>
1939 int simulatedAnnealingSolver(SimulatedAnnealingSolverSystem& solverSystem,
1940 double initialTemperature, double finalTemperature, double coolingRatio,
1941 size_t iterationsPerStep,
1942 CV_OUT double* lastTemperature = NULL,
1943 cv::RNG& rngEnergy = cv::theRNG()
1944);
1945
1947
1948}
1949}
1950
1951 #include <opencv2/ml/ml.inl.hpp>
1952
1953 #endif // __cplusplus
1954 #endif // OPENCV_ML_HPP
1955
1956 /* End of file. */
cv::Mat
n-dimensional dense array class
Definition: mat.hpp:802
cv::RNG
Random Number Generator
Definition: core.hpp:2783
cv::TermCriteria
The class defining termination criteria for iterative algorithms.
Definition: core/types.hpp:853
cv::split
CV_EXPORTS void split(const Mat &src, Mat *mvbegin)
Divides a multi-channel array into several single-channel arrays.
cv::theRNG
CV_EXPORTS RNG & theRNG()
Returns the default random number generator.
cv::ft::LINEAR
@ LINEAR
linear (triangular) shape
Definition: fuzzy/types.hpp:55
cv
"black box" representation of the file storage associated with a file on disk.
Definition: aruco.hpp:75
構築: doxygen 1.9.2