# DESKRIPSI PROYEK
NOTEBOOK_TITLE = 'taruma_udemy_rnn'
NOTEBOOK_VERSION = '1.0.0'
NOTEBOOK_NAME = "{}_{}".format(NOTEBOOK_TITLE, NOTEBOOK_VERSION.replace('.','_'))
print(f"NOTEBOOK_NAME = {NOTEBOOK_NAME}")

# MEMERIKSA VERSI PADA SISTEM
import sys
import keras
print("python version: {}".format(sys.version))
print("keras version: {}".format(keras.__version__))

# MENGGUNAKAN DATAFRAME INTERAKTIF
%load_ext google.colab.data_table

# MENGHUBUNGKAN DENGAN GOOGLE DRIVE
from google.colab import drive
drive.mount('/content/gdrive')
DROP_DRIVE = '/content/gdrive/My Drive/Colab Notebooks/_dropbox'

# AMBIL DATASET
!wget -O superdatascience_rnn_udemy.zip "https://sds-platform-private.s3-us-east-2.amazonaws.com/uploads/P16-Recurrent-Neural-Networks.zip"
!unzip superdatascience_rnn_udemy.zip

# MENENTUKAN DATASET PATH
DROP_DIRECTORY = 'Recurrent_Neural_Networks'
FILE_TRAIN = 'Google_Stock_Price_Train.csv'
FILE_TEST = 'Google_Stock_Price_Test.csv'

path_train = "{}/{}".format(DROP_DIRECTORY, FILE_TRAIN)
path_test = "{}/{}".format(DROP_DIRECTORY, FILE_TEST)
print(f'Training dataset: {path_train}')
print(f'Test dataset: {path_test}')

# IMPORT THE LIBRARIES
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd

# IMPORT TRAINING SET
dataset_train = pd.read_csv(path_train)
dataset_train

training_set = dataset_train.iloc[:, 1:2].values # 1:2 to create numpy array not simple vector
print(f'training_set.shape = {training_set.shape}')
training_set

# FEATURE SCALING
from sklearn.preprocessing import MinMaxScaler
sc = MinMaxScaler(feature_range=(0, 1))
training_set_scaled = sc.fit_transform(training_set)
training_set_scaled

# CREATING A DATA STRUCTURE WITH 60 TIMESTEPS AND 1 OUTPUT
X_train = []
y_train = []

N_TIMESTEPS = 60
COLUMN = 0
row = training_set.shape[0] # 1258

for i in range(N_TIMESTEPS, row):
    X_train.append(training_set_scaled[i-N_TIMESTEPS:i, COLUMN])
    y_train.append(training_set_scaled[i, COLUMN])
    
X_train, y_train = np.array(X_train), np.array(y_train)
print(f"X_train.shape = {X_train.shape}")
print(X_train)
print(f"y_train.shape = {y_train.shape}")
print(y_train)

# RESHAPING
X_train = np.reshape(X_train, (X_train.shape[0], X_train.shape[1], 1))
print(f"X_train.shape = {X_train.shape}")

# IMPORT LIBRARIES
from keras.models import Sequential
from keras.layers import Dense, LSTM, Dropout

# INITIALIZING THE RNN
regressor = Sequential()

# ADDING THE FIRST LSTM LAYER AND SOME DROPOUT REGULARISATION
regressor.add(LSTM(units=50, return_sequences=True, input_shape=(X_train.shape[1], 1)))
regressor.add(Dropout(rate=0.2))

# ADDDING A SECOND LAYERS
regressor.add(LSTM(units=50, return_sequences=True))
regressor.add(Dropout(rate=0.2))

# ADDDING A THIRD LAYERS
regressor.add(LSTM(units=50, return_sequences=True))
regressor.add(Dropout(rate=0.2))

# ADDING A FOURTH/LAST LAYERS
regressor.add(LSTM(units=50, return_sequences=False))
regressor.add(Dropout(rate=0.2))

# ADDING THE OUTPUT LAYERS
regressor.add(Dense(units=1))

# COMPILE THE RNN
# Choosing optimizer = https://keras.io/optimizers/
# Choosing losses = https://keras.io/losses/
regressor.compile(optimizer='adam', loss='mean_squared_error')

# SUMMARY MODEL
regressor.summary()

# FITTING RNN
regressor.fit(X_train, y_train, epochs=100, batch_size=32)

# SIMPAN MODEL
final_model = regressor

# Save model object
save_model = DROP_DRIVE + '/{}.h5'.format(NOTEBOOK_NAME)
final_model.save(save_model)
print('MODEL: {}'.format(save_model))

# Save Model in JSON
save_model_json = DROP_DRIVE + '/{}.json'.format(NOTEBOOK_NAME)
with open(save_model_json, 'w') as json_file:
    json_file.write(final_model.to_json())
print('MODEL JSON: {}'.format(save_model_json))

# Save Weights of model
save_weight_model = DROP_DRIVE + '/{}_weights.h5'.format(NOTEBOOK_NAME)
final_model.save_weights(save_weight_model)
print('MODEL WEIGHTS: {}'.format(save_weight_model))

# IMPORT TEST SET
dataset_test = pd.read_csv(path_test)
real_stock_price = dataset_test.iloc[:, 1:2].values
dataset_test

print(f"real_stock_price.shape = {real_stock_price.shape}")
dataset_test.plot(x='Date', y='Open');

# GETTING THE PREDICTED STOCK PRICE OF 2017
# concate data
dataset_total = pd.concat((dataset_train['Open'], dataset_test['Open']), axis=0)
index_inputs = len(dataset_total) - len(dataset_test) - N_TIMESTEPS
inputs = dataset_total[index_inputs:].values
print(f"inputs.shape = {inputs.shape}")
print(inputs)

# RESHAPE TO 2D TENSOR
inputs = inputs.reshape(-1, 1)
print(f"inputs.shape = {inputs.shape}")
print(inputs[:5, 0])
# SCALING
inputs = sc.transform(inputs)
print(inputs[:5, 0])

# RESHAPE TO 3D TENSOR
X_test = []
row, _ = inputs.shape

COLUMN = 0

for i in range(N_TIMESTEPS, row):
    X_test.append(inputs[i-N_TIMESTEPS:i, COLUMN])

X_test = np.array(X_test)
X_test = np.reshape(X_test, (X_test.shape[0], X_test.shape[1], 1))
print(f"X_test.shape = {X_test.shape}")

# PREDICT RESUTLS
predicted_stock_price = regressor.predict(X_test)
print(f"predicted_stock_price.shape = {predicted_stock_price.shape}")
predicted_stock_price

# INVERSE SCALING
predicted_stock_price = sc.inverse_transform(predicted_stock_price)
predicted_stock_price

plt.plot(real_stock_price, color='red', label='Real Google Stock Price')
plt.plot(predicted_stock_price, color='blue', label='Predicted Google Stock Price')
plt.title('Google Stock Price Prediction')
plt.xlabel('Time')
plt.ylabel('Google Stock Price')
plt.legend()
plt.show();