Point Cloud Library (PCL) 1.15.0
Loading...
Searching...
No Matches
decision_tree_evaluator.hpp
1/*
2 * Software License Agreement (BSD License)
3 *
4 * Point Cloud Library (PCL) - www.pointclouds.org
5 * Copyright (c) 2010-2011, Willow Garage, Inc.
6 *
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 *
13 * * Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * * Redistributions in binary form must reproduce the above
16 * copyright notice, this list of conditions and the following
17 * disclaimer in the documentation and/or other materials provided
18 * with the distribution.
19 * * Neither the name of Willow Garage, Inc. nor the names of its
20 * contributors may be used to endorse or promote products derived
21 * from this software without specific prior written permission.
22 *
23 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
24 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
25 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
26 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
27 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
28 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
29 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
30 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
31 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
33 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
34 * POSSIBILITY OF SUCH DAMAGE.
35 *
36 */
37
38#pragma once
39
40#include <pcl/common/common.h>
41#include <pcl/ml/dt/decision_tree.h>
42#include <pcl/ml/feature_handler.h>
43#include <pcl/ml/stats_estimator.h>
44
45#include <vector>
46
47namespace pcl {
48
49template <class FeatureType,
50 class DataSet,
51 class LabelType,
52 class ExampleIndex,
53 class NodeType>
55 DecisionTreeEvaluator() = default;
56
57template <class FeatureType,
58 class DataSet,
59 class LabelType,
60 class ExampleIndex,
61 class NodeType>
63 ~DecisionTreeEvaluator() = default;
64
65template <class FeatureType,
66 class DataSet,
67 class LabelType,
68 class ExampleIndex,
69 class NodeType>
70void
75 stats_estimator,
76 DataSet& data_set,
77 std::vector<ExampleIndex>& examples,
78 std::vector<LabelType>& label_data)
79{
80 const std::size_t num_of_examples = examples.size();
81 label_data.resize(num_of_examples);
82 for (int example_index = 0; example_index < num_of_examples; ++example_index) {
83 NodeType* node = &(tree.getRoot());
84
85 while (node->sub_nodes.size() != 0) {
86 float feature_result = 0.0f;
87 unsigned char flag = 0;
88 unsigned char branch_index = 0;
89
90 feature_handler.evaluateFeature(
91 node->feature, data_set, examples[example_index], feature_result, flag);
92 stats_estimator.computeBranchIndex(
93 feature_result, flag, node->threshold, branch_index);
94
95 node = &(node->sub_nodes[branch_index]);
96 }
97
98 label_data[example_index] = stats_estimator.getLabelOfNode(*node);
99 }
100}
101
102template <class FeatureType,
103 class DataSet,
104 class LabelType,
105 class ExampleIndex,
106 class NodeType>
107void
113 stats_estimator,
114 DataSet& data_set,
115 std::vector<ExampleIndex>& examples,
116 std::vector<LabelType>& label_data)
117{
118 const std::size_t num_of_examples = examples.size();
119 for (int example_index = 0; example_index < num_of_examples; ++example_index) {
120 NodeType* node = &(tree.getRoot());
121
122 while (node->sub_nodes.size() != 0) {
123 float feature_result = 0.0f;
124 unsigned char flag = 0;
125 unsigned char branch_index = 0;
126
127 feature_handler.evaluateFeature(
128 node->feature, data_set, examples[example_index], feature_result, flag);
129 stats_estimator.computeBranchIndex(
130 feature_result, flag, node->threshold, branch_index);
131
132 node = &(node->sub_nodes[branch_index]);
133 }
134
135 label_data[example_index] += stats_estimator.getLabelOfNode(*node);
136 }
137}
138
139template <class FeatureType,
140 class DataSet,
141 class LabelType,
142 class ExampleIndex,
143 class NodeType>
144void
149 stats_estimator,
150 DataSet& data_set,
151 ExampleIndex example,
152 NodeType& leave)
153{
154 NodeType* node = &(tree.getRoot());
155
156 while (!node->sub_nodes.empty()) {
157 float feature_result = 0.0f;
158 unsigned char flag = 0;
159 unsigned char branch_index = 0;
160
161 feature_handler.evaluateFeature(
162 node->feature, data_set, example, feature_result, flag);
163 stats_estimator.computeBranchIndex(
164 feature_result, flag, node->threshold, branch_index);
165
166 node = &(node->sub_nodes[branch_index]);
167 }
168
169 leave = *node;
170}
171
172template <class FeatureType,
173 class DataSet,
174 class LabelType,
175 class ExampleIndex,
176 class NodeType>
177void
182 stats_estimator,
183 DataSet& data_set,
184 std::vector<ExampleIndex>& examples,
185 std::vector<NodeType*>& nodes)
186{
187 const std::size_t num_of_examples = examples.size();
188 for (int example_index = 0; example_index < num_of_examples; ++example_index) {
189 NodeType* node = &(tree.getRoot());
190
191 while (node->sub_nodes.size() != 0) {
192 float feature_result = 0.0f;
193 unsigned char flag = 0;
194 unsigned char branch_index = 0;
195
196 feature_handler.evaluateFeature(
197 node->feature, data_set, examples[example_index], feature_result, flag);
198 stats_estimator.computeBranchIndex(
199 feature_result, node->threshold, flag, branch_index);
200
201 node = &(node->subNodes[branch_index]);
202 }
203
204 nodes.push_back(node);
205 }
206}
207
208} // namespace pcl
virtual ~DecisionTreeEvaluator()
Destructor.
void getNodes(pcl::DecisionTree< NodeType > &tree, pcl::FeatureHandler< FeatureType, DataSet, ExampleIndex > &feature_handler, pcl::StatsEstimator< LabelType, NodeType, DataSet, ExampleIndex > &stats_estimator, DataSet &data_set, std::vector< ExampleIndex > &examples, std::vector< NodeType * > &nodes)
Evaluates the specified examples using the supplied tree.
DecisionTreeEvaluator()
Constructor.
void evaluateAndAdd(pcl::DecisionTree< NodeType > &tree, pcl::FeatureHandler< FeatureType, DataSet, ExampleIndex > &feature_handler, pcl::StatsEstimator< LabelType, NodeType, DataSet, ExampleIndex > &stats_estimator, DataSet &data_set, std::vector< ExampleIndex > &examples, std::vector< LabelType > &label_data)
Evaluates the specified examples using the supplied tree and adds the results to the supplied results...
void evaluate(pcl::DecisionTree< NodeType > &tree, pcl::FeatureHandler< FeatureType, DataSet, ExampleIndex > &feature_handler, pcl::StatsEstimator< LabelType, NodeType, DataSet, ExampleIndex > &stats_estimator, DataSet &data_set, std::vector< ExampleIndex > &examples, std::vector< LabelType > &label_data)
Evaluates the specified examples using the supplied tree.
Class representing a decision tree.
NodeType & getRoot()
Returns the root node of the tree.
Utility class interface which is used for creating and evaluating features.
virtual void evaluateFeature(const FeatureType &feature, DataSet &data_set, std::vector< ExampleIndex > &examples, std::vector< float > &results, std::vector< unsigned char > &flags) const =0
Evaluates a feature on the specified data.
Class interface for gathering statistics for decision tree learning.
virtual LabelDataType getLabelOfNode(NodeType &node) const =0
Returns the label of the specified node.
virtual void computeBranchIndex(const float result, const unsigned char flag, const float threshold, unsigned char &branch_index) const =0
Computes the branch indices obtained by the specified threshold on the supplied feature evaluation re...
Define standard C methods and C++ classes that are common to all methods.