Mail Archives: djgpp/2003/01/28/00:53:09
Dear Sir,
I got the following errors(The file is at the bottom):
LSTM1.cpp: In member function `virtual char TLSTM::LoadPar()':
LSTM1.cpp:36: no matching function for call to `std::basic_fstream<char,
std::char_traits<char> >::scan(const char[17])'
LSTM1.cpp: In member function `char TLSTM::WriteWeightFile(char*)':
LSTM1.cpp:45: using typedef-name `std::iostream' after `class'
How to fix the problem about "no matching function..." and "using typedef-name `std::iostream' after `class' "? Thanks a lot for your help.
Regards,
Y Chen
// LSTM.cpp
#include <iostream>
#include <cstdlib>
//#include <fstream>
using namespace std;
//#include <stdlib.h>
#include <stdio.h>
//#include <iostream.h>
#include <iomanip.h>
#include <new.h> // for memory error handling
//#include <ctype.h>
#include <unistd.h> // sleep
//#include <termios.h> // struct termios
#include <fcntl.h>
#include <sys/param.h>
#include <math.h>
#include <errno.h>
#include <string.h>
#include <time.h>
#include <float.h> // To have max values for imposible inits.
#include "LSTM.h"
//// TLSTM
char TLSTM::LoadPar() {
double NotUsed;
if (TNeuralNetBase::LoadPar()) return 1;
if (OpenFile(cParFilename, ios::in)) return 1;
if (ReadComment()) return 1;
// Scan for the starting point in the parameter file.
//******
pFile->scan("NbPredictNextIn:");
return CloseFile();
}
char TLSTM::WriteWeightFile(char *FileName) {
if (OpenFile(FileName, ios::out)) return 1;
pFile->precision(PRECISION);
//******
WriteWeightStream(pFile,(void (*)(class iostream *, double &))&d2s,true);
return CloseFile();
}
///////////////////main
main(int argc, char **argv)
{
}
// LSTM.h
#include <iostream.h>
#include <strstream.h>
#include "NeuralNetBase.h"
//// defines
// switch for all debugging info
//#define DEBUG
//#define DEBUG_ONLINE_TO_COUT
#undef PARFILE
#define PARFILE "LSTM.par"
#define INNERSTATE_DUMP_LOGFILE "S_Dump.log"
#define FGGATE_Y_LOGFILE "Fg_y.log"
// Max number of MemoBlocks for a growing net.
#define MAX_MEMOBLOCKS 10
//#define NO_IN_OUT_SHORTCUTS
//#define CONNECT_GATES_TO_S
//#define CONNECT_TO_GATES
//#define CONNECT_GATES_OF_SAME_BLOCK
//#define USE_CELL_BIAS
//#define RECURRENT_OUTPUT
#define G_SIGMOID
//#define G_TANH
//#define G_RATIONAL_FUNC
//#define G_LINEAR
#define H_SIGMOID
//#define H_TANH
//#define H_RATIONAL_FUNC
//#define H_LINEAR
#define Yfg_SIGMOID 0
//#define Yfg_SHIFTEDPOLY
//#define RATIONAL_RECURSION
//#define USE_FORGET_GATES
//// classes in this header
class TLSTM;
////LSTM
class TLSTM : public TNeuralNetBase {
public:
TLSTM() { strcpy(cParFilename, PARFILE); }
~TLSTM() {}
virtual char Run();
private:
void InitNet();
virtual char LoadPar();
void InitMemoBlocks(unsigned int BegBlock, unsigned int EndBlock);
void DeleteNet();
char AddMemoBlock(int BegSrcBlockNb, int EndSrcBlockNb, int MemoBlockSize);
void AddMemoBlockToExistingBlocks(unsigned int BegBlock,
unsigned int EndBlock);
void ResetNet();
// For testing and freezing set the blocks for which we need derivatives.
void ForwardPass(struct TPatData &PatData,
unsigned int BegBlockDeriv, unsigned int EndBlockDeriv);
void BackwardPass(unsigned int BegBlock, unsigned int EndBlock);
#ifdef UPDATE_WEIGHTS_AFTER_SEQ
void ExecuteWeightChanges(unsigned int BegBlock, unsigned int EndBlock);
#endif
void PatStatistics(struct TPatData &PatData);
void SeqStatistics(struct TPatData &PatData);
void EpoStatistics(struct TPatData &PatData);
unsigned int Test();
char WriteWeightFile(char *FileName);
// For display and fileIO.
char WriteWeightStream(iostream *s,
void(*f)(iostream *s, double &d),
bool WriteWhiteSpace);
char LoadWeightFile(char *FileName);
char DumpAll(char *FileName);
void WriteNetStream(iostream *s, struct TPatData &PatData);
void DisplayNet(struct TPatData &PatData);
void DisplayWeights();
char WriteOutLogFile(char *FileName);
char Dump_Inner_States();
char DumpSomeAlphas(); // debugging local learning.
void TopoCheck();
void SetTopoStatistics();
char GetOnlineProblemStatistics();
// Inline functions.
// G().
#ifdef G_SIGMOID
void G(double x,double &g) {
if(x>709) { x=709; } //cerr << Tri <<"- x>709 in G()\n"; g=2; return; }
else if(x<-709){ x=-709; } //cerr << Tri <<"- x<709 in G()\n"; g=-2; return; }
g=2*LOGC(x)-1; }
void G_d(double g,double &gd) { gd=0.5*(1-g*g); }//gd=1-g*g*0.25; }
#endif
#ifdef G_TANH
void G(double x,double &g) { g=tanh(x); }
void G_d(double g,double &gd) { gd=(1-g*g); } // tanh_d
#endif
#ifdef G_RATIONAL_FUNC
double g__frac;
void G(double x,double &g) { g__frac=1/(1+fabs(x)); g=x*g__frac; }
void G_d(double &gd) { gd=SQR(g__frac); }
#endif
#ifdef G_LINEAR
void G(double x,double &g) { g=x; }
void G_d(double &gd) { gd=1; }
#endif
// H().
#ifdef H_SIGMOID
void H(double s,double &h) {
if(s>709) { s=709; } //cerr << Tri <<"- s>709 in H()\n"; h=1; return; }
else if(s<-709){ s=-709; }//cerr << Tri <<"- s<709 in H()\n"; h=-1; return; }
h=2*LOGC(s)-1; }
double H_d(double h) { return (0.5*(1-h*h)); }
#endif
#ifdef H_TANH
void H(double s,double &h) { h=tanh(s); }
double H_d(double h) { return (1-h*h); } // tanh_d
#endif
#ifdef H_RATIONAL_FUNC
double h__frac;
void H(double s,double &h) { h__frac=1/(1+fabs(s)); h=s*h__frac; }
double H_d() { return (SQR(h__frac)); }
#endif
#ifdef H_LINEAR
void H(double s,double &h) { h=s; }
double H_d() { return 1; }
#endif
// Yfg
#ifdef Yfg_SHIFTEDPOLY
double Yfg__frac;
void Yfg(double x,double &y) { Yfg__frac=1/(1+fabs(x)); y=x*Yfg__frac+1; }
double Yfg_d(double y,double &df) { df=Yfg__frac*Yfg__frac; return df; }
#endif
#ifdef Yfg_SIGMOID
void Yfg(double x,double &y) {
if(x>709) { x=709; }//cerr << Tri <<"- x>709 in Yfg()\n"; y=1; return; }
else if(x<-709){ x=-709; }//cerr << Tri <<"- x<709 in Yfg()\n"; y=-1; return; }
y= (1+Yfg_SIGMOID) * LOGC(x) - Yfg_SIGMOID; }// y=1/(1+EXP(-x)); }
double Yfg_d(double y,double &df) { //y*(1-y);
df=1/(Yfg_SIGMOID+1)*(y+Yfg_SIGMOID)*(1-y); return df; }
#endif
struct Ts_d_Gate { double s_d,alpha,h; }; // Here for follow. func..
void NewTs_d_Gate(Ts_d_Gate *&sd, unsigned int size);
void NewTs_d_Gate(Ts_d_Gate &sd); // For the biases.
// Function for the derivative update.
#if defined(USE_FORGET_GATES) && defined(RATIONAL_RECURSION)
double frac_abs_s_NegNet, frac_1_Sqr, frac_Sqr_s_NegNet;
#endif
void Update_Cell_s_d(double &s_d,int iB, double y_t1) {
#ifdef USE_FORGET_GATES
#ifndef RATIONAL_RECURSION
s_d *= MemoBlock[iB].FgGate.y;
#else
s_d *= frac_1_Sqr;
#endif
#endif
s_d += g_d__y_in*y_t1;
}
void Update_InGate_s_d(double &s_d, int iB, double y_t1) {
#ifdef USE_FORGET_GATES
#ifndef RATIONAL_RECURSION
s_d *= MemoBlock[iB].FgGate.y;
#else
s_d *= frac_1_Sqr;
#endif
#endif
s_d += y_in_d__g*y_t1;
}
#ifdef USE_FORGET_GATES
void Update_FgGate_s_d(double &s_d, int iB, double y_t1) {
#ifndef RATIONAL_RECURSION
s_d *= MemoBlock[iB].FgGate.y;
s_d += y__fg_d__s_t1*y_t1;
#else
s_d *= frac_1_Sqr;
s_d += frac_1_Sqr * frac_Sqr_s_NegNet * y_t1;
#endif
}
#endif
// Fields.
struct TCell {
double net,g,s,s_t1,h,y,y_t1; // s_t1 for the forget gates.
TWeight *w_In, **w_Cell, *w_InGate, *w_OutGate, w_Bias;
double *s_d_In, **s_d_Cell, *s_d_InGate, *s_d_OutGate, s_d_Bias;
Ts_d_Gate *s_d_InGate_In, *s_d_InGate_s, **s_d_InGate_Cell,
*s_d_InGate_InGate, *s_d_InGate_OutGate, s_d_InGate_Bias;
#ifdef USE_FORGET_GATES
Ts_d_Gate *s_d_FgGate_In, *s_d_FgGate_s, **s_d_FgGate_Cell,
*s_d_FgGate_InGate, *s_d_FgGate_OutGate, s_d_FgGate_Bias;
#endif
double e_unscaled,e;
};
double g_d,g_d__y_in,y_in_d__g,InGate_df,FgGate_df; // For calculations.
#ifdef USE_FORGET_GATES
double y__fg_d__s_t1;
#endif
struct TMemoBlock {
unsigned int MemoBlockSize;
// For not fully connected growing net.
// InputBeginBlockNb<= b < InputEndBlockNb (if==-1 -> NbMemoBlocks).
int BegSrcBlockNb, EndSrcBlockNb;
struct {
double net,y,y_t1;
TWeight *w_In, *w_s, **w_Cell, *w_InGate, *w_OutGate, w_Bias;
} InGate;
struct {
double net,y,y_t1,e,df,delta;
TWeight *w_In, *w_s, **w_Cell, *w_InGate, *w_OutGate, w_Bias;
} OutGate;
#ifdef USE_FORGET_GATES
// No connections from the FgGate, so no y_t1 and also no self connection.
struct {
double net,y;//,y_t1;
#ifdef RATIONAL_RECURSION
double exp_NegNet;
#endif
TWeight *w_In, *w_s, **w_Cell, *w_InGate, *w_OutGate, w_Bias;
} FgGate;
#endif
TCell *Cell;
} *MemoBlock;
struct TOut {
double net,y,e,df,delta;
TWeight *w_In, **w_Cell, *w_Hidden, w_Bias;
} *Out;
struct THidden { // BP units.
double net,y,e,df,delta;
TWeight *w_In, **w_Cell, w_Bias;
} *Hidden;
struct TPredictNextIn { // BP units.
double net,y,e,df,delta;
TWeight *w_In, *w_InClass, **w_Cell;
} *PredictNextIn;
struct TNextIn { // Out units for PredictNextIn.
double net,y,e,df,delta;
TWeight *w_PredictNextIn;
} *NextIn;
struct TPredictClass { // BP units.
double net,y,e,df,delta;
TWeight **w_Cell;
} *PredictClass;
struct TPredictClassOut { // Out units for PredictClass.
double net,y,e,df,delta;
TWeight *w_PredictClass;
} *PredictClassOut;
// Parameter for topology.
unsigned int NbPredictNextIn;
unsigned int NbPredictClass;
unsigned int NbPredictOut; // To calculate MSE.
// Use cell-cell, gate-to-cell connection inside block.
bool InternalBlockConect;
unsigned int NbMemoBlocks; // The block size is stored in TMemoBlock.
unsigned int FreezeEndBlock; // Lower Block number are frozen.
// LSTM statistics.
unsigned int NbCells, NbMemUnits;
// debugging.
//double ddd;
};
//NeuralNetBase.h
#include "PatternManagement.h"
#include "MathMacros.h"
//// defines
// Output file names. PARFILE should be redefined.
#define PARFILE "NNB.par"
#define ERRORLOGFILE "Error.log"
#define TEST_ERRORLOGFILE "TestError.log"
#define MSELOGFILE "MSE.log"
#define TEST_MSELOGFILE "TestMSE.log"
#define GROWLOGFILE "Grow.log"
#define WEIGHTLOGFILE "Weight.log"
#define DUMP_FILE "dump"
#define WEIGHTMEAN_LOGFILE "WeightMean.log"
#define ALPHAMEAN_LOGFILE "AlphaMean.log"
#define OUT_LOGFILE "Out.log"
#define ONLINEPATTICKS_LOGFILE "OnlinePatTicks.log"
// Algorithm.
//#define USE_LOCAL_ALPHA
//#define USE_LOCAL_ALPHA_SEQUENCEWISE
//#define MOMENTUM 0.99
//#define USE_WEIGHT_DECAY
//#define RESTRICT_WEIGHT_RANGE 100000
//#define USE_ALPHA_DECAY_IN_SEQ 5
//#define ALPHA_DECAY_IN_SEQ_LINEAR
//#define DO_WEIGHT_STATISTICS
//#define UPDATE_WEIGHTS_AFTER_SEQ
//#define DO_ONLINE_PAT_PRODUCTION
// For TempOrder, TempXOR task:
//#define NO_RESET_AFTER_ONLINE_SEQ
// For Timer task:
//#define SETSTEPTARGET_BUT_COUNT_SEQUENCEWISE
//#define ONLINE_PAT_FUNCNAME Online_ReberGrammar
//#define ONLINE_PAT_FUNCNAME Online_SlidingNBitMemory
//#define ONLINE_PAT_FUNCNAME Online_TempOrderEx6
//#define ONLINE_PAT_FUNCNAME Online_AddMulti
#define ONLINE_PAT_FUNCNAME Online_Timer
#define PRECISION 10
//#define BUFFER_EPO_LOG
//#define LOG_LIKELIHOOD_GATES
//#define LOG_LIKELIHOOD_CELLS
//#define LOG_LIKELIHOOD_OUTPUT
//#define LINEAR_OUTPUT
//#define USE_ERROR_SPLIT
//// classes in this header
class TEpoLogBuf;
class TNeuralNetBase;
////TEpoLogBuf
// Buffer for the epo log files.
class TEpoLogBuf {
public:
TEpoLogBuf();
~TEpoLogBuf();
void Init(unsigned int MaxBuf, unsigned int aAverageBuf);
void Reset();
void AddValue(unsigned int iEpo, double aVal);
unsigned int Max, NbVal, *BufEpo;
double *BufVal, *BufMin, *BufMax, ValMin, ValMax;
unsigned int AverageBuf, AverageCount;
};
////NeuralNetBase
class TNeuralNetBase : public TPatternGenerator {
public:
TNeuralNetBase();
~TNeuralNetBase() {}
virtual char Run();
protected:
char Init();
virtual char LoadPar();
char WriteLogfileEpo(char *FileName, double val);
char WriteLogfileEpo(char *FileName, double val0, double val1);
char FlushEpoLogBuf(char *FileName, TEpoLogBuf &EpoLogBuf);
char WriteOnlinePatTicks(char *FileName, double val);
void KeyCheck();
// Inline functions.
void log_sig(double x,double &y) {
if(x>709){x=709;}//cerr << Tri <<"- x>709 in log_sig()\n"; y=1; return;}
else if(x<-709){x=-709;}//cerr << Tri <<"- x<709 in log_sig()\n"; y=-1; return; }
y=LOGC(x); }//y=1/(1+EXP(-x)); }
double log_sig_d(double y,double &df) { df=y*(1-y); return df; }
double log_sig_d(double y) { return(y*(1-y)); }
double tanh_d(double y,double &df) { df=1-y*y; return df; }
double tanh_d(double y) { return (1-y*y); }
//{df=EXP(y); df=df/(1+df)*(1+df); return df;}
//{ df=y*(1-y); return df; }
// Parameter
char cParFilename[101];
unsigned int NbTrials;
long RandomSeed;
unsigned int MaxEpochs, EpochsAfterLearned, TestEpochs;
unsigned int TestEach_Epo, TestMaxEach_Epo, LastTestEpo; // 0 -> no tests.
double Alpha, AlphaBase, AlphaError, AlphaPredict, AlphaDecayInSeq;
double InitWeightRange, OutUnitBiasInitWeight, HiddenUnitBiasInitWeight;
bool GrowNet, GrowFullyNotCascade, GrowFirstOrder, FreezeAndGrow;
bool SetStepTarget;
// Parameter for topology.
unsigned int NbIn, NbOut, NbHidden;
// Parameter for Data,
// To generate the pattern instead of loading them from a file.
bool MixTrainSeqs, Generate_Pat;
unsigned int Generate_Pat_Each_Epoch;
unsigned int Generate_Pat_NbLoopAllSeqs_Test;
unsigned int Generate_Pat_NbLoopAllSeqs_Train;
char Pat_FuncName[256];
// Variables for statistics.
unsigned int PatWrong, ClassesWrong, TestClassesWrong;
double PatCorrect, PatCorrectTest; // For continuous prediction.
double MaxPatCorrectTrain; // To test only when improved.
bool StopLern;
double ClassesWrongRel;
unsigned int ClassNb, WinnerNb;
unsigned int LogErrRecSize, PartLogErrRecSize, NbLogedErr;
double LogErrRecMean, PartLogErrRecMean;
double MSEPat, MSESeq, MSEEpo, MSEStop, MaxMSE, TestMSEEpo;
double WeightMean, AlphaMean, AlphaStd;
double NbWeights;
// Debug variables.
double WeightsCount;// WPC;
bool OutputDebug;
// Global working variables (same as ).
unsigned int Tri, Epo, TestEpo, Seq, SeqOnline, Pat, Val;
unsigned int SeqOnlinePatCount; // For Dump_Inner_States numbering.
bool FreezeSeqLoop; // For sequencewise online pat generation.
// Variables for display and user interaction.
char cKey;
char cBuf[256];
char cPrecision, cWidth;
// Buffer
#ifdef BUFFER_EPO_LOG
TEpoLogBuf TrainMSEEpoLogBuf, TrainErrEpoLogBuf,
TestErrEpoLogBuf, TestMSEEpoLogBuf;
#endif
unsigned int AverageTrainBuf; // Alwaus defined, for the .par file.
// Defines for the local learning rate.
double Alpha_ROH, Alpha_MUE;
struct TWeight { double w;
#ifdef UPDATE_WEIGHTS_AFTER_SEQ
double Dw;
#endif
#ifdef MOMENTUM
double Dw_t1;
#endif
double alpha,h; }; // For Nic's K1.
void NewWeight(TWeight *&pW, unsigned int size);
void NewWeight(TWeight *&pW, unsigned int size, double InitWeight);
void NewWeight(TWeight &W, double InitWeight);
void NewWeight(double *&pW, unsigned int size);
void AdjustAlphaAndWeights(double delta,double df,
double yt1,TWeight &W) {
double dw;
#ifndef USE_LOCAL_ALPHA
dw = W.alpha * delta * yt1;
#ifdef MOMENTUM
dw += MOMENTUM * W.Dw_t1; W.Dw_t1 = dw;
#endif
#ifdef USE_ALPHA_DECAY_IN_SEQ
dw *= AlphaDecayInSeq;
#endif
#ifdef USE_WEIGHT_DECAY
// Weight decay.
if(((W.w>0)&&(dw>0))||((W.w<0)&&(dw<0))) dw *=0.9;
#endif
#ifdef UPDATE_WEIGHTS_AFTER_SEQ
W.Dw += dw;
#else
W.w += dw;
#endif
//W.w *= 0.999;
#else
double delta_yt1 = delta*yt1;
double df_yt1 = df*yt1;
// Calc alpha.
double bracket = 1+Alpha_MUE*W.h*delta_yt1;
if(bracket<Alpha_ROH) bracket=Alpha_ROH;
W.alpha *= bracket;
// Update w.
dw = W.alpha * delta_yt1; W.w += dw;
// Calc h.
double k = W.alpha * df_yt1;
bracket = 1 - k * df_yt1; if(bracket<0) bracket=0;
W.h = W.h * bracket + dw;
#endif
#ifdef DO_WEIGHT_STATISTICS
// Some global statistics.
WeightMean += fabs(W.w);
//AlphaMean += W.alpha; AlphaStd += SQR(W.alpha); //WPC++;
#endif
#ifdef RESTRICT_WEIGHT_RANGE
if(fabs(W.w)>RESTRICT_WEIGHT_RANGE) W.w=RESTRICT_WEIGHT_RANGE;
#endif
}
void RTRLAdjustAlphaAndWeights(double s_d,double e,double &alpha,
double &h,TWeight &W) {
double dw;
#ifndef USE_LOCAL_ALPHA
dw = alpha * s_d * e;
#ifdef MOMENTUM
dw += MOMENTUM * W.Dw_t1; W.Dw_t1 = dw;
#endif
#ifdef USE_ALPHA_DECAY_IN_SEQ
dw *= AlphaDecayInSeq;
#endif
#ifdef USE_WEIGHT_DECAY
// Weight decay.
if(((W.w>0)&&(dw>0))||((W.w<0)&&(dw<0))) dw *=0.9;
#endif
#ifdef UPDATE_WEIGHTS_AFTER_SEQ
W.Dw += dw;
#else
W.w += dw;
#endif
#else
// If USE_LOCAL_ALPHA. Calc alpha.
double bracket = 1+Alpha_MUE*h*e*s_d;
if(bracket<Alpha_ROH) bracket=Alpha_ROH;
alpha *= bracket;
// Update w.
double k = alpha * s_d;
dw = e * k; W.w += dw;
// Calc h.
bracket = 1 - k * s_d; if(bracket<0) bracket=0;
h = h * bracket + dw;
#endif
#ifdef DO_WEIGHT_STATISTICS
// Some global statistics.
WeightMean += fabs(W.w);
//AlphaMean += W.alpha; AlphaStd += SQR(W.alpha); //WPC++;
#endif
#ifdef RESTRICT_WEIGHT_RANGE
if(fabs(W.w)>RESTRICT_WEIGHT_RANGE) W.w=RESTRICT_WEIGHT_RANGE;
#endif
}
#ifdef UPDATE_WEIGHTS_AFTER_SEQ
void ExecuteWeightChange(TWeight &W) { W.w += W.Dw; W.Dw=0; }
#endif
};
//PatternManger.h
#include <ctype.h>
#include <time.h>
#include "IOBase.h"
/*** defines ***/
// switch for all debugging info
//#define DEBUG// file names
#define TRAINPATFILE "Train.pat"
#define TESTPATFILE "Test.pat"
#define RESULTTRAINPATFILE "ResultTrain.pat"
#define RESULTTESTPATFILE "ResultTest.pat"
/*** classes in this header ***/
class TPatternManager;
class TPatternGenerator;
///////////////////TPatternManager
// a pattern has input output lists for one time step
// a sequece is a list of pattern
// TPatternManager manages a list of sequences
// the number of inputs and outputs are constant for all
// pattern in all sequence,
// it has to be the same as the number of in- and output units in the net
// In the pattern file sequences are devided by "\n\n", pattern by "\n".
// and in-out values by "\t" or ' '. No global parameters. The number of
// values in a pattern must be constant for the whole file.
class TPatternManager : public TIOBase {
public:
TPatternManager();
~TPatternManager();
char cTrainPatFilename[101]; // training pattern
char cTestPatFilename[101]; // test pattern
char cTrainPatFilenameResult[101]; // mixed training pattern
char cTestPatFilenameResult[101]; // mixed training pattern
char LoadTrainPattern();
char LoadTestPattern();
// One class one Output classification.
char InitPatternClassification(unsigned int NbIn, unsigned int NbOut);
char SaveTrainPattern(); // for debugging and Id'tk
char SaveTestPattern(); // for debugging and Id'tk
void MixTrainSequences();
// The PatData is public to give the UI direct access for faster dispaly.
struct TPatData { // at least one for train and one for test
unsigned int NbSeq;
unsigned int* NbPat; // number of pattern in each sequence[NbSeq]
unsigned int NbPatTotal;
unsigned int* NbClass; // classification of sequence[NbSeq]
unsigned int NbVal; // number of values in each pattern
double*** SeqList; //[NbSeq][NbPat[NbSeq]][NbVal] set NULL in constructor
} sTrainData, sTestData;
unsigned int iVal, iPat, iSeq; // i for pattern management (pub to see).
protected:
void CountNbPatTotal(struct TPatData &apsPatData);
// If the *NbPat == NULL take the const lenght
char NewPatData(struct TPatData &apsPatData, unsigned int ConstNbPat);
// For destructor and to reload pattern.
void DeletePattern(struct TPatData &apsPatData);
char InitPatternClassification(struct TPatData &apsPatData,
unsigned int NbIn,
unsigned int NbOut);
void CopyPatData(struct TPatData &apsPatDataDst,
struct TPatData &apsPatDataSrc);
void MixSequences(struct TPatData &apsPatData);
void TransPat2StepByStepPredictALL(unsigned int NbInUnits,
unsigned int NbOutUnits);
void TransPat2StepByStepClassiALL(unsigned int NbInUnits,
unsigned int NbOutUnits);
void TransPat2UseContextNet(unsigned int NbInUnits,
unsigned int NbOutUnits) {}
char SavePatternFileSeppFormat(struct TPatData &apsPatData,
char* acPatFilename,
unsigned int NbInUnits);
private:
char LoadPattern(struct TPatData &apsPatData, char* acPatFilename);
char SavePatternFile(struct TPatData &apsPatData, char* acPatFilename);
void TransPat2StepByStepPredict(unsigned int NbInUnits,
unsigned int NbOutUnits,
struct TPatData &apsPatData);
void TransPat2StepByStepClassi(unsigned int NbInUnits,
unsigned int NbOutUnits,
struct TPatData &apsPatData);
unsigned int NbValTemp; // to confirm file consistency
char cScanned; // for scanning
float f; // for scanning
unsigned int i,ii,iii,iv; // for loops
};
///////////////////TPatternGenerator
// Collection of problem. Replaces TPatternManger for applications that
// that need data generation.
class TPatternGenerator : public TPatternManager {
public:
TPatternGenerator() { NbLoopAllSeqs = 1; RefData=NULL; ForONLINE = false; }
~TPatternGenerator() {}
void Init_Rand_Seed();
void GeneratePattern(struct TPatData &apsPatData, const char* FunktionName);
void Set_LoopAllSeqs(unsigned int ui) { NbLoopAllSeqs = ui; }
// e.g. set the TrainData as reference to generate TestData (NULL to unset)
void Set_RefData(struct TPatData &apsPatData) { RefData=&apsPatData; }
protected:
void New_OnlinePatData(struct TPatData &apsPatData, unsigned int MaxNbPat);
// For Online pat by pat.
void PatByPat_Reber(double out); // works on the train data.
// We set the sizes of the PatData in the functions that generate them.
void LongVeryNoisyTimesSeries(struct TPatData &apsPatData);
void TempOrderEx6(struct TPatData &apsPatData);
void TempXOR(struct TPatData &apsPatData);
void Adding(struct TPatData &apsPatData);
void Laufband(struct TPatData &apsPatData);
void EmbeddedReberGrammar(struct TPatData &apsPatData);
void Sinus(struct TPatData &apsPatData);
void SpaceToTime(struct TPatData &apsPatData);
// Online problems that generate one pattern or sequence at a time.
unsigned int MaxOnlineStreamLengthTrain,
MaxOnlineStreamLengthTest; // target for online Pat generattion.
unsigned int PatCount;// For online pat generation statistcs.
void Online_TempOrderEx6(struct TPatData &apsPatData,
bool SetBackToSeqStart);
void Online_ReberGrammar(struct TPatData &apsPatData,
bool SetBackToSeqStart);
// For on-line production, protected to reset the net.
bool ForONLINE; // If online method uses (calls) generation method.
char ReberGrammarState;
char EmbeddedReberGrammarState;
void Online_SlidingNBitMemory(struct TPatData &apsPatData,
bool SetBackToSeqStart);
void Online_AddMulti(struct TPatData &apsPatData,
bool SetBackToSeqStart);
void Online_Timer(struct TPatData &apsPatData,
bool SetBackToSeqStart);
double AddMultiVal, AddMultiLastVal;
#define SlidingNBitMemorySize 4
double SlidingNBitMemory[SlidingNBitMemorySize];
char SlidingNBitMemoryPointer;
// variables protected to log the Temp order (Exp 6).
int t1,t2,t3,t4,tick;
int XNotYt1,XNotYt2,XNotYt3,XNotYt4;
private:
unsigned int NbLoopAllSeqs;
struct TPatData *RefData;
// The next possible outputs.
enum RberGrammarSymbol {B,T,P,S,X,V,E} RberGrammarSymbol_p1;
unsigned int i,ii,iii;// for loops
};
// MathMacros.h
#include <math.h>
//#include <machine/endian.h>
#define SQR(x) ((x) * (x))
// macro for fast exp
static union {
double d;
struct {
// machine dependent storage of multi-byte quantities.
#ifdef LITTLE_ENDIAN
int j, i;
#else
int i, j;
#endif
} n;
} _eco, _eco2;
#define EXP(y) ((_eco.n.i = (int)(1512775*(y)) + 1072632448,_eco.n.j=0),\
_eco.d)
/* logistic: logc(y) = EXP(y/2)/(EXP(y/2) + EXP(-y/2)) */
/* auxiliary constants */
#define POW_2_20 (1 << 20)
#define POW_1023 (1023*POW_2_20)
#define POW_2045 (2045*POW_2_20)
#define EXP_A (POW_2_20/M_LN2) /* use 1512775 for int */
#define LOGC(y) (_eco2.n.i = (int)(POW_1023 - (EXP_A/2)*(y)), \
_eco.n.i = (POW_2045 + POW_2_20) - _eco2.n.i, _eco.d/(_eco.d + _eco2.d))
//IOBase.h
#include <fstream.h>
/*** defines ***/
// switch for all debugging info
//#define DEBUG
/*** classes in this header ***/
class TIOBase;
///////////////////TTIOBase
// a container class for trival common variables and functions.
// Handle the fileIO.
class TIOBase
{
public:
// We leave the standart constructor empty, and do all the initializations
// in the other one. The empty one is necessairy for TTopoCreator and
// TPatternManager, becase their constructors are empty too. But as thier
// classes exist only virtually for TRNN, the empty constructor of
// TIOBase will never be called. So no one will realize that it doesn't
// do its work properly.
TIOBase();
~TIOBase();
protected:
// possible Mode parameters are defined in clsss ios (ios::out,in,...)
// The childs are responsible closing and deleting the file again.
char OpenFile(char* acFilename, int aiMode);
char OpenFile(fstream *apFile, char* acFilename, int aiMode);
char CloseFile();
char CloseFile(fstream *apFile);
char ReadComment();
bool DirContainsFile(bool SubSearch, char *fn);
int Keypressed(char &ac);
// Double to stream and the other way round.
static void d2s(iostream *s, double &d) { *s << d; }
static void s2d(iostream *s, double &d) { *s >> d; }
// For long doubles.
static void ld2s(iostream *s, long double &d) {
double dd; dd=(double)d; *s << dd; }
static void s2ld(iostream *s, long double &d) {
double dd; *s >> dd; d=dd; }
// We keep only one fstream object alive and open - close the files
// instead of new - delete an fstream object every time we read a file.
fstream *pFile; // common stream pointer for all childs
long lFilePos; // to rescan the file begining after the global section
char c; // to read comments
private:
char cFilename[101];
int iFileRdState; // the status of the file.
};
- Raw text -