new

Average_Filter.m

@@ -0,0 +1,42 @@
+% Recursive weighted average fltering algorithm
+% RSSI_After: scalar
+% RSSI_Before: vector with 3 values
+
+function [RSSI_After, F1, F2, TimeCount] = Average_Filter(RSSI_Before, F1_Before, F2_Before,n)
+
+    beta1 = 0.2;
+    beta2 = 0.8;
+    beta3 = 0.05;
+    beta4 = 0.15;
+    beta5 = 0.8;
+    
+    TimeCount = n;
+    F1 = F1_Before;
+    F2 = F2_Before;
+    
+    if n == 1
+       F1(1) = RSSI_Before(1);
+       F2(1) = RSSI_Before(1);
+       RSSI_After = RSSI_Before(1);
+    end
+    
+    if n == 2
+        F1(2) = beta1*RSSI_Before(n-1) + beta2*RSSI_Before(n);
+        F2(2) = beta1*F1(n-1) + beta2*F1(n);
+        F3 = beta1*F2(n-1) + beta2*F2(n);
+        RSSI_After = F3;
+    end
+    
+    if n >= 3
+        if n > 3
+            n = 3;
+            F1(1) =  F1(2); F1(2) = F1(3); 
+            F2(1) =  F2(2); F2(2) = F2(3); 
+        end
+        F1(3) = beta3*RSSI_Before(n-2) + beta4*RSSI_Before(n-1)+beta5*RSSI_Before(n);
+        F2(3) = beta3*F1(n-2) + beta4*F1(n-1)+beta5*F1(n);
+        F3 = beta3*F2(n-2) + beta4*F2(n-1)+beta5*F2(n);
+        RSSI_After = F3;
+    end
+    TimeCount = TimeCount + 1;
+end

BiLSTM_Model_5_10fold.py

@@ -0,0 +1,388 @@
+#############################################################
+# 10 locations/ trajectory
+# First location is known
+# Date: 8 June 2018
+#############################################################
+
+import time
+import tensorflow
+# import lstm
+import os
+#import time
+import warnings
+import numpy as np
+from numpy import newaxis
+from keras.layers import TimeDistributed
+from keras.layers.core import Dense, Activation, Dropout
+from keras.layers.recurrent import LSTM
+from keras.models import Sequential
+# import matplotlib.pyplot as plt
+from matplotlib import pyplot
+import pandas as pd
+import math
+from pandas import DataFrame
+from keras import backend as K
+from keras.layers import Bidirectional
+
+def rmse(y_true, y_pred):
+        return K.sqrt(K.mean(K.square(y_pred - y_true), axis=-1))
+def err_absolute(y_true, y_pred):
+        err = K.sqrt(K.square(y_pred - y_true))
+        return err 
+
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' #Hide messy TensorFlow warnings
+warnings.filterwarnings("ignore") #Hide messy Numpy warnings
+
+# Open File to write results
+File1 = open('Error_BiLSTM_10_fold.csv','w')
+# File2 = open('Traj_Model_5_DiffSpeed_2ms.csv','w') 
+# File3 = open('Loss_PredictedL_50k_NoFilter.csv','w') 
+# File4 = open('Output_PredictedL_50k_NoFilter.csv','w') 
+
+NumTotalTraj = 365000
+
+# Configure the sampling set -----------------
+epochs_num  = 500
+N_fold = 5 
+NumTrajTraining = 20000
+NumSam_PerTraj = 1
+StartingTraj = 0
+StartingSample = StartingTraj*NumSam_PerTraj # the factor of NumSam_PerTraj 
+NumSample = NumTrajTraining*NumSam_PerTraj # NumTraj = NumSample/NumSam_PerTraj
+
+# Configure the validation set -----------------
+NumTrajVal = 10000
+StartingTrajVal = 100000
+
+StartingValidation = StartingTrajVal*NumSam_PerTraj
+NumValidation = NumTrajVal*NumSam_PerTraj
+
+# Main Run Thread
+global_start_time = time.time()
+input_layer = 13 # X, Y & 11 MAC Addresses
+num_rssi_reading = 11
+output_layer = 2
+timestep = 9
+NumBatch = 512 #512
+hidden_layer1 = 50
+hidden_layer2 = 50
+
+##########################################################
+###### Test Trajectory Splitting #########################
+########################################################## 
+# Read Training data --------------------------------------------------
+print('> Loading data... ')
+df1=pd.read_csv('Input_Location_RSSI_10points_365k.csv')
+df1= np.asarray(df1)
+
+df2=pd.read_csv('Output_Location_RSSI_10points_365k.csv')
+df2= np.asarray(df2)
+
+########################################################################
+# Read Validation data --------------------------------------------------
+#######################################################################
+# df3= df1[StartingValidation:StartingValidation+NumValidation,:]
+# input_validation = df3.reshape(len(df3),timestep,input_layer)
+# print(input_validation.shape)
+
+# df4=df2[StartingValidation:StartingValidation+NumValidation,:]
+# output_validation = df4.reshape(len(df4),timestep,output_layer)
+# print(output_validation.shape)
+
+####################################################################
+# Testing data ------------------------
+####################################################################
+# RSSI array
+TestData_origin =pd.read_csv('Long_Traj_6July_v1_AverageFilter.csv')
+print(TestData_origin.shape)
+TestData_origin = np.asarray(TestData_origin)
+
+LengthTest = len(TestData_origin)
+StartTestIdx = 0
+StopTestIdx = StartTestIdx + LengthTest
+
+# print(TestData.shape)
+TestData = TestData_origin[StartTestIdx:StopTestIdx, :]
+# LengthTest = len(TestData)
+
+# List of Locations 
+Location_origin = pd.read_csv('Long_Traj_Location.csv')
+print(Location_origin.shape)
+Location_origin = np.asarray(Location_origin)
+Location = Location_origin[StartTestIdx:StopTestIdx, :]
+
+print('> Data Loaded. Compiling...')
+
+####################################################################
+# Init 9 first Location ###########################################
+####################################################################
+L1 = Location[0,:]
+L2 = Location[0,:]
+L3 = Location[0,:]
+L4 = Location[0,:]
+L5 = Location[0,:]
+L6 = Location[0,:]
+L7 = Location[0,:]
+L8 = Location[0,:]
+L9 = Location[0,:]
+
+# Take RSSI
+RSSI_L1 = TestData[0,:]
+RSSI_L2 = TestData[1,:] 
+RSSI_L3 = TestData[1,:]
+RSSI_L4 = TestData[1,:] 
+RSSI_L5 = TestData[1,:]
+RSSI_L6 = TestData[1,:] 
+RSSI_L7 = TestData[1,:]
+RSSI_L8 = TestData[1,:] 
+RSSI_L9 = TestData[1,:]
+RSSI_L10 = TestData[1,:]
+
+# Build the network  --------------------------------------------
+model1 = Sequential()
+model1.add(Bidirectional(LSTM(hidden_layer1, return_sequences=True),input_shape=(timestep, input_layer),merge_mode='concat'))
+model1.add(Dropout(0.2))
+model1.add(Bidirectional(LSTM(hidden_layer2, return_sequences=True),input_shape=(timestep, input_layer),merge_mode='concat'))
+model1.add(LSTM(hidden_layer2,return_sequences=True))
+model1.add(Dropout(0.2))
+model1.add(TimeDistributed(Dense(output_layer)))
+model1.summary()
+start = time.time()
+model1.compile(loss="mse", optimizer="adam",metrics=[rmse])
+
+# Training --------------------------------------------------------
+loss = list()
+ResultPlot = DataFrame()
+
+#### Create a copy of input training ##########################
+# input_training_org = input_training
+# input_validation_org = input_validation
+###############################################################
+# model1.load_weights("lstm_Model_5_DiffSpeed.h5")
+# StartingValidation = 0
+for CountFold in xrange(1, N_fold): 
+    # training samples -----------------------
+    StartingTraj = CountFold*NumTrajTraining
+    StartingSample = StartingTraj*NumSam_PerTraj # the factor of NumSam_PerTraj 
+    df1_split = df1[StartingSample:StartingSample+NumSample,:]
+    input_training = df1_split.reshape(len(df1_split),timestep,input_layer)
+    # print(input_training.shape)
+    input_training_org = input_training
+
+    df2_split = df2[StartingSample:StartingSample+NumSample,:]
+    output_training = df2_split.reshape(len(df2_split),timestep,output_layer)
+    # print(output_training.shape)
+
+    H5_Name = 'Bilstm_Model_5_fold_'+ str(CountFold) + '.h5'
+    iTimeStep = 1
+    iTimeStep_val = 1
+    for ep in xrange(epochs_num):
+        print("Iteration {} ----- ".format(ep))
+
+        # Fit Model
+      #  hist = model1.fit(input_training,output_training, validation_data=(input_validation, output_validation), epochs=1, batch_size=NumBatch, verbose=1)
+        hist = model1.fit(input_training,output_training, epochs=1, batch_size=NumBatch, verbose=1, shuffle=False)
+        loss.append(hist.history['loss'][0])
+      #  File3.write(str(hist.history['loss'][0]) + '\n') #100 write to file
+
+        # Reform the input training ---------------------------------
+        print("Training Predict Sample {} ... ".format(iTimeStep))
+        Predicted_L_Training = model1.predict(input_training) 
+        # get the predicted locations to become the inputs of the next step
+        for iSample in xrange(0,len(df1_split)):
+            # First location: known
+            # Update predicted Location starting from the second location
+            input_training[iSample,iTimeStep,0] = Predicted_L_Training[iSample,iTimeStep-1,0]
+            input_training[iSample,iTimeStep,1] = Predicted_L_Training[iSample,iTimeStep-1,1]
+        iTimeStep = iTimeStep + 1 # Update for next time step
+
+        if iTimeStep == timestep:  # reset 1 round -------
+            input_training = input_training_org
+            iTimeStep = 1
+        # --------------------------------------------------------------------------------------
+
+        # Reform the validation set for testing -------------------------------------------------
+        # Input is updated by prediction
+        # Output: Ideal
+    #    print("Validation Predict ...")
+    #    Predicted_L_Validation = model1.predict(input_validation) 
+    #    for iSample in xrange(0,len(df3)):
+    #        input_validation[iSample,iTimeStep_val,0] = Predicted_L_Validation[iSample,iTimeStep_val-1,0]
+    #        input_validation[iSample,iTimeStep_val,1] = Predicted_L_Validation[iSample,iTimeStep_val-1,1]
+    #    iTimeStep_val = iTimeStep_val + 1        
+    #    print("TESTING...........")
+
+     #   if iTimeStep_val == timestep:  # reset 1 round -------
+    #        input_validation = input_validation_org
+     #       iTimeStep_val = 1
+         # ------------------------------------------------------------------------------------------
+         # Calculate the validation error ------------------------------------------------
+
+        # model1.fit(input_training,output_training, validation_split=0.2, epochs=epochs_num, batch_size=512)
+        model1.save_weights(H5_Name)
+    # print('Training duration (s) 100: ', time.time() - global_start_time)
+
+    # Testing --------------------------------------------------------- 
+    #########################################################
+    # The first 3 steps: Fill up the buffer
+    # #######################################################    
+    Acc_Location = np.zeros((timestep,2))
+    Acc_Location[0,:] = L1
+    L_combine = np.concatenate((L1,L2,L3,L4,L5,L6,L7,L8,L9), axis=0)
+    RSSI_combine = np.concatenate((RSSI_L2, RSSI_L3, RSSI_L4, RSSI_L5,RSSI_L6, RSSI_L7, RSSI_L8, RSSI_L9, RSSI_L10), axis=0)
+    
+    for Step in xrange(1,timestep):
+
+        # Update the Locations & RSSIs buffer
+        LocationIdx = 0
+        RSSIdx = 0
+        TestingData = np.zeros(len(L_combine)+len(RSSI_combine))
+        for i in xrange(timestep):
+            TestingData[LocationIdx] = L_combine[i*2]
+            TestingData[LocationIdx+1] = L_combine[i*2+1]
+            for j in xrange(len(RSSI_L2)):
+                TestingData[j+LocationIdx+2] = (float(RSSI_combine[j+RSSIdx])+100)/100
+            LocationIdx = LocationIdx + input_layer
+            RSSIdx = RSSIdx + num_rssi_reading
+            # print(TestingData)
+
+        TestingData = TestingData.reshape(1,timestep,input_layer)
+        # print(TestingData)
+
+        # Prediction 
+        Predicted_L = model1.predict(TestingData)
+        Acc_Location[Step,:] = Predicted_L[0,Step-1,:]
+        print(Acc_Location)
+
+        # Update for next step
+        # Init 4 first Location
+        IdxTemp = 0
+        # Update Location
+        for j in xrange(Step*2,len(L_combine)):
+            L_combine[j] = Acc_Location[Step,IdxTemp]
+            if IdxTemp == 0:
+                IdxTemp = 1
+            else:
+                IdxTemp = 0
+                pass
+
+        # Take RSSI
+        IdxTemp = 0
+        for j in xrange(Step*num_rssi_reading,len(RSSI_combine)):
+            RSSI_combine[j] = TestData[Step+1,IdxTemp]
+            IdxTemp = IdxTemp + 1
+            if IdxTemp == num_rssi_reading: # Reach the end
+                IdxTemp = 0
+
+    #########################################################
+    # AFter the buffer is full - Do the Test
+    # #######################################################  
+
+    CountArray = np.ones(timestep)
+    error = np.zeros(LengthTest-1)
+    # Predicted_array = np.zeros((LengthTest-1,2))
+    Average_Err = 0
+
+    for CountTest in xrange(LengthTest-timestep):
+        print("Location {}------------".format(CountTest))
+    # Update the Locations & RSSIs buffer
+        LocationIdx = 0
+        RSSIdx = 0
+        TestingData = np.zeros(len(L_combine)+len(RSSI_combine))
+        for i in xrange(timestep):
+            TestingData[LocationIdx] = L_combine[i*2]
+            TestingData[LocationIdx+1] = L_combine[i*2+1]
+            for j in xrange(len(RSSI_L2)):
+                TestingData[j+LocationIdx+2] = (float(RSSI_combine[j+RSSIdx])+100)/100
+            LocationIdx = LocationIdx + input_layer
+            RSSIdx = RSSIdx + num_rssi_reading
+
+        TestingData = TestingData.reshape(1,timestep,input_layer)
+        # print(TestingData)
+
+        # Prediction 
+        Predicted_L = model1.predict(TestingData)
+
+    # for t in xrange(timestep): 
+    #     File4.write(str(Predicted_L[0,t,0]) + ',') 
+    #     File4.write(str(Predicted_L[0,t,1])+ ',') # write to file
+    # File4.write('\n')
+
+        # Re-arrange Accumulated Location
+        for t in xrange(timestep-1): 
+            CountArray[t] = CountArray[t+1]
+            Acc_Location[t,:] = Acc_Location[t+1,:]+Predicted_L[0,t,:]
+            CountArray[t] = CountArray[t] + 1
+
+        Acc_Location[timestep-1,:] = Predicted_L[0,timestep-1,:] # Update new Location
+        CountArray[timestep-1] = 1 #Update New Count
+    # print(Acc_Location)
+    #  print(CountArray)  
+    ######################################################################
+    ############# UPDATE LOCATION ########################################
+    ######################################################################
+
+        Final_L = Acc_Location[0,:]/CountArray[0]
+        CountArray[0] = 1
+        # Take correct location, compare the result
+        Correct_L = Location[CountTest+1,:]
+        error[CountTest] = np.sqrt(np.power((Final_L[0] - Correct_L[0]),2)+np.power((Final_L[1] - Correct_L[1]),2))
+        print "Predict: {}--- Exact: {} , Error: {}" .format((Final_L[0], Final_L[1]), (Correct_L[0], Correct_L[1]), (error[CountTest]))
+        Average_Err = Average_Err + error[CountTest]
+
+        File1.write(str(error[CountTest]) + ' , ') # write to file
+    # File2.write(str(Final_L[0]) + ',') 
+    # File2.write(str(Final_L[1]) + '\n') # write to file
+        # Re-arrange L_combine
+        for t in xrange(timestep-1): 
+            L_combine[t*2] = L_combine[(t+1)*2]
+            L_combine[t*2+1] = L_combine[(t+1)*2+1] 
+        # Update 
+        L_combine[(timestep-1)*2] = Predicted_L[0,timestep-1,0] 
+        L_combine[(timestep-1)*2+1] = Predicted_L[0,timestep-1,1] 
+        # Re-arrange RSSI_combine
+        if CountTest+timestep+1 < LengthTest:
+            for t in xrange(timestep-1): 
+                for k in xrange(num_rssi_reading):
+                    RSSI_combine[t*num_rssi_reading+k] =  RSSI_combine[(t+1)*num_rssi_reading+k]
+
+            for k in xrange(num_rssi_reading):
+                RSSI_combine[(timestep-1)*num_rssi_reading+k] = TestData[CountTest+timestep+1,k]      
+
+    ###################################################################
+    ############### The Last Locations ###############################
+    ###################################################################
+    for i in xrange(timestep-1):
+        Final_L = Acc_Location[i+1,:]/CountArray[i+1]
+        # Take correct location, compare the result
+        Correct_L = Location[CountTest+1,:]
+        error[CountTest] = np.sqrt(np.power((Final_L[0] - Correct_L[0]),2)+np.power((Final_L[1] - Correct_L[1]),2))
+        print "Predict: {}--- Exact: {} , Error: {}" .format((Final_L[0], Final_L[1]), (Correct_L[0], Correct_L[1]),  error[CountTest])
+        Average_Err = Average_Err + error[CountTest]
+
+        File1.write(str(error[CountTest]) + ' , ') # write to file
+    #  File2.write(str(Final_L[0]) + ',') 
+    #  File2.write(str(Final_L[1]) + '\n') # write to file
+        CountTest = CountTest + 1
+
+    File1.write('\n')
+    Average_Err = Average_Err/(LengthTest-1)
+    print "Average Error: ", Average_Err
+
+    Std_Err = 0
+    for k in xrange(LengthTest-1):
+        Std_Err = Std_Err +  np.power((error[k] - Average_Err),2)
+    Std_Err = Std_Err/(LengthTest-1)
+    Std_Err = np.sqrt(Std_Err)
+    print "Std: ", Std_Err 
+
+#### Show Figure ######################
+#if epochs_num > 0:
+#    ResultPlot['neurons_500'] =  loss
+#    ResultPlot.plot()
+#    pyplot.show()
+
+File1.close()
+# File2.close()
+# File3.close()
+# File4.close()

BiRNN_Model_5_10fold.py

