PndMvaDataSet.h

Go to the documentation of this file.

//****************************************************************************
//*                   This file is part of PandaRoot.                        *
//*                                                                          *
//*            PandaRoot is distributed under the terms of the               *
//*              GNU General Public License (GPL) version 3,                 *
//*                 copied verbatim in the file "LICENSE".                   *
//*                                                                          *
//*  Copyright (C) 2006 - 2024 FAIR GmbH and copyright holders of PandaRoot  *
//*     The copyright holders are listed in the file "COPYRIGHTHOLDERS".     *
//*               The authors are listed in the file "AUTHORS".              *
//****************************************************************************

/***************************************
 * 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