Analysis/lstm_stock_predictor_fng.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# LSTM Stock Predictor Using Fear and Greed Index\n",
    "\n",
    "In this notebook, you will build and train a custom LSTM RNN that uses a 10 day window of Bitcoin fear and greed index values to predict the 11th day closing price. \n",
    "\n",
    "You will need to:\n",
    "\n",
    "1. Prepare the data for training and testing\n",
    "2. Build and train a custom LSTM RNN\n",
    "3. Evaluate the performance of the model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Preparation\n",
    "\n",
    "In this section, you will need to prepare the training and testing data for the model. The model will use a rolling 10 day window to predict the 11th day closing price.\n",
    "\n",
    "You will need to:\n",
    "1. Use the `window_data` function to generate the X and y values for the model.\n",
    "2. Split the data into 70% training and 30% testing\n",
    "3. Apply the MinMaxScaler to the X and y values\n",
    "4. Reshape the X_train and X_test data for the model. Note: The required input format for the LSTM is:\n",
    "\n",
    "```python\n",
    "reshape((X_train.shape[0], X_train.shape[1], 1))\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import hvplot.pandas\n",
    "from pathlib import Path\n",
    "import csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set the random seed for reproducibility\n",
    "# Note: This is for the homework solution, but it is good practice to comment this out and run multiple experiments to evaluate your model\n",
    "from numpy.random import seed\n",
    "seed(1)\n",
    "from tensorflow import random\n",
    "random.set_seed(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>fng_value</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>date</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2019-07-29</th>\n",
       "      <td>19</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-07-28</th>\n",
       "      <td>16</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-07-27</th>\n",
       "      <td>47</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-07-26</th>\n",
       "      <td>24</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-07-25</th>\n",
       "      <td>42</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             fng_value\n",
       "date                  \n",
       "2019-07-29          19\n",
       "2019-07-28          16\n",
       "2019-07-27          47\n",
       "2019-07-26          24\n",
       "2019-07-25          42"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Load the fear and greed sentiment data for Bitcoin\n",
    "df = pd.read_csv('../Data/btc_sentiment.csv', index_col=\"date\", infer_datetime_format=True, parse_dates=True)\n",
    "df = df.drop(columns=\"fng_classification\")\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Date\n",
       "2019-07-25    9882.429688\n",
       "2019-07-26    9847.450195\n",
       "2019-07-27    9478.320313\n",
       "2019-07-28    9531.769531\n",
       "2019-07-29    9529.889648\n",
       "Name: Close, dtype: float64"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Load the historical closing prices for Bitcoin\n",
    "df2 = pd.read_csv('../Data/btc_historic.csv', index_col=\"Date\", infer_datetime_format=True, parse_dates=True)['Close']\n",
    "df2 = df2.sort_index()\n",
    "df2.tail()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>fng_value</th>\n",
       "      <th>Close</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2019-07-25</th>\n",
       "      <td>42</td>\n",
       "      <td>9882.429688</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-07-26</th>\n",
       "      <td>24</td>\n",
       "      <td>9847.450195</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-07-27</th>\n",
       "      <td>47</td>\n",
       "      <td>9478.320313</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-07-28</th>\n",
       "      <td>16</td>\n",
       "      <td>9531.769531</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-07-29</th>\n",
       "      <td>19</td>\n",
       "      <td>9529.889648</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             fng_value        Close\n",
       "2019-07-25          42  9882.429688\n",
       "2019-07-26          24  9847.450195\n",
       "2019-07-27          47  9478.320313\n",
       "2019-07-28          16  9531.769531\n",
       "2019-07-29          19  9529.889648"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Join the data into a single DataFrame\n",
    "df = df.join(df2, how=\"inner\")\n",
    "df.tail()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>fng_value</th>\n",
       "      <th>Close</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2018-02-01</th>\n",
       "      <td>30</td>\n",
       "      <td>9114.719727</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018-02-02</th>\n",
       "      <td>15</td>\n",
       "      <td>8870.820313</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018-02-03</th>\n",
       "      <td>40</td>\n",
       "      <td>9251.269531</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018-02-04</th>\n",
       "      <td>24</td>\n",
       "      <td>8218.049805</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018-02-05</th>\n",
       "      <td>11</td>\n",
       "      <td>6937.080078</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             fng_value        Close\n",
       "2018-02-01          30  9114.719727\n",
       "2018-02-02          15  8870.820313\n",
       "2018-02-03          40  9251.269531\n",
       "2018-02-04          24  8218.049805\n",
       "2018-02-05          11  6937.080078"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This function accepts the column number for the features (X) and the target (y)\n",
    "# It chunks the data up with a rolling window of Xt-n to predict Xt\n",
    "# It returns a numpy array of X any y\n",
    "def window_data(df, window, feature_col_number, target_col_number):\n",
    "    X = []\n",
    "    y = []\n",
    "    for i in range(len(df) - window - 1):\n",
    "        features = df.iloc[i:(i + window), feature_col_number]\n",
    "        target = df.iloc[(i + window), target_col_number]\n",
    "        X.append(features)\n",
    "        y.append(target)\n",
    "    return np.array(X), np.array(y).reshape(-1, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Predict Closing Prices using a 10 day window of previous fng values\n",
    "# Then, experiment with window sizes anywhere from 1 to 10 and see how the model performance changes\n",
    "window_size = 10\n",
    "\n",
    "# Column index 0 is the 'fng_value' column\n",
    "# Column index 1 is the `Close` column\n",
    "feature_column = 0\n",
    "target_column = 1\n",
    "X, y = window_data(df, window_size, feature_column, target_column)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use 70% of the data for training and the remaineder for testing\n",
    "split = int(0.7 * len(X))\n",
    "X_train = X[: split]\n",
    "X_test = X[split:]\n",
    "y_train = y[: split]\n",
    "y_test = y[split:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import MinMaxScaler\n",
    "# Use the MinMaxScaler to scale data between 0 and 1.\n",
    "scaler = MinMaxScaler()\n",
    "scaler.fit(X)\n",
    "X_train = scaler.transform(X_train)\n",
    "X_test = scaler.transform(X_test)\n",
    "scaler.fit(y)\n",
    "y_train = scaler.transform(y_train)\n",
    "y_test = scaler.transform(y_test)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X_train sample values:\n",
      "[[[0.25287356]\n",
      "  [0.08045977]\n",
      "  [0.36781609]\n",
      "  [0.18390805]\n",
      "  [0.03448276]\n",
      "  [0.        ]\n",
      "  [0.31395349]\n",
      "  [0.24418605]\n",
      "  [0.40697674]\n",
      "  [0.52325581]]\n",
      "\n",
      " [[0.08045977]\n",
      "  [0.36781609]\n",
      "  [0.18390805]\n",
      "  [0.03448276]\n",
      "  [0.        ]\n",
      "  [0.32183908]\n",
      "  [0.24418605]\n",
      "  [0.40697674]\n",
      "  [0.52325581]\n",
      "  [0.25581395]]\n",
      "\n",
      " [[0.36781609]\n",
      "  [0.18390805]\n",
      "  [0.03448276]\n",
      "  [0.        ]\n",
      "  [0.32183908]\n",
      "  [0.25287356]\n",
      "  [0.40697674]\n",
      "  [0.52325581]\n",
      "  [0.25581395]\n",
      "  [0.38372093]]\n",
      "\n",
      " [[0.18390805]\n",
      "  [0.03448276]\n",
      "  [0.        ]\n",
      "  [0.32183908]\n",
      "  [0.25287356]\n",
      "  [0.4137931 ]\n",
      "  [0.52325581]\n",
      "  [0.25581395]\n",
      "  [0.38372093]\n",
      "  [0.30232558]]\n",
      "\n",
      " [[0.03448276]\n",
      "  [0.        ]\n",
      "  [0.32183908]\n",
      "  [0.25287356]\n",
      "  [0.4137931 ]\n",
      "  [0.52873563]\n",
      "  [0.25581395]\n",
      "  [0.38372093]\n",
      "  [0.30232558]\n",
      "  [0.53488372]]] \n",
      "\n",
      "X_test sample values:\n",
      "[[[0.36781609]\n",
      "  [0.43678161]\n",
      "  [0.34482759]\n",
      "  [0.45977011]\n",
      "  [0.45977011]\n",
      "  [0.40229885]\n",
      "  [0.39534884]\n",
      "  [0.37209302]\n",
      "  [0.3372093 ]\n",
      "  [0.62790698]]\n",
      "\n",
      " [[0.43678161]\n",
      "  [0.34482759]\n",
      "  [0.45977011]\n",
      "  [0.45977011]\n",
      "  [0.40229885]\n",
      "  [0.40229885]\n",
      "  [0.37209302]\n",
      "  [0.3372093 ]\n",
      "  [0.62790698]\n",
      "  [0.65116279]]\n",
      "\n",
      " [[0.34482759]\n",
      "  [0.45977011]\n",
      "  [0.45977011]\n",
      "  [0.40229885]\n",
      "  [0.40229885]\n",
      "  [0.37931034]\n",
      "  [0.3372093 ]\n",
      "  [0.62790698]\n",
      "  [0.65116279]\n",
      "  [0.58139535]]\n",
      "\n",
      " [[0.45977011]\n",
      "  [0.45977011]\n",
      "  [0.40229885]\n",
      "  [0.40229885]\n",
      "  [0.37931034]\n",
      "  [0.34482759]\n",
      "  [0.62790698]\n",
      "  [0.65116279]\n",
      "  [0.58139535]\n",
      "  [0.58139535]]\n",
      "\n",
      " [[0.45977011]\n",
      "  [0.40229885]\n",
      "  [0.40229885]\n",
      "  [0.37931034]\n",
      "  [0.34482759]\n",
      "  [0.63218391]\n",
      "  [0.65116279]\n",
      "  [0.58139535]\n",
      "  [0.58139535]\n",
      "  [0.60465116]]]\n"
     ]
    }
   ],
   "source": [
    "# Reshape the features for the model\n",
    "X_train = X_train.reshape((X_train.shape[0], X_train.shape[1], 1))\n",
    "X_test = X_test.reshape((X_test.shape[0], X_test.shape[1], 1))\n",
    "print (f\"X_train sample values:\\n{X_train[:5]} \\n\")\n",
    "print (f\"X_test sample values:\\n{X_test[:5]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Build and Train the LSTM RNN\n",
    "\n",
    "In this section, you will design a custom LSTM RNN and fit (train) it using the training data.\n",
    "\n",
    "You will need to:\n",
    "1. Define the model architecture\n",
    "2. Compile the model\n",
    "3. Fit the model to the training data\n",
    "\n",
    "### Hints:\n",
    "You will want to use the same model architecture and random seed for both notebooks. This is necessary to accurately compare the performance of the FNG model vs the closing price model. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import LSTM, Dense, Dropout"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Build the LSTM model. \n",
    "# The return sequences need to be set to True if you are adding additional LSTM layers, but \n",
    "# You don't have to do this for the final layer. \n",
    "# Note: The dropouts help prevent overfitting\n",
    "# Note: The input shape is the number of time steps and the number of indicators\n",
    "# Note: Batching inputs has a different input shape of Samples/TimeSteps/Features\n",
    "\n",
    "model = Sequential()\n",
    "\n",
    "number_units = 5\n",
    "dropout_fraction = 0.2\n",
    "\n",
    "# Layer 1\n",
    "model.add(LSTM(\n",
    "    units=number_units,\n",
    "    return_sequences=True,\n",
    "    input_shape=(X_train.shape[1], 1))\n",
    "    )\n",
    "model.add(Dropout(dropout_fraction))\n",
    "# Layer 2\n",
    "model.add(LSTM(units=number_units, return_sequences=True))\n",
    "model.add(Dropout(dropout_fraction))\n",
    "# Layer 3\n",
    "model.add(LSTM(units=number_units))\n",
    "model.add(Dropout(dropout_fraction))\n",
    "# Output layer\n",
    "model.add(Dense(1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compile the model\n",
    "model.compile(optimizer=\"adam\", loss=\"mean_squared_error\") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "lstm (LSTM)                  (None, 10, 5)             140       \n",
      "_________________________________________________________________\n",
      "dropout (Dropout)            (None, 10, 5)             0         \n",
      "_________________________________________________________________\n",
      "lstm_1 (LSTM)                (None, 10, 5)             220       \n",
      "_________________________________________________________________\n",
      "dropout_1 (Dropout)          (None, 10, 5)             0         \n",
      "_________________________________________________________________\n",
      "lstm_2 (LSTM)                (None, 5)                 220       \n",
      "_________________________________________________________________\n",
      "dropout_2 (Dropout)          (None, 5)                 0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 1)                 6         \n",
      "=================================================================\n",
      "Total params: 586\n",
      "Trainable params: 586\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "# Summarize the model\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "372/372 [==============================] - 4s 4ms/step - loss: 0.1600\n",
      "Epoch 2/10\n",
      "372/372 [==============================] - 2s 4ms/step - loss: 0.0954\n",
      "Epoch 3/10\n",
      "372/372 [==============================] - 2s 4ms/step - loss: 0.0996\n",
      "Epoch 4/10\n",
      "372/372 [==============================] - 2s 4ms/step - loss: 0.0952\n",
      "Epoch 5/10\n",
      "372/372 [==============================] - 2s 4ms/step - loss: 0.0940\n",
      "Epoch 6/10\n",
      "372/372 [==============================] - 2s 4ms/step - loss: 0.0893\n",
      "Epoch 7/10\n",
      "372/372 [==============================] - 2s 4ms/step - loss: 0.0935\n",
      "Epoch 8/10\n",
      "372/372 [==============================] - 2s 4ms/step - loss: 0.0882\n",
      "Epoch 9/10\n",
      "372/372 [==============================] - 1s 4ms/step - loss: 0.0821\n",
      "Epoch 10/10\n",
      "372/372 [==============================] - 2s 4ms/step - loss: 0.0835\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.keras.callbacks.History at 0x7fb54d65e190>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Train the model\n",
    "# Use at least 10 epochs\n",
    "# Do not shuffle the data\n",
    "# Experiement with the batch size, but a smaller batch size is recommended\n",
    "model.fit(X_train, y_train, epochs=10, shuffle=False, batch_size=1, verbose=1) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model Performance\n",
    "\n",
    "In this section, you will evaluate the model using the test data. \n",
    "\n",
    "You will need to:\n",
    "1. Evaluate the model using the `X_test` and `y_test` data.\n",
    "2. Use the X_test data to make predictions\n",
    "3. Create a DataFrame of Real (y_test) vs predicted values. \n",
    "4. Plot the Real vs predicted values as a line chart\n",
    "\n",
    "### Hints\n",
    "Remember to apply the `inverse_transform` function to the predicted and y_test values to recover the actual closing prices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Evaluate the model\n",
    "predicted = model.predict(X_test) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5/5 [==============================] - 0s 2ms/step - loss: 0.1088\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.1087786927819252"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Make some predictions\n",
    "model.evaluate(X_test, y_test) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Recover the original prices instead of the scaled version\n",
    "predicted_prices = scaler.inverse_transform(predicted)\n",
    "real_prices = scaler.inverse_transform(y_test.reshape(-1, 1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Real</th>\n",
       "      <th>Predicted</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2019-02-20</th>\n",
       "      <td>3924.239990</td>\n",
       "      <td>4805.774902</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-02-21</th>\n",
       "      <td>3974.050049</td>\n",
       "      <td>4875.478027</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-02-22</th>\n",
       "      <td>3937.040039</td>\n",
       "      <td>4945.709473</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-02-23</th>\n",
       "      <td>3983.530029</td>\n",
       "      <td>5049.415527</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-02-24</th>\n",
       "      <td>4149.089844</td>\n",
       "      <td>5121.046387</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                   Real    Predicted\n",
       "2019-02-20  3924.239990  4805.774902\n",
       "2019-02-21  3974.050049  4875.478027\n",
       "2019-02-22  3937.040039  4945.709473\n",
       "2019-02-23  3983.530029  5049.415527\n",
       "2019-02-24  4149.089844  5121.046387"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a DataFrame of Real and Predicted values\n",
    "stocks = pd.DataFrame({\n",
    "    \"Real\": real_prices.ravel(),\n",
    "    \"Predicted\": predicted_prices.ravel()\n",
    "}, index = df.index[-len(real_prices): ]) \n",
    "stocks.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:>"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the real vs predicted values as a line chart\n",
    "stocks.plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "file_extension": ".py",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.7"
  },
  "mimetype": "text/x-python",
  "name": "python",
  "npconvert_exporter": "python",
  "pygments_lexer": "ipython3",
  "version": 3
 },
 "nbformat": 4,
 "nbformat_minor": 4
}