@@ -0,0 +1,388 @@
+#############################################################
+# 10 locations/ trajectory
+# First location is known
+# Date: 8 June 2018
+#############################################################
+
+import time
+import tensorflow
+# import lstm
+import os
+#import time
+import warnings
+import numpy as np
+from numpy import newaxis
+from keras.layers import TimeDistributed
+from keras.layers.core import Dense, Activation, Dropout
+from keras.layers.recurrent import SimpleRNN
+from keras.models import Sequential
+# import matplotlib.pyplot as plt
+from matplotlib import pyplot
+import pandas as pd
+import math
+from pandas import DataFrame
+from keras import backend as K
+from keras.layers import Bidirectional
+
+def rmse(y_true, y_pred):
+        return K.sqrt(K.mean(K.square(y_pred - y_true), axis=-1))
+def err_absolute(y_true, y_pred):
+        err = K.sqrt(K.square(y_pred - y_true))
+        return err 
+
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' #Hide messy TensorFlow warnings
+warnings.filterwarnings("ignore") #Hide messy Numpy warnings
+
+# Open File to write results
+File1 = open('Error_BiSimpleRNN_10_fold.csv','w')
+# File2 = open('Traj_Model_5_DiffSpeed_2ms.csv','w') 
+# File3 = open('Loss_PredictedL_50k_NoFilter.csv','w') 
+# File4 = open('Output_PredictedL_50k_NoFilter.csv','w') 
+
+NumTotalTraj = 365000
+
+# Configure the sampling set -----------------
+epochs_num  = 500
+N_fold = 5 
+NumTrajTraining = 20000
+NumSam_PerTraj = 1
+StartingTraj = 0
+StartingSample = StartingTraj*NumSam_PerTraj # the factor of NumSam_PerTraj 
+NumSample = NumTrajTraining*NumSam_PerTraj # NumTraj = NumSample/NumSam_PerTraj
+
+# Configure the validation set -----------------
+NumTrajVal = 10000
+StartingTrajVal = 100000
+
+StartingValidation = StartingTrajVal*NumSam_PerTraj
+NumValidation = NumTrajVal*NumSam_PerTraj
+
+# Main Run Thread
+global_start_time = time.time()
+input_layer = 13 # X, Y & 11 MAC Addresses
+num_rssi_reading = 11
+output_layer = 2
+timestep = 9
+NumBatch = 512 #512
+hidden_layer1 = 50
+hidden_layer2 = 50
+
+##########################################################
+###### Test Trajectory Splitting #########################
+########################################################## 
+# Read Training data --------------------------------------------------
+print('> Loading data... ')
+df1=pd.read_csv('Input_Location_RSSI_10points_365k.csv')
+df1= np.asarray(df1)
+
+df2=pd.read_csv('Output_Location_RSSI_10points_365k.csv')
+df2= np.asarray(df2)
+
+########################################################################
+# Read Validation data --------------------------------------------------
+#######################################################################
+# df3= df1[StartingValidation:StartingValidation+NumValidation,:]
+# input_validation = df3.reshape(len(df3),timestep,input_layer)
+# print(input_validation.shape)
+
+# df4=df2[StartingValidation:StartingValidation+NumValidation,:]
+# output_validation = df4.reshape(len(df4),timestep,output_layer)
+# print(output_validation.shape)
+
+####################################################################
+# Testing data ------------------------
+####################################################################
+# RSSI array
+TestData_origin =pd.read_csv('Long_Traj_172Locations_RSSI.csv')
+print(TestData_origin.shape)
+TestData_origin = np.asarray(TestData_origin)
+
+LengthTest = len(TestData_origin)
+StartTestIdx = 0
+StopTestIdx = StartTestIdx + LengthTest
+
+# print(TestData.shape)
+TestData = TestData_origin[StartTestIdx:StopTestIdx, :]
+# LengthTest = len(TestData)
+
+# List of Locations 
+Location_origin = pd.read_csv('Long_Traj_172Locations.csv')
+print(Location_origin.shape)
+Location_origin = np.asarray(Location_origin)
+Location = Location_origin[StartTestIdx:StopTestIdx, :]
+
+print('> Data Loaded. Compiling...')
+
+####################################################################
+# Init 9 first Location ###########################################
+####################################################################
+L1 = Location[0,:]
+L2 = Location[0,:]
+L3 = Location[0,:]
+L4 = Location[0,:]
+L5 = Location[0,:]
+L6 = Location[0,:]
+L7 = Location[0,:]
+L8 = Location[0,:]
+L9 = Location[0,:]
+
+# Take RSSI
+RSSI_L1 = TestData[0,:]
+RSSI_L2 = TestData[1,:] 
+RSSI_L3 = TestData[1,:]
+RSSI_L4 = TestData[1,:] 
+RSSI_L5 = TestData[1,:]
+RSSI_L6 = TestData[1,:] 
+RSSI_L7 = TestData[1,:]
+RSSI_L8 = TestData[1,:] 
+RSSI_L9 = TestData[1,:]
+RSSI_L10 = TestData[1,:]
+
+# Build the network  --------------------------------------------
+model1 = Sequential()
+model1.add(Bidirectional(SimpleRNN(hidden_layer1, return_sequences=True),input_shape=(timestep, input_layer),merge_mode='concat'))
+model1.add(Dropout(0.2))
+model1.add(Bidirectional(SimpleRNN(hidden_layer2, return_sequences=True),input_shape=(timestep, input_layer),merge_mode='concat'))
+model1.add(SimpleRNN(hidden_layer2,return_sequences=True))
+model1.add(Dropout(0.2))
+model1.add(TimeDistributed(Dense(output_layer)))
+model1.summary()
+start = time.time()
+model1.compile(loss="mse", optimizer="adam",metrics=[rmse])
+
+# Training --------------------------------------------------------
+loss = list()
+ResultPlot = DataFrame()
+
+#### Create a copy of input training ##########################
+# input_training_org = input_training
+# input_validation_org = input_validation
+###############################################################
+# model1.load_weights("lstm_Model_5_DiffSpeed.h5")
+# StartingValidation = 0
+for CountFold in xrange(1, N_fold): 
+    # training samples -----------------------
+    StartingTraj = CountFold*NumTrajTraining
+    StartingSample = StartingTraj*NumSam_PerTraj # the factor of NumSam_PerTraj 
+    df1_split = df1[StartingSample:StartingSample+NumSample,:]
+    input_training = df1_split.reshape(len(df1_split),timestep,input_layer)
+    # print(input_training.shape)
+    input_training_org = input_training
+
+    df2_split = df2[StartingSample:StartingSample+NumSample,:]
+    output_training = df2_split.reshape(len(df2_split),timestep,output_layer)
+    # print(output_training.shape)
+
+    H5_Name = 'BiSimpleRNN_Model_5_fold_'+ str(CountFold) + '.h5'
+    iTimeStep = 1
+    iTimeStep_val = 1
+    for ep in xrange(epochs_num):
+        print("Iteration {} ----- ".format(ep))
+
+        # Fit Model
+      #  hist = model1.fit(input_training,output_training, validation_data=(input_validation, output_validation), epochs=1, batch_size=NumBatch, verbose=1)
+        hist = model1.fit(input_training,output_training, epochs=1, batch_size=NumBatch, verbose=1, shuffle=False)
+        loss.append(hist.history['loss'][0])
+      #  File3.write(str(hist.history['loss'][0]) + '\n') #100 write to file
+
+        # Reform the input training ---------------------------------
+        print("Training Predict Sample {} ... ".format(iTimeStep))
+        Predicted_L_Training = model1.predict(input_training) 
+        # get the predicted locations to become the inputs of the next step
+        for iSample in xrange(0,len(df1_split)):
+            # First location: known
+            # Update predicted Location starting from the second location
+            input_training[iSample,iTimeStep,0] = Predicted_L_Training[iSample,iTimeStep-1,0]
+            input_training[iSample,iTimeStep,1] = Predicted_L_Training[iSample,iTimeStep-1,1]
+        iTimeStep = iTimeStep + 1 # Update for next time step
+
+        if iTimeStep == timestep:  # reset 1 round -------
+            input_training = input_training_org
+            iTimeStep = 1
+        # --------------------------------------------------------------------------------------
+
+        # Reform the validation set for testing -------------------------------------------------
+        # Input is updated by prediction
+        # Output: Ideal
+    #    print("Validation Predict ...")
+    #    Predicted_L_Validation = model1.predict(input_validation) 
+    #    for iSample in xrange(0,len(df3)):
+    #        input_validation[iSample,iTimeStep_val,0] = Predicted_L_Validation[iSample,iTimeStep_val-1,0]
+    #        input_validation[iSample,iTimeStep_val,1] = Predicted_L_Validation[iSample,iTimeStep_val-1,1]
+    #    iTimeStep_val = iTimeStep_val + 1        
+    #    print("TESTING...........")
+
+     #   if iTimeStep_val == timestep:  # reset 1 round -------
+    #        input_validation = input_validation_org
+     #       iTimeStep_val = 1
+         # ------------------------------------------------------------------------------------------
+         # Calculate the validation error ------------------------------------------------
+
+        # model1.fit(input_training,output_training, validation_split=0.2, epochs=epochs_num, batch_size=512)
+        model1.save_weights(H5_Name)
+    # print('Training duration (s) 100: ', time.time() - global_start_time)
+
+    # Testing --------------------------------------------------------- 
+    #########################################################
+    # The first 3 steps: Fill up the buffer
+    # #######################################################    
+    Acc_Location = np.zeros((timestep,2))
+    Acc_Location[0,:] = L1
+    L_combine = np.concatenate((L1,L2,L3,L4,L5,L6,L7,L8,L9), axis=0)
+    RSSI_combine = np.concatenate((RSSI_L2, RSSI_L3, RSSI_L4, RSSI_L5,RSSI_L6, RSSI_L7, RSSI_L8, RSSI_L9, RSSI_L10), axis=0)
+    
+    for Step in xrange(1,timestep):
+
+        # Update the Locations & RSSIs buffer
+        LocationIdx = 0
+        RSSIdx = 0
+        TestingData = np.zeros(len(L_combine)+len(RSSI_combine))
+        for i in xrange(timestep):
+            TestingData[LocationIdx] = L_combine[i*2]
+            TestingData[LocationIdx+1] = L_combine[i*2+1]
+            for j in xrange(len(RSSI_L2)):
+                TestingData[j+LocationIdx+2] = (float(RSSI_combine[j+RSSIdx])+100)/100
+            LocationIdx = LocationIdx + input_layer
+            RSSIdx = RSSIdx + num_rssi_reading
+            # print(TestingData)
+
+        TestingData = TestingData.reshape(1,timestep,input_layer)
+        # print(TestingData)
+
+        # Prediction 
+        Predicted_L = model1.predict(TestingData)
+        Acc_Location[Step,:] = Predicted_L[0,Step-1,:]
+        print(Acc_Location)
+
+        # Update for next step
+        # Init 4 first Location
+        IdxTemp = 0
+        # Update Location
+        for j in xrange(Step*2,len(L_combine)):
+            L_combine[j] = Acc_Location[Step,IdxTemp]
+            if IdxTemp == 0:
+                IdxTemp = 1
+            else:
+                IdxTemp = 0
+                pass
+
+        # Take RSSI
+        IdxTemp = 0
+        for j in xrange(Step*num_rssi_reading,len(RSSI_combine)):
+            RSSI_combine[j] = TestData[Step+1,IdxTemp]
+            IdxTemp = IdxTemp + 1
+            if IdxTemp == num_rssi_reading: # Reach the end
+                IdxTemp = 0
+
+    #########################################################
+    # AFter the buffer is full - Do the Test
+    # #######################################################  
+
+    CountArray = np.ones(timestep)
+    error = np.zeros(LengthTest-1)
+    # Predicted_array = np.zeros((LengthTest-1,2))
+    Average_Err = 0
+
+    for CountTest in xrange(LengthTest-timestep):
+        print("Location {}------------".format(CountTest))
+    # Update the Locations & RSSIs buffer
+        LocationIdx = 0
+        RSSIdx = 0
+        TestingData = np.zeros(len(L_combine)+len(RSSI_combine))
+        for i in xrange(timestep):
+            TestingData[LocationIdx] = L_combine[i*2]
+            TestingData[LocationIdx+1] = L_combine[i*2+1]
+            for j in xrange(len(RSSI_L2)):
+                TestingData[j+LocationIdx+2] = (float(RSSI_combine[j+RSSIdx])+100)/100
+            LocationIdx = LocationIdx + input_layer
+            RSSIdx = RSSIdx + num_rssi_reading
+
+        TestingData = TestingData.reshape(1,timestep,input_layer)
+        # print(TestingData)
+
+        # Prediction 
+        Predicted_L = model1.predict(TestingData)
+
+    # for t in xrange(timestep): 
+    #     File4.write(str(Predicted_L[0,t,0]) + ',') 
+    #     File4.write(str(Predicted_L[0,t,1])+ ',') # write to file
+    # File4.write('\n')
+
+        # Re-arrange Accumulated Location
+        for t in xrange(timestep-1): 
+            CountArray[t] = CountArray[t+1]
+            Acc_Location[t,:] = Acc_Location[t+1,:]+Predicted_L[0,t,:]
+            CountArray[t] = CountArray[t] + 1
+
+        Acc_Location[timestep-1,:] = Predicted_L[0,timestep-1,:] # Update new Location
+        CountArray[timestep-1] = 1 #Update New Count
+    # print(Acc_Location)
+    #  print(CountArray)  
+    ######################################################################
+    ############# UPDATE LOCATION ########################################
+    ######################################################################
+
+        Final_L = Acc_Location[0,:]/CountArray[0]
+        CountArray[0] = 1
+        # Take correct location, compare the result
+        Correct_L = Location[CountTest+1,:]
+        error[CountTest] = np.sqrt(np.power((Final_L[0] - Correct_L[0]),2)+np.power((Final_L[1] - Correct_L[1]),2))
+        print "Predict: {}--- Exact: {} , Error: {}" .format((Final_L[0], Final_L[1]), (Correct_L[0], Correct_L[1]), (error[CountTest]))
+        Average_Err = Average_Err + error[CountTest]
+
+        File1.write(str(error[CountTest]) + ' , ') # write to file
+    # File2.write(str(Final_L[0]) + ',') 
+    # File2.write(str(Final_L[1]) + '\n') # write to file
+        # Re-arrange L_combine
+        for t in xrange(timestep-1): 
+            L_combine[t*2] = L_combine[(t+1)*2]
+            L_combine[t*2+1] = L_combine[(t+1)*2+1] 
+        # Update 
+        L_combine[(timestep-1)*2] = Predicted_L[0,timestep-1,0] 
+        L_combine[(timestep-1)*2+1] = Predicted_L[0,timestep-1,1] 
+        # Re-arrange RSSI_combine
+        if CountTest+timestep+1 < LengthTest:
+            for t in xrange(timestep-1): 
+                for k in xrange(num_rssi_reading):
+                    RSSI_combine[t*num_rssi_reading+k] =  RSSI_combine[(t+1)*num_rssi_reading+k]
+
+            for k in xrange(num_rssi_reading):
+                RSSI_combine[(timestep-1)*num_rssi_reading+k] = TestData[CountTest+timestep+1,k]      
+
+    ###################################################################
+    ############### The Last Locations ###############################
+    ###################################################################
+    for i in xrange(timestep-1):
+        Final_L = Acc_Location[i+1,:]/CountArray[i+1]
+        # Take correct location, compare the result
+        Correct_L = Location[CountTest+1,:]
+        error[CountTest] = np.sqrt(np.power((Final_L[0] - Correct_L[0]),2)+np.power((Final_L[1] - Correct_L[1]),2))
+        print "Predict: {}--- Exact: {} , Error: {}" .format((Final_L[0], Final_L[1]), (Correct_L[0], Correct_L[1]),  error[CountTest])
+        Average_Err = Average_Err + error[CountTest]
+
+        File1.write(str(error[CountTest]) + ' , ') # write to file
+    #  File2.write(str(Final_L[0]) + ',') 
+    #  File2.write(str(Final_L[1]) + '\n') # write to file
+        CountTest = CountTest + 1
+
+    File1.write('\n')
+    Average_Err = Average_Err/(LengthTest-1)
+    print "Average Error: ", Average_Err
+
+    Std_Err = 0
+    for k in xrange(LengthTest-1):
+        Std_Err = Std_Err +  np.power((error[k] - Average_Err),2)
+    Std_Err = Std_Err/(LengthTest-1)
+    Std_Err = np.sqrt(Std_Err)
+    print "Std: ", Std_Err 
+
+#### Show Figure ######################
+#if epochs_num > 0:
+#    ResultPlot['neurons_500'] =  loss
+#    ResultPlot.plot()
+#    pyplot.show()
+
+File1.close()
+# File2.close()
+# File3.close()
+# File4.close()

BiSimpleRNN_Model_5_fold_1.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:84c621bf54df42e2856b57a719eee2265ec31b2e9ba895d6da40bbec8c1f2981
+size 143184

Bigru_Model_5_fold_1.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2d81c7a69381a5cb602afa5747f24937ee93f80cbcb249597849dfc016934332
+size 375952

Bilstm_Model_5_fold_1.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a6d7f11011febf6ae0b3b1f62e5d0160a56ce66e1bda68e7d806691060c2889c
+size 491368

GRU_Model_5_10fold.py

@@ -0,0 +1,389 @@
+#############################################################
+# 10 locations/ trajectory
+# First location is known
+# Date: 8 June 2018
+#############################################################
+
+import time
+import tensorflow
+# import lstm
+import os
+#import time
+import warnings
+import numpy as np
+from numpy import newaxis
+from keras.layers import TimeDistributed
+from keras.layers.core import Dense, Activation, Dropout
+from keras.layers.recurrent import GRU
+from keras.models import Sequential
+# import matplotlib.pyplot as plt
+from matplotlib import pyplot
+import pandas as pd
+import math
+from pandas import DataFrame
+from keras import backend as K
+
+def rmse(y_true, y_pred):
+        return K.sqrt(K.mean(K.square(y_pred - y_true), axis=-1))
+def err_absolute(y_true, y_pred):
+        err = K.sqrt(K.square(y_pred - y_true))
+        return err 
+
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' #Hide messy TensorFlow warnings
+warnings.filterwarnings("ignore") #Hide messy Numpy warnings
+
+# Open File to write results
+File1 = open('Error_GRU_10_fold.csv','w')
+# File2 = open('Traj_Model_5_DiffSpeed_2ms.csv','w') 
+# File3 = open('Loss_PredictedL_50k_NoFilter.csv','w') 
+# File4 = open('Output_PredictedL_50k_NoFilter.csv','w') 
+
+NumTotalTraj = 365000
+
+# Configure the sampling set -----------------
+epochs_num  = 500
+N_fold = 10 
+NumTrajTraining = 20000
+NumSam_PerTraj = 1
+StartingTraj = 0
+StartingSample = StartingTraj*NumSam_PerTraj # the factor of NumSam_PerTraj 
+NumSample = NumTrajTraining*NumSam_PerTraj # NumTraj = NumSample/NumSam_PerTraj
+
+# Configure the validation set -----------------
+NumTrajVal = 10000
+StartingTrajVal = 100000
+
+StartingValidation = StartingTrajVal*NumSam_PerTraj
+NumValidation = NumTrajVal*NumSam_PerTraj
+
+# Main Run Thread
+global_start_time = time.time()
+input_layer = 13 # X, Y & 11 MAC Addresses
+num_rssi_reading = 11
+output_layer = 2
+timestep = 9
+NumBatch = 512 #512
+hidden_layer1 = 100
+hidden_layer2 = 100
+
+##########################################################
+###### Test Trajectory Splitting #########################
+########################################################## 
+# Read Training data --------------------------------------------------
+print('> Loading data... ')
+df1=pd.read_csv('Input_Location_RSSI_10points_365k.csv')
+df1= np.asarray(df1)
+
+df2=pd.read_csv('Output_Location_RSSI_10points_365k.csv')
+df2= np.asarray(df2)
+
+########################################################################
+# Read Validation data --------------------------------------------------
+#######################################################################
+# df3= df1[StartingValidation:StartingValidation+NumValidation,:]
+# input_validation = df3.reshape(len(df3),timestep,input_layer)
+# print(input_validation.shape)
+
+# df4=df2[StartingValidation:StartingValidation+NumValidation,:]
+# output_validation = df4.reshape(len(df4),timestep,output_layer)
+# print(output_validation.shape)
+
+####################################################################
+# Testing data ------------------------
+####################################################################
+# RSSI array
+TestData_origin =pd.read_csv('Long_Traj_6July_v1_AverageFilter.csv')
+print(TestData_origin.shape)
+TestData_origin = np.asarray(TestData_origin)
+
+LengthTest = len(TestData_origin)
+StartTestIdx = 0
+StopTestIdx = StartTestIdx + LengthTest
+
+# print(TestData.shape)
+TestData = TestData_origin[StartTestIdx:StopTestIdx, :]
+# LengthTest = len(TestData)
+
+# List of Locations 
+Location_origin = pd.read_csv('Long_Traj_Location.csv')
+print(Location_origin.shape)
+Location_origin = np.asarray(Location_origin)
+Location = Location_origin[StartTestIdx:StopTestIdx, :]
+
+print('> Data Loaded. Compiling...')
+
+####################################################################
+# Init 9 first Location ###########################################
+####################################################################
+L1 = Location[0,:]
+L2 = Location[0,:]
+L3 = Location[0,:]
+L4 = Location[0,:]
+L5 = Location[0,:]
+L6 = Location[0,:]
+L7 = Location[0,:]
+L8 = Location[0,:]
+L9 = Location[0,:]
+
+# Take RSSI
+RSSI_L1 = TestData[0,:]
+RSSI_L2 = TestData[1,:] 
+RSSI_L3 = TestData[1,:]
+RSSI_L4 = TestData[1,:] 
+RSSI_L5 = TestData[1,:]
+RSSI_L6 = TestData[1,:] 
+RSSI_L7 = TestData[1,:]
+RSSI_L8 = TestData[1,:] 
+RSSI_L9 = TestData[1,:]
+RSSI_L10 = TestData[1,:]
+
+# Build the network  --------------------------------------------
+model1 = Sequential()
+model1.add(GRU(hidden_layer1, input_shape=(timestep, input_layer), return_sequences=True))
+model1.add(Dropout(0.2))
+model1.add(GRU(hidden_layer2,return_sequences=True))
+model1.add(Dropout(0.2))
+model1.add(TimeDistributed(Dense(output_layer)))
+model1.summary()
+start = time.time()
+model1.compile(loss="mse", optimizer="adam",metrics=[rmse])
+# model1.compile(loss=rmse, optimizer="adam",metrics=[err_absolute]) #rmse
+# root_mean_squared_error
+print("> Compilation Time : ", time.time() - start)
+
+# Training --------------------------------------------------------
+loss = list()
+ResultPlot = DataFrame()
+
+#### Create a copy of input training ##########################
+# input_training_org = input_training
+# input_validation_org = input_validation
+###############################################################
+# model1.load_weights("lstm_Model_5_DiffSpeed.h5")
+# StartingValidation = 0
+for CountFold in xrange(1, N_fold): 
+    # training samples -----------------------
+    StartingTraj = CountFold*NumTrajTraining
+    StartingSample = StartingTraj*NumSam_PerTraj # the factor of NumSam_PerTraj 
+    df1_split = df1[StartingSample:StartingSample+NumSample,:]
+    input_training = df1_split.reshape(len(df1_split),timestep,input_layer)
+    # print(input_training.shape)
+    input_training_org = input_training
+
+    df2_split = df2[StartingSample:StartingSample+NumSample,:]
+    output_training = df2_split.reshape(len(df2_split),timestep,output_layer)
+    # print(output_training.shape)
+
+    H5_Name = 'gru_Model_5_fold_'+ str(CountFold) + '.h5'
+    iTimeStep = 1
+    iTimeStep_val = 1
+    for ep in xrange(epochs_num):
+        print("Iteration {} ----- ".format(ep))
+
+        # Fit Model
+      #  hist = model1.fit(input_training,output_training, validation_data=(input_validation, output_validation), epochs=1, batch_size=NumBatch, verbose=1)
+        hist = model1.fit(input_training,output_training, epochs=1, batch_size=NumBatch, verbose=1, shuffle=False)
+        loss.append(hist.history['loss'][0])
+      #  File3.write(str(hist.history['loss'][0]) + '\n') #100 write to file
+
+        # Reform the input training ---------------------------------
+        print("Training Predict Sample {} ... ".format(iTimeStep))
+        Predicted_L_Training = model1.predict(input_training) 
+        # get the predicted locations to become the inputs of the next step
+        for iSample in xrange(0,len(df1_split)):
+            # First location: known
+            # Update predicted Location starting from the second location
+            input_training[iSample,iTimeStep,0] = Predicted_L_Training[iSample,iTimeStep-1,0]
+            input_training[iSample,iTimeStep,1] = Predicted_L_Training[iSample,iTimeStep-1,1]
+        iTimeStep = iTimeStep + 1 # Update for next time step
+
+        if iTimeStep == timestep:  # reset 1 round -------
+            input_training = input_training_org
+            iTimeStep = 1
+        # --------------------------------------------------------------------------------------
+
+        # Reform the validation set for testing -------------------------------------------------
+        # Input is updated by prediction
+        # Output: Ideal
+    #    print("Validation Predict ...")
+    #    Predicted_L_Validation = model1.predict(input_validation) 
+    #    for iSample in xrange(0,len(df3)):
+    #        input_validation[iSample,iTimeStep_val,0] = Predicted_L_Validation[iSample,iTimeStep_val-1,0]
+    #        input_validation[iSample,iTimeStep_val,1] = Predicted_L_Validation[iSample,iTimeStep_val-1,1]
+    #    iTimeStep_val = iTimeStep_val + 1        
+    #    print("TESTING...........")
+
+     #   if iTimeStep_val == timestep:  # reset 1 round -------
+    #        input_validation = input_validation_org
+     #       iTimeStep_val = 1
+         # ------------------------------------------------------------------------------------------
+         # Calculate the validation error ------------------------------------------------
+
+        # model1.fit(input_training,output_training, validation_split=0.2, epochs=epochs_num, batch_size=512)
+        model1.save_weights(H5_Name)
+    # print('Training duration (s) 100: ', time.time() - global_start_time)
+
+    # Testing --------------------------------------------------------- 
+    #########################################################
+    # The first 3 steps: Fill up the buffer
+    # #######################################################    
+    Acc_Location = np.zeros((timestep,2))
+    Acc_Location[0,:] = L1
+    L_combine = np.concatenate((L1,L2,L3,L4,L5,L6,L7,L8,L9), axis=0)
+    RSSI_combine = np.concatenate((RSSI_L2, RSSI_L3, RSSI_L4, RSSI_L5,RSSI_L6, RSSI_L7, RSSI_L8, RSSI_L9, RSSI_L10), axis=0)
+    
+    for Step in xrange(1,timestep):
+
+        # Update the Locations & RSSIs buffer
+        LocationIdx = 0
+        RSSIdx = 0
+        TestingData = np.zeros(len(L_combine)+len(RSSI_combine))
+        for i in xrange(timestep):
+            TestingData[LocationIdx] = L_combine[i*2]
+            TestingData[LocationIdx+1] = L_combine[i*2+1]
+            for j in xrange(len(RSSI_L2)):
+                TestingData[j+LocationIdx+2] = (float(RSSI_combine[j+RSSIdx])+100)/100
+            LocationIdx = LocationIdx + input_layer
+            RSSIdx = RSSIdx + num_rssi_reading
+            # print(TestingData)
+
+        TestingData = TestingData.reshape(1,timestep,input_layer)
+        # print(TestingData)
+
+        # Prediction 
+        Predicted_L = model1.predict(TestingData)
+        Acc_Location[Step,:] = Predicted_L[0,Step-1,:]
+        print(Acc_Location)
+
+        # Update for next step
+        # Init 4 first Location
+        IdxTemp = 0
+        # Update Location
+        for j in xrange(Step*2,len(L_combine)):
+            L_combine[j] = Acc_Location[Step,IdxTemp]
+            if IdxTemp == 0:
+                IdxTemp = 1
+            else:
+                IdxTemp = 0
+                pass
+
+        # Take RSSI
+        IdxTemp = 0
+        for j in xrange(Step*num_rssi_reading,len(RSSI_combine)):
+            RSSI_combine[j] = TestData[Step+1,IdxTemp]
+            IdxTemp = IdxTemp + 1
+            if IdxTemp == num_rssi_reading: # Reach the end
+                IdxTemp = 0
+
+    #########################################################
+    # AFter the buffer is full - Do the Test
+    # #######################################################  
+
+    CountArray = np.ones(timestep)
+    error = np.zeros(LengthTest-1)
+    # Predicted_array = np.zeros((LengthTest-1,2))
+    Average_Err = 0
+
+    for CountTest in xrange(LengthTest-timestep):
+        print("Location {}------------".format(CountTest))
+    # Update the Locations & RSSIs buffer
+        LocationIdx = 0
+        RSSIdx = 0
+        TestingData = np.zeros(len(L_combine)+len(RSSI_combine))
+        for i in xrange(timestep):
+            TestingData[LocationIdx] = L_combine[i*2]
+            TestingData[LocationIdx+1] = L_combine[i*2+1]
+            for j in xrange(len(RSSI_L2)):
+                TestingData[j+LocationIdx+2] = (float(RSSI_combine[j+RSSIdx])+100)/100
+            LocationIdx = LocationIdx + input_layer
+            RSSIdx = RSSIdx + num_rssi_reading
+
+        TestingData = TestingData.reshape(1,timestep,input_layer)
+        # print(TestingData)
+
+        # Prediction 
+        Predicted_L = model1.predict(TestingData)
+
+    # for t in xrange(timestep): 
+    #     File4.write(str(Predicted_L[0,t,0]) + ',') 
+    #     File4.write(str(Predicted_L[0,t,1])+ ',') # write to file
+    # File4.write('\n')
+
+        # Re-arrange Accumulated Location
+        for t in xrange(timestep-1): 
+            CountArray[t] = CountArray[t+1]
+            Acc_Location[t,:] = Acc_Location[t+1,:]+Predicted_L[0,t,:]
+            CountArray[t] = CountArray[t] + 1
+
+        Acc_Location[timestep-1,:] = Predicted_L[0,timestep-1,:] # Update new Location
+        CountArray[timestep-1] = 1 #Update New Count
+    # print(Acc_Location)
+    #  print(CountArray)  
+    ######################################################################
+    ############# UPDATE LOCATION ########################################
+    ######################################################################
+
+        Final_L = Acc_Location[0,:]/CountArray[0]
+        CountArray[0] = 1
+        # Take correct location, compare the result
+        Correct_L = Location[CountTest+1,:]
+        error[CountTest] = np.sqrt(np.power((Final_L[0] - Correct_L[0]),2)+np.power((Final_L[1] - Correct_L[1]),2))
+        print "Predict: {}--- Exact: {} , Error: {}" .format((Final_L[0], Final_L[1]), (Correct_L[0], Correct_L[1]), (error[CountTest]))
+        Average_Err = Average_Err + error[CountTest]
+
+        File1.write(str(error[CountTest]) + ' , ') # write to file
+    # File2.write(str(Final_L[0]) + ',') 
+    # File2.write(str(Final_L[1]) + '\n') # write to file
+        # Re-arrange L_combine
+        for t in xrange(timestep-1): 
+            L_combine[t*2] = L_combine[(t+1)*2]
+            L_combine[t*2+1] = L_combine[(t+1)*2+1] 
+        # Update 
+        L_combine[(timestep-1)*2] = Predicted_L[0,timestep-1,0] 
+        L_combine[(timestep-1)*2+1] = Predicted_L[0,timestep-1,1] 
+        # Re-arrange RSSI_combine
+        if CountTest+timestep+1 < LengthTest:
+            for t in xrange(timestep-1): 
+                for k in xrange(num_rssi_reading):
+                    RSSI_combine[t*num_rssi_reading+k] =  RSSI_combine[(t+1)*num_rssi_reading+k]
+
+            for k in xrange(num_rssi_reading):
+                RSSI_combine[(timestep-1)*num_rssi_reading+k] = TestData[CountTest+timestep+1,k]      
+
+    ###################################################################
+    ############### The Last Locations ###############################
+    ###################################################################
+    for i in xrange(timestep-1):
+        Final_L = Acc_Location[i+1,:]/CountArray[i+1]
+        # Take correct location, compare the result
+        Correct_L = Location[CountTest+1,:]
+        error[CountTest] = np.sqrt(np.power((Final_L[0] - Correct_L[0]),2)+np.power((Final_L[1] - Correct_L[1]),2))
+        print "Predict: {}--- Exact: {} , Error: {}" .format((Final_L[0], Final_L[1]), (Correct_L[0], Correct_L[1]),  error[CountTest])
+        Average_Err = Average_Err + error[CountTest]
+
+        File1.write(str(error[CountTest]) + ' , ') # write to file
+    #  File2.write(str(Final_L[0]) + ',') 
+    #  File2.write(str(Final_L[1]) + '\n') # write to file
+        CountTest = CountTest + 1
+
+    File1.write('\n')
+    Average_Err = Average_Err/(LengthTest-1)
+    print "Average Error: ", Average_Err
+
+    Std_Err = 0
+    for k in xrange(LengthTest-1):
+        Std_Err = Std_Err +  np.power((error[k] - Average_Err),2)
+    Std_Err = Std_Err/(LengthTest-1)
+    Std_Err = np.sqrt(Std_Err)
+    print "Std: ", Std_Err 
+
+#### Show Figure ######################
+#if epochs_num > 0:
+#    ResultPlot['neurons_500'] =  loss
+#    ResultPlot.plot()
+#    pyplot.show()
+
+File1.close()
+# File2.close()
+# File3.close()
+# File4.close()

