1 // This is brl/bseg/brec/pro/processes/brec_learner_processes.cxx
2 #include <bprb/bprb_func_process.h>
3 //:
4 // \file
5 // \brief Processes to initialize learner class instances, collect stats and fit parametric distributions
6 //
7 // \author Ozge Can Ozcanli
8 // \date Jan 22, 2009
9 //
10 // \verbatim
11 // Modifications
12 // Ozge C. Ozcanli - Feb 03, 2009 - converted process-class to functions which is the new design for bprb processes.
13 // \endverbatim
14
15 #include <brdb/brdb_value.h>
16 #include <bprb/bprb_parameters.h>
17
18 #include <brec/brec_part_hierarchy_learner_sptr.h>
19 #include <brec/brec_part_hierarchy_learner.h>
20 #include <brec/brec_part_hierarchy.h>
21
22 //: Constructor
brec_learner_layer0_init_process_cons(bprb_func_process & pro)23 bool brec_learner_layer0_init_process_cons(bprb_func_process& pro)
24 {
25 //inputs
26 bool ok=false;
27 std::vector<std::string> input_types;
28 input_types.emplace_back("int"); // number of directions to try in range [180,-180)
29 input_types.emplace_back("float"); // lambda range (e.g. will try lambda0 and lambda1 in [1.0, lambda range])
30 input_types.emplace_back("float"); // lambda increment (e.g. will increment lambda0 and lambda1 with this amount)
31 input_types.emplace_back("int"); // visualization parameter n, n*n histograms are plotted in a row into the m file
32 ok = pro.set_input_types(input_types);
33 if (!ok) return ok;
34
35 //output
36 std::vector<std::string> output_types;
37 output_types.emplace_back("brec_part_hierarchy_learner_sptr"); // learner instance, initialized according to the input params
38 ok = pro.set_output_types(output_types);
39 return ok;
40 }
41
brec_learner_layer0_init_process(bprb_func_process & pro)42 bool brec_learner_layer0_init_process(bprb_func_process& pro)
43 {
44 // Sanity check
45 if (pro.n_inputs() < 4) {
46 std::cerr << " brec_learner_init_layer0_process - invalid inputs\n";
47 return false;
48 }
49
50 //: get input
51 unsigned i = 0;
52 int ndirs = pro.get_input<int>(i++);
53 auto lambda_range = pro.get_input<float>(i++);
54 auto lambda_inc = pro.get_input<float>(i++);
55 int n = pro.get_input<int>(i++);
56
57 brec_part_hierarchy_learner_sptr hl = new brec_part_hierarchy_learner();
58 hl->initialize_layer0_as_gaussians(ndirs, lambda_range, lambda_inc, n);
59
60 pro.set_output_val<brec_part_hierarchy_learner_sptr>(0, hl);
61
62 return true;
63 }
64
65
66 //: Constructor
brec_learner_layer0_fit_process_cons(bprb_func_process & pro)67 bool brec_learner_layer0_fit_process_cons(bprb_func_process& pro)
68 {
69 //inputs
70 bool ok=false;
71 std::vector<std::string> input_types;
72 input_types.emplace_back("brec_part_hierarchy_learner_sptr"); // the already initialized learner instance
73 input_types.emplace_back("vcl_string"); // the name of output file to print fitted distributions
74 ok = pro.set_input_types(input_types);
75 if (!ok) return ok;
76
77 //output
78 std::vector<std::string> output_types;
79 output_types.emplace_back("brec_part_hierarchy_learner_sptr"); // return learner instance back
80 ok = pro.set_output_types(output_types);
81 return ok;
82 }
83
84
brec_learner_layer0_fit_process(bprb_func_process & pro)85 bool brec_learner_layer0_fit_process(bprb_func_process& pro)
86 {
87 // Sanity check
88 if (pro.n_inputs() < 2) {
89 std::cerr << " brec_learner_fit_layer0_process - invalid inputs\n";
90 return false;
91 }
92
93 // get input
94 unsigned i = 0;
95 brec_part_hierarchy_learner_sptr hl = pro.get_input<brec_part_hierarchy_learner_sptr>(i++);
96 std::string output_name = pro.get_input<std::string>(i++);
97
98 hl->layer0_fit_parametric_dist();
99 hl->print_to_m_file_layer0_fitted_dists(output_name);
100
101 pro.set_output_val<brec_part_hierarchy_learner_sptr>(0, hl);
102
103 return true;
104 }
105
106 //: Constructor
brec_learner_layer0_rank_process_cons(bprb_func_process & pro)107 bool brec_learner_layer0_rank_process_cons(bprb_func_process& pro)
108 {
109 //inputs
110 bool ok=false;
111 std::vector<std::string> input_types;
112 input_types.emplace_back("brec_part_hierarchy_learner_sptr"); // the already initialized learner instance
113 input_types.emplace_back("int"); // N: top N layer0 prims are used in the created hierarchy
114 ok = pro.set_input_types(input_types);
115 if (!ok) return ok;
116
117 //output
118 std::vector<std::string> output_types;
119 output_types.emplace_back("brec_part_hierarchy_sptr");
120 ok = pro.set_output_types(output_types);
121 return ok;
122 }
123
brec_learner_layer0_rank_process(bprb_func_process & pro)124 bool brec_learner_layer0_rank_process(bprb_func_process& pro)
125 {
126 // Sanity check
127 if (pro.n_inputs() < 2) {
128 std::cerr << " brec_learner_layer0_rank_process - invalid inputs\n";
129 return false;
130 }
131
132 // get input
133 unsigned i = 0;
134 brec_part_hierarchy_learner_sptr hl = pro.get_input<brec_part_hierarchy_learner_sptr>(i++);
135 int N = pro.get_input<int>(i++);
136
137 brec_part_hierarchy_sptr h = hl->layer0_rank_and_create_hierarchy(N);
138 pro.set_output_val<brec_part_hierarchy_sptr>(0, h);
139
140 return true;
141 }
142
143 //: Constructor
brec_learner_layer_n_init_process_cons(bprb_func_process & pro)144 bool brec_learner_layer_n_init_process_cons(bprb_func_process& pro)
145 {
146 //inputs
147 bool ok=false;
148 std::vector<std::string> input_types;
149 input_types.emplace_back("brec_part_hierarchy_sptr"); // hierarchy whose layer n will be constructed
150 input_types.emplace_back("unsigned"); // n : id of the layer to construct (hierarchy should contain n-1)
151 input_types.emplace_back("unsigned"); // k: number of classes
152 input_types.emplace_back("float"); // radius that is to be used to collect stats for existence of pairs as they appear within each others neighborhood
153 ok = pro.set_input_types(input_types);
154 if (!ok) return ok;
155
156 //output
157 std::vector<std::string> output_types;
158 output_types.emplace_back("brec_part_hierarchy_learner_sptr"); // learner instance, initialized according to the input params
159 ok = pro.set_output_types(output_types);
160 return ok;
161 }
162
brec_learner_layer_n_init_process(bprb_func_process & pro)163 bool brec_learner_layer_n_init_process(bprb_func_process& pro)
164 {
165 // Sanity check
166 if (pro.n_inputs() < 3){
167 std::cerr << " brec_learner_init_layer0_process - invalid inputs\n";
168 return false;
169 }
170
171 //: get input
172 unsigned i = 0;
173 brec_part_hierarchy_sptr h = pro.get_input<brec_part_hierarchy_sptr>(i++);
174 auto n = pro.get_input<unsigned>(i++);
175 auto k = pro.get_input<unsigned>(i++);
176 auto rad = pro.get_input<float>(i++);
177
178 brec_part_hierarchy_learner_sptr hl = new brec_part_hierarchy_learner();
179 hl->initialize_layer_n_as_pairs(h, n, k, rad);
180
181 pro.set_output_val<brec_part_hierarchy_learner_sptr>(0, hl);
182
183 return true;
184 }
185
186 //: Constructor
brec_learner_layer_n_fit_process_cons(bprb_func_process & pro)187 bool brec_learner_layer_n_fit_process_cons(bprb_func_process& pro)
188 {
189 //inputs
190 bool ok=false;
191 std::vector<std::string> input_types;
192 input_types.emplace_back("brec_part_hierarchy_learner_sptr"); // the already initialized learner instance
193 input_types.emplace_back("unsigned"); // class id
194 input_types.emplace_back("unsigned"); // n : id of the layer to construct (hierarchy should contain n-1)
195 input_types.emplace_back("vcl_string"); // the name of output file to print fitted distributions
196 input_types.emplace_back("unsigned"); // M: number of best pair models to select for this class
197 ok = pro.set_input_types(input_types);
198 if (!ok) return ok;
199
200 //output
201 std::vector<std::string> output_types;
202 output_types.emplace_back("brec_part_hierarchy_sptr"); // output the hierarchy for this class, with fitted models for compositions of layer n
203 ok = pro.set_output_types(output_types);
204 return ok;
205 }
206
207
brec_learner_layer_n_fit_process(bprb_func_process & pro)208 bool brec_learner_layer_n_fit_process(bprb_func_process& pro)
209 {
210 // Sanity check
211 if (pro.n_inputs() < 2) {
212 std::cerr << " brec_learner_layer_n_fit_process - invalid inputs\n";
213 return false;
214 }
215
216 // get input
217 unsigned i = 0;
218 brec_part_hierarchy_learner_sptr hl = pro.get_input<brec_part_hierarchy_learner_sptr>(i++);
219 auto class_id = pro.get_input<unsigned>(i++);
220 auto n = pro.get_input<unsigned>(i++);
221 std::string output_name = pro.get_input<std::string>(i++);
222 auto M = pro.get_input<unsigned>(i++);
223
224 hl->layer_n_fit_distributions(class_id, n, M);
225 hl->print_to_m_file_layer_n(output_name, class_id, true);
226
227 pro.set_output_val<brec_part_hierarchy_sptr>(0, hl->h_map_[class_id]);
228
229 return true;
230 }
231