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