From 1bd110428df6b23815c0efd622337e77be2962cb Mon Sep 17 00:00:00 2001
From: wassname <git@wassname.org>
Date: Sat, 16 Jul 2022 15:44:22 +0800
Subject: [PATCH] tidy

---
 .../BasicWind-checkpoint.py                   |  80 ---
 .../GPGenerator-checkpoint.py                 | 178 ------
 .../.ipynb_checkpoints/README-checkpoint.md   |  15 -
 .../calib_plotter-checkpoint.ipynb            | 486 ----------------
 .../make_wind_dataset-checkpoint.ipynb        | 174 ------
 .../mtwind_plotting-checkpoint.ipynb          | 529 ------------------
 voltron/.env                                  |   2 -
 .../.ipynb_checkpoints/__init__-checkpoint.py |  12 -
 .../option_utils-checkpoint.py                |  41 --
 .../robinhood_utils-checkpoint.py             |  22 -
 .../rollout_utils-checkpoint.py               | 115 ----
 .../train_utils-checkpoint.py                 |  94 ----
 .../.ipynb_checkpoints/MakeData-checkpoint.py |  41 --
 .../.ipynb_checkpoints/__init__-checkpoint.py |   1 -
 .../test_tickers-checkpoint.txt               |  10 -
 .../.ipynb_checkpoints/BMKernel-checkpoint.py |  16 -
 .../VolKernel-checkpoint.py                   |  37 --
 .../.ipynb_checkpoints/__init__-checkpoint.py |   2 -
 .../.ipynb_checkpoints/__init__-checkpoint.py |   1 -
 .../volatility_likelihood-checkpoint.py       |  61 --
 .../.ipynb_checkpoints/EWMA-checkpoint.py     | 113 ----
 .../.ipynb_checkpoints/__init__-checkpoint.py |   3 -
 .../loglinear_mean-checkpoint.py              |  21 -
 .../.ipynb_checkpoints/BMGP-checkpoint.py     |   0
 .../BasicGPModels-checkpoint.py               |  53 --
 .../.ipynb_checkpoints/LSTM-checkpoint.py     | 113 ----
 .../.ipynb_checkpoints/Volt-checkpoint.py     | 162 ------
 .../.ipynb_checkpoints/__init__-checkpoint.py |   6 -
 .../single_task_variational_gp-checkpoint.py  | 265 ---------
 29 files changed, 2653 deletions(-)
 delete mode 100644 experiments/weather/.ipynb_checkpoints/BasicWind-checkpoint.py
 delete mode 100644 experiments/weather/.ipynb_checkpoints/GPGenerator-checkpoint.py
 delete mode 100644 experiments/weather/.ipynb_checkpoints/README-checkpoint.md
 delete mode 100644 experiments/weather/.ipynb_checkpoints/calib_plotter-checkpoint.ipynb
 delete mode 100644 experiments/weather/.ipynb_checkpoints/make_wind_dataset-checkpoint.ipynb
 delete mode 100644 experiments/weather/.ipynb_checkpoints/mtwind_plotting-checkpoint.ipynb
 delete mode 100644 voltron/.env
 delete mode 100644 voltron/.ipynb_checkpoints/__init__-checkpoint.py
 delete mode 100644 voltron/.ipynb_checkpoints/option_utils-checkpoint.py
 delete mode 100644 voltron/.ipynb_checkpoints/robinhood_utils-checkpoint.py
 delete mode 100644 voltron/.ipynb_checkpoints/rollout_utils-checkpoint.py
 delete mode 100644 voltron/.ipynb_checkpoints/train_utils-checkpoint.py
 delete mode 100644 voltron/data/.ipynb_checkpoints/MakeData-checkpoint.py
 delete mode 100644 voltron/data/.ipynb_checkpoints/__init__-checkpoint.py
 delete mode 100644 voltron/data/.ipynb_checkpoints/test_tickers-checkpoint.txt
 delete mode 100644 voltron/kernels/.ipynb_checkpoints/BMKernel-checkpoint.py
 delete mode 100644 voltron/kernels/.ipynb_checkpoints/VolKernel-checkpoint.py
 delete mode 100644 voltron/kernels/.ipynb_checkpoints/__init__-checkpoint.py
 delete mode 100644 voltron/likelihoods/.ipynb_checkpoints/__init__-checkpoint.py
 delete mode 100644 voltron/likelihoods/.ipynb_checkpoints/volatility_likelihood-checkpoint.py
 delete mode 100644 voltron/means/.ipynb_checkpoints/EWMA-checkpoint.py
 delete mode 100644 voltron/means/.ipynb_checkpoints/__init__-checkpoint.py
 delete mode 100644 voltron/means/.ipynb_checkpoints/loglinear_mean-checkpoint.py
 delete mode 100644 voltron/models/.ipynb_checkpoints/BMGP-checkpoint.py
 delete mode 100644 voltron/models/.ipynb_checkpoints/BasicGPModels-checkpoint.py
 delete mode 100644 voltron/models/.ipynb_checkpoints/LSTM-checkpoint.py
 delete mode 100644 voltron/models/.ipynb_checkpoints/Volt-checkpoint.py
 delete mode 100644 voltron/models/.ipynb_checkpoints/__init__-checkpoint.py
 delete mode 100644 voltron/models/.ipynb_checkpoints/single_task_variational_gp-checkpoint.py

