PndLVQTrain.h

Go to the documentation of this file.

/* ***************************************
 * LVQ  Training functions               *
 * Author: M.Babai@rug.nl                *
 * Version:                              *
 * LICENSE:                              *
 * ***************************************
 */
//#pragma once
#ifndef PND_LVQ_TRAIN_H
#define PND_LVQ_TRAIN_H

#ifdef _OPENMP
#include <omp.h>
#endif

//Local includes
#include "PndMvaTrainer.h"
#include "PndMvaCluster.h"

// ____ Local CPP definitions _________
#define DEBUG_LVQ_TRAIN 0
// ____________________________________

typedef enum ProtoInitType{
  RAND_FROM_DATA = 0,  // Select randomly from data vector.
  CCM_PR         = 1,  // Random init around Class Conditional Mean.
  KMEANS_PR      = 10, // Init using K-Means clustering.
  FILE_PR        = 20  // Read pre-init from file.
} ProtoInitType;

class PndLVQTrain: public PndMvaTrainer
{
  //----------------------------------------
  //================== public ==============
 public:

  explicit PndLVQTrain(std::vector< std::pair<std::string, std::vector<float>* > > const& InputEvtsParam,
                       std::vector<std::string> const& ClassNames, 
                       std::vector<std::string> const& VarNames,
                       bool trim = false);
  explicit PndLVQTrain(std::string const& InPut,
                       std::vector<std::string> const& ClassNames, 
                       std::vector<std::string> const& VarNames,
                       bool trim = true);
  virtual ~PndLVQTrain();
  
  void storeWeights();

  void Train();
  
  void Train21();

  inline void setProtoInitType(ProtoInitType iniTypeVal = RAND_FROM_DATA);

  inline void SetInitProtoFileName(std::string const& fileName);

  inline void SetLearnPrameters(double const initConst, double const etZ,
                                double const etF, unsigned int const Nswp);

  void SetNumberOfProto(size_t const numProto);
  
  void SetNumberOfProto(std::map<std::string, size_t> const& labelMap);
  
  inline void SetErrorStepSize(unsigned int const val = 1000);

  inline void SetLVQ2_1WindowSize(float const Wsize = 0.3);

  void EvalClassifierError();

  inline void SetPerEpochEval(bool val);

  inline bool GetPerEpochEval() const;

#if DEBUG_LVQ_TRAIN == 1
  inline std::vector< std::pair<std::string, std::vector<float>*> > const& train1sec()
  {
    InitProtoK_Means();
    return m_LVQProtos;
  };
  
  inline std::vector< std::pair<std::string, std::vector<float>*> > const& train2sec()
  {
    InitProtoRand();
    return m_LVQProtos;
  };
  
  float EvalClassifierError(std::vector< std::pair< std::string, std::vector<float>* > > const& TestEvts) const;
#endif
  
  //----------------------------------------
  // protected:
  //================== private =============
 private:
  // To avoid mistakes, :).
  PndLVQTrain(PndLVQTrain const& other);
  PndLVQTrain& operator=(PndLVQTrain const& other);
  
  void EvalClassifierError(unsigned int stp);

  void InitProtoRand();

  void InitRandProtoFromData();

  void InitProtoK_Means();

  void InitProtoTypes();
  
  void cleanProtoList();

  void UpdateProto(std::vector<float> const& EvtData,
                   std::vector<float>& proto,
                   int const delta, double const ethaT);

  void ValidateProtoUpdate(std::vector<float>& p);

  void ReadProtoFromFile();
  //=====================================

  std::vector< std::pair<std::string, std::vector<float>*> > m_LVQProtos;

  std::vector <PndMvaDistObj> m_distances;
  
  double m_initConst; 
  double m_ethaZero; 
  double m_ethaFinal;
  float  m_WindowSize;

  unsigned int m_NumSweep;

  ProtoInitType m_proto_init;

  std::string m_initProtoFile;

  unsigned int m_ErrorStep;
  unsigned int m_ProgStep;
  
  std::map < std::string, size_t> m_numProtoPerClass;

  bool m_PerEpoch;
};
//END Interface definition

//_______________________ Inline functions _________________________
inline void PndLVQTrain::setProtoInitType(ProtoInitType iniTypeVal)
{
  m_proto_init = iniTypeVal;
};

inline void PndLVQTrain::SetInitProtoFileName(std::string const& fileName)
{
  m_initProtoFile = fileName;
};

inline void PndLVQTrain::SetLearnPrameters(double const initConst, double const etZ,
                                           double const etF, unsigned int const Nswp)
{
  m_initConst = initConst;
  m_ethaZero = etZ;
  m_ethaFinal = etF;
  m_NumSweep = Nswp;
};

inline void PndLVQTrain::SetErrorStepSize(unsigned int const val)
{
  m_ErrorStep = val;
};

inline void PndLVQTrain::SetLVQ2_1WindowSize(float const Wsize)
{
  m_WindowSize = Wsize;
};

inline void PndLVQTrain::SetPerEpochEval(bool val)
{
  m_PerEpoch = val;
};

inline bool PndLVQTrain::GetPerEpochEval() const
{
  return m_PerEpoch;
};
#endif// End of interface definition