dlib C++ Library - structural_graph_labeling_trainer.h

    // Copyright (C) 2012  Davis E. King (davis@dlib.net)
    // License: Boost Software License   See LICENSE.txt for the full license.
    #ifndef DLIB_STRUCTURAL_GRAPH_LABELING_tRAINER_Hh_
    #define DLIB_STRUCTURAL_GRAPH_LABELING_tRAINER_Hh_

    #include "structural_graph_labeling_trainer_abstract.h"
    #include "../algs.h"
    #include "../optimization.h"
    #include "structural_svm_graph_labeling_problem.h"
    #include "../graph_cuts/graph_labeler.h"

    namespace dlib
    {

    // ----------------------------------------------------------------------------------------

        template <
            typename vector_type
            >
        class structural_graph_labeling_trainer
        {
        public:
            typedef std::vector<bool> label_type;
            typedef graph_labeler<vector_type> trained_function_type;

            structural_graph_labeling_trainer (
            )
            {
                C = 10;
                verbose = false;
                eps = 0.1;
                num_threads = 2;
                max_cache_size = 5;
                loss_pos = 1.0;
                loss_neg = 1.0;
            }

            void set_num_threads (
                unsigned long num
            )
            {
                num_threads = num;
            }

            unsigned long get_num_threads (
            ) const
            {
                return num_threads;
            }

            void set_epsilon (
                double eps_
            )
            {
                // make sure requires clause is not broken
                DLIB_ASSERT(eps_ > 0,
                    "\t void structural_graph_labeling_trainer::set_epsilon()"
                    << "\n\t eps_ must be greater than 0"
                    << "\n\t eps_: " << eps_
                    << "\n\t this: " << this
                    );

                eps = eps_;
            }

            double get_epsilon (
            ) const { return eps; }

            void set_max_cache_size (
                unsigned long max_size
            )
            {
                max_cache_size = max_size;
            }

            unsigned long get_max_cache_size (
            ) const
            {
                return max_cache_size;
            }

            void be_verbose (
            )
            {
                verbose = true;
            }

            void be_quiet (
            )
            {
                verbose = false;
            }

            void set_oca (
                const oca& item
            )
            {
                solver = item;
            }

            const oca get_oca (
            ) const
            {
                return solver;
            }

            void set_c (
                double C_
            )
            {
                // make sure requires clause is not broken
                DLIB_ASSERT(C_ > 0,
                    "\t void structural_graph_labeling_trainer::set_c()"
                    << "\n\t C_ must be greater than 0"
                    << "\n\t C_:    " << C_
                    << "\n\t this: " << this
                    );

                C = C_;
            }

            double get_c (
            ) const
            {
                return C;
            }

            void set_loss_on_positive_class (
                double loss
            )
            {
                // make sure requires clause is not broken
                DLIB_ASSERT(loss >= 0,
                        "\t structural_graph_labeling_trainer::set_loss_on_positive_class()"
                        << "\n\t Invalid inputs were given to this function."
                        << "\n\t loss: " << loss
                        << "\n\t this: " << this );

                loss_pos = loss;
            }

            void set_loss_on_negative_class (
                double loss
            )
            {
                // make sure requires clause is not broken
                DLIB_ASSERT(loss >= 0,
                        "\t structural_graph_labeling_trainer::set_loss_on_negative_class()"
                        << "\n\t Invalid inputs were given to this function."
                        << "\n\t loss: " << loss
                        << "\n\t this: " << this );

                loss_neg = loss;
            }

            double get_loss_on_negative_class (
            ) const { return loss_neg; }

            double get_loss_on_positive_class (
            ) const { return loss_pos; }

            template <
                typename graph_type
                >
            const graph_labeler<vector_type> train (
                const dlib::array<graph_type>& samples,
                const std::vector<label_type>& labels,
                const std::vector<std::vector<double> >& losses
            ) const
            {
    #ifdef ENABLE_ASSERTS
                std::string reason_for_failure;
                DLIB_ASSERT(is_graph_labeling_problem(samples, labels, reason_for_failure) == true ,
                        "\t void structural_graph_labeling_trainer::train()"
                        << "\n\t Invalid inputs were given to this function."
                        << "\n\t reason_for_failure: " << reason_for_failure
                        << "\n\t samples.size(): " << samples.size()
                        << "\n\t labels.size():  " << labels.size()
                        << "\n\t this: " << this );
                DLIB_ASSERT((losses.size() == 0 || sizes_match(labels, losses) == true) &&
                            all_values_are_nonnegative(losses) == true,
                        "\t void structural_graph_labeling_trainer::train()"
                        << "\n\t Invalid inputs were given to this function."
                        << "\n\t labels.size():  " << labels.size()
                        << "\n\t losses.size():  " << losses.size()
                        << "\n\t sizes_match(labels,losses): " << sizes_match(labels,losses)
                        << "\n\t all_values_are_nonnegative(losses): " << all_values_are_nonnegative(losses)
                        << "\n\t this: " << this );
    #endif

                structural_svm_graph_labeling_problem<graph_type> prob(samples, labels, losses, num_threads);

                if (verbose)
                    prob.be_verbose();

                prob.set_c(C);
                prob.set_epsilon(eps);
                prob.set_max_cache_size(max_cache_size);
                if (prob.get_losses().size() == 0)
                {
                    prob.set_loss_on_positive_class(loss_pos);
                    prob.set_loss_on_negative_class(loss_neg);
                }

                matrix<double,0,1> w;
                solver(prob, w, prob.get_num_edge_weights());

                vector_type edge_weights;
                vector_type node_weights;
                populate_weights(w, edge_weights, node_weights, prob.get_num_edge_weights());
                return graph_labeler<vector_type>(edge_weights, node_weights);
            }

            template <
                typename graph_type
                >
            const graph_labeler<vector_type> train (
                const dlib::array<graph_type>& samples,
                const std::vector<label_type>& labels
            ) const
            {
                std::vector<std::vector<double> > losses;
                return train(samples, labels, losses);
            }

        private:

            template <typename T>
            typename enable_if<is_matrix<T> >::type populate_weights (
                const matrix<double,0,1>& w,
                T& edge_weights,
                T& node_weights,
                long split_idx
            ) const
            {
                edge_weights = rowm(w,range(0, split_idx-1));
                node_weights = rowm(w,range(split_idx,w.size()-1));
            }

            template <typename T>
            typename disable_if<is_matrix<T> >::type populate_weights (
                const matrix<double,0,1>& w,
                T& edge_weights,
                T& node_weights,
                long split_idx
            ) const
            {
                edge_weights.clear();
                node_weights.clear();
                for (long i = 0; i < split_idx; ++i)
                {
                    if (w(i) != 0)
                        edge_weights.insert(edge_weights.end(), std::make_pair(i,w(i)));
                }
                for (long i = split_idx; i < w.size(); ++i)
                {
                    if (w(i) != 0)
                        node_weights.insert(node_weights.end(), std::make_pair(i-split_idx,w(i)));
                }
            }

            double C;
            oca solver;
            double eps;
            bool verbose;
            unsigned long num_threads;
            unsigned long max_cache_size;
            double loss_pos;
            double loss_neg;
        };

    // ----------------------------------------------------------------------------------------

    }

    #endif // DLIB_STRUCTURAL_GRAPH_LABELING_tRAINER_Hh_