---

prediction.h

Go to the documentation of this file.

#ifndef __PREDICTION_H__
#define __PREDICTION_H__

#include <magic/mmath.h>
#include <magic/mmatrix.h>
#include <magic/mmap.h>
#include <magic/mclass.h>
#include <magic/mpararr.h>
#include <inanna/annetwork.h>

class PatternSet;       // In patternset.h
class MatrixEqualizer;  // In equalization.h
class TrainingObserver; // In trainer.h



//                                                                           //
//  |   |                |    |       ___                    ----            //
//  |\ /|        _    |  | _  |       |  \   ___   |   ___  (      ___   |   //
//  | V |  __  |/ \  -+- |/ | | \   | |   |  ___| -+-  ___|  ---  /   ) -+-  //
//  | | | /  \ |   |  |  |  | |  \  | |   | (   |  |  (   |     ) |---   |   //
//  |   | \__/ |   |   \ |  | |   \_/ |__/   \__|   \  \__| ___/   \__    \  //
//                               \_/                                         //

class MonthlyDataSet : public Matrix {
  public:

            MonthlyDataSet  () {mFirstMonth0=mFirstYear=-1;}

            MonthlyDataSet  (const Matrix& matrix, int dateYYMM=0, int lag=0) : Matrix (matrix) {
                if (const MonthlyDataSet* set = dynamic_cast<const MonthlyDataSet*>(&matrix)) {
                    mFirstMonth0 = set->mFirstMonth0;
                    mFirstYear = set->mFirstYear;
                    mLag = set->mLag;
                } else {
                    mFirstMonth0 = (dateYYMM%100)-1;
                    mFirstYear = dateYYMM/100;
                    mLag = lag;
                }
            }

    Ref<MonthlyDataSet> sub             (int row0, int row1, int col0, int col1) const;

    int                 lag             () const {return mLag;}

    void                setLag          (int lag) {mLag=lag;}

    int                 firstMonth0     () const {return mFirstMonth0;}

    void                setFirstMonth0  (int m0) {mFirstMonth0=m0;}

  protected:
    int     mFirstMonth0;
    int     mFirstYear;
    int     mLag;
};


//                                                                                                          //
// ----                | o           o            -----                 ----                    |           //
// |   )      ___      |    ___   |           _     |    ___   ____  |  |   )  ___   ____       |  |   ____ //
// |---  |/\ /   )  ---| | |   \ -+- |  __  |/ \    |   /   ) (     -+- |---  /   ) (     |   | | -+- (     //
// |     |   |---  (   | | |      |  | /  \ |   |   |   |---   \__   |  | \   |---   \__  |   | |  |   \__  //
// |     |    \__   ---| |  \__/   \ | \__/ |   |   |    \__  ____)   \ |  \   \__  ____)  \__! |   \ ____) //
//                                                                                                          //

class PredictionTestResults : public Object {
  public:
                PredictionTestResults () {}

    void        make        (int variables);
    void        addValue    (int variable, double value);
    void        calculate   ();
    
    double      averageError;   // For all variables
    double      MSE;            // For all variables
    double      RMSE;           // For all variables
    Vector      averageErrors;  // For each variable
    Vector      MSEs;           // For each variable
    Vector      RMSEs;          // For each variable

    OStream&    operator>>	(OStream& out) const;

  private:
    int     mValues; 
    void operator = (const PredictionTestResults& o) {FORBIDDEN}
    PredictionTestResults (const PredictionTestResults& o) {FORBIDDEN}
};



//                                                                                          //
// ----                | o           o             ----                                     //
// |   )      ___      |    ___   |           _   (      |       ___   |   ___              //
// |---  |/\ /   )  ---| | |   \ -+- |  __  |/ \   ---  -+- |/\  ___| -+- /   )  ___  \   | //
// |     |   |---  (   | | |      |  | /  \ |   |     )  |  |   (   |  |  |---  (   \  \  | //
// |     |    \__   ---| |  \__/   \ | \__/ |   | ___/    \ |    \__|   \  \__   ---/   \_/ //
//                                                                               __/   \_/  //

class PredictionStrategy : public Object {
    decl_dynamic (PredictionStrategy);
  public:
                        PredictionStrategy  () {FORBIDDEN}
                        PredictionStrategy  (const String& name) : mName (name) {}

