Logo ROOT   6.10/09
Reference Guide
MethodFisher.h
Go to the documentation of this file.
1 // @(#)root/tmva $Id$
2 // Author: Andreas Hoecker, Xavier Prudent, Joerg Stelzer, Helge Voss, Kai Voss
3 
4 /**********************************************************************************
5  * Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
6  * Package: TMVA *
7  * Class : MethodFisher *
8  * Web : http://tmva.sourceforge.net *
9  * *
10  * Description: *
11  * Analysis of Fisher discriminant (Fisher or Mahalanobis approach) *
12  * *
13  * Original author of this Fisher-Discriminant implementation: *
14  * Andre Gaidot, CEA-France; *
15  * (Translation from FORTRAN) *
16  * *
17  * Authors (alphabetical): *
18  * Andreas Hoecker <Andreas.Hocker@cern.ch> - CERN, Switzerland *
19  * Xavier Prudent <prudent@lapp.in2p3.fr> - LAPP, France *
20  * Helge Voss <Helge.Voss@cern.ch> - MPI-K Heidelberg, Germany *
21  * Kai Voss <Kai.Voss@cern.ch> - U. of Victoria, Canada *
22  * *
23  * Copyright (c) 2005: *
24  * CERN, Switzerland *
25  * U. of Victoria, Canada *
26  * MPI-K Heidelberg, Germany *
27  * LAPP, Annecy, France *
28  * *
29  * Redistribution and use in source and binary forms, with or without *
30  * modification, are permitted according to the terms listed in LICENSE *
31  * (http://tmva.sourceforge.net/LICENSE) *
32  **********************************************************************************/
33 
34 #ifndef ROOT_TMVA_MethodFisher
35 #define ROOT_TMVA_MethodFisher
36 
37 //////////////////////////////////////////////////////////////////////////
38 // //
39 // MethodFisher //
40 // //
41 // Analysis of Fisher discriminant (Fisher or Mahalanobis approach) //
42 // //
43 //////////////////////////////////////////////////////////////////////////
44 
45 #include <vector>
46 
47 #include "TMVA/MethodBase.h"
48 #include "TMatrixDfwd.h"
49 
50 class TH1D;
51 
52 namespace TMVA {
53 
54  class MethodFisher : public MethodBase {
55 
56  public:
57 
58  MethodFisher( const TString& jobName,
59  const TString& methodTitle,
60  DataSetInfo& dsi,
61  const TString& theOption = "Fisher");
62 
64  const TString& theWeightFile);
65 
66  virtual ~MethodFisher( void );
67 
68  virtual Bool_t HasAnalysisType( Types::EAnalysisType type, UInt_t numberClasses, UInt_t numberTargets );
69 
70 
71  // training method
72  void Train( void );
73 
75 
76  // write weights to stream
77  void AddWeightsXMLTo ( void* parent ) const;
78 
79  // read weights from stream
80  void ReadWeightsFromStream( std::istream & i );
81  void ReadWeightsFromXML ( void* wghtnode );
82 
83  // calculate the MVA value
84  Double_t GetMvaValue( Double_t* err = 0, Double_t* errUpper = 0 );
85 
88 
89  // ranking of input variables
90  const Ranking* CreateRanking();
91 
92  // nice output
93  void PrintCoefficients( void );
94 
95 
96  protected:
97 
98  // make ROOT-independent C++ class for classifier response (classifier-specific implementation)
99  void MakeClassSpecific( std::ostream&, const TString& ) const;
100 
101  // get help message text
102  void GetHelpMessage() const;
103 
104  private:
105 
106  // the option handling methods
107  void DeclareOptions();
108  void ProcessOptions();
109 
110  // Initialization and allocation of matrices
111  void InitMatrices( void );
112 
113  // get mean value of variables
114  void GetMean( void );
115 
116  // get matrix of covariance within class
117  void GetCov_WithinClass( void );
118 
119  // get matrix of covariance between class
120  void GetCov_BetweenClass( void );
121 
122  // and the full covariance matrix
123  void GetCov_Full( void );
124 
125  // get discriminating power
126  void GetDiscrimPower( void );
127 
128  // get Fisher coefficients
129  void GetFisherCoeff( void );
130 
131  // matrix of variables means: S, B, S+B vs. variables
133 
134  // method to be used
135  TString fTheMethod; // Fisher or Mahalanobis
136  EFisherMethod fFisherMethod; // Fisher or Mahalanobis
137 
138  // covariance matrices
139  TMatrixD *fBetw; // between-class matrix
140  TMatrixD *fWith; // within-class matrix
141  TMatrixD *fCov; // full covariance matrix
142 
143  // number of events (sumOfWeights)
144  Double_t fSumOfWeightsS; // sum-of-weights for signal training events
145  Double_t fSumOfWeightsB; // sum-of-weights for background training events
146 
147  std::vector<Double_t>* fDiscrimPow; // discriminating power
148  std::vector<Double_t>* fFisherCoeff; // Fisher coefficients
149  Double_t fF0; // offset
150 
151  // default initialisation called by all constructors
152  void Init( void );
153 
154  ClassDef(MethodFisher,0); // Analysis of Fisher discriminant (Fisher or Mahalanobis approach)
155  };
156 
157 } // namespace TMVA
158 
159 #endif // MethodFisher_H
void GetCov_BetweenClass(void)
the matrix of covariance &#39;between class&#39; reflects the dispersion of the events of a class relative to...
const Ranking * CreateRanking()
computes ranking of input variables
MethodFisher(const TString &jobName, const TString &methodTitle, DataSetInfo &dsi, const TString &theOption="Fisher")
standard constructor for the "Fisher"
void ReadWeightsFromStream(std::istream &i)
read Fisher coefficients from weight file
virtual ~MethodFisher(void)
destructor
void GetCov_Full(void)
compute full covariance matrix from sum of within and between matrices
void GetDiscrimPower(void)
computation of discrimination power indicator for each variable small values of "fWith" indicates lit...
virtual Bool_t HasAnalysisType(Types::EAnalysisType type, UInt_t numberClasses, UInt_t numberTargets)
Fisher can only handle classification with 2 classes.
EFisherMethod GetFisherMethod(void)
Definition: MethodFisher.h:87
Double_t fSumOfWeightsS
Definition: MethodFisher.h:144
EAnalysisType
Definition: Types.h:125
Virtual base Class for all MVA method.
Definition: MethodBase.h:106
void AddWeightsXMLTo(void *parent) const
create XML description of Fisher classifier
Basic string class.
Definition: TString.h:129
TMatrixD * fMeanMatx
Definition: MethodFisher.h:132
Ranking for variables in method (implementation)
Definition: Ranking.h:48
bool Bool_t
Definition: RtypesCore.h:59
std::vector< Double_t > * fFisherCoeff
Definition: MethodFisher.h:148
void GetHelpMessage() const
get help message text
#define ClassDef(name, id)
Definition: Rtypes.h:297
Double_t fSumOfWeightsB
Definition: MethodFisher.h:145
EFisherMethod fFisherMethod
Definition: MethodFisher.h:136
Class that contains all the data information.
Definition: DataSetInfo.h:60
Double_t GetMvaValue(Double_t *err=0, Double_t *errUpper=0)
returns the Fisher value (no fixed range)
void Train(void)
computation of Fisher coefficients by series of matrix operations
void ReadWeightsFromXML(void *wghtnode)
read Fisher coefficients from xml weight file
void ProcessOptions()
process user options
unsigned int UInt_t
Definition: RtypesCore.h:42
void InitMatrices(void)
initialization method; creates global matrices and vectors
tomato 1-D histogram with a double per channel (see TH1 documentation)}
Definition: TH1.h:594
void DeclareOptions()
MethodFisher options: format and syntax of option string: "type" where type is "Fisher" or "Mahalanob...
double Double_t
Definition: RtypesCore.h:55
void GetMean(void)
compute mean values of variables in each sample, and the overall means
void GetCov_WithinClass(void)
the matrix of covariance &#39;within class&#39; reflects the dispersion of the events relative to the center ...
int type
Definition: TGX11.cxx:120
void MakeClassSpecific(std::ostream &, const TString &) const
write Fisher-specific classifier response
Abstract ClassifierFactory template that handles arbitrary types.
void PrintCoefficients(void)
display Fisher coefficients and discriminating power for each variable check maximum length of variab...
Fisher and Mahalanobis Discriminants (Linear Discriminant Analysis)
Definition: MethodFisher.h:54
virtual void ReadWeightsFromStream(std::istream &)=0
void GetFisherCoeff(void)
Fisher = Sum { [coeff]*[variables] }.
std::vector< Double_t > * fDiscrimPow
Definition: MethodFisher.h:147
void Init(void)
default initialization called by all constructors