├── src
    ├── NLPann.h
    ├── actvfunc.h
    ├── rnn.h
    ├── actvfunc.cpp
    ├── lstm.h
    ├── gru.h
    ├── bp.h
    ├── seq2vec.h
    ├── seq2seq.h
    ├── nlpmain.cpp
    ├── rnn.cpp
    ├── char2vec.h
    ├── gru.cpp
    ├── bp.cpp
    ├── lstm.cpp
    └── mainassist.h
├── .gitignore
├── README.md
├── LICENSE
└── makefile


/src/NLPann.h:
--------------------------------------------------------------------------------
 1 | /*NLPann.h header file by ValK*/
 2 | /*2019/3/29         version0.1*/
 3 | #ifndef __NLPANN_H__
 4 | #define __NLPANN_H__
 5 | 
 6 | #include "bp.h"
 7 | #include "rnn.h"
 8 | #include "lstm.h"
 9 | #include "gru.h"
10 | #include "actvfunc.h"
11 | #include "seq2seq.h"
12 | #include "seq2vec.h"
13 | #include "char2vec.h"
14 | 
15 | #endif
16 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Prerequisites
 2 | *.d
 3 | 
 4 | # Compiled Object files
 5 | *.slo
 6 | *.lo
 7 | *.o
 8 | *.obj
 9 | 
10 | # Precompiled Headers
11 | *.gch
12 | *.pch
13 | 
14 | # Compiled Dynamic libraries
15 | *.so
16 | *.dylib
17 | *.dll
18 | 
19 | # Fortran module files
20 | *.mod
21 | *.smod
22 | 
23 | # Compiled Static libraries
24 | *.lai
25 | *.la
26 | *.a
27 | *.lib
28 | 
29 | # Executables
30 | *.exe
31 | *.out
32 | *.app
33 | 
34 | .vscode
35 | easynlp
36 | ObjData.dat


--------------------------------------------------------------------------------
/src/actvfunc.h:
--------------------------------------------------------------------------------
 1 | /*actvfunc.h header file made by ValK*/
 2 | /*2019/5/7                        version 1.0*/
 3 | #ifndef __ACTIVATEFUNCTION_H__
 4 | #define __ACTIVATEFUNCTION_H__
 5 | 
 6 | #include <cmath>
 7 | 
 8 | double sigmoid(double);
 9 | double diffsigmoid(double);
10 | double tanh(double);
11 | double difftanh(double);
12 | double relu(double);
13 | double diffrelu(double);
14 | double leakyrelu(double);
15 | double diffleakyrelu(double);
16 | double elu(double);
17 | double diffelu(double);
18 | double clipgrad(double);
19 | 
20 | #endif
21 | 


--------------------------------------------------------------------------------
/src/rnn.h:
--------------------------------------------------------------------------------
 1 | /*rnn.h header file made by ValK*/
 2 | /*2019/3/24          version 0.1*/
 3 | #ifndef __RNN_H__
 4 | #define __RNN_H__
 5 | 
 6 | #include <iostream>
 7 | #include <cstring>
 8 | 
 9 | struct rnn_neuron
10 | {
11 |     double *in,*out,bia,*wi,*wh,*diff;
12 |     double transdiff,*transwi,*transwh,transbia;
13 | };
14 | 
15 | class NormalRNN
16 | {
17 | protected:
18 |     int INUM;
19 |     int HNUM;
20 |     int MAXTIME;
21 | public:
22 |     rnn_neuron *hide;
23 |     NormalRNN(int,int,int);
24 |     ~NormalRNN();
25 |     void Init();
26 |     void Datain(const std::string&);
27 |     void Dataout(const std::string&);
28 | };
29 | class DeepRNN
30 | {
31 | protected:
32 |     int INUM;
33 |     int HNUM;
34 |     int DEPTH;
35 |     int MAXTIME;
36 | public:
37 |     rnn_neuron *hlink;
38 |     rnn_neuron **hide;
39 |     DeepRNN(int,int,int,int);
40 |     ~DeepRNN();
41 |     void Init();
42 |     void Datain(const std::string&);
43 |     void Dataout(const std::string&);
44 | };
45 | 
46 | #endif
47 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # easyNLP
 2 | 
 3 | Do NLP without coding! (in fact it is the library of common models)
 4 | 
 5 | In this program i will use dynamic arrays to make neural networks which can do NLP tasks. (refactoring...)
 6 | 
 7 | ## Build
 8 | 
 9 | This project does not rely on any other third-party libraries.
10 | 
11 | Make sure you have `make`and `gcc` or `clang` in your environment. Then use this command:
12 | 
13 | ```bash
14 | make easynlp
15 | ```
16 | 
17 | Also can use `-j` to use multi-task of make.
18 | 
19 | ## Future Work
20 | 
21 | This repo is too old and i'm trying to make it running correctly. (and only running this program takes lots of time...)
22 | 
23 | `nlpmain.cpp` and `mainassist.h` are useless. If you really want to use this project, only do this:
24 | 
25 | ```C++
26 | #include "src/NLPann.h"
27 | ```
28 | 
29 | Add the `NLPann.h` as the header, then you could use all models in it.
30 | 
31 | The documention will be added later, but before this i'll make this project more like a `C++` project, not `C` project...
32 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2019 ValKmjolnir
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/src/actvfunc.cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | #include "actvfunc.h"
 3 | #include <cmath>
 4 | 
 5 | double sigmoid(double x){
 6 |     return 1.0/(1.0+std::exp(-x));
 7 | }
 8 | double diffsigmoid(double x){
 9 |     x=1.0/(1.0+std::exp(-x));
10 |     return x*(1-x);
11 | }
12 | double tanh(double x){
13 |     double t1=std::exp(x);
14 |     double t2=1.0/t1;
15 |     return (t1-t2)/(t1+t2);
16 | }
17 | double difftanh(double x){
18 |     x=tanh(x);
19 |     return 1-x*x;
20 | }
21 | double relu(double x){
22 |     return x>0? x:0;
23 | }
24 | double diffrelu(double x){
25 |     return x>0? 1:0;
26 | }
27 | double leakyrelu(double x){
28 |     return x>0? x:0.01*x;
29 | }
30 | double diffleakyrelu(double x){
31 |     return x>0? 1:0.01;
32 | }
33 | double elu(double x){
34 |     return x>0? (1+x):std::exp(x);
35 | }
36 | double diffelu(double x){
37 |     return x>0? 1:std::exp(x);
38 | }
39 | double clipgrad(double x){
40 |     double upper_threshold=0.01;
41 |     double lower_threshold=0.000001;
42 |     double sign=x>0? 1:-1;
43 |     x*=sign;
44 |     if(x>upper_threshold){
45 |         return sign*upper_threshold;
46 |     }else if(x<lower_threshold){
47 |         return lower_threshold*sign;
48 |     }
49 |     return x*sign;
50 | }


--------------------------------------------------------------------------------
/makefile:
--------------------------------------------------------------------------------
 1 | .PHONY=clean
 2 | 
 3 | SRC=./src/actvfunc.h\
 4 | 	./src/bp.h\
 5 | 	./src/char2vec.h\
 6 | 	./src/gru.h\
 7 | 	./src/lstm.h\
 8 | 	./src/NLPann.h\
 9 | 	./src/rnn.h\
10 | 	./src/seq2seq.h\
11 | 	./src/seq2vec.h
12 | 
13 | OBJECT=actvfunc.o bp.o rnn.o gru.o lstm.o seq2seq.o seq2vec.o
14 | 
15 | OPT=-O2
16 | 
17 | actvfunc.o: ./src/actvfunc.h ./src/actvfunc.cpp
18 | 	@ echo "[build] actvfunc"
19 | 	@ $(CXX) $(OPT) -std=c++11 -c ./src/actvfunc.cpp
20 | 
21 | bp.o: ./src/bp.h ./src/bp.cpp
22 | 	@ echo "[build] bp"
23 | 	@ $(CXX) $(OPT) -std=c++11 -c ./src/bp.cpp
24 | 
25 | rnn.o: ./src/rnn.h ./src/rnn.cpp
26 | 	@ echo "[build] rnn"
27 | 	@ $(CXX) $(OPT) -std=c++11 -c ./src/rnn.cpp
28 | 
29 | gru.o: ./src/gru.h ./src/gru.cpp
30 | 	@ echo "[build] gru"
31 | 	@ $(CXX) $(OPT) -std=c++11 -c ./src/gru.cpp
32 | 
33 | lstm.o: ./src/lstm.h ./src/lstm.cpp
34 | 	@ echo "[build] lstm"
35 | 	@ $(CXX) $(OPT) -std=c++11 -c ./src/lstm.cpp
36 | 
37 | seq2seq.o: ./src/seq2seq.h ./src/seq2seq.cpp
38 | 	@ echo "[build] seq2seq"
39 | 	@ $(CXX) $(OPT) -std=c++11 -c ./src/seq2seq.cpp
40 | 
41 | seq2vec.o: ./src/seq2vec.h ./src/seq2vec.cpp
42 | 	@ echo "[build] seq2vec"
43 | 	@ $(CXX) $(OPT) -std=c++11 -c ./src/seq2vec.cpp
44 | 
45 | easynlp: ./src/nlpmain.cpp ./src/mainassist.h $(SRC) $(OBJECT)
46 | 	@ $(CXX) $(OPT) -std=c++11 -c ./src/nlpmain.cpp
47 | 	@ echo "[link ] linking..."
48 | 	@ $(CXX) nlpmain.o $(OBJECT) -o easynlp
49 | 	@ rm nlpmain.o $(OBJECT)
50 | 	@ echo "[done ] build done"
51 | 
52 | clean:
53 | 	-@ rm easynlp


--------------------------------------------------------------------------------
/src/lstm.h:
--------------------------------------------------------------------------------
 1 | /*lstm.h header file made by ValK*/
 2 | /*2019/5/7            version 1.1*/
 3 | #ifndef __LSTM_H__
 4 | #define __LSTM_H__
 5 | 
 6 | #include "rnn.h"
 7 | #include <iostream>
 8 | #include <cstring>
 9 | 
10 | struct lstm_neuron
11 | {
12 |     double *cell;
13 |     double *out;
14 |     double *fog_in,*fog_out,fog_bia,*fog_wi,*fog_wh,*fog_diff;
15 |     double *sig_in,*sig_out,sig_bia,*sig_wi,*sig_wh,*sig_diff;
16 |     double *tan_in,*tan_out,tan_bia,*tan_wi,*tan_wh,*tan_diff;
17 |     double *out_in,*out_out,out_bia,*out_wi,*out_wh,*out_diff;
18 |     double fog_transbia,*fog_transwi,*fog_transwh;
19 |     double sig_transbia,*sig_transwi,*sig_transwh;
20 |     double tan_transbia,*tan_transwi,*tan_transwh;
21 |     double out_transbia,*out_transwi,*out_transwh;
22 | };
23 | 
24 | class NormalLSTM
25 | {
26 | protected:
27 |     int INUM;
28 |     int HNUM;
29 |     int MAXTIME;
30 | public:
31 |     lstm_neuron *hide;
32 |     NormalLSTM(int,int,int);
33 |     ~NormalLSTM();
34 |     void Init();
35 |     void Datain(const std::string&);
36 |     void Dataout(const std::string&);
37 | };
38 | 
39 | class DeepLSTM
40 | {
41 | protected:
42 |     int INUM;
43 |     int HNUM;
44 |     int DEPTH;
45 |     int MAXTIME;
46 | public:
47 |     lstm_neuron *hlink;
48 |     lstm_neuron **hide;
49 |     DeepLSTM(int,int,int,int);
50 |     ~DeepLSTM();
51 |     void ConstructorAssist();
52 |     void DestructorAssist();
53 |     void Init();
54 |     void Datain(const std::string&);
55 |     void Dataout(const std::string&);
56 | };
57 | 
58 | #endif
59 | 


--------------------------------------------------------------------------------
/src/gru.h:
--------------------------------------------------------------------------------
 1 | /*gru.h header file made by ValK*/
 2 | /*2019/5/7           version 1.1*/
 3 | #ifndef __GRU_H__
 4 | #define __GRU_H__
 5 | 
 6 | #include "rnn.h"
 7 | #include <iostream>
 8 | #include <cstring>
 9 | 
10 | struct gru_neuron
11 | {
12 |     double *out;
13 |     double *sig_update_in, *sig_update_out, *sig_update_wi, *sig_update_wh ;
14 |     double *sig_replace_in,*sig_replace_out,*sig_replace_wi,*sig_replace_wh;
15 |     double *tan_replace_in,*tan_replace_out,*tan_replace_wi,*tan_replace_wh;
16 |     double sig_update_bia, sig_update_transbia ;
17 |     double sig_replace_bia,sig_replace_transbia;
18 |     double tan_replace_bia,tan_replace_transbia;
19 |     double *sig_update_diff, *sig_update_transwi, *sig_update_transwh ;
20 |     double *sig_replace_diff,*sig_replace_transwi,*sig_replace_transwh;
21 |     double *tan_replace_diff,*tan_replace_transwi,*tan_replace_transwh;
22 | };
23 | 
24 | class NormalGRU
25 | {
26 | protected:
27 |     int INUM;
28 |     int HNUM;
29 |     int MAXTIME;
30 | public:
31 |     gru_neuron *hide;
32 |     NormalGRU(int,int,int);
33 |     ~NormalGRU();
34 |     void Init();
35 |     void Datain(const std::string&);
36 |     void Dataout(const std::string&);
37 | };
38 | 
39 | class DeepGRU
40 | {
41 | protected:
42 |     int INUM;
43 |     int HNUM;
44 |     int DEPTH;
45 |     int MAXTIME;
46 | public:
47 |     gru_neuron *hlink;
48 |     gru_neuron **hide;
49 |     DeepGRU(int,int,int,int);
50 |     ~DeepGRU();
51 |     void ConstructorAssist();
52 |     void DestructorAssist();
53 |     void Init();
54 |     void Datain(const std::string&);
55 |     void Dataout(const std::string&);
56 | };
57 | 
58 | #endif
59 | 


--------------------------------------------------------------------------------
/src/bp.h:
--------------------------------------------------------------------------------
 1 | /*bp.h header file made by ValK*/
 2 | /*2019/5/5          version 1.0*/
 3 | #ifndef __BP_H__
 4 | #define __BP_H__
 5 | 
 6 | #include <iostream>
 7 | #include <cmath>
 8 | #include <ctime>
 9 | #include <cstring>
10 | 
11 | struct neuron
12 | {
13 |     double in,out,bia,diff;
14 |     double *w;
15 | };
16 | 
17 | class NormalBP
18 | {
19 | private:
20 |     int INUM;
21 |     int HNUM;
22 |     int ONUM;
23 |     int batch_size;
24 |     neuron *hide;
25 |     neuron *output;
26 |     double *input;
27 |     double *expect;
28 |     double lr;
29 |     double error;
30 |     std::string func_name;
31 |     double ActivateFunction(double);
32 |     double DiffFunction(double);
33 | public:
34 |     NormalBP(int,int,int);
35 |     ~NormalBP();
36 |     void Init();
37 |     void Calc();
38 |     void ErrorCalc();
39 |     double GetError();
40 |     void Training();
41 |     void Datain(const std::string&);
42 |     void Dataout(const std::string&);
43 |     void SetFunction(const std::string&);
44 |     void SetLearningrate(double);
45 |     void TotalWork(const std::string&,const std::string&,const std::string&);
46 | };
47 | class DeepBP
48 | {
49 | private:
50 |     int INUM;
51 |     int HNUM;
52 |     int ONUM;
53 |     int DEPTH;
54 |     int batch_size;
55 |     neuron *hlink;
56 |     neuron **hide;
57 |     neuron *output;
58 |     double *input;
59 |     double *expect;
60 |     double lr;
61 |     double error;
62 |     std::string func_name;
63 |     double ActivateFunction(double);
64 |     double DiffFunction(double);
65 | public:
66 |     DeepBP(int,int,int,int);
67 |     ~DeepBP();
68 |     void Init();
69 |     void Calc();
70 |     void ErrorCalc();
71 |     double GetError();
72 |     void Training();
73 |     void Datain(const std::string&);
74 |     void Dataout(const std::string&);
75 |     void SetFunction(const std::string&);
76 |     void SetLearningrate(double);
77 |     void TotalWork(const std::string&,const std::string&,const std::string&);
78 | };
79 | 
80 | #endif
81 | 


--------------------------------------------------------------------------------
/src/seq2vec.h:
--------------------------------------------------------------------------------
 1 | /*seq2vec.h header file by ValK*/
 2 | /*2019/5/7           version1.4*/
 3 | #ifndef __SEQ2VEC_H__
 4 | #define __SEQ2VEC_H__
 5 | 
 6 | #include <cstring>
 7 | #include <cstdlib>
 8 | #include <ctime>
 9 | #include "bp.h"
10 | #include "rnn.h"
11 | #include "lstm.h"
12 | #include "gru.h"
13 | #include "actvfunc.h"
14 | 
15 | class Seq2Vec
16 | {
17 | protected:
18 |     int INUM;
19 |     int HNUM;
20 |     int ONUM;
21 |     int DEPTH;
22 |     int MAXTIME;
23 |     int batch_size;
24 |     double lr;
25 |     double **input;
26 |     double *expect;
27 |     double error;
28 |     double maxerror;
29 |     neuron *output;
30 |     std::string func_name;
31 | public:
32 |     virtual void SetFunction(const std::string&)=0;
33 |     virtual void SetBatchSize(const int)=0;
34 |     virtual void SetLearningRate(const double)=0;
35 |     virtual void Calc(const std::string&,const int)=0;
36 |     virtual void Training(const std::string&,const int)=0;
37 |     virtual void ErrorCalc()=0;
38 |     virtual void Datain(const std::string&,const std::string&,const std::string&)=0;
39 |     virtual void Dataout(const std::string&,const std::string&,const std::string&)=0;
40 |     virtual void TotalWork(const std::string&,const std::string&,const std::string&,const std::string&,const std::string&)=0;
41 | };
42 | 
43 | class NormalSeq2Vec:public Seq2Vec
44 | {
45 | private:
46 |     NormalRNN *rnnencoder;
47 |     NormalLSTM *lstmencoder;
48 |     NormalGRU *gruencoder;
49 | public:
50 |     NormalSeq2Vec(const std::string&,int,int,int,int);
51 |     ~NormalSeq2Vec();
52 |     void SetFunction(const std::string&);
53 |     void SetLearningRate(const double);
54 |     void SetBatchSize(const int);
55 |     void Calc(const std::string&,const int);
56 |     void Training(const std::string&,const int);
57 |     void ErrorCalc();
58 |     void Datain(const std::string&,const std::string&,const std::string&);
59 |     void Dataout(const std::string&,const std::string&,const std::string&);
60 |     void TotalWork(const std::string&,const std::string&,const std::string&,const std::string&,const std::string&);
61 | };
62 | 
63 | class DeepSeq2Vec:public Seq2Vec
64 | {
65 | private:
66 |     DeepRNN *rnnencoder;
67 |     DeepLSTM *lstmencoder;
68 |     DeepGRU *gruencoder;
69 | public:
70 |     DeepSeq2Vec(const std::string&,int,int,int,int,int);
71 |     ~DeepSeq2Vec();
72 |     void SetFunction(const std::string&);
73 |     void SetLearningRate(const double);
74 |     void SetBatchSize(const int);
75 |     void Calc(const std::string&,const int);
76 |     void Training(const std::string&,const int);
77 |     void ErrorCalc();
78 |     void Datain(const std::string&,const std::string&,const std::string&);
79 |     void Dataout(const std::string&,const std::string&,const std::string&);
80 |     void TotalWork(const std::string&,const std::string&,const std::string&,const std::string&,const std::string&);
81 | };
82 | 
83 | void Seq2VecDataMaker(const std::string&,const std::string&,const std::string&,const int);
84 | 
85 | #endif
86 | 


--------------------------------------------------------------------------------
/src/seq2seq.h:
--------------------------------------------------------------------------------
  1 | /*seq2seq.h header file by ValK*/
  2 | /*2019/5/7           version1.5*/
  3 | #ifndef __SEQ2SEQ_H__
  4 | #define __SEQ2SEQ_H__
  5 | 
  6 | #include <iostream>
  7 | #include <cstring>
  8 | #include <cstdlib>
  9 | #include <ctime>
 10 | 
 11 | #include "rnn.h"
 12 | #include "lstm.h"
 13 | #include "gru.h"
 14 | #include "actvfunc.h"
 15 | 
 16 | /*abstract class Seq2Seq*/
 17 | struct seq_neuron
 18 | {
 19 |     double *in,*out,*w,bia,*diff;
 20 |     double *transw,transbia;
 21 | };
 22 | 
 23 | class Seq2Seq
 24 | {
 25 |     protected:
 26 |         int INUM;
 27 |         int HNUM;
 28 |         int ONUM;
 29 |         int DEPTH;
 30 |         int MAXTIME;
 31 |         int batch_size;
 32 |         double lr;
 33 |         double **input;
 34 |         double **expect;
 35 |         double error;
 36 |         double maxerror;
 37 |         seq_neuron *output;
 38 |         std::string func_name;
 39 |         //output function is set as softmax so this doesn't work
 40 |     public:
 41 |         virtual void SetBatchSize(const int)=0;
 42 |         //this decides how many batches of data are used in training process
 43 |         virtual void SetLearningRate(const double)=0;
 44 |         //this decides the speed of updating model,but if you set a large rate,network may be corrupted
 45 |         virtual void Calc(const std::string&,const int,const int)=0;
 46 |         //used to calculate the forward propagation
 47 |         virtual void Training(const std::string&,const int,const int)=0;
 48 |         //used to calculate the back propagation through time
 49 |         virtual void ErrorCalc(const int)=0;
 50 |         //used to calculate the loss of training set
 51 |         virtual void SetFunction(const std::string&)=0;
 52 |         //set output activate function but the function has been set as softmax so this doesn't work
 53 |         virtual void Datain(const std::string&,const std::string&,const std::string&,const std::string&)=0;
 54 |         //input data before calculation
 55 |         virtual void Dataout(const std::string&,const std::string&,const std::string&,const std::string&)=0;
 56 |         //output data to save data.But if network is too large,this may take a lot of time
 57 |         virtual void TotalWork(const std::string&,const std::string&,const std::string&,const std::string&,const std::string&,const std::string&)=0;
 58 | };
 59 | /*NormalSeq2Seq with only one hidden layer*/
 60 | class NormalSeq2Seq:public Seq2Seq
 61 | {
 62 | private:
 63 |     NormalRNN *rnnencoder;
 64 |     NormalRNN *rnndecoder;
 65 |     NormalLSTM *lstmencoder;
 66 |     NormalLSTM *lstmdecoder;
 67 |     NormalGRU *gruencoder;
 68 |     NormalGRU *grudecoder;
 69 | public:
 70 |     NormalSeq2Seq(const std::string&,int,int,int,int);
 71 |     ~NormalSeq2Seq();
 72 |     void SetBatchSize(const int);
 73 |     void SetLearningRate(const double);
 74 |     void Calc(const std::string&,const int,const int);
 75 |     void Training(const std::string&,const int,const int);
 76 |     void ErrorCalc(const int);
 77 |     void SetFunction(const std::string&);
 78 |     void Datain(const std::string&,const std::string&,const std::string&,const std::string&);
 79 |     void Dataout(const std::string&,const std::string&,const std::string&,const std::string&);
 80 |     void TotalWork(const std::string&,const std::string&,const std::string&,const std::string&,const std::string&,const std::string&);
 81 | };
 82 | /*DeepSeq2Seq with deep neural networks*/
 83 | class DeepSeq2Seq:public Seq2Seq
 84 | {
 85 | private:
 86 |     DeepRNN *rnnencoder;
 87 |     DeepRNN *rnndecoder;
 88 |     DeepLSTM *lstmencoder;
 89 |     DeepLSTM *lstmdecoder;
 90 |     DeepGRU *gruencoder;
 91 |     DeepGRU *grudecoder;
 92 | public:
 93 |     DeepSeq2Seq(const std::string&,int,int,int,int,int);
 94 |     ~DeepSeq2Seq();
 95 |     void SetBatchSize(const int);
 96 |     void SetLearningRate(const double);
 97 |     void Calc(const std::string&,const int,const int);
 98 |     void Training(const std::string&,const int,const int);
 99 |     void ErrorCalc(const int);
100 |     void SetFunction(const std::string&);
101 |     void Datain(const std::string&,const std::string&,const std::string&,const std::string&);
102 |     void Dataout(const std::string&,const std::string&,const std::string&,const std::string&);
103 |     void TotalWork(const std::string&,const std::string&,const std::string&,const std::string&,const std::string&,const std::string&);
104 | };
105 | 
106 | #endif
107 | 


