M3 Deep Learning & Artificial intelligence
1. EDA
#Install relevant packages
!pip install --upgrade -q pandas-datareader
!pip install -q stellargraph
!pip install -q chardet
#Importing relevant packages
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
from pandas_datareader import data as pdr
import datetime as dt
from tensorflow.keras import utils
import stellargraph as sg
import seaborn as sns
sns.set()
#Before importing the dataset from we define the dates, that we would like to get the data from
start = dt.datetime(2010,1,1)
end = dt.datetime.now()
#Import dataset of Microsoft stocks from Yahoo, in the time interval that is define above:
#Start date is 1/1/2020
#End date is now (the last available stock price)
temp1 = pdr.DataReader("MSFT",'yahoo', start=start, end=end)
#Copy the data so we dount have to download it everytime
data = temp1.copy()
#Get an overview of the data
data
#To work any further with the stocks, we would like to sort the values by the dates.
data = data.sort_values('Date')
#As the dataset "data" has been imported, we would like to get an overview of it. This is done by ".head()", ".info()", ".shape" & ".describe()"
#In addition, we could check if there is any Nan-Values.
data.head()
data.info()
data.shape
data.isna().sum()
data.describe()
#Discover the development of the Microsoft Stock
plt.figure(figsize=(16,6))
plt.title('Close Price History')
plt.plot(data['Close'], color = "black")
plt.xlabel('Date', fontsize=18)
plt.ylabel('Close Price USD ($)', fontsize=18)
plt.title('Microsoft', fontsize = 20)
plt.show()
In addition, it could be relevant to see where, during the period, the biggest loss and profit came. Here we can conclude that biggest loss was when the COVID-10 lockdown started.
# Create a column with the percentual change with regards to the day before.
data['Daily Return'] = data["Adj Close"].pct_change()
#Discover the daily profit/loss of the Microsoft Stock the last 10 years.
plt.figure(figsize=(16,6))
plt.title('Daily return')
plt.plot(data['Daily Return'], color = "black")
plt.xlabel('Date', fontsize=18)
plt.ylabel('Daily profit/loss in pct.', fontsize=18)
plt.title('Daily profit/loss', fontsize = 20)
plt.show()
#Importing Packages
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import pandas_datareader as web
#Define the function
def calculate_ema(prices, days, smoothing=2):
pass
#symbol = 'MSFT'
#df = web.DataReader(symbol, 'yahoo', start, end)
df = data
#Calculating EMA
def calculate_ema(prices, days, smoothing=2):
ema = [sum(prices[:days]) / days] # First method
################################################
ema = []
ema.append(sum(prices[:days]) / days) # Second method
# Creating a loop through numbers there is not in range with the day length.
def calculate_ema(prices, days, smoothing=2):
ema = [sum(prices[:days]) / days]
for price in prices[days:]:
ema.append((price * (smoothing / (1 + days))) + ema[-1] * (1 - (smoothing / (1 + days))))
return ema
#Calculating and plotting the results
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import pandas_datareader as web
from datetime import timedelta
def calculate_ema(prices, days, smoothing=2):
ema = [sum(prices[:days]) / days]
for price in prices[days:]:
ema.append((price * (smoothing / (1 + days))) + ema[-1] * (1 - (smoothing / (1 + days))))
return ema
symbol = 'MSFT'
df = temp1
# The date from which on the date is displayed
display_start_date = pd.Timestamp('today') - timedelta(days=500)
df = df[df.index > display_start_date]
ema = calculate_ema(df['Close'], 10)
price_X = np.arange(df.shape[0]) # Creates array [0, 1, 2, 3, ..., df.shape[0]]
ema_X = np.arange(10, df.shape[0]+1) # Creates array [10, 11, 12, 13, ..., df.shape[0]+1]
# we use the first 10 values to calculate the SMA,
# Afterwards we calculate the EMA for the 11th value
#Plotting the results
plt.figure(figsize=(20,10))
plt.xlabel('Days')
plt.ylabel('Price')
plt.plot(price_X, df['Close'], label='Closing Prices')
plt.plot(ema_X, ema, label='EMA')
plt.legend()
plt.show()
2. LSTM
2.1 Preprocessing for LSTM
1. Here we split the data into training and test set.
# Create a new dataframe with only the 'Close column
LSTM_temp = temp1.filter(['Close'])
# Convert the dataframe to a numpy array
dataset = LSTM_temp.values
# Get the number of rows to train the model on
training_data_len = int(np.ceil( len(dataset) * .80 )) #We use 80% traing and 20% test - this means it predicts from 2019 in july.
training_data_len
2. Normalize data
Now we move on to normalization of the data, which is the process of making the properties more consistent. This will in turn allow the model to predict more accuratly.
# Scale the data
from sklearn.preprocessing import MinMaxScaler
# Scale the data
scaler = MinMaxScaler(feature_range=(0,1))
scaled_data = scaler.fit_transform(dataset)
scaled_data
3. X_train - y_train & 4. Reshape
Next is separating the normalized data into x_train and y_train. In the same step we reshape the data. This is done because we want the input to have 3 dimensions - which is typically: data-size, number of steps and number of features.
# Create the training data set
# Create the scaled training data set
train_data = scaled_data[0:int(training_data_len), :]
# Split the data into x_train and y_train data sets
x_train = []
y_train = []
for i in range(60, len(train_data)):
x_train.append(train_data[i-60:i, 0])
y_train.append(train_data[i, 0])
if i<= 61:
print(x_train)
print(y_train)
print()
# Convert the x_train and y_train to numpy arrays
x_train, y_train = np.array(x_train), np.array(y_train)
# Reshape the data
x_train = np.reshape(x_train, (x_train.shape[0], x_train.shape[1], 1))
# x_train.shape
2.2 LSTM-model with Keras
1. Create model:
First we create and initialize the model, which is a sequential model - meaning it's a stack of layers, using previous observations to predict the next.We add layers and dense it twice in the end.
#Import libaries from tensorflow
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, LSTM
# Build the LSTM model
model = Sequential()
model.add(LSTM(128, return_sequences=True, input_shape= (x_train.shape[1], 1)))
model.add(LSTM(64, return_sequences=False))
model.add(Dense(25))
model.add(Dense(1))
2. Compile model
Next step is to compile the model:optimizer: The optimizer does the process of updating our parameters for us here. For this adam is chosen. loss: It is a number that indicates how good or bad the model is to its prediction. As it approaches 0, the error starts to decrease.
# Compile the model
model.compile(optimizer='adam', loss='mean_squared_error', metrics=['MeanSquaredError'])
model.summary()
3 & 4 Fit the model, and choose the number of epochs and the size og batch
To choose the correct number of epochs (to minimize the loss), we will create a visualization of the right amount of epochs.
history = model.fit(x_train, y_train, epochs = 40, batch_size = 32, validation_split=0.2)
# save model
#model.save("LSTM.h5")
#Plotting the results
loss_train = history.history['loss']
loss_val = history.history['val_loss']
epochs = range(0,40)
plt.figure(figsize = (10,7))
plt.plot(epochs, loss_train, color="black", label='Training loss')
plt.plot(epochs, loss_val, color="red", label='validation loss')
plt.title('Training and Validation loss')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()
plt.show()
Here we combine the model that we just created with the training data (x and y):
# Train the model
#model.fit(x_train, y_train, batch_size=32, epochs=1)
2.3 Prediction using LSTM and model evaluation
Now we move on to predicting how well our model can predict the stock price of Microsoft
# Create the testing data set
# Create a new array containing scaled values from index 1543 to 2002
test_data = scaled_data[training_data_len - 60: , :]
# Create the data sets x_test and y_test
x_test = []
y_test = dataset[training_data_len:, :]
for i in range(60, len(test_data)):
x_test.append(test_data[i-60:i, 0])
# Convert the data to a numpy array
x_test = np.array(x_test)
# Reshape the data
x_test = np.reshape(x_test, (x_test.shape[0], x_test.shape[1], 1 ))
# Get the models predicted price values
predictions = model.predict(x_test)
predictions = scaler.inverse_transform(predictions)
# Get the root mean squared error (RMSE)
rmse = np.sqrt(np.mean(((predictions - y_test) ** 2)))
rmse
The root-mean-square error (RMSE), as seen above is a frequently used measure of the differences between values predicted by a model and the values observed. RMSE depends on the scale on which the model is measured - it is just the average of the squared difference between the predicted and the actual data points - in our case 9.2$, which is pretty ok! Now we plot our result of the prediction on the 20% test set.
predictions.shape
# Plot the data
train = data[:training_data_len]
valid = data[training_data_len:]
valid['Predictions'] = predictions
# Visualize the data
plt.figure(figsize=(16,6))
plt.title('Model')
plt.xlabel('Date', fontsize=18)
plt.ylabel('Close Price USD ($)', fontsize=18)
plt.plot(train['Close'])
plt.plot(valid[['Close', 'Predictions']])
plt.legend(['Train', 'Val', 'Predictions'], loc='lower right')
plt.show()
As we see above the predictions is pretty good! the predicted line follows the valid line, which is the real stock price.
Below is a dataframe where the real prices and the predicted prices can be seen:
# Show the valid and predicted prices
valid.head(2)
On the plot below, we zoomed in to the test set only, so we better can see how the valid line and the predicted line follows each other:
plt.figure(figsize=(18,6))
plt.plot(valid)
plt.legend(['Close Price', 'Predicted Price'])
plt.scatter(x_coordinates, y_coordinates, color='red')
plt.show()
In the above, we see how the model would have predicted previous dates, where we can validate against the actual stock price.
2.4 Predicting one day ahead
Now we will try to predict tomorrows price - so we can be rich, sort of.
# Last 60 days prices
Last60Days=np.array(LSTM_temp[-60:])
# Normalizing the data just like we did for training the model
Last60Days=scaler.transform(Last60Days.reshape(-1,1))
# Changing the shape of the data to 3D
Last60Days = np.reshape(Last60Days, (Last60Days.shape[0], Last60Days.shape[1], 1 ))
Last60Days.shape
# Choosing TimeSteps as 60 because we have used the same for training
NumSamples=1
TimeSteps=60
NumFeatures=1
Last60Days=Last60Days.reshape(NumSamples,TimeSteps,NumFeatures)
# Making predictions on data
predicted_Price = model.predict(Last60Days, verbose=2)
predicted_Price = scaler.inverse_transform(predicted_Price)
predicted_Price
x_coordinates = dt.date.today()
y_coordinates = predicted_Price
#Plotting the results
plt.figure(figsize=(18,6))
plt.plot(valid[['Close', 'Predictions']])
plt.legend(['Close Price', 'Predicted Price'])
plt.scatter(x_coordinates, y_coordinates, color='red')
plt.show()
#Calculating the %-change we predict from the latest stock price:
print('what is the price today:', LSTM_temp[-1:].values)
print('What is the predicted price tommorow:', predicted_Price)
print('predicted change in percantage from todays price compared to tomorrows price:',((predicted_Price - LSTM_temp[-1:])/LSTM_temp[-1:]).values*100)
2.5 Multi-step prediction
l = temp1
l = l.filter(['Close'])
from sklearn.preprocessing import MinMaxScaler
scaler_1 = MinMaxScaler(feature_range=(0,1))
scaled_data = scaler_1.fit_transform(l)
X=scaler_1.transform(l)
# Considering the Full Data again which we extracted above
# Printing the last 10 values
print('Original Prices')
print(l[-10:])
print('###################')
# Printing last 10 values of the scaled data which we have created above for the last model
# Here we changing the shape of the data to one dimensional array because
# for Multi step data preparation we need to X input in this fashion
X=X.reshape(X.shape[0],)
print('Scaled Prices')
print(X[-10:])
# Considering the Full Data again which we extracted above
# Printing the last 10 values
print('Original Prices')
print(l[-10:])
print('###################')
# Printing last 10 values of the scaled data which we have created above for the last model
# Here we changing the shape of the data to one dimensional array because
# for Multi step data preparation we need to X input in this fashion
X=X.reshape(X.shape[0],)
print('Scaled Prices')
print(X[-10:])
# Multi step data preparation
# split into samples
X_samples = list()
y_samples = list()
NumerOfRows = len(X)
TimeSteps=10 # next day's Price Prediction is based on last how many past day's prices
FutureTimeSteps=5 # How many days in future you want to predict the prices
# Iterate thru the values to create combinations
for i in range(TimeSteps , NumerOfRows , 1):
x_sample = X[i-TimeSteps:i]
y_sample = X[i]
X_samples.append(x_sample)
y_samples.append(y_sample)
################################################
# Reshape the Input as a 3D (number of samples, Time Steps, Features)
X_data=np.array(X_samples)
X_data=X_data.reshape(X_data.shape[0],X_data.shape[1], 1)
print('\n#### Input Data shape ####')
print(X_data.shape)
# We do not reshape y as a 3D data as it is supposed to be a single column only
y_data=np.array(y_samples)
y_data=y_data.reshape(y_data.shape[0], 1)
print('\n#### Output Data shape ####')
print(y_data.shape)
input_1
# Choosing the number of testing data records
TestingRecords=5
# Splitting the data into train and test
X_train=X_data[:-TestingRecords]
X_test=X_data[-TestingRecords:]
y_train=y_data[:-TestingRecords]
y_test=y_data[-TestingRecords:]
#############################################
# Printing the shape of training and testing
print('\n#### Training Data shape ####')
print(X_train.shape)
print(y_train.shape)
print('\n#### Testing Data shape ####')
print(X_test.shape)
print(y_test.shape)
# Choosing the number of testing data records
TestingRecords=5
# Splitting the data into train and test
X_train=X_data[:-TestingRecords]
X_test=X_data[-TestingRecords:]
y_train=y_data[:-TestingRecords]
y_test=y_data[-TestingRecords:]
#############################################
# Printing the shape of training and testing
print('\n#### Training Data shape ####')
print(X_train.shape)
print(y_train.shape)
print('\n#### Testing Data shape ####')
print(X_test.shape)
print(y_test.shape)
# Visualizing the input and output being sent to the LSTM model
# Based on last 10 days prices we are learning the next 5 days of prices
for inp, out in zip(X_train[0:2], y_train[0:2]):
print(inp)
print('====>')
print(out)
print('#'*20)
# Visualizing the input and output being sent to the LSTM model
# Based on last 10 days prices we are learning the next 5 days of prices
for inp, out in zip(X_train[0:2], y_train[0:2]):
print(inp)
print('====>')
print(out)
print('#'*20)
# Defining Input shapes for LSTM
TimeSteps=X_train.shape[1]
TotalFeatures=X_train.shape[2]
print("Number of TimeSteps:", TimeSteps)
print("Number of Features:", TotalFeatures)
# Defining Input shapes for LSTM
TimeSteps=X_train.shape[1]
TotalFeatures=X_train.shape[2]
print("Number of TimeSteps:", TimeSteps)
print("Number of Features:", TotalFeatures)
# Importing the Keras libraries and packages
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.layers import LSTM
# Initialising the RNN
regressor = Sequential()
# Adding the First input hidden layer and the LSTM layer
# return_sequences = True, means the output of every time step to be shared with hidden next layer
regressor.add(LSTM(units = 10, activation = 'relu', input_shape = (TimeSteps, TotalFeatures), return_sequences=True))
# Adding the Second hidden layer and the LSTM layer
regressor.add(LSTM(units = 5, activation = 'relu', input_shape = (TimeSteps, TotalFeatures), return_sequences=True))
# Adding the Third hidden layer and the LSTM layer
regressor.add(LSTM(units = 5, activation = 'relu', return_sequences=False ))
# Adding the output layer
# Notice the number of neurons in the dense layer is now the number of future time steps
# Based on the number of future days we want to predict
regressor.add(Dense(units = FutureTimeSteps))
# Compiling the RNN
regressor.compile(optimizer = 'adam', loss = 'mean_squared_error')
###################################################################
import time
# Measuring the time taken by the model to train
StartTime=time.time()
# Fitting the RNN to the Training set
regressor.fit(X_train, y_train, batch_size = 50, epochs = 10)
EndTime=time.time()
print("############### Total Time Taken: ", round((EndTime-StartTime)/60), 'Minutes #############')
# Importing the Keras libraries and packages
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.layers import LSTM
# Initialising the RNN
regressor = Sequential()
# Adding the First input hidden layer and the LSTM layer
# return_sequences = True, means the output of every time step to be shared with hidden next layer
regressor.add(LSTM(units = 10, activation = 'relu', input_shape = (TimeSteps, TotalFeatures), return_sequences=True))
# Adding the Second hidden layer and the LSTM layer
regressor.add(LSTM(units = 5, activation = 'relu', input_shape = (TimeSteps, TotalFeatures), return_sequences=True))
# Adding the Third hidden layer and the LSTM layer
regressor.add(LSTM(units = 5, activation = 'relu', return_sequences=False ))
# Adding the output layer
# Notice the number of neurons in the dense layer is now the number of future time steps
# Based on the number of future days we want to predict
regressor.add(Dense(units = FutureTimeSteps))
# Compiling the RNN
regressor.compile(optimizer = 'adam', loss = 'mean_squared_error')
###################################################################
import time
# Measuring the time taken by the model to train
StartTime=time.time()
# Fitting the RNN to the Training set
regressor.fit(X_train, y_train, batch_size = 50, epochs = 10)
EndTime=time.time()
print("############### Total Time Taken: ", round((EndTime-StartTime)/60), 'Minutes #############')
#Save model
regressor.save('multistep.h5')
#Load model
#keras.load_model('multistep.h5')
# Making predictions on test data
predicted_Price = regressor.predict(X_test)
predicted_Price = scaler_1.inverse_transform(predicted_Price)
print('#### Predicted Prices ####')
print(predicted_Price)
# Getting the original price values for testing data
orig=y_test
orig=scaler_1.inverse_transform(y_test)
print('\n#### Original Prices ####')
print(orig)
# Making predictions on test data
predicted_Price = regressor.predict(X_test)
predicted_Price = scaler_1.inverse_transform(predicted_Price)
print('#### Predicted Prices ####')
print(predicted_Price)
# Getting the original price values for testing data
orig=y_test
orig=scaler_1.inverse_transform(y_test)
print('\n#### Original Prices ####')
print(orig)
# Making predictions on test data
Last10DaysPrices=np.array(l[-10:])
# Reshaping the data to (-1,1 )because its a single entry
Last10DaysPrices=Last10DaysPrices.reshape(-1, 1)
# Scaling the data on the same level on which model was trained
X_test=scaler_1.transform(Last10DaysPrices)
NumberofSamples=1
TimeSteps=X_test.shape[0]
NumberofFeatures=X_test.shape[1]
# Reshaping the data as 3D input
X_test=X_test.reshape(NumberofSamples,TimeSteps,NumberofFeatures)
# Generating the predictions for next 5 days
Next5DaysPrice = regressor.predict(X_test)
# Generating the prices in original scale
Next5DaysPrice = scaler_1.inverse_transform(Next5DaysPrice)
Next5DaysPrice
# Making predictions on test data
Last10DaysPrices=np.array(l[-10:])
# Reshaping the data to (-1,1 )because its a single entry
Last10DaysPrices=Last10DaysPrices.reshape(-1, 1)
# Scaling the data on the same level on which model was trained
X_test=scaler_1.transform(Last10DaysPrices)
NumberofSamples=1
TimeSteps=X_test.shape[0]
NumberofFeatures=X_test.shape[1]
# Reshaping the data as 3D input
X_test=X_test.reshape(NumberofSamples,TimeSteps,NumberofFeatures)
# Generating the predictions for next 5 days
Next5DaysPrice = regressor.predict(X_test)
# Generating the prices in original scale
Next5DaysPrice = scaler_1.inverse_transform(Next5DaysPrice)
Next5DaysPrice
Day0 =np.array(l[-1:])
next5dayspredict = np.append(Day0, Next5DaysPrice)
#Plotting the results
A = pd.DataFrame(next5dayspredict, columns=['Price'])
plt.plot(A)
plt.xlabel('No. of days')
plt.ylabel('Price')
plt.title("Predicting the next 5 days's stock prices")
plt.show()
# Print last price and predicted price for the next day
price_today = np.round(Day0[0], 2)
predicted_price = np.round(next5dayspredict[5])
change_percent = np.round(100 - (price_today[0] * 100)/predicted_price, 2)
today = dt.datetime.today()
plus = '+'; minus = ''
print(f'The close price for Microsoft at {today} was {price_today}')
print(f'The predicted close price is {predicted_price} ({plus if change_percent > 0 else minus}{change_percent}%)')
3. RNN Model
In addition to the LSTM, we created a RNN model to compare the models, to conclude which one would be the best for the purpose of predicting the Microsoft stock price.
#Plotting the results
plt.figure(figsize=(16,6))
plt.title('Close Price History')
plt.plot(df['Close'])
plt.xlabel('Date', fontsize=18)
plt.ylabel('Close Price USD ($)', fontsize=18)
plt.show()
3.1 Preprocessing
# Create a new dataframe with only the 'Close column
data = temp1.filter(['Close'])
# Convert the dataframe to a numpy array
dataset = data.values
# Get the number of rows to train the model on
training_data_len = int(np.ceil( len(dataset) * .80 ))
training_data_len
We normalize the data, which is the process of making the properties more consistent. This will in turn allow the model to predict more accurately.
# Scale the data
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler(feature_range=(0,1))
scaled_data = scaler.fit_transform(dataset)
scaled_data
Split the dataset into a training- and a testset, when that is done we convert the x & y-train into Numpy arrays. At the end we reshape the data.
# Create the training data set
# Create the scaled training data set
train_data = scaled_data[0:int(training_data_len), :]
# Split the data into x_train and y_train data sets
x_train = []
y_train = []
for i in range(60, len(train_data)):
x_train.append(train_data[i-60:i, 0])
y_train.append(train_data[i, 0])
if i<= 61:
print(x_train)
print(y_train)
print()
# Convert the x_train and y_train to numpy arrays
x_train, y_train = np.array(x_train), np.array(y_train)
# Reshape the data
x_train = np.reshape(x_train, (x_train.shape[0], x_train.shape[1], 1))
# x_train.shape
#Importing relevant tenserflow libaries and packages
from tensorflow import keras
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.layers import SimpleRNN
from tensorflow.keras.layers import Dropout
from tensorflow.keras.layers import Dense, LSTM
3.2 Build the RNN model with Keras
Next step would be to build the model with Keras. When the model is build, we compile it right away.
# Build the LSTM model
model_rnn = Sequential()
model_rnn.add(LSTM(128, return_sequences=True, input_shape= (x_train.shape[1], 1)))
model_rnn.add(LSTM(64, return_sequences=False))
model_rnn.add(Dense(25))
model_rnn.add(Dense(1))
# Compile the model
model_rnn.compile(optimizer='adam', loss='mean_squared_error')
When the model is build, we train the model. In this case we have actually just used a batch size of 1 and with 1 epoch.
# Train the model
#model_rnn.fit(x_train, y_train, batch_size=1, epochs=1)
#save model
#model_rnn.save('RNN.h5')
#load model
model_rnn = keras.models.load_model('RNN.h5')
3.3 Predicting using RNN and model evaluation
To predict and ealuate the model, we calculate the root-mean-square error (RMSE)
# Create the testing data set
# Create a new array containing scaled values from index 1543 to 2002
test_data = scaled_data[training_data_len - 60: , :]
# Create the data sets x_test and y_test
x_test = []
y_test = dataset[training_data_len:, :]
for i in range(60, len(test_data)):
x_test.append(test_data[i-60:i, 0])
# Convert the data to a numpy array
x_test = np.array(x_test)
# Reshape the data
x_test = np.reshape(x_test, (x_test.shape[0], x_test.shape[1], 1 ))
# Get the models predicted price values
predictions_rnn = model_rnn.predict(x_test)
predictions_rnn = scaler.inverse_transform(predictions_rnn)
# Get the root mean squared error (RMSE)
rmse = np.sqrt(np.mean(((predictions - y_test) ** 2)))
rmse
The root-mean-square error (RMSE), as seen above is a frequently used measure of the differences between values predicted by a model and the values observed. RMSE depends on the scale on which the model is measured - it is just the average of the squared difference between the predicted and the actual data points - in our case 9.2$, which is pretty ok! Now we plot our result of the prediction on the 20% test set.
Now we plot the RNN model, to give a visualization
# Plotting the data and results
train = data[:training_data_len]
valid_rnn = data[training_data_len:]
valid_rnn['Predictions'] = predictions_rnn
# Visualize the dataeee
plt.figure(figsize=(16,6))
plt.title('Model')
plt.xlabel('Date', fontsize=18)
plt.ylabel('Close Price USD ($)', fontsize=18)
plt.plot(train['Close'])
plt.plot(valid[['Close', 'Predictions']])
plt.legend(['Train', 'Val', 'Predictions'], loc='lower right')
plt.show()
#Plotting the results
plt.figure(figsize=(16,6))
plt.plot(valid_rnn)
plt.legend(['Close Price', 'Predicted Price'])
plt.show()
4. Multivariate LSTM (Microsoft)
#Importing libaries and packages
from tensorflow.keras.callbacks import EarlyStopping
from tensorflow.keras.callbacks import EarlyStopping
from sklearn.metrics import mean_squared_error, r2_score, mean_absolute_error
import math
from math import sqrt
plt.style.use('ggplot')
from datetime import date, timedelta, datetime
#Define the Microsoft dataset as
df=temp1
stockname = 'Microsoft'
# Adding Month and Year in separate columns
d = pd.to_datetime(df.index)
df['Month'] = d.strftime("%m")
df['Year'] = d.strftime("%Y")
# Indexing Batches
train_df = df.sort_values(by=['Date']).copy()
# We safe a copy of the dates index, before we need to reset it to numbers
date_index = train_df.index
# We reset the index, so we can convert the date-index to a number-index
train_df = train_df.reset_index(drop=True).copy()
train_df.head(2)
# List of considered Features
FEATURES = ['High', 'Low', 'Open', 'Close', 'Volume','Adj Close','Month','Year'
]
#Printing list
print('FEATURE LIST')
print([f for f in FEATURES])
# Create the dataset with features and filter the data to the list of FEATURES
data = pd.DataFrame(train_df)
data_filtered = data[FEATURES]
# We add a prediction column and set dummy values to prepare the data for scaling
data_filtered_ext = data_filtered.copy()
data_filtered_ext['Prediction'] = data_filtered_ext['Close']
# Get the number of rows in the data
nrows = data_filtered.shape[0]
# Convert the data to numpy values
np_data_unscaled = np.array(data_filtered)
np_data = np.reshape(np_data_unscaled, (nrows, -1))
print(np_data.shape)
# Transform the data by scaling each feature to a range between 0 and 1
scaler = MinMaxScaler()
np_data_scaled = scaler.fit_transform(np_data_unscaled)
# Creating a separate scaler that works on a single column for scaling predictions
scaler_pred = MinMaxScaler()
df_Close = pd.DataFrame(data_filtered_ext['Close'])
np_Close_scaled = scaler_pred.fit_transform(df_Close)
# Set the sequence length - this is the timeframe used to make a single prediction
sequence_length = 50
# Prediction Index
index_Close = data.columns.get_loc("Close")
# Split the training data into train and train data sets
# As a first step, we get the number of rows to train the model on 80% of the data
train_data_len = math.ceil(np_data_scaled.shape[0] * 0.8)
# Create the training and test data
train_data = np_data_scaled[0:train_data_len, :]
test_data = np_data_scaled[train_data_len - sequence_length:, :]
# Here, we create N samples, sequence_length time steps per sample, and 8 features
def partition_dataset(sequence_length, data):
x, y = [], []
data_len = data.shape[0]
for i in range(sequence_length, data_len):
x.append(data[i-sequence_length:i,:]) #contains sequence_length values 0-sequence_length * columsn
y.append(data[i, index_Close]) #contains the prediction values for validation, for single-step prediction
# Convert the x and y to numpy arrays
x = np.array(x)
y = np.array(y)
return x, y
# Generate training data and test data
x_train, y_train = partition_dataset(sequence_length, train_data)
x_test, y_test = partition_dataset(sequence_length, test_data)
# Print the shapes: the result is: (rows, training_sequence, features) (prediction value, )
print(x_train.shape, y_train.shape)
print(x_test.shape, y_test.shape)
# Validate that the prediction value and the input match up
# The last close price of the second input sample should equal the first prediction value
print(x_train[1][sequence_length-1][index_Close])
print(y_train[0])
4.2 Model creation
# Configure the neural network model
model = Sequential()
# Model with n_neurons = inputshape Timestamps, each with x_train.shape[2] variables
n_neurons = x_train.shape[1] * x_train.shape[2]
print(n_neurons, x_train.shape[1], x_train.shape[2])
model.add(LSTM(n_neurons, return_sequences=True, input_shape=(x_train.shape[1], x_train.shape[2])))
model.add(LSTM(n_neurons, return_sequences=False))
model.add(Dense(5))
model.add(Dense(1))
# Compile the model
model.compile(optimizer='adam', loss='mse')
# Training the model
epochs = 50
batch_size = 16
early_stop = EarlyStopping(monitor='val_loss', min_delta=1e-4, patience=5,
verbose=1, mode='auto', restore_best_weights=True)
#history = model.fit(x_train, y_train,
# batch_size=batch_size,
# epochs=epochs,
# validation_data=(x_test, y_test),
# callbacks=[early_stop])
# Save a model
#model.save('multi_microsoft.h5')
After we ran the model training the first time we saved the result and suppresses the training and just load the trained model
#Load model
model = keras.models.load_model('multi_microsoft.h5')
We look at loss for each of the epoch iteration to the determent how the training of the model went.
#Plotting the results
loss_train = history.history['loss']
loss_val = history.history['val_loss']
epochs = range(0,40)
plt.figure(figsize = (10,7))
plt.plot(epochs, loss_train, color="black", label='Training loss')
plt.plot(epochs, loss_val, color="red", label='validation loss')
plt.title('Training and Validation loss')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()
plt.show()
Calculate the error ratings of the model
# Get the predicted values
y_pred_scaled = model.predict(x_test)
# Unscale the predicted values
y_pred = scaler_pred.inverse_transform(y_pred_scaled)
y_test_unscaled = scaler_pred.inverse_transform(y_test.reshape(-1, 1))
# Mean Squared Error (MSE)
MSE = mean_squared_error(y_test_unscaled, y_pred)
print(f'Median Squared Error (MSE): {np.round(MSE, 2)}')
# Mean Absolute Error (MAE)
MAE = mean_absolute_error(y_test_unscaled, y_pred)
print(f'Median Absolute Error (MAE): {np.round(MAE, 2)}')
# Mean Absolute Percentage Error (MAPE)
MAPE = np.mean((np.abs(np.subtract(y_test_unscaled, y_pred)/ y_test_unscaled))) * 100
print(f'Mean Absolute Percentage Error (MAPE): {np.round(MAPE, 2)} %')
# Median Absolute Percentage Error (MDAPE)
MDAPE = np.median((np.abs(np.subtract(y_test_unscaled, y_pred)/ y_test_unscaled)) ) * 100
print(f'Median Absolute Percentage Error (MDAPE): {np.round(MDAPE, 2)} %')
# R Squared (R2)
R2 = r2_score(y_test_unscaled, y_pred)
print(f'R Squared (R2): {np.round(R2, 2)}')
Now we visualise the models prediction and compare it to the real data.
at the bottom we show how big the difference is between the data is and if it positiv or negativ
# The date from which on the date is displayed
display_start_date = pd.Timestamp('today') - timedelta(days=500)
# Add the date column
data_filtered_sub = data_filtered.copy()
data_filtered_sub['Date'] = date_index
# Add the difference between the valid and predicted prices
train = data_filtered_sub[:train_data_len + 1]
valid = data_filtered_sub[train_data_len:]
valid.insert(1, "Prediction", y_pred.ravel(), True)
valid.insert(1, "Difference", valid["Prediction"] - valid["Close"], True)
# Zoom in to a closer timeframe
valid = valid[valid['Date'] > display_start_date]
train = train[train['Date'] > display_start_date]
# Visualize the data
fig, ax1 = plt.subplots(figsize=(22, 10), sharex=True)
xt = train['Date']; yt = train[["Close"]]
xv = valid['Date']; yv = valid[["Close", "Prediction"]]
plt.title("Predictions vs Actual Values", fontsize=20)
plt.ylabel(stockname, fontsize=18)
plt.plot(xt, yt, color="#039dfc", linewidth=2.0)
plt.plot(xv, yv["Prediction"], color="#E91D9E", linewidth=2.0)
plt.plot(xv, yv["Close"], color="black", linewidth=2.0)
plt.legend(["Train", "Test Predictions", "Actual Values"], loc="upper left")
# # Create the bar plot with the differences
x = valid['Date']
y = valid["Difference"]
# Create custom color range for positive and negative differences
valid.loc[y >= 0, 'diff_color'] = "#2BC97A"
valid.loc[y < 0, 'diff_color'] = "#C92B2B"
#Plotting the results
plt.bar(x, y, width=0.8, color=valid['diff_color'])
plt.grid()
plt.show()
Now we use the model to tell us what the closing value of the Microsoft stock would be tomorrow according to the stock
df_temp = df[-sequence_length:]
new_df = df_temp.filter(FEATURES)
today = dt.date.today()
N = sequence_length
# Get the last N day closing price values and scale the data to be values between 0 and 1
last_N_days = new_df[-sequence_length:].values
last_N_days_scaled = scaler.transform(last_N_days)
# Create an empty list and Append past N days
X_test_new = []
X_test_new.append(last_N_days_scaled)
# Convert the X_test data set to a numpy array and reshape the data
pred_price_scaled = model.predict(np.array(X_test_new))
pred_price_unscaled = scaler_pred.inverse_transform(pred_price_scaled.reshape(-1, 1))
# Print last price and predicted price for the next day
price_today = np.round(new_df['Close'][-1], 2)
predicted_price = np.round(pred_price_unscaled.ravel()[0], 2)
change_percent = np.round(100 - (price_today * 100)/predicted_price, 2)
plus = '+'; minus = ''
print(f'The close price for {stockname} at {today} was {price_today}')
print(f'The predicted close price is {predicted_price} ({plus if change_percent > 0 else minus}{change_percent}%)')
5. Multivariate LSTM (Multiple Stocks)
#Importing datasets from Yahoo finance
google1 = pdr.DataReader("GOOG",'yahoo', start=start, end=end)
amazon1 = pdr.DataReader("AMZN",'yahoo', start=start, end=end)
apple1 = pdr.DataReader("AAPL",'yahoo', start=start, end=end)
facebook1 = pdr.DataReader("FB",'yahoo', start=start, end=end)
microsoft1 = temp1
#Copy the dataset so we dont have to download them, incase of an error
google = google1.copy()
microsoft = microsoft1.copy()
apple = apple1.copy()
facebook = facebook1.copy()
amazon = amazon1.copy()
#Mergeing the datasets
merge1 = pd.merge(apple, microsoft, left_index=True, right_index=True)
merge2 = pd.merge(amazon, facebook, left_index=True, right_index=True)
merge3 = pd.merge(google, merge1, left_index=True, right_index=True)
ac_stock = pd.merge(merge2, merge3, left_index=True, right_index=True)
# Indexing Batches
train_df = ac_stock.sort_values(by=['Date']).copy()
# We safe a copy of the dates index, before we need to reset it to numbers
date_index = train_df.index
# We reset the index, so we can convert the date-index to a number-index
train_df = train_df.reset_index(drop=True).copy()
# List of considered Features
FEATURES= list(train_df.columns)
print('FEATURE LIST')
print([f for f in FEATURES])
# Create the dataset with features and filter the data to the list of FEATURES
data = pd.DataFrame(train_df)
data_filtered = data[FEATURES]
# We add a prediction column and set dummy values to prepare the data for scaling
data_filtered_ext = data_filtered.copy()
data_filtered_ext['Prediction'] = data_filtered_ext['microsoft_ac']
# Get the number of rows in the data
nrows = data_filtered.shape[0]
# Convert the data to numpy values
np_data_unscaled = np.array(data_filtered)
np_data = np.reshape(np_data_unscaled, (nrows, -1))
print(np_data.shape)
# Transform the data by scaling each feature to a range between 0 and 1
scaler = MinMaxScaler()
np_data_scaled = scaler.fit_transform(np_data_unscaled)
# Creating a separate scaler that works on a single column for scaling predictions
scaler_pred = MinMaxScaler()
df_Close = pd.DataFrame(data_filtered_ext['microsoft_ac'])
np_Close_scaled = scaler_pred.fit_transform(df_Close)
# Set the sequence length - this is the timeframe used to make a single prediction
sequence_length = 50
# Prediction Index
index_Close = data.columns.get_loc("microsoft_ac")
# Split the training data into train and train data sets
# As a first step, we get the number of rows to train the model on 80% of the data
train_data_len = math.ceil(np_data_scaled.shape[0] * 0.8)
# Create the training and test data
train_data = np_data_scaled[0:train_data_len, :]
test_data = np_data_scaled[train_data_len - sequence_length:, :]
# The RNN needs data with the format of [samples, time steps, features]
# Here, we create N samples, sequence_length time steps per sample, and 6 features
def partition_dataset(sequence_length, data):
x, y = [], []
data_len = data.shape[0]
for i in range(sequence_length, data_len):
x.append(data[i-sequence_length:i,:]) #contains sequence_length values 0-sequence_length * columsn
y.append(data[i, index_Close]) #contains the prediction values for validation, for single-step prediction
# Convert the x and y to numpy arrays
x = np.array(x)
y = np.array(y)
return x, y
# Generate training data and test data
x_train, y_train = partition_dataset(sequence_length, train_data)
x_test, y_test = partition_dataset(sequence_length, test_data)
# Print the shapes: the result is: (rows, training_sequence, features) (prediction value, )
print(x_train.shape, y_train.shape)
print(x_test.shape, y_test.shape)
# Validate that the prediction value and the input match up
# The last close price of the second input sample should equal the first prediction value
print(x_train[1][sequence_length-1][index_Close])
print(y_train[0])
4.2 Model creation
# Configure the neural network model
model = Sequential()
# Model with n_neurons = inputshape Timestamps, each with x_train.shape[2] variables
n_neurons = x_train.shape[1] * x_train.shape[2]
print(n_neurons, x_train.shape[1], x_train.shape[2])
model.add(LSTM(n_neurons, return_sequences=True, input_shape=(x_train.shape[1], x_train.shape[2])))
model.add(LSTM(n_neurons, return_sequences=False))
model.add(Dense(5))
model.add(Dense(1))
# Compile the model
model.compile(optimizer='adam', loss='mse')
# Training the model
epochs = 15
batch_size = 16
early_stop = EarlyStopping(monitor='val_loss', min_delta=1e-4, patience=5,
verbose=1, mode='auto', restore_best_weights=True)
history = model.fit(x_train, y_train,
batch_size=batch_size,
epochs=epochs,
validation_data=(x_test, y_test),
callbacks=[early_stop])
# Save a model
#model.save('multi_5_techs_stocks1.h5')
#Load model
model = keras.models.load_model('/work/multi_5_techs_tocks.h5')
Model evaluation
#Plotting the results
loss_train = history.history['loss']
loss_val = history.history['val_loss']
epochs = range(0,12)
plt.figure(figsize = (10,7))
plt.plot(epochs, loss_train, color="black", label='Training loss')
plt.plot(epochs, loss_val, color="red", label='validation loss')
plt.title('Training and Validation loss')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()
plt.show()
Calculate the error ratings of the model
# Get the predicted values
y_pred_scaled = model.predict(x_test)
# Unscale the predicted values
y_pred = scaler_pred.inverse_transform(y_pred_scaled)
y_test_unscaled = scaler_pred.inverse_transform(y_test.reshape(-1, 1))
# Mean Squared Error (MSE)
MSE = mean_squared_error(y_test_unscaled, y_pred)
print(f'Mean Squared Error (MSE): {np.round(MSE, 2)}')
#Root Mean Squared Error (RMSE)
rmse = np.sqrt(np.mean(((y_pred_scaled - y_test)**2)))
print(f'Root Mean Absolute Error (RMSE): {np.round(rmse, 2)}')
# Mean Absolute Error (MAE)
MAE = mean_absolute_error(y_test_unscaled, y_pred)
print(f'Mean Absolute Error (MAE): {np.round(MAE, 2)}')
# Mean Absolute Percentage Error (MAPE)
MAPE = np.mean((np.abs(np.subtract(y_test_unscaled, y_pred)/ y_test_unscaled))) * 100
print(f'Mean Absolute Percentage Error (MAPE): {np.round(MAPE, 2)} %')
# Median Absolute Percentage Error (MDAPE)
MDAPE = np.median((np.abs(np.subtract(y_test_unscaled, y_pred)/ y_test_unscaled)) ) * 100
print(f'Median Absolute Percentage Error (MDAPE): {np.round(MDAPE, 2)} %')
# R Squared (R2)
R2 = r2_score(y_test_unscaled, y_pred)
print(f'R Squared (R2): {np.round(R2, 2)}')
Multivariate LSTM predictions
# The date from which on the date is displayed
display_start_date = pd.Timestamp('today') - timedelta(days=500)
# Add the date column
data_filtered_sub = data_filtered.copy()
data_filtered_sub['Date'] = date_index
# Add the difference between the valid and predicted prices
train = data_filtered_sub[:train_data_len + 1]
valid = data_filtered_sub[train_data_len:]
valid.insert(1, "Prediction", y_pred.ravel(), True)
valid.insert(1, "Difference", valid["Prediction"] - valid["microsoft_ac"], True)
# Zoom in to a closer timeframe
valid = valid[valid['Date'] > display_start_date]
train = train[train['Date'] > display_start_date]
# Visualize the data
fig, ax1 = plt.subplots(figsize=(22, 10), sharex=True)
xt = train['Date']; yt = train[["microsoft_ac"]]
xv = valid['Date']; yv = valid[["microsoft_ac", "Prediction"]]
plt.title("Predictions vs Actual Values", fontsize=20)
plt.ylabel(stockname, fontsize=18)
plt.plot(xt, yt, color="#039dfc", linewidth=2.0)
plt.plot(xv, yv["Prediction"], color="#E91D9E", linewidth=2.0)
plt.plot(xv, yv["microsoft_ac"], color="black", linewidth=2.0)
plt.legend(["Train", "Test Predictions", "Actual Values"], loc="upper left")
# # Create the bar plot with the differences
x = valid['Date']
y = valid["Difference"]
# Create custom color range for positive and negative differences
valid.loc[y >= 0, 'diff_color'] = "#2BC97A"
valid.loc[y < 0, 'diff_color'] = "#C92B2B"
#Plotting the results
plt.bar(x, y, width=0.8, color=valid['diff_color'])
plt.grid()
plt.show()
df_temp = ac_stock[-sequence_length:]
new_df = df_temp.filter(FEATURES)
N = sequence_length
# Get the last N day closing price values and scale the data to be values between 0 and 1
last_N_days = new_df[-sequence_length:].values
last_N_days_scaled = scaler.transform(last_N_days)
# Create an empty list and Append past N days
X_test_new = []
X_test_new.append(last_N_days_scaled)
# Convert the X_test data set to a numpy array and reshape the data
pred_price_scaled = model.predict(np.array(X_test_new))
pred_price_unscaled = scaler_pred.inverse_transform(pred_price_scaled.reshape(-1, 1))
# Print last price and predicted price for the next day
price_today = np.round(new_df['microsoft_ac'][-1], 2)
predicted_price = np.round(pred_price_unscaled.ravel()[0], 2)
change_percent = np.round(100 - (price_today * 100)/predicted_price, 2)
plus = '+'; minus = ''
print(f'The close price for {stockname} at {today} was {price_today}')
print(f'The predicted close price is {predicted_price} ({plus if change_percent > 0 else minus}{change_percent}%)')