# Stock Price Prediction Using Python & Machine Learning

Using Python & Long Short-Term Memory (LSTM)

*Disclaimer: **The material in this article is purely educational and should not be taken as professional investment advice. Invest at your own discretion.*

In this article I will show you how to write a python program that predicts the price of stocks using a machine learning technique called **Long Short-Term Memory (LSTM)**. This program is really simple and I doubt any major profit will be made from this program, but it’s slightly better than guessing! Remember the stock price can be affected by many different things.

**Long short-term memory (LSTM)** is an artificial recurrent neural network (RNN) architecture used in the field of deep learning. Unlike standard feed forward neural networks, LSTM has feedback connections. It can not only process single data points (such as images), but also entire sequences of data (such as speech or video). — Wikipedia

LSTMs are widely used for sequence prediction problems and have proven to be extremely effective.The reason they work so well is because LSTM is able to store past information that is important, and forget the information that is not. -Stackabuse.com

**Common Architecture of LSTM:**Forget Gate

Input Gate

Output Gate

If you prefer not to read this article and would like a video representation of it, you can check out the **YouTube Video** below. It goes through everything in this article with a little more detail, and will help make it easy for you to start programming your own Machine Learning model even if you don’t have the programming language Python installed on your computer. Or you can use both as supplementary materials for learning about Machine Learning !

If you are also interested in reading more on machine learning to immediately get started with problems and examples then I strongly recommend you check out Hands-On Machine Learning with Scikit-Learn and TensorFlow: Concepts, Tools, and Techniques to Build Intelligent Systems. It is a great book for helping beginners learn how to write machine learning programs, and understanding machine learning concepts.

# Start Programming:

I will start by stating what I want this program to do. I want this program to predict the prices of Apple Inc. stock 60 days in the future based off of the current Close price.

First I will write a description about the program.

*# Description: This program uses an artificial recurrent neural network called Long Short Term Memory (LSTM) to predict the closing stock price of a corporation (Apple Inc.) using the past 60 day stock price.*

Next I will load / import the libraries that will be used throughout this program.

**#Import the libraries**

import **math**

**import** **pandas_datareader** **as** **web**

**import** **numpy** **as** **np**

**import** **pandas** **as** **pd**

**from** **sklearn.preprocessing** **import** MinMaxScaler

**from** **keras.models** **import** Sequential

**from** **keras.layers** **import** Dense, LSTM

**import** **matplotlib.pyplot** **as** **plt**

plt.style.use('fivethirtyeight')

I will get the stock quote for the company ‘Apple Inc.’ using the companies stock ticker (AAPL) from January 1st, 2012 to December 17th, 2019.

*#Get the stock quote*

df = web.DataReader('AAPL', data_source='yahoo', start='2012-01-01', end='2019-12-17')

*#Show the data*

df

Next, I will show the number of rows and columns in the data set. The result shows that we have 2003 rows or days the stock price was recorded, and 6 columns.

`df.shape`

Create a graph to visualize the data.

*#Visualize the closing price history*

plt.figure(figsize=(16,8))

plt.title('Close Price History')

plt.plot(df['Close'])

plt.xlabel('Date',fontsize=18)

plt.ylabel('Close Price USD ($)',fontsize=18)

plt.show()

Create a new data frame with only the closing price and convert it to an array.

Then create a variable to store the length of the training data set. I want the training data set to contain about 80% of the data.

#Create a new dataframe with only the 'Close' column

data = df.filter(['Close'])#Converting the dataframe to a numpy array

dataset = data.values#Get /Compute the number of rows to train the model on

training_data_len = math.ceil( len(dataset) *.8)

Now scale the data set to be values between 0 and 1 inclusive, I do this because it is generally good practice to scale your data before giving it to the neural network.

*#Scale the all of the data to be values between 0 and 1*

scaler = MinMaxScaler(feature_range=(0, 1))

scaled_data = scaler.fit_transform(dataset)

Create a training data set that contains the past 60 day closing price values that we want to use to predict the 61st closing price value.

So the first column in the ‘**x_train**’ data set will contain values from the data set from index 0 to index 59 (60 values total) and the second column will contain values from the data set from index 1 to index 60 (60 values) and so on and so forth.

The ‘**y_train**’ data set will contain the 61st value located at index 60 for it’s first column and the 62nd value located at index 61 of the data set for it’s second value and so on and so forth.

#Create the scaled training data set

train_data = scaled_data[0:training_data_len , : ]#Split the data into x_train and y_train data sets

x_train=[]

y_train = []foriinrange(60,len(train_data)):

x_train.append(train_data[i-60:i,0])

y_train.append(train_data[i,0])

Now convert the independent train data set ‘**x_train**’ and dependent train data set ‘**y_train**’ to numpy arrays so they can be used for training the LSTM model.

*#Convert x_train and y_train to numpy arrays*