--------------------------------------------------------------------------------
/src/nlpmain.cpp:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <fstream>
  3 | #include <cstring>
  4 | #include <cstdlib>
  5 | #include <iomanip>
  6 | #include <cmath>
  7 | #include <ctime>
  8 | 
  9 | #include "NLPann.h"
 10 | #include "mainassist.h"
 11 | 
 12 | //PrintHelp() can be called if needed
 13 | void help(){
 14 |     std::cout
 15 |     <<">> [Help]"<<std::endl
 16 |     <<"   |  d | Delete a project      |"<<std::endl
 17 |     <<"   |  c | Create a new project  |"<<std::endl
 18 |     <<"   |  l | List all projects     |"<<std::endl
 19 |     <<"   |  r | Run a project         |"<<std::endl
 20 |     <<"   |  f | Find a project        |"<<std::endl
 21 |     <<"   |  e | Edit a project        |"<<std::endl
 22 |     <<"   | lr | Change learning rate  |"<<std::endl
 23 |     <<"   | bs | Change batch size     |"<<std::endl
 24 |     <<"   | mk | Make data for Seq2Vec |"<<std::endl
 25 |     <<"   | ft | Find projects by type |"<<std::endl
 26 |     <<"   |  q | Quit                  |"<<std::endl
 27 |     <<">> You can find this help with cmd:\"h\" or \"help\""<<std::endl;
 28 |     return;
 29 | }
 30 | 
 31 | //PrintWarning() Updated by version
 32 | //This function is used to remind users that some functions are not available until next version
 33 | void warn(){
 34 |     std::cout
 35 |     <<">> [Tips] [easyNLP-2022 version 1.5 by ValK]"<<std::endl
 36 |     <<"   | BP neural networks can deal with all kinds of bp works"<<std::endl
 37 |     <<"   | Char2Vec model is used to calculate the probibility of next character"<<std::endl
 38 |     <<"   | Char2Vec now can deal with character between ASCII 32:' ' and 126:'~'"<<std::endl
 39 |     <<"   | Seq2Seq is used to deal with sequence-like data"<<std::endl
 40 |     <<"   | Seq2Seq now only works on sequences made with characters between ASCII 97:'a' and 122:'z' and ASCII 32:' '"<<std::endl
 41 |     <<"   | Seq2Seq model uses two space "  " as the end of answer sequence so please be careful of your data!"<<std::endl
 42 |     <<"   | Seq2Vec is used to predict a character with a sequence of input"<<std::endl
 43 |     <<"   | Seq2Vec can make new texts beginning with an appropriate sequence you given before"<<std::endl
 44 |     <<"   | Seq2Vec also only works on sequences made up with characters between ASCII 97:'a' and 122:'z' and 32:' '"<<std::endl
 45 |     <<"   | The MAXTIME of Seq2Vec decides the length of input sequence"<<std::endl
 46 |     <<"   | [Warning] Deep Seq2Seq or Seq2Vec may not have more than two layers or models will not work well!"<<std::endl
 47 |     <<"   | [Warning] GRU doesn't work well on Deep Seq2Seq and Seq2Vec"<<std::endl
 48 |     <<">> You can find tips with cmd:\"t\" or \"tips\""<<std::endl;
 49 |     return;
 50 | }
 51 | 
 52 | //main()
 53 | int main(){
 54 |     ObjManager manager;
 55 |     std::string cmd;
 56 |     manager.ObjDataIn();
 57 |     warn();
 58 |     help();
 59 |     while(1){
 60 |         std::cout<<">> ";
 61 |         std::cin>>cmd;
 62 |         if(cmd=="h"||cmd=="help"){
 63 |             help();
 64 |         }
 65 |         else if(cmd=="t"||cmd=="tips"){
 66 |             warn();
 67 |         }
 68 |         else if(cmd=="d"){
 69 |             manager.DeleteObj();
 70 |         }else if(cmd=="c"){
 71 |             manager.MakeData();
 72 |             manager.ObjDataOut();
 73 |         }else if(cmd=="l"){
 74 |             manager.PrintAllObj();
 75 |         }else if(cmd=="r"){
 76 |             manager.RunModule();
 77 |         }else if(cmd=="f"){
 78 |             manager.FindObj();
 79 |         }else if(cmd=="e"){
 80 |             manager.EditObj();
 81 |         }else if(cmd=="lr"){
 82 |             manager.ChangeLearningRate();
 83 |         }else if(cmd=="bs"){
 84 |             manager.ChangeBatchSize();
 85 |         }else if(cmd=="mk"){
 86 |             int maxtime;
 87 |             char Filename[100];
 88 |             char Sequencedata[100];
 89 |             char Trainingdata[100];
 90 |             std::cout<<">> Please input the name of text data:";
 91 |             std::cin>>Filename;
 92 |             std::cout<<">> Please input the name of sequence data(input data):";
 93 |             std::cin>>Sequencedata;
 94 |             std::cout<<">> Please input the name of training data:";
 95 |             std::cin>>Trainingdata;
 96 |             if(!fopen(Filename,"r")||!fopen(Sequencedata,"w")||!fopen(Trainingdata,"w")){
 97 |                 std::cout<<">> [Error] Cannot open file."<<std::endl;
 98 |             }else{
 99 |                 std::cout<<">> Please input the length of every input sequence:";
100 |                 std::cin>>maxtime;
101 |                 Seq2VecDataMaker(Filename,Sequencedata,Trainingdata,maxtime);
102 |             }
103 |         }else if(cmd=="ft"){
104 |             char Typename[100];
105 |             std::cout<<">> Which type of networks would you like to find?\neasyNLP>>";
106 |             std::cin>>Typename;
107 |             manager.FindSpecialObj(Typename);
108 |         }else if(cmd=="q"){
109 |             std::cout<<">> [Quiting] Please wait."<<std::endl;
110 |             manager.ObjDataOut();
111 |             break;
112 |         }else{
113 |             std::cout<<">> [Error] Undefined command."<<std::endl;
114 |             help();
115 |         }
116 |     }
117 |     return 0;
118 | }
119 | 


--------------------------------------------------------------------------------
/src/rnn.cpp:
--------------------------------------------------------------------------------
  1 | /*rnnfunction.h header file made by ValK*/
  2 | /*2019/3/29                  version 0.2*/
  3 | #include "rnn.h"
  4 | 
  5 | #include<iostream>
  6 | #include<ctime>
  7 | #include<fstream>
  8 | #include<cstdlib>
  9 | 
 10 | NormalRNN::NormalRNN(int InputlayerNum,int HiddenlayerNum,int Maxtime)
 11 | {
 12 |     MAXTIME=Maxtime;
 13 |     INUM=InputlayerNum;
 14 |     HNUM=HiddenlayerNum;
 15 | 
 16 |     hide=new rnn_neuron[HNUM];
 17 |     for(int i=0;i<HNUM;i++)
 18 |     {
 19 |         hide[i].in=new double[MAXTIME];
 20 |         hide[i].out=new double[MAXTIME];
 21 |         hide[i].diff=new double[MAXTIME];
 22 |         hide[i].wi=new double[INUM];
 23 |         hide[i].transwi=new double[INUM];
 24 |         hide[i].wh=new double[HNUM];
 25 |         hide[i].transwh=new double[HNUM];
 26 |     }
 27 | }
 28 | 
 29 | NormalRNN::~NormalRNN()
 30 | {
 31 |     for(int i=0;i<HNUM;i++)
 32 |     {
 33 |         delete []hide[i].in;
 34 |         delete []hide[i].out;
 35 |         delete []hide[i].diff;
 36 |         delete []hide[i].wi;
 37 |         delete []hide[i].transwi;
 38 |         delete []hide[i].wh;
 39 |         delete []hide[i].transwh;
 40 |     }
 41 |     delete []hide;
 42 | }
 43 | 
 44 | void NormalRNN::Init()
 45 | {
 46 |     srand(unsigned(time(NULL)));
 47 |     for(int i=0;i<HNUM;i++)
 48 |     {
 49 |         hide[i].out[0]=0;
 50 |         hide[i].bia=(rand()%2? 1:-1)*(1.0+rand()%10)/10.0;
 51 |         for(int j=0;j<INUM;j++)
 52 |             hide[i].wi[j]=(rand()%2? 1:-1)*(1.0+rand()%10)/50.0;
 53 |         for(int j=0;j<HNUM;j++)
 54 |             hide[i].wh[j]=(rand()%2? 1:-1)*(1.0+rand()%10)/50.0;
 55 |     }
 56 |     return;
 57 | }
 58 | 
 59 | void NormalRNN::Datain(const std::string& filename)
 60 | {
 61 |     std::ifstream fin(filename);
 62 |     if(fin.fail())
 63 |     {
 64 |         std::cout<<">> [Error] Cannot open file."<<std::endl;
 65 |         exit(-1);
 66 |     }
 67 |     for(int i=0;i<HNUM;i++)
 68 |     {
 69 |         fin>>hide[i].out[0];
 70 |         fin>>hide[i].bia;
 71 |         for(int j=0;j<INUM;j++)
 72 |             fin>>hide[i].wi[j];
 73 |         for(int j=0;j<HNUM;j++)
 74 |             fin>>hide[i].wh[j];
 75 |     }
 76 |     fin.close();
 77 |     return;
 78 | }
 79 | 
 80 | void NormalRNN::Dataout(const std::string& filename)
 81 | {
 82 |     std::ofstream fout(filename);
 83 |     if(fout.fail())
 84 |     {
 85 |         std::cout<<">> [Error] Cannot open file."<<std::endl;
 86 |         exit(-1);
 87 |     }
 88 |     for(int i=0;i<HNUM;i++)
 89 |     {
 90 |         fout<<hide[i].out[0]<<std::endl;
 91 |         fout<<hide[i].bia<<std::endl;
 92 |         for(int j=0;j<INUM;j++)
 93 |             fout<<hide[i].wi[j]<<std::endl;
 94 |         for(int j=0;j<HNUM;j++)
 95 |             fout<<hide[i].wh[j]<<std::endl;
 96 |     }
 97 |     fout.close();
 98 |     return;
 99 | }
100 | 
101 | DeepRNN::DeepRNN(int InputlayerNum,int HiddenlayerNum,int Depth,int Maxtime)
102 | {
103 |     MAXTIME=Maxtime;
104 |     INUM=InputlayerNum;
105 |     HNUM=HiddenlayerNum;
106 |     DEPTH=Depth-1;
107 | 
108 |     hlink=new rnn_neuron[HNUM];
109 |     hide=new rnn_neuron*[HNUM];
110 |     for(int i=0;i<HNUM;i++)
111 |         hide[i]=new rnn_neuron[DEPTH];
112 |     for(int i=0;i<HNUM;i++)
113 |     {
114 |         hlink[i].in=new double[MAXTIME];
115 |         hlink[i].out=new double[MAXTIME];
116 |         hlink[i].diff=new double[MAXTIME];
117 |         hlink[i].wi=new double[INUM];
118 |         hlink[i].transwi=new double[INUM];
119 |         hlink[i].wh=new double[HNUM];
120 |         hlink[i].transwh=new double[HNUM];
121 |     }
122 |     for(int d=0;d<DEPTH;d++)
123 |         for(int i=0;i<HNUM;i++)
124 |         {
125 |             hide[i][d].in=new double[MAXTIME];
126 |             hide[i][d].out=new double[MAXTIME];
127 |             hide[i][d].diff=new double[MAXTIME];
128 |             hide[i][d].wi=new double[HNUM];
129 |             hide[i][d].transwi=new double[HNUM];
130 |             hide[i][d].wh=new double[HNUM];
131 |             hide[i][d].transwh=new double[HNUM];
132 |         }
133 | }
134 | 
135 | DeepRNN::~DeepRNN()
136 | {
137 |     for(int d=0;d<DEPTH;d++)
138 |         for(int i=0;i<HNUM;i++)
139 |         {
140 |             delete []hide[i][d].in;
141 |             delete []hide[i][d].out;
142 |             delete []hide[i][d].diff;
143 |             delete []hide[i][d].wi;
144 |             delete []hide[i][d].transwi;
145 |             delete []hide[i][d].wh;
146 |             delete []hide[i][d].transwh;
147 |         }
148 |     for(int i=0;i<HNUM;i++)
149 |     {
150 |         delete []hlink[i].in;
151 |         delete []hlink[i].out;
152 |         delete []hlink[i].diff;
153 |         delete []hlink[i].wi;
154 |         delete []hlink[i].transwi;
155 |         delete []hlink[i].wh;
156 |         delete []hlink[i].transwh;
157 |     }
158 |     for(int i=0;i<HNUM;i++)
159 |         delete []hide[i];
160 |     delete []hlink;
161 |     delete []hide;
162 | }
163 | 
164 | void DeepRNN::Init()
165 | {
166 |     srand(unsigned(time(NULL)));
167 |     for(int i=0;i<HNUM;i++)
168 |     {
169 |         hlink[i].out[0]=0;
170 |         hlink[i].bia=(rand()%2? 1:-1)*(1.0+rand()%10)/10.0;
171 |         for(int j=0;j<INUM;j++)
172 |             hlink[i].wi[j]=(rand()%2? 1:-1)*(1.0+rand()%10)/50.0;
173 |         for(int j=0;j<HNUM;j++)
174 |             hlink[i].wh[j]=(rand()%2? 1:-1)*(1.0+rand()%10)/50.0;
175 |     }
176 |     for(int d=0;d<DEPTH;d++)
177 |         for(int i=0;i<HNUM;i++)
178 |         {
179 |             hide[i][d].out[0]=0;
180 |             hide[i][d].bia=(rand()%2? 1:-1)*(1.0+rand()%10)/10.0;
181 |             for(int j=0;j<HNUM;j++)
182 |             {
183 |                 hide[i][d].wi[j]=(rand()%2? 1:-1)*(1.0+rand()%10)/50.0;
184 |                 hide[i][d].wh[j]=(rand()%2? 1:-1)*(1.0+rand()%10)/50.0;
185 |             }
186 |         }
187 |     return;
188 | }
189 | 
190 | void DeepRNN::Datain(const std::string& filename)
191 | {
192 |     std::ifstream fin(filename);
193 |     if(fin.fail())
194 |     {
195 |         std::cout<<">> [Error] Cannot open file."<<std::endl;
196 |         exit(-1);
197 |     }
198 |     for(int i=0;i<HNUM;i++)
199 |     {
200 |         fin>>hlink[i].out[0];
201 |         fin>>hlink[i].bia;
202 |         for(int j=0;j<INUM;j++)
203 |             fin>>hlink[i].wi[j];
204 |         for(int j=0;j<HNUM;j++)
205 |             fin>>hlink[i].wh[j];
206 |     }
207 |     for(int d=0;d<DEPTH;d++)
208 |         for(int i=0;i<HNUM;i++)
209 |         {
210 |             fin>>hide[i][d].out[0];
211 |             fin>>hide[i][d].bia;
212 |             for(int j=0;j<HNUM;j++)
213 |             {
214 |                 fin>>hide[i][d].wi[j];
215 |                 fin>>hide[i][d].wh[j];
216 |             }
217 |         }
218 |     fin.close();
219 |     return;
220 | }
221 | 
222 | void DeepRNN::Dataout(const std::string& filename)
223 | {
224 |     std::ofstream fout(filename);
225 |     if(fout.fail())
226 |     {
227 |         std::cout<<">> [Error] Cannot open file."<<std::endl;
228 |         exit(-1);
229 |     }
230 |     for(int i=0;i<HNUM;i++)
231 |     {
232 |         fout<<hlink[i].out[0]<<std::endl;
233 |         fout<<hlink[i].bia<<std::endl;
234 |         for(int j=0;j<INUM;j++)
235 |             fout<<hlink[i].wi[j]<<std::endl;
236 |         for(int j=0;j<HNUM;j++)
237 |             fout<<hlink[i].wh[j]<<std::endl;
238 |     }
239 |     for(int d=0;d<DEPTH;d++)
240 |         for(int i=0;i<HNUM;i++)
241 |         {
242 |             fout<<hide[i][d].out[0]<<std::endl;
243 |             fout<<hide[i][d].bia<<std::endl;
244 |             for(int j=0;j<HNUM;j++)
245 |             {
246 |                 fout<<hide[i][d].wi[j]<<std::endl;
247 |                 fout<<hide[i][d].wh[j]<<std::endl;
248 |             }
249 |         }
250 |     fout.close();
251 |     return;
252 | }
253 | 


--------------------------------------------------------------------------------
/src/char2vec.h:
--------------------------------------------------------------------------------
  1 | /*char2vec.h header file made by valk*/
  2 | /*2019/5/2               version 1.1*/
  3 | #ifndef __CHAR2VEC_H__
  4 | #define __CHAR2VEC_H__
  5 | #include <iostream>
  6 | #include <fstream>
  7 | #include <cmath>
  8 | #include <cstdlib>
  9 | #include <vector>
 10 | #include "bp.h"
 11 | #include "actvfunc.h"
 12 | 
 13 | class Char2Vec
 14 | {
 15 | private:
 16 |     int INUM;
 17 |     int HNUM;
 18 |     int ONUM;
 19 |     std::vector<std::vector<double>> cnt;
 20 |     std::vector<double> input;
 21 |     std::vector<double> expect;
 22 |     double lr;
 23 |     std::vector<neuron> hide;
 24 |     std::vector<neuron> output;
 25 | public:
 26 |     Char2Vec(const int hnum=256)
 27 |     {
 28 |         lr=0.1;
 29 |         INUM=95;
 30 |         ONUM=95;
 31 |         HNUM=hnum;
 32 |         cnt.resize(95);
 33 |         for(int i=0;i<95;i++)
 34 |             cnt[i].resize(95,0);
 35 |         input.resize(95);
 36 |         expect.resize(95);
 37 |         hide.resize(HNUM);
 38 |         output.resize(ONUM);
 39 |         for(int i=0;i<HNUM;i++)
 40 |             hide[i].w=new double[INUM];
 41 |         for(int i=0;i<ONUM;i++)
 42 |             output[i].w=new double[HNUM];
 43 | 
 44 |         srand(unsigned(time(NULL)));
 45 |         for(int i=0;i<HNUM;i++)
 46 |         {
 47 |             hide[i].bia=(rand()%2? 1:-1)*(1.0+rand()%10)/(1.0*INUM);
 48 |             for(int j=0;j<INUM;j++)
 49 |                 hide[i].w[j]=(rand()%2? 1:-1)*(1.0+rand()%10)/(10.0*INUM);
 50 |         }
 51 |         for(int i=0;i<ONUM;i++)
 52 |         {
 53 |             output[i].bia=(rand()%2? 1:-1)*(1.0+rand()%10)/(1.0*HNUM);
 54 |             for(int j=0;j<HNUM;j++)
 55 |                 output[i].w[j]=(rand()%2? 1:-1)*(1.0+rand()%10)/(10.0*HNUM);
 56 |         }
 57 |         return;
 58 |     }
 59 |     ~Char2Vec()
 60 |     {
 61 |         for(int i=0;i<HNUM;i++)
 62 |             delete []hide[i].w;
 63 |         for(int i=0;i<ONUM;i++)
 64 |             delete []output[i].w;
 65 |     }
 66 |     void TotalWork(const std::string&,const std::string&);
 67 |     void Mainwork(const std::string&);
 68 |     void Calc();
 69 |     void Training();
 70 |     void Datain(const std::string&);
 71 |     void Dataout(const std::string&);
 72 |     void Print();
 73 |     void CountChar(const std::string&);
 74 |     void CharDataIllustration(const std::string&);
 75 | };
 76 | 
 77 | void Char2Vec::TotalWork(const std::string& dataFilename,const std::string& TrainingdataName)
 78 | {
 79 |     if(!fopen(dataFilename.c_str(),"r"))
 80 |     {
 81 |         Dataout(dataFilename);
 82 |         std::cout<<">> [Char2Vec-95char] Initializing completed.\n";
 83 |     }
 84 |     else
 85 |         Datain(dataFilename);
 86 |     CountChar(TrainingdataName);
 87 |     Mainwork(dataFilename);
 88 |     Print();
 89 | }
 90 | 
 91 | void Char2Vec::Mainwork(const std::string& filename)
 92 | {
 93 |     int epoch=0;
 94 |     double maxerror=1e8;
 95 |     double error=1e8;
 96 |     double softmax=0;
 97 | 
 98 |     double max_cnt=-1;
 99 |     for(auto& i:cnt)
100 |         for(auto j:i)
101 |             if(j>max_cnt)
102 |                 max_cnt=j;
103 |     // limit to 0~95
104 |     if(max_cnt!=0)
105 |         for(auto& i:cnt)
106 |             for(auto& j:i)
107 |                 j=j/max_cnt*95;
108 |     while(maxerror>0.1)
109 |     {
110 |         epoch++;
111 |         maxerror=0;
112 |         for(int i=0;i<95;i++)
113 |         {
114 |             for(int j=0;j<INUM;j++)
115 |                 input[j]=0;
116 |             input[i]=1;
117 |             softmax=0;
118 |             for(int j=0;j<95;j++)
119 |                 softmax+=std::exp(cnt[i][j]);
120 |             for(int j=0;j<ONUM;j++)
121 |                 expect[j]=std::exp(cnt[i][j])/softmax;
122 |             Calc();
123 |             error=0;
124 |             for(int j=0;j<ONUM;j++)
125 |                 error+=(expect[j]-output[j].out)*(expect[j]-output[j].out);
126 |             error*=0.5;
127 |             maxerror+=error;
128 |             Training();
129 |         }
130 |         if(epoch%100==0)
131 |         {
132 |             std::cout<<">> Epoch "<<epoch<<": Error :"<<maxerror<<std::endl;
133 |             if(epoch%500==0)
134 |                 Dataout(filename);
135 |         }
136 |     }
137 |     std::cout<<">> Finish training by "<<epoch<<" epoch, error="<<maxerror<<std::endl;
138 |     std::cout<<">> Final output in progress..."<<std::endl;
139 |     Dataout(filename);
140 |     std::cout<<">> Training complete."<<std::endl;
141 |     return;
142 | }
143 | void Char2Vec::Calc()
144 | {
145 |     double softmax=0;
146 |     for(int i=0;i<HNUM;i++)
147 |     {
148 |         hide[i].in=hide[i].bia;
149 |         for(int j=0;j<INUM;j++)
150 |             hide[i].in+=hide[i].w[j]*input[j];
151 |         hide[i].out=tanh(hide[i].in);
152 |     }
153 |     for(int i=0;i<ONUM;i++)
154 |     {
155 |         output[i].in=output[i].bia;
156 |         for(int j=0;j<HNUM;j++)
157 |             output[i].in+=output[i].w[j]*hide[j].out;
158 |         softmax+=std::exp(output[i].in);
159 |     }
160 |     for(int i=0;i<ONUM;i++)
161 |         output[i].out=std::exp(output[i].in)/softmax;
162 |     return;
163 | }
164 | void Char2Vec::Training()
165 | {
166 |     for(int i=0;i<ONUM;i++)
167 |         output[i].diff=(expect[i]-output[i].out)*output[i].out*(1-output[i].out);
168 |     for(int i=0;i<HNUM;i++)
169 |     {
170 |         hide[i].diff=0;
171 |         for(int j=0;j<ONUM;j++)
172 |             hide[i].diff+=output[j].diff*output[j].w[i];
173 |     }
174 |     for(int i=0;i<ONUM;i++)
175 |     {
176 |         output[i].bia+=lr*2*output[i].diff;
177 |         for(int j=0;j<HNUM;j++)
178 |             output[i].w[j]+=lr*output[i].diff*hide[j].out;
179 |     }
180 |     for(int i=0;i<HNUM;i++)
181 |     {
182 |         hide[i].bia+=lr*2*hide[i].diff;
183 |         for(int j=0;j<INUM;j++)
184 |             hide[i].w[j]+=lr*hide[i].diff*input[j];
185 |     }
186 |     return;
187 | }
188 | void Char2Vec::Datain(const std::string& filename)
189 | {
190 |     std::ifstream fin(filename);
191 |     if(fin.fail())
192 |     {
193 |         std::cout<<">> [Error] Cannot open data file!"<<std::endl;
194 |         exit(-1);
195 |     }
196 |     for(int i=0;i<HNUM;i++)
197 |     {
198 |         fin>>hide[i].bia;
199 |         for(int j=0;j<INUM;j++)
200 |             fin>>hide[i].w[j];
201 |     }
202 |     for(int i=0;i<ONUM;i++)
203 |     {
204 |         fin>>output[i].bia;
205 |         for(int j=0;j<HNUM;j++)
206 |             fin>>output[i].w[j];
207 |     }
208 |     fin.close();
209 |     return;
210 | }
211 | void Char2Vec::Dataout(const std::string& filename)
212 | {
213 |     std::ofstream fout(filename);
214 |     if(fout.fail())
215 |     {
216 |         std::cout<<">> [Error] Cannot open data file!"<<std::endl;
217 |         exit(-1);
218 |     }
219 |     for(int i=0;i<HNUM;i++)
220 |     {
221 |         fout<<hide[i].bia<<std::endl;
222 |         for(int j=0;j<INUM;j++)
223 |             fout<<hide[i].w[j]<<std::endl;
224 |     }
225 |     for(int i=0;i<ONUM;i++)
226 |     {
227 |         fout<<output[i].bia<<std::endl;
228 |         for(int j=0;j<HNUM;j++)
229 |             fout<<output[i].w[j]<<std::endl;
230 |     }
231 |     fout.close();
232 |     return;
233 | }
234 | void Char2Vec::Print()
235 | {
236 |     std::cout<<">> [Result-Char2Vec-95char]"<<std::endl;
237 |     for(int i=0;i<95;i++)
238 |     {
239 |         for(int j=0;j<INUM;j++)
240 |             input[j]=0;
241 |         input[i]=1;
242 |         Calc();
243 |         bool has_related=false;
244 |         for(int j=0;j<ONUM;j++)
245 |             if(output[j].out>0.1)
246 |             {
247 |                 has_related=true;
248 |                 break;
249 |             }
250 |         if(!has_related)
251 |             continue;
252 |         std::cout<<"   |"<<(char)(i+32)<<":  ";
253 |         for(int j=0;j<ONUM;j++)
254 |             if(output[j].out>0.05)
255 |                 std::cout<<"|"<<(char)(j+32)<<':'<<int(100*output[j].out)<<"% ";
256 |         std::cout<<std::endl;
257 |     }
258 |     return;
259 | }
260 | void Char2Vec::CountChar(const std::string& filename)
261 | {
262 |     for(int i=0;i<95;i++)
263 |         for(int j=0;j<95;j++)
264 |             cnt[i][j]=0;
265 |     char temp[1024];
266 |     std::ifstream fin(filename);
267 |     if(fin.fail())
268 |     {
269 |         std::cout<<">> [Error] Cannot open data file!"<<std::endl;
270 |         exit(-1);
271 |     }
272 |     while(!fin.eof())
273 |     {
274 |         for(int i=0;i<1024;i++)
275 |             temp[i]=0;
276 |         fin.getline(temp,1024,'\n');
277 |         if(fin.eof())
278 |             break;
279 |         for(int i=1;temp[i]!=0;i++)
280 |             if(temp[i-1]>=32&&temp[i-1]<=126&&temp[i]>=32&&temp[i]<=126)
281 |                 cnt[temp[i-1]-32][temp[i]-32]++;
282 |     }
283 |     std::cout<<">> [Info] character counting complete."<<std::endl;
284 |     return;
285 | }
286 | void Char2Vec::CharDataIllustration(const std::string& filename)
287 | {
288 |     std::ofstream fout(filename);
289 |     if(fout.fail())
290 |     {
291 |         std::cout<<">> [Error] Cannot open data file!"<<std::endl;
292 |         exit(-1);
293 |     }
294 |     fout<<"# ";
295 |     for(int i=0;i<95;i++)
296 |     {
297 |         if(i==0)
298 |             fout<<"space ";
299 |         else
300 |             fout<<(char)(i+32)<<' ';
301 |     }
302 |     fout<<std::endl;
303 |     for(int i=0;i<95;i++)
304 |     {
305 |         if(i==0)
306 |             fout<<"space ";
307 |         else
308 |             fout<<(char)(i+32)<<' ';
309 |         for(int j=0;j<95;j++)
310 |             fout<<cnt[i][j]/100.0<<' ';
311 |         fout<<std::endl;
312 |     }
313 |     fout.close();
314 | }
315 | #endif
316 | 


