35#ifndef VIGRA_RF_ALGORITHM_HXX
36#define VIGRA_RF_ALGORITHM_HXX
59 template<
class OrigMultiArray,
62 void choose(OrigMultiArray
const & in,
67 int columnCount = std::distance(b, e);
68 int rowCount = in.shape(0);
71 for(Iter iter = b; iter != e; ++iter, ++ii)
73 columnVector(out, ii) = columnVector(in, *iter);
101 template<
class Feature_t,
class Response_t>
103 Response_t
const & response)
126 typedef std::vector<int> FeatureList_t;
127 typedef std::vector<double> ErrorList_t;
128 typedef FeatureList_t::iterator Pivot_t;
154 template<
class FeatureT,
157 class ErrorRateCallBack>
158 bool init(FeatureT
const & all_features,
159 ResponseT
const & response,
162 ErrorRateCallBack errorcallback)
164 bool ret_ = init(all_features, response, errorcallback);
167 vigra_precondition(std::distance(b, e) ==
static_cast<std::ptrdiff_t
>(
selected.size()),
168 "Number of features in ranking != number of features matrix");
173 template<
class FeatureT,
176 bool init(FeatureT
const & all_features,
177 ResponseT
const & response,
182 return init(all_features, response, b, e, ecallback);
186 template<
class FeatureT,
188 bool init(FeatureT
const & all_features,
189 ResponseT
const & response)
191 return init(all_features, response, RFErrorCallback());
203 template<
class FeatureT,
205 class ErrorRateCallBack>
206 bool init(FeatureT
const & all_features,
207 ResponseT
const & response,
208 ErrorRateCallBack errorcallback)
216 selected.resize(all_features.shape(1), 0);
217 for(
unsigned int ii = 0; ii <
selected.size(); ++ii)
219 errors.resize(all_features.shape(1), -1);
220 errors.back() = errorcallback(all_features, response);
224 std::map<typename ResponseT::value_type, int> res_map;
225 std::vector<int> cts;
227 for(
int ii = 0; ii < response.shape(0); ++ii)
229 if(res_map.find(response(ii, 0)) == res_map.end())
231 res_map[response(ii, 0)] = counter;
235 cts[res_map[response(ii,0)]] +=1;
237 no_features = double(*(std::max_element(cts.begin(),
239 / double(response.shape(0));
294template<
class FeatureT,
class ResponseT,
class ErrorRateCallBack>
296 ResponseT
const & response,
298 ErrorRateCallBack errorcallback)
300 VariableSelectionResult::FeatureList_t & selected = result.
selected;
301 VariableSelectionResult::ErrorList_t & errors = result.
errors;
302 VariableSelectionResult::Pivot_t & pivot = result.pivot;
303 int featureCount = features.shape(1);
305 if(!result.init(features, response, errorcallback))
309 vigra_precondition(
static_cast<int>(selected.size()) == featureCount,
310 "forward_selection(): Number of features in Feature "
311 "matrix and number of features in previously used "
312 "result struct mismatch!");
316 int not_selected_size = std::distance(pivot, selected.end());
317 while(not_selected_size > 1)
319 std::vector<double> current_errors;
320 VariableSelectionResult::Pivot_t next = pivot;
321 for(
int ii = 0; ii < not_selected_size; ++ii, ++next)
323 std::swap(*pivot, *next);
325 detail::choose( features,
329 double error = errorcallback(cur_feats, response);
330 current_errors.push_back(error);
331 std::swap(*pivot, *next);
333 int pos = std::distance(current_errors.begin(),
334 std::min_element(current_errors.begin(),
335 current_errors.end()));
337 std::advance(next, pos);
338 std::swap(*pivot, *next);
339 errors[std::distance(selected.begin(), pivot)] = current_errors[pos];
341 std::copy(current_errors.begin(), current_errors.end(), std::ostream_iterator<double>(std::cerr,
", "));
342 std::cerr <<
"Choosing " << *pivot <<
" at error of " << current_errors[pos] << std::endl;
345 not_selected_size = std::distance(pivot, selected.end());
348template<
class FeatureT,
class ResponseT>
350 ResponseT
const & response,
351 VariableSelectionResult & result)
396template<
class FeatureT,
class ResponseT,
class ErrorRateCallBack>
398 ResponseT
const & response,
400 ErrorRateCallBack errorcallback)
402 int featureCount = features.shape(1);
403 VariableSelectionResult::FeatureList_t & selected = result.
selected;
404 VariableSelectionResult::ErrorList_t & errors = result.
errors;
405 VariableSelectionResult::Pivot_t & pivot = result.pivot;
408 if(!result.init(features, response, errorcallback))
412 vigra_precondition(
static_cast<int>(selected.size()) == featureCount,
413 "backward_elimination(): Number of features in Feature "
414 "matrix and number of features in previously used "
415 "result struct mismatch!");
417 pivot = selected.end() - 1;
419 int selected_size = std::distance(selected.begin(), pivot);
420 while(selected_size > 1)
422 VariableSelectionResult::Pivot_t next = selected.begin();
423 std::vector<double> current_errors;
424 for(
int ii = 0; ii < selected_size; ++ii, ++next)
426 std::swap(*pivot, *next);
428 detail::choose( features,
432 double error = errorcallback(cur_feats, response);
433 current_errors.push_back(error);
434 std::swap(*pivot, *next);
436 int pos = std::distance(current_errors.begin(),
437 std::min_element(current_errors.begin(),
438 current_errors.end()));
439 next = selected.begin();
440 std::advance(next, pos);
441 std::swap(*pivot, *next);
443 errors[std::distance(selected.begin(), pivot)-1] = current_errors[pos];
444 selected_size = std::distance(selected.begin(), pivot);
446 std::copy(current_errors.begin(), current_errors.end(), std::ostream_iterator<double>(std::cerr,
", "));
447 std::cerr <<
"Eliminating " << *pivot <<
" at error of " << current_errors[pos] << std::endl;
453template<
class FeatureT,
class ResponseT>
455 ResponseT
const & response,
456 VariableSelectionResult & result)
493template<
class FeatureT,
class ResponseT,
class ErrorRateCallBack>
495 ResponseT
const & response,
497 ErrorRateCallBack errorcallback)
499 VariableSelectionResult::FeatureList_t & selected = result.
selected;
500 VariableSelectionResult::ErrorList_t & errors = result.
errors;
501 VariableSelectionResult::Pivot_t & iter = result.pivot;
502 int featureCount = features.shape(1);
504 if(!result.init(features, response, errorcallback))
508 vigra_precondition(
static_cast<int>(selected.size()) == featureCount,
509 "forward_selection(): Number of features in Feature "
510 "matrix and number of features in previously used "
511 "result struct mismatch!");
514 for(; iter != selected.end(); ++iter)
517 detail::choose( features,
521 double error = errorcallback(cur_feats, response);
522 errors[std::distance(selected.begin(), iter)] = error;
524 std::copy(selected.begin(), iter+1, std::ostream_iterator<int>(std::cerr,
", "));
525 std::cerr <<
"Choosing " << *(iter+1) <<
" at error of " << error << std::endl;
531template<
class FeatureT,
class ResponseT>
533 ResponseT
const & response,
534 VariableSelectionResult & result)
541enum ClusterLeafTypes{c_Leaf = 95, c_Node = 99};
557 ClusterNode(
int nCol,
558 BT::T_Container_type & topology,
559 BT::P_Container_type & split_param)
560 : BT(nCol + 5, 5,topology, split_param)
570 ClusterNode( BT::T_Container_type
const & topology,
571 BT::P_Container_type
const & split_param,
573 :
NodeBase(5 , 5,topology, split_param, n)
579 ClusterNode( BT & node_)
584 BT::parameter_size_ += 0;
590 void set_index(
int in)
616 HC_Entry(
int p,
int l,
int a,
bool in)
617 : parent(p), level(l), addr(a), infm(in)
646 double dist_func(
double a,
double b)
648 return std::min(a, b);
654 template<
class Functor>
658 std::vector<int> stack;
659 stack.push_back(begin_addr);
660 while(!stack.empty())
662 ClusterNode node(topology_, parameters_, stack.
back());
666 if(node.columns_size() != 1)
668 stack.push_back(node.child(0));
669 stack.push_back(node.child(1));
677 template<
class Functor>
681 std::queue<HC_Entry> queue;
686 queue.push(
HC_Entry(parent,level,begin_addr, infm));
687 while(!queue.empty())
689 level = queue.front().level;
690 parent = queue.front().parent;
691 addr = queue.front().addr;
692 infm = queue.front().infm;
693 ClusterNode node(topology_, parameters_, queue.
front().addr);
697 parnt = ClusterNode(topology_, parameters_, parent);
700 bool istrue = tester(node, level, parnt, infm);
701 if(node.columns_size() != 1)
703 queue.push(
HC_Entry(addr, level +1,node.child(0),istrue));
704 queue.push(
HC_Entry(addr, level +1,node.child(1),istrue));
711 void save(std::string file, std::string prefix)
716 Shp(topology_.
size(),1),
720 Shp(parameters_.
size(), 1),
721 parameters_.
data()));
731 template<
class T,
class C>
735 std::vector<std::pair<int, int> > addr;
737 for(
int ii = 0; ii < distance.
shape(0); ++ii)
739 addr.push_back(std::make_pair(topology_.
size(), ii));
740 ClusterNode leaf(1, topology_, parameters_);
741 leaf.set_index(index);
743 leaf.columns_begin()[0] = ii;
746 while(addr.size() != 1)
751 double min_dist = dist((addr.begin()+ii_min)->second,
752 (addr.begin()+jj_min)->second);
753 for(
unsigned int ii = 0; ii < addr.size(); ++ii)
755 for(
unsigned int jj = ii+1; jj < addr.size(); ++jj)
757 if( dist((addr.begin()+ii_min)->second,
758 (addr.begin()+jj_min)->second)
759 > dist((addr.begin()+ii)->second,
760 (addr.begin()+jj)->second))
762 min_dist = dist((addr.begin()+ii)->second,
763 (addr.begin()+jj)->second);
775 ClusterNode firstChild(topology_,
777 (addr.begin() +ii_min)->first);
778 ClusterNode secondChild(topology_,
780 (addr.begin() +jj_min)->first);
781 col_size = firstChild.columns_size() + secondChild.columns_size();
783 int cur_addr = topology_.
size();
784 begin_addr = cur_addr;
786 ClusterNode parent(col_size,
789 ClusterNode firstChild(topology_,
791 (addr.begin() +ii_min)->first);
792 ClusterNode secondChild(topology_,
794 (addr.begin() +jj_min)->first);
795 parent.parameters_begin()[0] = min_dist;
796 parent.set_index(index);
798 std::merge(firstChild.columns_begin(), firstChild.columns_end(),
799 secondChild.columns_begin(),secondChild.columns_end(),
800 parent.columns_begin());
804 if(*parent.columns_begin() == *firstChild.columns_begin())
806 parent.child(0) = (addr.begin()+ii_min)->first;
807 parent.child(1) = (addr.begin()+jj_min)->first;
808 (addr.begin()+ii_min)->first = cur_addr;
810 to_desc = (addr.begin()+jj_min)->second;
811 addr.erase(addr.begin()+jj_min);
815 parent.child(1) = (addr.begin()+ii_min)->first;
816 parent.child(0) = (addr.begin()+jj_min)->first;
817 (addr.begin()+jj_min)->first = cur_addr;
819 to_desc = (addr.begin()+ii_min)->second;
820 addr.erase(addr.begin()+ii_min);
824 for(
int jj = 0 ; jj < static_cast<int>(addr.size()); ++jj)
828 double bla = dist_func(
829 dist(to_desc, (addr.begin()+jj)->second),
830 dist((addr.begin()+ii_keep)->second,
831 (addr.begin()+jj)->second));
833 dist((addr.begin()+ii_keep)->second,
834 (addr.begin()+jj)->second) = bla;
835 dist((addr.begin()+jj)->second,
836 (addr.begin()+ii_keep)->second) = bla;
857 bool operator()(Node& node)
870template<
class Iter,
class DT>
885 template<
class Feat_T,
class Label_T>
888 Feat_T
const & feats,
889 Label_T
const & labls,
894 :tmp_mem_(_spl(a, b).size(), feats.shape(1)),
897 feats_(_spl(a,b).size(), feats.shape(1)),
898 labels_(_spl(a,b).size(),1),
904 copy_splice(_spl(a,b),
905 _spl(feats.shape(1)),
908 copy_splice(_spl(a,b),
909 _spl(labls.shape(1)),
915 bool operator()(Node& node)
919 int class_count = perm_imp.
shape(1) - 1;
921 for(
int kk = 0; kk < nPerm; ++kk)
924 for(
int ii = 0; ii < rowCount(feats_); ++ii)
926 int index = random.
uniformInt(rowCount(feats_) - ii) +ii;
927 for(
int jj = 0; jj < node.columns_size(); ++jj)
929 if(node.columns_begin()[jj] != feats_.shape(1))
930 tmp_mem_(ii, node.columns_begin()[jj])
931 = tmp_mem_(index, node.columns_begin()[jj]);
935 for(
int ii = 0; ii < rowCount(tmp_mem_); ++ii)
938 .predictLabel(rowVector(tmp_mem_, ii))
942 ++perm_imp(index,labels_(ii, 0));
944 ++perm_imp(index, class_count);
948 double node_status = perm_imp(index, class_count);
949 node_status /= nPerm;
950 node_status -= orig_imp(0, class_count);
952 node_status /= oob_size;
953 node.status() += node_status;
974 void save(std::string file, std::string prefix)
982 bool operator()(Node& node)
984 for(
int ii = 0; ii < node.columns_size(); ++ii)
985 variables(index, ii) = node.columns_begin()[ii];
999 bool operator()(Nde & cur,
int , Nde parent,
bool )
1002 cur.status() = std::min(parent.status(), cur.status());
1029 std::ofstream graphviz;
1034 std::string
const gz)
1035 :features_(features), labels_(labels),
1036 graphviz(gz.c_str(), std::ios::out)
1038 graphviz <<
"digraph G\n{\n node [shape=\"record\"]";
1042 graphviz <<
"\n}\n";
1047 bool operator()(Nde & cur,
int , Nde parent,
bool )
1049 graphviz <<
"node" << cur.index() <<
" [style=\"filled\"][label = \" #Feats: "<< cur.columns_size() <<
"\\n";
1050 graphviz <<
" status: " << cur.status() <<
"\\n";
1051 for(
int kk = 0; kk < cur.columns_size(); ++kk)
1053 graphviz << cur.columns_begin()[kk] <<
" ";
1057 graphviz <<
"\"] [color = \"" <<cur.status() <<
" 1.000 1.000\"];\n";
1059 graphviz <<
"\"node" << parent.index() <<
"\" -> \"node" << cur.index() <<
"\";\n";
1079 int repetition_count_;
1085 void save(std::string filename, std::string prefix)
1087 std::string prefix1 =
"cluster_importance_" + prefix;
1091 prefix1 =
"vars_" + prefix;
1099 : repetition_count_(rep_cnt), clustering(clst)
1105 template<
class RF,
class PR>
1108 Int32 const class_count = rf.ext_param_.class_count_;
1109 Int32 const column_count = rf.ext_param_.column_count_+1;
1130 template<
class RF,
class PR,
class SM,
class ST>
1134 Int32 column_count = rf.ext_param_.column_count_ +1;
1135 Int32 class_count = rf.ext_param_.class_count_;
1139 typename PR::Feature_t & features
1140 =
const_cast<typename PR::Feature_t &
>(pr.features());
1144 ArrayVector<Int32>::iterator
1147 if(rf.ext_param_.actual_msample_ < pr.features().shape(0)- 10000)
1151 for(
int ii = 0; ii < pr.features().shape(0); ++ii)
1152 indices.push_back(ii); ;
1153 std::random_device rd;
1154 std::mt19937 g(rd());
1155 std::shuffle(indices.
begin(), indices.
end(), g);
1156 for(
int ii = 0; ii < rf.ext_param_.row_count_; ++ii)
1158 if(!sm.is_used()[indices[ii]] && cts[pr.response()(indices[ii], 0)] < 3000)
1160 oob_indices.push_back(indices[ii]);
1161 ++cts[pr.response()(indices[ii], 0)];
1167 for(
int ii = 0; ii < rf.ext_param_.row_count_; ++ii)
1168 if(!sm.is_used()[ii])
1169 oob_indices.push_back(ii);
1179 oob_right(Shp_t(1, class_count + 1));
1182 for(iter = oob_indices.
begin();
1183 iter != oob_indices.
end();
1187 .predictLabel(rowVector(features, *iter))
1188 == pr.response()(*iter, 0))
1191 ++oob_right[pr.response()(*iter,0)];
1193 ++oob_right[class_count];
1198 perm_oob_right (Shp_t(2* column_count-1, class_count + 1));
1201 pc(oob_indices.
begin(), oob_indices.
end(),
1210 perm_oob_right /= repetition_count_;
1211 for(
int ii = 0; ii < rowCount(perm_oob_right); ++ii)
1212 rowVector(perm_oob_right, ii) -= oob_right;
1214 perm_oob_right *= -1;
1215 perm_oob_right /= oob_indices.
size();
1224 template<
class RF,
class PR,
class SM,
class ST>
1232 template<
class RF,
class PR>
1272template<
class FeatureT,
class ResponseT>
1274 ResponseT
const & response,
1281 if(features.shape(0) > 40000)
1288 RF.
learn(features, response,
1289 create_visitor(missc, progress));
1304 create_visitor(progress, ci));
1317template<
class FeatureT,
class ResponseT>
1319 ResponseT
const & response,
1320 HClustering & linkage)
1327template<
class Array1,
class Vector1>
1328void get_ranking(Array1
const & in, Vector1 & out)
1330 std::map<double, int> mymap;
1331 for(
int ii = 0; ii < in.size(); ++ii)
1333 for(std::map<double, int>::reverse_iterator iter = mymap.rbegin(); iter!= mymap.rend(); ++iter)
1335 out.push_back(iter->second);
const_iterator begin() const
Definition array_vector.hxx:223
const_pointer data() const
Definition array_vector.hxx:209
size_type size() const
Definition array_vector.hxx:358
reference front()
Definition array_vector.hxx:307
const_iterator end() const
Definition array_vector.hxx:237
reference back()
Definition array_vector.hxx:321
Definition array_vector.hxx:514
Base class for, and view to, vigra::MultiArray.
Definition multi_fwd.hxx:127
const difference_type & shape() const
Definition multi_array.hxx:1650
Main MultiArray class containing the memory management.
Definition multi_fwd.hxx:131
void reshape(const difference_type &shape)
Definition multi_array.hxx:2863
Topology_type column_data() const
Definition rf_nodeproxy.hxx:159
INT & typeID()
Definition rf_nodeproxy.hxx:136
NodeBase()
Definition rf_nodeproxy.hxx:237
Parameter_type parameters_begin() const
Definition rf_nodeproxy.hxx:207
Options object for the random forest.
Definition rf_common.hxx:171
RandomForestOptions & use_stratification(RF_OptionTag in)
specify stratification strategy
Definition rf_common.hxx:374
RandomForestOptions & samples_per_tree(double in)
specify the fraction of the total number of samples used per tree for learning.
Definition rf_common.hxx:411
RandomForestOptions & tree_count(unsigned int in)
Definition rf_common.hxx:500
Random forest version 2 (see also vigra::rf3::RandomForest for version 3)
Definition random_forest.hxx:148
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
Definition random.hxx:346
UInt32 uniformInt() const
Definition random.hxx:472
Class for fixed size vectors.
Definition tinyvector.hxx:1008
Definition matrix.hxx:125
Definition rf_algorithm.hxx:1067
MultiArray< 2, double > cluster_importance_
Definition rf_algorithm.hxx:1075
MultiArray< 2, int > variables
Definition rf_algorithm.hxx:1072
void visit_at_end(RF &rf, PR &)
Definition rf_algorithm.hxx:1233
void visit_after_tree(RF &rf, PR &pr, SM &sm, ST &st, int index)
Definition rf_algorithm.hxx:1225
MultiArray< 2, double > cluster_stdev_
Definition rf_algorithm.hxx:1078
void after_tree_ip_impl(RF &rf, PR &pr, SM &sm, ST &, int index)
Definition rf_algorithm.hxx:1131
void visit_at_beginning(RF const &rf, PR const &)
Definition rf_algorithm.hxx:1106
Definition rf_algorithm.hxx:996
Definition rf_algorithm.hxx:1024
Definition rf_algorithm.hxx:963
MultiArrayView< 2, int > variables
Definition rf_algorithm.hxx:968
Definition rf_algorithm.hxx:638
void iterate(Functor &tester)
Definition rf_algorithm.hxx:655
void cluster(MultiArrayView< 2, T, C > distance)
Definition rf_algorithm.hxx:732
void breadth_first_traversal(Functor &tester)
Definition rf_algorithm.hxx:678
Definition rf_algorithm.hxx:847
NormalizeStatus(double m)
Definition rf_algorithm.hxx:853
Definition rf_algorithm.hxx:872
Definition rf_algorithm.hxx:85
double operator()(Feature_t const &features, Response_t const &response)
Definition rf_algorithm.hxx:102
RFErrorCallback(RandomForestOptions opt=RandomForestOptions())
Definition rf_algorithm.hxx:94
Definition rf_algorithm.hxx:118
double no_features
Definition rf_algorithm.hxx:152
ErrorList_t errors
Definition rf_algorithm.hxx:147
FeatureList_t selected
Definition rf_algorithm.hxx:134
bool init(FeatureT const &all_features, ResponseT const &response, ErrorRateCallBack errorcallback)
Definition rf_algorithm.hxx:206
Definition rf_visitors.hxx:1494
MultiArray< 2, double > distance
Definition rf_visitors.hxx:1522
Definition rf_visitors.hxx:865
double oob_breiman
Definition rf_visitors.hxx:875
Definition rf_visitors.hxx:1458
Definition rf_visitors.hxx:103
void backward_elimination(FeatureT const &features, ResponseT const &response, VariableSelectionResult &result, ErrorRateCallBack errorcallback)
Definition rf_algorithm.hxx:397
void rank_selection(FeatureT const &features, ResponseT const &response, VariableSelectionResult &result, ErrorRateCallBack errorcallback)
Definition rf_algorithm.hxx:494
void forward_selection(FeatureT const &features, ResponseT const &response, VariableSelectionResult &result, ErrorRateCallBack errorcallback)
Definition rf_algorithm.hxx:295
void cluster_permutation_importance(FeatureT const &features, ResponseT const &response, HClustering &linkage, MultiArray< 2, double > &distance)
Definition rf_algorithm.hxx:1273
detail::VisitorNode< A > create_visitor(A &a)
Definition rf_visitors.hxx:345
void writeHDF5(...)
Store array data in an HDF5 file.
detail::SelectIntegerType< 32, detail::SignedIntTypes >::type Int32
32-bit signed int
Definition sized_int.hxx:175
Definition metaprogramming.hxx:123
Definition rf_algorithm.hxx:611