LSTMFuture

import pandas as pd
import numpy as np
import seaborn as sns
import csv
from pandas import read_csv
from pandas import datetime
from matplotlib import pyplot
from datetime import date
import matplotlib.pyplot as plt
from pylab import rcParams
import statsmodels.api as sm
from sklearn.preprocessing import MinMaxScaler
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import LSTM
from keras.layers import Dropout
from sklearn.metrics import mean_squared_error
from keras.callbacks import ReduceLROnPlateau, EarlyStopping, ModelCheckpoint, LearningRateScheduler
from sklearn.metrics import mean_squared_error
from sklearn.metrics import mean_absolute_error
from keras.layers.core import Activation
from keras.layers import Bidirectional

import tensorflow as tf
from tensorflow.keras.layers import Dense, LSTM
from tensorflow.keras.models import Sequential
from sklearn.preprocessing import MinMaxScaler
pd.options.mode.chained_assignment = None
tf.random.set_seed(0)

# read the csv file
dataset = pd.read_csv("ABC.csv")
dataset['Tanggal'] = pd.to_datetime(dataset['Tanggal'])
dataset = dataset.sort_values('Tanggal')
dataset = dataset.groupby('Tanggal')['Harga'].sum().reset_index()
dataset.set_index('Tanggal', inplace=True)
dataset.head()

import plotly.express as px

#Melakukan pemeriksaan outliers
px.box(dataset, x='Harga')

y = dataset['Harga']
y.plot(figsize=(15, 6))
plt.show()

scaler = MinMaxScaler(feature_range = (0, 1))
df = scaler.fit_transform(dataset)

train_size = int(len(df) * 0.75)
train, test = df[0:train_size, :], df[train_size:len(df), :]
valid_size = int(len(train) * 0.7)
train1, valid = train[0:valid_size, :], train[valid_size:len(train), :]

def create_data_set(df, n_steps = 1):
    data_x, data_y = [], []
    for i in range(len(df) - n_steps - 1):
        a = df[i:(i + n_steps), 0]
        data_x.append(a)
        data_y.append(df[i + n_steps, 0])
    return np.array(data_x), np.array(data_y)

n_steps = 1
n_features = 1
X_train,Y_train,X_test,Y_test,X_valid,Y_valid  = [],[],[],[],[],[]

X_train,Y_train=create_data_set(train1,n_steps)
X_train = np.reshape(X_train, (X_train.shape[0], X_train.shape[1], n_features))

X_test,Y_test=create_data_set(test,n_steps)
X_test = np.reshape(X_test, (X_test.shape[0], X_test.shape[1], n_features))

X_valid,Y_valid=create_data_set(valid,n_steps)
X_valid = np.reshape(X_valid, (X_valid.shape[0], X_valid.shape[1], n_features))

model = Sequential()
model.add(LSTM(50, return_sequences = False, input_shape = (n_steps, n_features)))
# model.add(LSTM(50, return_sequences = True, input_shape = (n_steps, n_features)))
# model.add(LSTM(50, return_sequences = True))
# model.add(LSTM(50, return_sequences = False))
model.add(Dropout(0.05))
model.add(Dense(1))
model.compile(optimizer = 'adam', loss = 'mse')

call_back = EarlyStopping(monitor = 'val_loss', patience = 30, mode = 'min')
history = model.fit(X_train, Y_train, epochs = 250, batch_size = 30, validation_data = (X_valid, Y_valid), callbacks = [call_back], shuffle = False)

train_predict = model.predict(X_train)
test_predict = model.predict(X_test)

plt.figure(figsize = (15,6))
plt.plot(history.history['loss'], label = 'Train Loss')
plt.plot(history.history['val_loss'], label = 'Validation Loss')
plt.title('model loss')
plt.ylabel('loss')
plt.xlabel('epochs')
plt.legend(loc = 'upper right')
plt.show();

# # invert predictions
train_predict = scaler.inverse_transform(train_predict)
Y_train = scaler.inverse_transform([Y_train])
test_predict = scaler.inverse_transform(test_predict)
Y_test = scaler.inverse_transform([Y_test])


# Compare train data Actual vs. Prediction
plt.style.context("seaborn-white")
plt.figure(figsize=(15,6))
plt.plot(Y_train[0], 'b', label="actual")
plt.plot(train_predict, 'y', label="prediction")
plt.tight_layout()
plt.title('Train Data')
# sns.despine(top=True)
plt.subplots_adjust(left=0.07)
plt.ylabel('Price', size=15)
plt.legend(fontsize=15)
plt.show();

from sklearn.metrics import mean_absolute_percentage_error
print('Train MAPE:', mean_absolute_percentage_error(Y_train[0], train_predict[:,0]))
print('Train Mean Absolute Error:', mean_absolute_error(Y_train[0], train_predict[:,0]))
print('Test Mean Absolute Error:', mean_absolute_error(Y_test[0], test_predict[:,0]))

# Compare test data Actual vs. Prediction
plt.figure(figsize=(15,6))
plt.plot(Y_test[0], 'b', label="actual")
plt.plot(test_predict, 'y', label="prediction")
plt.tight_layout()
# sns.despine(top=True)
plt.subplots_adjust(left=0.07)
plt.ylabel('Price ( US Dollar )', size=11)
plt.xlabel('Total Test Data', size=11)
plt.legend(fontsize=15)
plt.show();

print('Test MAPE:', mean_absolute_percentage_error(Y_test[0], test_predict[:,0]))
print('Test Mean Absolute Error:', mean_absolute_error(Y_test[0], test_predict[:,0]))
print('Test Root Mean Squared Error:',np.sqrt(mean_squared_error(Y_test[0], test_predict[:,0])))

# generate the input and output sequences
n_lookback = 20  # length of input sequences (lookback period)
n_forecast = 20  # length of output sequences (forecast period)

# generate the forecasts
X_ = df[- n_lookback:]  # last available input sequence
X_ = X_.reshape(1, n_lookback, 1)

Y_ = model.predict(X_).reshape(-1, 1)
Y_ = scaler.inverse_transform(Y_)

dataset.reset_index(inplace=True)

# organize the results in a data frame
df_past = dataset
df_past.rename(columns={'Harga': 'Actual'}, inplace=True)
df_past['Forecast'] = np.nan
df_past['Forecast'].iloc[-1] = df_past['Actual'].iloc[-1]

df_future = pd.DataFrame(columns=['Tanggal', 'Actual', 'Forecast'])
df_future['Tanggal'] = pd.date_range(start=df_past['Tanggal'].iloc[-1] + pd.Timedelta(days=1), periods=n_forecast)
df_future['Forecast'] = Y_.flatten()
df_future['Actual'] = np.nan

results = df_past.append(df_future).set_index('Tanggal')

# plot the results
results.plot(title='AAPL')