LICENSE.md

@@ -0,0 +1,353 @@
+Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International
+
+Creative Commons Corporation ("Creative Commons") is not a law firm and
+does not provide legal services or legal advice. Distribution of
+Creative Commons public licenses does not create a lawyer-client or
+other relationship. Creative Commons makes its licenses and related
+information available on an "as-is" basis. Creative Commons gives no
+warranties regarding its licenses, any material licensed under their
+terms and conditions, or any related information. Creative Commons
+disclaims all liability for damages resulting from their use to the
+fullest extent possible.
+
+Using Creative Commons Public Licenses
+
+Creative Commons public licenses provide a standard set of terms and
+conditions that creators and other rights holders may use to share
+original works of authorship and other material subject to copyright and
+certain other rights specified in the public license below. The
+following considerations are for informational purposes only, are not
+exhaustive, and do not form part of our licenses.
+
+Considerations for licensors: Our public licenses are intended for use
+by those authorized to give the public permission to use material in
+ways otherwise restricted by copyright and certain other rights. Our
+licenses are irrevocable. Licensors should read and understand the terms
+and conditions of the license they choose before applying it. Licensors
+should also secure all rights necessary before applying our licenses so
+that the public can reuse the material as expected. Licensors should
+clearly mark any material not subject to the license. This includes
+other CC-licensed material, or material used under an exception or
+limitation to copyright. More considerations for licensors :
+wiki.creativecommons.org/Considerations_for_licensors
+
+Considerations for the public: By using one of our public licenses, a
+licensor grants the public permission to use the licensed material under
+specified terms and conditions. If the licensor's permission is not
+necessary for any reason–for example, because of any applicable
+exception or limitation to copyright–then that use is not regulated by
+the license. Our licenses grant only permissions under copyright and
+certain other rights that a licensor has authority to grant. Use of the
+licensed material may still be restricted for other reasons, including
+because others have copyright or other rights in the material. A
+licensor may make special requests, such as asking that all changes be
+marked or described. Although not required by our licenses, you are
+encouraged to respect those requests where reasonable. More
+considerations for the public :
+wiki.creativecommons.org/Considerations_for_licensees
+
+Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International
+Public License
+
+By exercising the Licensed Rights (defined below), You accept and agree
+to be bound by the terms and conditions of this Creative Commons
+Attribution-NonCommercial-ShareAlike 4.0 International Public License
+("Public License"). To the extent this Public License may be interpreted
+as a contract, You are granted the Licensed Rights in consideration of
+Your acceptance of these terms and conditions, and the Licensor grants
+You such rights in consideration of benefits the Licensor receives from
+making the Licensed Material available under these terms and conditions.
+
+Section 1 – Definitions.
+
+-   a. Adapted Material means material subject to Copyright and Similar
+    Rights that is derived from or based upon the Licensed Material and
+    in which the Licensed Material is translated, altered, arranged,
+    transformed, or otherwise modified in a manner requiring permission
+    under the Copyright and Similar Rights held by the Licensor. For
+    purposes of this Public License, where the Licensed Material is a
+    musical work, performance, or sound recording, Adapted Material is
+    always produced where the Licensed Material is synched in timed
+    relation with a moving image.
+-   b. Adapter's License means the license You apply to Your Copyright
+    and Similar Rights in Your contributions to Adapted Material in
+    accordance with the terms and conditions of this Public License.
+-   c. BY-NC-SA Compatible License means a license listed at
+    creativecommons.org/compatiblelicenses, approved by Creative Commons
+    as essentially the equivalent of this Public License.
+-   d. Copyright and Similar Rights means copyright and/or similar
+    rights closely related to copyright including, without limitation,
+    performance, broadcast, sound recording, and Sui Generis Database
+    Rights, without regard to how the rights are labeled or categorized.
+    For purposes of this Public License, the rights specified in Section
+    2(b)(1)-(2) are not Copyright and Similar Rights.
+-   e. Effective Technological Measures means those measures that, in
+    the absence of proper authority, may not be circumvented under laws
+    fulfilling obligations under Article 11 of the WIPO Copyright Treaty
+    adopted on December 20, 1996, and/or similar international
+    agreements.
+-   f. Exceptions and Limitations means fair use, fair dealing, and/or
+    any other exception or limitation to Copyright and Similar Rights
+    that applies to Your use of the Licensed Material.
+-   g. License Elements means the license attributes listed in the name
+    of a Creative Commons Public License. The License Elements of this
+    Public License are Attribution, NonCommercial, and ShareAlike.
+-   h. Licensed Material means the artistic or literary work, database,
+    or other material to which the Licensor applied this Public License.
+-   i. Licensed Rights means the rights granted to You subject to the
+    terms and conditions of this Public License, which are limited to
+    all Copyright and Similar Rights that apply to Your use of the
+    Licensed Material and that the Licensor has authority to license.
+-   j. Licensor means the individual(s) or entity(ies) granting rights
+    under this Public License.
+-   k. NonCommercial means not primarily intended for or directed
+    towards commercial advantage or monetary compensation. For purposes
+    of this Public License, the exchange of the Licensed Material for
+    other material subject to Copyright and Similar Rights by digital
+    file-sharing or similar means is NonCommercial provided there is no
+    payment of monetary compensation in connection with the exchange.
+-   l. Share means to provide material to the public by any means or
+    process that requires permission under the Licensed Rights, such as
+    reproduction, public display, public performance, distribution,
+    dissemination, communication, or importation, and to make material
+    available to the public including in ways that members of the public
+    may access the material from a place and at a time individually
+    chosen by them.
+-   m. Sui Generis Database Rights means rights other than copyright
+    resulting from Directive 96/9/EC of the European Parliament and of
+    the Council of 11 March 1996 on the legal protection of databases,
+    as amended and/or succeeded, as well as other essentially equivalent
+    rights anywhere in the world.
+-   n. You means the individual or entity exercising the Licensed Rights
+    under this Public License. Your has a corresponding meaning.
+
+Section 2 – Scope.
+
+-   a. License grant.
+    -   1. Subject to the terms and conditions of this Public License,
+        the Licensor hereby grants You a worldwide, royalty-free,
+        non-sublicensable, non-exclusive, irrevocable license to
+        exercise the Licensed Rights in the Licensed Material to:
+        -   A. reproduce and Share the Licensed Material, in whole or in
+            part, for NonCommercial purposes only; and
+        -   B. produce, reproduce, and Share Adapted Material for
+            NonCommercial purposes only.
+    -   2. Exceptions and Limitations. For the avoidance of doubt, where
+        Exceptions and Limitations apply to Your use, this Public
+        License does not apply, and You do not need to comply with its
+        terms and conditions.
+    -   3. Term. The term of this Public License is specified in Section
+        6(a).
+    -   4. Media and formats; technical modifications allowed. The
+        Licensor authorizes You to exercise the Licensed Rights in all
+        media and formats whether now known or hereafter created, and to
+        make technical modifications necessary to do so. The Licensor
+        waives and/or agrees not to assert any right or authority to
+        forbid You from making technical modifications necessary to
+        exercise the Licensed Rights, including technical modifications
+        necessary to circumvent Effective Technological Measures. For
+        purposes of this Public License, simply making modifications
+        authorized by this Section 2(a)(4) never produces Adapted
+        Material.
+    -   5. Downstream recipients.
+        -   A. Offer from the Licensor – Licensed Material. Every
+            recipient of the Licensed Material automatically receives an
+            offer from the Licensor to exercise the Licensed Rights
+            under the terms and conditions of this Public License.
+        -   B. Additional offer from the Licensor – Adapted Material.
+            Every recipient of Adapted Material from You automatically
+            receives an offer from the Licensor to exercise the Licensed
+            Rights in the Adapted Material under the conditions of the
+            Adapter's License You apply.
+        -   C. No downstream restrictions. You may not offer or impose
+            any additional or different terms or conditions on, or apply
+            any Effective Technological Measures to, the Licensed
+            Material if doing so restricts exercise of the Licensed
+            Rights by any recipient of the Licensed Material.
+    -   6. No endorsement. Nothing in this Public License constitutes or
+        may be construed as permission to assert or imply that You are,
+        or that Your use of the Licensed Material is, connected with, or
+        sponsored, endorsed, or granted official status by, the Licensor
+        or others designated to receive attribution as provided in
+        Section 3(a)(1)(A)(i).
+-   b. Other rights.
+    -   1. Moral rights, such as the right of integrity, are not
+        licensed under this Public License, nor are publicity, privacy,
+        and/or other similar personality rights; however, to the extent
+        possible, the Licensor waives and/or agrees not to assert any
+        such rights held by the Licensor to the limited extent necessary
+        to allow You to exercise the Licensed Rights, but not otherwise.
+    -   2. Patent and trademark rights are not licensed under this
+        Public License.
+    -   3. To the extent possible, the Licensor waives any right to
+        collect royalties from You for the exercise of the Licensed
+        Rights, whether directly or through a collecting society under
+        any voluntary or waivable statutory or compulsory licensing
+        scheme. In all other cases the Licensor expressly reserves any
+        right to collect such royalties, including when the Licensed
+        Material is used other than for NonCommercial purposes.
+
+Section 3 – License Conditions.
+
+Your exercise of the Licensed Rights is expressly made subject to the
+following conditions.
+
+-   a. Attribution.
+    -   1. If You Share the Licensed Material (including in modified
+        form), You must:
+        -   A. retain the following if it is supplied by the Licensor
+            with the Licensed Material:
+            -   i. identification of the creator(s) of the Licensed
+                Material and any others designated to receive
+                attribution, in any reasonable manner requested by the
+                Licensor (including by pseudonym if designated);
+            -   ii. a copyright notice;
+            -   iii. a notice that refers to this Public License;
+            -   iv. a notice that refers to the disclaimer of
+                warranties;
+            -   v. a URI or hyperlink to the Licensed Material to the
+                extent reasonably practicable;
+
+        -   B. indicate if You modified the Licensed Material and retain
+            an indication of any previous modifications; and
+        -   C. indicate the Licensed Material is licensed under this
+            Public License, and include the text of, or the URI or
+            hyperlink to, this Public License.
+    -   2. You may satisfy the conditions in Section 3(a)(1) in any
+        reasonable manner based on the medium, means, and context in
+        which You Share the Licensed Material. For example, it may be
+        reasonable to satisfy the conditions by providing a URI or
+        hyperlink to a resource that includes the required information.
+    -   3. If requested by the Licensor, You must remove any of the
+        information required by Section 3(a)(1)(A) to the extent
+        reasonably practicable.
+-   b. ShareAlike.In addition to the conditions in Section 3(a), if You
+    Share Adapted Material You produce, the following conditions also
+    apply.
+    -   1. The Adapter's License You apply must be a Creative Commons
+        license with the same License Elements, this version or later,
+        or a BY-NC-SA Compatible License.
+    -   2. You must include the text of, or the URI or hyperlink to, the
+        Adapter's License You apply. You may satisfy this condition in
+        any reasonable manner based on the medium, means, and context in
+        which You Share Adapted Material.
+    -   3. You may not offer or impose any additional or different terms
+        or conditions on, or apply any Effective Technological Measures
+        to, Adapted Material that restrict exercise of the rights
+        granted under the Adapter's License You apply.
+
+Section 4 – Sui Generis Database Rights.
+
+Where the Licensed Rights include Sui Generis Database Rights that apply
+to Your use of the Licensed Material:
+
+-   a. for the avoidance of doubt, Section 2(a)(1) grants You the right
+    to extract, reuse, reproduce, and Share all or a substantial portion
+    of the contents of the database for NonCommercial purposes only;
+-   b. if You include all or a substantial portion of the database
+    contents in a database in which You have Sui Generis Database
+    Rights, then the database in which You have Sui Generis Database
+    Rights (but not its individual contents) is Adapted Material,
+    including for purposes of Section 3(b); and
+-   c. You must comply with the conditions in Section 3(a) if You Share
+    all or a substantial portion of the contents of the database.
+    For the avoidance of doubt, this Section 4 supplements and does not
+    replace Your obligations under this Public License where the
+    Licensed Rights include other Copyright and Similar Rights.
+
+Section 5 – Disclaimer of Warranties and Limitation of Liability.
+
+-   a. Unless otherwise separately undertaken by the Licensor, to the
+    extent possible, the Licensor offers the Licensed Material as-is and
+    as-available, and makes no representations or warranties of any kind
+    concerning the Licensed Material, whether express, implied,
+    statutory, or other. This includes, without limitation, warranties
+    of title, merchantability, fitness for a particular purpose,
+    non-infringement, absence of latent or other defects, accuracy, or
+    the presence or absence of errors, whether or not known or
+    discoverable. Where disclaimers of warranties are not allowed in
+    full or in part, this disclaimer may not apply to You.
+-   b. To the extent possible, in no event will the Licensor be liable
+    to You on any legal theory (including, without limitation,
+    negligence) or otherwise for any direct, special, indirect,
+    incidental, consequential, punitive, exemplary, or other losses,
+    costs, expenses, or damages arising out of this Public License or
+    use of the Licensed Material, even if the Licensor has been advised
+    of the possibility of such losses, costs, expenses, or damages.
+    Where a limitation of liability is not allowed in full or in part,
+    this limitation may not apply to You.
+-   c. The disclaimer of warranties and limitation of liability provided
+    above shall be interpreted in a manner that, to the extent possible,
+    most closely approximates an absolute disclaimer and waiver of all
+    liability.
+
+Section 6 – Term and Termination.
+
+-   a. This Public License applies for the term of the Copyright and
+    Similar Rights licensed here. However, if You fail to comply with
+    this Public License, then Your rights under this Public License
+    terminate automatically.
+-   b. Where Your right to use the Licensed Material has terminated
+    under Section 6(a), it reinstates:
+
+    -   1. automatically as of the date the violation is cured, provided
+        it is cured within 30 days of Your discovery of the violation;
+        or
+    -   2. upon express reinstatement by the Licensor.
+
+    For the avoidance of doubt, this Section 6(b) does not affect any
+    right the Licensor may have to seek remedies for Your violations of
+    this Public License.
+
+-   c. For the avoidance of doubt, the Licensor may also offer the
+    Licensed Material under separate terms or conditions or stop
+    distributing the Licensed Material at any time; however, doing so
+    will not terminate this Public License.
+-   d. Sections 1, 5, 6, 7, and 8 survive termination of this Public
+    License.
+
+Section 7 – Other Terms and Conditions.
+
+-   a. The Licensor shall not be bound by any additional or different
+    terms or conditions communicated by You unless expressly agreed.
+-   b. Any arrangements, understandings, or agreements regarding the
+    Licensed Material not stated herein are separate from and
+    independent of the terms and conditions of this Public License.
+
+Section 8 – Interpretation.
+
+-   a. For the avoidance of doubt, this Public License does not, and
+    shall not be interpreted to, reduce, limit, restrict, or impose
+    conditions on any use of the Licensed Material that could lawfully
+    be made without permission under this Public License.
+-   b. To the extent possible, if any provision of this Public License
+    is deemed unenforceable, it shall be automatically reformed to the
+    minimum extent necessary to make it enforceable. If the provision
+    cannot be reformed, it shall be severed from this Public License
+    without affecting the enforceability of the remaining terms and
+    conditions.
+-   c. No term or condition of this Public License will be waived and no
+    failure to comply consented to unless expressly agreed to by the
+    Licensor.
+-   d. Nothing in this Public License constitutes or may be interpreted
+    as a limitation upon, or waiver of, any privileges and immunities
+    that apply to the Licensor or You, including from the legal
+    processes of any jurisdiction or authority.
+
+Creative Commons is not a party to its public licenses. Notwithstanding,
+Creative Commons may elect to apply one of its public licenses to
+material it publishes and in those instances will be considered the
+"Licensor." The text of the Creative Commons public licenses is
+dedicated to the public domain under the CC0 Public Domain Dedication.
+Except for the limited purpose of indicating that material is shared
+under a Creative Commons public license or as otherwise permitted by the
+Creative Commons policies published at creativecommons.org/policies,
+Creative Commons does not authorize the use of the trademark "Creative
+Commons" or any other trademark or logo of Creative Commons without its
+prior written consent including, without limitation, in connection with
+any unauthorized modifications to any of its public licenses or any
+other arrangements, understandings, or agreements concerning use of
+licensed material. For the avoidance of doubt, this paragraph does not
+form part of the public licenses.
+
+Creative Commons may be contacted at creativecommons.org.