    virtual void        make                (const StringMap& params);
    virtual void        train               (const Matrix& traindata, int startmonth);
    virtual Ref<Matrix> predict             (const Matrix& testdata, int startmonth) const;
    virtual PredictionTestResults*  test    (const Matrix& testdata, int startmonth) const;
    virtual void        testCurve           (const Matrix& testdata, int startmonth, const String& filename) const;

    const String&       name                () const {return mName;}
    virtual int         inputMonths         () const {return mInputMonths;}
    
  protected:
    String  mName;

    int     mInputMonths;

    static Ref<Matrix>  rowDeltas           (const Matrix& matrix);
};

class PreviousYear : public PredictionStrategy {
    decl_dynamic (PreviousYear);
  public:
                        PreviousYear            () : PredictionStrategy ("PreviousYear") {mInputMonths=0;}
                        PreviousYear            (const StringMap& params);
    virtual void        train                   (const Matrix& traindata, int startmonth);
    virtual Ref<Matrix> predict                 (const Matrix& testdata, int startmonth) const;
    virtual int         inputMonths             () const {return 0;}
  protected:
    Matrix          mData;
};

class PreviousYearsAvg : public PredictionStrategy {
    decl_dynamic (PreviousYearsAvg);
  public:
                        PreviousYearsAvg        () : PredictionStrategy ("PreviousYearsAvg") {mInputMonths=0;}
                        PreviousYearsAvg        (const StringMap& params);
    virtual void        train                   (const Matrix& traindata, int startmonth);
    virtual Ref<Matrix> predict                 (const Matrix& testdata, int startmonth) const;
    virtual int         inputMonths             () const {return 0;}

  protected:
    Matrix          mMonthlyAvg;
};

class AverageDeltaPrediction : public PredictionStrategy {
    decl_dynamic (AverageDeltaPrediction);
  public:
                        AverageDeltaPrediction  () : PredictionStrategy ("AverageDelta") {mInputMonths=1;}
                        AverageDeltaPrediction  (const StringMap& params);
    virtual void        train                   (const Matrix& traindata, int startmonth);
    virtual Ref<Matrix> predict                 (const Matrix& testdata, int startmonth) const;
    const Matrix&       deltas                  () const {return mMonthAvg;}
    virtual int         inputMonths             () const {return 1;}
  protected:
    Matrix          mMonthAvg;
    PackArray<int>  mMonthCnt;
};

class CombinedPrediction : public PredictionStrategy {
    decl_dynamic (CombinedPrediction);
  public:
                        CombinedPrediction      () : PredictionStrategy ("CombinedPrediction") {}
                        CombinedPrediction      (const StringMap& params);
    virtual void        make                    (const StringMap& params);
    virtual void        train                   (const Matrix& traindata, int startmonth);
    virtual Ref<Matrix> predict                 (const Matrix& testdata, int startmonth) const;

  protected:
    Array<PredictionStrategy>   mPredictors;
    PackTable<int>          mPredictorChoises;

  private:
    int                 determineInputMonths    () const;
};

class ZeroDeltaPrediction : public PredictionStrategy {
    decl_dynamic (ZeroDeltaPrediction);
  public:
                        ZeroDeltaPrediction     () : PredictionStrategy ("ZeroDelta") {mInputMonths=1;}
                        ZeroDeltaPrediction     (const StringMap& params);
    virtual void        train                   (const Matrix& traindata, int startmonth);
    virtual Ref<Matrix> predict                 (const Matrix& testdata, int startmonth) const;
    virtual int         inputMonths             () const {return 1;}
  protected:
};


// |   |                       | ----                | o           o            //
// |\  |  ___             ___  | |   )      ___      |    ___   |           _   //
// | \ | /   ) |   | |/\  ___| | |---  |/\ /   )  ---| | |   \ -+- |  __  |/ \  //
// |  \| |---  |   | |   (   | | |     |   |---  (   | | |      |  | /  \ |   | //
// |   |  \__   \__! |    \__| | |     |    \__   ---| |  \__/   \ | \__/ |   | //

class AbsoluteNeuralPrediction : public PredictionStrategy {
    decl_dynamic (AbsoluteNeuralPrediction);
  public:
                        AbsoluteNeuralPrediction    (const char* name=NULL) : PredictionStrategy (name? name:"AbsoluteNeural")  {mpNetwork=NULL; rpObserver=NULL;}
                        ~AbsoluteNeuralPrediction   ();
    virtual void        make                        (const StringMap& params);
    virtual void        train                       (const Matrix& traindata, int startmonth);
    virtual Ref<Matrix> predict                     (const Matrix& testdata, int startmonth) const;

