|
1 | 1 | --- |
2 | | -title: "Microsoft Stock Prediction using LSTM or GRU" |
| 2 | +title: "MSFT Stock Prediction using LSTM or GRU" |
3 | 3 | date: 2024-06-16T00:00:00+01:00 |
4 | 4 | description: "Short Stock price analysis on MSFT, then a prediction is tested using GRU" |
5 | 5 | menu: |
6 | 6 | sidebar: |
7 | 7 | name: GRU |
8 | 8 | identifier: GRU |
9 | | - parent: finance |
| 9 | + parent: stock_prediction |
10 | 10 | weight: 9 |
| 11 | +hero: images/stock-market-prediction-using-data-mining-techniques.jpg |
11 | 12 | tags: ["Finance", "Deep Learning", "Forecasting"] |
12 | 13 | categories: ["Finance"] |
13 | 14 | --- |
14 | 15 |
|
15 | | -## Pick a stock commodity |
| 16 | +## Introduction |
16 | 17 |
|
17 | | - ' |
18 | | - ... |
19 | | - ' |
| 18 | +In this article, we will explore time series data extracted from the **stock market**, focusing on prominent technology companies such as Apple, Amazon, Google, and Microsoft. Our objective is to equip data analysts and scientists with the essential skills to effectively manipulate and interpret stock market data. |
| 19 | + |
| 20 | +To achieve this, we will utilize the *yfinance* library to fetch stock information and leverage visualization tools such as Seaborn and Matplotlib to illustrate various facets of the data. Specifically, we will explore methods to analyze stock risk based on historical performance, and implement predictive modeling using **GRU/ LSTM** models. |
| 21 | + |
| 22 | +Throughout this tutorial, we aim to address the following key questions: |
| 23 | + |
| 24 | +1. How has the stock price evolved over time? |
| 25 | +2. What is the average **daily return** of the stock? |
| 26 | +3. How does the **moving average** of the stocks vary? |
| 27 | +4. What is the **correlation** between different stocks? |
| 28 | +5. How can we forecast future stock behavior, exemplified by predicting the closing price of Apple Inc. using LSTM or GRU?" |
| 29 | + |
| 30 | +*** |
| 31 | + |
| 32 | +## Getting Data |
| 33 | +The initial step involves **acquiring and loading** the data into memory. Our source of stock data is the **Yahoo Finance** website, renowned for its wealth of financial market data and investment tools. To access this data, we'll employ the **yfinance** library, known for its efficient and Pythonic approach to downloading market data from Yahoo. For further insights into yfinance, refer to the article titled [Reliably download historical market data from with Python](https://aroussi.com/post/python-yahoo-finance). |
| 34 | + |
| 35 | +### Install Dependencies |
| 36 | +```bash |
| 37 | +pip install -qU yfinance seaborn |
| 38 | +``` |
| 39 | +### Configuration Code |
| 40 | +```python |
| 41 | +import pandas as pd |
| 42 | +import numpy as np |
| 43 | + |
| 44 | +import matplotlib.pyplot as plt |
| 45 | +import seaborn as sns |
| 46 | +sns.set_style('whitegrid') |
| 47 | +plt.style.use("fivethirtyeight") |
| 48 | +%matplotlib inline #comment if you are not using a jupyter notebook |
| 49 | + |
| 50 | +# For reading stock data from yahoo |
| 51 | +from pandas_datareader.data import DataReader |
| 52 | +import yfinance as yf |
| 53 | +from pandas_datareader import data as pdr |
| 54 | + |
| 55 | +yf.pdr_override() |
| 56 | + |
| 57 | +# For time stamps |
| 58 | +from datetime import datetime |
| 59 | + |
| 60 | +# Get Microsoft data |
| 61 | +data = yf.download("MSFT", start, end) |
| 62 | +``` |
20 | 63 |
|
21 | 64 | ## Statistical Analysis on the price |
| 65 | +### Summary |
| 66 | +```python |
| 67 | +# Summary Stats |
| 68 | +data.describe() |
| 69 | +``` |
| 70 | + |
| 71 | +### Closing Price |
| 72 | +The closing price is the last price at which the stock is traded during the regular trading day. A stock’s closing price is the standard benchmark used by investors to track its performance over time. |
| 73 | + |
| 74 | +```python |
| 75 | +plt.figure(figsize=(14, 5)) |
| 76 | +plt.plot(data['Adj Close'], label='Close Price') |
| 77 | +plt.xlabel('Date') |
| 78 | +plt.ylabel('Close Price [$]') |
| 79 | +plt.title('Stock Price History') |
| 80 | +plt.legend() |
| 81 | +plt.show() |
| 82 | +``` |
| 83 | +### Volume of Sales |
| 84 | +Volume is the amount of an asset or security that _changes hands over some period of time_, often over the course of a day. For instance, the stock trading volume would refer to the number of shares of security traded between its daily open and close. Trading volume, and changes to volume over the course of time, are important inputs for technical traders. |
| 85 | +```python |
| 86 | +plt.figure(figsize=(14, 5)) |
| 87 | +plt.plot(data['Volume'], label='Volume') |
| 88 | +plt.xlabel('Date') |
| 89 | +plt.ylabel('Volume') |
| 90 | +plt.title('Stock Price History') |
| 91 | +plt.show() |
| 92 | +``` |
22 | 93 |
|
| 94 | +### Moving Average |
| 95 | +The moving average (MA) is a simple **technical analysis** tool that smooths out price data by creating a constantly updated average price. The average is taken over a specific period of time, like 10 days, 20 minutes, 30 weeks, or any time period the trader chooses. |
| 96 | + |
| 97 | + |
| 98 | +```python |
| 99 | +ma_day = [10, 20, 50] |
| 100 | + |
| 101 | +# compute moving average (can be also done in a vectorized way) |
| 102 | +for ma in ma_day: |
| 103 | + column_name = f"{ma} days MA" |
| 104 | + data[column_name] = data['Adj Close'].rolling(ma).mean() |
| 105 | + |
| 106 | +plt.figure(figsize=(14, 5)) |
| 107 | +data[['Adj Close', '10 days MA', '20 days MA', '50 days MA']].plot() |
| 108 | +plt.xlabel('Date') |
| 109 | +plt.ylabel('Volume') |
| 110 | +plt.title('Stock Price History') |
| 111 | +plt.show() |
| 112 | +``` |
23 | 113 |
|
24 | 114 | ## Statistical Analysis on the returns |
| 115 | +Now that we've done some baseline analysis, let's go ahead and dive a little deeper. We're now going to analyze the risk of the stock. In order to do so we'll need to take a closer look at the daily changes of the stock, and not just its absolute value. Let's go ahead and use pandas to retrieve teh daily returns for the **Microsoft** stock. |
| 116 | +```python |
| 117 | +# Compute daily return in percentage |
| 118 | +data['Daily Return'] = data['Adj Close'].pct_change() |
25 | 119 |
|
| 120 | +# simple plot |
| 121 | +plt.figure(figsize=(14, 5)) |
| 122 | +data['Daily Return'].hist(bins=50) |
| 123 | +plt.title('MSFT Daily Return Distribution') |
| 124 | +plt.xlabel('Daily Return') |
| 125 | +plt.show() |
26 | 126 |
|
27 | | -## GRU Model |
| 127 | +# histogram |
| 128 | +plt.figure(figsize=(8, 5)) |
| 129 | +data['Daily Return'].plot() |
| 130 | +plt.title('MSFT Daily Return') |
| 131 | +plt.show() |
28 | 132 |
|
29 | | -### Init |
| 133 | +``` |
| 134 | +## Data Preparation |
| 135 | +```python |
| 136 | +# Create a new dataframe with only the 'Close column |
| 137 | +X = data.filter(['Adj Close']) |
| 138 | +# Convert the dataframe to a numpy array |
| 139 | +X = X.values |
| 140 | +# Get the number of rows to train the model on |
| 141 | +training_data_len = int(np.ceil(len(X)*.95)) |
30 | 142 |
|
31 | | -### Training |
| 143 | +# Scale data |
| 144 | +from sklearn.preprocessing import MinMaxScaler |
| 145 | +scaler = MinMaxScaler(feature_range=(0,1)) |
| 146 | +scaled_data = scaler.fit_transform(X) |
32 | 147 |
|
33 | | -### Testing Metrics |
34 | | -* mean squared error |
| 148 | +scaled_data |
| 149 | +``` |
| 150 | +Split training data into small chunks to ingest into LSTM and GRU |
| 151 | +```python |
| 152 | +# Create the training data set |
| 153 | +# Create the scaled training data set |
| 154 | +train_data = scaled_data[0:int(training_data_len), :] |
| 155 | +# Split the data into x_train and y_train data sets |
| 156 | +x_train = [] |
| 157 | +y_train = [] |
| 158 | +seq_length = 60 |
| 159 | +for i in range(seq_length, len(train_data)): |
| 160 | + x_train.append(train_data[i-60:i, 0]) |
| 161 | + y_train.append(train_data[i, 0]) |
| 162 | + if i<= seq_length+1: |
| 163 | + print(x_train) |
| 164 | + print(y_train, end="\n\n") |
| 165 | + |
| 166 | +# Convert the x_train and y_train to numpy arrays |
| 167 | +x_train, y_train = np.array(x_train), np.array(y_train) |
| 168 | + |
| 169 | +# Reshape the data |
| 170 | +x_train = np.reshape(x_train, (x_train.shape[0], x_train.shape[1], 1)) |
| 171 | +``` |
| 172 | + |
| 173 | +## GRU |
| 174 | +Gated-Recurrent Unit (GRU) is adopted in this part |
| 175 | +```python |
| 176 | +from tensorflow.keras.models import Sequential |
| 177 | +from tensorflow.keras.layers import GRU, Dense, Dropout |
35 | 178 |
|
| 179 | +lstm_model = Sequential() |
| 180 | +lstm_model.add(GRU(units=128, return_sequences=True, input_shape=(seq_length, 1))) |
| 181 | +lstm_model.add(Dropout(0.2)) |
| 182 | +lstm_model.add(GRU(units=64, return_sequences=False)) |
| 183 | +lstm_model.add(Dropout(0.2)) |
| 184 | +lstm_model.add(Dense(units=1)) |
36 | 185 |
|
37 | | -## LSTM Comparison |
| 186 | +lstm_model.compile(optimizer='adam', loss='mean_squared_error') |
| 187 | +lstm_model.fit(x_train, y_train, epochs=10, batch_size=4) |
| 188 | +``` |
| 189 | + |
| 190 | +## LSTM |
| 191 | +Long Short-Term Memory (LSTM) is adopted in this part |
| 192 | +```python |
| 193 | +from tensorflow.keras.layers import LSTM |
| 194 | + |
| 195 | +lstm_model = Sequential() |
| 196 | +lstm_model.add(LSTM(units=128, return_sequences=True, input_shape=(seq_length, 1))) |
| 197 | +lstm_model.add(Dropout(0.2)) |
| 198 | +lstm_model.add(LSTM(units=64, return_sequences=False)) |
| 199 | +lstm_model.add(Dropout(0.2)) |
| 200 | +lstm_model.add(Dense(units=1)) |
| 201 | + |
| 202 | +lstm_model.compile(optimizer='adam', loss='mean_squared_error') |
| 203 | +lstm_model.fit(x_train, y_train, epochs=10, batch_size=4) |
| 204 | +``` |
| 205 | + |
| 206 | + |
| 207 | +## Testing Metrics |
| 208 | +* mean squared error |
38 | 209 |
|
| 210 | +### Test Plot |
39 | 211 |
|
40 | 212 | ## Possible trading performance |
0 commit comments