x_train, y_train = np.array(x_train), np.array(y_train)

Reshape the data to be 3-dimensional in the form [number of **samples**, number of **time steps**, and number of **features**]. The LSTM model is expecting a 3-dimensional data set.

*#Reshape the data into the shape accepted by the LSTM*

x_train = np.reshape(x_train, (x_train.shape[0],x_train.shape[1],1))

Build the LSTM model to have two LSTM layers with 50 neurons and two Dense layers, one with 25 neurons and the other with 1 neuron.

*#Build the LSTM network model*

model = Sequential()

model.add(LSTM(units=50, return_sequences=**True**,input_shape=(x_train.shape[1],1)))

model.add(LSTM(units=50, return_sequences=**False**))

model.add(Dense(units=25))

model.add(Dense(units=1))

Compile the model using the mean squared error (MSE) loss function and the adam optimizer.

*#Compile the model*

model.compile(optimizer='adam', loss='mean_squared_error')

Train the model using the training data sets. Note, fit is another name for train. Batch size is the total number of training examples present in a single batch, and epoch is the number of iterations when an entire data set is passed forward and backward through the neural network.

**#Train the model**

model.fit(x_train, y_train, batch_size=1, epochs=1)

Create a test data set.

#Test data set

test_data = scaled_data[training_data_len - 60: , : ]#Create the x_test and y_test data sets

x_test = []

y_test = dataset[training_data_len : , : ]#Get all of the rows from index 1603 to the rest and all of the columns (in this case it's only column 'Close'), so 2003 - 1603 = 400 rows of dataforiinrange(60,len(test_data)):

x_test.append(test_data[i-60:i,0])

Then convert the independent test data set ‘**x_test**’ to a numpy array so it can be used for testing the LSTM model.

*#Convert x_test to a numpy array *

x_test = np.array(x_test)

Reshape the data to be 3-dimensional in the form [number of **samples**, number of **time steps**, and number of **features**]. This needs to be done, because the LSTM model is expecting a 3-dimensional data set.

*#Reshape the data into the shape accepted by the LSTM*

x_test = np.reshape(x_test, (x_test.shape[0],x_test.shape[1],1))

Now get the predicted values from the model using the test data.

*#Getting the models predicted price values*

predictions = model.predict(x_test)

predictions = scaler.inverse_transform(predictions)*#Undo scaling*

Get the root mean squared error (RMSE), which is a good measure of how accurate the model is. A value of 0 would indicate that the models predicted values match the actual values from the test data set perfectly.

The lower the value the better the model performed. But usually it is best to use other metrics as well to truly get an idea of how well the model performed.

*#Calculate/Get the value of RMSE*

rmse=np.sqrt(np.mean(((predictions- y_test)**2)))

rmse

Let’s plot and visualize the data.

#Plot/Create the data for the graph

train = data[:training_data_len]

valid = data[training_data_len:]

valid['Predictions'] = predictions#Visualize the data

plt.figure(figsize=(16,8))

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()

Show the valid and predicted prices.

*#Show the valid and predicted prices*

valid

I want to test the model some more and get the predicted closing price value of Apple Inc. for December 18, 2019 (12/18/2019).

So I will get the quote, convert the data to an array that contains only the closing price. Then I will get the last 60 day closing price and scale the data to be values between 0 and 1 inclusive.

After that I will create an empty list and append the past 60 day price to it, and then convert it to a numpy array and reshape it so that I can input the data into the model.

Last but not least, I will input the data into the model and get the predicted price.

#Get the quote

apple_quote = web.DataReader('AAPL', data_source='yahoo', start='2012-01-01', end='2019-12-17')#Create a new dataframe

new_df = apple_quote.filter(['Close'])#Get teh last 60 day closing price

last_60_days = new_df[-60:].values#Scale the data to be values between 0 and 1

last_60_days_scaled = scaler.transform(last_60_days)#Create an empty list

X_test = []#Append teh past 60 days

X_test.append(last_60_days_scaled)#Convert the X_test data set 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 predicted scaled price

pred_price = model.predict(X_test)#undo the scaling

pred_price = scaler.inverse_transform(pred_price)

print(pred_price)

Now let’s see what the actual price for that day was.

#Get the quote

apple_quote2 = web.DataReader('AAPL', data_source='yahoo', start='2019-12-18', end='2019-12-18')print(apple_quote2['Close'])

If you want to start an investment portfolio, then sign up with WeBull using this link and get **FREE stocks**** **for depositing $100 or more. It’s free stocks that you can either sell, play with or create your own trading strategy with. I think it’s a great deal for a limited time and FREE money!

Thanks for reading this article I hope its helpful to you all ! If you enjoyed this article and found it helpful please leave some claps to show your appreciation. Keep up the learning, and if you like machine learning, mathematics, computer science, programming or algorithm analysis, please visit and subscribe to my YouTube channels (randerson112358 & compsci112358 ).