topAdaptive.h

Go to the documentation of this file.

 
#ifndef SI_MODEL_TOPADAPTIVE_H
#define SI_MODEL_TOPADAPTIVE_H
 
 
#include <si/model/adaptive.h>
#include <si/model/topModel.h>
#include <iostream>
 
 
namespace sigraph
{
  class Learner;
 
  class TopAdaptive : public Adaptive, public TopModel
  {
  public:
    TopAdaptive( Model* submod = 0 );
    TopAdaptive( const TopAdaptive & a );
    virtual ~TopAdaptive();
    virtual Model* clone() const;
 
    TopAdaptive & operator = ( const TopAdaptive & m );

    virtual Model* model() { return( _model ); }
    virtual void setModel( Model* subm ) { _model = subm; }

    virtual double prop( const Clique* );
    virtual double prop( const Clique* cl, 
                         const std::map<Vertex*, std::string> & changes );
    virtual bool doesOutputChange( const Clique* cl, 
                                   const std::map<Vertex*,
                                   std::string> & changes ) const;
    virtual bool openFile( const std::string & basename = "" );
    virtual void closeFile();
    virtual void subFiles( const std::string & prefix, 
                           std::set<std::string> & listNames ) const;
    virtual double printDescription( Clique* cl, bool = false );
    virtual TopModel* topModel();
    virtual const TopModel* topModel() const;


    virtual void generateDataBase(Learner &learner, const std::string &prefix,
                const std::list<Clique *> *lrnCliques,
                const std::list<Clique *> *tstCliques,
                int cycles, int cycles_tst);
    virtual double eval( const Clique *);
    //virtual void getVectors(LearnConstParam *lp);
    virtual double errorRate() const;
    virtual double genErrorRate() const;
    virtual double relianceWeight() const;
    virtual void init();
    virtual bool checkLearnFinished();
    virtual void forceLearnFinished();
 
    virtual void resetStats();
    virtual void trainStats(Learner &learner,
                        const std::list<Clique *> &cliques);


    virtual void buildTree( Tree & tr ) const;
    virtual void setBaseName( const std::string & basename );
 
  protected:
    Model          *_model;
 
  private:
  };
 
  //    Fonctions inline
 
  inline Model* TopAdaptive::clone() const
  {
    return( new TopAdaptive( *this ) );
  }
 
 
  inline double TopAdaptive::relianceWeight() const
  {
    if( _model->isAdaptive() )
      return static_cast<const Adaptive *>(_model)->relianceWeight();
    return 1.;
  }
 
 
  inline double TopAdaptive::prop( const Clique* cl )
  {
    return( _model->prop( cl ) );
  }
 
 
  inline double TopAdaptive::printDescription( Clique* cl, bool naming )
  {
    return( _model->printDescription( cl, naming ) );
  }
 
 
  inline bool TopAdaptive::openFile( const std::string & basename )
  {
    return( _model->openFile( basename ) );
  }
 
 
  inline void TopAdaptive::closeFile()
  {
    _model->closeFile();
  }
 
 
  inline void TopAdaptive::subFiles( const std::string & prefix, 
                                     std::set<std::string> & listNames ) const
  {
    _model->subFiles( prefix, listNames );
  }
 
 
inline void     TopAdaptive::generateDataBase(Learner &learner,
                        const std::string &prefix,
                        const std::list<Clique *> *lrnCliques,
                        const std::list<Clique *> *tstCliques,
                        int cycles, int cycles_tst)
{
        if (_model->isAdaptive())
                ((Adaptive *) _model)->generateDataBase(learner, prefix,
                        lrnCliques, tstCliques, cycles, cycles_tst);
}
 
  inline double TopAdaptive::eval( const Clique * cl )
  {
    if( _model->isAdaptive() )
      return( ((Adaptive *)_model)->eval( cl ) );
    else return( 0. );
  }
 
 
  inline double TopAdaptive::errorRate() const
  {
    if( _model->isAdaptive() )
      return( ((Adaptive *)_model)->errorRate() );
    else return( 0. );
  }
 
 
  inline double TopAdaptive::genErrorRate() const
  {
    if( _model->isAdaptive() )
      return( ((Adaptive *)_model)->genErrorRate() );
    else return( 0. );
  }
 
 
  inline void TopAdaptive::init()
  {
    if( _model->isAdaptive() )
      ((Adaptive *)_model)->init();
    _ndata = 0;
  }
 
 
  inline void TopAdaptive::resetStats()
  {
    if( _model->isAdaptive() )
      ((Adaptive *)_model)->resetStats();
  }
 
 
  inline void TopAdaptive::trainStats(Learner &learner,
                        const std::list<Clique *> &cliques)
  {
    if( _model->isAdaptive() )
      ((Adaptive *)_model)->trainStats(learner, cliques);
  }
 
 
  inline TopModel* TopAdaptive::topModel()
  {
    return( this );
  }
 
 
  inline const TopModel* TopAdaptive::topModel() const
  {
    return( this );
  }
 
  inline void TopAdaptive::setBaseName( const std::string & basename )
  {
    _model->setBaseName( basename );
  }
 
 
  inline bool TopAdaptive::checkLearnFinished()
  {
    if( !_learnfinished )
      {
        if( _model->isAdaptive() )
          _learnfinished = ((Adaptive *)_model)->checkLearnFinished();
        else
          _learnfinished = true;
      }
    return( _learnfinished );
  }
 
 
  inline void TopAdaptive::forceLearnFinished()
  {
    if( !_learnfinished && _model->isAdaptive() )
      ((Adaptive *)_model)->forceLearnFinished();
    _learnfinished = true;
  }
 
}
 
#endif