subAdaptive.h

Go to the documentation of this file.

 
 
#ifndef SI_SUBADAPTIVE_SUBADAPTIVE_H
#define SI_SUBADAPTIVE_SUBADAPTIVE_H
 
#include <si/learnable/dbLearnable.h>
#include <si/subadaptive/subAdResponse.h>
#include <vector>
#include <set>
#include <map>
#include <string>
 
class Tree;
 
 
namespace sigraph
{
 
class SiVectorLearnable;
class AdaptiveLeaf;
 
 

class SubAdaptive
{
 
public:
        struct Stat
        {
                double  mean;
                double  sigma;
        };
 
        enum RealClassMode
        {
                RealClassFromClassID,
                RealClassFromPotential
        };
 
        enum RelianceWeightMethod
        {
                MeanGenError,
                MisclassFrequency,
        };

        static double ForgetFactor;
        static double GenForgetFactor;
        static double GenGoodForgetFactor;
        static double GenBadForgetFactor;
        static double LocalForgetFactor;
 
        virtual ~SubAdaptive();
 
        virtual SubAdaptive & operator = (const SubAdaptive & sa);
        virtual SubAdaptive* clone() const = 0;


        virtual SubAdResponse *train(AdaptiveLeaf &, 
                        const SiDBLearnable &tr, const SiDBLearnable &tst) = 0;
        virtual bool hasIncrementalLearning(void) const = 0;
        virtual double normalizedPotential(double outp) const;
        virtual double unNormalizedPotential(double nout) const;
        virtual double getLearnedLabel(const SiVectorLearnable &vl) const;
        //Appel de la fonction de test sur l'ensemble d'une DB
        virtual SubAdResponse *test(const SiDBLearnable &tst);
        virtual double test(const SiVectorLearnable &vl);
        virtual double prop(const std::vector<double> & vec) = 0;
        virtual void init();
        virtual std::vector<double>*
                normalizeSelected(const double *vec, unsigned int size);

        virtual bool openFile(const std::string & filename = "");
        virtual void closeFile();
        virtual bool fileOpened() const
        { return(_stream != 0); }

        virtual std::string
        chooseFilename(const std::string & basename = "") const;
        virtual void subFiles(const std::string & prefix, 
                        std::set<std::string> & listNames) const;

        void    setRealClassMode(RealClassMode m) { _real_class_mode = m; }
        std::string getRealClassMode(void) const
        {
                static std::string   mode[] = {"class", "potential"};
                return mode[_real_class_mode];
        }
 


        virtual void resetStats();
        virtual void setStats(const std::vector<double> &mean,
                        const std::vector<double> &sigma);
        virtual void learnStats(const std::vector<double> &vec, double outp=0);
        unsigned nStats() const;
        void setNStats(unsigned nstats);
        const std::map<unsigned, Stat> & stats() const;
        void setStats(const std::map<unsigned, Stat> & stats);
        double getMean(unsigned ind) { return _stats[ind].mean; }
        double getSigma(unsigned ind) { return _stats[ind].sigma; }
        double errorRate() const { return(_errorRate); }
        double genErrorRate() const { return(_genErrorRate); }
        double genGoodErrorRate() const { return(_ggErrorRate); }
        double genBadErrorRate() const { return(_gbErrorRate); }
        double genMeanErrorRate() const;
        void setErrorRate(double rate) { _errorRate = rate; }
        void setGenErrorRate(double rate) { _genErrorRate = rate; }
        double localMinGErr() const { return(_ml); }
        double localMaxGErr() const { return(_Ml); }
        double globalMinGErr() const { return(_mg); }
        double globalMaxGErr() const { return(_Mg); }
        void setLocalMinGErr(double e) { _ml = e; }
        void setLocalMaxGErr(double e) { _Ml = e; }
        void setGlobalMinGErr(double e) { _mg = e; }
        void setGlobalMaxGErr(double e) { _Mg = e; }
        double misclassGoodRate() const { return _misclassGoodRate; }
        void setMisclassGoodRate(double x) { _misclassGoodRate = x; }
        double misclassBadRate() const { return _misclassBadRate; }
        void setMisclassBadRate(double x) { _misclassBadRate = x; }
        double misclassRate() const
        { return (_misclassGoodRate + _misclassBadRate) / 2; }

        void updateErrors(double err);
        void updateGoodErrors(double err);
        void updateBadErrors(double err);
        void setGenGoodErrorRate(double rate) { _ggErrorRate = rate; }
        void setGenBadErrorRate(double rate) { _gbErrorRate = rate; }
        void setLocalGoodMinGErr(double e) { _mgl = e; }
        void setLocalGoodMaxGErr(double e) { _Mgl = e; }
        void setGlobalGoodMinGErr(double e) { _mgg = e; }
        void setGlobalGoodMaxGErr(double e) { _Mgg = e; }
        double appGoodErrorRate() const { return(_agErrorRate); }
        void setAppGoodErrorRate(double e) { _agErrorRate = e; }
        unsigned stepsSinceGenMin() const { return(_stepsSinceGenMin); }
        void setStepsSinceGenMin(unsigned n) { _stepsSinceGenMin = n; }
        void setGlobalGenGBError(double e) { _mggb = e; }
        void setLearnfinished(bool s) { _learnfinished = s; }
        bool getLearnfinished(void) const { return _learnfinished; }


