StRoot: StPmdDiscriminatorMaker/StPmdNeuNet.h Source File

00001 
00004 
00005 //
00006 //  Neural Network classes :
00007 //  TNNFormula
00008 //  TNNTree
00009 //  TNNKernel
00010 //  TNNControlE
00011 //  TNNUtils
00012 //                             J.P. Ernenwein (rnenwein@in2p3.fr)
00014 
00015 
00017 /*
00018 #ifndef ROOT_TNamed
00019 #include "TNamed.h"
00020 #endif
00021 #ifndef ROOT_TROOT
00022 #include "TROOT.h"
00023 #endif
00024 #ifndef ROOT_TTree
00025 #include "TTree.h"
00026 #endif
00027 #ifndef ROOT_TString
00028 #include "TString.h"
00029 #endif
00030 //#ifndef ROOT_TFormula
00031 //#include "TFormula.h"
00032 //#endif
00033 //#ifndef ROOT_TTreeFormula
00034 //#include "TTreeFormula.h"
00035 //#endif
00036 #ifndef ROOT_TCanvas
00037 #include "TCanvas.h"
00038 #endif
00039 */
00040 #include "TFrame.h"
00041 #include "TStringLong.h"
00042 #include "TFile.h"
00043 #include "TText.h"
00044 #include "TDatime.h"
00045 #include "TRandom.h"
00046 #include "TPad.h"
00047 #include "math.h"
00048 #include "stdlib.h"
00049 #include "Stiostream.h"
00050 #include "StPmdDiscriminatorMaker.h"
00051 
00053 
00054 class StPmdNeuNet : public TNamed
00055 {
00056 
00057 
00058  private:
00059   Int_t  fNHiddL;  // number of hidden layers
00060   Float_t **fValues;     
00061   Double_t **fErrors;    
00062   Double_t **fBiases;    
00063   Int_t *fNUnits;    
00064   Double_t ***fW;    
00065 
00066   Int_t  fNTrainEvents;  // number of events for training
00067   Int_t  fNValidEvents;  // number of events for validation
00068 //  TNNTree *fValidTree;   // validation tree
00069   Double_t fLearnParam;   // learning parameter
00070   Float_t fLowerInitWeight;  // minimum weight for initialisation
00071   Float_t fUpperInitWeight;  // maximum weight for initialisation
00072   Float_t **fArrayOut;  
00073   Float_t *fTeach; 
00074   Float_t **fArrayIn; 
00075   Int_t *fEventsList; 
00076   Int_t fNTrainCycles; // Number of training cycles done
00077   Double_t fUseBiases;  // flag for use of biases or not (1=use, 0=no use)
00078   TRandom fRandom; // Random object used in initialisation and mixing
00079   Int_t fNWeights; // number of weights in neural network
00080   Double_t fMu; // backpropagation momentum parameter
00081   Double_t fFlatSE; // Flat Spot elimination paramater
00082   Double_t ***fDW;  
00083   Double_t **fDB;   
00084 
00085 
00086   void GetArrayEvt(Int_t iEvent)
00087   {
00088     Int_t l;
00089     for(l=0;l<fNUnits[0];l++)fValues[0][l]=fArrayIn[iEvent][l];
00090     for(l=0;l<fNUnits[fNHiddL+1];l++)fTeach[l]=fArrayOut[iEvent][l];
00091   };
00092   void LearnBackward();   // gradient retropropagation (updates of biases and weights)
00093   void Forward(); // do a simple forward propagation
00094   Double_t Error();// compute the error between forward propagation and teaching
00095   Double_t ErrorO();// compute the error between forward propagation and teaching
00096   void Error(const char*, const char*, ...) const{}//WarnOff
00097   void FreeVW();
00098   void ZeroAll();
00099   void AllocateVW(Int_t nInput, const Text_t *hidden, Int_t nOutput);
00100   void SetHidden(const Text_t *ttext);
00101   Float_t Alea();
00102   void DeleteArray();
00103 
00104  protected:
00105   virtual Double_t Sigmoide(Double_t x)
00106   {
00107     if(x> 10.) return 0.99999; // probability MUST be < 1
00108     if(x<-10.) return 0.;
00109     return (1./(1.+exp(-x)));
00110   };
00111   virtual Double_t SigPrim(Double_t x){return (x*(1.-x));};
00112   StPmdDiscriminatorMaker * m_DiscMaker;
00113 
00114  public:
00115   StPmdNeuNet();
00116   StPmdNeuNet(const Text_t *name, Int_t nInput=5, const Text_t *hidden="6:7:8", Int_t nOutput=4);
00117   void setDiscMaker(StPmdDiscriminatorMaker*);
00118   virtual ~StPmdNeuNet(); // destructor
00119   virtual void SetKernel(Int_t nInput, const Text_t *hidden, Int_t nOutput);
00120   virtual void SetLearnParam(Double_t learnParam=0.2,Double_t fse=0.,Double_t mu=0.);
00121   virtual void SetInitParam(Float_t lowerInitWeight=-1., Float_t upperInitWeight=1.);
00122   virtual void Init();   // init biases and weights
00123   virtual void PrintS(); // print structure of network
00124   virtual void Mix();    // mix the events before learning
00125   virtual Double_t TrainOneCycle();  // one loop on internal events = one cycle
00126   virtual void ResetCycles(){fNTrainCycles=0;};
00127   virtual void Export(const Text_t *fileName="exportNN.dat");
00128   virtual void Import(const Text_t *fileName="exportNN.dat");
00129   virtual void SetUseBiases(Bool_t trueForUse=1){fUseBiases=(Double_t)trueForUse;};
00130   virtual void SetRandomSeed(UInt_t seed=0){fRandom.SetSeed(seed);};
00131   virtual UInt_t GetRandomSeed(){return fRandom.GetSeed();};
00132   virtual Bool_t IsTrained(){return fNTrainCycles;};
00133   virtual Int_t GetNTrainCycles(){return fNTrainCycles;};
00134   virtual Int_t GetNTrainEvents(){return fNTrainEvents;};
00135   virtual void SetNTrainEvents(Int_t nevt){fNTrainEvents = nevt;};
00136   virtual Int_t GetNValidEvents(){return fNValidEvents;};
00137   virtual void SetArraySize(Int_t s=0);
00138   virtual void FillArray(Int_t,Int_t,Float_t);
00139   virtual void Fill(Int_t iev=0)
00140   {
00141     Int_t i;
00142     for(i=0;i<fNUnits[0];i++)fArrayIn[iev][i]=fValues[0][i];
00143     for(i=0;i<fNUnits[fNHiddL+1];i++)fArrayOut[iev][i]=fTeach[i];
00144   }
00145   virtual Float_t* GetInputAdr(){return fValues[0];};
00146   virtual void     SetInput(Float_t v,Int_t i){fValues[0][i]=v;};
00147   virtual Int_t    GetNInput(){return fNUnits[0];};
00148   virtual Int_t    GetNOutput(){return fNUnits[fNHiddL+1];};
00149   virtual Float_t  GetOutput(Int_t unit=0){return fValues[fNHiddL+1][unit];};
00150   virtual Float_t* GetOutputAdr(){return fValues[fNHiddL+1];};
00151   virtual Float_t* GetTeachAdr(){return fTeach;};
00152   virtual void     SetTeach(Float_t v,Int_t i){fTeach[i]=v;};
00153   virtual void     fillArrayOut(Float_t v,Int_t i,Int_t l){fArrayOut[i][l]=v;};
00154   virtual Double_t  GoThrough(){Forward();return ErrorO();};
00155   virtual Float_t  GetSumO()
00156   {
00157     Int_t i; Float_t s=0.;
00158     for(i=0;i<fNUnits[fNHiddL+1];i++)s+=fValues[fNHiddL+1][i];
00159     return s;
00160   };
00161 
00162   void PrintTrain()
00163   {
00164           cout<<"Units** "<<fNUnits[fNHiddL+1]<<endl;
00165 
00166     Int_t l;
00167     for(l=0;l<fNUnits[fNHiddL+1];l++){
00168             cout<<"teach "<<fTeach[l]<<"Value "<<fValues[fNHiddL+1][l]<<endl;
00169     }
00170   }
00171 
00172   //  virtual void SetTrainTree(TNNTree *t);
00173 //  virtual void SetValidTree(TNNTree *t);
00174   virtual Double_t Valid();
00175 //  virtual void TrainNCycles(TNNControlE *conte, Int_t period=5, Int_t nCycles=10);
00176   virtual void TrainNCycles(Int_t nCycles=10);
00177   virtual Int_t GetNWeights()
00178   {
00179      if(!fNUnits)return 0;
00180      Int_t n=0;
00181      for(Int_t i=0;i<fNHiddL+1;i++)
00182      {
00183        n+=fNUnits[i]*fNUnits[i+1];
00184      }
00185      return n;
00186   };
00187 
00188   virtual Double_t ApplyWeights(Float_t*,Float_t*);  // one loop on internal events = one cycle
00189 
00190   ClassDef(StPmdNeuNet,1)
00191 
00192 };
00193 
00194 inline void StPmdNeuNet::setDiscMaker(StPmdDiscriminatorMaker* disc){m_DiscMaker=disc;}