{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Stock Price Prediction: Model Comparison\n",
    "\n",
    "Jimmy Youngjae Sim\n",
    "\n",
    "Archived Colab implementation comparing a vanilla RNN, an LSTM, and a VAE-based forecaster. Code is preserved from the supplied export; the original notebook's generated filename/link header is omitted. No outputs have been regenerated.\n",
    "\n",
    "## Before running\n",
    "\n",
    "- Use a Python environment with NumPy, pandas, Matplotlib, TensorFlow/Keras, and scikit-learn. Package versions were not recorded in the supplied export.\n",
    "- Upload `all_stocks_5yr.csv` into the working directory. The dataset is not bundled. The code expects lowercase `open` and, for a multi-ticker dataset, `Name` columns.\n",
    "- Rows for each ticker must already be in chronological order: the code splits by row position, without sorting dates.\n",
    "- The archived version selects `GOOGL` in each model section. To compare a different ticker, change all three filters consistently.\n",
    "- Run the RNN, LSTM, and VAE sections in order. Later sections reuse the results dictionary and metric imports from the first section.\n",
    "- The export trains each model for 100 epochs with batch size 20. This can take time; the presentation's plots came from other experimental settings.\n",
    "\n",
    "No dataset, trained weights, saved metric values, or random seed was supplied. Running this notebook does not reproduce the presentation figures exactly.\n"
   ],
   "id": "stock-comparison-1"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. RNN and naive baseline"
   ],
   "id": "stock-comparison-2"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from tensorflow import keras\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "from sklearn.metrics import mean_squared_error, mean_absolute_error\n",
    "\n",
    "# Store results from all models here so we can compare them at the very end\n",
    "results = {}\n",
    "\n",
    "# 1. Load and preprocess data\n",
    "# Adjust the file path to match your environment (e.g. 'all_stocks_5yr.csv' or '../input/all_stocks_5yr.csv')\n",
    "data = pd.read_csv('all_stocks_5yr.csv')\n",
    "\n",
    "# If all_stocks_5yr.csv contains multiple tickers mixed together, extract just one ticker.\n",
    "if 'Name' in data.columns:\n",
    "    data = data[data['Name'] == 'GOOGL'].reset_index(drop=True)\n",
    "\n",
    "# 2. Train / test split (80:20)\n",
    "training_size = int(len(data) * 0.80)\n",
    "data_len = len(data)\n",
    "\n",
    "train = data.iloc[0:training_size]\n",
    "test = data.iloc[training_size:data_len]\n",
    "\n",
    "# Extract 'Open' price and normalize\n",
    "train_open = train.loc[:, [\"open\"]].values\n",
    "\n",
    "scaler = MinMaxScaler(feature_range=(0, 1))\n",
    "train_scaled = scaler.fit_transform(train_open)\n",
    "\n",
    "# 3. Build training time series data (timesteps)\n",
    "timesteps = 40\n",
    "X_train = []\n",
    "y_train = []\n",
    "\n",
    "for i in range(timesteps, len(train_scaled)):\n",
    "    X_train.append(train_scaled[i - timesteps:i, 0])\n",
    "    y_train.append(train_scaled[i, 0])\n",
    "\n",
    "X_train, y_train = np.array(X_train), np.array(y_train)\n",
    "X_train = np.reshape(X_train, (X_train.shape[0], X_train.shape[1], 1))\n",
    "\n",
    "# 4. Build and train the RNN model\n",
    "model = keras.Sequential([\n",
    "    keras.layers.SimpleRNN(units=50, return_sequences=True, input_shape=(X_train.shape[1], 1)),\n",
    "    keras.layers.Dropout(0.2),\n",
    "    keras.layers.SimpleRNN(units=50, return_sequences=True),\n",
    "    keras.layers.Dropout(0.2),\n",
    "    keras.layers.SimpleRNN(units=50, return_sequences=True),\n",
    "    keras.layers.Dropout(0.2),\n",
    "    keras.layers.SimpleRNN(units=50),\n",
    "    keras.layers.Dropout(0.2),\n",
    "    keras.layers.Dense(units=1)\n",
    "])\n",
    "\n",
    "model.compile(optimizer=\"adam\", loss=\"mse\")\n",
    "model.fit(X_train, y_train, epochs=100, batch_size=20)\n",
    "\n",
    "# 5. Build test data and predict\n",
    "# Prepend the previous `timesteps` (40 days) of data before the test set start to preserve continuity\n",
    "dataset_total = data[\"open\"]\n",
    "inputs = dataset_total[len(dataset_total) - len(test) - timesteps:].values.reshape(-1, 1)\n",
    "inputs = scaler.transform(inputs)\n",
    "\n",
    "X_test = []\n",
    "for i in range(timesteps, len(inputs)):\n",
    "    X_test.append(inputs[i - timesteps:i, 0])\n",
    "\n",
    "X_test = np.array(X_test)\n",
    "X_test = np.reshape(X_test, (X_test.shape[0], X_test.shape[1], 1))\n",
    "\n",
    "# Run prediction and inverse-transform back to the original scale\n",
    "predict = model.predict(X_test)\n",
    "predict = scaler.inverse_transform(predict)\n",
    "\n",
    "# 6. Visualize results\n",
    "real_price = test.loc[:, [\"open\"]].values\n",
    "\n",
    "plt.figure(figsize=(10, 5))\n",
    "plt.plot(real_price, color=\"red\", label=\"Real Stock Price\")\n",
    "plt.plot(predict, color=\"black\", label=\"Predicted Stock Price\")\n",
    "plt.title(\"Stock Price Prediction (RNN)\")\n",
    "plt.xlabel(\"Time\")\n",
    "plt.ylabel(\"Stock Price\")\n",
    "plt.legend()\n",
    "plt.show()\n",
    "\n",
    "# 7. Compute performance metrics (RMSE / MAE)\n",
    "rnn_rmse = np.sqrt(mean_squared_error(real_price, predict))\n",
    "rnn_mae = mean_absolute_error(real_price, predict)\n",
    "results[\"RNN\"] = {\"RMSE\": rnn_rmse, \"MAE\": rnn_mae}\n",
    "print(f\"[RNN] RMSE: {rnn_rmse:.4f}, MAE: {rnn_mae:.4f}\")\n",
    "\n",
    "# Naive baseline: \"tomorrow's price = today's price\", computed once here\n",
    "naive_predict = dataset_total.shift(1).iloc[len(dataset_total) - len(test):].values.reshape(-1, 1)\n",
    "naive_real = real_price\n",
    "naive_rmse = np.sqrt(mean_squared_error(naive_real, naive_predict))\n",
    "naive_mae = mean_absolute_error(naive_real, naive_predict)\n",
    "results[\"Naive Baseline\"] = {\"RMSE\": naive_rmse, \"MAE\": naive_mae}\n",
    "print(f\"[Naive Baseline] RMSE: {naive_rmse:.4f}, MAE: {naive_mae:.4f}\")\n",
    "\n"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "stock-comparison-3"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. LSTM"
   ],
   "id": "stock-comparison-4"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from tensorflow import keras\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "\n",
    "# 1. Load and preprocess data\n",
    "# Adjust the CSV file path to match your environment (e.g. 'all_stocks_5yr.csv' or '../input/all_stocks_5yr.csv')\n",
    "data = pd.read_csv('all_stocks_5yr.csv')\n",
    "\n",
    "# Filter down to just the ticker you want (e.g. 'TSLA') from all_stocks_5yr.csv\n",
    "if 'Name' in data.columns:\n",
    "    data = data[data['Name'] == 'GOOGL'].reset_index(drop=True)\n",
    "\n",
    "# 2. Train / test split (80:20)\n",
    "training_size = int(len(data) * 0.80)\n",
    "data_len = len(data)\n",
    "\n",
    "train = data.iloc[0:training_size]\n",
    "test = data.iloc[training_size:data_len]\n",
    "\n",
    "# Extract 'Open' price and normalize\n",
    "train_open = train.loc[:, [\"open\"]].values\n",
    "\n",
    "scaler = MinMaxScaler(feature_range=(0, 1))\n",
    "train_scaled = scaler.fit_transform(train_open)\n",
    "\n",
    "# 3. Build training time series data (timesteps)\n",
    "timesteps = 40\n",
    "X_train = []\n",
    "y_train = []\n",
    "\n",
    "for i in range(timesteps, len(train_scaled)):\n",
    "    X_train.append(train_scaled[i - timesteps:i, 0])\n",
    "    y_train.append(train_scaled[i, 0])\n",
    "\n",
    "X_train, y_train = np.array(X_train), np.array(y_train)\n",
    "X_train = np.reshape(X_train, (X_train.shape[0], X_train.shape[1], 1))\n",
    "\n",
    "\n",
    "# ====================================================================\n",
    "# 4. Build the model (LSTM)\n",
    "# ====================================================================\n",
    "model = keras.Sequential()\n",
    "\n",
    "# First LSTM layer\n",
    "model.add(keras.layers.LSTM(units=50, return_sequences=True, input_shape=(X_train.shape[1], 1)))\n",
    "model.add(keras.layers.Dropout(0.2))\n",
    "\n",
    "# Second LSTM layer\n",
    "model.add(keras.layers.LSTM(units=50, return_sequences=True))\n",
    "model.add(keras.layers.Dropout(0.2))\n",
    "\n",
    "# Third LSTM layer\n",
    "model.add(keras.layers.LSTM(units=50, return_sequences=True))\n",
    "model.add(keras.layers.Dropout(0.2))\n",
    "\n",
    "# Fourth LSTM layer\n",
    "model.add(keras.layers.LSTM(units=50))\n",
    "model.add(keras.layers.Dropout(0.2))\n",
    "\n",
    "# Output layer\n",
    "model.add(keras.layers.Dense(units=1))\n",
    "\n",
    "model.compile(optimizer=\"adam\", loss=\"mse\")\n",
    "model.fit(X_train, y_train, epochs=100, batch_size=20)\n",
    "# ====================================================================\n",
    "\n",
    "\n",
    "# 5. Build test data and predict\n",
    "# Slice starting from (test set start - timesteps) across the full dataset to preserve continuity\n",
    "dataset_total = data[\"open\"]\n",
    "inputs = dataset_total[len(dataset_total) - len(test) - timesteps:].values.reshape(-1, 1)\n",
    "inputs = scaler.transform(inputs)\n",
    "\n",
    "X_test = []\n",
    "for i in range(timesteps, len(inputs)):\n",
    "    X_test.append(inputs[i - timesteps:i, 0])\n",
    "\n",
    "X_test = np.array(X_test)\n",
    "X_test = np.reshape(X_test, (X_test.shape[0], X_test.shape[1], 1))\n",
    "\n",
    "# Run prediction and inverse-transform back to the original scale\n",
    "predict = model.predict(X_test)\n",
    "predict = scaler.inverse_transform(predict)\n",
    "\n",
    "# 6. Visualize results\n",
    "real_price = test.loc[:, [\"open\"]].values\n",
    "\n",
    "plt.figure(figsize=(10, 5))\n",
    "plt.plot(real_price, color=\"red\", label=\"Real Stock Price\")\n",
    "plt.plot(predict, color=\"black\", label=\"Predicted Stock Price\")\n",
    "plt.title(\"Stock Price Prediction (LSTM)\")\n",
    "plt.xlabel(\"Time\")\n",
    "plt.ylabel(\"Stock Price\")\n",
    "plt.legend()\n",
    "plt.show()\n",
    "\n",
    "# 7. Compute performance metrics (RMSE / MAE)\n",
    "lstm_rmse = np.sqrt(mean_squared_error(real_price, predict))\n",
    "lstm_mae = mean_absolute_error(real_price, predict)\n",
    "results[\"LSTM\"] = {\"RMSE\": lstm_rmse, \"MAE\": lstm_mae}\n",
    "print(f\"[LSTM] RMSE: {lstm_rmse:.4f}, MAE: {lstm_mae:.4f}\")\n",
    "\n"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "stock-comparison-5"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. VAE"
   ],
   "id": "stock-comparison-6"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import tensorflow as tf\n",
    "from tensorflow import keras\n",
    "from tensorflow.keras import layers\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "\n",
    "# ====================================================================\n",
    "# 1. Load and preprocess data\n",
    "# ====================================================================\n",
    "data = pd.read_csv('all_stocks_5yr.csv')\n",
    "\n",
    "# Extract a specific ticker (e.g. 'AAPL')\n",
    "if 'Name' in data.columns:\n",
    "    data = data[data['Name'] == 'GOOGL'].reset_index(drop=True)\n",
    "\n",
    "# Handle lowercase vs. capitalized column names\n",
    "open_col = 'open' if 'open' in data.columns else 'Open'\n",
    "\n",
    "training_size = int(len(data) * 0.80)\n",
    "data_len = len(data)\n",
    "\n",
    "train, test = data.iloc[0:training_size], data.iloc[training_size:data_len]\n",
    "\n",
    "# Normalize the Open price\n",
    "train_open = train.loc[:, [open_col]].values\n",
    "scaler = MinMaxScaler(feature_range=(0, 1))\n",
    "train_scaled = scaler.fit_transform(train_open)\n",
    "\n",
    "timesteps = 40\n",
    "end_len = len(train_scaled)\n",
    "X_train = []\n",
    "y_train = []\n",
    "\n",
    "for i in range(timesteps, end_len):\n",
    "    X_train.append(train_scaled[i - timesteps:i, 0])\n",
    "    y_train.append(train_scaled[i, 0])  # Tomorrow's price (target)\n",
    "\n",
    "X_train, y_train = np.array(X_train), np.array(y_train)\n",
    "X_train = np.reshape(X_train, (X_train.shape[0], X_train.shape[1], 1))\n",
    "y_train = np.reshape(y_train, (y_train.shape[0], 1))\n",
    "\n",
    "# ====================================================================\n",
    "# 2. Define VAE forecasting model components\n",
    "# ====================================================================\n",
    "latent_dim = 4  # Latent dimension raised to 4 for more representational capacity\n",
    "\n",
    "# (1) Sampling layer\n",
    "class Sampling(layers.Layer):\n",
    "    def call(self, inputs):\n",
    "        z_mean, z_log_var = inputs\n",
    "        batch = tf.shape(z_mean)[0]\n",
    "        dim = tf.shape(z_mean)[1]\n",
    "        epsilon = tf.random.normal(shape=(batch, dim))\n",
    "        return z_mean + tf.exp(0.5 * z_log_var) * epsilon\n",
    "\n",
    "# (2) Encoder: past 40-day sequence -> compressed into latent space\n",
    "encoder_inputs = layers.Input(shape=(timesteps, 1))\n",
    "x = layers.LSTM(64, return_sequences=True)(encoder_inputs)\n",
    "x = layers.Dropout(0.2)(x)\n",
    "x = layers.LSTM(32)(x)\n",
    "x = layers.Dropout(0.2)(x)\n",
    "\n",
    "z_mean = layers.Dense(latent_dim, name=\"z_mean\")(x)\n",
    "z_log_var = layers.Dense(latent_dim, name=\"z_log_var\")(x)\n",
    "z = Sampling()([z_mean, z_log_var])\n",
    "encoder = keras.Model(encoder_inputs, [z_mean, z_log_var, z], name=\"encoder\")\n",
    "\n",
    "# (3) Decoder: latent space -> a single next-day price (point prediction)\n",
    "latent_inputs = layers.Input(shape=(latent_dim,))\n",
    "x = layers.Dense(32, activation=\"relu\")(latent_inputs)\n",
    "x = layers.Dropout(0.2)(x)\n",
    "x = layers.Dense(16, activation=\"relu\")(x)\n",
    "decoder_outputs = layers.Dense(1)(x)  # Predicted next-day price\n",
    "decoder = keras.Model(latent_inputs, decoder_outputs, name=\"decoder\")\n",
    "\n",
    "# (4) VAE forecasting class with a custom train_step\n",
    "class VAEForecaster(keras.Model):\n",
    "    def __init__(self, encoder, decoder, kl_weight=0.001, **kwargs):\n",
    "        super().__init__(**kwargs)\n",
    "        self.encoder = encoder\n",
    "        self.decoder = decoder\n",
    "        self.kl_weight = kl_weight  # Weight to prevent the KL loss from dominating training\n",
    "        self.total_loss_tracker = keras.metrics.Mean(name=\"total_loss\")\n",
    "        self.pred_loss_tracker = keras.metrics.Mean(name=\"pred_loss\")\n",
    "        self.kl_loss_tracker = keras.metrics.Mean(name=\"kl_loss\")\n",
    "\n",
    "    @property\n",
    "    def metrics(self):\n",
    "        return [self.total_loss_tracker, self.pred_loss_tracker, self.kl_loss_tracker]\n",
    "\n",
    "    def train_step(self, data):\n",
    "        x_input, y_target = data  # Split into input (past 40 days) and target (next-day price)\n",
    "\n",
    "        with tf.GradientTape() as tape:\n",
    "            z_mean, z_log_var, z = self.encoder(x_input)\n",
    "            y_pred = self.decoder(z)\n",
    "\n",
    "            # 1. Prediction loss (MSE)\n",
    "            pred_loss = tf.reduce_mean(tf.square(y_target - y_pred))\n",
    "\n",
    "            # 2. KL divergence loss\n",
    "            kl_loss = -0.5 * tf.reduce_mean(\n",
    "                tf.reduce_sum(1 + z_log_var - tf.square(z_mean) - tf.exp(z_log_var), axis=-1)\n",
    "            )\n",
    "\n",
    "            # Total loss = prediction loss + weighted KL loss\n",
    "            total_loss = pred_loss + (self.kl_weight * kl_loss)\n",
    "\n",
    "        grads = tape.gradient(total_loss, self.trainable_weights)\n",
    "        self.optimizer.apply_gradients(zip(grads, self.trainable_weights))\n",
    "\n",
    "        self.total_loss_tracker.update_state(total_loss)\n",
    "        self.pred_loss_tracker.update_state(pred_loss)\n",
    "        self.kl_loss_tracker.update_state(kl_loss)\n",
    "        return {\n",
    "            \"loss\": self.total_loss_tracker.result(),\n",
    "            \"pred_loss\": self.pred_loss_tracker.result(),\n",
    "            \"kl_loss\": self.kl_loss_tracker.result(),\n",
    "        }\n",
    "\n",
    "# ====================================================================\n",
    "# 3. Train the model\n",
    "# ====================================================================\n",
    "vae_model = VAEForecaster(encoder, decoder, kl_weight=0.001)\n",
    "vae_model.compile(optimizer=keras.optimizers.Adam(learning_rate=0.001))\n",
    "\n",
    "# Pass X_train (past 40 days) and y_train (next-day price) together for training\n",
    "vae_model.fit(X_train, y_train, epochs=100, batch_size=20)\n",
    "\n",
    "# ====================================================================\n",
    "# 4. Build test data and predict\n",
    "# ====================================================================\n",
    "dataset_total = data[open_col]\n",
    "inputs = dataset_total[len(dataset_total) - len(test) - timesteps:].values.reshape(-1, 1)\n",
    "inputs = scaler.transform(inputs)\n",
    "\n",
    "X_test = []\n",
    "for i in range(timesteps, len(inputs)):\n",
    "    X_test.append(inputs[i - timesteps:i, 0])\n",
    "\n",
    "X_test = np.array(X_test)\n",
    "X_test = np.reshape(X_test, (X_test.shape[0], X_test.shape[1], 1))\n",
    "\n",
    "# Encoder -> extract z_mean -> pass through Decoder to predict\n",
    "z_mean_test, _, _ = vae_model.encoder.predict(X_test)\n",
    "predict = vae_model.decoder.predict(z_mean_test)\n",
    "\n",
    "# Inverse-transform back to the original scale\n",
    "predict = scaler.inverse_transform(predict)\n",
    "\n",
    "# ====================================================================\n",
    "# 5. Visualize\n",
    "# ====================================================================\n",
    "real_price = test.loc[:, [open_col]].values\n",
    "\n",
    "plt.figure(figsize=(12, 6))\n",
    "plt.plot(real_price, color=\"red\", label=\"Real Stock Price\")\n",
    "plt.plot(predict, color=\"black\", label=\"Predicted Stock Price (VAE)\")\n",
    "plt.title(\"Stock Price Prediction (VAE)\")\n",
    "plt.xlabel(\"Time\")\n",
    "plt.ylabel(\"Stock Price\")\n",
    "plt.legend()\n",
    "plt.grid(True)\n",
    "plt.show()\n",
    "\n",
    "# 6. Compute performance metrics (RMSE / MAE)\n",
    "vae_rmse = np.sqrt(mean_squared_error(real_price, predict))\n",
    "vae_mae = mean_absolute_error(real_price, predict)\n",
    "results[\"VAE\"] = {\"RMSE\": vae_rmse, \"MAE\": vae_mae}\n",
    "print(f\"[VAE] RMSE: {vae_rmse:.4f}, MAE: {vae_mae:.4f}\")\n",
    "\n",
    "# ====================================================================\n",
    "# 7. Compare all models (RNN vs LSTM vs VAE vs Naive Baseline)\n",
    "# ====================================================================\n",
    "comparison_df = pd.DataFrame(results).T\n",
    "comparison_df = comparison_df.sort_values(\"RMSE\")\n",
    "print(\"\\n=== Model Comparison (lower is better) ===\")\n",
    "print(comparison_df)\n",
    "\n",
    "comparison_df[\"RMSE\"].plot(kind=\"bar\", figsize=(8, 5), title=\"RMSE by Model (lower is better)\")\n",
    "plt.ylabel(\"RMSE\")\n",
    "plt.xticks(rotation=0)\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "stock-comparison-7"
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
