TGLM.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$
 
/*
 class="" URANIE::Modeler::TGLM
 
 @brief  Description of the class TGLM.
 
 This class implements the \b "Generalized \b Linear \b Models" model
 
 The algorith implemented is the \b Iterative \b Weighted \b Least \b Squares (\b IWLS ).
 \li Assign starting values to the parameters \f$ beta^{(0)}\f$, generally by resolving the Least Squares Normal equations (i.e. without weights);
 \li Update the \f$ \eta^{(i)}\f$ and \f$ \mu^{(i)}\f$ with parameters \f$ beta^{(i)}\f$
 \li Update the weights using the new estimated mean vector: \f$ \frac{1}{v^(i+1)} = \var(\mu^{i}) * f(\mu^{i}) \f$
 \li Resolve the Weighted Least Squares Normal equations to give \f$ beta^{(i+1)}\f$
 \li Repeat the thre last steps until convergence (\em i.e. \f$ X\hat{\Beta^{i}} - X\hat{\Beta^{i+1}}\f$ is sufficiently close to zero).
 */
#ifndef TGLM_H
#define TGLM_H
 
//ROOT
 
// Uranie
#include "TModeler.h"
 
namespace URANIE
{
namespace Modeler
{
class TGLM: public TModeler
{
    // Attributs
public:
    enum EDistribution
    {
        kUnknown, kPoisson, kGamma, kBinomial, kNormal
    };
    enum ELinkFunctin
    {
        kCanonical, kIdentity, kLogit, kProbit, kLogLog, kLog, kInverse
    };
private:
    EDistribution _nDistribution;                
    ELinkFunctin _nLinkFunction;     
    Int_t _nIteration;   
    Int_t _nMaxIteration;      
 
    TVectorD _vecBetaInit;                         
    Double_t _dTolerance;   
    Double_t _dNullDeviance;                       
    Double_t _dResidualDeviance;                
    // Operations
public:
    //---------------------------------------------
 
    /*
     \param tds (URANIE::DataServer::TDataServer *) the dataserver
     \param architecture(TString) The architecture (input and output attributes) of the model separated by the caracter ":"
     \param option (Option_t *)[""]  The option to pass
     */
    TGLM(URANIE::DataServer::TDataServer *tds, TString architecture,
            Option_t *option = "");
    /*
     \param tds (URANIE::DataServer::TDataServer *) the dataserver
     \param varexpinput(const char*)[""] The list of input attributes to pass to the function separated by the caracter ":"
     \param varexpoutput (const char *)[""]  The list of output attributes separated by the caracter ":"
     \param option (Option_t *)[""]  The option to pass
     */
    TGLM(URANIE::DataServer::TDataServer *tds, const char *varexpinput,
            const char *varexpoutput, Option_t * option = "");
    virtual ~TGLM();
 
    //---------------------------------------------
 
    void setFamily(EDistribution nYDistribution = kUnknown,
            ELinkFunctin nLinkFunction = kCanonical);
    EDistribution getYDistribution()
    {
        return _nDistribution;
    }
    ELinkFunctin getLinkFunction()
    {
        return _nLinkFunction;
    }
    void setMaxIteration(Int_t n)
    {
        if (n > -1)
            _nMaxIteration = n;
    }
    Int_t getNIteration()
    {
        return _nIteration;
    }
    Int_t getMaxIteration()
    {
        return _nMaxIteration;
    }
    void setTolerance(Double_t dtol)
    {
        if (dtol > 0)
            _dTolerance = dtol;
    }
    Double_t getTolerance()
    {
        return _dTolerance;
    }
    Double_t getNullDeviance()
    {
        return _dNullDeviance;
    }
    Double_t getResidualDeviance()
    {
        return _dResidualDeviance;
    }
    void setInitialBeta(TVectorD vecIni);
    TVectorD getInitialBeta()
    {
        return _vecBetaInit;
    }
 
    //---------------------------------------------
    void estimate(Option_t * option = "");
 
    void fillData(TMatrixD &Aw, TVectorD &yw, TMatrixD &matY);
 
    //---------------------------------------------
 
    void exportModelCplusplus(std::ofstream * sourcefile) const;
 
    void exportModelFortran(std::ofstream * sourcefile) const;
    
    
 
    void exportModelPMML(const char* file = "", 
                         const char* name = "",Option_t *option = "") const
    {
        TString soption = option;
        soption.ToLower();
        UNUSED(file,name);
        std::cerr
                << "   --- Method TGLM::exportModelPMML(ofstream * sourcefile) not yet implemented"
                << endl;
        throw URANIE::Exceptions::UWarningExceptions(__FILE__, __LINE__,
            "TGLM::exportFunction\n The PMML language is not yet implemented.");        
    };
    
 
    void exportModelPython(std::ofstream * sourcefile) const
    {
        UNUSED(sourcefile);
        std::cerr
                << "   --- Method TGLM::exportModelPython(ofstream * sourcefile) not yet implemented"
                << endl;
        throw URANIE::Exceptions::UWarningExceptions(__FILE__, __LINE__,
            "TGLM::exportFunction\n The Python language is not yet implemented.");        
    };
 
    //---------------------------------------------
    void printLog(Option_t *option = "");
 
    ClassDef(URANIE::Modeler::TGLM, ID_MODELER)
    //Classe de
};
} // Fin du namespace Modeler
} // Fin du namespace URANIE
#endif // TGLM_H