--------------------------------------------------------------------------------
/src/gru.cpp:
--------------------------------------------------------------------------------
  1 | /*grufunction.h header file made by ValK*/
  2 | /*2019/5/9                   version 1.2*/
  3 | #include "gru.h"
  4 | 
  5 | #include <iostream>
  6 | #include <fstream>
  7 | #include <cstring>
  8 | #include <cmath>
  9 | #include <cstdlib>
 10 | #include <ctime>
 11 | 
 12 | NormalGRU::NormalGRU(int InputlayerNum,int HiddenlayerNum,int Maxtime)
 13 | {
 14 |     INUM=InputlayerNum;
 15 |     HNUM=HiddenlayerNum;
 16 |     MAXTIME=Maxtime;
 17 |     hide=new gru_neuron[HNUM];
 18 |     for(int i=0;i<HNUM;i++)
 19 |     {
 20 |         hide[i].out=new double[Maxtime];
 21 |         hide[i].sig_update_in=new double[Maxtime];  hide[i].sig_replace_in=new double[Maxtime];  hide[i].tan_replace_in=new double[Maxtime];
 22 |         hide[i].sig_update_out=new double[Maxtime]; hide[i].sig_replace_out=new double[Maxtime]; hide[i].tan_replace_out=new double[Maxtime];
 23 |         hide[i].sig_update_diff=new double[Maxtime];hide[i].sig_replace_diff=new double[Maxtime];hide[i].tan_replace_diff=new double[Maxtime];
 24 |         hide[i].sig_update_wi=new double[INUM];     hide[i].sig_replace_wi=new double[INUM];     hide[i].tan_replace_wi=new double[INUM];
 25 |         hide[i].sig_update_wh=new double[HNUM];     hide[i].sig_replace_wh=new double[HNUM];     hide[i].tan_replace_wh=new double[HNUM];
 26 |         hide[i].sig_update_transwi=new double[INUM];hide[i].sig_replace_transwi=new double[INUM];hide[i].tan_replace_transwi=new double[INUM];
 27 |         hide[i].sig_update_transwh=new double[HNUM];hide[i].sig_replace_transwh=new double[HNUM];hide[i].tan_replace_transwh=new double[HNUM];
 28 |     }
 29 |     return;
 30 | }
 31 | 
 32 | NormalGRU::~NormalGRU()
 33 | {
 34 |     for(int i=0;i<HNUM;i++)
 35 |     {
 36 |         delete []hide[i].out;
 37 |         delete []hide[i].sig_update_in;     delete []hide[i].sig_replace_in;     delete []hide[i].tan_replace_in;
 38 |         delete []hide[i].sig_update_out;    delete []hide[i].sig_replace_out;    delete []hide[i].tan_replace_out;
 39 |         delete []hide[i].sig_update_diff;   delete []hide[i].sig_replace_diff;   delete []hide[i].tan_replace_diff;
 40 |         delete []hide[i].sig_update_wi;     delete []hide[i].sig_replace_wi;     delete []hide[i].tan_replace_wi;
 41 |         delete []hide[i].sig_update_wh;     delete []hide[i].sig_replace_wh;     delete []hide[i].tan_replace_wh;
 42 |         delete []hide[i].sig_update_transwi;delete []hide[i].sig_replace_transwi;delete []hide[i].tan_replace_transwi;
 43 |         delete []hide[i].sig_update_transwh;delete []hide[i].sig_replace_transwh;delete []hide[i].tan_replace_transwh;
 44 |     }
 45 |     delete []hide;
 46 |     return;
 47 | }
 48 | 
 49 | void NormalGRU::Init()
 50 | {
 51 |     srand(unsigned(time(NULL)));
 52 |     for(int i=0;i<HNUM;i++)
 53 |     {
 54 |         hide[i].out[0]=0;
 55 |         hide[i].sig_update_bia=(rand()%2? 1:-1)*(1.0+rand()%10)/10.0;
 56 |         hide[i].sig_replace_bia=(rand()%2? 1:-1)*(1.0+rand()%10)/10.0;
 57 |         hide[i].tan_replace_bia=(rand()%2? 1:-1)*(1.0+rand()%10)/10.0;
 58 |         for(int j=0;j<INUM;j++)
 59 |         {
 60 |             hide[i].sig_update_wi[j]=(rand()%2? 1:-1)*(1.0+rand()%10)/50.0;
 61 |             hide[i].sig_replace_wi[j]=(rand()%2? 1:-1)*(1.0+rand()%10)/50.0;
 62 |             hide[i].tan_replace_wi[j]=(rand()%2? 1:-1)*(1.0+rand()%10)/50.0;
 63 |         }
 64 |         for(int j=0;j<HNUM;j++)
 65 |         {
 66 |             hide[i].sig_update_wh[j]=(rand()%2? 1:-1)*(1.0+rand()%10)/50.0;
 67 |             hide[i].sig_replace_wh[j]=(rand()%2? 1:-1)*(1.0+rand()%10)/50.0;
 68 |             hide[i].tan_replace_wh[j]=(rand()%2? 1:-1)*(1.0+rand()%10)/50.0;
 69 |         }
 70 |     }
 71 |     return;
 72 | }
 73 | 
 74 | void NormalGRU::Datain(const std::string& filename)
 75 | {
 76 |     std::ifstream fin(filename);
 77 |     if(fin.fail())
 78 |     {
 79 |         std::cout<<">> [Error] Cannot open file."<<std::endl;
 80 |         exit(-1);
 81 |     }
 82 |     for(int i=0;i<HNUM;i++)
 83 |     {
 84 |         fin>>hide[i].out[0];
 85 |         fin>>hide[i].sig_update_bia;
 86 |         fin>>hide[i].sig_replace_bia;
 87 |         fin>>hide[i].tan_replace_bia;
 88 |         for(int j=0;j<INUM;j++)
 89 |         {
 90 |             fin>>hide[i].sig_update_wi[j];
 91 |             fin>>hide[i].sig_replace_wi[j];
 92 |             fin>>hide[i].tan_replace_wi[j];
 93 |         }
 94 |         for(int j=0;j<HNUM;j++)
 95 |         {
 96 |             fin>>hide[i].sig_update_wh[j];
 97 |             fin>>hide[i].sig_replace_wh[j];
 98 |             fin>>hide[i].tan_replace_wh[j];
 99 |         }
100 |     }
101 |     fin.close();
102 |     return;
103 | }
104 | 
105 | void NormalGRU::Dataout(const std::string& filename)
106 | {
107 |     std::ofstream fout(filename);
108 |     if(fout.fail())
109 |     {
110 |         std::cout<<">> [Error] Cannot open file."<<std::endl;
111 |         exit(-1);
112 |     }
113 |     for(int i=0;i<HNUM;i++)
114 |     {
115 |         fout<<hide[i].out[0]<<std::endl;
116 |         fout<<hide[i].sig_update_bia<<std::endl;
117 |         fout<<hide[i].sig_replace_bia<<std::endl;
118 |         fout<<hide[i].tan_replace_bia<<std::endl;
119 |         for(int j=0;j<INUM;j++)
120 |         {
121 |             fout<<hide[i].sig_update_wi[j]<<std::endl;
122 |             fout<<hide[i].sig_replace_wi[j]<<std::endl;
123 |             fout<<hide[i].tan_replace_wi[j]<<std::endl;
124 |         }
125 |         for(int j=0;j<HNUM;j++)
126 |         {
127 |             fout<<hide[i].sig_update_wh[j]<<std::endl;
128 |             fout<<hide[i].sig_replace_wh[j]<<std::endl;
129 |             fout<<hide[i].tan_replace_wh[j]<<std::endl;
130 |         }
131 |     }
132 |     fout.close();
133 |     return;
134 | }
135 | 
136 | DeepGRU::DeepGRU(int InputlayerNum,int HiddenlayerNum,int Depth,int Maxtime)
137 | {
138 |     INUM=InputlayerNum;
139 |     HNUM=HiddenlayerNum;
140 |     DEPTH=Depth-1;
141 |     MAXTIME=Maxtime;
142 |     ConstructorAssist();
143 | }
144 | 
145 | DeepGRU::~DeepGRU()
146 | {
147 |     DestructorAssist();
148 | }
149 | 
150 | void DeepGRU::ConstructorAssist()
151 | {
152 |     int Maxtime=MAXTIME;
153 |     hlink=new gru_neuron[HNUM];
154 |     hide=new gru_neuron*[HNUM];
155 |     for(int i=0;i<HNUM;i++)
156 |         hide[i]=new gru_neuron[DEPTH];
157 |     for(int i=0;i<HNUM;i++)
158 |     {
159 |         hlink[i].out=new double[Maxtime];
160 |         hlink[i].sig_update_in=new double[Maxtime];  hlink[i].sig_replace_in=new double[Maxtime];  hlink[i].tan_replace_in=new double[Maxtime];
161 |         hlink[i].sig_update_out=new double[Maxtime]; hlink[i].sig_replace_out=new double[Maxtime]; hlink[i].tan_replace_out=new double[Maxtime];
162 |         hlink[i].sig_update_diff=new double[Maxtime];hlink[i].sig_replace_diff=new double[Maxtime];hlink[i].tan_replace_diff=new double[Maxtime];
163 |         hlink[i].sig_update_wi=new double[INUM];     hlink[i].sig_replace_wi=new double[INUM];     hlink[i].tan_replace_wi=new double[INUM];
164 |         hlink[i].sig_update_wh=new double[HNUM];     hlink[i].sig_replace_wh=new double[HNUM];     hlink[i].tan_replace_wh=new double[HNUM];
165 |         hlink[i].sig_update_transwi=new double[INUM];hlink[i].sig_replace_transwi=new double[INUM];hlink[i].tan_replace_transwi=new double[INUM];
166 |         hlink[i].sig_update_transwh=new double[HNUM];hlink[i].sig_replace_transwh=new double[HNUM];hlink[i].tan_replace_transwh=new double[HNUM];
167 |     }
168 |     for(int d=0;d<DEPTH;d++)
169 |         for(int i=0;i<HNUM;i++)
170 |         {
171 |             hide[i][d].out=new double[Maxtime];
172 |             hide[i][d].sig_update_in=new double[Maxtime];  hide[i][d].sig_replace_in=new double[Maxtime];  hide[i][d].tan_replace_in=new double[Maxtime];
173 |             hide[i][d].sig_update_out=new double[Maxtime]; hide[i][d].sig_replace_out=new double[Maxtime]; hide[i][d].tan_replace_out=new double[Maxtime];
174 |             hide[i][d].sig_update_diff=new double[Maxtime];hide[i][d].sig_replace_diff=new double[Maxtime];hide[i][d].tan_replace_diff=new double[Maxtime];
175 |             hide[i][d].sig_update_wi=new double[HNUM];     hide[i][d].sig_replace_wi=new double[HNUM];     hide[i][d].tan_replace_wi=new double[HNUM];//must be HNUM
176 |             hide[i][d].sig_update_wh=new double[HNUM];     hide[i][d].sig_replace_wh=new double[HNUM];     hide[i][d].tan_replace_wh=new double[HNUM];
177 |             hide[i][d].sig_update_transwi=new double[HNUM];hide[i][d].sig_replace_transwi=new double[HNUM];hide[i][d].tan_replace_transwi=new double[HNUM];
178 |             hide[i][d].sig_update_transwh=new double[HNUM];hide[i][d].sig_replace_transwh=new double[HNUM];hide[i][d].tan_replace_transwh=new double[HNUM];
179 |         }
180 | }
181 | 
182 | void DeepGRU::DestructorAssist()
183 | {
184 |     for(int d=0;d<DEPTH;d++)
185 |         for(int i=0;i<HNUM;i++)
186 |         {
187 |             delete []hide[i][d].out;
188 |             delete []hide[i][d].sig_update_in;     delete []hide[i][d].sig_replace_in;     delete []hide[i][d].tan_replace_in;
189 |             delete []hide[i][d].sig_update_out;    delete []hide[i][d].sig_replace_out;    delete []hide[i][d].tan_replace_out;
190 |             delete []hide[i][d].sig_update_diff;   delete []hide[i][d].sig_replace_diff;   delete []hide[i][d].tan_replace_diff;
191 |             delete []hide[i][d].sig_update_wi;     delete []hide[i][d].sig_replace_wi;     delete []hide[i][d].tan_replace_wi;
192 |             delete []hide[i][d].sig_update_wh;     delete []hide[i][d].sig_replace_wh;     delete []hide[i][d].tan_replace_wh;
193 |             delete []hide[i][d].sig_update_transwi;delete []hide[i][d].sig_replace_transwi;delete []hide[i][d].tan_replace_transwi;
194 |             delete []hide[i][d].sig_update_transwh;delete []hide[i][d].sig_replace_transwh;delete []hide[i][d].tan_replace_transwh;
195 |         }
196 |     for(int i=0;i<HNUM;i++)
197 |     {
198 |         delete []hlink[i].out;
199 |         delete []hlink[i].sig_update_in;     delete []hlink[i].sig_replace_in;     delete []hlink[i].tan_replace_in;
200 |         delete []hlink[i].sig_update_out;    delete []hlink[i].sig_replace_out;    delete []hlink[i].tan_replace_out;
201 |         delete []hlink[i].sig_update_diff;   delete []hlink[i].sig_replace_diff;   delete []hlink[i].tan_replace_diff;
202 |         delete []hlink[i].sig_update_wi;     delete []hlink[i].sig_replace_wi;     delete []hlink[i].tan_replace_wi;
203 |         delete []hlink[i].sig_update_wh;     delete []hlink[i].sig_replace_wh;     delete []hlink[i].tan_replace_wh;
204 |         delete []hlink[i].sig_update_transwi;delete []hlink[i].sig_replace_transwi;delete []hlink[i].tan_replace_transwi;
205 |         delete []hlink[i].sig_update_transwh;delete []hlink[i].sig_replace_transwh;delete []hlink[i].tan_replace_transwh;
206 |     }
207 |     for(int i=0;i<HNUM;i++)
208 |         delete []hide[i];
209 |     delete []hlink;
210 |     delete []hide;
211 | }
212 | 
213 | void DeepGRU::Init()
214 | {
215 |     srand(unsigned(time(NULL)));
216 |     for(int i=0;i<HNUM;i++)
217 |     {
218 |         hlink[i].out[0]=0;
219 |         hlink[i].sig_update_bia=(rand()%2? 1:-1)*(1.0+rand()%10)/10.0;
220 |         hlink[i].sig_replace_bia=(rand()%2? 1:-1)*(1.0+rand()%10)/10.0;
221 |         hlink[i].tan_replace_bia=(rand()%2? 1:-1)*(1.0+rand()%10)/10.0;
222 |         for(int j=0;j<INUM;j++)
223 |         {
224 |             hlink[i].sig_update_wi[j]=(rand()%2? 1:-1)*(1.0+rand()%10)/50.0;
225 |             hlink[i].sig_replace_wi[j]=(rand()%2? 1:-1)*(1.0+rand()%10)/50.0;
226 |             hlink[i].tan_replace_wi[j]=(rand()%2? 1:-1)*(1.0+rand()%10)/50.0;
227 |         }
228 |         for(int j=0;j<HNUM;j++)
229 |         {
230 |             hlink[i].sig_update_wh[j]=(rand()%2? 1:-1)*(1.0+rand()%10)/50.0;
231 |             hlink[i].sig_replace_wh[j]=(rand()%2? 1:-1)*(1.0+rand()%10)/50.0;
232 |             hlink[i].tan_replace_wh[j]=(rand()%2? 1:-1)*(1.0+rand()%10)/50.0;
233 |         }
234 |     }
235 |     for(int d=0;d<DEPTH;d++)
236 |         for(int i=0;i<HNUM;i++)
237 |         {
238 |             hide[i][d].out[0]=0;
239 |             hide[i][d].sig_update_bia=(rand()%2? 1:-1)*(1.0+rand()%10)/10.0;
240 |             hide[i][d].sig_replace_bia=(rand()%2? 1:-1)*(1.0+rand()%10)/10.0;
241 |             hide[i][d].tan_replace_bia=(rand()%2? 1:-1)*(1.0+rand()%10)/10.0;
242 |             for(int j=0;j<HNUM;j++)
243 |             {
244 |                 hide[i][d].sig_update_wi[j]=(rand()%2? 1:-1)*(1.0+rand()%10)/50.0;
245 |                 hide[i][d].sig_replace_wi[j]=(rand()%2? 1:-1)*(1.0+rand()%10)/50.0;
246 |                 hide[i][d].tan_replace_wi[j]=(rand()%2? 1:-1)*(1.0+rand()%10)/50.0;
247 |                 hide[i][d].sig_update_wh[j]=(rand()%2? 1:-1)*(1.0+rand()%10)/50.0;
248 |                 hide[i][d].sig_replace_wh[j]=(rand()%2? 1:-1)*(1.0+rand()%10)/50.0;
249 |                 hide[i][d].tan_replace_wh[j]=(rand()%2? 1:-1)*(1.0+rand()%10)/50.0;
250 |             }
251 |         }
252 |     return;
253 | }
254 | 
255 | void DeepGRU::Datain(const std::string& filename)
256 | {
257 |     std::ifstream fin(filename);
258 |     if(fin.fail())
259 |     {
260 |         std::cout<<">> [Error] Cannot open file."<<std::endl;
261 |         exit(-1);
262 |     }
263 |     for(int i=0;i<HNUM;i++)
264 |     {
265 |         fin>>hlink[i].out[0];
266 |         fin>>hlink[i].sig_update_bia;
267 |         fin>>hlink[i].sig_replace_bia;
268 |         fin>>hlink[i].tan_replace_bia;
269 |         for(int j=0;j<INUM;j++)
270 |         {
271 |             fin>>hlink[i].sig_update_wi[j];
272 |             fin>>hlink[i].sig_replace_wi[j];
273 |             fin>>hlink[i].tan_replace_wi[j];
274 |         }
275 |         for(int j=0;j<HNUM;j++)
276 |         {
277 |             fin>>hlink[i].sig_update_wh[j];
278 |             fin>>hlink[i].sig_replace_wh[j];
279 |             fin>>hlink[i].tan_replace_wh[j];
280 |         }
281 |     }
282 |     for(int d=0;d<DEPTH;d++)
283 |         for(int i=0;i<HNUM;i++)
284 |         {
285 |             fin>>hide[i][d].out[0];
286 |             fin>>hide[i][d].sig_update_bia;
287 |             fin>>hide[i][d].sig_replace_bia;
288 |             fin>>hide[i][d].tan_replace_bia;
289 |             for(int j=0;j<HNUM;j++)
290 |             {
291 |                 fin>>hide[i][d].sig_update_wi[j];
292 |                 fin>>hide[i][d].sig_replace_wi[j];
293 |                 fin>>hide[i][d].tan_replace_wi[j];
294 |                 fin>>hide[i][d].sig_update_wh[j];
295 |                 fin>>hide[i][d].sig_replace_wh[j];
296 |                 fin>>hide[i][d].tan_replace_wh[j];
297 |             }
298 |         }
299 |     fin.close();
300 |     return;
301 | }
302 | 
303 | void DeepGRU::Dataout(const std::string& filename)
304 | {
305 |     std::ofstream fout(filename);
306 |     if(fout.fail())
307 |     {
308 |         std::cout<<">> [Error] Cannot open file."<<std::endl;
309 |         exit(-1);
310 |     }
311 |     for(int i=0;i<HNUM;i++)
312 |     {
313 |         fout<<hlink[i].out[0]<<std::endl;
314 |         fout<<hlink[i].sig_update_bia<<std::endl;
315 |         fout<<hlink[i].sig_replace_bia<<std::endl;
316 |         fout<<hlink[i].tan_replace_bia<<std::endl;
317 |         for(int j=0;j<INUM;j++)
318 |         {
319 |             fout<<hlink[i].sig_update_wi[j]<<std::endl;
320 |             fout<<hlink[i].sig_replace_wi[j]<<std::endl;
321 |             fout<<hlink[i].tan_replace_wi[j]<<std::endl;
322 |         }
323 |         for(int j=0;j<HNUM;j++)
324 |         {
325 |             fout<<hlink[i].sig_update_wh[j]<<std::endl;
326 |             fout<<hlink[i].sig_replace_wh[j]<<std::endl;
327 |             fout<<hlink[i].tan_replace_wh[j]<<std::endl;
328 |         }
329 |     }
330 |     for(int d=0;d<DEPTH;d++)
331 |         for(int i=0;i<HNUM;i++)
332 |         {
333 |             fout<<hide[i][d].out[0];
334 |             fout<<hide[i][d].sig_update_bia<<std::endl;
335 |             fout<<hide[i][d].sig_replace_bia<<std::endl;
336 |             fout<<hide[i][d].tan_replace_bia<<std::endl;
337 |             for(int j=0;j<HNUM;j++)
338 |             {
339 |                 fout<<hide[i][d].sig_update_wi[j]<<std::endl;
340 |                 fout<<hide[i][d].sig_replace_wi[j]<<std::endl;
341 |                 fout<<hide[i][d].tan_replace_wi[j]<<std::endl;
342 |                 fout<<hide[i][d].sig_update_wh[j]<<std::endl;
343 |                 fout<<hide[i][d].sig_replace_wh[j]<<std::endl;
344 |                 fout<<hide[i][d].tan_replace_wh[j]<<std::endl;
345 |             }
346 |         }
347 |     fout.close();
348 |     return;
349 | }
350 | 


