artmap.h

Go to the documentation of this file.

#ifndef ARTMAP_H
#define ARTMAP_H

#include <iostream>
#include <vector>
#include <fstream>
#include <valarray>

#include "Logger.h"
#include "MsgException.h"
#include "util.h"

using std::ifstream;
using std::vector;
using std::string;
using std::istringstream;

#ifndef ARTMAP_DLL
#define ARTMAP_DECLSPEC
#else
#ifdef ARTMAP_IMPORT
#define ARTMAP_DECLSPEC __declspec(dllimport)
#else
#define ARTMAP_DECLSPEC __declspec(dllexport)
#endif
#endif

class ARTMAP_DECLSPEC artmap {
 public:
  typedef enum RunModeType { FUZZY, DEFAULT, IC, DISTRIB };

 private:
  RunModeType NetworkType;  

  int     M;          
  int     L;          
  
  float   RhoBar;     
  float   RhoBarTest; 
  float   Alpha;      
  float   Beta;       
  float   Eps;        
  float   P;          
  
  int     C;          
  
  int     J;          
  int     K;          

  float   rho;        

  float * A;          
  float * x;          
  float * y;          
  float * Y;          
  float * T;          
  float * S;          
  float * H;          
  float * c;          
  bool  * lambda;     
  float * sigma_i;    
  float * sigma_k;    
  int   * kap;        
  float * dKap;       
  float * tIj;        
  float * tJi;        

  bool    dMapWeights;  

  /* Utility variables (not in algorithm) */
  float  Tu;          
  float  sum_x;       
  int    _2M;         
  int    N;           
  int    i, j, k;     

  void complementCode(float  *a);
  int  F0_to_F2_signal();
  void newNode();
  void CAM_distrib();
  void CAM_WTA();
  void F1signal_WTA();
  void F1signal_distrib();
  bool passesVigilance();
  int  prediction_distrib();
  int  prediction_WTA();
  void matchTracking();
  void creditAssignment();
  void resonance_distrib();
  void resonance_WTA();
  void growF2 (float  factor);

  float cost(float x) { return ((2-Alpha)*M - x); }
  ofstream *ostCategoryActivations;
  void toStr();
  void toStr_dimensions();
  void toStr_A();
  void toStr_nodeJTSH(int j);
  void toStr_nodeJdetails(int j);
  void toStr_nodeJtauIj(int j);
  void toStr_nodeJtauJi(int j);
  void toStr_x();
  void toStr_sigma_i();
  void toStr_sigma_k();
    
 public:
         artmap    (int M, int L);
        ~artmap();
  void   train     (float  *a, int K);
  void   test      (float  *a);
  float  getOutput (int k) { return sigma_k[k]; }
  int    getMaxOutputIndex () { 
    std::valarray<float> outs = std::valarray<float> (sigma_k, L);
    return getIndexOfMaxElt (outs);
  }

  void   fwrite    (ofstream &ofs);
  void   fread     (ifstream &ifs, string &specialRequest);

  void setParam (const string &name, const string &value);
  int         getC()            { return C;           }
  int         getNodeClass (int j) { if ((j < 0) || (j > C) || dMapWeights) { return -1; } else { return kap[j]; } }
  int         getLtmRequired () { return C * M * 2 * sizeof (float ); }
  float  &tauIj (int i, int j);
  float  &tauJi (int i, int j);
  int     getOutputType (const string &name);
  int     getInt        (const string &name);
  float   getFloat      (const string &name);
  string &getString     (const string &name);

  void    requestOutput (const string &name, ofstream *ost);
  void    closeStreams  ();

  void setNetworkType (RunModeType v) { NetworkType = v; } 
  void setM           (int         v) { M     = v; }       
  void setL           (int         v) { L     = v; }       
  void setRhoBar      (float       v) { RhoBar      = v; } 
  void setRhoBarTest  (float       v) { RhoBarTest  = v; } 
  void setAlpha       (float       v) { Alpha       = v; } 
  void setBeta        (float       v) { Beta        = v; } 
  void setEps         (float       v) { Eps         = v; } 
  void setP           (float       v) { P           = v; } 

  RunModeType getNetworkType() { return NetworkType; }     
  int         getM()           { return M;           }     
  int         getL()           { return L;           }     
  float       getRhoBar()      { return RhoBar;      }     
  float       getRhoBarTest()  { return RhoBarTest;  }     
  float       getAlpha()       { return Alpha;       }     
  float       getBeta()        { return Beta;        }     
  float       getEps()         { return Eps;         }     
  float       getP()           { return P;           }     
};

/* Used to iterate the 'official' indices */
#define foreach_i for (i = 0; i < _2M; i++)
#define foreach_j for (j = 0; j <   C; j++) 
#define foreach_k for (k = 0; k <   L; k++)

#define forall_j  for (j = 0; j < N; j++)

#endif

---