AdaBoostClassModel.h

Go to the documentation of this file.

#ifndef GRT_ADABOOST_CLASS_MODEL_HEADER
#define GRT_ADABOOST_CLASS_MODEL_HEADER

#include "WeakClassifiers/WeakClassifier.h"

GRT_BEGIN_NAMESPACE

class GRT_API AdaBoostClassModel{
 public:
 AdaBoostClassModel(){
 classLabel = 0;
 debugLog.setProceedingText("[DEBUG AdaBoostClassModel]");
 errorLog.setProceedingText("[ERROR AdaBoostClassModel]");
 warningLog.setProceedingText("[WARNING AdaBoostClassModel]");
 }
 ~AdaBoostClassModel(){
 clear();
 }
 
 AdaBoostClassModel(const AdaBoostClassModel &rhs){
 *this = rhs;
 }
 
 AdaBoostClassModel& operator=(const AdaBoostClassModel &rhs){
 if( this != &rhs ){
 clear();
 this->classLabel = rhs.classLabel;
 
 //We need to deep copy the weak classifiers
 for(UINT i=0; i<rhs.getNumWeakClassifiers(); i++){
 if( !addClassifierToCommitee(rhs.weakClassifiers[i], rhs.weights[i]) ){
 clear();
 errorLog << "operator= Failed to deep copy weak classifiers!" << std::endl;
 break;
 }
 }
 }
 return *this;
 }
 
 bool clear(){
 classLabel = 0;
 weights.clear();
 for(UINT i=0; i<weakClassifiers.size(); i++){
 if( weakClassifiers[i] != NULL ){
 delete weakClassifiers[i];
 weakClassifiers[i] = NULL;
 }
 }
 weakClassifiers.clear();
 return true;
 }
 
 bool setClassLabel(const UINT classLabel){
 this->classLabel = classLabel;
 return true;
 }
 
 bool addClassifierToCommitee(const WeakClassifier *weakClassifier,Float weight){
 if( weakClassifier == NULL ) return false;
 
 //Deep copy the weak classifier
 WeakClassifier *weakClassifierPtr = weakClassifier->createNewInstance();
 if( !weakClassifierPtr->deepCopyFrom( weakClassifier ) ){
 delete weakClassifierPtr;
 weakClassifierPtr = NULL;
 warningLog << "addClassifierToCommitee(...) Failed to add weak classifier to commitee!" << std::endl;
 return false;
 }
 weights.push_back( weight );
 weakClassifiers.push_back( weakClassifierPtr );
 
 return true;
 }
 
 Float predict(const VectorFloat &inputVector){
 Float v = 0;
 UINT N = (UINT)weakClassifiers.getSize();
 for(UINT i=0; i<N; i++){
 v += weakClassifiers[i]->predict( inputVector ) * weights[i];
 }
 //Return the value, rather than the sign of the value
 return v;
 }
 
 void print() const{
 std::cout << "ClassLabel: " << classLabel << std::endl;
 for(UINT i=0; i<weakClassifiers.getSize(); i++){
 std::cout << "Weight: " << weights[i] << std::endl;
 weakClassifiers[i]->print();
 }
 }
 
 UINT getClassLabel() const{
 return classLabel;
 }
 
 UINT getNumWeakClassifiers() const{
 return weakClassifiers.getSize();
 }
 
 Vector< WeakClassifier* > getWeakClassifiers() const{
 
 Vector< WeakClassifier* > classifiers;
 
 for(UINT i=0; i<getNumWeakClassifiers(); i++){
 
 //Deep copy the weak classifier
 WeakClassifier *weakClassifierPtr = weakClassifiers[i]->createNewInstance();
 if( !weakClassifierPtr->deepCopyFrom( weakClassifiers[i] ) ){
 return classifiers;
 }
 classifiers.push_back( weakClassifierPtr );
 }
 
 return classifiers;
 }
 
 template< class T > T* getWeakClassifier(const UINT &index){
 
 if( index >= weakClassifiers.getSize() ) return NULL;
 
 T temp;
 
 if( temp.getWeakClassifierType() == weakClassifiers[index]->getWeakClassifierType() ){
 return (T*)weakClassifiers[index];
 }
 return NULL;
 }
 