        virtual void buildTree(Tree & tr) const;
        std::string name() const { return(_name); }
        void setName(const std::string name) { _name = name; }
        virtual void setBaseName(const std::string &) {}
        virtual void getStreams(SubAdaptive & sa)
        {
                _stream = sa._stream;
                _tstream = sa._tstream; 
                sa._stream = 0;
                sa._tstream = 0;
        }

        virtual void setFileNames(const std::string &) {}
        virtual std::string fileNames() const { return(""); }
        virtual void setMinOut(double mino) { _minOut = mino; }
        virtual void setMaxOut(double maxo) { _maxOut = maxo; }
        virtual double relianceWeight() const;
        RelianceWeightMethod relianceWeightMethod() const
        { return _relianceWeightMethod; }
        void setRelianceWeightMethod(RelianceWeightMethod x)
        { _relianceWeightMethod = x; }
 
 
protected:
        std::string     _name;
        unsigned        _nStats;
        std::map<unsigned, Stat>        _stats;
        std::ostream    *_stream;
        std::ostream    *_tstream;
        double  _errorRate;
        double  _genErrorRate;
        double  _mg;
        double  _Mg;
        double  _ml;
        double  _Ml;
        double  _ggErrorRate;
        double  _mgl;
        double  _Mgl;
        double  _mgg;
        double  _Mgg;
        double  _agErrorRate;
        unsigned        _stepsSinceGenMin;
        double  _gbErrorRate;
        double  _mggb;
        double  _misclassGoodRate;
        double  _misclassBadRate;
        double  _minOut;
        double  _maxOut;
        bool    _learnfinished;

        RealClassMode        _real_class_mode;
        RelianceWeightMethod  _relianceWeightMethod;
 
 
        SubAdaptive(const std::string name = "");
        SubAdaptive(const SubAdaptive & sa);
 
private:
};
 
 
//      Fonctions inline
 
inline SubAdaptive::SubAdaptive(const SubAdaptive & sa) 
        : _name(sa._name), _nStats(sa._nStats), 
        _stats(sa._stats), _stream(0), _tstream(0), 
        _errorRate(sa._errorRate), 
        _genErrorRate(sa._genErrorRate), _mg(sa._mg), _Mg(sa._Mg), 
        _ml(sa._ml), _Ml(sa._Ml), _ggErrorRate(sa._ggErrorRate), 
        _mgl(sa._mgl), _Mgl(sa._Mgl), _mgg(sa._mgg), _Mgg(sa._Mgg), 
        _agErrorRate(sa._agErrorRate), 
        _stepsSinceGenMin(sa._stepsSinceGenMin),
        _gbErrorRate(sa._gbErrorRate), _mggb(sa._mggb),
        _misclassGoodRate(sa._misclassGoodRate),
        _misclassBadRate(sa._misclassBadRate),
        _minOut(sa._minOut), _maxOut(sa._maxOut), _learnfinished(false),
        _real_class_mode(sa._real_class_mode),
        _relianceWeightMethod(MeanGenError)
{
}
 
 
inline SubAdaptive & SubAdaptive::operator = (const SubAdaptive & sa)
{
        if(this != &sa)
        {
                _name = sa._name;
                _nStats = sa._nStats;
                _stats = sa._stats;
                _errorRate = sa._errorRate;
                _genErrorRate = sa._genErrorRate;
                _mg = sa._mg;
                _Mg = sa._Mg;
                _ml = sa._ml;
                _Ml = sa._Ml;
                _ggErrorRate = sa._ggErrorRate;
                _mgl = sa._mgl;
                _Mgl = sa._Mgl;
                _mgg = sa._mgg;
                _Mgg = sa._Mgg;
                _agErrorRate = sa._agErrorRate;
                _stepsSinceGenMin = sa._stepsSinceGenMin;
                _gbErrorRate = sa._gbErrorRate;
                _mggb = sa._mggb;
                _misclassGoodRate = sa._misclassGoodRate;
                _misclassBadRate = sa._misclassBadRate;
                _minOut = sa._minOut;
                _maxOut = sa._maxOut;
                _learnfinished = sa._learnfinished;
                _real_class_mode = sa._real_class_mode;
                _relianceWeightMethod = sa._relianceWeightMethod;
        }
        return(*this);
}
 
 
inline unsigned SubAdaptive::nStats() const
{
        return(_nStats);
}
 
 
inline void SubAdaptive::setNStats(unsigned nstats)
{
        _nStats = nstats;
}
 
 
inline 
const std::map<unsigned, SubAdaptive::Stat> & SubAdaptive::stats() const
{
        return(_stats);
}
 
 
inline void SubAdaptive::setStats(const std::map<unsigned, Stat> & stats)
{
        _stats = stats;
}
 
inline double   SubAdaptive::normalizedPotential(double outp) const
{
        return (outp - _minOut) / (_maxOut == _minOut ? 1 : _maxOut - _minOut);
}
 
inline double SubAdaptive::unNormalizedPotential(double nout) const
{
        double  outp;
 
        outp = _minOut + nout * (_maxOut == _minOut ? 1 : _maxOut - _minOut);
        /* truncate subadaptive unNormalized output : to prevent errors from
         * crazy subadaptive models. */
        if (outp < _minOut) outp = _minOut;
        else if (outp > _maxOut) outp = _maxOut;
        return outp;
}
 
}
 
#endif