diff --git a/0.4-mc-smartmeters-autoregtransformer.ipynb b/0.4-mc-smartmeters-autoregtransformer.ipynb new file mode 100644 index 0000000..8c445b1 --- /dev/null +++ b/0.4-mc-smartmeters-autoregtransformer.ipynb @@ -0,0 +1,1150 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# auto regressive transformer https://fast-transformers.github.io/" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "ExecuteTime": { + "end_time": "2020-07-12T03:02:14.247046Z", + "start_time": "2020-07-12T03:02:13.787175Z" + } + }, + "outputs": [], + "source": [ + "# OPTIONAL: Load the \"autoreload\" extension so that code can change. But blacklist large modules\n", + "%load_ext autoreload\n", + "%autoreload 2\n", + "%aimport -pandas\n", + "%aimport -torch\n", + "%aimport -numpy\n", + "%aimport -matplotlib\n", + "%aimport -dask\n", + "%aimport -functools\n", + "%aimport -tqdm\n", + "%aimport -pytorch_lightning\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "ExecuteTime": { + "end_time": "2020-07-12T03:02:16.959533Z", + "start_time": "2020-07-12T03:02:14.250015Z" + } + }, + "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 optuna\n", + "import pytorch_lightning as pl\n", + "from optuna.integration import PyTorchLightningPruningCallback\n", + "\n", + "\n", + "import math\n", + "%matplotlib inline\n", + "%reload_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "ExecuteTime": { + "end_time": "2020-07-12T03:02:17.065392Z", + "start_time": "2020-07-12T03:02:16.965142Z" + } + }, + "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-07-12T03:02:17.452085Z", + "start_time": "2020-07-12T03:02:17.070868Z" + } + }, + "outputs": [], + "source": [ + "\n", + "from neural_processes.data.smart_meter import collate_fns, SmartMeterDataSet, get_smartmeter_df\n", + "from neural_processes.plot import plot_from_loader\n", + "\n", + "from neural_processes.dict_logger import DictLogger\n", + "from neural_processes.utils import PyTorchLightningPruningCallback\n", + "from neural_processes.train import main, objective, add_number, run_trial\n", + "\n", + "from neural_processes.models.neural_process.lightning import PL_NP, PL_ANP, PL_ANPRNN\n", + "\n", + "from neural_processes.models.transformer import PL_Transformer\n", + "from neural_processes.models.transformer_seq2seq import TransformerSeq2Seq_PL\n", + "from neural_processes.models.transformer_seq2seq_autor import TransformerSeq2SeqAutoR_PL\n", + "\n", + "from neural_processes.models.lstm_seqseq import LSTMSeq2Seq_PL\n", + "from neural_processes.models.lstm_std import LSTM_PL_STD" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "ExecuteTime": { + "end_time": "2020-07-12T03:02:17.552778Z", + "start_time": "2020-07-12T03:02:17.454870Z" + } + }, + "outputs": [], + "source": [ + "# Params\n", + "device='cuda'\n", + "use_logy=False" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "ExecuteTime": { + "end_time": "2020-07-12T03:02:17.685045Z", + "start_time": "2020-07-12T03:02:17.555986Z" + } + }, + "outputs": [], + "source": [ + "import logging\n", + "logging.basicConfig(stream=sys.stdout, level=logging.INFO)\n", + "logger = logging.getLogger(\"autoregt.ipynb\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Load kaggle smart meter data" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "ExecuteTime": { + "end_time": "2020-07-12T03:02:18.246949Z", + "start_time": "2020-07-12T03:02:17.689292Z" + } + }, + "outputs": [], + "source": [ + "df_train, df_val, df_test = get_smartmeter_df(\n", + "# indir=Path('./data/smart-meters-in-london'), \n", + "# use_logy=False, \n", + "# max_files=40\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "ExecuteTime": { + "end_time": "2020-07-12T03:02:18.393680Z", + "start_time": "2020-07-12T03:02:18.249472Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[torch.Size([1, 7, 17]),\n", + " torch.Size([1, 7, 1]),\n", + " torch.Size([1, 15, 17]),\n", + " torch.Size([1, 15, 1])]" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data_train = SmartMeterDataSet(\n", + " df_train, 10, 20)\n", + "b = data_train[10]\n", + "b = collate_fns(10, 20, sample=True)([b])\n", + "[bb.shape for bb in b]" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "ExecuteTime": { + "end_time": "2020-07-12T03:02:22.573372Z", + "start_time": "2020-07-12T03:02:18.395713Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "for name,g in df_train.groupby('block'):\n", + " g['energy(kWh/hh)'].resample('D').mean().plot(ax=plt.gca(), ylim=[0,2])\n", + "plt.title('train')\n", + "plt.ylabel('energy(kWh/hh) mean daily usage')\n", + "plt.show()\n", + "\n", + "plt.figure()\n", + "for name,g in df_val.groupby('block'):\n", + " g['energy(kWh/hh)'].resample('D').mean().plot(ax=plt.gca(), ylim=[0,2])\n", + "plt.title('val')\n", + "plt.ylabel('energy(kWh/hh) mean daily usage')\n", + "plt.show()\n", + "\n", + "plt.figure()\n", + "for name,g in df_test.groupby('block'):\n", + " g['energy(kWh/hh)'].resample('D').mean().plot(ax=plt.gca(), ylim=[0,2])\n", + "plt.title('test')\n", + "plt.ylabel('energy(kWh/hh) mean daily usage')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "ExecuteTime": { + "end_time": "2020-07-12T03:02:22.700106Z", + "start_time": "2020-07-12T03:02:22.575619Z" + } + }, + "outputs": [], + "source": [ + "# df_train[['energy(kWh/hh)']].resample('30T').mean().plot(title='train', ylim=[0,3])\n", + "# df_val[['energy(kWh/hh)']].resample('30T').mean().plot(title='val', ylim=[0,3])\n", + "# df_test[['energy(kWh/hh)']].resample('30T').mean().plot(title='test', ylim=[0,3])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# MODEL (move to src)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "ExecuteTime": { + "end_time": "2020-07-12T03:02:22.839162Z", + "start_time": "2020-07-12T03:02:22.702621Z" + }, + "scrolled": true + }, + "outputs": [], + "source": [ + "import fast_transformers\n", + "from fast_transformers.builders import TransformerEncoderBuilder\n", + "# hidden=16\n", + "# n_heads=4\n", + "# encoder = fast_transformers.builders.TransformerEncoderBuilder.from_kwargs(\n", + "# attention_type=\"full\",\n", + "# n_layers=6,\n", + "# n_heads=n_heads,\n", + "# feed_forward_dimensions=hidden*4,\n", + "# query_dimensions=hidden//n_heads,\n", + "# value_dimensions=hidden//n_heads,\n", + "# activation=\"gelu\"\n", + "# ).get()\n", + "# x = torch.rand((10, 100, 16))\n", + "# print(encoder)\n", + "# encoder(x)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "ExecuteTime": { + "end_time": "2020-07-12T03:02:23.144605Z", + "start_time": "2020-07-12T03:02:22.842266Z" + } + }, + "outputs": [], + "source": [ + "import os\n", + "import numpy as np\n", + "import pandas as pd\n", + "import torch\n", + "from tqdm.auto import tqdm\n", + "from torch import nn\n", + "from torch.nn import functional as F\n", + "from torch.utils.data import DataLoader\n", + "from torchvision.datasets import MNIST\n", + "from test_tube import Experiment, HyperOptArgumentParser\n", + "from neural_processes.data.smart_meter import (\n", + " collate_fns,\n", + " SmartMeterDataSet,\n", + " get_smartmeter_df,\n", + ")\n", + "import torchvision.transforms as transforms\n", + "from neural_processes.plot import plot_from_loader_to_tensor, plot_from_loader\n", + "from argparse import ArgumentParser\n", + "import json\n", + "import pytorch_lightning as pl\n", + "import math\n", + "from matplotlib import pyplot as plt\n", + "import torch\n", + "import io\n", + "import PIL\n", + "import optuna\n", + "from torchvision.transforms import ToTensor\n", + "\n", + "from neural_processes.data.smart_meter import get_smartmeter_df\n", + "from neural_processes.modules import BatchNormSequence, LSTMBlock, NPBlockRelu2d\n", + "\n", + "from neural_processes.utils import ObjectDict\n", + "from neural_processes.lightning import PL_Seq2Seq\n", + "from neural_processes.logger import logger\n", + "from neural_processes.utils import hparams_power\n", + "\n", + "\n", + "class TransformerSeq2SeqAutoRNet(nn.Module):\n", + " def __init__(self, hparams):\n", + " super().__init__()\n", + " hparams = hparams_power(hparams)\n", + " self.hparams = hparams\n", + " self._min_std = hparams.min_std\n", + "\n", + " hidden_out_size = self.hparams.hidden_out_size\n", + " y_size = self.hparams.input_size - self.hparams.input_size_decoder\n", + " x_size = self.hparams.input_size_decoder\n", + "\n", + " # Sometimes input normalisation can be important, an initial batch norm is a nice way to ensure this https://stackoverflow.com/a/46772183/221742\n", + " self.x_norm = BatchNormSequence(x_size, affine=False)\n", + " self.y_norm = BatchNormSequence(y_size, affine=False)\n", + "\n", + " # TODO embedd both X's the same\n", + " if self.hparams.get('use_lstm', False): \n", + " self.x_emb = LSTMBlock(x_size, x_size)\n", + " self.y_emb = LSTMBlock(y_size, y_size)\n", + " \n", + " n_heads = self.hparams.nhead\n", + " self.enc_emb = nn.Linear(self.hparams.input_size, hidden_out_size*n_heads)\n", + "# print(-1, self.hparams.input_size, hidden_out_size)\n", + " self.dec_emb = nn.Linear(self.hparams.input_size_decoder, hidden_out_size*n_heads)\n", + " \n", + " \n", + " self.encoder = fast_transformers.builders.TransformerEncoderBuilder.from_kwargs(\n", + " attention_type=\"full\",\n", + " n_layers=self.hparams.nlayers,\n", + " n_heads=n_heads,\n", + " feed_forward_dimensions=hidden_out_size*4,\n", + " query_dimensions=hidden_out_size,\n", + " value_dimensions=hidden_out_size,\n", + " activation=\"gelu\",\n", + " attention_dropout=self.hparams.attention_dropout,\n", + " dropout=self.hparams.dropout,\n", + " ).get()\n", + " \n", + " hidden_out_size *= 2\n", + " self.decoder = fast_transformers.builders.TransformerEncoderBuilder.from_kwargs(\n", + " attention_type=\"improved-causal\",\n", + " n_layers=self.hparams.nlayers,\n", + " n_heads=n_heads,\n", + " feed_forward_dimensions=hidden_out_size*4,\n", + " query_dimensions=hidden_out_size,\n", + " value_dimensions=hidden_out_size,\n", + " activation=\"gelu\",\n", + " attention_dropout=self.hparams.attention_dropout,\n", + " dropout=self.hparams.dropout,\n", + " ).get()\n", + " self.mean = NPBlockRelu2d(hidden_out_size, self.hparams.output_size)\n", + " self.std = NPBlockRelu2d(hidden_out_size, self.hparams.output_size)\n", + "\n", + " def forward(self, context_x, context_y, target_x, target_y=None, mask_context=True, mask_target=True):\n", + " device = next(self.parameters()).device\n", + "\n", + " # Norm\n", + " context_x = self.x_norm(context_x)\n", + " target_x = self.x_norm(target_x)\n", + " context_y = self.y_norm(context_y)\n", + "\n", + " # LSTM\n", + " if self.hparams.get('use_lstm', False): \n", + " context_x = self.x_emb(context_x)\n", + " target_x = self.x_emb(target_x)\n", + " # Size([B, C, X]) -> Size([B, C, X])\n", + " context_y = self.y_emb(context_y)\n", + " # Size([B, T, Y]) -> Size([B, T, Y])\n", + "\n", + " # Embed\n", + " x = torch.cat([context_x, context_y], -1)\n", + " x = self.enc_emb(x)\n", + " # Size([B, C, X]) -> Size([B, C, hidden_dim])\n", + " target_x = self.dec_emb(target_x)\n", + " # Size([B, C, T]) -> Size([B, C, hidden_dim])\n", + " \n", + " # requires (B, C, hidden_dim)\n", + " memory = self.encoder(x)\n", + "\n", + " # In transformers the memory and target_x need to be the same length. Lets use a permutation invariant agg on the context\n", + " # Then expand it, so it's available as we decode, conditional on target_x\n", + " # (C, B, emb_dim) -> (B, emb_dim) -> (T, B, emb_dim)\n", + " # In transformers the memory and target_x need to be the same length. Lets use a permutation invariant agg on the context\n", + " # Then expand it, so it's available as we decode, conditional on target_x\n", + " memory = memory_last = memory[:, -1:, :].expand_as(target_x)\n", + " x2 = torch.cat([target_x, memory], -1)\n", + " N = x2.shape[0]\n", + " mask = fast_transformers.masking.TriangularCausalMask(N, device=device)\n", + " outputs = self.decoder(x2, attn_mask=mask)\n", + " \n", + " # Size([B, T, emb_dim])\n", + " mean = self.mean(outputs)\n", + " log_sigma = self.std(outputs)\n", + " sigma = self._min_std + (1 - self._min_std) * F.softplus(log_sigma)\n", + " y_dist = torch.distributions.Normal(mean, sigma)\n", + "\n", + " # Loss\n", + " loss_mse = loss_p = loss_p_weighted = None\n", + " if target_y is not None:\n", + " loss_mse = F.mse_loss(mean, target_y, reduction=\"none\")\n", + " loss_p = -y_dist.log_prob(target_y).mean(-1)\n", + "\n", + " # Weight loss nearer to prediction time?\n", + " weight = (torch.arange(loss_p.shape[1]) + 1).float().to(device)[None, :]\n", + " loss_p_weighted = loss_p / torch.sqrt(weight) # We want to weight nearer stuff more\n", + "\n", + " y_pred = y_dist.rsample if self.training else y_dist.loc\n", + " return (\n", + " y_pred,\n", + " dict(loss=loss_p.mean(), loss_p=loss_p.mean(), loss_mse=loss_mse.mean(), loss_p_weighted=loss_p_weighted.mean()),\n", + " dict(log_sigma=log_sigma, y_dist=y_dist),\n", + " )\n", + "\n", + "\n", + "class TransformerSeq2SeqAutoR_PL(PL_Seq2Seq):\n", + " def __init__(self, hparams, MODEL_CLS=TransformerSeq2SeqAutoRNet, **kwargs):\n", + " super().__init__(hparams, MODEL_CLS=MODEL_CLS, **kwargs)\n", + "\n", + " DEFAULT_ARGS = {\n", + " \"attention_dropout\": 0.2,\n", + " \"dropout\": 0.2,\n", + " \"hidden_out_size_power\": 4,\n", + " \"hidden_size_power\": 5,\n", + " \"learning_rate\": 2e-3,\n", + " \"nhead_power\": 3,\n", + " \"nlayers\": 6,\n", + " \"use_lstm\": False\n", + " }\n", + "\n", + " @staticmethod\n", + " def add_suggest(trial: optuna.Trial, user_attrs={}):\n", + " \"\"\"\n", + " Add hyperparam ranges to an optuna trial and typical user attrs.\n", + " \n", + " Usage:\n", + " trial = optuna.trial.FixedTrial(\n", + " params={ \n", + " 'hidden_size': 128,\n", + " }\n", + " )\n", + " trial = add_suggest(trial)\n", + " trainer = pl.Trainer()\n", + " model = LSTM_PL(dict(**trial.params, **trial.user_attrs), dataset_train,\n", + " dataset_test, cache_base_path, norm)\n", + " trainer.fit(model)\n", + " \"\"\"\n", + " trial.suggest_loguniform(\"learning_rate\", 1e-6, 1e-2)\n", + " trial.suggest_uniform(\"attention_dropout\", 0, 0.75)\n", + " trial.suggest_uniform(\"dropout\", 0, 0.75)\n", + " # we must have nhead<==hidden_size\n", + " # so nhead_power.max()<==hidden_size_power.min()\n", + " trial.suggest_discrete_uniform(\"hidden_size_power\", 4, 10, 1)\n", + " trial.suggest_discrete_uniform(\"hidden_out_size_power\", 4, 9, 1)\n", + " trial.suggest_discrete_uniform(\"nhead_power\", 1, 4, 1)\n", + " trial.suggest_int(\"nlayers\", 1, 12)\n", + " trial.suggest_categorical(\"use_lstm\", [False, True])\n", + "\n", + " user_attrs_default = {\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", + " \"output_size\": 1,\n", + " \"patience\": 3,\n", + " 'min_std': 0.005,\n", + " }\n", + " [trial.set_user_attr(k, v) for k, v in user_attrs_default.items()]\n", + " [trial.set_user_attr(k, v) for k, v in user_attrs.items()]\n", + " return trial\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2020-04-11T01:56:38.106876Z", + "start_time": "2020-04-11T01:56:38.100361Z" + } + }, + "source": [ + "# Experiments" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "ExecuteTime": { + "end_time": "2020-07-12T03:02:23.253413Z", + "start_time": "2020-07-12T03:02:23.146832Z" + } + }, + "outputs": [], + "source": [ + "# Summarize results\n", + "\n", + "\n", + "def summarize_results(results):\n", + " result_dfs = []\n", + " for k in results:\n", + " v = results[k]\n", + " df = pd.DataFrame(v).mean()\n", + " df.name = k+'_mean'\n", + " df['n'] = len(v)\n", + " result_dfs.append(df)\n", + "\n", + "# df = pd.DataFrame(v).std()\n", + "# df.name = k+'_std'\n", + "# df['n'] = len(v)\n", + "# result_dfs.append(df)\n", + "\n", + " if len(result_dfs)==0:\n", + " return None\n", + " result_df = pd.concat(result_dfs, 1).T\n", + " \n", + " return result_df.sort_values('agg_test_score').T" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "ExecuteTime": { + "end_time": "2020-07-12T03:02:23.366433Z", + "start_time": "2020-07-12T03:02:23.255794Z" + } + }, + "outputs": [], + "source": [ + "default_user_attrs = {\n", + " 'x_dim': 17,\n", + " 'y_dim': 1,\n", + " 'vis_i': '670',\n", + " 'num_workers': 3,\n", + " 'num_context': 48 * 7,\n", + " 'num_extra_target': 48 * 2,\n", + " 'max_nb_epochs': 20,\n", + " 'min_std': 0.005,\n", + " 'grad_clip': 40,\n", + " 'batch_size': 24,\n", + " 'patience': 2,\n", + " 'max_epoch_steps': 32 * 600,\n", + "}\n", + "N = 3\n", + "\n", + "experiments = [\n", + " dict(\n", + " name=\"TransformerSeq2SeqAutoR_PL\",\n", + " PL_MODEL_CLS=TransformerSeq2SeqAutoR_PL,\n", + " ),\n", + "]\n", + "number = -1\n", + "results = collections.defaultdict(list)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "ExecuteTime": { + "end_time": "2020-07-12T03:02:29.662925Z", + "start_time": "2020-07-12T03:02:23.369468Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:predict_heading2:now run `tensorboard --logdir lightning_logs`\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "EarlyStopping mode auto is unknown, fallback to auto mode.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:lightning:EarlyStopping mode auto is unknown, fallback to auto mode.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "EarlyStopping mode set to min for monitoring val_loss.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:lightning:EarlyStopping mode set to min for monitoring val_loss.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True, used: True\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:lightning:GPU available: True, used: True\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "TPU available: False, using: 0 TPU cores\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:lightning:TPU available: False, using: 0 TPU cores\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "CUDA_VISIBLE_DEVICES: [0]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:lightning:CUDA_VISIBLE_DEVICES: [0]\n", + "INFO:predict_heading2:trial number=-1000 name=TransformerSeq2SeqAutoR_PL, trial= params={'learning_rate': 0.002, 'attention_dropout': 0.2, 'dropout': 0.2, 'hidden_size_power': 5, 'hidden_out_size_power': 4, 'nhead_power': 3, 'nlayers': 6, 'use_lstm': False} attrs={'batch_size': 24, 'grad_clip': 40, 'max_nb_epochs': 20, 'num_workers': 3, 'num_extra_target': 96, 'vis_i': '670', 'num_context': 336, 'input_size': 18, 'input_size_decoder': 17, 'output_size': 1, 'patience': 2, 'min_std': 0.005, 'x_dim': 17, 'y_dim': 1, 'max_epoch_steps': 19200}\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + " | Name | Type | Params\n", + "------------------------------------------------------\n", + "0 | _model | TransformerSeq2SeqAutoRNet | 2 M \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:lightning:\n", + " | Name | Type | Params\n", + "------------------------------------------------------\n", + "0 | _model | TransformerSeq2SeqAutoRNet | 2 M \n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "67c792ca027a4c378d493c2aff5e31da", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=1.0, bar_style='info', description='Validation sanity check', layout=Layout…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "ename": "RuntimeError", + "evalue": "start (0) + length (100) exceeds dimension size (96). (narrow at /pytorch/aten/src/ATen/native/TensorShape.cpp:412)\nframe #0: c10::Error::Error(c10::SourceLocation, std::string const&) + 0x33 (0x7fec2237f813 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/lib/python3.7/site-packages/torch/lib/libc10.so)\nframe #1: at::native::narrow(at::Tensor const&, long, long, long) + 0x3b7 (0x7fec2434be77 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/lib/python3.7/site-packages/torch/lib/libtorch.so)\nframe #2: + 0x1e65109 (0x7fec24637109 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/lib/python3.7/site-packages/torch/lib/libtorch.so)\nframe #3: + 0x37c6966 (0x7fec25f98966 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/lib/python3.7/site-packages/torch/lib/libtorch.so)\nframe #4: + 0x1d6f976 (0x7fec24541976 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/lib/python3.7/site-packages/torch/lib/libtorch.so)\nframe #5: at::Tensor::narrow(long, long, long) const + 0xf7 (0x7fec685d8187 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/lib/python3.7/site-packages/torch/lib/libtorch_python.so)\nframe #6: cluster(at::Tensor, at::Tensor, at::Tensor, at::Tensor, at::Tensor, at::Tensor, at::Tensor, int, int) + 0x13c (0x7fec1ac692d8 in /media/oldhome/wassname/Opt/fast-transformers2/fast_transformers/clustering/hamming/cluster_cuda.cpython-37m-x86_64-linux-gnu.so)\nframe #7: + 0x5890f (0x7fec1ac8f90f in /media/oldhome/wassname/Opt/fast-transformers2/fast_transformers/clustering/hamming/cluster_cuda.cpython-37m-x86_64-linux-gnu.so)\nframe #8: + 0x5566c (0x7fec1ac8c66c in /media/oldhome/wassname/Opt/fast-transformers2/fast_transformers/clustering/hamming/cluster_cuda.cpython-37m-x86_64-linux-gnu.so)\nframe #9: + 0x50dab (0x7fec1ac87dab in /media/oldhome/wassname/Opt/fast-transformers2/fast_transformers/clustering/hamming/cluster_cuda.cpython-37m-x86_64-linux-gnu.so)\nframe #10: + 0x512bc (0x7fec1ac882bc in /media/oldhome/wassname/Opt/fast-transformers2/fast_transformers/clustering/hamming/cluster_cuda.cpython-37m-x86_64-linux-gnu.so)\nframe #11: + 0x3fa92 (0x7fec1ac76a92 in /media/oldhome/wassname/Opt/fast-transformers2/fast_transformers/clustering/hamming/cluster_cuda.cpython-37m-x86_64-linux-gnu.so)\nframe #12: _PyCFunction_FastCallKeywords + 0x431 (0x43d1d1 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #13: _PyEval_EvalFrameDefault + 0x8803 (0x429c83 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #14: _PyEval_EvalCodeWithName + 0xa17 (0x4f26c7 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #15: _PyFunction_FastCallKeywords + 0xa5 (0x43c565 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #16: _PyEval_EvalFrameDefault + 0x6f78 (0x4283f8 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #17: /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7() [0x420308]\nframe #18: _PyEval_EvalFrameDefault + 0x7655 (0x428ad5 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #19: /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7() [0x420308]\nframe #20: _PyFunction_FastCallDict + 0x2be (0x43c4ae in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #21: _PyObject_Call_Prepend + 0x259 (0x43fcc9 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #22: PyObject_Call + 0x70 (0x43da20 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #23: _PyEval_EvalFrameDefault + 0x2fac (0x42442c in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #24: _PyEval_EvalCodeWithName + 0xa17 (0x4f26c7 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #25: _PyFunction_FastCallDict + 0x116 (0x43c306 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #26: _PyObject_Call_Prepend + 0x259 (0x43fcc9 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #27: /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7() [0x497a45]\nframe #28: _PyObject_FastCallKeywords + 0x141 (0x43cb71 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #29: _PyEval_EvalFrameDefault + 0x5f4f (0x4273cf in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #30: _PyEval_EvalCodeWithName + 0xa17 (0x4f26c7 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #31: _PyFunction_FastCallDict + 0x1ff (0x43c3ef in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #32: _PyObject_Call_Prepend + 0x259 (0x43fcc9 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #33: PyObject_Call + 0x70 (0x43da20 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #34: _PyEval_EvalFrameDefault + 0x2fac (0x42442c in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #35: _PyEval_EvalCodeWithName + 0xa17 (0x4f26c7 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #36: _PyFunction_FastCallDict + 0x1ff (0x43c3ef in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #37: _PyObject_Call_Prepend + 0x259 (0x43fcc9 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #38: /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7() [0x497a45]\nframe #39: _PyObject_FastCallKeywords + 0x141 (0x43cb71 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #40: _PyEval_EvalFrameDefault + 0x30ee (0x42456e in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #41: _PyEval_EvalCodeWithName + 0xa17 (0x4f26c7 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #42: _PyFunction_FastCallDict + 0x1ff (0x43c3ef in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #43: _PyObject_Call_Prepend + 0x259 (0x43fcc9 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #44: PyObject_Call + 0x70 (0x43da20 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #45: _PyEval_EvalFrameDefault + 0x2fac (0x42442c in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #46: _PyEval_EvalCodeWithName + 0xa17 (0x4f26c7 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #47: _PyFunction_FastCallDict + 0x1ff (0x43c3ef in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #48: _PyObject_Call_Prepend + 0x259 (0x43fcc9 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #49: /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7() [0x497a45]\nframe #50: _PyObject_FastCallKeywords + 0x141 (0x43cb71 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #51: _PyEval_EvalFrameDefault + 0x30ee (0x42456e in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #52: _PyEval_EvalCodeWithName + 0xa17 (0x4f26c7 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #53: _PyFunction_FastCallDict + 0x1ff (0x43c3ef in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #54: _PyObject_Call_Prepend + 0x259 (0x43fcc9 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #55: PyObject_Call + 0x70 (0x43da20 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #56: _PyEval_EvalFrameDefault + 0x2fac (0x42442c in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #57: _PyEval_EvalCodeWithName + 0xa17 (0x4f26c7 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #58: _PyFunction_FastCallDict + 0x1ff (0x43c3ef in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #59: _PyObject_Call_Prepend + 0x259 (0x43fcc9 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #60: /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7() [0x497a45]\nframe #61: _PyObject_FastCallKeywords + 0x141 (0x43cb71 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #62: _PyEval_EvalFrameDefault + 0x30ee (0x42456e in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #63: _PyEval_EvalCodeWithName + 0xa17 (0x4f26c7 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\n", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mRuntimeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0muser_attrs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdefault_user_attrs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[0mnumber\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnumber\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0;36m100\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1000\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 10\u001b[0;31m **exp)\n\u001b[0m", + "\u001b[0;32m/media/wassname/Storage5/projects2/3ST/attentive-neural-processes/neural_processes/train.py\u001b[0m in \u001b[0;36mrun_trial\u001b[0;34m(name, PL_MODEL_CLS, params, user_attrs, MODEL_DIR, plot_from_loader, number)\u001b[0m\n\u001b[1;32m 133\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcheckpoints\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m==\u001b[0m\u001b[0;36m0\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0mnumber\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 134\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 135\u001b[0;31m \u001b[0mtrainer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 136\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mKeyboardInterrupt\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 137\u001b[0m \u001b[0mlogger\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwarning\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'KeyboardInterrupt, skipping rest of training'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.pyenv/versions/3.7.2/envs/jup3.7.2/lib/python3.7/site-packages/pytorch_lightning/trainer/trainer.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, model, train_dataloader, val_dataloaders)\u001b[0m\n\u001b[1;32m 1001\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1002\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msingle_gpu\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1003\u001b[0;31m \u001b[0mresults\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msingle_gpu_train\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1004\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1005\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0muse_tpu\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;31m# pragma: no-cover\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.pyenv/versions/3.7.2/envs/jup3.7.2/lib/python3.7/site-packages/pytorch_lightning/trainer/distrib_parts.py\u001b[0m in \u001b[0;36msingle_gpu_train\u001b[0;34m(self, model)\u001b[0m\n\u001b[1;32m 184\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreinit_scheduler_properties\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moptimizers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlr_schedulers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 185\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 186\u001b[0;31m \u001b[0mresults\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun_pretrain_routine\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 187\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mresults\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 188\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.pyenv/versions/3.7.2/envs/jup3.7.2/lib/python3.7/site-packages/pytorch_lightning/trainer/trainer.py\u001b[0m in \u001b[0;36mrun_pretrain_routine\u001b[0;34m(self, model)\u001b[0m\n\u001b[1;32m 1194\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mval_dataloaders\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1195\u001b[0m \u001b[0mmax_batches\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1196\u001b[0;31m False)\n\u001b[0m\u001b[1;32m 1197\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1198\u001b[0m \u001b[0;31m# allow no returns from eval\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.pyenv/versions/3.7.2/envs/jup3.7.2/lib/python3.7/site-packages/pytorch_lightning/trainer/evaluation_loop.py\u001b[0m in \u001b[0;36m_evaluate\u001b[0;34m(self, model, dataloaders, max_batches, test_mode)\u001b[0m\n\u001b[1;32m 291\u001b[0m \u001b[0moutput\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mevaluation_forward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbatch\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbatch_idx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdataloader_idx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtest_mode\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 292\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 293\u001b[0;31m \u001b[0moutput\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mevaluation_forward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbatch\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbatch_idx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdataloader_idx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtest_mode\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 294\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 295\u001b[0m \u001b[0;31m# on dp / ddp2 might still want to do something with the batch parts\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.pyenv/versions/3.7.2/envs/jup3.7.2/lib/python3.7/site-packages/pytorch_lightning/trainer/evaluation_loop.py\u001b[0m in \u001b[0;36mevaluation_forward\u001b[0;34m(self, model, batch, batch_idx, dataloader_idx, test_mode)\u001b[0m\n\u001b[1;32m 468\u001b[0m \u001b[0moutput\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtest_step\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 469\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 470\u001b[0;31m \u001b[0moutput\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalidation_step\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 471\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 472\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0moutput\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/media/wassname/Storage5/projects2/3ST/attentive-neural-processes/neural_processes/lightning.py\u001b[0m in \u001b[0;36mvalidation_step\u001b[0;34m(self, batch, batch_idx)\u001b[0m\n\u001b[1;32m 40\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 41\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mvalidation_step\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbatch\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbatch_idx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 42\u001b[0;31m \u001b[0my_dist\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlosses\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mextra\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mbatch\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 43\u001b[0m \u001b[0mtensorboard_logs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m\"val_\"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mk\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mv\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mk\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mv\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mlosses\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mitems\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 44\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m\"val_loss\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mlosses\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"loss\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"log\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mtensorboard_logs\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/media/wassname/Storage5/projects2/3ST/attentive-neural-processes/neural_processes/lightning.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 29\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 30\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 31\u001b[0;31m \u001b[0my_dist\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlosses\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mextra\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_model\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 32\u001b[0m \u001b[0;32massert\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0misfinite\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlosses\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"loss\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 33\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0my_dist\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlosses\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mextra\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.pyenv/versions/3.7.2/envs/jup3.7.2/lib/python3.7/site-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m 539\u001b[0m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_slow_forward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 540\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 541\u001b[0;31m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 542\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mhook\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_forward_hooks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 543\u001b[0m \u001b[0mhook_result\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mhook\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mresult\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, context_x, context_y, target_x, target_y, mask_context, mask_target)\u001b[0m\n\u001b[1;32m 124\u001b[0m \u001b[0mN\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mx2\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 125\u001b[0m \u001b[0mmask\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfast_transformers\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmasking\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mTriangularCausalMask\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mN\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdevice\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 126\u001b[0;31m \u001b[0moutputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdecoder\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mattn_mask\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmask\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 127\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 128\u001b[0m \u001b[0;31m# Size([B, T, emb_dim])\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.pyenv/versions/3.7.2/envs/jup3.7.2/lib/python3.7/site-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m 539\u001b[0m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_slow_forward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 540\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 541\u001b[0;31m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 542\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mhook\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_forward_hooks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 543\u001b[0m \u001b[0mhook_result\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mhook\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mresult\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/media/oldhome/wassname/Opt/fast-transformers2/fast_transformers/transformers.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, x, attn_mask, length_mask)\u001b[0m\n\u001b[1;32m 129\u001b[0m \u001b[0;31m# Apply all the transformers\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 130\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mlayer\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlayers\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 131\u001b[0;31m \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlayer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mattn_mask\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mattn_mask\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlength_mask\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mlength_mask\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 132\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 133\u001b[0m \u001b[0;31m# Apply the normalization if needed\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.pyenv/versions/3.7.2/envs/jup3.7.2/lib/python3.7/site-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m 539\u001b[0m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_slow_forward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 540\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 541\u001b[0;31m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 542\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mhook\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_forward_hooks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 543\u001b[0m \u001b[0mhook_result\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mhook\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mresult\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/media/oldhome/wassname/Opt/fast-transformers2/fast_transformers/transformers.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, x, attn_mask, length_mask)\u001b[0m\n\u001b[1;32m 75\u001b[0m \u001b[0mattn_mask\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mattn_mask\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 76\u001b[0m \u001b[0mquery_lengths\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mlength_mask\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 77\u001b[0;31m \u001b[0mkey_lengths\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mlength_mask\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 78\u001b[0m ))\n\u001b[1;32m 79\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.pyenv/versions/3.7.2/envs/jup3.7.2/lib/python3.7/site-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m 539\u001b[0m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_slow_forward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 540\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 541\u001b[0;31m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 542\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mhook\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_forward_hooks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 543\u001b[0m \u001b[0mhook_result\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mhook\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mresult\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/media/oldhome/wassname/Opt/fast-transformers2/fast_transformers/attention/attention_layer.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, queries, keys, values, attn_mask, query_lengths, key_lengths)\u001b[0m\n\u001b[1;32m 96\u001b[0m \u001b[0mattn_mask\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 97\u001b[0m \u001b[0mquery_lengths\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 98\u001b[0;31m \u001b[0mkey_lengths\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 99\u001b[0m ).view(N, L, -1)\n\u001b[1;32m 100\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.pyenv/versions/3.7.2/envs/jup3.7.2/lib/python3.7/site-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m 539\u001b[0m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_slow_forward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 540\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 541\u001b[0;31m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 542\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mhook\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_forward_hooks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 543\u001b[0m \u001b[0mhook_result\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mhook\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mresult\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/media/oldhome/wassname/Opt/fast-transformers2/fast_transformers/attention/improved_clustered_causal_attention.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, queries, keys, values, attn_mask, query_lengths, key_lengths)\u001b[0m\n\u001b[1;32m 182\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 183\u001b[0m \u001b[0;31m# Cluster the queries into groups\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 184\u001b[0;31m \u001b[0mclusters\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcounts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_create_query_groups\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mqueries\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mquery_lengths\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 185\u001b[0m \u001b[0mQ_grouped\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_GroupQueries\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mapply\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mqueries\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mclusters\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcounts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 186\u001b[0m \u001b[0;31m# Compute the attention\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/media/oldhome/wassname/Opt/fast-transformers2/fast_transformers/attention/improved_clustered_causal_attention.py\u001b[0m in \u001b[0;36m_create_query_groups\u001b[0;34m(self, Q, query_lengths)\u001b[0m\n\u001b[1;32m 117\u001b[0m \u001b[0mclusters\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclusters\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 118\u001b[0m \u001b[0miterations\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0miterations\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 119\u001b[0;31m \u001b[0mbits\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbits\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 120\u001b[0m )\n\u001b[1;32m 121\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mclusters\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcounts\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/media/oldhome/wassname/Opt/fast-transformers2/fast_transformers/clustering/hamming/__init__.py\u001b[0m in \u001b[0;36mcluster\u001b[0;34m(hashes, lengths, groups, counts, centroids, distances, bitcounts, clusters, iterations, bits)\u001b[0m\n\u001b[1;32m 105\u001b[0m \u001b[0mhashes\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlengths\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 106\u001b[0m \u001b[0mcentroids\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdistances\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbitcounts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgroups\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcounts\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 107\u001b[0;31m \u001b[0miterations\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbits\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 108\u001b[0m )\n\u001b[1;32m 109\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mRuntimeError\u001b[0m: start (0) + length (100) exceeds dimension size (96). (narrow at /pytorch/aten/src/ATen/native/TensorShape.cpp:412)\nframe #0: c10::Error::Error(c10::SourceLocation, std::string const&) + 0x33 (0x7fec2237f813 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/lib/python3.7/site-packages/torch/lib/libc10.so)\nframe #1: at::native::narrow(at::Tensor const&, long, long, long) + 0x3b7 (0x7fec2434be77 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/lib/python3.7/site-packages/torch/lib/libtorch.so)\nframe #2: + 0x1e65109 (0x7fec24637109 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/lib/python3.7/site-packages/torch/lib/libtorch.so)\nframe #3: + 0x37c6966 (0x7fec25f98966 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/lib/python3.7/site-packages/torch/lib/libtorch.so)\nframe #4: + 0x1d6f976 (0x7fec24541976 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/lib/python3.7/site-packages/torch/lib/libtorch.so)\nframe #5: at::Tensor::narrow(long, long, long) const + 0xf7 (0x7fec685d8187 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/lib/python3.7/site-packages/torch/lib/libtorch_python.so)\nframe #6: cluster(at::Tensor, at::Tensor, at::Tensor, at::Tensor, at::Tensor, at::Tensor, at::Tensor, int, int) + 0x13c (0x7fec1ac692d8 in /media/oldhome/wassname/Opt/fast-transformers2/fast_transformers/clustering/hamming/cluster_cuda.cpython-37m-x86_64-linux-gnu.so)\nframe #7: + 0x5890f (0x7fec1ac8f90f in /media/oldhome/wassname/Opt/fast-transformers2/fast_transformers/clustering/hamming/cluster_cuda.cpython-37m-x86_64-linux-gnu.so)\nframe #8: + 0x5566c (0x7fec1ac8c66c in /media/oldhome/wassname/Opt/fast-transformers2/fast_transformers/clustering/hamming/cluster_cuda.cpython-37m-x86_64-linux-gnu.so)\nframe #9: + 0x50dab (0x7fec1ac87dab in /media/oldhome/wassname/Opt/fast-transformers2/fast_transformers/clustering/hamming/cluster_cuda.cpython-37m-x86_64-linux-gnu.so)\nframe #10: + 0x512bc (0x7fec1ac882bc in /media/oldhome/wassname/Opt/fast-transformers2/fast_transformers/clustering/hamming/cluster_cuda.cpython-37m-x86_64-linux-gnu.so)\nframe #11: + 0x3fa92 (0x7fec1ac76a92 in /media/oldhome/wassname/Opt/fast-transformers2/fast_transformers/clustering/hamming/cluster_cuda.cpython-37m-x86_64-linux-gnu.so)\nframe #12: _PyCFunction_FastCallKeywords + 0x431 (0x43d1d1 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #13: _PyEval_EvalFrameDefault + 0x8803 (0x429c83 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #14: _PyEval_EvalCodeWithName + 0xa17 (0x4f26c7 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #15: _PyFunction_FastCallKeywords + 0xa5 (0x43c565 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #16: _PyEval_EvalFrameDefault + 0x6f78 (0x4283f8 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #17: /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7() [0x420308]\nframe #18: _PyEval_EvalFrameDefault + 0x7655 (0x428ad5 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #19: /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7() [0x420308]\nframe #20: _PyFunction_FastCallDict + 0x2be (0x43c4ae in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #21: _PyObject_Call_Prepend + 0x259 (0x43fcc9 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #22: PyObject_Call + 0x70 (0x43da20 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #23: _PyEval_EvalFrameDefault + 0x2fac (0x42442c in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #24: _PyEval_EvalCodeWithName + 0xa17 (0x4f26c7 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #25: _PyFunction_FastCallDict + 0x116 (0x43c306 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #26: _PyObject_Call_Prepend + 0x259 (0x43fcc9 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #27: /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7() [0x497a45]\nframe #28: _PyObject_FastCallKeywords + 0x141 (0x43cb71 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #29: _PyEval_EvalFrameDefault + 0x5f4f (0x4273cf in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #30: _PyEval_EvalCodeWithName + 0xa17 (0x4f26c7 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #31: _PyFunction_FastCallDict + 0x1ff (0x43c3ef in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #32: _PyObject_Call_Prepend + 0x259 (0x43fcc9 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #33: PyObject_Call + 0x70 (0x43da20 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #34: _PyEval_EvalFrameDefault + 0x2fac (0x42442c in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #35: _PyEval_EvalCodeWithName + 0xa17 (0x4f26c7 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #36: _PyFunction_FastCallDict + 0x1ff (0x43c3ef in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #37: _PyObject_Call_Prepend + 0x259 (0x43fcc9 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #38: /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7() [0x497a45]\nframe #39: _PyObject_FastCallKeywords + 0x141 (0x43cb71 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #40: _PyEval_EvalFrameDefault + 0x30ee (0x42456e in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #41: _PyEval_EvalCodeWithName + 0xa17 (0x4f26c7 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #42: _PyFunction_FastCallDict + 0x1ff (0x43c3ef in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #43: _PyObject_Call_Prepend + 0x259 (0x43fcc9 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #44: PyObject_Call + 0x70 (0x43da20 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #45: _PyEval_EvalFrameDefault + 0x2fac (0x42442c in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #46: _PyEval_EvalCodeWithName + 0xa17 (0x4f26c7 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #47: _PyFunction_FastCallDict + 0x1ff (0x43c3ef in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #48: _PyObject_Call_Prepend + 0x259 (0x43fcc9 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #49: /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7() [0x497a45]\nframe #50: _PyObject_FastCallKeywords + 0x141 (0x43cb71 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #51: _PyEval_EvalFrameDefault + 0x30ee (0x42456e in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #52: _PyEval_EvalCodeWithName + 0xa17 (0x4f26c7 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #53: _PyFunction_FastCallDict + 0x1ff (0x43c3ef in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #54: _PyObject_Call_Prepend + 0x259 (0x43fcc9 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #55: PyObject_Call + 0x70 (0x43da20 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #56: _PyEval_EvalFrameDefault + 0x2fac (0x42442c in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #57: _PyEval_EvalCodeWithName + 0xa17 (0x4f26c7 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #58: _PyFunction_FastCallDict + 0x1ff (0x43c3ef in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #59: _PyObject_Call_Prepend + 0x259 (0x43fcc9 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #60: /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7() [0x497a45]\nframe #61: _PyObject_FastCallKeywords + 0x141 (0x43cb71 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #62: _PyEval_EvalFrameDefault + 0x30ee (0x42456e in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\nframe #63: _PyEval_EvalCodeWithName + 0xa17 (0x4f26c7 in /home/wassname/.pyenv/versions/3.7.2/envs/jup3.7.2/bin/python3.7)\n" + ] + } + ], + "source": [ + "# TEST\n", + "i=0\n", + "exp= dict(\n", + " name=\"TransformerSeq2SeqAutoR_PL\",\n", + " PL_MODEL_CLS=TransformerSeq2SeqAutoR_PL,\n", + " )\n", + "trial, trainer, model = run_trial(\n", + " user_attrs = default_user_attrs,\n", + " number=number*i*100-1000,\n", + " **exp)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-07-12T03:02:29.669226Z", + "start_time": "2020-07-12T03:02:13.805Z" + } + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-07-12T03:02:29.671551Z", + "start_time": "2020-07-12T03:02:13.808Z" + }, + "scrolled": true + }, + "outputs": [], + "source": [ + "for i in range(N):\n", + " for exp in experiments:\n", + " print(i, exp)\n", + " trial, trainer, model = run_trial(\n", + " user_attrs = default_user_attrs,\n", + " number=number*i*100-1000,\n", + " **exp)\n", + "\n", + " name = trainer.logger.name\n", + " r=trainer.logger.metrics[-1]\n", + " if 'agg_test_score' in r:\n", + " results[name].append(r)\n", + "\n", + " display(summarize_results(results))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-04-27T07:14:30.020600Z", + "start_time": "2020-04-27T07:07:02.236955Z" + } + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-07-12T03:02:29.673719Z", + "start_time": "2020-07-12T03:02:13.812Z" + } + }, + "outputs": [], + "source": [ + "display(summarize_results(results))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-07-12T03:02:29.675832Z", + "start_time": "2020-07-12T03:02:13.814Z" + } + }, + "outputs": [], + "source": [ + "result_dfs = []\n", + "for k in results:\n", + " v = results[k]\n", + " df = pd.DataFrame(v).mean()\n", + " df = pd.concat([pd.DataFrame(v).mean().rename(lambda x:'mean_' + x),\n", + " pd.DataFrame(v).std().rename(lambda x:'std_' + x),\n", + " pd.DataFrame(v).min().rename(lambda x:'min_' + x)])\n", + "\n", + " df.name = k\n", + " df['n'] = len(v)\n", + " result_dfs.append(df)\n", + "\n", + "# df = pd.DataFrame(v).std()\n", + "# df.name = k+'_std'\n", + "# df['n'] = len(v)\n", + "# result_dfs.append(df)\n", + "\n", + "\n", + "result_df = pd.concat(result_dfs, 1).T\n", + "result_df.sort_values('min_agg_test_score').T" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-04-26T04:49:59.013927Z", + "start_time": "2020-04-26T04:49:58.949675Z" + } + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-04-26T04:47:58.718550Z", + "start_time": "2020-04-26T04:47:58.643300Z" + } + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Manual exp" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-07-12T03:02:29.677914Z", + "start_time": "2020-07-12T03:02:13.821Z" + } + }, + "outputs": [], + "source": [ + "number=None" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-04-27T15:25:08.045015Z", + "start_time": "2020-04-27T15:25:07.115517Z" + } + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2020-01-27T04:27:28.582523Z", + "start_time": "2020-01-27T04:27:28.445326Z" + } + }, + "source": [ + "# Hyperparam" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-07-12T03:02:29.680026Z", + "start_time": "2020-07-12T03:02:13.825Z" + } + }, + "outputs": [], + "source": [ + "from neural_processes.train import objective\n", + "import argparse " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-07-12T03:02:29.682128Z", + "start_time": "2020-07-12T03:02:13.828Z" + } + }, + "outputs": [], + "source": [ + "optuna_path = Path('./optuna_result2')\n", + "optuna_path.mkdir(exist_ok=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-07-12T03:02:29.684165Z", + "start_time": "2020-07-12T03:02:13.831Z" + } + }, + "outputs": [], + "source": [ + "for PL_MODEL_CLS in [TransformerSeq2Seq_PL, PL_ANPRNN]:\n", + " name = str(PL_MODEL_CLS.__name__)\n", + " func = functools.partial(objective,\n", + " PL_MODEL_CLS=PL_MODEL_CLS,\n", + " name=name,\n", + " user_attrs=default_user_attrs)\n", + "\n", + " parser = argparse.ArgumentParser(description='PyTorch Lightning example.')\n", + " parser.add_argument(\n", + " '--pruning',\n", + " '-p',\n", + " 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(\n", + " n_warmup_steps=1,\n", + " n_startup_trials=6) if args.pruning else optuna.pruners.NopPruner()\n", + " pruner = optuna.pruners.PercentilePruner(75.0)\n", + "\n", + " study = optuna.create_study(direction='minimize',\n", + " pruner=pruner,\n", + " storage=f'sqlite:///{optuna_path}/{name}.db',\n", + " study_name=name,\n", + " load_if_exists=True)\n", + "\n", + "# 1/0\n", + " study.optimize(func=func,\n", + " n_trials=200,\n", + " timeout=pd.Timedelta('0.5d').total_seconds())\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))\n", + "\n", + " # shutil.rmtree(MODEL_DIR)\n", + "\n", + " df = study.trials_dataframe(attrs=('number', 'value', 'params', 'state'))\n", + " print(df.sort_values('value'))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-07-12T03:02:29.686268Z", + "start_time": "2020-07-12T03:02:13.834Z" + } + }, + "outputs": [], + "source": [ + "PL_MODEL_CLS" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-07-12T03:02:29.688322Z", + "start_time": "2020-07-12T03:02:13.837Z" + }, + "scrolled": true + }, + "outputs": [], + "source": [ + "df = study.trials_dataframe(attrs=('number', 'value', 'params', 'state'))\n", + "df.sort_values('value')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-01-27T07:45:29.794794Z", + "start_time": "2020-01-27T07:45:29.733450Z" + } + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "file_extension": ".py", + "kernelspec": { + "display_name": "jup3.7.2", + "language": "python", + "name": "jup3.7.2" + }, + "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.2" + }, + "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/neural_processes/data/smart_meter.py b/neural_processes/data/smart_meter.py index 2783a24..83ce24a 100644 --- a/neural_processes/data/smart_meter.py +++ b/neural_processes/data/smart_meter.py @@ -15,7 +15,7 @@ def npsample_batch(x, y, size=None, sort=True): inds.sort() return x[:, inds], y[:, inds] -def collate_fns(max_num_context, max_num_extra_target, sample, sort=True, context_in_target=True): +def collate_fns(max_num_context, max_num_extra_target, sample, sort=True, context_in_target=False): def collate_fn(batch, sample=sample): # Collate x = np.stack([x for x, y in batch], 0) diff --git a/neural_processes/lightning.py b/neural_processes/lightning.py index 9980f84..cebb421 100644 --- a/neural_processes/lightning.py +++ b/neural_processes/lightning.py @@ -28,74 +28,63 @@ class PL_Seq2Seq(pl.LightningModule): # TODO make data source configurable def forward(self, *args, **kwargs): - return self._model(*args, **kwargs) + y_dist, losses, extra = self._model(*args, **kwargs) + assert torch.isfinite(losses["loss"]) + return y_dist, losses, extra + # steps 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) + y_dist, losses, extra = self.forward(*batch) tensorboard_logs = {"train_" + k: v for k, v in losses.items()} - assert torch.isfinite(tensorboard_logs["train_loss"]) - return {"loss": tensorboard_logs['train_loss'], "log": tensorboard_logs} + return {"loss": losses["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) + y_dist, losses, extra = self.forward(*batch) tensorboard_logs = {"val_" + k: v for k, v in losses.items()} - assert torch.isfinite(tensorboard_logs["val_loss"]) - return {"val_loss": tensorboard_logs["val_loss"], "log": tensorboard_logs} - - def validation_end(self, outputs): - if int(self.hparams["vis_i"]) > 0: - self.show_image() - - outputs = agg_logs(outputs) - - # agg and print self.train_logs HACK https://github.com/PyTorchLightning/pytorch-lightning/issues/100 - train_outputs = agg_logs(self.train_logs) - self.train_logs = [] - - logger.info(f"val step={self.trainer.global_step}, val={round_values(outputs)} tain={round_values(train_outputs)}") - - # tensorboard_logs_str = {k: f"{v}" for k, v in tensorboard_logs.items()} - # print(f"step {self.trainer.global_step}, {outputs}") - return {"val_loss": outputs["agg_val_loss"], "train_loss": train_outputs.get("agg_train_loss", None), "log": {**train_outputs.get("log", {}), **outputs["log"]}} - - - 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) + return {"val_loss": losses["loss"], "log": tensorboard_logs} def test_step(self, batch, batch_idx): - pred, losses, extra = self.forward(*batch) - - context_x, context_y, target_x, target_y = batch - y_dist = extra['y_dist'] - - # For test use a -logp only - loss = -y_dist.log_prob(target_y).mean() + y_dist, losses, extra = self.forward(*batch) tensorboard_logs = {"test_" + k: v for k, v in losses.items()} - tensorboard_logs["test_score"] = loss - assert torch.isfinite(loss) - return {"test_loss": loss, "log": tensorboard_logs} + return {"test_loss": losses["loss"], "log": tensorboard_logs} - def test_end(self, outputs): - - outputs = agg_logs(outputs) + # epoch ends + def _epoch_end(self, outputs, name): + outputs = [o.get("log", o) for o in outputs] + outputs = merge_dict_torch(outputs) logger.info( - f"step {self.trainer.global_step}, {outputs}" + f"{name} step={self.trainer.global_step}, outputs={round_values(outputs)}" ) - return {"test_loss": outputs["agg_test_loss"], "log": outputs["log"]} + return { + f"{name}_loss": outputs.get(f"{name}_loss"), + "log": outputs, + } + + def training_epoch_end(self, outputs): + if int(self.hparams.vis_i) > 0: + self.show_image(loader = self.train_dataloader(), title='train ') + return self._epoch_end(outputs, "train") + + def test_epoch_end(self, outputs): + return self._epoch_end(outputs, "test") + + def validation_epoch_end(self, outputs): + outputs = self._epoch_end(outputs, "val") + if int(self.hparams.vis_i) > 0: + self.show_image(loader = self.val_dataloader(), title='val ') + return outputs + + def show_image(self, loader, title=''): + # https://github.com/PytorchLightning/pytorch-lightning/blob/f8d9f8f/pytorch_lightning/core/lightning.py#L293 + vis_i = min(int(self.hparams["vis_i"]), len(loader.dataset)) + if isinstance(self.hparams["vis_i"], str): + # if it's a string we show + image = plot_from_loader(loader, self, i=int(vis_i), title=f'{title}, step={self.trainer.global_step}') + plt.show() + else: + # if it's a int we send to tensorboard + image = plot_from_loader_to_tensor(loader, self, i=vis_i) + self.logger.experiment.add_image('val/image', image, self.trainer.global_step) def configure_optimizers(self): optim = torch.optim.Adam(self.parameters(), lr=self.hparams["learning_rate"]) @@ -129,7 +118,7 @@ class PL_Seq2Seq(pl.LightningModule): 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"] + self.hparams["num_context"], self.hparams["num_extra_target"], sample=True ), sampler=sampler, num_workers=self.hparams["num_workers"], @@ -151,7 +140,7 @@ class PL_Seq2Seq(pl.LightningModule): # shuffle=False, sampler=sampler, collate_fn=collate_fns( - self.hparams["num_context"], self.hparams["num_extra_target"], sample=False, context_in_target=self.hparams["context_in_target"] + self.hparams["num_context"], self.hparams["num_extra_target"], sample=False ), num_workers=self.hparams["num_workers"], ) @@ -170,7 +159,7 @@ class PL_Seq2Seq(pl.LightningModule): 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"] + self.hparams["num_context"], self.hparams["num_extra_target"], sample=False ), sampler=sampler, num_workers=self.hparams["num_workers"], diff --git a/neural_processes/models/transformer_seq2seq_autor.py b/neural_processes/models/transformer_seq2seq_autor.py new file mode 100644 index 0000000..b4cefcd --- /dev/null +++ b/neural_processes/models/transformer_seq2seq_autor.py @@ -0,0 +1,262 @@ +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 neural_processes.data.smart_meter import ( + collate_fns, + SmartMeterDataSet, + get_smartmeter_df, +) +import torchvision.transforms as transforms +from neural_processes.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 +import optuna +from torchvision.transforms import ToTensor + +from neural_processes.data.smart_meter import get_smartmeter_df +from neural_processes.modules import BatchNormSequence, LSTMBlock, NPBlockRelu2d + +from neural_processes.utils import ObjectDict +from neural_processes.lightning import PL_Seq2Seq +from ..logger import logger +from ..utils import hparams_power + + +class TransformerSeq2SeqAutoRNet(nn.Module): + def __init__(self, hparams): + super().__init__() + hparams = hparams_power(hparams) + self.hparams = hparams + self._min_std = hparams.min_std + + hidden_out_size = self.hparams.hidden_out_size + y_size = self.hparams.input_size - self.hparams.input_size_decoder + x_size = self.hparams.input_size_decoder + + # Sometimes input normalisation can be important, an initial batch norm is a nice way to ensure this https://stackoverflow.com/a/46772183/221742 + self.x_norm = BatchNormSequence(x_size, affine=False) + self.y_norm = BatchNormSequence(y_size, affine=False) + + # TODO embedd both X's the same + if self.hparams.get('use_lstm', False): + self.x_emb = LSTMBlock(x_size, x_size) + self.y_emb = LSTMBlock(y_size, y_size) + + self.enc_emb = nn.Linear(self.hparams.input_size, hidden_out_size) + self.dec_emb = nn.Linear(self.hparams.input_size_decoder, hidden_out_size) + + encoder_norm = nn.LayerNorm(hidden_out_size) + layer_enc = nn.TransformerEncoderLayer( + d_model=hidden_out_size, + dim_feedforward=hidden_out_size*4, + dropout=self.hparams.attention_dropout, + nhead=self.hparams.nhead, + # activation + ) + self.encoder = nn.TransformerEncoder( + layer_enc, num_layers=self.hparams.nlayers, norm=encoder_norm + ) + + layer_dec = nn.TransformerDecoderLayer( + d_model=hidden_out_size, + dim_feedforward=hidden_out_size*4, + dropout=self.hparams.attention_dropout, + nhead=self.hparams.nhead, + ) + decoder_norm = nn.LayerNorm(hidden_out_size) + self.decoder = nn.TransformerDecoder( + layer_dec, num_layers=self.hparams.nlayers, norm=decoder_norm + ) + self.mean = NPBlockRelu2d(hidden_out_size, self.hparams.output_size) + self.std = NPBlockRelu2d(hidden_out_size, self.hparams.output_size) + self._use_lvar = False + # self._reset_parameters() + + def _reset_parameters(self): + r"""Initiate parameters in the transformer model.""" + + for p in self.parameters(): + if p.dim() > 1: + torch.nn.init.xavier_uniform_(p) + + def forward(self, context_x, context_y, target_x, target_y=None, mask_context=True, mask_target=True): + device = next(self.parameters()).device + + tgt_key_padding_mask = None + # if target_y is not None and mask_target: + # # Mask nan's + # target_mask = torch.isfinite(target_y)# & (target_y!=self.hparams.nan_value) + # target_y[~target_mask] = 0 + # target_y = target_y.detach() + # tgt_key_padding_mask = ~target_mask.any(-1) + + src_key_padding_mask = None + # if mask_context: + # # Mask nan's + # context_mask = torch.isfinite(context_y)# & (context_y!=self.hparams.nan_value) + # context_y[~context_mask] = 0 + # context_y = context_y.detach() + # src_key_padding_mask = ~context_mask.any(-1)# * float('-inf') + + # Norm + context_x = self.x_norm(context_x) + target_x = self.x_norm(target_x) + context_y = self.y_norm(context_y) + # if target_y is not None: + # target_y = self.y_norm(target_y) + + # LSTM + if self.hparams.get('use_lstm', False): + context_x = self.x_emb(context_x) + target_x = self.x_emb(target_x) + # Size([B, C, X]) -> Size([B, C, X]) + context_y = self.y_emb(context_y) + # Size([B, T, Y]) -> Size([B, T, Y]) + + + # Embed + x = torch.cat([context_x, context_y], -1) + x = self.enc_emb(x) + # Size([B, C, X]) -> Size([B, C, hidden_dim]) + target_x = self.dec_emb(target_x) + # Size([B, C, T]) -> Size([B, C, hidden_dim]) + + x = x.permute(1, 0, 2) # (B,C,hidden_dim) -> (C,B,hidden_dim) + target_x = target_x.permute(1, 0, 2) + # requires (C, B, hidden_dim) + memory = self.encoder(x, src_key_padding_mask=src_key_padding_mask) + + # 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 + # (C, B, emb_dim) -> (B, emb_dim) -> (T, B, 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_max = memory.max(dim=0, keepdim=True)[0].expand_as(target_x) + memory_mean = memory.mean(dim=0, keepdim=True)[0].expand_as(target_x) + memory_last = memory[-1:, :, :].expand_as(target_x) + memory_all = memory_max + memory_last + if self.hparams.agg == 'max': + memory = memory_max + elif self.hparams.agg == 'last': + memory = memory_last + elif self.hparams.agg == 'all': + memory = memory_all + elif self.hparams.agg == 'mean': + memory = memory_mean + else: + raise Exception(f"hparams.agg should be in ['last', 'max', 'mean', 'all'] not '{self.hparams.agg}''") + + outputs = self.decoder(target_x, memory, tgt_key_padding_mask=tgt_key_padding_mask) + + # [T, B, emb_dim] -> [B, T, emb_dim] + outputs = outputs.permute(1, 0, 2).contiguous() + # Size([B, T, emb_dim]) + mean = self.mean(outputs) + log_sigma = self.std(outputs) + if self._use_lvar: + log_sigma = torch.clamp( + log_sigma, math.log(self._min_std), -math.log(self._min_std) + ) + sigma = torch.exp(log_sigma) + else: + sigma = self._min_std + (1 - self._min_std) * F.softplus(log_sigma) + y_dist = torch.distributions.Normal(mean, sigma) + + # Loss + loss_mse = loss_p = loss_p_weighted = None + if target_y is not None: + loss_mse = F.mse_loss(mean, target_y, reduction="none") + if self._use_lvar: + loss_p = -log_prob_sigma(target_y, mean, log_sigma) + else: + loss_p = -y_dist.log_prob(target_y).mean(-1) + if self.hparams["context_in_target"]: + loss_p[: context_x.size(1)] /= 100 + loss_mse[: context_x.size(1)] /= 100 + + # Weight loss nearer to prediction time? + weight = (torch.arange(loss_p.shape[1]) + 1).float().to(device)[None, :] + loss_p_weighted = loss_p / torch.sqrt(weight) # We want to weight nearer stuff more + + y_pred = y_dist.rsample if self.training else y_dist.loc + return ( + y_pred, + dict(loss=loss_p.mean(), loss_p=loss_p.mean(), loss_mse=loss_mse.mean(), loss_p_weighted=loss_p_weighted.mean()), + dict(log_sigma=log_sigma, y_dist=y_dist), + ) + + +class TransformerSeq2SeqAutoR_PL(PL_Seq2Seq): + def __init__(self, hparams, MODEL_CLS=TransformerSeq2SeqAutoRNet, **kwargs): + super().__init__(hparams, MODEL_CLS=MODEL_CLS, **kwargs) + + DEFAULT_ARGS = { + "agg": "max", + "attention_dropout": 0.2, + "hidden_out_size_power": 4, + "hidden_size_power": 5, + "learning_rate": 0.002, + "nhead_power": 3, + "nlayers": 2, + "use_lstm": False + } + + @staticmethod + def add_suggest(trial: optuna.Trial, user_attrs={}): + """ + Add hyperparam ranges to an optuna trial and typical user attrs. + + Usage: + trial = optuna.trial.FixedTrial( + params={ + 'hidden_size': 128, + } + ) + trial = add_suggest(trial) + trainer = pl.Trainer() + model = LSTM_PL(dict(**trial.params, **trial.user_attrs), dataset_train, + dataset_test, cache_base_path, norm) + trainer.fit(model) + """ + trial.suggest_loguniform("learning_rate", 1e-6, 1e-2) + trial.suggest_uniform("attention_dropout", 0, 0.75) + # we must have nhead<==hidden_size + # so nhead_power.max()<==hidden_size_power.min() + trial.suggest_discrete_uniform("hidden_size_power", 4, 10, 1) + trial.suggest_discrete_uniform("hidden_out_size_power", 4, 9, 1) + trial.suggest_discrete_uniform("nhead_power", 1, 4, 1) + trial.suggest_int("nlayers", 1, 12) + trial.suggest_categorical("use_lstm", [False, True]) + trial.suggest_categorical("agg", ['last', 'max', 'mean', 'all']) + + user_attrs_default = { + "batch_size": 16, + "grad_clip": 40, + "max_nb_epochs": 200, + "num_workers": 4, + "num_extra_target": 24 * 4, + "vis_i": "670", + "num_context": 24 * 4, + "input_size": 18, + "input_size_decoder": 17, + "context_in_target": False, + "output_size": 1, + "patience": 3, + 'min_std': 0.005, + } + [trial.set_user_attr(k, v) for k, v in user_attrs_default.items()] + [trial.set_user_attr(k, v) for k, v in user_attrs.items()] + return trial