    void                setObserver                 (TrainingObserver* observer) {rpObserver=observer;}
    virtual void        load                        (TextIStream& in);
    virtual void        save                        (TextOStream& out) const;

  protected:
    ANNetwork*          mpNetwork;

    bool                mUseAllOutputs;

    bool                mUseAllInputs;

    int                 mVariable;

    bool                mGlobalEqualization;

    String              mHiddenTopology;

    StringMap           mParams;

    TrainingObserver*   rpObserver;

  protected:
    PatternSet*         makeSet                 (const Matrix& data, int startmonth) const;

  private:
    int                 inputVariables          (int datacolumns) const {return 12+mInputMonths*(mUseAllInputs? datacolumns : 1);}
    int                 outputVariables         (int datacolumns) const {return mUseAllOutputs? datacolumns : 1;}
};

class SingleNeuralPrediction : public AbsoluteNeuralPrediction {
    decl_dynamic (SingleNeuralPrediction);
  public:
                        SingleNeuralPrediction      () : AbsoluteNeuralPrediction ("SingleNeural")  {mpNetwork=NULL;}
    virtual void        make                        (const StringMap& params);
    virtual void        train                       (const Matrix& traindata, int startmonth);
    virtual Ref<Matrix> predict                     (const Matrix& testdata, int startmonth) const;

    virtual void        load                        (TextIStream& in);
    virtual void        save                        (TextOStream& out) const;

  protected:
    Array<ANNetwork>    mNetworks;
};

class DeltaNeuralPrediction : public PredictionStrategy {
    decl_dynamic (DeltaNeuralPrediction);
  public:
                        DeltaNeuralPrediction   () : PredictionStrategy ("DeltaNeural") {}
                        DeltaNeuralPrediction   (const StringMap& params);
    virtual void        train                   (const Matrix& traindata, int startmonth);
    virtual Ref<Matrix> predict                 (const Matrix& testdata, int startmonth) const;
  protected:
};

class StochasticPrediction : public PredictionStrategy {
  public:
    virtual void        make                        (const StringMap& params);
    virtual void        train                       (const Matrix& traindata, int startmonth);
    virtual Ref<Matrix> predict                     (const Matrix& testdata, int startmonth) const;

  protected:
    virtual Matrix  predictRun                  ();
};

class NeuralPrediction {
  public:
  protected:
};



//   _             | o     o              ----                                     |     o       //
//  / \            |    |      _         (      |       ___   |   ___              |       |     //
// /   \ |   |  ---| | -+- | |/ \   ___   ---  -+- |/\  ___| -+- /   )  ___  \   | |     | |---  //
// |---| |   | (   | |  |  | |   | (   \     )  |  |   (   |  |  |---  (   \  \  | |     | |   ) //
// |   |  \__!  ---| |   \ | |   |  ---/ ___/    \ |    \__|   \  \__   ---/   \_/ |____ | |__/  //
//                                  __/                                 __/   \_/                //

class PredictionStrategyLib {
  public:
                                    PredictionStrategyLib ();
    PredictionStrategy*             create      (int i) const;
    int                             strategies  () const {return mClassNames.size();}
    void                            registerCls (const String& classname) {mClassNames.add(classname);}
    static  PredictionStrategyLib&  instance    () {return sInstance;}
  protected:
    static PredictionStrategyLib    sInstance;
    Array<String>                   mClassNames;
};



// -----           o       ----                                                  //
//   |        ___      _   |   )  ___       ___         ___   |   ___       ____ //
//   |   |/\  ___| | |/ \  |---   ___| |/\  ___| |/|/| /   ) -+- /   ) |/\ (     //
//   |   |   (   | | |   | |     (   | |   (   | | | | |---   |  |---  |    \__  //
//   |   |    \__| | |   | |      \__| |    \__| | | |  \__    \  \__  |   ____) //

class TrainParameters {
  public:
                    TrainParameters () {defaults();}

    void            defaults        ();
    String          hiddenString    () const;
    Ref<StringMap>  getParams       () const;
    void            setParams       (const StringMap& map);
    void            write           (TextOStream& out) const;
    void            read            (TextIStream& in);

  public:
    int     trainCycles;
    float   delta0;
    float   deltaMax;
    float   weightDecay;
    bool    useWeightDecay;
    int     hidden1;
    int     hidden2;
    int     hidden3;
    int     runs;
    bool    allInputs;
    bool    allOutputs;
    bool    monthInputs;
    bool    equalizeGlobal;
    int     inputMonths;
};

#endif

---