import pandas as pd
import numpy as np
import sklearn 
from sklearn import preprocessing
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt

import keras
from keras import Sequential
from keras.layers.core import Dense, Activation, Dropout
from keras.layers.recurrent import LSTM
from sklearn.metrics import mean_squared_error
from sklearn.utils import shuffle
%matplotlib inline

dataframe = pd.read_csv("../datasets/sine-wave.csv")
plt.figure(figsize=(10,5))
plt.plot(dataframe)
plt.title("Sine Wave")

plt.figure(figsize=(10,5))

plt.plot(dataframe[:50])
plt.title("first 50 points")

# Window size 
#Fix the moving window size to be 50. 
# For this purpose we use pandas shift function that shifts the entire column by the number we specify. 

# we shifted the column up by 1 (hence used -1. we want to predict future values) 
# If we want to shift it down by 1, we will have to use +1) and then concatenate that to the original data.

window_size = 50
copied_dataframe = scaled_dataframe.copy()

for i in range(window_size):
    
    scaled_dataframe = pd.concat([scaled_dataframe, copied_dataframe.shift(-(i+1))], axis=1)
    
scaled_dataframe

# Remove missing values 
scaled_dataframe.dropna(axis=0, inplace=True)
scaled_dataframe

split_data = int(round(0.8*scaled_dataframe.shape[0]))
split_data

# Consider last column as output
train_data_x = train_data.iloc[:,:-1]
train_data_y = train_data.iloc[:,-1]
test_data_x = test_data.iloc[:,:-1]
test_data_y = test_data.iloc[:,-1]
print "train features shape ", train_data_x.shape
print "train label shape ", train_data_y.shape
print "test data y ", test_data_y.shape

# Reshape it for LSTM 
train_data_x = np.array(train_data_x)
test_data_x = np.array(test_data_x)
# print train_data_x.shape[0], train_data_x.shape[1]
train_data_x = train_data_x.reshape(train_data_x.shape[0],train_data_x.shape[1],1)
test_data_x = test_data_x.reshape(test_data_x.shape[0],test_data_x.shape[1],1)
print "Reshape train example x ", train_data_x.shape
print "Reshape test example x ", test_data_x.shape
input_shape = (50,1)
output = 50

model = Sequential()
model.add(LSTM(input_shape = input_shape, units= output, return_sequences = True))
model.add(Dropout(0.25))
model.add(LSTM(256))

model.add(Dropout(0.25))
model.add(Dense(1))
model.add(Activation("linear"))
model.compile(loss="mse", optimizer="adam", metrics=['accuracy'])
model.summary()

# Train

model.fit(train_data_x,train_data_y,batch_size=512,epochs=6,validation_split=0.1)

# convert actual to its original form
# test_data_y = test_data_y.values.reshape(-1,1)
test_data_y = test_data_y.reshape(test_data.shape[0],1)
# print test_data_y.shape
actual_output_scaled = scaler.inverse_transform(test_data_y)
# actual_output.shape

print "mean square error ", mean_squared_error(actual_output_scaled,predicted_output_scaled)

plt.figure(figsize=(15,7))
plt.plot(actual_output_scaled, '-b', label='actual output')
# we just visualize prediction of first 200 points because predicted and actual output overlaps completely
plt.plot(predicted_output_scaled[:200], '-r', label='predicted output')
plt.title("Actual and predicted output for sine wave")
plt.legend(loc='upper left')

# print test_data_x[0]
def movingTestWindowPrediction(number_of_future_predictions, test_data_x):
    
    preds_moving = []
    moving_test_window = [test_data_x[0,:].tolist()] # Take time predictions 
    
    moving_test_window = np.array(moving_test_window)

    for i in range(number_of_future_predictions):
        
        predicted_one_step = model.predict(moving_test_window)
        
#         print "Predicted one step ", predicted_one_step
#         print "Appended predicted one step ", predicted_one_step[0][0]
        # Append each prediction in list
        preds_moving.append(predicted_one_step[0][0])
        
        predicted_one_step = predicted_one_step.reshape(1,1,1)

        # way of concatenating 3d array
        # we always maintain the size of window i.e. 50. 
        # each iteration we remove first element from window and add predicted output at the last of window
        moving_test_window = np.concatenate((moving_test_window[:,1:,:], predicted_one_step), axis=1)

    preds_moving = np.array(preds_moving)
    preds_moving = preds_moving.reshape(preds_moving.shape[0],1)
    preds_moving = scaler.inverse_transform(preds_moving)
    
    
    
    return preds_moving
    
preds_moving = movingTestWindowPrediction(500, test_data_x)
    
    
plt.plot(actual_output_scaled)
plt.plot(preds_moving)
plt.title("Sine Wave prediction using LSTM for 500 steps")
plt.xlabel("Number of steps")
plt.ylabel("Frequency")
plt.show()