commit

Author: heshanera

LSTMNet.cpp

@@ -14,11 +14,9 @@ LSTMNet::LSTMNet(int memCells, int inputVecSize) {
     noOfIns = 0;
 }
 
-LSTMNet::LSTMNet(const LSTMNet& orig) {
-}
+LSTMNet::LSTMNet(const LSTMNet& orig) { }
 
-LSTMNet::~LSTMNet() {
-}
+LSTMNet::~LSTMNet() { }
 
 int LSTMNet::forward(std::vector<double> * input, int timeSteps) {
 
@@ -150,7 +148,6 @@ int LSTMNet::train(std::vector<double> * input, std::vector<double> output, int
 
     std::vector<double> *inVec;
 
-    
     for (int i = 0; i < trainingIterations; i++){
 
         inVec = input + (timeSteps*i);
@@ -159,8 +156,6 @@ int LSTMNet::train(std::vector<double> * input, std::vector<double> output, int
         std::vector<double>::const_iterator last = output.begin() + (timeSteps*i + timeSteps);
         std::vector<double> outVec(first, last);
 
-//        printVector(outVec);
-        
         forward(inVec,timeSteps);
         backward(outVec,timeSteps);
 
@@ -185,23 +180,19 @@ int LSTMNet::train(std::vector<double> * input, std::vector<double> output, int
                     oDeltaWeightVecArr[p].at(wPos) += *it * delta_o_t;
                     wPos++;
                 }
-
                 delta_bias_a_t += delta_a_t;
                 delta_bias_i_t += delta_i_t;
                 delta_bias_f_t += delta_f_t;
                 delta_bias_o_t += delta_o_t;
             }
-
             aBiasArr[p] -= (delta_bias_a_t * learningRate);
             iBiasArr[p] -= (delta_bias_i_t * learningRate);       
             fBiasArr[p] -= (delta_bias_f_t * learningRate);
             oBiasArr[p] -= (delta_bias_o_t * learningRate);
 
         }
-        
-                
+          
         index += timeSteps;
-        
         for(int j = 0; j < memCells; j++) {
 
             std::transform(
@@ -248,10 +239,8 @@ int LSTMNet::train(std::vector<double> * input, std::vector<double> output, int
                 oWeightVecArr[j].begin(), oWeightVecArr[j].end(), 
                 oDeltaWeightVecArr[j].begin(), oWeightVecArr[j].begin(), 
                 std::minus<double>()
-            );
-            
-        }
-        
+            );  
+        } 
         clearVectors();
     }    
     return 0;
@@ -405,7 +394,6 @@ int LSTMNet::clearVectors() {
         memCellOutArr[i].clear();
         memCellOutArr[i].push_back(out);
     }        
-        
     return 0;
 }
 
@@ -424,7 +412,6 @@ double LSTMNet::predict(std::vector<double> * input) {
         result += *(memCellOutArr[i].end()-1);
     }
 
-    
 //    output2.push_back(result);
 //    if (noOfIns == timeSteps) {
 //        printVector(memCellOutArr[0]);
@@ -434,8 +421,7 @@ double LSTMNet::predict(std::vector<double> * input) {
 //        noOfIns = 0;
 //        train(input2, output, timeSteps, timeSteps, 0.095);
 //    }
-    
-    
+ 
     return result;
 }
 

LSTMNet.h

@@ -25,29 +25,93 @@ class LSTMNet {
     LSTMNet(const LSTMNet& orig);
     virtual ~LSTMNet();
 
+    /**
+    * 
+    * @param input: training data set
+    * @param output: target values
+    * @param trainDataSize: training data size
+    * @param timeSteps: unfolding time steps
+    * @param learningRate
+    * @param iterations: training iterations
+    * @return 0
+    */
     int train(std::vector<double> * input, std::vector<double> output, int trainDataSize, int timeSteps, float learningRate, int iterations);
+    /**
+    * predict a future point using a input vector of size n
+    * 
+    * input: {t-n,...,t-2,t-1,t}
+    * result: {t+1} 
+    * 
+    * @param input: input vector for he prediction
+    * @return result: predicted value
+    */
     double predict(std::vector<double> * input);
 
 
 private:
+    /**
+     * Forward Propagation of the network
+     *  
+     * @param input: input vector
+     * @param timeSteps: unfolded time steps in the input vector
+     * @return 0
+     */
     int forward(std::vector<double> * input, int timeSteps);
+    /**
+     * Backward Propagation of the network
+     * 
+     * @param output: output from the forward propagation
+     * @param timeSteps: unfolded time steps
+     * @return 0
+     */
     int backward(std::vector<double> output, int timeSteps);
-    double sigmoid(double x);
-    std::vector<double> sigmoid(std::vector<double> x);
+    /**
+     * Initialize the weights and bias values for the gates
+     * Random initialization
+     * 
+     * @return 0
+     */
     int initWeights();
+    /**
+     * Clear Vectors
+     * 
+     * @return 0
+     */
     int clearVectors();
+    /**
+     * print the given vector
+     * 
+     * @param vec: vector
+     * @return 0 
+     */
     int printVector(std::vector<double> vec);
+    /**
+     * Sigmoid function
+     * 
+     * @param x
+     * @return value
+     */
+    double sigmoid(double x);
+    /**
+     * Sigmoid function
+     * 
+     * @param x: input vector
+     * @return vector
+     */
+    std::vector<double> sigmoid(std::vector<double> x);
 
 private:
     int memCells;
     int inputVectDim;
     int timeSteps;
 
+    // weight vector arrays
     std::vector<double> * aWeightVecArr;
     std::vector<double> * iWeightVecArr;
     std::vector<double> * fWeightVecArr;
     std::vector<double> * oWeightVecArr;
 
+    // bias value arrays
     double * aBiasArr;
     double * iBiasArr;
     double * fBiasArr;
@@ -56,6 +120,7 @@ class LSTMNet {
     std::vector<double> * memCellOutArr;
     std::vector<double> * memCellStateArr;
 
+    // gate output value arrays
     std::vector<double> * aGateVecArr;
     std::vector<double> * iGateVecArr;
     std::vector<double> * fGateVecArr;