AdaBoostTrainer.h

Go to the documentation of this file.

/* XBoost: Ada-Boost and Friends on Haar/ICF/HOG Features, Library and ToolBox
 *
 * Copyright (c) 2008-2014 Paolo Medici <medici@ce.unipr.it>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */

#ifndef _ADABOOST_TRAINER_H
#define _ADABOOST_TRAINER_H

#include "DataSet.h"
#include "Test.h"
#include "AdaBoost.h"
#include "Classifier/BoostClassifier.h"
#include "Classifier/BoostableClassifier.h"
#include "Pattern/Pattern.h"
#include "AdaBoostCommon.h"

#include <vector>
#include <cmath>
#include <algorithm>
#include <limits>

template<class Oracle>
class AdaBoostTrainer: public AdaBoost< typename Oracle::ClassifierType >, public Oracle {
public:

    typedef PatternAggregator<WeightedPattern< typename Oracle::DataType >, typename Oracle::ParamType>  AdaBoostPattern;
    
    typedef DataSetHandle<AdaBoostPattern> DataSetType;
    

    typedef typename Oracle::ClassifierType WeakClassifierType;

    typedef BoostClassifier<WeakClassifierType> ClassifierType;

    typedef typename ClassifierType::ClassifierListType ClassifierListType;

private:

    ClassifierType m_classifier;

    DataSetType  m_validation_set;

    bool m_useMAdaBoost;

public:
    AdaBoostTrainer() : m_useMAdaBoost(false) { }
    ~AdaBoostTrainer() { }

    void EnableMAdaBoost(bool mada)
    {
        m_useMAdaBoost = mada;
    }

    static std::string signature() {
        return ClassifierType::signature();
    }

    template<class SourceDataSetType>
    void SetValidationSet(const SourceDataSetType & set)
    {
        std::cout << "Update with: " << set.n_patternP << "(+), " << set.n_patternN << "(-)\n";

        m_validation_set = set;
        //std::cin.get();
    }

    const DataSetType & GetValidationSet() const {
        return m_validation_set;
    }


    void ResetValidationSet(double positive_weight = -1.0) // se e' random conviene iniziare con -1.0
    {
        ResetWeight(m_validation_set, positive_weight); 
    }

    void Restart(bool reOptimize);

    ClassifierType &Classifier() {
        return m_classifier;
    }

    const ClassifierType &Classifier() const {
        return m_classifier;
    }

    bool Train();

    bool Test();
    
    ReportTest TestAndExportStat(double th, int max_concurrent_jobs);
};




template<class Oracle>
bool AdaBoostTrainer<Oracle>::Test()
{
    std::cout << m_classifier.size() << " classifiers:\n";

    return ::Test( m_classifier, m_validation_set);
}
template<class Oracle>
ReportTest AdaBoostTrainer<Oracle>::TestAndExportStat(double th, int max_concurrent_jobs)
{
    std::cout << m_classifier.size() << " classifiers:\n";

    return ::TestAndExportStat( m_classifier, m_validation_set, th, max_concurrent_jobs);
}


template<class Oracle>
void AdaBoostTrainer<Oracle>::Restart(bool reOptimize)
{
    ClassifierListType & list =   m_classifier.list();
// for any Classifier call Post
    for(typename ClassifierListType::iterator i = list.begin(); i != list.end();)
    {
        if(reOptimize)
        {
            // reoptimize (using validation? training?)
            Oracle::Optimize(*i);
        }
        
        // TODO MAdaBoost is missing?

        // Update AdaBoost weights on training/validation set
        bool valid = this->Update(*i, Oracle::GetTrainingSet(), m_validation_set);

        if( !valid )
        {
            std::cout << "Bad classifier removed from list" << std::endl;
            i = list.erase(i);
        }
        else
        {
            ++i;
        }
    }

    Test(); // nono ?

}

template<class Oracle>
bool AdaBoostTrainer<Oracle>::Train()
{
    WeakClassifierType bestH;

    if(m_useMAdaBoost)
    {
      // TODO: probabilmente non funziona
      
        // Modify the "Traning Set" using MAdaBoost variant
        DataSetType & train = Oracle::GetTrainingSet();
        double d = 1.0/m_validation_set.Size(); // MAdaBoost threshold
        int n = 0;
        for(unsigned int i =0; i<train.Size(); i++)
            if( train.templates[i].d > d)
            {
                train.templates[i].d = d;
                ++n;
            }
        std::cout << "[+] MAdaBoost: " << n << " samples of " << train.Size() << " (" << (n*100)/train.Size() << "%) have been limited in weight (" << d <<")" << std::endl;
    }

// get the best Weak Classifier using AdaBoost* metric on Training Set
    if(!Oracle::GetHypothesis(bestH))
        return false;

    // Call AdaBoost Update on validation_set. Eventually improve bestH using validation set.
    // TODO: attenzione che se calcola alpha sul validation set, probabilmente si ottengono degli alpha negativi (anche in Madaboost)
    bool valid = this->Update(bestH, Oracle::GetTrainingSet(), m_validation_set);

    if(valid)
    {
        // store
        m_classifier.insert(bestH);
    }
    else
    {
        std::cout << "[WW] classifier skipped by update rule" << std::endl;
    }

    return true;
}

#endif