StRoot: StPmdDiscriminatorMaker/StPmdNeuNet.cxx Source File

00001 
00002 
00003 #include "StPmdNeuNet.h"
00004 #include<StMessMgr.h>
00005 
00006 //  StPmdNeuNet 
00007 //  Feed-Forward Neural Network 
00008 //
00010 ClassImp(StPmdNeuNet)
00011 
00012 Float_t Teach[200000]={0.};
00013 Float_t Value[200000]={0.};
00014 
00015 
00017 StPmdNeuNet::StPmdNeuNet(const Text_t *name, Int_t nInput, const Text_t *hidden, Int_t nOutput):TNamed(name,"Neural Network")
00018 {
00019   ZeroAll();
00020   AllocateVW(nInput,hidden,nOutput);
00021     
00022   fUseBiases=1.;
00023   fLearnParam=0.2;
00024   fFlatSE=0.;
00025   fMu=0.;
00026   fLowerInitWeight=-1.;
00027   fUpperInitWeight=1.;
00028 
00029   fNTrainEvents=10;   //default value was 0
00030 
00031   fNTrainCycles=100;  //default value was 0
00032 
00033   TDatime temps;
00034   fRandom.SetSeed(temps.Convert());
00035   gMessMgr->Info()<<"StPmdNeuNet::StPmdNeuNet: First Random Seed = "<<fRandom.GetSeed();
00036   gMessMgr->Info()<<"StPmdNeuNet::StPmdNeuNet: Neural Network is created";
00037 
00038 }
00039 
00040 
00042 StPmdNeuNet::StPmdNeuNet()
00043 {
00044   ZeroAll();
00045   fUseBiases=1.;
00046   fLearnParam=0.2;
00047   fFlatSE=0.;
00048   fMu=0.;
00049   fLowerInitWeight=-1.;
00050   fUpperInitWeight=1.;
00051   fNHiddL=0;
00052 
00053   fNTrainEvents=10;
00054   fNTrainCycles=100;
00055 
00056   TDatime temps;
00057   fRandom.SetSeed(temps.Convert());
00058   gMessMgr->Info()<<"StPmdNeuNet::StPmdNeuNet: First Random Seed = "<<fRandom.GetSeed();
00059 }
00060 
00061 
00062 
00063 // Destructor
00064 StPmdNeuNet::~StPmdNeuNet() 
00065 {
00066   // destructor  
00067   gMessMgr->Info()<<"StPmdNeuNet::~StPmdNeuNet : we are done ";
00068   DeleteArray(); 
00069   FreeVW();
00070   if(fEventsList) delete [] fEventsList;
00071 }  
00072 
00073 
00075 void StPmdNeuNet::ZeroAll()
00076 {
00077   fValues     = 0;
00078   fErrors     = 0;
00079   fBiases     = 0;
00080   fNUnits     = 0;
00081   fW          = 0;
00082 
00083   fArrayIn    = 0;
00084   fArrayOut   = 0;
00085   fTeach      = 0;
00086   fEventsList = 0;
00087 
00088   fDW         = 0;
00089   fDB         = 0;
00090 
00091 }
00092 
00093 
00094 void StPmdNeuNet::SetHidden(const Text_t *ttext)
00095 {
00096   Int_t i,j;
00097   TString *number;
00098   Text_t text[100];
00099   strcpy(text,ttext);
00100 
00101   fNHiddL=1;
00102   for (i=0;text[i];i++)if(text[i]==':')fNHiddL++;
00103   if (fNUnits) delete [] fNUnits;
00104   fNUnits = new Int_t[fNHiddL+2];
00105 
00106   j=0;
00107   for (i=1;i<=fNHiddL;i++)
00108   {
00109     number=new TString();
00110     while(text[j]&&(text[j]!=':')){number->Append(text[j]);j++;}
00111     j++;
00112     sscanf(number->Data(),"%i",&fNUnits[i]);  
00113     delete number;
00114 //    printf("%i \n",fNUnits[i]); 
00115   }
00116 
00117 }
00118 
00119 
00120 void StPmdNeuNet::FreeVW()
00121 {
00122   Int_t i,l;
00123 
00124   // free of values
00125   
00126   if (fValues)
00127   {
00128     for (i=0;i<fNHiddL+2;i++)
00129       {delete [] fValues[i]; delete [] fErrors[i]; delete [] fBiases[i];delete [] fDB[i];} 
00130     delete [] fValues; delete [] fErrors; delete [] fBiases;delete [] fDB;
00131     fValues=0;
00132   }
00133   
00134   // free of teaching
00135   
00136   if (fTeach) 
00137   {
00138     delete [] fTeach;
00139     fTeach=0;
00140   }
00141   
00142   // free of weights
00143   
00144   if (fW)
00145   {
00146     for (i=0;i<fNHiddL+1;i++)
00147     {
00148       for(l=0;l<fNUnits[i];l++){delete [] fW[i][l];delete [] fDW[i][l];}  
00149       delete [] fW[i];delete [] fDW[i];
00150     }    
00151     fW=0;
00152   }
00153   
00154   // free of units
00155   
00156   if (fNUnits){ delete [] fNUnits; fNUnits=0;}
00157 }
00158 
00159 void StPmdNeuNet::AllocateVW(Int_t nInput, const Text_t *hidden, Int_t nOutput)
00160 {
00161   Int_t i,l;
00162   
00163   if(fW){
00164     gMessMgr->Info()<<"StPmdNeuNet::AllocateVW: free memory first ";
00165     return;
00166   }
00167 
00168   SetHidden(hidden);
00169   fNUnits[0]=nInput;
00170   fNUnits[fNHiddL+1]=nOutput;
00171   
00172   // allocation of values
00173   
00174   fValues = new Float_t*[fNHiddL+2];
00175   fErrors = new Double_t*[fNHiddL+2];
00176   fBiases = new Double_t*[fNHiddL+2];
00177   fDB = new Double_t*[fNHiddL+2];
00178 
00179   for (i=0;i<fNHiddL+2;i++)
00180   {
00181     fValues[i]=new Float_t[fNUnits[i]]; 
00182     fErrors[i]=new Double_t[fNUnits[i]]; 
00183     fBiases[i]=new Double_t[fNUnits[i]]; 
00184     fDB[i]=new Double_t[fNUnits[i]]; 
00185   }
00186   
00187   // allocation of teaching
00188   
00189   fTeach=new Float_t[fNUnits[fNHiddL+1]]; 
00190     
00191   // allocation of weights
00192   
00193   fW=new Double_t**[fNHiddL+1];
00194   fDW=new Double_t**[fNHiddL+1];
00195   
00196   for (i=0;i<fNHiddL+1;i++)
00197   {
00198     fW[i]=new Double_t*[fNUnits[i]];
00199     fDW[i]=new Double_t*[fNUnits[i]];
00200     for (l=0;l<fNUnits[i];l++)
00201     {
00202       fW[i][l]=new Double_t[fNUnits[i+1]];  
00203       fDW[i][l]=new Double_t[fNUnits[i+1]]; 
00204     }
00205   }
00206   
00207 }
00208 
00209 void StPmdNeuNet::SetKernel(Int_t nInput, const Text_t *hidden, Int_t nOutput)
00210 {  
00211    FreeVW();
00212    AllocateVW(nInput,hidden,nOutput);
00213 }
00214 
00215 
00222 void StPmdNeuNet::SetLearnParam(Double_t learnParam,Double_t fse,Double_t mu)
00223 {
00224   fLearnParam=fabs(learnParam);
00225   fFlatSE=fabs(fse);
00226   fMu=fabs(mu);
00227 
00228     gMessMgr->Info()<<"StPmdNeuNet::AllocateVW: free memory first ";
00229   if (fLearnParam>1.0)  gMessMgr->Info()<<"StPmdNeuNet::SetLearnParam: Warning : is not an usual value "<<fLearnParam;
00230   if (fLearnParam==0.0) gMessMgr->Info()<<"StPmdNeuNet::SetLearnParam: Warning : 0 is a stupid value";
00231   gMessMgr->Info()<<"StPmdNeuNet::SetLearnParam: Learning Parameter set to : "<<fLearnParam;
00232   gMessMgr->Info()<<"StPmdNeuNet::SetLearnParam: Flat Spot elimination value  set to :"<<fFlatSE;
00233   gMessMgr->Info()<<"StPmdNeuNet::SetLearnParam: Momentum set to : "<<fMu;
00234 }
00235 
00236 
00238 void StPmdNeuNet::SetInitParam(Float_t lowerInitWeight, Float_t upperInitWeight)
00239 {
00240   Float_t temp;
00241 
00242   fLowerInitWeight=lowerInitWeight;
00243   fUpperInitWeight=upperInitWeight;
00244   if (fLowerInitWeight>fUpperInitWeight)
00245   {
00246     temp=fUpperInitWeight;
00247     fUpperInitWeight=fLowerInitWeight;
00248     fLowerInitWeight=temp;
00249   } 
00250   if (fLowerInitWeight==fUpperInitWeight)
00251     gMessMgr->Info()<<"StPmdNeuNet::SetInitParam: Warning : the weights initialisation bounds are equal ";
00252   gMessMgr->Info()<<"StPmdNeuNet::SetInitParam: Init Parameters set to ";
00253   gMessMgr->Info()<<"StPmdNeuNet::SetInitParam: --> Lower bound = "<<fLowerInitWeight;
00254   gMessMgr->Info()<<"StPmdNeuNet::SetInitParam: --> Upper bound = "<<fUpperInitWeight;
00255 
00256 }
00257 
00258 
00259 Float_t StPmdNeuNet::Alea()
00260 {
00261   return fLowerInitWeight+fRandom.Rndm()*(fUpperInitWeight-fLowerInitWeight);
00262 }
00263 
00264 
00265 
00271 void StPmdNeuNet::Init()
00272 {  
00273   Int_t i,l,c;
00274   
00275   if(!fW){gMessMgr->Info()<<"StPmdNeuNet::Init: allocate memory first";return;}
00276   
00277   // init of weights
00278   
00279   for (i=0;i<fNHiddL+1;i++)
00280     for (l=0;l<fNUnits[i];l++)
00281       for (c=0;c<fNUnits[i+1];c++) fW[i][l][c]=(Double_t)Alea();
00282 
00283   for(i=0;i<fNHiddL+1;i++)for(l=0;l<fNUnits[i];l++)for(c=0;c<fNUnits[i+1];c++)
00284       fDW[i][l][c]=0.;       
00285   
00286   // init of biases
00287   
00288   for (i=1;i<fNHiddL+2;i++)
00289     for (l=0;l<fNUnits[i];l++) fBiases[i][l]=(Double_t)(Alea())*fUseBiases;
00290 
00291   for(i=1;i<fNHiddL+2;i++)for(l=0;l<fNUnits[i];l++)fDB[i][l]=0.;
00292 
00293 
00294   fNTrainCycles=0;
00295   gMessMgr->Info()<<"StPmdNeuNet::Init: Initialisation done";
00296 }
00297 
00298 
00300 void StPmdNeuNet::PrintS()
00301 {
00302   Int_t i,l,c;
00303   
00304   if(!fW){gMessMgr->Info()<<"StPmdNeuNet::PrintS: no unit ";return;} 
00305   
00306   gMessMgr->Info()<<"StPmdNeuNet::PrintS: +++++++++ Neural Network ++++++++++++"<<GetName();
00307   for(i=0;i<fNHiddL+2;i++)gMessMgr->Info()<<"StPmdNeuNet::PrintS: Layer contains units"<<i<<" "<<fNUnits[i];
00308 
00309   if(fUseBiases)gMessMgr->Info()<<"StPmdNeuNet::PrintS: >>>>>>> Biases USED";
00310   else          gMessMgr->Info()<<"StPmdNeuNet::PrintS: >>>>>>>Biases DUMMY";
00311 
00312   gMessMgr->Info()<<"StPmdNeuNet::PrintS: ----------   Biases   ---------- ";
00313   Int_t maxl=0;
00314   for(i=0;i<fNHiddL+2;i++)if(fNUnits[i]>=maxl)maxl=fNUnits[i];
00315   for(i=0;i<fNHiddL+2;i++)gMessMgr->Info()<<"      | "<<i;
00316   for(i=0;i<fNHiddL+2;i++)gMessMgr->Info()<<"--------|-";
00317   for(l=0;l<maxl;l++)
00318   {
00319     for(i=0;i<fNHiddL+2;i++)
00320       if(l<fNUnits[i])gMessMgr->Info()<<"StPmdNeuNet::PrintS:  | "<<fBiases[i][l];
00321       else gMessMgr->Info()<<"        | "; 
00322   }
00323 
00324 
00325   gMessMgr->Info()<<"StPmdNeuNet::PrintS:    ----------   Weights ----------- ";
00326   for(i=0;i<fNHiddL+1;i++)
00327   {
00328     gMessMgr->Info()<<"StPmdNeuNet::PrintS:  From  "<<i<<" to " <<i+1;
00329    gMessMgr->Info()<<"StPmdNeuNet::PrintS: "<<i;for(l=0;l<fNUnits[i];l++)gMessMgr->Info()<<"  |"<<l;
00330     gMessMgr->Info()<<"StPmdNeuNet::PrintS: ===|";for(l=0;l<fNUnits[i];l++)gMessMgr->Info()<<"-------";
00331      gMessMgr->Info()<<"StPmdNeuNet::PrintS:  |"<<i+1; for(l=0;l<fNUnits[i];l++)gMessMgr->Info()<<"-------";
00332     for(c=0;c<fNUnits[i+1];c++)
00333     { 
00334        gMessMgr->Info()<<"StPmdNeuNet::PrintS: |"<<c;
00335        for(l=0;l<fNUnits[i];l++)gMessMgr->Info()<<"|"<<fW[i][l][c];
00336     }     
00337   }  
00338 
00339   gMessMgr->Info()<<"StPmdNeuNet::PrintS: Learning parameter = "<<fLearnParam;
00340  gMessMgr->Info()<<"StPmdNeuNet::PrintS: Flat Spot elimination value = "<<fFlatSE;
00341   gMessMgr->Info()<<"StPmdNeuNet::PrintS: Momentum = "<<fMu;
00342   gMessMgr->Info()<<"StPmdNeuNet::PrintS: Lower initialisation weight = "<<fLowerInitWeight;
00343   gMessMgr->Info()<<"StPmdNeuNet::PrintS: Upper initialisation weight = "<<fUpperInitWeight;
00344   gMessMgr->Info()<<"StPmdNeuNet::PrintS: Number of events for training   = "<<fNTrainEvents;
00345   gMessMgr->Info()<<"StPmdNeuNet::PrintS: Number of events for validation = "<<fNValidEvents;
00346   gMessMgr->Info()<<"StPmdNeuNet::PrintS: Number of cycles done = "<<fNTrainCycles;
00347   gMessMgr->Info()<<"StPmdNeuNet::PrintS: +++++++++++++++++++++++++++++++++++++++++++++++";
00348 
00349 }
00350 
00355 void StPmdNeuNet::Forward()
00356 {
00357   Int_t i,l,c;
00358   Double_t sum;
00359   //  cout<<"Valid forward called "<<endl;
00360   if(!fW){ 
00361     gMessMgr->Info()<<"StPmdNeuNet::Forward no unit !";
00362     return;
00363   }  
00364   
00365   for (i=0;i<fNHiddL+1;i++)  
00366     for (c=0;c<fNUnits[i+1];c++)
00367       {
00368         sum=0.; 
00369         for(l=0;l<fNUnits[i];l++)sum+=fW[i][l][c]*(Double_t)fValues[i][l];
00370         fValues[i+1][c]=(Float_t)Sigmoide(sum+fBiases[i+1][c]*fUseBiases);
00371       }
00372 }
00373 
00374 
00375 
00377 void StPmdNeuNet::LearnBackward()
00378 {
00379   if(fNTrainEvents<1){gMessMgr->Info()<<"StPmdNeuNet::LearnBackward: No event to train !!!";return;}
00380   if(!fW){gMessMgr->Info()<<"StPmdNeuNet::LearnBackward: no unit !";return;}
00381 
00382   Int_t i,l,c;
00383   Double_t delta;
00384   
00385   // weights
00386     
00387   for (i=0;i<fNHiddL+1;i++)  
00388     for (l=0;l<fNUnits[i];l++)
00389       for(c=0;c<fNUnits[i+1];c++)
00390       {
00391         delta=fLearnParam*fErrors[i+1][c]*(Double_t)fValues[i][l]+fMu*fDW[i][l][c];
00392         fW[i][l][c]+=delta;
00393         fDW[i][l][c]=delta;
00394       }
00395   // biases
00396   if(((Bool_t)fUseBiases))
00397   {
00398     for (i=1;i<fNHiddL+2;i++)  
00399       for (l=0;l<fNUnits[i];l++)
00400       {
00401         delta=fLearnParam*fErrors[i][l]+fMu*fDB[i][l];
00402         fBiases[i][l]+=delta;
00403         fDB[i][l]=delta;
00404       }
00405   }
00406 }
00407 
00408 
00413 Double_t StPmdNeuNet::Error()
00414 {
00415 
00416   Int_t i,l,c;
00417   Double_t sum,error=0,errorOneUnit;
00418   if(!fW){gMessMgr->Info()<<"StPmdNeuNet::Error: no unit !";return 0;}    
00419   
00420   //  Error on Output Units
00421 
00422   for(l=0;l<fNUnits[fNHiddL+1];l++)
00423   {
00424     errorOneUnit=(Double_t)(fTeach[l]-fValues[fNHiddL+1][l]);
00425     //    cout<<"teach "<<fTeach[l]<<"Value "<<fValues[fNHiddL+1][l]<<endl;
00426 
00427     error+=fabs(errorOneUnit);
00428     fErrors[fNHiddL+1][l]=errorOneUnit*(SigPrim(fValues[fNHiddL+1][l])+fFlatSE);
00429   }
00430   error=error/(Double_t)fNUnits[fNHiddL+1];
00431 
00432   //  Error on Hidden Units
00433 
00434   for(i=fNHiddL;i==1;i--)
00435   {  
00436     for(l=0;l<fNUnits[i];l++)
00437     {
00438       sum=0.;
00439       for(c=0;c<fNUnits[i+1];c++) sum+=fW[i][l][c]*fErrors[i+1][c];
00440       fErrors[i][l]=sum*(SigPrim((Double_t)fValues[i][l])+fFlatSE);
00441     }  
00442   }
00443   
00444   return error;
00445 }
00446 
00447 
00453 Double_t StPmdNeuNet::ErrorO()
00454 {
00455 
00456   
00457 //  cout<<"Error0 called "<<endl;
00458   Int_t l;
00459   Double_t error=0;
00460   if(!fW){gMessMgr->Info()<<"StPmdNeuNet::ErrorO: no unit !";return 0;}    
00461   for(l=0;l<fNUnits[fNHiddL+1];l++)
00462     error+=fabs((Double_t)(fTeach[l]-fValues[fNHiddL+1][l]));
00463   error=error/(Double_t)fNUnits[fNHiddL+1];  
00464   return error;
00465   
00466 }  
00467 
00468 
00477 Double_t StPmdNeuNet::TrainOneCycle()
00478 {
00479   if(fNTrainEvents<1){gMessMgr->Info()<<"StPmdNeuNet::TrainOneCycle: No event to train !!!";return 0.;}
00480   if(!fW){gMessMgr->Info()<<"StPmdNeuNet::TrainOneCycle: no unit !";return 0.;}
00481 
00482 
00483   Int_t i;
00484   Double_t error=0.;
00485 
00486   for(i=0;i<fNTrainEvents;i++)
00487   {  
00488     GetArrayEvt(fEventsList[i]); 
00489     Forward();
00490     for(Int_t l=0;l<fNUnits[fNHiddL+1];l++)
00491       {
00492         Teach[i]=fTeach[l];
00493         Value[i]=fValues[fNHiddL+1][l];
00494         
00495         //  cout<<"evt  "<<i<<"teach **"<<fTeach[l]<<"favle "<<fValues[fNHiddL+1][l]<<endl;
00496       }
00497 
00498     error+=Error();
00499     LearnBackward();
00500   
00501 
00502   }
00503  
00504   fNTrainCycles++;
00505   error=error/(Double_t)fNTrainEvents;
00506   gMessMgr->Info()<<"StPmdNeuNet::TrainOneCycle: cycle  : E_t =  "<<fNTrainCycles<<" "<<error;
00507 
00508   return error;
00509 }
00510 
00511 
00518 Double_t StPmdNeuNet::Valid()
00519 {
00520   if(fNValidEvents<1) return 0.;
00521  
00522 
00523   // we will now pass all the validation events through the kernel, and
00524   // compute the mean error on output 
00525   Double_t error=0.;
00526 
00527   for (Int_t j=0;j<fNValidEvents;j++)
00528     {
00529       error+=GoThrough(); // forward propagation and error on one event 
00530     }
00531   error=error/(Double_t)fNValidEvents; // mean
00532   return error;
00533 }
00534 
00535 
00540 void StPmdNeuNet::TrainNCycles(Int_t nCycles)
00541 {
00542   //sub  if(!conte){gMessMgr->Info()<<"no controller !";return;}
00543   Float_t errt,errv;
00544   for(Int_t i=0;i<nCycles;i++)
00545   {
00546     Mix();
00547     errt=(Float_t)TrainOneCycle();
00548     errv=(Float_t)Valid();
00549     gMessMgr->Info()<<"StPmdNeuNet::TrainNCycles: cycle  > train : "<<fNTrainCycles<<" "<<errt;
00550     if(fNValidEvents)gMessMgr->Info()<<"StPmdNeuNet::TrainNCycles: and valid : ";
00551     else gMessMgr->Info()<<("  ");
00552 
00553   }
00554   
00555 }
00556 
00557 
00564 void StPmdNeuNet::Export(const Text_t *fileName)
00565 {
00566   Int_t i,l,c;
00567   
00568   if(!fW){gMessMgr->Info()<<"StPmdNeuNet::Export: no unit !";return;} 
00569   
00570   FILE  *file=0;
00571   file = fopen(fileName,"w");
00572   if ( ! file){
00573     gMessMgr->Info()<<"StPmdNeuNet::Export: ERROR Cannot open  for write  "<<fileName;
00574     return;
00575   }
00576 
00577   fprintf(file,"%8i\n",fNTrainEvents);
00578   for(l=0;l<fNTrainEvents;l++)fprintf(file,"%8.4f %8.4f\n",Teach[l],Value[l]);
00579 
00581   m_DiscMaker->mNNoutput->Fill(Value[l]);
00582 
00583   fprintf(file,"%3i\n",fNHiddL);
00584   for(i=0;i<fNHiddL+2;i++)fprintf(file,"%3i\n",fNUnits[i]);
00585 
00586   for(i=0;i<fNHiddL+2;i++)
00587     for(l=0;l<fNUnits[i];l++)fprintf(file,"%8.4f\n",fBiases[i][l]);
00588 
00589   for(i=0;i<fNHiddL+1;i++)
00590     for(l=0;l<fNUnits[i];l++)
00591       for(c=0;c<fNUnits[i+1];c++)fprintf(file,"%8.4f\n",fW[i][l][c]);
00592   
00593   fprintf(file,"%5i\n",fNTrainCycles);  
00594   fprintf(file,"%2.0f\n",fUseBiases); 
00595     
00596   fclose(file);   
00597 }
00598 
00599 
00606 void StPmdNeuNet::Import(const Text_t *fileName)
00607 {
00608   Int_t i,l,c,newI,newHL,newO;
00609   Text_t hidden[100],piece[5];
00610   FILE *file=0;
00611   file = fopen(fileName,"r");
00612   
00613   if ( ! file){
00614     gMessMgr->Info()<<"StPmdNeuNet::Import: ERROR Cannot open  for read"<<fileName;
00615     return;
00616   }
00617 
00618   fscanf(file,"%3i",&newHL);
00619   fscanf(file,"%3i",&newI); 
00620   strcpy(hidden,"");
00621   for(i=1;i<newHL;i++)
00622     {fscanf(file,"%s",piece);strcat(hidden,piece);strcat(hidden,":");} 
00623   fscanf(file,"%s",piece);strcat(hidden,piece);
00624   fscanf(file,"%3i",&newO); 
00625   
00626   gMessMgr->Info()<<"StPmdNeuNet::Import: New NN set to : "<<newI<<" "<<hidden<<" "<<newO;
00627   FreeVW();                       
00628 
00629   gMessMgr->Info()<<"StPmdNeuNet::Import: Allocating";
00630   AllocateVW(newI,hidden,newO);
00631 
00632   gMessMgr->Info()<<"StPmdNeuNet::Import: Filling fDB+fscanf()";
00633   Float_t tmpfl;
00634   for(i=0;i<fNHiddL+2;i++)
00635     for(l=0;l<fNUnits[i];l++){fDB[i][l]=0.;fscanf(file,"%f",&tmpfl);*(fBiases[i]+l)=(Double_t)tmpfl;}
00636 
00637   for(i=0;i<fNHiddL+1;i++)
00638     for(l=0;l<fNUnits[i];l++)
00639       for(c=0;c<fNUnits[i+1];c++){
00640         fDW[i][l][c]=0.;fscanf(file,"%f",&tmpfl);*(fW[i][l]+c)=(Double_t)tmpfl;
00641         //      cout<<"Nhidd "<<i<<"Nunit "<<l<<"unit_next "<<c<<"wei "<<fW[i][l][c]<<endl;     
00642       }
00643   
00644 
00645   fscanf(file,"%5i",&fNTrainCycles);  
00646   fscanf(file,"%f",&tmpfl);fUseBiases=(Double_t)tmpfl;  
00647   fclose(file);   
00648   gMessMgr->Info()<<"StPmdNeuNet::Import: Done";
00649 }
00650 
00651 
00656 void StPmdNeuNet::Mix()
00657 {
00658   Int_t i,i1,i2;
00659   Int_t temp;
00660   for (i=0;i<3*fNTrainEvents;i++)
00661   {
00662      i1=(Int_t)(fRandom.Rndm()*(Float_t)fNTrainEvents);
00663      i2=(Int_t)(fRandom.Rndm()*(Float_t)fNTrainEvents);
00664      temp=fEventsList[i1];
00665      fEventsList[i1]=fEventsList[i2];
00666      fEventsList[i2]=temp;
00667   }
00668 
00669   //  for (i=0;i<fNTrainEvents;i++)printf("%i \n",fEventsList[i]);  
00670   //  printf("Mixed ... ");
00671 }
00672 
00673 
00674 void StPmdNeuNet::SetArraySize(Int_t size)
00675 {
00676   DeleteArray();
00677   if (fEventsList) delete [] fEventsList;
00678   if(!size)return;
00679   Int_t i;
00680   fNTrainEvents=size;  
00681   fArrayIn  = new Float_t*[fNTrainEvents];
00682   for (i=0;i<fNTrainEvents;i++) fArrayIn[i] = new Float_t[fNUnits[0]];
00683 
00684 
00685   fArrayOut = new Float_t*[fNTrainEvents];  
00686   for (i=0;i<fNTrainEvents;i++) fArrayOut[i] = new Float_t[fNUnits[fNHiddL+1]];
00687   
00688   fEventsList = new Int_t[fNTrainEvents];
00689   for (i=0;i<fNTrainEvents;i++)fEventsList[i]=i;
00690 }
00691 
00692 void StPmdNeuNet::DeleteArray()
00693 {
00694   Int_t i; 
00695 
00696   if(fArrayIn) 
00697   {
00698     for (i=0;i<fNTrainEvents;i++)delete [] fArrayIn[i];
00699     delete [] fArrayIn;
00700     fArrayIn=0;
00701   }
00702 
00703   if(fArrayOut) 
00704   {
00705     for (i=0;i<fNTrainEvents;i++)delete [] fArrayOut[i];
00706     delete [] fArrayOut;
00707     fArrayOut=0;
00708   }
00709   
00710 }
00711 
00712 /*
00713 void StPmdNeuNet::SetTrainTree(TNNTree *t)
00714 {
00715 // method to associate a TNNTree to the kernel :
00716 // the events of the tree will be transferred in the internal
00717 // array of the kernel.
00718 
00719   if(!t){printf("no tree !\n");return;}
00720   Int_t i;
00721   
00722 //allocation  
00723   
00724   SetArraySize((Int_t)(t->GetTree()->GetEntries()));
00725   printf(" nbr evts for training : %i \n",GetNTrainEvents());  
00726     
00727 // loop  
00728 // the methods GetInputAdr() and GetTeachAdr()
00729 // return the adresses of arrays in kernel, and the method
00730 // GetEvent fills these adresses with event i of the train tree t
00731 // the method Fill(i) translates the filled arrays in the internal array
00732    
00733    for (i=0;i<(Int_t)(t->GetTree()->GetEntries());i++)
00734    {
00735      t->GetEvent(GetInputAdr(),GetTeachAdr(),i);
00736      Fill(i);  
00737    }
00738 
00739 }
00740 
00741 void StPmdNeuNet::SetValidTree(TNNTree *t)
00742 {
00743 // method to associate a TNNTree to the kernel :
00744 // a link will be done between the tree and the kernel.
00745 // it is not necessary to keep these events in the kernel
00746 
00747   if(!t){printf("no tree !\n");return;}
00748   fValidTree=t;
00749   fNValidEvents=(Int_t)(t->GetTree()->GetEntries());
00750 }
00751 
00752 */
00753 
00754 void StPmdNeuNet::FillArray(Int_t iev,Int_t iunit,Float_t value)
00755 {
00756   //cout<<"inside fillarray**"<<iev<<" "<<iunit<<" "<<value<<endl;
00757 
00758   fArrayIn[iev][iunit]=value;
00759 }
00760 
00761 
00762 
00771 Double_t StPmdNeuNet::ApplyWeights(Float_t *Teach,Float_t *Value)
00772 {
00773   if(fNTrainEvents<1){gMessMgr->Info()<<"StPmdNeuNet::ApplyWeights: No event to train !!!";return 0.;}
00774   if(!fW){gMessMgr->Info()<<"StPmdNeuNet::ApplyWeights: no unit !";return 0.;}
00775   FILE *file1;
00776   file1=fopen("testout","w");
00777 
00778   Int_t i;
00779   Double_t error=0.;
00780 
00781   for(i=0;i<fNTrainEvents;i++)
00782   {  
00783     GetArrayEvt(fEventsList[i]); 
00784     Forward();
00785     for(Int_t l=0;l<fNUnits[fNHiddL+1];l++)
00786       {
00787         Teach[i]=fTeach[l];
00788         Value[i]=fValues[fNHiddL+1][l];
00789         
00790         
00791         //        cout<<"evt  "<<i<<"teach **"<<fTeach[l]<<"favle "<<fValues[fNHiddL+1][l]<<endl;
00792       }
00793     fprintf(file1,"%d %8.4f %8.4f\n",i,Teach[i],Value[i]);
00794 
00795     error+=Error();
00796     //    LearnBackward();
00797   
00798     
00799   }
00800  
00801   fNTrainCycles++;
00802   error=error/(Double_t)fNTrainEvents;
00803   // printf("cycle %i : E_t = %6.4f ",fNTrainCycles,error);
00804 
00805   return error;
00806 }