LSTM_Model_1.py

@@ -0,0 +1,296 @@
+#############################################################
+# 10 locations/ trajectory
+# First location is known
+# Date: 8 June 2018
+#############################################################
+
+import time
+import tensorflow
+# import lstm
+import os
+#import time
+import warnings
+import numpy as np
+from numpy import newaxis
+from keras.layers import TimeDistributed
+from keras.layers.core import Dense, Activation, Dropout
+from keras.layers.recurrent import LSTM
+from keras.models import Sequential
+# import matplotlib.pyplot as plt
+from matplotlib import pyplot
+import pandas as pd
+import math
+from pandas import DataFrame
+from keras import backend as K
+
+def rmse(y_true, y_pred):
+        return K.sqrt(K.mean(K.square(y_pred - y_true), axis=-1))
+def err_absolute(y_true, y_pred):
+        err = K.sqrt(K.square(y_pred - y_true))
+        return err 
+
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' #Hide messy TensorFlow warnings
+warnings.filterwarnings("ignore") #Hide messy Numpy warnings
+
+# Open File to write results
+File1 = open('Error_Model1_NoFilter.csv','w')
+File2 = open('Traj_Model1_NoFilter.csv','w') 
+# File3 = open('Loss_PredictedL_50k_NoFilter.csv','w') 
+# File4 = open('Output_PredictedL_50k_NoFilter.csv','w') 
+
+NumTotalTraj = 120000
+
+# Configure the sampling set -----------------
+epochs_num  = 0
+NumTrajTraining = 20000
+NumSam_PerTraj = 1
+StartingTraj = 0
+StartingSample = StartingTraj*NumSam_PerTraj # the factor of NumSam_PerTraj 
+NumSample = NumTrajTraining*NumSam_PerTraj # NumTraj = NumSample/NumSam_PerTraj
+
+# Configure the validation set -----------------
+NumTrajVal = 10000
+StartingTrajVal = 100000
+
+StartingValidation = StartingTrajVal*NumSam_PerTraj
+NumValidation = NumTrajVal*NumSam_PerTraj
+
+# Main Run Thread
+global_start_time = time.time()
+num_rssi_reading = 11
+output_layer = 2
+timestep = 10
+input_layer = num_rssi_reading*timestep # X, Y & 11 MAC Addresses
+NumBatch = 256
+hidden_layer1 = 100
+hidden_layer2 = 100
+
+##########################################################
+###### Test Trajectory Splitting #########################
+########################################################## 
+# Read Training data -------5-------------------------------------------
+print('> Loading data... ')
+filename = os.path.join(fileDir, '../RSSI_6AP_Experiments/Nexus4_Data/InputRNN_10points_120k_RSSI.csv')
+filename = os.path.abspath(os.path.realpath(filename))
+df1=pd.read_csv(filename)
+df1= np.asarray(df1)
+df1_split = df1[StartingSample:StartingSample+NumSample,:]
+input_training = df1_split.reshape(len(df1_split),1,input_layer)
+print(input_training.shape)
+
+filename = os.path.join(fileDir, '../RSSI_6AP_Experiments/Nexus4_Data/Output_10point_RSSI_Model1.csv')
+filename = os.path.abspath(os.path.realpath(filename))
+df2=pd.read_csv(filename)
+df2= np.asarray(df2)
+df2_split = df2[StartingSample:StartingSample+NumSample,:]
+output_training = df2_split.reshape(len(df2_split),1,output_layer)
+print(output_training.shape)
+
+########################################################################
+# Read Validation data --------------------------------------------------
+#######################################################################
+df3= df1[StartingValidation:StartingValidation+NumValidation,:]
+input_validation = df3.reshape(len(df3),1,input_layer)
+print(input_validation.shape)
+
+df4=df2[StartingValidation:StartingValidation+NumValidation,:]
+output_validation = df4.reshape(len(df4),1,output_layer)
+print(output_validation.shape)
+
+####################################################################
+# Testing data ------------------------
+####################################################################
+# RSSI array
+filename = os.path.join(fileDir, '../RSSI_6AP_Experiments/Nexus4_Data/Long_Traj_6July_v1.csv')
+filename = os.path.abspath(os.path.realpath(filename))
+TestData_origin =pd.read_csv(filename)
+print(TestData_origin.shape)
+TestData_origin = np.asarray(TestData_origin)
+
+LengthTest = len(TestData_origin)
+StartTestIdx = 0
+StopTestIdx = StartTestIdx + LengthTest
+
+# print(TestData.shape)
+TestData = TestData_origin[StartTestIdx:StopTestIdx, :]
+# LengthTest = len(TestData)
+
+# List of Locations 
+filename = os.path.join(fileDir, '../RSSI_6AP_Experiments/Nexus4_Data/Long_Traj_Location.csv')
+filename = os.path.abspath(os.path.realpath(filename))
+Location_origin = pd.read_csv(filename)
+print(Location_origin.shape)
+Location_origin = np.asarray(Location_origin)
+Location = Location_origin[StartTestIdx:StopTestIdx, :]
+
+print('> Data Loaded. Compiling...')
+
+####################################################################
+# Init 9 first Location ###########################################
+####################################################################
+L1 = Location[0,:]
+L2 = Location[0,:]
+L3 = Location[0,:]
+L4 = Location[0,:]
+L5 = Location[0,:]
+L6 = Location[0,:]
+L7 = Location[0,:]
+L8 = Location[0,:]
+L9 = Location[0,:]
+L_combine = np.concatenate((L1,L2,L3,L4,L5,L6,L7,L8,L9), axis=0)
+
+# Take RSSI
+RSSI_L1 = TestData[0,:]
+RSSI_L2 = TestData[1,:] 
+RSSI_L3 = TestData[1,:]
+RSSI_L4 = TestData[1,:] 
+RSSI_L5 = TestData[1,:]
+RSSI_L6 = TestData[1,:] 
+RSSI_L7 = TestData[1,:]
+RSSI_L8 = TestData[1,:] 
+RSSI_L9 = TestData[1,:]
+RSSI_L10 = TestData[1,:]
+RSSI_combine = np.concatenate((RSSI_L1, RSSI_L2, RSSI_L3, RSSI_L4, RSSI_L5,RSSI_L6, RSSI_L7, RSSI_L8, RSSI_L9, RSSI_L10), axis=0)
+
+# Build the network  --------------------------------------------
+model1 = Sequential()
+model1.add(LSTM(hidden_layer1, input_shape=(1, input_layer), return_sequences=True))
+model1.add(Dropout(0.2))
+model1.add(LSTM(hidden_layer2,return_sequences=True))
+model1.add(Dropout(0.2))
+model1.add(TimeDistributed(Dense(output_layer)))
+model1.summary()
+start = time.time()
+model1.compile(loss="mse", optimizer="adam",metrics=[rmse])
+# model1.compile(loss=rmse, optimizer="adam",metrics=[err_absolute]) #rmse
+# root_mean_squared_error
+print("> Compilation Time : ", time.time() - start)
+
+# Training --------------------------------------------------------
+loss = list()
+ResultPlot = DataFrame()
+
+#### Create a copy of input training ##########################
+input_training_org = input_training
+input_validation_org = input_validation
+###############################################################
+model1.load_weights("lstm_20k_model1.h5")
+StartingValidation = 0
+if epochs_num > 0:
+ #   iTimeStep = 1
+  #  iTimeStep_val = 1
+    for ep in xrange(epochs_num):
+        print("Iteration {} ----- ".format(ep))
+
+        # Fit Model
+      #  hist = model1.fit(input_training,output_training, validation_data=(input_validation, output_validation), epochs=1, batch_size=NumBatch, verbose=1)
+        hist = model1.fit(input_training,output_training, epochs=1, batch_size=NumBatch, verbose=1)
+        loss.append(hist.history['loss'][0])
+
+        # model1.fit(input_training,output_training, validation_split=0.2, epochs=epochs_num, batch_size=512)
+        model1.save_weights("lstm_20k_model1.h5")
+    print('Training duration (s) : ', time.time() - global_start_time)
+else:
+    print("TESTING...........")
+    pass
+
+# Testing --------------------------------------------------------- 
+#########################################################
+# The first steps: Fill up the buffer
+# #######################################################
+CountTest = 0
+Average_Err = 0 
+error = np.zeros(LengthTest)
+
+for Step in xrange(timestep):
+    print("Location {}------------".format(CountTest))
+    # Update the Locations & RSSIs buffer
+    RSSIdx = 0
+    TestingData = np.zeros(len(RSSI_combine))
+    for i in xrange(timestep):
+        for j in xrange(len(RSSI_L2)): # Repeat the first location
+            TestingData[j+RSSIdx] = (float(RSSI_combine[j+RSSIdx])+100)/100
+        RSSIdx = RSSIdx + num_rssi_reading
+
+    TestingData = TestingData.reshape(1,1,input_layer)
+    # Prediction 
+    Predicted_L = model1.predict(TestingData)   
+    Final_L = Predicted_L[0,0,:]  
+   # print(Final_L)
+
+    Correct_L = Location[CountTest,:]
+    error[CountTest] = np.sqrt(np.power((Final_L[0] - Correct_L[0]),2)+np.power((Final_L[1] - Correct_L[1]),2))
+    print "Predict: {}--- Exact: {} , Error: {}" .format((Final_L[0], Final_L[1]), (Correct_L[0], Correct_L[1]), (error[CountTest]))
+    Average_Err = Average_Err + error[CountTest]
+    CountTest = CountTest + 1
+
+    # Take RSSI
+    IdxTemp = 0
+    for j in xrange(Step*num_rssi_reading,len(RSSI_combine)):
+        RSSI_combine[j] = TestData[Step+1,IdxTemp]
+        IdxTemp = IdxTemp + 1
+        if IdxTemp == num_rssi_reading: # Reach the end
+            IdxTemp = 0
+
+#########################################################
+# AFter the buffer is full -
+# #######################################################  
+
+while CountTest < LengthTest-1:
+    print("Location {}------------".format(CountTest))
+# Update the Locations & RSSIs buffer
+    RSSIdx = 0
+    TestingData = np.zeros(len(RSSI_combine))
+    for i in xrange(timestep):
+        for j in xrange(len(RSSI_L2)):
+            TestingData[j+RSSIdx] = (float(RSSI_combine[j+RSSIdx])+100)/100
+        RSSIdx = RSSIdx + num_rssi_reading
+
+    TestingData = TestingData.reshape(1,1,input_layer)
+
+    # Prediction 
+    Predicted_L = model1.predict(TestingData)   
+    Final_L = Predicted_L[0,0,:]   
+    
+    Correct_L = Location[CountTest,:]
+    error[CountTest] = np.sqrt(np.power((Final_L[0] - Correct_L[0]),2)+np.power((Final_L[1] - Correct_L[1]),2))
+    print "Predict: {}--- Exact: {} , Error: {}" .format((Final_L[0], Final_L[1]), (Correct_L[0], Correct_L[1]), (error[CountTest]))
+    Average_Err = Average_Err + error[CountTest]
+
+    File1.write(str(error[CountTest]) + ' , ') # write to file
+    File2.write(str(Final_L[0]) + ',') 
+    File2.write(str(Final_L[1]) + '\n') # write to file
+
+    # Re-arrange RSSI_combine
+    for t in xrange(timestep-1): 
+        for k in xrange(num_rssi_reading):
+            RSSI_combine[t*num_rssi_reading+k] =  RSSI_combine[(t+1)*num_rssi_reading+k]
+
+    for k in xrange(num_rssi_reading):
+        RSSI_combine[(timestep-1)*num_rssi_reading+k] = TestData[CountTest+1,k]      
+
+    CountTest = CountTest + 1 
+###################################################################
+############### The Last Locations ###############################
+###################################################################
+
+Average_Err = Average_Err/LengthTest
+print "Average Error: ", Average_Err
+
+Std_Err = 0
+for k in xrange(LengthTest):
+    Std_Err = Std_Err +  np.power((error[k] - Average_Err),2)
+Std_Err = Std_Err/(LengthTest-1)
+Std_Err = np.sqrt(Std_Err)
+print "Std: ", Std_Err 
+
+#### Show Figure ######################
+#if epochs_num > 0:
+#    ResultPlot['neurons_500'] =  loss
+#    ResultPlot.plot()
+#    pyplot.show()
+
+File1.close()
+File2.close()
+# File3.close()
+# File4.close()

LSTM_Model_2.py

@@ -0,0 +1,325 @@
+#############################################################
+# 10 locations/ trajectory
+# First location is known
+# Date: 8 June 2018
+#############################################################
+
+import time
+import tensorflow
+# import lstm
+import os
+#import time
+import warnings
+import numpy as np
+from numpy import newaxis
+from keras.layers import TimeDistributed
+from keras.layers.core import Dense, Activation, Dropout
+from keras.layers.recurrent import LSTM
+from keras.models import Sequential
+# import matplotlib.pyplot as plt
+from matplotlib import pyplot
+import pandas as pd
+import math
+from pandas import DataFrame
+from keras import backend as K
+
+def rmse(y_true, y_pred):
+        return K.sqrt(K.mean(K.square(y_pred - y_true), axis=-1))
+def err_absolute(y_true, y_pred):
+        err = K.sqrt(K.square(y_pred - y_true))
+        return err 
+
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' #Hide messy TensorFlow warnings
+warnings.filterwarnings("ignore") #Hide messy Numpy warnings
+
+# Open File to write results
+File1 = open('Error_Model2.csv','w')
+File2 = open('Traj_Model2.csv','w') 
+# File3 = open('Loss_PredictedL_50k_NoFilter.csv','w') 
+# File4 = open('Output_PredictedL_50k_NoFilter.csv','w') 
+
+NumTotalTraj = 120000
+
+# Configure the sampling set -----------------
+epochs_num  = 300
+NumTrajTraining = 40000
+NumSam_PerTraj = 1
+StartingTraj = 30000
+StartingSample = StartingTraj*NumSam_PerTraj # the factor of NumSam_PerTraj 
+NumSample = NumTrajTraining*NumSam_PerTraj # NumTraj = NumSample/NumSam_PerTraj
+
+# Configure the validation set -----------------
+NumTrajVal = 10000
+StartingTrajVal = 100000
+
+StartingValidation = StartingTrajVal*NumSam_PerTraj
+NumValidation = NumTrajVal*NumSam_PerTraj
+
+# Main Run Thread
+global_start_time = time.time()
+num_rssi_reading = 11
+num_out_location = 2
+output_layer = 2
+timestep = 9
+input_layer = (num_rssi_reading + num_out_location)*timestep # X, Y & 11 MAC Addresses
+NumBatch = 256
+hidden_layer1 = 100
+hidden_layer2 = 100
+
+##########################################################
+###### Test Trajectory Splitting #########################
+########################################################## 
+# Read Training data -------5-------------------------------------------
+print('> Loading data... ')
+filename = os.path.join(fileDir, '../RSSI_6AP_Experiments/Nexus4_Data/Input_Location_RSSI_10points_365k.csv')
+filename = os.path.abspath(os.path.realpath(filename))
+df1=pd.read_csv(filename)
+df1= np.asarray(df1)
+df1_split = df1[StartingSample:StartingSample+NumSample,:]
+input_training = df1_split.reshape(len(df1_split),1,input_layer)
+print(input_training.shape)
+
+filename = os.path.join(fileDir, '../RSSI_6AP_Experiments/Nexus4_Data/Output_Location_RSSI_10points_365k_Model2.csv')
+filename = os.path.abspath(os.path.realpath(filename))
+df2=pd.read_csv(filename)
+df2= np.asarray(df2)
+df2_split = df2[StartingSample:StartingSample+NumSample,:]
+output_training = df2_split.reshape(len(df2_split),1,output_layer)
+print(output_training.shape)
+
+########################################################################
+# Read Validation data --------------------------------------------------
+#######################################################################
+df3= df1[StartingValidation:StartingValidation+NumValidation,:]
+input_validation = df3.reshape(len(df3),1,input_layer)
+print(input_validation.shape)
+
+df4=df2[StartingValidation:StartingValidation+NumValidation,:]
+output_validation = df4.reshape(len(df4),1,output_layer)
+print(output_validation.shape)
+
+####################################################################
+# Testing data ------------------------
+####################################################################
+# RSSI array
+filename = os.path.join(fileDir, '../RSSI_6AP_Experiments/Nexus4_Data/Long_Traj_6July_v1_AverageFilter.csv')
+filename = os.path.abspath(os.path.realpath(filename))
+TestData_origin =pd.read_csv(filename)
+print(TestData_origin.shape)
+TestData_origin = np.asarray(TestData_origin)
+
+LengthTest = len(TestData_origin)
+StartTestIdx = 0
+StopTestIdx = StartTestIdx + LengthTest
+
+# print(TestData.shape)
+TestData = TestData_origin[StartTestIdx:StopTestIdx, :]
+# LengthTest = len(TestData)
+
+# List of Locations 
+filename = os.path.join(fileDir, '../RSSI_6AP_Experiments/Nexus4_Data/Long_Traj_Location.csv')
+filename = os.path.abspath(os.path.realpath(filename))
+Location_origin = pd.read_csv(filename)
+print(Location_origin.shape)
+Location_origin = np.asarray(Location_origin)
+Location = Location_origin[StartTestIdx:StopTestIdx, :]
+
+print('> Data Loaded. Compiling...')
+
+####################################################################
+# Init 9 first Location ###########################################
+####################################################################
+L1 = Location[0,:]
+L2 = Location[0,:]
+L3 = Location[0,:]
+L4 = Location[0,:]
+L5 = Location[0,:]
+L6 = Location[0,:]
+L7 = Location[0,:]
+L8 = Location[0,:]
+L9 = Location[0,:]
+L10 = Location[0,:]
+L_combine = np.concatenate((L1,L2,L3,L4,L5,L6,L7,L8,L9), axis=0)
+
+# Take RSSI
+RSSI_L1 = TestData[0,:]
+RSSI_L2 = TestData[1,:] 
+RSSI_L3 = TestData[1,:]
+RSSI_L4 = TestData[1,:] 
+RSSI_L5 = TestData[1,:]
+RSSI_L6 = TestData[1,:] 
+RSSI_L7 = TestData[1,:]
+RSSI_L8 = TestData[1,:] 
+RSSI_L9 = TestData[1,:]
+RSSI_L10 = TestData[1,:]
+RSSI_combine = np.concatenate((RSSI_L2, RSSI_L3, RSSI_L4, RSSI_L5,RSSI_L6, RSSI_L7, RSSI_L8, RSSI_L9, RSSI_L10), axis=0)
+
+# Build the network  --------------------------------------------
+model1 = Sequential()
+model1.add(LSTM(hidden_layer1, input_shape=(1, input_layer), return_sequences=True))
+model1.add(Dropout(0.2))
+model1.add(LSTM(hidden_layer2,return_sequences=True))
+model1.add(Dropout(0.2))
+model1.add(TimeDistributed(Dense(output_layer)))
+model1.summary()
+start = time.time()
+model1.compile(loss="mse", optimizer="adam",metrics=[rmse])
+# model1.compile(loss=rmse, optimizer="adam",metrics=[err_absolute]) #rmse
+# root_mean_squared_error
+print("> Compilation Time : ", time.time() - start)
+
+# Training --------------------------------------------------------
+loss = list()
+ResultPlot = DataFrame()
+
+#### Create a copy of input training ##########################
+input_training_org = input_training
+input_validation_org = input_validation
+###############################################################
+model1.load_weights("lstm_20k_model2.h5")
+StartingValidation = 0
+if epochs_num > 0:
+ #   iTimeStep = 1
+  #  iTimeStep_val = 1
+    for ep in xrange(epochs_num):
+        print("Iteration {} ----- ".format(ep))
+
+        # Fit Model
+      #  hist = model1.fit(input_training,output_training, validation_data=(input_validation, output_validation), epochs=1, batch_size=NumBatch, verbose=1)
+        hist = model1.fit(input_training,output_training, epochs=1, batch_size=NumBatch, verbose=1)
+        loss.append(hist.history['loss'][0])
+
+        # model1.fit(input_training,output_training, validation_split=0.2, epochs=epochs_num, batch_size=512)
+        model1.save_weights("lstm_20k_model2.h5")
+    print('Training duration (s) : ', time.time() - global_start_time)
+else:
+    print("TESTING...........")
+    pass
+
+# Testing --------------------------------------------------------- 
+#########################################################
+# The first steps: Fill up the buffer
+# #######################################################
+CountTest = 0
+Average_Err = 0 
+error = np.zeros(LengthTest)
+
+for Step in xrange(timestep):
+    print("Location {}------------".format(CountTest))
+    # Update the Locations & RSSIs buffer
+    # Update the Locations & RSSIs buffer
+    LocationIdx = 0
+    RSSIdx = 0
+    TestingData = np.zeros(len(L_combine)+len(RSSI_combine))
+    for i in xrange(timestep):
+        TestingData[LocationIdx] = L_combine[i*2]
+        TestingData[LocationIdx+1] = L_combine[i*2+1]
+        for j in xrange(len(RSSI_L2)):
+            TestingData[j+LocationIdx+2] = (float(RSSI_combine[j+RSSIdx])+100)/100
+        LocationIdx = LocationIdx + num_rssi_reading + 2
+        RSSIdx = RSSIdx + num_rssi_reading
+        # print(TestingData)
+
+    TestingData = TestingData.reshape(1,1,input_layer)
+    # Prediction 
+    Predicted_L = model1.predict(TestingData)   
+    Final_L = Predicted_L[0,0,:] 
+    
+    Correct_L = Location[CountTest,:]
+    error[CountTest] = np.sqrt(np.power((Final_L[0] - Correct_L[0]),2)+np.power((Final_L[1] - Correct_L[1]),2))
+    print "Predict: {}--- Exact: {} , Error: {}" .format((Final_L[0], Final_L[1]), (Correct_L[0], Correct_L[1]), (error[CountTest]))
+    Average_Err = Average_Err + error[CountTest]
+    CountTest = CountTest + 1
+
+    IdxTemp = 0
+    # Update Location
+    for j in xrange(Step*2,len(L_combine)):
+        L_combine[j] = Final_L[IdxTemp]
+        if IdxTemp == 0:
+            IdxTemp = 1
+        else:
+            IdxTemp = 0
+            pass
+
+    # Take RSSI
+    IdxTemp = 0
+    for j in xrange(Step*num_rssi_reading,len(RSSI_combine)):
+        RSSI_combine[j] = TestData[Step+1,IdxTemp]
+        IdxTemp = IdxTemp + 1
+        if IdxTemp == num_rssi_reading: # Reach the end
+            IdxTemp = 0
+
+#########################################################
+# AFter the buffer is full -
+# #######################################################  
+
+while CountTest < LengthTest-1:
+    print("Location {}------------".format(CountTest))
+# Update the Locations & RSSIs buffer
+    LocationIdx = 0
+    RSSIdx = 0
+    TestingData = np.zeros(len(L_combine)+len(RSSI_combine))
+    for i in xrange(timestep):
+        TestingData[LocationIdx] = L_combine[i*2]
+        TestingData[LocationIdx+1] = L_combine[i*2+1]
+        for j in xrange(len(RSSI_L2)):
+            TestingData[j+LocationIdx+2] = (float(RSSI_combine[j+RSSIdx])+100)/100
+        LocationIdx = LocationIdx + num_rssi_reading + 2
+        RSSIdx = RSSIdx + num_rssi_reading
+
+    TestingData = TestingData.reshape(1,1,input_layer)
+
+    # Prediction 
+    Predicted_L = model1.predict(TestingData)   
+    Final_L = Predicted_L[0,0,:]   
+    
+    Correct_L = Location[CountTest,:]
+    error[CountTest] = np.sqrt(np.power((Final_L[0] - Correct_L[0]),2)+np.power((Final_L[1] - Correct_L[1]),2))
+    print "Predict: {}--- Exact: {} , Error: {}" .format((Final_L[0], Final_L[1]), (Correct_L[0], Correct_L[1]), (error[CountTest]))
+    Average_Err = Average_Err + error[CountTest]
+
+    File1.write(str(error[CountTest]) + ' , ') # write to file
+    File2.write(str(Final_L[0]) + ',') 
+    File2.write(str(Final_L[1]) + '\n') # write to file
+
+    # Re-arrange L_combine
+    for t in xrange(timestep-1): 
+        L_combine[t*2] = L_combine[(t+1)*2]
+        L_combine[t*2+1] = L_combine[(t+1)*2+1] 
+    # Update 
+    L_combine[(timestep-1)*2] = Final_L[0] 
+    L_combine[(timestep-1)*2+1] = Final_L[1] 
+
+    # Re-arrange RSSI_combine
+    for t in xrange(timestep-1): 
+        for k in xrange(num_rssi_reading):
+            RSSI_combine[t*num_rssi_reading+k] =  RSSI_combine[(t+1)*num_rssi_reading+k]
+
+    for k in xrange(num_rssi_reading):
+        RSSI_combine[(timestep-1)*num_rssi_reading+k] = TestData[CountTest+1,k]      
+
+    CountTest = CountTest + 1 
+###################################################################
+############### The Last Locations ###############################
+###################################################################
+
+Average_Err = Average_Err/LengthTest
+print "Average Error: ", Average_Err
+
+Std_Err = 0
+for k in xrange(LengthTest):
+    Std_Err = Std_Err +  np.power((error[k] - Average_Err),2)
+Std_Err = Std_Err/(LengthTest-1)
+Std_Err = np.sqrt(Std_Err)
+print "Std: ", Std_Err 
+
+#### Show Figure ######################
+if epochs_num > 0:
+    ResultPlot['neurons_500'] =  loss
+    ResultPlot.plot()
+    pyplot.show()
+
+File1.close()
+File2.close()
+# File3.close()
+# File4.close()

