dlib C++ Library - one_vs_all_trainer.h

    // 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_TRAiNER_Hh_
    #define DLIB_ONE_VS_ALL_TRAiNER_Hh_

    #include "one_vs_all_trainer_abstract.h"

    #include "one_vs_all_decision_function.h"
    #include <vector>

    #include "multiclass_tools.h"

    #include <sstream>
    #include <iostream>

    #include "../any.h"
    #include <map>
    #include <set>
    #include "../threads.h"

    namespace dlib
    {

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

        template <
            typename any_trainer,
            typename label_type_ = double
            >
        class one_vs_all_trainer
        {
        public:
            typedef label_type_ label_type;

            typedef typename any_trainer::sample_type sample_type;
            typedef typename any_trainer::scalar_type scalar_type;
            typedef typename any_trainer::mem_manager_type mem_manager_type;

            typedef one_vs_all_decision_function<one_vs_all_trainer> trained_function_type;

            one_vs_all_trainer (
            ) :
                verbose(false),
                num_threads(4)
            {}

            void set_trainer (
                const any_trainer& trainer
            )
            {
                default_trainer = trainer;
                trainers.clear();
            }

            void set_trainer (
                const any_trainer& trainer,
                const label_type& l
            )
            {
                trainers[l] = trainer;
            }

            void be_verbose (
            )
            {
                verbose = true;
            }

            void be_quiet (
            )
            {
                verbose = false;
            }

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

            unsigned long get_num_threads (
            ) const
            {
                return num_threads;
            }

            struct invalid_label : public dlib::error
            {
                invalid_label(const std::string& msg, const label_type& l_
                    ) : dlib::error(msg), l(l_) {};

                virtual ~invalid_label(
                ) throw() {}

                label_type l;
            };

            trained_function_type train (
                const std::vector<sample_type>& all_samples,
                const std::vector<label_type>& all_labels
            ) const
            {
                // make sure requires clause is not broken
                DLIB_ASSERT(is_learning_problem(all_samples,all_labels),
                    "\t trained_function_type one_vs_all_trainer::train(all_samples,all_labels)"
                    << "\n\t invalid inputs were given to this function"
                    << "\n\t all_samples.size():     " << all_samples.size()
                    << "\n\t all_labels.size():      " << all_labels.size()
                    );

                const std::vector<label_type> distinct_labels = select_all_distinct_labels(all_labels);

                // make sure we have a trainer object for each of the label types.
                for (unsigned long i = 0; i < distinct_labels.size(); ++i)
                {
                    const label_type l = distinct_labels[i];
                    const typename binary_function_table::const_iterator itr = trainers.find(l);

                    if (itr == trainers.end() && default_trainer.is_empty())
                    {
                        std::ostringstream sout;
                        sout << "In one_vs_all_trainer, no trainer registered for the " << l << " label.";
                        throw invalid_label(sout.str(), l);
                    }
                }

                // now do the training
                parallel_for_helper helper(all_samples,all_labels,default_trainer,trainers,verbose,distinct_labels);
                parallel_for(num_threads, 0, distinct_labels.size(), helper, 500);

                if (helper.error_message.size() != 0)
                {
                    throw dlib::error("binary trainer threw while training one vs. all classifier.  Error was: " + helper.error_message);
                }
                return trained_function_type(helper.dfs);
            }

        private:

            typedef std::map<label_type, any_trainer> binary_function_table;
            struct parallel_for_helper
            {
                parallel_for_helper(
                    const std::vector<sample_type>& all_samples_,
                    const std::vector<label_type>& all_labels_,
                    const any_trainer& default_trainer_,
                    const binary_function_table& trainers_,
                    const bool verbose_,
                    const std::vector<label_type>& distinct_labels_
                ) :
                    all_samples(all_samples_),
                    all_labels(all_labels_),
                    default_trainer(default_trainer_),
                    trainers(trainers_),
                    verbose(verbose_),
                    distinct_labels(distinct_labels_)
                {}

                void operator()(long i) const
                {
                    try
                    {
                        std::vector<scalar_type> labels;

                        const label_type l = distinct_labels[i];

                        // setup one of the one vs all training sets
                        for (unsigned long k = 0; k < all_samples.size(); ++k)
                        {
                            if (all_labels[k] == l)
                                labels.push_back(+1);
                            else
                                labels.push_back(-1);
                        }

                        if (verbose)
                        {
                            auto_mutex lock(class_mutex);
                            std::cout << "Training classifier for " << l << " vs. all" << std::endl;
                        }

                        any_trainer trainer;
                        // now train a binary classifier using the samples we selected
                        { auto_mutex lock(class_mutex);
                        const typename binary_function_table::const_iterator itr = trainers.find(l);
                        if (itr != trainers.end())
                            trainer = itr->second;
                        else
                            trainer = default_trainer;
                        }

                        any_decision_function<sample_type,scalar_type> binary_df = trainer.train(all_samples, labels);

                        auto_mutex lock(class_mutex);
                        dfs[l] = binary_df;
                    }
                    catch (std::exception& e)
                    {
                        auto_mutex lock(class_mutex);
                        error_message = e.what();
                    }
                }

                mutable typename trained_function_type::binary_function_table dfs;
                mutex class_mutex;
                mutable std::string error_message;

                const std::vector<sample_type>& all_samples;
                const std::vector<label_type>& all_labels;
                const any_trainer& default_trainer;
                const binary_function_table& trainers;
                const bool verbose;
                const std::vector<label_type>& distinct_labels;
            };

            any_trainer default_trainer;

            binary_function_table trainers;

            bool verbose;
            unsigned long num_threads;

        };

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

    }

    #endif // DLIB_ONE_VS_ALL_TRAiNER_Hh_