File size: 5,485 Bytes
9375c9a |
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 |
// Copyright (C) 2013 Davis E. King ([email protected])
// License: Boost Software License See LICENSE.txt for the full license.
#include "opaque_types.h"
#include <dlib/python.h>
#include <dlib/matrix.h>
#include <dlib/svm.h>
using namespace dlib;
using namespace std;
namespace py = pybind11;
template <typename psi_type>
class svm_struct_prob : public structural_svm_problem<matrix<double,0,1>, psi_type>
{
typedef structural_svm_problem<matrix<double,0,1>, psi_type> base;
typedef typename base::feature_vector_type feature_vector_type;
typedef typename base::matrix_type matrix_type;
typedef typename base::scalar_type scalar_type;
public:
svm_struct_prob (
py::object& problem_,
long num_dimensions_,
long num_samples_
) :
num_dimensions(num_dimensions_),
num_samples(num_samples_),
problem(problem_)
{}
virtual long get_num_dimensions (
) const { return num_dimensions; }
virtual long get_num_samples (
) const { return num_samples; }
virtual void get_truth_joint_feature_vector (
long idx,
feature_vector_type& psi
) const
{
psi = problem.attr("get_truth_joint_feature_vector")(idx).template cast<feature_vector_type&>();
}
virtual void separation_oracle (
const long idx,
const matrix_type& current_solution,
scalar_type& loss,
feature_vector_type& psi
) const
{
py::object res = problem.attr("separation_oracle")(idx,std::ref(current_solution));
pyassert(len(res) == 2, "separation_oracle() must return two objects, the loss and the psi vector");
py::tuple t = res.cast<py::tuple>();
// let the user supply the output arguments in any order.
try {
loss = t[0].cast<scalar_type>();
psi = t[1].cast<feature_vector_type&>();
} catch(py::cast_error&) {
psi = t[0].cast<feature_vector_type&>();
loss = t[1].cast<scalar_type>();
}
}
private:
const long num_dimensions;
const long num_samples;
py::object& problem;
};
// ----------------------------------------------------------------------------------------
template <typename psi_type>
matrix<double,0,1> solve_structural_svm_problem_impl(
py::object problem
)
{
const double C = problem.attr("C").cast<double>();
const bool be_verbose = py::hasattr(problem,"be_verbose") && problem.attr("be_verbose").cast<bool>();
const bool use_sparse_feature_vectors = py::hasattr(problem,"use_sparse_feature_vectors") &&
problem.attr("use_sparse_feature_vectors").cast<bool>();
const bool learns_nonnegative_weights = py::hasattr(problem,"learns_nonnegative_weights") &&
problem.attr("learns_nonnegative_weights").cast<bool>();
double eps = 0.001;
unsigned long max_cache_size = 10;
if (py::hasattr(problem, "epsilon"))
eps = problem.attr("epsilon").cast<double>();
if (py::hasattr(problem, "max_cache_size"))
max_cache_size = problem.attr("max_cache_size").cast<double>();
const long num_samples = problem.attr("num_samples").cast<long>();
const long num_dimensions = problem.attr("num_dimensions").cast<long>();
pyassert(num_samples > 0, "You can't train a Structural-SVM if you don't have any training samples.");
if (be_verbose)
{
cout << "C: " << C << endl;
cout << "epsilon: " << eps << endl;
cout << "max_cache_size: " << max_cache_size << endl;
cout << "num_samples: " << num_samples << endl;
cout << "num_dimensions: " << num_dimensions << endl;
cout << "use_sparse_feature_vectors: " << std::boolalpha << use_sparse_feature_vectors << endl;
cout << "learns_nonnegative_weights: " << std::boolalpha << learns_nonnegative_weights << endl;
cout << endl;
}
svm_struct_prob<psi_type> prob(problem, num_dimensions, num_samples);
prob.set_c(C);
prob.set_epsilon(eps);
prob.set_max_cache_size(max_cache_size);
if (be_verbose)
prob.be_verbose();
oca solver;
matrix<double,0,1> w;
if (learns_nonnegative_weights)
solver(prob, w, prob.get_num_dimensions());
else
solver(prob, w);
return w;
}
// ----------------------------------------------------------------------------------------
matrix<double,0,1> solve_structural_svm_problem(
py::object problem
)
{
// Check if the python code is using sparse or dense vectors to represent PSI()
if (py::isinstance<matrix<double,0,1>>(problem.attr("get_truth_joint_feature_vector")(0)))
return solve_structural_svm_problem_impl<matrix<double,0,1> >(problem);
else
return solve_structural_svm_problem_impl<std::vector<std::pair<unsigned long,double> > >(problem);
}
// ----------------------------------------------------------------------------------------
void bind_svm_struct(py::module& m)
{
m.def("solve_structural_svm_problem",solve_structural_svm_problem, py::arg("problem"),
"This function solves a structural SVM problem and returns the weight vector \n\
that defines the solution. See the example program python_examples/svm_struct.py \n\
for documentation about how to create a proper problem object. "
);
}
// ----------------------------------------------------------------------------------------
|