LSTM_Model_3.py

@@ -0,0 +1,323 @@
+#############################################################
+# 10 locations/ trajectory
+# First location is known
+# Date: 8 June 2018
+#############################################################
+
+import time
+import tensorflow
+# import lstm
+import os
+#import time
+import warnings
+import numpy as np
+from numpy import newaxis
+from keras.layers import TimeDistributed
+from keras.layers.core import Dense, Activation, Dropout
+from keras.layers.recurrent import LSTM
+from keras.models import Sequential
+# import matplotlib.pyplot as plt
+from matplotlib import pyplot
+import pandas as pd
+import math
+from pandas import DataFrame
+from keras import backend as K
+
+def rmse(y_true, y_pred):
+        return K.sqrt(K.mean(K.square(y_pred - y_true), axis=-1))
+def err_absolute(y_true, y_pred):
+        err = K.sqrt(K.square(y_pred - y_true))
+        return err 
+
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' #Hide messy TensorFlow warnings
+warnings.filterwarnings("ignore") #Hide messy Numpy warnings
+
+# Open File to write results
+File1 = open('Error_Model3.csv','w')
+File2 = open('Traj_Model3.csv','w') 
+# File3 = open('Loss_PredictedL_50k_NoFilter.csv','w') 
+# File4 = open('Output_PredictedL_50k_NoFilter.csv','w') 
+
+NumTotalTraj = 120000
+
+# Configure the sampling set -----------------
+epochs_num  = 0
+NumTrajTraining = 20000
+NumSam_PerTraj = 1
+StartingTraj = 20000
+StartingSample = StartingTraj*NumSam_PerTraj # the factor of NumSam_PerTraj 
+NumSample = NumTrajTraining*NumSam_PerTraj # NumTraj = NumSample/NumSam_PerTraj
+
+# Configure the validation set -----------------
+NumTrajVal = 10000
+StartingTrajVal = 100000
+
+StartingValidation = StartingTrajVal*NumSam_PerTraj
+NumValidation = NumTrajVal*NumSam_PerTraj
+
+# Main Run Thread
+global_start_time = time.time()
+input_layer = 11 # X, Y & 11 MAC Addresses
+num_rssi_reading = 11
+output_layer = 2
+timestep = 10
+NumBatch = 256
+hidden_layer1 = 100
+hidden_layer2 = 100
+
+##########################################################
+###### Test Trajectory Splitting #########################
+########################################################## 
+# Read Training data -------5-------------------------------------------
+print('> Loading data... ')
+filename = os.path.join(fileDir, '../RSSI_6AP_Experiments/Nexus4_Data/InputRNN_10points_120k_RSSI.csv')
+filename = os.path.abspath(os.path.realpath(filename))
+df1=pd.read_csv(filename)
+df1= np.asarray(df1)
+df1_split = df1[StartingSample:StartingSample+NumSample,:]
+input_training = df1_split.reshape(len(df1_split),timestep,input_layer)
+print(input_training.shape)
+
+filename = os.path.join(fileDir, '../RSSI_6AP_Experiments/Nexus4_Data/Traj_10points_120k_ModelTest.csv')
+filename = os.path.abspath(os.path.realpath(filename))
+df2=pd.read_csv(filename)
+df2= np.asarray(df2)
+df2_split = df2[StartingSample:StartingSample+NumSample,:]
+output_training = df2_split.reshape(len(df2_split),timestep,output_layer)
+print(output_training.shape)
+
+########################################################################
+# Read Validation data --------------------------------------------------
+#######################################################################
+df3= df1[StartingValidation:StartingValidation+NumValidation,:]
+input_validation = df3.reshape(len(df3),timestep,input_layer)
+print(input_validation.shape)
+
+df4=df2[StartingValidation:StartingValidation+NumValidation,:]
+output_validation = df4.reshape(len(df4),timestep,output_layer)
+print(output_validation.shape)
+
+####################################################################
+# Testing data ------------------------
+####################################################################
+# RSSI array
+filename = os.path.join(fileDir, '../RSSI_6AP_Experiments/Nexus4_Data/Long_Traj_6July_v1_AverageFilter.csv')
+filename = os.path.abspath(os.path.realpath(filename))
+TestData_origin =pd.read_csv(filename)
+print(TestData_origin.shape)
+TestData_origin = np.asarray(TestData_origin)
+
+LengthTest = len(TestData_origin)
+StartTestIdx = 0
+StopTestIdx = StartTestIdx + LengthTest
+
+# print(TestData.shape)
+TestData = TestData_origin[StartTestIdx:StopTestIdx, :]
+# LengthTest = len(TestData)
+
+# List of Locations 
+filename = os.path.join(fileDir, '../RSSI_6AP_Experiments/Nexus4_Data/Long_Traj_Location.csv')
+filename = os.path.abspath(os.path.realpath(filename))
+Location_origin = pd.read_csv(filename)
+print(Location_origin.shape)
+Location_origin = np.asarray(Location_origin)
+Location = Location_origin[StartTestIdx:StopTestIdx, :]
+
+print('> Data Loaded. Compiling...')
+
+####################################################################
+# Init 9 first Location ###########################################
+####################################################################
+L1 = Location[0,:]
+L2 = Location[0,:]
+L3 = Location[0,:]
+L4 = Location[0,:]
+L5 = Location[0,:]
+L6 = Location[0,:]
+L7 = Location[0,:]
+L8 = Location[0,:]
+L9 = Location[0,:]
+L_combine = np.concatenate((L1,L2,L3,L4,L5,L6,L7,L8,L9), axis=0)
+
+# Take RSSI
+RSSI_L1 = TestData[0,:]
+RSSI_L2 = TestData[1,:] 
+RSSI_L3 = TestData[1,:]
+RSSI_L4 = TestData[1,:] 
+RSSI_L5 = TestData[1,:]
+RSSI_L6 = TestData[1,:] 
+RSSI_L7 = TestData[1,:]
+RSSI_L8 = TestData[1,:] 
+RSSI_L9 = TestData[1,:]
+RSSI_L10 = TestData[1,:]
+RSSI_combine = np.concatenate((RSSI_L1, RSSI_L2, RSSI_L3, RSSI_L4, RSSI_L5,RSSI_L6, RSSI_L7, RSSI_L8, RSSI_L9, RSSI_L10), axis=0)
+
+# Build the network  --------------------------------------------
+model1 = Sequential()
+model1.add(LSTM(hidden_layer1, input_shape=(timestep, input_layer), return_sequences=True))
+model1.add(Dropout(0.2))
+model1.add(LSTM(hidden_layer2,return_sequences=True))
+model1.add(Dropout(0.2))
+model1.add(TimeDistributed(Dense(output_layer)))
+model1.summary()
+start = time.time()
+model1.compile(loss="mse", optimizer="adam",metrics=[rmse])
+# model1.compile(loss=rmse, optimizer="adam",metrics=[err_absolute]) #rmse
+# root_mean_squared_error
+print("> Compilation Time : ", time.time() - start)
+
+# Training --------------------------------------------------------
+loss = list()
+ResultPlot = DataFrame()
+
+#### Create a copy of input training ##########################
+input_training_org = input_training
+input_validation_org = input_validation
+###############################################################
+model1.load_weights("lstm_20k_model3.h5")
+StartingValidation = 0
+if epochs_num > 0:
+ #   iTimeStep = 1
+  #  iTimeStep_val = 1
+    for ep in xrange(epochs_num):
+        print("Iteration {} ----- ".format(ep))
+
+        # Fit Model
+      #  hist = model1.fit(input_training,output_training, validation_data=(input_validation, output_validation), epochs=1, batch_size=NumBatch, verbose=1)
+        hist = model1.fit(input_training,output_training, epochs=1, batch_size=NumBatch, verbose=1)
+        loss.append(hist.history['loss'][0])
+
+        # model1.fit(input_training,output_training, validation_split=0.2, epochs=epochs_num, batch_size=512)
+        model1.save_weights("lstm_20k_model3.h5")
+    print('Training duration (s) : ', time.time() - global_start_time)
+else:
+    print("TESTING...........")
+    pass
+
+# Testing --------------------------------------------------------- 
+#########################################################
+# The first steps: Fill up the buffer
+# #######################################################    
+Acc_Location = np.zeros((timestep,2))
+Acc_Location[0,:] = L1
+
+for Step in xrange(1,timestep):
+
+    # Update the Locations & RSSIs buffer
+    RSSIdx = 0
+    TestingData = np.zeros(len(RSSI_combine))
+    for i in xrange(timestep):
+        for j in xrange(len(RSSI_L2)): # Repeat the first location
+            TestingData[j+RSSIdx] = (float(RSSI_combine[j+RSSIdx])+100)/100
+        RSSIdx = RSSIdx + num_rssi_reading
+
+    TestingData = TestingData.reshape(1,timestep,input_layer)
+   # print(TestingData)
+
+    # Prediction 
+    Predicted_L = model1.predict(TestingData)
+    Acc_Location[Step,:] = Predicted_L[0,Step,:]
+    print(Acc_Location)
+
+    # Take RSSI
+    IdxTemp = 0
+    for j in xrange(Step*num_rssi_reading,len(RSSI_combine)):
+        RSSI_combine[j] = TestData[Step+1,IdxTemp]
+        IdxTemp = IdxTemp + 1
+        if IdxTemp == num_rssi_reading: # Reach the end
+            IdxTemp = 0
+
+#########################################################
+# AFter the buffer is full - Do the Test
+# #######################################################  
+
+CountArray = np.ones(timestep)
+error = np.zeros(LengthTest-1)
+# Predicted_array = np.zeros((LengthTest-1,2))
+Average_Err = 0
+
+for CountTest in xrange(LengthTest-timestep):
+    print("Location {}------------".format(CountTest))
+# Update the Locations & RSSIs buffer
+    RSSIdx = 0
+    TestingData = np.zeros(len(RSSI_combine))
+    for i in xrange(timestep):
+        for j in xrange(len(RSSI_L2)):
+            TestingData[j+RSSIdx] = (float(RSSI_combine[j+RSSIdx])+100)/100
+        RSSIdx = RSSIdx + num_rssi_reading
+
+    TestingData = TestingData.reshape(1,timestep,input_layer)
+
+    # Prediction 
+    Predicted_L = model1.predict(TestingData)
+    # Re-arrange Accumulated Location
+    for t in xrange(timestep-1): 
+        CountArray[t] = CountArray[t+1]
+        Acc_Location[t,:] = Acc_Location[t+1,:]+Predicted_L[0,t,:]
+        CountArray[t] = CountArray[t] + 1
+
+    Acc_Location[timestep-1,:] = Predicted_L[0,timestep-1,:] # Update new Location
+    CountArray[timestep-1] = 1 #Update New Count
+   # print(Acc_Location)
+  #  print(CountArray)  
+######################################################################
+############# UPDATE LOCATION ########################################
+######################################################################
+
+    Final_L = Acc_Location[0,:]/CountArray[0]
+    CountArray[0] = 1
+     # Take correct location, compare the result
+    Correct_L = Location[CountTest+1,:]
+    error[CountTest] = np.sqrt(np.power((Final_L[0] - Correct_L[0]),2)+np.power((Final_L[1] - Correct_L[1]),2))
+    print "Predict: {}--- Exact: {} , Error: {}" .format((Final_L[0], Final_L[1]), (Correct_L[0], Correct_L[1]), (error[CountTest]))
+    Average_Err = Average_Err + error[CountTest]
+
+    File1.write(str(error[CountTest]) + ' , ') # write to file
+    File2.write(str(Final_L[0]) + ',') 
+    File2.write(str(Final_L[1]) + '\n') # write to file
+
+    # Re-arrange RSSI_combine
+    if CountTest+timestep+1 < LengthTest:
+        for t in xrange(timestep-1): 
+            for k in xrange(num_rssi_reading):
+                RSSI_combine[t*num_rssi_reading+k] =  RSSI_combine[(t+1)*num_rssi_reading+k]
+
+        for k in xrange(num_rssi_reading):
+            RSSI_combine[(timestep-1)*num_rssi_reading+k] = TestData[CountTest+timestep+1,k]      
+
+###################################################################
+############### The Last Locations ###############################
+###################################################################
+for i in xrange(timestep-1):
+    Final_L = Acc_Location[i+1,:]/CountArray[i+1]
+     # Take correct location, compare the result
+    Correct_L = Location[CountTest+1,:]
+    error[CountTest] = np.sqrt(np.power((Final_L[0] - Correct_L[0]),2)+np.power((Final_L[1] - Correct_L[1]),2))
+    print "Predict: {}--- Exact: {} , Error: {}" .format((Final_L[0], Final_L[1]), (Correct_L[0], Correct_L[1]),  error[CountTest])
+    Average_Err = Average_Err + error[CountTest]
+
+    File1.write(str(error[CountTest]) + ' , ') # write to file
+    File2.write(str(Final_L[0]) + ',') 
+    File2.write(str(Final_L[1]) + '\n') # write to file
+    CountTest = CountTest + 1
+
+Average_Err = Average_Err/(LengthTest-1)
+print "Average Error: ", Average_Err
+
+Std_Err = 0
+for k in xrange(LengthTest-1):
+    Std_Err = Std_Err +  np.power((error[k] - Average_Err),2)
+Std_Err = Std_Err/(LengthTest-1)
+Std_Err = np.sqrt(Std_Err)
+print "Std: ", Std_Err 
+
+#### Show Figure ######################
+if epochs_num > 0:
+    ResultPlot['neurons_500'] =  loss
+    ResultPlot.plot()
+    pyplot.show()
+
+File1.close()
+File2.close()
+# File3.close()
+# File4.close()

LSTM_Model_4.py

