Starter_Code/lstm_stock_predictor_closing.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# LSTM Stock Predictor Using Closing Prices\n",
    "\n",
    "In this notebook, you will build and train a custom LSTM RNN that uses a 10 day window of Bitcoin closing prices 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": 144,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import hvplot.pandas\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import LSTM, Dense, Dropout"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "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": 146,
   "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": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Load the fear and greed sentiment data for Bitcoin\n",
    "df = pd.read_csv('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": 147,
   "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": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Load the historical closing prices for Bitcoin\n",
    "df2 = pd.read_csv('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": 148,
   "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": 148,
     "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": 149,
   "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": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "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": 151,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Predict Closing Prices using a 10 day window of previous closing prices\n",
    "# Then, experiment with window sizes anywhere from 1 to 10 and see how the model performance changes\n",
    "window_size = 5\n",
    "\n",
    "# Column index 0 is the 'fng_value' column\n",
    "# Column index 1 is the `Close` column\n",
    "feature_column = 1\n",
    "target_column = 1\n",
    "X, y = window_data(df, window_size, feature_column, target_column)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use 70% of the data for training and the remaineder for testing\n",
    "split = int(0.7 * len(X))\n",
    "\n",
    "X_train = X[: split - 1]\n",
    "X_test = X[split:]\n",
    "\n",
    "y_train = y[: split - 1]\n",
    "y_test = y[split:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use the MinMaxScaler to scale data between 0 and 1.\n",
    "# Create a MinMaxScaler object\n",
    "scaler = MinMaxScaler()\n",
    "\n",
    "# Fit the MinMaxScaler object with the features data X\n",
    "scaler.fit(X)\n",
    "\n",
    "# Scale the features training and testing sets\n",
    "X_train = scaler.transform(X_train)\n",
    "X_test = scaler.transform(X_test)\n",
    "\n",
    "# Fit the MinMaxScaler object with the target data Y\n",
    "scaler.fit(y)\n",
    "\n",
    "# Scale the target training and testing sets\n",
    "y_train = scaler.transform(y_train)\n",
    "y_test = scaler.transform(y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X_train sample values:\n",
      "[[[0.60761794]\n",
      "  [0.58242373]\n",
      "  [0.62172321]\n",
      "  [0.51499412]\n",
      "  [0.38267307]]\n",
      "\n",
      " [[0.58242373]\n",
      "  [0.62172321]\n",
      "  [0.51499412]\n",
      "  [0.38267307]\n",
      "  [0.46160996]]\n",
      "\n",
      " [[0.62172321]\n",
      "  [0.51499412]\n",
      "  [0.38267307]\n",
      "  [0.46160996]\n",
      "  [0.4503991 ]]] \n",
      "\n",
      "X_test sample values:\n",
      "[[[0.03856719]\n",
      "  [0.03679562]\n",
      "  [0.03728835]\n",
      "  [0.03974167]\n",
      "  [0.04528668]]\n",
      "\n",
      " [[0.03679562]\n",
      "  [0.03728835]\n",
      "  [0.03974167]\n",
      "  [0.04528668]\n",
      "  [0.04528668]]\n",
      "\n",
      " [[0.03728835]\n",
      "  [0.03974167]\n",
      "  [0.04528668]\n",
      "  [0.04528668]\n",
      "  [0.07024855]]]\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",
    "\n",
    "# Print some sample data after reshaping the datasets\n",
    "print (f\"X_train sample values:\\n{X_train[:3]} \\n\")\n",
    "print (f\"X_test sample values:\\n{X_test[:3]}\")"
   ]
  },
  {
   "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": 155,
   "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",
    "# Define the LSTM RNN model.\n",
    "model = Sequential()\n",
    "\n",
    "# Initial model setup\n",
    "number_units = 10\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",
    "\n",
    "# Layer 2\n",
    "model.add(LSTM(units=number_units, return_sequences=True))\n",
    "model.add(Dropout(dropout_fraction))\n",
    "\n",
    "# Layer 3\n",
    "model.add(LSTM(units=number_units))\n",
    "model.add(Dropout(dropout_fraction))\n",
    "\n",
    "# Output layer\n",
    "model.add(Dense(1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compile the model\n",
    "model.compile(optimizer=\"adam\", loss=\"mean_squared_error\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_6\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "lstm_18 (LSTM)               (None, 5, 10)             480       \n",
      "_________________________________________________________________\n",
      "dropout_18 (Dropout)         (None, 5, 10)             0         \n",
      "_________________________________________________________________\n",
      "lstm_19 (LSTM)               (None, 5, 10)             840       \n",
      "_________________________________________________________________\n",
      "dropout_19 (Dropout)         (None, 5, 10)             0         \n",
      "_________________________________________________________________\n",
      "lstm_20 (LSTM)               (None, 10)                840       \n",
      "_________________________________________________________________\n",
      "dropout_20 (Dropout)         (None, 10)                0         \n",
      "_________________________________________________________________\n",
      "dense_6 (Dense)              (None, 1)                 11        \n",
      "=================================================================\n",
      "Total params: 2,171\n",
      "Trainable params: 2,171\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "# Summarize the model\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "75/75 [==============================] - 0s 7ms/step - loss: 0.0998\n",
      "Epoch 2/10\n",
      "75/75 [==============================] - 0s 6ms/step - loss: 0.0431\n",
      "Epoch 3/10\n",
      "75/75 [==============================] - 1s 7ms/step - loss: 0.0341\n",
      "Epoch 4/10\n",
      "75/75 [==============================] - 1s 7ms/step - loss: 0.0278\n",
      "Epoch 5/10\n",
      "75/75 [==============================] - 0s 6ms/step - loss: 0.0177\n",
      "Epoch 6/10\n",
      "75/75 [==============================] - 0s 6ms/step - loss: 0.0123\n",
      "Epoch 7/10\n",
      "75/75 [==============================] - 0s 6ms/step - loss: 0.0120\n",
      "Epoch 8/10\n",
      "75/75 [==============================] - 0s 6ms/step - loss: 0.0086\n",
      "Epoch 9/10\n",
      "75/75 [==============================] - 1s 7ms/step - loss: 0.0077\n",
      "Epoch 10/10\n",
      "75/75 [==============================] - 0s 6ms/step - loss: 0.0090\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.keras.callbacks.History at 0x7fc78aee0390>"
      ]
     },
     "execution_count": 158,
     "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=5)"
   ]
  },
  {
   "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": 159,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6/6 [==============================] - 0s 2ms/step - loss: 0.0070\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.00698684249073267"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Evaluate the model\n",
    "model.evaluate(X_test, y_test, verbose=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make some predictions\n",
    "predicted = model.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "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": 162,
   "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-18</th>\n",
       "      <td>3670.919922</td>\n",
       "      <td>3645.835693</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-02-19</th>\n",
       "      <td>3912.570068</td>\n",
       "      <td>3649.565430</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-02-20</th>\n",
       "      <td>3924.239990</td>\n",
       "      <td>3669.048096</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-02-21</th>\n",
       "      <td>3974.050049</td>\n",
       "      <td>3703.831299</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-02-22</th>\n",
       "      <td>3937.040039</td>\n",
       "      <td>3752.048828</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                   Real    Predicted\n",
       "2019-02-18  3670.919922  3645.835693\n",
       "2019-02-19  3912.570068  3649.565430\n",
       "2019-02-20  3924.239990  3669.048096\n",
       "2019-02-21  3974.050049  3703.831299\n",
       "2019-02-22  3937.040039  3752.048828"
      ]
     },
     "execution_count": 162,
     "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": 163,
   "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-18</th>\n",
       "      <td>3670.919922</td>\n",
       "      <td>3645.835693</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-02-19</th>\n",
       "      <td>3912.570068</td>\n",
       "      <td>3649.565430</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-02-20</th>\n",
       "      <td>3924.239990</td>\n",
       "      <td>3669.048096</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-02-21</th>\n",
       "      <td>3974.050049</td>\n",
       "      <td>3703.831299</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-02-22</th>\n",
       "      <td>3937.040039</td>\n",
       "      <td>3752.048828</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                   Real    Predicted\n",
       "2019-02-18  3670.919922  3645.835693\n",
       "2019-02-19  3912.570068  3649.565430\n",
       "2019-02-20  3924.239990  3669.048096\n",
       "2019-02-21  3974.050049  3703.831299\n",
       "2019-02-22  3937.040039  3752.048828"
      ]
     },
     "execution_count": 163,
     "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": 164,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7fc771ded910>"
      ]
     },
     "execution_count": 164,
     "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(title=\"Real Vs. Predicted\")"
   ]
  }
 ],
 "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
}