diff --git a/neural_processes/lightning.py b/neural_processes/lightning.py
index 77a6695..89316b9 100644
--- a/neural_processes/lightning.py
+++ b/neural_processes/lightning.py
@@ -35,40 +35,27 @@ class PL_Seq2Seq(pl.LightningModule):
         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}
+        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}
 
     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}
+        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()
 
-        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 = self.agg_logs(outputs)
+
         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}
+        return {"avg_val_loss": tensorboard_logs["val_loss"], "log": tensorboard_logs}
 
     def agg_logs(self, outputs):
         if isinstance(outputs, dict):
@@ -99,25 +86,24 @@ class PL_Seq2Seq(pl.LightningModule):
 
     def test_step(self, batch, batch_idx):
         pred, losses, extra = self.forward(*batch)
-        # For test use a diff loss, MSE over next 24
-        # loss = losses["loss"]
-        loss = F.mse_loss(pred, batch[-1], reduction='none')[:, :24].mean()
+
+        context_x, context_y, target_x, target_y = batch
+        y_dist = extra['y_dist']
+
+        # For test use a diff loss, log_p over next <24h, so it's a standard amount of steps
+        loss = -y_dist.log_prob(target_y)[:, :24].mean()
         tensorboard_logs = {"test_" + k: v for k, v in losses.items()}
+        assert torch.isfinite(loss)
         return {"test_loss": loss, "log": tensorboard_logs}
 
     def test_end(self, outputs):
-        avg_loss = torch.stack([x["test_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()}
+
+        tensorboard_logs = self.agg_logs(outputs)
 
         logger.info(
             f"step {self.trainer.global_step}, {tensorboard_logs_str}"
         )
-        return {"avg_val_loss": avg_loss, "log": tensorboard_logs}
+        return {"avg_test_loss": tensorboard_logs["test_loss"], "log": tensorboard_logs}
 
     def configure_optimizers(self):
         optim = torch.optim.Adam(self.parameters(), lr=self.hparams["learning_rate"])
diff --git a/neural_processes/models/lstm_seqseq.py b/neural_processes/models/lstm_seqseq.py
index 5e8c16e..db73a0f 100644
--- a/neural_processes/models/lstm_seqseq.py
+++ b/neural_processes/models/lstm_seqseq.py
@@ -109,7 +109,7 @@ class Seq2SeqNet(nn.Module):
         y_dist = torch.distributions.Normal(mean, sigma)
 
         # Loss
-        loss_mse = loss_p = None
+        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:
@@ -120,15 +120,16 @@ class Seq2SeqNet(nn.Module):
             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:]
+
+            # 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)
 
         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),
+            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),
         )
 
 
diff --git a/neural_processes/models/lstm_std.py b/neural_processes/models/lstm_std.py
index 685bed0..bfd0374 100644
--- a/neural_processes/models/lstm_std.py
+++ b/neural_processes/models/lstm_std.py
@@ -76,7 +76,7 @@ class LSTMNet(nn.Module):
         y_dist = torch.distributions.Normal(mean, sigma)
 
         # Loss
-        loss_mse = loss_p = None
+        loss_mse = loss_p_weighted = loss_p = None
         if target_y is not None:
             loss_mse = F.mse_loss(mean, target_y, reduction="none")
             if self._use_lvar:
@@ -86,19 +86,16 @@ class LSTMNet(nn.Module):
             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:]
 
             # Weight loss nearer to prediction time?
             weight = (torch.arange(loss_p.shape[1]) + 1).float().to(device)[None, :]
-            loss_p = loss_p / torch.sqrt(weight)  # We want to weight nearer stuff more
+            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_p=loss_p.mean(), loss_mse=loss_mse.mean()),
-            dict(log_sigma=log_sigma, dist=y_dist),
+            dict(loss=loss_p.mean(), loss_p_weighted=loss_p_weighted.mean(), loss_p=loss_p.mean(), loss_mse=loss_mse.mean()),
+            dict(log_sigma=log_sigma, y_dist=y_dist),
         )
         # loss = None
         # if target_y is not None:
diff --git a/neural_processes/models/neural_process/lightning.py b/neural_processes/models/neural_process/lightning.py
index 30a0d43..af6a2c6 100644
--- a/neural_processes/models/neural_process/lightning.py
+++ b/neural_processes/models/neural_process/lightning.py
@@ -9,32 +9,50 @@ from neural_processes.utils import ObjectDict
 
 
 class PL_NeuralProcess(PL_Seq2Seq):
+    """Base class with everything off."""
     def __init__(self, hparams,
         MODEL_CLS=NeuralProcess.FROM_HPARAMS, **kwargs):
         super().__init__(hparams,
         MODEL_CLS=MODEL_CLS, **kwargs)
 
     DEFAULT_ARGS = {
-        'attention_dropout': 0,
-        'attention_layers': 2,
-        'batchnorm': False,
-        'det_enc_cross_attn_type': 'multihead',
-        'det_enc_self_attn_type': 'uniform',
         'dropout': 0,
-        'hidden_dim_power': 7,
-        'latent_dim_power': 7,
+        'learning_rate': 0.006,
+        'attention_dropout': 0,
+        'batchnorm': False,
+        'attention_layers': 2,
+        'det_enc_cross_attn_type': 'uniform',
+        'det_enc_self_attn_type': 'uniform',
         'latent_enc_self_attn_type': 'uniform',
-        'learning_rate': 0.002,
-        'n_decoder_layers': 4,
-        'n_det_encoder_layers': 4,
-        'n_latent_encoder_layers': 2,
         'num_heads_power': 3,
-        'use_deterministic_path': True,
-        'use_lvar': True,
-        'use_self_attn': True,
+        'hidden_dim_power': 5,
+        'latent_dim_power': 4,
+        'n_decoder_layers': 4,
+        'n_latent_encoder_layers': 2,
+        'use_deterministic_path': False,
+        'n_det_encoder_layers': 4,
+        'use_lvar': False,
+        'use_self_attn': False,
         'use_rnn': False,
     }
 
+
+    USR_ATTRS_DEFAULT = {
+            'batch_size': 16,
+            'grad_clip': 40,
+            'max_nb_epochs': 200,
+            'num_workers': 4,
+            'num_context': 24* 4,
+            'vis_i': '670',
+            'num_extra_target': 24*4,
+            'x_dim': 18,
+            'context_in_target': False,
+            'y_dim': 1,
+            'patience': 3,
+            'min_std': 0.005,
+        }
+
+
     @staticmethod
     def add_suggest(trial, user_attrs={}):        
         trial.suggest_loguniform("learning_rate", 1e-6, 1e-2)
@@ -42,15 +60,11 @@ class PL_NeuralProcess(PL_Seq2Seq):
         trial.suggest_discrete_uniform("num_heads_power", 2, 4, 1)
 
         trial.suggest_discrete_uniform(
-            "hidden_dim_power", 3, 11, 1
+            "hidden_dim_power", 4, 11, 1
         )
         trial.suggest_discrete_uniform(
-            "latent_dim_power", 3, 11, 1
+            "latent_dim_power", 4, 11, 1
         )
-        trial.suggest_int(
-            "n_latent_encoder_layers", 1, 11
-        )
-
         trial.suggest_int("n_latent_encoder_layers", 1, 12)
         trial.suggest_int("n_det_encoder_layers", 1, 12)
         trial.suggest_int("n_decoder_layers", 1, 12)
@@ -70,21 +84,147 @@ class PL_NeuralProcess(PL_Seq2Seq):
         trial.suggest_categorical("use_deterministic_path", [False, True])
         trial.suggest_categorical("use_rnn", [True, False])
 