--------------------------------------------------------------------------------
/src/bp.cpp:
--------------------------------------------------------------------------------
  1 | /*bpfunction.h header file made by ValK*/
  2 | /*2019/5/5                  version 1.0*/
  3 | #include "bp.h"
  4 | #include "actvfunc.h"
  5 | 
  6 | #include <iostream>
  7 | #include <ctime>
  8 | #include <fstream>
  9 | #include <cstdlib>
 10 | 
 11 | NormalBP::NormalBP(int inputlayer_num,int hiddenlayer_num,int outputlayer_num)
 12 | {
 13 |     error=1e8;
 14 |     lr=0;
 15 |     func_name="Unknown";
 16 |     INUM=inputlayer_num;
 17 |     HNUM=hiddenlayer_num;
 18 |     ONUM=outputlayer_num;
 19 |     batch_size=1;
 20 |     input=new double[INUM];
 21 |     expect=new double[ONUM];
 22 |     hide=new neuron[HNUM];
 23 |     output=new neuron[ONUM];
 24 |     for(int i=0;i<HNUM;i++)
 25 |         hide[i].w=new double[INUM];
 26 |     for(int i=0;i<ONUM;i++)
 27 |         output[i].w=new double[HNUM];
 28 | }
 29 | 
 30 | NormalBP::~NormalBP()
 31 | {
 32 |     for(int i=0;i<HNUM;i++)
 33 |         delete []hide[i].w;
 34 |     for(int i=0;i<ONUM;i++)
 35 |         delete []output[i].w;
 36 |     delete []hide;
 37 |     delete []output;
 38 |     delete []input;
 39 |     delete []expect;
 40 | }
 41 | 
 42 | double NormalBP::ActivateFunction(double x)
 43 | {
 44 |     if(func_name=="Unknown")
 45 |     {
 46 |         std::cout<<">> [Error] You haven't chose a correct funtion.";
 47 |         exit(-1);
 48 |     }
 49 |     else if(func_name=="sigmoid")
 50 |         return sigmoid(x);
 51 |     else if(func_name=="tanh")
 52 |         return tanh(x);
 53 |     else if(func_name=="relu")
 54 |         return relu(x);
 55 |     else if(func_name=="leakyrelu")
 56 |         return leakyrelu(x);
 57 |     else if(func_name=="elu")
 58 |         return elu(x);
 59 |     else
 60 |     {
 61 |         std::cout<<">> [Error] You haven't chose a correct funtion.";
 62 |         exit(-1);
 63 |     }
 64 | }
 65 | 
 66 | double NormalBP::DiffFunction(double x)
 67 | {
 68 |     if(func_name=="Unknown")
 69 |     {
 70 |         std::cout<<">> [Error] You haven't chose a correct funtion.";
 71 |         exit(-1);
 72 |     }
 73 |     else if(func_name=="sigmoid")
 74 |         return diffsigmoid(x);
 75 |     else if(func_name=="tanh")
 76 |         return difftanh(x);
 77 |     else if(func_name=="relu")
 78 |         return diffrelu(x);
 79 |     else if(func_name=="leakyrelu")
 80 |         return diffleakyrelu(x);
 81 |     else if(func_name=="elu")
 82 |         return diffelu(x);
 83 |     else
 84 |     {
 85 |         std::cout<<">> [Error] You haven't chose a correct funtion.";
 86 |         exit(-1);
 87 |     }
 88 | }
 89 | 
 90 | void NormalBP::Init()
 91 | {
 92 |     srand(unsigned(time(NULL)));
 93 |     for(int i=0;i<HNUM;i++)
 94 |     {
 95 |         hide[i].bia=(1+rand()%10)/10.0;
 96 |         for(int j=0;j<INUM;j++)
 97 |             hide[i].w[j]=(1+rand()%10)/50.0;
 98 |     }
 99 |     for(int i=0;i<ONUM;i++)
100 |     {
101 |         output[i].bia=(1+rand()%10)/10.0;
102 |         for(int j=0;j<HNUM;j++)
103 |             output[i].w[j]=(1+rand()%10)/50.0;
104 |     }
105 |     return;
106 | }
107 | 
108 | void NormalBP::Calc()
109 | {
110 |     for(int i=0;i<HNUM;i++)
111 |     {
112 |         hide[i].in=hide[i].bia;
113 |         for(int j=0;j<INUM;j++)
114 |             hide[i].in+=hide[i].w[j]*input[j];
115 |         hide[i].out=ActivateFunction(hide[i].in);
116 |     }
117 |     for(int i=0;i<ONUM;i++)
118 |     {
119 |         output[i].in=output[i].bia;
120 |         for(int j=0;j<INUM;j++)
121 |             output[i].in+=output[i].w[j]*hide[j].out;
122 |         output[i].out=ActivateFunction(output[i].in);
123 |     }
124 |     return;
125 | }
126 | 
127 | void NormalBP::ErrorCalc()
128 | {
129 |     double trans;
130 |     error=0;
131 |     for(int i=0;i<ONUM;i++)
132 |     {
133 |         trans=expect[i]-output[i].out;
134 |         error+=trans*trans;
135 |     }
136 |     error*=0.5;
137 |     return;
138 | }
139 | 
140 | double NormalBP::GetError()
141 | {
142 |     return error;
143 | }
144 | 
145 | void NormalBP::SetLearningrate(double __lr)
146 | {
147 |     lr=__lr;
148 | }
149 | 
150 | void NormalBP::Training()
151 | {
152 |     for(int i=0;i<ONUM;i++)
153 |         output[i].diff=(expect[i]-output[i].out)*DiffFunction(output[i].in);
154 |     for(int i=0;i<HNUM;i++)
155 |     {
156 |         hide[i].diff=0;
157 |         for(int j=0;j<ONUM;j++)
158 |             hide[i].diff+=output[j].w[i]*output[j].diff;
159 |         hide[i].diff*=DiffFunction(hide[i].in);
160 |     }
161 |     
162 |     for(int i=0;i<ONUM;i++)
163 |     {
164 |         output[i].bia+=2*lr*output[i].diff;
165 |         for(int j=0;j<HNUM;j++)
166 |             output[i].w[j]+=lr*output[i].diff*hide[j].out;
167 |     }
168 |     for(int i=0;i<HNUM;i++)
169 |     {
170 |         hide[i].bia+=2*lr*hide[i].diff;
171 |         for(int j=0;j<INUM;j++)
172 |             hide[i].w[j]+=lr*hide[i].diff*input[j];
173 |     }
174 |     return;
175 | }
176 | 
177 | void NormalBP::Datain(const std::string& filename)
178 | {
179 |     std::ifstream fin(filename);
180 |     if(fin.fail())
181 |     {
182 |         std::cout<<">> [Error] Cannot open file."<<std::endl;
183 |         exit(-1);
184 |     }
185 |     for(int i=0;i<HNUM;i++)
186 |     {
187 |         fin>>hide[i].bia;
188 |         for(int j=0;j<INUM;j++)
189 |             fin>>hide[i].w[j];
190 |     }
191 |     for(int i=0;i<ONUM;i++)
192 |     {
193 |         fin>>output[i].bia;
194 |         for(int j=0;j<HNUM;j++)
195 |             fin>>output[i].w[j];
196 |     }
197 |     fin.close();
198 | }
199 | 
200 | void NormalBP::Dataout(const std::string& filename)
201 | {
202 |     std::ofstream fout(filename);
203 |     if(fout.fail())
204 |     {
205 |         std::cout<<">> [Error] Cannot open file."<<std::endl;
206 |         exit(-1);
207 |     }
208 |     for(int i=0;i<HNUM;i++)
209 |     {
210 |         fout<<hide[i].bia<<std::endl;
211 |         for(int j=0;j<INUM;j++)
212 |             fout<<hide[i].w[j]<<std::endl;
213 |     }
214 |     for(int i=0;i<ONUM;i++)
215 |     {
216 |         fout<<output[i].bia<<std::endl;
217 |         for(int j=0;j<HNUM;j++)
218 |             fout<<output[i].w[j]<<std::endl;
219 |     }
220 |     fout.close();
221 |     std::cout<<">> Output finished"<<std::endl;
222 | }
223 | 
224 | void NormalBP::SetFunction(const std::string& func)
225 | {
226 |     func_name=func;
227 | }
228 | 
229 | void NormalBP::TotalWork(
230 |     const std::string& dataFilename,
231 |     const std::string& QuestiondataName,
232 |     const std::string& TrainingdataName)
233 | {
234 |     if(!fopen(dataFilename.c_str(),"r"))
235 |     {
236 |         Init();
237 |         Dataout(dataFilename);
238 |         std::cout<<">> [NormalBP] Initializing completed.\n";
239 |     }
240 |     else
241 |         Datain(dataFilename);
242 |     double maxerror=1e8;
243 |     int epoch=0;
244 |     while(maxerror>0.01)
245 |     {
246 |         epoch++;
247 |         maxerror=0;
248 |         std::ifstream finq(QuestiondataName);
249 |         std::ifstream fint(TrainingdataName);
250 |         if(finq.fail()||fint.fail())
251 |         {
252 |             std::cout<<">> [Error] Cannot open data file!"<<std::endl;
253 |             std::cout<<">> [Error] Lack "<<QuestiondataName<<" and "<<TrainingdataName<<std::endl;
254 |             exit(-1);
255 |         }
256 |         for(int b=0;b<batch_size;b++)
257 |         {
258 |             for(int i=0;i<INUM;i++)
259 |                 finq>>input[i];
260 |             for(int i=0;i<ONUM;i++)
261 |                 fint>>expect[i];
262 |             Calc();
263 |             ErrorCalc();
264 |             Training();
265 |             maxerror+=error;
266 |         }
267 |         finq.close();
268 |         fint.close();
269 |         if(epoch%10==0)
270 |         {
271 |             std::cout<<">> Epoch "<<epoch<<": Error :"<<maxerror<<std::endl;
272 |             if(epoch%50==0)
273 |                 Dataout(dataFilename);
274 |         }
275 |     }
276 |     std::cout<<">> Final output in progress..."<<std::endl;
277 |     Dataout(dataFilename);
278 |     std::cout<<">> Training complete."<<std::endl;
279 |     return;
280 | }
281 | 
282 | DeepBP::DeepBP(int inputlayer_num,int hiddenlayer_num,int outputlayer_num,int depth)
283 | {
284 |     error=1e8;
285 |     lr=0;
286 |     func_name="Unknown";
287 |     INUM=inputlayer_num;
288 |     HNUM=hiddenlayer_num;
289 |     ONUM=outputlayer_num;
290 |     batch_size=1;
291 |     DEPTH=depth-1;
292 |     input=new double[INUM];
293 |     expect=new double[ONUM];
294 |     hlink=new neuron[HNUM];
295 |     hide=new neuron*[HNUM];
296 |     output=new neuron[ONUM];
297 |     for(int i=0;i<HNUM;i++)
298 |         hide[i]=new neuron[DEPTH];
299 |     for(int d=0;d<DEPTH;d++)
300 |         for(int i=0;i<HNUM;i++)
301 |             hide[i][d].w=new double[HNUM];
302 |     for(int i=0;i<HNUM;i++)
303 |         hlink[i].w=new double[INUM];
304 |     for(int i=0;i<ONUM;i++)
305 |         output[i].w=new double[HNUM];
306 | }
307 | 
308 | DeepBP::~DeepBP()
309 | {
310 |     delete []input;
311 |     delete []expect;
312 |     for(int d=0;d<DEPTH;d++)
313 |         for(int i=0;i<HNUM;i++)
314 |             delete []hide[i][d].w;
315 |     for(int i=0;i<HNUM;i++)
316 |         delete []hide[i];
317 |     for(int i=0;i<HNUM;i++)
318 |         delete []hlink[i].w;
319 |     for(int i=0;i<ONUM;i++)
320 |         delete []output[i].w;
321 |     delete []hlink;
322 |     delete []hide;
323 |     delete []output;
324 | }
325 | 
326 | double DeepBP::ActivateFunction(double x)
327 | {
328 |     if(func_name=="Unknown")
329 |     {
330 |         std::cout<<">> [Error] You haven't chose a correct funtion.";
331 |         exit(-1);
332 |     }
333 |     else if(func_name=="sigmoid")
334 |         return sigmoid(x);
335 |     else if(func_name=="tanh")
336 |         return tanh(x);
337 |     else if(func_name=="relu")
338 |         return relu(x);
339 |     else if(func_name=="leakyrelu")
340 |         return leakyrelu(x);
341 |     else if(func_name=="elu")
342 |         return elu(x);
343 |     else
344 |     {
345 |         std::cout<<">> [Error] You haven't chose a correct funtion.";
346 |         exit(-1);
347 |     }
348 | }
349 | 
350 | double DeepBP::DiffFunction(double x)
351 | {
352 |     if(func_name=="Unknown")
353 |     {
354 |         std::cout<<">> [Error] You haven't chose a correct funtion.";
355 |         exit(-1);
356 |     }
357 |     else if(func_name=="sigmoid")
358 |         return diffsigmoid(x);
359 |     else if(func_name=="tanh")
360 |         return difftanh(x);
361 |     else if(func_name=="relu")
362 |         return diffrelu(x);
363 |     else if(func_name=="leakyrelu")
364 |         return diffleakyrelu(x);
365 |     else if(func_name=="elu")
366 |         return diffelu(x);
367 |     else
368 |     {
369 |         std::cout<<">> [Error] You haven't chose a correct funtion.";
370 |         exit(-1);
371 |     }
372 | }
373 | 
374 | void DeepBP::Init()
375 | {
376 |     srand(unsigned(time(NULL)));
377 |     for(int i=0;i<HNUM;i++)
378 |     {
379 |         hlink[i].bia=(1+rand()%10)/10.0;
380 |         for(int j=0;j<INUM;j++)
381 |             hlink[i].w[j]=(1+rand()%10)/50.0;
382 |     }
383 |     for(int d=0;d<DEPTH;d++)
384 |         for(int i=0;i<HNUM;i++)
385 |         {
386 |             hide[i][d].bia=(1+rand()%10)/10.0;
387 |             for(int j=0;j<HNUM;j++)
388 |                 hide[i][d].w[j]=(1+rand()%10)/50.0;
389 |         }
390 |     for(int i=0;i<ONUM;i++)
391 |     {
392 |         output[i].bia=(1+rand()%10)/10.0;
393 |         for(int j=0;j<HNUM;j++)
394 |             output[i].w[j]=(1+rand()%10)/50.0;
395 |     }
396 |     return;
397 | }
398 | 
399 | void DeepBP::Calc()
400 | {
401 |     for(int i=0;i<HNUM;i++)
402 |     {
403 |         hlink[i].in=hlink[i].bia;
404 |         for(int j=0;j<INUM;j++)
405 |             hlink[i].in+=hlink[i].w[j]*input[j];
406 |         hlink[i].out=ActivateFunction(hlink[i].in);
407 |     }
408 |     for(int d=0;d<DEPTH;d++)
409 |         for(int i=0;i<HNUM;i++)
410 |         {
411 |             hide[i][d].in=hide[i][d].bia;
412 |             for(int j=0;j<HNUM;j++)
413 |                 hide[i][d].in+=hide[i][d].w[j]*(d==0? hlink[j].out:hide[j][d-1].out);
414 |             hide[i][d].out=ActivateFunction(hide[i][d].in);
415 |         }
416 |     for(int i=0;i<ONUM;i++)
417 |     {
418 |         output[i].in=output[i].bia;
419 |         for(int j=0;j<HNUM;j++)
420 |             output[i].in+=output[i].w[j]*hide[j][DEPTH-1].out;
421 |         output[i].out=ActivateFunction(output[i].in);
422 |     }
423 |     return;
424 | }
425 | 
426 | void DeepBP::ErrorCalc()
427 | {
428 |     double trans;
429 |     error=0;
430 |     for(int i=0;i<ONUM;i++)
431 |     {
432 |         trans=expect[i]-output[i].out;
433 |         error+=trans*trans;
434 |     }
435 |     error*=0.5;
436 |     return;
437 | }
438 | 
439 | double DeepBP::GetError()
440 | {
441 |     return error;
442 | }
443 | 
444 | void DeepBP::SetLearningrate(double __lr)
445 | {
446 |     lr=__lr;
447 | }
448 | 
449 | void DeepBP::Training()
450 | {
451 |     for(int i=0;i<ONUM;i++)
452 |         output[i].diff=(expect[i]-output[i].out)*DiffFunction(output[i].in);
453 |     for(int i=0;i<HNUM;i++)
454 |     {
455 |         hide[i][DEPTH-1].diff=0;
456 |         for(int j=0;j<ONUM;j++)
457 |             hide[i][DEPTH-1].diff+=output[j].w[i]*output[j].diff;
458 |         hide[i][DEPTH-1].diff*=DiffFunction(hide[i][DEPTH-1].in);
459 |     }
460 |     for(int d=DEPTH-2;d>=0;d--)
461 |         for(int i=0;i<HNUM;i++)
462 |         {
463 |             hide[i][d].diff=0;
464 |             for(int j=0;j<HNUM;j++)
465 |                 hide[i][d].diff+=hide[j][d+1].w[i]*hide[j][d+1].diff;
466 |             hide[i][d].diff*=DiffFunction(hide[i][d].in);
467 |         }
468 |     for(int i=0;i<HNUM;i++)
469 |     {
470 |         hlink[i].diff=0;
471 |         for(int j=0;j<HNUM;j++)
472 |             hlink[i].diff+=hide[j][0].w[i]*hide[j][0].diff;
473 |         hlink[i].diff*=DiffFunction(hlink[i].in);
474 |     }
475 |     
476 |     for(int i=0;i<HNUM;i++)
477 |     {
478 |         hlink[i].bia+=2*lr*hlink[i].diff;
479 |         for(int j=0;j<INUM;j++)
480 |             hlink[i].w[j]+=lr*hlink[i].diff*input[j];
481 |     }
482 |     for(int d=0;d<DEPTH;d++)
483 |         for(int i=0;i<HNUM;i++)
484 |         {
485 |             hide[i][d].bia+=2*lr*hide[i][d].diff;
486 |             for(int j=0;j<HNUM;j++)
487 |                 hide[i][d].w[j]+=lr*hide[i][d].diff*(d==0? hlink[j].out:hide[j][d-1].out);
488 |         }
489 |     for(int i=0;i<ONUM;i++)
490 |     {
491 |         output[i].bia+=2*lr*output[i].diff;
492 |         for(int j=0;j<HNUM;j++)
493 |             output[i].w[j]+=lr*output[i].diff*hide[j][DEPTH-1].out;
494 |     }
495 |     return;
496 | }
497 | 
498 | void DeepBP::Datain(const std::string& filename)
499 | {
500 |     std::ifstream fin(filename);
501 |     if(fin.fail())
502 |     {
503 |         std::cout<<">> [Error] Cannot open file."<<std::endl;
504 |         exit(-1);
505 |     }
506 |     for(int i=0;i<HNUM;i++)
507 |     {
508 |         fin>>hlink[i].bia;
509 |         for(int j=0;j<INUM;j++)
510 |             fin>>hlink[i].w[j];
511 |     }
512 |     for(int d=0;d<DEPTH;d++)
513 |         for(int i=0;i<HNUM;i++)
514 |         {
515 |             fin>>hide[i][d].bia;
516 |             for(int j=0;j<HNUM;j++)
517 |                 fin>>hide[i][d].w[j];
518 |         }
519 |     for(int i=0;i<ONUM;i++)
520 |     {
521 |         fin>>output[i].bia;
522 |         for(int j=0;j<HNUM;j++)
523 |             fin>>output[i].w[j];
524 |     }
525 |     fin.close();
526 | }
527 | 
528 | void DeepBP::Dataout(const std::string& filename)
529 | {
530 |     std::ofstream fout(filename);
531 |     if(fout.fail())
532 |     {
533 |         std::cout<<">> [Error] Cannot open file."<<std::endl;
534 |         exit(-1);
535 |     }
536 |     for(int i=0;i<HNUM;i++)
537 |     {
538 |         fout<<hlink[i].bia<<std::endl;
539 |         for(int j=0;j<INUM;j++)
540 |             fout<<hlink[i].w[j]<<std::endl;
541 |     }
542 |     for(int d=0;d<DEPTH;d++)
543 |         for(int i=0;i<HNUM;i++)
544 |         {
545 |             fout<<hide[i][d].bia<<std::endl;
546 |             for(int j=0;j<HNUM;j++)
547 |                 fout<<hide[i][d].w[j]<<std::endl;
548 |         }
549 |     for(int i=0;i<ONUM;i++)
550 |     {
551 |         fout<<output[i].bia<<std::endl;
552 |         for(int j=0;j<HNUM;j++)
553 |             fout<<output[i].w[j]<<std::endl;
554 |     }
555 |     fout.close();
556 |     std::cout<<">> Output finished"<<std::endl;
557 | }
558 | 
559 | void DeepBP::SetFunction(const std::string& func)
560 | {
561 |     func_name=func;
562 | }
563 | 
564 | void DeepBP::TotalWork(
565 |     const std::string& dataFilename,
566 |     const std::string& QuestiondataName,
567 |     const std::string& TrainingdataName)
568 | {
569 |     if(!fopen(dataFilename.c_str(),"r"))
570 |     {
571 |         Init();
572 |         Dataout(dataFilename);
573 |         std::cout<<">> [DeepBP] Initializing completed.\n";
574 |     }
575 |     else
576 |         Datain(dataFilename);
577 |     double maxerror=1e8;
578 |     int epoch=0;
579 |     while(maxerror>0.01)
580 |     {
581 |         epoch++;
582 |         maxerror=0;
583 |         std::ifstream finq(QuestiondataName);
584 |         std::ifstream fint(TrainingdataName);
585 |         if(finq.fail()||fint.fail())
586 |         {
587 |             std::cout<<">> [Error] Cannot open data file!"<<std::endl;
588 |             std::cout<<">> [Error] Lack "<<QuestiondataName<<" and "<<TrainingdataName<<std::endl;
589 |             exit(-1);
590 |         }
591 |         for(int b=0;b<batch_size;b++)
592 |         {
593 |             for(int i=0;i<INUM;i++)
594 |                 finq>>input[i];
595 |             for(int i=0;i<ONUM;i++)
596 |                 fint>>expect[i];
597 |             Calc();
598 |             ErrorCalc();
599 |             Training();
600 |             maxerror+=error;
601 |         }
602 |         finq.close();
603 |         fint.close();
604 |         if(epoch%10==0)
605 |         {
606 |             std::cout<<">> Epoch "<<epoch<<": Error :"<<maxerror<<std::endl;
607 |             if(epoch%50==0)
608 |                 Dataout(dataFilename);
609 |         }
610 |     }
611 |     std::cout<<">> Final output in progress..."<<std::endl;
612 |     Dataout(dataFilename);
613 |     std::cout<<">> Training complete."<<std::endl;
614 |     return;
615 | }
616 | 