@@ -0,0 +1,392 @@
+#############################################################
+# 10 locations/ trajectory
+# First location is known
+# Date: 8 June 2018
+#############################################################
+
+import time
+import tensorflow
+# import lstm
+import os
+#import time
+import warnings
+import numpy as np
+from numpy import newaxis
+from keras.layers import TimeDistributed
+from keras.layers.core import Dense, Activation, Dropout
+from keras.layers.recurrent import LSTM
+from keras.models import Sequential
+# import matplotlib.pyplot as plt
+from matplotlib import pyplot
+import pandas as pd
+import math
+from pandas import DataFrame
+from keras import backend as K
+
+def rmse(y_true, y_pred):
+        return K.sqrt(K.mean(K.square(y_pred - y_true), axis=-1))
+def err_absolute(y_true, y_pred):
+        err = K.sqrt(K.square(y_pred - y_true))
+        return err 
+
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' #Hide messy TensorFlow warnings
+warnings.filterwarnings("ignore") #Hide messy Numpy warnings
+
+# Open File to write results
+File1 = open('Error_Model_4.csv','w')
+File2 = open('Traj_Model_4.csv','w') 
+# File3 = open('Loss_PredictedL_50k_NoFilter.csv','w') 
+# File4 = open('Output_PredictedL_50k_NoFilter.csv','w') 
+
+NumTotalTraj = 365000
+
+# Configure the sampling set -----------------
+epochs_num  = 200
+NumTrajTraining = 20000
+NumSam_PerTraj = 1
+StartingTraj = 0
+StartingSample = StartingTraj*NumSam_PerTraj # the factor of NumSam_PerTraj 
+NumSample = NumTrajTraining*NumSam_PerTraj # NumTraj = NumSample/NumSam_PerTraj
+
+# Configure the validation set -----------------
+NumTrajVal = 10000
+StartingTrajVal = 100000
+
+StartingValidation = StartingTrajVal*NumSam_PerTraj
+NumValidation = NumTrajVal*NumSam_PerTraj
+
+# Main Run Thread
+global_start_time = time.time()
+input_layer = 13 # X, Y & 11 MAC Addresses
+num_rssi_reading = 11
+output_layer = 2
+timestep = 9
+NumBatch = 512
+hidden_layer1 = 100
+hidden_layer2 = 100
+
+##########################################################
+###### Test Trajectory Splitting #########################
+########################################################## 
+# Read Training data -------5-------------------------------------------
+print('> Loading data... ')
+filename = os.path.join(fileDir, '../RSSI_6AP_Experiments/Nexus4_Data/Input_Location_RSSI_10points_365k.csv')
+filename = os.path.abspath(os.path.realpath(filename))
+df1=pd.read_csv(filename)
+df1= np.asarray(df1)
+df1_split = df1[StartingSample:StartingSample+NumSample,:]
+input_training = df1_split.reshape(len(df1_split),timestep,input_layer)
+print(input_training.shape)
+
+filename = os.path.join(fileDir, '../RSSI_6AP_Experiments/Nexus4_Data/Output_Location_RSSI_10points_365k.csv')
+filename = os.path.abspath(os.path.realpath(filename))
+df2=pd.read_csv(filename)
+df2= np.asarray(df2)
+df2_split = df2[StartingSample:StartingSample+NumSample,:]
+output_training = df2_split.reshape(len(df2_split),timestep,output_layer)
+print(output_training.shape)
+
+########################################################################
+# Read Validation data --------------------------------------------------
+#######################################################################
+df3= df1[StartingValidation:StartingValidation+NumValidation,:]
+input_validation = df3.reshape(len(df3),timestep,input_layer)
+print(input_validation.shape)
+
+df4=df2[StartingValidation:StartingValidation+NumValidation,:]
+output_validation = df4.reshape(len(df4),timestep,output_layer)
+print(output_validation.shape)
+
+####################################################################
+# Testing data ------------------------
+####################################################################
+# RSSI array
+filename = os.path.join(fileDir, '../RSSI_6AP_Experiments/Nexus4_Data/Long_Traj_6July_v1_AverageFilter.csv')
+filename = os.path.abspath(os.path.realpath(filename))
+TestData_origin =pd.read_csv(filename)
+print(TestData_origin.shape)
+TestData_origin = np.asarray(TestData_origin)
+
+LengthTest = len(TestData_origin)
+StartTestIdx = 0
+StopTestIdx = StartTestIdx + LengthTest
+
+# print(TestData.shape)
+TestData = TestData_origin[StartTestIdx:StopTestIdx, :]
+# LengthTest = len(TestData)
+
+# List of Locations 
+filename = os.path.join(fileDir, '../RSSI_6AP_Experiments/Nexus4_Data/Long_Traj_Location.csv')
+filename = os.path.abspath(os.path.realpath(filename))
+Location_origin = pd.read_csv(filename)
+print(Location_origin.shape)
+Location_origin = np.asarray(Location_origin)
+Location = Location_origin[StartTestIdx:StopTestIdx, :]
+
+print('> Data Loaded. Compiling...')
+
+####################################################################
+# Init 9 first Location ###########################################
+####################################################################
+L1 = Location[0,:]
+L2 = Location[0,:]
+L3 = Location[0,:]
+L4 = Location[0,:]
+L5 = Location[0,:]
+L6 = Location[0,:]
+L7 = Location[0,:]
+L8 = Location[0,:]
+L9 = Location[0,:]
+L_combine = np.concatenate((L1,L2,L3,L4,L5,L6,L7,L8,L9), axis=0)
+
+# Take RSSI
+RSSI_L1 = TestData[0,:]
+RSSI_L2 = TestData[1,:] 
+RSSI_L3 = TestData[1,:]
+RSSI_L4 = TestData[1,:] 
+RSSI_L5 = TestData[1,:]
+RSSI_L6 = TestData[1,:] 
+RSSI_L7 = TestData[1,:]
+RSSI_L8 = TestData[1,:] 
+RSSI_L9 = TestData[1,:]
+RSSI_L10 = TestData[1,:]
+RSSI_combine = np.concatenate((RSSI_L2, RSSI_L3, RSSI_L4, RSSI_L5,RSSI_L6, RSSI_L7, RSSI_L8, RSSI_L9, RSSI_L10), axis=0)
+
+# Build the network  --------------------------------------------
+model1 = Sequential()
+model1.add(LSTM(hidden_layer1, input_shape=(timestep, input_layer), return_sequences=True))
+model1.add(Dropout(0.2))
+model1.add(LSTM(hidden_layer2,return_sequences=True))
+model1.add(Dropout(0.2))
+model1.add(TimeDistributed(Dense(output_layer)))
+model1.summary()
+start = time.time()
+model1.compile(loss="mse", optimizer="adam",metrics=[rmse])
+# model1.compile(loss=rmse, optimizer="adam",metrics=[err_absolute]) #rmse
+# root_mean_squared_error
+print("> Compilation Time : ", time.time() - start)
+
+# Training --------------------------------------------------------
+loss = list()
+ResultPlot = DataFrame()
+
+#### Create a copy of input training ##########################
+input_training_org = input_training
+input_validation_org = input_validation
+###############################################################
+model1.load_weights("LSTM_Model_4_v1.h5")
+StartingValidation = 0
+if epochs_num > 0:
+    iTimeStep = 1
+    iTimeStep_val = 1
+    for ep in xrange(epochs_num):
+        print("Iteration {} ----- ".format(ep))
+
+        # Fit Model
+      #  hist = model1.fit(input_training,output_training, validation_data=(input_validation, output_validation), epochs=1, batch_size=NumBatch, verbose=1)
+        hist = model1.fit(input_training,output_training, epochs=1, batch_size=NumBatch, verbose=1)
+        loss.append(hist.history['loss'][0])
+      #  File3.write(str(hist.history['loss'][0]) + '\n') # write to file
+
+        # Reform the input training ---------------------------------
+   #     print("Training Predict Sample {} ... ".format(iTimeStep))
+    #    Predicted_L_Training = model1.predict(input_training) 
+        # get the predicted locations to become the inputs of the next step
+    #    for iSample in xrange(0,len(df1_split)):
+            # First location: known
+            # Update predicted Location sNormalizeOutputRNN_10points_120k_AverageFiltertarting from the second location
+     #       input_training[iSample,iTimeStep,0] = Predicted_L_Training[iSample,iTimeStep-1,0]
+     #       input_training[iSample,iTimeStep,1] = Predicted_L_Training[iSample,iTimeStep-1,1]
+     #   iTimeStep = iTimeStep + 1 # Update for next time step
+
+     #   if iTimeStep == timestep:  # reset 1 round -------
+     #       input_training = input_training_org
+     #       iTimeStep = 1
+        # --------------------------------------------------------------------------------------
+
+        # Reform the validation set for testing -------------------------------------------------
+        # Input is updated by prediction
+        # Output: Ideal
+    #    print("Validation Predict ...")
+    #    Predicted_L_Validation = model1.predict(input_validation) 
+    #    for iSample in xrange(0,len(df3)):
+    #        input_validation[iSample,iTimeStep_val,0] = Predicted_L_Validation[iSample,iTimeStep_val-1,0]
+    #        input_validation[iSample,iTimeStep_val,1] = Predicted_L_Validation[iSample,iTimeStep_val-1,1]
+    #    iTimeStep_val = iTimeStep_val + 1        
+    #    print("TESTING...........")
+
+     #   if iTimeStep_val == timestep:  # reset 1 round -------
+    #        input_validation = input_validation_org
+     #       iTimeStep_val = 1
+         # ------------------------------------------------------------------------------------------
+         # Calculate the validation error -------------------------------------------------
+
+
+        # model1.fit(input_training,output_training, validation_split=0.2, epochs=epochs_num, batch_size=512)
+        model1.save_weights("LSTM_Model_4_v1.h5")
+    print('Training duration (s) : ', time.time() - global_start_time)
+else:
+    print("TESTING...........")
+    pass
+
+# Testing --------------------------------------------------------- 
+#########################################################
+# The first 3 steps: Fill up the buffer
+# #######################################################    
+Acc_Location = np.zeros((timestep,2))
+Acc_Location[0,:] = L1
+
+for Step in xrange(1,timestep):
+
+    # Update the Locations & RSSIs buffer
+    LocationIdx = 0
+    RSSIdx = 0
+    TestingData = np.zeros(len(L_combine)+len(RSSI_combine))
+    for i in xrange(timestep):
+        TestingData[LocationIdx] = L_combine[i*2]
+        TestingData[LocationIdx+1] = L_combine[i*2+1]
+        for j in xrange(len(RSSI_L2)):
+            TestingData[j+LocationIdx+2] = (float(RSSI_combine[j+RSSIdx])+100)/100
+        LocationIdx = LocationIdx + input_layer
+        RSSIdx = RSSIdx + num_rssi_reading
+
+    TestingData = TestingData.reshape(1,timestep,input_layer)
+   # print(TestingData)
+
+    # Prediction 
+    Predicted_L = model1.predict(TestingData)
+    Acc_Location[Step,:] = Predicted_L[0,Step-1,:]
+    print(Acc_Location)
+
+    # Update for next step
+    # Init 4 first Location
+    IdxTemp = 0
+    # Update Location
+    for j in xrange(Step*2,len(L_combine)):
+        L_combine[j] = Acc_Location[Step,IdxTemp]
+        if IdxTemp == 0:
+            IdxTemp = 1
+        else:
+            IdxTemp = 0
+            pass
+
+    # Take RSSI
+    IdxTemp = 0
+    for j in xrange(Step*num_rssi_reading,len(RSSI_combine)):
+        RSSI_combine[j] = TestData[Step+1,IdxTemp]
+        IdxTemp = IdxTemp + 1
+        if IdxTemp == num_rssi_reading: # Reach the end
+            IdxTemp = 0
+
+#########################################################
+# AFter the buffer is full - Do the Test
+# #######################################################  
+
+CountArray = np.ones(timestep)
+error = np.zeros(LengthTest-1)
+# Predicted_array = np.zeros((LengthTest-1,2))
+Average_Err = 0
+
+for CountTest in xrange(LengthTest-timestep):
+    print("Location {}------------".format(CountTest))
+# Update the Locations & RSSIs buffer
+    LocationIdx = 0
+    RSSIdx = 0
+    TestingData = np.zeros(len(L_combine)+len(RSSI_combine))
+    for i in xrange(timestep):
+        TestingData[LocationIdx] = L_combine[i*2]
+        TestingData[LocationIdx+1] = L_combine[i*2+1]
+        for j in xrange(len(RSSI_L2)):
+            TestingData[j+LocationIdx+2] = (float(RSSI_combine[j+RSSIdx])+100)/100
+        LocationIdx = LocationIdx + input_layer
+        RSSIdx = RSSIdx + num_rssi_reading
+
+    TestingData = TestingData.reshape(1,timestep,input_layer)
+    # print(TestingData)
+
+    # Prediction 
+    Predicted_L = model1.predict(TestingData)
+
+   # for t in xrange(timestep): 
+   #     File4.write(str(Predicted_L[0,t,0]) + ',') 
+   #     File4.write(str(Predicted_L[0,t,1])+ ',') # write to file
+   # File4.write('\n')
+
+    # Re-arrange Accumulated Location
+    for t in xrange(timestep-1): 
+        CountArray[t] = CountArray[t+1]
+        Acc_Location[t,:] = Acc_Location[t+1,:]+Predicted_L[0,t,:]
+        CountArray[t] = CountArray[t] + 1
+
+    Acc_Location[timestep-1,:] = Predicted_L[0,timestep-1,:] # Update new Location
+    CountArray[timestep-1] = 1 #Update New Count
+   # print(Acc_Location)
+  #  print(CountArray)  
+######################################################################
+############# UPDATE LOCATION ########################################
+######################################################################
+
+    Final_L = Acc_Location[0,:]/CountArray[0]
+    CountArray[0] = 1
+     # Take correct location, compare the result
+    Correct_L = Location[CountTest+1,:]
+    error[CountTest] = np.sqrt(np.power((Final_L[0] - Correct_L[0]),2)+np.power((Final_L[1] - Correct_L[1]),2))
+    print "Predict: {}--- Exact: {} , Error: {}" .format((Final_L[0], Final_L[1]), (Correct_L[0], Correct_L[1]), (error[CountTest]))
+    Average_Err = Average_Err + error[CountTest]
+
+    File1.write(str(error[CountTest]) + ' , ') # write to file
+    File2.write(str(Final_L[0]) + ',') 
+    File2.write(str(Final_L[1]) + '\n') # write to file
+
+    # Re-arrange L_combine
+    for t in xrange(timestep-1): 
+        L_combine[t*2] = L_combine[(t+1)*2]
+        L_combine[t*2+1] = L_combine[(t+1)*2+1] 
+    # Update 
+    L_combine[(timestep-1)*2] = Predicted_L[0,timestep-1,0] 
+    L_combine[(timestep-1)*2+1] = Predicted_L[0,timestep-1,1] 
+    # Re-arrange RSSI_combine
+    if CountTest+timestep+1 < LengthTest:
+        for t in xrange(timestep-1): 
+            for k in xrange(num_rssi_reading):
+                RSSI_combine[t*num_rssi_reading+k] =  RSSI_combine[(t+1)*num_rssi_reading+k]
+
+        for k in xrange(num_rssi_reading):
+            RSSI_combine[(timestep-1)*num_rssi_reading+k] = TestData[CountTest+timestep+1,k]      
+
+###################################################################
+############### The Last Locations ###############################
+###################################################################
+for i in xrange(timestep-1):
+    Final_L = Acc_Location[i+1,:]/CountArray[i+1]
+     # Take correct location, compare the result
+    Correct_L = Location[CountTest+1,:]
+    error[CountTest] = np.sqrt(np.power((Final_L[0] - Correct_L[0]),2)+np.power((Final_L[1] - Correct_L[1]),2))
+    print "Predict: {}--- Exact: {} , Error: {}" .format((Final_L[0], Final_L[1]), (Correct_L[0], Correct_L[1]),  error[CountTest])
+    Average_Err = Average_Err + error[CountTest]
+
+    File1.write(str(error[CountTest]) + ' , ') # write to file
+    File2.write(str(Final_L[0]) + ',') 
+    File2.write(str(Final_L[1]) + '\n') # write to file
+    CountTest = CountTest + 1
+
+Average_Err = Average_Err/(LengthTest-1)
+print "Average Error: ", Average_Err
+
+Std_Err = 0
+for k in xrange(LengthTest-1):
+    Std_Err = Std_Err +  np.power((error[k] - Average_Err),2)
+Std_Err = Std_Err/(LengthTest-1)
+Std_Err = np.sqrt(Std_Err)
+print "Std: ", Std_Err 
+
+#### Show Figure ######################
+#if epochs_num > 0:
+#    ResultPlot['neurons_500'] =  loss
+#    ResultPlot.plot()
+ #   pyplot.show()
+
+File1.close()
+File2.close()
+# File3.close()
+# File4.close()

LSTM_Model_4_v1.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:079f3fbd158367da1807e6a589f355a7177186da7e5f464389c6c6ad97138b29
+size 522080

LSTM_Model_5.py

@@ -0,0 +1,395 @@
+#############################################################
+# 10 locations/ trajectory
+# First location is known
+# Date: 8 June 2018
+#############################################################
+
+import time
+import tensorflow
+# import lstm
+import os
+#import time
+import warnings
+import numpy as np
+from numpy import newaxis
+from keras.layers import TimeDistributed
+from keras.layers.core import Dense, Activation, Dropout
+from keras.layers.recurrent import LSTM
+from keras.models import Sequential
+# import matplotlib.pyplot as plt
+from matplotlib import pyplot
+import pandas as pd
+import math
+from pandas import DataFrame
+from keras import backend as K
+
+def rmse(y_true, y_pred):
+        return K.sqrt(K.mean(K.square(y_pred - y_true), axis=-1))
+def err_absolute(y_true, y_pred):
+        err = K.sqrt(K.square(y_pred - y_true))
+        return err 
+
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' #Hide messy TensorFlow warnings
+warnings.filterwarnings("ignore") #Hide messy Numpy warnings
+
+# Open File to write results
+File1 = open('Error_Model_5_0_5ms.csv','w')
+File2 = open('Traj_Model_5.csv','w') 
+# File3 = open('Loss_PredictedL_50k_NoFilter.csv','w') 
+# File4 = open('Output_PredictedL_50k_NoFilter.csv','w') 
+
+NumTotalTraj = 365000
+
+# Configure the sampling set -----------------
+epochs_num  = 0
+NumTrajTraining = 20000
+NumSam_PerTraj = 1
+StartingTraj = 0
+StartingSample = StartingTraj*NumSam_PerTraj # the factor of NumSam_PerTraj 
+NumSample = NumTrajTraining*NumSam_PerTraj # NumTraj = NumSample/NumSam_PerTraj
+
+# Configure the validation set -----------------
+NumTrajVal = 10000
+StartingTrajVal = 100000
+
+StartingValidation = StartingTrajVal*NumSam_PerTraj
+NumValidation = NumTrajVal*NumSam_PerTraj
+
+# Main Run Thread
+global_start_time = time.time()
+input_layer = 13 # X, Y & 11 MAC Addresses
+num_rssi_reading = 11
+output_layer = 2
+timestep = 9
+NumBatch = 512
+hidden_layer1 = 100
+hidden_layer2 = 100
+
+##########################################################
+###### Test Trajectory Splitting #########################
+########################################################## 
+# Read Training data -------5-------------------------------------------
+if epochs_num > 0:
+    print('> Loading data... ')
+    filename = os.path.join(fileDir, '../RSSI_6AP_Experiments/Nexus4_Data/Input_Location_RSSI_10points_365k.csv')
+    filename = os.path.abspath(os.path.realpath(filename))
+    df1=pd.read_csv(filename)
+    df1= np.asarray(df1)
+    df1_split = df1[StartingSample:StartingSample+NumSample,:]
+    input_training = df1_split.reshape(len(df1_split),timestep,input_layer)
+    print(input_training.shape)
+
+    filename = os.path.join(fileDir, '../RSSI_6AP_Experiments/Nexus4_Data/Output_Location_RSSI_10points_365k.csv')
+    filename = os.path.abspath(os.path.realpath(filename))
+    df2=pd.read_csv(filename)
+    df2= np.asarray(df2)
+    df2_split = df2[StartingSample:StartingSample+NumSample,:]
+    output_training = df2_split.reshape(len(df2_split),timestep,output_layer)
+    print(output_training.shape)
+
+    ########################################################################
+    # Read Validation data --------------------------------------------------
+    #######################################################################
+    df3= df1[StartingValidation:StartingValidation+NumValidation,:]
+    input_validation = df3.reshape(len(df3),timestep,input_layer)
+    print(input_validation.shape)
+
+    df4=df2[StartingValidation:StartingValidation+NumValidation,:]
+    output_validation = df4.reshape(len(df4),timestep,output_layer)
+    print(output_validation.shape)
+
+####################################################################
+# Testing data ------------------------
+####################################################################
+# RSSI array
+filename = os.path.join(fileDir, '../RSSI_6AP_Experiments/Nexus4_Data/Long_Traj_6July_v1_AverageFilter.csv')
+filename = os.path.abspath(os.path.realpath(filename))
+TestData_origin =pd.read_csv(filename)
+print(TestData_origin.shape)
+TestData_origin = np.asarray(TestData_origin)
+
+LengthTest = len(TestData_origin)
+StartTestIdx = 0
+StopTestIdx = StartTestIdx + LengthTest
+
+# print(TestData.shape)
+TestData = TestData_origin[StartTestIdx:StopTestIdx, :]
+# LengthTest = len(TestData)
+
+# List of Locations 
+filename = os.path.join(fileDir, '../RSSI_6AP_Experiments/Nexus4_Data/Long_Traj_Location.csv')
+filename = os.path.abspath(os.path.realpath(filename))
+Location_origin = pd.read_csv(filename)
+print(Location_origin.shape)
+Location_origin = np.asarray(Location_origin)
+Location = Location_origin[StartTestIdx:StopTestIdx, :]
+
+print('> Data Loaded. Compiling...')
+
+
+####################################################################
+# Init 9 first Location ###########################################
+####################################################################
+L1 = Location[0,:]
+L2 = Location[0,:]
+L3 = Location[0,:]
+L4 = Location[0,:]
+L5 = Location[0,:]
+L6 = Location[0,:]
+L7 = Location[0,:]
+L8 = Location[0,:]
+L9 = Location[0,:]
+L_combine = np.concatenate((L1,L2,L3,L4,L5,L6,L7,L8,L9), axis=0)
+
+# Take RSSI
+RSSI_L1 = TestData[0,:]
+RSSI_L2 = TestData[1,:] 
+RSSI_L3 = TestData[1,:]
+RSSI_L4 = TestData[1,:] 
+RSSI_L5 = TestData[1,:]
+RSSI_L6 = TestData[1,:] 
+RSSI_L7 = TestData[1,:]
+RSSI_L8 = TestData[1,:] 
+RSSI_L9 = TestData[1,:]
+RSSI_L10 = TestData[1,:]
+RSSI_combine = np.concatenate((RSSI_L2, RSSI_L3, RSSI_L4, RSSI_L5,RSSI_L6, RSSI_L7, RSSI_L8, RSSI_L9, RSSI_L10), axis=0)
+
+# Build the network  --------------------------------------------
+model1 = Sequential()
+model1.add(LSTM(hidden_layer1, input_shape=(timestep, input_layer), return_sequences=True))
+model1.add(Dropout(0.2))
+model1.add(LSTM(hidden_layer2,return_sequences=True))
+model1.add(Dropout(0.2))
+model1.add(TimeDistributed(Dense(output_layer)))
+model1.summary()
+start = time.time()
+model1.compile(loss="mse", optimizer="adam",metrics=[rmse])
+# model1.compile(loss=rmse, optimizer="adam",metrics=[err_absolute]) #rmse
+# root_mean_squared_error
+print("> Compilation Time : ", time.time() - start)
+
+# Training --------------------------------------------------------
+loss = list()
+ResultPlot = DataFrame()
+
+#### Create a copy of input training ##########################
+if epochs_num > 0:
+    input_training_org = input_training
+    input_validation_org = input_validation
+###############################################################
+model1.load_weights("lstm_Model_5_DiffSpeed.h5")
+StartingValidation = 0
+if epochs_num > 0:
+    iTimeStep = 1
+    iTimeStep_val = 1
+    for ep in xrange(epochs_num):
+        print("Iteration {} ----- ".format(ep))
+
+        # Fit Model
+      #  hist = model1.fit(input_training,output_training, validation_data=(input_validation, output_validation), epochs=1, batch_size=NumBatch, verbose=1)
+        hist = model1.fit(input_training,output_training, epochs=1, batch_size=NumBatch, verbose=1)
+        loss.append(hist.history['loss'][0])
+      #  File3.write(str(hist.history['loss'][0]) + '\n') # write to file
+
+        # Reform the input training ---------------------------------
+   #     print("Training Predict Sample {} ... ".format(iTimeStep))
+        Predicted_L_Training = model1.predict(input_training) 
+        # get the predicted locations to become the inputs of the next step
+        for iSample in xrange(0,len(df1_split)):
+            # First location: known
+            # Update predicted Location sNormalizeOutputRNN_10points_120k_AverageFiltertarting from the second location
+            input_training[iSample,iTimeStep,0] = Predicted_L_Training[iSample,iTimeStep-1,0]
+            input_training[iSample,iTimeStep,1] = Predicted_L_Training[iSample,iTimeStep-1,1]
+        iTimeStep = iTimeStep + 1 # Update for next time step
+
+        if iTimeStep == timestep:  # reset 1 round -------
+            input_training = input_training_org
+            iTimeStep = 1
+        # --------------------------------------------------------------------------------------
+
+        # Reform the validation set for testing -------------------------------------------------
+        # Input is updated by prediction
+        # Output: Ideal
+    #    print("Validation Predict ...")
+    #    Predicted_L_Validation = model1.predict(input_validation) 
+    #    for iSample in xrange(0,len(df3)):
+    #        input_validation[iSample,iTimeStep_val,0] = Predicted_L_Validation[iSample,iTimeStep_val-1,0]
+    #        input_validation[iSample,iTimeStep_val,1] = Predicted_L_Validation[iSample,iTimeStep_val-1,1]
+    #    iTimeStep_val = iTimeStep_val + 1        
+    #    print("TESTING...........")
+
+     #   if iTimeStep_val == timestep:  # reset 1 round -------
+    #        input_validation = input_validation_org
+     #       iTimeStep_val = 1
+         # ------------------------------------------------------------------------------------------
+         # Calculate the validation error -------------------------------------------------
+
+
+        # model1.fit(input_training,output_training, validation_split=0.2, epochs=epochs_num, batch_size=512)
+        model1.save_weights("lstm_Model_5_DiffSpeed.h5")
+    print('Training duration (s) : ', time.time() - global_start_time)
+else:
+    print("TESTING...........")
+    pass
+
+# Testing --------------------------------------------------------- 
+#########################################################
+# The first 3 steps: Fill up the buffer
+# #######################################################    
+Acc_Location = np.zeros((timestep,2))
+Acc_Location[0,:] = L1
+
+for Step in xrange(1,timestep):
+
+    # Update the Locations & RSSIs buffer
+    LocationIdx = 0
+    RSSIdx = 0
+    TestingData = np.zeros(len(L_combine)+len(RSSI_combine))
+    for i in xrange(timestep):
+        TestingData[LocationIdx] = L_combine[i*2]
+        TestingData[LocationIdx+1] = L_combine[i*2+1]
+        for j in xrange(len(RSSI_L2)):
+            TestingData[j+LocationIdx+2] = (float(RSSI_combine[j+RSSIdx])+100)/100
+        LocationIdx = LocationIdx + input_layer
+        RSSIdx = RSSIdx + num_rssi_reading
+
+    TestingData = TestingData.reshape(1,timestep,input_layer)
+   # print(TestingData)
+
+    # Prediction 
+    Predicted_L = model1.predict(TestingData)
+    Acc_Location[Step,:] = Predicted_L[0,Step-1,:]
+    print(Acc_Location)
+
+    # Update for next step
+    # Init 4 first Location
+    IdxTemp = 0
+    # Update Location
+    for j in xrange(Step*2,len(L_combine)):
+        L_combine[j] = Acc_Location[Step,IdxTemp]
+        if IdxTemp == 0:
+            IdxTemp = 1
+        else:
+            IdxTemp = 0
+            pass
+
+    # Take RSSI
+    IdxTemp = 0
+    for j in xrange(Step*num_rssi_reading,len(RSSI_combine)):
+        RSSI_combine[j] = TestData[Step+1,IdxTemp]
+        IdxTemp = IdxTemp + 1
+        if IdxTemp == num_rssi_reading: # Reach the end
+            IdxTemp = 0
+
+#########################################################
+# AFter the buffer is full - Do the Test
+# #######################################################  
+
+CountArray = np.ones(timestep)
+error = np.zeros(LengthTest-1)
+# Predicted_array = np.zeros((LengthTest-1,2))
+Average_Err = 0
+
+for CountTest in xrange(LengthTest-timestep):
+    print("Location {}------------".format(CountTest))
+# Update the Locations & RSSIs buffer
+    LocationIdx = 0
+    RSSIdx = 0
+    TestingData = np.zeros(len(L_combine)+len(RSSI_combine))
+    for i in xrange(timestep):
+        TestingData[LocationIdx] = L_combine[i*2]
+        TestingData[LocationIdx+1] = L_combine[i*2+1]
+        for j in xrange(len(RSSI_L2)):
+            TestingData[j+LocationIdx+2] = (float(RSSI_combine[j+RSSIdx])+100)/100
+        LocationIdx = LocationIdx + input_layer
+        RSSIdx = RSSIdx + num_rssi_reading
+
+    TestingData = TestingData.reshape(1,timestep,input_layer)
+    # print(TestingData)
+
+    # Prediction 
+    Predicted_L = model1.predict(TestingData)
+
+   # for t in xrange(timestep): 
+   #     File4.write(str(Predicted_L[0,t,0]) + ',') 
+   #     File4.write(str(Predicted_L[0,t,1])+ ',') # write to file
+   # File4.write('\n')
+
+    # Re-arrange Accumulated Location
+    for t in xrange(timestep-1): 
+        CountArray[t] = CountArray[t+1]
+        Acc_Location[t,:] = Acc_Location[t+1,:]+Predicted_L[0,t,:]
+        CountArray[t] = CountArray[t] + 1
+
+    Acc_Location[timestep-1,:] = Predicted_L[0,timestep-1,:] # Update new Location
+    CountArray[timestep-1] = 1 #Update New Count
+   # print(Acc_Location)
+  #  print(CountArray)  
+######################################################################
+############# UPDATE LOCATION ########################################
+######################################################################
+
+    Final_L = Acc_Location[0,:]/CountArray[0]
+    CountArray[0] = 1
+     # Take correct location, compare the result
+    Correct_L = Location[CountTest+1,:]
+    error[CountTest] = np.sqrt(np.power((Final_L[0] - Correct_L[0]),2)+np.power((Final_L[1] - Correct_L[1]),2))
+    print "Predict: {}--- Exact: {} , Error: {}" .format((Final_L[0], Final_L[1]), (Correct_L[0], Correct_L[1]), (error[CountTest]))
+    Average_Err = Average_Err + error[CountTest]
+
+    File1.write(str(error[CountTest]) + ' , ') # write to file
+    File2.write(str(Final_L[0]) + ',') 
+    File2.write(str(Final_L[1]) + '\n') # write to file
+
+    # Re-arrange L_combine
+    for t in xrange(timestep-1): 
+        L_combine[t*2] = L_combine[(t+1)*2]
+        L_combine[t*2+1] = L_combine[(t+1)*2+1] 
+    # Update 
+    L_combine[(timestep-1)*2] = Predicted_L[0,timestep-1,0] 
+    L_combine[(timestep-1)*2+1] = Predicted_L[0,timestep-1,1] 
+    # Re-arrange RSSI_combine
+    if CountTest+timestep+1 < LengthTest:
+        for t in xrange(timestep-1): 
+            for k in xrange(num_rssi_reading):
+                RSSI_combine[t*num_rssi_reading+k] =  RSSI_combine[(t+1)*num_rssi_reading+k]
+
+        for k in xrange(num_rssi_reading):
+            RSSI_combine[(timestep-1)*num_rssi_reading+k] = TestData[CountTest+timestep+1,k]      
+
+###################################################################
+############### The Last Locations ###############################
+###################################################################
+for i in xrange(timestep-1):
+    Final_L = Acc_Location[i+1,:]/CountArray[i+1]
+     # Take correct location, compare the result
+    Correct_L = Location[CountTest+1,:]
+    error[CountTest] = np.sqrt(np.power((Final_L[0] - Correct_L[0]),2)+np.power((Final_L[1] - Correct_L[1]),2))
+    print "Predict: {}--- Exact: {} , Error: {}" .format((Final_L[0], Final_L[1]), (Correct_L[0], Correct_L[1]),  error[CountTest])
+    Average_Err = Average_Err + error[CountTest]
+
+    File1.write(str(error[CountTest]) + ' , ') # write to file
+    File2.write(str(Final_L[0]) + ',') 
+    File2.write(str(Final_L[1]) + '\n') # write to file
+    CountTest = CountTest + 1
+
+Average_Err = Average_Err/(LengthTest-1)
+print "Average Error: ", Average_Err
+
+Std_Err = 0
+for k in xrange(LengthTest-1):
+    Std_Err = Std_Err +  np.power((error[k] - Average_Err),2)
+Std_Err = Std_Err/(LengthTest-1)
+Std_Err = np.sqrt(Std_Err)
+print "Std: ", Std_Err 
+
+#### Show Figure ######################
+#if epochs_num > 0:
+#    ResultPlot['neurons_500'] =  loss
+#    ResultPlot.plot()
+ #   pyplot.show()
+
+File1.close()
+File2.close()
+# File3.close()
+# File4.close()

