PndMvaDataSet.h

Go to the documentation of this file.

/***************************************
 * Class interface of DataSet class.   *
 * Author: M.Babai (M.Babai@rug.nl)    *
 * License:                            *
 * Version:                            *
 ***************************************/
//#pragma once
#ifndef PND_MVA_DATASET_H
#define PND_MVA_DATASET_H

// C++ includes
#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <algorithm>
#include <cmath>
#include <cassert>
#include <limits>
#include <typeinfo>
#include <exception>
#include <utility>

// ROOT
#include "TFile.h"
#include "TTree.h"
#include "TRandom3.h"

// Local includes
#include "PndMvaClass.h"
#include "PndMvaVariable.h"
#include "PndMvaVarPCATransform.h"

// ========================================================================
// Application type
typedef enum AppType{
  UNKAPP        = 0,
  TRAIN         = 1, // Training algorithm.
  CLASSIFY      = 2, // Read weights to do classification.
  TMVATRAIN     = 10,// Provide input for TMVA Training.
  TMVACLS       = 20,// TMVA classification.
  PRE_INIT_EVTS = 30 // Pre-initialized event data.
} AppType;

// Normalization schemes
typedef enum NormType{
  NONORM  = 0, // Do nothing
  VARX    = 1, // Use Sample variance
  MINMAX  = 2, // Use Sample Min and Max
  MEDIAN  = 3, // Use median and interquartile range (IQR).
  VARNORM = 4 // Variable Normalize Transform
} NormType;


class PndMvaDataSetException: public std::exception
{
 public:
 explicit PndMvaDataSetException()
   : m_message("UNKNOWN_MvaDataSetException")
    {};
  
  explicit PndMvaDataSetException(std::string const& val)
    : m_message(val)
  {};
  
  virtual ~PndMvaDataSetException() throw()
    {};
  
  virtual char const* what() const throw()
  {
    return m_message.c_str();
  };
  
  virtual std::string const& what()
  {
    return m_message;
  };
  
 private:
  std::string m_message;
};

// ==================== Data set class ==========================
class PndMvaDataSet
{
 public:

  explicit PndMvaDataSet( std::vector< std::pair<std::string, std::vector<float>*> > const& InputEvtsParam,
                          std::vector<std::string> const& classNames,
                          std::vector<std::string> const& varNames,
                          AppType type);
  explicit PndMvaDataSet( std::string const& WeightFile,
                          std::vector<std::string> const& classNames,
                          std::vector<std::string> const& varNames,
                          AppType type);
  
  virtual ~PndMvaDataSet();
  
  //void WriteDataSet(std::string const& outFile) __attribute__ ((deprecated));
  virtual void WriteDataSet(std::string const& outFile);

  virtual void InitClsCondMeans(std::set <size_t> const& excludeIndxs);

  inline void SetTrim(bool t);

  inline std::vector< std::pair<std::string, std::vector<float>* > > const& GetData() const;

  inline std::vector<PndMvaClass> const& GetClasses() const;
  
  inline std::vector<PndMvaVariable> const& GetVars() const;
  
  inline std::map< std::string, std::vector<float>* > const& GetClassCondMeans() const;
  
  inline std::string const& GetInFileName() const;

  //========================= PCA =====================//
  virtual void PCATransForm();

  inline bool Used_PCA() const;

  inline void Use_PCA(bool t);
  
  inline PndMvaVarPCATransform const& Get_PCA() const;

  //_________________________ PCA _____________________//

  inline NormType GetNormType() const;
  
  inline void SetNormType(NormType t);

  inline AppType GetAppType () const;

  inline void SetAppType(AppType t);

  virtual void Initialize();

  inline size_t GetRndSeed()const;
  inline void SetRndSeed(size_t const sd);

  //______________________________________________________________
 protected:
  void ReadInput();
  
  void ReadWeightsFromFile();

  //==============================================================
 private:
  // Private to avoid mistakes.
  PndMvaDataSet(PndMvaDataSet const& other);
  PndMvaDataSet& operator=(PndMvaDataSet const& other);

  void Trim();

  void NormalizeDataSet();
  
  void InitClasses(std::vector<std::string> const& labels);
  
  void InitVariables(std::vector<std::string> const& variables);
  
  // Validate the input file
  void ValidateWeightFile();

  void CompClsCondMean( std::string const& clsName, std::set <size_t> const& exCluds );
  
  void ComputeVariance();
  
  void DetermineMedian();
  
  void MinMaxDiff();
  
  void FindMinMax();

  void VarNormalize();

  // __________________________ Member parameters ___________
  std::string m_input;
  
  std::vector<PndMvaClass> m_classes;
  
  std::vector<PndMvaVariable> m_vars;
  
  std::vector< std::pair<std::string, std::vector<float>*> > m_events;
  
  std::map< std::string, std::vector<float>* > m_ClassCondMeans;
  
  // PCA transformation.
  PndMvaVarPCATransform m_PCA;
  
  // If PCA was applied.
  bool m_UsePCA;

  // Normalization scheme
  NormType m_NormType;

  // Application type.
  AppType  m_AppType;
  bool m_trim;
  size_t m_RND_seed;
};
// End of class interface definition.

// ============= Inline implementation ==================

inline size_t PndMvaDataSet::GetRndSeed()const
{
  return this->m_RND_seed;
};

inline void PndMvaDataSet::SetRndSeed(size_t const sd)
{
  this->m_RND_seed = sd;
};

inline std::vector< std::pair<std::string, std::vector<float>*> > const& PndMvaDataSet::GetData() const
{
  assert(m_events.size() !=  0);
  return m_events;
};

inline std::vector<PndMvaClass> const& PndMvaDataSet::GetClasses() const
{
  return m_classes;
};

inline std::vector<PndMvaVariable> const& PndMvaDataSet::GetVars() const
{
  return m_vars;
};

inline std::map< std::string, std::vector<float>* > const& PndMvaDataSet::GetClassCondMeans() const
{
  return m_ClassCondMeans;
};

inline std::string const& PndMvaDataSet::GetInFileName() const
{
  return m_input;
};

inline bool PndMvaDataSet::Used_PCA() const
{
  return m_UsePCA;
};
inline void PndMvaDataSet::Use_PCA(bool t)
{
  m_UsePCA = t;
};
inline PndMvaVarPCATransform const& PndMvaDataSet::Get_PCA() const
{
  return m_PCA;
};
inline NormType PndMvaDataSet::GetNormType() const
{
  return m_NormType;
};
inline void PndMvaDataSet::SetNormType(NormType t)
{
  m_NormType = t;
};
inline AppType PndMvaDataSet::GetAppType() const
{
  return m_AppType;
};
inline void PndMvaDataSet::SetAppType(AppType t)
{
  m_AppType = t;
};
inline void PndMvaDataSet::SetTrim(bool t)
{
  m_trim = t;
};
#endif