diff --git a/experiments/weather/.ipynb_checkpoints/BasicWind-checkpoint.py b/experiments/weather/.ipynb_checkpoints/BasicWind-checkpoint.py
deleted file mode 100644
index 02695c9..0000000
--- a/experiments/weather/.ipynb_checkpoints/BasicWind-checkpoint.py
+++ /dev/null
@@ -1,80 +0,0 @@
-import matplotlib.pyplot as plt
-import seaborn as sns
-import numpy as np
-import torch
-import pandas as pd
-import os
-import gpytorch
-import argparse
-import datetime
-
-from botorch.models import SingleTaskGP
-from botorch.optim.fit import fit_gpytorch_torch
-from gpytorch.likelihoods import GaussianLikelihood
-from gpytorch.mlls import ExactMarginalLogLikelihood
-from gpytorch.means import ConstantMean, LinearMean
-from gpytorch.kernels import SpectralMixtureKernel, MaternKernel, RBFKernel, ScaleKernel
-from voltron.means import EWMAMean, DEWMAMean, TEWMAMean
-from voltron.train_utils import LearnGPCV, TrainVolModel, TrainVoltMagpieModel, TrainBasicModel
-from voltron.models import VoltMagpie
-from voltron.means import LogLinearMean
-
-from voltron.rollout_utils import GeneratePrediction, Rollouts
-from voltron.data import make_ticker_list, DataGetter, GetStockHistory
-
-
-def BasicWindRollouts(train_x, train_y, test_x, kernel_name, mean_name='ewma', k=20,
-                        train_iters=600, nsample=1000):
-    
-
-    kernel_possibilities = {"sm": SpectralMixtureKernel, 
-                            "matern": MaternKernel, 
-                            "rbf": RBFKernel}
-    kernel = kernel_possibilities[kernel_name.lower()]
-    if kernel_name.lower() != "sm":
-        kernel = ScaleKernel(kernel())
-    else:
-        kernel = kernel(num_mixtures=20)
-        kernel.initialize_from_data_empspect(train_x, train_y.log())
-
-    model = SingleTaskGP(
-        train_x.view(-1,1), 
-        train_y.log().reshape(-1, 1), 
-        covar_module=kernel, 
-        likelihood=GaussianLikelihood()
-    )
-
-    mean_name = mean_name.lower()
-    if mean_name == "loglinear":
-        model.mean_module = LogLinearMean(1)
-        model.mean_module.initialize_from_data(train_x, train_y.log())
-    elif mean_name == 'linear':
-        model.mean_module = LinearMean(1)
-    elif mean_name == "constant":
-        model.mean_module = ConstantMean()
-    elif mean_name == "ewma":
-        model.mean_module = EWMAMean(train_x, train_y.log(), k=k).to(train_x.device)
-    elif mean_name == "dewma":
-        model.mean_module = DEWMAMean(train_x, train_y.log(), k=k).to(train_x.device)
-    elif mean_name == "tewma":
-        model.mean_module = TEWMAMean(train_x, train_y.log(), k=k).to(train_x.device)
-
-    
-    model = model.to(train_x.device)
-    mll = ExactMarginalLogLikelihood(model.likelihood, model)
-    fit_gpytorch_torch(mll, options={'maxiter':train_iters, 'disp':False})
-
-    if mean_name in ["loglinear", "constant", 'linear']:
-        save_samples = model.posterior(test_x).sample(torch.Size((nsample,
-                                                                ))).squeeze(-1).cpu().detach()
-    else:
-        save_samples = Rollouts(
-            train_x, train_y, test_x, model, nsample=nsample, method = "nonvol"
-        ).cpu().detach()
-
-
-    torch.cuda.empty_cache()
-    del model
-
-
-    return save_samples
\ No newline at end of file
diff --git a/experiments/weather/.ipynb_checkpoints/GPGenerator-checkpoint.py b/experiments/weather/.ipynb_checkpoints/GPGenerator-checkpoint.py
deleted file mode 100644
index 2792ac6..0000000
--- a/experiments/weather/.ipynb_checkpoints/GPGenerator-checkpoint.py
+++ /dev/null
@@ -1,178 +0,0 @@
-import numpy as np
-import torch
-import pandas as pd
-import gpytorch
-import argparse
-import datetime
-import warnings
-import copy
-import os
-from voltron.data import make_ticker_list, GetStockHistory
-import sys
-sys.path.append("../calibration")
-from LSTMUtils import SequenceDataset, LSTM, TrainLSTM, LSTMRollouts, NLL
-from torch.utils.data import DataLoader
-from voltron.train_utils import LearnGPCV, TrainVolModel, TrainVoltMagpieModel, TrainBasicModel 
-from voltron.rollout_utils import Rollouts
-from BasicWind import BasicWindRollouts
-import pickle as pkl
-
-def main(args):
-    
-    stn_names, stn_lonlat, full_data = pkl.load(open("./wind_data.p", 'rb'))
-    
-    use_cuda = False
-    if torch.cuda.is_available():
-        use_cuda = True
-    
-    stn = args.stn_idx
-    ntest = args.forecast_horizon
-    ntrain = args.ntrain
-    n_test_times = args.n_test_times
-    ntime = full_data[0].shape[0]
-    
-    test_idxs = torch.arange(ntrain, ntime-ntest, 
-                         int((ntime-ntest-ntrain)/n_test_times))
-    
-    stn_idxs = list(stn_names.keys())
-    if args.kernel == 'volt':
-        train_x = torch.arange(ntrain-1).float()/365
-    else:
-        train_x = torch.arange(ntrain).float()/365
-    test_x = torch.arange(ntrain, ntrain + ntest).float()/365
-
-    if use_cuda:
-        train_x, test_x = train_x.cuda(), test_x.cuda()
-    
-    savepath = "./saved-outputs/stn" + str(stn) + "/"
-    stn_data = full_data[stn]
-    stn_data[stn_data == -99.0] = 0.
-    if stn_data.mean() != 0:
-        if not os.path.exists(savepath):
-            os.mkdir(savepath)
-
-        for last_day in test_idxs:
-#             try:
-            raw_y = stn_data[last_day-ntrain:last_day] + 1
-            train_y = torch.FloatTensor(raw_y)
-            if use_cuda:
-                train_y = train_y.cuda()
-
-            if args.kernel == 'volt':
-                with gpytorch.settings.max_cholesky_size(2000):
-                    vol = LearnGPCV(train_x, train_y, train_iters=200,
-                                        printing=False)
-                    vmod, vlh = TrainVolModel(train_x, vol, 
-                                              train_iters=500, printing=False)
-
-                if args.mean == 'constant':
-                    voltron, lh = TrainVoltMagpieModel(train_x, train_y[1:], 
-                           vmod, vlh, vol,
-                           printing=False, 
-                           train_iters=200, mean_func="constant")
-                    vmod.eval();
-                    voltron.eval();
-                    voltron.vol_model.eval();
-                    theta = 0.01
-#                         for theta in [0., 0.01, 0.025, 0.05, 0.1]:
-
-                    temp_model = copy.deepcopy(voltron)
-                    with torch.no_grad():
-                        save_samples = Rollouts(train_x, train_y, test_x, temp_model, 
-                                        nsample=args.nsample, theta=theta)
-                    torch.save(save_samples, savepath + args.kernel + "_theta" + str(theta) +\
-                               "_" + str(last_day.item()) + ".pt")
-
-                    del temp_model
-
-                else:
-                    for k in [400]:
-                        voltron, lh = TrainVoltMagpieModel(train_x, train_y[1:], 
-                               vmod, vlh, vol,
-                               printing=False, 
-                               train_iters=0, mean_func="ewma", k=k)
-                        vmod.eval();
-                        voltron.eval();
-                        voltron.vol_model.eval();
-                        for theta in [0.01]:
-                            temp_model = copy.deepcopy(voltron)
-                            with torch.no_grad():
-                                save_samples = Rollouts(train_x, train_y, 
-                                                        test_x, temp_model, 
-                                                nsample=args.nsample, theta=theta)
-                            torch.save(save_samples, savepath + args.kernel + "_ema" + str(k) +\
-                                       "_theta" + str(theta) +\
-                                       "_" + str(last_day.item()) + ".pt")
-                            del temp_model
-                    del voltron, vmod, vol, vlh
-            else:
-                k=200
-                rollouts = BasicWindRollouts(train_x, train_y, test_x,
-                                             train_iters=args.train_epochs,
-                                            kernel_name=args.kernel,
-                                            mean_name=args.mean, k=k,
-                                            nsample=200)
-                
-                torch.save(rollouts, savepath + args.kernel + "_" +\
-                           args.mean + str(k) + "_" + str(last_day.item()) + ".pt")
-
-            print("stn ", stn, " idx ", last_day.item())
-
-            torch.cuda.empty_cache()
-#             except:
-#                 print("### BROKEN stn", stn, " idx", last_day, " ###")
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--stn_idx",
-        type=int,
-        default=0,
-    )
-    parser.add_argument(
-        "--mean",
-        type=str,
-        default='constant',
-    )
-    parser.add_argument(
-        "--n_test_times",
-        type=int,
-        default=10,
-    )
-    parser.add_argument(
-        "--forecast_horizon",
-        type=int,
-        default=100,
-    )
-    parser.add_argument(
-        "--kernel",
-        type=str,
-        default="matern",
-    )
-    parser.add_argument(
-        "--ntrain",
-        type=int,
-        default=400,
-    )
-    parser.add_argument(
-        "--nsample",
-        type=int,
-        default=1000,
-    )
-    parser.add_argument(
-        "--printing",
-        type=bool,
-        default=False
-    )
-    parser.add_argument(
-        "--train_epochs",
-        type=int,
-        default=500,
-    )
-    parser.add_argument(
-        "--save",
-        type=bool,
-        default=False,
-    )
-    args = parser.parse_args()
-
-    main(args)
\ No newline at end of file
diff --git a/experiments/weather/.ipynb_checkpoints/README-checkpoint.md b/experiments/weather/.ipynb_checkpoints/README-checkpoint.md
deleted file mode 100644
index ddec14e..0000000
--- a/experiments/weather/.ipynb_checkpoints/README-checkpoint.md
+++ /dev/null
@@ -1,15 +0,0 @@
-This directory contains the code needed to run Volt+Magpie on wind speed data taken from the [U.S. Climate Reference Network](https://www.ncei.noaa.gov/access/crn/).
-
-
-To source the data first walk through the `make_wind_dataset` notebook.
-
-To generate forecasts for a station then run
-
-```{bash}
-python GPGenerator.py 
-    --kernel={volt, sm, matern} ## kernel choice
-    --stn_idx=0 ## station index in the dataset
-    --mean={ewma, constant} ## mean choice
-    --ntrain=400 ## training window
-    --n_test_times=100 ## number of test time points
-```
\ No newline at end of file
diff --git a/experiments/weather/.ipynb_checkpoints/calib_plotter-checkpoint.ipynb b/experiments/weather/.ipynb_checkpoints/calib_plotter-checkpoint.ipynb
deleted file mode 100644
index 9c61180..0000000
--- a/experiments/weather/.ipynb_checkpoints/calib_plotter-checkpoint.ipynb
+++ /dev/null
@@ -1,486 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "f7c22e90-d490-4588-95c4-5fde46204bcb",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import pickle as pkl\n",
-    "import pandas as pd\n",
-    "import numpy as np\n",
-    "import torch\n",
-    "import matplotlib.pyplot as plt\n",
-    "import seaborn as sns\n",
-    "import os\n",
-    "\n",
-    "sns.set_style('white')\n",
-    "palette = [\"#1b4079\", \"#C6DDF0\", \"#048A81\", \"#B9E28C\", \"#8C2155\", \"#AF7595\", \"#E6480F\", \"#FA9500\"]\n",
-    "sns.set(palette = palette, font_scale=2.0, style=\"white\", rc={\"lines.linewidth\": 4.0})"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "1c672fb1-f4b1-49f8-9343-2fc417cd7072",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "stn_names, stn_lonlat, full_data = pkl.load(open(\"./wind_data.p\", 'rb'))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "93596c44-98fd-4fbc-958f-1110dde120ab",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def ECDF(sample_pxs, true_px):    \n",
-    "    return (torch.sum(sample_pxs < true_px, 0)/sample_pxs.shape[0])\n",
-    " \n",
-    "def Calibration(pcts, percentile=0.95):\n",
-    "    in_band = np.where((pcts < percentile))[0].shape[0]\n",
-    "    return in_band/pcts.shape[0]\n",
-    "\n",
-    "def GetCalibration(model, ema=True, k=100, theta=0.0, horizon=np.arange(75,100), \n",
-    "                   logger=[], exp=True):\n",
-    "    \n",
-    "    ntime = full_data[0].shape[0]\n",
-    "    ntrain = 400\n",
-    "    n_test_times = 20\n",
-    "    ntest = 100\n",
-    "    test_idxs = torch.arange(ntrain, ntime-ntest, \n",
-    "                             int((ntime-ntest-ntrain)/n_test_times))\n",
-    "    \n",
-    "    stns = list(stn_names.keys())\n",
-    "#     pcts = torch.zeros(len(stns), len(test_idxs), horizon.shape[0])    \n",
-    "    pcts = torch.tensor([])\n",
-    "    for stn_save_idx, stn_idx in enumerate(stns):\n",
-    "        for test_save_idx, test_idx in enumerate(test_idxs):\n",
-    "\n",
-    "            fpath = \"./saved-outputs/stn\" + str(stn_idx) + \"/\"\n",
-    "            fname = model + \"_\"\n",
-    "            if model == 'volt':\n",
-    "                if ema:\n",
-    "                    fname += \"ema\" + str(k) + \"_\"\n",
-    "                fname += \"theta\" + str(theta) + \"_\"\n",
-    "                \n",
-    "            fname += str(test_idx.item()) + \".pt\"\n",
-    "            \n",
-    "#             print(fpath + fname)\n",
-    "            if os.path.exists(fpath + fname): \n",
-    "                if model == 'volt':\n",
-    "                    preds = torch.load(fpath + fname)[0]\n",
-    "                elif model == 'matern':\n",
-    "                    preds = torch.load(fpath + fname).cpu()\n",
-    "                else:\n",
-    "                    preds = torch.load(fpath + fname)\n",
-    "                \n",
-    "                preds = preds[:, horizon]\n",
-    "                test_y = torch.tensor(full_data[stn_idx][test_idx:]) + 1\n",
-    "                \n",
-    "#                 return preds, test_y\n",
-    "                if exp:\n",
-    "                    preds = preds.exp()\n",
-    "                pcts = torch.cat((pcts, ECDF(preds, test_y[horizon])))\n",
-    "            \n",
-    "    pcts = pcts.flatten().numpy()\n",
-    "    percentiles = np.linspace(0.05, 0.95, 19)\n",
-    "    for pct in percentiles:\n",
-    "        clb = Calibration(pcts, pct)\n",
-    "        logger.append([clb, np.round(pct, 2), model, theta, ema, k])\n",
-    "        \n",
-    "    return logger"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "id": "cf3f611f-75eb-4081-bb3c-3e6b238e7038",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "logger = []\n",
-    "\n",
-    "logger = GetCalibration('lstm', theta=0.0,\n",
-    "              exp=True, logger=logger)\n",
-    "logger = GetCalibration('matern', theta=0.0,\n",
-    "              exp=True, logger=logger)\n",
-    "logger = GetCalibration('volt', ema=True, k=200, theta=0.025,\n",
-    "              exp=True, logger=logger)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "id": "b8af92c8-4c4a-4275-9686-cdb9ffccc3f5",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "df = pd.DataFrame(logger)\n",
-    "df.columns = ['Calibration', 'Percentile', 'Type', 'theta', 'ema', 'k']"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 21,
-   "id": "4ab50047-962d-41de-ba3a-ed9b1d9c526f",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 1050x600 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "def PlotCalib(df, ax, title):\n",
-    "\n",
-    "    pal = [ palette[0], palette[4], palette[6]]\n",
-    "    sns.lineplot(x='Percentile', y=\"Calibration\", hue='Type', data=df, ax=ax, alpha=0.5,\n",
-    "                palette=pal, legend=True)\n",
-    "    sns.scatterplot(x='Percentile', y=\"Calibration\", hue='Type', data=df, ax=ax, s=120, legend=False, zorder=4,\n",
-    "                   palette=pal)\n",
-    "    x = np.linspace(0.05,0.95)\n",
-    "    y = np.linspace(0, len(percentiles))\n",
-    "    ax.plot(x, x, color=\"gray\", lw=1., ls=\"--\")\n",
-    "    ax.set_title(title)\n",
-    "\n",
-    "\n",
-    "from matplotlib.lines import Line2D\n",
-    "colors = [\"#1b4079\", \"#C6DDF0\", \"#048A81\", \"#B9E28C\", \"#8C2155\", \"#AF7595\", \"#E6480F\", \"#FA9500\"]\n",
-    "fig, ax = plt.subplots(1,1,dpi=150, figsize=(7, 4))\n",
-    "\n",
-    "percentiles = np.linspace(0.05, 0.95, 19)\n",
-    "PlotCalib(df, ax, \"Wind Speed Calibration\")\n",
-    "\n",
-    "\n",
-    "plt.tick_params(labelsize=16)\n",
-    "sns.despine()\n",
-    "\n",
-    "custom_lines = [Line2D([0], [0], color=palette[0], lw=2),\n",
-    "               Line2D([0], [0], color=palette[4], lw=2),\n",
-    "               Line2D([0], [0], color=palette[6], lw=2)]\n",
-    "\n",
-    "\n",
-    "plt.legend(custom_lines, ['LSTM', r\"GP-Matérn\", \"Volt + Magpie\"],\n",
-    "           fontsize=14, frameon=False, bbox_to_anchor=(0.45, 0.6))\n",
-    "# ax.legend(fontsize=14, bbox_to_anchor=(1., 0.75))\n",
-    "# plt.label(\"Percentile\")\n",
-    "plt.savefig(\"./wind_calibration.pdf\", bbox_inches=\"tight\")\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "c8d78872-3d84-4225-8bde-f960c8155247",
-   "metadata": {},
-   "source": [
-    "## Theta Sensitivity"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "cfe39573-cac1-4091-847a-912fec719089",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "logger = []\n",
-    "logger = GetCalibration('volt', theta=0.0,\n",
-    "              exp=True, logger=logger)\n",
-    "logger = GetCalibration('volt', theta=0.01,\n",
-    "              exp=True, logger=logger)\n",
-    "logger = GetCalibration('volt', theta=0.025,\n",
-    "              exp=True, logger=logger)\n",
-    "logger = GetCalibration('volt', theta=0.05,\n",
-    "              exp=True, logger=logger)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "id": "7c2f0a47-a9b1-415f-908b-b1d7357c75c6",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "df = pd.DataFrame(logger)\n",
-    "df.columns = ['Calibration', 'Percentile', 'Type', 'theta', 'ema', 'k']"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "id": "add1176b-16c8-4932-b29c-9c28afe3259c",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 900x600 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "def PlotCalib(df, ax, title):\n",
-    "#     pal = [palette[6], palette[0], palette[4]]\n",
-    "#     sns.lineplot(x='Percentile', y=\"Calibration\", hue='Type', data=df, ax=ax, alpha=0.25,\n",
-    "#                 palette=pal, legend=False)\n",
-    "#     sns.scatterplot(x='Percentile', y=\"Calibration\", hue='Type', data=df, ax=ax, s=120, legend=False, zorder=4,\n",
-    "#                    palette=pal, alpha=0.5)\n",
-    "\n",
-    "\n",
-    "    pal = [palette[6], palette[0], palette[4], palette[7]]\n",
-    "    sns.lineplot(x='Percentile', y=\"Calibration\", hue='theta', data=df, ax=ax, alpha=0.5,\n",
-    "                palette=pal, legend=True)\n",
-    "    sns.scatterplot(x='Percentile', y=\"Calibration\", hue='theta', data=df, ax=ax, s=120, legend=False, zorder=4,\n",
-    "                   palette=pal)\n",
-    "    x = np.linspace(0.05,0.95)\n",
-    "    y = np.linspace(0, len(percentiles))\n",
-    "    ax.plot(x, x, color=\"gray\", lw=1., ls=\"--\")\n",
-    "    ax.set_title(title)\n",
-    "\n",
-    "\n",
-    "from matplotlib.lines import Line2D\n",
-    "colors = [\"#1b4079\", \"#C6DDF0\", \"#048A81\", \"#B9E28C\", \"#8C2155\", \"#AF7595\", \"#E6480F\", \"#FA9500\"]\n",
-    "fig, ax = plt.subplots(1,1,dpi=150, figsize=(6, 4))\n",
-    "\n",
-    "percentiles = np.linspace(0.05, 0.95, 19)\n",
-    "PlotCalib(df, ax, \"Wind Speed Mean Reversion\")\n",
-    "\n",
-    "\n",
-    "plt.tick_params(labelsize=16)\n",
-    "sns.despine()\n",
-    "\n",
-    "custom_lines = [Line2D([0], [0], color=palette[6], lw=2),\n",
-    "                Line2D([0], [0], color=palette[0], lw=2),\n",
-    "                Line2D([0], [0], color=palette[4], lw=2),\n",
-    "               Line2D([0], [0], color=palette[7], lw=2)]\n",
-    "\n",
-    "\n",
-    "legend = plt.legend(custom_lines,['0.0', \"0.01\", \"0.025\", \"0.05\"], \n",
-    "           fontsize=14, frameon=False, bbox_to_anchor=(1., 0.75))\n",
-    "legend.set_title(r'$\\theta$')\n",
-    "# ax.legend(fontsize=14, bbox_to_anchor=(1., 0.75))\n",
-    "# plt.label(\"Percentile\")\n",
-    "plt.savefig(\"./theta_sensitivity.pdf\", bbox_inches=\"tight\")\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "18c85912-e2b3-49ef-b3f2-cc62e7226ecb",
-   "metadata": {},
-   "source": [
-    "## EMA Calibration"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "id": "1e5da442-bbe8-45dc-b13d-b42a7df4e4da",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "logger = []\n",
-    "logger = GetCalibration('volt', ema=True, theta=0.025, k=50,\n",
-    "              exp=True, logger=logger)\n",
-    "logger = GetCalibration('volt', ema=True, theta=0.025, k=100,\n",
-    "              exp=True, logger=logger)\n",
-    "logger = GetCalibration('volt', ema=True, theta=0.025, k=200,\n",
-    "              exp=True, logger=logger)\n",
-    "logger = GetCalibration('volt', ema=True, theta=0.025, k=400,\n",
-    "              exp=True, logger=logger)\n",
-    "logger = GetCalibration('volt', ema=False, theta=0.025, k=400,\n",
-    "              exp=True, logger=logger)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "id": "538dba70-fd2a-4292-86d3-707d045088dd",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "df = pd.DataFrame(logger)\n",
-    "df.columns = ['Calibration', 'Percentile', 'Type', 'theta', 'ema', 'k']"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "id": "5f897d07-6e65-4553-a08a-e9b7dd881b26",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 1050x600 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "def PlotCalib(df, ax, title):\n",
-    "    sub_df = df[(df['ema']==True) & (df['k']!=50)]\n",
-    "    pal = [palette[0], palette[4], palette[6]]\n",
-    "    sns.lineplot(x='Percentile', y=\"Calibration\", hue='k', data=sub_df, ax=ax, alpha=0.5,\n",
-    "                palette=pal, legend=True)\n",
-    "    sns.scatterplot(x='Percentile', y=\"Calibration\", hue='k', data=sub_df, ax=ax, s=120, legend=False, zorder=4,\n",
-    "                   palette=pal)\n",
-    "    x = np.linspace(0.05,0.95)\n",
-    "    y = np.linspace(0, len(percentiles))\n",
-    "    ax.plot(x, x, color=\"gray\", lw=1., ls=\"--\")\n",
-    "    ax.set_title(title)\n",
-    "    \n",
-    "    \n",
-    "    pal = [palette[2]]\n",
-    "    sub_df = df[df['ema']==False]\n",
-    "    sns.lineplot(x='Percentile', y=\"Calibration\", hue='Type', data=sub_df, ax=ax, alpha=0.5,\n",
-    "                palette=pal, legend=True)\n",
-    "    sns.scatterplot(x='Percentile', y=\"Calibration\", hue='Type', data=sub_df, ax=ax, s=120, legend=False, zorder=4,\n",
-    "                   palette=pal)\n",
-    "    x = np.linspace(0.05,0.95)\n",
-    "    y = np.linspace(0, len(percentiles))\n",
-    "    ax.plot(x, x, color=\"gray\", lw=1., ls=\"--\")\n",
-    "    ax.set_title(title)\n",
-    "\n",
-    "\n",
-    "from matplotlib.lines import Line2D\n",
-    "colors = [\"#1b4079\", \"#C6DDF0\", \"#048A81\", \"#B9E28C\", \"#8C2155\", \"#AF7595\", \"#E6480F\", \"#FA9500\"]\n",
-    "fig, ax = plt.subplots(1,1,dpi=150, figsize=(7, 4))\n",
-    "\n",
-    "percentiles = np.linspace(0.05, 0.95, 19)\n",
-    "PlotCalib(df, ax, \"Wind Speed Calibration\")\n",
-    "\n",
-    "\n",
-    "plt.tick_params(labelsize=16)\n",
-    "sns.despine()\n",
-    "\n",
-    "# custom_lines = [Line2D([0], [0], color=palette[0], lw=2),\n",
-    "#                Line2D([0], [0], color=palette[4], lw=2),\n",
-    "#                Line2D([0], [0], color=palette[6], lw=2)]\n",
-    "\n",
-    "\n",
-    "# plt.legend(custom_lines, ['LSTM', r\"GP-Matérn\", \"GP-Volt\"],\n",
-    "#            fontsize=14, frameon=False, bbox_to_anchor=(0.45, 0.6))\n",
-    "# ax.legend(fontsize=14, bbox_to_anchor=(1., 0.75))\n",
-    "# plt.label(\"Percentile\")\n",
-    "# plt.savefig(\"./wind_calibration.pdf\", bbox_inches=\"tight\")\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "a8726416-26b1-4fea-900f-df2b72385619",
-   "metadata": {},
-   "source": [
-    "## NLL"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 35,
-   "id": "894e358a-52d3-4e69-baa2-037669015f77",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def GetNLL(model, ema=True, k=100, theta=0.0, horizon=np.arange(75,100), \n",
-    "                   logger=[], exp=True):\n",
-    "    \n",
-    "    ntime = full_data[0].shape[0]\n",
-    "    ntrain = 400\n",
-    "    n_test_times = 20\n",
-    "    ntest = 100\n",
-    "    test_idxs = torch.arange(ntrain, ntime-ntest, \n",
-    "                             int((ntime-ntest-ntrain)/n_test_times))\n",
-    "    \n",
-    "    stns = list(stn_names.keys())\n",
-    "    nlls = torch.tensor([])\n",
-    "    for stn_save_idx, stn_idx in enumerate(stns):\n",
-    "        for test_save_idx, test_idx in enumerate(test_idxs):\n",
-    "\n",
-    "            fpath = \"./saved-outputs/stn\" + str(stn_idx) + \"/\"\n",
-    "            fname = model + \"_\"\n",
-    "            if model == 'volt':\n",
-    "                if ema:\n",
-    "                    fname += \"ema\" + str(k) + \"_\"\n",
-    "                fname += \"theta\" + str(theta) + \"_\"\n",
-    "                \n",
-    "            fname += str(test_idx.item()) + \".pt\"\n",
-    "            \n",
-    "#             print(fpath + fname)\n",
-    "            if os.path.exists(fpath + fname): \n",
-    "                if model == 'volt':\n",
-    "                    preds = torch.load(fpath + fname)[0]\n",
-    "                elif model == 'matern':\n",
-    "                    preds = torch.load(fpath + fname).cpu()\n",
-    "                else:\n",
-    "                    preds = torch.load(fpath + fname)\n",
-    "                \n",
-    "                preds = preds[:, horizon]\n",
-    "                test_y = torch.tensor(full_data[stn_idx][test_idx:]) + 1\n",
-    "                \n",
-    "#                 return preds, test_y\n",
-    "                if exp:\n",
-    "                    preds = preds.exp()\n",
-    "            \n",
-    "                \n",
-    "                try:\n",
-    "                    curr = torch.distributions.Normal(preds.mean(0), preds.std(0)).log_prob(test_y[horizon])\n",
-    "                    nlls = torch.cat((curr, nlls))\n",
-    "                except:\n",
-    "                    pass\n",
-    "            \n",
-    "\n",
-    "    if nlls.numel() > 0:\n",
-    "        logger.append([-nlls.sum().item(), -nlls.mean().item(), nlls.std().item(), model, mean, k])\n",
-    "        \n",
-    "    return logger"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "1a435a51-c4a0-4931-bb3a-755af4cb1c9f",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "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.8.8"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
diff --git a/experiments/weather/.ipynb_checkpoints/make_wind_dataset-checkpoint.ipynb b/experiments/weather/.ipynb_checkpoints/make_wind_dataset-checkpoint.ipynb
deleted file mode 100644
index 976eff7..0000000
--- a/experiments/weather/.ipynb_checkpoints/make_wind_dataset-checkpoint.ipynb
+++ /dev/null
@@ -1,174 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "21eabbd3-cd2d-48dc-ae08-e4088abf5609",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import numpy as np\n",
-    "import pandas as pd\n",
-    "from bs4 import BeautifulSoup\n",
-    "import requests\n",
-    "import matplotlib.pyplot as plt\n",
-    "import torch"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "e3b55ef7-21f0-4265-a6cc-4ba4fb905024",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "base_url = 'https://www.ncei.noaa.gov/pub/data/uscrn/products/subhourly01/2021/'"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "acce1d74-81f9-490e-88d6-f351cc29f489",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "grab = requests.get(base_url)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "eb774d40-fb46-4c11-80b6-0fadb348a7bd",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "stn_names = {}\n",
-    "stn_lonlat = {}\n",
-    "stn_data = {}\n",
-    "ndata = 105120\n",
-    "stn_id = 0\n",
-    "\n",
-    "soup = BeautifulSoup(grab.text, 'html.parser')\n",
-    "for link in soup.find_all('a'):\n",
-    "    url = link.get('href')\n",
-    "    if url[-4:] == '.txt':\n",
-    "        dat = pd.read_csv(base_url + url,\n",
-    "                          header=None, delim_whitespace=True)\n",
-    "        if dat.shape[0] == ndata:\n",
-    "            stn_names[stn_id] = url[17:-4]\n",
-    "            stn_lonlat[stn_id] = [dat.iloc[0, 6], dat.iloc[0, 7]]\n",
-    "            stn_data[stn_id] = dat.iloc[:, 21].to_numpy()\n",
-    "            stn_id += 1"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "81464613-f48c-4341-9c67-7a35c1740b65",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "full_dat = np.stack( list(stn_data.values()))\n",
-    "lonlat = np.array(list(stn_lonlat.values()))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "82066517-6625-4b6c-ad77-73ed32c9525c",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "full_dat[full_dat == -99.0] = 0."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "29fd2ffd-57c5-4aed-b321-7a9dc3b0b5a4",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.lines.Line2D at 0x7f765db6d250>"
-      ]
-     },
-     "execution_count": 7,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 900x600 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.figure(dpi=150)\n",
-    "plt.scatter(lonlat[:, 0], lonlat[:, 1], c=full_dat.mean(-1))\n",
-    "plt.axvline(-128)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "03d676dd-4cff-4a12-9b1e-3877242b1ecc",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import pickle as pkl"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "e07bed54-2fe3-4c05-a530-4ae1032b1f60",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "dicts = [stn_names, stn_lonlat, stn_data]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "id": "fbd09e88-8c49-4490-a0a7-f26985ae1366",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "pkl.dump(dicts, open(\"./wind_data.p\", \"wb\"))"
-   ]
-  }
- ],
- "metadata": {
-  "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.8.8"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
diff --git a/experiments/weather/.ipynb_checkpoints/mtwind_plotting-checkpoint.ipynb b/experiments/weather/.ipynb_checkpoints/mtwind_plotting-checkpoint.ipynb
deleted file mode 100644
index 1bc2cd3..0000000
--- a/experiments/weather/.ipynb_checkpoints/mtwind_plotting-checkpoint.ipynb
+++ /dev/null
@@ -1,529 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 54,
-   "id": "886427e7",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import torch\n",
-    "import seaborn as sns\n",
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "sns.set_style('white')\n",
-    "palette = [\"#1b4079\", \"#C6DDF0\", \"#048A81\", \"#B9E28C\", \"#8C2155\", \"#AF7595\", \"#E6480F\", \"#FA9500\"]\n",
-    "sns.set(palette = palette, font_scale=1.5, style=\"white\", rc={\"lines.linewidth\": 3.0})"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 55,
-   "id": "f7e159c2",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "mtgp_magpie = torch.load(\"./full_ewma400_theta005_.pt\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 56,
-   "id": "5eab3be8",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "['quantiles',\n",
-       " 'x_paths',\n",
-       " 'v_paths',\n",
-       " 'covar',\n",
-       " 'train_v_list',\n",
-       " 'names_list',\n",
-       " 'pars']"
-      ]
-     },
-     "execution_count": 56,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "list(mtgp_magpie.keys())"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 57,
-   "id": "2b7ca372",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "inds = [3, 10, 30, 50, 70, 90]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 58,
-   "id": "2883a443",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "torch.Size([111, 100, 126])"
-      ]
-     },
-     "execution_count": 58,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "mtgp_magpie[\"x_paths\"][0].shape"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 59,
-   "id": "ed7fd1e4",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "array(['AR_Batesville_8_WNW', 'CA_Merced_23_WSW', 'IL_Champaign_9_SW',\n",
-       "       'ND_Jamestown_38_WSW', 'ON_Egbert_1_W', 'UT_Torrey_7_E'],\n",
-       "      dtype='<U34')"
-      ]
-     },
-     "execution_count": 59,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "mtgp_magpie[\"names_list\"][-10][inds]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 60,
-   "id": "b83b62de",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "paths = mtgp_magpie[\"x_paths\"][0]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 61,
-   "id": "660a5dff",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "path_lmeans = paths.log().mean(1)\n",
-    "path_lstds = paths.log().std(1)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 62,
-   "id": "0db951cc",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "lower = paths.sort(1)[0][inds, 33]\n",
-    "upper = paths.sort(1)[0][inds, 67]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 63,
-   "id": "c5a35f3f",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[<matplotlib.collections.PolyCollection at 0x7f6af859f5e0>,\n",
-       " <matplotlib.collections.PolyCollection at 0x7f6af859f9d0>,\n",
-       " <matplotlib.collections.PolyCollection at 0x7f6af859fd90>,\n",
-       " <matplotlib.collections.PolyCollection at 0x7f6af85ad190>,\n",
-       " <matplotlib.collections.PolyCollection at 0x7f6af85ad550>,\n",
-       " <matplotlib.collections.PolyCollection at 0x7f6af85ad910>]"
-      ]
-     },
-     "execution_count": 63,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "[plt.fill_between(torch.arange(126), lower[i], upper[i], alpha = 0.3) for i in range(6)]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 64,
-   "id": "26db9a7c",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 1152x360 with 6 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "fig, ax = plt.subplots(3, 2, figsize = (16, 5))\n",
-    "ax = ax.reshape(-1)\n",
-    "\n",
-    "for i in range(6):\n",
-    "    ax[i].plot(paths[inds[i]].t(), alpha = 0.1, color = \"grey\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 65,
-   "id": "25e263c5",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "ntrain = 252\n",
-    "ntest = 126\n",
-    "neval = 25"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 66,
-   "id": "3bfde56e",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[[0, 252], [4194, 4446], [8388, 8640], [12582, 12834], [16776, 17028], [20970, 21222], [25164, 25416], [29358, 29610], [33552, 33804], [37746, 37998], [41940, 42192], [46134, 46386], [50328, 50580], [54522, 54774], [58716, 58968], [62910, 63162], [67104, 67356], [71298, 71550], [75492, 75744], [79686, 79938], [83880, 84132], [88074, 88326], [92268, 92520], [96462, 96714], [100656, 100908], [104850, 105102]] [378, 4572, 8766, 12960, 17154, 21348, 25542, 29736, 33930, 38124, 42318, 46512, 50706, 54900, 59094, 63288, 67482, 71676, 75870, 80064, 84258, 88452, 92646, 96840, 101034, 105119]\n"
-     ]
-    }
-   ],
-   "source": [
-    "    import pickle as pkl\n",
-    "    import numpy as np\n",
-    "    \n",
-    "    stn_names, stn_lonlat, stn_data = pkl.load(open(\"./wind_data.p\", 'rb'))\n",
-    "    lonlat = np.array(list(stn_lonlat.values()))\n",
-    "    full_dat = np.stack(list(stn_data.values()), -1).T\n",
-    "    full_dat[full_dat == -99.0] = 0.\n",
-    "    names = np.array(list(stn_names.values()))\n",
-    "\n",
-    "    conus_idx = np.where(lonlat[:, 0] > -128)[0]\n",
-    "    lonlat = lonlat[conus_idx]\n",
-    "    full_dat = full_dat[conus_idx]\n",
-    "    names = names[conus_idx]\n",
-    "\n",
-    "    full_data = torch.tensor(full_dat).float() + 1 # wind speeds can be zero.\n",
-    "    ndata = full_data.shape[-1]\n",
-    "    full_returns = torch.log(full_data[..., 1:] / full_data[..., :-1])\n",
-    "\n",
-    "    T = 52\n",
-    "    ts = torch.linspace(0, T, ndata) + 1\n",
-    "\n",
-    "    device = torch.device(\"cpu\")\n",
-    "\n",
-    "    # train on one full year worht of data and test on 6 mos for defaults\n",
-    "    # we can do logner\n",
-    "    split_diff = int((ndata - ntrain) / neval)\n",
-    "    train_starts = list(range(0, ndata - ntrain, split_diff))\n",
-    "    train_splits = [[x, x + ntrain] for x in train_starts]\n",
-    "    if train_splits[-1][-1] > (ndata-1):\n",
-    "        train_splits.pop(-1)\n",
-    "    eval_splits = [min(ndata-1, x + ntest + ntrain) for x in train_starts]\n",
-    "    print(train_splits, eval_splits)\n",
-    "\n",
-    "    ts = ts.to(device)\n",
-    "    full_returns = full_returns.to(device)\n",
-    "    full_data = full_data.to(device)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 67,
-   "id": "7db3e048",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "i = 0"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 68,
-   "id": "6db14348",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[  4   5  14  19  20  21  22  23  24  25  26  27  28  29  30  31  32  33\n",
-      "  34  35  36  37  38  39  40  41  42  43  44  45  46  47  49  50  51  52\n",
-      "  53  54  55  56  57  58  59  60  61  63  64  65  67  68  69  70  71  72\n",
-      "  73  74  75  76  77  78  79  80  81  82  83  84  85  86  87  88  89  90\n",
-      "  91  92  93  94  95  96  97  98  99 100 101 102 103 104 105 106 107 108\n",
-      " 109 110 111 112 113 114 115 116 117 118 119 120 121 122 124 125 126 127\n",
-      " 128 129 130]\n"
-     ]
-    }
-   ],
-   "source": [
-    "train_start, train_end = train_splits[i][0], train_splits[i][1]\n",
-    "test_end = eval_splits[i]\n",
-    "\n",
-    "# filter out any tses w/ only missing data\n",
-    "keep_idx = np.where((full_data[:, train_start:train_end]-1).mean(-1).cpu() > 0.)[0]\n",
-    "print(keep_idx)\n",
-    "clonlat = lonlat[keep_idx]\n",
-    "full_data = full_data[keep_idx]\n",
-    "names = names[keep_idx]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 69,
-   "id": "aad7f0ea",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[67104, 67356]"
-      ]
-     },
-     "execution_count": 69,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "train_splits[-10]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 70,
-   "id": "2c648c98",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "train_y = full_data[:, train_splits[-10][0]:train_splits[-10][1]]\n",
-    "test_y = full_data[:, train_splits[-10][1]:eval_splits[-10]]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 71,
-   "id": "ae77ba82",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "train_x = ts[train_splits[0][0]:train_splits[0][1]]\n",
-    "test_x = ts[train_splits[0][1]:eval_splits[0]]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 72,
-   "id": "43998749",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 1152x360 with 6 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "fig, ax = plt.subplots(3, 2, figsize = (16, 5))\n",
-    "ax = ax.reshape(-1)\n",
-    "\n",
-    "for i in range(6):\n",
-    "    ax[i].plot(test_x, paths[inds[i]].t(), alpha = 0.1, color = \"grey\")\n",
-    "    ax[i].plot(train_x, train_y[inds[i]], color = \"blue\", linewidth =4)\n",
-    "    ax[i].plot(test_x, test_y[inds[i]], color = \"orange\", linewidth=4)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 73,
-   "id": "d5f2d96e",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "50"
-      ]
-     },
-     "execution_count": 73,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "inds[3]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 74,
-   "id": "7eff5601",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "70"
-      ]
-     },
-     "execution_count": 74,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "inds[4]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 83,
-   "id": "126730ba",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "train_x = torch.arange(0, 252*5, 5)\n",
-    "test_x = torch.arange(252 * 5, 252 * 5 + 126 * 5, 5)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 93,
-   "id": "4c6b96f4",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 576x432 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "fig, ax = plt.subplots(2, 1, figsize = (8, 6))\n",
-    "ax[0].plot(train_x, train_y[inds[3]],linewidth=2, label = \"Observed Wind\")\n",
-    "ax[1].plot(train_x, train_y[inds[5]],linewidth=2)\n",
-    "\n",
-    "ax[0].plot(test_x, paths[inds[3]][5:10].t(), color = palette[7], alpha = 0.5, \n",
-    "           label = [None, None, None, None, \"Volt Samples\"])\n",
-    "ax[1].plot(test_x, paths[inds[5]][5:10].t(), color = palette[7], alpha = 0.5)\n",
-    "\n",
-    "ax[0].plot(test_x, test_y[inds[3]], color = palette[2], linewidth=2, label = \"Truth\")\n",
-    "ax[1].plot(test_x, test_y[inds[5]], color = palette[2], linewidth=2)\n",
-    "\n",
-    "ax[0].set_title(\"St. Mary, MT\")\n",
-    "ax[1].set_title(\"Sioux Falls, SD\")\n",
-    "\n",
-    "ax[0].legend(frameon=False)\n",
-    "ax[0].set_xlabel(\"Minutes\")\n",
-    "ax[1].set_xlabel(\"Minutes\")\n",
-    "ax[0].set_ylabel(\"Wind Speed (m/s)\")\n",
-    "ax[1].set_ylabel(\"Wind Speed (m/s)\")\n",
-    "plt.tight_layout()\n",
-    "sns.despine()\n",
-    "plt.savefig(\"mt_wind_modelling.pdf\", bbox_inches=\"tight\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 104,
-   "id": "9778360a",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 576x360 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "fig, ax = plt.subplots(figsize = (8, 5))\n",
-    "f = plt.scatter(*lonlat[keep_idx].T, c=mtgp_magpie[\"covar\"][0][15].log())\n",
-    "plt.colorbar(f, label = \"Log Covariance\")\n",
-    "plt.savefig(\"mt_wind_usa.pdf\", bbox_inches = \"tight\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "25bf1a12",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "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.5"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
diff --git a/voltron/.env b/voltron/.env
deleted file mode 100644
index 4fbca55..0000000
--- a/voltron/.env
+++ /dev/null
@@ -1,2 +0,0 @@
-robinhood_username="greg.w.benton@gmail.com"
-robinhood_password="Tho561mas!"
\ No newline at end of file
diff --git a/voltron/.ipynb_checkpoints/__init__-checkpoint.py b/voltron/.ipynb_checkpoints/__init__-checkpoint.py
deleted file mode 100644
index 81321ba..0000000
--- a/voltron/.ipynb_checkpoints/__init__-checkpoint.py
+++ /dev/null
@@ -1,12 +0,0 @@
-__version__ = 'alpha'
-from .kernels import BMKernel, VolatilityKernel
-from .models import BMGP, MultitaskBMGP
-from .train_utils import LearnGPCV
-from .option_utils import *
-try:
-    from .robinhood_utils import GetStockData
-except:
-    print("Warning no robinhood utils.")
-    
-from .rollout_utils import Rollouts, GeneratePrediction
-    
diff --git a/voltron/.ipynb_checkpoints/option_utils-checkpoint.py b/voltron/.ipynb_checkpoints/option_utils-checkpoint.py
deleted file mode 100644
index e851c6e..0000000
--- a/voltron/.ipynb_checkpoints/option_utils-checkpoint.py
+++ /dev/null
@@ -1,41 +0,0 @@
-import numpy as np
-import torch
-import pandas as pd
-
-
-def GetTrainingData(SPY, date, N):
-    idx = SPY[SPY["Date"] == date].index.item()
-    return SPY['Close'].iloc[(idx-N):idx]
-
-def GetTrueValue(SPY, date, strike):
-    close_px = SPY['Close'][SPY["Date"] == date].item()
-    return np.maximum(close_px-strike, 0)
-
-def GetTradingDays(SPY, start, stop):
-    start_idx = SPY[SPY["Date"] == start].index.item()
-    stop_idx = SPY[SPY["Date"] == stop].index.item()
-    return stop_idx-start_idx
-
-def FindLastTradingDays(SPY, dates):
-    last_days = []
-    for date in dates:
-        last_days.append(np.max(np.where(SPY.Date < date)[0]))
-        
-    return np.array(SPY.Date[last_days])
-
-def Pricer(mc_pxs, options, edays, true_pxs):
-    logger = []
-    for eday_idx, eday in enumerate(edays):
-        eday = pd.Timestamp(eday)
-        opts = options[options.expiration==pd.Timestamp(eday)]
-        for idx, row in opts.iterrows():
-            K = row.strike
-            bid = row.bid
-            ask = row.ask
-            valuation = np.mean(np.maximum(mc_pxs[:, eday_idx].numpy() - K, 0))
-            rtn = np.maximum(true_pxs[eday_idx] - K, 0)
-            logger.append([eday, K, bid, ask, valuation, rtn.item()])
-            
-    df = pd.DataFrame(logger)
-    df.columns = ['Expiry', "Strike", "Bid", "Ask", "Voltron", "Return"]
-    return df
\ No newline at end of file
diff --git a/voltron/.ipynb_checkpoints/robinhood_utils-checkpoint.py b/voltron/.ipynb_checkpoints/robinhood_utils-checkpoint.py
deleted file mode 100644
index 5380222..0000000
--- a/voltron/.ipynb_checkpoints/robinhood_utils-checkpoint.py
+++ /dev/null
@@ -1,22 +0,0 @@
-import robin_stocks.robinhood as r
-import os
-import pandas as pd
-from dotenv import load_dotenv
-
-def GetStockData(symbols, interval='day', span='5year'):
-    """
-    just a wrapper for robin-stocks calls
-    """
-    load_dotenv()
-    username = os.getenv("robinhood_username")
-    password = os.getenv("robinhood_password")
-    r.login(username, password);
-    
-    data = pd.DataFrame(r.stocks.get_stock_historicals(symbols, interval, span))
-    data['date'] = pd.to_datetime(data['begins_at'], format='%Y-%m-%d').dt.date
-    
-    ohlc = ['open_price', 'close_price', 'high_price', 'low_price']
-    data[ohlc] = data[ohlc].astype("float")
-    
-    return data[['date', 'symbol', 'open_price', 'close_price', 
-                'high_price', 'low_price']]
\ No newline at end of file
diff --git a/voltron/.ipynb_checkpoints/rollout_utils-checkpoint.py b/voltron/.ipynb_checkpoints/rollout_utils-checkpoint.py
deleted file mode 100644
index 80056c8..0000000
--- a/voltron/.ipynb_checkpoints/rollout_utils-checkpoint.py
+++ /dev/null
@@ -1,115 +0,0 @@
-import torch
-import gpytorch
-from gpytorch.utils.cholesky import psd_safe_cholesky
-from gpytorch.utils.cholesky import psd_safe_cholesky
-
-def GeneratePrediction(train_x, train_y, test_x, pred_vol, model, latent_mean=None, theta=0.5):
-    vol = model.log_vol_path.exp()
-    if train_x.ndim != test_x.ndim:
-        test_x_for_stack = test_x.unsqueeze(0).repeat(train_x.shape[0], 1)
-    else:
-        test_x_for_stack = test_x
-    if vol.ndim == 1:
-        vol_for_stack = vol.unsqueeze(0).repeat(pred_vol.shape[0], 1)
-    else:
-        vol_for_stack = vol
-
-    full_x = torch.cat((train_x, test_x_for_stack),dim=-1)
-    # print("vol stack = ", vol_for_stack.shape)
-    # print("pred_vol = ", pred_vol.shape)
-    full_vol = torch.cat((vol_for_stack, pred_vol),dim=-1)
-
-    test_x.repeat(2, test_x.numel())
-
-    idx_cut = train_x.shape[-1]
-    
-    cov_mat = model.covar_module(full_x.unsqueeze(-1), full_vol.unsqueeze(-1)).evaluate()
-    K_tr = cov_mat[..., :idx_cut, :idx_cut]
-    K_tr_te = cov_mat[..., :idx_cut, idx_cut:]
-    K_te = cov_mat[..., idx_cut:, idx_cut:]
-
-    train_mean = model.mean_module(train_x)
-    train_diffs = train_y.unsqueeze(-1) - train_mean.unsqueeze(-1)
-    # use psd cholesky if you must evaluate
-    K_tr_chol = psd_safe_cholesky(K_tr, jitter=1e-4)
-    pred_mean = K_tr_te.transpose(-1, -2).matmul(torch.cholesky_solve(train_diffs, K_tr_chol))
-    # print(voltron.mean_module(test_x).detach().T.shape)
-    # print(pred_mean.shape)
-    pred_mean += model.mean_module(test_x).detach().T.unsqueeze(-1)
-    
-    if latent_mean is not None:
-        pred_mean -= theta * (pred_mean - latent_mean)
-
-    pred_cov = K_te - K_tr_te.transpose(-1, -2).matmul(torch.cholesky_solve(K_tr_te, K_tr_chol))
-
-    pred_cov_L = psd_safe_cholesky(pred_cov, jitter=1e-4)
-    samples = torch.randn(*cov_mat.shape[:-2], test_x.shape[0], 1).to(test_x.device)
-    samples = pred_cov_L @ samples
-
-    if pred_mean.ndim == 1:
-        return samples + pred_mean.unsqueeze(-1)
-    else:
-        return (samples + pred_mean).squeeze(-1)
-    
-
-
-def Rollouts(train_x, train_y, test_x, model, nsample=50, method = "volt", theta=None,
-            return_vol=False):
-    if method != "volt":
-        return nonvol_rollouts(train_x, train_y, test_x, model, nsample=nsample)
-    if theta is None:
-        latent_mean = None
-    else:
-        latent_mean = train_y.log().mean()
-    ntest = test_x.numel()
-    samples = torch.zeros(nsample, ntest)
-    pred_vol = model.vol_model(test_x).sample(torch.Size((nsample, ))).exp()
-    samples[:, 0] = GeneratePrediction(train_x, train_y, 
-                                       test_x[0].unsqueeze(0), 
-                                       pred_vol[:, 0].unsqueeze(1),
-                                      model, latent_mean, theta).squeeze()
-    train_stack_y = train_y.repeat(nsample, 1)
-    train_stack_vol = model.log_vol_path.repeat(nsample, 1)
-    
-    for idx in range(1, ntest):
-        stack_y = torch.cat((train_stack_y, 
-                             samples[:, :idx].to(train_stack_y.device)), -1)
-        stack_vol = torch.cat((train_stack_vol, 
-                               pred_vol[:, :idx].to(train_stack_vol.device).log()), -1)
-
-        rolling_x = torch.cat((train_x, test_x[:idx]))
-        model.mean_module.train_y = stack_y
-        model.mean_module.train_x = rolling_x
-        
-#         train_x = rolling_x
-#         train_y = stack_y
-        model.log_vol_path = stack_vol
-        samples[:, idx] = GeneratePrediction(rolling_x, stack_y, 
-                                             test_x[idx].unsqueeze(0), 
-                                           pred_vol[:, idx].unsqueeze(-1),
-                                            model, latent_mean, theta).squeeze()
-    if return_vol:
-        return samples, pred_vol
-    else:
-        return samples
-
-def nonvol_rollouts(train_x, train_y, test_x, model, nsample=50):
-    ntest = test_x.numel()
-    samples = torch.zeros(nsample, ntest)
-    samples[:, 0] = model.posterior(test_x[0].unsqueeze(0)).sample(torch.Size((nsample,))).squeeze().squeeze()
-    train_stack_y = train_y.repeat(nsample, 1)
-    
-    for idx in range(1, ntest):
-        stack_y = torch.cat((train_stack_y, 
-                             samples[:, :idx].to(train_stack_y.device)), -1)
-        rolling_x = torch.cat((train_x, test_x[:idx]))
-
-        model.mean_module.train_y = stack_y
-        model.mean_module.train_x = rolling_x
-        
-        model.train_inputs = (rolling_x.view(-1,1),)
-        model.train_targets = stack_y
-        model.train() # clear any caches that might have built up
-        test_pt = test_x[idx].view(-1,1)
-        samples[:, idx] = model.posterior(test_pt).sample().squeeze()
-    return samples
\ No newline at end of file
diff --git a/voltron/.ipynb_checkpoints/train_utils-checkpoint.py b/voltron/.ipynb_checkpoints/train_utils-checkpoint.py
deleted file mode 100644
index cc2ba51..0000000
--- a/voltron/.ipynb_checkpoints/train_utils-checkpoint.py
+++ /dev/null
@@ -1,94 +0,0 @@
-import numpy as np
-import torch
-import gpytorch
-import sys
-
-sys.path.append("../")
-from voltron.likelihoods import VolatilityGaussianLikelihood
-from voltron.models import SingleTaskVariationalGP
-from voltron.kernels import BMKernel, VolatilityKernel, FBMKernel
-from voltron.models import BMGP, BasicGP, Volt
-from voltron.means import LogLinearMean, EWMAMean, DEWMAMean, TEWMAMean, MeanRevertingEMAMean
-from gpytorch.kernels import ScaleKernel, RBFKernel, MaternKernel
-
-
-def LearnGPCV(train_x, train_y, train_iters=1000, printing=False, early_stopping=False, kernel = "bm"):
-    dt = train_x[1]-train_x[0]
-    scaled_returns = (train_y[1:] - train_y[:-1]) / (train_y[:-1]) / (dt**0.5)
-    yy = scaled_returns
-    
-    likelihood = VolatilityGaussianLikelihood(param="exp")
-    # likelihood.raw_a.data -= 4.
-    if kernel == "bm":
-        covar_module = BMKernel()
-    elif kernel == "fbm":
-        covar_module = FBMKernel()
-    model = SingleTaskVariationalGP(
-        init_points=train_x.view(-1,1), likelihood=likelihood, use_piv_chol_init=False,
-        mean_module = gpytorch.means.ConstantMean(), covar_module=covar_module, 
-        learn_inducing_locations=False, use_whitened_var_strat=False
-    )
-    model.initialize_variational_parameters(likelihood, train_x, y=yy)
-    
-    model.train()
-    likelihood.train()
-
-    # Use the adam optimizer
-    optimizer = torch.optim.Adam([
-        {"params": model.parameters()}, 
-        # {"params": likelihood.parameters(), "lr": 0.1}
-    ], lr=0.01)
-
-    # "Loss" for GPs - the marginal log likelihood
-    # num_data refers to the number of training datapoints
-    mll = gpytorch.mlls.VariationalELBO(likelihood, model, yy.numel(), combine_terms = True)
-    
-    print_every = 50
-    for i in range(train_iters):
-        # Zero backpropped gradients from previous iteration
-        optimizer.zero_grad()
-        # Get predictive output
-        with gpytorch.settings.num_gauss_hermite_locs(75):
-            output = model(train_x)
-            # Calc loss and backprop gradients
-            loss = -mll(output, yy)
-            loss.backward()
-            
-            if printing:
-                if i % print_every == 0:
-                    print('Iter %d/%d - Loss: %.3f' % (i + 1, train_iters, loss.item()))
-            optimizer.step()
-    model.eval();
-    likelihood.eval();
-    predictive = model(train_x)
-    pred_scale = likelihood(predictive, return_gaussian=False).scale.mean(0).detach()
-    
-    return pred_scale
-
-def TrainVolModel(train_x, vol_path, train_iters=1000, printing=False, kernel = "bm"):
-    vol_lh = gpytorch.likelihoods.GaussianLikelihood().to(train_x.device)
-    vol_lh.noise.data = torch.tensor([1e-2])
-    vol_model = BMGP(train_x, vol_path.log(), vol_lh, kernel=kernel).to(train_x.device)
-#     vol_model.covar_module.raw_vol.data = torch.tensor([-3.])
-
-    optimizer = torch.optim.Adam([
-        {'params': vol_model.parameters()},  # Includes GaussianLikelihood parameters
-    ], lr=0.01)
-
-    # "Loss" for GPs - the marginal log likelihood
-    mll = gpytorch.mlls.ExactMarginalLogLikelihood(vol_lh, vol_model)
-    
-    print_every = 50
-    for i in range(train_iters):
-        # Zero gradients from previous iteration
-        optimizer.zero_grad()
-        # Output from model
-        output = vol_model(train_x)
-        # Calc loss and backprop gradients
-        loss = -mll(output, vol_path.log())
-        loss.backward()
-        if printing:
-            if i % print_every == 0:
-                print('Iter %d/%d - Loss: %.3f' % (i + 1, train_iters, loss.item()))
-        optimizer.step()
-    return vol_model, vol_lh
\ No newline at end of file
diff --git a/voltron/data/.ipynb_checkpoints/MakeData-checkpoint.py b/voltron/data/.ipynb_checkpoints/MakeData-checkpoint.py
deleted file mode 100644
index c9e0d2d..0000000
--- a/voltron/data/.ipynb_checkpoints/MakeData-checkpoint.py
+++ /dev/null
@@ -1,41 +0,0 @@
-import pandas as pd
-import yfinance as yf
-import datetime
-
-
-def make_ticker_list(file_name):
-    tickers = open(file_name, 'r')
-    tickers = [i.strip() for i in list(tickers)]
-    return tickers
-
-def make_price_files(tickers, start, end, fpath, printing):
-    for i in tickers:
-        history = yf.download(tickers=i, 
-                              start=start, 
-                              end=end, 
-                              progress=False,
-                             )
-        history.to_csv(fpath + str(i) + '.csv')
-        if printing:
-            print(str(i))
-        
-
-def DataGetter(history = 500, fpath="../data/", printing=False, end_date=None,
-               ticker_file="test_tickers.txt"):
-    if end_date is None:
-        end_date = datetime.date.today()
-    else:
-        end_date = datetime.datetime.strptime(end_date, "%Y-%m-%d").date()
-        
-    start_date = end_date - datetime.timedelta(history)
-    end_date = str(end_date)
-
-    tickers = make_ticker_list(fpath + ticker_file)
-    make_price_files(tickers, start_date, end_date, fpath, printing)
-    
-def GetStockHistory(ticker, end_date=str(datetime.date.today()), history=500):
-    end_date = datetime.datetime.strptime(end_date, "%Y-%m-%d").date()
-    start_date = end_date - datetime.timedelta(history)
-    return yf.download(tickers=ticker, start=start_date, end=end_date, progress=False)
-    
-    
diff --git a/voltron/data/.ipynb_checkpoints/__init__-checkpoint.py b/voltron/data/.ipynb_checkpoints/__init__-checkpoint.py
deleted file mode 100644
index eaa11af..0000000
--- a/voltron/data/.ipynb_checkpoints/__init__-checkpoint.py
+++ /dev/null
@@ -1 +0,0 @@
-from .MakeData import make_ticker_list, make_price_files, DataGetter, GetStockHistory
\ No newline at end of file
diff --git a/voltron/data/.ipynb_checkpoints/test_tickers-checkpoint.txt b/voltron/data/.ipynb_checkpoints/test_tickers-checkpoint.txt
deleted file mode 100644
index 1b5ce98..0000000
--- a/voltron/data/.ipynb_checkpoints/test_tickers-checkpoint.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-ADBE
-GOOG
-AMZN
-AMAT
-BRK-B
-DAL
-MCD
-NFLX
-PENN
-ZBRA
\ No newline at end of file
diff --git a/voltron/kernels/.ipynb_checkpoints/BMKernel-checkpoint.py b/voltron/kernels/.ipynb_checkpoints/BMKernel-checkpoint.py
deleted file mode 100644
index d4fbbff..0000000
--- a/voltron/kernels/.ipynb_checkpoints/BMKernel-checkpoint.py
+++ /dev/null
@@ -1,16 +0,0 @@
-import torch
-from torch.nn.functional import softplus
-from gpytorch.kernels import Kernel
-
-class BMKernel(Kernel):
-    def __init__(self, vol=0., **kwargs):
-        super(BMKernel, self).__init__(**kwargs)
-        self.register_parameter(name='raw_vol', 
-                                parameter=torch.nn.Parameter(vol*torch.ones(1)))
-    
-    def forward(self, x1s, x2s, **kwargs):        
-        
-        X1, X2 = torch.meshgrid(x1s[:, 0], x2s[:, 0])
-#         return self.raw_vol.exp() * torch.minimum(X1,X2)
-        cov = self.raw_vol.exp() * torch.minimum(X1,X2)
-        return cov
\ No newline at end of file
diff --git a/voltron/kernels/.ipynb_checkpoints/VolKernel-checkpoint.py b/voltron/kernels/.ipynb_checkpoints/VolKernel-checkpoint.py
deleted file mode 100644
index 3155b95..0000000
--- a/voltron/kernels/.ipynb_checkpoints/VolKernel-checkpoint.py
+++ /dev/null
@@ -1,37 +0,0 @@
-import torch
-from gpytorch.kernels import Kernel
-
-def CumTrapz(y, x):
-    dx = x[1] - x[0]
-    wghts = dx * torch.ones_like(x)
-    wghts[0] *= 0.5
-    wghts[-1] *= 0.5
-    return torch.cumsum(wghts * y, 0)
-
-class VolatilityKernel(Kernel):
-    has_lengthscale = False
-    
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-        
-    def forward(self, x, vol_path, diag=False, **params):    
-        
-        last_dim_is_batch = params.get("last_dim_is_batch", False)
-        if not last_dim_is_batch:
-            vol_int = CumTrapz(vol_path.squeeze()**2, x.squeeze())
-        else:
-            x = x.unsqueeze(-1).repeat(x, vol_path.shape[-1])
-            vol_int = CumTrapz(vol_path.pow(2.0), x)
-        
-        idx = torch.arange(x.shape[0])
-        idx1, idx2 = torch.meshgrid(idx, idx)
-        idx = torch.minimum(idx1, idx2)
-        res = vol_int[idx]
-            
-        if vol_path.shape[-1] > 1:
-            res = res.permute(2, 0, 1)
-            
-        if diag:
-            return torch.diagonal(res, dim1=-2, dim2=-1)
-        else:
-            return res
\ No newline at end of file
diff --git a/voltron/kernels/.ipynb_checkpoints/__init__-checkpoint.py b/voltron/kernels/.ipynb_checkpoints/__init__-checkpoint.py
deleted file mode 100644
index 2b08b29..0000000
--- a/voltron/kernels/.ipynb_checkpoints/__init__-checkpoint.py
+++ /dev/null
@@ -1,2 +0,0 @@
-from .BMKernel import BMKernel
-from .VolKernel import VolatilityKernel
\ No newline at end of file
diff --git a/voltron/likelihoods/.ipynb_checkpoints/__init__-checkpoint.py b/voltron/likelihoods/.ipynb_checkpoints/__init__-checkpoint.py
deleted file mode 100644
index 7cae10d..0000000
--- a/voltron/likelihoods/.ipynb_checkpoints/__init__-checkpoint.py
+++ /dev/null
@@ -1 +0,0 @@
-from .volatility_likelihood import VolatilityGaussianLikelihood
diff --git a/voltron/likelihoods/.ipynb_checkpoints/volatility_likelihood-checkpoint.py b/voltron/likelihoods/.ipynb_checkpoints/volatility_likelihood-checkpoint.py
deleted file mode 100644
index fb3d67c..0000000
--- a/voltron/likelihoods/.ipynb_checkpoints/volatility_likelihood-checkpoint.py
+++ /dev/null
@@ -1,61 +0,0 @@
-import torch
-
-from torch.distributions import Normal
-from gpytorch.constraints import Positive, Interval
-from gpytorch.likelihoods import Likelihood, _OneDimensionalLikelihood
-
-
-class VolatilityGaussianLikelihood(_OneDimensionalLikelihood):
-    def __init__(self, K=5, batch_shape=torch.Size(), param="cv", *args, **kwargs):
-        """
-        parameterization of gaussian likelihood for volatility models like in 
-        wilson & ghahramani, copula processes, eq. 21.
-
-        we also consider the gp-exp parameterization
-        """
-
-        super().__init__()
-        if param == "cv":
-            self.raw_a = torch.nn.Parameter(torch.rand(*batch_shape, K, requires_grad=True))
-            raw_b_init = 0.1 * torch.rand(*batch_shape, K)
-            self.raw_b = torch.nn.Parameter(raw_b_init.detach_().requires_grad_())
-            self.raw_c = torch.nn.Parameter(torch.rand(*batch_shape, K, requires_grad=True))
-
-            self.register_constraint("raw_a", Positive())
-            self.register_constraint("raw_b", Interval(0.0, 3.0))
-            self.register_constraint("raw_c", Interval(-3.0, 3.0))
-#         elif param == "exp":
-#             print("Using gp-exp parameterization.")
-        self.param = param
-
-    @property
-    def trans_a(self):
-        return self.raw_a_constraint.transform(self.raw_a)
-
-    @property
-    def trans_b(self):
-        return self.raw_b_constraint.transform(self.raw_b)
-
-    @property
-    def trans_c(self):
-        return self.raw_c_constraint.transform(self.raw_c)
-
-    def forward(self, function_samples, *args, **kwargs):
-        if self.param == "cv":
-            transform = (
-                (self.trans_b * function_samples.unsqueeze(-1) + self.trans_c).exp() + 1
-            ).log() * self.trans_a
-            summed_transform = transform.sum(-1)
-        else:
-            summed_transform = function_samples.exp()
-        return Normal(torch.zeros_like(summed_transform), summed_transform.clamp(min=1e-3))
-
-    def expected_log_prob(self, target, input, *params, **kwargs):
-        res = super().expected_log_prob(target, input, *params, **kwargs)
-        num_event_dim = len(input.event_shape)
-        if num_event_dim > 1:
-            res = res.sum(-1)
-        return res
-
-
-# TODO: use a multitask Gaussian likelihood somehow in the multitask setting
diff --git a/voltron/means/.ipynb_checkpoints/EWMA-checkpoint.py b/voltron/means/.ipynb_checkpoints/EWMA-checkpoint.py
deleted file mode 100644
index d116ea2..0000000
--- a/voltron/means/.ipynb_checkpoints/EWMA-checkpoint.py
+++ /dev/null
@@ -1,113 +0,0 @@
-import torch
-import gpytorch
-from gpytorch.means import Mean
-import numpy as np
-
-def _EWMA(y, k):
-    alpha = 2./(k + 1)
-    conv = torch.nn.Conv1d(1, 1, kernel_size=k)
-    wghts = alpha * (1-alpha)**(torch.arange(k-1, -1, -1))
-    conv.weight.data = wghts.unsqueeze(0).unsqueeze(0)/wghts.sum()
-    conv.bias.data = torch.zeros(1)
-
-    padded_px = torch.cat((y.squeeze()[0] * torch.ones(k),
-                           y.squeeze()))
-    padded_px = padded_px.reshape(1, 1, -1)
-    with torch.no_grad():
-        ma = conv(padded_px).squeeze()
-    return ma.type(torch.FloatTensor)
-
-def EWMA(y, k):
-    alpha = 2./(k + 1)
-    conv = torch.nn.Conv1d(1, 1, kernel_size=k)
-    wghts = alpha * (1-alpha)**(torch.arange(k-1, -1, -1))
-    conv.weight.data = wghts.unsqueeze(0).unsqueeze(0)/wghts.sum()
-    conv.bias.data = torch.zeros(1)    
-
-    conv = conv.to(y.device)
-    res = y[..., 0].unsqueeze(-1) * torch.ones(*y.shape[:-1], k).to(y.device)
-    padded_px = torch.cat((res, y), dim=-1)
-    batch_dim = y.shape[-2] if y.ndim > 1 else 1
-    padded_px = padded_px.reshape(batch_dim, 1, -1)
-    # print("padded_px shape = ", padded_px.shape)
-    with torch.no_grad():
-        ma = conv(padded_px).squeeze()
-        
-    # print("ma shape = ", ma.shape)
-    return ma.type(torch.FloatTensor)
-
-class EWMAMean(Mean):
-    def __init__(self, train_x, train_y, k=20):
-        super().__init__()
-        self.k = k
-        self.train_x = train_x
-        self.train_y = train_y
-        
-    def forward(self, x):
-        ewma = EWMA(self.train_y, self.k)
-        if x.numel() == 1:
-            res = ewma[..., -1].unsqueeze(0)
-            return res.type(torch.FloatTensor).to(self.train_x.device)
-        elif torch.equal(x.squeeze(), self.train_x.squeeze()):
-            return ewma[..., :-1].type(torch.FloatTensor).to(self.train_x.device)
-        else:
-            return ewma.type(torch.FloatTensor).to(self.train_x.device)
-        
-        
-class HEWMAMean(Mean):
-    def __init__(self, train_x, train_y, k=20):
-        super().__init__()
-        self.k = k
-        self.train_x = train_x
-        self.train_y = train_y
-        
-    def forward(self, x):
-        wma_k = EWMA(self.train_y, self.k)
-        wma_k2 = EWMA(self.train_y, int(self.k/2))
-        hma = EWMA(2*wma_k2[:-1] - wma_k[:-1], int(np.sqrt(self.k)))
-        if torch.equal(x.squeeze(), self.train_x.squeeze()):
-            return hma[:-1].type(torch.FloatTensor).to(self.train_x.device)
-        else:
-            return hma.type(torch.FloatTensor).to(self.train_x.device)
-    
-    
-class DEWMAMean(Mean):
-    def __init__(self, train_x, train_y, k=20):
-        super().__init__()
-        self.k = k
-        self.train_x = train_x
-        self.train_y = train_y
-        
-    def forward(self, x):
-        ema = EWMA(self.train_y, self.k)#[..., :-1]
-        ema_ema = EWMA(ema, self.k)[..., :-1]
-        dema = 2*ema - ema_ema
-        if x.numel() == 1:
-            res = dema[..., -1].unsqueeze(0)
-            return res.type(torch.FloatTensor).to(self.train_x.device)
-        elif torch.equal(x.squeeze(), self.train_x.squeeze()):
-            return dema[..., :-1].type(torch.FloatTensor).to(self.train_x.device)
-        else:
-            return dema.type(torch.FloatTensor).to(self.train_x.device)
-
-        
-class TEWMAMean(Mean):
-    def __init__(self, train_x, train_y, k=20):
-        super().__init__()
-        self.k = k
-        self.alpha = 2./(self.k + 1)
-        self.train_x = train_x
-        self.train_y = train_y
-        
-    def forward(self, x):
-        ema = EWMA(self.train_y, self.k)
-        ema_ema = EWMA(ema, self.k)[..., :-1]
-        ema_ema_ema = EWMA(ema_ema, self.k)[..., :-1]
-        tema = 3*ema - 3*ema_ema + ema_ema_ema
-        if x.numel() == 1:
-            res = tema[..., -1].unsqueeze(0)
-            return res.type(torch.FloatTensor).to(self.train_x.device)
-        elif torch.equal(x.squeeze(), self.train_x.squeeze()):
-            return tema[..., :-1].type(torch.FloatTensor).to(self.train_x.device)
-        else:
-            return tema.type(torch.FloatTensor).to(self.train_x.device)
\ No newline at end of file
diff --git a/voltron/means/.ipynb_checkpoints/__init__-checkpoint.py b/voltron/means/.ipynb_checkpoints/__init__-checkpoint.py
deleted file mode 100644
index 45b5e01..0000000
--- a/voltron/means/.ipynb_checkpoints/__init__-checkpoint.py
+++ /dev/null
@@ -1,3 +0,0 @@
-from .loglinear_mean import LogLinearMean
-from .mulidentity_mean import MulIdentityMean
-from .EWMA import EWMAMean, DEWMAMean, TEWMAMean
\ No newline at end of file
diff --git a/voltron/means/.ipynb_checkpoints/loglinear_mean-checkpoint.py b/voltron/means/.ipynb_checkpoints/loglinear_mean-checkpoint.py
deleted file mode 100644
index 67db2a2..0000000
--- a/voltron/means/.ipynb_checkpoints/loglinear_mean-checkpoint.py
+++ /dev/null
@@ -1,21 +0,0 @@
-import torch
-
-from gpytorch.means import LinearMean
-
-class LogLinearMean(LinearMean):
-    def __init__(self, input_size, batch_shape=None, bias=True):
-        if batch_shape is None:
-            batch_shape = torch.Size()
-
-        super().__init__(input_size=input_size, batch_shape=batch_shape, bias=bias)
-
-    def initialize_from_data(self, x, y):
-        with torch.no_grad():
-            # assume y is on log scale
-            self.bias.data = y.exp().mean(-1)
-            # is there anything we should do for the mean term?
-
-    def forward(self, x):
-        linear_term = super().forward(x)
-        # to prevent linear stuff
-        return linear_term.clamp(min=1e-6).log()
\ No newline at end of file
diff --git a/voltron/models/.ipynb_checkpoints/BMGP-checkpoint.py b/voltron/models/.ipynb_checkpoints/BMGP-checkpoint.py
deleted file mode 100644
index e69de29..0000000
diff --git a/voltron/models/.ipynb_checkpoints/BasicGPModels-checkpoint.py b/voltron/models/.ipynb_checkpoints/BasicGPModels-checkpoint.py
deleted file mode 100644
index b889961..0000000
--- a/voltron/models/.ipynb_checkpoints/BasicGPModels-checkpoint.py
+++ /dev/null
@@ -1,53 +0,0 @@
-import math
-import torch
-import gpytorch
-import numpy as np
-from voltron.means import EWMAMean, DEWMAMean, TEWMAMean
-from botorch.models import SingleTaskGP
-from botorch.optim.fit import fit_gpytorch_torch
-from voltron.rollout_utils import nonvol_rollouts
-
-class BasicGP():
-    def __init__(self, train_x, train_y, kernel="matern", mean='constant', 
-                 k=400, num_mixtures=10):
-#         super(BasicGP, self).__init__(train_x, train_y, likelihood)
-        if mean.lower() == 'constant':
-            mean_module = gpytorch.means.ConstantMean().to(train_x.device)
-        elif mean.lower() == 'ewma':
-            mean_module = EWMAMean(train_x, train_y, k).to(train_x.device)
-        elif mean.lower() == 'dewma':
-            mean_module = DEWMAMean(train_x, train_y, k).to(train_x.device)
-        elif mean.lower() == 'tewma':
-            mean_module = TEWMAMean(train_x, train_y, k).to(train_x.device)
-        else:
-            print("ERROR: Mean not implemented")
-        
-        if kernel.lower() == 'matern':
-            covar_module = gpytorch.kernels.ScaleKernel(gpytorch.kernels.MaternKernel())
-        elif kernel.lower() in ['sm', 'spectralmixture', 'spectral']:
-            covar_module = gpytorch.kernels.SpectralMixtureKernel(num_mixtures=num_mixtures)
-            covar_module.initialize_from_data(train_x, train_y)
-        elif kernel.lower() == 'rbf':
-            covar_module = gpytorch.kernels.ScaleKernel(gpytorch.kernels.RBFKernel())
-        else:
-            print("ERROR: Kernel not implemented")
-
-        self.model = SingleTaskGP(train_x.view(-1, 1), train_y.reshape(-1, 1),
-                                  covar_module=covar_module,
-                                  likelihood=gpytorch.likelihoods.GaussianLikelihood())
-        self.model.mean_module = mean_module
-                
-    def Train(self, train_iters=400, display=False):
-        mll = gpytorch.mlls.ExactMarginalLogLikelihood(self.model.likelihood, self.model)
-        fit_gpytorch_torch(mll, options={'maxiter':train_iters, 'disp':display})
-        
-    def Forecast(self, test_x, nsample=100):
-        if not isinstance(self.model.mean_module, (EWMAMean, DEWMAMean, TEWMAMean)):
-            
-            samples = self.model.posterior(test_x).sample(torch.Size((nsample, )))
-            
-        else:
-            samples = nonvol_rollouts(self.model.train_inputs[0].squeeze(),
-                                      self.model.train_targets.squeeze(),
-                                      test_x, self.model, nsample)
-        return samples.squeeze()
\ No newline at end of file
diff --git a/voltron/models/.ipynb_checkpoints/LSTM-checkpoint.py b/voltron/models/.ipynb_checkpoints/LSTM-checkpoint.py
deleted file mode 100644
index dd5907c..0000000
--- a/voltron/models/.ipynb_checkpoints/LSTM-checkpoint.py
+++ /dev/null
@@ -1,113 +0,0 @@
-import numpy as np
-import torch
-from torch import nn
-from torch.utils.data import DataLoader, Dataset
-from torch.autograd import Variable  
-
-
-class SequenceDataset(Dataset):
-    def __init__(self, data, sequence_length=5):
-        self.sequence_length = sequence_length
-        self.X = data.float()
-
-    def __len__(self):
-        return self.X.shape[0]-1
-
-    def __getitem__(self, i): 
-        if i >= self.sequence_length - 1:
-            i_start = i - self.sequence_length + 1
-            x = self.X[i_start:(i + 1)]
-        else:
-            padding = self.X[0].repeat(self.sequence_length - i - 1, 1).squeeze(-1)
-            x = self.X[0:(i + 1)]
-            x = torch.cat((padding, x), 0)
-            
-        return x.unsqueeze(0), self.X[i+1]
-
-class LSTM(nn.Module):
-    def __init__(self, train_x, train_y, seq_len, hidden_size, 
-                 num_layers, batch_size=128):
-        super(LSTM, self).__init__()
-        
-        self.train_x = train_x
-        self.train_y = train_y
-        
-        self.norm_y = (train_y - train_y.mean())/train_y.std()
-
-        self.dset = SequenceDataset(self.norm_y, sequence_length=seq_len)
-        self.trainloader = DataLoader(self.dset, batch_size=batch_size,
-                                      shuffle=True)
-        
-        self.num_classes = 1
-        self.num_layers = num_layers
-        self.input_size = seq_len
-        self.hidden_size = hidden_size
-
-        self.lstm = nn.LSTM(input_size=seq_len, hidden_size=hidden_size,
-                          num_layers=num_layers, batch_first=True) #lstm
-        self.fc_1 =  nn.Linear(hidden_size, 128) #fully connected 1
-        self.fc = nn.Linear(128, 2) #fully connected last layer
-
-        self.relu = nn.ReLU()
-        self.softplus = nn.Softplus()
-    
-    def forward(self,x):
-        h_0 = Variable(torch.zeros(self.num_layers, x.size(0), self.hidden_size)).to(x.device) #hidden state
-        c_0 = Variable(torch.zeros(self.num_layers, x.size(0), self.hidden_size)).to(x.device) #internal state
-        # Propagate input through LSTM
-        output, (hn, cn) = self.lstm(x, (h_0, c_0)) #lstm with input, hidden, and internal state
-
-        hn = hn[self.num_layers-1]
-        hn = hn.view(-1, self.hidden_size) #reshaping the data for Dense layer next
-        out = self.relu(hn)
-        out = self.fc_1(out) #first Dense
-        out = self.relu(out) #relu
-        out = self.fc(out) #Final Output
-        
-        output = torch.zeros_like(out)
-        output[:, 0] = out[:, 0]
-        output[:, 1] = self.softplus(out[:, 1])
-        return output
-    
-    def Loss(self, targets, outputs):
-        dist = torch.distributions.Normal(outputs[:, 0], outputs[:, 1])
-        return -dist.log_prob(targets).sum()
-
-    def Train(self, epochs, display=False):
-        optimizer = torch.optim.Adam(self.parameters(), lr=0.01)
-        num_batches = len(self.trainloader)
-        total_loss = 0
-        self.train()
-        for epoch in range(epochs):
-            for X, y in self.trainloader:
-                X = X.to(self.train_x.device)
-                y = y.to(self.train_x.device)
-                output = self(X)
-                loss = self.Loss(y, output)
-
-                optimizer.zero_grad()
-                loss.backward()
-                optimizer.step()
-
-                total_loss += loss.item()
-            if display:
-                if epoch%50 == 0:
-                    avg_loss = total_loss / num_batches
-                    print(f"Train loss: {avg_loss}, Epoch: {epoch}")
-
-    
-    def Forecast(self, test_x, nsample=50):
-        rollout_len = test_x.shape[0]
-        xin, xout = self.dset[len(self.dset)-1]
-        xx = torch.cat((xin[0, 1:], xout.unsqueeze(0)))
-        xx = xx.repeat(nsample, 1).unsqueeze(1)
-        xx = xx.to(self.train_x.device)
-        roll_pxs = torch.zeros(nsample, rollout_len)
-        with torch.no_grad():
-            for idx in range(rollout_len):
-                out = self(xx)
-                smpl = torch.normal(out[:, 0], out[:, 1])
-                roll_pxs[:, idx] = smpl
-                xx = torch.cat((xx[..., 1:], smpl.unsqueeze(-1).unsqueeze(-1)), -1)
-        return roll_pxs * self.train_y.std() + self.train_y.mean()
-        
\ No newline at end of file
diff --git a/voltron/models/.ipynb_checkpoints/Volt-checkpoint.py b/voltron/models/.ipynb_checkpoints/Volt-checkpoint.py
deleted file mode 100644
index 3e372ba..0000000
--- a/voltron/models/.ipynb_checkpoints/Volt-checkpoint.py
+++ /dev/null
@@ -1,162 +0,0 @@
-import torch
-from torch.nn.functional import softplus
-import gpytorch
-from gpytorch.kernels import Kernel
-from gpytorch.means import ConstantMean
-from gpytorch.utils.cholesky import psd_safe_cholesky
-
-from voltron.models.BMGP import BMGP, MultitaskBMGP
-from voltron.kernels import VolatilityKernel
-
-# import sys
-# sys.path.append("../means/")
-from voltron.means import EWMAMean, DEWMAMean, TEWMAMean
-from voltron.train_utils import LearnGPCV, TrainVolModel
-from voltron.rollout_utils import Rollouts
-
-class Volt(gpytorch.models.ExactGP):
-    def __init__(self, train_x, log_data, mean='constant',
-                 vol_path=None, k=25):
-        
-        # WE ASSUME IN THE BATCHED CASE THAT
-        # TRAIN_X: N 
-        # TRAIN_Y: T X N
-        # VOL_PATH: T X N
-
-        likelihood = gpytorch.likelihoods.GaussianLikelihood()
-        
-        super(Volt, self).__init__(train_x[1:], log_data[1:], likelihood)
-        
-        if log_data.ndim > 1:
-            batch_shape = log_data.shape[:-1]
-        else:
-            batch_shape = torch.Size()
-            
-        if mean.lower() == 'constant':
-            mean_module = gpytorch.means.ConstantMean().to(train_x.device)
-        elif mean.lower() == 'ewma':
-            mean_module = EWMAMean(train_x[1:], log_data[1:], k).to(train_x.device)
-        elif mean.lower() == 'dewma':
-            mean_module = DEWMAMean(train_x[1:], log_data[1:], k).to(train_x.device)
-        elif mean.lower() == 'tewma':
-            mean_module = TEWMAMean(train_x[1:], log_data[1:], k).to(train_x.device)
-        else:
-            print("ERROR: Mean not implemented")
-            
-        self.mean_module = mean_module.to(train_x.device)
-        self.covar_module = VolatilityKernel().to(train_x.device)
-        
-        # but we store a T X N X 1 copy of train_x to maintain consistency w/ 
-        # gpytorch
-        if log_data.ndim > 1:
-            self.train_x = train_x.unsqueeze(0).repeat(*batch_shape, 1)
-        else:
-            self.train_x = train_x
-        self.train_y = log_data
-        
-        if vol_path is None:
-            self.log_vol_path = -1 * torch.ones(train_x.shape[0]-1)
-        else:
-            self.log_vol_path = vol_path.log()
-        
-        self.train_cov = self.covar_module(self.train_x.unsqueeze(-1), self.log_vol_path.exp().unsqueeze(-1)).detach()
-        
-        if batch_shape == torch.Size():
-            self.vol_lh = gpytorch.likelihoods.GaussianLikelihood()
-            self.vol_model = BMGP(train_x, self.log_vol_path, self.vol_lh) 
-        else:
-            self.vol_lh = gpytorch.likelihoods.MultitaskGaussianLikelihood(num_tasks=batch_shape[0])
-            self.vol_lh.noise = 1e-3
-            # we want the vol path GP to be N x T shaped and train_x to be N shaped
-            self.vol_model = MultitaskBMGP(train_x, self.log_vol_path.t(), self.vol_lh)
-        
-    def UpdateVolPath(self, vol_path):
-        self.log_vol_path = vol_path.log()
-        self.train_cov = self.covar_module(self.train_inputs[0], self.log_vol_path.exp())
-        return
-        
-    def VolMLL(self):
-        vol_mll = gpytorch.mlls.ExactMarginalLogLikelihood(self.vol_lh, self.vol_model)
-        outputs = self.vol_model(self.train_x)
-        return vol_mll(outputs, self.log_vol_path)
-        
-    def forward(self, x):
-        mean_x = self.mean_module(x)
-        if torch.equal(x, self.train_inputs[0]):
-            covar_x = self.train_cov
-#             print("TRAIN COV")
-        else:
-            covar_x = self.covar_module(x, self.log_vol_path.exp())
-#             print("NOT TRAIN COV")
-            
-#         print(covar_x.evaluate().shape)
-        return gpytorch.distributions.MultivariateNormal(mean_x, covar_x)
-    
-    def Train(self, gpcv_iters=400, vol_mod_iters=1000, data_mod_iters=400, display=False):
-        x = self.train_x.squeeze()
-        data = self.train_y.exp()
-
-        ##############################
-        ## Train GPCV and Vol Model ##
-        ##############################
-        vol = LearnGPCV(x[1:], data, gpcv_iters, printing=display)
-        vmod, vlh = TrainVolModel(x[1:], vol, vol_mod_iters, printing=display)
-        
-        self.UpdateVolPath(vol)
-        ######################
-        ## Train Data Model ##
-        ######################
-        if isinstance(self.mean_module, (EWMAMean, DEWMAMean, TEWMAMean)):
-            grad_flags = [True, False, False, False]
-        else:
-            grad_flags = [True, True, False, False, False]
-            
-        
-        self.likelihood.raw_noise.data = torch.tensor([1e-5]).to(x.device)
-        self.vol_lh = vlh.to(x.device)
-        self.vol_model = vmod.to(x.device)
-    
-        for idx, p in enumerate(self.parameters()):
-            p.requires_grad = grad_flags[idx]
-            
-        self.train();
-        self.vol_lh.train();
-        self.vol_model.train();
-        
-        
-        optimizer = torch.optim.Adam([
-            {'params': self.parameters()},  # Includes GaussianLikelihood parameters
-        ], lr=0.1)
-        mll = gpytorch.mlls.ExactMarginalLogLikelihood(self.likelihood, self)
-        
-        print_every = 50
-        for i in range(data_mod_iters):
-            # Zero gradients from previous iteration
-            optimizer.zero_grad()
-            # Output from model
-            output = self(x[1:])
-#             print(output)
-#             print(data.log().shape)
-            # Calc loss and backprop gradients
-            loss = -mll(output, data.log()[1:])
-            loss.backward()
-            if display:
-                if i % print_every == 0:
-                    print('Iter %d/%d - Loss: %.3f' % (i + 1, data_mod_iters, loss.item()))
-            optimizer.step()
-            
-        
-    def Forecast(self, test_x, nsample=50, return_vol=False, mean_revert=False, theta=0.05):
-        self.vol_model.eval();
-        self.eval();
-        latent_mean = None
-        if mean_revert:
-            latent_mean = self.train_targets.squeeze().mean()
-        samples = Rollouts(self.train_inputs[0].squeeze(),
-                           self.train_targets.squeeze(), 
-                           test_x, self, 
-                            nsample=nsample,
-                          return_vol=return_vol,
-                          latent_mean=latent_mean, theta=theta)
-        
-        return samples
\ No newline at end of file
diff --git a/voltron/models/.ipynb_checkpoints/__init__-checkpoint.py b/voltron/models/.ipynb_checkpoints/__init__-checkpoint.py
deleted file mode 100644
index 0b93e6c..0000000
--- a/voltron/models/.ipynb_checkpoints/__init__-checkpoint.py
+++ /dev/null
@@ -1,6 +0,0 @@
-from .BMGP import BMGP, MultitaskBMGP
-from .multi_task_variational_gp import MultitaskVariationalGP
-from .single_task_variational_gp import SingleTaskVariationalGP
-from .BasicGPModels import BasicGP
-from .Volt import Volt
-from .LSTM import LSTM
diff --git a/voltron/models/.ipynb_checkpoints/single_task_variational_gp-checkpoint.py b/voltron/models/.ipynb_checkpoints/single_task_variational_gp-checkpoint.py
deleted file mode 100644
index 5a66e55..0000000
--- a/voltron/models/.ipynb_checkpoints/single_task_variational_gp-checkpoint.py
+++ /dev/null
@@ -1,265 +0,0 @@
-from typing import Union
-from copy import deepcopy
-
-import torch
-import functools
-
-from botorch.models.gpytorch import GPyTorchModel
-from botorch.models import SingleTaskGP
-from botorch.posteriors import GPyTorchPosterior
-
-from gpytorch import lazify
-from gpytorch.distributions import MultivariateNormal
-from gpytorch.lazy import (
-    CholLazyTensor,
-    TriangularLazyTensor,
-)
-from gpytorch.likelihoods import GaussianLikelihood
-from gpytorch.likelihoods import FixedNoiseGaussianLikelihood as FNGaussianLikelihood
-from gpytorch.likelihoods.gaussian_likelihood import _GaussianLikelihoodBase
-from gpytorch.means import ConstantMean
-from gpytorch.models import ApproximateGP
-from gpytorch.kernels import ScaleKernel, RBFKernel, InducingPointKernel
-from gpytorch.utils.errors import NotPSDError
-from gpytorch.utils.memoize import cached, add_to_cache, clear_cache_hook
-from gpytorch.variational import (
-    CholeskyVariationalDistribution,
-    UnwhitenedVariationalStrategy,
-    VariationalStrategy,
-)
-
-# from ..utils import pivoted_cholesky_init
-
-# copied from wjmaddox/volatilitygp
-
-# def _update_caches(m, *args, **kwargs):
-#     if hasattr(m, "_memoize_cache"):
-#         for key, item in m._memoize_cache.items():
-#             if type(item) is not tuple and type(item) is not MultivariateNormal:
-#                 if len(args) is 0:
-#                     new_lc = item.to(torch.empty(0, **kwargs))
-#                 else:
-#                     new_lc = item.to(*args)
-#                 m._memoize_cache[key] = new_lc
-#                 if type(item) is TriangularLazyTensor:
-#                     m._memoize_cache[key] = m._memoize_cache[key].double()
-#             elif type(item) is MultivariateNormal:
-#                 if len(args) is 0:
-#                     new_lc = item.lazy_covariance_matrix.to(torch.empty(0, **kwargs))
-#                 else:
-#                     new_lc = item.lazy_covariance_matrix.to(*args)
-#                 m._memoize_cache[key] = MultivariateNormal(
-#                     item.mean.to(*args, **kwargs), new_lc
-#                 )
-#             else:
-#                 m._memoize_cache[key] = (x.to(*args, **kwargs) for x in item)
-
-
-# def _add_cache_hook(tsr, pred_strat):
-#     if tsr.grad_fn is not None:
-#         wrapper = functools.partial(clear_cache_hook, pred_strat)
-#         functools.update_wrapper(wrapper, clear_cache_hook)
-#         tsr.grad_fn.register_hook(wrapper)
-#     return tsr
-
-
-class _SingleTaskVariationalGP(ApproximateGP):
-    def __init__(
-        self,
-        init_points: torch.Tensor = None,
-        likelihood=None,
-        learn_inducing_locations=True,
-        covar_module=None,
-        mean_module=None,
-        use_piv_chol_init=True,
-        num_inducing=None,
-        use_whitened_var_strat=True,
-        init_targets=None,
-        train_inputs=None,
-        train_targets=None,
-    ):
-
-        if covar_module is None:
-            covar_module = ScaleKernel(RBFKernel())
-
-        # if use_piv_chol_init:
-        #     if num_inducing is None:
-        #         num_inducing = int(init_points.shape[-2] / 2)
-
-        #     if num_inducing < init_points.shape[-2]:
-        #         covar_module = covar_module.to(init_points)
-
-        #         covariance = covar_module(init_points)
-        #         if init_targets is not None and init_targets.shape[-1] == 1:
-        #             init_targets = init_targets.squeeze(-1)
-        #         if likelihood is not None and not isinstance(
-        #             likelihood, GaussianLikelihood
-        #         ):
-        #             _ = likelihood.newton_iteration(
-        #                 init_points, init_targets, model=None, covar=covariance
-        #             )
-        #             if likelihood.has_diag_hessian:
-        #                 hessian_sqrt = likelihood.expected_hessian().sqrt()
-        #             else:
-        #                 hessian_sqrt = (
-        #                     lazify(likelihood.expected_hessian())
-        #                     .root_decomposition()
-        #                     .root
-        #                 )
-        #             covariance = hessian_sqrt.matmul(covariance).matmul(
-        #                 hessian_sqrt.transpose(-1, -2)
-        #             )
-        #         inducing_points = pivoted_cholesky_init(
-        #             init_points, covariance.evaluate(), num_inducing
-        #         )
-        #     else:
-        #         inducing_points = init_points.detach().clone()
-        # else:
-        inducing_points = init_points.detach().clone()
-
-        variational_distribution = CholeskyVariationalDistribution(
-            inducing_points.shape[-2]
-        )
-        if use_whitened_var_strat:
-            variational_strategy = VariationalStrategy(
-                self,
-                inducing_points,
-                variational_distribution,
-                learn_inducing_locations=learn_inducing_locations,
-            )
-        else:
-            variational_strategy = UnwhitenedVariationalStrategy(
-                self,
-                inducing_points,
-                variational_distribution,
-                learn_inducing_locations=learn_inducing_locations,
-            )
-        super(_SingleTaskVariationalGP, self).__init__(variational_strategy)
-        self.mean_module = ConstantMean() if mean_module is None else mean_module
-        self.mean_module.to(init_points)
-        self.covar_module = covar_module
-
-        self.likelihood = GaussianLikelihood() if likelihood is None else likelihood
-        self.likelihood.to(init_points)
-        self.train_inputs = [train_inputs] if train_inputs is not None else [init_points]
-        self.train_targets = train_targets if train_targets is not None else init_targets
-
-        self.condition_into_exact = True
-
-        self.to(init_points)
-
-    def forward(self, x):
-        mean_x = self.mean_module(x)
-        covar_x = self.covar_module(x)
-        latent_pred = MultivariateNormal(mean_x, covar_x)
-        return latent_pred
-
-    # may actually want to keep this one in the future
-    # def to(self, *args, **kwargs):
-    #     _update_caches(self, *args, **kwargs)
-    #     self.variational_strategy = self.variational_strategy.to(*args, **kwargs)
-    #     _update_caches(self.variational_strategy, *args, **kwargs)
-    #     return super().to(*args, **kwargs)
-
-
-class SingleTaskVariationalGP(_SingleTaskVariationalGP, GPyTorchModel):
-    def __init__(
-        self,
-        init_points=None,
-        likelihood=None,
-        learn_inducing_locations=True,
-        covar_module=None,
-        mean_module=None,
-        use_piv_chol_init=True,
-        num_inducing=None,
-        use_whitened_var_strat=True,
-        init_targets=None,
-        train_inputs=None,
-        train_targets=None,
-        outcome_transform=None,
-        input_transform=None,
-    ):
-        if outcome_transform is not None:
-            is_gaussian_likelihood = (
-                isinstance(likelihood, GaussianLikelihood) or likelihood is None
-            )
-            if train_targets is not None and is_gaussian_likelihood:
-                if train_targets.ndim == 1:
-                    train_targets = train_targets.unsqueeze(-1)
-                train_targets, _ = outcome_transform(train_targets)
-
-            if init_targets is not None and is_gaussian_likelihood:
-                init_targets, _ = outcome_transform(init_targets)
-                init_targets = init_targets.squeeze(-1)
-
-        if train_targets is not None:
-            train_targets = train_targets.squeeze(-1)
-
-        # unlike in the exact gp case we need to use the input transform to pre-define the inducing pts
-        if input_transform is not None:
-            if init_points is not None:
-                init_points = input_transform(init_points)
-
-        _SingleTaskVariationalGP.__init__(
-            self,
-            init_points=init_points,
-            likelihood=likelihood,
-            learn_inducing_locations=learn_inducing_locations,
-            covar_module=covar_module,
-            mean_module=mean_module,
-            use_piv_chol_init=use_piv_chol_init,
-            num_inducing=num_inducing,
-            use_whitened_var_strat=use_whitened_var_strat,
-            init_targets=init_targets,
-            train_inputs=train_inputs,
-            train_targets=train_targets,
-        )
-
-        if input_transform is not None:
-            self.input_transform = input_transform.to(
-                self.variational_strategy.inducing_points
-            )
-
-        if outcome_transform is not None:
-            self.outcome_transform = outcome_transform.to(
-                self.variational_strategy.inducing_points
-            )
-
-    def forward(self, x):
-        x = self.transform_inputs(x)
-        return super().forward(x)
-
-    @property
-    def num_outputs(self) -> int:
-        # we should only be able to have one output without a multitask variational strategy here
-        return 1
-
-    # might be useful in the future though
-    # def posterior(
-    #     self,
-    #     X: torch.Tensor,
-    #     observation_noise: Union[bool, torch.Tensor] = False,
-    #     **kwargs,
-    # ):
-    #     if observation_noise and not isinstance(self.likelihood, _GaussianLikelihoodBase):
-    #         noiseless_posterior = super().posterior(
-    #             X=X, observation_noise=False, **kwargs
-    #         )
-    #         noiseless_mvn = noiseless_posterior.mvn
-    #         neg_hessian_f = self.likelihood.neg_hessian_f(noiseless_mvn.mean)
-    #         try:
-    #             likelihood_cov = neg_hessian_f.inverse()
-    #         except:
-    #             eye_like_hessian = torch.eye(
-    #                 neg_hessian_f.shape[-2],
-    #                 device=neg_hessian_f.device,
-    #                 dtype=neg_hessian_f.dtype,
-    #             )
-    #             likelihood_cov = lazify(neg_hessian_f).inv_matmul(eye_like_hessian)
-
-    #         noisy_mvn = type(noiseless_mvn)(
-    #             noiseless_mvn.mean, noiseless_mvn.lazy_covariance_matrix + likelihood_cov
-    #         )
-    #         return GPyTorchPosterior(mvn=noisy_mvn)
-
-    #     return super().posterior(X=X, observation_noise=observation_noise, **kwargs)
\ No newline at end of file