[ VIGRA Homepage | Function Index | Class Index | Namespaces | File List | Main Page ]

random_forest.hxx |

1 /************************************************************************/
2 /* */
3 /* Copyright 2008-2009 by Ullrich Koethe and Rahul Nair */
4 /* */
5 /* This file is part of the VIGRA computer vision library. */
6 /* The VIGRA Website is */
7 /* http://hci.iwr.uni-heidelberg.de/vigra/ */
8 /* Please direct questions, bug reports, and contributions to */
9 /* ullrich.koethe@iwr.uni-heidelberg.de or */
10 /* vigra@informatik.uni-hamburg.de */
11 /* */
12 /* Permission is hereby granted, free of charge, to any person */
13 /* obtaining a copy of this software and associated documentation */
14 /* files (the "Software"), to deal in the Software without */
15 /* restriction, including without limitation the rights to use, */
16 /* copy, modify, merge, publish, distribute, sublicense, and/or */
17 /* sell copies of the Software, and to permit persons to whom the */
18 /* Software is furnished to do so, subject to the following */
19 /* conditions: */
20 /* */
21 /* The above copyright notice and this permission notice shall be */
22 /* included in all copies or substantial portions of the */
23 /* Software. */
24 /* */
25 /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND */
26 /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES */
27 /* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND */
28 /* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT */
29 /* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, */
30 /* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING */
31 /* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR */
32 /* OTHER DEALINGS IN THE SOFTWARE. */
33 /* */
34 /************************************************************************/
35
36
37 #ifndef VIGRA_RANDOM_FOREST_HXX
38 #define VIGRA_RANDOM_FOREST_HXX
39
40 #include <iostream>
41 #include <algorithm>
42 #include <map>
43 #include <set>
44 #include <list>
45 #include <numeric>
46 #include "mathutil.hxx"
47 #include "array_vector.hxx"
48 #include "sized_int.hxx"
49 #include "matrix.hxx"
50 #include "metaprogramming.hxx"
51 #include "random.hxx"
52 #include "functorexpression.hxx"
53 #include "random_forest/rf_common.hxx"
54 #include "random_forest/rf_nodeproxy.hxx"
55 #include "random_forest/rf_split.hxx"
56 #include "random_forest/rf_decisionTree.hxx"
57 #include "random_forest/rf_visitors.hxx"
58 #include "random_forest/rf_region.hxx"
59 #include "sampling.hxx"
60 #include "random_forest/rf_preprocessing.hxx"
61 #include "random_forest/rf_online_prediction_set.hxx"
62 #include "random_forest/rf_earlystopping.hxx"
63 #include "random_forest/rf_ridge_split.hxx"
64 namespace vigra
65 {
66
67 /** \addtogroup MachineLearning Machine Learning
68
69 This module provides classification algorithms that map
70 features to labels or label probabilities.
71 Look at the \ref vigra::RandomForest class (for implementation version 2) or the
72 \ref vigra::rf3::random_forest() factory function (for implementation version 3)
73 for an overview of the functionality as well as use cases.
74 **/
75
76 namespace detail
77 {
78
79
80
81 /* \brief sampling option factory function
82 */
83 inline SamplerOptions make_sampler_opt ( RandomForestOptions & RF_opt)
84 {
85 SamplerOptions return_opt;
86 return_opt.withReplacement(RF_opt.sample_with_replacement_);
87 return_opt.stratified(RF_opt.stratification_method_ == RF_EQUAL);
88 return return_opt;
89 }
90 }//namespace detail
91
92 /** \brief Random forest version 2 (see also \ref vigra::rf3::RandomForest for version 3)
93 *
94 * \ingroup MachineLearning
95 *
96 * \tparam <LabelType = double> Type used for predicted labels.
97 * \tparam <PreprocessorTag = ClassificationTag> Class used to preprocess
98 * the input while learning and predicting. Currently Available:
99 * ClassificationTag and RegressionTag. It is recommended to use
100 * Splitfunctor::Preprocessor_t while using custom splitfunctors
101 * as they may need the data to be in a different format.
102 * \sa Preprocessor
103 *
104 * Simple usage for classification (regression is not yet supported):
105 * look at RandomForest::learn() as well as RandomForestOptions() for additional
106 * options.
107 *
108 * \code
109 * using namespace vigra;
110 * using namespace rf;
111 * typedef xxx feature_t; \\ replace xxx with whichever type
112 * typedef yyy label_t; \\ likewise
113 *
114 * // allocate the training data
115 * MultiArrayView<2, feature_t> f = get_training_features();
116 * MultiArrayView<2, label_t> l = get_training_labels();
117 *
118 * RandomForest<label_t> rf;
119 *
120 * // construct visitor to calculate out-of-bag error
121 * visitors::OOB_Error oob_v;
122 *
123 * // perform training
124 * rf.learn(f, l, visitors::create_visitor(oob_v));
125 *
126 * std::cout << "the out-of-bag error is: " << oob_v.oob_breiman << "\n";
127 *
128 * // get features for new data to be used for prediction
129 * MultiArrayView<2, feature_t> pf = get_features();
130 *
131 * // allocate space for the response (pf.shape(0) is the number of samples)
132 * MultiArrayView<2, label_t> prediction(pf.shape(0), 1);
133 * MultiArrayView<2, double> prob(pf.shape(0), rf.class_count());
134 *
135 * // perform prediction on new data
136 * rf.predictLabels(pf, prediction);
137 * rf.predictProbabilities(pf, prob);
138 *
139 * \endcode
140 *
141 * Additional information such as Variable Importance measures are accessed
142 * via Visitors defined in rf::visitors.
143 * Have a look at rf::split for other splitting methods.
144 *
145 */
146 template <class LabelType = double , class PreprocessorTag = ClassificationTag >
147 class RandomForest
148 {
149
150 public:
151 //public typedefs
152 typedef RandomForestOptions Options_t;
153 typedef detail::DecisionTree DecisionTree_t;
154 typedef ProblemSpec<LabelType> ProblemSpec_t;
155 typedef GiniSplit Default_Split_t;
156 typedef EarlyStoppStd Default_Stop_t;
157 typedef rf::visitors::StopVisiting Default_Visitor_t;
158 typedef DT_StackEntry<ArrayVectorView<Int32>::iterator>
159 StackEntry_t;
160 typedef LabelType LabelT;
161
162 //problem independent data.
163 Options_t options_;
164 //problem dependent data members - is only set if
165 //a copy constructor, some sort of import
166 //function or the learn function is called
167 ArrayVector<DecisionTree_t> trees_;
168 ProblemSpec_t ext_param_;
169 /*mutable ArrayVector<int> tree_indices_;*/
170 rf::visitors::OnlineLearnVisitor online_visitor_;
171
172
173 void reset()
174 {
175 ext_param_.clear();
176 trees_.clear();
177 }
178
179 public:
180
181 /** \name Constructors
182 * Note: No copy constructor specified as no pointers are manipulated
183 * in this class
184
185 * @{
186 */
187
188 /**\brief default constructor
189 *
190 * \param options general options to the Random Forest. Must be of Type
191 * Options_t
192 * \param ext_param problem specific values that can be supplied
193 * additionally. (class weights , labels etc)
194 * \sa RandomForestOptions, ProblemSpec
195 *
196 */
197 RandomForest(Options_t const & options = Options_t(),
198 ProblemSpec_t const & ext_param = ProblemSpec_t())
199 :
200 options_(options),
201 ext_param_(ext_param)/*,
202 tree_indices_(options.tree_count_,0)*/
203 {
204 /*for(int ii = 0 ; ii < int(tree_indices_.size()); ++ii)
205 tree_indices_[ii] = ii;*/
206 }
207
208 /**\brief Create RF from external source
209 * \param treeCount Number of trees to add.
210 * \param topology_begin
211 * Iterator to a Container where the topology_ data
212 * of the trees are stored.
213 * Iterator should support at least treeCount forward
214 * iterations. (i.e. topology_end - topology_begin >= treeCount
215 * \param parameter_begin
216 * iterator to a Container where the parameters_ data
217 * of the trees are stored. Iterator should support at
218 * least treeCount forward iterations.
219 * \param problem_spec
220 * Extrinsic parameters that specify the problem e.g.
221 * ClassCount, featureCount etc.
222 * \param options (optional) specify options used to train the original
223 * Random forest. This parameter is not used anywhere
224 * during prediction and thus is optional.
225 *
226 */
227 template<class TopologyIterator, class ParameterIterator>
228 RandomForest(int treeCount,
229 TopologyIterator topology_begin,
230 ParameterIterator parameter_begin,
231 ProblemSpec_t const & problem_spec,
232 Options_t const & options = Options_t())
233 :
234 trees_(treeCount, DecisionTree_t(problem_spec)),
235 ext_param_(problem_spec),
236 options_(options)
237 {
238 /* TODO: This constructor may be replaced by a Constructor using
239 * NodeProxy iterators to encapsulate the underlying data type.
240 */
241 for(int k=0; k<treeCount; ++k, ++topology_begin, ++parameter_begin)
242 {
243 trees_[k].topology_ = *topology_begin;
244 trees_[k].parameters_ = *parameter_begin;
245 }
246 }
247
248 /** @} */
249
250
251 /** \name Data Access
252 * data access interface - usage of member variables is deprecated
253 *
254 * @{
255 */
256
257 /**\brief return external parameters for viewing
258 * \return ProblemSpec_t
259 */
260 ProblemSpec_t const & ext_param() const
261 {
262 vigra_precondition(ext_param_.used() == true,
263 "RandomForest::ext_param(): "
264 "Random forest has not been trained yet.");
265 return ext_param_;
266 }
267
268 /**\brief set external parameters
269 *
270 * \param in external parameters to be set
271 *
272 * set external parameters explicitly.
273 * If Random Forest has not been trained the preprocessor will
274 * either ignore filling values set this way or will throw an exception
275 * if values specified manually do not match the value calculated
276 & during the preparation step.
277 */
278 void set_ext_param(ProblemSpec_t const & in)
279 {
280 ignore_argument(in);
281 vigra_precondition(ext_param_.used() == false,
282 "RandomForest::set_ext_param():"
283 "Random forest has been trained! Call reset()"
284 "before specifying new extrinsic parameters.");
285 }
286
287 /**\brief access random forest options
288 *
289 * \return random forest options
290 */
291 Options_t & set_options()
292 {
293 return options_;
294 }
295
296
297 /**\brief access const random forest options
298 *
299 * \return const Option_t
300 */
301 Options_t const & options() const
302 {
303 return options_;
304 }
305
306 /**\brief access const trees
307 */
308 DecisionTree_t const & tree(int index) const
309 {
310 return trees_[index];
311 }
312
313 /**\brief access trees
314 */
315 DecisionTree_t & tree(int index)
316 {
317 return trees_[index];
318 }
319
320 /**\brief return number of features used while
321 * training.
322 */
323 int feature_count() const
324 {
325 return ext_param_.column_count_;
326 }
327
328
329 /**\brief return number of features used while
330 * training.
331 *
332 * deprecated. Use feature_count() instead.
333 */
334 int column_count() const
335 {
336 return ext_param_.column_count_;
337 }
338
339 /**\brief return number of classes used while
340 * training.
341 */
342 int class_count() const
343 {
344 return ext_param_.class_count_;
345 }
346
347 /**\brief return number of trees
348 */
349 int tree_count() const
350 {
351 return options_.tree_count_;
352 }
353
354 /** @} */
355
356 /**\name Learning
357 * Following functions differ in the degree of customization
358 * allowed
359 *
360 * @{
361 */
362
363 /**\brief learn on data with custom config and random number generator
364 *
365 * \param features a N x M matrix containing N samples with M
366 * features
367 * \param response a N x D matrix containing the corresponding
368 * response. Current split functors assume D to
369 * be 1 and ignore any additional columns.
370 * This is not enforced to allow future support
371 * for uncertain labels, label independent strata etc.
372 * The Preprocessor specified during construction
373 * should be able to handle features and labels
374 * features and the labels.
375 * see also: SplitFunctor, Preprocessing
376 *
377 * \param visitor visitor which is to be applied after each split,
378 * tree and at the end. Use rf_default() for using
379 * default value. (No Visitors)
380 * see also: rf::visitors
381 * \param split split functor to be used to calculate each split
382 * use rf_default() for using default value. (GiniSplit)
383 * see also: rf::split
384 * \param stop
385 * predicate to be used to calculate each split
386 * use rf_default() for using default value. (EarlyStoppStd)
387 * \param random RandomNumberGenerator to be used. Use
388 * rf_default() to use default value.(RandomMT19337)
389 *
390 *
391 */
392 template <class U, class C1,
393 class U2,class C2,
394 class Split_t,
395 class Stop_t,
396 class Visitor_t,
397 class Random_t>
398 void learn( MultiArrayView<2, U, C1> const & features,
399 MultiArrayView<2, U2,C2> const & response,
400 Visitor_t visitor,
401 Split_t split,
402 Stop_t stop,
403 Random_t const & random);
404
405 template <class U, class C1,
406 class U2,class C2,
407 class Split_t,
408 class Stop_t,
409 class Visitor_t>
410 void learn( MultiArrayView<2, U, C1> const & features,
411 MultiArrayView<2, U2,C2> const & response,
412 Visitor_t visitor,
413 Split_t split,
414 Stop_t stop)
415
416 {
417 RandomNumberGenerator<> rnd = RandomNumberGenerator<>(RandomSeed);
418 learn( features,
419 response,
420 visitor,
421 split,
422 stop,
423 rnd);
424 }
425
426 template <class U, class C1, class U2,class C2, class Visitor_t>
427 void learn( MultiArrayView<2, U, C1> const & features,
428 MultiArrayView<2, U2,C2> const & labels,
429 Visitor_t visitor)
430 {
431 learn( features,
432 labels,
433 visitor,
434 rf_default(),
435 rf_default());
436 }
437
438 template <class U, class C1, class U2,class C2,
439 class Visitor_t, class Split_t>
440 void learn( MultiArrayView<2, U, C1> const & features,
441 MultiArrayView<2, U2,C2> const & labels,
442 Visitor_t visitor,
443 Split_t split)
444 {
445 learn( features,
446 labels,
447 visitor,
448 split,
449 rf_default());
450 }
451
452 /**\brief learn on data with default configuration
453 *
454 * \param features a N x M matrix containing N samples with M
455 * features
456 * \param labels a N x D matrix containing the corresponding
457 * N labels. Current split functors assume D to
458 * be 1 and ignore any additional columns.
459 * this is not enforced to allow future support
460 * for uncertain labels.
461 *
462 * learning is done with:
463 *
464 * \sa rf::split, EarlyStoppStd
465 *
466 * - Randomly seeded random number generator
467 * - default gini split functor as described by Breiman
468 * - default The standard early stopping criterion
469 */
470 template <class U, class C1, class U2,class C2>
471 void learn( MultiArrayView<2, U, C1> const & features,
472 MultiArrayView<2, U2,C2> const & labels)
473 {
474 learn( features,
475 labels,
476 rf_default(),
477 rf_default(),
478 rf_default());
479 }
480
481
482 template<class U,class C1,
483 class U2, class C2,
484 class Split_t,
485 class Stop_t,
486 class Visitor_t,
487 class Random_t>
488 void onlineLearn( MultiArrayView<2,U,C1> const & features,
489 MultiArrayView<2,U2,C2> const & response,
490 int new_start_index,
491 Visitor_t visitor_,
492 Split_t split_,
493 Stop_t stop_,
494 Random_t & random,
495 bool adjust_thresholds=false);
496
497 template <class U, class C1, class U2,class C2>
498 void onlineLearn( MultiArrayView<2, U, C1> const & features,
499 MultiArrayView<2, U2,C2> const & labels,int new_start_index,bool adjust_thresholds=false)
500 {
501 RandomNumberGenerator<> rnd = RandomNumberGenerator<>(RandomSeed);
502 onlineLearn(features,
503 labels,
504 new_start_index,
505 rf_default(),
506 rf_default(),
507 rf_default(),
508 rnd,
509 adjust_thresholds);
510 }
511
512 template<class U,class C1,
513 class U2, class C2,
514 class Split_t,
515 class Stop_t,
516 class Visitor_t,
517 class Random_t>
518 void reLearnTree(MultiArrayView<2,U,C1> const & features,
519 MultiArrayView<2,U2,C2> const & response,
520 int treeId,
521 Visitor_t visitor_,
522 Split_t split_,
523 Stop_t stop_,
524 Random_t & random);
525
526 template<class U, class C1, class U2, class C2>
527 void reLearnTree(MultiArrayView<2, U, C1> const & features,
528 MultiArrayView<2, U2, C2> const & labels,
529 int treeId)
530 {
531 RandomNumberGenerator<> rnd = RandomNumberGenerator<>(RandomSeed);
532 reLearnTree(features,
533 labels,
534 treeId,
535 rf_default(),
536 rf_default(),
537 rf_default(),
538 rnd);
539 }
540
541 /** @} */
542
543
544
545 /**\name Prediction
546 *
547 * @{
548 */
549
550 /** \brief predict a label given a feature.
551 *
552 * \param features: a 1 by featureCount matrix containing
553 * data point to be predicted (this only works in
554 * classification setting)
555 * \param stop: early stopping criterion
556 * \return double value representing class. You can use the
557 * predictLabels() function together with the
558 * rf.external_parameter().class_type_ attribute
559 * to get back the same type used during learning.
560 */
561 template <class U, class C, class Stop>
562 LabelType predictLabel(MultiArrayView<2, U, C>const & features, Stop & stop) const;
563
564 template <class U, class C>
565 LabelType predictLabel(MultiArrayView<2, U, C>const & features)
566 {
567 return predictLabel(features, rf_default());
568 }
569 /** \brief predict a label with features and class priors
570 *
571 * \param features: same as above.
572 * \param prior: iterator to prior weighting of classes
573 * \return sam as above.
574 */
575 template <class U, class C>
576 LabelType predictLabel(MultiArrayView<2, U, C> const & features,
577 ArrayVectorView<double> prior) const;
578
579 /** \brief predict multiple labels with given features
580 *
581 * \param features: a n by featureCount matrix containing
582 * data point to be predicted (this only works in
583 * classification setting)
584 * \param labels: a n by 1 matrix passed by reference to store
585 * output.
586 *
587 * If the input contains an NaN value, an precondition exception is thrown.
588 */
589 template <class U, class C1, class T, class C2>
590 void predictLabels(MultiArrayView<2, U, C1>const & features,
591 MultiArrayView<2, T, C2> & labels) const
592 {
593 vigra_precondition(features.shape(0) == labels.shape(0),
594 "RandomForest::predictLabels(): Label array has wrong size.");
595 for(int k=0; k<features.shape(0); ++k)
596 {
597 vigra_precondition(!detail::contains_nan(rowVector(features, k)),
598 "RandomForest::predictLabels(): NaN in feature matrix.");
599 labels(k,0) = detail::RequiresExplicitCast<T>::cast(predictLabel(rowVector(features, k), rf_default()));
600 }
601 }
602
603 /** \brief predict multiple labels with given features
604 *
605 * \param features: a n by featureCount matrix containing
606 * data point to be predicted (this only works in
607 * classification setting)
608 * \param labels: a n by 1 matrix passed by reference to store
609 * output.
610 * \param nanLabel: label to be returned for the row of the input that
611 * contain an NaN value.
612 */
613 template <class U, class C1, class T, class C2>
614 void predictLabels(MultiArrayView<2, U, C1>const & features,
615 MultiArrayView<2, T, C2> & labels,
616 LabelType nanLabel) const
617 {
618 vigra_precondition(features.shape(0) == labels.shape(0),
619 "RandomForest::predictLabels(): Label array has wrong size.");
620 for(int k=0; k<features.shape(0); ++k)
621 {
622 if(detail::contains_nan(rowVector(features, k)))
623 labels(k,0) = nanLabel;
624 else
625 labels(k,0) = detail::RequiresExplicitCast<T>::cast(predictLabel(rowVector(features, k), rf_default()));
626 }
627 }
628
629 /** \brief predict multiple labels with given features
630 *
631 * \param features: a n by featureCount matrix containing
632 * data point to be predicted (this only works in
633 * classification setting)
634 * \param labels: a n by 1 matrix passed by reference to store
635 * output.
636 * \param stop: an early stopping criterion.
637 */
638 template <class U, class C1, class T, class C2, class Stop>
639 void predictLabels(MultiArrayView<2, U, C1>const & features,
640 MultiArrayView<2, T, C2> & labels,
641 Stop & stop) const
642 {
643 vigra_precondition(features.shape(0) == labels.shape(0),
644 "RandomForest::predictLabels(): Label array has wrong size.");
645 for(int k=0; k<features.shape(0); ++k)
646 labels(k,0) = detail::RequiresExplicitCast<T>::cast(predictLabel(rowVector(features, k), stop));
647 }
648 /** \brief predict the class probabilities for multiple labels
649 *
650 * \param features same as above
651 * \param prob a n x class_count_ matrix. passed by reference to
652 * save class probabilities
653 * \param stop earlystopping criterion
654 * \sa EarlyStopping
655
656 When a row of the feature array contains an NaN, the corresponding instance
657 cannot belong to any of the classes. The corresponding row in the probability
658 array will therefore contain all zeros.
659 */
660 template <class U, class C1, class T, class C2, class Stop>
661 void predictProbabilities(MultiArrayView<2, U, C1>const & features,
662 MultiArrayView<2, T, C2> & prob,
663 Stop & stop) const;
664 template <class T1,class T2, class C>
665 void predictProbabilities(OnlinePredictionSet<T1> & predictionSet,
666 MultiArrayView<2, T2, C> & prob);
667
668 /** \brief predict the class probabilities for multiple labels
669 *
670 * \param features same as above
671 * \param prob a n x class_count_ matrix. passed by reference to
672 * save class probabilities
673 */
674 template <class U, class C1, class T, class C2>
675 void predictProbabilities(MultiArrayView<2, U, C1>const & features,
676 MultiArrayView<2, T, C2> & prob) const
677 {
678 predictProbabilities(features, prob, rf_default());
679 }
680
681 template <class U, class C1, class T, class C2>
682 void predictRaw(MultiArrayView<2, U, C1>const & features,
683 MultiArrayView<2, T, C2> & prob) const;
684
685
686 /** @} */
687
688 };
689
690
691 template <class LabelType, class PreprocessorTag>
692 template<class U,class C1,
693 class U2, class C2,
694 class Split_t,
695 class Stop_t,
696 class Visitor_t,
697 class Random_t>
698 void RandomForest<LabelType, PreprocessorTag>::onlineLearn(MultiArrayView<2,U,C1> const & features,
699 MultiArrayView<2,U2,C2> const & response,
700 int new_start_index,
701 Visitor_t visitor_,
702 Split_t split_,
703 Stop_t stop_,
704 Random_t & random,
705 bool adjust_thresholds)
706 {
707 online_visitor_.activate();
708 online_visitor_.adjust_thresholds=adjust_thresholds;
709
710 using namespace rf;
711 //typedefs
712 typedef Processor<PreprocessorTag,LabelType,U,C1,U2,C2> Preprocessor_t;
713 typedef UniformIntRandomFunctor<Random_t>
714 RandFunctor_t;
715 // default values and initialization
716 // Value Chooser chooses second argument as value if first argument
717 // is of type RF_DEFAULT. (thanks to template magic - don't care about
718 // it - just smile and wave.
719
720 #define RF_CHOOSER(type_) detail::Value_Chooser<type_, Default_##type_>
721 Default_Stop_t default_stop(options_);
722 typename RF_CHOOSER(Stop_t)::type stop
723 = RF_CHOOSER(Stop_t)::choose(stop_, default_stop);
724 Default_Split_t default_split;
725 typename RF_CHOOSER(Split_t)::type split
726 = RF_CHOOSER(Split_t)::choose(split_, default_split);
727 rf::visitors::StopVisiting stopvisiting;
728 typedef rf::visitors::detail::VisitorNode
729 <rf::visitors::OnlineLearnVisitor,
730 typename RF_CHOOSER(Visitor_t)::type>
731 IntermedVis;
732 IntermedVis
733 visitor(online_visitor_, RF_CHOOSER(Visitor_t)::choose(visitor_, stopvisiting));
734 #undef RF_CHOOSER
735 vigra_precondition(options_.prepare_online_learning_,"onlineLearn: online learning must be enabled on RandomForest construction");
736
737 // Preprocess the data to get something the split functor can work
738 // with. Also fill the ext_param structure by preprocessing
739 // option parameters that could only be completely evaluated
740 // when the training data is known.
741 ext_param_.class_count_=0;
742 Preprocessor_t preprocessor( features, response,
743 options_, ext_param_);
744
745 // Make stl compatible random functor.
746 RandFunctor_t randint ( random);
747
748 // Give the Split functor information about the data.
749 split.set_external_parameters(ext_param_);
750 stop.set_external_parameters(ext_param_);
751
752
753 //Create poisson samples
754 PoissonSampler<RandomTT800> poisson_sampler(1.0,vigra::Int32(new_start_index),vigra::Int32(ext_param().row_count_));
755
756 //TODO: visitors for online learning
757 //visitor.visit_at_beginning(*this, preprocessor);
758
759 // THE MAIN EFFING RF LOOP - YEAY DUDE!
760 for(int ii = 0; ii < static_cast<int>(trees_.size()); ++ii)
761 {
762 online_visitor_.tree_id=ii;
763 poisson_sampler.sample();
764 std::map<int,int> leaf_parents;
765 leaf_parents.clear();
766 //Get all the leaf nodes for that sample
767 for(int s=0;s<poisson_sampler.numOfSamples();++s)
768 {
769 int sample=poisson_sampler[s];
770 online_visitor_.current_label=preprocessor.response()(sample,0);
771 online_visitor_.last_node_id=StackEntry_t::DecisionTreeNoParent;
772 int leaf=trees_[ii].getToLeaf(rowVector(features,sample),online_visitor_);
773
774
775 //Add to the list for that leaf
776 online_visitor_.add_to_index_list(ii,leaf,sample);
777 //TODO: Class count?
778 //Store parent
779 if(Node<e_ConstProbNode>(trees_[ii].topology_,trees_[ii].parameters_,leaf).prob_begin()[preprocessor.response()(sample,0)]!=1.0)
780 {
781 leaf_parents[leaf]=online_visitor_.last_node_id;
782 }
783 }
784
785
786 std::map<int,int>::iterator leaf_iterator;
787 for(leaf_iterator=leaf_parents.begin();leaf_iterator!=leaf_parents.end();++leaf_iterator)
788 {
789 int leaf=leaf_iterator->first;
790 int parent=leaf_iterator->second;
791 int lin_index=online_visitor_.trees_online_information[ii].exterior_to_index[leaf];
792 ArrayVector<Int32> indeces;
793 indeces.clear();
794 indeces.swap(online_visitor_.trees_online_information[ii].index_lists[lin_index]);
795 StackEntry_t stack_entry(indeces.begin(),
796 indeces.end(),
797 ext_param_.class_count_);
798
799
800 if(parent!=-1)
801 {
802 if(NodeBase(trees_[ii].topology_,trees_[ii].parameters_,parent).child(0)==leaf)
803 {
804 stack_entry.leftParent=parent;
805 }
806 else
807 {
808 vigra_assert(NodeBase(trees_[ii].topology_,trees_[ii].parameters_,parent).child(1)==leaf,"last_node_id seems to be wrong");
809 stack_entry.rightParent=parent;
810 }
811 }
812 //trees_[ii].continueLearn(preprocessor.features(),preprocessor.response(),stack_entry,split,stop,visitor,randint,leaf);
813 trees_[ii].continueLearn(preprocessor.features(),preprocessor.response(),stack_entry,split,stop,visitor,randint,-1);
814 //Now, the last one moved onto leaf
815 online_visitor_.move_exterior_node(ii,trees_[ii].topology_.size(),ii,leaf);
816 //Now it should be classified correctly!
817 }
818
819 /*visitor
820 .visit_after_tree( *this,
821 preprocessor,
822 poisson_sampler,
823 stack_entry,
824 ii);*/
825 }
826
827 //visitor.visit_at_end(*this, preprocessor);
828 online_visitor_.deactivate();
829 }
830
831 template<class LabelType, class PreprocessorTag>
832 template<class U,class C1,
833 class U2, class C2,
834 class Split_t,
835 class Stop_t,
836 class Visitor_t,
837 class Random_t>
838 void RandomForest<LabelType, PreprocessorTag>::reLearnTree(MultiArrayView<2,U,C1> const & features,
839 MultiArrayView<2,U2,C2> const & response,
840 int treeId,
841 Visitor_t visitor_,
842 Split_t split_,
843 Stop_t stop_,
844 Random_t & random)
845 {
846 using namespace rf;
847
848
849 typedef UniformIntRandomFunctor<Random_t>
850 RandFunctor_t;
851
852 // See rf_preprocessing.hxx for more info on this
853 ext_param_.class_count_=0;
854 typedef Processor<PreprocessorTag,LabelType, U, C1, U2, C2> Preprocessor_t;
855
856 // default values and initialization
857 // Value Chooser chooses second argument as value if first argument
858 // is of type RF_DEFAULT. (thanks to template magic - don't care about
859 // it - just smile and wave.
860
861 #define RF_CHOOSER(type_) detail::Value_Chooser<type_, Default_##type_>
862 Default_Stop_t default_stop(options_);
863 typename RF_CHOOSER(Stop_t)::type stop
864 = RF_CHOOSER(Stop_t)::choose(stop_, default_stop);
865 Default_Split_t default_split;
866 typename RF_CHOOSER(Split_t)::type split
867 = RF_CHOOSER(Split_t)::choose(split_, default_split);
868 rf::visitors::StopVisiting stopvisiting;
869 typedef rf::visitors::detail::VisitorNode
870 <rf::visitors::OnlineLearnVisitor,
871 typename RF_CHOOSER(Visitor_t)::type> IntermedVis;
872 IntermedVis
873 visitor(online_visitor_, RF_CHOOSER(Visitor_t)::choose(visitor_, stopvisiting));
874 #undef RF_CHOOSER
875 vigra_precondition(options_.prepare_online_learning_,"reLearnTree: Re learning trees only makes sense, if online learning is enabled");
876 online_visitor_.activate();
877
878 // Make stl compatible random functor.
879 RandFunctor_t randint ( random);
880
881 // Preprocess the data to get something the split functor can work
882 // with. Also fill the ext_param structure by preprocessing
883 // option parameters that could only be completely evaluated
884 // when the training data is known.
885 Preprocessor_t preprocessor( features, response,
886 options_, ext_param_);
887
888 // Give the Split functor information about the data.
889 split.set_external_parameters(ext_param_);
890 stop.set_external_parameters(ext_param_);
891
892 /**\todo replace this crappy class out. It uses function pointers.
893 * and is making code slower according to me.
894 * Comment from Nathan: This is copied from Rahul, so me=Rahul
895 */
896 Sampler<Random_t > sampler(preprocessor.strata().begin(),
897 preprocessor.strata().end(),
898 detail::make_sampler_opt(options_)
899 .sampleSize(ext_param().actual_msample_),
900 &random);
901 //initialize First region/node/stack entry
902 sampler
903 .sample();
904
905 StackEntry_t
906 first_stack_entry( sampler.sampledIndices().begin(),
907 sampler.sampledIndices().end(),
908 ext_param_.class_count_);
909 first_stack_entry
910 .set_oob_range( sampler.oobIndices().begin(),
911 sampler.oobIndices().end());
912 online_visitor_.reset_tree(treeId);
913 online_visitor_.tree_id=treeId;
914 trees_[treeId].reset();
915 trees_[treeId]
916 .learn( preprocessor.features(),
917 preprocessor.response(),
918 first_stack_entry,
919 split,
920 stop,
921 visitor,
922 randint);
923 visitor
924 .visit_after_tree( *this,
925 preprocessor,
926 sampler,
927 first_stack_entry,
928 treeId);
929
930 online_visitor_.deactivate();
931 }
932
933 template <class LabelType, class PreprocessorTag>
934 template <class U, class C1,
935 class U2,class C2,
936 class Split_t,
937 class Stop_t,
938 class Visitor_t,
939 class Random_t>
940 void RandomForest<LabelType, PreprocessorTag>::
941 learn( MultiArrayView<2, U, C1> const & features,
942 MultiArrayView<2, U2,C2> const & response,
943 Visitor_t visitor_,
944 Split_t split_,
945 Stop_t stop_,
946 Random_t const & random)
947 {
948 using namespace rf;
949 //this->reset();
950 //typedefs
951 typedef UniformIntRandomFunctor<Random_t>
952 RandFunctor_t;
953
954 // See rf_preprocessing.hxx for more info on this
955 typedef Processor<PreprocessorTag,LabelType, U, C1, U2, C2> Preprocessor_t;
956
957 vigra_precondition(features.shape(0) == response.shape(0),
958 "RandomForest::learn(): shape mismatch between features and response.");
959
960 // default values and initialization
961 // Value Chooser chooses second argument as value if first argument
962 // is of type RF_DEFAULT. (thanks to template magic - don't care about
963 // it - just smile and wave).
964
965 #define RF_CHOOSER(type_) detail::Value_Chooser<type_, Default_##type_>
966 Default_Stop_t default_stop(options_);
967 typename RF_CHOOSER(Stop_t)::type stop
968 = RF_CHOOSER(Stop_t)::choose(stop_, default_stop);
969 Default_Split_t default_split;
970 typename RF_CHOOSER(Split_t)::type split
971 = RF_CHOOSER(Split_t)::choose(split_, default_split);
972 rf::visitors::StopVisiting stopvisiting;
973 typedef rf::visitors::detail::VisitorNode<
974 rf::visitors::OnlineLearnVisitor,
975 typename RF_CHOOSER(Visitor_t)::type> IntermedVis;
976 IntermedVis
977 visitor(online_visitor_, RF_CHOOSER(Visitor_t)::choose(visitor_, stopvisiting));
978 #undef RF_CHOOSER
979 if(options_.prepare_online_learning_)
980 online_visitor_.activate();
981 else
982 online_visitor_.deactivate();
983
984
985 // Make stl compatible random functor.
986 RandFunctor_t randint ( random);
987
988
989 // Preprocess the data to get something the split functor can work
990 // with. Also fill the ext_param structure by preprocessing
991 // option parameters that could only be completely evaluated
992 // when the training data is known.
993 Preprocessor_t preprocessor( features, response,
994 options_, ext_param_);
995
996 // Give the Split functor information about the data.
997 split.set_external_parameters(ext_param_);
998 stop.set_external_parameters(ext_param_);
999
1000
1001 //initialize trees.
1002 trees_.resize(options_.tree_count_ , DecisionTree_t(ext_param_));
1003
1004 Sampler<Random_t > sampler(preprocessor.strata().begin(),
1005 preprocessor.strata().end(),
1006 detail::make_sampler_opt(options_)
1007 .sampleSize(ext_param().actual_msample_),
1008 &random);
1009
1010 visitor.visit_at_beginning(*this, preprocessor);
1011 // THE MAIN EFFING RF LOOP - YEAY DUDE!
1012
1013 for(int ii = 0; ii < static_cast<int>(trees_.size()); ++ii)
1014 {
1015 //initialize First region/node/stack entry
1016 sampler
1017 .sample();
1018 StackEntry_t
1019 first_stack_entry( sampler.sampledIndices().begin(),
1020 sampler.sampledIndices().end(),
1021 ext_param_.class_count_);
1022 first_stack_entry
1023 .set_oob_range( sampler.oobIndices().begin(),
1024 sampler.oobIndices().end());
1025 trees_[ii]
1026 .learn( preprocessor.features(),
1027 preprocessor.response(),
1028 first_stack_entry,
1029 split,
1030 stop,
1031 visitor,
1032 randint);
1033 visitor
1034 .visit_after_tree( *this,
1035 preprocessor,
1036 sampler,
1037 first_stack_entry,
1038 ii);
1039 }
1040
1041 visitor.visit_at_end(*this, preprocessor);
1042 // Only for online learning?
1043 online_visitor_.deactivate();
1044 }
1045
1046
1047
1048
1049 template <class LabelType, class Tag>
1050 template <class U, class C, class Stop>
1051 LabelType RandomForest<LabelType, Tag>
1052 ::predictLabel(MultiArrayView<2, U, C> const & features, Stop & stop) const
1053 {
1054 vigra_precondition(columnCount(features) >= ext_param_.column_count_,
1055 "RandomForestn::predictLabel():"
1056 " Too few columns in feature matrix.");
1057 vigra_precondition(rowCount(features) == 1,
1058 "RandomForestn::predictLabel():"
1059 " Feature matrix must have a singlerow.");
1060 MultiArray<2, double> probabilities(Shape2(1, ext_param_.class_count_), 0.0);
1061 LabelType d;
1062 predictProbabilities(features, probabilities, stop);
1063 ext_param_.to_classlabel(argMax(probabilities), d);
1064 return d;
1065 }
1066
1067
1068 //Same thing as above with priors for each label !!!
1069 template <class LabelType, class PreprocessorTag>
1070 template <class U, class C>
1071 LabelType RandomForest<LabelType, PreprocessorTag>
1072 ::predictLabel( MultiArrayView<2, U, C> const & features,
1073 ArrayVectorView<double> priors) const
1074 {
1075 using namespace functor;
1076 vigra_precondition(columnCount(features) >= ext_param_.column_count_,
1077 "RandomForestn::predictLabel(): Too few columns in feature matrix.");
1078 vigra_precondition(rowCount(features) == 1,
1079 "RandomForestn::predictLabel():"
1080 " Feature matrix must have a single row.");
1081 Matrix<double> prob(1,ext_param_.class_count_);
1082 predictProbabilities(features, prob);
1083 std::transform( prob.begin(), prob.end(),
1084 priors.begin(), prob.begin(),
1085 Arg1()*Arg2());
1086 LabelType d;
1087 ext_param_.to_classlabel(argMax(prob), d);
1088 return d;
1089 }
1090
1091 template<class LabelType,class PreprocessorTag>
1092 template <class T1,class T2, class C>
1093 void RandomForest<LabelType,PreprocessorTag>
1094 ::predictProbabilities(OnlinePredictionSet<T1> & predictionSet,
1095 MultiArrayView<2, T2, C> & prob)
1096 {
1097 //Features are n xp
1098 //prob is n x NumOfLabel probability for each feature in each class
1099
1100 vigra_precondition(rowCount(predictionSet.features) == rowCount(prob),
1101 "RandomFroest::predictProbabilities():"
1102 " Feature matrix and probability matrix size mismatch.");
1103 // num of features must be bigger than num of features in Random forest training
1104 // but why bigger?
1105 vigra_precondition( columnCount(predictionSet.features) >= ext_param_.column_count_,
1106 "RandomForestn::predictProbabilities():"
1107 " Too few columns in feature matrix.");
1108 vigra_precondition( columnCount(prob)
1109 == static_cast<MultiArrayIndex>(ext_param_.class_count_),
1110 "RandomForestn::predictProbabilities():"
1111 " Probability matrix must have as many columns as there are classes.");
1112 prob.init(0.0);
1113 //store total weights
1114 std::vector<T1> totalWeights(predictionSet.indices[0].size(),0.0);
1115 //Go through all trees
1116 int set_id=-1;
1117 for(int k=0; k<options_.tree_count_; ++k)
1118 {
1119 set_id=(set_id+1) % predictionSet.indices[0].size();
1120 typedef std::set<SampleRange<T1> > my_set;
1121 typedef typename my_set::iterator set_it;
1122 //typedef std::set<std::pair<int,SampleRange<T1> > >::iterator set_it;
1123 //Build a stack with all the ranges we have
1124 std::vector<std::pair<int,set_it> > stack;
1125 stack.clear();
1126 for(set_it i=predictionSet.ranges[set_id].begin();
1127 i!=predictionSet.ranges[set_id].end();++i)
1128 stack.push_back(std::pair<int,set_it>(2,i));
1129 //get weights predicted by single tree
1130 int num_decisions=0;
1131 while(!stack.empty())
1132 {
1133 set_it range=stack.back().second;
1134 int index=stack.back().first;
1135 stack.pop_back();
1136 ++num_decisions;
1137
1138 if(trees_[k].isLeafNode(trees_[k].topology_[index]))
1139 {
1140 ArrayVector<double>::iterator weights=Node<e_ConstProbNode>(trees_[k].topology_,
1141 trees_[k].parameters_,
1142 index).prob_begin();
1143 for(int i=range->start;i!=range->end;++i)
1144 {
1145 //update votecount.
1146 for(int l=0; l<ext_param_.class_count_; ++l)
1147 {
1148 prob(predictionSet.indices[set_id][i], l) += static_cast<T2>(weights[l]);
1149 //every weight in totalWeight.
1150 totalWeights[predictionSet.indices[set_id][i]] += static_cast<T1>(weights[l]);
1151 }
1152 }
1153 }
1154
1155 else
1156 {
1157 if(trees_[k].topology_[index]!=i_ThresholdNode)
1158 {
1159 throw std::runtime_error("predicting with online prediction sets is only supported for RFs with threshold nodes");
1160 }
1161 Node<i_ThresholdNode> node(trees_[k].topology_,trees_[k].parameters_,index);
1162 if(range->min_boundaries[node.column()]>=node.threshold())
1163 {
1164 //Everything goes to right child
1165 stack.push_back(std::pair<int,set_it>(node.child(1),range));
1166 continue;
1167 }
1168 if(range->max_boundaries[node.column()]<node.threshold())
1169 {
1170 //Everything goes to the left child
1171 stack.push_back(std::pair<int,set_it>(node.child(0),range));
1172 continue;
1173 }
1174 //We have to split at this node
1175 SampleRange<T1> new_range=*range;
1176 new_range.min_boundaries[node.column()]=FLT_MAX;
1177 range->max_boundaries[node.column()]=-FLT_MAX;
1178 new_range.start=new_range.end=range->end;
1179 int i=range->start;
1180 while(i!=range->end)
1181 {
1182 //Decide for range->indices[i]
1183 if(predictionSet.features(predictionSet.indices[set_id][i],node.column())>=node.threshold())
1184 {
1185 new_range.min_boundaries[node.column()]=std::min(new_range.min_boundaries[node.column()],
1186 predictionSet.features(predictionSet.indices[set_id][i],node.column()));
1187 --range->end;
1188 --new_range.start;
1189 std::swap(predictionSet.indices[set_id][i],predictionSet.indices[set_id][range->end]);
1190
1191 }
1192 else
1193 {
1194 range->max_boundaries[node.column()]=std::max(range->max_boundaries[node.column()],
1195 predictionSet.features(predictionSet.indices[set_id][i],node.column()));
1196 ++i;
1197 }
1198 }
1199 //The old one ...
1200 if(range->start==range->end)
1201 {
1202 predictionSet.ranges[set_id].erase(range);
1203 }
1204 else
1205 {
1206 stack.push_back(std::pair<int,set_it>(node.child(0),range));
1207 }
1208 //And the new one ...
1209 if(new_range.start!=new_range.end)
1210 {
1211 std::pair<set_it,bool> new_it=predictionSet.ranges[set_id].insert(new_range);
1212 stack.push_back(std::pair<int,set_it>(node.child(1),new_it.first));
1213 }
1214 }
1215 }
1216 predictionSet.cumulativePredTime[k]=num_decisions;
1217 }
1218 for(unsigned int i=0;i<totalWeights.size();++i)
1219 {
1220 double test=0.0;
1221 //Normalise votes in each row by total VoteCount (totalWeight
1222 for(int l=0; l<ext_param_.class_count_; ++l)
1223 {
1224 test+=prob(i,l);
1225 prob(i, l) /= totalWeights[i];
1226 }
1227 assert(test==totalWeights[i]);
1228 assert(totalWeights[i]>0.0);
1229 }
1230 }
1231
1232 template <class LabelType, class PreprocessorTag>
1233 template <class U, class C1, class T, class C2, class Stop_t>
1234 void RandomForest<LabelType, PreprocessorTag>
1235 ::predictProbabilities(MultiArrayView<2, U, C1>const & features,
1236 MultiArrayView<2, T, C2> & prob,
1237 Stop_t & stop_) const
1238 {
1239 //Features are n xp
1240 //prob is n x NumOfLabel probability for each feature in each class
1241
1242 vigra_precondition(rowCount(features) == rowCount(prob),
1243 "RandomForestn::predictProbabilities():"
1244 " Feature matrix and probability matrix size mismatch.");
1245
1246 // num of features must be bigger than num of features in Random forest training
1247 // but why bigger?
1248 vigra_precondition( columnCount(features) >= ext_param_.column_count_,
1249 "RandomForestn::predictProbabilities():"
1250 " Too few columns in feature matrix.");
1251 vigra_precondition( columnCount(prob)
1252 == static_cast<MultiArrayIndex>(ext_param_.class_count_),
1253 "RandomForestn::predictProbabilities():"
1254 " Probability matrix must have as many columns as there are classes.");
1255
1256 #define RF_CHOOSER(type_) detail::Value_Chooser<type_, Default_##type_>
1257 Default_Stop_t default_stop(options_);
1258 typename RF_CHOOSER(Stop_t)::type & stop
1259 = RF_CHOOSER(Stop_t)::choose(stop_, default_stop);
1260 #undef RF_CHOOSER
1261 stop.set_external_parameters(ext_param_, tree_count());
1262 prob.init(NumericTraits<T>::zero());
1263 /* This code was originally there for testing early stopping
1264 * - we wanted the order of the trees to be randomized
1265 if(tree_indices_.size() != 0)
1266 {
1267 std::random_shuffle(tree_indices_.begin(),
1268 tree_indices_.end());
1269 }
1270 */
1271 //Classify for each row.
1272 for(int row=0; row < rowCount(features); ++row)
1273 {
1274 MultiArrayView<2, U, StridedArrayTag> currentRow(rowVector(features, row));
1275
1276 // when the features contain an NaN, the instance doesn't belong to any class
1277 // => indicate this by returning a zero probability array.
1278 if(detail::contains_nan(currentRow))
1279 {
1280 rowVector(prob, row).init(0.0);
1281 continue;
1282 }
1283
1284 ArrayVector<double>::const_iterator weights;
1285
1286 //totalWeight == totalVoteCount!
1287 double totalWeight = 0.0;
1288
1289 //Let each tree classify...
1290 for(int k=0; k<options_.tree_count_; ++k)
1291 {
1292 //get weights predicted by single tree
1293 weights = trees_[k /*tree_indices_[k]*/].predict(currentRow);
1294
1295 //update votecount.
1296 int weighted = options_.predict_weighted_;
1297 for(int l=0; l<ext_param_.class_count_; ++l)
1298 {
1299 double cur_w = weights[l] * (weighted * (*(weights-1))
1300 + (1-weighted));
1301 prob(row, l) += static_cast<T>(cur_w);
1302 //every weight in totalWeight.
1303 totalWeight += cur_w;
1304 }
1305 if(stop.after_prediction(weights,
1306 k,
1307 rowVector(prob, row),
1308 totalWeight))
1309 {
1310 break;
1311 }
1312 }
1313
1314 //Normalise votes in each row by total VoteCount (totalWeight
1315 for(int l=0; l< ext_param_.class_count_; ++l)
1316 {
1317 prob(row, l) /= detail::RequiresExplicitCast<T>::cast(totalWeight);
1318 }
1319 }
1320
1321 }
1322
1323 template <class LabelType, class PreprocessorTag>
1324 template <class U, class C1, class T, class C2>
1325 void RandomForest<LabelType, PreprocessorTag>
1326 ::predictRaw(MultiArrayView<2, U, C1>const & features,
1327 MultiArrayView<2, T, C2> & prob) const
1328 {
1329 //Features are n xp
1330 //prob is n x NumOfLabel probability for each feature in each class
1331
1332 vigra_precondition(rowCount(features) == rowCount(prob),
1333 "RandomForestn::predictProbabilities():"
1334 " Feature matrix and probability matrix size mismatch.");
1335
1336 // num of features must be bigger than num of features in Random forest training
1337 // but why bigger?
1338 vigra_precondition( columnCount(features) >= ext_param_.column_count_,
1339 "RandomForestn::predictProbabilities():"
1340 " Too few columns in feature matrix.");
1341 vigra_precondition( columnCount(prob)
1342 == static_cast<MultiArrayIndex>(ext_param_.class_count_),
1343 "RandomForestn::predictProbabilities():"
1344 " Probability matrix must have as many columns as there are classes.");
1345
1346 #define RF_CHOOSER(type_) detail::Value_Chooser<type_, Default_##type_>
1347 prob.init(NumericTraits<T>::zero());
1348 /* This code was originally there for testing early stopping
1349 * - we wanted the order of the trees to be randomized
1350 if(tree_indices_.size() != 0)
1351 {
1352 std::random_shuffle(tree_indices_.begin(),
1353 tree_indices_.end());
1354 }
1355 */
1356 //Classify for each row.
1357 for(int row=0; row < rowCount(features); ++row)
1358 {
1359 ArrayVector<double>::const_iterator weights;
1360
1361 //totalWeight == totalVoteCount!
1362 double totalWeight = 0.0;
1363
1364 //Let each tree classify...
1365 for(int k=0; k<options_.tree_count_; ++k)
1366 {
1367 //get weights predicted by single tree
1368 weights = trees_[k /*tree_indices_[k]*/].predict(rowVector(features, row));
1369
1370 //update votecount.
1371 int weighted = options_.predict_weighted_;
1372 for(int l=0; l<ext_param_.class_count_; ++l)
1373 {
1374 double cur_w = weights[l] * (weighted * (*(weights-1))
1375 + (1-weighted));
1376 prob(row, l) += static_cast<T>(cur_w);
1377 //every weight in totalWeight.
1378 totalWeight += cur_w;
1379 }
1380 }
1381 }
1382 prob/= options_.tree_count_;
1383
1384 }
1385
1386 } // namespace vigra
1387
1388 #include "random_forest/rf_algorithm.hxx"
1389 #endif // VIGRA_RANDOM_FOREST_HXX
vigra::DT_StackEntry
Definition: rf_region.hxx:57
vigra::RandomForest::set_ext_param
void set_ext_param(ProblemSpec_t const &in)
set external parameters
Definition: random_forest.hxx:278
vigra::RandomForest::class_count
int class_count() const
return number of classes used while training.
Definition: random_forest.hxx:342
vigra::Node< e_ConstProbNode >
Definition: rf_nodeproxy.hxx:626
vigra::rf_default
detail::RF_DEFAULT & rf_default()
factory function to return a RF_DEFAULT tag
Definition: rf_common.hxx:131
vigra::linalg::rowCount
MultiArrayIndex rowCount(const MultiArrayView< 2, T, C > &x)
Definition: matrix.hxx:671
vigra::Processor
Definition: rf_preprocessing.hxx:63
vigra::RandomForest::feature_count
int feature_count() const
return number of features used while training.
Definition: random_forest.hxx:323
vigra::RandomForest::column_count
int column_count() const
return number of features used while training.
Definition: random_forest.hxx:334
vigra::Sampler
Create random samples from a sequence of indices.
Definition: sampling.hxx:232
vigra::MultiArrayView::shape
const difference_type & shape() const
Definition: multi_array.hxx:1648
vigra::Sampler::sample
void sample()
Definition: sampling.hxx:467
vigra::ThresholdSplit
Definition: rf_split.hxx:993
vigra::RandomForest::predictLabels
void predictLabels(MultiArrayView< 2, U, C1 >const &features, MultiArrayView< 2, T, C2 > &labels, LabelType nanLabel) const
predict multiple labels with given features
Definition: random_forest.hxx:614
vigra::ArrayVectorView< double >
vigra::ArrayVectorView::begin
const_iterator begin() const
Definition: array_vector.hxx:223
vigra::ProblemSpec
problem specification class for the random forest.
Definition: rf_common.hxx:538
vigra::MultiArray< 2, double >
vigra::RandomForest::RandomForest
RandomForest(Options_t const &options=Options_t(), ProblemSpec_t const &ext_param=ProblemSpec_t())
default constructor
Definition: random_forest.hxx:197
vigra::EarlyStoppStd
Standard early stopping criterion.
Definition: rf_common.hxx:885
vigra::UniformIntRandomFunctor
Definition: random.hxx:669
vigra::RandomForest::ext_param
ProblemSpec_t const & ext_param() const
return external parameters for viewing
Definition: random_forest.hxx:260
vigra::RandomForest::tree
DecisionTree_t & tree(int index)
access trees
Definition: random_forest.hxx:315
vigra::RandomForest::tree
DecisionTree_t const & tree(int index) const
access const trees
Definition: random_forest.hxx:308
vigra::ArrayVector< DecisionTree_t >
vigra::RandomForest::set_options
Options_t & set_options()
access random forest options
Definition: random_forest.hxx:291
vigra::RandomForest::learn
void learn(MultiArrayView< 2, U, C1 > const &features, MultiArrayView< 2, U2, C2 > const &labels)
learn on data with default configuration
Definition: random_forest.hxx:471
vigra::RandomForest::predictProbabilities
void predictProbabilities(MultiArrayView< 2, U, C1 >const &features, MultiArrayView< 2, T, C2 > &prob) const
predict the class probabilities for multiple labels
Definition: random_forest.hxx:675
vigra::RandomForest
Random forest version 2 (see also vigra::rf3::RandomForest for version 3)
Definition: random_forest.hxx:147
vigra::RandomForest::options
Options_t const & options() const
access const random forest options
Definition: random_forest.hxx:301
vigra::rf::visitors::detail::VisitorNode
Definition: rf_visitors.hxx:254
vigra::Int32
detail::SelectIntegerType< 32, detail::SignedIntTypes >::type Int32
32-bit signed int
Definition: sized_int.hxx:175
vigra::argMax
Iterator argMax(Iterator first, Iterator last)
Find the maximum element in a sequence.
Definition: algorithm.hxx:96
vigra::RandomForest::predictLabel
LabelType predictLabel(MultiArrayView< 2, U, C >const &features, Stop &stop) const
predict a label given a feature.
Definition: random_forest.hxx:1052
vigra::rf::visitors::OnlineLearnVisitor
Definition: rf_visitors.hxx:583
vigra::RandomForest::predictLabels
void predictLabels(MultiArrayView< 2, U, C1 >const &features, MultiArrayView< 2, T, C2 > &labels) const
predict multiple labels with given features
Definition: random_forest.hxx:590
vigra::SamplerOptions::stratified
SamplerOptions & stratified(bool in=true)
Draw equally many samples from each "stratum". A stratum is a group of like entities, e.g. pixels belonging to the same object class. This is useful to create balanced samples when the class probabilities are very unbalanced (e.g. when there are many background and few foreground pixels). Stratified sampling thus avoids that a trained classifier is biased towards the majority class.
Definition: sampling.hxx:141
vigra::SamplerOptions::withReplacement
SamplerOptions & withReplacement(bool in=true)
Sample from training population with replacement.
Definition: sampling.hxx:83
vigra::linalg::rowVector
MultiArrayView< 2, T, C > rowVector(MultiArrayView< 2, T, C > const &m, MultiArrayIndex d)
Definition: matrix.hxx:697
vigra::RandomForest::tree_count
int tree_count() const
return number of trees
Definition: random_forest.hxx:349
vigra::RandomForest::reLearnTree
void reLearnTree(MultiArrayView< 2, U, C1 > const &features, MultiArrayView< 2, U2, C2 > const &response, int treeId, Visitor_t visitor_, Split_t split_, Stop_t stop_, Random_t &random)
Definition: random_forest.hxx:838
vigra::linalg::columnCount
MultiArrayIndex columnCount(const MultiArrayView< 2, T, C > &x)
Definition: matrix.hxx:684
vigra::RandomForest::RandomForest
RandomForest(int treeCount, TopologyIterator topology_begin, ParameterIterator parameter_begin, ProblemSpec_t const &problem_spec, Options_t const &options=Options_t())
Create RF from external source.
Definition: random_forest.hxx:228
vigra::RandomNumberGenerator
Definition: random.hxx:336
vigra::MultiArrayView
Base class for, and view to, vigra::MultiArray.
Definition: multi_array.hxx:704
vigra::RandomForestOptions
Options object for the random forest.
Definition: rf_common.hxx:170
vigra::RandomForest::predictLabels
void predictLabels(MultiArrayView< 2, U, C1 >const &features, MultiArrayView< 2, T, C2 > &labels, Stop &stop) const
predict multiple labels with given features
Definition: random_forest.hxx:639
vigra::MultiArrayView::init
MultiArrayView & init(const U &init)
Definition: multi_array.hxx:1206
vigra::RandomForest::learn
void learn(MultiArrayView< 2, U, C1 > const &features, MultiArrayView< 2, U2, C2 > const &response, Visitor_t visitor, Split_t split, Stop_t stop, Random_t const &random)
learn on data with custom config and random number generator
Definition: random_forest.hxx:941
vigra::RandomForest::predictProbabilities
void predictProbabilities(MultiArrayView< 2, U, C1 >const &features, MultiArrayView< 2, T, C2 > &prob, Stop &stop) const
predict the class probabilities for multiple labels
vigra::rf::visitors::StopVisiting
Definition: rf_visitors.hxx:234

© Ullrich Köthe (ullrich.koethe@iwr.uni-heidelberg.de) Heidelberg Collaboratory for Image Processing, University of Heidelberg, Germany | html generated using doxygen and Python vigra 1.11.1 (Fri May 19 2017)