---

patternset.h

Go to the documentation of this file.

#ifndef __TRAINSET_H__
#define __TRAINSET_H__

#include <magic/mobject.h>
#include <magic/mmath.h>
#include <magic/mmatrix.h>
#include <magic/mattribute.h>
#include <magic/mpararr.h>


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

class PatternSource : public Object, public Attributed {
    decl_dynamic (PatternSource);
  public:
                    PatternSource       ();

                    PatternSource       (const PatternSource& orig);

    virtual void    print           (FILE* out = stdout) const {MUST_OVERLOAD}

    virtual double  input           (int p, int i) const {MUST_OVERLOAD; return 0.0;}

    virtual double  output          (int p, int j) const {MUST_OVERLOAD; return 0.0;}
    virtual void    set_input       (int p, int i, double value) {MUST_OVERLOAD;}
    virtual void    set_output      (int p, int j, double value) {MUST_OVERLOAD;}

    virtual int     getClass        (int p) const;

    virtual void    recombine       (int startp=-1, int endp=-1) {MUST_OVERLOAD;}

    virtual void    recombine2      (int startp=-1, int endp=-1) {MUST_OVERLOAD;}
    
    // Common operations
    
    virtual void    copy            (const PatternSource& other, int startp=-1, int endp=-1);

    void            operator=		(const PatternSource& other) {copy (other);}

    const String&   name            () const {return mName;}

    void            setName         (const String& name) {mName=name;}

    void            join            (const PatternSource& a, const PatternSource& b);

    void            split           (PatternSource& a, PatternSource& b, double ratio) const;

    void            filter          (const PatternSource& source, const String& bits);

    int             classes         () const {return (outputs==1)? 2:outputs;}

    Array<int>      countClasses    () const;

    void            check           () const;

    int inputs;

    int outputs;

    int patterns;

    enum psetflags {INPUTS=1, OUTPUTS=2};

  protected:
    String  mName;

    virtual void    make        (int patterns, int inputs, int outputs) {MUST_OVERLOAD}
    void            make1       (int patterns, int inputs, int outputs);
    
};

#define TrainingSet PatternSource



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

class PatternSet : public PatternSource {
  public:

                        PatternSet  () {}

                        PatternSet  (int patts, int ins, int outs);
    
                        PatternSet  (const String& fname, int ins=0, int outs=0);

                        PatternSet  (const Matrix& m, int ins=-1, int outs=0);
    
                        PatternSet  (const PatternSet& orig);
                
                        ~PatternSet () {}

    void                make            (int patts=0, int ins=0, int outs=0);

    enum filetypes {FT_SNNS=0, FT_RAW=1};
    
    virtual void        load        (const char* filename);
    virtual void        load        (TextIStream& in, const String& extension=".raw");
    void                save        (const String& filename, int filetype=FT_SNNS);
    
    // Virtual method implementations

    virtual void        print           (FILE* out = stdout) const;

    virtual double      input           (int p, int i) const {return mInps.get (p,i);}

    virtual double      output          (int p, int j) const {return mOutps.get (p,j);}

    virtual void        set_input       (int p, int i, double value) {mInps.get (p,i) = value;}

    virtual void        set_output      (int p, int j, double value) {mOutps.get (p,j) = value;}

    Ref<Matrix>         getMatrix       () const;

    void                mutate          (int errcnt);

    void                recombine       (int startp=-1, int endp=-1);

    void                recombine2      (int startp=-1, int endp=-1);
    
    virtual void        copy            (const PatternSet& orig, int start=-1, int end=-1);

    void                check           () const;

  protected:
    Matrix          mInps;

    Matrix          mOutps;

    //Array<String>*    mComments;

    void            calc_means      ();

    void            calc_stddevs    ();

  private:
    void operator= (const PatternSet& orig) {FORBIDDEN}
};



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

class ArrayTrainSet : public PatternSource {
  public:

                    ArrayTrainSet   (int inputs, int outputs, char* filename);
                    ~ArrayTrainSet  () {;}

    virtual void    make            (int patterns, int inputs, int outputs) {FORBIDDEN}

    // Virtual method implementations
    
    virtual void    print           (FILE* out = stdout) const;
    virtual double  input           (int p, int i) const {return data[p+i];}
    virtual double  output          (int p, int j) const {return data[p+inputs+j];}

    // New methods
    
    void            multiply        (double k);

    void            truncate        (int size);

  public:
    Array<double>   data;

};

#endif

---