From 38ab6cac232d23c97d2d75290887cd486999cc29 Mon Sep 17 00:00:00 2001 From: wassname Date: Sat, 14 Mar 2020 15:16:14 +0800 Subject: [PATCH] try attention seq2seq --- smartmeters-transformer-seq2seq.ipynb | 981 ++++++++++++++++++++++++++ src/data/smart_meter.py | 2 +- src/models/transformer_seq2seq.py | 272 +++++++ src/plot.py | 14 +- src/utils.py | 45 ++ 5 files changed, 1307 insertions(+), 7 deletions(-) create mode 100644 smartmeters-transformer-seq2seq.ipynb create mode 100644 src/models/transformer_seq2seq.py diff --git a/smartmeters-transformer-seq2seq.ipynb b/smartmeters-transformer-seq2seq.ipynb new file mode 100644 index 0000000..629d7f9 --- /dev/null +++ b/smartmeters-transformer-seq2seq.ipynb @@ -0,0 +1,981 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# This notebook uses pytorch lightning & optuna & an LSTM\n", + "\n", + "This notebook trains an LSTM on timeseries data from smartmeters.\n", + "\n", + "It uses pytorch lighting for the training loop. And Optuna for the hyperparameter optimisation.\n", + "\n", + "It also pushes results to the tensorboard hyperparameter dashboard for examination.\n", + "\n", + "- https://github.com/optuna/optuna/blob/master/examples/pytorch_lightning_simple.py" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-14T07:09:05.502663Z", + "start_time": "2020-03-14T07:09:05.101070Z" + } + }, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "%reload_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-14T07:09:07.495992Z", + "start_time": "2020-03-14T07:09:05.505650Z" + } + }, + "outputs": [], + "source": [ + "import sys, re, os, itertools, functools, collections\n", + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import collections\n", + "from pathlib import Path\n", + "from tqdm.auto import tqdm\n", + "\n", + "import pytorch_lightning as pl\n", + "import optuna\n", + "from optuna.integration import PyTorchLightningPruningCallback\n", + "\n", + "\n", + "import math\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-14T07:09:07.553714Z", + "start_time": "2020-03-14T07:09:07.500345Z" + } + }, + "outputs": [], + "source": [ + "import torch\n", + "from torch import nn\n", + "import torch.nn.functional as F" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-14T07:09:07.680674Z", + "start_time": "2020-03-14T07:09:07.557348Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/pytorch_lightning/core/decorators.py:13: UserWarning:\n", + "\n", + "data_loader decorator deprecated in 0.7.0. Will remove 0.9.0\n", + "\n" + ] + } + ], + "source": [ + "from src.models.model import LatentModel\n", + "from src.data.smart_meter import collate_fns, SmartMeterDataSet, get_smartmeter_df\n", + "from src.plot import plot_from_loader\n", + "from src.models.transformer_seq2seq import TransformerSeq2Seq_PL\n", + "from src.dict_logger import DictLogger\n", + "from src.utils import PyTorchLightningPruningCallback" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-14T07:09:07.734741Z", + "start_time": "2020-03-14T07:09:07.682916Z" + } + }, + "outputs": [], + "source": [ + "import logging\n", + "logging.basicConfig(stream=sys.stdout, level=logging.INFO)\n", + "logger = logging.getLogger(\"smartmeters.ipynb\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-14T07:09:07.788003Z", + "start_time": "2020-03-14T07:09:07.737690Z" + } + }, + "outputs": [], + "source": [ + "# Params\n", + "device='cuda'\n", + "use_logy=False" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Load kaggle smart meter data" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-14T07:09:16.678003Z", + "start_time": "2020-03-14T07:09:07.790696Z" + } + }, + "outputs": [], + "source": [ + "df_train, df_test = get_smartmeter_df()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-14T07:09:17.405503Z", + "start_time": "2020-03-14T07:09:16.683653Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Show split\n", + "df_train['energy(kWh/hh)'].plot(label='train')\n", + "df_test['energy(kWh/hh)'].plot(label='test')\n", + "plt.title('energy(kWh/hh)')\n", + "plt.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-02-16T00:24:15.905017Z", + "start_time": "2020-02-16T00:24:15.747859Z" + } + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Train helpers" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-14T07:00:55.672759Z", + "start_time": "2020-03-14T07:00:55.564212Z" + } + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-14T07:03:19.316016Z", + "start_time": "2020-03-14T07:03:19.236454Z" + } + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-14T07:09:17.486980Z", + "start_time": "2020-03-14T07:09:17.409793Z" + } + }, + "outputs": [], + "source": [ + "def main(trial, train=True):\n", + " # PyTorch Lightning will try to restore model parameters from previous trials if checkpoint\n", + " # filenames match. Therefore, the filenames for each trial must be made unique.\n", + " \n", + " checkpoint_callback = pl.callbacks.ModelCheckpoint(\n", + " os.path.join(MODEL_DIR, name, 'version_{}'.format(trial.number), \"chk\"), monitor='val_loss', mode='min')\n", + "\n", + " # The default logger in PyTorch Lightning writes to event files to be consumed by\n", + " # TensorBoard. We create a simple logger instead that holds the log in memory so that the\n", + " # final accuracy can be obtained after optimization. When using the default logger, the\n", + " # final accuracy could be stored in an attribute of the `Trainer` instead.\n", + " logger = DictLogger(MODEL_DIR, name=name, version=trial.number)\n", + "# print(\"log_dir\", logger.experiment.log_dir)\n", + " hparams = dict(**trial.params, **trial.user_attrs)\n", + "\n", + " trainer = pl.Trainer(\n", + " logger=logger,\n", + " val_percent_check=PERCENT_TEST_EXAMPLES,\n", + " checkpoint_callback=checkpoint_callback,\n", + " max_epochs=hparams['max_nb_epochs'],\n", + " gpus=-1 if torch.cuda.is_available() else None,\n", + " early_stop_callback=PyTorchLightningPruningCallback(trial, monitor='val_loss')\n", + " )\n", + " \n", + " model = TransformerSeq2Seq_PL(hparams)\n", + " if train:\n", + " trainer.fit(model)\n", + " return model, trainer" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-14T07:09:17.552317Z", + "start_time": "2020-03-14T07:09:17.489796Z" + } + }, + "outputs": [], + "source": [ + "def add_suggest(trial):\n", + " trial.suggest_loguniform(\"learning_rate\", 1e-7, 1e-2)\n", + " trial.suggest_uniform(\"attention_dropout\", 0, 0.75)\n", + " trial.suggest_categorical(\"hidden_size\", [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048]) \n", + " trial.suggest_categorical(\"hidden_out_size\", [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048]) \n", + " trial.suggest_categorical(\"nlayers\", [1, 2, 4, 8]) \n", + " trial.suggest_categorical(\"nhead\", [1, 2, 8, 16])\n", + " \n", + "\n", + " trial._user_attrs = {\n", + " 'batch_size': 16,\n", + " 'grad_clip': 40,\n", + " 'max_nb_epochs': 200,\n", + " 'num_workers': 4,\n", + " 'num_extra_target': 24*4,\n", + " 'vis_i': '670',\n", + " 'num_context': 24*4,\n", + " 'input_size': 18,\n", + " 'input_size_decoder': 17,\n", + " 'context_in_target': True,\n", + " 'output_size': 1\n", + " }\n", + " \n", + " # For manual experiment we will start at -1 and deincr by 1\n", + " versions = [int(s.stem.split('_')[-1]) for s in (MODEL_DIR / name).glob('version_*')] + [-1]\n", + " trial.number = min(versions)-1\n", + " print('trial.number', trial.number)\n", + " return trial" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-14T07:09:17.608044Z", + "start_time": "2020-03-14T07:09:17.554643Z" + } + }, + "outputs": [], + "source": [ + "\n", + "def objective(trial):\n", + " # see https://github.com/optuna/optuna/blob/cf6f02d/examples/pytorch_lightning_simple.py\n", + " trial = add_suggest(trial)\n", + "\n", + " \n", + " print('trial', trial.number, 'params', trial.params)\n", + " \n", + " model, trainer = main(trial)\n", + " \n", + " # also report to tensorboard & print\n", + " print('logger.metrics', model.logger.metrics[-1:])\n", + " model.logger.experiment.add_hparams(trial.params, logger.metrics[-1])\n", + " model.logger.save()\n", + " \n", + " return model.logger.metrics[-1]['val_loss']\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Train" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-14T07:09:17.660071Z", + "start_time": "2020-03-14T07:09:17.610356Z" + } + }, + "outputs": [], + "source": [ + "PERCENT_TEST_EXAMPLES = 0.3\n", + "EPOCHS = 2\n", + "DIR = Path(os.getcwd())\n", + "name = \"transformer_seq2seq\"\n", + "MODEL_DIR = DIR/ 'lightning_logs'\n", + "\n", + "MODEL_DIR.mkdir(parents=True, exist_ok=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-14T07:09:17.729742Z", + "start_time": "2020-03-14T07:09:17.662794Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "now run `tensorboard --logdir /media/wassname/Storage5/projects2/3ST/attentive-neural-processes/lightning_logs\n" + ] + } + ], + "source": [ + "print(f\"now run `tensorboard --logdir {MODEL_DIR}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-14T05:06:20.950545Z", + "start_time": "2020-03-14T05:06:20.876126Z" + } + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2020-02-16T01:47:59.598921Z", + "start_time": "2020-02-16T01:47:02.100Z" + } + }, + "source": [ + "Note that the LSTM has access to the y values for the first half of the plot (the context) to match the NP setup." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "start_time": "2020-03-14T07:09:05.200Z" + }, + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "trial.number -17\n", + "INFO:root:GPU available: True, used: True\n", + "INFO:root:VISIBLE GPUS: 0\n", + "INFO:root:\n", + " | Name | Type | Params\n", + "---------------------------------------------------------------------------------------\n", + "0 | model | TransformerSeq2SeqNet | 1 M \n", + "1 | model.enc_emb | Linear | 4 K \n", + "2 | model.encoder | TransformerEncoder | 660 K \n", + "3 | model.encoder.layers | ModuleList | 660 K \n", + "4 | model.encoder.layers.0 | TransformerEncoderLayer | 330 K \n", + "5 | model.encoder.layers.0.self_attn | MultiheadAttention | 263 K \n", + "6 | model.encoder.layers.0.self_attn.out_proj | Linear | 65 K \n", + "7 | model.encoder.layers.0.linear1 | Linear | 32 K \n", + "8 | model.encoder.layers.0.dropout | Dropout | 0 \n", + "9 | model.encoder.layers.0.linear2 | Linear | 33 K \n", + "10 | model.encoder.layers.0.norm1 | LayerNorm | 512 \n", + "11 | model.encoder.layers.0.norm2 | LayerNorm | 512 \n", + "12 | model.encoder.layers.0.dropout1 | Dropout | 0 \n", + "13 | model.encoder.layers.0.dropout2 | Dropout | 0 \n", + "14 | model.encoder.layers.1 | TransformerEncoderLayer | 330 K \n", + "15 | model.encoder.layers.1.self_attn | MultiheadAttention | 263 K \n", + "16 | model.encoder.layers.1.self_attn.out_proj | Linear | 65 K \n", + "17 | model.encoder.layers.1.linear1 | Linear | 32 K \n", + "18 | model.encoder.layers.1.dropout | Dropout | 0 \n", + "19 | model.encoder.layers.1.linear2 | Linear | 33 K \n", + "20 | model.encoder.layers.1.norm1 | LayerNorm | 512 \n", + "21 | model.encoder.layers.1.norm2 | LayerNorm | 512 \n", + "22 | model.encoder.layers.1.dropout1 | Dropout | 0 \n", + "23 | model.encoder.layers.1.dropout2 | Dropout | 0 \n", + "24 | model.dec_emb | Linear | 4 K \n", + "25 | model.decoder | TransformerDecoder | 1 M \n", + "26 | model.decoder.layers | ModuleList | 1 M \n", + "27 | model.decoder.layers.0 | TransformerDecoderLayer | 593 K \n", + "28 | model.decoder.layers.0.self_attn | MultiheadAttention | 263 K \n", + "29 | model.decoder.layers.0.self_attn.out_proj | Linear | 65 K \n", + "30 | model.decoder.layers.0.multihead_attn | MultiheadAttention | 263 K \n", + "31 | model.decoder.layers.0.multihead_attn.out_proj | Linear | 65 K \n", + "32 | model.decoder.layers.0.linear1 | Linear | 32 K \n", + "33 | model.decoder.layers.0.dropout | Dropout | 0 \n", + "34 | model.decoder.layers.0.linear2 | Linear | 33 K \n", + "35 | model.decoder.layers.0.norm1 | LayerNorm | 512 \n", + "36 | model.decoder.layers.0.norm2 | LayerNorm | 512 \n", + "37 | model.decoder.layers.0.norm3 | LayerNorm | 512 \n", + "38 | model.decoder.layers.0.dropout1 | Dropout | 0 \n", + "39 | model.decoder.layers.0.dropout2 | Dropout | 0 \n", + "40 | model.decoder.layers.0.dropout3 | Dropout | 0 \n", + "41 | model.decoder.layers.1 | TransformerDecoderLayer | 593 K \n", + "42 | model.decoder.layers.1.self_attn | MultiheadAttention | 263 K \n", + "43 | model.decoder.layers.1.self_attn.out_proj | Linear | 65 K \n", + "44 | model.decoder.layers.1.multihead_attn | MultiheadAttention | 263 K \n", + "45 | model.decoder.layers.1.multihead_attn.out_proj | Linear | 65 K \n", + "46 | model.decoder.layers.1.linear1 | Linear | 32 K \n", + "47 | model.decoder.layers.1.dropout | Dropout | 0 \n", + "48 | model.decoder.layers.1.linear2 | Linear | 33 K \n", + "49 | model.decoder.layers.1.norm1 | LayerNorm | 512 \n", + "50 | model.decoder.layers.1.norm2 | LayerNorm | 512 \n", + "51 | model.decoder.layers.1.norm3 | LayerNorm | 512 \n", + "52 | model.decoder.layers.1.dropout1 | Dropout | 0 \n", + "53 | model.decoder.layers.1.dropout2 | Dropout | 0 \n", + "54 | model.decoder.layers.1.dropout3 | Dropout | 0 \n", + "55 | model.mean | Linear | 257 \n", + "56 | model.std | Linear | 257 \n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, description='Validation sanity check', layout=Layout(flex='2'), max=5.…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "step 0, {'val_loss': '1.146193265914917', 'val/loss_mse': '0.1482062190771103', 'val/loss_p': '1.146193265914917', 'val/sigma': '1.196487307548523'}\n", + "\r" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8d6007c3b6fc4fc8825cde7ecc9fed66", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=1.0, bar_style='info', layout=Layout(flex='2'), max=1.0), HTML(value='')), …" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=70.0, style=Pro…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "step 2194, {'val_loss': '-0.309064656496048', 'val/loss_mse': '0.023657485842704773', 'val/loss_p': '-0.309064656496048', 'val/sigma': '0.23991245031356812'}\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=70.0, style=Pro…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "step 4389, {'val_loss': '-0.42497867345809937', 'val/loss_mse': '0.020270122215151787', 'val/loss_p': '-0.42497867345809937', 'val/sigma': '0.20783782005310059'}\n" + ] + } + ], + "source": [ + "trial = optuna.trial.FixedTrial(\n", + " params={\n", + " 'hidden_size': 128,\n", + " 'hidden_out_size': 256,\n", + " 'learning_rate': 2e-5,\n", + " 'attention_dropout': 0.0,\n", + " 'nlayers': 2,\n", + " 'nhead': 8\n", + " })\n", + "trial = add_suggest(trial)\n", + "trial._user_attrs = {\n", + " 'batch_size': 16,\n", + " 'grad_clip': 40,\n", + " 'max_nb_epochs': 200,\n", + " 'num_workers': 4,\n", + " 'num_extra_target': 24*4,\n", + " 'vis_i': '670',\n", + " 'num_context': 24*4,\n", + " 'input_size': 18,\n", + " 'input_size_decoder': 17,\n", + " 'context_in_target': False,\n", + " 'output_size': 1\n", + "}\n", + "model, trainer = main(trial, train=False)\n", + "trainer.fit(model)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-14T07:07:13.794149Z", + "start_time": "2020-03-14T07:07:11.052417Z" + } + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "start_time": "2020-03-14T07:09:05.200Z" + } + }, + "outputs": [], + "source": [ + "# test\n", + "trainer.test(model)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "start_time": "2020-03-14T07:09:05.200Z" + } + }, + "outputs": [], + "source": [ + "loader = model.val_dataloader()\n", + "dset_test = loader.dataset\n", + "label_names = dset_test.label_names\n", + "plot_from_loader(loader, model, i=670)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "start_time": "2020-03-14T07:09:05.200Z" + } + }, + "outputs": [], + "source": [ + "# Look at input data, low temp, and holidays imply \n", + "rows_x, rows_y = dset_test.get_rows(670)\n", + "rows_x[['apparentTemperature', 'holiday', 'dayofweek']].plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2020-01-27T09:03:28.792465Z", + "start_time": "2020-01-27T09:03:28.346446Z" + } + }, + "source": [ + "# Hyperparam opt" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "start_time": "2020-03-14T07:09:05.200Z" + } + }, + "outputs": [], + "source": [ + "import argparse \n", + "\n", + "parser = argparse.ArgumentParser(description='PyTorch Lightning example.')\n", + "parser.add_argument('--pruning', '-p', action='store_true',\n", + " help='Activate the pruning feature. `MedianPruner` stops unpromising '\n", + " 'trials at the early stages of training.')\n", + "args = parser.parse_args(['-p'])\n", + "\n", + "pruner = optuna.pruners.MedianPruner() if args.pruning else optuna.pruners.NopPruner()\n", + "\n", + "study = optuna.create_study(direction='minimize', pruner=pruner, storage=f'sqlite:///optuna_result/{name}.db', study_name='no-name-b60e37fc-4ab6-4793-8a0a-c87a1b40c5c0', load_if_exists=True)\n", + "\n", + "# shutil.rmtree(MODEL_DIR)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-01-27T23:38:16.813496Z", + "start_time": "2020-01-27T23:38:16.766674Z" + } + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "start_time": "2020-03-14T07:09:05.200Z" + } + }, + "outputs": [], + "source": [ + "study.optimize(objective, n_trials=200, timeout=6000)\n", + "\n", + "print('Number of finished trials: {}'.format(len(study.trials)))\n", + "\n", + "print('Best trial:')\n", + "trial = study.best_trial\n", + "\n", + "print(' Value: {}'.format(trial.value))\n", + "\n", + "print(' Params: ')\n", + "for key, value in trial.params.items():\n", + " print(' {}: {}'.format(key, value))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "start_time": "2020-03-14T07:09:05.200Z" + } + }, + "outputs": [], + "source": [ + "study.optimize(objective, n_trials=200, timeout=6000)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "start_time": "2020-03-14T07:09:05.300Z" + } + }, + "outputs": [], + "source": [ + "df = study.trials_dataframe(attrs=('number', 'value', 'params', 'state'))\n", + "df.sort_values('value')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Scratch" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "start_time": "2020-03-14T07:09:05.300Z" + } + }, + "outputs": [], + "source": [ + "model, trainer = main(trial, train=False)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "start_time": "2020-03-14T07:09:05.300Z" + } + }, + "outputs": [], + "source": [ + "loader = model.val_dataloader()[0]\n", + "dset_test = loader.dataset\n", + "label_names = dset_test.label_names" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "start_time": "2020-03-14T07:09:05.300Z" + } + }, + "outputs": [], + "source": [ + "x_rows, y_rows = dset_test.iloc(10)\n", + "x_rows.loc[x_rows.index[model.hparams.window_length:], dset_test.label_names] = 0.\n", + "x_rows" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "start_time": "2020-03-14T07:09:05.300Z" + } + }, + "outputs": [], + "source": [ + "x_rows.loc[x_rows.index[model.hparams.window_length:]]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "start_time": "2020-03-14T07:09:05.300Z" + } + }, + "outputs": [], + "source": [ + "self=dset_test\n", + "idx=10\n", + "k = idx + self.hparams.window_length + self.hparams.target_length\n", + "j = k - self.hparams.target_length\n", + "i = j - self.hparams.window_length\n", + "idx, k, j, i, self.hparams.window_length + self.hparams.target_length" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "start_time": "2020-03-14T07:09:05.300Z" + } + }, + "outputs": [], + "source": [ + "j-i" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "start_time": "2020-03-14T07:09:05.300Z" + } + }, + "outputs": [], + "source": [ + "self.hparams.window_length + self.hparams.target_length" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "file_extension": ".py", + "kernelspec": { + "display_name": "jup3.7.3", + "language": "python", + "name": "jup3.7.3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.3" + }, + "mimetype": "text/x-python", + "name": "python", + "npconvert_exporter": "python", + "pygments_lexer": "ipython3", + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": { + "height": "calc(100% - 180px)", + "left": "10px", + "top": "150px", + "width": "384px" + }, + "toc_section_display": true, + "toc_window_display": true + }, + "version": 3 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/src/data/smart_meter.py b/src/data/smart_meter.py index 1bb9949..80456b0 100644 --- a/src/data/smart_meter.py +++ b/src/data/smart_meter.py @@ -48,7 +48,7 @@ def collate_fns(max_num_context, max_num_extra_target, sample, sort=True, contex ) # do we want to compute loss over context+target_extra, or focus in on only target_extra? - if context_in_target: + if context_in_target is True: x_target = torch.cat([x_context, x_target_extra], 1) y_target = torch.cat([y_context, y_target_extra], 1) else: diff --git a/src/models/transformer_seq2seq.py b/src/models/transformer_seq2seq.py new file mode 100644 index 0000000..c90c02c --- /dev/null +++ b/src/models/transformer_seq2seq.py @@ -0,0 +1,272 @@ +import os +import numpy as np +import pandas as pd +import torch +from tqdm.auto import tqdm +from torch import nn +from torch.nn import functional as F +from torch.utils.data import DataLoader +from torchvision.datasets import MNIST +from test_tube import Experiment, HyperOptArgumentParser +from src.data.smart_meter import collate_fns, SmartMeterDataSet, get_smartmeter_df +import torchvision.transforms as transforms +from src.plot import plot_from_loader_to_tensor, plot_from_loader +from argparse import ArgumentParser +import json +import pytorch_lightning as pl +import math +from matplotlib import pyplot as plt +import torch +import io +import PIL +from torchvision.transforms import ToTensor + +from src.data.smart_meter import get_smartmeter_df + +from src.utils import ObjectDict + +def log_prob_sigma(value, loc, log_scale): + """A slightly more stable (not confirmed yet) log prob taking in log_var instead of scale. + modified from https://github.com/pytorch/pytorch/blob/2431eac7c011afe42d4c22b8b3f46dedae65e7c0/torch/distributions/normal.py#L65 + """ + var = torch.exp(log_scale * 2) + return ( + -((value - loc) ** 2) / (2 * var) - log_scale - math.log(math.sqrt(2 * math.pi)) + ) + + +class TransformerSeq2SeqNet(nn.Module): + def __init__(self, hparams, _min_std = 0.05): + super().__init__() + self.hparams = hparams + self._min_std = _min_std + + # TODO project to 8*nhead + hidden_out_size = self.hparams.hidden_out_size + self.enc_emb = nn.Linear(self.hparams.input_size, hidden_out_size) + layer_enc = nn.TransformerEncoderLayer( + d_model=hidden_out_size, + dim_feedforward=self.hparams.hidden_size, + dropout=self.hparams.attention_dropout, + nhead=self.hparams.nhead, + # activation + ) + self.encoder = nn.TransformerEncoder( + layer_enc, + num_layers=self.hparams.nlayers, + ) + + + self.dec_emb = nn.Linear(self.hparams.input_size_decoder, hidden_out_size) + layer_dec = nn.TransformerDecoderLayer( + d_model=hidden_out_size, + dim_feedforward=self.hparams.hidden_size, + dropout=self.hparams.attention_dropout, + nhead=self.hparams.nhead, + ) + self.decoder = nn.TransformerDecoder( + layer_dec, + num_layers=self.hparams.nlayers, + ) + self.mean = nn.Linear(hidden_out_size, self.hparams.output_size) + self.std = nn.Linear(hidden_out_size, self.hparams.output_size) + + def forward(self, context_x, context_y, target_x, target_y=None): + x = torch.cat([context_x, context_y], -1) + # Size([B, C, input_dim]) + x = self.enc_emb(x) + # Size([B, C, emb_dim]) + memory = self.encoder(x) + # Size([B, C, emb_dim]) + target_x = self.dec_emb(target_x) + # Size([B, T, input_target_dim]) -> Size([B, T, emb_dim]) + + # In transformers the memory and target_x need to be the same length. Lets use a permutation invariant agg on the context + # Then expand it, so it's available as we decode, conditional on target_x + memory = memory.mean(dim=1, keepdim=True).expand_as(target_x) + + outputs = self.decoder(target_x, memory) + # Size([B, T, emb_dim]) + mean = self.mean(outputs) + log_sigma = self.std(outputs) + log_sigma = torch.clamp(log_sigma, math.log(self._min_std), -math.log(self._min_std)) + + sigma = torch.exp(log_sigma) + y_dist=torch.distributions.Normal(mean, sigma) + + # Loss + loss_mse = loss_p = None + if target_y is not None: + loss_mse = F.mse_loss(mean, target_y, reduction='none') + loss_p = -log_prob_sigma(target_y, mean, log_sigma) + + if self.hparams["context_in_target"]: + loss_p[:context_x.size(1)] /= 100 + loss_mse[:context_x.size(1)] /= 100 + # # Don't catch loss on context window + # mean = mean[:, self.hparams.num_context:] + # log_sigma = log_sigma[:, self.hparams.num_context:] + + y_pred = y_dist.rsample if self.training else y_dist.loc + return y_pred, dict(loss_p=loss_p.mean(), loss_mse=loss_mse.mean()), dict(log_sigma=log_sigma, dist=y_dist) + + +class TransformerSeq2Seq_PL(pl.LightningModule): + def __init__(self, hparams): + # TODO make label name configurable + # TODO make data source configurable + super().__init__() + self.hparams = ObjectDict() + self.hparams.update( + hparams.__dict__ if hasattr(hparams, "__dict__") else hparams + ) + self.model = TransformerSeq2SeqNet(self.hparams) + self._dfs = None + + def forward(self, context_x, context_y, target_x, target_y): + return self.model(context_x, context_y, target_x, target_y) + + def training_step(self, batch, batch_idx): + # REQUIRED + assert all(torch.isfinite(d).all() for d in batch) + context_x, context_y, target_x, target_y = batch + y_dist, losses, extra = self.forward(context_x, context_y, target_x, target_y) + loss = losses['loss_p'] # + loss_mse + tensorboard_logs = { + "train/loss": loss, + 'train/loss_mse': losses['loss_mse'], + "train/loss_p": losses['loss_p'], + "train/sigma": torch.exp(extra['log_sigma']).mean()} + return {"loss": loss, "log": tensorboard_logs} + + def validation_step(self, batch, batch_idx): + context_x, context_y, target_x, target_y = batch + assert all(torch.isfinite(d).all() for d in batch) + y_dist, losses, extra = self.forward(context_x, context_y, target_x, target_y) + loss = losses['loss_p'] # + loss_mse + tensorboard_logs = { + "val_loss": loss, + 'val/loss_mse': losses['loss_mse'], + "val/loss_p": losses['loss_p'], + "val/sigma": torch.exp(extra['log_sigma']).mean()} + return {"val_loss": loss, "log": tensorboard_logs} + + def validation_end(self, outputs): + if int(self.hparams["vis_i"]) > 0: + self.show_image() + + avg_loss = torch.stack([x["val_loss"] for x in outputs]).mean() + keys = outputs[0]["log"].keys() + tensorboard_logs = { + k: torch.stack([x["log"][k] for x in outputs if k in x["log"]]).mean() + for k in keys + } + tensorboard_logs_str = {k: f"{v}" for k, v in tensorboard_logs.items()} + print(f"step {self.trainer.global_step}, {tensorboard_logs_str}") + assert torch.isfinite(avg_loss) + return {"avg_val_loss": avg_loss, "log": tensorboard_logs} + + + def show_image(self): + # https://github.com/PytorchLightning/pytorch-lightning/blob/f8d9f8f/pytorch_lightning/core/lightning.py#L293 + loader = self.val_dataloader() + vis_i = min(int(self.hparams["vis_i"]), len(loader.dataset)) + # print('vis_i', vis_i) + if isinstance(self.hparams["vis_i"], str): + image = plot_from_loader(loader, self, i=int(vis_i)) + plt.show() + else: + image = plot_from_loader_to_tensor(loader, self, i=vis_i) + self.logger.experiment.add_image('val/image', image, self.trainer.global_step) + + def test_step(self, *args, **kwargs): + return self.validation_step(*args, **kwargs) + + def test_end(self, *args, **kwargs): + return self.validation_end(*args, **kwargs) + + def configure_optimizers(self): + optim = torch.optim.Adam(self.parameters(), lr=self.hparams["learning_rate"]) + scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau( + optim, patience=2, verbose=True, min_lr=1e-5 + ) # note early stopping has patient 3 + return [optim], [scheduler] + + def _get_cache_dfs(self): + if self._dfs is None: + df_train, df_test = get_smartmeter_df() + # self._dfs = dict(df_train=df_train[:600], df_test=df_test[:600]) + self._dfs = dict(df_train=df_train, df_test=df_test) + return self._dfs + + @pl.data_loader + def train_dataloader(self): + df_train = self._get_cache_dfs()['df_train'] + data_train = SmartMeterDataSet( + df_train, self.hparams["num_context"], self.hparams["num_extra_target"] + ) + return torch.utils.data.DataLoader( + data_train, + batch_size=self.hparams["batch_size"], + shuffle=True, + collate_fn=collate_fns( + self.hparams["num_context"], self.hparams["num_extra_target"], sample=True, context_in_target=self.hparams["context_in_target"] + ), + num_workers=self.hparams["num_workers"], + ) + + @pl.data_loader + def val_dataloader(self): + df_test = self._get_cache_dfs()['df_test'] + data_test = SmartMeterDataSet( + df_test, self.hparams["num_context"], self.hparams["num_extra_target"] + ) + return torch.utils.data.DataLoader( + data_test, + batch_size=self.hparams["batch_size"], + shuffle=False, + collate_fn=collate_fns( + self.hparams["num_context"], self.hparams["num_extra_target"], sample=False, context_in_target=self.hparams["context_in_target"] + ), + ) + + @pl.data_loader + def test_dataloader(self): + df_test = self._get_cache_dfs()['df_test'] + data_test = SmartMeterDataSet( + df_test, self.hparams["num_context"], self.hparams["num_extra_target"] + ) + return torch.utils.data.DataLoader( + data_test, + batch_size=self.hparams["batch_size"], + shuffle=False, + collate_fn=collate_fns( + self.hparams["num_context"], self.hparams["num_extra_target"], sample=False, context_in_target=self.hparams["context_in_target"] + ), + ) + + @staticmethod + def add_model_specific_args(parent_parser): + """ + Specify the hyperparams for this LightningModule + """ + # MODEL specific + parser = HyperOptArgumentParser(parents=[parent_parser]) + parser.add_argument("--learning_rate", default=0.002, type=float) + parser.add_argument("--batch_size", default=16, type=int) + parser.add_argument("--attention_dropout", default=0.5, type=float) + parser.add_argument("--hidden_size", default=16, type=int) + parser.add_argument("--hidden_out_size", default=16, type=int) + parser.add_argument("--input_size", default=8, type=int) + parser.add_argument("--nhead", default=8, type=int) + parser.add_argument("--input_size_decoder", default=8, type=int) + parser.add_argument("--nlayers", default=8, type=int) + # parser.add_argument("--bidirectional", default=False, type=bool) + + # training specific (for this model) + parser.add_argument("--num_context", type=int, default=12) + parser.add_argument("--num_extra_target", type=int, default=2) + parser.add_argument("--max_nb_epochs", default=10, type=int) + parser.add_argument("--num_workers", default=4, type=int) + + return parser diff --git a/src/plot.py b/src/plot.py index e0ade0e..19ceb70 100644 --- a/src/plot.py +++ b/src/plot.py @@ -107,12 +107,14 @@ def plot_from_loader( x_target_extra_rows = x_rows[max_num_context:] dt = y_target_extra_rows.index[0] - # # for the plotting we are doing to run prediction on the context points too - if not context_in_target: - target_x = torch.cat([context_x, target_x_extra], 1) - target_y = torch.cat([context_y, target_y_extra], 1) - y_target_rows = y_rows - x_target_rows = x_rows + if context_in_target: + y_target_rows = y_rows + x_target_rows = x_rows + else: + y_target_rows = y_target_extra_rows + x_target_rows = x_target_extra_rows + # target_x = torch.cat([context_x, target_x_extra], 1) + # target_y = torch.cat([context_y, target_y_extra], 1) model.eval() with torch.no_grad(): diff --git a/src/utils.py b/src/utils.py index caadf0b..62acdcd 100644 --- a/src/utils.py +++ b/src/utils.py @@ -1,3 +1,46 @@ +from pytorch_lightning.callbacks import EarlyStopping +from optuna.integration.pytorch_lightning import _check_pytorch_lightning_availability + +class PyTorchLightningPruningCallback(EarlyStopping): + """Optuna PyTorch Lightning callback to prune unpromising trials. + Example: + Add a pruning callback which observes validation accuracy. + .. code:: + trainer.pytorch_lightning.Trainer( + early_stop_callback=PyTorchLightningPruningCallback(trial, monitor='avg_val_acc')) + Args: + trial: + A :class:`~optuna.trial.Trial` corresponding to the current evaluation of the + objective function. + monitor: + An evaluation metric for pruning, e.g., ``val_loss`` or + ``val_acc``. The metrics are obtained from the returned dictionaries from e.g. + ``pytorch_lightning.LightningModule.training_step`` or + ``pytorch_lightning.LightningModule.validation_end`` and the names thus depend on + how this dictionary is formatted. + """ + + def __init__(self, trial, monitor): + # type: (optuna.trial.Trial, str) -> None + + super(PyTorchLightningPruningCallback, self).__init__(monitor) + + _check_pytorch_lightning_availability() + + self._trial = trial + self._monitor = monitor + + def on_epoch_end(self, trainer, pl_module): + epoch = trainer.current_epoch + logs = trainer.callback_metrics or {} + current_score = logs.get(self._monitor) + if current_score is None: + return + self._trial.report(current_score, step=epoch) + if self._trial.should_prune(): + message = "Trial was pruned at epoch {}.".format(epoch) + raise optuna.exceptions.TrialPruned(message) + class ObjectDict(dict): """ Interface similar to an argparser @@ -18,3 +61,5 @@ class ObjectDict(dict): @property def __dict__(self): return dict(self) + +