 VectorFloat getWeights() const{
 return weights;
 }
 
 bool save( std::fstream &file ) const{
 
 if(!file.is_open())
 {
 return false;
 }
 
 UINT N = getNumWeakClassifiers();
 
 //Write the Model info
 file << "ClassLabel: " << classLabel << std::endl;
 file << "NumWeakClassifiers: "<< getNumWeakClassifiers() << std::endl;
 file << "WeakClassifierTypes: " << std::endl;
 for(UINT i=0; i<N; i++){
 if( weakClassifiers[i] == NULL ) return false;
 file << weakClassifiers[i]->getWeakClassifierType() << std::endl;
 }
 
 file << "Weights: ";
 for(UINT i=0; i<N; i++){
 file << weights[i] << " ";
 }
 file << std::endl;
 
 file << "WeakClassifiers: " << std::endl;
 for(UINT i=0; i<N; i++){
 if( weakClassifiers[i] == NULL ) return false;
 if( !weakClassifiers[i]->saveModelToFile( file ) ) return false;
 }
 
 return true;
 }
 
 bool load( std::fstream &file ){
 
 //Clear any previous models
 clear();
 
 if(!file.is_open())
 {
 errorLog <<"load(fstream &file) - The file is not open!" << std::endl;
 return false;
 }
 
 std::string word;
 UINT numWeakClassifiers = 0;
 
 file >> word;
 if( word != "ClassLabel:" ){
 errorLog <<"load(fstream &file) - Failed to read ClassLabel header!" << std::endl;
 return false;
 }
 file >> classLabel;
 
 file >> word;
 if( word != "NumWeakClassifiers:" ){
 errorLog <<"load(fstream &file) - Failed to read NumWeakClassifiers header!" << std::endl;
 return false;
 }
 file >> numWeakClassifiers;
 
 file >> word;
 if( word != "WeakClassifierTypes:" ){
 errorLog <<"load(fstream &file) - Failed to read WeakClassifierTypes header!" << std::endl;
 return false;
 }
 
 //Load the weak classifier types and setup the weak classifiers
 if( numWeakClassifiers > 0 ){
 weights.resize( numWeakClassifiers, 0 );
 weakClassifiers.resize( numWeakClassifiers, NULL );
 
 for(UINT i=0; i<numWeakClassifiers; i++){
 file >> word;
 weakClassifiers[i] = WeakClassifier::createInstanceFromString(word);
 if( weakClassifiers[i] == NULL ){
 errorLog << "load(fstream &file) - WeakClassifier " << i << " is NULL!" << std::endl;
 return false;
 }
 }
 }
 
 //Load the Weights
 file >> word;
 if( word != "Weights:" ){
 errorLog <<"loadModelFromFile(fstream &file) - Failed to read Weights header!" << std::endl;
 return false;
 }
 for(UINT i=0; i<numWeakClassifiers; i++){
 file >> weights[i];
 }
 
 //Load the WeakClassifiers
 file >> word;
 if( word != "WeakClassifiers:" ){
 errorLog <<"loadModelFromFile(fstream &file) - Failed to read WeakClassifiers header!" << std::endl;
 errorLog << word << std::endl;
 return false;
 }
 for(UINT i=0; i<numWeakClassifiers; i++){
 if( !weakClassifiers[i]->loadModelFromFile( file ) ){
 errorLog <<"loadModelFromFile(fstream &file) - Failed to load weakClassifer: " << i << std::endl;
 return false;
 }
 }
 
 //We don't need to close the file as the function that called this function should handle that
 return true;
 }
 
 bool normalizeWeights(){
 if( weights.size() == 0 ) return false;
 Float sum = 0;
 UINT N = (UINT)weights.size();
 for(UINT i=0; i<N; i++){
 sum += weights[i];
 }
 for(UINT i=0; i<N; i++){
 weights[i] /= sum;
 }
 return true;
 }
 
 protected:
 UINT classLabel;
 VectorFloat weights;
 Vector< WeakClassifier* > weakClassifiers;
 
 DebugLog debugLog;
 WarningLog warningLog;
 ErrorLog errorLog;
 
};

GRT_END_NAMESPACE

#endif// GRT_ADABOOST_CLASS_MODEL_HEADER