-        user_attrs_default = {
-            'batch_size': 16,
-            'grad_clip': 40,
-            'max_nb_epochs': 200,
-            'num_workers': 4,
-            'num_context': 24* 4,
-            'vis_i': '670',
-            'num_extra_target': 24*4,
-            'x_dim': 18,
-            'context_in_target': False,
-            'y_dim': 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 PL_NeuralProcess.USR_ATTRS_DEFAULT.items()]
+        [trial.set_user_attr(k, v) for k, v in user_attrs.items()]    
+        return trial
+
+
+class PL_NP(PL_NeuralProcess):
+    """Vanilla NP with no attention or RNN."""
+
+    def __init__(self, hparams,
+        MODEL_CLS=NeuralProcess.FROM_HPARAMS, **kwargs):
+        super().__init__(hparams,
+        MODEL_CLS=MODEL_CLS, **kwargs)
+
+    DEFAULT_ARGS = {
+        **PL_NeuralProcess.DEFAULT_ARGS,
+        'det_enc_cross_attn_type': 'uniform',
+        'det_enc_self_attn_type': 'uniform',
+        'latent_enc_self_attn_type': 'uniform',
+        'use_deterministic_path': False,
+    }
+
+    @staticmethod
+    def add_suggest(trial, user_attrs={}):        
+        trial.suggest_loguniform("learning_rate", 1e-6, 1e-2)
+
+        trial.suggest_discrete_uniform(
+            "hidden_dim_power", 3, 11, 1
+        )
+        trial.suggest_discrete_uniform(
+            "latent_dim_power", 3, 11, 1
+        )
+
+        trial.suggest_int("n_latent_encoder_layers", 1, 12)
+        trial.suggest_int("n_decoder_layers", 1, 12)
+
+        trial.suggest_uniform("dropout", 0, 0.9)
+
+        trial.suggest_categorical("batchnorm", [False, True])
+
+        [trial.set_user_attr(k, v) for k, v in PL_NeuralProcess.USR_ATTRS_DEFAULT.items()]
+        [trial.set_user_attr(k, v) for k, v in user_attrs.items()]    
+        return trial
+
+
+
+class PL_ANP(PL_NeuralProcess):
+    def __init__(self, hparams,
+        MODEL_CLS=NeuralProcess.FROM_HPARAMS, **kwargs):
+        super().__init__(hparams,
+        MODEL_CLS=MODEL_CLS, **kwargs)
+
+    DEFAULT_ARGS = {
+        **PL_NeuralProcess.DEFAULT_ARGS,
+        'det_enc_cross_attn_type': 'multihead',
+        'det_enc_self_attn_type': 'multihead',
+        'latent_enc_self_attn_type': 'multihead',
+        'use_self_attn': True,
+        'use_deterministic_path': True,
+    }
+
+
+    @staticmethod
+    def add_suggest(trial, user_attrs={}):
+        trial.suggest_loguniform("learning_rate", 1e-6, 1e-2)
+        trial.suggest_int("attention_layers", 1, 4)
+        trial.suggest_discrete_uniform("num_heads_power", 2, 4, 1)
+
+        trial.suggest_discrete_uniform(
+            "hidden_dim_power", 4, 11, 1
+        )
+        trial.suggest_discrete_uniform(
+            "latent_dim_power", 4, 11, 1
+        )
+        trial.suggest_int("n_latent_encoder_layers", 1, 12)
+        trial.suggest_int("n_det_encoder_layers", 1, 12)
+        trial.suggest_int("n_decoder_layers", 1, 12)
+
+        trial.suggest_uniform("dropout", 0, 0.9)
+        trial.suggest_uniform("attention_dropout", 0, 0.9)
+
+        trial.suggest_categorical(
+            "latent_enc_self_attn_type", ['uniform', 'multihead']
+        )
+        trial.suggest_categorical("det_enc_self_attn_type",  ['uniform', 'multihead'])
+        trial.suggest_categorical("det_enc_cross_attn_type", ['uniform', 'multihead'])
+
+        trial.suggest_categorical("batchnorm", [False, True])
+        trial.suggest_categorical("use_deterministic_path", [False, True])
+
+        [trial.set_user_attr(k, v) for k, v in PL_NeuralProcess.USR_ATTRS_DEFAULT.items()]
+        [trial.set_user_attr(k, v) for k, v in user_attrs.items()]    
+        return trial
+
+
+
+class PL_ANPRNN(PL_NeuralProcess):
+    """
+    Recurrent Attentive Neural Process for Sequential Data.
+    
+    https://arxiv.org/abs/1910.09323
+    """
+    
+    def __init__(self, hparams,
+        MODEL_CLS=NeuralProcess.FROM_HPARAMS, **kwargs):
+        super().__init__(hparams,
+        MODEL_CLS=MODEL_CLS, **kwargs)
+
+    DEFAULT_ARGS = {
+        **PL_NeuralProcess.DEFAULT_ARGS,
+        'det_enc_cross_attn_type': 'multihead',
+        'det_enc_self_attn_type': 'multihead',
+        'latent_enc_self_attn_type': 'multihead',
+        'use_self_attn': True,
+        'use_rnn': True,
+    }
+
+
+    @staticmethod
+    def add_suggest(trial, user_attrs={}):        
+        trial.suggest_loguniform("learning_rate", 1e-6, 1e-2)
+        trial.suggest_int("attention_layers", 1, 4)
+        trial.suggest_discrete_uniform("num_heads_power", 2, 4, 1)
+
+        trial.suggest_discrete_uniform(
+            "hidden_dim_power", 4, 11, 1
+        )
+        trial.suggest_discrete_uniform(
+            "latent_dim_power", 4, 11, 1
+        )
+        trial.suggest_int("n_latent_encoder_layers", 1, 12)
+        trial.suggest_int("n_det_encoder_layers", 1, 12)
+        trial.suggest_int("n_decoder_layers", 1, 12)
+
+        trial.suggest_uniform("dropout", 0, 0.9)
+        trial.suggest_uniform("attention_dropout", 0, 0.9)
+
+        trial.suggest_categorical("batchnorm", [False, True])
+        trial.suggest_categorical("use_deterministic_path", [False, True])
+
+        [trial.set_user_attr(k, v) for k, v in PL_NeuralProcess.USR_ATTRS_DEFAULT.items()]
         [trial.set_user_attr(k, v) for k, v in user_attrs.items()]    
         return trial
 
diff --git a/neural_processes/models/neural_process/model.py b/neural_processes/models/neural_process/model.py
index 1567bc5..70b7617 100644
--- a/neural_processes/models/neural_process/model.py
+++ b/neural_processes/models/neural_process/model.py
@@ -304,7 +304,8 @@ class NeuralProcess(nn.Module):
         self._use_lvar = use_lvar
 
     def forward(self, context_x, context_y, target_x, target_y=None):
-
+        device = next(self.parameters()).device
+        
         # https://stackoverflow.com/a/46772183/221742
         target_x = self.norm_x(target_x)
         context_x = self.norm_x(context_x)
@@ -353,18 +354,27 @@ class NeuralProcess(nn.Module):
                     log_p[:, :context_x.size(1)] /= 100 # There's the temptation for it to fit only on context, where it knows the answer, and learn very low uncertainty. 
                 loss_kl = torch.distributions.kl_divergence(
                     dist_post, dist_prior).mean(-1)  # [B, R].mean(-1)
+            
             loss_kl = loss_kl[:, None].expand(log_p.shape)
             mse_loss = F.mse_loss(dist.loc, target_y, reduction='none')[:,:context_x.size(1)].mean()
-            loss_p = -log_p.mean()
+            loss_p = -log_p
+
+            # 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
+            loss_p_weighted = loss_p_weighted.mean()
+
             loss = (loss_kl - log_p).mean()
             loss_kl = loss_kl.mean()
             log_p = log_p.mean()
+            loss_p = loss_p.mean()
 
         else:
             loss_p = None
             mse_loss = None
             loss_kl = None
             loss = None
+            loss_p_weighted = None
 
         y_pred = dist.rsample() if self.training else dist.loc
-        return y_pred, dict(loss=loss, loss_p=loss_p, loss_kl=loss_kl, loss_mse=mse_loss), dict(log_sigma=log_sigma, dist=dist)
+        return y_pred, dict(loss=loss, loss_p=loss_p, loss_kl=loss_kl, loss_mse=mse_loss, loss_p_weighted=loss_p_weighted), dict(log_sigma=log_sigma, dist=dist)
diff --git a/neural_processes/models/transformer.py b/neural_processes/models/transformer.py
index 4831937..4346156 100644
--- a/neural_processes/models/transformer.py
+++ b/neural_processes/models/transformer.py
@@ -68,22 +68,17 @@ class NetTransformer(nn.Module):
         x[~x_mask] = 0
         x = x.detach()
         x_key_padding_mask = ~x_mask.any(-1)
-        # print('x_key_padding_mask', x_mask.float().mean())
-        # print(x.shape, 'x1')
+
         x = self.enc_emb(x).permute(1, 0, 2)
-        # print(x.shape, 'x2')
-        # Size([C, B, emb_dim])
+        
         outputs = self.encoder(x, src_key_padding_mask=x_key_padding_mask).permute(
             1, 0, 2
         )
-        # print(outputs.shape, 'outputs')
 
         # Seems to help a little, especially with extrapolating out of bounds
         steps = context_y.shape[1]
         mean = self.mean(outputs)[:, steps:, :]
         log_sigma = self.std(outputs)[:, steps:, :]
-        # mean_target = mean[:, -steps:, :]
-        # mean_context = mean[:, :-steps, :]
 
         if self._use_lvar:
             log_sigma = torch.clamp(
@@ -105,81 +100,17 @@ class NetTransformer(nn.Module):
             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:]
 
             # Weight loss nearer to prediction time?
             weight = (torch.arange(loss_p.shape[1]) + 1).float().to(device)[None, :]
-            loss_p = loss_p / torch.sqrt(weight)  # We want to weight nearer stuff more
+            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_p=loss_p.mean(), loss_mse=loss_mse.mean()),
-            dict(log_sigma=log_sigma, dist=y_dist),
+            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),
         )
