MAClassifier.hpp

/*
 *  This file is part of the AiBO+ project
 *
 *  Copyright (C) 2005-2016 Csaba Kertész (csaba.kertesz@gmail.com)
 *
 *  AiBO+ is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  AiBO+ 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 General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Street #330, Boston, MA 02111-1307, USA.
 *
 */

#pragma once

#include "MAClassifierTypes.hpp"

#include "core/MACoreTypes.hpp"

#include <MCTypes.hpp>

#include <boost/serialization/access.hpp>
#include <boost/serialization/split_member.hpp>
#include <boost/tuple/tuple.hpp>
#include <boost/scoped_ptr.hpp>
#include <boost/shared_ptr.hpp>

class CvANN_MLP;
class CvEmWrapper;
class CvNormalBayesClassifier;
class CvKNearest;
class CvSVM;
class CvSVMParams;
class CvDTree;
class CvDTreeParams;
class CvERTrees;
class CvGBTrees;
class DlibWrapper;
class GpWrapper;
class ME_Model;
class LWPR_Object;
class PLS_Model;
class MCBinaryData;
class MAClassifier;
class MAModel;
class MARandomTrees;

namespace MA
{
typedef boost::shared_ptr<MAClassifier> ClassifierSPtr;

/*
 * @brief Cross-validation results
 *
 * The first table list contains the confusion matrices of the testing results.
 * The second table list contains the confusion matrices of the validation results.
 * The third element is a list of sample ranking where higher value means better model
 * building capability.
 *
 */
typedef boost::tuple<MA::FloatTableList, MA::FloatTableList, MC::FloatList> CvResultsType;
}

class MAClassifier
{
  friend class boost::serialization::access;

  MC_DISABLE_COPY(MAClassifier)

  
  MAClassifier();

public:

  MAClassifier(MA::CRMethodType method, int label_count, bool regression = false);
  ~MAClassifier();

  bool IsValid() const;

  MA::CRMethodType GetMethodType() const;

  bool IsRegression() const;

  unsigned int GetFeatureVectorSize() const;

  MC::FloatTable& GetFeatureVectors();

  MC::FloatList& GetLabels();

  MC::FloatList GetModelLabels() const;

  void PrioritizeClasses(const MC::FloatList& labels);

  void Reset();

  void SetParameter(MA::CRMethodParamType method_parameter, float value);

  float GetParameter(MA::CRMethodParamType method_parameter);

  void SetPreprocessingMode(MA::FeaturePreprocessingType preprocessing_mode);

  void AddSamples(const MC::FloatTable& input_vectors, const MC::FloatList& labels);

  MC::FloatList Predict(const MC::FloatTable& input_vectors, MC::FloatList& confidences);

  float Predict(const MC::FloatList& input_vector, MC::FloatList& confidence);
private:
  float PredictReal(const MC::FloatList& input_vector, MC::FloatList& confidence);
  void Train();
public:

  MA::CvResultsType CrossValidate(int iterations, MA::ClassifierCrossValidationType cv_type,
                                  float cv_parameter, const MC::FloatTable& samples,
                                  const MC::FloatList& labels,
                                  const MC::FloatTable& validation_samples = MC::FloatTable(),
                                  const MC::FloatList& validation_labels = MC::FloatList(),
                                  float regression_accuracy = MCFloatInfinity());

  MCBinaryData* Encode() const;

  static MAClassifier* Decode(const MCBinaryData& data);

  MAModel* ExportModel() const;

private:

  void CreateClassifier();

  template<class Archive>
  void load(Archive& archive, const unsigned int version);
  template<class Archive>
  void save(Archive& archive, const unsigned int version) const;
  BOOST_SERIALIZATION_SPLIT_MEMBER();

  MA::CRMethodType Classifier;
  MA::FeaturePreprocessingType Preprocessing;
  bool Regression;
  bool Trained;
  unsigned int FeatureCount;
  unsigned int LabelCount;
  float SvmGamma;
  float SvmC;
  float SvmP;
  float SvmNu;
  bool SvmAutoTrain;
  float DlibEpsilon;
  float RvmSigmoidGamma;
  float RvmRbfGamma;
  float KrrGamma;
  float KrrLambda;
  float MeL1;
  float MeL2;
  float LwprAlpha;
  /*
   * Components parameter (partial least squares regression)
   * 0 is the default value which means autodetection
   */
  int PlsrComponents;
  float KrlsTolerance;
  float KrlsGamma;
  int TreeMaxDepth;
  // Tree node sample limit (decision/random trees)
  int TreeNodeSampleLimit;
  int RtMaxForestSize;
  boost::scoped_ptr<CvANN_MLP> NeuralNetwork;
  boost::scoped_ptr<CvNormalBayesClassifier> BayesClassifier;
  boost::scoped_ptr<CvKNearest> KNearestClassifier;
  boost::scoped_ptr<CvSVM> SvmClassifier;
  boost::scoped_ptr<CvSVMParams> SvmClassifierParams;
  boost::scoped_ptr<CvDTree> DecisionTree;
  boost::scoped_ptr<MARandomTrees> RandomTrees;
  boost::scoped_ptr<CvERTrees> ExtremeRandomTrees;
  boost::scoped_ptr<CvGBTrees> GradientBoostedTrees;
  boost::scoped_ptr<CvEmWrapper> EmClassifier;
  boost::scoped_ptr<DlibWrapper> DlibFunctions;
  boost::scoped_ptr<ME_Model> MaxEntropy;
  boost::scoped_ptr<LWPR_Object> Lwpr;
  boost::scoped_ptr<PLS_Model> Plsr;
  boost::scoped_ptr<GpWrapper> Gpr;
  MC::FloatTable CachedSamples;
  MC::FloatList CachedLabels;
  MA::FloatSet CachedUniqueLabels;
  MC::FloatTable PreprocessedData;
  MC::FloatList PrioritizedClasses;
  MC::FloatList PriorityLabels;
};