LSTM_Model_5_10fold.py

@@ -0,0 +1,389 @@
+#############################################################
+# 10 locations/ trajectory
+# First location is known
+# Date: 8 June 2018
+#############################################################
+
+import time
+import tensorflow
+# import lstm
+import os
+#import time
+import warnings
+import numpy as np
+from numpy import newaxis
+from keras.layers import TimeDistributed
+from keras.layers.core import Dense, Activation, Dropout
+from keras.layers.recurrent import LSTM
+from keras.models import Sequential
+# import matplotlib.pyplot as plt
+from matplotlib import pyplot
+import pandas as pd
+import math
+from pandas import DataFrame
+from keras import backend as K
+
+def rmse(y_true, y_pred):
+        return K.sqrt(K.mean(K.square(y_pred - y_true), axis=-1))
+def err_absolute(y_true, y_pred):
+        err = K.sqrt(K.square(y_pred - y_true))
+        return err 
+
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' #Hide messy TensorFlow warnings
+warnings.filterwarnings("ignore") #Hide messy Numpy warnings
+
+# Open File to write results
+File1 = open('Error_Model_5_10_fold.csv','w')
+# File2 = open('Traj_Model_5_DiffSpeed_2ms.csv','w') 
+# File3 = open('Loss_PredictedL_50k_NoFilter.csv','w') 
+# File4 = open('Output_PredictedL_50k_NoFilter.csv','w') 
+
+NumTotalTraj = 365000
+
+# Configure the sampling set -----------------
+epochs_num  = 500
+N_fold = 10 
+NumTrajTraining = 20000
+NumSam_PerTraj = 1
+StartingTraj = 0
+StartingSample = StartingTraj*NumSam_PerTraj # the factor of NumSam_PerTraj 
+NumSample = NumTrajTraining*NumSam_PerTraj # NumTraj = NumSample/NumSam_PerTraj
+
+# Configure the validation set -----------------
+NumTrajVal = 10000
+StartingTrajVal = 100000
+
+StartingValidation = StartingTrajVal*NumSam_PerTraj
+NumValidation = NumTrajVal*NumSam_PerTraj
+
+# Main Run Thread
+global_start_time = time.time()
+input_layer = 13 # X, Y & 11 MAC Addresses
+num_rssi_reading = 11
+output_layer = 2
+timestep = 9
+NumBatch = 512 #512
+hidden_layer1 = 100
+hidden_layer2 = 100
+
+##########################################################
+###### Test Trajectory Splitting #########################
+########################################################## 
+# Read Training data --------------------------------------------------
+print('> Loading data... ')
+df1=pd.read_csv('Input_Location_RSSI_10points_365k.csv')
+df1= np.asarray(df1)
+
+df2=pd.read_csv('Output_Location_RSSI_10points_365k.csv')
+df2= np.asarray(df2)
+
+########################################################################
+# Read Validation data --------------------------------------------------
+#######################################################################
+# df3= df1[StartingValidation:StartingValidation+NumValidation,:]
+# input_validation = df3.reshape(len(df3),timestep,input_layer)
+# print(input_validation.shape)
+
+# df4=df2[StartingValidation:StartingValidation+NumValidation,:]
+# output_validation = df4.reshape(len(df4),timestep,output_layer)
+# print(output_validation.shape)
+
+####################################################################
+# Testing data ------------------------
+####################################################################
+# RSSI array
+TestData_origin =pd.read_csv('Long_Traj_6July_v1_AverageFilter.csv')
+print(TestData_origin.shape)
+TestData_origin = np.asarray(TestData_origin)
+
+LengthTest = len(TestData_origin)
+StartTestIdx = 0
+StopTestIdx = StartTestIdx + LengthTest
+
+# print(TestData.shape)
+TestData = TestData_origin[StartTestIdx:StopTestIdx, :]
+# LengthTest = len(TestData)
+
+# List of Locations 
+Location_origin = pd.read_csv('Long_Traj_Location.csv')
+print(Location_origin.shape)
+Location_origin = np.asarray(Location_origin)
+Location = Location_origin[StartTestIdx:StopTestIdx, :]
+
+print('> Data Loaded. Compiling...')
+
+####################################################################
+# Init 9 first Location ###########################################
+####################################################################
+L1 = Location[0,:]
+L2 = Location[0,:]
+L3 = Location[0,:]
+L4 = Location[0,:]
+L5 = Location[0,:]
+L6 = Location[0,:]
+L7 = Location[0,:]
+L8 = Location[0,:]
+L9 = Location[0,:]
+
+# Take RSSI
+RSSI_L1 = TestData[0,:]
+RSSI_L2 = TestData[1,:] 
+RSSI_L3 = TestData[1,:]
+RSSI_L4 = TestData[1,:] 
+RSSI_L5 = TestData[1,:]
+RSSI_L6 = TestData[1,:] 
+RSSI_L7 = TestData[1,:]
+RSSI_L8 = TestData[1,:] 
+RSSI_L9 = TestData[1,:]
+RSSI_L10 = TestData[1,:]
+
+# Build the network  --------------------------------------------
+model1 = Sequential()
+model1.add(LSTM(hidden_layer1, input_shape=(timestep, input_layer), return_sequences=True))
+model1.add(Dropout(0.2))
+model1.add(LSTM(hidden_layer2,return_sequences=True))
+model1.add(Dropout(0.2))
+model1.add(TimeDistributed(Dense(output_layer)))
+model1.summary()
+start = time.time()
+model1.compile(loss="mse", optimizer="adam",metrics=[rmse])
+# model1.compile(loss=rmse, optimizer="adam",metrics=[err_absolute]) #rmse
+# root_mean_squared_error
+print("> Compilation Time : ", time.time() - start)
+
+# Training --------------------------------------------------------
+loss = list()
+ResultPlot = DataFrame()
+
+#### Create a copy of input training ##########################
+# input_training_org = input_training
+# input_validation_org = input_validation
+###############################################################
+# model1.load_weights("lstm_Model_5_DiffSpeed.h5")
+# StartingValidation = 0
+for CountFold in xrange(1, N_fold): 
+    # training samples -----------------------
+    StartingTraj = CountFold*NumTrajTraining
+    StartingSample = StartingTraj*NumSam_PerTraj # the factor of NumSam_PerTraj 
+    df1_split = df1[StartingSample:StartingSample+NumSample,:]
+    input_training = df1_split.reshape(len(df1_split),timestep,input_layer)
+    # print(input_training.shape)
+    input_training_org = input_training
+
+    df2_split = df2[StartingSample:StartingSample+NumSample,:]
+    output_training = df2_split.reshape(len(df2_split),timestep,output_layer)
+    # print(output_training.shape)
+
+    H5_Name = 'lstm_Model_5_fold_'+ str(CountFold) + '.h5'
+    iTimeStep = 1
+    iTimeStep_val = 1
+    for ep in xrange(epochs_num):
+        print("Iteration {} ----- ".format(ep))
+
+        # Fit Model
+      #  hist = model1.fit(input_training,output_training, validation_data=(input_validation, output_validation), epochs=1, batch_size=NumBatch, verbose=1)
+        hist = model1.fit(input_training,output_training, epochs=1, batch_size=NumBatch, verbose=1, shuffle=False)
+        loss.append(hist.history['loss'][0])
+      #  File3.write(str(hist.history['loss'][0]) + '\n') #100 write to file
+
+        # Reform the input training ---------------------------------
+        print("Training Predict Sample {} ... ".format(iTimeStep))
+        Predicted_L_Training = model1.predict(input_training) 
+        # get the predicted locations to become the inputs of the next step
+        for iSample in xrange(0,len(df1_split)):
+            # First location: known
+            # Update predicted Location starting from the second location
+            input_training[iSample,iTimeStep,0] = Predicted_L_Training[iSample,iTimeStep-1,0]
+            input_training[iSample,iTimeStep,1] = Predicted_L_Training[iSample,iTimeStep-1,1]
+        iTimeStep = iTimeStep + 1 # Update for next time step
+
+        if iTimeStep == timestep:  # reset 1 round -------
+            input_training = input_training_org
+            iTimeStep = 1
+        # --------------------------------------------------------------------------------------
+
+        # Reform the validation set for testing -------------------------------------------------
+        # Input is updated by prediction
+        # Output: Ideal
+    #    print("Validation Predict ...")
+    #    Predicted_L_Validation = model1.predict(input_validation) 
+    #    for iSample in xrange(0,len(df3)):
+    #        input_validation[iSample,iTimeStep_val,0] = Predicted_L_Validation[iSample,iTimeStep_val-1,0]
+    #        input_validation[iSample,iTimeStep_val,1] = Predicted_L_Validation[iSample,iTimeStep_val-1,1]
+    #    iTimeStep_val = iTimeStep_val + 1        
+    #    print("TESTING...........")
+
+     #   if iTimeStep_val == timestep:  # reset 1 round -------
+    #        input_validation = input_validation_org
+     #       iTimeStep_val = 1
+         # ------------------------------------------------------------------------------------------
+         # Calculate the validation error ------------------------------------------------
+
+        # model1.fit(input_training,output_training, validation_split=0.2, epochs=epochs_num, batch_size=512)
+        model1.save_weights(H5_Name)
+    # print('Training duration (s) 100: ', time.time() - global_start_time)
+
+    # Testing --------------------------------------------------------- 
+    #########################################################
+    # The first 3 steps: Fill up the buffer
+    # #######################################################    
+    Acc_Location = np.zeros((timestep,2))
+    Acc_Location[0,:] = L1
+    L_combine = np.concatenate((L1,L2,L3,L4,L5,L6,L7,L8,L9), axis=0)
+    RSSI_combine = np.concatenate((RSSI_L2, RSSI_L3, RSSI_L4, RSSI_L5,RSSI_L6, RSSI_L7, RSSI_L8, RSSI_L9, RSSI_L10), axis=0)
+    
+    for Step in xrange(1,timestep):
+
+        # Update the Locations & RSSIs buffer
+        LocationIdx = 0
+        RSSIdx = 0
+        TestingData = np.zeros(len(L_combine)+len(RSSI_combine))
+        for i in xrange(timestep):
+            TestingData[LocationIdx] = L_combine[i*2]
+            TestingData[LocationIdx+1] = L_combine[i*2+1]
+            for j in xrange(len(RSSI_L2)):
+                TestingData[j+LocationIdx+2] = (float(RSSI_combine[j+RSSIdx])+100)/100
+            LocationIdx = LocationIdx + input_layer
+            RSSIdx = RSSIdx + num_rssi_reading
+            # print(TestingData)
+
+        TestingData = TestingData.reshape(1,timestep,input_layer)
+        # print(TestingData)
+
+        # Prediction 
+        Predicted_L = model1.predict(TestingData)
+        Acc_Location[Step,:] = Predicted_L[0,Step-1,:]
+        print(Acc_Location)
+
+        # Update for next step
+        # Init 4 first Location
+        IdxTemp = 0
+        # Update Location
+        for j in xrange(Step*2,len(L_combine)):
+            L_combine[j] = Acc_Location[Step,IdxTemp]
+            if IdxTemp == 0:
+                IdxTemp = 1
+            else:
+                IdxTemp = 0
+                pass
+
+        # Take RSSI
+        IdxTemp = 0
+        for j in xrange(Step*num_rssi_reading,len(RSSI_combine)):
+            RSSI_combine[j] = TestData[Step+1,IdxTemp]
+            IdxTemp = IdxTemp + 1
+            if IdxTemp == num_rssi_reading: # Reach the end
+                IdxTemp = 0
+
+    #########################################################
+    # AFter the buffer is full - Do the Test
+    # #######################################################  
+
+    CountArray = np.ones(timestep)
+    error = np.zeros(LengthTest-1)
+    # Predicted_array = np.zeros((LengthTest-1,2))
+    Average_Err = 0
+
+    for CountTest in xrange(LengthTest-timestep):
+        print("Location {}------------".format(CountTest))
+    # Update the Locations & RSSIs buffer
+        LocationIdx = 0
+        RSSIdx = 0
+        TestingData = np.zeros(len(L_combine)+len(RSSI_combine))
+        for i in xrange(timestep):
+            TestingData[LocationIdx] = L_combine[i*2]
+            TestingData[LocationIdx+1] = L_combine[i*2+1]
+            for j in xrange(len(RSSI_L2)):
+                TestingData[j+LocationIdx+2] = (float(RSSI_combine[j+RSSIdx])+100)/100
+            LocationIdx = LocationIdx + input_layer
+            RSSIdx = RSSIdx + num_rssi_reading
+
+        TestingData = TestingData.reshape(1,timestep,input_layer)
+        # print(TestingData)
+
+        # Prediction 
+        Predicted_L = model1.predict(TestingData)
+
+    # for t in xrange(timestep): 
+    #     File4.write(str(Predicted_L[0,t,0]) + ',') 
+    #     File4.write(str(Predicted_L[0,t,1])+ ',') # write to file
+    # File4.write('\n')
+
+        # Re-arrange Accumulated Location
+        for t in xrange(timestep-1): 
+            CountArray[t] = CountArray[t+1]
+            Acc_Location[t,:] = Acc_Location[t+1,:]+Predicted_L[0,t,:]
+            CountArray[t] = CountArray[t] + 1
+
+        Acc_Location[timestep-1,:] = Predicted_L[0,timestep-1,:] # Update new Location
+        CountArray[timestep-1] = 1 #Update New Count
+    # print(Acc_Location)
+    #  print(CountArray)  
+    ######################################################################
+    ############# UPDATE LOCATION ########################################
+    ######################################################################
+
+        Final_L = Acc_Location[0,:]/CountArray[0]
+        CountArray[0] = 1
+        # Take correct location, compare the result
+        Correct_L = Location[CountTest+1,:]
+        error[CountTest] = np.sqrt(np.power((Final_L[0] - Correct_L[0]),2)+np.power((Final_L[1] - Correct_L[1]),2))
+        print "Predict: {}--- Exact: {} , Error: {}" .format((Final_L[0], Final_L[1]), (Correct_L[0], Correct_L[1]), (error[CountTest]))
+        Average_Err = Average_Err + error[CountTest]
+
+        File1.write(str(error[CountTest]) + ' , ') # write to file
+    # File2.write(str(Final_L[0]) + ',') 
+    # File2.write(str(Final_L[1]) + '\n') # write to file
+        # Re-arrange L_combine
+        for t in xrange(timestep-1): 
+            L_combine[t*2] = L_combine[(t+1)*2]
+            L_combine[t*2+1] = L_combine[(t+1)*2+1] 
+        # Update 
+        L_combine[(timestep-1)*2] = Predicted_L[0,timestep-1,0] 
+        L_combine[(timestep-1)*2+1] = Predicted_L[0,timestep-1,1] 
+        # Re-arrange RSSI_combine
+        if CountTest+timestep+1 < LengthTest:
+            for t in xrange(timestep-1): 
+                for k in xrange(num_rssi_reading):
+                    RSSI_combine[t*num_rssi_reading+k] =  RSSI_combine[(t+1)*num_rssi_reading+k]
+
+            for k in xrange(num_rssi_reading):
+                RSSI_combine[(timestep-1)*num_rssi_reading+k] = TestData[CountTest+timestep+1,k]      
+
+    ###################################################################
+    ############### The Last Locations ###############################
+    ###################################################################
+    for i in xrange(timestep-1):
+        Final_L = Acc_Location[i+1,:]/CountArray[i+1]
+        # Take correct location, compare the result
+        Correct_L = Location[CountTest+1,:]
+        error[CountTest] = np.sqrt(np.power((Final_L[0] - Correct_L[0]),2)+np.power((Final_L[1] - Correct_L[1]),2))
+        print "Predict: {}--- Exact: {} , Error: {}" .format((Final_L[0], Final_L[1]), (Correct_L[0], Correct_L[1]),  error[CountTest])
+        Average_Err = Average_Err + error[CountTest]
+
+        File1.write(str(error[CountTest]) + ' , ') # write to file
+    #  File2.write(str(Final_L[0]) + ',') 
+    #  File2.write(str(Final_L[1]) + '\n') # write to file
+        CountTest = CountTest + 1
+
+    File1.write('\n')
+    Average_Err = Average_Err/(LengthTest-1)
+    print "Average Error: ", Average_Err
+
+    Std_Err = 0
+    for k in xrange(LengthTest-1):
+        Std_Err = Std_Err +  np.power((error[k] - Average_Err),2)
+    Std_Err = Std_Err/(LengthTest-1)
+    Std_Err = np.sqrt(Std_Err)
+    print "Std: ", Std_Err 
+
+#### Show Figure ######################
+#if epochs_num > 0:
+#    ResultPlot['neurons_500'] =  loss
+#    ResultPlot.plot()
+#    pyplot.show()
+
+File1.close()
+# File2.close()
+# File3.close()
+# File4.close()