--------------------------------------------------------------------------------
/src/lstm.cpp:
--------------------------------------------------------------------------------
  1 | /*lstmfunction.h header file made by ValK*/
  2 | /*2019/5/9                    version 1.2*/
  3 | #include "lstm.h"
  4 | 
  5 | #include <iostream>
  6 | #include <ctime>
  7 | #include <fstream>
  8 | #include <cstdlib>
  9 | 
 10 | NormalLSTM::NormalLSTM(int InputlayerNum,int HiddenlayerNum,int Maxtime)
 11 | {
 12 |     MAXTIME=Maxtime;
 13 |     INUM=InputlayerNum;
 14 |     HNUM=HiddenlayerNum;
 15 |     hide=new lstm_neuron[HNUM];
 16 |     for(int i=0;i<HNUM;i++)
 17 |     {
 18 |         hide[i].cell=new double[MAXTIME];
 19 |         hide[i].out=new double[MAXTIME];
 20 | 
 21 |         hide[i].fog_in=new double[MAXTIME];
 22 |         hide[i].sig_in=new double[MAXTIME];
 23 |         hide[i].tan_in=new double[MAXTIME];
 24 |         hide[i].out_in=new double[MAXTIME];
 25 | 
 26 |         hide[i].fog_out=new double[MAXTIME];
 27 |         hide[i].sig_out=new double[MAXTIME];
 28 |         hide[i].tan_out=new double[MAXTIME];
 29 |         hide[i].out_out=new double[MAXTIME];
 30 | 
 31 |         hide[i].fog_diff=new double[MAXTIME];
 32 |         hide[i].sig_diff=new double[MAXTIME];
 33 |         hide[i].tan_diff=new double[MAXTIME];
 34 |         hide[i].out_diff=new double[MAXTIME];
 35 | 
 36 |         hide[i].fog_wi=new double[INUM];
 37 |         hide[i].sig_wi=new double[INUM];
 38 |         hide[i].tan_wi=new double[INUM];
 39 |         hide[i].out_wi=new double[INUM];
 40 | 
 41 |         hide[i].fog_transwi=new double[INUM];
 42 |         hide[i].sig_transwi=new double[INUM];
 43 |         hide[i].tan_transwi=new double[INUM];
 44 |         hide[i].out_transwi=new double[INUM];
 45 | 
 46 |         hide[i].fog_wh=new double[HNUM];
 47 |         hide[i].sig_wh=new double[HNUM];
 48 |         hide[i].tan_wh=new double[HNUM];
 49 |         hide[i].out_wh=new double[HNUM];
 50 | 
 51 |         hide[i].fog_transwh=new double[HNUM];
 52 |         hide[i].sig_transwh=new double[HNUM];
 53 |         hide[i].tan_transwh=new double[HNUM];
 54 |         hide[i].out_transwh=new double[HNUM];
 55 |     }
 56 | }
 57 | 
 58 | NormalLSTM::~NormalLSTM()
 59 | {
 60 |     for(int i=0;i<HNUM;i++)
 61 |     {
 62 |         delete []hide[i].cell;
 63 |         delete []hide[i].out;
 64 | 
 65 |         delete []hide[i].fog_in;
 66 |         delete []hide[i].sig_in;
 67 |         delete []hide[i].tan_in;
 68 |         delete []hide[i].out_in;
 69 | 
 70 |         delete []hide[i].fog_out;
 71 |         delete []hide[i].sig_out;
 72 |         delete []hide[i].tan_out;
 73 |         delete []hide[i].out_out;
 74 | 
 75 |         delete []hide[i].fog_diff;
 76 |         delete []hide[i].sig_diff;
 77 |         delete []hide[i].tan_diff;
 78 |         delete []hide[i].out_diff;
 79 | 
 80 |         delete []hide[i].fog_wi;
 81 |         delete []hide[i].sig_wi;
 82 |         delete []hide[i].tan_wi;
 83 |         delete []hide[i].out_wi;
 84 | 
 85 |         delete []hide[i].fog_transwi;
 86 |         delete []hide[i].sig_transwi;
 87 |         delete []hide[i].tan_transwi;
 88 |         delete []hide[i].out_transwi;
 89 | 
 90 |         delete []hide[i].fog_wh;
 91 |         delete []hide[i].sig_wh;
 92 |         delete []hide[i].tan_wh;
 93 |         delete []hide[i].out_wh;
 94 | 
 95 |         delete []hide[i].fog_transwh;
 96 |         delete []hide[i].sig_transwh;
 97 |         delete []hide[i].tan_transwh;
 98 |         delete []hide[i].out_transwh;
 99 |     }
100 |     delete []hide;
101 | }
102 | 
103 | void NormalLSTM::Init()
104 | {
105 |     srand(unsigned(time(NULL)));
106 |     for(int i=0;i<HNUM;i++)
107 |     {
108 |         hide[i].cell[0]=0;
109 |         hide[i].out[0]=0;
110 |         hide[i].fog_bia=(rand()%2? 1:-1)*(1.0+rand()%10)/10.0;
111 |         hide[i].sig_bia=(rand()%2? 1:-1)*(1.0+rand()%10)/10.0;
112 |         hide[i].tan_bia=(rand()%2? 1:-1)*(1.0+rand()%10)/10.0;
113 |         hide[i].out_bia=(rand()%2? 1:-1)*(1.0+rand()%10)/10.0;
114 |         for(int j=0;j<INUM;j++)
115 |         {
116 |             hide[i].fog_wi[j]=(rand()%2? 1:-1)*(1.0+rand()%10)/50.0;
117 |             hide[i].sig_wi[j]=(rand()%2? 1:-1)*(1.0+rand()%10)/50.0;
118 |             hide[i].tan_wi[j]=(rand()%2? 1:-1)*(1.0+rand()%10)/50.0;
119 |             hide[i].out_wi[j]=(rand()%2? 1:-1)*(1.0+rand()%10)/50.0;
120 |         }
121 |         for(int j=0;j<HNUM;j++)
122 |         {
123 |             hide[i].fog_wh[j]=(rand()%2? 1:-1)*(1.0+rand()%10)/50.0;
124 |             hide[i].sig_wh[j]=(rand()%2? 1:-1)*(1.0+rand()%10)/50.0;
125 |             hide[i].tan_wh[j]=(rand()%2? 1:-1)*(1.0+rand()%10)/50.0;
126 |             hide[i].out_wh[j]=(rand()%2? 1:-1)*(1.0+rand()%10)/50.0;
127 |         }
128 |     }
129 | }
130 | 
131 | void NormalLSTM::Datain(const std::string& filename)
132 | {
133 |     std::ifstream fin(filename);
134 |     if(fin.fail())
135 |     {
136 |         std::cout<<">> [Error] Cannot open file."<<std::endl;
137 |         exit(-1);
138 |     }
139 |     for(int i=0;i<HNUM;i++)
140 |     {
141 |         fin>>hide[i].cell[0];
142 |         fin>>hide[i].out[0];
143 |         fin>>hide[i].fog_bia;
144 |         fin>>hide[i].sig_bia;
145 |         fin>>hide[i].tan_bia;
146 |         fin>>hide[i].out_bia;
147 |         for(int j=0;j<INUM;j++)
148 |         {
149 |             fin>>hide[i].fog_wi[j];
150 |             fin>>hide[i].sig_wi[j];
151 |             fin>>hide[i].tan_wi[j];
152 |             fin>>hide[i].out_wi[j];
153 |         }
154 |         for(int j=0;j<HNUM;j++)
155 |         {
156 |             fin>>hide[i].fog_wh[j];
157 |             fin>>hide[i].sig_wh[j];
158 |             fin>>hide[i].tan_wh[j];
159 |             fin>>hide[i].out_wh[j];
160 |         }
161 |     }
162 |     fin.close();
163 |     return;
164 | }
165 | 
166 | void NormalLSTM::Dataout(const std::string& filename)
167 | {
168 |     std::ofstream fout(filename);
169 |     if(fout.fail())
170 |     {
171 |         std::cout<<">> [Error] Cannot open file."<<std::endl;
172 |         exit(-1);
173 |     }
174 |     for(int i=0;i<HNUM;i++)
175 |     {
176 |         fout<<hide[i].cell[0]<<std::endl;
177 |         fout<<hide[i].out[0]<<std::endl;
178 |         fout<<hide[i].fog_bia<<std::endl;
179 |         fout<<hide[i].sig_bia<<std::endl;
180 |         fout<<hide[i].tan_bia<<std::endl;
181 |         fout<<hide[i].out_bia<<std::endl;
182 |         for(int j=0;j<INUM;j++)
183 |         {
184 |             fout<<hide[i].fog_wi[j]<<std::endl;
185 |             fout<<hide[i].sig_wi[j]<<std::endl;
186 |             fout<<hide[i].tan_wi[j]<<std::endl;
187 |             fout<<hide[i].out_wi[j]<<std::endl;
188 |         }
189 |         for(int j=0;j<HNUM;j++)
190 |         {
191 |             fout<<hide[i].fog_wh[j]<<std::endl;
192 |             fout<<hide[i].sig_wh[j]<<std::endl;
193 |             fout<<hide[i].tan_wh[j]<<std::endl;
194 |             fout<<hide[i].out_wh[j]<<std::endl;
195 |         }
196 |     }
197 |     fout.close();
198 |     return;
199 | }
200 | 
201 | DeepLSTM::DeepLSTM(int InputlayerNum,int HiddenlayerNum,int Depth,int Maxtime)
202 | {
203 |     MAXTIME=Maxtime;
204 |     INUM=InputlayerNum;
205 |     HNUM=HiddenlayerNum;
206 |     DEPTH=Depth-1;
207 |     ConstructorAssist();
208 | }
209 | 
210 | DeepLSTM::~DeepLSTM()
211 | {
212 |     DestructorAssist();
213 | }
214 | 
215 | 
216 | void DeepLSTM::ConstructorAssist()
217 | {
218 |     hlink=new lstm_neuron[HNUM];
219 |     hide=new lstm_neuron*[HNUM];
220 |     for(int i=0;i<HNUM;i++)
221 |         hide[i]=new lstm_neuron[DEPTH];
222 |     for(int i=0;i<HNUM;i++)
223 |     {
224 |         hlink[i].cell=new double[MAXTIME];
225 |         hlink[i].out=new double[MAXTIME];
226 | 
227 |         hlink[i].fog_in=new double[MAXTIME];
228 |         hlink[i].sig_in=new double[MAXTIME];
229 |         hlink[i].tan_in=new double[MAXTIME];
230 |         hlink[i].out_in=new double[MAXTIME];
231 | 
232 |         hlink[i].fog_out=new double[MAXTIME];
233 |         hlink[i].sig_out=new double[MAXTIME];
234 |         hlink[i].tan_out=new double[MAXTIME];
235 |         hlink[i].out_out=new double[MAXTIME];
236 | 
237 |         hlink[i].fog_diff=new double[MAXTIME];
238 |         hlink[i].sig_diff=new double[MAXTIME];
239 |         hlink[i].tan_diff=new double[MAXTIME];
240 |         hlink[i].out_diff=new double[MAXTIME];
241 | 
242 |         hlink[i].fog_wi=new double[INUM];
243 |         hlink[i].sig_wi=new double[INUM];
244 |         hlink[i].tan_wi=new double[INUM];
245 |         hlink[i].out_wi=new double[INUM];
246 | 
247 |         hlink[i].fog_transwi=new double[INUM];
248 |         hlink[i].sig_transwi=new double[INUM];
249 |         hlink[i].tan_transwi=new double[INUM];
250 |         hlink[i].out_transwi=new double[INUM];
251 | 
252 |         hlink[i].fog_wh=new double[HNUM];
253 |         hlink[i].sig_wh=new double[HNUM];
254 |         hlink[i].tan_wh=new double[HNUM];
255 |         hlink[i].out_wh=new double[HNUM];
256 | 
257 |         hlink[i].fog_transwh=new double[HNUM];
258 |         hlink[i].sig_transwh=new double[HNUM];
259 |         hlink[i].tan_transwh=new double[HNUM];
260 |         hlink[i].out_transwh=new double[HNUM];
261 |     }
262 |     for(int d=0;d<DEPTH;d++)
263 |         for(int i=0;i<HNUM;i++)
264 |         {
265 |             hide[i][d].cell=new double[MAXTIME];
266 |             hide[i][d].out=new double[MAXTIME];
267 | 
268 |             hide[i][d].fog_in=new double[MAXTIME];
269 |             hide[i][d].sig_in=new double[MAXTIME];
270 |             hide[i][d].tan_in=new double[MAXTIME];
271 |             hide[i][d].out_in=new double[MAXTIME];
272 | 
273 |             hide[i][d].fog_out=new double[MAXTIME];
274 |             hide[i][d].sig_out=new double[MAXTIME];
275 |             hide[i][d].tan_out=new double[MAXTIME];
276 |             hide[i][d].out_out=new double[MAXTIME];
277 | 
278 |             hide[i][d].fog_diff=new double[MAXTIME];
279 |             hide[i][d].sig_diff=new double[MAXTIME];
280 |             hide[i][d].tan_diff=new double[MAXTIME];
281 |             hide[i][d].out_diff=new double[MAXTIME];
282 | 
283 |             hide[i][d].fog_wi=new double[HNUM];//must be HNUM
284 |             hide[i][d].sig_wi=new double[HNUM];
285 |             hide[i][d].tan_wi=new double[HNUM];
286 |             hide[i][d].out_wi=new double[HNUM];
287 | 
288 |             hide[i][d].fog_transwi=new double[HNUM];
289 |             hide[i][d].sig_transwi=new double[HNUM];
290 |             hide[i][d].tan_transwi=new double[HNUM];
291 |             hide[i][d].out_transwi=new double[HNUM];
292 | 
293 |             hide[i][d].fog_wh=new double[HNUM];
294 |             hide[i][d].sig_wh=new double[HNUM];
295 |             hide[i][d].tan_wh=new double[HNUM];
296 |             hide[i][d].out_wh=new double[HNUM];
297 | 
298 |             hide[i][d].fog_transwh=new double[HNUM];
299 |             hide[i][d].sig_transwh=new double[HNUM];
300 |             hide[i][d].tan_transwh=new double[HNUM];
301 |             hide[i][d].out_transwh=new double[HNUM];
302 |         }
303 | }
304 | 
305 | void DeepLSTM::DestructorAssist()
306 | {
307 |     for(int d=0;d<DEPTH;d++)
308 |         for(int i=0;i<HNUM;i++)
309 |         {
310 |             delete []hide[i][d].cell;
311 |             delete []hide[i][d].out;
312 | 
313 |             delete []hide[i][d].fog_in;
314 |             delete []hide[i][d].sig_in;
315 |             delete []hide[i][d].tan_in;
316 |             delete []hide[i][d].out_in;
317 | 
318 |             delete []hide[i][d].fog_out;
319 |             delete []hide[i][d].sig_out;
320 |             delete []hide[i][d].tan_out;
321 |             delete []hide[i][d].out_out;
322 | 
323 |             delete []hide[i][d].fog_diff;
324 |             delete []hide[i][d].sig_diff;
325 |             delete []hide[i][d].tan_diff;
326 |             delete []hide[i][d].out_diff;
327 | 
328 |             delete []hide[i][d].fog_wi;
329 |             delete []hide[i][d].sig_wi;
330 |             delete []hide[i][d].tan_wi;
331 |             delete []hide[i][d].out_wi;
332 | 
333 |             delete []hide[i][d].fog_transwi;
334 |             delete []hide[i][d].sig_transwi;
335 |             delete []hide[i][d].tan_transwi;
336 |             delete []hide[i][d].out_transwi;
337 | 
338 |             delete []hide[i][d].fog_wh;
339 |             delete []hide[i][d].sig_wh;
340 |             delete []hide[i][d].tan_wh;
341 |             delete []hide[i][d].out_wh;
342 | 
343 |             delete []hide[i][d].fog_transwh;
344 |             delete []hide[i][d].sig_transwh;
345 |             delete []hide[i][d].tan_transwh;
346 |             delete []hide[i][d].out_transwh;
347 |         }
348 |     for(int i=0;i<HNUM;i++)
349 |     {
350 |         delete []hlink[i].cell;
351 |         delete []hlink[i].out;
352 | 
353 |         delete []hlink[i].fog_in;
354 |         delete []hlink[i].sig_in;
355 |         delete []hlink[i].tan_in;
356 |         delete []hlink[i].out_in;
357 | 
358 |         delete []hlink[i].fog_out;
359 |         delete []hlink[i].sig_out;
360 |         delete []hlink[i].tan_out;
361 |         delete []hlink[i].out_out;
362 | 
363 |         delete []hlink[i].fog_diff;
364 |         delete []hlink[i].sig_diff;
365 |         delete []hlink[i].tan_diff;
366 |         delete []hlink[i].out_diff;
367 | 
368 |         delete []hlink[i].fog_wi;
369 |         delete []hlink[i].sig_wi;
370 |         delete []hlink[i].tan_wi;
371 |         delete []hlink[i].out_wi;
372 | 
373 |         delete []hlink[i].fog_transwi;
374 |         delete []hlink[i].sig_transwi;
375 |         delete []hlink[i].tan_transwi;
376 |         delete []hlink[i].out_transwi;
377 | 
378 |         delete []hlink[i].fog_wh;
379 |         delete []hlink[i].sig_wh;
380 |         delete []hlink[i].tan_wh;
381 |         delete []hlink[i].out_wh;
382 | 
383 |         delete []hlink[i].fog_transwh;
384 |         delete []hlink[i].sig_transwh;
385 |         delete []hlink[i].tan_transwh;
386 |         delete []hlink[i].out_transwh;
387 |     }
388 |     for(int i=0;i<HNUM;i++)
389 |         delete []hide[i];
390 |     delete []hlink;
391 |     delete []hide;
392 | }
393 | 
394 | void DeepLSTM::Init()
395 | {
396 |     srand(unsigned(time(NULL)));
397 |     for(int i=0;i<HNUM;i++)
398 |     {
399 |         hlink[i].cell[0]=0;
400 |         hlink[i].out[0]=0;
401 |         hlink[i].fog_bia=(rand()%2? 1:-1)*(1.0+rand()%10)/10.0;
402 |         hlink[i].sig_bia=(rand()%2? 1:-1)*(1.0+rand()%10)/10.0;
403 |         hlink[i].tan_bia=(rand()%2? 1:-1)*(1.0+rand()%10)/10.0;
404 |         hlink[i].out_bia=(rand()%2? 1:-1)*(1.0+rand()%10)/10.0;
405 |         for(int j=0;j<INUM;j++)
406 |         {
407 |             hlink[i].fog_wi[j]=(rand()%2? 1:-1)*(1.0+rand()%10)/50.0;
408 |             hlink[i].sig_wi[j]=(rand()%2? 1:-1)*(1.0+rand()%10)/50.0;
409 |             hlink[i].tan_wi[j]=(rand()%2? 1:-1)*(1.0+rand()%10)/50.0;
410 |             hlink[i].out_wi[j]=(rand()%2? 1:-1)*(1.0+rand()%10)/50.0;
411 |         }
412 |         for(int j=0;j<HNUM;j++)
413 |         {
414 |             hlink[i].fog_wh[j]=(rand()%2? 1:-1)*(1.0+rand()%10)/50.0;
415 |             hlink[i].sig_wh[j]=(rand()%2? 1:-1)*(1.0+rand()%10)/50.0;
416 |             hlink[i].tan_wh[j]=(rand()%2? 1:-1)*(1.0+rand()%10)/50.0;
417 |             hlink[i].out_wh[j]=(rand()%2? 1:-1)*(1.0+rand()%10)/50.0;
418 |         }
419 |     }
420 |     for(int d=0;d<DEPTH;d++)
421 |         for(int i=0;i<HNUM;i++)
422 |         {
423 |             hide[i][d].cell[0]=0;
424 |             hide[i][d].out[0]=0;
425 |             hide[i][d].fog_bia=(rand()%2? 1:-1)*(1.0+rand()%10)/10.0;
426 |             hide[i][d].sig_bia=(rand()%2? 1:-1)*(1.0+rand()%10)/10.0;
427 |             hide[i][d].tan_bia=(rand()%2? 1:-1)*(1.0+rand()%10)/10.0;
428 |             hide[i][d].out_bia=(rand()%2? 1:-1)*(1.0+rand()%10)/10.0;
429 |             for(int j=0;j<HNUM;j++)
430 |             {
431 |                 hide[i][d].fog_wi[j]=(rand()%2? 1:-1)*(1.0+rand()%10)/50.0;
432 |                 hide[i][d].sig_wi[j]=(rand()%2? 1:-1)*(1.0+rand()%10)/50.0;
433 |                 hide[i][d].tan_wi[j]=(rand()%2? 1:-1)*(1.0+rand()%10)/50.0;
434 |                 hide[i][d].out_wi[j]=(rand()%2? 1:-1)*(1.0+rand()%10)/50.0;
435 | 
436 |                 hide[i][d].fog_wh[j]=(rand()%2? 1:-1)*(1.0+rand()%10)/50.0;
437 |                 hide[i][d].sig_wh[j]=(rand()%2? 1:-1)*(1.0+rand()%10)/50.0;
438 |                 hide[i][d].tan_wh[j]=(rand()%2? 1:-1)*(1.0+rand()%10)/50.0;
439 |                 hide[i][d].out_wh[j]=(rand()%2? 1:-1)*(1.0+rand()%10)/50.0;
440 |             }
441 |         }
442 |     return;
443 | }
444 | 
445 | void DeepLSTM::Datain(const std::string& filename)
446 | {
447 |     std::ifstream fin(filename);
448 |     if(fin.fail())
449 |     {
450 |         std::cout<<">> [Error] Cannot open file."<<std::endl;
451 |         exit(-1);
452 |     }
453 |     for(int i=0;i<HNUM;i++)
454 |     {
455 |         fin>>hlink[i].cell[0];
456 |         fin>>hlink[i].out[0];
457 |         fin>>hlink[i].fog_bia;
458 |         fin>>hlink[i].sig_bia;
459 |         fin>>hlink[i].tan_bia;
460 |         fin>>hlink[i].out_bia;
461 |         for(int j=0;j<INUM;j++)
462 |         {
463 |             fin>>hlink[i].fog_wi[j];
464 |             fin>>hlink[i].sig_wi[j];
465 |             fin>>hlink[i].tan_wi[j];
466 |             fin>>hlink[i].out_wi[j];
467 |         }
468 |         for(int j=0;j<HNUM;j++)
469 |         {
470 |             fin>>hlink[i].fog_wh[j];
471 |             fin>>hlink[i].sig_wh[j];
472 |             fin>>hlink[i].tan_wh[j];
473 |             fin>>hlink[i].out_wh[j];
474 |         }
475 |     }
476 |     for(int d=0;d<DEPTH;d++)
477 |         for(int i=0;i<HNUM;i++)
478 |         {
479 |             fin>>hide[i][d].cell[0];
480 |             fin>>hide[i][d].out[0];
481 |             fin>>hide[i][d].fog_bia;
482 |             fin>>hide[i][d].sig_bia;
483 |             fin>>hide[i][d].tan_bia;
484 |             fin>>hide[i][d].out_bia;
485 |             for(int j=0;j<HNUM;j++)
486 |             {
487 |                 fin>>hide[i][d].fog_wi[j];
488 |                 fin>>hide[i][d].sig_wi[j];
489 |                 fin>>hide[i][d].tan_wi[j];
490 |                 fin>>hide[i][d].out_wi[j];
491 | 
492 |                 fin>>hide[i][d].fog_wh[j];
493 |                 fin>>hide[i][d].sig_wh[j];
494 |                 fin>>hide[i][d].tan_wh[j];
495 |                 fin>>hide[i][d].out_wh[j];
496 |             }
497 |         }
498 |     fin.close();
499 |     return;
500 | }
501 | 
502 | void DeepLSTM::Dataout(const std::string& filename)
503 | {
504 |     std::ofstream fout(filename);
505 |     if(fout.fail())
506 |     {
507 |         std::cout<<">> [Error] Cannot open file."<<std::endl;
508 |         exit(-1);
509 |     }
510 |     for(int i=0;i<HNUM;i++)
511 |     {
512 |         fout<<hlink[i].cell[0]<<std::endl;
513 |         fout<<hlink[i].out[0]<<std::endl;
514 |         fout<<hlink[i].fog_bia<<std::endl;
515 |         fout<<hlink[i].sig_bia<<std::endl;
516 |         fout<<hlink[i].tan_bia<<std::endl;
517 |         fout<<hlink[i].out_bia<<std::endl;
518 |         for(int j=0;j<INUM;j++)
519 |         {
520 |             fout<<hlink[i].fog_wi[j]<<std::endl;
521 |             fout<<hlink[i].sig_wi[j]<<std::endl;
522 |             fout<<hlink[i].tan_wi[j]<<std::endl;
523 |             fout<<hlink[i].out_wi[j]<<std::endl;
524 |         }
525 |         for(int j=0;j<HNUM;j++)
526 |         {
527 |             fout<<hlink[i].fog_wh[j]<<std::endl;
528 |             fout<<hlink[i].sig_wh[j]<<std::endl;
529 |             fout<<hlink[i].tan_wh[j]<<std::endl;
530 |             fout<<hlink[i].out_wh[j]<<std::endl;
531 |         }
532 |     }
533 |     for(int d=0;d<DEPTH;d++)
534 |         for(int i=0;i<HNUM;i++)
535 |         {
536 |             fout<<hide[i][d].cell[0]<<std::endl;
537 |             fout<<hide[i][d].out[0]<<std::endl;
538 |             fout<<hide[i][d].fog_bia<<std::endl;
539 |             fout<<hide[i][d].sig_bia<<std::endl;
540 |             fout<<hide[i][d].tan_bia<<std::endl;
541 |             fout<<hide[i][d].out_bia<<std::endl;
542 |             for(int j=0;j<HNUM;j++)
543 |             {
544 |                 fout<<hide[i][d].fog_wi[j]<<std::endl;
545 |                 fout<<hide[i][d].sig_wi[j]<<std::endl;
546 |                 fout<<hide[i][d].tan_wi[j]<<std::endl;
547 |                 fout<<hide[i][d].out_wi[j]<<std::endl;
548 | 
549 |                 fout<<hide[i][d].fog_wh[j]<<std::endl;
550 |                 fout<<hide[i][d].sig_wh[j]<<std::endl;
551 |                 fout<<hide[i][d].tan_wh[j]<<std::endl;
552 |                 fout<<hide[i][d].out_wh[j]<<std::endl;
553 |             }
554 |         }
555 |     fout.close();
556 |     return;
557 | }
558 | 


