TANNModeler.h

Go to the documentation of this file.

 
// Copyright (C) 2013-2024 CEA/DES
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published
// by the Free Software Foundation, either version 3 of the License, or any
// later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// $Id$
// $Author$
// $Date$
// $Revision$
// $State$
 
#ifndef TANNMODELER_H
#define TANNMODELER_H
 
// Newmat
#include "newmat.h"
using namespace NEWMAT;
 
#include <iostream>
 
//ROOT
#include "Rtypes.h"
#include "TNamed.h"
 
//Uranie
#include "Modeler.h"
#include "TModeler.h"
#include "TDataServer.h"
#include "TPatternsEventList.h"
#include "UMLP.h"
 
//   GPU training of ANN
#if defined(WITH_GPUANN) && !defined(__CINT__)
#include "nn_headers.h"
namespace NNLM = NeuralNetworkLevenbergMarquardt;
#endif
 
 
namespace URANIE
{
namespace Modeler
{
 
class TempSolution;
 
class TANNModeler: public TModeler
{
public:
    enum EProblem {
        kRegression, kClassification
    };
 
    enum ENorm
    {
        kCR, kMinusOneOne, kZeroOne
    };
    // Attributes
protected:
    Int_t _nSeed;                             
 
private:
    Int_t _nInput;                                    
    Int_t _nHidden;                                   
    Int_t _nHiddenLayer;                              
    Int_t _nOutput;                                   
    Int_t _nNeurons;                                  
 
    Int_t _nApp;                            
    Int_t _nTest;                         
    Double_t _dLearn;                                  
    Double_t _dTest;                                    
    Double_t _dWeightDecay;                       
    URANIE::DataServer::TPatternsEventList * _elAll; 
    Bool_t _bMix;               
 
    TString _sArchi;                                  
    TString _sInput;
    TString _sHidden;
    TString _sOutput;
 
    Int_t _nWeight;                                   
 
    ColumnVector _vecWeights;
    TempSolution * _tmpSolution;
 
 
    ColumnVector _vecMinValues;                       
    ColumnVector _vecMaxValues;                       
 
        
    TList * _listOfAttributes;
    //---------------------------------------------
    Double_t _dFcnTol;                  
    ENorm _nNormType;                   
    EProblem _nProlemType;              
 
    Double_t * _dval;  // size: _nInput+1 (a full training vector = input + (a single) output)
 
    static const int OPTIM_MAX_ITER = 10000;   //<! Maximal number of iterations in the optimization algorithms
    static const int OPTIM_MAX_FEVAL = 50000;  //<! Maximal number of evaluations in the optimization algorithms
public:
    Bool_t _blog;                             
    URANIE::DataServer::TDataServer *_tds;     
    UMLP *_UMLP;
public:
    //---------------------------------------------
 
    TANNModeler(URANIE::DataServer::TDataServer *tds, TString architecture,
            Double_t dratio = 0.80, Option_t *option = "");
#ifdef  WITH_LIBXML2
    TANNModeler (URANIE::DataServer::TDataServer *tds, const char* pmmlfile, const char* ANNname, Double_t dratio = 0.80, Option_t *option ="");
#endif
    virtual ~TANNModeler();
    //---------------------------------------------
 
    Int_t getNInput()
    {
        return _nInput;
    }
    Int_t getNHidden()
    {
        return _nHidden;
    }
    Int_t getNOutput()
    {
        return _nOutput;
    }
    Int_t getNAPP()
    {
        return _nApp;
    }
    Int_t getNTest()
    {
        return _nTest;
    }
 
    void setWeights(ColumnVector weights)
    {
        _vecWeights = weights;
    }
    ColumnVector getWeights()
    {
        return _vecWeights;
    }
 
 
    Double_t getWeight(Int_t ind)
    {
        return _vecWeights(ind + 1);
    }
 
    Double_t getMinValue(Int_t ind)
    {
        return _vecMinValues(ind);
    }
    Double_t getMaxValue(Int_t ind)
    {
        return _vecMaxValues(ind);
    }
    Double_t * getdval()
    {
        return _dval;
    }
 