-        # mean_target = mean[:, -steps:, :]
-        # mean_context = mean[:, :-steps, :]
-
-        # loss = None
-        # if target_y is not None:
-        #     y = torch.cat([context_y, target_y], 1)
-        #     y_mask = torch.isfinite(y) & (y != self.hparams.nan_value)
-        #     y[~y_mask] = 0
-        #     y = y.detach()
-
-        #     loss_scale = 100
-        #     # loss = F.mse_loss(mean * loss_scale, y * loss_scale, reduction='none') / loss_scale
-
-        #     loss_target = (
-        #         F.mse_loss(
-        #             mean_target * loss_scale,
-        #             y[:, -steps:, :] * loss_scale,
-        #             reduction="none",
-        #         )
-        #         / loss_scale
-        #     )
-        #     loss_context = (
-        #         F.mse_loss(
-        #             mean_context * loss_scale,
-        #             y[:, :-steps, :] * loss_scale,
-        #             reduction="none",
-        #         )
-        #         / loss_scale
-        #     )
-
-        #     y_mask_target = y_mask[:, -steps:, :].detach()
-        #     y_mask_context = y_mask[:, :-steps, :].detach()
-        #     # loss_target = loss[:, -steps:, :]
-        #     # loss_context = loss[:, :-steps, :]
-        #     # print(0, loss_context.sum(), loss_target.sum())
-
-        #     weight = (
-        #         (torch.arange(loss_target.shape[1]) + 0.5)
-        #         .float()
-        #         .to(device)[None, :, None]
-        #     )
-        #     # weight /= weight.sum()
-        #     # print(1.0, loss_context.sum(), loss_target.sum())
-        #     loss_target = loss_target / torch.sqrt(
-        #         weight
-        #     )  # We want to weight nearer stuff more
-        #     # print(1.5, loss_context.sum(), y_mask_context.sum(), loss_target.sum(), y_mask_target.sum(), (loss_context * y_mask_context).sum())
-        #     loss_context = (loss_context * y_mask_context.float()).sum() / (
-        #         y_mask_context.sum() + 1.0
-        #     )
-        #     loss_target = (loss_target * y_mask_target.float()).sum() / (
-        #         y_mask_target.sum() + 1.0
-        #     )  # Mean over unmasked ones
-        #     # print(2, loss_context.sum(), loss_target.sum())
-
-        #     # Perhaps predicting the past, as a secondary loss will help
-        #     loss = loss_context / 100.0 + loss_target
-
-        #     assert torch.isfinite(loss)
-
-        # return mean_target, dict(loss=loss), dict()
 
 
 class PL_Transformer(PL_Seq2Seq):
diff --git a/neural_processes/models/transformer_seq2seq.py b/neural_processes/models/transformer_seq2seq.py
index 29b35c5..e611d9d 100644
--- a/neural_processes/models/transformer_seq2seq.py
+++ b/neural_processes/models/transformer_seq2seq.py
@@ -110,7 +110,7 @@ class TransformerSeq2SeqNet(nn.Module):
         y_dist = torch.distributions.Normal(mean, sigma)
 
         # Loss
-        loss_mse = loss_p = None
+        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:
@@ -120,19 +120,16 @@ class TransformerSeq2SeqNet(nn.Module):
             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:]
 
             # Weight loss nearer to prediction time?
             weight = (torch.arange(loss_p.shape[1]) + 1).float().to(device)[None, :]
-            loss_p = loss_p / torch.sqrt(weight)  # We want to weight nearer stuff more
+            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_p=loss_p.mean(), loss_mse=loss_mse.mean()),
-            dict(log_sigma=log_sigma, dist=y_dist),
+            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),
         )
 
 
@@ -141,13 +138,13 @@ class TransformerSeq2Seq_PL(PL_Seq2Seq):
         super().__init__(hparams, MODEL_CLS=MODEL_CLS, **kwargs)
 
     DEFAULT_ARGS = {
-        "agg": "mean",
-        "attention_dropout": 0.12,
+        "agg": "max",
+        "attention_dropout": 0.2,
         "hidden_out_size_power": 4,
-        "hidden_size_power": 7,
-        "learning_rate": 0.0023,
-        "nhead_power": 2,
-        "nlayers": 4,
+        "hidden_size_power": 5,
+        "learning_rate": 0.006,
+        "nhead_power": 3,
+        "nlayers": 2,
     }
 
     @staticmethod
