1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
|
// Copyright (C) 2010 Davis E. King (davis@dlib.net)
// License: Boost Software License See LICENSE.txt for the full license.
#ifndef DLIB_ONE_VS_ALL_DECISION_FUnCTION_H__
#define DLIB_ONE_VS_ALL_DECISION_FUnCTION_H__
#include "one_vs_all_decision_function_abstract.h"
#include "../serialize.h"
#include "../type_safe_union.h"
#include <sstream>
#include <map>
#include "../any.h"
#include "null_df.h"
namespace dlib
{
// ----------------------------------------------------------------------------------------
template <
typename one_vs_all_trainer,
typename DF1 = null_df, typename DF2 = null_df, typename DF3 = null_df,
typename DF4 = null_df, typename DF5 = null_df, typename DF6 = null_df,
typename DF7 = null_df, typename DF8 = null_df, typename DF9 = null_df,
typename DF10 = null_df
>
class one_vs_all_decision_function
{
public:
typedef typename one_vs_all_trainer::label_type result_type;
typedef typename one_vs_all_trainer::sample_type sample_type;
typedef typename one_vs_all_trainer::scalar_type scalar_type;
typedef typename one_vs_all_trainer::mem_manager_type mem_manager_type;
typedef std::map<result_type, any_decision_function<sample_type, scalar_type> > binary_function_table;
one_vs_all_decision_function() :num_classes(0) {}
explicit one_vs_all_decision_function(
const binary_function_table& dfs_
) : dfs(dfs_)
{
num_classes = dfs.size();
}
const binary_function_table& get_binary_decision_functions (
) const
{
return dfs;
}
const std::vector<result_type> get_labels (
) const
{
std::vector<result_type> temp;
temp.reserve(dfs.size());
for (typename binary_function_table::const_iterator i = dfs.begin(); i != dfs.end(); ++i)
{
temp.push_back(i->first);
}
return temp;
}
template <
typename df1, typename df2, typename df3, typename df4, typename df5,
typename df6, typename df7, typename df8, typename df9, typename df10
>
one_vs_all_decision_function (
const one_vs_all_decision_function<one_vs_all_trainer,
df1, df2, df3, df4, df5,
df6, df7, df8, df9, df10>& item
) : dfs(item.get_binary_decision_functions()), num_classes(item.number_of_classes()) {}
unsigned long number_of_classes (
) const
{
return num_classes;
}
result_type operator() (
const sample_type& sample
) const
{
DLIB_ASSERT(number_of_classes() != 0,
"\t void one_vs_all_decision_function::operator()"
<< "\n\t You can't make predictions with an empty decision function."
<< "\n\t this: " << this
);
result_type best_label = result_type();
scalar_type best_score = -std::numeric_limits<scalar_type>::infinity();
// run all the classifiers over the sample and find the best one
for(typename binary_function_table::const_iterator i = dfs.begin(); i != dfs.end(); ++i)
{
const scalar_type score = i->second(sample);
if (score > best_score)
{
best_score = score;
best_label = i->first;
}
}
return best_label;
}
private:
binary_function_table dfs;
unsigned long num_classes;
};
// ----------------------------------------------------------------------------------------
template <
typename T,
typename DF1, typename DF2, typename DF3,
typename DF4, typename DF5, typename DF6,
typename DF7, typename DF8, typename DF9,
typename DF10
>
void serialize(
const one_vs_all_decision_function<T,DF1,DF2,DF3,DF4,DF5,DF6,DF7,DF8,DF9,DF10>& item,
std::ostream& out
)
{
try
{
type_safe_union<DF1,DF2,DF3,DF4,DF5,DF6,DF7,DF8,DF9,DF10> temp;
typedef typename T::label_type result_type;
typedef typename T::sample_type sample_type;
typedef typename T::scalar_type scalar_type;
typedef std::map<result_type, any_decision_function<sample_type, scalar_type> > binary_function_table;
const unsigned long version = 1;
serialize(version, out);
const unsigned long size = item.get_binary_decision_functions().size();
serialize(size, out);
for(typename binary_function_table::const_iterator i = item.get_binary_decision_functions().begin();
i != item.get_binary_decision_functions().end(); ++i)
{
serialize(i->first, out);
if (i->second.template contains<DF1>()) temp.template get<DF1>() = any_cast<DF1>(i->second);
else if (i->second.template contains<DF2>()) temp.template get<DF2>() = any_cast<DF2>(i->second);
else if (i->second.template contains<DF3>()) temp.template get<DF3>() = any_cast<DF3>(i->second);
else if (i->second.template contains<DF4>()) temp.template get<DF4>() = any_cast<DF4>(i->second);
else if (i->second.template contains<DF5>()) temp.template get<DF5>() = any_cast<DF5>(i->second);
else if (i->second.template contains<DF6>()) temp.template get<DF6>() = any_cast<DF6>(i->second);
else if (i->second.template contains<DF7>()) temp.template get<DF7>() = any_cast<DF7>(i->second);
else if (i->second.template contains<DF8>()) temp.template get<DF8>() = any_cast<DF8>(i->second);
else if (i->second.template contains<DF9>()) temp.template get<DF9>() = any_cast<DF9>(i->second);
else if (i->second.template contains<DF10>()) temp.template get<DF10>() = any_cast<DF10>(i->second);
else throw serialization_error("Can't serialize one_vs_all_decision_function. Not all decision functions defined.");
serialize(temp,out);
}
}
catch (serialization_error& e)
{
throw serialization_error(e.info + "\n while serializing an object of type one_vs_all_decision_function");
}
}
// ----------------------------------------------------------------------------------------
namespace impl_ova
{
template <typename sample_type, typename scalar_type>
struct copy_to_df_helper
{
copy_to_df_helper(any_decision_function<sample_type, scalar_type>& target_) : target(target_) {}
any_decision_function<sample_type, scalar_type>& target;
template <typename T>
void operator() (
const T& item
) const
{
target = item;
}
};
}
template <
typename T,
typename DF1, typename DF2, typename DF3,
typename DF4, typename DF5, typename DF6,
typename DF7, typename DF8, typename DF9,
typename DF10
>
void deserialize(
one_vs_all_decision_function<T,DF1,DF2,DF3,DF4,DF5,DF6,DF7,DF8,DF9,DF10>& item,
std::istream& in
)
{
try
{
type_safe_union<DF1,DF2,DF3,DF4,DF5,DF6,DF7,DF8,DF9,DF10> temp;
typedef typename T::label_type result_type;
typedef typename T::sample_type sample_type;
typedef typename T::scalar_type scalar_type;
typedef impl_ova::copy_to_df_helper<sample_type, scalar_type> copy_to;
unsigned long version;
deserialize(version, in);
if (version != 1)
throw serialization_error("Can't deserialize one_vs_all_decision_function. Wrong version.");
unsigned long size;
deserialize(size, in);
typedef std::map<result_type, any_decision_function<sample_type, scalar_type> > binary_function_table;
binary_function_table dfs;
result_type l;
for (unsigned long i = 0; i < size; ++i)
{
deserialize(l, in);
deserialize(temp, in);
if (temp.template contains<null_df>())
throw serialization_error("A sub decision function of unknown type was encountered.");
temp.apply_to_contents(copy_to(dfs[l]));
}
item = one_vs_all_decision_function<T,DF1,DF2,DF3,DF4,DF5,DF6,DF7,DF8,DF9,DF10>(dfs);
}
catch (serialization_error& e)
{
throw serialization_error(e.info + "\n while deserializing an object of type one_vs_all_decision_function");
}
}
// ----------------------------------------------------------------------------------------
}
#endif // DLIB_ONE_VS_ALL_DECISION_FUnCTION_H__
|