    void setValue(Int_t ind, Int_t &ncrt, Double_t *xy, Bool_t normalize=true);
 
    void setDataSet(URANIE::DataServer::TPatternsEventList* tel)
    {
        _elAll = tel;
    }
 
    void setMix(Bool_t bmix = kTRUE)
    {
        _bMix = bmix;
    }
    void setFcnTol(Double_t dprec)
    {
        _dFcnTol = dprec;
    }
    Double_t getFcnTol()
    {
        return _dFcnTol;
    }
 
    void setNormalization(ENorm n);
    ENorm getNormalization()
    {
        return _nNormType;
    }
 
    EProblem getProblem() { return _nProlemType;}
 
    void setSeed(Int_t ind = 0);
    Int_t getSeed()
    {
        return _nSeed;
    }
    const char * getInputName(Int_t i)
    {
        URANIE::DataServer::TAttribute *att;
        att = (URANIE::DataServer::TAttribute *) _listOfAttributes->At(i);
        return att->GetName();
    }
    const char * getOutputName()
    {
        return _sOutput.Data();
    }
 
    //---------------------------------------------
    // Init the ANN
    void init();
    void randomizeWeights();
#ifdef WITH_GPUANN
    void train(Int_t niter = 10, Int_t nInit = 10, Option_t* option = "text", Bool_t useGPU = true);
#else
    void train(Int_t niter = 10, Int_t nInit = 10, Option_t* option = "text", Bool_t useGPU = false);
#endif
 
    Double_t getEQM(Option_t* option = "");
    Double_t getWeightDecay()
    {
        return _dWeightDecay;
    }
 
    void saveIfBetter(const ColumnVector & weights, Double_t eqm_app, Double_t eqm_tst);
 
 
    //---------------------------------------------
 
//     void exportFunction(const char* lang, const char* file = "",
//             const char* name = "", Option_t *option = "");
    void exportModelCplusplus(const char* file = "", const char* name = "",
            Option_t *option = "") const;
//    /*!
//     \todo Write this method as a TModeler method
//     */
    void exportModelCplusplus(std::ofstream * sourcefile)  const;
//     {
//         cerr
//                 << "   --- Method TANNModeler::exportModelCplusplus(ofstream * sourcefile) not yet implemented"
//                 << endl;
//         cerr
//                 << "   --- Then using the method TANNModeler::exportModelCplusplus(file, name, option)"
//                 << endl;
//     }
//     ;
 
    void exportModelPMML(const char* file = "", const char* name = "", Option_t *option = "") const;
    void exportModelFortran(const char* file, const char* name, Option_t *option = "") ;
    void exportModelFortran(std::ofstream * sourcefile) const;
//     {
//         std::cerr
//                 << "   --- Method TANNModeler::exportModelFortran(ofstream * sourcefile) not yet implemented"
//                 << endl;
//         std::cerr
//                 << "   --- Then using the method TANNModeler::exportModelFortran(file, name, option)"
//                 << endl;
//     }
//     ;
    
    
 
    void exportModelPython(std::ofstream * sourcefile) const
    {
        UNUSED(sourcefile);
        std::cerr
                << "   --- Method TANNModeler::exportModelPython(ofstream * sourcefile) not yet implemented"
                << endl;
    };
 
    //---------------------------------------------
    virtual void printLog(Option_t *option = "");
    ClassDef(URANIE::Modeler::TANNModeler, ID_MODELER)
    //Classe def
 
private:
    void train_cpu(Int_t niter, Int_t nInit, Bool_t randomizeweights);
 
#if defined(WITH_GPUANN)
    void train_gpu(NNLM::NeuronType T, Int_t niter, Int_t nInit, Bool_t randomizeweights);
#endif
 
};
} // Fin du namespace Modeler
} // Fin du namespace URANIE
 
R__EXTERN URANIE::Modeler::TANNModeler *gUranieANNModeler;
 
#endif