@@ -169,8 +166,10 @@ class TransformerSeq2Seq_PL(PL_Seq2Seq):
         """
         trial.suggest_loguniform("learning_rate", 1e-6, 1e-2)
         trial.suggest_uniform("attention_dropout", 0, 0.75)
-        trial.suggest_discrete_uniform("hidden_size_power", 2, 10, 1)
-        trial.suggest_discrete_uniform("hidden_out_size_power", 2, 9, 1)
+        # 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)
 
diff --git a/neural_processes/train.py b/neural_processes/train.py
index 13b4ed5..f00bdf1 100644
--- a/neural_processes/train.py
+++ b/neural_processes/train.py
@@ -56,21 +56,32 @@ def main(
     return model, trainer
 
 
-def objective(trial, PL_MODEL_CLS, name):
+def objective(trial, PL_MODEL_CLS, name, user_attrs):
+    """For optuna hparam opt."""
     # see https://github.com/optuna/optuna/blob/cf6f02d/examples/pytorch_lightning_simple.py
     trial = PL_MODEL_CLS.add_suggest(trial)
-    # trial._user_attrs.update(user_attrs)
+    [trial.set_user_attr(k, v) for k, v in user_attrs.items()]
 
-    print("trial", trial.number, "params", trial.params, trial._user_attrs)
+    print(dict(number=trial.number, params=trial.params, user_attrs=trial.user_attrs))
 
     model, trainer = main(trial, PL_MODEL_CLS=PL_MODEL_CLS, name=name)
 
+    # Load checkpoint
+    checkpoints = sorted(Path(trainer.checkpoint_callback.dirpath).glob("*.ckpt"))
+    if len(checkpoints):
+        checkpoint = checkpoints[-1]
+        device = next(model.parameters()).device
+        print(f"Loading checkpoint {checkpoint}")
+        model = model.load_from_checkpoint(checkpoint).to(device)
+    
+    trainer.test(model)
+
     # also report to tensorboard & print
     print("logger.metrics", model.logger.metrics[-1:])
-    model.logger.experiment.add_hparams(trial.params, logger.metrics[-1])
+    model.logger.experiment.add_hparams(trial.params, model.logger.metrics[-1])
     model.logger.save()
 
-    return model.logger.metrics[-1]["val_loss"]
+    return model.logger.metrics[-1]["avg_test_loss"]
 
 
 def add_number(trial: optuna.Trial, model_dir: Path):
@@ -109,12 +120,13 @@ def run_trial(
         trial.number = number
 
     # Add user attributes
-    trial._user_attrs.update(user_attrs)
+    [trial.set_user_attr(k, v) for k, v in user_attrs.items()]
     print('trial', trial.number, trial, trial.params, trial.user_attrs)
 
     model, trainer = main(
         trial, PL_MODEL_CLS, name=name, MODEL_DIR=MODEL_DIR, train=False, prune=False
     )
+    
     checkpoints = sorted(Path(trainer.checkpoint_callback.dirpath).glob("*.ckpt"))
     if len(checkpoints)==0 or number is None:
         try:
diff --git a/neural_processes/utils.py b/neural_processes/utils.py
index f2de220..2fbc0f5 100644
--- a/neural_processes/utils.py
+++ b/neural_processes/utils.py
@@ -6,6 +6,7 @@ import torch
 import math
 import torch
 import optuna
+from .logger import logger
 
 
 def init_random_seed(seed):
@@ -91,6 +92,7 @@ def hparams_power(hparams):
         if k.endswith("_power"):
             k_new = k.replace("_power", "")
             hparams[k_new] = int(2 ** hparams[k])
+    logger.debug('hparams %s', hparams)
     return hparams
 
 def log_prob_sigma(value, loc, log_scale):
diff --git a/smartmeters.ipynb b/smartmeters.ipynb
index 8e10238..b880e27 100644
--- a/smartmeters.ipynb
+++ b/smartmeters.ipynb
@@ -42,8 +42,8 @@
    "execution_count": 1,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-18T00:28:21.154061Z",
-     "start_time": "2020-04-18T00:28:18.724097Z"
+     "end_time": "2020-04-19T03:45:49.185251Z",
+     "start_time": "2020-04-19T03:45:46.719899Z"
     }
    },
    "outputs": [],
@@ -72,8 +72,8 @@
    "execution_count": 2,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-18T00:28:21.204671Z",
-     "start_time": "2020-04-18T00:28:21.157119Z"
+     "end_time": "2020-04-19T03:45:49.237192Z",
+     "start_time": "2020-04-19T03:45:49.188664Z"
     }
    },
    "outputs": [],
@@ -88,8 +88,8 @@
    "execution_count": 3,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-18T00:28:21.533689Z",
-     "start_time": "2020-04-18T00:28:21.207514Z"
+     "end_time": "2020-04-19T03:45:49.522618Z",
+     "start_time": "2020-04-19T03:45:49.242253Z"
     }
    },
    "outputs": [
@@ -113,7 +113,7 @@
     "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 import PL_NeuralProcess\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",
@@ -127,8 +127,8 @@
    "execution_count": 4,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-18T00:28:21.588332Z",
-     "start_time": "2020-04-18T00:28:21.536260Z"
+     "end_time": "2020-04-19T03:45:49.575733Z",
+     "start_time": "2020-04-19T03:45:49.525888Z"
     }
    },
    "outputs": [],
@@ -143,8 +143,8 @@
    "execution_count": 5,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-18T00:28:21.640759Z",
-     "start_time": "2020-04-18T00:28:21.591883Z"
+     "end_time": "2020-04-19T03:45:49.649171Z",
+     "start_time": "2020-04-19T03:45:49.578488Z"
     }
    },
    "outputs": [],
@@ -166,8 +166,8 @@
    "execution_count": 6,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-18T00:28:23.575166Z",
-     "start_time": "2020-04-18T00:28:21.643810Z"
+     "end_time": "2020-04-19T03:45:50.024536Z",
+     "start_time": "2020-04-19T03:45:49.652470Z"
     }
    },
    "outputs": [],
@@ -196,8 +196,8 @@
    "execution_count": 7,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-18T00:28:26.565887Z",
-     "start_time": "2020-04-18T00:28:23.578775Z"
+     "end_time": "2020-04-19T03:45:53.016343Z",
+     "start_time": "2020-04-19T03:45:50.027742Z"
     }
    },
    "outputs": [
@@ -263,11 +263,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-18T00:28:26.630064Z",
-     "start_time": "2020-04-18T00:28:26.568221Z"
+     "start_time": "2020-04-19T03:45:46.800Z"
     }
    },
    "outputs": [],
@@ -291,11 +290,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-18T00:28:26.695625Z",
-     "start_time": "2020-04-18T00:28:26.632823Z"
+     "start_time": "2020-04-19T03:45:46.800Z"
     }
    },
    "outputs": [],
@@ -311,8 +309,8 @@
     "    'max_nb_epochs': 100,\n",
     "    'min_std': 0.005,\n",
     "    'grad_clip': 40,\n",
-    "    'batch_size': 16,\n",
-    "    'patience': 2,\n",
+    "    'batch_size': 32,\n",
+    "    'patience': 1,\n",
     "    'max_epoch_steps': 16*10*400,\n",
     "}\n",
     "N = 5\n",
@@ -321,43 +319,36 @@
     "    dict(name=\"anp-rnn\",\n",
     "         params={\n",
     "             'det_enc_cross_attn_type': 'multihead',\n",
-    "             'det_enc_self_attn_type': 'uniform',\n",
-    "             'latent_enc_self_attn_type': 'uniform',\n",
-    "             'use_deterministic_path': True,\n",
-    "             'use_rnn': True,\n",
-    "             'use_lvar': False,\n",
-    "         },\n",
-    "         PL_MODEL_CLS=PL_NeuralProcess),\n",
-    "    dict(\n",
-    "        name=\"anp-rnn_self_attn\",\n",
-    "        params={\n",
-    "            'det_enc_self_attn_type': 'multihead',\n",
-    "            'latent_enc_self_attn_type': 'multihead',\n",
-    "            'use_deterministic_path': False,\n",
-    "            'use_rnn': True,\n",
-    "            'use_lvar': False,\n",
-    "        },\n",
-    "        PL_MODEL_CLS=PL_NeuralProcess,\n",
-    "    ),\n",
-    "    dict(name=\"anp_c\",\n",
-    "         params={\n",
-    "             'det_enc_cross_attn_type': 'multihead',\n",
     "             'det_enc_self_attn_type': 'multihead',\n",
     "             'latent_enc_self_attn_type': 'multihead',\n",
-    "             'use_deterministic_path': False,\n",
-    "             'use_lvar': False,\n",
+    "             'use_deterministic_path': True,\n",
     "         },\n",
-    "         PL_MODEL_CLS=PL_NeuralProcess),\n",
+    "         PL_MODEL_CLS=PL_ANPRNN),\n",
+    "    dict(name=\"anp-rnn_all\",\n",
+    "         params={\n",
+    "             'det_enc_cross_attn_type': 'ptmultihead',\n",
+    "             'det_enc_self_attn_type': 'ptmultihead',\n",
+    "             'latent_enc_self_attn_type': 'ptmultihead',\n",
+    "             'use_deterministic_path': True,\n",
+    "             'batchnorm': True,\n",
+    "             'attention_dropout': 0.2,\n",
+    "             'dropout': 0.2,\n",
+    "             'use_lvar': True,\n",
+    "             \n",
+    "         },\n",
+    "         PL_MODEL_CLS=PL_ANPRNN),\n",
+    "    dict(\n",
+    "        name=\"anp-rnn_no_det\",\n",
+    "        params={\n",
+    "            'use_deterministic_path': False,\n",
+    "        },\n",
+    "        PL_MODEL_CLS=PL_ANPRNN,\n",
+    "    ),\n",
+    "    dict(name=\"anp_c\",\n",
+    "         PL_MODEL_CLS=PL_ANP),\n",
     "    dict(\n",
     "        name=\"np\",\n",
-    "        params={\n",
-    "            'det_enc_cross_attn_type': 'uniform',\n",
-    "            'det_enc_self_attn_type': 'uniform',\n",
-    "            'latent_enc_self_attn_type': 'uniform',\n",
-    "            'use_deterministic_path': False,\n",
-    "            'use_lvar': False,\n",
-    "        },\n",
-    "        PL_MODEL_CLS=PL_NeuralProcess,\n",
+    "        PL_MODEL_CLS=PL_NP,\n",
     "    ),\n",
     "    dict(\n",
     "        name=\"PL_Transformer\",\n",
@@ -379,11 +370,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-18T00:28:26.769476Z",
-     "start_time": "2020-04-18T00:28:26.698057Z"
+     "start_time": "2020-04-19T03:45:46.800Z"
     }
    },
    "outputs": [],
@@ -407,613 +397,20 @@
     "\n",
     "    if len(result_dfs)==0:\n",
     "        return None\n",
-    "    result_df = pd.concat(result_dfs, 1)\n",
-    "    return result_df"
+    "    result_df = pd.concat(result_dfs, 1).T\n",
+    "#     result_df['test_loss_p'] = result_df['test_loss_p'].fillna(100)\n",
+    "    return result_df.sort_values('test_loss_p').T"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-18T00:32:46.573911Z",
-     "start_time": "2020-04-18T00:28:26.772532Z"
+     "start_time": "2020-04-19T03:45:46.800Z"
     }
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "0 {'name': 'anp-rnn', 'params': {'det_enc_cross_attn_type': 'multihead', 'det_enc_self_attn_type': 'uniform', 'latent_enc_self_attn_type': 'uniform', 'use_deterministic_path': True, 'use_rnn': True, 'use_lvar': False}, 'PL_MODEL_CLS': <class 'neural_processes.models.neural_process.lightning.PL_NeuralProcess'>}\n",
-      "now run `tensorboard --logdir lightning_logs`\n",
-      "trial -1000 <optuna.trial.FixedTrial object at 0x7f21f0495be0> {'learning_rate': 0.002, 'attention_layers': 2, 'num_heads_power': 3, 'hidden_dim_power': 7, 'latent_dim_power': 7, 'n_latent_encoder_layers': 2, 'n_det_encoder_layers': 4, 'n_decoder_layers': 4, 'dropout': 0, 'attention_dropout': 0, 'latent_enc_self_attn_type': 'uniform', 'det_enc_self_attn_type': 'uniform', 'det_enc_cross_attn_type': 'multihead', 'batchnorm': False, 'use_self_attn': True, 'use_lvar': False, 'use_deterministic_path': True, 'use_rnn': True} {'batch_size': 16, 'grad_clip': 40, 'max_nb_epochs': 100, 'num_workers': 3, 'num_context': 96, 'vis_i': '670', 'num_extra_target': 96, 'x_dim': 17, 'context_in_target': False, 'y_dim': 1, 'patience': 2, 'min_std': 0.005, 'max_epoch_steps': 64000}\n",
-      "INFO:root:GPU available: True, used: True\n",
-      "INFO:root:VISIBLE GPUS: 0\n",
-      "Loading checkpoint lightning_logs/anp-rnn/version_-1000/_ckpt_epoch_14.ckpt\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "727a77ee56b14edaae44dd9699497a7d",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "HBox(children=(FloatProgress(value=0.0, description='Testing', layout=Layout(flex='2'), max=400.0, style=Progr…"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "INFO:predict_heading2:step 0, {'test_loss': '39.80715560913086', 'test_loss_p': '0.332550048828125', 'test_loss_kl': '39.47460174560547', 'test_loss_mse': '0.05435580015182495'}\n",
-      "----------------------------------------------------------------------------------------------------\n",
-      "TEST RESULTS\n",
-      "{}\n",
-      "----------------------------------------------------------------------------------------------------\n",
-      "\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "<div>\n",
-       "<style scoped>\n",
-       "    .dataframe tbody tr th:only-of-type {\n",
-       "        vertical-align: middle;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe tbody tr th {\n",
-       "        vertical-align: top;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe thead th {\n",
-       "        text-align: right;\n",
-       "    }\n",
-       "</style>\n",
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr style=\"text-align: right;\">\n",
-       "      <th></th>\n",
-       "      <th>anp-rnn_mean</th>\n",
-       "      <th>anp-rnn_std</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th>test_loss</th>\n",
-       "      <td>39.807156</td>\n",
-       "      <td>NaN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>test_loss_p</th>\n",
-       "      <td>0.332550</td>\n",
-       "      <td>NaN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>test_loss_kl</th>\n",
-       "      <td>39.474602</td>\n",
-       "      <td>NaN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>test_loss_mse</th>\n",
-       "      <td>0.054356</td>\n",
-       "      <td>NaN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>n</th>\n",
-       "      <td>1.000000</td>\n",
-       "      <td>1.0</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "</div>"
-      ],
-      "text/plain": [
-       "               anp-rnn_mean  anp-rnn_std\n",
-       "test_loss         39.807156          NaN\n",
-       "test_loss_p        0.332550          NaN\n",
-       "test_loss_kl      39.474602          NaN\n",
-       "test_loss_mse      0.054356          NaN\n",
-       "n                  1.000000          1.0"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "0 {'name': 'anp-rnn_self_attn', 'params': {'det_enc_self_attn_type': 'multihead', 'latent_enc_self_attn_type': 'multihead', 'use_deterministic_path': False, 'use_rnn': True, 'use_lvar': False}, 'PL_MODEL_CLS': <class 'neural_processes.models.neural_process.lightning.PL_NeuralProcess'>}\n",
-      "now run `tensorboard --logdir lightning_logs`\n",
-      "trial -1000 <optuna.trial.FixedTrial object at 0x7f21e6804f98> {'learning_rate': 0.002, 'attention_layers': 2, 'num_heads_power': 3, 'hidden_dim_power': 7, 'latent_dim_power': 7, 'n_latent_encoder_layers': 2, 'n_det_encoder_layers': 4, 'n_decoder_layers': 4, 'dropout': 0, 'attention_dropout': 0, 'latent_enc_self_attn_type': 'multihead', 'det_enc_self_attn_type': 'multihead', 'det_enc_cross_attn_type': 'multihead', 'batchnorm': False, 'use_self_attn': True, 'use_lvar': False, 'use_deterministic_path': False, 'use_rnn': True} {'batch_size': 16, 'grad_clip': 40, 'max_nb_epochs': 100, 'num_workers': 3, 'num_context': 96, 'vis_i': '670', 'num_extra_target': 96, 'x_dim': 17, 'context_in_target': False, 'y_dim': 1, 'patience': 2, 'min_std': 0.005, 'max_epoch_steps': 64000}\n",
-      "INFO:root:GPU available: True, used: True\n",
-      "INFO:root:VISIBLE GPUS: 0\n",
-      "Loading checkpoint lightning_logs/anp-rnn_self_attn/version_-1000/_ckpt_epoch_8.ckpt\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "2377913239064b92b473f8fef92cb453",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "HBox(children=(FloatProgress(value=0.0, description='Testing', layout=Layout(flex='2'), max=400.0, style=Progr…"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "INFO:predict_heading2:step 0, {'test_loss': '1.1680686473846436', 'test_loss_p': '0.7360194325447083', 'test_loss_kl': '0.4320492446422577', 'test_loss_mse': '0.09021934121847153'}\n",
-      "----------------------------------------------------------------------------------------------------\n",
-      "TEST RESULTS\n",
-      "{}\n",
-      "----------------------------------------------------------------------------------------------------\n",
-      "\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "<div>\n",
-       "<style scoped>\n",
-       "    .dataframe tbody tr th:only-of-type {\n",
-       "        vertical-align: middle;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe tbody tr th {\n",
-       "        vertical-align: top;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe thead th {\n",
-       "        text-align: right;\n",
-       "    }\n",
-       "</style>\n",
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr style=\"text-align: right;\">\n",
-       "      <th></th>\n",
-       "      <th>anp-rnn_mean</th>\n",
-       "      <th>anp-rnn_std</th>\n",
-       "      <th>anp-rnn_self_attn_mean</th>\n",
-       "      <th>anp-rnn_self_attn_std</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th>test_loss</th>\n",
-       "      <td>39.807156</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>1.168069</td>\n",
-       "      <td>NaN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>test_loss_p</th>\n",
-       "      <td>0.332550</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>0.736019</td>\n",
-       "      <td>NaN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>test_loss_kl</th>\n",
-       "      <td>39.474602</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>0.432049</td>\n",
-       "      <td>NaN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>test_loss_mse</th>\n",
-       "      <td>0.054356</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>0.090219</td>\n",
-       "      <td>NaN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>n</th>\n",
-       "      <td>1.000000</td>\n",
-       "      <td>1.0</td>\n",
-       "      <td>1.000000</td>\n",
-       "      <td>1.0</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "</div>"
-      ],
-      "text/plain": [
-       "               anp-rnn_mean  anp-rnn_std  anp-rnn_self_attn_mean  \\\n",
-       "test_loss         39.807156          NaN                1.168069   \n",
-       "test_loss_p        0.332550          NaN                0.736019   \n",
-       "test_loss_kl      39.474602          NaN                0.432049   \n",
-       "test_loss_mse      0.054356          NaN                0.090219   \n",
-       "n                  1.000000          1.0                1.000000   \n",
-       "\n",
-       "               anp-rnn_self_attn_std  \n",
-       "test_loss                        NaN  \n",
-       "test_loss_p                      NaN  \n",
-       "test_loss_kl                     NaN  \n",
-       "test_loss_mse                    NaN  \n",
-       "n                                1.0  "
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "0 {'name': 'anp_c', 'params': {'det_enc_cross_attn_type': 'multihead', 'det_enc_self_attn_type': 'multihead', 'latent_enc_self_attn_type': 'multihead', 'use_deterministic_path': False, 'use_lvar': False}, 'PL_MODEL_CLS': <class 'neural_processes.models.neural_process.lightning.PL_NeuralProcess'>}\n",
-      "now run `tensorboard --logdir lightning_logs`\n",
-      "trial -1000 <optuna.trial.FixedTrial object at 0x7f21e2f8b128> {'learning_rate': 0.002, 'attention_layers': 2, 'num_heads_power': 3, 'hidden_dim_power': 7, 'latent_dim_power': 7, 'n_latent_encoder_layers': 2, 'n_det_encoder_layers': 4, 'n_decoder_layers': 4, 'dropout': 0, 'attention_dropout': 0, 'latent_enc_self_attn_type': 'multihead', 'det_enc_self_attn_type': 'multihead', 'det_enc_cross_attn_type': 'multihead', 'batchnorm': False, 'use_self_attn': True, 'use_lvar': False, 'use_deterministic_path': False, 'use_rnn': False} {'batch_size': 16, 'grad_clip': 40, 'max_nb_epochs': 100, 'num_workers': 3, 'num_context': 96, 'vis_i': '670', 'num_extra_target': 96, 'x_dim': 17, 'context_in_target': False, 'y_dim': 1, 'patience': 2, 'min_std': 0.005, 'max_epoch_steps': 64000}\n",
-      "INFO:root:GPU available: True, used: True\n",
-      "INFO:root:VISIBLE GPUS: 0\n",
-      "Loading checkpoint lightning_logs/anp_c/version_-1000/_ckpt_epoch_2.ckpt\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "555054131f6948c1a0a268d6d8d9bde2",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "HBox(children=(FloatProgress(value=0.0, description='Testing', layout=Layout(flex='2'), max=400.0, style=Progr…"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "INFO:predict_heading2:step 0, {'test_loss': '13.74710464477539', 'test_loss_p': '0.18432480096817017', 'test_loss_kl': '13.562780380249023', 'test_loss_mse': '0.06910192966461182'}\n",
-      "----------------------------------------------------------------------------------------------------\n",
-      "TEST RESULTS\n",
-      "{}\n",
-      "----------------------------------------------------------------------------------------------------\n",
-      "\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "<div>\n",
-       "<style scoped>\n",
-       "    .dataframe tbody tr th:only-of-type {\n",
-       "        vertical-align: middle;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe tbody tr th {\n",
-       "        vertical-align: top;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe thead th {\n",
-       "        text-align: right;\n",
-       "    }\n",
-       "</style>\n",
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr style=\"text-align: right;\">\n",
-       "      <th></th>\n",
-       "      <th>anp-rnn_mean</th>\n",
-       "      <th>anp-rnn_std</th>\n",
-       "      <th>anp-rnn_self_attn_mean</th>\n",
-       "      <th>anp-rnn_self_attn_std</th>\n",
-       "      <th>anp_c_mean</th>\n",
-       "      <th>anp_c_std</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th>test_loss</th>\n",
-       "      <td>39.807156</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>1.168069</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>13.747105</td>\n",
-       "      <td>NaN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>test_loss_p</th>\n",
-       "      <td>0.332550</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>0.736019</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>0.184325</td>\n",
-       "      <td>NaN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>test_loss_kl</th>\n",
-       "      <td>39.474602</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>0.432049</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>13.562780</td>\n",
-       "      <td>NaN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>test_loss_mse</th>\n",
-       "      <td>0.054356</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>0.090219</td>\n",
-       "      <td>NaN</td>\n",
-       "      <td>0.069102</td>\n",
-       "      <td>NaN</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>n</th>\n",
-       "      <td>1.000000</td>\n",
-       "      <td>1.0</td>\n",
-       "      <td>1.000000</td>\n",
-       "      <td>1.0</td>\n",
-       "      <td>1.000000</td>\n",
-       "      <td>1.0</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "</div>"
-      ],
-      "text/plain": [
-       "               anp-rnn_mean  anp-rnn_std  anp-rnn_self_attn_mean  \\\n",
-       "test_loss         39.807156          NaN                1.168069   \n",
-       "test_loss_p        0.332550          NaN                0.736019   \n",
-       "test_loss_kl      39.474602          NaN                0.432049   \n",
-       "test_loss_mse      0.054356          NaN                0.090219   \n",
-       "n                  1.000000          1.0                1.000000   \n",
-       "\n",
-       "               anp-rnn_self_attn_std  anp_c_mean  anp_c_std  \n",
-       "test_loss                        NaN   13.747105        NaN  \n",
-       "test_loss_p                      NaN    0.184325        NaN  \n",
-       "test_loss_kl                     NaN   13.562780        NaN  \n",
-       "test_loss_mse                    NaN    0.069102        NaN  \n",
-       "n                                1.0    1.000000        1.0  "
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "0 {'name': 'np', 'params': {'det_enc_cross_attn_type': 'uniform', 'det_enc_self_attn_type': 'uniform', 'latent_enc_self_attn_type': 'uniform', 'use_deterministic_path': False, 'use_lvar': False}, 'PL_MODEL_CLS': <class 'neural_processes.models.neural_process.lightning.PL_NeuralProcess'>}\n",
-      "now run `tensorboard --logdir lightning_logs`\n",
-      "trial -1000 <optuna.trial.FixedTrial object at 0x7f21e66d1470> {'learning_rate': 0.002, 'attention_layers': 2, 'num_heads_power': 3, 'hidden_dim_power': 7, 'latent_dim_power': 7, 'n_latent_encoder_layers': 2, 'n_det_encoder_layers': 4, 'n_decoder_layers': 4, 'dropout': 0, 'attention_dropout': 0, 'latent_enc_self_attn_type': 'uniform', 'det_enc_self_attn_type': 'uniform', 'det_enc_cross_attn_type': 'uniform', 'batchnorm': False, 'use_self_attn': True, 'use_lvar': False, 'use_deterministic_path': False, 'use_rnn': False} {'batch_size': 16, 'grad_clip': 40, 'max_nb_epochs': 100, 'num_workers': 3, 'num_context': 96, 'vis_i': '670', 'num_extra_target': 96, 'x_dim': 17, 'context_in_target': False, 'y_dim': 1, 'patience': 2, 'min_std': 0.005, 'max_epoch_steps': 64000}\n",
-      "INFO:root:GPU available: True, used: True\n",
-      "INFO:root:VISIBLE GPUS: 0\n",
-      "Loading checkpoint lightning_logs/np/version_-1000/_ckpt_epoch_9.ckpt\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "ddbc8e280a8447bf9eac6275591b467c",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "HBox(children=(FloatProgress(value=0.0, description='Testing', layout=Layout(flex='2'), max=400.0, style=Progr…"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "KeyboardInterrupt, skipping rest of testing\n",
-      "ERROR:root:Internal Python error in the inspect module.\n",
-      "Below is the traceback from this internal error.\n",
-      "\n",
-      "Traceback (most recent call last):\n",
-      "  File \"/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/IPython/core/interactiveshell.py\", line 3325, in run_code\n",
-      "    exec(code_obj, self.user_global_ns, self.user_ns)\n",
-      "  File \"<ipython-input-11-edee89b33285>\", line 11, in <module>\n",
-      "    **trainer.logger.metrics[-1],\n",
-      "IndexError: list index out of range\n",
-      "\n",
-      "During handling of the above exception, another exception occurred:\n",
-      "\n",
-      "Traceback (most recent call last):\n",
-      "  File \"/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/IPython/core/interactiveshell.py\", line 2039, in showtraceback\n",
-      "    stb = value._render_traceback_()\n",
-      "AttributeError: 'IndexError' object has no attribute '_render_traceback_'\n",
-      "\n",
-      "During handling of the above exception, another exception occurred:\n",
-      "\n",
-      "Traceback (most recent call last):\n",
-      "  File \"/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/IPython/core/ultratb.py\", line 1101, in get_records\n",
-      "    return _fixed_getinnerframes(etb, number_of_lines_of_context, tb_offset)\n",
-      "  File \"/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/IPython/core/ultratb.py\", line 319, in wrapped\n",
-      "    return f(*args, **kwargs)\n",
-      "  File \"/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/IPython/core/ultratb.py\", line 353, in _fixed_getinnerframes\n",
-      "    records = fix_frame_records_filenames(inspect.getinnerframes(etb, context))\n",
-      "  File \"/home/wassname/.pyenv/versions/3.7.3/lib/python3.7/inspect.py\", line 1502, in getinnerframes\n",
-      "    frameinfo = (tb.tb_frame,) + getframeinfo(tb, context)\n",
-      "  File \"/home/wassname/.pyenv/versions/3.7.3/lib/python3.7/inspect.py\", line 1460, in getframeinfo\n",
-      "    filename = getsourcefile(frame) or getfile(frame)\n",
-      "  File \"/home/wassname/.pyenv/versions/3.7.3/lib/python3.7/inspect.py\", line 696, in getsourcefile\n",
-      "    if getattr(getmodule(object, filename), '__loader__', None) is not None:\n",
-      "  File \"/home/wassname/.pyenv/versions/3.7.3/lib/python3.7/inspect.py\", line 742, in getmodule\n",
-      "    os.path.realpath(f)] = module.__name__\n",
-      "  File \"/home/wassname/.pyenv/versions/3.7.3/lib/python3.7/posixpath.py\", line 395, in realpath\n",
-      "    path, ok = _joinrealpath(filename[:0], filename, {})\n",
-      "  File \"/home/wassname/.pyenv/versions/3.7.3/lib/python3.7/posixpath.py\", line 443, in _joinrealpath\n",
-      "    path, ok = _joinrealpath(path, os.readlink(newpath), seen)\n",
-      "KeyboardInterrupt\n",
-      "INFO:root:\n",
-      "Unfortunately, your original traceback can not be constructed.\n",
-      "\n"
-     ]
-    },
-    {
-     "ename": "IndexError",
-     "evalue": "list index out of range",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "for i in range(N):\n",
     "    for exp in experiments:\n",
@@ -1038,8 +435,33 @@
    "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-18T00:32:46.577452Z",
-     "start_time": "2020-04-18T00:28:19.000Z"
+     "start_time": "2020-04-19T03:45:46.800Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "display(summarize_results(results))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "start_time": "2020-04-19T03:45:46.800Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# %debug"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "start_time": "2020-04-19T03:45:46.800Z"
     }
    },
    "outputs": [],
@@ -1059,8 +481,7 @@
    "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-18T00:32:46.578719Z",
-     "start_time": "2020-04-18T00:28:19.000Z"
+     "start_time": "2020-04-19T03:45:46.800Z"
     }
    },
    "outputs": [],
@@ -1073,12 +494,12 @@
     "    'num_workers': 3,\n",
     "    'num_context': 24*4,\n",
     "    'num_extra_target': 24*4,\n",
-    "    'max_nb_epochs': 200,\n",
+    "    'max_nb_epochs': 20,\n",
     "    'min_std': 0.005,\n",
     "    'grad_clip': 40,\n",
     "    'batch_size': 16,\n",
     "    'patience': 2,\n",
-    "    'max_epoch_steps': 10000,\n",
+    "    'max_epoch_steps': 6000,\n",
     "}\n",
     "number=None"
    ]
@@ -1095,8 +516,7 @@
    "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-18T00:32:46.579967Z",
-     "start_time": "2020-04-18T00:28:19.000Z"
+     "start_time": "2020-04-19T03:45:46.800Z"
     }
    },
    "outputs": [],
@@ -1179,8 +599,7 @@
    "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-18T00:32:46.581162Z",
-     "start_time": "2020-04-18T00:28:19.000Z"
+     "start_time": "2020-04-19T03:45:46.800Z"
     }
    },
    "outputs": [],
@@ -1204,8 +623,7 @@
    "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-18T00:32:46.582349Z",
-     "start_time": "2020-04-18T00:28:19.000Z"
+     "start_time": "2020-04-19T03:45:46.900Z"
     }
    },
    "outputs": [],
@@ -1236,8 +654,7 @@
    "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-18T00:32:46.585493Z",
-     "start_time": "2020-04-18T00:28:19.000Z"
+     "start_time": "2020-04-19T03:45:46.900Z"
     }
    },
    "outputs": [],
@@ -1260,8 +677,7 @@
    "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-18T00:32:46.587096Z",
-     "start_time": "2020-04-18T00:28:19.000Z"
+     "start_time": "2020-04-19T03:45:46.900Z"
     }
    },
    "outputs": [],
@@ -1286,8 +702,7 @@
    "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-18T00:32:46.589030Z",
-     "start_time": "2020-04-18T00:28:19.000Z"
+     "start_time": "2020-04-19T03:45:46.900Z"
     }
    },
    "outputs": [],
@@ -1310,8 +725,7 @@
    "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-18T00:32:46.591219Z",
-     "start_time": "2020-04-18T00:28:19.000Z"
+     "start_time": "2020-04-19T03:45:46.900Z"
     },
     "scrolled": true
    },
@@ -1342,8 +756,7 @@
    "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-18T00:32:46.592773Z",
-     "start_time": "2020-04-18T00:28:19.000Z"
+     "start_time": "2020-04-19T03:45:46.900Z"
     }
    },
    "outputs": [],
@@ -1363,8 +776,7 @@
    "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-18T00:32:46.594279Z",
-     "start_time": "2020-04-18T00:28:19.000Z"
+     "start_time": "2020-04-19T03:45:46.900Z"
     }
    },
    "outputs": [],
@@ -1377,8 +789,7 @@
    "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-18T00:32:46.595880Z",
-     "start_time": "2020-04-18T00:28:19.000Z"
+     "start_time": "2020-04-19T03:45:46.900Z"
     }
    },
    "outputs": [],
@@ -1403,8 +814,7 @@
    "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-18T00:32:46.597379Z",
-     "start_time": "2020-04-18T00:28:19.000Z"
+     "start_time": "2020-04-19T03:45:46.900Z"
     }
    },
    "outputs": [],
@@ -1421,8 +831,7 @@
    "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-18T00:32:46.598846Z",
-     "start_time": "2020-04-18T00:28:19.000Z"
+     "start_time": "2020-04-19T03:45:46.900Z"
     },
     "scrolled": true
    },
@@ -1448,8 +857,7 @@
    "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-18T00:32:46.600939Z",
-     "start_time": "2020-04-18T00:28:19.000Z"
+     "start_time": "2020-04-19T03:45:46.900Z"
     },
     "scrolled": true
    },
@@ -1467,8 +875,7 @@
    "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-18T00:32:46.602431Z",
-     "start_time": "2020-04-18T00:28:19.000Z"
+     "start_time": "2020-04-19T03:45:47.000Z"
     }
    },
    "outputs": [],
@@ -1493,8 +900,7 @@
    "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-18T00:32:46.604297Z",
-     "start_time": "2020-04-18T00:28:19.000Z"
+     "start_time": "2020-04-19T03:45:47.000Z"
     }
    },
    "outputs": [],
@@ -1511,8 +917,7 @@
    "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-18T00:32:46.605815Z",
-     "start_time": "2020-04-18T00:28:19.000Z"
+     "start_time": "2020-04-19T03:45:47.000Z"
     }
    },
    "outputs": [],
@@ -1539,173 +944,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-18T00:33:31.150152Z",
-     "start_time": "2020-04-18T00:33:31.084953Z"
+     "start_time": "2020-04-19T03:45:47.000Z"
     }
    },
    "outputs": [],
    "source": [
-    "from neural_processes.train import objective"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 25,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2020-04-18T00:34:23.699626Z",
-     "start_time": "2020-04-18T00:34:23.625457Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "PL_MODEL_CLS = TransformerSeq2Seq_PL\n",
-    "name = str(PL_MODEL_CLS.__name__)\n",
-    "func = functools.partial(objective, PL_MODEL_CLS=PL_MODEL_CLS, name=name)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 33,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2020-04-18T00:42:56.945941Z",
-     "start_time": "2020-04-18T00:42:23.495345Z"
-    },
-    "scrolled": true
-   },
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "[autoreload of neural_processes.models.neural_process.lightning failed: Traceback (most recent call last):\n",
-      "  File \"/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/IPython/extensions/autoreload.py\", line 245, in check\n",
-      "    superreload(m, reload, self.old_objects)\n",
-      "  File \"/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/IPython/extensions/autoreload.py\", line 450, in superreload\n",
-      "    update_generic(old_obj, new_obj)\n",
-      "  File \"/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/IPython/extensions/autoreload.py\", line 387, in update_generic\n",
-      "    update(a, b)\n",
-      "  File \"/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/IPython/extensions/autoreload.py\", line 357, in update_class\n",
-      "    update_instances(old, new)\n",
-      "  File \"/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/IPython/extensions/autoreload.py\", line 317, in update_instances\n",
-      "    update_instances(old, new, obj, visited)\n",
-      "  File \"/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/IPython/extensions/autoreload.py\", line 317, in update_instances\n",
-      "    update_instances(old, new, obj, visited)\n",
-      "  File \"/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/IPython/extensions/autoreload.py\", line 300, in update_instances\n",
-      "    for obj in (obj for obj in objects if id(obj) not in visited):\n",
-      "  File \"/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/IPython/extensions/autoreload.py\", line 300, in <genexpr>\n",
-      "    for obj in (obj for obj in objects if id(obj) not in visited):\n",
-      "  File \"/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/IPython/extensions/autoreload.py\", line 295, in <genexpr>\n",
-      "    if not str(key).startswith('_')\n",
-      "KeyboardInterrupt\n",
-      "]\n",
-      "[autoreload of neural_processes.models.transformer failed: Traceback (most recent call last):\n",
-      "  File \"/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/IPython/extensions/autoreload.py\", line 245, in check\n",
-      "    superreload(m, reload, self.old_objects)\n",
-      "  File \"/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/IPython/extensions/autoreload.py\", line 450, in superreload\n",
-      "    update_generic(old_obj, new_obj)\n",
-      "  File \"/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/IPython/extensions/autoreload.py\", line 387, in update_generic\n",
-      "    update(a, b)\n",
-      "  File \"/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/IPython/extensions/autoreload.py\", line 357, in update_class\n",
-      "    update_instances(old, new)\n",
-      "  File \"/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/IPython/extensions/autoreload.py\", line 317, in update_instances\n",
-      "    update_instances(old, new, obj, visited)\n",
-      "  File \"/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/IPython/extensions/autoreload.py\", line 317, in update_instances\n",
-      "    update_instances(old, new, obj, visited)\n",
-      "  File \"/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/IPython/extensions/autoreload.py\", line 300, in update_instances\n",
-      "    for obj in (obj for obj in objects if id(obj) not in visited):\n",
-      "  File \"/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/IPython/extensions/autoreload.py\", line 300, in <genexpr>\n",
-      "    for obj in (obj for obj in objects if id(obj) not in visited):\n",
-      "  File \"/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/IPython/extensions/autoreload.py\", line 295, in <genexpr>\n",
-      "    if not str(key).startswith('_')\n",
-      "KeyboardInterrupt\n",
-      "]\n",
-      "[autoreload of neural_processes.models.transformer_seq2seq failed: Traceback (most recent call last):\n",
-      "  File \"/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/IPython/extensions/autoreload.py\", line 245, in check\n",
-      "    superreload(m, reload, self.old_objects)\n",
-      "  File \"/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/IPython/extensions/autoreload.py\", line 434, in superreload\n",
-      "    module = reload(module)\n",
-      "  File \"/home/wassname/.pyenv/versions/3.7.3/lib/python3.7/imp.py\", line 314, in reload\n",
-      "    return importlib.reload(module)\n",
-      "  File \"/home/wassname/.pyenv/versions/3.7.3/lib/python3.7/importlib/__init__.py\", line 169, in reload\n",
-      "    _bootstrap._exec(spec, module)\n",
-      "  File \"<frozen importlib._bootstrap>\", line 630, in _exec\n",
-      "  File \"<frozen importlib._bootstrap_external>\", line 724, in exec_module\n",
-      "  File \"<frozen importlib._bootstrap_external>\", line 860, in get_code\n",
-      "  File \"<frozen importlib._bootstrap_external>\", line 791, in source_to_code\n",
-      "  File \"<frozen importlib._bootstrap>\", line 219, in _call_with_frames_removed\n",
-      "  File \"/media/wassname/Storage5/projects2/3ST/attentive-neural-processes/neural_processes/models/transformer_seq2seq.py\", line 154\n",
-      "    def add_suggest(trial: optuna.Trial, user_attrs{}):\n",
-      "                                                   ^\n",
-      "SyntaxError: invalid syntax\n",
-      "]\n",
-      "[autoreload of neural_processes.models.lstm_seqseq failed: Traceback (most recent call last):\n",
-      "  File \"/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/IPython/extensions/autoreload.py\", line 245, in check\n",
-      "    superreload(m, reload, self.old_objects)\n",
-      "  File \"/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/IPython/extensions/autoreload.py\", line 450, in superreload\n",
-      "    update_generic(old_obj, new_obj)\n",
-      "  File \"/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/IPython/extensions/autoreload.py\", line 387, in update_generic\n",
-      "    update(a, b)\n",
-      "  File \"/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/IPython/extensions/autoreload.py\", line 357, in update_class\n",
-      "    update_instances(old, new)\n",
-      "  File \"/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/IPython/extensions/autoreload.py\", line 317, in update_instances\n",
-      "    update_instances(old, new, obj, visited)\n",
-      "  File \"/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/IPython/extensions/autoreload.py\", line 317, in update_instances\n",
-      "    update_instances(old, new, obj, visited)\n",
-      "  File \"/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/IPython/extensions/autoreload.py\", line 300, in update_instances\n",
-      "    for obj in (obj for obj in objects if id(obj) not in visited):\n",
-      "  File \"/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/IPython/extensions/autoreload.py\", line 300, in <genexpr>\n",
-      "    for obj in (obj for obj in objects if id(obj) not in visited):\n",
-      "  File \"/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/IPython/extensions/autoreload.py\", line 295, in <genexpr>\n",
-      "    if not str(key).startswith('_')\n",
-      "KeyboardInterrupt\n",
-      "]\n",
-      "[autoreload of neural_processes.models.lstm_std failed: Traceback (most recent call last):\n",
-      "  File \"/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/IPython/extensions/autoreload.py\", line 245, in check\n",
-      "    superreload(m, reload, self.old_objects)\n",
-      "  File \"/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/IPython/extensions/autoreload.py\", line 450, in superreload\n",
-      "    update_generic(old_obj, new_obj)\n",
-      "  File \"/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/IPython/extensions/autoreload.py\", line 387, in update_generic\n",
-      "    update(a, b)\n",
-      "  File \"/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/IPython/extensions/autoreload.py\", line 357, in update_class\n",
-      "    update_instances(old, new)\n",
-      "  File \"/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/IPython/extensions/autoreload.py\", line 317, in update_instances\n",
-      "    update_instances(old, new, obj, visited)\n",
-      "  File \"/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/IPython/extensions/autoreload.py\", line 317, in update_instances\n",
-      "    update_instances(old, new, obj, visited)\n",
-      "  File \"/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/IPython/extensions/autoreload.py\", line 300, in update_instances\n",
-      "    for obj in (obj for obj in objects if id(obj) not in visited):\n",
-      "  File \"/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/IPython/extensions/autoreload.py\", line 300, in <genexpr>\n",
-      "    for obj in (obj for obj in objects if id(obj) not in visited):\n",
-      "KeyboardInterrupt\n",
-      "]\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "[I 2020-04-18 08:42:56,932] Using an existing study with name 'TransformerSeq2Seq_PL' instead of creating a new one.\n"
-     ]
-    }
-   ],
-   "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(n_warmup_steps=1, n_startup_trials=20) if args.pruning else optuna.pruners.NopPruner()\n",
-    "pruner = optuna.pruners.PercentilePruner(75.0)\n",
-    "\n",
-    "study = optuna.create_study(direction='minimize', pruner=pruner, storage=f'sqlite:///optuna_result/{name}.db', study_name=name, load_if_exists=True)\n"
+    "from neural_processes.train import objective\n",
+    "import argparse "
    ]
   },
   {
@@ -1713,50 +961,58 @@
    "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "start_time": "2020-04-18T00:42:24.300Z"
-    },
-    "scrolled": true
+     "start_time": "2020-04-19T03:45:47.000Z"
+    }
    },
    "outputs": [],
    "source": [
-    "study.optimize(func=func, n_trials=200, timeout=pd.Timedelta('3d').total_seconds())"
+    "for PL_MODEL_CLS in [ TransformerSeq2Seq_PL, LSTM_PL_STD, LSTMSeq2Seq_PL, PL_Transformer, PL_NeuralProcess]:\n",
+    "    name = str(PL_MODEL_CLS.__name__)\n",
+    "    func = functools.partial(objective, PL_MODEL_CLS=PL_MODEL_CLS, name=name, user_attrs=default_user_attrs)\n",
+    "    \n",
+    "    \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(n_warmup_steps=1, n_startup_trials=10) if args.pruning else optuna.pruners.NopPruner()\n",
+    "    pruner = optuna.pruners.PercentilePruner(75.0)\n",
+    "\n",
+    "    study = optuna.create_study(direction='minimize', pruner=pruner, storage=f'sqlite:///optuna_result/{name}.db', study_name=name, load_if_exists=True)\n",
+    "\n",
+    "    study.optimize(func=func, n_trials=200, timeout=pd.Timedelta('3d').total_seconds())\n",
+    "    \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": 32,
+   "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-18T00:42:20.857746Z",
-     "start_time": "2020-04-18T00:37:02.229161Z"
+     "end_time": "2020-04-19T02:00:51.812259Z",
+     "start_time": "2020-04-19T02:00:01.621210Z"
     }
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "> /media/wassname/Storage5/projects2/3ST/attentive-neural-processes/neural_processes/train.py(44)main()\n",
-      "     42         val_percent_check=PERCENT_TEST_EXAMPLES,\n",
-      "     43         checkpoint_callback=checkpoint_callback,\n",
-      "---> 44         max_epochs=hparams[\"max_nb_epochs\"],\n",
-      "     45         gpus=-1 if torch.cuda.is_available() else None,\n",
-      "     46         early_stop_callback=PyTorchLightningPruningCallback(trial, monitor=\"val_loss\")\n",
-      "\n",
-      "ipdb> hparams\n",
-      "{'attention_dropout': 0.23184703203538995, 'hidden_out_size_power': 4.0, 'hidden_size_power': 4.0, 'learning_rate': 8.864337175784957e-05, 'nhead_power': 4.0, 'nlayers': 5}\n",
-      "ipdb> trial.user_attrs\n",
-      "{}\n",
-      "ipdb> trial.params\n",
-      "{'attention_dropout': 0.23184703203538995, 'hidden_out_size_power': 4.0, 'hidden_size_power': 4.0, 'learning_rate': 8.864337175784957e-05, 'nhead_power': 4.0, 'nlayers': 5}\n",
-      "ipdb> trial._user_attrs\n",
-      "{'batch_size': 16, 'grad_clip': 40, 'max_nb_epochs': 200, 'num_workers': 4, 'num_extra_target': 96, 'vis_i': '670', 'num_context': 96, 'input_size': 18, 'input_size_decoder': 17, 'context_in_target': False, 'output_size': 1, 'patience': 3, 'min_std': 0.005}\n",
-      "ipdb> trial.user_attrs\n",
-      "{}\n",
-      "ipdb> q\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": []
   },
   {
@@ -1764,28 +1020,54 @@
    "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-18T00:33:51.394196Z",
-     "start_time": "2020-04-18T00:33:50.600Z"
+     "start_time": "2020-04-19T03:45:47.000Z"
     },
     "scrolled": true
    },
    "outputs": [],
    "source": [
-    "\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)"
+    "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-04-18T00:47:04.818110Z",
+     "start_time": "2020-04-18T00:44:57.906685Z"
+    },
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2020-04-18T00:42:20.857746Z",
+     "start_time": "2020-04-18T00:37:02.229161Z"
+    }
+   },
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2020-04-18T00:44:03.703580Z",
+     "start_time": "2020-04-18T00:44:02.100Z"
+    },
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": []
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -1817,8 +1099,7 @@
    "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-18T00:32:46.612084Z",
-     "start_time": "2020-04-18T00:28:19.100Z"
+     "start_time": "2020-04-19T03:45:47.000Z"
     }
    },
    "outputs": [],
@@ -1832,8 +1113,7 @@
    "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-04-18T00:32:46.613596Z",
-     "start_time": "2020-04-18T00:28:19.100Z"
+     "start_time": "2020-04-19T03:45:47.000Z"
     }
    },
    "outputs": [],