diff --git a/examples/quantile-regression/conformal-quantile-regression_example.ipynb b/examples/quantile-regression/conformal-quantile-regression_example.ipynb new file mode 100644 index 00000000..38d33822 --- /dev/null +++ b/examples/quantile-regression/conformal-quantile-regression_example.ipynb @@ -0,0 +1,469 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import torch\n", + "from torch import nn, optim\n", + "\n", + "from torchts.nn.loss import quantile_loss\n", + "from torchts.nn.model import TimeSeriesModel\n", + "from sklearn.preprocessing import StandardScaler\n", + "from sklearn.model_selection import train_test_split" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Set random seed for reproducibility" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "seed = 0\n", + "torch.manual_seed(seed)\n", + "np.random.seed(seed)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Generate data" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# generate linear time series data with some noise\n", + "n = 1000\n", + "x_max = 20\n", + "slope = 2\n", + "scale = 2\n", + "\n", + "x = torch.from_numpy(np.linspace(0, x_max, n).reshape(-1, 1).astype(np.float32))\n", + "y = slope * x + np.random.normal(0, scale, n).reshape(-1, 1).astype(np.float32)\n", + "\n", + "plt.plot(x, y)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Split data set" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "x_train, x_test,y_train,y_test = train_test_split(x,y,test_size =0.2)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "# easier for future ploting \n", + "x_train_sort = x_train.sort(dim = 0)[0]\n", + "y_train_sort = y_train[x_train.sort(dim = 0)[1].flatten()]\n", + "x_test_sort = x_test.sort(dim = 0)[0]\n", + "y_test_sort = y_test[x_test.sort(dim = 0)[1].flatten()]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Define model that predicts quantiles" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "class QuantileLSTM(TimeSeriesModel):\n", + " def __init__(\n", + " self, input_size, output_size, hidden_size, optimizer, quantile=0.5, mode=None,method=None,significance=None, **kwargs\n", + " ):\n", + " super().__init__(\n", + " optimizer,\n", + " criterion=quantile_loss,\n", + " criterion_args={\"quantile\": quantile},\n", + " method=method,\n", + " mode=mode,\n", + " significance=significance,\n", + " **kwargs\n", + " )\n", + " n_quantiles = 1 if isinstance(quantile, float) else len(quantile)\n", + " self.lstm = nn.ModuleList(\n", + " [nn.LSTMCell(input_size, hidden_size) for _ in range(output_size)]\n", + " )\n", + " self.linear = nn.ModuleList(\n", + " [nn.Linear(hidden_size, n_quantiles) for _ in range(output_size)]\n", + " )\n", + "\n", + " def forward(self, x, y=None, batches_seen=None):\n", + " hidden, _ = zip(*[m(x) for m in self.lstm])\n", + " out = [m(h) for m, h in zip(self.linear, hidden)]\n", + " return torch.hstack(out)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Train model to predict multiple quantiles" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "input_size = 1\n", + "output_size = 1\n", + "hidden_size = 16\n", + "optimizer = optim.Adam\n", + "optimizer_args = {\"lr\": 0.05}\n", + "max_epochs =30\n", + "batch_size = 10\n", + "quantile = [0.025, 0.5, 0.975]\n", + "\n", + "model = QuantileLSTM(\n", + " input_size,\n", + " output_size,\n", + " hidden_size,\n", + " optimizer,\n", + " quantile=quantile,\n", + " method='conformal',\n", + " mode='regression',\n", + " significance=0.1,\n", + " optimizer_args=optimizer_args,\n", + " scaler = None\n", + " # scaler= StandardScaler()\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: False, used: False\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "\n", + " | Name | Type | Params\n", + "--------------------------------------\n", + "0 | lstm | ModuleList | 1.2 K \n", + "1 | linear | ModuleList | 51 \n", + "--------------------------------------\n", + "1.3 K Trainable params\n", + "0 Non-trainable params\n", + "1.3 K Total params\n", + "0.005 Total estimated model params size (MB)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " " + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/judyyy/opt/anaconda3/envs/spatiotemporal/lib/python3.9/site-packages/pytorch_lightning/trainer/data_loading.py:659: UserWarning: Your `val_dataloader` has `shuffle=True`, it is strongly recommended that you turn this off for val/test/predict dataloaders.\n", + " rank_zero_warn(\n", + "/Users/judyyy/opt/anaconda3/envs/spatiotemporal/lib/python3.9/site-packages/pytorch_lightning/trainer/data_loading.py:132: UserWarning: The dataloader, val_dataloader 0, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 8 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", + " rank_zero_warn(\n", + "/Users/judyyy/opt/anaconda3/envs/spatiotemporal/lib/python3.9/site-packages/pytorch_lightning/trainer/data_loading.py:132: UserWarning: The dataloader, train_dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 8 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", + " rank_zero_warn(\n", + "/Users/judyyy/opt/anaconda3/envs/spatiotemporal/lib/python3.9/site-packages/pytorch_lightning/trainer/data_loading.py:432: UserWarning: The number of training samples (48) is smaller than the logging interval Trainer(log_every_n_steps=50). Set a lower value for log_every_n_steps if you want to see logs for the training epoch.\n", + " rank_zero_warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0: 60%|▌| 48/80 [00:00<00:00, 175.59it/s, loss=11.9, v_num=167, train_los\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 0: 100%|█| 80/80 [00:00<00:00, 226.04it/s, loss=11.9, v_num=167, train_los\u001b[A\n", + "Epoch 1: 60%|▌| 48/80 [00:00<00:00, 178.40it/s, loss=2.63, v_num=167, train_los\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 1: 100%|█| 80/80 [00:00<00:00, 236.59it/s, loss=2.63, v_num=167, train_los\u001b[A\n", + "Epoch 2: 60%|▌| 48/80 [00:00<00:00, 193.33it/s, loss=1.88, v_num=167, train_los\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 2: 100%|█| 80/80 [00:00<00:00, 254.19it/s, loss=1.88, v_num=167, train_los\u001b[A\n", + "Epoch 3: 60%|▌| 48/80 [00:00<00:00, 170.43it/s, loss=1.28, v_num=167, train_los\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 3: 100%|█| 80/80 [00:00<00:00, 229.33it/s, loss=1.28, v_num=167, train_los\u001b[A\n", + "Epoch 4: 60%|▌| 48/80 [00:00<00:00, 190.43it/s, loss=1.44, v_num=167, train_los\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 4: 100%|█| 80/80 [00:00<00:00, 247.00it/s, loss=1.44, v_num=167, train_los\u001b[A\n", + "Epoch 5: 60%|▌| 48/80 [00:00<00:00, 188.04it/s, loss=1.2, v_num=167, train_loss\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 5: 100%|█| 80/80 [00:00<00:00, 243.53it/s, loss=1.2, v_num=167, train_loss\u001b[A\n", + "Epoch 6: 60%|▌| 48/80 [00:00<00:00, 190.50it/s, loss=1.35, v_num=167, train_los\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 6: 100%|█| 80/80 [00:00<00:00, 250.50it/s, loss=1.35, v_num=167, train_los\u001b[A\n", + "Epoch 7: 60%|▌| 48/80 [00:00<00:00, 163.93it/s, loss=1.21, v_num=167, train_los\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 7: 100%|█| 80/80 [00:00<00:00, 213.88it/s, loss=1.21, v_num=167, train_los\u001b[A\n", + "Epoch 8: 60%|▌| 48/80 [00:00<00:00, 149.51it/s, loss=1.2, v_num=167, train_loss\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 8: 100%|█| 80/80 [00:00<00:00, 203.44it/s, loss=1.2, v_num=167, train_loss\u001b[A\n", + "Epoch 9: 60%|▌| 48/80 [00:00<00:00, 154.53it/s, loss=1.26, v_num=167, train_los\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 9: 100%|█| 80/80 [00:00<00:00, 202.27it/s, loss=1.26, v_num=167, train_los\u001b[A\n", + "Epoch 10: 60%|▌| 48/80 [00:00<00:00, 155.12it/s, loss=1.46, v_num=167, train_lo\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 10: 100%|█| 80/80 [00:00<00:00, 198.41it/s, loss=1.46, v_num=167, train_lo\u001b[A\n", + "Epoch 11: 60%|▌| 48/80 [00:00<00:00, 177.64it/s, loss=1.45, v_num=167, train_lo\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 11: 100%|█| 80/80 [00:00<00:00, 235.29it/s, loss=1.45, v_num=167, train_lo\u001b[A\n", + "Epoch 12: 60%|▌| 48/80 [00:00<00:00, 192.29it/s, loss=1.1, v_num=167, train_los\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 12: 100%|█| 80/80 [00:00<00:00, 241.53it/s, loss=1.1, v_num=167, train_los\u001b[A\n", + "Epoch 13: 60%|▌| 48/80 [00:00<00:00, 175.78it/s, loss=1.34, v_num=167, train_lo\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 13: 100%|█| 80/80 [00:00<00:00, 235.26it/s, loss=1.34, v_num=167, train_lo\u001b[A\n", + "Epoch 14: 60%|▌| 48/80 [00:00<00:00, 189.61it/s, loss=1.58, v_num=167, train_lo\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 14: 100%|█| 80/80 [00:00<00:00, 250.91it/s, loss=1.58, v_num=167, train_lo\u001b[A\n", + "Epoch 15: 60%|▌| 48/80 [00:00<00:00, 174.62it/s, loss=1.62, v_num=167, train_lo\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 15: 100%|█| 80/80 [00:00<00:00, 226.57it/s, loss=1.62, v_num=167, train_lo\u001b[A\n", + "Epoch 16: 60%|▌| 48/80 [00:00<00:00, 180.34it/s, loss=1.19, v_num=167, train_lo\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 16: 100%|█| 80/80 [00:00<00:00, 241.08it/s, loss=1.19, v_num=167, train_lo\u001b[A\n", + "Epoch 17: 60%|▌| 48/80 [00:00<00:00, 201.28it/s, loss=1.34, v_num=167, train_lo\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 17: 100%|█| 80/80 [00:00<00:00, 260.31it/s, loss=1.34, v_num=167, train_lo\u001b[A\n", + "Epoch 18: 60%|▌| 48/80 [00:00<00:00, 148.08it/s, loss=1.35, v_num=167, train_lo\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 18: 100%|█| 80/80 [00:00<00:00, 198.35it/s, loss=1.35, v_num=167, train_lo\u001b[A\n", + "Epoch 19: 60%|▌| 48/80 [00:00<00:00, 171.22it/s, loss=1.25, v_num=167, train_lo\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 19: 100%|█| 80/80 [00:00<00:00, 222.11it/s, loss=1.25, v_num=167, train_lo\u001b[A\n", + "Epoch 20: 60%|▌| 48/80 [00:00<00:00, 196.04it/s, loss=1.23, v_num=167, train_lo\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 20: 100%|█| 80/80 [00:00<00:00, 259.04it/s, loss=1.23, v_num=167, train_lo\u001b[A\n", + "Epoch 21: 60%|▌| 48/80 [00:00<00:00, 184.68it/s, loss=1.4, v_num=167, train_los\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 21: 100%|█| 80/80 [00:00<00:00, 244.64it/s, loss=1.4, v_num=167, train_los\u001b[A\n", + "Epoch 22: 60%|▌| 48/80 [00:00<00:00, 169.82it/s, loss=1.15, v_num=167, train_lo\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 22: 100%|█| 80/80 [00:00<00:00, 225.04it/s, loss=1.15, v_num=167, train_lo\u001b[A\n", + "Epoch 23: 60%|▌| 48/80 [00:00<00:00, 160.91it/s, loss=1.19, v_num=167, train_lo\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 23: 100%|█| 80/80 [00:00<00:00, 216.59it/s, loss=1.19, v_num=167, train_lo\u001b[A\n", + "Epoch 24: 60%|▌| 48/80 [00:00<00:00, 166.67it/s, loss=1.1, v_num=167, train_los\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 24: 100%|█| 80/80 [00:00<00:00, 215.97it/s, loss=1.1, v_num=167, train_los\u001b[A\n", + "Epoch 25: 60%|▌| 48/80 [00:00<00:00, 189.12it/s, loss=1.37, v_num=167, train_lo\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 25: 100%|█| 80/80 [00:00<00:00, 243.67it/s, loss=1.37, v_num=167, train_lo\u001b[A\n", + "Epoch 26: 60%|▌| 48/80 [00:00<00:00, 177.13it/s, loss=1.19, v_num=167, train_lo\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 26: 100%|█| 80/80 [00:00<00:00, 234.45it/s, loss=1.19, v_num=167, train_lo\u001b[A\n", + "Epoch 27: 60%|▌| 48/80 [00:00<00:00, 170.81it/s, loss=1.35, v_num=167, train_lo\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 27: 100%|█| 80/80 [00:00<00:00, 222.22it/s, loss=1.35, v_num=167, train_lo\u001b[A\n", + "Epoch 28: 60%|▌| 48/80 [00:00<00:00, 180.38it/s, loss=1.2, v_num=167, train_los\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 28: 100%|█| 80/80 [00:00<00:00, 229.53it/s, loss=1.2, v_num=167, train_los\u001b[A\n", + "Epoch 29: 60%|▌| 48/80 [00:00<00:00, 177.99it/s, loss=1.16, v_num=167, train_lo\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 29: 100%|█| 80/80 [00:00<00:00, 233.15it/s, loss=1.16, v_num=167, train_lo\u001b[A\n", + "Epoch 29: 100%|█| 80/80 [00:00<00:00, 226.45it/s, loss=1.16, v_num=167, train_lo\u001b[A\n" + ] + } + ], + "source": [ + "model.fit(x_train, y_train, max_epochs=max_epochs, batch_size=batch_size)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "y_pred = model.predict(x)\n", + "y_pred_conformal = model.conformal_predict(x)\n", + "n_quantiles = len(quantile)\n", + "cycle_colors = plt.rcParams['axes.prop_cycle'].by_key()['color']\n", + "color_index = [2, 1, 3]\n", + "\n", + "plt.plot(x, y, label=\"y_true\")\n", + "\n", + "for i, c in zip(range(n_quantiles), color_index):\n", + " plt.plot(x, y_pred[:, i], c=cycle_colors[c], label=f\"p={quantile[i]}\",alpha = 0.3)\n", + "\n", + "for i, c in zip(range(n_quantiles), color_index):\n", + " plt.plot(x, y_pred_conformal[:, i], c=cycle_colors[c], label=f\"p={quantile[i]}:conformal\")\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# plot x_train\n", + "y_pred = model.predict(x_train_sort)\n", + "y_pred_conformal = model.conformal_predict(x_train_sort)\n", + "n_quantiles = len(quantile)\n", + "cycle_colors = plt.rcParams['axes.prop_cycle'].by_key()['color']\n", + "color_index = [2, 1, 3]\n", + "\n", + "plt.plot(x_train_sort, y_train_sort, label=\"y_true\")\n", + "\n", + "for i, c in zip(range(n_quantiles), color_index):\n", + " plt.plot(x_train_sort, y_pred[:, i], c=cycle_colors[c], label=f\"p={quantile[i]}\",alpha = 0.3)\n", + "\n", + "for i, c in zip(range(n_quantiles), color_index):\n", + " plt.plot(x_train_sort, y_pred_conformal[:, i], c=cycle_colors[c], label=f\"p={quantile[i]}:conformal\")\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# plot x_test\n", + "y_pred = model.predict(x_test_sort)\n", + "y_pred_conformal = model.conformal_predict(x_test_sort)\n", + "n_quantiles = len(quantile)\n", + "cycle_colors = plt.rcParams['axes.prop_cycle'].by_key()['color']\n", + "color_index = [2, 1, 3]\n", + "\n", + "plt.plot(x_test_sort, y_test_sort, label=\"y_true\")\n", + "\n", + "for i, c in zip(range(n_quantiles), color_index):\n", + " if i != 1:\n", + " plt.plot(x_test_sort, y_pred[:, i], c=cycle_colors[c], label=f\"p={quantile[i]}\",alpha = 0.3)\n", + "\n", + "for i, c in zip(range(n_quantiles), color_index):\n", + " plt.plot(x_test_sort, y_pred_conformal[:, i], c=cycle_colors[c], label=f\"p={quantile[i]}:conformal\")\n", + "plt.legend()\n", + "plt.show()" + ] + } + ], + "metadata": { + "interpreter": { + "hash": "6a69466490a3cd78f8127aa86c71c97a1b8be0ac73f00bec705cc872d22503a4" + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.9.7" + }, + "toc-autonumbering": true, + "toc-showcode": true, + "toc-showmarkdowntxt": false + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/examples/quantile-regression/conformal-quantile-timeseries_example.ipynb b/examples/quantile-regression/conformal-quantile-timeseries_example.ipynb new file mode 100644 index 00000000..bc983b73 --- /dev/null +++ b/examples/quantile-regression/conformal-quantile-timeseries_example.ipynb @@ -0,0 +1,673 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import torch\n", + "from torch import nn, optim\n", + "import pandas as pd\n", + "\n", + "from torchts.nn.loss import quantile_loss\n", + "from torchts.nn.model import TimeSeriesModel\n", + "from sklearn.preprocessing import StandardScaler\n", + "from sklearn.model_selection import train_test_split" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Set random seed for reproducibility" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "seed = 0\n", + "torch.manual_seed(seed)\n", + "np.random.seed(seed)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Generate data" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# generate linear time series data with some noise\n", + "n = 1000\n", + "x_max = 20\n", + "slope = 2\n", + "scale = 0.2\n", + "\n", + "x_data = torch.from_numpy(np.linspace(0, x_max, n).reshape(-1, 1).astype(np.float32))\n", + "y_data = np.sin(x_data) + np.random.normal(0, scale, n).reshape(-1, 1).astype(np.float32)\n", + "\n", + "plt.plot(x_data, y_data)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# # generate linear time series data with some noise\n", + "# n = 1000\n", + "# x_max = 20\n", + "# slope = 2\n", + "# scale = 1\n", + "\n", + "# x_data = torch.from_numpy(np.linspace(0, x_max, n).reshape(-1, 1).astype(np.float32))\n", + "# y_data = slope * x_data + np.random.normal(0, scale, n).reshape(-1, 1).astype(np.float32)\n", + "\n", + "# plt.plot(x_data, y_data)\n", + "# plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Split data set" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def train_data(data, seq_length):\n", + " \n", + " data_x = []\n", + " data_y = []\n", + " \n", + " # iterate through the array, one sequence at a time\n", + " for n in range(0, data.shape[0]-seq_length):\n", + " # The features\n", + " data_x.append(data[n:n+seq_length])\n", + " # The targets, shifted by one\n", + " data_y.append(data[n+seq_length:n+seq_length+1])\n", + " \n", + " return data_x,data_y" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "sequence_len = 40\n", + "x,y = train_data(y_data,sequence_len)\n", + "x = torch.cat(x,dim = -1)\n", + "x = torch.t(x)\n", + "y = torch.cat(y,dim = 0)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(torch.Size([960, 40]), torch.Size([960, 1]))" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x.shape,y.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(torch.float32, torch.float32)" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "scaler= StandardScaler()\n", + "x_new = torch.tensor(scaler.fit_transform(x),dtype=torch.float32)\n", + "x_new.dtype,x.dtype" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "lengths = [int(x.shape[0]*0.6), int(x.shape[0]*0.8)]\n", + "x_train, x_val, x_test = x[:lengths[0],], x[lengths[0]:lengths[1],:], x[lengths[1]:,:]\n", + "y_train, y_val, y_test = y[:lengths[0],], y[lengths[0]:lengths[1],:], y[lengths[1]:,:]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Define model that predicts quantiles" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "class QuantileLSTM(TimeSeriesModel):\n", + " def __init__(\n", + " self, input_size, output_size, hidden_size, optimizer, quantile=0.5, mode=None,method=None,significance=None, **kwargs\n", + " ):\n", + " super().__init__(\n", + " optimizer,\n", + " criterion=quantile_loss,\n", + " criterion_args={\"quantile\": quantile},\n", + " method=method,\n", + " mode=mode,\n", + " significance=significance,\n", + " **kwargs\n", + " )\n", + " n_quantiles = 1 if isinstance(quantile, float) else len(quantile)\n", + " self.lstm = nn.ModuleList(\n", + " [nn.LSTMCell(input_size, hidden_size) for _ in range(output_size)]\n", + " )\n", + " self.linear = nn.ModuleList(\n", + " [nn.Linear(hidden_size, n_quantiles) for _ in range(output_size)]\n", + " )\n", + "\n", + " def forward(self, x, y=None, batches_seen=None):\n", + " hidden, _ = zip(*[m(x) for m in self.lstm])\n", + " out = [m(h) for m, h in zip(self.linear, hidden)]\n", + " return torch.hstack(out)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Train model to predict multiple quantiles" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "input_size = sequence_len\n", + "output_size = 1\n", + "hidden_size = 64\n", + "optimizer = optim.Adam\n", + "optimizer_args = {\"lr\": 0.005}\n", + "max_epochs = 30\n", + "batch_size = 16\n", + "quantile = [0.025, 0.5, 0.975]\n", + "\n", + "\n", + "model = QuantileLSTM(\n", + " input_size,\n", + " output_size,\n", + " hidden_size,\n", + " optimizer,\n", + " quantile=quantile,\n", + " method='conformal',\n", + " mode='time_series',\n", + " significance=0.1,\n", + " optimizer_args=optimizer_args,\n", + " scaler = None\n", + " # scaler= StandardScaler()\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: False, used: False\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "\n", + " | Name | Type | Params\n", + "--------------------------------------\n", + "0 | lstm | ModuleList | 27.1 K\n", + "1 | linear | ModuleList | 195 \n", + "--------------------------------------\n", + "27.3 K Trainable params\n", + "0 Non-trainable params\n", + "27.3 K Total params\n", + "0.109 Total estimated model params size (MB)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " " + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/judyyy/opt/anaconda3/envs/spatiotemporal/lib/python3.9/site-packages/pytorch_lightning/trainer/data_loading.py:659: UserWarning: Your `val_dataloader` has `shuffle=True`, it is strongly recommended that you turn this off for val/test/predict dataloaders.\n", + " rank_zero_warn(\n", + "/Users/judyyy/opt/anaconda3/envs/spatiotemporal/lib/python3.9/site-packages/pytorch_lightning/trainer/data_loading.py:132: UserWarning: The dataloader, val_dataloader 0, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 8 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", + " rank_zero_warn(\n", + "/Users/judyyy/opt/anaconda3/envs/spatiotemporal/lib/python3.9/site-packages/pytorch_lightning/trainer/data_loading.py:132: UserWarning: The dataloader, train_dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 8 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", + " rank_zero_warn(\n", + "/Users/judyyy/opt/anaconda3/envs/spatiotemporal/lib/python3.9/site-packages/pytorch_lightning/trainer/data_loading.py:432: UserWarning: The number of training samples (22) is smaller than the logging interval Trainer(log_every_n_steps=50). Set a lower value for log_every_n_steps if you want to see logs for the training epoch.\n", + " rank_zero_warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0: 59%|▌| 22/37 [00:00<00:00, 200.83it/s, loss=0.31, v_num=172, train_los\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 0: 100%|█| 37/37 [00:00<00:00, 255.32it/s, loss=0.31, v_num=172, train_los\u001b[A\n", + "Epoch 1: 59%|▌| 22/37 [00:00<00:00, 166.99it/s, loss=0.168, v_num=172, train_lo\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 1: 100%|█| 37/37 [00:00<00:00, 211.77it/s, loss=0.168, v_num=172, train_lo\u001b[A\n", + "Epoch 2: 59%|▌| 22/37 [00:00<00:00, 190.57it/s, loss=0.125, v_num=172, train_lo\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 2: 100%|█| 37/37 [00:00<00:00, 249.89it/s, loss=0.125, v_num=172, train_lo\u001b[A\n", + "Epoch 3: 59%|▌| 22/37 [00:00<00:00, 215.62it/s, loss=0.114, v_num=172, train_lo\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 3: 100%|█| 37/37 [00:00<00:00, 277.93it/s, loss=0.114, v_num=172, train_lo\u001b[A\n", + "Epoch 4: 59%|▌| 22/37 [00:00<00:00, 228.38it/s, loss=0.115, v_num=172, train_lo\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 4: 100%|█| 37/37 [00:00<00:00, 277.04it/s, loss=0.115, v_num=172, train_lo\u001b[A\n", + "Epoch 5: 59%|▌| 22/37 [00:00<00:00, 218.84it/s, loss=0.11, v_num=172, train_los\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 5: 100%|█| 37/37 [00:00<00:00, 275.32it/s, loss=0.11, v_num=172, train_los\u001b[A\n", + "Epoch 6: 59%|▌| 22/37 [00:00<00:00, 218.16it/s, loss=0.112, v_num=172, train_lo\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 6: 100%|█| 37/37 [00:00<00:00, 267.40it/s, loss=0.112, v_num=172, train_lo\u001b[A\n", + "Epoch 7: 59%|▌| 22/37 [00:00<00:00, 227.97it/s, loss=0.109, v_num=172, train_lo\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 7: 100%|█| 37/37 [00:00<00:00, 283.35it/s, loss=0.109, v_num=172, train_lo\u001b[A\n", + "Epoch 8: 59%|▌| 22/37 [00:00<00:00, 222.78it/s, loss=0.105, v_num=172, train_lo\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 8: 100%|█| 37/37 [00:00<00:00, 279.59it/s, loss=0.105, v_num=172, train_lo\u001b[A\n", + "Epoch 9: 59%|▌| 22/37 [00:00<00:00, 203.58it/s, loss=0.114, v_num=172, train_lo\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 9: 100%|█| 37/37 [00:00<00:00, 252.56it/s, loss=0.114, v_num=172, train_lo\u001b[A\n", + "Epoch 10: 59%|▌| 22/37 [00:00<00:00, 175.14it/s, loss=0.108, v_num=172, train_l\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 10: 100%|█| 37/37 [00:00<00:00, 214.06it/s, loss=0.108, v_num=172, train_l\u001b[A\n", + "Epoch 11: 59%|▌| 22/37 [00:00<00:00, 219.30it/s, loss=0.101, v_num=172, train_l\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 11: 100%|█| 37/37 [00:00<00:00, 277.18it/s, loss=0.101, v_num=172, train_l\u001b[A\n", + "Epoch 12: 59%|▌| 22/37 [00:00<00:00, 211.46it/s, loss=0.102, v_num=172, train_l\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 12: 100%|█| 37/37 [00:00<00:00, 263.81it/s, loss=0.102, v_num=172, train_l\u001b[A\n", + "Epoch 13: 59%|▌| 22/37 [00:00<00:00, 209.01it/s, loss=0.103, v_num=172, train_l\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 13: 100%|█| 37/37 [00:00<00:00, 269.92it/s, loss=0.103, v_num=172, train_l\u001b[A\n", + "Epoch 14: 59%|▌| 22/37 [00:00<00:00, 228.83it/s, loss=0.101, v_num=172, train_l\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 14: 100%|█| 37/37 [00:00<00:00, 288.03it/s, loss=0.101, v_num=172, train_l\u001b[A\n", + "Epoch 15: 59%|▌| 22/37 [00:00<00:00, 227.63it/s, loss=0.0993, v_num=172, train_\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 15: 100%|█| 37/37 [00:00<00:00, 278.53it/s, loss=0.0993, v_num=172, train_\u001b[A\n", + "Epoch 16: 59%|▌| 22/37 [00:00<00:00, 200.16it/s, loss=0.0983, v_num=172, train_\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 16: 100%|█| 37/37 [00:00<00:00, 254.47it/s, loss=0.0983, v_num=172, train_\u001b[A\n", + "Epoch 17: 59%|▌| 22/37 [00:00<00:00, 213.24it/s, loss=0.101, v_num=172, train_l\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 17: 100%|█| 37/37 [00:00<00:00, 272.68it/s, loss=0.101, v_num=172, train_l\u001b[A\n", + "Epoch 18: 59%|▌| 22/37 [00:00<00:00, 219.80it/s, loss=0.0978, v_num=172, train_\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 18: 100%|█| 37/37 [00:00<00:00, 278.25it/s, loss=0.0978, v_num=172, train_\u001b[A\n", + "Epoch 19: 59%|▌| 22/37 [00:00<00:00, 226.14it/s, loss=0.0938, v_num=172, train_\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 19: 100%|█| 37/37 [00:00<00:00, 278.35it/s, loss=0.0938, v_num=172, train_\u001b[A\n", + "Epoch 20: 59%|▌| 22/37 [00:00<00:00, 222.94it/s, loss=0.0957, v_num=172, train_\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 20: 100%|█| 37/37 [00:00<00:00, 258.91it/s, loss=0.0957, v_num=172, train_\u001b[A\n", + "Epoch 21: 59%|▌| 22/37 [00:00<00:00, 211.00it/s, loss=0.1, v_num=172, train_los\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 21: 100%|█| 37/37 [00:00<00:00, 273.39it/s, loss=0.1, v_num=172, train_los\u001b[A\n", + "Epoch 22: 59%|▌| 22/37 [00:00<00:00, 228.75it/s, loss=0.0937, v_num=172, train_\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 22: 100%|█| 37/37 [00:00<00:00, 281.84it/s, loss=0.0937, v_num=172, train_\u001b[A\n", + "Epoch 23: 59%|▌| 22/37 [00:00<00:00, 221.81it/s, loss=0.0934, v_num=172, train_\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 23: 100%|█| 37/37 [00:00<00:00, 278.76it/s, loss=0.0934, v_num=172, train_\u001b[A\n", + "Epoch 24: 59%|▌| 22/37 [00:00<00:00, 219.45it/s, loss=0.101, v_num=172, train_l\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 24: 100%|█| 37/37 [00:00<00:00, 276.55it/s, loss=0.101, v_num=172, train_l\u001b[A\n", + "Epoch 25: 59%|▌| 22/37 [00:00<00:00, 224.01it/s, loss=0.0938, v_num=172, train_\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 25: 100%|█| 37/37 [00:00<00:00, 281.76it/s, loss=0.0938, v_num=172, train_\u001b[A\n", + "Epoch 26: 59%|▌| 22/37 [00:00<00:00, 219.04it/s, loss=0.0868, v_num=172, train_\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 26: 100%|█| 37/37 [00:00<00:00, 274.49it/s, loss=0.0868, v_num=172, train_\u001b[A\n", + "Epoch 27: 59%|▌| 22/37 [00:00<00:00, 218.18it/s, loss=0.0901, v_num=172, train_\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 27: 100%|█| 37/37 [00:00<00:00, 271.59it/s, loss=0.0901, v_num=172, train_\u001b[A\n", + "Epoch 28: 59%|▌| 22/37 [00:00<00:00, 208.63it/s, loss=0.0883, v_num=172, train_\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 28: 100%|█| 37/37 [00:00<00:00, 265.92it/s, loss=0.0883, v_num=172, train_\u001b[A\n", + "Epoch 29: 59%|▌| 22/37 [00:00<00:00, 196.44it/s, loss=0.0871, v_num=172, train_\u001b[A\n", + "Validating: 0it [00:00, ?it/s]\u001b[A\n", + "Epoch 29: 100%|█| 37/37 [00:00<00:00, 246.41it/s, loss=0.0871, v_num=172, train_\u001b[A\n", + "Epoch 29: 100%|█| 37/37 [00:00<00:00, 233.53it/s, loss=0.0871, v_num=172, train_\u001b[A\n" + ] + } + ], + "source": [ + "model.fit(x_train, y_train, max_epochs=max_epochs, batch_size=batch_size)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# plot x_train\n", + "y_pred = model.predict(x_train)\n", + "y_pred_conformal = model.conformal_predict(x_train)\n", + "n_quantiles = len(quantile)\n", + "cycle_colors = plt.rcParams['axes.prop_cycle'].by_key()['color']\n", + "color_index = [2, 1, 3]\n", + "\n", + "plt.plot(np.arange(x_train.shape[0]), y_train, label=\"y_true\")\n", + "\n", + "for i, c in zip(range(n_quantiles), color_index):\n", + " plt.plot(np.arange(x_train.shape[0]), y_pred[:, i], c=cycle_colors[c], label=f\"p={quantile[i]}\",alpha = 0.3)\n", + "\n", + "for i, c in zip(range(n_quantiles), color_index):\n", + " plt.plot(np.arange(x_train.shape[0]), y_pred_conformal[:, i], c=cycle_colors[c], label=f\"p={quantile[i]}:conformal\")\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# plot x_test\n", + "y_pred = model.predict(x_val)\n", + "y_pred_conformal = model.conformal_predict(x_val)\n", + "n_quantiles = len(quantile)\n", + "cycle_colors = plt.rcParams['axes.prop_cycle'].by_key()['color']\n", + "color_index = [2, 1, 3]\n", + "\n", + "plt.plot(np.arange(x_val.shape[0]), y_val, label=\"y_true\")\n", + "\n", + "for i, c in zip(range(n_quantiles), color_index):\n", + " if i != 1:\n", + " plt.plot(np.arange(x_val.shape[0]), y_pred[:, i], c=cycle_colors[c], label=f\"p={quantile[i]}\",alpha = 0.3)\n", + "\n", + "for i, c in zip(range(n_quantiles), color_index):\n", + " plt.plot(np.arange(x_val.shape[0]), y_pred_conformal[:, i], c=cycle_colors[c], label=f\"p={quantile[i]}:conformal\")\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "y_pred =[]\n", + "y_pred_conformal = []\n", + "pred_length = x_val.shape[0]\n", + "for i in range(pred_length):\n", + " if i <10:\n", + " x_val_temp = x_val[i]\n", + " else:\n", + " x_val_temp = torch.cat((x_val_temp[0,1:],y_temp),0)\n", + " x_val_temp = x_val_temp.reshape(1,-1)\n", + " y_pred_temp = model.predict(x_val_temp)\n", + " y_pred_conformal_temp = model.conformal_predict(x_val_temp)\n", + " y_temp = y_pred_temp[0][1].reshape(-1)\n", + " y_pred.append(list(y_pred_temp.flatten().numpy()))\n", + " y_pred_conformal.append(list(y_pred_conformal_temp.flatten()))\n", + "y_pred = np.array(y_pred)\n", + "y_pred_conformal = np.array(y_pred_conformal)\n", + "n_quantiles = len(quantile)\n", + "cycle_colors = plt.rcParams['axes.prop_cycle'].by_key()['color']\n", + "color_index = [2, 1, 3]\n", + "\n", + "plt.plot(np.arange(x_val.shape[0]), y_val, label=\"y_true\")\n", + "\n", + "for i, c in zip(range(n_quantiles), color_index):\n", + " if i != 1:\n", + " plt.plot(np.arange(pred_length), y_pred[:, i], c=cycle_colors[c], label=f\"p={quantile[i]}\",alpha = 0.3)\n", + "\n", + "for i, c in zip(range(n_quantiles), color_index):\n", + " plt.plot(np.arange(pred_length), y_pred_conformal[:, i], c=cycle_colors[c], label=f\"p={quantile[i]}:conformal\")\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# plot x_test\n", + "y_pred = model.predict(x_test)\n", + "y_pred_conformal = model.conformal_predict(x_test)\n", + "n_quantiles = len(quantile)\n", + "cycle_colors = plt.rcParams['axes.prop_cycle'].by_key()['color']\n", + "color_index = [2, 1, 3]\n", + "\n", + "plt.plot(np.arange(x_test.shape[0]), y_test, label=\"y_true\")\n", + "\n", + "for i, c in zip(range(n_quantiles), color_index):\n", + " if i != 1:\n", + " plt.plot(np.arange(x_test.shape[0]), y_pred[:, i], c=cycle_colors[c], label=f\"p={quantile[i]}\",alpha = 0.3)\n", + "\n", + "for i, c in zip(range(n_quantiles), color_index):\n", + " plt.plot(np.arange(x_test.shape[0]), y_pred_conformal[:, i], c=cycle_colors[c], label=f\"p={quantile[i]}:conformal\")\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "y_pred =[]\n", + "y_pred_conformal = []\n", + "pred_length = x_test.shape[0]\n", + "for i in range(pred_length):\n", + " if i <10:\n", + " x_test_temp = x_test[i]\n", + " else:\n", + " x_test_temp = torch.cat((x_test_temp[0,1:],y_temp),0)\n", + " x_test_temp = x_test_temp.reshape(1,-1)\n", + " y_pred_temp = model.predict(x_test_temp)\n", + " y_pred_conformal_temp = model.conformal_predict(x_test_temp)\n", + " y_temp = y_pred_temp[0][1].reshape(-1)\n", + " y_pred.append(list(y_pred_temp.flatten().numpy()))\n", + " y_pred_conformal.append(list(y_pred_conformal_temp.flatten()))\n", + "y_pred = np.array(y_pred)\n", + "y_pred_conformal = np.array(y_pred_conformal)\n", + "n_quantiles = len(quantile)\n", + "cycle_colors = plt.rcParams['axes.prop_cycle'].by_key()['color']\n", + "color_index = [2, 1, 3]\n", + "\n", + "plt.plot(np.arange(x_test.shape[0]), y_test, label=\"y_true\")\n", + "\n", + "for i, c in zip(range(n_quantiles), color_index):\n", + " if i != 1:\n", + " plt.plot(np.arange(pred_length), y_pred[:, i], c=cycle_colors[c], label=f\"p={quantile[i]}\",alpha = 0.3)\n", + "\n", + "for i, c in zip(range(n_quantiles), color_index):\n", + " plt.plot(np.arange(pred_length), y_pred_conformal[:, i], c=cycle_colors[c], label=f\"p={quantile[i]}:conformal\")\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "interpreter": { + "hash": "6a69466490a3cd78f8127aa86c71c97a1b8be0ac73f00bec705cc872d22503a4" + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.9.7" + }, + "toc-autonumbering": true, + "toc-showcode": true, + "toc-showmarkdowntxt": false + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/examples/quantile-regression/lstm-quantile-regression.ipynb b/examples/quantile-regression/lstm-quantile-regression.ipynb index f683d8b7..a3ee0a34 100644 --- a/examples/quantile-regression/lstm-quantile-regression.ipynb +++ b/examples/quantile-regression/lstm-quantile-regression.ipynb @@ -6,30 +6,48 @@ "metadata": {}, "outputs": [], "source": [ - "import torch\n", - "import numpy as np\n", "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import torch\n", + "from torch import nn, optim\n", "\n", "from torchts.nn.loss import quantile_loss\n", - "from torchts.nn.model import TimeSeriesModel\n", - "from torchts.nn.models.seq2seq import Encoder, Decoder, Seq2Seq " + "from torchts.nn.model import TimeSeriesModel" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "# Generate dataset" + "# Set random seed for reproducibility" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, + "outputs": [], + "source": [ + "seed = 0\n", + "torch.manual_seed(seed)\n", + "np.random.seed(seed)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Generate data" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -42,9 +60,15 @@ ], "source": [ "# generate linear time series data with some noise\n", - "x = np.linspace(-10,10,100).reshape(-1,1).astype(np.float32)\n", - "y = 2*x+1 + np.random.normal(0, 2, x.shape).reshape(-1,1).astype(np.float32)\n", - "plt.plot(x.flatten(), y.flatten())\n", + "n = 200\n", + "x_max = 10\n", + "slope = 2\n", + "scale = 2\n", + "\n", + "x = torch.from_numpy(np.linspace(-x_max, x_max, n).reshape(-1, 1).astype(np.float32))\n", + "y = slope * x + np.random.normal(0, scale, n).reshape(-1, 1).astype(np.float32)\n", + "\n", + "plt.plot(x, y)\n", "plt.show()" ] }, @@ -52,62 +76,74 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Enable uncertainty quantification in LSTM model" + "# Define model that predicts quantiles" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ - "class LSTM(TimeSeriesModel):\n", - " def __init__(self, input_size, output_size, optimizer, hidden_size=8, batch_size=10, **kwargs):\n", - " super(LSTM, self).__init__(optimizer, **kwargs)\n", - " self.hidden_size = hidden_size\n", - " self.batch_size = batch_size\n", - "\n", - " self.lstm = torch.nn.LSTMCell(input_size, hidden_size)\n", - " self.linear = torch.nn.Linear(hidden_size, output_size)\n", - "\n", - " def init_hidden(self):\n", - " # initialize the hidden state and the cell state to zeros\n", - " return (torch.zeros(self.batch_size, self.hidden_size),\n", - " torch.zeros(self.batch_size, self.hidden_size))\n", + "class QuantileLSTM(TimeSeriesModel):\n", + " def __init__(\n", + " self, input_size, output_size, hidden_size, optimizer, quantile=0.5, **kwargs\n", + " ):\n", + " super().__init__(\n", + " optimizer,\n", + " criterion=quantile_loss,\n", + " criterion_args={\"quantile\": quantile},\n", + " **kwargs\n", + " )\n", + " n_quantiles = 1 if isinstance(quantile, float) else len(quantile)\n", + " self.lstm = nn.ModuleList(\n", + " [nn.LSTMCell(input_size, hidden_size) for _ in range(output_size)]\n", + " )\n", + " self.linear = nn.ModuleList(\n", + " [nn.Linear(hidden_size, n_quantiles) for _ in range(output_size)]\n", + " )\n", "\n", " def forward(self, x, y=None, batches_seen=None):\n", - " hc = self.init_hidden()\n", - " \n", - " hidden, _ = self.lstm(x, hc)\n", - " out = self.linear(hidden)\n", - " return out" + " hidden, _ = zip(*[m(x) for m in self.lstm])\n", + " out = [m(h) for m, h in zip(self.linear, hidden)]\n", + " return torch.hstack(out)" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ - "inputDim = 1 \n", - "outputDim = 1 \n", - "optimizer_args = {\"lr\": 0.01}\n", - "quantiles = [0.025, 0.5, 0.975]\n", - "\n", + "input_size = 1\n", + "output_size = 1\n", + "hidden_size = 16\n", + "quantile = 0.5\n", + "optimizer = optim.Adam\n", + "optimizer_args = {\"lr\": 0.005}\n", + "max_epochs = 100\n", "batch_size = 10\n", - "models = {quantile: LSTM(\n", - " inputDim, \n", - " outputDim, \n", - " torch.optim.Adam,\n", - " criterion=quantile_loss, \n", - " criterion_args={\"quantile\": quantile}, \n", - " optimizer_args=optimizer_args\n", - " ) for quantile in quantiles}" + "\n", + "model = QuantileLSTM(\n", + " input_size,\n", + " output_size,\n", + " hidden_size,\n", + " optimizer,\n", + " quantile=quantile,\n", + " optimizer_args=optimizer_args,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Train model to predict a single quantile" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -117,34 +153,21 @@ "GPU available: False, used: False\n", "TPU available: False, using: 0 TPU cores\n", "IPU available: False, using: 0 IPUs\n", - "/Users/kailing/Documents/GitHub/DSC/dsc_180a/torchTS_kai_dev/venv/lib/python3.8/site-packages/pytorch_lightning/trainer/configuration_validator.py:101: UserWarning: you defined a validation_step but have no val_dataloader. Skipping val loop\n", - " rank_zero_warn(f\"you defined a {step_name} but have no {loader_name}. Skipping {stage} loop\")\n", + "/Users/klane/.repos/github.com/Rose-STL-Lab/torchTS/.venv/lib/python3.8/site-packages/pytorch_lightning/trainer/configuration_validator.py:122: UserWarning: You defined a `validation_step` but have no `val_dataloader`. Skipping val loop.\n", + " rank_zero_warn(\"You defined a `validation_step` but have no `val_dataloader`. Skipping val loop.\")\n", "\n", - " | Name | Type | Params\n", - "------------------------------------\n", - "0 | lstm | LSTMCell | 352 \n", - "1 | linear | Linear | 9 \n", - "------------------------------------\n", - "361 Trainable params\n", + " | Name | Type | Params\n", + "--------------------------------------\n", + "0 | lstm | ModuleList | 1.2 K \n", + "1 | linear | ModuleList | 17 \n", + "--------------------------------------\n", + "1.2 K Trainable params\n", "0 Non-trainable params\n", - "361 Total params\n", - "0.001 Total estimated model params size (MB)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Epoch 0: 100%|██████████| 10/10 [00:00<00:00, 119.81it/s, loss=4.45, v_num=75, train_loss_step=6.840]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/kailing/Documents/GitHub/DSC/dsc_180a/torchTS_kai_dev/venv/lib/python3.8/site-packages/pytorch_lightning/trainer/data_loading.py:105: UserWarning: The dataloader, train dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 8 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", + "1.2 K Total params\n", + "0.005 Total estimated model params size (MB)\n", + "/Users/klane/.repos/github.com/Rose-STL-Lab/torchTS/.venv/lib/python3.8/site-packages/pytorch_lightning/trainer/data_loading.py:116: UserWarning: The dataloader, train_dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 8 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", " rank_zero_warn(\n", - "/Users/kailing/Documents/GitHub/DSC/dsc_180a/torchTS_kai_dev/venv/lib/python3.8/site-packages/pytorch_lightning/trainer/data_loading.py:322: UserWarning: The number of training samples (10) is smaller than the logging interval Trainer(log_every_n_steps=50). Set a lower value for log_every_n_steps if you want to see logs for the training epoch.\n", + "/Users/klane/.repos/github.com/Rose-STL-Lab/torchTS/.venv/lib/python3.8/site-packages/pytorch_lightning/trainer/data_loading.py:412: UserWarning: The number of training samples (20) is smaller than the logging interval Trainer(log_every_n_steps=50). Set a lower value for log_every_n_steps if you want to see logs for the training epoch.\n", " rank_zero_warn(\n" ] }, @@ -152,9 +175,73 @@ "name": "stdout", "output_type": "stream", "text": [ - "Epoch 99: 100%|██████████| 10/10 [00:00<00:00, 83.19it/s, loss=0.103, v_num=75, train_loss_step=0.0911, train_loss_epoch=0.110]\n" + "Epoch 99: 100%|██████████| 20/20 [00:00<00:00, 231.19it/s, loss=0.815, v_num=301, train_loss_step=0.681, train_loss_epoch=0.815]\n" ] - }, + } + ], + "source": [ + "# train model\n", + "model.fit(x, y, max_epochs=max_epochs, batch_size=batch_size)\n", + "\n", + "# inference\n", + "y_preds = model.predict(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(x, y, label=\"y_true\")\n", + "plt.plot(x, y_preds, label=f\"p={quantile}\")\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Train model to predict multiple quantiles" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "quantile = [0.025, 0.5, 0.975]\n", + "\n", + "model = QuantileLSTM(\n", + " input_size,\n", + " output_size,\n", + " hidden_size,\n", + " optimizer,\n", + " quantile=quantile,\n", + " optimizer_args=optimizer_args,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ { "name": "stderr", "output_type": "stream", @@ -162,25 +249,141 @@ "GPU available: False, used: False\n", "TPU available: False, using: 0 TPU cores\n", "IPU available: False, using: 0 IPUs\n", + "/Users/klane/.repos/github.com/Rose-STL-Lab/torchTS/.venv/lib/python3.8/site-packages/pytorch_lightning/trainer/configuration_validator.py:122: UserWarning: You defined a `validation_step` but have no `val_dataloader`. Skipping val loop.\n", + " rank_zero_warn(\"You defined a `validation_step` but have no `val_dataloader`. Skipping val loop.\")\n", "\n", - " | Name | Type | Params\n", - "------------------------------------\n", - "0 | lstm | LSTMCell | 352 \n", - "1 | linear | Linear | 9 \n", - "------------------------------------\n", - "361 Trainable params\n", + " | Name | Type | Params\n", + "--------------------------------------\n", + "0 | lstm | ModuleList | 1.2 K \n", + "1 | linear | ModuleList | 51 \n", + "--------------------------------------\n", + "1.3 K Trainable params\n", "0 Non-trainable params\n", - "361 Total params\n", - "0.001 Total estimated model params size (MB)\n" + "1.3 K Total params\n", + "0.005 Total estimated model params size (MB)\n", + "/Users/klane/.repos/github.com/Rose-STL-Lab/torchTS/.venv/lib/python3.8/site-packages/pytorch_lightning/trainer/data_loading.py:116: UserWarning: The dataloader, train_dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 8 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", + " rank_zero_warn(\n", + "/Users/klane/.repos/github.com/Rose-STL-Lab/torchTS/.venv/lib/python3.8/site-packages/pytorch_lightning/trainer/data_loading.py:412: UserWarning: The number of training samples (20) is smaller than the logging interval Trainer(log_every_n_steps=50). Set a lower value for log_every_n_steps if you want to see logs for the training epoch.\n", + " rank_zero_warn(\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch 99: 100%|██████████| 10/10 [00:00<00:00, 121.28it/s, loss=0.768, v_num=76, train_loss_step=0.919, train_loss_epoch=0.758]\n" + "Epoch 99: 100%|██████████| 20/20 [00:00<00:00, 229.07it/s, loss=1.02, v_num=302, train_loss_step=0.978, train_loss_epoch=1.020] \n" ] - }, + } + ], + "source": [ + "# train model\n", + "model.fit(x, y, max_epochs=max_epochs, batch_size=batch_size)\n", + "\n", + "# inference\n", + "y_preds = model.predict(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "n_quantiles = len(quantile)\n", + "cycle_colors = plt.rcParams['axes.prop_cycle'].by_key()['color']\n", + "color_index = [2, 1, 3]\n", + "\n", + "plt.plot(x, y, label=\"y_true\")\n", + "\n", + "for i, c in zip(range(n_quantiles), color_index):\n", + " plt.plot(x, y_preds[:, i], c=cycle_colors[c], label=f\"p={quantile[i]}\")\n", + "\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Add second response variable" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "y_max = slope * x_max\n", + "y2 = 2 * y_max / (1 + np.exp(-x)) - y_max\n", + "y2 += np.random.normal(0, scale, n).reshape(-1, 1).astype(np.float32)\n", + "y = torch.hstack([y, y2])\n", + "\n", + "plt.figure(figsize=(12, 4))\n", + "plt.subplot(1, 2, 1)\n", + "plt.plot(x, y[:, 0])\n", + "plt.subplot(1, 2, 2)\n", + "plt.plot(x, y[:, 1])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Train model to predict quantiles for two response variables" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "output_size = 2\n", + "\n", + "model = QuantileLSTM(\n", + " input_size,\n", + " output_size,\n", + " hidden_size,\n", + " optimizer,\n", + " quantile=quantile,\n", + " optimizer_args=optimizer_args,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ { "name": "stderr", "output_type": "stream", @@ -188,64 +391,50 @@ "GPU available: False, used: False\n", "TPU available: False, using: 0 TPU cores\n", "IPU available: False, using: 0 IPUs\n", + "/Users/klane/.repos/github.com/Rose-STL-Lab/torchTS/.venv/lib/python3.8/site-packages/pytorch_lightning/trainer/configuration_validator.py:122: UserWarning: You defined a `validation_step` but have no `val_dataloader`. Skipping val loop.\n", + " rank_zero_warn(\"You defined a `validation_step` but have no `val_dataloader`. Skipping val loop.\")\n", "\n", - " | Name | Type | Params\n", - "------------------------------------\n", - "0 | lstm | LSTMCell | 352 \n", - "1 | linear | Linear | 9 \n", - "------------------------------------\n", - "361 Trainable params\n", + " | Name | Type | Params\n", + "--------------------------------------\n", + "0 | lstm | ModuleList | 2.4 K \n", + "1 | linear | ModuleList | 102 \n", + "--------------------------------------\n", + "2.5 K Trainable params\n", "0 Non-trainable params\n", - "361 Total params\n", - "0.001 Total estimated model params size (MB)\n" + "2.5 K Total params\n", + "0.010 Total estimated model params size (MB)\n", + "/Users/klane/.repos/github.com/Rose-STL-Lab/torchTS/.venv/lib/python3.8/site-packages/pytorch_lightning/trainer/data_loading.py:116: UserWarning: The dataloader, train_dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 8 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", + " rank_zero_warn(\n", + "/Users/klane/.repos/github.com/Rose-STL-Lab/torchTS/.venv/lib/python3.8/site-packages/pytorch_lightning/trainer/data_loading.py:412: UserWarning: The number of training samples (20) is smaller than the logging interval Trainer(log_every_n_steps=50). Set a lower value for log_every_n_steps if you want to see logs for the training epoch.\n", + " rank_zero_warn(\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch 99: 100%|██████████| 10/10 [00:00<00:00, 135.13it/s, loss=0.138, v_num=77, train_loss_step=0.0974, train_loss_epoch=0.139]\n" + "Epoch 99: 100%|██████████| 20/20 [00:00<00:00, 205.84it/s, loss=1.98, v_num=303, train_loss_step=2.110, train_loss_epoch=1.980]\n" ] } ], "source": [ - "for _, model in models.items():\n", - " # train model\n", - " model.fit(\n", - " torch.from_numpy(x),\n", - " torch.from_numpy(y),\n", - " max_epochs=100,\n", - " batch_size=batch_size,\n", - " )" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ + "# train model\n", + "model.fit(x, y, max_epochs=max_epochs, batch_size=batch_size)\n", + "\n", "# inference\n", - "y_preds = {}\n", - "for x_batch in torch.split(torch.from_numpy(x), batch_size):\n", - " for q, model in models.items():\n", - " if q not in y_preds:\n", - " y_preds[q] = [model.predict(x_batch).detach().numpy()]\n", - " else:\n", - " y_preds[q].append(model.predict(x_batch).detach().numpy())\n", - "y_preds = {q: np.concatenate(y_pred) for q, y_pred in y_preds.items()}" + "y_preds = model.predict(x)" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 14, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -255,20 +444,26 @@ } ], "source": [ - "plt.plot(x.flatten(), y_preds[0.025].flatten(), label=\"p=0.025\")\n", - "plt.plot(x.flatten(), y_preds[0.5].flatten(), label=\"p=0.5\")\n", - "plt.plot(x.flatten(), y_preds[0.975].flatten(), label=\"p=0.975\")\n", - "plt.plot(x.flatten(), y.flatten(), label=\"y_true\")\n", + "plt.figure(figsize=(12, 4))\n", + "\n", + "plt.subplot(1, 2, 1)\n", + "plt.plot(x, y[:, 0], label=\"y_true\")\n", + "\n", + "for i, c in zip(range(n_quantiles), color_index):\n", + " plt.plot(x, y_preds[:, i], c=cycle_colors[c], label=f\"p={quantile[i]}\")\n", + "\n", "plt.legend()\n", + "\n", + "plt.subplot(1, 2, 2)\n", + "plt.plot(x, y[:, 1], label=\"y_true\")\n", + "\n", + "for i, c in zip(range(n_quantiles), color_index):\n", + " plt.plot(x, y_preds[:, i + n_quantiles], c=cycle_colors[c], label=f\"p={quantile[i]}\")\n", + "\n", + "plt.legend()\n", + "\n", "plt.show()" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { @@ -276,7 +471,7 @@ "hash": "6a69466490a3cd78f8127aa86c71c97a1b8be0ac73f00bec705cc872d22503a4" }, "kernelspec": { - "display_name": "Python 3.8.2 64-bit ('venv': venv)", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -290,10 +485,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.2" - }, - "orig_nbformat": 4 + "version": "3.9.7" + } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } diff --git a/tests/nn/test_loss.py b/tests/nn/test_loss.py index 4efd9f9e..e594ff2b 100644 --- a/tests/nn/test_loss.py +++ b/tests/nn/test_loss.py @@ -7,13 +7,13 @@ @pytest.fixture def y_true(): data = [1, 2, 3] - return torch.tensor(data) + return torch.tensor(data).reshape(-1, 1) @pytest.fixture def y_pred(): data = [1.1, 1.9, 3.1] - return torch.tensor(data) + return torch.tensor(data).reshape(-1, 1) def test_masked_mae_loss(y_true, y_pred): @@ -23,7 +23,13 @@ def test_masked_mae_loss(y_true, y_pred): @pytest.mark.parametrize( - "quantile, expected_loss", [(0.05, 0.065), (0.5, 0.05), (0.95, 0.035)] + "quantile, expected_loss", + [ + (0.05, 0.065), + (0.5, 0.05), + (0.95, 0.035), + ([0.05, 0.5, 0.95], 0.065 + 0.05 + 0.035), + ], ) def test_quantile_loss(y_true, y_pred, quantile, expected_loss): """Test quantile_loss()""" diff --git a/torchts/nn/loss.py b/torchts/nn/loss.py index 529ba56b..dd1ce93e 100644 --- a/torchts/nn/loss.py +++ b/torchts/nn/loss.py @@ -1,3 +1,6 @@ +from typing import List, Union + +import numpy as np import torch @@ -21,18 +24,44 @@ def masked_mae_loss(y_pred, y_true): return loss.mean() -def quantile_loss(y_pred: torch.tensor, y_true: torch.tensor, quantile: float) -> float: +def quantile_loss( + y_pred: torch.tensor, y_true: torch.tensor, quantile: Union[float, List[float]] +) -> torch.tensor: """Calculate quantile loss Args: y_pred (torch.tensor): Predicted values y_true (torch.tensor): True values - quantile (float): quantile (e.g. 0.5 for median) + quantile (float or list): quantile(s) (e.g. 0.5 for median) Returns: - float: output losses + torch.tensor: output losses """ - errors = y_true - y_pred + if isinstance(quantile, list): + errors = torch.repeat_interleave(y_true, len(quantile), dim=1) - y_pred + quantile = torch.FloatTensor(quantile) + quantile = quantile.repeat(1, y_true.shape[-1]) + else: + errors = y_true - y_pred + loss = torch.max((quantile - 1) * errors, quantile * errors) - loss = torch.mean(loss) + loss = torch.mean(loss, dim=0) + loss = torch.sum(loss) + return loss + + +def quantile_err(prediction, y): + """ + prediction: arr where first 3 columns are: lower quantile, middle quantile (50%), upper quantile in that order + """ + y_lower = prediction[:, 0] + y_upper = prediction[:, 2] + # Calculate error on our predicted upper and lower quantiles + # this will get us an array of negative values with the distance between the upper/lower quantile and the + # 50% quantile + error_low = y_lower - y.view(-1) + error_high = y.view(-1) - y_upper + # Make an array where each entry is the highest error when comparing the upper and lower bounds for that entry prediction + err = np.maximum(error_high, error_low) + return err diff --git a/torchts/nn/model.py b/torchts/nn/model.py index 97869e3a..4dce2a21 100644 --- a/torchts/nn/model.py +++ b/torchts/nn/model.py @@ -1,9 +1,16 @@ from abc import abstractmethod from functools import partial +import matplotlib.pyplot as plt +import numpy as np +import torch import torch.nn.functional as F +from matplotlib import fontconfig_pattern from pytorch_lightning import LightningModule, Trainer -from torch.utils.data import DataLoader, TensorDataset +from sklearn.model_selection import train_test_split +from torch.utils.data import DataLoader, TensorDataset, random_split + +from torchts.nn.loss import quantile_err class TimeSeriesModel(LightningModule): @@ -14,6 +21,7 @@ class TimeSeriesModel(LightningModule): opimizer_args (dict): Arguments for the optimizer criterion: Loss function criterion_args (dict): Arguments for the loss function + method: conformal prediction scheduler (torch.optim.lr_scheduler): Learning rate scheduler scheduler_args (dict): Arguments for the scheduler scaler (torchts.utils.scaler.Scaler): Scaler @@ -25,6 +33,9 @@ def __init__( optimizer_args=None, criterion=F.mse_loss, criterion_args=None, + significance=None, + method=None, + mode=None, scheduler=None, scheduler_args=None, scaler=None, @@ -32,7 +43,10 @@ def __init__( super().__init__() self.criterion = criterion self.criterion_args = criterion_args + self.significance = significance + self.method = method self.scaler = scaler + self.mode = mode if optimizer_args is not None: self.optimizer = partial(optimizer, **optimizer_args) @@ -54,9 +68,36 @@ def fit(self, x, y, max_epochs=10, batch_size=128): batch_size (int): Batch size for torch.utils.data.DataLoader """ dataset = TensorDataset(x, y) - loader = DataLoader(dataset, batch_size=batch_size, shuffle=True) + # loader = DataLoader(dataset, batch_size=batch_size, shuffle=True) + # trainer.fit(self, loader) + trainer = Trainer(max_epochs=max_epochs) - trainer.fit(self, loader) + + # conformal prediction, data initiation + if self.method == "conformal": + lengths = [int(len(dataset) * 0.6), len(dataset) - int(len(dataset) * 0.6)] + if self.mode == "regression": + train_dataset, cal_dataset = random_split(dataset, lengths) + if self.mode == "time_series": + train_dataset, cal_dataset = random_split(dataset, lengths) + # self.train_dataset, self.cal_dataset = train_test_split(dataset,test_size =0.4,shuffle=False) + train_dataloader = DataLoader( + train_dataset, batch_size=batch_size, shuffle=True + ) + cal_dataloader = DataLoader( + cal_dataset, batch_size=batch_size, shuffle=True + ) + # self.trainer.fit(self, train_dataloader) + trainer.fit(self, train_dataloader, cal_dataloader) + + else: + # train_dataloader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True) + # val_dataloader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False) + # test_dataloader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False) + + # split to only train on training set + loader = DataLoader(dataset, batch_size=batch_size, shuffle=True) + trainer.fit(self, loader) def prepare_batch(self, batch): return batch @@ -72,7 +113,6 @@ def _step(self, batch, batch_idx, num_batches): Returns: loss for the batch """ x, y = self.prepare_batch(batch) - if self.training: batches_seen = batch_idx + self.current_epoch * num_batches else: @@ -82,10 +122,23 @@ def _step(self, batch, batch_idx, num_batches): if self.scaler is not None: y = self.scaler.inverse_transform(y) - pred = self.scaler.inverse_transform(pred) + y = torch.tensor(y).float() + pred = self.scaler.inverse_transform(pred.detach()) + pred = torch.tensor(pred, requires_grad=True).float() if self.criterion_args is not None: - loss = self.criterion(pred, y, **self.criterion_args) + # if in validation step, do the conformal on calibrition set + if (not self.training) and self.method == "conformal": + intervals = np.zeros((x.shape[0], 3)) + # ensure that we want to multiply our error distances by the size of our training set + err_dist = np.hstack([self.err_dist] * x.shape[0]) + + intervals[:, 0] = pred[:, 0] - err_dist[0, :] + intervals[:, 1] = pred[:, 1] + intervals[:, -1] = pred[:, -1] + err_dist[1, :] + loss = self.criterion(intervals, y, **self.criterion_args) + else: + loss = self.criterion(pred, y, **self.criterion_args) else: loss = self.criterion(pred, y) @@ -116,7 +169,13 @@ def validation_step(self, batch, batch_idx): batch (torch.Tensor): Output of the torch.utils.data.DataLoader batch_idx (int): Integer displaying index of this batch """ - val_loss = self._step(batch, batch_idx, len(self.trainer.val_dataloader)) + + # do calibration on validation set to prevent overfitting + if self.method == "conformal": + self.err_dist = self.calibration( + batch, batch_idx, len(self.trainer.val_dataloaders) + ) + val_loss = self._step(batch, batch_idx, len(self.trainer.val_dataloaders)) self.log("val_loss", val_loss) return val_loss @@ -127,10 +186,61 @@ def test_step(self, batch, batch_idx): batch (torch.Tensor): Output of the torch.utils.data.DataLoader batch_idx (int): Integer displaying index of this batch """ - test_loss = self._step(batch, batch_idx, len(self.trainer.test_dataloader)) + test_loss = self._step(batch, batch_idx, len(self.trainer.test_dataloaders)) self.log("test_loss", test_loss) return test_loss + def calibration(self, batch, batch_idx, num_batches): + """ + + Args: + batch: Output of the torch.utils.data.DataLoader + batch_idx: Integer displaying index of this batch + + Returns: err_dist for the calibration set + """ + x, y = self.prepare_batch(batch) + batches_seen = batch_idx + pred = self(x, y, batches_seen) + + if self.scaler is not None: + y = self.scaler.inverse_transform(y) + y = torch.tensor(y).float() + pred = self.scaler.inverse_transform(pred.detach()) + pred = torch.tensor(pred).float() + + cal_scores = quantile_err(pred, y) + + # Sort calibration scores in ascending order + nc = np.sort(cal_scores, 0) # [::-1] + + index = int(np.ceil((1 - self.significance) * (nc.shape[0] + 1))) - 1 + # find largest error that gets us guaranteed coverage + index = min(max(index, 0), nc.shape[0] - 1) + err_dist = np.vstack([nc[index], nc[index]]) + + return err_dist + + def calibration_pred(self, x): + """ + Incorprating the err_dist, predict result + Args: + x (torch.Tensor): Input data + + Output: Predicted interval + """ + + pred = self.predict(x) + intervals = np.zeros((x.shape[0], 3)) + # ensure that we want to multiply our error distances by the size of our training set + err_dist = np.hstack([self.err_dist] * x.shape[0]) + + intervals[:, 0] = pred[:, 0] - err_dist[0, :] + intervals[:, 1] = pred[:, 1] + intervals[:, -1] = pred[:, -1] + err_dist[1, :] + conformal_intervals = intervals + return conformal_intervals + @abstractmethod def forward(self, x, y=None, batches_seen=None): """Forward pass. @@ -153,6 +263,19 @@ def predict(self, x): """ return self(x).detach() + def conformal_predict(self, x): + """Runs model inference. + + Args: + x (torch.Tensor): Input data + + Returns: + torch.Tensor: Predicted confromal result + """ + if self.method == "conformal": + return self.calibration_pred(x) + return self(x).detach() + def configure_optimizers(self): """Configure optimizer.