--------------------------------------------------------------------------------
/src/mainassist.h:
--------------------------------------------------------------------------------
   1 | /*mainassist.h header file by ValK*/
   2 | /*2019/5/9             version 1.1*/
   3 | #ifndef MAINASSIST_H
   4 | #define MAINASSIST_H
   5 | #include "NLPann.h"
   6 | #include <iostream>
   7 | #include <fstream>
   8 | #include <cstdlib>
   9 | #include <cstring>
  10 | 
  11 | struct ObjElement
  12 | {
  13 |     char ObjName[40];
  14 |     char FileName_1[40];
  15 |     char FileName_2[40];
  16 |     char FileName_3[40];
  17 |     char FileName_4[40];
  18 |     char FileName_5[40];
  19 |     char FileName_6[40];
  20 |     char FileName_7[40];
  21 |     char FileName_8[40];
  22 |     char Function[10];
  23 |     int INUM;
  24 |     int HNUM;
  25 |     int ONUM;
  26 |     int DEPTH;
  27 |     int MAXTIME;
  28 |     int NetworkType;
  29 |     int BatchSize;
  30 |     double LearningRate;
  31 | };
  32 | 
  33 | class UserObject
  34 | {
  35 |     private:
  36 |         ObjElement Obj;
  37 |     public:
  38 |         UserObject *p;
  39 |         UserObject(
  40 |         const char *objname="NULL",
  41 |         const char *filename1="NULL",
  42 |         const char *filename2="NULL",
  43 |         const char *filename3="NULL",
  44 |         const char *filename4="NULL",
  45 |         const char *filename5="NULL",
  46 |         const char *filename6="NULL",
  47 |         const char *filename7="NULL",
  48 |         const char *filename8="NULL",
  49 |         const char *function="NULL",
  50 |         int inum=0,
  51 |         int hnum=0,
  52 |         int onum=0,
  53 |         int depth=0,
  54 |         int maxtime=0,
  55 |         int networktype=0,
  56 |         int batchsize=0,
  57 |         double lr=0.1
  58 |         )
  59 |         {
  60 |             strcpy(Obj.ObjName,objname);
  61 |             strcpy(Obj.FileName_1,filename1);
  62 |             strcpy(Obj.FileName_2,filename2);
  63 |             strcpy(Obj.FileName_3,filename3);
  64 |             strcpy(Obj.FileName_4,filename4);
  65 |             strcpy(Obj.FileName_5,filename5);
  66 |             strcpy(Obj.FileName_6,filename6);
  67 |             strcpy(Obj.FileName_7,filename7);
  68 |             strcpy(Obj.FileName_8,filename8);
  69 |             strcpy(Obj.Function,function);
  70 |             Obj.INUM=inum;
  71 |             Obj.HNUM=hnum;
  72 |             Obj.ONUM=onum;
  73 |             Obj.DEPTH=depth;
  74 |             Obj.MAXTIME=maxtime;
  75 |             Obj.NetworkType=networktype;
  76 |             Obj.BatchSize=batchsize;
  77 |             Obj.LearningRate=lr;
  78 |             p=NULL;
  79 |         }
  80 |         void PrintObj()
  81 |         {
  82 |             std::cout<<"   ------------------------------------------------------"<<std::endl;
  83 |             std::cout<<"   |Name         |"<<Obj.ObjName<<std::endl;
  84 |             if(strcmp(Obj.FileName_1,"NULL"))
  85 |                 std::cout<<"   |File 1       |"<<Obj.FileName_1<<std::endl;
  86 |             if(strcmp(Obj.FileName_2,"NULL"))
  87 |                 std::cout<<"   |File 2       |"<<Obj.FileName_2<<std::endl;
  88 |             if(strcmp(Obj.FileName_3,"NULL"))
  89 |                 std::cout<<"   |File 3       |"<<Obj.FileName_3<<std::endl;
  90 |             if(strcmp(Obj.FileName_4,"NULL"))
  91 |                 std::cout<<"   |File 4       |"<<Obj.FileName_4<<std::endl;
  92 |             if(strcmp(Obj.FileName_5,"NULL"))
  93 |                 std::cout<<"   |File 5       |"<<Obj.FileName_5<<std::endl;
  94 |             if(strcmp(Obj.FileName_6,"NULL"))
  95 |                 std::cout<<"   |File 6       |"<<Obj.FileName_6<<std::endl;
  96 |             if(strcmp(Obj.FileName_7,"NULL"))
  97 |                 std::cout<<"   |File 7       |"<<Obj.FileName_7<<std::endl;
  98 |             if(strcmp(Obj.FileName_8,"NULL"))
  99 |                 std::cout<<"   |File 8       |"<<Obj.FileName_8<<std::endl;
 100 |             std::cout<<"   |Function     |"<<Obj.Function<<std::endl;
 101 |             std::cout<<"   |INUM         |"<<Obj.INUM<<std::endl;
 102 |             std::cout<<"   |HNUM         |"<<Obj.HNUM<<std::endl;
 103 |             std::cout<<"   |ONUM         |"<<Obj.ONUM<<std::endl;
 104 |             std::cout<<"   |DEPTH        |"<<Obj.DEPTH<<std::endl;
 105 |             std::cout<<"   |MAXTIME      |"<<Obj.MAXTIME<<std::endl;
 106 |             std::cout<<"   |LearningRate |"<<Obj.LearningRate<<std::endl;
 107 |             std::cout<<"   |Batch Size   |"<<Obj.BatchSize<<std::endl;
 108 |             std::cout<<"   |Network Type |";
 109 |             switch(Obj.NetworkType)
 110 |             {
 111 |                 case 1:
 112 |                     std::cout<<"BP(Normal neural network)"<<std::endl;
 113 |                     break;
 114 |                 case 2:
 115 |                     std::cout<<"BP(Deep neural network)"<<std::endl;
 116 |                     break;
 117 |                 case 3:
 118 |                     std::cout<<"RNN seq2seq(Normal neural network)"<<std::endl;
 119 |                     break;
 120 |                 case 4:
 121 |                     std::cout<<"RNN seq2seq(Deep neural network)"<<std::endl;
 122 |                     break;
 123 |                 case 5:
 124 |                     std::cout<<"LSTM seq2seq(Normal neural network)"<<std::endl;
 125 |                     break;
 126 |                 case 6:
 127 |                     std::cout<<"LSTM seq2seq(Deep neural network)"<<std::endl;
 128 |                     break;
 129 |                 case 7:
 130 |                     std::cout<<"GRU seq2seq(Normal neural network)"<<std::endl;
 131 |                     break;
 132 |                 case 8:
 133 |                     std::cout<<"GRU seq2seq(Deep neural network)"<<std::endl;
 134 |                     break;
 135 |                 case 9:
 136 |                     std::cout<<"RNN seq2vec(Normal neural network)"<<std::endl;
 137 |                     break;
 138 |                 case 10:
 139 |                     std::cout<<"RNN seq2vec(Deep neural network)"<<std::endl;
 140 |                     break;
 141 |                 case 11:
 142 |                     std::cout<<"LSTM seq2vec(Normal neural network)"<<std::endl;
 143 |                     break;
 144 |                 case 12:
 145 |                     std::cout<<"LSTM seq2vec(Deep neural network)"<<std::endl;
 146 |                     break;
 147 |                 case 13:
 148 |                     std::cout<<"GRU seq2vec(Normal neural network)"<<std::endl;
 149 |                     break;
 150 |                 case 14:
 151 |                     std::cout<<"GRU seq2vec(Deep neural network)"<<std::endl;
 152 |                     break;
 153 |                 case 15:
 154 |                     std::cout<<"BP char2vec(Normal neural network)"<<std::endl;
 155 |                     break;
 156 |                 default:
 157 |                     std::cout<<"Unknown Type"<<std::endl;
 158 |                     break;
 159 |             }
 160 |             std::cout<<"   ------------------------------------------------------"<<std::endl;
 161 |         }
 162 |         ObjElement* getObjPointer()
 163 |         {
 164 |             return &Obj;
 165 |         }
 166 |         bool CheckObjName(std::string &TempName)
 167 |         {
 168 |             if(TempName==Obj.ObjName)
 169 |                 return true;
 170 |             else
 171 |                 return false;
 172 |         }
 173 |         bool CheckObjName(const char *t)
 174 |         {
 175 |             if(!strcmp(t,Obj.ObjName))
 176 |                 return true;
 177 |             else
 178 |                 return false;
 179 |         }
 180 |         void ObjChange(ObjElement &temp)
 181 |         {
 182 |             Obj=temp;
 183 |             return;
 184 |         }
 185 | };
 186 | 
 187 | 
 188 | class ObjManager
 189 | {
 190 |     private:
 191 |         UserObject *Head;
 192 |         ObjElement Datatemp;
 193 |     public:
 194 |         ObjManager();
 195 |         ~ObjManager();
 196 |         void ObjDataIn();
 197 |         void ObjDataOut();
 198 |         void MakeData();
 199 |         bool ObjChoose();
 200 |         void RunModule();
 201 |         void PrintAllObj();
 202 |         void FindObj();
 203 |         void EditObj();
 204 |         void DeleteObj();
 205 |         void ChangeLearningRate();
 206 |         void ChangeBatchSize();
 207 |         void FindSpecialObj(const char*);
 208 | };
 209 | 
 210 | ObjManager::ObjManager()
 211 | {
 212 |     Head=new UserObject;
 213 |     Head->p=NULL;
 214 | }
 215 | 
 216 | ObjManager::~ObjManager()
 217 | {
 218 |     UserObject *Node=Head;
 219 |     UserObject *Temp;
 220 |     while(Node->p!=NULL)
 221 |     {
 222 |         Temp=Node;
 223 |         Node=Node->p;
 224 |         delete Temp;
 225 |     }
 226 |     delete Node;
 227 | }
 228 | 
 229 | void ObjManager::ObjDataIn()
 230 | {
 231 |     UserObject *Node=Head;
 232 |     if(!fopen("ObjData.dat","r"))
 233 |     {
 234 |         FILE* fd=fopen("ObjData.dat","w");
 235 |         fclose(fd);
 236 |         std::cout<<">> [init] Initializing completed."<<std::endl;
 237 |     }
 238 |     std::ifstream fin("ObjData.dat",std::ios::binary);
 239 |     if(fin.fail())
 240 |     {
 241 |         std::cout<<">> [Error] Cannot open important data \"ObjData.dat\" or this data maybe lost!"<<std::endl;
 242 |         exit(-1);
 243 |     }
 244 |     while(!fin.eof())
 245 |     {
 246 |         fin.read((char*)&Datatemp,sizeof(ObjElement));
 247 |         if(fin.eof())
 248 |             break;
 249 |         Node->p=new UserObject(
 250 |         Datatemp.ObjName,
 251 |         Datatemp.FileName_1,
 252 |         Datatemp.FileName_2,
 253 |         Datatemp.FileName_3,
 254 |         Datatemp.FileName_4,
 255 |         Datatemp.FileName_5,
 256 |         Datatemp.FileName_6,
 257 |         Datatemp.FileName_7,
 258 |         Datatemp.FileName_8,
 259 |         Datatemp.Function,
 260 |         Datatemp.INUM,
 261 |         Datatemp.HNUM,
 262 |         Datatemp.ONUM,
 263 |         Datatemp.DEPTH,
 264 |         Datatemp.MAXTIME,
 265 |         Datatemp.NetworkType,
 266 |         Datatemp.BatchSize,
 267 |         Datatemp.LearningRate
 268 |         );
 269 |         Node=Node->p;
 270 |         Node->p=NULL;
 271 |     }
 272 |     fin.close();
 273 |     return;
 274 | }
 275 | 
 276 | void ObjManager::ObjDataOut()
 277 | {
 278 |     UserObject *Node=Head;
 279 |     std::ofstream fout("ObjData.dat",std::ios::binary);
 280 |     if(fout.fail())
 281 |     {
 282 |         std::cout<<">> [Error] Cannot open important data \"Objdata.dat\" or this data maybe lost!"<<std::endl;
 283 |         exit(-1);
 284 |     }
 285 |     while(Node->p!=NULL)
 286 |     {
 287 |         Node=Node->p;
 288 |         fout.write((char*)Node->getObjPointer(),sizeof(ObjElement));
 289 |     }
 290 |     fout.close(); 
 291 |     return;
 292 | }
 293 | 
 294 | void ObjManager::MakeData()
 295 | {
 296 |     UserObject *Node=Head;
 297 |     std::cout<<">> Name of your project: ";
 298 |     std::cin>>Datatemp.ObjName;
 299 |     while(Node->p!=NULL)
 300 |     {
 301 |         Node=Node->p;
 302 |         if(Node->CheckObjName(Datatemp.ObjName))
 303 |         {
 304 |             std::cout<<">> [Error] You have already created this project!"<<std::endl<<std::endl;
 305 |             std::cout<<"   |The project is:"<<std::endl;
 306 |             Node->PrintObj();
 307 |             return;
 308 |         }
 309 |     }
 310 |     if(!ObjChoose())
 311 |     {
 312 |         std::cout<<">> [Quiting]"<<std::endl;
 313 |         return;
 314 |     }
 315 |     Node->p=new UserObject(
 316 |     Datatemp.ObjName,
 317 |     Datatemp.FileName_1,
 318 |     Datatemp.FileName_2,
 319 |     Datatemp.FileName_3,
 320 |     Datatemp.FileName_4,
 321 |     Datatemp.FileName_5,
 322 |     Datatemp.FileName_6,
 323 |     Datatemp.FileName_7,
 324 |     Datatemp.FileName_8,
 325 |     Datatemp.Function,
 326 |     Datatemp.INUM,
 327 |     Datatemp.HNUM,
 328 |     Datatemp.ONUM,
 329 |     Datatemp.DEPTH,
 330 |     Datatemp.MAXTIME,
 331 |     Datatemp.NetworkType,
 332 |     Datatemp.BatchSize,
 333 |     Datatemp.LearningRate
 334 |     );
 335 |     Node=Node->p;
 336 |     Node->p=NULL;
 337 |     std::cout<<">> New project is established successfully."<<std::endl;
 338 | }
 339 | 
 340 | bool ObjManager::ObjChoose()
 341 | {
 342 |     std::string Command;
 343 |     std::cout<<">>"<<std::endl;
 344 |     std::cout<<"   |1. |BP project(Normal)            |"<<std::endl;
 345 |     std::cout<<"   |2. |BP project(Deep)              |"<<std::endl;
 346 |     std::cout<<"   |3. |seq2seq project(RNN:Normal)   |"<<std::endl;
 347 |     std::cout<<"   |4. |seq2seq project(RNN:Deep)     |"<<std::endl;
 348 |     std::cout<<"   |5. |seq2seq project(LSTM:Normal)  |"<<std::endl;
 349 |     std::cout<<"   |6. |seq2seq project(LSTM:Deep)    |"<<std::endl;
 350 |     std::cout<<"   |7. |seq2seq project(GRU:Normal)   |"<<std::endl;
 351 |     std::cout<<"   |8. |seq2seq project(GRU:Deep)     |"<<std::endl;
 352 |     std::cout<<"   |9. |seq2vec project(RNN:Normal)   |"<<std::endl;
 353 |     std::cout<<"   |10.|seq2vec project(RNN:Deep)     |"<<std::endl;
 354 |     std::cout<<"   |11.|seq2vec project(LSTM:Normal)  |"<<std::endl;
 355 |     std::cout<<"   |12.|seq2vec project(LSTM:Deep)    |"<<std::endl;
 356 |     std::cout<<"   |13.|seq2vec project(GRU:Normal)   |"<<std::endl;
 357 |     std::cout<<"   |14.|seq2vec project(GRU:Deep)     |"<<std::endl;
 358 |     std::cout<<"   |15.|char2vec project(BP:Normal)   |"<<std::endl;
 359 |     std::cout<<"   |16.|I don't want to choose.(quit) |"<<std::endl;
 360 |     while(1)
 361 |     {
 362 |         std::cout<<">> [Choice] Input your choice: ";
 363 |         std::cin>>Command;
 364 |         if(Command=="1")
 365 |         {
 366 |             std::cout<<">>"<<std::endl;
 367 |             std::cout<<"   |BP project(Normal) needs:"<<std::endl;
 368 |             std::cout<<"   |INUM: Number of input layer neurons"<<std::endl;
 369 |             std::cout<<"   |HNUM: Number of hidden layer neurons"<<std::endl;
 370 |             std::cout<<"   |ONUM: Number of output layer neurons"<<std::endl;
 371 |             std::cout<<"   |File: Name of data file"<<std::endl;
 372 |             std::cout<<"   |File: Name of input set file"<<std::endl;
 373 |             std::cout<<"   |File: Name of training set file"<<std::endl;
 374 |             std::cout<<"   |Function: one of activate functions(for all layers)"<<std::endl;
 375 |             std::cout<<"   |Batch size: Size of input/training set batch"<<std::endl;
 376 |             std::cout<<"   |Learning rate:This decides how fast your model runs"<<std::endl;
 377 |             std::cout<<">> Name of the output file: ";
 378 |             std::cin>>Datatemp.FileName_1;
 379 |             strcpy(Datatemp.FileName_2,"NULL");
 380 |             strcpy(Datatemp.FileName_3,"NULL");
 381 |             strcpy(Datatemp.FileName_4,"NULL");
 382 |             strcpy(Datatemp.FileName_5,"NULL");
 383 |             strcpy(Datatemp.FileName_6,"NULL");
 384 |             std::cout<<">> Name of input set file: ";
 385 |             std::cin>>Datatemp.FileName_7;
 386 |             std::cout<<">> Name of training set file: ";
 387 |             std::cin>>Datatemp.FileName_8;
 388 |             std::cout<<">> Name of the activate function: ";
 389 |             std::cin>>Datatemp.Function;
 390 |             std::cout<<">> Number of input layer neurons: ";
 391 |             std::cin>>Datatemp.INUM;
 392 |             std::cout<<">> Number of hidden layer neurons: ";
 393 |             std::cin>>Datatemp.HNUM;
 394 |             std::cout<<">> Number of output layer neurons: ";
 395 |             std::cin>>Datatemp.ONUM;
 396 |             Datatemp.DEPTH=0;
 397 |             Datatemp.MAXTIME=0;
 398 |             Datatemp.NetworkType=1;
 399 |             std::cout<<">> Learning rate(must more than 0 but less than 1): ";
 400 |             std::cin>>Datatemp.LearningRate;
 401 |             std::cout<<">> Size of input/training set batch: ";
 402 |             std::cin>>Datatemp.BatchSize;
 403 |             break;
 404 |         }
 405 |         else if(Command=="2")
 406 |         {
 407 |             std::cout<<">>"<<std::endl;
 408 |             std::cout<<"   |BP project(Deep) needs:"<<std::endl;
 409 |             std::cout<<"   |INUM: Number of input layer neurons"<<std::endl;
 410 |             std::cout<<"   |HNUM: Number of hidden layer neurons"<<std::endl;
 411 |             std::cout<<"   |ONUM: Number of output layer neurons"<<std::endl;
 412 |             std::cout<<"   |DEPTH: Number of layers"<<std::endl;
 413 |             std::cout<<"   |File: Name of data file"<<std::endl;
 414 |             std::cout<<"   |File: Name of input set file"<<std::endl;
 415 |             std::cout<<"   |File: Name of training set file"<<std::endl;
 416 |             std::cout<<"   |Function: one of activate functions(for all layers)"<<std::endl;
 417 |             std::cout<<"   |Batch size: Size of input/training set batch"<<std::endl;
 418 |             std::cout<<"   |Learning rate:This decides how fast your model runs"<<std::endl;
 419 |             std::cout<<">> Name of the output file: ";
 420 |             std::cin>>Datatemp.FileName_1;
 421 |             strcpy(Datatemp.FileName_2,"NULL");
 422 |             strcpy(Datatemp.FileName_3,"NULL");
 423 |             strcpy(Datatemp.FileName_4,"NULL");
 424 |             strcpy(Datatemp.FileName_5,"NULL");
 425 |             strcpy(Datatemp.FileName_6,"NULL");
 426 |             std::cout<<">> Name of input set file: ";
 427 |             std::cin>>Datatemp.FileName_7;
 428 |             std::cout<<">> Name of training set file: ";
 429 |             std::cin>>Datatemp.FileName_8;
 430 |             std::cout<<">> Name of the activate function: ";
 431 |             std::cin>>Datatemp.Function;
 432 |             std::cout<<">> Number of input layer neurons: ";
 433 |             std::cin>>Datatemp.INUM;
 434 |             std::cout<<">> Number of hidden layer neurons: ";
 435 |             std::cin>>Datatemp.HNUM;
 436 |             std::cout<<">> Number of output layer neurons: ";
 437 |             std::cin>>Datatemp.ONUM;
 438 |             std::cout<<">> Number of layers: ";
 439 |             std::cin>>Datatemp.DEPTH;
 440 |             Datatemp.MAXTIME=0;
 441 |             Datatemp.NetworkType=2;
 442 |             std::cout<<">> Learning rate(must more than 0 but less than 1): ";
 443 |             std::cin>>Datatemp.LearningRate;
 444 |             std::cout<<">> Size of input/training set batch: ";
 445 |             std::cin>>Datatemp.BatchSize;
 446 |             break;
 447 |         }
 448 |         else if(Command=="3")
 449 |         {
 450 |             std::cout<<">> [RNN]"<<std::endl;
 451 |             std::cout<<"   |seq2seq project(RNN/LSTM/GRU:Normal) needs:"<<std::endl;
 452 |             std::cout<<"   |INUM: Number of input layer neurons"<<std::endl;
 453 |             std::cout<<"   |HNUM: Number of hidden layer neurons"<<std::endl;
 454 |             std::cout<<"   |ONUM: Number of output layer neurons"<<std::endl;
 455 |             std::cout<<"   |MAXTIME: Max length of sequence"<<std::endl;
 456 |             std::cout<<"   |File: Name of data file"<<std::endl;
 457 |             std::cout<<"   |File: Name of input set file"<<std::endl;
 458 |             std::cout<<"   |File: Name of training set file"<<std::endl;
 459 |             std::cout<<"   |Function: one of activate functions(for output layer)"<<std::endl;
 460 |             std::cout<<"   |Batch size: Size of input/training set batch"<<std::endl;
 461 |             std::cout<<"   |Learning rate:This decides how fast your model runs"<<std::endl;
 462 |             std::cout<<">> Name of the encoder module file: ";
 463 |             std::cin>>Datatemp.FileName_1;
 464 |             std::cout<<">> Name of the decoder module file: ";
 465 |             std::cin>>Datatemp.FileName_2;
 466 |             std::cout<<">> Name of the output layer file: ";
 467 |             std::cin>>Datatemp.FileName_3;
 468 |             strcpy(Datatemp.FileName_4,"NULL");
 469 |             strcpy(Datatemp.FileName_5,"NULL");
 470 |             strcpy(Datatemp.FileName_6,"NULL");
 471 |             std::cout<<">> Name of input set file: ";
 472 |             std::cin>>Datatemp.FileName_7;
 473 |             std::cout<<">> Name of training set file: ";
 474 |             std::cin>>Datatemp.FileName_8;
 475 |             std::cout<<">> Name of the activate function(seq2seq uses softmax as output and your function may not work): ";
 476 |             std::cin>>Datatemp.Function;
 477 |             std::cout<<">> Number of input layer neurons: ";
 478 |             std::cin>>Datatemp.INUM;
 479 |             std::cout<<">> Number of hidden layer neurons: ";
 480 |             std::cin>>Datatemp.HNUM;
 481 |             std::cout<<">> Number of output layer neurons: ";
 482 |             std::cin>>Datatemp.ONUM;
 483 |             Datatemp.INUM=27;
 484 |             Datatemp.ONUM=27;
 485 |             Datatemp.DEPTH=0;
 486 |             std::cout<<">> Max length of sequence: ";
 487 |             std::cin>>Datatemp.MAXTIME;
 488 |             Datatemp.NetworkType=3;
 489 |             std::cout<<">> Learning rate(must more than 0 but less than 1): ";
 490 |             std::cin>>Datatemp.LearningRate;
 491 |             std::cout<<">> Size of input/training set batch: ";
 492 |             std::cin>>Datatemp.BatchSize;
 493 |             break;
 494 |         }
 495 |         else if(Command=="4")
 496 |         {
 497 |             std::cout<<">> [RNN]"<<std::endl;
 498 |             std::cout<<"   |seq2seq project(RNN/LSTM/GRU:Deep) needs:"<<std::endl;
 499 |             std::cout<<"   |INUM: Number of input layer neurons"<<std::endl;
 500 |             std::cout<<"   |HNUM: Number of hidden layer neurons"<<std::endl;
 501 |             std::cout<<"   |ONUM: Number of output layer neurons"<<std::endl;
 502 |             std::cout<<"   |DEPTH: Number of layers"<<std::endl;
 503 |             std::cout<<"   |MAXTIME: Max length of sequence"<<std::endl;
 504 |             std::cout<<"   |File: Name of data file"<<std::endl;
 505 |             std::cout<<"   |File: Name of input set file"<<std::endl;
 506 |             std::cout<<"   |File: Name of training set file"<<std::endl;
 507 |             std::cout<<"   |Function: one of activate functions(for output layer)"<<std::endl;
 508 |             std::cout<<"   |Batch size: Size of input/training set batch"<<std::endl;
 509 |             std::cout<<"   |Learning rate:This decides how fast your model runs"<<std::endl;
 510 |             std::cout<<">> Name of the encoder module file: ";
 511 |             std::cin>>Datatemp.FileName_1;
 512 |             std::cout<<">> Name of the decoder module file: ";
 513 |             std::cin>>Datatemp.FileName_2;
 514 |             std::cout<<">> Name of the output layer file: ";
 515 |             std::cin>>Datatemp.FileName_3;
 516 |             strcpy(Datatemp.FileName_4,"NULL");
 517 |             strcpy(Datatemp.FileName_5,"NULL");
 518 |             strcpy(Datatemp.FileName_6,"NULL");
 519 |             std::cout<<">> Name of input set file: ";
 520 |             std::cin>>Datatemp.FileName_7;
 521 |             std::cout<<">> Name of training set file: ";
 522 |             std::cin>>Datatemp.FileName_8;
 523 |             std::cout<<">> Name of the activate function(seq2seq uses softmax as output and your function may not work): ";
 524 |             std::cin>>Datatemp.Function;
 525 |             std::cout<<">> Number of input layer neurons: ";
 526 |             std::cin>>Datatemp.INUM;
 527 |             std::cout<<">> Number of hidden layer neurons: ";
 528 |             std::cin>>Datatemp.HNUM;
 529 |             std::cout<<">> Number of output layer neurons: ";
 530 |             std::cin>>Datatemp.ONUM;
 531 |             Datatemp.INUM=27;
 532 |             Datatemp.ONUM=27;
 533 |             std::cout<<">> Number of layers: ";
 534 |             std::cin>>Datatemp.DEPTH;
 535 |             std::cout<<">> Max length of sequence: ";
 536 |             std::cin>>Datatemp.MAXTIME;
 537 |             Datatemp.NetworkType=4;
 538 |             std::cout<<">> Learning rate(must more than 0 but less than 1): ";
 539 |             std::cin>>Datatemp.LearningRate;
 540 |             std::cout<<">> Size of input/training set batch: ";
 541 |             std::cin>>Datatemp.BatchSize;
 542 |             break;
 543 |         }
 544 |         else if(Command=="5")
 545 |         {
 546 |             std::cout<<">> [LSTM]"<<std::endl;
 547 |             std::cout<<"   |seq2seq project(RNN/LSTM/GRU:Normal) needs:"<<std::endl;
 548 |             std::cout<<"   |INUM: Number of input layer neurons"<<std::endl;
 549 |             std::cout<<"   |HNUM: Number of hidden layer neurons"<<std::endl;
 550 |             std::cout<<"   |ONUM: Number of output layer neurons"<<std::endl;
 551 |             std::cout<<"   |MAXTIME: Max length of sequence"<<std::endl;
 552 |             std::cout<<"   |File: Name of data file"<<std::endl;
 553 |             std::cout<<"   |File: Name of input set file"<<std::endl;
 554 |             std::cout<<"   |File: Name of training set file"<<std::endl;
 555 |             std::cout<<"   |Function: one of activate functions(for output layer)"<<std::endl;
 556 |             std::cout<<"   |Batch size: Size of input/training set batch"<<std::endl;
 557 |             std::cout<<"   |Learning rate:This decides how fast your model runs"<<std::endl;
 558 |             std::cout<<">> Name of the encoder module file: ";
 559 |             std::cin>>Datatemp.FileName_1;
 560 |             std::cout<<">> Name of the decoder module file: ";
 561 |             std::cin>>Datatemp.FileName_2;
 562 |             std::cout<<">> Name of the output layer file: ";
 563 |             std::cin>>Datatemp.FileName_3;
 564 |             strcpy(Datatemp.FileName_4,"NULL");
 565 |             strcpy(Datatemp.FileName_5,"NULL");
 566 |             strcpy(Datatemp.FileName_6,"NULL");
 567 |             std::cout<<">> Name of input set file: ";
 568 |             std::cin>>Datatemp.FileName_7;
 569 |             std::cout<<">> Name of training set file: ";
 570 |             std::cin>>Datatemp.FileName_8;
 571 |             std::cout<<">> Name of the activate function(seq2seq uses softmax as output and your function may not work): ";
 572 |             std::cin>>Datatemp.Function;
 573 |             std::cout<<">> Number of input layer neurons: ";
 574 |             std::cin>>Datatemp.INUM;
 575 |             std::cout<<">> Number of hidden layer neurons: ";
 576 |             std::cin>>Datatemp.HNUM;
 577 |             std::cout<<">> Number of output layer neurons: ";
 578 |             std::cin>>Datatemp.ONUM;
 579 |             Datatemp.INUM=27;
 580 |             Datatemp.ONUM=27;
 581 |             Datatemp.DEPTH=0;
 582 |             std::cout<<">> Max length of sequence: ";
 583 |             std::cin>>Datatemp.MAXTIME;
 584 |             Datatemp.NetworkType=5;
 585 |             std::cout<<">> Learning rate(must more than 0 but less than 1): ";
 586 |             std::cin>>Datatemp.LearningRate;
 587 |             std::cout<<">> Size of input/training set batch: ";
 588 |             std::cin>>Datatemp.BatchSize;
 589 |             break;
 590 |         }
 591 |         else if(Command=="6")
 592 |         {
 593 |             std::cout<<">> [LSTM]"<<std::endl;
 594 |             std::cout<<"   |seq2seq project(RNN/LSTM/GRU:Deep) needs:"<<std::endl;
 595 |             std::cout<<"   |INUM: Number of input layer neurons"<<std::endl;
 596 |             std::cout<<"   |HNUM: Number of hidden layer neurons"<<std::endl;
 597 |             std::cout<<"   |ONUM: Number of output layer neurons"<<std::endl;
 598 |             std::cout<<"   |DEPTH: Number of layers"<<std::endl;
 599 |             std::cout<<"   |MAXTIME: Max length of sequence"<<std::endl;
 600 |             std::cout<<"   |File: Name of data file"<<std::endl;
 601 |             std::cout<<"   |File: Name of input set file"<<std::endl;
 602 |             std::cout<<"   |File: Name of training set file"<<std::endl;
 603 |             std::cout<<"   |Function: one of activate functions(for output layer)"<<std::endl;
 604 |             std::cout<<"   |Batch size: Size of input/training set batch"<<std::endl;
 605 |             std::cout<<"   |Learning rate:This decides how fast your model runs"<<std::endl;
 606 |             std::cout<<">> Name of the encoder module file: ";
 607 |             std::cin>>Datatemp.FileName_1;
 608 |             std::cout<<">> Name of the decoder module file: ";
 609 |             std::cin>>Datatemp.FileName_2;
 610 |             std::cout<<">> Name of the output layer file: ";
 611 |             std::cin>>Datatemp.FileName_3;
 612 |             strcpy(Datatemp.FileName_4,"NULL");
 613 |             strcpy(Datatemp.FileName_5,"NULL");
 614 |             strcpy(Datatemp.FileName_6,"NULL");
 615 |             std::cout<<">> Name of input set file: ";
 616 |             std::cin>>Datatemp.FileName_7;
 617 |             std::cout<<">> Name of training set file: ";
 618 |             std::cin>>Datatemp.FileName_8;
 619 |             std::cout<<">> Name of the activate function(seq2seq uses softmax as output and your function may not work): ";
 620 |             std::cin>>Datatemp.Function;
 621 |             std::cout<<">> Number of input layer neurons: ";
 622 |             std::cin>>Datatemp.INUM;
 623 |             std::cout<<">> Number of hidden layer neurons: ";
 624 |             std::cin>>Datatemp.HNUM;
 625 |             std::cout<<">> Number of output layer neurons: ";
 626 |             std::cin>>Datatemp.ONUM;
 627 |             std::cout<<">> Number of layers: ";
 628 |             std::cin>>Datatemp.DEPTH;
 629 |             std::cout<<">> Max length of sequence: ";
 630 |             std::cin>>Datatemp.MAXTIME;
 631 |             Datatemp.INUM=27;
 632 |             Datatemp.ONUM=27;
 633 |             Datatemp.NetworkType=6;
 634 |             std::cout<<">> Learning rate(must more than 0 but less than 1): ";
 635 |             std::cin>>Datatemp.LearningRate;
 636 |             std::cout<<">> Size of input/training set batch: ";
 637 |             std::cin>>Datatemp.BatchSize;
 638 |             break;
 639 |         }
 640 |         else if(Command=="7")
 641 |         {
 642 |             std::cout<<">> [GRU]"<<std::endl;
 643 |             std::cout<<"   |seq2seq project(RNN/LSTM/GRU:Normal) needs:"<<std::endl;
 644 |             std::cout<<"   |INUM: Number of input layer neurons"<<std::endl;
 645 |             std::cout<<"   |HNUM: Number of hidden layer neurons"<<std::endl;
 646 |             std::cout<<"   |ONUM: Number of output layer neurons"<<std::endl;
 647 |             std::cout<<"   |MAXTIME: Max length of sequence"<<std::endl;
 648 |             std::cout<<"   |File: Name of data file"<<std::endl;
 649 |             std::cout<<"   |File: Name of input set file"<<std::endl;
 650 |             std::cout<<"   |File: Name of training set file"<<std::endl;
 651 |             std::cout<<"   |Function: one of activate functions(for output layer)"<<std::endl;
 652 |             std::cout<<"   |Batch size: Size of input/training set batch"<<std::endl;
 653 |             std::cout<<"   |Learning rate:This decides how fast your model runs"<<std::endl;
 654 |             std::cout<<">> Name of the encoder module file: ";
 655 |             std::cin>>Datatemp.FileName_1;
 656 |             std::cout<<">> Name of the decoder module file: ";
 657 |             std::cin>>Datatemp.FileName_2;
 658 |             std::cout<<">> Name of the output layer file: ";
 659 |             std::cin>>Datatemp.FileName_3;
 660 |             strcpy(Datatemp.FileName_4,"NULL");
 661 |             strcpy(Datatemp.FileName_5,"NULL");
 662 |             strcpy(Datatemp.FileName_6,"NULL");
 663 |             std::cout<<">> Name of input set file: ";
 664 |             std::cin>>Datatemp.FileName_7;
 665 |             std::cout<<">> Name of training set file: ";
 666 |             std::cin>>Datatemp.FileName_8;
 667 |             std::cout<<">> Name of the activate function(seq2seq uses softmax as output and your function may not work): ";
 668 |             std::cin>>Datatemp.Function;
 669 |             std::cout<<">> Number of input layer neurons: ";
 670 |             std::cin>>Datatemp.INUM;
 671 |             std::cout<<">> Number of hidden layer neurons: ";
 672 |             std::cin>>Datatemp.HNUM;
 673 |             std::cout<<">> Number of output layer neurons: ";
 674 |             std::cin>>Datatemp.ONUM;
 675 |             Datatemp.INUM=27;
 676 |             Datatemp.ONUM=27;
 677 |             Datatemp.DEPTH=0;
 678 |             std::cout<<">> Max length of sequence: ";
 679 |             std::cin>>Datatemp.MAXTIME;
 680 |             Datatemp.NetworkType=7;
 681 |             std::cout<<">> Learning rate(must more than 0 but less than 1): ";
 682 |             std::cin>>Datatemp.LearningRate;
 683 |             std::cout<<">> Size of input/training set batch: ";
 684 |             std::cin>>Datatemp.BatchSize;
 685 |             break;
 686 |         }
 687 |         else if(Command=="8")
 688 |         {
 689 |             std::cout<<">> [GRU]"<<std::endl;
 690 |             std::cout<<"   |seq2seq project(RNN/LSTM/GRU:Deep) needs:"<<std::endl;
 691 |             std::cout<<"   |INUM: Number of input layer neurons"<<std::endl;
 692 |             std::cout<<"   |HNUM: Number of hidden layer neurons"<<std::endl;
 693 |             std::cout<<"   |ONUM: Number of output layer neurons"<<std::endl;
 694 |             std::cout<<"   |DEPTH: Number of layers"<<std::endl;
 695 |             std::cout<<"   |MAXTIME: Max length of sequence"<<std::endl;
 696 |             std::cout<<"   |File: Name of data file"<<std::endl;
 697 |             std::cout<<"   |File: Name of input set file"<<std::endl;
 698 |             std::cout<<"   |File: Name of training set file"<<std::endl;
 699 |             std::cout<<"   |Function: one of activate functions(for output layer)"<<std::endl;
 700 |             std::cout<<"   |Batch size: Size of input/training set batch"<<std::endl;
 701 |             std::cout<<"   |Learning rate:This decides how fast your model runs"<<std::endl;
 702 |             std::cout<<">> Name of the encoder module file: ";
 703 |             std::cin>>Datatemp.FileName_1;
 704 |             std::cout<<">> Name of the decoder module file: ";
 705 |             std::cin>>Datatemp.FileName_2;
 706 |             std::cout<<">> Name of the output layer file: ";
 707 |             std::cin>>Datatemp.FileName_3;
 708 |             strcpy(Datatemp.FileName_4,"NULL");
 709 |             strcpy(Datatemp.FileName_5,"NULL");
 710 |             strcpy(Datatemp.FileName_6,"NULL");
 711 |             std::cout<<">> Name of input set file: ";
 712 |             std::cin>>Datatemp.FileName_7;
 713 |             std::cout<<">> Name of training set file: ";
 714 |             std::cin>>Datatemp.FileName_8;
 715 |             std::cout<<">> Name of the activate function(seq2seq uses softmax as output and your function may not work): ";
 716 |             std::cin>>Datatemp.Function;
 717 |             std::cout<<">> Number of input layer neurons: ";
 718 |             std::cin>>Datatemp.INUM;
 719 |             std::cout<<">> Number of hidden layer neurons: ";
 720 |             std::cin>>Datatemp.HNUM;
 721 |             std::cout<<">> Number of output layer neurons: ";
 722 |             std::cin>>Datatemp.ONUM;
 723 |             Datatemp.INUM=27;
 724 |             Datatemp.ONUM=27;
 725 |             std::cout<<">> Number of layers: ";
 726 |             std::cin>>Datatemp.DEPTH;
 727 |             std::cout<<">> Max length of sequence: ";
 728 |             std::cin>>Datatemp.MAXTIME;
 729 |             Datatemp.NetworkType=8;
 730 |             std::cout<<">> Learning rate(must more than 0 but less than 1): ";
 731 |             std::cin>>Datatemp.LearningRate;
 732 |             std::cout<<">> Size of input/training set batch: ";
 733 |             std::cin>>Datatemp.BatchSize;
 734 |             break;
 735 |         }
 736 |         else if(Command=="9")
 737 |         {
 738 |             std::cout<<">> [RNN]"<<std::endl;
 739 |             std::cout<<"   |seq2vec project(RNN/LSTM/GRU:Normal) needs:"<<std::endl;
 740 |             std::cout<<"   |INUM: Number of input layer neurons"<<std::endl;
 741 |             std::cout<<"   |HNUM: Number of hidden layer neurons"<<std::endl;
 742 |             std::cout<<"   |ONUM: Number of output layer neurons"<<std::endl;
 743 |             std::cout<<"   |MAXTIME: Max length of sequence"<<std::endl;
 744 |             std::cout<<"   |File: Name of data file"<<std::endl;
 745 |             std::cout<<"   |File: Name of input set file"<<std::endl;
 746 |             std::cout<<"   |File: Name of training set file"<<std::endl;
 747 |             std::cout<<"   |Function: one of activate functions(for output layer)"<<std::endl;
 748 |             std::cout<<"   |Batch size: Size of input/training set batch"<<std::endl;
 749 |             std::cout<<"   |Learning rate:This decides how fast your model runs"<<std::endl;
 750 |             std::cout<<">> Name of the encoder module file: ";
 751 |             std::cin>>Datatemp.FileName_1;
 752 |             std::cout<<">> Name of the output layer file: ";
 753 |             std::cin>>Datatemp.FileName_2;
 754 |             strcpy(Datatemp.FileName_3,"NULL");
 755 |             strcpy(Datatemp.FileName_4,"NULL");
 756 |             strcpy(Datatemp.FileName_5,"NULL");
 757 |             strcpy(Datatemp.FileName_6,"NULL");
 758 |             std::cout<<">> Name of input set file: ";
 759 |             std::cin>>Datatemp.FileName_7;
 760 |             std::cout<<">> Name of training set file: ";
 761 |             std::cin>>Datatemp.FileName_8;
 762 |             std::cout<<">> Name of the activate function(seq2vec uses softmax as output and your function may not work): ";
 763 |             std::cin>>Datatemp.Function;
 764 |             std::cout<<">> Number of input layer neurons: ";
 765 |             std::cin>>Datatemp.INUM;
 766 |             std::cout<<">> Number of hidden layer neurons: ";
 767 |             std::cin>>Datatemp.HNUM;
 768 |             std::cout<<">> Number of output layer neurons: ";
 769 |             std::cin>>Datatemp.ONUM;
 770 |             Datatemp.INUM=27;
 771 |             Datatemp.ONUM=27;
 772 |             Datatemp.DEPTH=0;
 773 |             std::cout<<">> Max length of sequence: ";
 774 |             std::cin>>Datatemp.MAXTIME;
 775 |             Datatemp.NetworkType=9;
 776 |             std::cout<<">> Learning rate(must more than 0 but less than 1): ";
 777 |             std::cin>>Datatemp.LearningRate;
 778 |             std::cout<<">> Size of input/training set batch: ";
 779 |             std::cin>>Datatemp.BatchSize;
 780 |             break;
 781 |         }
 782 |         else if(Command=="10")
 783 |         {
 784 |             std::cout<<">> [RNN]"<<std::endl;
 785 |             std::cout<<"   |seq2vec project(RNN/LSTM/GRU:Deep) needs:"<<std::endl;
 786 |             std::cout<<"   |INUM: Number of input layer neurons"<<std::endl;
 787 |             std::cout<<"   |HNUM: Number of hidden layer neurons"<<std::endl;
 788 |             std::cout<<"   |ONUM: Number of output layer neurons"<<std::endl;
 789 |             std::cout<<"   |DEPTH: Number of layers"<<std::endl;
 790 |             std::cout<<"   |MAXTIME: Max length of sequence"<<std::endl;
 791 |             std::cout<<"   |File: Name of data file"<<std::endl;
 792 |             std::cout<<"   |File: Name of input set file"<<std::endl;
 793 |             std::cout<<"   |File: Name of training set file"<<std::endl;
 794 |             std::cout<<"   |Function: one of activate functions(for output layer)"<<std::endl;
 795 |             std::cout<<"   |Batch size: Size of input/training set batch"<<std::endl;
 796 |             std::cout<<"   |Learning rate:This decides how fast your model runs"<<std::endl;
 797 |             std::cout<<">> Name of the encoder module file: ";
 798 |             std::cin>>Datatemp.FileName_1;
 799 |             std::cout<<">> Name of the output layer file: ";
 800 |             std::cin>>Datatemp.FileName_2;
 801 |             strcpy(Datatemp.FileName_3,"NULL");
 802 |             strcpy(Datatemp.FileName_4,"NULL");
 803 |             strcpy(Datatemp.FileName_5,"NULL");
 804 |             strcpy(Datatemp.FileName_6,"NULL");
 805 |             std::cout<<">> Name of input set file: ";
 806 |             std::cin>>Datatemp.FileName_7;
 807 |             std::cout<<">> Name of training set file: ";
 808 |             std::cin>>Datatemp.FileName_8;
 809 |             std::cout<<">> Name of the activate function(seq2vec uses softmax as output and your function may not work): ";
 810 |             std::cin>>Datatemp.Function;
 811 |             std::cout<<">> Number of input layer neurons: ";
 812 |             std::cin>>Datatemp.INUM;
 813 |             std::cout<<">> Number of hidden layer neurons: ";
 814 |             std::cin>>Datatemp.HNUM;
 815 |             std::cout<<">> Number of output layer neurons: ";
 816 |             std::cin>>Datatemp.ONUM;
 817 |             Datatemp.INUM=27;
 818 |             Datatemp.ONUM=27;
 819 |             std::cout<<">> Number of layers: ";
 820 |             std::cin>>Datatemp.DEPTH;
 821 |             std::cout<<">> Max length of sequence: ";
 822 |             std::cin>>Datatemp.MAXTIME;
 823 |             Datatemp.NetworkType=10;
 824 |             std::cout<<">> Learning rate(must more than 0 but less than 1): ";
 825 |             std::cin>>Datatemp.LearningRate;
 826 |             std::cout<<">> Size of input/training set batch: ";
 827 |             std::cin>>Datatemp.BatchSize;
 828 |             break;
 829 |         }
 830 |         else if(Command=="11")
 831 |         {
 832 |             std::cout<<">> [LSTM]"<<std::endl;
 833 |             std::cout<<"   |seq2vec project(RNN/LSTM/GRU:Normal) needs:"<<std::endl;
 834 |             std::cout<<"   |INUM: Number of input layer neurons"<<std::endl;
 835 |             std::cout<<"   |HNUM: Number of hidden layer neurons"<<std::endl;
 836 |             std::cout<<"   |ONUM: Number of output layer neurons"<<std::endl;
 837 |             std::cout<<"   |MAXTIME: Max length of sequence"<<std::endl;
 838 |             std::cout<<"   |File: Name of data file"<<std::endl;
 839 |             std::cout<<"   |File: Name of input set file"<<std::endl;
 840 |             std::cout<<"   |File: Name of training set file"<<std::endl;
 841 |             std::cout<<"   |Function: one of activate functions(for output layer)"<<std::endl;
 842 |             std::cout<<"   |Batch size: Size of input/training set batch"<<std::endl;
 843 |             std::cout<<"   |Learning rate:This decides how fast your model runs"<<std::endl;
 844 |             std::cout<<">> Name of the encoder module file: ";
 845 |             std::cin>>Datatemp.FileName_1;
 846 |             std::cout<<">> Name of the output layer file: ";
 847 |             std::cin>>Datatemp.FileName_2;
 848 |             strcpy(Datatemp.FileName_3,"NULL");
 849 |             strcpy(Datatemp.FileName_4,"NULL");
 850 |             strcpy(Datatemp.FileName_5,"NULL");
 851 |             strcpy(Datatemp.FileName_6,"NULL");
 852 |             std::cout<<">> Name of input set file: ";
 853 |             std::cin>>Datatemp.FileName_7;
 854 |             std::cout<<">> Name of training set file: ";
 855 |             std::cin>>Datatemp.FileName_8;
 856 |             std::cout<<">> Name of the activate function(seq2vec uses softmax as output and your function may not work): ";
 857 |             std::cin>>Datatemp.Function;
 858 |             std::cout<<">> Number of input layer neurons: ";
 859 |             std::cin>>Datatemp.INUM;
 860 |             std::cout<<">> Number of hidden layer neurons: ";
 861 |             std::cin>>Datatemp.HNUM;
 862 |             std::cout<<">> Number of output layer neurons: ";
 863 |             std::cin>>Datatemp.ONUM;
 864 |             Datatemp.INUM=27;
 865 |             Datatemp.ONUM=27;
 866 |             Datatemp.DEPTH=0;
 867 |             std::cout<<">> Max length of sequence: ";
 868 |             std::cin>>Datatemp.MAXTIME;
 869 |             Datatemp.NetworkType=11;
 870 |             std::cout<<">> Learning rate(must more than 0 but less than 1): ";
 871 |             std::cin>>Datatemp.LearningRate;
 872 |             std::cout<<">> Size of input/training set batch: ";
 873 |             std::cin>>Datatemp.BatchSize;
 874 |             break;
 875 |         }
 876 |         else if(Command=="12")
 877 |         {
 878 |             std::cout<<">> [LSTM]"<<std::endl;
 879 |             std::cout<<"   |seq2vec project(RNN/LSTM/GRU:Deep) needs:"<<std::endl;
 880 |             std::cout<<"   |INUM: Number of input layer neurons"<<std::endl;
 881 |             std::cout<<"   |HNUM: Number of hidden layer neurons"<<std::endl;
 882 |             std::cout<<"   |ONUM: Number of output layer neurons"<<std::endl;
 883 |             std::cout<<"   |DEPTH: Number of layers"<<std::endl;
 884 |             std::cout<<"   |MAXTIME: Max length of sequence"<<std::endl;
 885 |             std::cout<<"   |File: Name of data file"<<std::endl;
 886 |             std::cout<<"   |File: Name of input set file"<<std::endl;
 887 |             std::cout<<"   |File: Name of training set file"<<std::endl;
 888 |             std::cout<<"   |Function: one of activate functions(for output layer)"<<std::endl;
 889 |             std::cout<<"   |Batch size: Size of input/training set batch"<<std::endl;
 890 |             std::cout<<"   |Learning rate:This decides how fast your model runs"<<std::endl;
 891 |             std::cout<<">> Name of the encoder module file: ";
 892 |             std::cin>>Datatemp.FileName_1;
 893 |             std::cout<<">> Name of the output layer file: ";
 894 |             std::cin>>Datatemp.FileName_2;
 895 |             strcpy(Datatemp.FileName_3,"NULL");
 896 |             strcpy(Datatemp.FileName_4,"NULL");
 897 |             strcpy(Datatemp.FileName_5,"NULL");
 898 |             strcpy(Datatemp.FileName_6,"NULL");
 899 |             std::cout<<">> Name of input set file: ";
 900 |             std::cin>>Datatemp.FileName_7;
 901 |             std::cout<<">> Name of training set file: ";
 902 |             std::cin>>Datatemp.FileName_8;
 903 |             std::cout<<">> Name of the activate function(seq2vec uses softmax as output and your function may not work): ";
 904 |             std::cin>>Datatemp.Function;
 905 |             std::cout<<">> Number of input layer neurons: ";
 906 |             std::cin>>Datatemp.INUM;
 907 |             std::cout<<">> Number of hidden layer neurons: ";
 908 |             std::cin>>Datatemp.HNUM;
 909 |             std::cout<<">> Number of output layer neurons: ";
 910 |             std::cin>>Datatemp.ONUM;
 911 |             Datatemp.INUM=27;
 912 |             Datatemp.ONUM=27;
 913 |             std::cout<<">> Number of layers: ";
 914 |             std::cin>>Datatemp.DEPTH;
 915 |             std::cout<<">> Max length of sequence: ";
 916 |             std::cin>>Datatemp.MAXTIME;
 917 |             Datatemp.NetworkType=12;
 918 |             std::cout<<">> Learning rate(must more than 0 but less than 1): ";
 919 |             std::cin>>Datatemp.LearningRate;
 920 |             std::cout<<">> Size of input/training set batch: ";
 921 |             std::cin>>Datatemp.BatchSize;
 922 |             break;
 923 |         }
 924 |         else if(Command=="13")
 925 |         {
 926 |             std::cout<<">> [GRU]"<<std::endl;
 927 |             std::cout<<"   |seq2vec project(RNN/LSTM/GRU:Normal) needs:"<<std::endl;
 928 |             std::cout<<"   |INUM: Number of input layer neurons"<<std::endl;
 929 |             std::cout<<"   |HNUM: Number of hidden layer neurons"<<std::endl;
 930 |             std::cout<<"   |ONUM: Number of output layer neurons"<<std::endl;
 931 |             std::cout<<"   |MAXTIME: Max length of sequence"<<std::endl;
 932 |             std::cout<<"   |File: Name of data file"<<std::endl;
 933 |             std::cout<<"   |File: Name of input set file"<<std::endl;
 934 |             std::cout<<"   |File: Name of training set file"<<std::endl;
 935 |             std::cout<<"   |Function: one of activate functions(for output layer)"<<std::endl;
 936 |             std::cout<<"   |Batch size: Size of input/training set batch"<<std::endl;
 937 |             std::cout<<"   |Learning rate:This decides how fast your model runs"<<std::endl;
 938 |             std::cout<<">> Name of the encoder module file: ";
 939 |             std::cin>>Datatemp.FileName_1;
 940 |             std::cout<<">> Name of the output layer file: ";
 941 |             std::cin>>Datatemp.FileName_2;
 942 |             strcpy(Datatemp.FileName_3,"NULL");
 943 |             strcpy(Datatemp.FileName_4,"NULL");
 944 |             strcpy(Datatemp.FileName_5,"NULL");
 945 |             strcpy(Datatemp.FileName_6,"NULL");
 946 |             std::cout<<">> Name of input set file: ";
 947 |             std::cin>>Datatemp.FileName_7;
 948 |             std::cout<<">> Name of training set file: ";
 949 |             std::cin>>Datatemp.FileName_8;
 950 |             std::cout<<">> Name of the activate function(seq2vec uses softmax as output and your function may not work): ";
 951 |             std::cin>>Datatemp.Function;
 952 |             std::cout<<">> Number of input layer neurons: ";
 953 |             std::cin>>Datatemp.INUM;
 954 |             std::cout<<">> Number of hidden layer neurons: ";
 955 |             std::cin>>Datatemp.HNUM;
 956 |             std::cout<<">> Number of output layer neurons: ";
 957 |             std::cin>>Datatemp.ONUM;
 958 |             Datatemp.INUM=27;
 959 |             Datatemp.ONUM=27;
 960 |             Datatemp.DEPTH=0;
 961 |             std::cout<<">> Max length of sequence: ";
 962 |             std::cin>>Datatemp.MAXTIME;
 963 |             Datatemp.NetworkType=13;
 964 |             std::cout<<">> Learning rate(must more than 0 but less than 1): ";
 965 |             std::cin>>Datatemp.LearningRate;
 966 |             std::cout<<">> Size of input/training set batch: ";
 967 |             std::cin>>Datatemp.BatchSize;
 968 |             break;
 969 |         }
 970 |         else if(Command=="14")
 971 |         {
 972 |             std::cout<<">> [GRU]"<<std::endl;
 973 |             std::cout<<"   |seq2vec project(RNN/LSTM/GRU:Deep) needs:"<<std::endl;
 974 |             std::cout<<"   |INUM: Number of input layer neurons"<<std::endl;
 975 |             std::cout<<"   |HNUM: Number of hidden layer neurons"<<std::endl;
 976 |             std::cout<<"   |ONUM: Number of output layer neurons"<<std::endl;
 977 |             std::cout<<"   |DEPTH: Number of layers"<<std::endl;
 978 |             std::cout<<"   |MAXTIME: Max length of sequence"<<std::endl;
 979 |             std::cout<<"   |File: Name of data file"<<std::endl;
 980 |             std::cout<<"   |File: Name of input set file"<<std::endl;
 981 |             std::cout<<"   |File: Name of training set file"<<std::endl;
 982 |             std::cout<<"   |Function: one of activate functions(for output layer)"<<std::endl;
 983 |             std::cout<<"   |Batch size: Size of input/training set batch"<<std::endl;
 984 |             std::cout<<"   |Learning rate:This decides how fast your model runs"<<std::endl;
 985 |             std::cout<<">> Name of the encoder module file: ";
 986 |             std::cin>>Datatemp.FileName_1;
 987 |             std::cout<<">> Name of the output layer file: ";
 988 |             std::cin>>Datatemp.FileName_2;
 989 |             strcpy(Datatemp.FileName_3,"NULL");
 990 |             strcpy(Datatemp.FileName_4,"NULL");
 991 |             strcpy(Datatemp.FileName_5,"NULL");
 992 |             strcpy(Datatemp.FileName_6,"NULL");
 993 |             std::cout<<">> Name of input set file: ";
 994 |             std::cin>>Datatemp.FileName_7;
 995 |             std::cout<<">> Name of training set file: ";
 996 |             std::cin>>Datatemp.FileName_8;
 997 |             std::cout<<">> Name of the activate function(seq2vec uses softmax as output and your function may not work): ";
 998 |             std::cin>>Datatemp.Function;
 999 |             std::cout<<">> Number of input layer neurons: ";
1000 |             std::cin>>Datatemp.INUM;
1001 |             std::cout<<">> Number of hidden layer neurons: ";
1002 |             std::cin>>Datatemp.HNUM;
1003 |             std::cout<<">> Number of output layer neurons: ";
1004 |             std::cin>>Datatemp.ONUM;
1005 |             Datatemp.INUM=27;
1006 |             Datatemp.ONUM=27;
1007 |             std::cout<<">> Number of layers: ";
1008 |             std::cin>>Datatemp.DEPTH;
1009 |             std::cout<<">> Max length of sequence: ";
1010 |             std::cin>>Datatemp.MAXTIME;
1011 |             Datatemp.NetworkType=14;
1012 |             std::cout<<">> Learning rate(must more than 0 but less than 1): ";
1013 |             std::cin>>Datatemp.LearningRate;
1014 |             std::cout<<">> Size of input/training set batch: ";
1015 |             std::cin>>Datatemp.BatchSize;
1016 |             break;
1017 |         }
1018 |         else if(Command=="15")
1019 |         {
1020 |             std::cout<<">>"<<std::endl;
1021 |             std::cout<<"   |char2vec project(BP:Normal) needs:"<<std::endl;
1022 |             std::cout<<"   |INUM: Number of input layer neurons is set to 95"<<std::endl;
1023 |             std::cout<<"   |HNUM: Number of hidden layer neurons"<<std::endl;
1024 |             std::cout<<"   |ONUM: Number of output layer neurons is set to 95"<<std::endl;
1025 |             std::cout<<"   |File: Name of data file"<<std::endl;
1026 |             std::cout<<"   |File: Name of training set file"<<std::endl;
1027 |             std::cout<<"   |Function: one of activate functions is set as softmax"<<std::endl;
1028 |             std::cout<<"   |Learning rate:0.1"<<std::endl;
1029 |             std::cout<<">> Name of the output data file: ";
1030 |             std::cin>>Datatemp.FileName_1;
1031 |             strcpy(Datatemp.FileName_2,"NULL");
1032 |             strcpy(Datatemp.FileName_3,"NULL");
1033 |             strcpy(Datatemp.FileName_4,"NULL");
1034 |             strcpy(Datatemp.FileName_5,"NULL");
1035 |             strcpy(Datatemp.FileName_6,"NULL");
1036 |             strcpy(Datatemp.FileName_7,"NULL");
1037 |             std::cout<<">> Name of training set file: ";
1038 |             std::cin>>Datatemp.FileName_8;
1039 |             strcpy(Datatemp.Function,"softmax");
1040 |             Datatemp.INUM=95;
1041 |             std::cout<<">> Number of hidden layer neurons: ";
1042 |             std::cin>>Datatemp.HNUM;
1043 |             Datatemp.ONUM=95;
1044 |             Datatemp.DEPTH=0;
1045 |             Datatemp.MAXTIME=0;
1046 |             Datatemp.NetworkType=15;
1047 |             Datatemp.LearningRate=0.1;
1048 |             Datatemp.BatchSize=0;
1049 |             break;
1050 |         }
1051 |         else if(Command=="16")
1052 |         {
1053 |             return false;
1054 |         }
1055 |         else
1056 |             std::cout<<">> [Error] Undefined choice."<<std::endl;
1057 |     }
1058 |     return true;
1059 | }
1060 | 
1061 | void ObjManager::RunModule()
1062 | {
1063 |     bool FoundObj=false;
1064 |     UserObject *Node=Head;
1065 |     std::string temp_obj_name;
1066 |     std::cout<<">> Name of the project: ";
1067 |     std::cin>>temp_obj_name;
1068 |     while(Node->p!=NULL)
1069 |     {
1070 |         Node=Node->p;
1071 |         if(Node->CheckObjName(temp_obj_name))
1072 |         {
1073 |             Node->PrintObj();
1074 |             FoundObj=true;
1075 |             break;
1076 |         }
1077 |     }
1078 |     if(FoundObj)
1079 |     {
1080 |         if(Node->getObjPointer()->NetworkType==1)
1081 |         {
1082 |             std::cout<<">> [Running] BP(Normal neural network)"<<std::endl;
1083 |             if(!fopen(Node->getObjPointer()->FileName_7,"r")||!fopen(Node->getObjPointer()->FileName_8,"r"))
1084 |             {
1085 |                 std::cout<<">> [Error] Cannot open file."<<std::endl;
1086 |                 std::cout<<">> [Lack] "<<Node->getObjPointer()->FileName_7<<" and "<<Node->getObjPointer()->FileName_8<<std::endl;
1087 |                 return;
1088 |             }
1089 |             NormalBP MainBP(Node->getObjPointer()->INUM,Node->getObjPointer()->HNUM,Node->getObjPointer()->ONUM);
1090 |             MainBP.SetFunction(Node->getObjPointer()->Function);
1091 |             MainBP.SetLearningrate(Node->getObjPointer()->LearningRate);
1092 |             MainBP.TotalWork(Node->getObjPointer()->FileName_1,Node->getObjPointer()->FileName_7,Node->getObjPointer()->FileName_8);
1093 |         }
1094 |         else if(Node->getObjPointer()->NetworkType==2)
1095 |         {
1096 |             std::cout<<">> [Running] BP(Deep neural network)"<<std::endl;
1097 |             if(!fopen(Node->getObjPointer()->FileName_7,"r")||!fopen(Node->getObjPointer()->FileName_8,"r"))
1098 |             {
1099 |                 std::cout<<">> [Error] Cannot open file."<<std::endl;
1100 |                 std::cout<<">> [Lack] "<<Node->getObjPointer()->FileName_7<<" and "<<Node->getObjPointer()->FileName_8<<std::endl;
1101 |                 return;
1102 |             }
1103 |             DeepBP MainBP(Node->getObjPointer()->INUM,Node->getObjPointer()->HNUM,Node->getObjPointer()->ONUM,Node->getObjPointer()->DEPTH);
1104 |             MainBP.SetFunction(Node->getObjPointer()->Function);
1105 |             MainBP.SetLearningrate(Node->getObjPointer()->LearningRate);
1106 |             MainBP.TotalWork(Node->getObjPointer()->FileName_1,Node->getObjPointer()->FileName_7,Node->getObjPointer()->FileName_8);
1107 |         }
1108 |         else if(Node->getObjPointer()->NetworkType==3)
1109 |         {
1110 |             std::cout<<">> [Running] RNN seq2seq(Normal neural network)"<<std::endl;
1111 |             if(!fopen(Node->getObjPointer()->FileName_7,"r")||!fopen(Node->getObjPointer()->FileName_8,"r"))
1112 |             {
1113 |                 std::cout<<">> [Error] Cannot open file."<<std::endl;
1114 |                 std::cout<<">> [Lack] "<<Node->getObjPointer()->FileName_7<<" and "<<Node->getObjPointer()->FileName_8<<std::endl;
1115 |                 return;
1116 |             }
1117 |             NormalSeq2Seq MainSeq("rnn",Node->getObjPointer()->INUM,Node->getObjPointer()->HNUM,Node->getObjPointer()->ONUM,Node->getObjPointer()->MAXTIME);
1118 |             MainSeq.SetFunction(Node->getObjPointer()->Function);
1119 |             MainSeq.SetLearningRate(Node->getObjPointer()->LearningRate);
1120 |             MainSeq.SetBatchSize(Node->getObjPointer()->BatchSize);
1121 |             MainSeq.TotalWork("rnn",Node->getObjPointer()->FileName_1,
1122 |                                     Node->getObjPointer()->FileName_2,
1123 |                                     Node->getObjPointer()->FileName_3,
1124 |                                     Node->getObjPointer()->FileName_7,
1125 |                                     Node->getObjPointer()->FileName_8);
1126 |         }
1127 |         else if(Node->getObjPointer()->NetworkType==4)
1128 |         {
1129 |             std::cout<<">> [Running] RNN seq2seq(Deep neural network)"<<std::endl;
1130 |             if(Node->getObjPointer()->DEPTH>2)
1131 |             {
1132 |                 char Confirm;
1133 |                 std::cout<<">> [Warning] Seq2Seq with two more layers may not work well,do you still want to run this model?(y/n)"<<std::endl;
1134 |                 std::cin>>Confirm;
1135 |                 if(Confirm!='y')
1136 |                 {
1137 |                     std::cout<<">> [Error] Running process cancelled"<<std::endl;
1138 |                     return;
1139 |                 }
1140 |             }
1141 |             if(!fopen(Node->getObjPointer()->FileName_7,"r")||!fopen(Node->getObjPointer()->FileName_8,"r"))
1142 |             {
1143 |                 std::cout<<">> [Error] Cannot open file."<<std::endl;
1144 |                 std::cout<<">> [Lack] "<<Node->getObjPointer()->FileName_7<<" and "<<Node->getObjPointer()->FileName_8<<std::endl;
1145 |                 return;
1146 |             }
1147 |             DeepSeq2Seq MainSeq("rnn",Node->getObjPointer()->INUM,Node->getObjPointer()->HNUM,Node->getObjPointer()->ONUM,Node->getObjPointer()->DEPTH,Node->getObjPointer()->MAXTIME);
1148 |             MainSeq.SetFunction(Node->getObjPointer()->Function);
1149 |             MainSeq.SetLearningRate(Node->getObjPointer()->LearningRate);
1150 |             MainSeq.SetBatchSize(Node->getObjPointer()->BatchSize);
1151 |             MainSeq.TotalWork("rnn",Node->getObjPointer()->FileName_1,
1152 |                                     Node->getObjPointer()->FileName_2,
1153 |                                     Node->getObjPointer()->FileName_3,
1154 |                                     Node->getObjPointer()->FileName_7,
1155 |                                     Node->getObjPointer()->FileName_8);
1156 |         }
1157 |         else if(Node->getObjPointer()->NetworkType==5)
1158 |         {
1159 |             std::cout<<">> [Running] LSTM seq2seq(Normal neural network)"<<std::endl;
1160 |             if(!fopen(Node->getObjPointer()->FileName_7,"r")||!fopen(Node->getObjPointer()->FileName_8,"r"))
1161 |             {
1162 |                 std::cout<<">> [Error] Cannot open file."<<std::endl;
1163 |                 std::cout<<">> [Lack] "<<Node->getObjPointer()->FileName_7<<" and "<<Node->getObjPointer()->FileName_8<<std::endl;
1164 |                 return;
1165 |             }
1166 |             NormalSeq2Seq MainSeq("lstm",Node->getObjPointer()->INUM,Node->getObjPointer()->HNUM,Node->getObjPointer()->ONUM,Node->getObjPointer()->MAXTIME);
1167 |             MainSeq.SetFunction(Node->getObjPointer()->Function);
1168 |             MainSeq.SetLearningRate(Node->getObjPointer()->LearningRate);
1169 |             MainSeq.SetBatchSize(Node->getObjPointer()->BatchSize);
1170 |             MainSeq.TotalWork("lstm",Node->getObjPointer()->FileName_1,
1171 |                                     Node->getObjPointer()->FileName_2,
1172 |                                     Node->getObjPointer()->FileName_3,
1173 |                                     Node->getObjPointer()->FileName_7,
1174 |                                     Node->getObjPointer()->FileName_8);
1175 |         }
1176 |         else if(Node->getObjPointer()->NetworkType==6)
1177 |         {
1178 |             std::cout<<">> [Running] LSTM seq2seq(Deep neural network)"<<std::endl;
1179 |             if(Node->getObjPointer()->DEPTH>2)
1180 |             {
1181 |                 char Confirm;
1182 |                 std::cout<<">> [Warning] Seq2Seq with two more layers may not work well,do you still want to run this model?(y/n)"<<std::endl;
1183 |                 std::cin>>Confirm;
1184 |                 if(Confirm!='y')
1185 |                 {
1186 |                     std::cout<<">> [Error] Running process cancelled"<<std::endl;
1187 |                     return;
1188 |                 }
1189 |             }
1190 |             if(!fopen(Node->getObjPointer()->FileName_7,"r")||!fopen(Node->getObjPointer()->FileName_8,"r"))
1191 |             {
1192 |                 std::cout<<">> [Error] Cannot open file."<<std::endl;
1193 |                 std::cout<<">> [Lack] "<<Node->getObjPointer()->FileName_7<<" and "<<Node->getObjPointer()->FileName_8<<std::endl;
1194 |                 return;
1195 |             }
1196 |             DeepSeq2Seq MainSeq("lstm",Node->getObjPointer()->INUM,Node->getObjPointer()->HNUM,Node->getObjPointer()->ONUM,Node->getObjPointer()->DEPTH,Node->getObjPointer()->MAXTIME);
1197 |             MainSeq.SetFunction(Node->getObjPointer()->Function);
1198 |             MainSeq.SetLearningRate(Node->getObjPointer()->LearningRate);
1199 |             MainSeq.SetBatchSize(Node->getObjPointer()->BatchSize);
1200 |             MainSeq.TotalWork("lstm",Node->getObjPointer()->FileName_1,
1201 |                                     Node->getObjPointer()->FileName_2,
1202 |                                     Node->getObjPointer()->FileName_3,
1203 |                                     Node->getObjPointer()->FileName_7,
1204 |                                     Node->getObjPointer()->FileName_8);
1205 |         }
1206 |         else if(Node->getObjPointer()->NetworkType==7)
1207 |         {
1208 |             std::cout<<">> [Running] GRU seq2seq(Normal neural network)"<<std::endl;
1209 |             if(!fopen(Node->getObjPointer()->FileName_7,"r")||!fopen(Node->getObjPointer()->FileName_8,"r"))
1210 |             {
1211 |                 std::cout<<">> [Error] Cannot open file."<<std::endl;
1212 |                 std::cout<<">> [Lack] "<<Node->getObjPointer()->FileName_7<<" and "<<Node->getObjPointer()->FileName_8<<std::endl;
1213 |                 return;
1214 |             }
1215 |             NormalSeq2Seq MainSeq("gru",Node->getObjPointer()->INUM,Node->getObjPointer()->HNUM,Node->getObjPointer()->ONUM,Node->getObjPointer()->MAXTIME);
1216 |             MainSeq.SetFunction(Node->getObjPointer()->Function);
1217 |             MainSeq.SetLearningRate(Node->getObjPointer()->LearningRate);
1218 |             MainSeq.SetBatchSize(Node->getObjPointer()->BatchSize);
1219 |             MainSeq.TotalWork("gru",Node->getObjPointer()->FileName_1,
1220 |                                     Node->getObjPointer()->FileName_2,
1221 |                                     Node->getObjPointer()->FileName_3,
1222 |                                     Node->getObjPointer()->FileName_7,
1223 |                                     Node->getObjPointer()->FileName_8);
1224 |         }
1225 |         else if(Node->getObjPointer()->NetworkType==8)
1226 |         {
1227 |             std::cout<<">> [Running] GRU seq2seq(Deep neural network)"<<std::endl;
1228 |             if(Node->getObjPointer()->DEPTH>2)
1229 |             {
1230 |                 char Confirm;
1231 |                 std::cout<<">> [Warning] Seq2Seq with two more layers may not work well,do you still want to run this model?(y/n)"<<std::endl;
1232 |                 std::cin>>Confirm;
1233 |                 if(Confirm!='y')
1234 |                 {
1235 |                     std::cout<<">> [Error] Running process cancelled"<<std::endl;
1236 |                     return;
1237 |                 }
1238 |             }
1239 |             if(!fopen(Node->getObjPointer()->FileName_7,"r")||!fopen(Node->getObjPointer()->FileName_8,"r"))
1240 |             {
1241 |                 std::cout<<">> [Error] Cannot open file."<<std::endl;
1242 |                 std::cout<<">> [Lack] "<<Node->getObjPointer()->FileName_7<<" and "<<Node->getObjPointer()->FileName_8<<std::endl;
1243 |                 return;
1244 |             }
1245 |             DeepSeq2Seq MainSeq("gru",Node->getObjPointer()->INUM,Node->getObjPointer()->HNUM,Node->getObjPointer()->ONUM,Node->getObjPointer()->DEPTH,Node->getObjPointer()->MAXTIME);
1246 |             MainSeq.SetFunction(Node->getObjPointer()->Function);
1247 |             MainSeq.SetLearningRate(Node->getObjPointer()->LearningRate);
1248 |             MainSeq.SetBatchSize(Node->getObjPointer()->BatchSize);
1249 |             MainSeq.TotalWork("gru",Node->getObjPointer()->FileName_1,
1250 |                                     Node->getObjPointer()->FileName_2,
1251 |                                     Node->getObjPointer()->FileName_3,
1252 |                                     Node->getObjPointer()->FileName_7,
1253 |                                     Node->getObjPointer()->FileName_8);
1254 |         }
1255 |         else if(Node->getObjPointer()->NetworkType==9)
1256 |         {
1257 |             std::cout<<">> [Running] RNN seq2vec(Normal neural network)"<<std::endl;
1258 |             if(!fopen(Node->getObjPointer()->FileName_7,"r")||!fopen(Node->getObjPointer()->FileName_8,"r"))
1259 |             {
1260 |                 std::cout<<">> [Error] Cannot open file."<<std::endl;
1261 |                 std::cout<<">> [Lack] "<<Node->getObjPointer()->FileName_7<<" and "<<Node->getObjPointer()->FileName_8<<std::endl;
1262 |                 return;
1263 |             }
1264 |             NormalSeq2Vec MainVec("rnn",Node->getObjPointer()->INUM,Node->getObjPointer()->HNUM,Node->getObjPointer()->ONUM,Node->getObjPointer()->MAXTIME);
1265 |             MainVec.SetFunction(Node->getObjPointer()->Function);
1266 |             MainVec.SetLearningRate(Node->getObjPointer()->LearningRate);
1267 |             MainVec.SetBatchSize(Node->getObjPointer()->BatchSize);
1268 |             MainVec.TotalWork("rnn",Node->getObjPointer()->FileName_1,Node->getObjPointer()->FileName_2,Node->getObjPointer()->FileName_7,Node->getObjPointer()->FileName_8);
1269 |         }
1270 |         else if(Node->getObjPointer()->NetworkType==10)
1271 |         {
1272 |             std::cout<<">> [Running] RNN seq2vec(Deep neural network)"<<std::endl;
1273 |             if(Node->getObjPointer()->DEPTH>2)
1274 |             {
1275 |                 char Confirm;
1276 |                 std::cout<<">> [Warning] Seq2Vec with two more layers may not work well,do you still want to run this model?(y/n)"<<std::endl;
1277 |                 std::cin>>Confirm;
1278 |                 if(Confirm!='y')
1279 |                 {
1280 |                     std::cout<<">> [Error] Running process cancelled"<<std::endl;
1281 |                     return;
1282 |                 }
1283 |             }
1284 |             if(!fopen(Node->getObjPointer()->FileName_7,"r")||!fopen(Node->getObjPointer()->FileName_8,"r"))
1285 |             {
1286 |                 std::cout<<">> [Error] Cannot open file."<<std::endl;
1287 |                 std::cout<<">> [Lack] "<<Node->getObjPointer()->FileName_7<<" and "<<Node->getObjPointer()->FileName_8<<std::endl;
1288 |                 return;
1289 |             }
1290 |             DeepSeq2Vec MainVec("rnn",Node->getObjPointer()->INUM,Node->getObjPointer()->HNUM,Node->getObjPointer()->ONUM,Node->getObjPointer()->DEPTH,Node->getObjPointer()->MAXTIME);
1291 |             MainVec.SetFunction(Node->getObjPointer()->Function);
1292 |             MainVec.SetLearningRate(Node->getObjPointer()->LearningRate);
1293 |             MainVec.SetBatchSize(Node->getObjPointer()->BatchSize);
1294 |             MainVec.TotalWork("rnn",Node->getObjPointer()->FileName_1,Node->getObjPointer()->FileName_2,Node->getObjPointer()->FileName_7,Node->getObjPointer()->FileName_8);
1295 |         }
1296 |         else if(Node->getObjPointer()->NetworkType==11)
1297 |         {
1298 |             std::cout<<">> [Running] LSTM seq2vec(Normal neural network)"<<std::endl;
1299 |             if(!fopen(Node->getObjPointer()->FileName_7,"r")||!fopen(Node->getObjPointer()->FileName_8,"r"))
1300 |             {
1301 |                 std::cout<<">> [Error] Cannot open file."<<std::endl;
1302 |                 std::cout<<">> [Lack] "<<Node->getObjPointer()->FileName_7<<" and "<<Node->getObjPointer()->FileName_8<<std::endl;
1303 |                 return;
1304 |             }
1305 |             NormalSeq2Vec MainVec("lstm",Node->getObjPointer()->INUM,Node->getObjPointer()->HNUM,Node->getObjPointer()->ONUM,Node->getObjPointer()->MAXTIME);
1306 |             MainVec.SetFunction(Node->getObjPointer()->Function);
1307 |             MainVec.SetLearningRate(Node->getObjPointer()->LearningRate);
1308 |             MainVec.SetBatchSize(Node->getObjPointer()->BatchSize);
1309 |             MainVec.TotalWork("lstm",Node->getObjPointer()->FileName_1,Node->getObjPointer()->FileName_2,Node->getObjPointer()->FileName_7,Node->getObjPointer()->FileName_8);
1310 |         }
1311 |         else if(Node->getObjPointer()->NetworkType==12)
1312 |         {
1313 |             std::cout<<">> [Running] LSTM seq2vec(Deep neural network)"<<std::endl;
1314 |             if(Node->getObjPointer()->DEPTH>2)
1315 |             {
1316 |                 char Confirm;
1317 |                 std::cout<<">> [Warning] Seq2Vec with two more layers may not work well,do you still want to run this model?(y/n)"<<std::endl;
1318 |                 std::cin>>Confirm;
1319 |                 if(Confirm!='y')
1320 |                 {
1321 |                     std::cout<<">> [Error] Running process cancelled"<<std::endl;
1322 |                     return;
1323 |                 }
1324 |             }
1325 |             if(!fopen(Node->getObjPointer()->FileName_7,"r")||!fopen(Node->getObjPointer()->FileName_8,"r"))
1326 |             {
1327 |                 std::cout<<">> [Error] Cannot open file."<<std::endl;
1328 |                 std::cout<<">> [Lack] "<<Node->getObjPointer()->FileName_7<<" and "<<Node->getObjPointer()->FileName_8<<std::endl;
1329 |                 return;
1330 |             }
1331 |             DeepSeq2Vec MainVec("lstm",Node->getObjPointer()->INUM,Node->getObjPointer()->HNUM,Node->getObjPointer()->ONUM,Node->getObjPointer()->DEPTH,Node->getObjPointer()->MAXTIME);
1332 |             MainVec.SetFunction(Node->getObjPointer()->Function);
1333 |             MainVec.SetLearningRate(Node->getObjPointer()->LearningRate);
1334 |             MainVec.SetBatchSize(Node->getObjPointer()->BatchSize);
1335 |             MainVec.TotalWork("lstm",Node->getObjPointer()->FileName_1,Node->getObjPointer()->FileName_2,Node->getObjPointer()->FileName_7,Node->getObjPointer()->FileName_8);
1336 |         }
1337 |         else if(Node->getObjPointer()->NetworkType==13)
1338 |         {
1339 |             std::cout<<">> [Running] GRU seq2vec(Normal neural network)"<<std::endl;
1340 |             if(!fopen(Node->getObjPointer()->FileName_7,"r")||!fopen(Node->getObjPointer()->FileName_8,"r"))
1341 |             {
1342 |                 std::cout<<">> [Error] Cannot open file."<<std::endl;
1343 |                 std::cout<<">> [Lack] "<<Node->getObjPointer()->FileName_7<<" and "<<Node->getObjPointer()->FileName_8<<std::endl;
1344 |                 return;
1345 |             }
1346 |             NormalSeq2Vec MainVec("gru",Node->getObjPointer()->INUM,Node->getObjPointer()->HNUM,Node->getObjPointer()->ONUM,Node->getObjPointer()->MAXTIME);
1347 |             MainVec.SetFunction(Node->getObjPointer()->Function);
1348 |             MainVec.SetLearningRate(Node->getObjPointer()->LearningRate);
1349 |             MainVec.SetBatchSize(Node->getObjPointer()->BatchSize);
1350 |             MainVec.TotalWork("gru",Node->getObjPointer()->FileName_1,Node->getObjPointer()->FileName_2,Node->getObjPointer()->FileName_7,Node->getObjPointer()->FileName_8);
1351 |         }
1352 |         else if(Node->getObjPointer()->NetworkType==14)
1353 |         {
1354 |             std::cout<<">> [Running] GRU seq2vec(Deep neural network)"<<std::endl;
1355 |             if(Node->getObjPointer()->DEPTH>2)
1356 |             {
1357 |                 char Confirm;
1358 |                 std::cout<<">> [Warning] Seq2Vec with two more layers may not work well,do you still want to run this model?(y/n)"<<std::endl;
1359 |                 std::cin>>Confirm;
1360 |                 if(Confirm!='y')
1361 |                 {
1362 |                     std::cout<<">> [Error] Running process cancelled"<<std::endl;
1363 |                     return;
1364 |                 }
1365 |             }
1366 |             if(!fopen(Node->getObjPointer()->FileName_7,"r")||!fopen(Node->getObjPointer()->FileName_8,"r"))
1367 |             {
1368 |                 std::cout<<">> [Error] Cannot open file."<<std::endl;
1369 |                 std::cout<<">> [Lack] "<<Node->getObjPointer()->FileName_7<<" and "<<Node->getObjPointer()->FileName_8<<std::endl;
1370 |                 return;
1371 |             }
1372 |             DeepSeq2Vec MainVec("gru",Node->getObjPointer()->INUM,Node->getObjPointer()->HNUM,Node->getObjPointer()->ONUM,Node->getObjPointer()->DEPTH,Node->getObjPointer()->MAXTIME);
1373 |             MainVec.SetFunction(Node->getObjPointer()->Function);
1374 |             MainVec.SetLearningRate(Node->getObjPointer()->LearningRate);
1375 |             MainVec.SetBatchSize(Node->getObjPointer()->BatchSize);
1376 |             MainVec.TotalWork("gru",Node->getObjPointer()->FileName_1,Node->getObjPointer()->FileName_2,Node->getObjPointer()->FileName_7,Node->getObjPointer()->FileName_8);
1377 |         }
1378 |         else if(Node->getObjPointer()->NetworkType==15)
1379 |         {
1380 |             std::cout<<">> [Running] BP char2vec(Normal neural network)"<<std::endl;
1381 |             if(!fopen(Node->getObjPointer()->FileName_8,"r"))
1382 |             {
1383 |                 std::cout<<">> [Error] Cannot open file."<<std::endl;
1384 |                 std::cout<<">> [Lack] "<<Node->getObjPointer()->FileName_8<<std::endl;
1385 |                 return;
1386 |             }
1387 |             Char2Vec MainVec(Node->getObjPointer()->HNUM);
1388 |             MainVec.TotalWork(Node->getObjPointer()->FileName_1,Node->getObjPointer()->FileName_8);
1389 |         }
1390 |         else
1391 |             std::cout<<">> [Error] Unknown Type"<<std::endl;
1392 |         return;
1393 |     }
1394 |     std::cout<<">> [Error] This project does not exist."<<std::endl;
1395 |     return;
1396 | }
1397 | 
1398 | void ObjManager::PrintAllObj()
1399 | {
1400 |     UserObject *Node=Head;
1401 |     if(Head->p==NULL)
1402 |     {
1403 |         std::cout<<">> [Error] Empty list.(0 project inside)"<<std::endl;
1404 |         return;
1405 |     }
1406 |     while(Node->p!=NULL)
1407 |     {
1408 |         Node=Node->p;
1409 |         Node->PrintObj();
1410 |     }
1411 |     return;
1412 | }
1413 | 
1414 | void ObjManager::FindObj()
1415 | {
1416 |     UserObject *Node=Head;
1417 |     std::string temp_obj_name;
1418 |     std::cout<<">> Name of the project: ";
1419 |     std::cin>>temp_obj_name;
1420 |     while(Node->p!=NULL)
1421 |     {
1422 |         Node=Node->p;
1423 |         if(Node->CheckObjName(temp_obj_name))
1424 |         {
1425 |             Node->PrintObj();
1426 |             return;
1427 |         }
1428 |     }
1429 |     std::cout<<">> [Error] This project does not exist."<<std::endl;
1430 | }
1431 | 
1432 | void ObjManager::EditObj()
1433 | {
1434 |     UserObject *Node=Head;
1435 |     ObjElement Temp;
1436 |     std::string temp_obj_name;
1437 |     std::cout<<">> Name of the project: ";
1438 |     std::cin>>temp_obj_name;
1439 |     while(Node->p!=NULL)
1440 |     {
1441 |         Node=Node->p;
1442 |         if(Node->CheckObjName(temp_obj_name))
1443 |         {
1444 |             Node->PrintObj();
1445 |             std::cout<<">> [Editing]"<<std::endl;
1446 |             std::cout<<"   ------------------------------------------------------"<<std::endl;
1447 |             std::cout<<"   |Name         |";std::cin>>Temp.ObjName;
1448 |             std::cout<<"   |File 1       |";std::cin>>Temp.FileName_1;
1449 |             std::cout<<"   |File 2       |";std::cin>>Temp.FileName_2;
1450 |             std::cout<<"   |File 3       |";std::cin>>Temp.FileName_3;
1451 |             std::cout<<"   |File 4(NULL) |";std::cin>>Temp.FileName_4;
1452 |             std::cout<<"   |File 5(NULL) |";std::cin>>Temp.FileName_5;
1453 |             std::cout<<"   |File 6(NULL) |";std::cin>>Temp.FileName_6;
1454 |             std::cout<<"   |Input File   |";std::cin>>Temp.FileName_7;
1455 |             std::cout<<"   |Train File   |";std::cin>>Temp.FileName_8;
1456 |             std::cout<<"   |Function     |";std::cin>>Temp.Function;
1457 |             std::cout<<"   |INUM         |";std::cin>>Temp.INUM;
1458 |             std::cout<<"   |HNUM         |";std::cin>>Temp.HNUM;
1459 |             std::cout<<"   |ONUM         |";std::cin>>Temp.ONUM;
1460 |             std::cout<<"   |DEPTH        |";std::cin>>Temp.DEPTH;
1461 |             std::cout<<"   |MAXTIME      |";std::cin>>Temp.MAXTIME;
1462 |             std::cout<<"   |LearningRate |";std::cin>>Temp.LearningRate;
1463 |             std::cout<<"   |Batch Size   |";std::cin>>Temp.BatchSize;
1464 |             std::cout<<"   |Network Type |You Cannot Edit This."<<std::endl;Temp.NetworkType=Node->getObjPointer()->NetworkType;
1465 |             std::cout<<"   ------------------------------------------------------"<<std::endl;
1466 |             Node->ObjChange(Temp);
1467 |             ObjDataOut();
1468 |             return;
1469 |         }
1470 |     }
1471 |     std::cout<<">> [Error] This project does not exist."<<std::endl;
1472 | }
1473 | 
1474 | void ObjManager::DeleteObj()
1475 | {
1476 |     std::string DelObjName;
1477 |     std::cout<<">> Input the name of the project you want to delete: ";
1478 |     std::cin>>DelObjName;
1479 |     UserObject *Node=Head;
1480 |     UserObject *Temp;
1481 |     while(Node->p!=NULL)
1482 |     {
1483 |         Temp=Node;
1484 |         Node=Node->p;
1485 |         if(Node->CheckObjName(DelObjName))
1486 |         {
1487 |             Temp->p=Node->p;
1488 |             delete Node;
1489 |             ObjDataOut();
1490 |             std::cout<<">> Finished.(But the data must be deleted by yourself!)"<<std::endl;
1491 |             return;
1492 |         }
1493 |     }
1494 |     std::cout<<">> [Error] Cannot find this project."<<std::endl;
1495 |     return;
1496 | }
1497 | 
1498 | void ObjManager::ChangeLearningRate()
1499 | {
1500 |     UserObject *Node=Head;
1501 |     double Temp_Learning_Rate;
1502 |     std::string temp_obj_name;
1503 |     std::cout<<">> Name of the project: ";
1504 |     std::cin>>temp_obj_name;
1505 |     while(Node->p!=NULL)
1506 |     {
1507 |         Node=Node->p;
1508 |         if(Node->CheckObjName(temp_obj_name))
1509 |         {
1510 |             Node->PrintObj();
1511 |             std::cout<<"   |LearningRate |";std::cin>>Temp_Learning_Rate;
1512 |             Node->getObjPointer()->LearningRate=Temp_Learning_Rate;
1513 |             ObjDataOut();
1514 |             return;
1515 |         }
1516 |     }
1517 |     std::cout<<">> [Error] This project does not exist."<<std::endl;
1518 | }
1519 | 
1520 | void ObjManager::ChangeBatchSize()
1521 | {
1522 |     UserObject *Node=Head;
1523 |     int Temp_Batch_size;
1524 |     std::string temp_obj_name;
1525 |     std::cout<<">> Name of the project: ";
1526 |     std::cin>>temp_obj_name;
1527 |     while(Node->p!=NULL)
1528 |     {
1529 |         Node=Node->p;
1530 |         if(Node->CheckObjName(temp_obj_name))
1531 |         {
1532 |             Node->PrintObj();
1533 |             std::cout<<"   |Batch Size   |";std::cin>>Temp_Batch_size;
1534 |             Node->getObjPointer()->BatchSize=Temp_Batch_size;
1535 |             ObjDataOut();
1536 |             return;
1537 |         }
1538 |     }
1539 |     std::cout<<">> [Error] This project does not exist."<<std::endl;
1540 | }
1541 | 
1542 | void ObjManager::FindSpecialObj(const char *Typename)
1543 | {
1544 |     if(strcmp(Typename,"bp")&&strcmp(Typename,"rnn")&&strcmp(Typename,"lstm")&&strcmp(Typename,"gru"))
1545 |     {
1546 |         std::cout<<">> [Error] Undefined type."<<std::endl;
1547 |         return;
1548 |     }
1549 |     UserObject *Node=Head;
1550 |     while(Node->p!=NULL)
1551 |     {
1552 |         Node=Node->p;
1553 |         if(strcmp(Typename,"bp")==0)
1554 |         {
1555 |             if(Node->getObjPointer()->NetworkType==1||Node->getObjPointer()->NetworkType==2||Node->getObjPointer()->NetworkType==15)
1556 |                 Node->PrintObj();
1557 |         }
1558 |         else if(strcmp(Typename,"rnn")==0)
1559 |         {
1560 |             if(Node->getObjPointer()->NetworkType==3||Node->getObjPointer()->NetworkType==4||Node->getObjPointer()->NetworkType==9||Node->getObjPointer()->NetworkType==10)
1561 |                 Node->PrintObj();
1562 |         }
1563 |         else if(strcmp(Typename,"lstm")==0)
1564 |         {
1565 |             if(Node->getObjPointer()->NetworkType==5||Node->getObjPointer()->NetworkType==6||Node->getObjPointer()->NetworkType==11||Node->getObjPointer()->NetworkType==12)
1566 |                 Node->PrintObj();
1567 |         }
1568 |         else if(strcmp(Typename,"gru")==0)
1569 |         {
1570 |             if(Node->getObjPointer()->NetworkType==7||Node->getObjPointer()->NetworkType==8||Node->getObjPointer()->NetworkType==13||Node->getObjPointer()->NetworkType==14)
1571 |                 Node->PrintObj();
1572 |         }
1573 |     }
1574 |     std::cout<<">> [End] End of the list."<<std::endl;
1575 |     return;
1576 | }
1577 | 
1578 | #endif
1579 | 


--------------------------------------------------------------------------------