Median_Filter.m

@@ -0,0 +1,18 @@
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% Median Filter
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% N: Window Size
+% RSSI_Before: Array
+% RSSI_After : Scalar
+% n: number of available samples in the RSSI_Before
+
+function RSSI_After = Median_Filter(RSSI_Before, n)
+  
+  % 
+  if n < length(RSSI_Before) % if don't have enough samples
+      RSSI_After =   RSSI_Before(n);
+  else % have enough sample
+      RSSI_After = median(RSSI_Before); 
+  end
+  
+end

NormalizedDatabase.m

@@ -0,0 +1,81 @@
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% X Y Z MAC1 Mean_RSSI1 MAC2 Mean_RSSI2 ...   
+% Normalize Database - Standardization
+% 
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+clear;
+close all;
+clc;
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% Parameter - 1 Unit = 40 inches
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+Num_Mac = 11; % Number of APs per vector in database
+
+% Normalize ------------------------------------
+% r = (r- mean)/sigma 
+% -----------------------------------------------
+
+% Test
+myFolder = 'C:\Users\minh_\Desktop\CSI_RSSI_Database\RSSI_6AP_Experiments\Nexus4_Data\'; % Database Folder
+InputTest = importdata([myFolder 'UpdatedDatabase_8June2018_11MAC_AverageFilter.csv']);
+Database = InputTest;
+Temp = size(Database);
+LengthDatabase = Temp(1); % Number of Test points
+
+% % % % InputMean = importdata('NormalizeddDatabase_AverageFilter.csv');
+
+RSSI_Array = Database(:,3:end);
+Location_Array = Database(:,1:2);
+NumLocation = length(Location_Array);
+
+%%%% Locations %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+MeanArray_Location = zeros(1,2);
+StdArray_Location = zeros(1,2);
+for ii = 1:2
+    MeanArray_Location(ii) = mean(Location_Array(:,ii));
+end
+for Count = 1:NumLocation
+    for CountMac = 1:2
+        StdArray_Location(CountMac) =  StdArray_Location(CountMac) + (Location_Array(Count,CountMac)-MeanArray_Location(CountMac))^2;
+    end
+end
+StdArray_Location = StdArray_Location/LengthDatabase;
+StdArray_Location = sqrt(StdArray_Location);
+
+%%%% RSSI %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% Calculate Mean & Standard deviation for every AP
+MeanArray_RSSI = zeros(1,Num_Mac);
+%%%% Mean Calculation %%%%%%%%%%%%%%%%
+for Count = 1:LengthDatabase
+    for CountMac = 1:Num_Mac
+        MeanArray_RSSI(CountMac) =  MeanArray_RSSI(CountMac) + RSSI_Array(Count,CountMac);
+    end
+end
+MeanArray_RSSI = round(MeanArray_RSSI / LengthDatabase);
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%%% Standard Deviation %%%%%%%%%%%%%%%%%%%%%
+StdArray_RSSI = zeros(1,Num_Mac);
+for Count = 1:LengthDatabase
+    for CountMac = 1:Num_Mac
+        StdArray_RSSI(CountMac) =  StdArray_RSSI(CountMac) + (RSSI_Array(Count,CountMac)-MeanArray_RSSI(CountMac))^2;
+    end
+end
+StdArray_RSSI = StdArray_RSSI/LengthDatabase;
+StdArray_RSSI = round(sqrt(StdArray_RSSI));
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+%% Normalized Step
+Normalized_Database = zeros(size(Database));
+for Count = 1:LengthDatabase
+    % Location 
+    for ii = 1:2
+        Normalized_Database(Count,ii) = (Database(Count,ii) - MeanArray_Location(ii))/StdArray_Location(ii);
+    end
+    % RSSI
+    for ii = 3:13
+        Normalized_Database(Count,ii) = (Database(Count,ii) - MeanArray_RSSI(ii-2))/StdArray_RSSI(ii-2);
+    end
+end
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+csvwrite([myFolder 'Normalize_Database_AverageFilter.csv'],Normalized_Database); 

README.md

@@ -1,3 +1,18 @@
----
-license: cc-by-nc-sa-4.0
----
+# Recurrent Neural Networks for Accurate RSSI Indoor Localization
+
+Source code for M.T. Hoang, B. Yuen, X. Dong, T. Lu, R. Westendorp and K. Reddy, “Recurrent Neural Networks for Accurate RSSI Indoor Localization,” IEEE Internet of Things Journal, 2019
+
+
+# Folder Structure
+*  Step1_FilterDatabase.m: Filter the database with Average Weighted Filter or Mean Filter
+*  Step2_Create_RandomTraj.m: Generate random training trajectories under the constraints that the distance between consecutive locations is bounded by 
+the maximum distance a user can travel within the sample interval in practical scenarios.
+*  Step2_CreateInputTraining_Model5: Create the input training data for P-MIMO LSTM
+*  RNN models training code (Using Keras and Tensorflow) 
+   *  LSTM_Model_1.py 
+   *  LSTM_Model_2.py
+   *  LSTM_Model_3.py
+   *  LSTM_Model_4.py
+   *  LSTM_Model_5.py
+
+

Step1_FilterDatabase.m

@@ -0,0 +1,94 @@
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% Wifi Indoor Localization
+% Minhtu 
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% Filter the database with Average Weighted Filter
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+clear;
+close all;
+clc;
+
+FILTER_OPTION = 1;  % 1: Average Filter
+                    % 0: Median Filter
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% Parameter - 1 Unit = 1m
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+Num_Mac = 11; % Number of APs per vector in database
+
+% Test
+myFolder = 'C:\Users\minh_\Desktop\CSI_RSSI_Database\RSSI_6AP_Experiments\Nexus4_Data\'; % Database Folder
+Input = importdata([myFolder  'UpdatedDatabase_24Jan2018_Full.csv']);
+Database = Input.data;
+Temp = size(Database);
+LengthDatabase = Temp(1); % Number of RPs
+
+%%% Spit locaion from Database
+PreX = Database(1,1);
+PreY = Database(1,2);
+StartingPoint = 1;
+CountLocation = 0;
+for CountBlock = 2:LengthDatabase
+    X = Database(CountBlock,1);
+    Y = Database(CountBlock,2);
+    if (X ~= PreX) || (Y ~= PreY) || (CountBlock == LengthDatabase)
+        PreX = X;
+        PreY = Y;
+        EndingPoint = CountBlock-1;
+        CountLocation = CountLocation + 1 % Count Number of Location
+        LengthBlock = EndingPoint - StartingPoint + 1;
+        %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+        %%%%%%%%%%%%%%% Filter RSSI in a specific location %%%%%%%%%%%
+        %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+        RSSI_Original = Database(StartingPoint:EndingPoint, 3:end);
+        RSSI_Filtered = zeros(size(RSSI_Original));
+        F1_Before = zeros(1,3);
+        F2_Before = zeros(1,3);
+        RSSI_Before = zeros(1,3);
+
+        for CountMac = 1:Num_Mac
+            RSSI_Array_Temp = RSSI_Original(1:LengthBlock, CountMac);
+            RSSI_Array_After = zeros(LengthBlock, 1);
+            MeanValue = mean(RSSI_Array_Temp);
+            n = 1;
+            for CountPoint = 1:LengthBlock  
+                RSSI_Temp = RSSI_Array_Temp(CountPoint);
+                if RSSI_Temp == -100 % Avoid -100
+                    RSSI_Temp = MeanValue;
+                end
+                if n == 1
+                    RSSI_Before(1) = RSSI_Temp;
+                elseif n == 2
+                     RSSI_Before(2) = RSSI_Temp;  
+                elseif n == 3
+                     RSSI_Before(3) = RSSI_Temp;     
+                else
+                    RSSI_Before(1) = RSSI_Before(2);
+                    RSSI_Before(2) = RSSI_Before(3);  
+                    RSSI_Before(3) = RSSI_Temp; 
+                end
+                % Median Filter
+                if FILTER_OPTION == 0 % Median Filter
+                    RSSI_After_Median = Median_Filter(RSSI_Before,n);
+                    RSSI_Array_After(CountPoint) = round(RSSI_After_Median);
+                    n = n + 1;
+                else          
+                    % Average Filter
+                    % Filter
+                    [RSSI_After, F1, F2, TimeCount] = Average_Filter(RSSI_Before, F1_Before, F2_Before,n);               
+                    % Updated Array
+                    n = TimeCount;
+                    F1_Before = F1;
+                    F2_Before = F2;
+                    RSSI_Array_After(CountPoint) = round(RSSI_After);
+                end
+            end
+            RSSI_Filtered(1:LengthBlock, CountMac) = RSSI_Array_After;
+        end
+        % Update to Database
+        Database(StartingPoint:EndingPoint, 3:end) = RSSI_Filtered;
+        StartingPoint = CountBlock; % Restart Starting Point
+    end
+end
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+csvwrite([myFolder 'UpdatedDatabase_8June2018_11MAC_AverageFilter.csv'],Database);    
+    

Step2_CreateInputTraining_Model1.m

@@ -0,0 +1,63 @@
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% Wifi Indoor Localization
+% Minhtu 
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+clear;
+close all;
+clc;
+
+% Database
+myFolder = 'C:\Users\minh_\Desktop\CSI_RSSI_Database\RSSI_6AP_Experiments\Nexus4_Data\'; % Database Folder
+
+Input = importdata([myFolder 'UpdatedDatabase_8June2018_11MAC_AverageFilter.csv']);
+Database = Input;
+L_Data = length(Database);
+NumReading = 11;
+
+TrajInput = importdata([myFolder 'Traj_10points_5k_5m_s.csv']);
+TrajData = TrajInput;
+
+SizeTraj = size(TrajData);
+L = SizeTraj(1);
+NumPointPerTraj = SizeTraj(2)/2;
+
+%-----------------------------------------------------------
+%%%% Add RSSI to the trajectory 
+%-----------------------------------------------------------
+RNN_Database = zeros(L, (NumPointPerTraj-1)*NumReading);
+for ii = 1:L % Scan all trajectory
+    CntColRNN = 1;
+    for jj = 1: NumPointPerTraj % Scan all points in the trajectory
+        
+        X = TrajData(ii,(jj-1)*2+1); 
+        Y = TrajData(ii,(jj-1)*2+2); 
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%        
+% % %         X = TrajData(ii,jj*2+1); % Take the next RSSI for current point
+% % %         Y = TrajData(ii,jj*2+2); 
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+        for kk = 1:5:L_Data    
+            if (abs(Database(kk,1) - X) < 10^-3)&&(abs(Database(kk,2) - Y) < 10^-3)
+                RandNum = round(100*rand(1)); % Randomly pick up 1 RSSI Reading Row
+                if kk+RandNum > length(Database)
+                    RandNum = 0;
+                end
+                if (abs(Database(kk+RandNum,1) - X) < 10^-3)&&(abs(Database(kk+RandNum,2) - Y) < 10^-3)
+                    for mm = 1:NumReading
+%                        RNN_Database(ii, CntColRNN) =  Database(kk+RandNum,mm+2);
+                       RNN_Database(ii, CntColRNN) =  (Database(kk+RandNum,mm+2)+100)/100;
+                       CntColRNN = CntColRNN+1;   
+                    end
+                else % if out of range, pick up the 1st one
+                    for mm = 1:NumReading
+%                        RNN_Database(ii, CntColRNN) =  Database(kk,mm+2);
+                       RNN_Database(ii, CntColRNN) =  (Database(kk,mm+2)+100)/100;
+                       CntColRNN = CntColRNN+1;   
+                    end
+                end
+                break;
+            end    
+        end
+    end
+end
+csvwrite('InputRNN_10points_RSSI.csv',RNN_Database);

Step2_CreateInputTraining_Model5.m

@@ -0,0 +1,70 @@
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% Wifi Indoor Localization
+% Minhtu 
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+clear;
+close all;
+clc;
+
+% Database
+myFolder = 'C:\Users\minh_\Desktop\CSI_RSSI_Database\RSSI_6AP_Experiments\Nexus4_Data\'; % Database Folder
+
+Input = importdata([myFolder 'UpdatedDatabase_8June2018_11MAC_AverageFilter.csv']);
+Database = Input;
+L_Data = length(Database);
+NumReading = 11;
+
+TrajInput = importdata([myFolder 'Traj_10points_5k_5m_s.csv']);
+TrajData = TrajInput;
+
+SizeTraj = size(TrajData);
+L = SizeTraj(1);
+NumPointPerTraj = SizeTraj(2)/2; % How many Time Steps in LSTM trajectory
+
+%-----------------------------------------------------------
+%%%% Add RSSI to the trajectory 
+%-----------------------------------------------------------
+RNN_Database = zeros(L, NumPointPerTraj*2+(NumPointPerTraj-1)*NumReading);
+for ii = 1:L % Scan all trajectory
+    CntColRNN = 1;
+    for jj = 1: NumPointPerTraj % Scan all points in the trajectory
+        
+        if jj == NumPointPerTraj % Don't take the last RSSI
+            break;
+        end
+        X = TrajData(ii,(jj-1)*2+1); 
+        Y = TrajData(ii,(jj-1)*2+2); 
+        RNN_Database(ii, CntColRNN) = X; 
+        RNN_Database(ii, CntColRNN+1) = Y; 
+        CntColRNN = CntColRNN + 2;
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%        
+        X = TrajData(ii,jj*2+1); % Take the next RSSI for current point
+        Y = TrajData(ii,jj*2+2); 
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+        for kk = 1:5:L_Data % Scan all   
+            if (abs(Database(kk,1) - X) < 10^-3)&&(abs(Database(kk,2) - Y) < 10^-3)
+                RandNum = round(100*rand(1)); % Randomly pick up 1 RSSI Reading Row
+                if kk+RandNum > length(Database)
+                    RandNum = 0;
+                end
+                if (abs(Database(kk+RandNum,1) - X) < 10^-3)&&(abs(Database(kk+RandNum,2) - Y) < 10^-3)
+                    for mm = 1:NumReading
+%                        RNN_Database(ii, CntColRNN) =  Database(kk+RandNum,mm+2);
+                       RNN_Database(ii, CntColRNN) =  (Database(kk+RandNum,mm+2)+100)/100;
+                       CntColRNN = CntColRNN+1;   
+                    end
+                else % if out of range, pick up the 1st one
+                    for mm = 1:NumReading
+%                        RNN_Database(ii, CntColRNN) =  Database(kk,mm+2);
+                       RNN_Database(ii, CntColRNN) =  (Database(kk,mm+2)+100)/100;
+                       CntColRNN = CntColRNN+1;   
+                    end
+                end
+                break;
+            end    
+        end
+    end
+end
+csvwrite([myFolder 'Input_Location_RSSI_10points.csv'],RNN_Database);

Step2_Create_RandomTraj.m

@@ -0,0 +1,156 @@
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% WiFi Indoor Localization
+% Minhtu 
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% % % Generate random training trajectories under the constraints 
+% % % that the distance between consecutive locations is bounded by 
+% % % the maximum distance a user can travel within the sample 
+% % % interval in practical scenarios.
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+clear;
+close all;
+clc;
+
+% Database
+Norm_On = 0; % 1: Stardadization Normalization
+             % 0: Mean Normalization
+
+myFolder = 'C:\Users\minh_\Desktop\CSI_RSSI_Database\RSSI_6AP_Experiments\Nexus4_Data\'; % Database Folder
+if Norm_On == 1
+    Input = importdata('MeanDatabase_Normalize_AverageFilter.csv');
+    Mean_Location = [11.1397910665714,-3.78622840030012];
+    Std_Location = [6.31809099260756,6.42186397145320];
+else
+    Input = importdata([myFolder 'MeanDatabase_8June2018_11MAC.csv']);
+end
+
+Database = Input;
+L = length(Database);
+% Number of times which the database is repeated
+NumRepeatedDatabase = 15; % Num of Trajectories = NumRepeatedDatabase*L 
+NumPointPerTraj = 10;     % Number of Time Steps in LSTM networks
+
+MapDistance = zeros(L+2, L+2);
+NumNeighboursArray = zeros(L,1);
+SumProbArray = zeros(L,1);
+
+% Assumption
+v_user_max = 5; % m/s % Bounded Speed
+t_request = 1; % Period of request time is 5 seconds
+distance_max = v_user_max*t_request;
+sigma = distance_max;
+
+if Norm_On == 1 
+    distance_max = v_user_max*t_request/Std_Location(1);
+    sigma = distance_max;
+end
+%-------------------------------------------------------------
+%%%% Build Map Distance 
+%-------------------------------------------------------------
+
+for ii = 1:L
+    X = Database(ii,1);
+    Y = Database(ii,2);
+    MapDistance(ii+2,1) = X;
+    MapDistance(ii+2,2) = Y;
+    MapDistance(1,ii+2) = X;
+    MapDistance(2,ii+2) = Y;
+    
+    CountNeighbour = 0;
+    Sum_Prob = 0;
+    for jj = 1:L
+        X1 = Database(jj,1);
+        Y1 = Database(jj,2);
+        
+        % Calculate Distance
+        MapDistance(ii+2,jj+2) = sqrt((X-X1)^2 + (Y-Y1)^2);
+      
+        if MapDistance(ii+2,jj+2)>distance_max
+            MapDistance(ii+2,jj+2) = 0;
+        else
+          %  Weight = exp(MapDistance(ii+2,jj+3)/(2*sigma^2)); % Based on Gaussian
+            ProbFactor = -1/(2*(sigma^2)*(exp(-(distance_max^2)/(2*sigma^2)) - 1));
+            % ProbFactor = 1/(sqrt(2*pi)*sigma);
+            P_l = ProbFactor*exp(- MapDistance(ii+2,jj+2)/(2*sigma^2)); % Based on Gaussian
+            Sum_Prob = Sum_Prob+ P_l;
+            MapDistance(ii+2,jj+2) = P_l;
+            CountNeighbour = CountNeighbour + 1;
+        end
+    end
+    NumNeighboursArray(ii) = CountNeighbour;
+    SumProbArray(ii) = Sum_Prob;
+end
+
+%%% Normalized Map
+for ii = 1:L
+  Sum_Prob = SumProbArray(ii);
+  for jj = 1:L
+     if MapDistance(ii+2,jj+2) ~= 0
+        MapDistance(ii+2,jj+2) = MapDistance(ii+2,jj+2)/Sum_Prob;
+     end
+  end  
+end
+
+%%% Create CDF Map
+for ii = 1:L
+  SumCDF = 0;
+  for jj = 1:L
+     if MapDistance(ii+2,jj+2) ~= 0
+        SumCDF = SumCDF + MapDistance(ii+2,jj+2);
+        MapDistance(ii+2,jj+2) = SumCDF;
+     end
+  end  
+end
+
+%%% Create Map with position 
+Pos_Map = MapDistance;
+for ii = 1:L
+    X = MapDistance(ii+2,1);
+    Y = MapDistance(ii+2,2);
+    for jj = 1:L
+         X1 = MapDistance(1,jj+2);
+         Y1 = MapDistance(2,jj+2);
+         % Searching for Position in the array
+         if MapDistance(ii+2,jj+2) ~= 0
+            for kk = 1:L 
+                X2 = MapDistance(kk+2,1);
+                Y2 = MapDistance(kk+2,2);
+                if (X2 == X1) && (Y2 == Y1)
+                    Pos_Map(ii+2,jj+2) = kk;
+                    break;
+                end
+            end
+         end
+    end
+end
+
+%-------------------------------------------------------------
+%%%% Structure: x1 y1 x2 y2 x3 y3 ... ----------------------------
+%-------------------------------------------------------------
+TrajArray = zeros(L*NumRepeatedDatabase, NumPointPerTraj*2);
+TrajOrder = zeros(L*NumRepeatedDatabase, NumPointPerTraj); 
+%%% Generate random number to choose Trajectory
+ for jj = 1:NumRepeatedDatabase % Scan all Traj
+    for ii = 1:L % Scan all database
+        TrajArray(ii+(jj-1)*L,1) = MapDistance(ii+2,1); % Point 1
+        TrajArray(ii+(jj-1)*L,2) = MapDistance(ii+2,2);
+        
+        NextPos = ii;
+        TrajOrder(ii+(jj-1)*L,1) = NextPos;
+       
+        for NumPoint = 2: NumPointPerTraj
+            RanNum = rand(1);
+            for kk=1:L % Find the neighbour
+                if MapDistance(NextPos+2,kk+2) > RanNum
+                     TrajArray(ii+(jj-1)*L,(NumPoint-1)*2+1) = MapDistance(1,kk+2); % Next Point 
+                     TrajArray(ii+(jj-1)*L,(NumPoint-1)*2+2) = MapDistance(2,kk+2);
+                     NextPos = Pos_Map(NextPos+2,kk+2);
+                     TrajOrder(ii+(jj-1)*L,NumPoint) = NextPos;
+                     break;
+                end
+            end 
+            
+        end
+    end
+end
+csvwrite([myFolder 'Traj_10points_5k_5m_s.csv'],TrajArray);

gru_Model_5_fold_1.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9a32e897683cc999c8c8450b924aff06939646f849874a705d3f9faee5e259c6
+size 396064

lstm_20k_model1.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:465b7f289a3a50fc9c88033f4a488fb80b97573ce99dbeff75876ca10162f8cc
+size 677280

lstm_20k_model2.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a8d44f20709b4372ef23e9977653b97c35b9dbd4d573a13ae6e5fe63ab57b235
+size 688480

lstm_20k_model3.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:42230c5044b3d7eca47e37f509a71d4dbdf8ce35886b865721f9856e1d35dcad
+size 518880

lstm_Model_5_DiffSpeed.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0f78a8eba2ad37c65f99f838e30145bc6103859d436319938cd3f9b3b3a32e44
+size 522080